Add per-source-file tests for authoritative Binary64 and Binary32 implementations

Completes 1:1 test file mapping following INCITS 4-1986 pattern:
- IEEE_754.Binary64 Tests.swift: Tests for authoritative Binary64 implementation
- IEEE_754.Binary32 Tests.swift: Tests for authoritative Binary32 implementation

Each file tests:
- Constants (byteSize, bitSize, exponentBits, significandBits, exponentBias, maxExponent)
- Authoritative serialization (bytes(from:endianness:))
- Authoritative deserialization (value(from:endianness:))
- Special values (NaN, ±0 with sign preservation)
- Byte count validation
- Endianness handling

Tests increased from 48 to 80 across 22 suites. All tests passing.

Author: coenttb

Tests/IEEE_754 Tests/IEEE_754.Binary32 Tests.swift

@@ -0,0 +1,151 @@
+// IEEE_754.Binary32 Tests.swift
+// swift-ieee-754
+//
+// Tests for IEEE 754 Binary32 (authoritative implementation)
+
+import Testing
+@testable import IEEE_754
+
+@Suite("IEEE_754.Binary32 - Constants")
+struct Binary32ConstantsTests {
+    @Test func `byte size is 4`() {
+        #expect(IEEE_754.Binary32.byteSize == 4)
+    }
+
+    @Test func `bit size is 32`() {
+        #expect(IEEE_754.Binary32.bitSize == 32)
+    }
+
+    @Test func `sign bits is 1`() {
+        #expect(IEEE_754.Binary32.signBits == 1)
+    }
+
+    @Test func `exponent bits is 8`() {
+        #expect(IEEE_754.Binary32.exponentBits == 8)
+    }
+
+    @Test func `significand bits is 23`() {
+        #expect(IEEE_754.Binary32.significandBits == 23)
+    }
+
+    @Test func `exponent bias is 127`() {
+        #expect(IEEE_754.Binary32.exponentBias == 127)
+    }
+
+    @Test func `max exponent is 255`() {
+        #expect(IEEE_754.Binary32.maxExponent == 255)
+    }
+
+    @Test func `bit layout sums to 32`() {
+        let total = IEEE_754.Binary32.signBits +
+                   IEEE_754.Binary32.exponentBits +
+                   IEEE_754.Binary32.significandBits
+        #expect(total == 32, "Sign + exponent + significand bits should equal 32")
+    }
+}
+
+@Suite("IEEE_754.Binary32 - Authoritative serialization")
+struct Binary32SerializationTests {
+    @Test(arguments: [
+        Float(3.14159),
+        Float(2.71828),
+        Float(1.41421),
+        Float(0.0),
+        Float(-0.0),
+        Float(1.0),
+        Float(-1.0),
+        Float.infinity,
+        -Float.infinity,
+        Float.pi,
+    ])
+    func `bytes(from:) produces correct byte count`(value: Float) {
+        let bytes = IEEE_754.Binary32.bytes(from: value)
+        #expect(bytes.count == 4, "Binary32 should always produce 4 bytes")
+    }
+
+    @Test(arguments: [Float(3.14), Float(2.718), Float(1.414), Float(42.0)])
+    func `bytes(from:) with different endianness`(value: Float) {
+        let little = IEEE_754.Binary32.bytes(from: value, endianness: .little)
+        let big = IEEE_754.Binary32.bytes(from: value, endianness: .big)
+
+        #expect(little.count == 4, "Little endian should produce 4 bytes")
+        #expect(big.count == 4, "Big endian should produce 4 bytes")
+        #expect(little != big, "Different endianness should produce different byte order")
+        #expect(little == big.reversed(), "Big endian should be reverse of little")
+    }
+}
+
+@Suite("IEEE_754.Binary32 - Authoritative deserialization")
+struct Binary32DeserializationTests {
+    @Test(arguments: [
+        Float(3.14159),
+        Float(2.71828),
+        Float(1.41421),
+        Float(0.0),
+        Float(1.0),
+        Float(-1.0),
+        Float.infinity,
+        -Float.infinity,
+    ])
+    func `value(from:) round-trip`(original: Float) {
+        let bytes = IEEE_754.Binary32.bytes(from: original)
+        let restored = IEEE_754.Binary32.value(from: bytes)
+
+        #expect(restored == original, "\(original) should round-trip through Binary32")
+    }
+
+    @Test func `value(from:) with wrong byte count returns nil`() {
+        #expect(IEEE_754.Binary32.value(from: []) == nil, "Empty array should return nil")
+        #expect(IEEE_754.Binary32.value(from: [UInt8](repeating: 0, count: 3)) == nil, "3 bytes should return nil")
+        #expect(IEEE_754.Binary32.value(from: [UInt8](repeating: 0, count: 5)) == nil, "5 bytes should return nil")
+    }
+
+    @Test func `value(from:) with exactly 4 bytes succeeds`() {
+        let bytes = [UInt8](repeating: 0, count: 4)
+        let result = IEEE_754.Binary32.value(from: bytes)
+
+        #expect(result != nil, "4 bytes should succeed")
+        #expect(result == 0.0, "All-zero bytes should decode to 0.0")
+    }
+
+    @Test(arguments: [Float(3.14), Float(2.718), Float(1.414)])
+    func `value(from:) respects endianness`(value: Float) {
+        let littleBytes = IEEE_754.Binary32.bytes(from: value, endianness: .little)
+        let bigBytes = IEEE_754.Binary32.bytes(from: value, endianness: .big)
+
+        let fromLittle = IEEE_754.Binary32.value(from: littleBytes, endianness: .little)
+        let fromBig = IEEE_754.Binary32.value(from: bigBytes, endianness: .big)
+
+        #expect(fromLittle == value, "Little endian round-trip should work")
+        #expect(fromBig == value, "Big endian round-trip should work")
+
+        // Mismatched endianness should fail
+        let wrongLittle = IEEE_754.Binary32.value(from: bigBytes, endianness: .little)
+        let wrongBig = IEEE_754.Binary32.value(from: littleBytes, endianness: .big)
+
+        #expect(wrongLittle != value, "Mismatched endianness should fail")
+        #expect(wrongBig != value, "Mismatched endianness should fail")
+    }
+}
+
+@Suite("IEEE_754.Binary32 - Special values")
+struct Binary32SpecialValuesTests {
+    @Test func `NaN round-trip`() {
+        let nan = Float.nan
+        let bytes = IEEE_754.Binary32.bytes(from: nan)
+        let restored = IEEE_754.Binary32.value(from: bytes)
+
+        #expect(restored?.isNaN == true, "NaN should round-trip as NaN")
+    }
+
+    @Test(arguments: [Float(0.0), Float(-0.0)])
+    func `zero with sign preservation`(value: Float) {
+        let bytes = IEEE_754.Binary32.bytes(from: value)
+        let restored = IEEE_754.Binary32.value(from: bytes)
+
+        #expect(restored == value, "Zero should round-trip")
+        if value.sign == .minus {
+            #expect(restored?.sign == .minus, "Negative zero should preserve sign")
+        }
+    }
+}

