TestNSString.swift

// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2022 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 os(macOS) || os(iOS)
internalletkCFStringEncodingMacRoman=CFStringBuiltInEncodings.macRoman.rawValue
internalletkCFStringEncodingWindowsLatin1=CFStringBuiltInEncodings.windowsLatin1.rawValue
internalletkCFStringEncodingISOLatin1=CFStringBuiltInEncodings.isoLatin1.rawValue
internalletkCFStringEncodingNextStepLatin=CFStringBuiltInEncodings.nextStepLatin.rawValue
internalletkCFStringEncodingASCII=CFStringBuiltInEncodings.ASCII.rawValue
internalletkCFStringEncodingUnicode=CFStringBuiltInEncodings.unicode.rawValue
internalletkCFStringEncodingUTF8=CFStringBuiltInEncodings.UTF8.rawValue
internalletkCFStringEncodingNonLossyASCII=CFStringBuiltInEncodings.nonLossyASCII.rawValue
internalletkCFStringEncodingUTF16=CFStringBuiltInEncodings.UTF16.rawValue
internalletkCFStringEncodingUTF16BE=CFStringBuiltInEncodings.UTF16BE.rawValue
internalletkCFStringEncodingUTF16LE=CFStringBuiltInEncodings.UTF16LE.rawValue
internalletkCFStringEncodingUTF32=CFStringBuiltInEncodings.UTF32.rawValue
internalletkCFStringEncodingUTF32BE=CFStringBuiltInEncodings.UTF32BE.rawValue
internalletkCFStringEncodingUTF32LE=CFStringBuiltInEncodings.UTF32LE.rawValue
#endif


