Merge branch 'master' into rename-conflicting-classes-and-methods

validation-test/stdlib/Bitset.swift

@@ -0,0 +1,157 @@
+// RUN: %target-run-stdlib-swift
+// REQUIRES: executable_test
+
+import StdlibUnittest
+
+var BitsetTests = TestSuite("Bitset")
+
+BitsetTests.test("_UnsafeBitset.wordCount(forCapacity:)") {
+  expectEqual(0, _UnsafeBitset.wordCount(forCapacity: 0))
+#if arch(i386) || arch(arm)
+  for i in 1...32 {
+    expectEqual(1, _UnsafeBitset.wordCount(forCapacity: i), "i=\(i)")
+  }
+  for i in 33...64 {
+    expectEqual(2, _UnsafeBitset.wordCount(forCapacity: i), "i=\(i)")
+  }
+  for i in 65...96 {
+    expectEqual(3, _UnsafeBitset.wordCount(forCapacity: i), "i=\(i)")
+  }
+  for i in 97...128 {
+    expectEqual(4, _UnsafeBitset.wordCount(forCapacity: i), "i=\(i)")
+  }
+#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
+  for i in 1...64 {
+    expectEqual(1, _UnsafeBitset.wordCount(forCapacity: i), "i=\(i)")
+  }
+  for i in 65...128 {
+    expectEqual(2, _UnsafeBitset.wordCount(forCapacity: i), "i=\(i)")
+  }
+  for i in 193...256 {
+    expectEqual(4, _UnsafeBitset.wordCount(forCapacity: i), "i=\(i)")
+  }
+#else
+  _UnimplementedError()
+#endif
+}
+
+BitsetTests.test("_UnsafeBitset.split(_:)") {
+#if arch(i386) || arch(arm)
+  for i in 0...31 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(0, comps.word, "i=\(i)")
+    expectEqual(i, comps.bit, "i=\(i)")
+  }
+  for i in 32...63 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(1, comps.word, "i=\(i)")
+    expectEqual(i - 32, comps.bit, "i=\(i)")
+  }
+  for i in 64...95 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(2, comps.word, "i=\(i)")
+    expectEqual(i - 64, comps.bit, "i=\(i)")
+  }
+  for i in 96...127 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(3, comps.word, "i=\(i)")
+    expectEqual(i - 96, comps.bit, "i=\(i)")
+  }
+#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
+  for i in 0...63 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(0, comps.word, "i=\(i)")
+    expectEqual(i, comps.bit, "i=\(i)")
+  }
+  for i in 64...127 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(1, comps.word, "i=\(i)")
+    expectEqual(i - 64, comps.bit, "i=\(i)")
+  }
+  for i in 128...191 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(2, comps.word, "i=\(i)")
+    expectEqual(i - 128, comps.bit, "i=\(i)")
+  }
+  for i in 192...255 {
+    let comps = _UnsafeBitset.split(i)
+    expectEqual(3, comps.word, "i=\(i)")
+    expectEqual(i - 192, comps.bit, "i=\(i)")
+  }
+#else
+  _UnimplementedError()
+#endif
+}
+
+BitsetTests.test("Word.capacity") {
+  expectEqual(_UnsafeBitset.Word.capacity, UInt.bitWidth)
+}
+
+BitsetTests.test("Word.uncheckedContains(_:)") {
+  typealias Word = _UnsafeBitset.Word
+  for i in 0 ..< Word.capacity {
+    expectEqual(Word(0).uncheckedContains(i), false, "i=\(i)")
+    expectEqual(Word(1).uncheckedContains(i), i == 0, "i=\(i)")
+    expectEqual(Word(2).uncheckedContains(i), i == 1, "i=\(i)")
+    expectEqual(Word(4).uncheckedContains(i), i == 2, "i=\(i)")
+    expectEqual(Word(8).uncheckedContains(i), i == 3, "i=\(i)")
+    expectEqual(Word(15).uncheckedContains(i), i <= 3, "i=\(i)")
+    expectEqual(Word(~1).uncheckedContains(i), i != 0, "i=\(i)")
+    expectEqual(Word(~2).uncheckedContains(i), i != 1, "i=\(i)")
+    expectEqual(Word(~4).uncheckedContains(i), i != 2, "i=\(i)")
+    expectEqual(Word(~8).uncheckedContains(i), i != 3, "i=\(i)")
+    expectEqual(Word(~15).uncheckedContains(i), i > 3, "i=\(i)")
+    expectEqual(Word(UInt.max).uncheckedContains(i), true, "i=\(i)")
+  }
+}
+
+BitsetTests.test("Word.uncheckedInsert(_:)") {
+  typealias Word = _UnsafeBitset.Word
+  var word = Word(0)
+  for i in 0 ..< Word.capacity {
+    expectFalse(word.uncheckedContains(i))
+    expectTrue(word.uncheckedInsert(i))
+    expectTrue(word.uncheckedContains(i))
+    expectFalse(word.uncheckedInsert(i))
+  }
+  expectEqual(word.value, UInt.max)
+}
+
+BitsetTests.test("Word.uncheckedRemove(_:)") {
+  typealias Word = _UnsafeBitset.Word
+  var word = Word(UInt.max)
+  for i in 0 ..< Word.capacity {
+    expectTrue(word.uncheckedContains(i))
+    expectTrue(word.uncheckedRemove(i))
+    expectFalse(word.uncheckedContains(i))
+    expectFalse(word.uncheckedRemove(i))
+  }
+  expectEqual(word.value, 0)
+}
+
+BitsetTests.test("Word.count") {
+  typealias Word = _UnsafeBitset.Word
+  var word = Word(0)
+  for i in 0 ..< Word.capacity {
+    expectEqual(word.count, i)
+    _ = word.uncheckedInsert(i)
+    expectEqual(word.count, i + 1)
+  }
+  for i in 0 ..< Word.capacity {
+    expectEqual(word.count, Word.capacity - i)
+    _ = word.uncheckedRemove(i)
+    expectEqual(word.count, Word.capacity - i - 1)
+  }
+}
+
+BitsetTests.test("Word.makeIterator()") {
+  typealias Word = _UnsafeBitset.Word
+  expectEqual(Array(Word(0)), [])
+  expectEqual(Array(Word(1)), [0])
+  expectEqual(Array(Word(2)), [1])
+  expectEqual(Array(Word(3)), [0, 1])
+  expectEqual(Array(Word(42)), [1, 3, 5])
+  expectEqual(Array(Word(UInt.max)), Array(0..<UInt.bitWidth))
+}
+
+runAllTests()

