         let ip2 = IndexPath(indexes: [5, 6, 7])
         
         ip.append(ip2)
+        
+        expectEqual(ip.count, 7)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[6], 7)
+        
+        let ip3 = ip.appending(IndexPath(indexes: [8, 9]))
+        expectEqual(ip3.count, 9)
+        expectEqual(ip3[7], 8)
+        expectEqual(ip3[8], 9)
+        
+        let ip4 = ip3.appending([10, 11])
+        expectEqual(ip4.count, 11)
+        expectEqual(ip4[9], 10)
+        expectEqual(ip4[10], 11)
+        
+        let ip5 = ip.appending(8)
+        expectEqual(ip5.count, 8)
+        expectEqual(ip5[7], 8)
+    }
+    
+    func testAppendEmpty() {
+        var ip: IndexPath = []
+        ip.append(1)
+        
+        expectEqual(ip.count, 1)
+        expectEqual(ip[0], 1)
+        
+        ip.append(2)
+        expectEqual(ip.count, 2)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[1], 2)
+        
+        ip.append(3)
+        expectEqual(ip.count, 3)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[1], 2)
+        expectEqual(ip[2], 3)
+        
+        ip.append(4)
+        expectEqual(ip.count, 4)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[1], 2)
+        expectEqual(ip[2], 3)
+        expectEqual(ip[3], 4)
+    }
+    
+    func testAppendEmptyIndexPath() {
+        var ip: IndexPath = []
+        ip.append(IndexPath(indexes: []))
+        
+        expectEqual(ip.count, 0)
+    }
+    
+    func testAppendManyIndexPath() {
+        var ip: IndexPath = []
+        ip.append(IndexPath(indexes: [1, 2, 3]))
+        
+        expectEqual(ip.count, 3)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[1], 2)
+        expectEqual(ip[2], 3)
+    }
+    
+    func testAppendEmptyIndexPathToSingle() {
+        var ip: IndexPath = [1]
+        ip.append(IndexPath(indexes: []))
+        
+        expectEqual(ip.count, 1)
+        expectEqual(ip[0], 1)
+    }
+    
+    func testAppendSingleIndexPath() {
+        var ip: IndexPath = []
+        ip.append(IndexPath(indexes: [1]))
+        
+        expectEqual(ip.count, 1)
+        expectEqual(ip[0], 1)
+    }
+    
+    func testAppendSingleIndexPathToSingle() {
+        var ip: IndexPath = [1]
+        ip.append(IndexPath(indexes: [1]))
+        
+        expectEqual(ip.count, 2)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[1], 1)
+    }
+    
+    func testAppendPairIndexPath() {
+        var ip: IndexPath = []
+        ip.append(IndexPath(indexes: [1, 2]))
+        
+        expectEqual(ip.count, 2)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[1], 2)
+    }
+    
+    func testAppendManyIndexPathToEmpty() {
+        var ip: IndexPath = []
+        ip.append(IndexPath(indexes: [1, 2, 3]))
+        
+        expectEqual(ip.count, 3)
+        expectEqual(ip[0], 1)
+        expectEqual(ip[1], 2)
+        expectEqual(ip[2], 3)
+    }
+    
+    func testAppendByOperator() {
+        let ip1: IndexPath = []
+        let ip2: IndexPath = []
+        
+        let ip3 = ip1 + ip2
+        expectEqual(ip3.count, 0)
+        
+        let ip4: IndexPath = [1]
+        let ip5: IndexPath = [2]
+        
+        let ip6 = ip4 + ip5
+        expectEqual(ip6.count, 2)
+        expectEqual(ip6[0], 1)
+        expectEqual(ip6[1], 2)
+        
+        var ip7: IndexPath = []
+        ip7 += ip6
+        expectEqual(ip7.count, 2)
+        expectEqual(ip7[0], 1)
+        expectEqual(ip7[1], 2)
+    }
+    
+    func testAppendArray() {
+        var ip: IndexPath = [1, 2, 3, 4]
+        let indexes = [5, 6, 7]
+        
+        ip.append(indexes)
         
         expectEqual(ip.count, 7)
         expectEqual(ip[0], 1)

        expectNotEqual(anyHashables[0], anyHashables[1])
        expectEqual(anyHashables[1], anyHashables[2])
    }
    
    // TODO: Test bridging
    
}