classTestNSString:LoopbackServerTest{

func test_initData(){
lettestString="\u{00} This is a test string"
letdata= testString.data(using:.utf8)!
XCTAssertEqual(data.count,23)
 data.withUnsafeBytes{(bytes:UnsafeRawBufferPointer)in
iflet text1 =NSString(bytes: bytes.baseAddress!, length: data.count, encoding:String.Encoding.utf8.rawValue){
XCTAssertEqual(text1.length, data.count)
XCTAssertEqual(text1, testString asNSString)
}else{
XCTFail("Cant convert Data to NSString")
}
}

iflet text2 =String(data: data, encoding:.utf8){
XCTAssertEqual(text2.count, data.count)
XCTAssertEqual(text2, testString)
}else{
XCTFail("Cant convert Data to String")
}

 // Test multibyte UTF8 and UTF16
 // kra ("ĸ") has codepoint value 312,
 // as UTF-8 bytes it is 0xC4 0xB8
 // as UTF-16 bytes it is 0x1, 0x38
letkra="ĸ"
letutf8KraData=Data([0xc4,0xb8])
iflet utf8kra = utf8KraData.withUnsafeBytes({(bytes:UnsafeRawBufferPointer)->NSString?in
returnNSString(bytes: bytes.baseAddress!, length: utf8KraData.count, encoding:String.Encoding.utf8.rawValue)
}){
XCTAssertEqual(kra.count,1)
XCTAssertEqual(kra.utf8.count,2)
XCTAssertEqual(kra.utf16.count,1)
XCTAssertEqual(kra, utf8kra asString)
}else{
XCTFail("Cant create UTF8 kra")
}

letutf16KraData=Data([0x1,0x38])
iflet utf16kra = utf16KraData.withUnsafeBytes({(bytes:UnsafeRawBufferPointer)->NSString?in
returnNSString(bytes: bytes.baseAddress!, length: utf16KraData.count, encoding:String.Encoding.utf16.rawValue)
}){
XCTAssertEqual(kra.count,1)
XCTAssertEqual(kra.utf8.count,2)
XCTAssertEqual(kra.utf16.count,1)
XCTAssertEqual(kra, utf16kra asString)
}else{
XCTFail("Cant create UTF16 kra")
}

 // Test a large string > 255 characters
letlargeString="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut at tincidunt arcu. Suspendisse nec sodales erat, sit amet imperdiet ipsum. Etiam sed ornare felis. Nunc mauris turpis, bibendum non lectus quis, malesuada placerat turpis. Nam adipiscing non massa et semper. Nulla convallis semper bibendum."
XCTAssertTrue(largeString.count >255)
letlargeData= largeString.data(using:.utf8)!
iflet largeText = largeData.withUnsafeBytes({(bytes:UnsafeRawBufferPointer)->NSString?in
returnNSString(bytes: bytes.baseAddress!, length: largeData.count, encoding:String.Encoding.ascii.rawValue)
}){
XCTAssertEqual(largeText.length, largeString.count)
XCTAssertEqual(largeText.length, largeData.count)
XCTAssertEqual(largeString, largeText asString)
}else{
XCTFail("Cant convert large Data string to String")
}
}

func test_boolValue(){
lettrueStrings:[NSString]=["t","true","TRUE","tRuE","yes","YES","1","+000009"]
forstringin trueStrings {
XCTAssert(string.boolValue)
}
letfalseStrings:[NSString]=["false","FALSE","fAlSe","no","NO","0","<true>","_true","-00000","+t","+","0t","++"]
forstringin falseStrings {
XCTAssertFalse(string.boolValue)
}
}

func test_BridgeConstruction(){
letliteralConversion:NSString="literal"
XCTAssertEqual(literalConversion.length,7)

letnonLiteralConversion=NSString(string:"test\(self)")
XCTAssertTrue(nonLiteralConversion.length >4)

letnonLiteral2=NSString(string:String(4))
lett= nonLiteral2.character(at:0)
XCTAssertTrue(t ==52)

letexternalString:NSString=NSString(string:String.localizedName(of:String.defaultCStringEncoding))
XCTAssertTrue(externalString.length >=4)

letcluster:NSString="✌🏾"
XCTAssertEqual(cluster.length,3)
}

func test_bridging(){
letnsstring=NSString("NSString")
letanyNSstring= nsstring asAny

XCTAssertEqual(nsstring asString,"NSString")
XCTAssertEqual(nsstring asSubstring,"NSString")

XCTAssertEqual(anyNSstring as!String,"NSString")
XCTAssertEqual(anyNSstring as!Substring,"NSString")

XCTAssertEqual(anyNSstring as?String,"NSString")
XCTAssertEqual(anyNSstring as?Substring,"NSString")

letstring="String"
letsubString= string.dropFirst()
XCTAssertEqual(string asNSString,NSString("String"))
XCTAssertEqual(subString asNSString,NSString("tring"))

letabc="abc"asSubstringasNSString
XCTAssertEqual(abc,NSString("abc"))
}


func test_integerValue(){
letstring1:NSString="123"
XCTAssertEqual(string1.integerValue,123)

letstring2:NSString="123a"
XCTAssertEqual(string2.integerValue,123)

letstring3:NSString="-123a"
XCTAssertEqual(string3.integerValue,-123)

letstring4:NSString="a123"
XCTAssertEqual(string4.integerValue,0)

letstring5:NSString="+123"
XCTAssertEqual(string5.integerValue,123)

letstring6:NSString="++123"
XCTAssertEqual(string6.integerValue,0)

letstring7:NSString="-123"
XCTAssertEqual(string7.integerValue,-123)

letstring8:NSString="--123"
XCTAssertEqual(string8.integerValue,0)

letstring9:NSString="999999999999999999999999999999"
XCTAssertEqual(string9.integerValue,Int.max)

letstring10:NSString="-999999999999999999999999999999"
XCTAssertEqual(string10.integerValue,Int.min)
}

func test_intValue(){
letstring1:NSString="123"
XCTAssertEqual(string1.intValue,123)

letstring2:NSString="123a"
XCTAssertEqual(string2.intValue,123)

letstring3:NSString="-123a"
XCTAssertEqual(string3.intValue,-123)

letstring4:NSString="a123"
XCTAssertEqual(string4.intValue,0)

letstring5:NSString="+123"
XCTAssertEqual(string5.intValue,123)

letstring6:NSString="++123"
XCTAssertEqual(string6.intValue,0)

letstring7:NSString="-123"
XCTAssertEqual(string7.intValue,-123)

letstring8:NSString="--123"
XCTAssertEqual(string8.intValue,0)

letstring9:NSString="999999999999999999999999999999"
XCTAssertEqual(string9.intValue,Int32.max)

letstring10:NSString="-999999999999999999999999999999"
XCTAssertEqual(string10.intValue,Int32.min)
}

func test_doubleValue(){
XCTAssertEqual(NSString(string:".2").doubleValue,0.2)
XCTAssertEqual(NSString(string:"+.2").doubleValue,0.2)
XCTAssertEqual(NSString(string:"-.2").doubleValue,-0.2)
XCTAssertEqual(NSString(string:"1.23015e+3").doubleValue,1230.15)
XCTAssertEqual(NSString(string:"12.3015e+02").doubleValue,1230.15)
XCTAssertEqual(NSString(string:"+1.23015e+3").doubleValue,1230.15)
XCTAssertEqual(NSString(string:"+12.3015e+02").doubleValue,1230.15)
XCTAssertEqual(NSString(string:"-1.23015e+3").doubleValue,-1230.15)
XCTAssertEqual(NSString(string:"-12.3015e+02").doubleValue,-1230.15)
XCTAssertEqual(NSString(string:"-12.3015e02").doubleValue,-1230.15)
XCTAssertEqual(NSString(string:"-31.25e-04").doubleValue,-0.003125)

XCTAssertEqual(NSString(string:".e12").doubleValue,0)
XCTAssertEqual(NSString(string:"2e3.12").doubleValue,2000)
XCTAssertEqual(NSString(string:"1e2.3").doubleValue,100)
XCTAssertEqual(NSString(string:"12.e4").doubleValue,120000)
XCTAssertEqual(NSString(string:"1.2.3.4").doubleValue,1.2)
XCTAssertEqual(NSString(string:"1e2.3").doubleValue,100)
XCTAssertEqual(NSString(string:"1E3").doubleValue,1000)
}

func test_isEqualToStringWithSwiftString(){
letstring:NSString="literal"
letswiftString="literal"
XCTAssertTrue(string.isEqual(to: swiftString))
}

func test_isEqualToObjectWithNSString(){
letstring1:NSString="literal"
letstring2:NSString="literal"
XCTAssertTrue(string1.isEqual(string2))
}

func test_isNotEqualToObjectWithNSNumber(){
letstring:NSString="5"
letnumber:NSNumber=5
XCTAssertFalse(string.isEqual(number))
}

internalletmockASCIIStringBytes:[UInt8]=[0x48,0x65,0x6C,0x6C,0x6F,0x20,0x53,0x77,0x69,0x66,0x74,0x21]
internalletmockASCIIString="Hello Swift!"
internalletmockUTF8StringBytes:[UInt8]=[0x49,0x20,0xE2,0x9D,0xA4,0xEF,0xB8,0x8F,0x20,0x53,0x77,0x69,0x66,0x74]
internalletmockUTF8String="I ❤️ Swift"
internalletmockMalformedUTF8StringBytes:[UInt8]=[0xFF]

func test_FromASCIIData(){
letbytes= mockASCIIStringBytes
letstring=NSString(bytes: bytes, length: bytes.count, encoding:String.Encoding.ascii.rawValue)
XCTAssertNotNil(string)
XCTAssertTrue(string?.isEqual(to: mockASCIIString)??false)
}

func test_FromUTF8Data(){
letbytes= mockUTF8StringBytes
letstring=NSString(bytes: bytes, length: bytes.count, encoding:String.Encoding.utf8.rawValue)
XCTAssertNotNil(string)
XCTAssertTrue(string?.isEqual(to: mockUTF8String)??false)
}

func test_FromMalformedUTF8Data(){
letbytes= mockMalformedUTF8StringBytes
letstring=NSString(bytes: bytes, length: bytes.count, encoding:String.Encoding.utf8.rawValue)
XCTAssertNil(string)
}

func test_FromASCIINSData(){
letbytes= mockASCIIStringBytes
letdata=Data(bytes: bytes, count: bytes.count)
letstring=NSString(data: data, encoding:String.Encoding.ascii.rawValue)
XCTAssertNotNil(string)
XCTAssertTrue(string?.isEqual(to: mockASCIIString)??false)
}

func test_FromUTF8NSData(){
letbytes= mockUTF8StringBytes
letdata=Data(bytes: bytes, count: bytes.count)
letstring=NSString(data: data, encoding:String.Encoding.utf8.rawValue)
XCTAssertNotNil(string)
XCTAssertTrue(string?.isEqual(to: mockUTF8String)??false)
}

func test_FromMalformedUTF8NSData(){
letbytes= mockMalformedUTF8StringBytes
letdata=Data(bytes: bytes, count: bytes.count)
letstring=NSString(data: data, encoding:String.Encoding.utf8.rawValue)
XCTAssertNil(string)
}

func test_FromNullTerminatedCStringInASCII(){
letbytes= mockASCIIStringBytes +[0x00]
letstring=NSString(cString: bytes.map{Int8(bitPattern: $0)}, encoding:String.Encoding.ascii.rawValue)
XCTAssertNotNil(string)
XCTAssertTrue(string?.isEqual(to: mockASCIIString)??false)
}

func test_FromNullTerminatedCStringInUTF8(){
letbytes= mockUTF8StringBytes +[0x00]
letstring=NSString(cString: bytes.map{Int8(bitPattern: $0)}, encoding:String.Encoding.utf8.rawValue)
XCTAssertNotNil(string)
XCTAssertTrue(string?.isEqual(to: mockUTF8String)??false)
}

func test_FromMalformedNullTerminatedCStringInUTF8(){
letbytes= mockMalformedUTF8StringBytes +[0x00]
letstring=NSString(cString: bytes.map{Int8(bitPattern: $0)}, encoding:String.Encoding.utf8.rawValue)
XCTAssertNil(string)
}

func test_cStringArray(){
letstr="abc"
letencoded= str.cString(using:.ascii)
XCTAssertEqual(encoded,[97,98,99,0])
}

func test_FromContentsOfURL()throws{
throwXCTSkip("Test is flaky in CI: https://bugs.swift.org/browse/SR-10514")
#if false
guardlet testFileURL =testBundle().url(forResource:"NSStringTestData", withExtension:"txt")else{
XCTFail("URL for NSStringTestData.txt is nil")
return
}

do{
letstring=tryNSString(contentsOf: testFileURL, encoding:String.Encoding.utf8.rawValue)
XCTAssertEqual(string,"swift-corelibs-foundation")
}catch{
XCTFail("Unable to init NSString from contentsOf:encoding:")
}
do{
letstring=tryNSString(contentsOf: testFileURL, encoding:String.Encoding.utf16.rawValue)
XCTAssertNotEqual(string,"swift-corelibs-foundation","Wrong result when reading UTF-8 file with UTF-16 encoding in contentsOf:encoding")
}catch{
XCTFail("Unable to init NSString from contentsOf:encoding:")
}

leturl=URL(string:"http://127.0.0.1:\(TestURLSession.serverPort)/NSString-ISO-8859-1-data.txt")!
varenc:UInt=0
letcontents=try?NSString(contentsOf: url, usedEncoding:&enc)

XCTAssertNotNil(contents)
XCTAssertEqual(enc,String.Encoding.isoLatin1.rawValue)
iflet contents = contents {
XCTAssertEqual(contents,"This file is encoded as ISO-8859-1\nÀÁÂÃÄÅÿ\n±\n")
}

guardlet zeroFileURL =testBundle().url(forResource:"TestFileWithZeros", withExtension:"txt")else{
XCTFail("Cant get URL for TestFileWithZeros.txt")
return
}
guardlet zeroString =try?String(contentsOf: zeroFileURL, encoding:.utf8)else{
XCTFail("Cant create string from \(zeroFileURL)")
return
}
XCTAssertEqual(zeroString,"Some\u{00}text\u{00}with\u{00}NUL\u{00}bytes\u{00}instead\u{00}of\u{00}spaces.\u{00}\n")
#endif
}

func test_FromContentOfFileUsedEncodingIgnored(){
lettestFilePath=testBundle().path(forResource:"NSStringTestData", ofType:"txt")
XCTAssertNotNil(testFilePath)

do{
letstr=tryNSString(contentsOfFile: testFilePath!, usedEncoding:nil)
XCTAssertEqual(str,"swift-corelibs-foundation")
}catch{
XCTFail("Unable to init NSString from contentsOfFile:encoding:")
}
}

func test_FromContentOfFileUsedEncodingUTF8(){
lettestFilePath=testBundle().path(forResource:"NSStringTestData", ofType:"txt")
XCTAssertNotNil(testFilePath)

do{
varencoding:UInt=0
letstr=tryNSString(contentsOfFile: testFilePath!, usedEncoding:&encoding)
XCTAssertEqual(str,"swift-corelibs-foundation")
XCTAssertEqual(encoding,String.Encoding.utf8.rawValue,"Wrong encoding detected from UTF8 file")
}catch{
XCTFail("Unable to init NSString from contentsOfFile:encoding:")
}
}

func test_FromContentsOfURLUsedEncodingUTF16BE(){
guardlet testFileURL =testBundle().url(forResource:"NSString-UTF16-BE-data", withExtension:"txt")else{
XCTFail("URL for NSString-UTF16-BE-data.txt is nil")
return
}

do{
varencoding:UInt=0
letstring=tryNSString(contentsOf: testFileURL, usedEncoding:&encoding)
XCTAssertEqual(string,"NSString fromURL usedEncoding test with UTF16 BE file","Wrong result when reading UTF16BE file")
XCTAssertEqual(encoding,String.Encoding.utf16BigEndian.rawValue,"Wrong encoding detected from UTF16BE file")
}catch{
XCTFail("Unable to init NSString from contentsOf:usedEncoding:")
}
}

func test_FromContentsOfURLUsedEncodingUTF16LE(){
guardlet testFileURL =testBundle().url(forResource:"NSString-UTF16-LE-data", withExtension:"txt")else{
XCTFail("URL for NSString-UTF16-LE-data.txt is nil")
return
}

do{
varencoding:UInt=0
letstring=tryNSString(contentsOf: testFileURL, usedEncoding:&encoding)
XCTAssertEqual(string,"NSString fromURL usedEncoding test with UTF16 LE file","Wrong result when reading UTF16LE file")
XCTAssertEqual(encoding,String.Encoding.utf16LittleEndian.rawValue,"Wrong encoding detected from UTF16LE file")
}catch{
XCTFail("Unable to init NSString from contentOf:usedEncoding:")
}
}

func test_FromContentsOfURLUsedEncodingUTF32BE(){
guardlet testFileURL =testBundle().url(forResource:"NSString-UTF32-BE-data", withExtension:"txt")else{
XCTFail("URL for NSString-UTF32-BE-data.txt is nil")
return
}

do{
varencoding:UInt=0
letstring=tryNSString(contentsOf: testFileURL, usedEncoding:&encoding)
XCTAssertEqual(string,"NSString fromURL usedEncoding test with UTF32 BE file","Wrong result when reading UTF32BE file")
XCTAssertEqual(encoding,String.Encoding.utf32BigEndian.rawValue,"Wrong encoding detected from UTF32BE file")
}catch{
XCTFail("Unable to init NSString from contentOf:usedEncoding:")
}
}

func test_FromContentsOfURLUsedEncodingUTF32LE(){
guardlet testFileURL =testBundle().url(forResource:"NSString-UTF32-LE-data", withExtension:"txt")else{
XCTFail("URL for NSString-UTF32-LE-data.txt is nil")
return
}

do{
varencoding:UInt=0
letstring=tryNSString(contentsOf: testFileURL, usedEncoding:&encoding)
XCTAssertEqual(string,"NSString fromURL usedEncoding test with UTF32 LE file","Wrong result when reading UTF32LE file")
XCTAssertEqual(encoding,String.Encoding.utf32LittleEndian.rawValue,"Wrong encoding detected from UTF32LE file")
}catch{
XCTFail("Unable to init NSString from contentOf:usedEncoding:")
}
}

func test_FromContentOfFile(){
lettestFilePath=testBundle().path(forResource:"NSStringTestData", ofType:"txt")
XCTAssertNotNil(testFilePath)

do{
letstr=tryNSString(contentsOfFile: testFilePath!, encoding:String.Encoding.utf8.rawValue)
XCTAssertEqual(str,"swift-corelibs-foundation")
}catch{
XCTFail("Unable to init NSString from contentsOfFile:encoding:")
}
}

func test_writeToURLHasBOM_UTF32()throws{
varurl=URL(fileURLWithPath:NSTemporaryDirectory(), isDirectory:true)
tryFileManager.default.createDirectory(at: url, withIntermediateDirectories:true, attributes:nil)
 url.appendPathComponent("swiftfoundation-\(#function)-tmp")

 // Writing with String.Encoding.utf32 should include the BOM.
letstring=NSString("hello, 🌍!")
do{
try string.write(to: url, atomically:false, encoding:String.Encoding.utf32.rawValue)
letdata=tryData(contentsOf: url)
#if _endian(little)
XCTAssertTrue(data.starts(with:[0xFF,0xFE,0x00,0x00]))
#else
XCTAssertTrue(data.starts(with:[0x00,0x00,0xFE,0xFF]))
#endif
}
 // Writing with String.Encoding.utf32{Big/Little}Endian does not include the BOM.
do{
try string.write(to: url, atomically:false, encoding:String.Encoding.utf32BigEndian.rawValue)
letdata=tryData(contentsOf: url)
XCTAssertTrue(data.starts(with:[0x00,0x00,0x00,0x68]))
}
do{
try string.write(to: url, atomically:false, encoding:String.Encoding.utf32LittleEndian.rawValue)
letdata=tryData(contentsOf: url)
XCTAssertTrue(data.starts(with:[0x68,0x00,0x00,0x00]))
}
}

func test_uppercaseString(){
XCTAssertEqual(NSString(stringLiteral:"abcd").uppercased,"ABCD")
XCTAssertEqual(NSString(stringLiteral:"ａｂｃｄ").uppercased,"ＡＢＣＤ") // full-width
XCTAssertEqual(NSString(stringLiteral:"абВГ").uppercased,"АБВГ")
XCTAssertEqual(NSString(stringLiteral:"たちつてと").uppercased,"たちつてと")

 // Special casing (see swift/validation-tests/stdlib/NSStringAPI.swift)
XCTAssertEqual(NSString(stringLiteral:"\u{0069}").uppercased(with:Locale(identifier:"en")),"\u{0049}")
 // Currently fails; likely there are locale loading issues that are preventing this from functioning correctly
 // XCTAssertEqual(NSString(stringLiteral: "\u{0069}").uppercased(with: NSLocale(localeIdentifier: "tr")), "\u{0130}")
XCTAssertEqual(NSString(stringLiteral:"\u{00df}").uppercased,"\u{0053}\u{0053}")
XCTAssertEqual(NSString(stringLiteral:"\u{fb01}").uppercased,"\u{0046}\u{0049}")
}

func test_lowercaseString(){
XCTAssertEqual(NSString(stringLiteral:"abCD").lowercased,"abcd")
XCTAssertEqual(NSString(stringLiteral:"ＡＢＣＤ").lowercased,"ａｂｃｄ") // full-width
XCTAssertEqual(NSString(stringLiteral:"aБВГ").lowercased,"aбвг")
XCTAssertEqual(NSString(stringLiteral:"たちつてと").lowercased,"たちつてと")

 // Special casing (see swift/validation-tests/stdlib/NSStringAPI.swift)
XCTAssertEqual(NSString(stringLiteral:"\u{0130}").lowercased(with:Locale(identifier:"en")),"\u{0069}\u{0307}")
 // Currently fails; likely there are locale loading issues that are preventing this from functioning correctly
 // XCTAssertEqual(NSString(stringLiteral: "\u{0130}").lowercased(with: NSLocale(localeIdentifier: "tr")), "\u{0069}")
XCTAssertEqual(NSString(stringLiteral:"\u{0049}\u{0307}").lowercased(with:Locale(identifier:"en")),"\u{0069}\u{0307}")
 // Currently fails; likely there are locale loading issues that are preventing this from functioning correctly
 // XCTAssertEqual(NSString(stringLiteral: "\u{0049}\u{0307}").lowercaseStringWithLocale(NSLocale(localeIdentifier: "tr")), "\u{0069}")
}

func test_capitalizedString(){
XCTAssertEqual(NSString(stringLiteral:"foo Foo fOO FOO").capitalized,"Foo Foo Foo Foo")
XCTAssertEqual(NSString(stringLiteral:"жжж").capitalized,"Жжж")
}

func test_longLongValue(){
letstring1:NSString="123"
XCTAssertEqual(string1.longLongValue,123)

letstring2:NSString="123a"
XCTAssertEqual(string2.longLongValue,123)

letstring3:NSString="-123a"
XCTAssertEqual(string3.longLongValue,-123)

letstring4:NSString="a123"
XCTAssertEqual(string4.longLongValue,0)

letstring5:NSString="+123"
XCTAssertEqual(string5.longLongValue,123)

letstring6:NSString="++123"
XCTAssertEqual(string6.longLongValue,0)

letstring7:NSString="-123"
XCTAssertEqual(string7.longLongValue,-123)

letstring8:NSString="--123"
XCTAssertEqual(string8.longLongValue,0)

letstring9:NSString="999999999999999999999999999999"
XCTAssertEqual(string9.longLongValue,Int64.max)

letstring10:NSString="-999999999999999999999999999999"
XCTAssertEqual(string10.longLongValue,Int64.min)
}

func test_rangeOfCharacterFromSet(){
letstring:NSString="0Az"
letletters=CharacterSet.letters
letdecimalDigits=CharacterSet.decimalDigits
XCTAssertEqual(string.rangeOfCharacter(from: letters).location,1)
XCTAssertEqual(string.rangeOfCharacter(from: decimalDigits).location,0)
XCTAssertEqual(string.rangeOfCharacter(from: letters, options:.backwards).location,2)
XCTAssertEqual(string.rangeOfCharacter(from: letters, options:[], range:NSRange(location:2, length:1)).location,2)
}

func test_CFStringCreateMutableCopy(){
letnsstring:NSString="абВГ"
XCTAssertEqual(nsstring, nsstring.mutableCopy()as!NSString)
}

 // This test verifies that CFStringGetBytes with a UTF16 encoding works on an NSString backed by a Swift string
func test_swiftStringUTF16(){
lettestString="hello world"
letstring=NSString(string: testString)

 // Get the bytes as UTF16
letdata:Data= string.data(using:String.Encoding.utf16.rawValue, allowLossyConversion:false)!

 // Make a new string out of it
letnewString= data.withUnsafeBytes{
NSString(bytes: $0.baseAddress!, length: $0.count, encoding:String.Encoding.utf16.rawValue)!
}

XCTAssertTrue(newString.isEqual(to: testString))
}

func test_completePathIntoString()throws{
#if os(Windows)
throwXCTSkip("This test is not supported on Windows")
#else
 // Check all strings start with a common prefix
func startWith(_ prefix:String, strings:[String])->Bool{
return strings.contains{ !$0.hasPrefix(prefix)}==false
}

func stringsAreCaseInsensitivelyEqual(_ lhs:String, _ rhs:String)->Bool{
return lhs.compare(rhs, options:.caseInsensitive)==.orderedSame
}

trywithTemporaryDirectory{
(tmpDir, tmpDirPath)in

func tmpPath(_ path:String)->String{
 // Trailing '/' ensures path is created as a directory not a file
return tmpDir.appendingPathComponent(path).path +(path.hasSuffix("/")?"/":"")
}

letfileNames=[
tmpPath("Test_completePathIntoString_01"),
tmpPath("test_completePathIntoString_02"),
tmpPath("test_completePathIntoString_01.txt"),
tmpPath("test_completePathIntoString_01.dat"),
tmpPath("test_completePathIntoString_03.DAT"),
]

guardensureFiles(fileNames)else{throwTestError.fileCreationFailed }

do{
leturlToTmp= tmpDir.appendingPathComponent("tmp")
letpath= urlToTmp.path +"/"
guardensureFiles([path])else{throwTestError.fileCreationFailed }

varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
XCTAssertEqual(outName,"/","If NSString is valid path to directory which has '/' suffix then outName is '/'.")
XCTAssertEqual(matches.count, count)
}catch{
XCTFail("Could not finish test due to error: \(error)")
}

do{
 // Create a subdirectory with non-matching files
leturlToTmp= tmpDir.appendingPathComponent("tmp")
guardensureFiles([
 urlToTmp.appendingPathComponent("abc").path,
 urlToTmp.appendingPathComponent("xyz").path
])else{throwTestError.fileCreationFailed }
letpath= urlToTmp.path

varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
letcontents=tryFileManager.default.contentsOfDirectory(at: urlToTmp, includingPropertiesForKeys:nil, options:[])
XCTAssertEqual(outName, path +"/","If path could be completed to existing directory then outName is a string itself plus '/'.")
XCTAssertEqual(matches.count, count)
XCTAssertEqual(matches.count, contents.count,"If NSString is valid path to directory then matches contain all content of directory.")
}catch{
XCTFail("Could not finish test due to error: \(error)")
}

letfileNames2=[
tmpPath("ABC/"),
tmpPath("ABCD/"),
tmpPath("abcde")
]

guardensureFiles(fileNames2)else{
XCTFail("Could not create temp files for testing.")
return
}

do{
letpath=tmpPath("ABC")
varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
XCTAssertTrue(stringsAreCaseInsensitivelyEqual(outName, path),"If NSString is valid path to directory then outName is string itself.")
XCTAssertEqual(matches.count,count)
XCTAssertEqual(count, fileNames2.count)
}

do{
letpath=tmpPath("Test_completePathIntoString_01")
varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:true, matchesInto:&matches, filterTypes:nil)
XCTAssertEqual(outName, path,"If NSString is valid path to file and search is case sensitive then outName is string itself.")
XCTAssertTrue(stringsAreCaseInsensitivelyEqual(matches[0], path),"If NSString is valid path to file and search is case sensitive then matches contain that file path only")
XCTAssertEqual(matches.count,1)
XCTAssertEqual(count,1)
}

do{
letpath=tmpPath("Test_completePathIntoString_01")
varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
XCTAssertTrue(stringsAreCaseInsensitivelyEqual(outName, path),"If NSString is valid path to file and search is case insensitive then outName is string equal to self.")
XCTAssertEqual(matches.count,3,"Matches contain all files with similar name.")
XCTAssertEqual(count,3,"Matches contain all files with similar name.")
}

do{
letpath=tmpPath(NSUUID().uuidString)
varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
XCTAssertEqual(outName,"","If no matches found then outName is nil.")
XCTAssertTrue(matches.isEmpty)
XCTAssertEqual(count,0,"If no matches found then return 0 and matches is empty.")
}

do{
letpath=""
varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
XCTAssertEqual(outName,"","If no matches found then outName is nil.")
XCTAssertTrue(matches.isEmpty)
XCTAssertEqual(count,0,"If no matches found then return 0 and matches is empty.")
}

do{
letpath=tmpPath("test_c")
varoutName=""
varmatches:[String]=[]
 // case insensitive
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
XCTAssertTrue(stringsAreCaseInsensitivelyEqual(outName,tmpPath("Test_completePathIntoString_0")),"If there are matches then outName should be longest common prefix of all matches.")
XCTAssertEqual(matches.count, fileNames.count,"If there are matches then matches array contains them.")
XCTAssertEqual(count, fileNames.count)
}

do{
letpath=tmpPath("test_c")
varoutName=""
varmatches:[String]=[]
 // case sensitive
letcount= path.completePath(into:&outName, caseSensitive:true, matchesInto:&matches, filterTypes:nil)
XCTAssertEqual(outName,tmpPath("test_completePathIntoString_0"),"If there are matches then outName should be longest common prefix of all matches.")
XCTAssertEqual(matches.count,4,"Supports case sensitive search")
XCTAssertEqual(count,4)
}

do{
letpath=tmpPath("test_c")
varoutName=""
varmatches:[String]=[]
 // case sensitive
letcount= path.completePath(into:&outName, caseSensitive:true, matchesInto:&matches, filterTypes:["DAT"])
XCTAssertEqual(outName,tmpPath("test_completePathIntoString_03.DAT"),"If there are matches then outName should be longest common prefix of all matches.")
XCTAssertEqual(matches.count,1,"Supports case sensitive search by extensions")
XCTAssertEqual(count,1)
}

do{
letpath=tmpPath("test_c")
varoutName=""
varmatches:[String]=[]
 // type by filter
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:["txt","dat"])
XCTAssertTrue(stringsAreCaseInsensitivelyEqual(outName,tmpPath("test_completePathIntoString_0")),"If there are matches then outName should be longest common prefix of all matches.")
XCTAssertEqual(matches.count,3,"Supports filtration by type")
XCTAssertEqual(count,3)
}

do{
 // will be resolved against current working directory that is directory there results of build process are stored
letpath="TestFoundation"
varoutName=""
varmatches:[String]=[]
letcount= path.completePath(into:&outName, caseSensitive:false, matchesInto:&matches, filterTypes:nil)
 // Build directory at least contains executable itself and *.swiftmodule directory
XCTAssertEqual(matches.count, count)
XCTAssertGreaterThanOrEqual(count,0,"Supports relative paths.")
XCTAssertTrue(startWith(path, strings: matches),"For relative paths matches are relative too.")
}

 // Next check has no sense on Linux due to case sensitive file system.
#if os(macOS)
guardensureFiles([tmpPath("ABC/temp.txt")])else{
XCTFail("Could not create temp files for testing.")
return
}

do{
letpath=tmpPath("aBc/t")
varoutName=""
varmatches:[String]=[]
 // type by filter
letcount= path.completePath(into:&outName, caseSensitive:true, matchesInto:&matches, filterTypes:["txt","dat"])
XCTAssertEqual(outName,tmpPath("aBc/temp.txt"),"outName starts with receiver.")
XCTAssertGreaterThanOrEqual(matches.count,1,"There are matches")
XCTAssertEqual(matches.count, count)
}
#endif
}
#endif
}


