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

privatestructBox:Equatable{
privateletns:NSCharacterSet
privateletswift:CharacterSet

privateinit(ns:NSCharacterSet, swift:CharacterSet){
self.ns = ns
self.swift = swift
}

init(charactersIn string:String){
self.ns =NSCharacterSet(charactersIn: string)
self.swift =CharacterSet(charactersIn: string)
}

staticvaralphanumerics:Box{
returnBox(ns:NSCharacterSet.alphanumerics._bridgeToObjectiveC(),
 swift:.alphanumerics)
}

staticvardecimalDigits:Box{
returnBox(ns:NSCharacterSet.decimalDigits._bridgeToObjectiveC(),
 swift:.decimalDigits)
}

 // MARK: Equatable

staticfunc==(lhs:Box, rhs:Box)->Bool{
return lhs.ns == rhs.ns
 && lhs.swift == rhs.swift
 && lhs.ns._bridgeToSwift()== rhs.ns._bridgeToSwift()
 && lhs.swift._bridgeToObjectiveC()== rhs.swift._bridgeToObjectiveC()
 && lhs.ns.isEqual(rhs.ns)
 && lhs.ns.isEqual(rhs.swift)
 && lhs.ns.isEqual(rhs.ns._bridgeToSwift())
 && lhs.ns.isEqual(rhs.swift._bridgeToObjectiveC())
 && lhs.swift._bridgeToObjectiveC().isEqual(rhs.ns)
 && lhs.swift._bridgeToObjectiveC().isEqual(rhs.swift)
 && lhs.swift._bridgeToObjectiveC().isEqual(rhs.ns._bridgeToSwift())
 && lhs.swift._bridgeToObjectiveC().isEqual(rhs.swift._bridgeToObjectiveC())
}
}

classTestCharacterSet:XCTestCase{

letcapitalA=UnicodeScalar(0x0041)! // LATIN CAPITAL LETTER A
letcapitalB=UnicodeScalar(0x0042)! // LATIN CAPITAL LETTER B
letcapitalC=UnicodeScalar(0x0043)! // LATIN CAPITAL LETTER C

func testBasicConstruction(){
 // Create a character set
letcs=CharacterSet.letters

 // Use some method from it
letinvertedCs= cs.inverted
XCTAssertTrue(!invertedCs.contains(capitalA),"Character set must not contain our letter")

 // Use another method from it
letoriginalCs= invertedCs.inverted

XCTAssertTrue(originalCs.contains(capitalA),"Character set must contain our letter")
}

func testMutability_copyOnWrite(){
varfirstCharacterSet=CharacterSet(charactersIn:"ABC")
XCTAssertTrue(firstCharacterSet.contains(capitalA),"Character set must contain our letter")
XCTAssertTrue(firstCharacterSet.contains(capitalB),"Character set must contain our letter")
XCTAssertTrue(firstCharacterSet.contains(capitalC),"Character set must contain our letter")

 // Make a 'copy' (just the struct)
varsecondCharacterSet= firstCharacterSet
 // first: ABC, second: ABC

 // Mutate first and verify that it has correct content
 firstCharacterSet.remove(charactersIn:"A")
 // first: BC, second: ABC

XCTAssertTrue(!firstCharacterSet.contains(capitalA),"Character set must not contain our letter")
XCTAssertTrue(secondCharacterSet.contains(capitalA),"Copy should not have been mutated")

 // Make a 'copy' (just the struct) of the second set, mutate it
letthirdCharacterSet= secondCharacterSet
 // first: BC, second: ABC, third: ABC

 secondCharacterSet.remove(charactersIn:"B")
 // first: BC, second: AC, third: ABC

XCTAssertTrue(firstCharacterSet.contains(capitalB),"Character set must contain our letter")
XCTAssertTrue(!secondCharacterSet.contains(capitalB),"Character set must not contain our letter")
XCTAssertTrue(thirdCharacterSet.contains(capitalB),"Character set must contain our letter")

 firstCharacterSet.remove(charactersIn:"C")
 // first: B, second: AC, third: ABC

XCTAssertTrue(!firstCharacterSet.contains(capitalC),"Character set must not contain our letter")
XCTAssertTrue(secondCharacterSet.contains(capitalC),"Character set must not contain our letter")
XCTAssertTrue(thirdCharacterSet.contains(capitalC),"Character set must contain our letter")
}

func testRanges(){
 // Simple range check
letasciiUppercase=CharacterSet(charactersIn:UnicodeScalar(0x41)!...UnicodeScalar(0x5A)!)
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x49)!))
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)!))
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))
XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x5B)!))

 // Some string filtering tests
letasciiLowercase=CharacterSet(charactersIn:UnicodeScalar(0x61)!...UnicodeScalar(0x7B)!)
lettestString="helloHELLOhello"
letexpected="HELLO"

letresult= testString.trimmingCharacters(in: asciiLowercase)
XCTAssertEqual(result, expected)
}

