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

classTestNSArray:XCTestCase{
func test_BasicConstruction(){
letarray=NSArray()
letarray2:NSArray=["foo","bar"]
XCTAssertEqual(array.count,0)
XCTAssertEqual(array2.count,2)
}

func test_constructors(){
letarrayNil=NSArray(objects:nil, count:0)
XCTAssertEqual(arrayNil.count,0)

letarray1=NSArray(object:"foo")
XCTAssertEqual(array1.count,1)

lettestStrings:[AnyObject]=[NSString(string:"foo"),NSString(string:"bar")]
 testStrings.withUnsafeBufferPointer{ ptr in
letarray2=NSArray(objects: ptr.baseAddress, count:1)
XCTAssertEqual(array1, array2)
}

letarray3=NSArray(objects:"foo"asNSString,"bar"asNSString,"baz"asNSString)
XCTAssertEqual(array3.count,3)
letarray4=NSArray(array:["foo","bar","baz"])
XCTAssertEqual(array4.count,3)
letarray5=NSArray(arrayLiteral:"foo","bar","baz")
XCTAssertEqual(array5.count,3)
XCTAssertEqual(array3, array4)
XCTAssertEqual(array3, array5)
XCTAssertEqual(array4, array5)

letmutArray=NSMutableArray(array:[1,2,3,4])
letarray6=NSArray(array: mutArray)
XCTAssertEqual(array6, mutArray)
mutArray[0]=0
XCTAssertNotEqual(array6, mutArray)

letarray7=NSMutableArray(array: mutArray)
XCTAssertEqual(array7, mutArray)
 array7.removeObject(at:3)
XCTAssertNotEqual(array7.count, mutArray.count)
}

func test_constructorWithCopyItems(){
letfoo="foo"asNSMutableString

letarray1=NSArray(array:[foo], copyItems:false)
letarray2=NSArray(array:[foo], copyItems:true)

XCTAssertEqual(array1[0]as!String,"foo")
XCTAssertEqual(array2[0]as!String,"foo")
 foo.append("1")
XCTAssertEqual(array1[0]as!String,"foo1")
XCTAssertEqual(array2[0]as!String,"foo")
}

func test_enumeration(){
letarray:NSArray=["foo","bar","baz"]
lete= array.objectEnumerator()
XCTAssertEqual((e.nextObject()as!String),"foo")
XCTAssertEqual((e.nextObject()as!String),"bar")
XCTAssertEqual((e.nextObject()as!String),"baz")
XCTAssertNil(e.nextObject())
XCTAssertNil(e.nextObject())

letr= array.reverseObjectEnumerator()
XCTAssertEqual((r.nextObject()as!String),"baz")
XCTAssertEqual((r.nextObject()as!String),"bar")
XCTAssertEqual((r.nextObject()as!String),"foo")
XCTAssertNil(r.nextObject())
XCTAssertNil(r.nextObject())

letempty=NSArray().objectEnumerator()
XCTAssertNil(empty.nextObject())
XCTAssertNil(empty.nextObject())

letreverseEmpty=NSArray().reverseObjectEnumerator()
XCTAssertNil(reverseEmpty.nextObject())
XCTAssertNil(reverseEmpty.nextObject())
}

func test_enumerationUsingBlock(){
letarray:NSArray=NSArray(array:Array(0..<100))
letcreateIndexesArrayHavingSeen={(havingSeen:IndexSet)in
return(0..< array.count).map{ havingSeen.contains($0)}
}

letnoIndexes=IndexSet()
letallIndexes=IndexSet(integersIn:0..< array.count)
letfirstHalfOfIndexes=IndexSet(integersIn:0..< array.count /2)
letlastHalfOfIndexes=IndexSet(integersIn: array.count /2..< array.count)
letevenIndexes:IndexSet={
varindexes=IndexSet()
forindexin allIndexes.filter({ $0 %2==0}){
 indexes.insert(index)
}
return indexes
}()

lettestExpectingToSee={(expectation:IndexSet, block:(inoutUnsafeMutableBufferPointer<Bool>)->Void)in
varindexesSeen=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:
letoptionsToTest:[NSEnumerationOptions]=[
[],
[.concurrent],
[.reverse],
[.concurrent,.reverse],
]

foroptionsin 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),
letindexesForHalfEnumeration= 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.
varindexesForStaggeredEnumeration= indexesForHalfEnumeration
 indexesForStaggeredEnumeration.formIntersection(evenIndexes)

letfinalCount= indexesForStaggeredEnumeration.count

letlockForSeenCount=NSLock()
varseenCount=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
letcurrentCount= seenCount
 lockForSeenCount.unlock()

if currentCount == finalCount {
 stop.pointee =true
}
}
})
}
}

}

