Merge pull request #16 from szakatsa/Feature/netStandard2compatibility

.NET Standard 2.0 compatibility
aevitas · Jul 18, 2024 · 14259d4 · 14259d4
2 parents 645385e + 2f57bd7
commit 14259d4
Show file tree

Hide file tree

Showing 6 changed files with 172 additions and 166 deletions.
diff --git a/src/FlakeId.Tests/FlakeId.Tests.csproj b/src/FlakeId.Tests/FlakeId.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>netcoreapp2.0;netcoreapp2.1;netcoreapp2.2;netcoreapp3.0;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net461;net462;net47;net471;net472;net48;net481;</TargetFrameworks>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>

diff --git a/src/FlakeId.Tests/IdExtensionsTests.cs b/src/FlakeId.Tests/IdExtensionsTests.cs
@@ -2,47 +2,48 @@
 using FlakeId.Extensions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-namespace FlakeId.Tests;
-
-[TestClass]
-public class IdExtensionsTests
+namespace FlakeId.Tests
 {
-    [TestMethod]
-    public void Id_ToDateTimeOffset()
-    {
-        Id id = Id.Create();
-        DateTimeOffset timeStamp = id.ToDateTimeOffset();
-        DateTimeOffset now = DateTimeOffset.Now;
-        TimeSpan delta = now - timeStamp;
-
-        Assert.IsTrue(delta.Seconds <= 1);
-    }
-
-    [TestMethod]
-    public void Id_ToUnixTimeMilliseconds()
-    {
-        Id id = Id.Create();
-        long timestamp = id.ToUnixTimeMilliseconds();
-        long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
-
-        Assert.IsTrue(now - timestamp < 100);
-    }
-
-    [TestMethod]
-    public void Id_IsValid()
+    [TestClass]
+    public class IdExtensionsTests
     {
-        Id id = Id.Create();
-        bool isValid = id.IsSnowflake();
-
-        Assert.IsTrue(isValid);
-    }
-
-    [TestMethod]
-    public void Id_ToStringIdentifier_ProducesValidId()
-    {
-        Id id = Id.Create();
-        string s = id.ToStringIdentifier();
-
-        Assert.AreNotEqual(default, s);
+        [TestMethod]
+        public void Id_ToDateTimeOffset()
+        {
+            Id id = Id.Create();
+            DateTimeOffset timeStamp = id.ToDateTimeOffset();
+            DateTimeOffset now = DateTimeOffset.Now;
+            TimeSpan delta = now - timeStamp;
+
+            Assert.IsTrue(delta.Seconds <= 1);
+        }
+
+        [TestMethod]
+        public void Id_ToUnixTimeMilliseconds()
+        {
+            Id id = Id.Create();
+            long timestamp = id.ToUnixTimeMilliseconds();
+            long now = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+
+            Assert.IsTrue(now - timestamp < 100);
+        }
+
+        [TestMethod]
+        public void Id_IsValid()
+        {
+            Id id = Id.Create();
+            bool isValid = id.IsSnowflake();
+
+            Assert.IsTrue(isValid);
+        }
+
+        [TestMethod]
+        public void Id_ToStringIdentifier_ProducesValidId()
+        {
+            Id id = Id.Create();
+            string s = id.ToStringIdentifier();
+
+            Assert.AreNotEqual(default, s);
+        }
     }
 }
diff --git a/src/FlakeId.Tests/IdTests.cs b/src/FlakeId.Tests/IdTests.cs
@@ -5,98 +5,99 @@
 using FlakeId.Extensions;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-namespace FlakeId.Tests;