func test_stringByTrimmingCharactersInSet(){
letcharacterSet=CharacterSet.whitespaces
letstring:NSString=" abc "
XCTAssertEqual(string.trimmingCharacters(in: characterSet),"abc")

letemojiString:NSString="\u{1F62C}"
XCTAssertEqual(emojiString.trimmingCharacters(in: characterSet),"\u{1F62C}")
}

func test_initializeWithFormat(){
letargument:[CVarArg]=[42,42.0]
withVaList(argument){
 pointer in
letstring=NSString(format:"Value is %d (%.1f)", arguments: pointer)
XCTAssertEqual(string,"Value is 42 (42.0)")
}
}

func test_initializeWithFormat2(){
letargument:UInt8=75
letstring=NSString(format:"%02X", argument)
XCTAssertEqual(string,"4B")
}

func test_initializeWithFormat3(){
letargument:[CVarArg]=[1000,42.0]

withVaList(argument){
 pointer in
letstring=NSString(format:"Default value is %d (%.1f)", locale:nil, arguments: pointer)
XCTAssertEqual(string,"Default value is 1000 (42.0)")
}

withVaList(argument){
 pointer in
letstring=NSString(format:"en_GB value is %d (%.1f)", locale:Locale.init(identifier:"en_GB")asAnyObject, arguments: pointer)
XCTAssertEqual(string,"en_GB value is 1,000 (42.0)")
}

withVaList(argument){
 pointer in
letstring=NSString(format:"de_DE value is %d (%.1f)", locale:Locale.init(identifier:"de_DE")asAnyObject, arguments: pointer)
XCTAssertEqual(string,"de_DE value is 1.000 (42,0)")
}

withVaList(argument){
 pointer in
letloc:NSDictionary=["NSDecimalSeparator"asNSString:"&"asNSString]
letstring=NSString(format:"NSDictionary value is %d (%.1f)", locale: loc, arguments: pointer)
XCTAssertEqual(string,"NSDictionary value is 1000 (42&0)")
}
}