func test_sequenceType(){
letarray:NSArray=["foo","bar","baz"]
varres=[String]()
forobjin array {
 res.append((obj as!String))
}
XCTAssertEqual(res,["foo","bar","baz"])
}

// func test_getObjects() {
// let array : NSArray = ["foo", "bar", "baz", "foo1", "bar2", "baz3",].bridge()
// var objects = [AnyObject]()
// array.getObjects(&objects, range: NSRange(location: 1, length: 3))
// XCTAssertEqual(objects.count, 3)
// let fetched = [
// (objects[0] as! NSString).bridge(),
// (objects[1] as! NSString).bridge(),
// (objects[2] as! NSString).bridge(),
// ]
// XCTAssertEqual(fetched, ["bar", "baz", "foo1"])
// }

func test_objectAtIndex(){
letarray:NSArray=["foo","bar"]
letfoo= array.object(at:0)as!String
XCTAssertEqual(foo,"foo")

letbar= array.object(at:1)as!String
XCTAssertEqual(bar,"bar")
}

func test_binarySearch(){
letnumbers:[AnyObject]=[
NSNumber(value:0asInt),NSNumber(value:1asInt),NSNumber(value:2asInt),NSNumber(value:2asInt),NSNumber(value:3asInt),
NSNumber(value:4asInt),NSNumber(value:4asInt),NSNumber(value:6asInt),NSNumber(value:7asInt),NSNumber(value:7asInt),
NSNumber(value:7asInt),NSNumber(value:8asInt),NSNumber(value:9asInt),NSNumber(value:9asInt)]
letarray=NSArray(array: numbers)

 // Not sure how to test fatal errors.

// NSArray throws NSInvalidArgument if range exceeds bounds of the array.
// let rangeOutOfArray = NSRange(location: 5, length: 15)
// let _ = array.indexOfObject(NSNumber(value: 9 as Int), inSortedRange: rangeOutOfArray, options: [.insertionIndex, .firstEqual], usingComparator: compareIntNSNumber)

// NSArray throws NSInvalidArgument if both .firstEqual and .lastEqual are specified
// let searchForBoth: NSBinarySearchingOptions = [.firstEqual, .lastEqual]
// let _ = objectIndexInArray(array, value: 9, startingFrom: 0, length: 13, options: searchForBoth)

letnotFound=objectIndexInArray(array, value:11, startingFrom:0, length:13)
XCTAssertEqual(notFound, NSNotFound,"NSArray return NSNotFound if object is not found.")

letnotFoundInRange=objectIndexInArray(array, value:7, startingFrom:0, length:5)
XCTAssertEqual(notFoundInRange, NSNotFound,"NSArray return NSNotFound if object is not found.")

letindexOfAnySeven=objectIndexInArray(array, value:7, startingFrom:0, length:13)
XCTAssertTrue(Set([8,9,10]).contains(indexOfAnySeven),"If no options provided NSArray returns an arbitrary matching object's index.")

letindexOfFirstNine=objectIndexInArray(array, value:9, startingFrom:7, length:6, options:[.firstEqual])
XCTAssertTrue(indexOfFirstNine ==12,"If .FirstEqual is set NSArray returns the lowest index of equal objects.")

letindexOfLastTwo=objectIndexInArray(array, value:2, startingFrom:1, length:7, options:[.lastEqual])
XCTAssertTrue(indexOfLastTwo ==3,"If .LastEqual is set NSArray returns the highest index of equal objects.")

letanyIndexToInsertNine=objectIndexInArray(array, value:9, startingFrom:0, length:13, options:[.insertionIndex])
XCTAssertTrue(Set([12,13,14]).contains(anyIndexToInsertNine),"If .InsertionIndex is specified and no other options provided NSArray returns any equal or one larger index than any matching object’s index.")

letlowestIndexToInsertTwo=objectIndexInArray(array, value:2, startingFrom:0, length:5, options:[.insertionIndex,.firstEqual])
XCTAssertTrue(lowestIndexToInsertTwo ==2,"If both .InsertionIndex and .FirstEqual are specified NSArray returns the lowest index of equal objects.")

lethighestIndexToInsertNine=objectIndexInArray(array, value:9, startingFrom:7, length:6, options:[.insertionIndex,.lastEqual])
XCTAssertTrue(highestIndexToInsertNine ==13,"If both .InsertionIndex and .LastEqual are specified NSArray returns the index of the least greater object...")

letindexOfLeastGreaterObjectThanFive=objectIndexInArray(array, value:5, startingFrom:0, length:10, options:[.insertionIndex,.lastEqual])
XCTAssertTrue(indexOfLeastGreaterObjectThanFive ==7,"If both .InsertionIndex and .LastEqual are specified NSArray returns the index of the least greater object...")

letrangeStart=0
letrangeLength=13
letendOfArray=objectIndexInArray(array, value:10, startingFrom: rangeStart, length: rangeLength, options:[.insertionIndex,.lastEqual])
XCTAssertTrue(endOfArray ==(rangeStart + rangeLength),"...or the index at the end of the array if the object is larger than all other elements.")

letarrayOfTwo=NSArray(array:[NSNumber(value:0asInt),NSNumber(value:2asInt)])
letindexInMiddle=objectIndexInArray(arrayOfTwo, value:1, startingFrom:0, length:2, options:[.insertionIndex,.firstEqual])
XCTAssertEqual(indexInMiddle,1,"If no match found item should be inserted before least greater object")
letindexInMiddle2=objectIndexInArray(arrayOfTwo, value:1, startingFrom:0, length:2, options:[.insertionIndex,.lastEqual])
XCTAssertEqual(indexInMiddle2,1,"If no match found item should be inserted before least greater object")
letindexInMiddle3=objectIndexInArray(arrayOfTwo, value:1, startingFrom:0, length:2, options:[.insertionIndex])
XCTAssertEqual(indexInMiddle3,1,"If no match found item should be inserted before least greater object")
}