Tests/IEEE_754 Tests/IEEE_754.Binary64 Tests.swift

@@ -0,0 +1,151 @@
+// IEEE_754.Binary64 Tests.swift
+// swift-ieee-754
+//
+// Tests for IEEE 754 Binary64 (authoritative implementation)
+
+import Testing
+@testable import IEEE_754
+
+@Suite("IEEE_754.Binary64 - Constants")
+struct Binary64ConstantsTests {
+    @Test func `byte size is 8`() {
+        #expect(IEEE_754.Binary64.byteSize == 8)
+    }
+
+    @Test func `bit size is 64`() {
+        #expect(IEEE_754.Binary64.bitSize == 64)
+    }
+
+    @Test func `sign bits is 1`() {
+        #expect(IEEE_754.Binary64.signBits == 1)
+    }
+
+    @Test func `exponent bits is 11`() {
+        #expect(IEEE_754.Binary64.exponentBits == 11)
+    }
+
+    @Test func `significand bits is 52`() {
+        #expect(IEEE_754.Binary64.significandBits == 52)
+    }
+
+    @Test func `exponent bias is 1023`() {
+        #expect(IEEE_754.Binary64.exponentBias == 1023)
+    }
+
+    @Test func `max exponent is 2047`() {
+        #expect(IEEE_754.Binary64.maxExponent == 2047)
+    }
+
+    @Test func `bit layout sums to 64`() {
+        let total = IEEE_754.Binary64.signBits +
+                   IEEE_754.Binary64.exponentBits +
+                   IEEE_754.Binary64.significandBits
+        #expect(total == 64, "Sign + exponent + significand bits should equal 64")
+    }
+}
+
+@Suite("IEEE_754.Binary64 - Authoritative serialization")
+struct Binary64SerializationTests {
+    @Test(arguments: [
+        3.14159265358979323846,
+        2.71828182845904523536,
+        1.41421356237309504880,
+        0.0,
+        -0.0,
+        1.0,
+        -1.0,
+        Double.infinity,
+        -Double.infinity,
+        Double.pi,
+    ])
+    func `bytes(from:) produces correct byte count`(value: Double) {
+        let bytes = IEEE_754.Binary64.bytes(from: value)
+        #expect(bytes.count == 8, "Binary64 should always produce 8 bytes")
+    }
+
+    @Test(arguments: [3.14159, 2.71828, 1.41421, 42.0])
+    func `bytes(from:) with different endianness`(value: Double) {
+        let little = IEEE_754.Binary64.bytes(from: value, endianness: .little)
+        let big = IEEE_754.Binary64.bytes(from: value, endianness: .big)
+
+        #expect(little.count == 8, "Little endian should produce 8 bytes")
+        #expect(big.count == 8, "Big endian should produce 8 bytes")
+        #expect(little != big, "Different endianness should produce different byte order")
+        #expect(little == big.reversed(), "Big endian should be reverse of little")
+    }
+}
+
+@Suite("IEEE_754.Binary64 - Authoritative deserialization")
+struct Binary64DeserializationTests {
+    @Test(arguments: [
+        3.14159265358979323846,
+        2.71828182845904523536,
+        1.41421356237309504880,
+        0.0,
+        1.0,
+        -1.0,
+        Double.infinity,
+        -Double.infinity,
+    ])
+    func `value(from:) round-trip`(original: Double) {
+        let bytes = IEEE_754.Binary64.bytes(from: original)
+        let restored = IEEE_754.Binary64.value(from: bytes)
+
+        #expect(restored == original, "\(original) should round-trip through Binary64")
+    }
+
+    @Test func `value(from:) with wrong byte count returns nil`() {
+        #expect(IEEE_754.Binary64.value(from: []) == nil, "Empty array should return nil")
+        #expect(IEEE_754.Binary64.value(from: [UInt8](repeating: 0, count: 7)) == nil, "7 bytes should return nil")
+        #expect(IEEE_754.Binary64.value(from: [UInt8](repeating: 0, count: 9)) == nil, "9 bytes should return nil")
+    }
+
+    @Test func `value(from:) with exactly 8 bytes succeeds`() {
+        let bytes = [UInt8](repeating: 0, count: 8)
+        let result = IEEE_754.Binary64.value(from: bytes)
+
+        #expect(result != nil, "8 bytes should succeed")
+        #expect(result == 0.0, "All-zero bytes should decode to 0.0")
+    }
+
+    @Test(arguments: [3.14159, 2.71828, 1.41421])
+    func `value(from:) respects endianness`(value: Double) {
+        let littleBytes = IEEE_754.Binary64.bytes(from: value, endianness: .little)
+        let bigBytes = IEEE_754.Binary64.bytes(from: value, endianness: .big)
+
+        let fromLittle = IEEE_754.Binary64.value(from: littleBytes, endianness: .little)
+        let fromBig = IEEE_754.Binary64.value(from: bigBytes, endianness: .big)
+
+        #expect(fromLittle == value, "Little endian round-trip should work")
+        #expect(fromBig == value, "Big endian round-trip should work")
+
+        // Mismatched endianness should fail
+        let wrongLittle = IEEE_754.Binary64.value(from: bigBytes, endianness: .little)
+        let wrongBig = IEEE_754.Binary64.value(from: littleBytes, endianness: .big)
+
+        #expect(wrongLittle != value, "Mismatched endianness should fail")
+        #expect(wrongBig != value, "Mismatched endianness should fail")
+    }
+}
+
+@Suite("IEEE_754.Binary64 - Special values")
+struct Binary64SpecialValuesTests {
+    @Test func `NaN round-trip`() {
+        let nan = Double.nan
+        let bytes = IEEE_754.Binary64.bytes(from: nan)
+        let restored = IEEE_754.Binary64.value(from: bytes)
+
+        #expect(restored?.isNaN == true, "NaN should round-trip as NaN")
+    }
+
+    @Test(arguments: [0.0, -0.0])
+    func `zero with sign preservation`(value: Double) {
+        let bytes = IEEE_754.Binary64.bytes(from: value)
+        let restored = IEEE_754.Binary64.value(from: bytes)
+
+        #expect(restored == value, "Zero should round-trip")
+        if value.sign == .minus {
+            #expect(restored?.sign == .minus, "Negative zero should preserve sign")
+        }
+    }
+}