Add library evolution tests for constructor, computed property, subscript default implementations

Author: slavapestov

validation-test/Evolution/Inputs/protocol_add_requirements.swift

@@ -7,11 +7,12 @@ public func getVersion() -> Int {
 #endif
 }
 
+
 public protocol ElementProtocol : Equatable {
   func increment() -> Self
 }
 
-public protocol AddRequirementsProtocol {
+public protocol AddMethodsProtocol {
   associatedtype Element : ElementProtocol
 
   func importantOperation() -> Element
@@ -22,7 +23,7 @@ public protocol AddRequirementsProtocol {
 #endif
 }
 
-extension AddRequirementsProtocol {
+extension AddMethodsProtocol {
   public func unimportantOperation() -> Element {
     return importantOperation().increment()
   }
@@ -34,7 +35,7 @@ extension AddRequirementsProtocol {
 #endif
 }
 
-public func doSomething<T : AddRequirementsProtocol>(t: T) -> [T.Element] {
+public func doSomething<T : AddMethodsProtocol>(t: T) -> [T.Element] {
 #if BEFORE
   return [
       t.importantOperation(),
@@ -49,3 +50,128 @@ public func doSomething<T : AddRequirementsProtocol>(t: T) -> [T.Element] {
   ]
 #endif
 }
+
+
+public protocol AddConstructorsProtocol {
+  init(name: String)
+
+#if AFTER
+  init?(nickname: String)
+#endif
+}
+
+extension AddConstructorsProtocol {
+  public init?(nickname: String) {
+    if nickname == "" {
+      return nil
+    }
+    self.init(name: nickname + "ster")
+  }
+}
+
+public func testConstructorProtocol<T : AddConstructorsProtocol>(t: T.Type) -> [T?] {
+#if BEFORE
+  return [t.init(name: "Puff")]
+#else
+  return [t.init(name: "Meow meow"),
+          t.init(nickname: ""),
+          t.init(nickname: "Robster the Lob")]
+#endif
+}
+
+
+public protocol AddPropertiesProtocol {
+  var topSpeed: Int { get nonmutating set }
+  var maxRPM: Int { get set }
+
+#if AFTER
+  var maxSafeSpeed: Int { get set }
+  var minSafeSpeed: Int { get nonmutating set }
+  var redLine: Int { mutating get set }
+#endif
+}
+
+extension AddPropertiesProtocol {
+#if AFTER
+  public var maxSafeSpeed: Int {
+    get {
+      return topSpeed / 2
+    }
+    set {
+      topSpeed = newValue * 2
+    }
+  }
+
+  public var minSafeSpeed: Int {
+    get {
+      return topSpeed / 4
+    }
+    nonmutating set {
+      topSpeed = newValue * 4
+    }
+  }
+
+  public var redLine: Int {
+    get {
+      return maxRPM - 2000
+    }
+    set {
+      maxRPM = newValue + 2000
+    }
+  }
+#endif
+}
+
+public func getProperties<T : AddPropertiesProtocol>(t: inout T) -> [Int] {
+#if BEFORE
+  return [t.topSpeed, t.maxRPM]
+#else
+  return [t.topSpeed, t.maxRPM, t.maxSafeSpeed, t.minSafeSpeed, t.redLine]
+#endif
+}
+
+func increment(x: inout Int, by: Int) {
+  x += by
+}
+
+public func setProperties<T : AddPropertiesProtocol>(t: inout T) {
+#if AFTER
+  t.minSafeSpeed = t.maxSafeSpeed
+  increment(&t.redLine, by: 7000)
+#else
+  increment(&t.topSpeed, by: t.topSpeed)
+  increment(&t.maxRPM, by: 7000)
+#endif
+}
+
+
+public protocol AddSubscriptProtocol {
+  associatedtype Key
+  associatedtype Value
+
+  func get(key key: Key) -> Value
+  mutating func set(key key: Key, value: Value)
+
+#if AFTER
+  subscript(key: Key) -> Value { get set }
+#endif
+}
+
+extension AddSubscriptProtocol {
+  public subscript(key: Key) -> Value {
+    get {
+      return get(key: key)
+    }
+    set {
+      set(key: key, value: newValue)
+    }
+  }
+}
+
+public func doSomething<T : AddSubscriptProtocol>(t: inout T, k1: T.Key, k2: T.Key) {
+#if BEFORE
+  t.set(key: k1, value: t.get(key: k2))
+#else
+  t[k1] = t[k2]
+#endif
+}

validation-test/Evolution/test_protocol_add_requirements.swift

@@ -27,7 +27,7 @@ func ==(h1: Halogen, h2: Halogen) -> Bool {
   return h1.x == h2.x
 }
 
-struct ConformingType : AddRequirementsProtocol {
+struct AddMethods : AddMethodsProtocol {
   func importantOperation() -> Halogen {
     return Halogen(x: 0)
   }
@@ -39,8 +39,8 @@ struct ConformingType : AddRequirementsProtocol {
 #endif
 }
 
-ProtocolAddRequirementsTest.test("AddRequirements") {
-  let result = doSomething(ConformingType())
+ProtocolAddRequirementsTest.test("AddMethodRequirements") {
+  let result = doSomething(AddMethods())
 
 #if BEFORE
   let expected = [0, 1, 2].map(Halogen.init)
@@ -51,5 +51,105 @@ ProtocolAddRequirementsTest.test("AddRequirements") {
   expectEqual(result, expected)
 }
 
+
+struct AddConstructors : AddConstructorsProtocol, Equatable {
+  var name: String
+
+  init(name: String) {
+    self.name = name
+  }
+}
+
+func ==(a1: AddConstructors, a2: AddConstructors) -> Bool {
+  return a1.name == a2.name
+}
+
+ProtocolAddRequirementsTest.test("AddConstructorsProtocol") {
+  // Would be nice if [T?] was Equatable...
+  if getVersion() == 0 {
+    let result = testConstructorProtocol(AddConstructors.self)
+    expectEqual(result.count, 1)
+    expectEqual(result[0], AddConstructors(name: "Puff"))
+  } else {
+    let result = testConstructorProtocol(AddConstructors.self)
+    expectEqual(result.count, 3)
+    expectEqual(result[0], AddConstructors(name: "Meow meow"))
+    expectEqual(result[1], nil)
+    expectEqual(result[2], AddConstructors(name: "Robster the Lobster"))
+  }
+}
+
+
+class Box<T> {
+  var value: T
+
+  init(value: T) {
+    self.value = value
+  }
+}
+
+struct AddProperties : AddPropertiesProtocol {
+  var speedBox: Box<Int> = Box<Int>(value: 160)
+  var gearBox: Box<Int> = Box<Int>(value: 8000)
+
+  var topSpeed: Int {
+    get {
+      return speedBox.value
+    }
+    nonmutating set {
+      speedBox.value = newValue
+    }
+  }
+
+  var maxRPM: Int {
+    get {
+      return gearBox.value
+    }
+    set {
+      gearBox.value = newValue
+    }
+  }
+}
+
+ProtocolAddRequirementsTest.test("AddPropertyRequirements") {
+  var x = AddProperties()
+
+  do {
+    let expected = (getVersion() == 0
+                    ? [160, 8000]
+                    : [160, 8000, 80, 40, 6000])
+    expectEqual(getProperties(&x), expected)
+  }
+
+  setProperties(&x)
+
+  do {
+    let expected = (getVersion() == 0
+                    ? [320, 15000]
+                    : [320, 15000, 160, 80, 13000])
+    expectEqual(getProperties(&x), expected)
+  }
+}
+
+
+struct AddSubscript<Key : Hashable, Value> : AddSubscriptProtocol {
+  var dict: [Key : Value] = [:]
+
+  func get(key key: Key) -> Value {
+    return dict[key]!
+  }
+
+  mutating func set(key key: Key, value: Value) {
+    dict[key] = value
+  }
+}
+
+ProtocolAddRequirementsTest.test("AddPropertyRequirements") {
+  var t = AddSubscript<String, Int>()
+  t.set(key: "B", value: 20)
+  doSomething(&t, k1: "A", k2: "B")
+  expectEqual(t.get(key: "A"), 20)
+}
+
 runAllTests()