1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
@_spi(RawSyntax) import SwiftSyntax
import XCTest
final class SyntaxTextTests: XCTestCase {
func testLiteral() {
let strBasic: SyntaxText = "foobar"
let strASCII: SyntaxText = "A"
let strHiragana: SyntaxText = "γ"
let strEmojiSingle: SyntaxText = "π€"
let strUTF8: SyntaxText = "γγγ«γ‘γ―δΈηοΌ"
XCTAssertEqual(String(syntaxText: strBasic), String("foobar"))
XCTAssertEqual(String(syntaxText: strASCII), String("A"))
XCTAssertEqual(String(syntaxText: strHiragana), String("γ"))
XCTAssertEqual(String(syntaxText: strEmojiSingle), String("π€"))
XCTAssertEqual(String(syntaxText: strUTF8), String("γγγ«γ‘γ―δΈηοΌ"))
}
func testInvalid() {
let invalidUTF8: [UInt8] = [0x43, 0x61, 0x66, 0xC3]
invalidUTF8.withUnsafeBufferPointer { buffer in
let fromData = SyntaxText(baseAddress: buffer.baseAddress, count: buffer.count)
XCTAssertEqual(String(syntaxText: fromData), "Caf\u{FFFD}")
}
}
func testSlice() {
let text: SyntaxText = "0123456789"
let slice1 = SyntaxText(rebasing: text[0..<4])
let slice2 = SyntaxText(rebasing: text[0..<text.count])
let slice3 = SyntaxText(rebasing: text[3..<text.count])
XCTAssert(slice1.isSlice(of: text))
XCTAssert(slice2.isSlice(of: text))
XCTAssert(slice3.isSlice(of: text))
XCTAssertNotNil(text.firstRange(of: slice1))
XCTAssertNotNil(text.firstRange(of: slice2))
XCTAssertNotNil(text.firstRange(of: slice3))
let empty: SyntaxText = ""
let emptySlice: SyntaxText = SyntaxText(rebasing: empty[...])
XCTAssertTrue(emptySlice.isSlice(of: empty))
XCTAssertEqual(emptySlice, "")
XCTAssertEqual(SyntaxText(rebasing: text[2..<2]), SyntaxText(rebasing: text[3..<3]))
}
func testEmptyCompare() {
let text: SyntaxText = "0123456789"
let emptyDefault = SyntaxText()
let emptyStatic: SyntaxText = ""
let emptySlice1 = SyntaxText(rebasing: text[1..<1])
let emptySlice2 = SyntaxText(rebasing: text[6..<6])
XCTAssertTrue(emptyDefault.baseAddress == nil && emptyDefault.isEmpty)
XCTAssertTrue(emptyStatic.baseAddress != nil && emptyStatic.isEmpty)
XCTAssertTrue(emptySlice1.baseAddress != nil && emptySlice1.isEmpty)
XCTAssertTrue(emptySlice2.baseAddress != nil && emptySlice2.isEmpty)
XCTAssertTrue(emptyDefault == emptyDefault)
XCTAssertTrue(emptyDefault == emptyStatic)
XCTAssertTrue(emptyDefault == emptySlice1)
XCTAssertTrue(emptyDefault == emptySlice2)
XCTAssertTrue(emptyStatic == emptyDefault)
XCTAssertTrue(emptyStatic == emptyStatic)
XCTAssertTrue(emptyStatic == emptySlice1)
XCTAssertTrue(emptyStatic == emptySlice2)
XCTAssertTrue(emptySlice1 == emptyDefault)
XCTAssertTrue(emptySlice1 == emptyStatic)
XCTAssertTrue(emptySlice1 == emptySlice1)
XCTAssertTrue(emptySlice1 == emptySlice2)
XCTAssertTrue(emptySlice2 == emptyDefault)
XCTAssertTrue(emptySlice2 == emptyStatic)
XCTAssertTrue(emptySlice2 == emptySlice1)
XCTAssertTrue(emptySlice2 == emptySlice2)
}
func testFirstRange() {
let text: SyntaxText = "0123456789012345"
XCTAssertEqual(text.firstRange(of: ""), nil)
XCTAssertEqual(text.firstRange(of: SyntaxText(rebasing: SyntaxText("012")[1..<1])), nil)
XCTAssertEqual(text.firstRange(of: "abc"), nil)
XCTAssertEqual(text.firstRange(of: "01234567890123456"), nil)
XCTAssertEqual(text.firstRange(of: "0"), 0..<1)
XCTAssertEqual(text.firstRange(of: "1"), 1..<2)
XCTAssertEqual(text.firstRange(of: "5"), 5..<6)
XCTAssertEqual(text.firstRange(of: "012"), 0..<3)
XCTAssertEqual(text.firstRange(of: "234"), 2..<5)
XCTAssertEqual(text.firstRange(of: "9012345"), 9..<16)
XCTAssertEqual(SyntaxText(rebasing: text[2..<12]).firstRange(of: "123"), nil)
XCTAssertEqual(SyntaxText(rebasing: text[5...]).firstRange(of: "5"), 0..<1)
XCTAssertEqual(SyntaxText(rebasing: text[5...]).firstRange(of: "0"), 5..<6)
}
func testContains() {
let text: SyntaxText = "0123456789012345"
XCTAssertTrue(text.contains("123"))
XCTAssertTrue(text.contains("0123456789012345"))
XCTAssertTrue(text.contains("9012345"))
XCTAssertFalse(text.contains(""))
XCTAssertFalse(text.contains("foo"))
XCTAssertFalse(text.contains("01234567890123456"))
}
func testHasPrefixSuffix() {
let text: SyntaxText = "0123456789012345"
XCTAssertTrue(text.hasPrefix(""))
XCTAssertTrue(text.hasPrefix("0"))
XCTAssertTrue(text.hasPrefix("0123"))
XCTAssertTrue(text.hasPrefix("0123456789012345"))
XCTAssertFalse(text.hasPrefix("345"))
XCTAssertFalse(text.hasPrefix("abc"))
XCTAssertTrue(text.hasSuffix(""))
XCTAssertTrue(text.hasSuffix("5"))
XCTAssertTrue(text.hasSuffix("12345"))
XCTAssertTrue(text.hasSuffix("0123456789012345"))
XCTAssertFalse(text.hasSuffix("012"))
XCTAssertFalse(text.hasSuffix("abc"))
}
func testWithSyntaxText() {
var str = "Lorem ipsum"
str.withSyntaxText { text in
XCTAssertEqual(SyntaxText(rebasing: text[0..<5]), "Lorem")
XCTAssertEqual(SyntaxText(rebasing: text[6..<9]), "ips")
}
}
}
|