Fix V7 UUID to use Unix milliseconds per RFC9562 instead of FileTime

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

Author: Copilot

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

@@ -1,21 +1,37 @@
 namespace DaanV2.UUID;
 
 public static partial class V7 {
-    /// <summary>Extracts the UTC from the UUID</summary>
-    /// <param name="uuid">The <see cref="UUID"/> to extract the UTC from</param>
-    /// <returns>The UTC value</returns>
+    /// <summary>Extracts the Unix milliseconds timestamp from the UUID</summary>
+    /// <param name="uuid">The <see cref="UUID"/> to extract the timestamp from</param>
+    /// <returns>Unix timestamp in milliseconds</returns>
     public static UInt64 ExtractUtc(UUID uuid) {
         (UInt64 bits48, _, _) = Format.Extract(uuid);
 
         return bits48;
     }
 
     /// <summary>Extracts the datetime from the UUID</summary>
-    /// <param name="uuid">The <see cref="UUID"/> to extract the UTC from</param>
+    /// <param name="uuid">The <see cref="UUID"/> to extract the timestamp from</param>
     /// <returns>The <see cref="DateTime"/></returns>
     public static DateTime Extract(UUID uuid) {
-        UInt64 fileUTC = ExtractUtc(uuid);
+        UInt64 unixMs = ExtractUtc(uuid);
 
-        return DateTime.FromFileTimeUtc((Int64)fileUTC);
+        return UnixMillisecondsToDateTime(unixMs);
+    }
+    
+    /// <summary>Converts Unix milliseconds to DateTime</summary>
+    /// <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);
+        }
+        catch (ArgumentOutOfRangeException) {
+            // If the milliseconds value is too large, return MaxValue
+            return DateTime.MaxValue;
+        }
     }
 }

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

@@ -65,15 +65,34 @@ public static UUID Generate(UInt64 utc, ReadOnlySpan<Byte> bytes10) {
 
     /// <inheritdoc cref="Generate()"/>
     public static UUID Generate(DateTime timestamp, UInt16 randomA, UInt64 randomB) {
-        UInt64 t = (UInt64)timestamp.ToFileTimeUtc();
+        // RFC9562: V7 uses Unix epoch timestamp in milliseconds (48 bits)
+        UInt64 unixMs = DateTimeToUnixMilliseconds(timestamp);
 
-        return Generate(t, randomA, randomB);
+        return Generate(unixMs, randomA, randomB);
     }
 
     /// <inheritdoc cref="Generate()"/>
-    public static UUID Generate(UInt64 utc, UInt16 randomA, UInt64 randomB) {
-        Vector128<Byte> u = Format.Create(V7.Version, V7.Variant, utc, randomA, randomB);
+    /// <param name="unixMs">Unix timestamp in milliseconds (48-bit value)</param>
+    /// <param name="randomA">12 bits of random data</param>
+    /// <param name="randomB">62 bits of random data</param>
+    public static UUID Generate(UInt64 unixMs, UInt16 randomA, UInt64 randomB) {
+        Vector128<Byte> u = Format.Create(V7.Version, V7.Variant, unixMs, randomA, randomB);
 
         return new UUID(u);
     }
+    
+    /// <summary>Converts a DateTime to Unix milliseconds</summary>
+    /// <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;
+        
+        // Ensure non-negative and within 48-bit range
+        if (milliseconds < 0) milliseconds = 0;
+        if (milliseconds > 0xFFFFFFFFFFFF) milliseconds = 0xFFFFFFFFFFFF;
+        
+        return (UInt64)milliseconds;
+    }
 }

Tests/Generation/V7Tests.cs

