TestNSOrderedSet.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//

class TestNSOrderedSet : XCTestCase {

    func test_BasicConstruction() {
        let set = NSOrderedSet()
        let set2 = NSOrderedSet(array: ["foo", "bar"])
        XCTAssertEqual(set.count, 0)
        XCTAssertEqual(set2.count, 2)
    }

    func test_Enumeration() {
        let arr = ["foo", "bar", "bar"]
        let set = NSOrderedSet(array: arr)
        var index = 0
        for item in set {
            XCTAssertEqual(arr[index], item as? String)
            index += 1
        }
    }
    
    func test_enumerationUsingBlock() {
        let array = NSOrderedSet(array: Array(0..<100))
        let createIndexesArrayHavingSeen = { (havingSeen: IndexSet) in
            return (0 ..< array.count).map { havingSeen.contains($0) }
        }
        
        let noIndexes = IndexSet()
        let allIndexes = IndexSet(integersIn: 0 ..< array.count)
        let firstHalfOfIndexes = IndexSet(integersIn: 0 ..< array.count / 2)
        let lastHalfOfIndexes = IndexSet(integersIn: array.count / 2 ..< array.count)
        let evenIndexes : IndexSet = {
            var indexes = IndexSet()
            for index in allIndexes.filter({ $0 % 2 == 0 }) {
                indexes.insert(index)
            }
            return indexes
        }()
        
        let testExpectingToSee = { (expectation: IndexSet, block: (inout UnsafeMutableBufferPointer<Bool>) -> Void) in
            var indexesSeen = createIndexesArrayHavingSeen(noIndexes)
            indexesSeen.withUnsafeMutableBufferPointer(block)
            XCTAssertEqual(indexesSeen, createIndexesArrayHavingSeen(expectation))
        }
        
        // Test enumerateObjects(_:), allowing it to run to completion...
        
        testExpectingToSee(allIndexes) { (indexesSeen) in
            array.enumerateObjects { (value, index, stop) in
                XCTAssertEqual(value as! NSNumber, array[index] as! NSNumber)
                indexesSeen[index] = true
            }
        }
        
        // ... and stopping after the first half:
        
        testExpectingToSee(firstHalfOfIndexes) { (indexesSeen) in
            array.enumerateObjects { (value, index, stop) in
                XCTAssertEqual(value as! NSNumber, array[index] as! NSNumber)
                
                if firstHalfOfIndexes.contains(index) {
                    indexesSeen[index] = true
                } else {
                    stop.pointee = true
                }
            }
        }
        
        // -----
        // Test enumerateObjects(options:using) and enumerateObjects(at:options:using:):
        
        // Test each of these options combinations:
        let optionsToTest: [NSEnumerationOptions] = [
            [],
            [.concurrent],
            [.reverse],
            [.concurrent, .reverse],
            ]
        
        for options in optionsToTest {
            // Run to completion,
            testExpectingToSee(allIndexes) { (indexesSeen) in
                array.enumerateObjects(options: options, using: { (value, index, stop) in
                    XCTAssertEqual(value as! NSNumber, array[index] as! NSNumber)
                    indexesSeen[index] = true
                })
            }
            
            // run it only for half the indexes (use the right half depending on where we start),
            let indexesForHalfEnumeration = options.contains(.reverse) ? lastHalfOfIndexes : firstHalfOfIndexes
            
            testExpectingToSee(indexesForHalfEnumeration) { (indexesSeen) in
                array.enumerateObjects(options: options, using: { (value, index, stop) in
                    XCTAssertEqual(value as! NSNumber, array[index] as! NSNumber)
                    
                    if indexesForHalfEnumeration.contains(index) {
                        indexesSeen[index] = true
                    } else {
                        stop.pointee = true
                    }
                })
            }
            
            // run only for a specific index set to test the at:… variant,
            testExpectingToSee(evenIndexes) { (indexesSeen) in
                array.enumerateObjects(at: evenIndexes, options: options, using: { (value, index, stop) in
                    XCTAssertEqual(value as! NSNumber, array[index] as! NSNumber)
                    indexesSeen[index] = true
                })
            }
            
            // and run for some indexes only to test stopping.
            var indexesForStaggeredEnumeration = indexesForHalfEnumeration
            indexesForStaggeredEnumeration.formIntersection(evenIndexes)
            
            let finalCount = indexesForStaggeredEnumeration.count
            
            let lockForSeenCount = NSLock()
            var seenCount = 0
            
            testExpectingToSee(indexesForStaggeredEnumeration) { (indexesSeen) in
                array.enumerateObjects(at: evenIndexes, options: options, using: { (value, index, stop) in
                    XCTAssertEqual(value as! NSNumber, array[index] as! NSNumber)
                    
                    if (indexesForStaggeredEnumeration.contains(index)) {
                        indexesSeen[index] = true
                        
                        lockForSeenCount.lock()
                        seenCount += 1
                        let currentCount = seenCount
                        lockForSeenCount.unlock()
                        
                        if currentCount == finalCount {
                            stop.pointee = true
                        }
                    }
                })
            }
        }
    }