#if !FOUNDATION_XCTEST
var IndexPathTests = TestSuite("TestIndexPath")
IndexPathTests.test("testBasics") { TestIndexPath().testBasics() }
IndexPathTests.test("testAppending") { TestIndexPath().testAppending() }
IndexPathTests.test("testRanges") { TestIndexPath().testRanges() }
IndexPathTests.test("testMoreRanges") { TestIndexPath().testMoreRanges() }
IndexPathTests.test("testIteration") { TestIndexPath().testIteration() }
IndexPathTests.test("test_AnyHashableContainingIndexPath") { TestIndexPath().test_AnyHashableContainingIndexPath() }
IndexPathTests.test("test_AnyHashableCreatedFromNSIndexPath") { TestIndexPath().test_AnyHashableCreatedFromNSIndexPath() }
runAllTests()
#endif


class TestIndexPathSuper { }
#endif

class TestIndexPath: TestIndexPathSuper {
    func testEmpty() {
        let ip = IndexPath()
        expectEqual(ip.count, 0)
    }
    
    func testSingleIndex() {
        let ip = IndexPath(index: 1)
        expectEqual(ip.count, 1)
        expectEqual(ip[0], 1)
        
        let highValueIp = IndexPath(index: .max)
        expectEqual(highValueIp.count, 1)
        expectEqual(highValueIp[0], .max)
        
        let lowValueIp = IndexPath(index: .min)
        expectEqual(lowValueIp.count, 1)
        expectEqual(lowValueIp[0], .min)
    }
    
    func testTwoIndexes() {
        let ip = IndexPath(indexes: [0, 1])
        expectEqual(ip.count, 2)
        expectEqual(ip[0], 0)
        expectEqual(ip[1], 1)
    }
    
    func testManyIndexes() {
        let ip = IndexPath(indexes: [0, 1, 2, 3, 4])
        expectEqual(ip.count, 5)
        expectEqual(ip[0], 0)
        expectEqual(ip[1], 1)
        expectEqual(ip[2], 2)
        expectEqual(ip[3], 3)
        expectEqual(ip[4], 4)
    }
    
    func testCreateFromSequence() {
        let seq = repeatElement(5, count: 3)
        let ip = IndexPath(indexes: seq)
        expectEqual(ip.count, 3)
        expectEqual(ip[0], 5)
        expectEqual(ip[1], 5)
        expectEqual(ip[2], 5)
    }
    
    func testCreateFromLiteral() {
        let ip: IndexPath = [1, 2, 3, 4]
        expectEqual(ip.count, 4)
        expectEqual(ip[0], 1)
        expectEqual(ip[1], 2)
        expectEqual(ip[2], 3)
        expectEqual(ip[3], 4)
    }
    
    func testDropLast() {
        let ip: IndexPath = [1, 2, 3, 4]
        let ip2 = ip.dropLast()
        expectEqual(ip2.count, 3)
        expectEqual(ip2[0], 1)
        expectEqual(ip2[1], 2)
        expectEqual(ip2[2], 3)
    }
    
    func testDropLastFromEmpty() {
        let ip: IndexPath = []
        let ip2 = ip.dropLast()
        expectEqual(ip2.count, 0)
    }
    
    func testDropLastFromSingle() {
        let ip: IndexPath = [1]
        let ip2 = ip.dropLast()
        expectEqual(ip2.count, 0)
    }
    
    func testDropLastFromPair() {
        let ip: IndexPath = [1, 2]
        let ip2 = ip.dropLast()
        expectEqual(ip2.count, 1)
        expectEqual(ip2[0], 1)
    }
    