func test_arrayReplacement(){
letnumbers:[AnyObject]=[
NSNumber(value:0asInt),NSNumber(value:1asInt),NSNumber(value:2asInt),NSNumber(value:3asInt),
NSNumber(value:4asInt),NSNumber(value:5asInt),NSNumber(value:7asInt)]
letarray=NSMutableArray(array: numbers)
 array.replaceObjects(in:NSRange(location:0, length:2), withObjectsFrom:[NSNumber(value:8asInt),NSNumber(value:9asInt)])
XCTAssertTrue((array[0]as!NSNumber).intValue ==8)
XCTAssertTrue((array[1]as!NSNumber).intValue ==9)
XCTAssertTrue((array[2]as!NSNumber).intValue ==2)
}

func test_arrayReplaceObjectsInRangeFromRange(){
letnumbers:[AnyObject]=[
NSNumber(value:0asInt),NSNumber(value:1asInt),NSNumber(value:2asInt),NSNumber(value:3asInt),
NSNumber(value:4asInt),NSNumber(value:5asInt),NSNumber(value:7asInt)]
letarray=NSMutableArray(array: numbers)
 array.replaceObjects(in:NSRange(location:0, length:2), withObjectsFrom:[NSNumber(value:8asInt),NSNumber(value:9asInt),NSNumber(value:10asInt)], range:NSRange(location:1, length:2))
XCTAssertTrue((array[0]as!NSNumber).intValue ==9)
XCTAssertTrue((array[1]as!NSNumber).intValue ==10)
XCTAssertTrue((array[2]as!NSNumber).intValue ==2)
}

func test_replaceObjectAtIndex(){
letnumbers:[AnyObject]=[
NSNumber(value:0asInt),NSNumber(value:1asInt),NSNumber(value:2asInt),NSNumber(value:3asInt),
NSNumber(value:4asInt),NSNumber(value:5asInt),NSNumber(value:7asInt)]
letarray=NSMutableArray(array: numbers)

 // 1. Check replacement in the middle of the array
 array.replaceObject(at:3, with:NSNumber(value:8asInt))
XCTAssertEqual(array.count,7)
XCTAssertEqual((array[3]as!NSNumber).intValue,8)

 // 2. Check replacement of the first element
 array.replaceObject(at:0, with:NSNumber(value:7asInt))
XCTAssertEqual(array.count,7)
XCTAssertEqual((array[0]as!NSNumber).intValue,7)

 // 3. Check replacement of the last element
 array.replaceObject(at:6, with:NSNumber(value:6asInt))
XCTAssertEqual(array.count,7)
XCTAssertEqual((array[6]as!NSNumber).intValue,6)
}

