Address code review feedback: improve performance and test precision

Co-authored-by: DaanV2 <2393905+DaanV2@users.noreply.github.com>

Author: Copilot

Library/Static Classes/V7/V7 - Const.cs

@@ -10,4 +10,10 @@ public static partial class V7 {
 
     private static readonly Vector128<Byte> _VersionMask = Format.VersionVariantMaskNot(V7.Version, V7.Variant);
     private static readonly Vector128<Byte> _VersionOverlay = Format.VersionVariantOverlayer(V7.Version, V7.Variant);
+    
+    /// <summary>Unix epoch: January 1, 1970 00:00:00 UTC</summary>
+    private static readonly DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+    
+    /// <summary>Maximum value that can fit in 48 bits (for RFC9562 V7 timestamp)</summary>
+    private const UInt64 Max48BitValue = 0xFFFFFFFFFFFF;
 }

Library/Static Classes/V7/V7 - Extract.cs

@@ -23,11 +23,8 @@ public static DateTime Extract(UUID uuid) {
     /// <param name="unixMs">Milliseconds since Unix epoch (1970-01-01 00:00:00 UTC)</param>
     /// <returns>The corresponding DateTime in UTC</returns>
     private static DateTime UnixMillisecondsToDateTime(UInt64 unixMs) {
-        // Unix epoch: January 1, 1970 00:00:00 UTC
-        var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-        
         try {
-            return unixEpoch.AddMilliseconds(unixMs);
+            return UnixEpoch.AddMilliseconds(unixMs);
         }
         catch (ArgumentOutOfRangeException) {
             // If the milliseconds value is too large, return MaxValue

Library/Static Classes/V7/V7 - Generate.cs

@@ -85,13 +85,11 @@ public static UUID Generate(UInt64 unixMs, UInt16 randomA, UInt64 randomB) {
     /// <param name="timestamp">The DateTime to convert</param>
     /// <returns>Milliseconds since Unix epoch (1970-01-01 00:00:00 UTC)</returns>
     private static UInt64 DateTimeToUnixMilliseconds(DateTime timestamp) {
-        // Unix epoch: January 1, 1970 00:00:00 UTC
-        var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-        var milliseconds = (timestamp.ToUniversalTime() - unixEpoch).TotalMilliseconds;
+        var milliseconds = (timestamp.ToUniversalTime() - UnixEpoch).TotalMilliseconds;
 
         // Ensure non-negative and within 48-bit range
         if (milliseconds < 0) milliseconds = 0;
-        if (milliseconds > 0xFFFFFFFFFFFF) milliseconds = 0xFFFFFFFFFFFF;
+        if (milliseconds > Max48BitValue) milliseconds = Max48BitValue;
 
         return (UInt64)milliseconds;
     }

Tests/RFC/RFC9562.cs

@@ -81,8 +81,9 @@ public void RFC9562_V6_ReorderedTime() {
 
         // V6 should contain a timestamp
         var info = V6.Extract(uuid);
-        Assert.True(info.Timestamp >= beforeGen.AddSeconds(-1));
-        Assert.True(info.Timestamp <= afterGen.AddSeconds(1));
+        // V6 uses 100-nanosecond intervals, so use tighter tolerance (100ms)
+        Assert.True(info.Timestamp >= beforeGen.AddMilliseconds(-100));
+        Assert.True(info.Timestamp <= afterGen.AddMilliseconds(100));
     }
 
     [Fact(DisplayName = "RFC9562 Section 5.6 - V6 UUIDs are sortable by time")]
@@ -192,6 +193,9 @@ public void RFC9562_V7_Uniqueness() {
     public void RFC9562_V7_MillisecondPrecision() {
         // Generate multiple UUIDs within the same millisecond
         var uuids = new List<UUID>();
+        var startTime = DateTime.UtcNow;
+        
+        // Generate rapidly to likely get some in the same millisecond
         for (int i = 0; i < 100; i++) {
             uuids.Add(V7.Generate());
         }
@@ -205,6 +209,22 @@ public void RFC9562_V7_MillisecondPrecision() {
 
         // All should be unique despite potentially being generated in same millisecond
         Assert.Equal(uuids.Count, uuids.Distinct().Count());
+        
+        // Verify that UUIDs with the same timestamp have identical timestamp bits but different random bits
+        var grouped = uuids.GroupBy(u => V7.ExtractUtc(u)).Where(g => g.Count() > 1).ToList();
+        if (grouped.Any()) {
+            // Found UUIDs with same millisecond timestamp
+            var group = grouped.First();
+            var timestampMs = group.Key;
+            
+            // All UUIDs in this group should have same timestamp value
+            foreach (var uuid in group) {
+                Assert.Equal(timestampMs, V7.ExtractUtc(uuid));
+            }
+            
+            // But all UUIDs should be unique (different random portions)
+            Assert.Equal(group.Count(), group.Distinct().Count());
+        }
     }
 
     // ========== V8 Specific Tests (RFC 9562 Section 5.8) ==========