func testInsertAndRemove(){
varasciiUppercase=CharacterSet(charactersIn:UnicodeScalar(0x41)!...UnicodeScalar(0x5A)!)
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x49)!))
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)!))
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))

 asciiUppercase.remove(UnicodeScalar(0x49))
XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x49)!))
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x5A)!))
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))


 // Zero-length range
 asciiUppercase.remove(charactersIn:UnicodeScalar(0x41)!..<UnicodeScalar(0x41)!)
XCTAssertTrue(asciiUppercase.contains(UnicodeScalar(0x41)!))

 asciiUppercase.remove(charactersIn:UnicodeScalar(0x41)!..<UnicodeScalar(0x42)!)
XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x41)!))

 asciiUppercase.remove(charactersIn:"Z")
XCTAssertTrue(!asciiUppercase.contains(UnicodeScalar(0x5A)!))
}

func testBasics(){

varresult:[String]=[]

letstring="The quick, brown, fox jumps over the lazy dog - because, why not?"
varset=CharacterSet(charactersIn:",-")
 result = string.components(separatedBy: set)
XCTAssertEqual(5, result.count)
XCTAssertEqual(["The quick"," brown"," fox jumps over the lazy dog "," because"," why not?"], result)

 set.remove(charactersIn:",")
 set.insert(charactersIn:"")
 result = string.components(separatedBy: set)
XCTAssertEqual(14, result.count)

 set.remove("".unicodeScalars.first!)
 result = string.components(separatedBy: set)
XCTAssertEqual(2, result.count)
}

func test_Predefines(){
letcset=CharacterSet.controlCharacters

XCTAssertTrue(cset.contains(UnicodeScalar(0xFEFF)!),"Control set should contain UFEFF")
XCTAssertTrue(CharacterSet.letters.contains(UnicodeScalar(0x61)!),"Letter set should contain 'a'")
XCTAssertTrue(CharacterSet.lowercaseLetters.contains(UnicodeScalar(0x61)!),"Lowercase Letter set should contain 'a'")
XCTAssertTrue(CharacterSet.uppercaseLetters.contains(UnicodeScalar(0x41)!),"Uppercase Letter set should contain 'A'")
XCTAssertTrue(CharacterSet.uppercaseLetters.contains(UnicodeScalar(0x01C5)!),"Uppercase Letter set should contain U01C5")
XCTAssertTrue(CharacterSet.capitalizedLetters.contains(UnicodeScalar(0x01C5)!),"Uppercase Letter set should contain U01C5")
XCTAssertTrue(CharacterSet.symbols.contains(UnicodeScalar(0x002B)!),"Symbol set should contain U002B")
XCTAssertTrue(CharacterSet.symbols.contains(UnicodeScalar(0x20B1)!),"Symbol set should contain U20B1")
XCTAssertTrue(CharacterSet.newlines.contains(UnicodeScalar(0x000A)!),"Newline set should contain 0x000A")
XCTAssertTrue(CharacterSet.newlines.contains(UnicodeScalar(0x2029)!),"Newline set should contain 0x2029")

letmcset=CharacterSet.whitespacesAndNewlines
letcset2=CharacterSet.whitespacesAndNewlines

XCTAssert(mcset.isSuperset(of: cset2))
XCTAssert(cset2.isSuperset(of: mcset))

XCTAssertTrue(CharacterSet.whitespacesAndNewlines.isSuperset(of:.newlines),"whitespace and newline should be a superset of newline")
letdata=CharacterSet.uppercaseLetters.bitmapRepresentation
XCTAssertNotNil(data)
}

func test_Range(){
// let cset1 = CharacterSet(range: NSRange(location: 0x20, length: 40))
letcset1=CharacterSet(charactersIn:UnicodeScalar(0x20)!..<UnicodeScalar(0x20+40)!)
foridx:unicharin0..<0xFFFF{
if idx <0xD800 || idx >0xDFFF{
XCTAssertEqual(cset1.contains(UnicodeScalar(idx)!),(idx >=0x20 && idx <0x20+40?true:false))
}

}

letcset2=CharacterSet(charactersIn:UnicodeScalar(0x0000)!..<UnicodeScalar(0xFFFF)!)
foridx:unicharin0..<0xFFFF{
if idx <0xD800 || idx >0xDFFF{
XCTAssertEqual(cset2.contains(UnicodeScalar(idx)!),true)
}

}


letcset3=CharacterSet(charactersIn:UnicodeScalar(0x0000)!..<UnicodeScalar(10)!)
foridx:unicharin0..<0xFFFF{
if idx <0xD800 || idx >0xDFFF{
XCTAssertEqual(cset3.contains(UnicodeScalar(idx)!),(idx <10?true:false))
}

}

letcset4=CharacterSet(charactersIn:UnicodeScalar(0x20)!..<UnicodeScalar(0x20)!)
foridx:unicharin0..<0xFFFF{
if idx <0xD800 || idx >0xDFFF{
XCTAssertEqual(cset4.contains(UnicodeScalar(idx)!),false)
}

}
}