func test_removeObjectsInArray(){
letnumbers:[AnyObject]=[
NSNumber(value:0asInt),NSNumber(value:1asInt),NSNumber(value:2asInt),NSNumber(value:3asInt),
NSNumber(value:4asInt),NSNumber(value:5asInt),NSNumber(value:7asInt)]
letarray=NSMutableArray(array: numbers)
letobjectsToRemove:Array<AnyObject>=[
NSNumber(value:1asInt),NSNumber(value:22asInt),NSNumber(value:7asInt),NSNumber(value:5asInt)]
 array.removeObjects(in: objectsToRemove)
XCTAssertEqual(array.count,4)
XCTAssertEqual((array[0]as!NSNumber).intValue,0)
XCTAssertEqual((array[1]as!NSNumber).intValue,2)
XCTAssertEqual((array[2]as!NSNumber).intValue,3)
XCTAssertEqual((array[3]as!NSNumber).intValue,4)
}

func test_binarySearchFringeCases(){
letnumbers:[AnyObject]=[
NSNumber(value:0asInt),NSNumber(value:1asInt),NSNumber(value:2asInt),NSNumber(value:2asInt),NSNumber(value:3asInt),
NSNumber(value:4asInt),NSNumber(value:4asInt),NSNumber(value:6asInt),NSNumber(value:7asInt),NSNumber(value:7asInt),
NSNumber(value:7asInt),NSNumber(value:8asInt),NSNumber(value:9asInt),NSNumber(value:9asInt)]
letarray=NSArray(array: numbers)

letemptyArray=NSArray()
// Same as for non empty NSArray but error message ends with 'bounds for empty array'.
// let _ = objectIndexInArray(emptyArray, value: 0, startingFrom: 0, length: 1)

letnotFoundInEmptyArray=objectIndexInArray(emptyArray, value:9, startingFrom:0, length:0)
XCTAssertEqual(notFoundInEmptyArray, NSNotFound,"Empty NSArray return NSNotFound for any valid arguments.")

letstartIndex=objectIndexInArray(emptyArray, value:7, startingFrom:0, length:0, options:[.insertionIndex])
XCTAssertTrue(startIndex ==0,"For Empty NSArray any objects should be inserted at start.")

letrangeStart=0
letrangeLength=13

letleastSearch=objectIndexInArray(array, value:-1, startingFrom: rangeStart, length: rangeLength)
XCTAssertTrue(leastSearch == NSNotFound,"If object is less than least object in the range then there is no change it could be found.")

letgreatestSearch=objectIndexInArray(array, value:15, startingFrom: rangeStart, length: rangeLength)
XCTAssertTrue(greatestSearch == NSNotFound,"If object is greater than greatest object in the range then there is no change it could be found.")

letleastInsert=objectIndexInArray(array, value:-1, startingFrom: rangeStart, length: rangeLength, options:.insertionIndex)
XCTAssertTrue(leastInsert == rangeStart,"If object is less than least object in the range it should be inserted at range' location.")

letgreatestInsert=objectIndexInArray(array, value:15, startingFrom: rangeStart, length: rangeLength, options:.insertionIndex)
XCTAssertTrue(greatestInsert ==(rangeStart + rangeLength),"If object is greater than greatest object in the range it should be inserted at range' end.")
}

func objectIndexInArray(_ array:NSArray, value:Int, startingFrom:Int, length:Int, options:NSBinarySearchingOptions=[])->Int{
return array.index(of:NSNumber(value: value), inSortedRange:NSRange(location: startingFrom, length: length), options: options, usingComparator: compareIntNSNumber)
}

func compareIntNSNumber(_ lhs:Any, rhs:Any)->ComparisonResult{
letlhsInt=(lhs as!NSNumber).intValue
letrhsInt=(rhs as!NSNumber).intValue
if lhsInt == rhsInt {
return.orderedSame
}
if lhsInt < rhsInt {
return.orderedAscending
}

return.orderedDescending
}