    func test_Uniqueness() {
        let set = NSOrderedSet(array: ["foo", "bar", "bar"])
        XCTAssertEqual(set.count, 2)
        XCTAssertEqual(set.object(at: 0) as? String, "foo")
        XCTAssertEqual(set.object(at: 1) as? String, "bar")
    }

    func test_reversedEnumeration() {
        let arr = ["foo", "bar", "baz"]
        let set = NSOrderedSet(array: arr)
        var index = set.count - 1
        let revSet = set.reverseObjectEnumerator()
        for item in revSet {
            XCTAssertEqual(set.object(at: index) as? String, item as? String)
            index -= 1
        }
    }

    func test_reversedOrderedSet() {
        let days = ["monday", "tuesday", "wednesday", "thursday", "friday"]
        let work = NSOrderedSet(array: days)
        let krow = work.reversed
        var index = work.count - 1
        for item in krow {
            XCTAssertEqual(work.object(at: index) as? String, item as? String)
           index -= 1
        }
    }

    func test_reversedEmpty() {
        let set = NSOrderedSet(array: [])
        let reversedEnum = set.reverseObjectEnumerator()
        XCTAssertNil(reversedEnum.nextObject())
        let reversedSet = set.reversed
        XCTAssertNil(reversedSet.firstObject)
    }

    func test_ObjectAtIndex() {
        let set = NSOrderedSet(array: ["foo", "bar", "baz"])
        XCTAssertEqual(set.object(at: 0) as? String, "foo")
        XCTAssertEqual(set.object(at: 1) as? String, "bar")
        XCTAssertEqual(set.object(at: 2) as? String, "baz")
    }

    func test_ObjectsAtIndexes() {
        let set = NSOrderedSet(array: ["foo", "bar", "baz", "1", "2", "3"])
        let objects = set.objects(at: [1, 3, 5])
        XCTAssertEqual(objects.count, 3)
        XCTAssertEqual(objects[0] as? String, "bar")
        XCTAssertEqual(objects[1] as? String, "1")
        XCTAssertEqual(objects[2] as? String, "3")
    }

    func test_FirstAndLastObjects() {
        let set = NSOrderedSet(array: ["foo", "bar", "baz"])
        XCTAssertEqual(set.firstObject as? String, "foo")
        XCTAssertEqual(set.lastObject as? String, "baz")
    }

    func test_AddObject() {
        let set = NSMutableOrderedSet()
        set.add("1")
        set.add("2")
        XCTAssertEqual(set[0] as? String, "1")
        XCTAssertEqual(set[1] as? String, "2")
        XCTAssertEqual(set.count, 2)
    }

    func test_AddObjects() {
        let set = NSMutableOrderedSet()
        set.addObjects(from: ["foo", "bar", "baz"])
        XCTAssertEqual(set.object(at: 0) as? String, "foo")
        XCTAssertEqual(set.object(at: 1) as? String, "bar")
        XCTAssertEqual(set.object(at: 2) as? String, "baz")
    }

    func test_RemoveAllObjects() {
        let set = NSMutableOrderedSet()
        set.addObjects(from: ["foo", "bar", "baz"])
        XCTAssertEqual(set.index(of: "foo"), 0)
        set.removeAllObjects()
        XCTAssertEqual(set.count, 0)
        XCTAssertEqual(set.index(of: "foo"), NSNotFound)
    }