validation-test/stdlib/Dictionary.swift

@@ -1374,7 +1374,7 @@ DictionaryTestSuite.test("COW.Fast.KeysAccessDoesNotReallocate") {
   { $0 == $1 }
   
   do {
-    let d2: [MinimalHashableValue : Int] = [
+    var d2: [MinimalHashableValue : Int] = [
       MinimalHashableValue(10): 1010,
       MinimalHashableValue(20): 1020,
       MinimalHashableValue(30): 1030,
@@ -1385,6 +1385,8 @@ DictionaryTestSuite.test("COW.Fast.KeysAccessDoesNotReallocate") {
       MinimalHashableValue(80): 1080,
       MinimalHashableValue(90): 1090,
     ]
+    // Make collisions less likely
+    d2.reserveCapacity(1000)
     
     // Find the last key in the dictionary
     var lastKey: MinimalHashableValue = d2.first!.key
@@ -2591,12 +2593,14 @@ DictionaryTestSuite.test("BridgedFromObjC.Nonverbatim.RemoveValueForKey")
 DictionaryTestSuite.test("BridgedFromObjC.Verbatim.RemoveAll") {
   do {
     var d = getBridgedVerbatimDictionary([:])
-    let identity1 = d._rawIdentifier()
     assert(isCocoaDictionary(d))
     assert(d.count == 0)
 
+    let empty = Dictionary<Int, Int>()
+    expectNotEqual(empty._rawIdentifier(), d._rawIdentifier())
+
     d.removeAll()
-    assert(identity1 == d._rawIdentifier())
+    assert(empty._rawIdentifier() == d._rawIdentifier())
     assert(d.count == 0)
   }
 
@@ -2674,12 +2678,14 @@ DictionaryTestSuite.test("BridgedFromObjC.Verbatim.RemoveAll") {
 DictionaryTestSuite.test("BridgedFromObjC.Nonverbatim.RemoveAll") {
   do {
     var d = getBridgedNonverbatimDictionary([:])
-    let identity1 = d._rawIdentifier()
     assert(isNativeDictionary(d))
     assert(d.count == 0)
 
+    let empty = Dictionary<Int, Int>()
+    expectNotEqual(empty._rawIdentifier(), d._rawIdentifier())
+
     d.removeAll()
-    assert(identity1 == d._rawIdentifier())
+    assert(empty._rawIdentifier() == d._rawIdentifier())
     assert(d.count == 0)
   }
 

validation-test/stdlib/Set.swift

@@ -123,7 +123,11 @@ func isNativeSet<T : Hashable>(_ s: Set<T>) -> Bool {
 #if _runtime(_ObjC)
 func isNativeNSSet(_ s: NSSet) -> Bool {
   let className: NSString = NSStringFromClass(type(of: s)) as NSString
-  return ["_SwiftDeferredNSSet", "NativeSetStorage"].contains {
+  return [
+    "_SwiftDeferredNSSet",
+    "_EmptySetSingleton",
+    "_SetStorage"
+  ].contains {
     className.range(of: $0).length > 0
   }
 }
@@ -1791,12 +1795,14 @@ SetTestSuite.test("BridgedFromObjC.Nonverbatim.Remove")
 SetTestSuite.test("BridgedFromObjC.Verbatim.RemoveAll") {
   do {
     var s = getBridgedVerbatimSet([])
-    let identity1 = s._rawIdentifier()
     expectTrue(isCocoaSet(s))
     expectEqual(0, s.count)
 
+    let emptySet = Set<Int>()
+    expectNotEqual(emptySet._rawIdentifier(), s._rawIdentifier())
+
     s.removeAll()
-    expectEqual(identity1, s._rawIdentifier())
+    expectEqual(emptySet._rawIdentifier(), s._rawIdentifier())
     expectEqual(0, s.count)
   }
 
@@ -1853,12 +1859,14 @@ SetTestSuite.test("BridgedFromObjC.Verbatim.RemoveAll") {
 SetTestSuite.test("BridgedFromObjC.Nonverbatim.RemoveAll") {
   do {
     var s = getBridgedNonverbatimSet([])
-    let identity1 = s._rawIdentifier()
     expectTrue(isNativeSet(s))
     expectEqual(0, s.count)
 
+    let emptySet = Set<Int>()
+    expectNotEqual(emptySet._rawIdentifier(), s._rawIdentifier())
+
     s.removeAll()
-    expectEqual(identity1, s._rawIdentifier())
+    expectEqual(emptySet._rawIdentifier(), s._rawIdentifier())
     expectEqual(0, s.count)
   }
 
@@ -3070,6 +3078,7 @@ SetTestSuite.test("formSymmetricDifference")
   .code {
   // Overlap with 4040, 5050, 6060
   var s1 = Set([1010, 2020, 3030, 4040, 5050, 6060])
+  let s1_copy = s1
   let s2 = Set([1010])
   let result = Set([2020, 3030, 4040, 5050, 6060])
 
@@ -3077,10 +3086,11 @@ SetTestSuite.test("formSymmetricDifference")
   let identity1 = s1._rawIdentifier()
   s1.formSymmetricDifference(s2)
 
-  // Removing just one element shouldn't cause an identity change
-  expectEqual(identity1, s1._rawIdentifier())
+  // COW should trigger a copy
+  expectNotEqual(identity1, s1._rawIdentifier())
 
   expectEqual(s1, result)
+  expectEqual(s1_copy, Set([1010, 2020, 3030, 4040, 5050, 6060]))
 
   // A ⨁ A == {}
   s1.formSymmetricDifference(s1)

validation-test/stdlib/UnsafeBitMap.swift

@@ -1,124 +0,0 @@
-// RUN: %target-run-stdlib-swift
-// REQUIRES: executable_test
-
-import StdlibUnittest
-
-var UnsafeBitMapTests = TestSuite("UnsafeBitMap")
-
-UnsafeBitMapTests.test("wordIndex(_:), bitIndex(_:)") {
-#if arch(i386) || arch(arm)
-  for i in 0...31 {
-    expectEqual(0, _UnsafeBitMap.wordIndex(i), "i=\(i)")
-    expectEqual(i, Int(_UnsafeBitMap.bitIndex(i)), "i=\(i)")
-  }
-  for i in 32...63 {
-    expectEqual(1, _UnsafeBitMap.wordIndex(i), "i=\(i)")
-    expectEqual(i - 32, Int(_UnsafeBitMap.bitIndex(i)), "i=\(i)")
-  }
-  for i in 64...95 {
-    expectEqual(2, _UnsafeBitMap.wordIndex(i), "i=\(i)")
-    expectEqual(i - 64, Int(_UnsafeBitMap.bitIndex(i)), "i=\(i)")
-  }
-  for i in 96...127 {
-    expectEqual(3, _UnsafeBitMap.wordIndex(i), "i=\(i)")
-    expectEqual(i - 96, Int(_UnsafeBitMap.bitIndex(i)), "i=\(i)")
-  }
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
-  for i in 0...63 {
-    expectEqual(0, _UnsafeBitMap.wordIndex(i), "i=\(i)")
-    expectEqual(i, Int(_UnsafeBitMap.bitIndex(i)), "i=\(i)")
-  }
-  for i in 64...127 {
-    expectEqual(1, _UnsafeBitMap.wordIndex(i), "i=\(i)")
-    expectEqual(i - 64, Int(_UnsafeBitMap.bitIndex(i)), "i=\(i)")
-  }
-  for i in 192...255 {
-    expectEqual(3, _UnsafeBitMap.wordIndex(i), "i=\(i)")
-    expectEqual(i - 192, Int(_UnsafeBitMap.bitIndex(i)), "i=\(i)")
-  }
-#else
-  _UnimplementedError()
-#endif
-}
-
-UnsafeBitMapTests.test("sizeInWords(forSizeInBits:)") {
-  expectEqual(0, _UnsafeBitMap.sizeInWords(forSizeInBits: 0))
-#if arch(i386) || arch(arm)
-  for i in 1...32 {
-    expectEqual(1, _UnsafeBitMap.sizeInWords(forSizeInBits: i), "i=\(i)")
-  }
-  for i in 33...64 {
-    expectEqual(2, _UnsafeBitMap.sizeInWords(forSizeInBits: i), "i=\(i)")
-  }
-  for i in 65...96 {
-    expectEqual(3, _UnsafeBitMap.sizeInWords(forSizeInBits: i), "i=\(i)")
-  }
-  for i in 97...128 {
-    expectEqual(4, _UnsafeBitMap.sizeInWords(forSizeInBits: i), "i=\(i)")
-  }
-#elseif arch(x86_64) || arch(arm64) || arch(powerpc64) || arch(powerpc64le) || arch(s390x)
-  for i in 1...64 {
-    expectEqual(1, _UnsafeBitMap.sizeInWords(forSizeInBits: i), "i=\(i)")
-  }
-  for i in 65...128 {
-    expectEqual(2, _UnsafeBitMap.sizeInWords(forSizeInBits: i), "i=\(i)")
-  }
-  for i in 193...256 {
-    expectEqual(4, _UnsafeBitMap.sizeInWords(forSizeInBits: i), "i=\(i)")
-  }
-#else
-  _UnimplementedError()
-#endif
-}
-
-let sizes = [
-  0, 1, 2, 3, 7, 8, 9, 31, 32, 33, 48, 63, 64, 65, 127, 128, 129, 1024, 10000
-]
-
-func make(sizeInBits: Int) -> _UnsafeBitMap {
-  let sizeInWords = _UnsafeBitMap.sizeInWords(forSizeInBits: sizeInBits)
-  let storage = UnsafeMutablePointer<UInt>.allocate(capacity: sizeInWords)
-  let bitMap = _UnsafeBitMap(storage: storage, bitCount: sizeInBits)
-  expectEqual(sizeInWords, bitMap.numberOfWords)
-  return bitMap
-}
-
-UnsafeBitMapTests.test("initializeToZero()")
-  .forEach(in: sizes) {
-  sizeInBits in
-  let bitMap = make(sizeInBits: sizeInBits)
-  defer { bitMap.values.deallocate() }
-
-  bitMap.initializeToZero()
-  for i in 0..<sizeInBits {
-    expectEqual(false, bitMap[i])
-  }
-}
-
-UnsafeBitMapTests.test("subscript")
-  .forEach(in: sizes) {
-  sizeInBits in
-  let bitMap = make(sizeInBits: sizeInBits)
-  defer { bitMap.values.deallocate() }
-
-  if sizeInBits != 0 {
-    bitMap.initializeToZero()
-    let index = 7882627 % sizeInBits
-    bitMap[index] = true
-    for i in 0..<sizeInBits {
-      expectEqual(i == index, bitMap[i])
-    }
-  }
-
-  if sizeInBits < 500 {
-    for i in 0..<sizeInBits {
-      bitMap.initializeToZero()
-      bitMap[i] = true
-      for j in 0..<sizeInBits {
-        expectEqual(i == j, bitMap[j])
-      }
-    }
-  }
-}
-
-runAllTests()