func test_replaceObjectsInRange_withObjectsFrom(){
letarray1=NSMutableArray(array:[
"foo1",
"bar1",
"baz1"])

letarray2:[Any]=[
"foo2",
"bar2",
"baz2"]

 array1.replaceObjects(in:NSRange(location:0, length:2), withObjectsFrom: array2)

XCTAssertEqual(array1[0]as?String,"foo2","Expected foo2 but was \(array1[0])")
XCTAssertEqual(array1[1]as?String,"bar2","Expected bar2 but was \(array1[1])")
XCTAssertEqual(array1[2]as?String,"baz2","Expected baz2 but was \(array1[2])")
XCTAssertEqual(array1[3]as?String,"baz1","Expected baz1 but was \(array1[3])")
}

func test_replaceObjectsInRange_withObjectsFrom_range(){
letarray1=NSMutableArray(array:[
"foo1",
"bar1",
"baz1"])

letarray2:[Any]=[
"foo2",
"bar2",
"baz2"]

 array1.replaceObjects(in:NSRange(location:1, length:1), withObjectsFrom: array2, range:NSRange(location:1, length:2))

XCTAssertEqual(array1[0]as?String,"foo1","Expected foo1 but was \(array1[0])")
XCTAssertEqual(array1[1]as?String,"bar2","Expected bar2 but was \(array1[1])")
XCTAssertEqual(array1[2]as?String,"baz2","Expected baz2 but was \(array1[2])")
XCTAssertEqual(array1[3]as?String,"baz1","Expected baz1 but was \(array1[3])")
}

func test_sortedArrayUsingComparator(){
 // sort with localized caseInsensitive compare
letinput=["this","is","a","test","of","sort","with","strings"]
letexpectedResult:Array<String>= input.sorted()
letresult=NSArray(array: input).sortedArray(comparator:){ left, right ->ComparisonResultin
letl= left as!String
letr= right as!String
return l.localizedCaseInsensitiveCompare(r)
}
XCTAssertEqual(result.map{($0 as!String)}, expectedResult)

 // sort empty array
letemptyArray=NSArray().sortedArray(comparator:){ _,_ in.orderedSame }
XCTAssertTrue(emptyArray.isEmpty)

 // sort numbers
letinputNumbers=[0,10,25,100,21,22]
letexpectedNumbers= inputNumbers.sorted()
letresultNumbers=NSArray(array: inputNumbers).sortedArray(comparator:){ left, right ->ComparisonResultin
letl=(left as!NSNumber).intValue
letr=(right as!NSNumber).intValue
return l < r ?.orderedAscending :(l == r ?.orderedSame :.orderedDescending)
}
XCTAssertEqual(resultNumbers.map{($0 as!NSNumber).intValue}, expectedNumbers)
}

func test_sortedArrayWithOptionsUsingComparator(){
 // check that sortedArrayWithOptions:comparator: works in the way sortedArrayUsingComparator does
letinput=NSArray(array:["this","is","a","test","of","sort","with","strings"])
letcomparator:(Any,Any)->ComparisonResult={ left, right ->ComparisonResultin
letl= left as!String
letr= right as!String
return l.localizedCaseInsensitiveCompare(r)
}
letresult1=NSArray(array: input.sortedArray(comparator: comparator))
letresult2= input.sortedArray(options:[], usingComparator: comparator)

XCTAssertTrue(result1.isEqual(to: result2))

 // sort empty array
letemptyArray=NSArray().sortedArray(options:[]){ _,_ in.orderedSame }
XCTAssertTrue(emptyArray.isEmpty)
}

func test_sortUsingFunction(){
letinputNumbers=[11,120,215,11,1,-22,35,-89,65]
letmutableInput=NSArray(array: inputNumbers).mutableCopy()as!NSMutableArray
letexpectedNumbers= inputNumbers.sorted()

func compare(_ left:Any, right:Any, context:UnsafeMutableRawPointer?)->Int{
letl=(left as!NSNumber).intValue
letr=(right as!NSNumber).intValue
return l < r ?-1:(l == r ?0:1)
}
 mutableInput.sort(compare, context:UnsafeMutableRawPointer(bitPattern:0))

XCTAssertEqual(mutableInput.map{($0 as!NSNumber).intValue}, expectedNumbers)
}

