// 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
//


#if DEPLOYMENT_RUNTIME_OBJC || os(Linux)
import Foundation
import XCTest
#else
import SwiftFoundation
import SwiftXCTest
#endif


class TestNSSet : XCTestCase {
    
    static var allTests: [(String, (TestNSSet) -> () throws -> Void)] {
        return [
            ("test_BasicConstruction", test_BasicConstruction),
            ("testInitWithSet", testInitWithSet),
            ("test_enumeration", test_enumeration),
            ("test_sequenceType", test_sequenceType),
            ("test_setOperations", test_setOperations),
            ("test_equality", test_equality),
            ("test_copying", test_copying),
            ("test_mutableCopying", test_mutableCopying),
            ("test_CountedSetBasicConstruction", test_CountedSetBasicConstruction),
            ("test_CountedSetObjectCount", test_CountedSetObjectCount),
            ("test_CountedSetAddObject", test_CountedSetAddObject),
            ("test_CountedSetRemoveObject", test_CountedSetRemoveObject),
            ("test_CountedSetCopying", test_CountedSetCopying),
            ("test_mutablesetWithDictionary", test_mutablesetWithDictionary),
        ]
    }
    
    func test_BasicConstruction() {
        let set = NSSet()
        let set2 = NSSet(array: ["foo", "bar"])
        XCTAssertEqual(set.count, 0)
        XCTAssertEqual(set2.count, 2)
    }

    func testInitWithSet() {
        let genres: Set<AnyHashable> = ["Rock", "Classical", "Hip hop"]
        let set1 = NSSet(set: genres)
        let set2 = NSSet(set: genres, copyItems: false)
        XCTAssertEqual(set1.count, 3)
        XCTAssertEqual(set2.count, 3)
        XCTAssertEqual(set1, set2)

        let set3 = NSSet(set: genres, copyItems: true)
        XCTAssertEqual(set3.count, 3)
        XCTAssertEqual(set3, set2)
    }
    
    func test_enumeration() {
        let set = NSSet(array: ["foo", "bar", "baz"])
        let e = set.objectEnumerator()
        var result = Set<String>()
        result.insert((e.nextObject()! as! String))
        result.insert((e.nextObject()! as! String))
        result.insert((e.nextObject()! as! String))
        XCTAssertEqual(result, Set(["foo", "bar", "baz"]))
        
        let empty = NSSet().objectEnumerator()
        XCTAssertNil(empty.nextObject())
        XCTAssertNil(empty.nextObject())
    }
    
    func test_sequenceType() {
        let set = NSSet(array: ["foo", "bar", "baz"])
        var res = Set<String>()
        for obj in set {
            res.insert((obj as! String))
        }
        XCTAssertEqual(res, Set(["foo", "bar", "baz"]))
    }
    
    func test_setOperations() {
        let set = NSMutableSet(array: ["foo", "bar"])
        set.union(["bar", "baz"])
        XCTAssertTrue(set.isEqual(to: ["foo", "bar", "baz"]))
    }

    func test_equality() {
        let inputArray1 = ["this", "is", "a", "test", "of", "equality", "with", "strings"]
        let inputArray2 = ["this", "is", "a", "test", "of", "equality", "with", "objects"]
        let set1 = NSSet(array: inputArray1)
        let set2 = NSSet(array: inputArray1)
        let set3 = NSSet(array: inputArray2)

        XCTAssertTrue(set1 == set2)
        XCTAssertTrue(set1.isEqual(set2))
        XCTAssertTrue(set1.isEqual(to: Set(inputArray1)))
        XCTAssertEqual(set1.hash, set2.hash)
        XCTAssertEqual(set1.hashValue, set2.hashValue)

        XCTAssertFalse(set1 == set3)
        XCTAssertFalse(set1.isEqual(set3))
        XCTAssertFalse(set1.isEqual(to: Set(inputArray2)))

        XCTAssertFalse(set1.isEqual(nil))
        XCTAssertFalse(set1.isEqual(NSObject()))
    }

    func test_copying() {
        let inputArray = ["this", "is", "a", "test", "of", "copy", "with", "strings"]
        
        let set = NSSet(array: inputArray)
        let setCopy1 = set.copy() as! NSSet
        XCTAssertTrue(set === setCopy1)

        let setMutableCopy = set.mutableCopy() as! NSMutableSet
        let setCopy2 = setMutableCopy.copy() as! NSSet
        XCTAssertTrue(type(of: setCopy2) === NSSet.self)
        XCTAssertFalse(setMutableCopy === setCopy2)
        for entry in setCopy2 {
            XCTAssertTrue(NSArray(array: setMutableCopy.allObjects).index(of: entry) != NSNotFound)
        }
    }

