mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
469 lines
16 KiB
Swift
469 lines
16 KiB
Swift
// RUN: %target-run-simple-swift
|
||
// REQUIRES: executable_test
|
||
// UNSUPPORTED: freestanding
|
||
|
||
import StdlibUnittest
|
||
|
||
var StringIndexTests = TestSuite("StringIndexTests")
|
||
|
||
enum SimpleString: String {
|
||
case smallASCII = "abcdefg"
|
||
case smallUnicode = "abéÏ𓀀"
|
||
case largeASCII = "012345678901234567890"
|
||
case largeUnicode = "abéÏ012345678901234567890𓀀"
|
||
case emoji = "😀😃🤢🤮👩🏿🎤🧛🏻♂️🧛🏻♂️👩👩👦👦"
|
||
}
|
||
|
||
let simpleStrings: [String] = [
|
||
SimpleString.smallASCII.rawValue,
|
||
SimpleString.smallUnicode.rawValue,
|
||
SimpleString.largeASCII.rawValue,
|
||
SimpleString.largeUnicode.rawValue,
|
||
SimpleString.emoji.rawValue,
|
||
"",
|
||
]
|
||
|
||
StringIndexTests.test("basic sanity checks") {
|
||
for s in simpleStrings {
|
||
let utf8 = Array(s.utf8)
|
||
let subUTF8 = Array(s[...].utf8)
|
||
let utf16 = Array(s.utf16)
|
||
let subUTF16 = Array(s[...].utf16)
|
||
let utf32 = Array(s.unicodeScalars.map { $0.value })
|
||
let subUTF32 = Array(s[...].unicodeScalars.map { $0.value })
|
||
|
||
expectEqual(s, String(decoding: utf8, as: UTF8.self))
|
||
expectEqual(s, String(decoding: subUTF8, as: UTF8.self))
|
||
expectEqual(s, String(decoding: utf16, as: UTF16.self))
|
||
expectEqual(s, String(decoding: subUTF16, as: UTF16.self))
|
||
expectEqual(s, String(decoding: utf32, as: UTF32.self))
|
||
expectEqual(s, String(decoding: subUTF32, as: UTF32.self))
|
||
}
|
||
}
|
||
|
||
StringIndexTests.test("view counts") {
|
||
func validateViewCount<View: BidirectionalCollection>(
|
||
_ view: View, for string: String,
|
||
stackTrace: SourceLocStack = SourceLocStack(),
|
||
showFrame: Bool = true,
|
||
file: String = #file, line: UInt = #line
|
||
) where View.Element: Equatable, View.Index == String.Index {
|
||
|
||
var stackTrace = stackTrace.pushIf(showFrame, file: file, line: line)
|
||
|
||
let count = view.count
|
||
func expect(_ i: Int,
|
||
file: String = #file, line: UInt = #line
|
||
) {
|
||
expectEqual(count, i, "for String: \(string)",
|
||
stackTrace: stackTrace.pushIf(showFrame, file: file, line: line),
|
||
showFrame: false)
|
||
}
|
||
|
||
let reversedView = view.reversed()
|
||
|
||
expect(Array(view).count)
|
||
expect(view.indices.count)
|
||
expect(view.indices.reversed().count)
|
||
expect(reversedView.indices.count)
|
||
expect(view.distance(from: view.startIndex, to: view.endIndex))
|
||
expect(reversedView.distance(
|
||
from: reversedView.startIndex, to: reversedView.endIndex))
|
||
|
||
// Access the elements from the indices
|
||
expectEqual(Array(view), view.indices.map { view[$0] })
|
||
expectEqual(
|
||
Array(reversedView), reversedView.indices.map { reversedView[$0] })
|
||
|
||
let indicesArray = Array<String.Index>(view.indices)
|
||
for i in 0..<indicesArray.count {
|
||
var idx = view.startIndex
|
||
idx = view.index(idx, offsetBy: i)
|
||
expectEqual(indicesArray[i], idx)
|
||
}
|
||
}
|
||
|
||
for s in simpleStrings {
|
||
validateViewCount(s, for: s)
|
||
validateViewCount(s.utf8, for: s)
|
||
validateViewCount(s.utf16, for: s)
|
||
validateViewCount(s.unicodeScalars, for: s)
|
||
|
||
validateViewCount(s[...], for: s)
|
||
validateViewCount(s[...].utf8, for: s)
|
||
validateViewCount(s[...].utf16, for: s)
|
||
validateViewCount(s[...].unicodeScalars, for: s)
|
||
}
|
||
}
|
||
|
||
StringIndexTests.test("interchange") {
|
||
// Basic index alignment
|
||
|
||
func validateIndices(_ s: String) {
|
||
for idx in s.utf8.indices {
|
||
let char = s.utf8[idx]
|
||
|
||
// ASCII or leading code unit in the scalar
|
||
if char <= 0x7F || char >= 0b1100_0000 {
|
||
expectEqual(idx, idx.samePosition(in: s.unicodeScalars))
|
||
expectEqual(idx, idx.samePosition(in: s.utf16))
|
||
|
||
// ASCII
|
||
if char <= 0x7F {
|
||
expectEqual(UInt16(char), s.utf16[idx])
|
||
expectEqual(UInt32(char), s.unicodeScalars[idx].value)
|
||
}
|
||
} else {
|
||
// Continuation code unit
|
||
assert(char & 0b1100_0000 == 0b1000_0000)
|
||
expectNil(idx.samePosition(in: s))
|
||
expectNil(idx.samePosition(in: s.utf16))
|
||
expectNil(idx.samePosition(in: s.unicodeScalars))
|
||
}
|
||
}
|
||
}
|
||
|
||
for s in simpleStrings {
|
||
validateIndices(s)
|
||
}
|
||
}
|
||
|
||
StringIndexTests.test("UTF-16 Offsets") {
|
||
func validateOffsets(_ s: String) {
|
||
let end = s.endIndex
|
||
let utf16Count = s.utf16.count
|
||
|
||
expectEqual(end, String.Index(utf16Offset: utf16Count, in: s))
|
||
expectEqual(end, String.Index(utf16Offset: utf16Count, in: s[...]))
|
||
|
||
let pastEnd = String.Index(utf16Offset: utf16Count+1, in: s)
|
||
|
||
expectNotEqual(end, pastEnd)
|
||
expectEqual(pastEnd, String.Index(utf16Offset: utf16Count+1, in: s[...]))
|
||
expectEqual(pastEnd, String.Index(utf16Offset: utf16Count+2, in: s))
|
||
expectEqual(pastEnd, String.Index(utf16Offset: -1, in: s))
|
||
expectEqual(
|
||
pastEnd, String.Index(utf16Offset: Swift.max(1, utf16Count), in: s.dropFirst()))
|
||
|
||
let utf16Indices = Array(s.utf16.indices)
|
||
expectEqual(utf16Count, utf16Indices.count)
|
||
for i in 0..<utf16Indices.count {
|
||
let idx = String.Index(utf16Offset: i, in: s)
|
||
expectEqual(utf16Indices[i], idx)
|
||
expectEqual(i, idx.utf16Offset(in: s))
|
||
expectEqual(i, idx.utf16Offset(in: s[...]))
|
||
|
||
if i < s.dropLast().utf16.count {
|
||
expectEqual(
|
||
utf16Indices[i], String.Index(utf16Offset: i, in: s.dropLast()))
|
||
expectEqual(i, idx.utf16Offset(in: s.dropLast()))
|
||
} else if i == s.dropLast().utf16.count {
|
||
expectEqual(
|
||
utf16Indices[i], String.Index(utf16Offset: i, in: s.dropLast()))
|
||
} else {
|
||
expectNotEqual(
|
||
utf16Indices[i], String.Index(utf16Offset: i, in: s.dropLast()))
|
||
}
|
||
}
|
||
}
|
||
|
||
for s in simpleStrings {
|
||
validateOffsets(s)
|
||
}
|
||
}
|
||
|
||
func swift5ScalarAlign(_ idx: String.Index, in str: String) -> String.Index {
|
||
var idx = idx
|
||
while str.utf8[idx] & 0xC0 == 0x80 { str.utf8.formIndex(before: &idx) }
|
||
return idx
|
||
}
|
||
|
||
StringIndexTests.test("Scalar Align UTF-8 indices") {
|
||
// TODO: Test a new aligning API when we add it. For now, we
|
||
// test scalar-aligning UTF-8 indices
|
||
|
||
let str = "a😇"
|
||
let subScalarIdx = str.utf8.index(str.utf8.startIndex, offsetBy: 2)
|
||
|
||
let roundedIdx = swift5ScalarAlign(subScalarIdx, in: str)
|
||
expectEqual(1, roundedIdx.utf16Offset(in: str))
|
||
|
||
let roundedIdx2 = str.utf8[...subScalarIdx].lastIndex { $0 & 0xC0 != 0x80 }
|
||
expectEqual(roundedIdx, roundedIdx2)
|
||
|
||
var roundedIdx3 = subScalarIdx
|
||
while roundedIdx3.samePosition(in: str.unicodeScalars) == nil {
|
||
str.utf8.formIndex(before: &roundedIdx3)
|
||
}
|
||
expectEqual(roundedIdx, roundedIdx3)
|
||
}
|
||
|
||
#if _runtime(_ObjC)
|
||
import Foundation
|
||
StringIndexTests.test("String.Index(_:within) / Range<String.Index>(_:in:)") {
|
||
guard #available(SwiftStdlib 5.1, *) else {
|
||
return
|
||
}
|
||
|
||
let str = simpleStrings.joined()
|
||
let substr = str[...]
|
||
for idx in str.utf8.indices {
|
||
expectEqual(
|
||
String.Index(idx, within: str), String.Index(idx, within: substr))
|
||
}
|
||
|
||
expectNil(String.Index(str.startIndex, within: str.dropFirst()))
|
||
expectNil(String.Index(str.endIndex, within: str.dropLast()))
|
||
expectNotNil(String.Index(str.startIndex, within: str))
|
||
expectNotNil(String.Index(str.endIndex, within: str))
|
||
|
||
let utf16Count = str.utf16.count
|
||
let utf16Indices = Array(str.utf16.indices) + [str.utf16.endIndex]
|
||
for location in 0..<utf16Count {
|
||
for length in 0...(utf16Count - location) {
|
||
let strLB = String.Index(utf16Indices[location], within: str)
|
||
let substrLB = String.Index(utf16Indices[location], within: substr)
|
||
let strUB = String.Index(utf16Indices[location+length], within: str)
|
||
let substrUB = String.Index(utf16Indices[location+length], within: substr)
|
||
expectEqual(strLB, substrLB)
|
||
expectEqual(strUB, substrUB)
|
||
|
||
let nsRange = NSRange(location: location, length: length)
|
||
let strRange = Range<String.Index>(nsRange, in: str)
|
||
let substrRange = Range<String.Index>(nsRange, in: substr)
|
||
|
||
expectEqual(strRange, substrRange)
|
||
guard strLB != nil && strUB != nil else {
|
||
expectNil(strRange)
|
||
continue
|
||
}
|
||
expectEqual(strRange, Range(uncheckedBounds: (strLB!, strUB!)))
|
||
}
|
||
}
|
||
}
|
||
|
||
StringIndexTests.test("Misaligned") {
|
||
// Misaligned indices were fixed in 5.1
|
||
guard _hasSwift_5_1() else { return }
|
||
|
||
func doIt(_ str: String) {
|
||
let characterIndices = Array(str.indices)
|
||
let scalarIndices = Array(str.unicodeScalars.indices) + [str.endIndex]
|
||
let utf8Indices = Array(str.utf8.indices)
|
||
|
||
var lastScalarI = 0
|
||
for i in 1..<utf8Indices.count {
|
||
let idx = utf8Indices[i]
|
||
|
||
// Skip aligned indices
|
||
guard idx < scalarIndices[lastScalarI + 1] else {
|
||
assert(idx == scalarIndices[lastScalarI + 1])
|
||
lastScalarI += 1
|
||
continue
|
||
}
|
||
expectTrue(UTF8.isContinuation(str.utf8[idx]))
|
||
|
||
let lastScalarIdx = scalarIndices[lastScalarI]
|
||
|
||
// Check aligning-down
|
||
expectEqual(str[lastScalarIdx], str[idx])
|
||
expectEqual(str.utf16[lastScalarIdx], str.utf16[idx])
|
||
expectEqual(str.unicodeScalars[lastScalarIdx], str.unicodeScalars[idx])
|
||
|
||
// Check distance
|
||
let (start, end) = (str.startIndex, str.endIndex)
|
||
if characterIndices.contains(lastScalarIdx) {
|
||
expectEqual(0, str.distance(from: lastScalarIdx, to: idx))
|
||
expectEqual(str[..<idx].count, str.distance(from: start, to: idx))
|
||
expectEqual(str[idx...].count, str.distance(from: idx, to: end))
|
||
}
|
||
expectEqual(
|
||
0, str.unicodeScalars.distance(from: lastScalarIdx, to: idx))
|
||
expectEqual(
|
||
str.unicodeScalars[..<idx].count,
|
||
str.unicodeScalars.distance(from: start, to: idx))
|
||
expectEqual(
|
||
str.unicodeScalars[idx...].count,
|
||
str.unicodeScalars.distance(from: idx, to: end))
|
||
|
||
expectEqual(0, str.utf16.distance(from: lastScalarIdx, to: idx))
|
||
expectEqual(
|
||
str.utf16[..<idx].count, str.utf16.distance(from: start, to: idx))
|
||
expectEqual(
|
||
str.utf16[idx...].count, str.utf16.distance(from: idx, to: end))
|
||
}
|
||
}
|
||
|
||
let nsstring: NSString = "aодиde\u{301}日🧟♀️"
|
||
doIt(nsstring as String)
|
||
|
||
let string = "aодиde\u{301}日🧟♀️"
|
||
doIt(string)
|
||
}
|
||
|
||
#endif // _runtime(_ObjC)
|
||
|
||
StringIndexTests.test("Exhaustive Index Interchange") {
|
||
// Exhaustively test aspects of string index interchange
|
||
func testInterchange(
|
||
_ str: String,
|
||
stackTrace: SourceLocStack = SourceLocStack(),
|
||
showFrame: Bool = true,
|
||
file: String = #file,
|
||
line: UInt = #line
|
||
) {
|
||
guard #available(SwiftStdlib 5.1, *) else {
|
||
return
|
||
}
|
||
|
||
let stackTrace = stackTrace.pushIf(showFrame, file: file, line: line)
|
||
func expect(
|
||
_ condition: @autoclosure () -> Bool,
|
||
_ message: String = "",
|
||
file: String = #file,
|
||
line: UInt = #line
|
||
) {
|
||
expectTrue(condition(), message,
|
||
stackTrace: stackTrace, showFrame: showFrame,
|
||
file: file, line: line)
|
||
}
|
||
|
||
var curCharIdx = str.startIndex
|
||
var curScalarIdx = str.startIndex
|
||
var curUTF8Idx = str.startIndex
|
||
var curUTF16Idx = str.startIndex
|
||
|
||
while curCharIdx < str.endIndex {
|
||
let curChar = str[curCharIdx]
|
||
expect(curChar == str[curScalarIdx])
|
||
expect(curChar == str[curUTF8Idx])
|
||
expect(curChar == str[curUTF16Idx])
|
||
|
||
// Advance the character index once and have the scalar index catch up
|
||
str.formIndex(after: &curCharIdx)
|
||
|
||
let scalarStartIdx = curScalarIdx
|
||
defer {
|
||
let sub = str[scalarStartIdx..<curScalarIdx]
|
||
expect(sub.count == 1)
|
||
expect(sub.first! == curChar)
|
||
expect(str.distance(from: scalarStartIdx, to: curScalarIdx) == 1)
|
||
}
|
||
|
||
while curScalarIdx < curCharIdx {
|
||
let scalarStartIdx = curScalarIdx
|
||
let curScalar = str.unicodeScalars[curScalarIdx]
|
||
let curSubChar = str[curScalarIdx]
|
||
|
||
// If there is a Character prior to this scalar, remember it and check
|
||
// that misalignd code unit indices also produce it.
|
||
let scalarPriorCharacter: Character?
|
||
if scalarStartIdx == str.startIndex {
|
||
scalarPriorCharacter = nil
|
||
} else {
|
||
scalarPriorCharacter = str[str.index(before: scalarStartIdx)]
|
||
}
|
||
|
||
// Advance the scalar index once and have the code unit indices catch up
|
||
str.unicodeScalars.formIndex(after: &curScalarIdx)
|
||
|
||
|
||
let utf8StartIdx = curUTF8Idx
|
||
defer {
|
||
let sub = str.unicodeScalars[utf8StartIdx..<curUTF8Idx]
|
||
expect(sub.count == 1)
|
||
expect(sub.first! == curScalar)
|
||
expect(str.unicodeScalars.distance(
|
||
from: utf8StartIdx, to: curUTF8Idx) == 1)
|
||
expect(str.utf8.distance(
|
||
from: utf8StartIdx, to: curUTF8Idx) == curScalar.utf8.count)
|
||
}
|
||
|
||
while curUTF8Idx < curScalarIdx {
|
||
expect(curScalar == str.unicodeScalars[curUTF8Idx])
|
||
expect(curSubChar == str[curUTF8Idx])
|
||
expect(!UTF16.isTrailSurrogate(str.utf16[curUTF8Idx]))
|
||
expect(utf8StartIdx == str[curUTF8Idx...].startIndex)
|
||
expect(str[utf8StartIdx..<curUTF8Idx].isEmpty)
|
||
expect(0 == str.utf16.distance(from: utf8StartIdx, to: curUTF8Idx))
|
||
|
||
if let scalarPrior = scalarPriorCharacter {
|
||
expect(scalarPrior == str[str.index(before: curUTF8Idx)])
|
||
}
|
||
|
||
str.utf8.formIndex(after: &curUTF8Idx)
|
||
}
|
||
expect(curUTF8Idx == curScalarIdx)
|
||
|
||
var utf8RevIdx = curUTF8Idx
|
||
while utf8RevIdx > utf8StartIdx {
|
||
str.utf8.formIndex(before: &utf8RevIdx)
|
||
|
||
expect(curScalar == str.unicodeScalars[utf8RevIdx])
|
||
expect(curSubChar == str[utf8RevIdx])
|
||
expect(!UTF16.isTrailSurrogate(str.utf16[utf8RevIdx]))
|
||
expect(utf8StartIdx == str[utf8RevIdx...].startIndex)
|
||
expect(str[utf8StartIdx..<utf8RevIdx].isEmpty)
|
||
expect(0 == str.utf16.distance(from: utf8StartIdx, to: utf8RevIdx))
|
||
}
|
||
expect(utf8RevIdx == utf8StartIdx)
|
||
|
||
let utf16StartIdx = curUTF16Idx
|
||
defer {
|
||
let sub = str.unicodeScalars[utf16StartIdx..<curUTF16Idx]
|
||
expect(sub.count == 1)
|
||
expect(sub.first! == curScalar)
|
||
expect(str.unicodeScalars.distance(
|
||
from: utf16StartIdx, to: curUTF16Idx) == 1)
|
||
expect(str.utf16.distance(
|
||
from: utf16StartIdx, to: curUTF16Idx) == curScalar.utf16.count)
|
||
}
|
||
|
||
while curUTF16Idx < curScalarIdx {
|
||
expect(curScalar == str.unicodeScalars[curUTF16Idx])
|
||
expect(curSubChar == str[curUTF16Idx])
|
||
expect(!UTF8.isContinuation(str.utf8[curUTF16Idx]))
|
||
expect(utf16StartIdx == str[curUTF16Idx...].startIndex)
|
||
expect(str[utf16StartIdx..<curUTF16Idx].isEmpty)
|
||
expect(0 == str.utf8.distance(from: utf16StartIdx, to: curUTF16Idx))
|
||
|
||
if let scalarPrior = scalarPriorCharacter {
|
||
expect(scalarPrior == str[str.index(before: curUTF16Idx)])
|
||
}
|
||
|
||
str.utf16.formIndex(after: &curUTF16Idx)
|
||
}
|
||
expect(curUTF16Idx == curScalarIdx)
|
||
|
||
var utf16RevIdx = curUTF16Idx
|
||
while utf16RevIdx > utf16StartIdx {
|
||
str.utf16.formIndex(before: &utf16RevIdx)
|
||
|
||
expect(curScalar == str.unicodeScalars[utf16RevIdx])
|
||
expect(curSubChar == str[utf16RevIdx])
|
||
expect(!UTF8.isContinuation(str.utf8[utf16RevIdx]))
|
||
expect(utf16StartIdx == str[utf16RevIdx...].startIndex)
|
||
expect(str[utf16StartIdx..<utf16RevIdx].isEmpty)
|
||
expect(0 == str.utf8.distance(from: utf16StartIdx, to: utf16RevIdx))
|
||
}
|
||
expect(utf16RevIdx == utf16StartIdx)
|
||
|
||
}
|
||
}
|
||
}
|
||
|
||
testInterchange("abc\r\ndefg")
|
||
|
||
#if _runtime(_ObjC)
|
||
testInterchange(("abc\r\ndefg" as NSString) as String)
|
||
#endif // _runtime(_ObjC)
|
||
|
||
testInterchange("ab\r\ncдe\u{301}日🧟♀️x🧟x🏳️🌈🇺🇸🇨🇦")
|
||
|
||
#if _runtime(_ObjC)
|
||
testInterchange(("ab\r\ncдe\u{301}日🧟♀️x🧟x🏳️🌈🇺🇸🇨🇦" as NSString) as String)
|
||
#endif // _runtime(_ObjC)
|
||
}
|
||
|
||
runAllTests()
|