Make tests work on 32-bit

Sources/NIO/ByteBuffer-core.swift

@@ -231,7 +231,7 @@ public struct ByteBuffer {
         }
 
         private static func allocateAndPrepareRawMemory(bytes: Capacity, allocator: Allocator) -> UnsafeMutableRawPointer {
-            let bytes = Int(bytes)
+            let bytes = Int(bytes) /* Note(hh): this can fail on 32-bit (Int32 vs UInt32 Capacity)) */
             let ptr = allocator.malloc(bytes)!
             /* bind the memory so we can assume it elsewhere to be bound to UInt8 */
             ptr.bindMemory(to: UInt8.self, capacity: bytes)
@@ -332,7 +332,7 @@ public struct ByteBuffer {
                 self._slice = _ByteBufferSlice(_slice.lowerBound ..< self._storage.capacity)
             }
         }
-        assert(self._slice.lowerBound + index + capacity <= self._slice.upperBound)
+        assert(self._slice.lowerBound + index + capacity <= self._slice.upperBound) // TODO(hh): fails on 32-bit
         assert(self._slice.lowerBound >= 0, "illegal slice: negative lower bound: \(self._slice.lowerBound)")
         assert(self._slice.upperBound <= self._storage.capacity, "illegal slice: upper bound (\(self._slice.upperBound)) exceeds capacity: \(self._storage.capacity)")
     }

Sources/NIO/ByteBuffer-int.swift