func test_String(){
letcset=CharacterSet(charactersIn:"abcABC")
foridx:unicharin0..<0xFFFF{
if idx <0xD800 || idx >0xDFFF{
XCTAssertEqual(cset.contains(UnicodeScalar(idx)!),(idx >=unichar(unicodeScalarLiteral:"a") && idx <=unichar(unicodeScalarLiteral:"c")) || (idx >=unichar(unicodeScalarLiteral:"A") && idx <=unichar(unicodeScalarLiteral:"C"))?true:false)
}
}
}

func testClosedRanges_SR_2988(){
 // "CharacterSet.insert(charactersIn: ClosedRange) crashes on a closed ClosedRange<UnicodeScalar> containing U+D7FF"
letproblematicChar=UnicodeScalar(0xD7FF)!
letrange= capitalA...problematicChar
varcharacters=CharacterSet(charactersIn: range) // this should not crash
XCTAssertTrue(characters.contains(problematicChar))
 characters.remove(charactersIn: range) // this should not crash
XCTAssertTrue(!characters.contains(problematicChar))
 characters.insert(charactersIn: range) // this should not crash
XCTAssertTrue(characters.contains(problematicChar))
}

func test_Bitmap(){

}

func test_AnnexPlanes(){

}

func test_Planes(){

}

func test_InlineBuffer(){

}

func test_Subtracting(){
letdifference=CharacterSet(charactersIn:"abc").subtracting(CharacterSet(charactersIn:"b"))
letexpected=CharacterSet(charactersIn:"ac")
XCTAssertEqual(expected, difference)
}

func test_SubtractEmptySet(){
varmutableSet=CharacterSet(charactersIn:"abc")
letemptySet=CharacterSet()
 mutableSet.subtract(emptySet)
letexpected=CharacterSet(charactersIn:"abc")
XCTAssertEqual(expected, mutableSet)
}

func test_SubtractNonEmptySet(){
varmutableSet=CharacterSet()
letnonEmptySet=CharacterSet(charactersIn:"abc")
 mutableSet.subtract(nonEmptySet)
XCTAssertTrue(mutableSet.isEmpty)
}

func test_SymmetricDifference(){
letsymmetricDifference=CharacterSet(charactersIn:"ac").symmetricDifference(CharacterSet(charactersIn:"b"))
letexpected=CharacterSet(charactersIn:"abc")
XCTAssertEqual(expected, symmetricDifference)
}

func test_Equatable(){
letequalPairs=[
("",""),
("a","a"),
("abcde","abcde"),
("12345","12345")
]

 /*
 Tests disabled due to CoreFoundation bug?
 These NSCharacterSet pairs are (wrongly?) evaluated to be equal. Same behaviour can be observed on macOS 10.12.
 Interestingly, on iOS 11 Simulator, they are evaluated to be _not_ equal,
 while on iOS 10.3.1 Simulator, they are evaluated to be equal.
 */
letnotEqualPairs=[
("abc","123"),
// ("ab", "abc"),
// ("abc", "")
]

forpairin equalPairs {
XCTAssertEqual(Box(charactersIn: pair.0),Box(charactersIn: pair.1))
}
XCTAssertEqual(Box.alphanumerics,Box.alphanumerics)

forpairin notEqualPairs {
XCTAssertNotEqual(Box(charactersIn: pair.0),Box(charactersIn: pair.1))
}
XCTAssertNotEqual(Box.alphanumerics,Box.decimalDigits)
}

func test_formUnion(){
varcharset=CharacterSet(charactersIn:"a")
 charset.formUnion(CharacterSet(charactersIn:"A"))
XCTAssertTrue(charset.contains("A"asUnicodeScalar))
}

func test_union(){
letcharset=CharacterSet(charactersIn:"a")
letunion= charset.union(CharacterSet(charactersIn:"A"))
XCTAssertTrue(union.contains("A"asUnicodeScalar))
}

func test_SR5971(){
letproblematicString="\u{10000}"
letcharset1=CharacterSet(charactersIn:problematicString) // this should not crash
XCTAssertTrue(charset1.contains("\u{10000}"))
 // Case from SR-3215
letcharset2=CharacterSet(charactersIn:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789&+")
XCTAssertTrue(charset2.contains("+"))
}

func test_hashing(){
leta=CharacterSet(charactersIn:"ABC")
letb=CharacterSet(charactersIn:"CBA")
letc=CharacterSet(charactersIn:"bad")
letd=CharacterSet(charactersIn:"abd")
lete=CharacterSet.capitalizedLetters
letf=CharacterSet.lowercaseLetters
checkHashableGroups(
[[a, b],[c, d],[e],[f]],
 // FIXME: CharacterSet delegates equality and hashing to
 // CFCharacterSet, which uses unseeded hashing, so it's not
 // complete.
 allowIncompleteHashing:true)
}

letfixtures=[
Fixtures.characterSetEmpty,
Fixtures.characterSetRange,
Fixtures.characterSetString,
Fixtures.characterSetBitmap,
Fixtures.characterSetBuiltin,
]

func test_codingRoundtrip()throws{
forfixturein fixtures {
try fixture.assertValueRoundtripsInCoder()
}
}
}