    func test_RemoveObject() {
        let set = NSMutableOrderedSet()
        set.addObjects(from: ["foo", "bar", "baz"])
        set.remove("bar")
        XCTAssertEqual(set.count, 2)
        XCTAssertEqual(set.index(of: "baz"), 1)
    }

    func test_RemoveObjectAtIndex() {
        let set = NSMutableOrderedSet()
        set.addObjects(from: ["foo", "bar", "baz"])
        set.removeObject(at: 1)
        XCTAssertEqual(set.count, 2)
        XCTAssertEqual(set.index(of: "baz"), 1)
    }

    func test_IsEqualToOrderedSet() {
        let set = NSOrderedSet(array: ["foo", "bar", "baz"])
        let otherSet = NSOrderedSet(array: ["foo", "bar", "baz"])
        let otherOtherSet = NSOrderedSet(array: ["foo", "bar", "123"])
        XCTAssert(set.isEqual(to: otherSet))
        XCTAssertFalse(set.isEqual(to: otherOtherSet))
    }

    func test_Subsets() {
        let set = NSOrderedSet(array: ["foo", "bar", "baz"])
        let otherOrderedSet = NSOrderedSet(array: ["foo", "bar"])
        let otherSet = Set<AnyHashable>(["foo", "baz"])
        let otherOtherSet = Set<AnyHashable>(["foo", "bar", "baz", "123"])
        XCTAssert(otherOrderedSet.isSubset(of: set))
        XCTAssertFalse(set.isSubset(of: otherOrderedSet))
        XCTAssertFalse(set.isSubset(of: otherSet))
        XCTAssert(set.isSubset(of: otherOtherSet))
    }