-
-[TestClass]
-public class IdTests
+namespace FlakeId.Tests
 {
-    [TestMethod]
-    public void Id_Create()
-    {
-        Id id = Id.Create();
-
-        Assert.IsTrue(id > 1);
-    }
-
-    [TestMethod]
-    public void Id_CreateFromTimeStamp() 
+    [TestClass]
+    public class IdTests
     {
-        DateTimeOffset now = DateTimeOffset.UtcNow;
-        long timeStamp = now.ToUnixTimeMilliseconds();
-        Id id = Id.Create(timeStamp);
+        [TestMethod]
+        public void Id_Create()
+        {
+            Id id = Id.Create();
 
-        Assert.AreEqual(timeStamp, id.ToUnixTimeMilliseconds());
-    }
+            Assert.IsTrue(id > 1);
+        }
 
-    [TestMethod]
-    public void Id_CreateFromTimeStamp_RecentTimeStamp()
-    {
-        Assert.ThrowsException<ArgumentException>(
-            () => Id.Create(new DateTimeOffset(2010, 1, 1, 0, 0, 0, 0, TimeSpan.Zero).ToUnixTimeMilliseconds()));
-    }
+        [TestMethod]
+        public void Id_CreateFromTimeStamp()
+        {
+            DateTimeOffset now = DateTimeOffset.UtcNow;
+            long timeStamp = now.ToUnixTimeMilliseconds();
+            Id id = Id.Create(timeStamp);
 
-    [TestMethod]
-    public void Id_CreateManyFast()
-    {
-        Id[] ids = Enumerable.Range(0, 1000).Select(_ => Id.Create()).ToArray();
+            Assert.AreEqual(timeStamp, id.ToUnixTimeMilliseconds());
+        }
 
-        foreach (Id id in ids)
+        [TestMethod]
+        public void Id_CreateFromTimeStamp_RecentTimeStamp()
         {
-            Assert.IsTrue(ids.Count(i => i == id) == 1);
+            Assert.ThrowsException<ArgumentException>(
+                () => Id.Create(new DateTimeOffset(2010, 1, 1, 0, 0, 0, 0, TimeSpan.Zero).ToUnixTimeMilliseconds()));
         }
-    }
-
-    [TestMethod]
-    public async Task Id_CreateManyDelayed()
-    {
-        List<Id> ids = [];
 
-        for (int i = 0; i < 100; i++)
+        [TestMethod]
+        public void Id_CreateManyFast()
         {
-            ids.Add(Id.Create());
-            await Task.Delay(TimeSpan.FromMilliseconds(5));
+            Id[] ids = Enumerable.Range(0, 1000).Select(_ => Id.Create()).ToArray();
+
+            foreach (Id id in ids)
+            {
+                Assert.IsTrue(ids.Count(i => i == id) == 1);
+            }
         }
 
-        foreach (Id id in ids)
+        [TestMethod]
+        public async Task Id_CreateManyDelayed()
         {
-            Assert.IsTrue(ids.Count(i => i == id) == 1);
+            List<Id> ids = new List<Id>();
+
+            for (int i = 0; i < 100; i++)
+            {
+                ids.Add(Id.Create());
+                await Task.Delay(TimeSpan.FromMilliseconds(5));
+            }
+
+            foreach (Id id in ids)
+            {
+                Assert.IsTrue(ids.Count(i => i == id) == 1);
+            }
         }
-    }
 
-    [TestMethod]
-    public void Id_Equality()
-    {
-        // This test should never fail so long as Id is a struct.
-        Id left = new(5956206959003041793);
-        Id right = new(5956206959003041793);
+        [TestMethod]
+        public void Id_Equality()
+        {
+            // This test should never fail so long as Id is a struct.
+            Id left = new Id(5956206959003041793);
+            Id right = new Id(5956206959003041793);
 
-        Assert.AreEqual(left, right);
-    }
+            Assert.AreEqual(left, right);
+        }
 
-    [TestMethod]
-    public void Id_Sortable()
-    {
-        // The sequence in which Ids are generated should be equal to a set of sorted Ids.
-        Id[] ids = Enumerable.Range(0, 1000).Select(_ => Id.Create()).ToArray();
-        Id[] sorted = [.. ids.OrderBy(i => i)];
+        [TestMethod]
+        public void Id_Sortable()
+        {
+            // The sequence in which Ids are generated should be equal to a set of sorted Ids.
+            Id[] ids = Enumerable.Range(0, 1000).Select(_ => Id.Create()).ToArray();
+            Id[] sorted = ids.OrderBy(i => i).ToArray();
 
-        Assert.IsTrue(ids.SequenceEqual(sorted));
-    }
+            Assert.IsTrue(ids.SequenceEqual(sorted));
+        }
 
-    [TestMethod]
-    public void Id_ToString()
-    {
-        long id = Id.Create();
+        [TestMethod]
+        public void Id_ToString()
+        {
+            long id = Id.Create();
 
-        Assert.AreEqual(id.ToString(), id.ToString());
-    }
+            Assert.AreEqual(id.ToString(), id.ToString());
+        }
 
-    [TestMethod]
-    public void Id_ContainsTimeZoneComponent()
-    {
-        DateTimeOffset timeStamp = new(2020, 1, 1, 0, 0, 0, TimeSpan.FromHours(7));
-        Id id = Id.Create(timeStamp.ToUnixTimeMilliseconds());
+        [TestMethod]
+        public void Id_ContainsTimeZoneComponent()
+        {
+            DateTimeOffset timeStamp = new DateTimeOffset(2020, 1, 1, 0, 0, 0, TimeSpan.FromHours(7));
+            Id id = Id.Create(timeStamp.ToUnixTimeMilliseconds());
 
-        Assert.AreEqual(timeStamp.ToUnixTimeMilliseconds(), id.ToUnixTimeMilliseconds());
+            Assert.AreEqual(timeStamp.ToUnixTimeMilliseconds(), id.ToUnixTimeMilliseconds());
+        }
     }
 }
