[test] Improve grapheme breaking tests

Instead of just checking the number of breaks in each test case,
expose and check the actual positions of those breaks, too.

Author: lorentey

stdlib/private/StdlibUnicodeUnittest/GraphemeBreaking.swift

@@ -15,56 +15,47 @@
 #if _runtime(_ObjC)
 import Foundation
 
-func parseGraphemeBreakTests(
-  _ data: String,
-  into result: inout [(String, Int)]
-) {
-  for line in data.split(separator: "\n") {
+public struct GraphemeBreakTest {
+  public let string: String
+  public let pieces: [[Unicode.Scalar]]
+
+  init?(line: some StringProtocol) {
     // Only look at actual tests
-    guard line.hasPrefix("÷") else {
-      continue
-    }
+    guard line.hasPrefix("÷") else { return nil }
 
     let info = line.split(separator: "#")
     let components = info[0].split(separator: " ")
 
     var string = ""
-    var count = 0
-
-    for i in components.indices {
-      guard i != 0 else {
-        continue
-      }
-
-      let scalar: Unicode.Scalar
-
-      // If we're an odd index, this is a scalar.
-      if i & 0x1 == 1 {
-        scalar = Unicode.Scalar(UInt32(components[i], radix: 16)!)!
-
+    var pieces: [[Unicode.Scalar]] = []
+
+    var piece: [Unicode.Scalar] = []
+    for component in components {
+      switch component {
+      case "":
+        break
+      case "×": // no grapheme break opportunity
+        break
+      case "÷": // grapheme break opportunity
+        guard !piece.isEmpty else { break }
+        pieces.append(piece)
+        piece = []
+      case _: // hexadecimal scalar value
+        guard let value = UInt32(component, radix: 16) else { return nil }
+        guard let scalar = Unicode.Scalar(value) else { return nil }
         string.unicodeScalars.append(scalar)
-      } else {
-        // Otherwise, it is a grapheme breaking operator.
-
-        // If this is a break, record the +1 count. Otherwise it is × which is
-        // not a break.
-        if components[i] == "÷" {
-          count += 1
-        }
+        piece.append(scalar)
       }
     }
-
-    result.append((string, count))
+    if !piece.isEmpty { pieces.append(piece) }
+    self.string = string
+    self.pieces = pieces
   }
 }
 
-public let graphemeBreakTests: [(String, Int)] = {
-  var result: [(String, Int)] = []
-
+public let graphemeBreakTests: [GraphemeBreakTest] = {
   let testFile = readInputFile("GraphemeBreakTest.txt")
-
-  parseGraphemeBreakTests(testFile, into: &result)
-
-  return result
+  return testFile.split(separator: "\n")
+    .compactMap { GraphemeBreakTest(line: $0) }
 }()
 #endif

test/stdlib/StringIndex.swift

@@ -656,8 +656,8 @@ suite.test("Fully exhaustive index interchange")
 
 #if _runtime(_ObjC)
 suite.test("Fully exhaustive index interchange/GraphemeBreakTests") {
-  for string in graphemeBreakTests.map { $0.0 } {
-    fullyExhaustiveIndexInterchange(string)
+  for test in graphemeBreakTests {
+    fullyExhaustiveIndexInterchange(test.string)
   }
 }
 #endif

validation-test/stdlib/StringGraphemeBreaking.swift

@@ -10,47 +10,59 @@ import StdlibUnicodeUnittest
 import Foundation
 
 let StringGraphemeBreaking = TestSuite("StringGraphemeBreaking")
+defer { runAllTests() }
 
 extension String {
-  var backwardsCount: Int {
-    var c = 0
-    var index = endIndex
-    while index != startIndex {
-      c += 1
-      formIndex(before: &index)
+  var forwardPieces: [[Unicode.Scalar]] {
+    var i = startIndex
+    var r: [[Unicode.Scalar]] = []
+    while i < endIndex {
+      let j = self.index(after: i)
+      r.append(Array(self[i..<j].unicodeScalars))
+      i = j
     }
-    return c
+    return r
+  }
+
+  var backwardPieces: [[Unicode.Scalar]] {
+    var j = endIndex
+    var r: [[Unicode.Scalar]] = []
+    while j > startIndex {
+      let i = self.index(before: j)
+      r.append(Array(self[i..<j].unicodeScalars))
+      j = i
+    }
+    r.reverse()
+    return r
   }
 }
 
 if #available(SwiftStdlib 5.6, *) {
   StringGraphemeBreaking.test("grapheme breaking") {
-    for graphemeBreakTest in graphemeBreakTests {
+    for test in graphemeBreakTests {
       expectEqual(
-        graphemeBreakTest.1,
-        graphemeBreakTest.0.count,
-        "string: \(String(reflecting: graphemeBreakTest.0))")
+        test.string.forwardPieces, test.pieces,
+        "string: \(String(reflecting: test.string)) (forward)")
       expectEqual(
-        graphemeBreakTest.1,
-        graphemeBreakTest.0.backwardsCount,
-        "string: \(String(reflecting: graphemeBreakTest.0))")
+        test.string.backwardPieces, test.pieces,
+        "string: \(String(reflecting: test.string)) (backward)")
     }
   }
 }
 
 // The most simple subclass of NSString that CoreFoundation does not know
 // about.
-class NonContiguousNSString : NSString {
+class NonContiguousNSString: NSString {
   required init(coder aDecoder: NSCoder) {
     fatalError("don't call this initializer")
   }
   required init(itemProviderData data: Data, typeIdentifier: String) throws {
-    fatalError("don't call this initializer")    
+    fatalError("don't call this initializer")
   }
 
-  override init() { 
+  override init() {
     _value = []
-    super.init() 
+    super.init()
   }
 
   init(_ value: [UInt16]) {
@@ -80,33 +92,19 @@ extension _StringGuts {
   func _isForeign() -> Bool
 }
 
-func getUTF16Array(from string: String) -> [UInt16] {
-  var result: [UInt16] = []
-
-  for cp in string.utf16 {
-    result.append(cp)
-  }
-
-  return result
-}
-
 if #available(SwiftStdlib 5.6, *) {
   StringGraphemeBreaking.test("grapheme breaking foreign") {
-    for graphemeBreakTest in graphemeBreakTests {
-      let foreignTest = NonContiguousNSString(
-        getUTF16Array(from: graphemeBreakTest.0)
-      )
-      let test = foreignTest as String
+    for test in graphemeBreakTests {
+      let foreign = NonContiguousNSString(Array(test.string.utf16))
+      let string = foreign as String
 
-      expectTrue(test._guts._isForeign())
+      expectTrue(string._guts._isForeign())
       expectEqual(
-        graphemeBreakTest.1, test.count,
-        "string: \(String(reflecting: graphemeBreakTest.0))")
+        string.forwardPieces, test.pieces,
+        "string: \(String(reflecting: test.string)) (forward)")
       expectEqual(
-        graphemeBreakTest.1, test.backwardsCount,
-        "string: \(String(reflecting: graphemeBreakTest.0))")
+        string.backwardPieces, test.pieces,
+        "string: \(String(reflecting: test.string)) (backward)")
     }
   }
 }
-
-runAllTests()