    func test_ReplaceObject() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        set.replaceObject(at: 1, with: "123")
        set[2] = "456"
        XCTAssertEqual(set.count, 3)
        XCTAssertEqual(set[0] as? String, "foo")
        XCTAssertEqual(set[1] as? String, "123")
        XCTAssertEqual(set[2] as? String, "456")
    }

    func test_ExchangeObjects() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        set.exchangeObject(at: 0, withObjectAt: 2)
        XCTAssertEqual(set.count, 3)
        XCTAssertEqual(set[0] as? String, "baz")
        XCTAssertEqual(set[1] as? String, "bar")
        XCTAssertEqual(set[2] as? String, "foo")
    }

    func test_MoveObjects() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz", "123", "456")
        var indexes = IndexSet()
        indexes.insert(1)
        indexes.insert(2)
        indexes.insert(4)
        set.moveObjects(at: indexes, to: 0)
        XCTAssertEqual(set.count, 5)
        XCTAssertEqual(set[0] as? String, "bar")
        XCTAssertEqual(set[1] as? String, "baz")
        XCTAssertEqual(set[2] as? String, "456")
        XCTAssertEqual(set[3] as? String, "foo")
        XCTAssertEqual(set[4] as? String, "123")
    }

    func test_InsertObjects() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        var indexes = IndexSet()
        indexes.insert(1)
        indexes.insert(3)
        set.insert(["123", "456"], at: indexes)
        XCTAssertEqual(set.count, 5)
        XCTAssertEqual(set[0] as? String, "foo")
        XCTAssertEqual(set[1] as? String, "123")
        XCTAssertEqual(set[2] as? String, "bar")
        XCTAssertEqual(set[3] as? String, "456")
        XCTAssertEqual(set[4] as? String, "baz")
    }

    func test_Insert() {
        let set = NSMutableOrderedSet()
        set.insert("foo", at: 0)
        XCTAssertEqual(set.count, 1)
        XCTAssertEqual(set[0] as? String, "foo")
        set.insert("bar", at: 1)
        XCTAssertEqual(set.count, 2)
        XCTAssertEqual(set[1] as? String, "bar")
    }

    func test_SetObjectAtIndex() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        set.setObject("123", at: 1)
        XCTAssertEqual(set[0] as? String, "foo")
        XCTAssertEqual(set[1] as? String, "123")
        XCTAssertEqual(set[2] as? String, "baz")
        set.setObject("456", at: 3)
        XCTAssertEqual(set[3] as? String, "456")
    }

    func test_RemoveObjectsInRange() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz", "123", "456")
        set.removeObjects(in: NSRange(location: 1, length: 2))
        XCTAssertEqual(set.count, 3)
        XCTAssertEqual(set[0] as? String, "foo")
        XCTAssertEqual(set[1] as? String, "123")
        XCTAssertEqual(set[2] as? String, "456")
    }

    func test_ReplaceObjectsAtIndexes() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        var indexes = IndexSet()
        indexes.insert(0)
        indexes.insert(2)
        set.replaceObjects(at: indexes, with: ["a", "b"])
        XCTAssertEqual(set.count, 3)
        XCTAssertEqual(set[0] as? String, "a")
        XCTAssertEqual(set[1] as? String, "bar")
        XCTAssertEqual(set[2] as? String, "b")
    }

    func test_Intersection() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        let otherSet = NSOrderedSet(array: ["foo", "baz"])
        XCTAssert(set.intersects(otherSet))
        let otherOtherSet = Set<AnyHashable>(["foo", "123"])
        XCTAssert(set.intersectsSet(otherOtherSet))
        set.intersect(otherSet)
        XCTAssertEqual(set.count, 2)
        XCTAssertEqual(set[0] as? String, "foo")
        XCTAssertEqual(set[1] as? String, "baz")
        set.intersectSet(otherOtherSet)
        XCTAssertEqual(set.count, 1)
        XCTAssertEqual(set[0] as? String, "foo")

        let nonIntersectingSet = Set<AnyHashable>(["asdf"])
        XCTAssertFalse(set.intersectsSet(nonIntersectingSet))
    }

    func test_Subtraction() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        let otherSet = NSOrderedSet(array: ["baz"])
        let otherOtherSet = Set<AnyHashable>(["foo"])
        set.minus(otherSet)
        XCTAssertEqual(set.count, 2)
        XCTAssertEqual(set[0] as? String, "foo")
        XCTAssertEqual(set[1] as? String, "bar")
        set.minusSet(otherOtherSet)
        XCTAssertEqual(set.count, 1)
        XCTAssertEqual(set[0] as? String, "bar")
    }

    func test_Union() {
        let set = NSMutableOrderedSet(arrayLiteral: "foo", "bar", "baz")
        let otherSet = NSOrderedSet(array: ["123", "baz"])
        let otherOtherSet = Set<AnyHashable>(["foo", "456"])
        set.union(otherSet)
        XCTAssertEqual(set.count, 4)
        XCTAssertEqual(set[0] as? String, "foo")
        XCTAssertEqual(set[1] as? String, "bar")
        XCTAssertEqual(set[2] as? String, "baz")
        XCTAssertEqual(set[3] as? String, "123")
        set.unionSet(otherOtherSet)
        XCTAssertEqual(set.count, 5)
        XCTAssertEqual(set[4] as? String, "456")
    }

    func test_Initializers() {
        let copyableObject = NSObject()
        let set = NSMutableOrderedSet(arrayLiteral: copyableObject, "bar", "baz")
        let newSet = NSOrderedSet(orderedSet: set)
        XCTAssert(newSet.isEqual(to: set))
//        XCTAssert(set[0] === newSet[0])

        let unorderedSet = Set<AnyHashable>(["foo", "bar", "baz"])
        let newSetFromUnorderedSet = NSOrderedSet(set: unorderedSet)
        XCTAssertEqual(newSetFromUnorderedSet.count, 3)
        XCTAssert(newSetFromUnorderedSet.contains("foo"))
    }

    func test_Sorting() {
        let set = NSMutableOrderedSet(arrayLiteral: "a", "d", "c", "b")
        set.sort(options: []) { lhs, rhs in
            if let lhs = lhs as? String, let rhs = rhs as? String {
                return lhs.compare(rhs)
            }
            return .orderedSame
        }
        XCTAssertEqual(set[0] as? String, "a")
        XCTAssertEqual(set[1] as? String, "b")
        XCTAssertEqual(set[2] as? String, "c")
        XCTAssertEqual(set[3] as? String, "d")

        set.sortRange(NSRange(location: 1, length: 2), options: []) { lhs, rhs in
            if let lhs = lhs as? String, let rhs = rhs as? String {
                return rhs.compare(lhs)
            }
            return .orderedSame
        }
        XCTAssertEqual(set[0] as? String, "a")
        XCTAssertEqual(set[1] as? String, "c")
        XCTAssertEqual(set[2] as? String, "b")
        XCTAssertEqual(set[3] as? String, "d")
    }

    func test_reversedEnumerationMutable() {
        let arr = ["foo", "bar", "baz"]
        let set = NSMutableOrderedSet()
        set.addObjects(from: arr)

        set.add("jazz")
        var index = set.count - 1
        var revSet = set.reverseObjectEnumerator()
        for item in revSet {
            XCTAssertEqual(set.object(at: index) as? String, item as? String)
            index -= 1
        }

        set.remove("jazz")
        index = set.count - 1
        revSet = set.reverseObjectEnumerator()
        for item in revSet {
            XCTAssertEqual(set.object(at: index) as? String, item as? String)
            index -= 1
        }


    }

    func test_reversedOrderedSetMutable() {
        let days = ["monday", "tuesday", "wednesday", "thursday", "friday"]
        let work =  NSMutableOrderedSet()
        work.addObjects(from: days)
        var krow = work.reversed
        XCTAssertEqual(work.firstObject as? String, krow.lastObject as? String)
        XCTAssertEqual(work.lastObject as? String, krow.firstObject as? String)

        work.add("saturday")
        krow = work.reversed
        XCTAssertEqual(work.firstObject as? String, krow.lastObject as? String)
        XCTAssertEqual(work.lastObject as? String, krow.firstObject as? String)
    }

    let fixtures = [
        Fixtures.orderedSetEmpty,
        Fixtures.orderedSetOfNumbers
    ]
    
    let mutableFixtures = [
        Fixtures.mutableOrderedSetEmpty,
        Fixtures.mutableOrderedSetOfNumbers
    ]
    
    func test_codingRoundtrip() throws {
        for fixture in fixtures {
            try fixture.assertValueRoundtripsInCoder()
        }
        for fixture in mutableFixtures {
            try fixture.assertValueRoundtripsInCoder()
        }
    }
    
    func test_loadedValuesMatch() throws {
        for fixture in fixtures {
            try fixture.assertLoadedValuesMatch()
        }
        for fixture in mutableFixtures {
            try fixture.assertLoadedValuesMatch()
        }
    }
    
    static var allTests: [(String, (TestNSOrderedSet) -> () throws -> Void)] {
        return [
            ("test_BasicConstruction", test_BasicConstruction),
            ("test_Enumeration", test_Enumeration),
            ("test_Uniqueness", test_Uniqueness),
            ("test_reversedEnumeration", test_reversedEnumeration),
            ("test_reversedOrderedSet", test_reversedOrderedSet),
            ("test_reversedEmpty", test_reversedEmpty),
            ("test_ObjectAtIndex", test_ObjectAtIndex),
            ("test_ObjectsAtIndexes", test_ObjectsAtIndexes),
            ("test_FirstAndLastObjects", test_FirstAndLastObjects),
            ("test_AddObject", test_AddObject),
            ("test_AddObjects", test_AddObjects),
            ("test_RemoveAllObjects", test_RemoveAllObjects),
            ("test_RemoveObject", test_RemoveObject),
            ("test_RemoveObjectAtIndex", test_RemoveObjectAtIndex),
            ("test_IsEqualToOrderedSet", test_IsEqualToOrderedSet),
            ("test_Subsets", test_Subsets),
            ("test_ReplaceObject", test_ReplaceObject),
            ("test_ExchangeObjects", test_ExchangeObjects),
            ("test_MoveObjects", test_MoveObjects),
            ("test_InsertObjects", test_InsertObjects),
            ("test_Insert", test_Insert),
            ("test_SetObjectAtIndex", test_SetObjectAtIndex),
            ("test_RemoveObjectsInRange", test_RemoveObjectsInRange),
            ("test_ReplaceObjectsAtIndexes", test_ReplaceObjectsAtIndexes),
            ("test_Intersection", test_Intersection),
            ("test_Subtraction", test_Subtraction),
            ("test_Union", test_Union),
            ("test_Initializers", test_Initializers),
            ("test_Sorting", test_Sorting),
            ("test_reversedEnumerationMutable", test_reversedEnumerationMutable),
            ("test_reversedOrderedSetMutable", test_reversedOrderedSetMutable),
            ("test_codingRoundtrip", test_codingRoundtrip),
            ("test_loadedValuesMatch", test_loadedValuesMatch),
        ]
    }
}