    func testDropLastFromTriple() {
        let ip: IndexPath = [1, 2, 3]
        let ip2 = ip.dropLast()
        expectEqual(ip2.count, 2)
        expectEqual(ip2[0], 1)
        expectEqual(ip2[1], 2)
    }
    
    func testStartEndIndex() {
        let ip: IndexPath = [1, 2, 3, 4]
        expectEqual(ip.startIndex, 0)
        expectEqual(ip.endIndex, ip.count)
    }
    
    func testIterator() {
        let ip: IndexPath = [1, 2, 3, 4]
        var iter = ip.makeIterator()
        var sum = 0
        while let index = iter.next() {
            sum += index
        }
        expectEqual(sum, 1 + 2 + 3 + 4)
    }
    
    func testIndexing() {
        let ip: IndexPath = [1, 2, 3, 4]
        expectEqual(ip.index(before: 1), 0)
        expectEqual(ip.index(before: 0), -1) // beyond range!
        expectEqual(ip.index(after: 1), 2)
        expectEqual(ip.index(after: 4), 5) // beyond range!
    }
    
    func testCompare() {
        let ip1: IndexPath = [1, 2]
        let ip2: IndexPath = [3, 4]
        let ip3: IndexPath = [5, 1]
        let ip4: IndexPath = [1, 1, 1]
        let ip5: IndexPath = [1, 1, 9]
        
        expectEqual(ip1.compare(ip1), ComparisonResult.orderedSame)
        expectEqual(ip1 < ip1, false)
        expectEqual(ip1 <= ip1, true)
        expectEqual(ip1 == ip1, true)
        expectEqual(ip1 >= ip1, true)
        expectEqual(ip1 > ip1, false)
        
        expectEqual(ip1.compare(ip2), ComparisonResult.orderedAscending)
        expectEqual(ip1 < ip2, true)
        expectEqual(ip1 <= ip2, true)
        expectEqual(ip1 == ip2, false)
        expectEqual(ip1 >= ip2, false)
        expectEqual(ip1 > ip2, false)
        
        expectEqual(ip1.compare(ip3), ComparisonResult.orderedAscending)
        expectEqual(ip1 < ip3, true)
        expectEqual(ip1 <= ip3, true)
        expectEqual(ip1 == ip3, false)
        expectEqual(ip1 >= ip3, false)
        expectEqual(ip1 > ip3, false)
        
        expectEqual(ip1.compare(ip4), ComparisonResult.orderedDescending)
        expectEqual(ip1 < ip4, false)
        expectEqual(ip1 <= ip4, false)
        expectEqual(ip1 == ip4, false)
        expectEqual(ip1 >= ip4, true)
        expectEqual(ip1 > ip4, true)
        
        expectEqual(ip1.compare(ip5), ComparisonResult.orderedDescending)
        expectEqual(ip1 < ip5, false)
        expectEqual(ip1 <= ip5, false)
        expectEqual(ip1 == ip5, false)
        expectEqual(ip1 >= ip5, true)
        expectEqual(ip1 > ip5, true)
        
        expectEqual(ip2.compare(ip1), ComparisonResult.orderedDescending)
        expectEqual(ip2 < ip1, false)
        expectEqual(ip2 <= ip1, false)
        expectEqual(ip2 == ip1, false)
        expectEqual(ip2 >= ip1, true)
        expectEqual(ip2 > ip1, true)
        
        expectEqual(ip2.compare(ip2), ComparisonResult.orderedSame)
        expectEqual(ip2 < ip2, false)
        expectEqual(ip2 <= ip2, true)
        expectEqual(ip2 == ip2, true)
        expectEqual(ip2 >= ip2, true)
        expectEqual(ip2 > ip2, false)
        
        expectEqual(ip2.compare(ip3), ComparisonResult.orderedAscending)
        expectEqual(ip2 < ip3, true)
        expectEqual(ip2 <= ip3, true)
        expectEqual(ip2 == ip3, false)
        expectEqual(ip2 >= ip3, false)
        expectEqual(ip2 > ip3, false)
        
        expectEqual(ip2.compare(ip4), ComparisonResult.orderedDescending)
        expectEqual(ip2.compare(ip5), ComparisonResult.orderedDescending)
        expectEqual(ip3.compare(ip1), ComparisonResult.orderedDescending)
        expectEqual(ip3.compare(ip2), ComparisonResult.orderedDescending)
        expectEqual(ip3.compare(ip3), ComparisonResult.orderedSame)
        expectEqual(ip3.compare(ip4), ComparisonResult.orderedDescending)
        expectEqual(ip3.compare(ip5), ComparisonResult.orderedDescending)
        expectEqual(ip4.compare(ip1), ComparisonResult.orderedAscending)
        expectEqual(ip4.compare(ip2), ComparisonResult.orderedAscending)
        expectEqual(ip4.compare(ip3), ComparisonResult.orderedAscending)
        expectEqual(ip4.compare(ip4), ComparisonResult.orderedSame)
        expectEqual(ip4.compare(ip5), ComparisonResult.orderedAscending)
        expectEqual(ip5.compare(ip1), ComparisonResult.orderedAscending)
        expectEqual(ip5.compare(ip2), ComparisonResult.orderedAscending)
        expectEqual(ip5.compare(ip3), ComparisonResult.orderedAscending)
        expectEqual(ip5.compare(ip4), ComparisonResult.orderedDescending)
        expectEqual(ip5.compare(ip5), ComparisonResult.orderedSame)
        
        let ip6: IndexPath = [1, 1]
        expectEqual(ip6.compare(ip5), ComparisonResult.orderedAscending)
        expectEqual(ip5.compare(ip6), ComparisonResult.orderedDescending)
    }
    