@@ -113,13 +113,19 @@ extension UInt32 {
 
         var n = self
 
+        #if arch(arm) // 32-bit, Raspi/AppleWatch/etc
+            let max = UInt32(Int32.max)
+        #else
+            let max = UInt32.max
+        #endif
+
         n -= 1
         n |= n >> 1
         n |= n >> 2
         n |= n >> 4
         n |= n >> 8
         n |= n >> 16
-        if n != .max {
+        if n != max {
             n += 1
         }
 

Sources/NIO/Socket.swift

@@ -20,7 +20,14 @@ public typealias IOVector = iovec
 
     /// The maximum number of bytes to write per `writev` call.
     static var writevLimitBytes: Int {
-        return Int(Int32.max)
+        #if arch(arm) // 32-bit, Raspi/AppleWatch/etc
+            // Note(hh): This is not a _proper_ fix, but necessary because
+            //           other places extend on that. Should be fine in
+            //           practice on 32-bit platforms.
+            return Int(Int32.max / 4)
+        #else
+            return Int(Int32.max)
+        #endif
     }
 
     /// The maximum number of `IOVector`s to write per `writev` call.

Sources/NIOWebSocket/WebSocketFrameEncoder.swift

@@ -16,7 +16,14 @@ import NIO
 
 private let maxOneByteSize = 125
 private let maxTwoByteSize = Int(UInt16.max)
-private let maxNIOFrameSize = Int(UInt32.max)
+#if arch(arm) // 32-bit, Raspi/AppleWatch/etc
+    // Note(hh): This is not a _proper_ fix, but necessary because
+    //           other places extend on that. Should be fine in
+    //           practice on 32-bit platforms.
+    private let maxNIOFrameSize = Int(Int32.max / 4)
+#else
+    private let maxNIOFrameSize = Int(UInt32.max)
+#endif
 
 /// An inbound `ChannelHandler` that serializes structured websocket frames into a byte stream
 /// for sending on the network.

Tests/NIOTests/ByteBufferTest.swift

@@ -1073,22 +1073,37 @@ class ByteBufferTest: XCTestCase {
     }
 
     func testAllocationOfReallyBigByteBuffer() throws {
+        #if !arch(arm) // !32-bit, Raspi/AppleWatch/etc
         let alloc = ByteBufferAllocator(hookedMalloc: { testAllocationOfReallyBigByteBuffer_mallocHook($0) },
                                         hookedRealloc: { testAllocationOfReallyBigByteBuffer_reallocHook($0, $1) },
                                         hookedFree: { testAllocationOfReallyBigByteBuffer_freeHook($0) },
                                         hookedMemcpy: { testAllocationOfReallyBigByteBuffer_memcpyHook($0, $1, $2) })
 
+        #if arch(arm) // 32-bit, Raspi/AppleWatch/etc
+            let reallyBigSize = Int(Int16.max) // well, but Int32 is too big (1GB RAM, no swap)
+        #else
+            let reallyBigSize = Int(Int32.max)
+        #endif
         XCTAssertEqual(AllocationExpectationState.begin, testAllocationOfReallyBigByteBuffer_state)
-        var buf = alloc.buffer(capacity: Int(Int32.max))
+        var buf = alloc.buffer(capacity: reallyBigSize)
         XCTAssertEqual(AllocationExpectationState.mallocDone, testAllocationOfReallyBigByteBuffer_state)
-        XCTAssertGreaterThanOrEqual(buf.capacity, Int(Int32.max))
+        XCTAssertGreaterThanOrEqual(buf.capacity, reallyBigSize)
 
         buf.set(bytes: [1], at: 0)
         /* now make it expand (will trigger realloc) */
         buf.set(bytes: [1], at: buf.capacity)
 
         XCTAssertEqual(AllocationExpectationState.reallocDone, testAllocationOfReallyBigByteBuffer_state)
-        XCTAssertEqual(buf.capacity, Int(UInt32.max))
+        #if arch(arm) // 32-bit, Raspi/AppleWatch/etc
+            // TODO(hh): no idea, but not UInt32.max :-)
+            XCTAssertGreaterThanOrEqual(buf.capacity, reallyBigSize)
+        #else
+            XCTAssertEqual(buf.capacity, Int(UInt32.max))
+        #endif
+        #else
+            // fails hard on Raspi
+            XCTAssertTrue(false, "testAllocationOfReallyBigByteBuffer fails on 32-bit Raspi")
+        #endif
     }
 
     func testWritableBytesAccountsForSlicing() throws {

Tests/NIOTests/ChannelTests.swift

@@ -169,9 +169,15 @@ public class ChannelTests: XCTestCase {
         for _ in 0..<bufferSize {
             buffer.write(staticString: "a")
         }
+
 
+        #if arch(arm) // 32-bit, Raspi/AppleWatch/etc
+            let lotsOfData = Int(Int32.max / 8)
+        #else
+            let lotsOfData = Int(INT32_MAX) // TBD(hh): should that be Int32.max?
+        #endif
         var written = 0
-        while written <= Int(INT32_MAX) {
+        while written <= lotsOfData {
             clientChannel.write(NIOAny(buffer), promise: nil)
             written += bufferSize
         }
@@ -220,7 +226,7 @@ public class ChannelTests: XCTestCase {
             var iovecs: [IOVector] = Array(repeating: iovec(), count: Socket.writevLimitIOVectors + 1)
             var managed: [Unmanaged<AnyObject>] = Array(repeating: Unmanaged.passUnretained(o), count: Socket.writevLimitIOVectors + 1)
             /* put a canary value at the end */
-            iovecs[iovecs.count - 1] = iovec(iov_base: UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)!, iov_len: 0xdeadbeef)
+            iovecs[iovecs.count - 1] = iovec(iov_base: UnsafeMutableRawPointer(bitPattern: 0x1337beef)!, iov_len: 0x1337beef)
             try iovecs.withUnsafeMutableBufferPointer { iovecs in
                 try managed.withUnsafeMutableBufferPointer { managed in
                     let pwm = NIO.PendingStreamWritesManager(iovecs: iovecs, storageRefs: managed)
@@ -237,8 +243,8 @@ public class ChannelTests: XCTestCase {
             }
             /* assert that the canary values are still okay, we should definitely have never written those */
             XCTAssertEqual(managed.last!.toOpaque(), Unmanaged.passUnretained(o).toOpaque())
-            XCTAssertEqual(0xdeadbeef, Int(bitPattern: iovecs.last!.iov_base))
-            XCTAssertEqual(0xdeadbeef, iovecs.last!.iov_len)
+            XCTAssertEqual(0x1337beef, Int(bitPattern: iovecs.last!.iov_base))
+            XCTAssertEqual(0x1337beef, iovecs.last!.iov_len)
         }
     }
 
@@ -676,8 +682,8 @@ public class ChannelTests: XCTestCase {
     /// Test that with a few massive buffers, we don't offer more than we should to `writev` if the individual chunks fit.
     func testPendingWritesNoMoreThanWritevLimitIsWritten() throws {
         let el = EmbeddedEventLoop()
-        let alloc = ByteBufferAllocator(hookedMalloc: { _ in UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
-                                        hookedRealloc: { _, _ in UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
+        let alloc = ByteBufferAllocator(hookedMalloc: { _ in UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
+                                        hookedRealloc: { _, _ in UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
                                         hookedFree: { _ in },
                                         hookedMemcpy: { _, _, _ in })
         /* each buffer is half the writev limit */
@@ -708,8 +714,8 @@ public class ChannelTests: XCTestCase {
     /// Test that with a massive buffers (bigger than writev size), we don't offer more than we should to `writev`.
     func testPendingWritesNoMoreThanWritevLimitIsWrittenInOneMassiveChunk() throws {
         let el = EmbeddedEventLoop()
-        let alloc = ByteBufferAllocator(hookedMalloc: { _ in UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
-                                        hookedRealloc: { _, _ in UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
+        let alloc = ByteBufferAllocator(hookedMalloc: { _ in UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
+                                        hookedRealloc: { _, _ in UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
                                         hookedFree: { _ in },
                                         hookedMemcpy: { _, _, _ in })
         /* each buffer is half the writev limit */

Tests/NIOTests/DatagramChannelTests.swift

@@ -244,8 +244,13 @@ final class DatagramChannelTests: XCTestCase {
             }
             let envelope = AddressedEnvelope(remoteAddress: self.secondChannel.localAddress!, data: buffer)
 
+            #if arch(arm) // 32-bit, Raspi/AppleWatch/etc
+                let lotsOfData = Int(Int32.max / 8)
+            #else
+                let lotsOfData = Int(INT32_MAX) // TBD(hh): should that be Int32.max?
+            #endif
             var written = 0
-            while written <= Int(INT32_MAX) {
+            while written <= lotsOfData {
                 self.firstChannel.write(NIOAny(envelope), promise: myPromise)
                 overall = EventLoopFuture<Void>.andAll([overall, myPromise.futureResult], eventLoop: self.firstChannel.eventLoop)
                 written += bufferSize

Tests/NIOTests/EmbeddedEventLoopTest.swift

@@ -110,7 +110,7 @@ public class EmbeddedEventLoopTest: XCTestCase {
         var sentinel = 0
         let loop = EmbeddedEventLoop()
         for index in 1...10 {
-            _ = loop.scheduleTask(in: .nanoseconds(index)) {
+            _ = loop.scheduleTask(in: .nanoseconds(TimeAmount.Value(index))) {
                 sentinel = index
             }
         }

Tests/NIOTests/PendingDatagramWritesManagerTests.swift

@@ -62,7 +62,7 @@ class PendingDatagramWritesManagerTests: XCTestCase {
             var msgs: [MMsgHdr] = Array(repeating: MMsgHdr(), count: Socket.writevLimitIOVectors + 1)
             var addresses: [sockaddr_storage] = Array(repeating: sockaddr_storage(), count: Socket.writevLimitIOVectors + 1)
             /* put a canary value at the end */
-            iovecs[iovecs.count - 1] = iovec(iov_base: UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)!, iov_len: 0xdeadbeef)
+            iovecs[iovecs.count - 1] = iovec(iov_base: UnsafeMutableRawPointer(bitPattern: 0x1337beef)!, iov_len: 0x1337beef)
             try iovecs.withUnsafeMutableBufferPointer { iovecs in
                 try managed.withUnsafeMutableBufferPointer { managed in
                     try msgs.withUnsafeMutableBufferPointer { msgs in
@@ -83,8 +83,8 @@ class PendingDatagramWritesManagerTests: XCTestCase {
             }
             /* assert that the canary values are still okay, we should definitely have never written those */
             XCTAssertEqual(managed.last!.toOpaque(), Unmanaged.passUnretained(o).toOpaque())
-            XCTAssertEqual(0xdeadbeef, Int(bitPattern: iovecs.last!.iov_base))
-            XCTAssertEqual(0xdeadbeef, iovecs.last!.iov_len)
+            XCTAssertEqual(0x1337beef, Int(bitPattern: iovecs.last!.iov_base))
+            XCTAssertEqual(0x1337beef, iovecs.last!.iov_len)
         }
     }
 
@@ -433,8 +433,8 @@ class PendingDatagramWritesManagerTests: XCTestCase {
     /// Test that with a few massive buffers, we don't offer more than we should to `writev` if the individual chunks fit.
     func testPendingWritesNoMoreThanWritevLimitIsWritten() throws {
         let el = EmbeddedEventLoop()
-        let alloc = ByteBufferAllocator(hookedMalloc: { _ in return UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
-                                        hookedRealloc: { _, _ in return UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
+        let alloc = ByteBufferAllocator(hookedMalloc: { _ in return UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
+                                        hookedRealloc: { _, _ in return UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
                                         hookedFree: { _ in },
                                         hookedMemcpy: { _, _, _ in })
         /* each buffer is half the writev limit */
@@ -466,8 +466,8 @@ class PendingDatagramWritesManagerTests: XCTestCase {
     func testPendingWritesNoMoreThanWritevLimitIsWrittenInOneMassiveChunk() throws {
         let el = EmbeddedEventLoop()
         let address = try SocketAddress(ipAddress: "127.0.0.1", port: 65535)
-        let alloc = ByteBufferAllocator(hookedMalloc: { _ in return UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
-                                        hookedRealloc: { _, _ in return UnsafeMutableRawPointer(bitPattern: 0xdeadbeef)! },
+        let alloc = ByteBufferAllocator(hookedMalloc: { _ in return UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
+                                        hookedRealloc: { _, _ in return UnsafeMutableRawPointer(bitPattern: 0x1337beef)! },
                                         hookedFree: { _ in },
                                         hookedMemcpy: { _, _, _ in })
         /* each buffer is half the writev limit */

Tests/NIOTests/SystemCallWrapperHelpers.swift

@@ -72,7 +72,7 @@ func runSystemCallWrapperPerformanceTest(testAssertFunction: (@autoclosure () ->
     }
 
     let iterations = isDebugMode ? 100_000 : 1_000_000
-    let pointer = UnsafePointer<UInt8>(bitPattern: 0xdeadbeef)!
+    let pointer = UnsafePointer<UInt8>(bitPattern: 0x1337beef)!
 
     let directCallTime = try measureRunTime { () -> Int in
         /* imitate what the system call wrappers do to have a fair comparison */