[test] Add missing version guards to tests for new stdlib behavior

rdar://75837172

Author: lorentey

test/stdlib/FloatingPoint.swift.gyb

@@ -243,15 +243,20 @@ FloatingPoint.test("BinaryFloatingPoint/genericFloatingPointConversion") {
       from: Double._convert(from: Float.leastNonzeroMagnitude).value).value,
     Float.leastNonzeroMagnitude)
 
-  // Let's make sure that the correct value is returned when two representable
-  // values are equally close to the original value.
-  let bitPattern: UInt64 = 0b01111111111_0000000000000000000000110000000000000000000000000000
-  var z = Double(bitPattern: bitPattern)
-  expectEqual(Float._convert(from: z).value, Float(z))
-
-  z = Double(Float.greatestFiniteMagnitude) +
-      Double(Float.greatestFiniteMagnitude.ulp / 2)
-  expectEqual(Float._convert(from: z).value, Float(z))
+  if #available(macOS 11, iOS 14, watchOS 7, tvOS 14, *) {
+    // The behavior tested here was introduced in
+    // https://github.com/apple/swift/pull/30194
+
+    // Let's make sure that the correct value is returned when two representable
+    // values are equally close to the original value.
+    let bitPattern: UInt64 = 0b01111111111_0000000000000000000000110000000000000000000000000000
+    var z = Double(bitPattern: bitPattern)
+    expectEqual(Float._convert(from: z).value, Float(z))
+
+    z = Double(Float.greatestFiniteMagnitude) +
+    Double(Float.greatestFiniteMagnitude.ulp / 2)
+    expectEqual(Float._convert(from: z).value, Float(z))
+  }
 }
 
 func positiveOne<T: ExpressibleByIntegerLiteral>() -> T {

test/stdlib/objc-array-slice.swift

@@ -8,15 +8,19 @@
 
 import Foundation
 
-let array = NSMutableArray()
-for _ in 0..<1000 {
-  array.insert(NSObject(), at: 0)
-}
+if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
+  // This tests behavior that was fixed in
+  // https://github.com/apple/swift/pull/36355
+
+  let array = NSMutableArray()
+  for _ in 0..<1000 {
+    array.insert(NSObject(), at: 0)
+  }
 
-// Check that this does not crash because of an over-release of the array content.
-_ = (array as! [NSObject]).prefix(3)
-_ = (array as! [NSObject]).prefix(3)
+  // Check that this does not crash because of an over-release of the array content.
+  _ = (array as! [NSObject]).prefix(3)
+  _ = (array as! [NSObject]).prefix(3)
+}
 
 // CHECK: done
 print("done")
-

validation-test/stdlib/DictionaryTrapsObjC.swift

@@ -141,170 +141,175 @@ DictionaryTraps.test("BridgedKeyIsNotNSCopyable2")
   nsd.mutableCopy()
 }
 
-DictionaryTraps.test("ForcedNonverbatimBridge.StringKey")
+if #available(macOS 15, iOS 13, watchOS 6, tvOS 13, *) {
+  // The behavior tested here was introduced in
+  // https://github.com/apple/swift/pull/23174
+
+  DictionaryTraps.test("ForcedNonverbatimBridge.StringKey")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
-  let d1: NSDictionary = [
-    "Gordon" as NSString: NSObject(),
-    "William" as NSString: NSObject(),
-    "Katherine" as NSString: NSObject(),
-    "Lynn" as NSString: NSObject(),
-    "Brian" as NSString: NSObject(),
-    1756 as NSNumber: NSObject()]
-
-  expectCrashLater()
-  _ = d1 as! Dictionary<String, Any>
-}
+    let d1: NSDictionary = [
+      "Gordon" as NSString: NSObject(),
+      "William" as NSString: NSObject(),
+      "Katherine" as NSString: NSObject(),
+      "Lynn" as NSString: NSObject(),
+      "Brian" as NSString: NSObject(),
+      1756 as NSNumber: NSObject()]
+
+    expectCrashLater()
+    _ = d1 as! Dictionary<String, Any>
+  }
 
-DictionaryTraps.test("ForcedNonverbatimBridge.IntKey")
+  DictionaryTraps.test("ForcedNonverbatimBridge.IntKey")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
 
-  let d1: NSDictionary = [
-    4 as NSNumber: NSObject(),
-    8 as NSNumber: NSObject(),
-    15 as NSNumber: NSObject(),
-    16 as NSNumber: NSObject(),
-    23 as NSNumber: NSObject(),
-    42 as NSNumber: NSObject(),
-    "John" as NSString: NSObject()]
-
-  expectCrashLater()
-  _ = d1 as! Dictionary<Int, Any>
-}
+    let d1: NSDictionary = [
+      4 as NSNumber: NSObject(),
+      8 as NSNumber: NSObject(),
+      15 as NSNumber: NSObject(),
+      16 as NSNumber: NSObject(),
+      23 as NSNumber: NSObject(),
+      42 as NSNumber: NSObject(),
+      "John" as NSString: NSObject()]
+
+    expectCrashLater()
+    _ = d1 as! Dictionary<Int, Any>
+  }
 
