SmallStringTestUtilities.swift

#if _runtime(_ObjC)
import Foundation
#endif
import StdlibUnittest

extensionString:Error{}

func verifySmallString(_ small:_SmallString, _ input:String,
 file:String= #file, line:UInt= #line
){
letloc=SourceLoc(file, line, comment:"test data")
expectEqual(_SmallString.capacity, small.count + small.unusedCapacity,
 stackTrace:SourceLocStack().with(loc))
lettiny=Array(input.utf8)
expectEqual(tiny.count, small.count, stackTrace:SourceLocStack().with(loc))
for(lhs, rhs)inzip(tiny, small){
expectEqual(lhs, rhs, stackTrace:SourceLocStack().with(loc))
}

letsmallFromUTF16=_SmallString(Array(input.utf16))
expectNotNil(smallFromUTF16,
 stackTrace:SourceLocStack().with(loc))
expectEqualSequence(small, smallFromUTF16!,
 stackTrace:SourceLocStack().with(loc))

 // Test slicing
 //
foriin0..<small.count {
forjin i...small.count {
expectEqualSequence(tiny[i..<j],small[i..<j],
 stackTrace:SourceLocStack().with(loc))
if j < small.count {
expectEqualSequence(tiny[i...j],small[i...j],
 stackTrace:SourceLocStack().with(loc))
}
}
}

 // Test RAC and Mutable
varcopy= small
foriin0..<small.count /2{
lettmp=copy[i]
copy[i]=copy[copy.count -1- i]
copy[copy.count -1- i]= tmp
}
expectEqualSequence(small.reversed(), copy,
 stackTrace:SourceLocStack().with(loc))
}

// Testing helper inits
extension_SmallString{
init?(_ codeUnits:Array<UInt8>){
guardlet smol = codeUnits.withUnsafeBufferPointer({
return_SmallString($0)
})else{
returnnil
}
self= smol
}

init?(_ codeUnits:Array<UInt16>){
letstr= codeUnits.withUnsafeBufferPointer{
returnString._uncheckedFromUTF16($0)
}
if !str._guts.isSmall {
returnnil
}
self.init(str._guts._object)
}


#if _runtime(_ObjC)
init?(_cocoaString ns:NSString){
#if _pointerBitWidth(_32)
returnnil
#else
guard_isObjCTaggedPointer(ns)else{returnnil}
self=(ns asString)._guts.asSmall //regular tagged NSStrings are guaranteed to bridge to SmallStrings
assert(_StringGuts(self).isSmall)
#endif
}
#endif

func _appending(_ other:_SmallString)->_SmallString?{
return_SmallString(self, appending: other)
}

func _repeated(_ n:Int)->_SmallString?{
varbase=self
lettoAppend=self
for_in0..<(n &-1){
guardlet s =_SmallString(
 base, appending: toAppend)
else{returnnil}
 base = s
}
return base
}
}

func expectSmall(_ str:String,
 stackTrace:SourceLocStack=SourceLocStack(),
 showFrame:Bool=true,
 file:String= #file, line:UInt= #line
){
switch str._classify()._form {
case._small:return
default:expectationFailure("expected: small", trace:"",
 stackTrace: stackTrace.pushIf(showFrame, file: file, line: line))
}
}

func expectCocoa(_ str:String,
 stackTrace:SourceLocStack=SourceLocStack(),
 showFrame:Bool=true,
 file:String= #file, line:UInt= #line
){
switch str._classify()._form {
case._cocoa:return
default:expectationFailure("expected: cocoa", trace:"",
 stackTrace: stackTrace.pushIf(showFrame, file: file, line: line))
}
}