stdlib: add basic tests for _UnsafeBitMap

Author: gribozavr

stdlib/public/core/UnsafeBitMap.swift

@@ -11,40 +11,51 @@
 //===----------------------------------------------------------------------===//
 
 /// A wrapper around a bitmap storage with room for at least `bitCount` bits.
-internal struct _UnsafeBitMap {
-  internal let values: UnsafeMutablePointer<UInt>
-  internal let bitCount: Int
+public // @testable
+struct _UnsafeBitMap {
+  public // @testable
+  let values: UnsafeMutablePointer<UInt>
 
-  internal static func wordIndex(_ i: Int) -> Int {
+  public // @testable
+  let bitCount: Int
+
+  public // @testable
+  static func wordIndex(_ i: Int) -> Int {
     // Note: We perform the operation on UInts to get faster unsigned math
     // (shifts).
     return Int(bitPattern: UInt(bitPattern: i) / UInt(UInt._sizeInBits))
   }
 
-  internal static func bitIndex(_ i: Int) -> UInt {
+  public // @testable
+  static func bitIndex(_ i: Int) -> UInt {
     // Note: We perform the operation on UInts to get faster unsigned math
     // (shifts).
     return UInt(bitPattern: i) % UInt(UInt._sizeInBits)
   }
 
-  internal static func sizeInWords(forSizeInBits bitCount: Int) -> Int {
+  public // @testable
+  static func sizeInWords(forSizeInBits bitCount: Int) -> Int {
     return bitCount + Int._sizeInBytes - 1 / Int._sizeInBytes
   }
 
-  internal init(storage: UnsafeMutablePointer<UInt>, bitCount: Int) {
+  public // @testable
+  init(storage: UnsafeMutablePointer<UInt>, bitCount: Int) {
     self.bitCount = bitCount
     self.values = storage
   }
 
-  internal var numberOfWords: Int {
+  public // @testable
+  var numberOfWords: Int {
     return _UnsafeBitMap.sizeInWords(forSizeInBits: bitCount)
   }
 
-  internal func initializeToZero() {
+  public // @testable
+  func initializeToZero() {
     values.initialize(with: 0, count: numberOfWords)
   }
 
-  internal subscript(i: Int) -> Bool {
+  public // @testable
+  subscript(i: Int) -> Bool {
     get {
       _sanityCheck(i < Int(bitCount) && i >= 0, "index out of bounds")
       let word = values[_UnsafeBitMap.wordIndex(i)]

validation-test/stdlib/UnsafeBitMap.swift

@@ -0,0 +1,126 @@
+// RUN: %target-run-simple-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)
+  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:)")
+  .xfail(.always("the API is buggy")).code {
+  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)
+  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>(allocatingCapacity: 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.deallocateCapacity(bitMap.numberOfWords) }
+
+  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.deallocateCapacity(bitMap.numberOfWords) }
+
+  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()
+