         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("testEmpty") { TestIndexPath().testEmpty() }
+IndexPathTests.test("testSingleIndex") { TestIndexPath().testSingleIndex() }
+IndexPathTests.test("testTwoIndexes") { TestIndexPath().testTwoIndexes() }
+IndexPathTests.test("testManyIndexes") { TestIndexPath().testManyIndexes() }
+IndexPathTests.test("testCreateFromSequence") { TestIndexPath().testCreateFromSequence() }
+IndexPathTests.test("testCreateFromLiteral") { TestIndexPath().testCreateFromLiteral() }
+IndexPathTests.test("testDropLast") { TestIndexPath().testDropLast() }
+IndexPathTests.test("testDropLastFromEmpty") { TestIndexPath().testDropLastFromEmpty() }
+IndexPathTests.test("testDropLastFromSingle") { TestIndexPath().testDropLastFromSingle() }
+IndexPathTests.test("testDropLastFromPair") { TestIndexPath().testDropLastFromPair() }
+IndexPathTests.test("testDropLastFromTriple") { TestIndexPath().testDropLastFromTriple() }
+IndexPathTests.test("testStartEndIndex") { TestIndexPath().testStartEndIndex() }
+IndexPathTests.test("testIterator") { TestIndexPath().testIterator() }
+IndexPathTests.test("testIndexing") { TestIndexPath().testIndexing() }
+IndexPathTests.test("testCompare") { TestIndexPath().testCompare() }
+IndexPathTests.test("testHashing") { TestIndexPath().testHashing() }
+IndexPathTests.test("testEquality") { TestIndexPath().testEquality() }
+IndexPathTests.test("testSubscripting") { TestIndexPath().testSubscripting() }
 IndexPathTests.test("testAppending") { TestIndexPath().testAppending() }
+IndexPathTests.test("testAppendEmpty") { TestIndexPath().testAppendEmpty() }
+IndexPathTests.test("testAppendEmptyIndexPath") { TestIndexPath().testAppendEmptyIndexPath() }
+IndexPathTests.test("testAppendManyIndexPath") { TestIndexPath().testAppendManyIndexPath() }
+IndexPathTests.test("testAppendEmptyIndexPathToSingle") { TestIndexPath().testAppendEmptyIndexPathToSingle() }
+IndexPathTests.test("testAppendSingleIndexPath") { TestIndexPath().testAppendSingleIndexPath() }
+IndexPathTests.test("testAppendSingleIndexPathToSingle") { TestIndexPath().testAppendSingleIndexPathToSingle() }
+IndexPathTests.test("testAppendPairIndexPath") { TestIndexPath().testAppendPairIndexPath() }
+IndexPathTests.test("testAppendManyIndexPathToEmpty") { TestIndexPath().testAppendManyIndexPathToEmpty() }
+IndexPathTests.test("testAppendByOperator") { TestIndexPath().testAppendByOperator() }
+IndexPathTests.test("testAppendArray") { TestIndexPath().testAppendArray() }
 IndexPathTests.test("testRanges") { TestIndexPath().testRanges() }
+IndexPathTests.test("testRangeFromEmpty") { TestIndexPath().testRangeFromEmpty() }
+IndexPathTests.test("testRangeFromSingle") { TestIndexPath().testRangeFromSingle() }
+IndexPathTests.test("testRangeFromPair") { TestIndexPath().testRangeFromPair() }
+IndexPathTests.test("testRangeFromMany") { TestIndexPath().testRangeFromMany() }
+IndexPathTests.test("testRangeReplacementSingle") { TestIndexPath().testRangeReplacementSingle() }
+IndexPathTests.test("testRangeReplacementPair") { TestIndexPath().testRangeReplacementPair() }
 IndexPathTests.test("testMoreRanges") { TestIndexPath().testMoreRanges() }
 IndexPathTests.test("testIteration") { TestIndexPath().testIteration() }