    func testHashing() {
        let ip1: IndexPath = [5, 1]
        let ip2: IndexPath = [1, 1, 1]
        
        expectNotEqual(ip1.hashValue, ip2.hashValue)
        
        let nsip1 = ip1._bridgeToObjectiveC()
        expectEqual(nsip1.hash, ip1.hashValue)
    }
    
    func testEquality() {
        let ip1: IndexPath = [1, 1]
        let ip2: IndexPath = [1, 1]
        let ip3: IndexPath = [1, 1, 1]
        let ip4: IndexPath = []
        let ip5: IndexPath = [1]
        
        expectTrue(ip1 == ip2)
        expectFalse(ip1 == ip3)
        expectFalse(ip1 == ip4)
        expectFalse(ip4 == ip1)
        expectFalse(ip5 == ip1)
        expectFalse(ip5 == ip4)
        expectTrue(ip4 == ip4)
        expectTrue(ip5 == ip5)
    }
    
    func testSubscripting() {
        var ip1: IndexPath = [1]
        var ip2: IndexPath = [1, 2]
        var ip3: IndexPath = [1, 2, 3]
        
        expectEqual(ip1[0], 1)
        
        expectEqual(ip2[0], 1)
        expectEqual(ip2[1], 2)
        
        expectEqual(ip3[0], 1)
        expectEqual(ip3[1], 2)
        expectEqual(ip3[2], 3)
        
        ip1[0] = 2
        expectEqual(ip1[0], 2)
        
        ip2[0] = 2
        ip2[1] = 3
        expectEqual(ip2[0], 2)
        expectEqual(ip2[1], 3)
        
        ip3[0] = 2
        ip3[1] = 3
        ip3[2] = 4
        expectEqual(ip3[0], 2)
        expectEqual(ip3[1], 3)
        expectEqual(ip3[2], 4)
        
        let ip4 = ip3[0..<2]
        expectEqual(ip4.count, 2)
        expectEqual(ip4[0], 2)
        expectEqual(ip4[1], 3)
    }
    
    func testAppending() {