func test_sortUsingComparator(){
 // check behaviour with Array's sort method
letinputNumbers=[11,120,215,11,1,-22,35,-89,65]
letmutableInput=NSMutableArray(array: inputNumbers)
letexpectedNumbers= inputNumbers.sorted()

 mutableInput.sort{ left, right ->ComparisonResultin
letl=(left as!NSNumber).intValue
letr=(right as!NSNumber).intValue
return l < r ?.orderedAscending :(l == r ?.orderedSame :.orderedDescending)
}

XCTAssertEqual(mutableInput.map{($0 as!NSNumber).intValue}, expectedNumbers)

 // check that it works in the way self.sortWithOptions([], usingComparator: cmptr) does
letinputStrings=["this","is","a","test","of","sort","with","strings"]
letmutableStringsInput1=NSMutableArray(array: inputStrings)
letmutableStringsInput2=NSMutableArray(array: inputStrings)
letcomparator:(Any,Any)->ComparisonResult={ left, right ->ComparisonResultin
letl= left as!String
letr= right as!String
return l.localizedCaseInsensitiveCompare(r)
}
 mutableStringsInput1.sort(comparator: comparator)
 mutableStringsInput2.sort(options:[], usingComparator: comparator)
XCTAssertTrue(mutableStringsInput1.isEqual(to:Array(mutableStringsInput2)))
}

func test_equality(){
letarray1=NSArray(array:["this","is","a","test","of","equal","with","strings"])
letarray2=NSArray(array:["this","is","a","test","of","equal","with","strings"])
letarray3=NSArray(array:["this","is","a","test","of","equal","with","objects"])

XCTAssertTrue(array1 == array2)
XCTAssertTrue(array1.isEqual(array2))
XCTAssertTrue(array1.isEqual(to:Array(array2)))
 // if 2 arrays are equal, hashes should be equal as well. But not vise versa
XCTAssertEqual(array1.hash, array2.hash)
XCTAssertEqual(array1.hashValue, array2.hashValue)

XCTAssertFalse(array1 == array3)
XCTAssertFalse(array1.isEqual(array3))
XCTAssertFalse(array1.isEqual(to:Array(array3)))

XCTAssertFalse(array1.isEqual(nil))
XCTAssertFalse(array1.isEqual(NSObject()))

letobjectsArray1=NSArray(array:[NSArray(array:[0])])
letobjectsArray2=NSArray(array:[NSArray(array:[1])])
XCTAssertFalse(objectsArray1 == objectsArray2)
XCTAssertFalse(objectsArray1.isEqual(objectsArray2))
XCTAssertFalse(objectsArray1.isEqual(to:Array(objectsArray2)))
}

 /// - Note: value type conversion will destroy identity. So use index(of:) instead of indexOfObjectIdentical(to:)
func test_copying(){
letarray=NSArray(array:["this","is","a","test","of","copy","with","strings"])

letarrayCopy1= array.copy()as!NSArray
XCTAssertTrue(array === arrayCopy1)

letarrayMutableCopy= array.mutableCopy()as!NSMutableArray
letarrayCopy2= arrayMutableCopy.copy()as!NSArray
XCTAssertTrue(type(of: arrayCopy2)===NSArray.self)
XCTAssertFalse(arrayMutableCopy === arrayCopy2)
forentryin arrayCopy2 {
XCTAssertTrue(array.index(of: entry)!= NSNotFound)
}

}

func test_mutableCopying(){
letarray=NSArray(array:["this","is","a","test","of","mutableCopy","with","strings"])

letarrayMutableCopy1= array.mutableCopy()as!NSMutableArray
XCTAssertTrue(type(of: arrayMutableCopy1)===NSMutableArray.self)
XCTAssertFalse(array === arrayMutableCopy1)
forentryin arrayMutableCopy1 {
XCTAssertTrue(array.index(of: entry)!= NSNotFound)
}

letarrayMutableCopy2= arrayMutableCopy1.mutableCopy()as!NSMutableArray
XCTAssertTrue(type(of: arrayMutableCopy2)===NSMutableArray.self)
XCTAssertFalse(arrayMutableCopy2 === arrayMutableCopy1)
forentryin arrayMutableCopy2 {
XCTAssertTrue(arrayMutableCopy1.index(of: entry)!= NSNotFound)
}
}