-DictionaryTraps.test("ForcedNonverbatimBridge.Value")
+  DictionaryTraps.test("ForcedNonverbatimBridge.Value")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
 
-  let d1: NSDictionary = [
-    4 as NSNumber: "Jack" as NSString,
-    8 as NSNumber: "Kate" as NSString,
-    15 as NSNumber: "Hurley" as NSString,
-    16 as NSNumber: "Sawyer" as NSString,
-    23 as NSNumber: "John" as NSString,
-    42 as NSNumber: NSObject()]
+    let d1: NSDictionary = [
+      4 as NSNumber: "Jack" as NSString,
+      8 as NSNumber: "Kate" as NSString,
+      15 as NSNumber: "Hurley" as NSString,
+      16 as NSNumber: "Sawyer" as NSString,
+      23 as NSNumber: "John" as NSString,
+      42 as NSNumber: NSObject()]
 
-  expectCrashLater()
-  _ = d1 as! Dictionary<NSObject, String>
-}
+    expectCrashLater()
+    _ = d1 as! Dictionary<NSObject, String>
+  }
 
-DictionaryTraps.test("ForcedVerbatimBridge.StringKey")
+  DictionaryTraps.test("ForcedVerbatimBridge.StringKey")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
-  let d1: NSDictionary = [
-    "Gordon" as NSString: NSObject(),
-    "William" as NSString: NSObject(),
-    "Katherine" as NSString: NSObject(),
-    "Lynn" as NSString: NSObject(),
-    "Brian" as NSString: NSObject(),
-    1756 as NSNumber: NSObject()]
-
-  // With the ObjC runtime, the verbatim downcast is O(1); it performs no
-  // runtime checks.
-  let d2 = d1 as! Dictionary<NSString, NSObject>
-  // Element access goes through the bridged path and performs forced downcasts.
-  // This is where the odd numeric value is caught.
-  expectCrashLater()
-  for (key, value) in d2 {
-    _ = (key, value)
+    let d1: NSDictionary = [
+      "Gordon" as NSString: NSObject(),
+      "William" as NSString: NSObject(),
+      "Katherine" as NSString: NSObject(),
+      "Lynn" as NSString: NSObject(),
+      "Brian" as NSString: NSObject(),
+      1756 as NSNumber: NSObject()]
+
+    // With the ObjC runtime, the verbatim downcast is O(1); it performs no
+    // runtime checks.
+    let d2 = d1 as! Dictionary<NSString, NSObject>
+    // Element access goes through the bridged path and performs forced downcasts.
+    // This is where the odd numeric value is caught.
+    expectCrashLater()
+    for (key, value) in d2 {
+      _ = (key, value)
+    }
   }
-}
 
-DictionaryTraps.test("ForcedVerbatimBridge.IntKey")
+  DictionaryTraps.test("ForcedVerbatimBridge.IntKey")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
 
-  let d1: NSDictionary = [
-    4 as NSNumber: NSObject(),
-    8 as NSNumber: NSObject(),
-    15 as NSNumber: NSObject(),
-    16 as NSNumber: NSObject(),
-    23 as NSNumber: NSObject(),
-    42 as NSNumber: NSObject(),
-    "John" as NSString: NSObject()]
-
-  // With the ObjC runtime, the verbatim downcast is O(1); it performs no
-  // runtime checks.
-  let d2 = d1 as! Dictionary<NSNumber, NSObject>
-  // Element access goes through the bridged path and performs forced downcasts.
-  // This is where the odd numeric value is caught.
-  expectCrashLater()
-  for (key, value) in d2 {
-    _ = (key, value)
+    let d1: NSDictionary = [
+      4 as NSNumber: NSObject(),
+      8 as NSNumber: NSObject(),
+      15 as NSNumber: NSObject(),
+      16 as NSNumber: NSObject(),
+      23 as NSNumber: NSObject(),
+      42 as NSNumber: NSObject(),
+      "John" as NSString: NSObject()]
+
+    // With the ObjC runtime, the verbatim downcast is O(1); it performs no
+    // runtime checks.
+    let d2 = d1 as! Dictionary<NSNumber, NSObject>
+    // Element access goes through the bridged path and performs forced downcasts.
+    // This is where the odd numeric value is caught.
+    expectCrashLater()
+    for (key, value) in d2 {
+      _ = (key, value)
+    }
   }
-}
 
-DictionaryTraps.test("ForcedVerbatimBridge.Value")
+  DictionaryTraps.test("ForcedVerbatimBridge.Value")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
 
