[test] new stdlib load/store behaviours

Author: glessard

test/stdlib/UnsafeRawBufferPointer.swift

@@ -498,6 +498,47 @@ UnsafeRawBufferPointerTestSuite.test("load.after")
   }
 }
 
+UnsafeRawBufferPointerTestSuite.test("load.aligned") {
+  var data: [UInt8] = [0, 0, 0, 0, .max, .max, .max, .max]
+  data.withUnsafeBytes {
+    let x = $0.load(fromByteOffset: 4, as: UInt32.self)
+    expectEqual(x, .max)
+  }
+  data.withUnsafeMutableBytes {
+    let x = $0.load(fromByteOffset: 0, as: UInt32.self)
+    expectEqual(x, 0)
+  }
+}
+
+UnsafeRawBufferPointerTestSuite.test("load.invalid")
+.skip(.custom({ !_isDebugAssertConfiguration() }, // require debugAssert
+              reason: "This tests a debug precondition.."))
+.code {
+  let data: [UInt8] = [0, 0, 0, .max, .max, .max, .max, 0]
+  let i = data.firstIndex(of: .max)!
+  expectCrashLater()
+  _ = data.withUnsafeBytes {
+    $0.load(fromByteOffset: i, as: UInt32.self)
+  }
+}
+
+UnsafeRawBufferPointerTestSuite.test("load.unaligned")
+.skip(.custom({ // require SwiftStdlib 5.7
+  if #available(SwiftStdlib 5.7, *) { return false } else { return true }
+}, reason: "Requires stdlib from Swift 5.7"))
+.code {
+  var data: [UInt8] = [0, 0, 0, .max, .max, .max, .max, 0]
+  let i = data.firstIndex(of: .max)!
+  data.withUnsafeBytes {
+    let x = $0.loadUnaligned(fromByteOffset: i, as: UInt32.self)
+    expectEqual(x, .max)
+  }
+  data.withUnsafeMutableBytes {
+    let x = $0.loadUnaligned(fromByteOffset: i-1, as: UInt32.self)
+    expectEqual(UInt32(littleEndian: x), 0xffffff00)
+  }
+}
+
 UnsafeRawBufferPointerTestSuite.test("store.before")
 .skip(.custom(
     { !_isDebugAssertConfiguration() },
@@ -521,6 +562,33 @@ UnsafeRawBufferPointerTestSuite.test("store.after")
   }
 }
 
+UnsafeRawBufferPointerTestSuite.test("store.invalid")
+.skip(.custom({ !_isDebugAssertConfiguration() }, // require debugAssert
+              reason: "This tests a debug precondition.."))
+.skip(.custom({ // require SwiftStdlib 5.7
+  if #available(SwiftStdlib 5.7, *) { return false } else { return true }
+}, reason: "Requires stdlib from Swift 5.7"))
+.code {
+  let t = "Text that is longer than fits in a small String."
+  let p1 = UnsafeMutableRawPointer.allocate(
+    byteCount: MemoryLayout<String>.size,
+    alignment: MemoryLayout<String>.alignment
+  )
+  defer { p1.deallocate() }
+  expectCrashLater()
+  p1.storeBytes(of: t, as: String.self)
+  expectUnreachable()
+}
+
+UnsafeRawBufferPointerTestSuite.test("store.valid") {
+  let value32 = UInt32.max
+  var value64 = Int64.zero
+  withUnsafeMutableBytes(of: &value64) {
+    $0.storeBytes(of: value32, toByteOffset: MemoryLayout<UInt32>.stride, as: UInt32.self)
+  }
+  expectEqual(value64, 0xffffffff << 32)
+}
+
 UnsafeRawBufferPointerTestSuite.test("copy.bytes.overflow")
 .skip(.custom(
     { !_isDebugAssertConfiguration() },

test/stdlib/UnsafeRawPointer.swift

@@ -94,6 +94,69 @@ UnsafeMutableRawPointerExtraTestSuite.test("load/store") {
   expectEqual(6, p1.load(fromByteOffset: 2 * MemoryLayout<Int>.stride, as: Int.self))
 }
 
+UnsafeMutableRawPointerExtraTestSuite.test("load.unaligned")
+.skip(.custom({
+  if #available(SwiftStdlib 5.7, *) { return false }
+  return true
+}, reason: "Requires Swift 5.7's stdlib"))
+.code {
+  var data: [UInt8] = [0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0]
+  var result: UInt32
+  result = data.withUnsafeBytes {
+    $0.loadUnaligned(fromByteOffset: 3, as: UInt32.self)
+  }
+  expectEqual(result, 0xffff_ffff)
+  result = data.withUnsafeMutableBytes {
+    $0[0] = 0
+    return $0.loadUnaligned(fromByteOffset: 1, as: UInt32.self)
+  }
+  expectEqual(result, 0xffff_0000)
+}
+
+UnsafeMutableRawPointerExtraTestSuite.test("load.invalid")
+.skip(.custom({ !_isDebugAssertConfiguration() },
+              reason: "This tests a debug precondition.."))
+.code {
+  let data: [UInt8] = [0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0]
+  expectCrashLater()
+  _ = data.withUnsafeBytes {
+    $0.load(fromByteOffset: 3, as: UInt32.self)
+  }
+  expectUnreachable()
+}
+
+UnsafeMutableRawPointerExtraTestSuite.test("load.invalid.mutable")
+.skip(.custom({ !_isDebugAssertConfiguration() },
+              reason: "This tests a debug precondition.."))
+.code {
+  var data: [UInt8] = [0x0, 0x0, 0x0, 0xff, 0xff, 0xff, 0xff, 0x0]
+  expectCrashLater()
+  _ = data.withUnsafeMutableBytes {
+    $0.load(fromByteOffset: 1, as: UInt32.self)
+  }
+  expectUnreachable()
+}
+
+UnsafeMutableRawPointerExtraTestSuite.test("store.invalid")
+.skip(.custom({ !_isDebugAssertConfiguration() },
+              reason: "This tests a debug precondition.."))
+.skip(.custom({
+  if #available(SwiftStdlib 5.7, *) { return false }
+  return true
+}, reason: "Requires Swift 5.7's stdlib"))
+.code {
+  Missile.missilesLaunched = 0
+  let m = Missile(0)
+  let p1 = UnsafeMutableRawPointer.allocate(
+    byteCount: MemoryLayout<Missile>.size,
+    alignment: MemoryLayout<Missile>.alignment
+  )
+  defer { p1.deallocate() }
+  expectCrashLater()
+  p1.storeBytes(of: m, as: Missile.self)
+  expectUnreachable()
+}
+
 UnsafeMutableRawPointerExtraTestSuite.test("copyMemory") {
   let sizeInBytes = 4 * MemoryLayout<Int>.stride
   let rawPtr = UnsafeMutableRawPointer.allocate(