@available(*, deprecated) // test of deprecated API, suppress deprecation warning
func test_initWithContentsOfFile(){
lettestFilePath=createTestFile("TestFileOut.txt", _contents:Data(capacity:234))
iflet _ = testFilePath {
leta1:NSArray=["foo","bar"]
letisWritten= a1.write(toFile: testFilePath!, atomically:true)
if isWritten {
letarray=NSArray.init(contentsOfFile: testFilePath!)
XCTAssert(array == a1)
}else{
XCTFail("Write to file failed")
}
removeTestFile(testFilePath!)
}else{
XCTFail("Temporary file creation failed")
}
}

@available(*, deprecated) // test of deprecated API, suppress deprecation warning
func test_initMutableWithContentsOfFile(){
iflet testFilePath =createTestFile("TestFileOut.txt", _contents:Data(capacity:234)){
leta1:NSArray=["foo","bar"]
letisWritten= a1.write(toFile: testFilePath, atomically:true)
if isWritten {
letarray=NSMutableArray.init(contentsOfFile: testFilePath)
XCTAssert(array == a1)
XCTAssertEqual(array?.count,2)
 array?.removeAllObjects()
XCTAssertEqual(array?.count,0)
}else{
XCTFail("Write to file failed")
}
removeTestFile(testFilePath)
}else{
XCTFail("Temporary file creation failed")
}
}

@available(*, deprecated) // test of deprecated API, suppress deprecation warning
func test_initMutableWithContentsOfURL(){
iflet testFilePath =createTestFile("TestFileOut.txt", _contents:Data(capacity:234)){
leta1:NSArray=["foo","bar"]
letisWritten= a1.write(toFile: testFilePath, atomically:true)
if isWritten {
leturl=URL(fileURLWithPath: testFilePath, isDirectory:false)
letarray=NSMutableArray.init(contentsOf: url)
XCTAssert(array == a1)
XCTAssertEqual(array?.count,2)
 array?.removeAllObjects()
XCTAssertEqual(array?.count,0)
}else{
XCTFail("Write to file failed")
}
removeTestFile(testFilePath)
}else{
XCTFail("Temporary file creation failed")
}
}

@available(*, deprecated) // test of deprecated API, suppress deprecation warning
func test_writeToFile(){
lettestFilePath=createTestFile("TestFileOut.txt", _contents:Data(capacity:234))
iflet _ = testFilePath {
letd1:NSArray=["foo","bar"]
letisWritten= d1.write(toFile: testFilePath!, atomically:true)
if isWritten {
do{
letplistDoc=tryXMLDocument(contentsOf:URL(fileURLWithPath: testFilePath!, isDirectory:false), options:[])
XCTAssert(plistDoc.rootElement()?.name =="plist")
letplist=tryPropertyListSerialization.propertyList(from: plistDoc.xmlData, options:[], format:nil)as![Any]
XCTAssert((plist[0]as?String)==d1[0]as?String)
XCTAssert((plist[1]as?String)==d1[1]as?String)
}catch{
XCTFail("Failed to read and parse XMLDocument")
}
}else{
XCTFail("Write to file failed")
}
removeTestFile(testFilePath!)
}else{
XCTFail("Temporary file creation failed")
}
}

func test_readWriteURL(){
letdata=NSArray(arrayLiteral:"one","two","three","four","five")
do{
lettempDir=NSTemporaryDirectory()+"TestFoundation_Playground_"+ NSUUID().uuidString
tryFileManager.default.createDirectory(atPath: tempDir, withIntermediateDirectories:false, attributes:nil)
lettestFile= tempDir +"/readWriteURL.txt"
leturl=URL(fileURLWithPath: testFile)
letdata2:NSArray
#if DARWIN_COMPATIBILITY_TESTS
if #available(macOS 10.13,*){
try data.write(to: url)
 data2 =tryNSArray(contentsOf: url, error:())
}else{
guard data.write(toFile: testFile, atomically:true)else{
throwNSError(domain: NSCocoaErrorDomain, code:CocoaError.fileWriteUnknown.rawValue)
}
 data2 =NSArray(contentsOfFile: testFile)!
}
#else
try data.write(to: url)
 data2 =tryNSArray(contentsOf: url, error:())
#endif
XCTAssertEqual(data, data2)
removeTestFile(testFile)
}catch{
XCTFail("Failed to write to file: \(error)")
}
}