    func test_mutableCopying() {
        let inputArray = ["this", "is", "a", "test", "of", "mutableCopy", "with", "strings"]
        let set = NSSet(array: inputArray)

        let setMutableCopy1 = set.mutableCopy() as! NSMutableSet
        XCTAssertTrue(type(of: setMutableCopy1) === NSMutableSet.self)
        XCTAssertFalse(set === setMutableCopy1)
        for entry in setMutableCopy1 {
            XCTAssertTrue(NSArray(array: set.allObjects).index(of: entry) != NSNotFound)
        }

        let setMutableCopy2 = setMutableCopy1.mutableCopy() as! NSMutableSet
        XCTAssertTrue(type(of: setMutableCopy2) === NSMutableSet.self)
        XCTAssertFalse(setMutableCopy2 === setMutableCopy1)
        for entry in setMutableCopy2 {
            XCTAssertTrue(NSArray(array: setMutableCopy1.allObjects).index(of: entry) != NSNotFound)
        }
    }

    func test_CountedSetBasicConstruction() {
        let v1 = "v1"
        let v2 = "v2"
        let v3asv1 = "v1"
        let set = NSCountedSet()
        let set2 = NSCountedSet(array: [v1, v1, v2,v3asv1])
        let set3 = NSCountedSet(set: [v1, v1, v2,v3asv1])
        let set4 = NSCountedSet(capacity: 4)

        XCTAssertEqual(set.count, 0)
        XCTAssertEqual(set2.count, 2)
        XCTAssertEqual(set3.count, 2)
        XCTAssertEqual(set4.count, 0)

    }

    func test_CountedSetObjectCount() {
        let v1 = "v1"
        let v2 = "v2"
        let v3asv1 = "v1"
        let set = NSCountedSet()
        let set2 = NSCountedSet(array: [v1, v1, v2,v3asv1])
        let set3 = NSCountedSet(set: [v1, v1, v2,v3asv1])

        XCTAssertEqual(set.count(for: v1), 0)
        XCTAssertEqual(set2.count(for: v1), 3)
        XCTAssertEqual(set2.count(for: v2), 1)
        XCTAssertEqual(set2.count(for: v3asv1), 3)
        XCTAssertEqual(set3.count(for: v1), 1)
        XCTAssertEqual(set3.count(for: v2), 1)
        XCTAssertEqual(set3.count(for: v3asv1), 1)
    }

    func test_CountedSetAddObject() {
        let v1 = "v1"
        let v2 = "v2"
        let v3asv1 = "v1"
        let set = NSCountedSet(array: [v1, v1, v2])

        XCTAssertEqual(set.count(for: v1), 2)
        XCTAssertEqual(set.count(for: v2), 1)
        set.add(v3asv1)
        XCTAssertEqual(set.count(for: v1), 3)
        set.addObjects(from: [v1,v2])
        XCTAssertEqual(set.count(for: v1), 4)
        XCTAssertEqual(set.count(for: v2), 2)
    }


    func test_CountedSetRemoveObject() {
        let v1 = "v1"
        let v2 = "v2"
        let set = NSCountedSet(array: [v1, v1, v2])

        XCTAssertEqual(set.count(for: v1), 2)
        XCTAssertEqual(set.count(for: v2), 1)
        set.remove(v2)
        XCTAssertEqual(set.count(for: v2), 0)
        XCTAssertEqual(set.count(for: v1), 2)
        set.remove(v2)
        XCTAssertEqual(set.count(for: v2), 0)
        XCTAssertEqual(set.count(for: v1), 2)
        set.removeAllObjects()
        XCTAssertEqual(set.count(for: v2), 0)
        XCTAssertEqual(set.count(for: v1), 0)
    }

    func test_CountedSetCopying() {
        let inputArray = ["this", "is", "a", "test", "of", "copy", "with", "strings"]

        let set = NSCountedSet(array: inputArray)
        let setCopy = set.copy() as! NSCountedSet
        XCTAssertFalse(set === setCopy)

        let setMutableCopy = set.mutableCopy() as! NSCountedSet
        XCTAssertFalse(set === setMutableCopy)
        XCTAssertTrue(type(of: setCopy) === NSCountedSet.self)
        XCTAssertTrue(type(of: setMutableCopy) === NSCountedSet.self)
        for entry in setCopy {
            XCTAssertTrue(NSArray(array: setMutableCopy.allObjects).index(of: entry) != NSNotFound)
        }
    }
    
    func test_mutablesetWithDictionary() {
        let aSet = NSMutableSet()
        let dictionary = NSMutableDictionary()
        let key = NSString(string: "Hello")
        aSet.add(["world": "again"])
        dictionary.setObject(aSet, forKey: key)
        XCTAssertNotNil(dictionary.description) //should not crash
    }
}