func test_initializeWithFormat4(){
 // The NSString() is required on macOS to work around error: `Type of expression is ambiguous without more context`
letargument:[CVarArg]=[NSString("One"),NSString("Two"),NSString("Three")]
withVaList(argument){
 pointer in
letstring=NSString(format:"Testing %@ %@ %@", arguments: pointer)
XCTAssertEqual(string,"Testing One Two Three")
}
}

func test_appendingPathComponent(){
do{
letpath:NSString="/tmp"
letresult= path.appendingPathComponent("scratch.tiff")
XCTAssertEqual(result,"/tmp/scratch.tiff")
}

do{
letpath:NSString="/tmp/"
letresult= path.appendingPathComponent("scratch.tiff")
XCTAssertEqual(result,"/tmp/scratch.tiff")
}

do{
letpath:NSString="/"
letresult= path.appendingPathComponent("scratch.tiff")
XCTAssertEqual(result,"/scratch.tiff")
}

do{
letpath:NSString=""
letresult= path.appendingPathComponent("scratch.tiff")
XCTAssertEqual(result,"scratch.tiff")
}
}

func test_deletingLastPathComponent(){
do{
letpath:NSString="/tmp/scratch.tiff"
letresult= path.deletingLastPathComponent
XCTAssertEqual(result,"/tmp")
}

do{
letpath:NSString="/tmp/lock/"
letresult= path.deletingLastPathComponent
XCTAssertEqual(result,"/tmp")
}

do{
letpath:NSString="/tmp/"
letresult= path.deletingLastPathComponent
XCTAssertEqual(result,"/")
}

do{
letpath:NSString="/tmp"
letresult= path.deletingLastPathComponent
XCTAssertEqual(result,"/")
}

do{
letpath:NSString="/"
letresult= path.deletingLastPathComponent
XCTAssertEqual(result,"/")
}

do{
letpath:NSString="scratch.tiff"
letresult= path.deletingLastPathComponent
XCTAssertEqual(result,"")
}

do{
letpath:NSString="foo/bar"
letresult= path.deletingLastPathComponent
XCTAssertEqual(result,"foo","Relative path stays relative.")
}
}