func test_insertObjectAtIndex(){
leta1=NSMutableArray(arrayLiteral:"one","two","three","four")
 a1.insert("a", at:0)
XCTAssertEqual(a1,["a","one","two","three","four"])

leta2=NSMutableArray(arrayLiteral:"one","two","three","four")
 a2.insert("a", at:4)
XCTAssertEqual(a2,["one","two","three","four","a"])

leta3=NSMutableArray()
 a3.insert("a", at:0)
XCTAssertEqual(a3,["a"])
}

func test_insertObjectsAtIndexes(){
leta1=NSMutableArray(arrayLiteral:"one","two","three","four")
 a1.insert(["a","b"], at:[0,1])
XCTAssertEqual(a1,["a","b","one","two","three","four"])

leta2=NSMutableArray(arrayLiteral:"one","two","three","four")
 a2.insert(["a","b"], at:[1,3])
XCTAssertEqual(a2,["one","a","two","b","three","four"])

leta3=NSMutableArray(arrayLiteral:"one","two","three","four")
 a3.insert(["a","b"], at:[5,4])
XCTAssertEqual(a3,["one","two","three","four","a","b"])

leta4=NSMutableArray()
 a4.insert(["a","b"], at:[0,1])
XCTAssertEqual(a4,["a","b"])
}

func test_replaceObjectsAtIndexesWithObjects(){
leta1=NSMutableArray(arrayLiteral:"one","two","three","four")
 a1.replaceObjects(at:[0], with:["a"])
XCTAssertEqual(a1,["a","two","three","four"])

leta2=NSMutableArray(arrayLiteral:"one","two","three","four")
 a2.replaceObjects(at:[1,2], with:["a","b"])
XCTAssertEqual(a2,["one","a","b","four"])

leta3=NSMutableArray(arrayLiteral:"one","two","three","four")
 a3.replaceObjects(at:[3,2,1,0], with:["a","b","c","d"])
XCTAssertEqual(a3,["a","b","c","d"])
}

func test_pathsMatchingExtensions(){
letpaths=NSArray(arrayLiteral:"file1.txt","/tmp/file2.txt","file3.jpg","file3.png","/file4.png","txt",".txt")
letmatch1= paths.pathsMatchingExtensions(["txt"])
XCTAssertEqual(match1,["file1.txt","/tmp/file2.txt"])

letmatch2= paths.pathsMatchingExtensions([])
XCTAssertEqual(match2,[])

letmatch3= paths.pathsMatchingExtensions([".txt","png"])
XCTAssertEqual(match3,["file3.png","/file4.png"])

letmatch4= paths.pathsMatchingExtensions(["",".tx","tx"])
XCTAssertEqual(match4,[])

letmatch5= paths.pathsMatchingExtensions(["..txt"])
XCTAssertEqual(match5,[])
}

func test_customMirror(){
letinputArray=["this","is","a","test","of","custom","mirror"]
letarray=NSArray(array: inputArray)
letarrayMirror= array.customMirror

XCTAssertEqual(array[0]as!String, arrayMirror.descendant(0)as!String)
XCTAssertEqual(array[1]as!String, arrayMirror.descendant(1)as!String)
XCTAssertEqual(array[2]as!String, arrayMirror.descendant(2)as!String)
XCTAssertEqual(array[3]as!String, arrayMirror.descendant(3)as!String)
XCTAssertEqual(array[4]as!String, arrayMirror.descendant(4)as!String)
XCTAssertEqual(array[5]as!String, arrayMirror.descendant(5)as!String)
XCTAssertEqual(array[6]as!String, arrayMirror.descendant(6)as!String)
}

privatefunc createTestFile(_ path:String, _contents:Data)->String?{
lettempDir=NSTemporaryDirectory()+"TestFoundation_Playground_"+ NSUUID().uuidString +"/"
do{
tryFileManager.default.createDirectory(atPath: tempDir, withIntermediateDirectories:false, attributes:nil)
ifFileManager.default.createFile(atPath: tempDir +"/"+ path, contents: _contents, attributes:nil){
return tempDir + path
}else{
returnnil
}
}catch{
returnnil
}
}

privatefunc removeTestFile(_ location:String){
try?FileManager.default.removeItem(atPath: location)
}
}