Update test suite for lossless string conversion

Author: CodaFi

stdlib/private/StdlibUnittest/StdlibUnittest.swift.gyb

@@ -2215,6 +2215,12 @@ public func checkStrideable<Instances : Collection, Strides : Collection>(
   }
 }
 
+public func checkLosslessStringConvertible<Instance>(
+  _ instances: [Instance]
+) where Instance : LosslessStringConvertible & Equatable {
+  expectEqualFunctionsForDomain(instances, { $0 }, { Instance(String($0))! })
+}
+
 public func nthIndex<C: Collection>(_ x: C, _ n: Int) -> C.Index {
   return x.index(x.startIndex, offsetBy: numericCast(n))
 }

stdlib/public/core/AnyHashable.swift

@@ -151,7 +151,7 @@ extension AnyHashable : Hashable {
 
 extension AnyHashable : CustomStringConvertible {
   public var description: String {
-    return String(base)
+    return String(describing: base)
   }
 }
 

stdlib/public/core/Character.swift

@@ -355,7 +355,7 @@ public struct Character :
 
 extension Character : CustomStringConvertible {
   public var description: String {
-    return String(self)
+    return String(describing: self)
   }
 }
 

stdlib/public/core/FloatingPointParsing.swift.gyb

@@ -42,7 +42,7 @@ internal func _isspace_clocale(_ u: UTF16.CodeUnit) -> Bool {
 % end
 
 //===--- Parsing ----------------------------------------------------------===//
-extension ${Self} {
+extension ${Self} : LosslessStringConvertible {
   /// Construct from an ASCII representation.
   ///
   /// Returns the result of calling the POSIX function

stdlib/public/core/OutputStream.swift

@@ -171,7 +171,7 @@ public protocol CustomStringConvertible {
 ///
 /// The description property of a conforming type must be a value-preserving
 /// representation of the original value. As such, it should be possible to
-/// attempt to re-create an instance from its string representation.
+/// re-create an instance from its string representation.
 public protocol LosslessStringConvertible : CustomStringConvertible {
   /// Instantiates an instance of the conforming type from a string
   /// representation.

stdlib/public/core/String.swift

@@ -983,7 +983,7 @@ extension String {
   }
 
   /// Creates an instance from the description of a given
-  /// LosslessStringConvertible instance.
+  /// `LosslessStringConvertible` instance.
   public init<T : LosslessStringConvertible>(_ value: T) {
     self = value.description
   }

stdlib/public/core/UnicodeScalar.swift

@@ -271,10 +271,13 @@ public struct UnicodeScalar :
 }
 
 extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible {
-  /// An escaped textual representation of the Unicode scalar.
+  /// A textual representation of the Unicode scalar.
   public var description: String {
-    return String(value)
+    return String._fromWellFormedCodeUnitSequence(
+      UTF32.self,
+      input: repeatElement(self.value, count: 1))
   }
+
   /// An escaped textual representation of the Unicode scalar, suitable for
   /// debugging.
   public var debugDescription: String {
@@ -284,12 +287,11 @@ extension UnicodeScalar : CustomStringConvertible, CustomDebugStringConvertible
 
 extension UnicodeScalar : LosslessStringConvertible {
   public init?(_ description: String) {
-    if let v = UInt32(description) where (v < 0xD800 || v > 0xDFFF)
-      && v <= 0x10FFFF {
-      self = UnicodeScalar(v)
-    } else {
+    let scalars = description.unicodeScalars
+    guard let v = scalars.first, scalars.count == 1 else {
       return nil
     }
+    self = v
   }
 }
 

test/1_stdlib/Character.swift

@@ -14,7 +14,7 @@ import SwiftPrivate
 //
 // These scalars should be "base characters" with regards to their position in
 // a grapheme cluster.
-let baseScalars = [
+let baseScalars: [UnicodeScalar] = [
   // U+0065 LATIN SMALL LETTER E
   "\u{0065}",
 
@@ -54,7 +54,7 @@ let baseScalars = [
 
 // Single Unicode scalars that are "continuing characters" with regards to
 // their position in a grapheme cluster.
-let continuingScalars = [
+let continuingScalars: [UnicodeScalar] = [
   // U+0300 COMBINING GRAVE ACCENT
   "\u{0300}",
 
@@ -94,9 +94,9 @@ let testCharacters = [
 
 func randomGraphemeCluster(_ minSize: Int, _ maxSize: Int) -> String {
   let n = pickRandom((minSize + 1)..<maxSize)
-  var result = pickRandom(baseScalars)
+  var result = String(pickRandom(baseScalars))
   for _ in 0..<n {
-    result += pickRandom(continuingScalars)
+    result += String(pickRandom(continuingScalars))
   }
   return result
 }
@@ -150,8 +150,8 @@ CharacterTests.test("sizeof") {
 
 CharacterTests.test("Hashable") {
   for characters in [
-    baseScalars,
-    continuingScalars,
+    baseScalars.map { String($0) },
+    continuingScalars.map { String($0) },
     testCharacters
   ] {
     for i in characters.indices {
@@ -197,8 +197,8 @@ func checkRepresentation(_ s: String) {
 CharacterTests.test("RoundTripping") {
   // Single Unicode Scalar Value tests
   for s in baseScalars {
-    checkRepresentation(s)
-    checkRoundTripThroughCharacter(s)
+    checkRepresentation(String(s))
+    checkRoundTripThroughCharacter(String(s))
   }
 
   // Edge case tests
@@ -274,7 +274,7 @@ UnicodeScalarTests.test("UInt8(ascii: UnicodeScalar)/non-ASCII should trap")
 }
 
 UnicodeScalarTests.test("UInt32(_: UnicodeScalar),UInt64(_: UnicodeScalar)") {
-  for us in baseScalars.map({ $0.unicodeScalars.first! }) {
+  for us in baseScalars {
     expectEqual(us.value, UInt32(us))
     expectEqual(UInt64(us.value), UInt64(us))
   }
@@ -304,5 +304,12 @@ UnicodeScalarTests.test("Comparable") {
   expectTrue("B" >= CharA)
 }
 
+UnicodeScalarTests.test("LosslessStringConvertible") {
+  // FIXME: these tests are insufficient.
+
+  checkLosslessStringConvertible((0xE000...0xF000).map { UnicodeScalar(Int($0))! })
+  checkLosslessStringConvertible((0...127).map { UnicodeScalar(Int($0))! })
+}
+
 runAllTests()
 

test/1_stdlib/FloatingPoint.swift.gyb

@@ -370,6 +370,17 @@ FloatingPoint.test("${Self}.addingProduct") {
   let ulp = ${Self}.ulpOfOne
   expectEqual(ulp*ulp, one.addingProduct(ulp + one, ulp - one))
 }
+
+FloatingPoint.test("${Self}/LosslessStringConvertible") {
+  let instances = [ 
+    1.0, -1.0,
+    0.0, -0.0,
+    ${Self}.infinity, -${Self}.infinity 
+  ]
+
+  checkLosslessStringConvertible(instances)
+  expectTrue(Float(String(Float.nan))!.isNaN)
+}
 % if Self == 'Float80':
 #endif
 % end

test/1_stdlib/Inputs/PrintTestTypes.swift

@@ -151,7 +151,7 @@ public struct MyString : ExpressibleByStringLiteral,
   }
 
   public init<T>(stringInterpolationSegment expr: T) {
-    self.init(str: "<segment " + String(expr) + ">")
+    self.init(str: "<segment " + String(describing: expr) + ">")
   }
 }