+IndexPathTests.test("testDescription") { TestIndexPath().testDescription() }
+IndexPathTests.test("testBridgeToObjC") { TestIndexPath().testBridgeToObjC() }
+IndexPathTests.test("testForceBridgeFromObjC") { TestIndexPath().testForceBridgeFromObjC() }
+IndexPathTests.test("testConditionalBridgeFromObjC") { TestIndexPath().testConditionalBridgeFromObjC() }
+IndexPathTests.test("testUnconditionalBridgeFromObjC") { TestIndexPath().testUnconditionalBridgeFromObjC() }
+IndexPathTests.test("testObjcBridgeType") { TestIndexPath().testObjcBridgeType() }
 IndexPathTests.test("test_AnyHashableContainingIndexPath") { TestIndexPath().test_AnyHashableContainingIndexPath() }
 IndexPathTests.test("test_AnyHashableCreatedFromNSIndexPath") { TestIndexPath().test_AnyHashableCreatedFromNSIndexPath() }
 runAllTests()
 #endif
-

        
        expectEqual(3, count)
    }

    func test_AnyHashableContainingIndexPath() {
        let values: [IndexPath] = [
            IndexPath(indexes: [1, 2]),
            IndexPath(indexes: [1, 2, 3]),
            IndexPath(indexes: [1, 2, 3]),
        ]
        let anyHashables = values.map(AnyHashable.init)
        expectEqual(IndexPath.self, type(of: anyHashables[0].base))
        expectEqual(IndexPath.self, type(of: anyHashables[1].base))

        expectEqual(mutateMe, IndexPath(indexes: [1, 2, 6, 7, 8, 3]))
    }
    
    func testRangeFromEmpty() {
        let ip1 = IndexPath()
        let ip2 = ip1[0..<0]
        expectEqual(ip2.count, 0)
    }
    
    func testRangeFromSingle() {
        let ip1 = IndexPath(indexes: [1])
        let ip2 = ip1[0..<0]
        expectEqual(ip2.count, 0)
        let ip3 = ip1[0..<1]
        expectEqual(ip3.count, 1)
        expectEqual(ip3[0], 1)
    }
    
    func testRangeFromPair() {
        let ip1 = IndexPath(indexes: [1, 2])
        let ip2 = ip1[0..<0]
        expectEqual(ip2.count, 0)
        let ip3 = ip1[0..<1]
        expectEqual(ip3.count, 1)
        expectEqual(ip3[0], 1)
        let ip4 = ip1[1..<1]
        expectEqual(ip4.count, 0)
        let ip5 = ip1[0..<2]
        expectEqual(ip5.count, 2)
        expectEqual(ip5[0], 1)
        expectEqual(ip5[1], 2)
        let ip6 = ip1[1..<2]
        expectEqual(ip6.count, 1)
        expectEqual(ip6[0], 2)
        let ip7 = ip1[2..<2]
        expectEqual(ip7.count, 0)
    }
    
    func testRangeFromMany() {
        let ip1 = IndexPath(indexes: [1, 2, 3])
        let ip2 = ip1[0..<0]
        expectEqual(ip2.count, 0)
        let ip3 = ip1[0..<1]
        expectEqual(ip3.count, 1)
        let ip4 = ip1[0..<2]
        expectEqual(ip4.count, 2)
        let ip5 = ip1[0..<3]
        expectEqual(ip5.count, 3)
    }
    
    func testRangeReplacementSingle() {
        var ip1 = IndexPath(indexes: [1])
        ip1[0..<1] = IndexPath(indexes: [2])
        expectEqual(ip1[0], 2)
        
        ip1[0..<1] = IndexPath(indexes: [])
        expectEqual(ip1.count, 0)
    }
    
    func testRangeReplacementPair() {
        var ip1 = IndexPath(indexes: [1, 2])
        ip1[0..<1] = IndexPath(indexes: [2, 3])
        expectEqual(ip1.count, 3)
        expectEqual(ip1[0], 2)
        expectEqual(ip1[1], 3)
        expectEqual(ip1[2], 2)
        
        ip1[0..<1] = IndexPath(indexes: [])
        expectEqual(ip1.count, 2)
    }
    
    func testMoreRanges() {
        var ip = IndexPath(indexes: [1, 2, 3])
        let ip2 = IndexPath(indexes: [5, 6, 7, 8, 9, 10])