-  let d1: NSDictionary = [
-    4 as NSNumber: "Jack" as NSString,
-    8 as NSNumber: "Kate" as NSString,
-    15 as NSNumber: "Hurley" as NSString,
-    16 as NSNumber: "Sawyer" as NSString,
-    23 as NSNumber: "John" as NSString,
-    42 as NSNumber: NSObject()]
-
-  // With the ObjC runtime, the verbatim downcast is O(1); it performs no
-  // runtime checks.
-  let d2 = d1 as! Dictionary<NSObject, NSString>
-  // Element access goes through the bridged path and performs forced downcasts.
-  // This is where the odd numeric value is caught.
-  expectCrashLater()
-  for (key, value) in d2 {
-    _ = (key, value)
+    let d1: NSDictionary = [
+      4 as NSNumber: "Jack" as NSString,
+      8 as NSNumber: "Kate" as NSString,
+      15 as NSNumber: "Hurley" as NSString,
+      16 as NSNumber: "Sawyer" as NSString,
+      23 as NSNumber: "John" as NSString,
+      42 as NSNumber: NSObject()]
+
+    // With the ObjC runtime, the verbatim downcast is O(1); it performs no
+    // runtime checks.
+    let d2 = d1 as! Dictionary<NSObject, NSString>
+    // Element access goes through the bridged path and performs forced downcasts.
+    // This is where the odd numeric value is caught.
+    expectCrashLater()
+    for (key, value) in d2 {
+      _ = (key, value)
+    }
   }
-}
 
-DictionaryTraps.test("Downcast.Verbatim")
+  DictionaryTraps.test("Downcast.Verbatim")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
-  let d: Dictionary<NSObject, NSObject> = [ TestObjCKeyTy(10): NSObject(),
-                                            NSObject() : NSObject() ]
-  let d2: Dictionary<TestObjCKeyTy, NSObject> = _dictionaryDownCast(d)
-  expectCrashLater()
-  _ = d2[TestObjCKeyTy(10)]
-  _ = d2[TestObjCKeyTy(20)]
-
-  // This triggers failure.
-  for (_, _) in d2 { }
-}
+    let d: Dictionary<NSObject, NSObject> = [ TestObjCKeyTy(10): NSObject(),
+      NSObject() : NSObject() ]
+    let d2: Dictionary<TestObjCKeyTy, NSObject> = _dictionaryDownCast(d)
+    expectCrashLater()
+    _ = d2[TestObjCKeyTy(10)]
+    _ = d2[TestObjCKeyTy(20)]
+
+    // This triggers failure.
+    for (_, _) in d2 { }
+  }
 
-DictionaryTraps.test("Downcast.NonVerbatimBridged")
+  DictionaryTraps.test("Downcast.NonVerbatimBridged")
   .skip(.custom(
-    { _isFastAssertConfiguration() },
-    reason: "this trap is not guaranteed to happen in -Ounchecked"))
+      { _isFastAssertConfiguration() },
+      reason: "this trap is not guaranteed to happen in -Ounchecked"))
   .crashOutputMatches("Could not cast value of type")
   .code {
-  let d: Dictionary<NSObject, NSObject> = [ TestObjCKeyTy(10): NSObject(),
-                                            NSObject() : NSObject() ]
+    let d: Dictionary<NSObject, NSObject> = [ TestObjCKeyTy(10): NSObject(),
+      NSObject() : NSObject() ]
 
-  expectCrashLater()
-  let d2 = d as! Dictionary<TestBridgedKeyTy, NSObject>
-  _ = d2[TestBridgedKeyTy(10)]
+    expectCrashLater()
+    let d2 = d as! Dictionary<TestBridgedKeyTy, NSObject>
+    _ = d2[TestBridgedKeyTy(10)]
+  }
 }
 
 runAllTests()

validation-test/stdlib/Stride.swift

@@ -9,15 +9,21 @@ var StrideTestSuite = TestSuite("Stride")
 StrideTestSuite.test("to") {
   checkSequence(Array(0...4), stride(from: 0, to: 5, by: 1))
   checkSequence(Array(1...5).reversed(), stride(from: 5, to: 0, by: -1))
-  checkSequence(stride(from: 0, to: 127, by: 3).map { Int8($0) },
-                stride(from: 0, to: 127 as Int8, by: 3))
+  if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
+    // This used to crash before https://github.com/apple/swift/pull/34860
+    checkSequence(stride(from: 0, to: 127, by: 3).map { Int8($0) },
+      stride(from: 0, to: 127 as Int8, by: 3))
+  }
 }
 
 StrideTestSuite.test("through") {
   checkSequence(Array(0...5), stride(from: 0, through: 5, by: 1))
   checkSequence(Array(0...5).reversed(), stride(from: 5, through: 0, by: -1))
-  checkSequence(stride(from: 0, through: 127, by: 3).map { Int8($0) },
-                stride(from: 0, through: 127 as Int8, by: 3))
+  if #available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *) {
+    // This used to crash before https://github.com/apple/swift/pull/34860
+    checkSequence(stride(from: 0, through: 127, by: 3).map { Int8($0) },
+                  stride(from: 0, through: 127 as Int8, by: 3))
+  }
 }
 
 runAllTests()