diff --git a/src/FlakeId.Tests/ParseTests.cs b/src/FlakeId.Tests/ParseTests.cs
@@ -4,73 +4,74 @@
 using System.Linq;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
-namespace FlakeId.Tests;
-
-[TestClass]
-public class ParseTests
+namespace FlakeId.Tests
 {
-
-
-    [TestMethod]
-    public void Id_Parse_Invalid()
+    [TestClass]
+    public class ParseTests
     {
-        const long value = 10;
 
-        Assert.ThrowsException<FormatException>(() => Id.Parse(value));
-    }
 
-    [TestMethod]
-    public void Id_Parse()
-    {
-        long id = Id.Create();
+        [TestMethod]
+        public void Id_Parse_Invalid()
+        {
+            const long value = 10;
 
-        Id.Parse(id);
-    }
+            Assert.ThrowsException<FormatException>(() => Id.Parse(value));
+        }
 
-    [TestMethod]
-    public void Id_TryParse_Invalid()
-    {
-        const long value = 10;
+        [TestMethod]
+        public void Id_Parse()
+        {
+            long id = Id.Create();
 
-        bool parse = Id.TryParse(value, out _);
+            Id.Parse(id);
+        }
 
-        Assert.IsFalse(parse);
-    }
+        [TestMethod]
+        public void Id_TryParse_Invalid()
+        {
+            const long value = 10;
 
-    [TestMethod]
-    public void Id_TryParse()
-    {
-        long id = Id.Create();
+            bool parse = Id.TryParse(value, out _);
 
-        bool parse = Id.TryParse(id, out Id parsed);
+            Assert.IsFalse(parse);
+        }
 
-        Assert.IsTrue(parse);
-        Assert.AreEqual(id, parsed);
-    }
+        [TestMethod]
+        public void Id_TryParse()
+        {
+            long id = Id.Create();
 
-    [TestMethod]
-    public void Id_TryParse_Many()
-    {
-        List<Id> ids = Enumerable.Range(0, 100_000).Select(_ => Id.Create()).ToList();
-        List<Id> problematic = new();
+            bool parse = Id.TryParse(id, out Id parsed);
 
-        bool failed = false;
-        foreach (var id in ids)
+            Assert.IsTrue(parse);
+            Assert.AreEqual(id, parsed);
+        }
+
+        [TestMethod]
+        public void Id_TryParse_Many()
         {
-            if (!Id.TryParse(id, out Id parsed))
+            List<Id> ids = Enumerable.Range(0, 100_000).Select(_ => Id.Create()).ToList();
+            List<Id> problematic = new List<Id>();
+
+            bool failed = false;
+            foreach (var id in ids)
             {
-                Debug.WriteLine(id);
-                problematic.Add(id);
-                failed = true;
+                if (!Id.TryParse(id, out Id parsed))
+                {
+                    Debug.WriteLine(id);
+                    problematic.Add(id);
+                    failed = true;
+                }
             }
-        }
 
-        Assert.IsFalse(failed);
-    }
+            Assert.IsFalse(failed);
+        }
 
-    [TestMethod]
-    public void Id_TryParse_Problematic()
-    {
-        Id id = Id.Parse(1108047973760811023);
+        [TestMethod]
+        public void Id_TryParse_Problematic()
+        {
+            Id id = Id.Parse(1108047973760811023);
+        }
     }
 }