func test_resolvingSymlinksInPath(){
do{
letpath:NSString="foo/bar"
letresult= path.resolvingSymlinksInPath
XCTAssertEqual(result,"foo/bar","For relative paths, symbolic links that can’t be resolved are left unresolved in the returned string.")
}

do{
letpath:NSString="/tmp/.."
letresult= path.resolvingSymlinksInPath

#if os(macOS)
letexpected="/private"
#else
letexpected="/"
#endif

XCTAssertEqual(result, expected,"For absolute paths, all symbolic links are guaranteed to be removed.")
}

do{
letpath:NSString="tmp/.."
letresult= path.resolvingSymlinksInPath
XCTAssertEqual(result,"tmp/..","Parent links could be resolved for absolute paths only.")
}

do{
letpath:NSString="/tmp/"
letresult= path.resolvingSymlinksInPath
XCTAssertEqual(result,"/tmp","Result doesn't contain trailing slash.")
}

do{
letpath:NSString="http://google.com/search/.."
letresult= path.resolvingSymlinksInPath
XCTAssertEqual(result,"http:/google.com/search/..","resolvingSymlinksInPath treats receiver as file path always")
}

do{
letpath:NSString="file:///tmp/.."
letresult= path.resolvingSymlinksInPath
XCTAssertEqual(result,"file:/tmp/..","resolvingSymlinksInPath treats receiver as file path always")
}
}

func test_getCString_simple(){
letstr:NSString="foo"
varchars=[Int8](repeating:0xF, count:4)
letcount= chars.count
letexpected:[Int8]=[102,111,111,0]
varres:Bool=false
 chars.withUnsafeMutableBufferPointer(){
letptr= $0.baseAddress!
 res = str.getCString(ptr, maxLength: count, encoding:String.Encoding.ascii.rawValue)
}
XCTAssertTrue(res,"getCString should work on simple strings with ascii string encoding")
XCTAssertEqual(chars, expected,"getCString on \(str) should have resulted in \(expected) but got \(chars)")
}

func test_getCString_nonASCII_withASCIIAccessor(){
letstr:NSString="ƒoo"
varchars=[Int8](repeating:0xF, count:5)
letexpected:[Int8]=[-58,-110,111,111,0]
letcount= chars.count
varres:Bool=false
 chars.withUnsafeMutableBufferPointer(){