@@ -5,16 +5,21 @@ public sealed partial class V7Tests {
     // From https://www.ietf.org/archive/id/draft-peabody-dispatch-new-uuid-format-04.html#name-example-of-a-uuidv7-value
     [Fact(DisplayName = "Given a known example, will generate the expected UUID")]
     public void TestVector() {
-        var timestamp = DateTime.FromFileTimeUtc(1645557742000);
+        // RFC9562 test vector: UUID 017f22e2-79b0-7cc3-98c4-dc0c0c07398f
+        // First 48 bits are Unix milliseconds: 0x017f22e279b0 = 1645557742000
+        // This is 2022-02-22 19:22:22 UTC
+        var unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var timestamp = unixEpoch.AddMilliseconds(1645557742000);
+        
         UInt16 randA = (UInt16)0xCC3;
         UInt64 randB = (UInt64)0x18C4DC0C0C07398F;
 
         UUID u = V7.Generate(timestamp, randA, randB);
 
         Assert.Equal("017f22e2-79b0-7cc3-98c4-dc0c0c07398f", u.ToString());
 
-        Int64 extractedUTC = (Int64)V7.ExtractUtc(u);
-        Assert.Equal(timestamp.ToFileTimeUtc(), extractedUTC);
+        UInt64 extractedMs = V7.ExtractUtc(u);
+        Assert.Equal(1645557742000UL, extractedMs);
 
         DateTime extracted = V7.Extract(u);
         Assert.Equal(timestamp, extracted);

Tests/RFC/RFC9562.cs

@@ -130,9 +130,8 @@ public void RFC9562_V6_Uniqueness() {
 
     [Fact(DisplayName = "RFC9562 Section 5.7 - V7 contains Unix Epoch timestamp")]
     public void RFC9562_V7_ContainsTimestamp() {
-        // Note: V7 only stores 48 bits for timestamp. When using FileTimeUtc, this limits the range.
-        // Use a timestamp that fits within 48-bit FileTime range for this test
-        var inputTime = DateTime.FromFileTimeUtc(1645557742000); // Known good value from RFC test vector
+        // V7 uses Unix epoch milliseconds (RFC9562 Section 5.7)
+        var inputTime = DateTime.UtcNow;
         var uuid = V7.Generate(inputTime);
 
         Assert.Equal(DaanV2.UUID.Version.V7, uuid.Version);
@@ -141,34 +140,39 @@ public void RFC9562_V7_ContainsTimestamp() {
         // Extract timestamp and verify round-trip accuracy
         var extractedTime = V7.Extract(uuid);
 
-        // V7 timestamps should round-trip correctly
-        Assert.Equal(inputTime, extractedTime);
+        // V7 only stores milliseconds, so allow up to 1ms difference
+        var timeDiff = Math.Abs((extractedTime - inputTime).TotalMilliseconds);
+        Assert.True(timeDiff < 2, 
+            $"Time difference {timeDiff}ms is too large. Input: {inputTime}, Extracted: {extractedTime}");
     }
 
     [Fact(DisplayName = "RFC9562 Section 5.7 - V7 UUIDs are sortable by time")]
     public void RFC9562_V7_Sortable() {
-        var uuids = new List<UUID>();
+        var uuids = new List<(UUID uuid, DateTime time)>();
 
-        for (int i = 0; i < 100; i++) {
-            uuids.Add(V7.Generate());
-            // Small delay to ensure time progression
-            if (i % 10 == 0) {
-                Thread.Sleep(1);
-            }
+        // Generate UUIDs with known time gaps
+        for (int i = 0; i < 20; i++) {
+            var time = DateTime.UtcNow;
+            uuids.Add((V7.Generate(time), time));
+            Thread.Sleep(5); // 5ms delay to ensure time progression
         }
 
-        // V7 UUIDs should be in ascending order when generated sequentially
-        // Check that most UUIDs maintain order
-        int inOrder = 0;
-        for (int i = 0; i < uuids.Count - 1; i++) {
-            if (string.Compare(uuids[i].ToString(), uuids[i + 1].ToString(), StringComparison.Ordinal) <= 0) {
-                inOrder++;
-            }
-        }
+        // Verify that UUIDs generated at different times maintain time order
+        // Group by millisecond and verify cross-group ordering
+        var groups = uuids.GroupBy(x => x.time.Ticks / TimeSpan.TicksPerMillisecond).ToList();
 
-        // At least 90% should be in order
-        Assert.True(inOrder >= (uuids.Count - 1) * 0.9, 
-            $"Expected at least 90% in order, got {inOrder}/{uuids.Count - 1}");
+        // With 5ms delays, we should have multiple distinct timestamps
+        Assert.True(groups.Count >= 10, $"Expected at least 10 distinct timestamps, got {groups.Count}");
+        
+        // Compare first UUID from each group - they should be in time order
+        for (int i = 0; i < groups.Count - 1; i++) {
+            var earlier = groups[i].First().uuid;
+            var later = groups[i + 1].First().uuid;
+            
+            // UUIDs from earlier time should compare less than UUIDs from later time
+            Assert.True(string.Compare(earlier.ToString(), later.ToString(), StringComparison.Ordinal) < 0,
+                $"UUID from earlier time should be less than UUID from later time");
+        }
     }
 
     [Fact(DisplayName = "RFC9562 Section 5.7 - V7 uniqueness")]