Added tests for TechnitiumLibrary.Net, kept the failing tests on purpose

.github/workflows/unit-testing.yml

@@ -0,0 +1,41 @@
+name: Unit testing (Windows / MSBuild)
+
+on:
+  workflow_dispatch:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+  schedule:
+    - cron: "0 0 * * 0"   # weekly, Sunday 00:00 UTC
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: windows-latest
+
+    env:
+      SOLUTION_NAME: TechnitiumLibrary.sln
+      BUILD_CONFIGURATION: Debug
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install .NET 9 SDK
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: 9.0.x
+
+      - name: Add MSBuild to PATH
+        uses: microsoft/setup-msbuild@v2
+
+      - name: Restore
+        run: msbuild ${{ env.SOLUTION_NAME }} /t:Restore
+
+      - name: Build
+        run: msbuild ${{ env.SOLUTION_NAME }} /m /p:Configuration=${{ env.BUILD_CONFIGURATION }}
+
+      - name: Test (msbuild)
+        run: msbuild TechnitiumLibrary.UnitTests\TechnitiumLibrary.UnitTests.csproj /t:Test /p:Configuration=${{ env.BUILD_CONFIGURATION }}

README.md

@@ -1,2 +1,6 @@
 # TechnitiumLibrary
 A library for .net based applications.
+
+## Quality Assurance
+
+[![Unit testing (Windows / MSBuild)](https://github.com/TechnitiumSoftware/TechnitiumLibrary/actions/workflows/unit-testing.yml/badge.svg)](https://github.com/TechnitiumSoftware/TechnitiumLibrary/actions/workflows/unit-testing.yml)

TechnitiumLibrary.Tests/TechnitiumLibrary.Net/Dns/ResourceRecords/CanonicallySerializedResourceRecordTests.cs

@@ -0,0 +1,86 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.IO;
+using System.Net;
+using TechnitiumLibrary.Net.Dns.ResourceRecords;
+
+namespace TechnitiumLibrary.Tests.TechnitiumLibrary.Net.Dns.ResourceRecords
+{
+    [TestClass]
+    public class CanonicallySerializedResourceRecordTests
+    {
+        [TestMethod]
+        public void CompareTo_UsesCanonicalRdataOrdering()
+        {
+            using MemoryStream buffer = new();
+
+            var low = CanonicallySerializedResourceRecord.Create(
+                "example.com",
+                DnsResourceRecordType.A,
+                DnsClass.IN,
+                60,
+                new DnsARecordData(IPAddress.Parse("192.0.2.1")),
+                buffer);
+
+            var high = CanonicallySerializedResourceRecord.Create(
+                "example.com",
+                DnsResourceRecordType.A,
+                DnsClass.IN,
+                60,
+                new DnsARecordData(IPAddress.Parse("192.0.2.200")),
+                buffer);
+
+            Assert.IsTrue(low.CompareTo(high) < 0);
+            Assert.IsTrue(high.CompareTo(low) > 0);
+        }
+
+        [TestMethod]
+        public void Create_CanonicalizesOwnerName_ToLowercase()
+        {
+            using MemoryStream buffer = new();
+
+            var record = CanonicallySerializedResourceRecord.Create(
+                name: "Example.COM",
+                type: DnsResourceRecordType.A,
+                @class: DnsClass.IN,
+                originalTtl: 3600,
+                rData: new DnsARecordData(IPAddress.Parse("192.0.2.1")),
+                buffer: buffer);
+
+            using MemoryStream ms = new();
+            record.WriteTo(ms);
+
+            string wire = System.Text.Encoding.ASCII.GetString(ms.ToArray());
+            StringAssert.Contains(wire, "example");
+        }
+
+        [TestMethod]
+        public void WriteTo_IsDeterministic_ForSameInput()
+        {
+            using MemoryStream buffer = new();
+
+            var a = CanonicallySerializedResourceRecord.Create(
+                "example.com",
+                DnsResourceRecordType.A,
+                DnsClass.IN,
+                60,
+                new DnsARecordData(IPAddress.Parse("192.0.2.1")),
+                buffer);
+
+            var b = CanonicallySerializedResourceRecord.Create(
+                "example.com",
+                DnsResourceRecordType.A,
+                DnsClass.IN,
+                60,
+                new DnsARecordData(IPAddress.Parse("192.0.2.1")),
+                buffer);
+
+            using MemoryStream m1 = new();
+            using MemoryStream m2 = new();
+
+            a.WriteTo(m1);
+            b.WriteTo(m2);
+
+            CollectionAssert.AreEqual(m1.ToArray(), m2.ToArray());
+        }
+    }
+}

TechnitiumLibrary.Tests/TechnitiumLibrary.Net/Dns/ResourceRecords/DnsAAAARecordDataTests.cs

@@ -0,0 +1,106 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.IO;
+using System.Net;
+using System.Text;
+using TechnitiumLibrary.Net.Dns;
+using TechnitiumLibrary.Net.Dns.ResourceRecords;
+
+namespace TechnitiumLibrary.Tests.TechnitiumLibrary.Net.Dns.ResourceRecords
+{
+    [TestClass]
+    public class DnsAAAARecordDataTests
+    {
+        [TestMethod]
+        public void Constructor_IPv4Address_Throws()
+        {
+            IPAddress ipv4 = IPAddress.Parse("192.0.2.1");
+
+            Assert.ThrowsExactly<DnsClientException>(() =>
+                new DnsAAAARecordData(ipv4));
+        }
+
+        [TestMethod]
+        public void Constructor_ValidIPv6Address_Succeeds()
+        {
+            IPAddress address = IPAddress.Parse("2001:db8::1");
+
+            var rdata = new DnsAAAARecordData(address);
+
+            Assert.AreEqual(address, rdata.Address);
+            Assert.AreEqual(16, rdata.UncompressedLength);
+        }
+
+        [TestMethod]
+        public void Equals_DifferentAddress_IsFalse()
+        {
+            var a = new DnsAAAARecordData(IPAddress.Parse("2001:db8::1"));
+            var b = new DnsAAAARecordData(IPAddress.Parse("2001:db8::2"));
+
+            Assert.IsFalse(a.Equals(b));
+        }
+
+        [TestMethod]
+        public void Equals_SameAddress_IsTrue()
+        {
+            IPAddress address = IPAddress.Parse("2001:db8::1");
+
+            var a = new DnsAAAARecordData(address);
+            var b = new DnsAAAARecordData(IPAddress.Parse("2001:db8::1"));
+
+            Assert.IsTrue(a.Equals(b));
+            Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
+        }
+
+        [TestMethod]
+        public void RoundTrip_StreamConstructor_PreservesEquality()
+        {
+            IPAddress address = IPAddress.Parse("2001:db8::dead:beef");
+
+            var original = new DnsResourceRecord(
+                "example",
+                DnsResourceRecordType.AAAA,
+                DnsClass.IN,
+                300,
+                new DnsAAAARecordData(address));
+
+            byte[] wire = Serialize(original);
+
+            using MemoryStream ms = new(wire);
+            var parsed = new DnsResourceRecord(ms);
+
+            Assert.AreEqual(original, parsed);
+        }
+
+        [TestMethod]
+        public void SerializeTo_ProducesExpectedJson()
+        {
+            var rdata = new DnsAAAARecordData(IPAddress.Parse("2001:db8::1"));
+
+            using MemoryStream ms = new();
+            using var writer = new System.Text.Json.Utf8JsonWriter(ms);
+
+            rdata.SerializeTo(writer);
+            writer.Flush();
+
+            string json = Encoding.UTF8.GetString(ms.ToArray());
+
+            StringAssert.Contains(json, "IPAddress");
+            StringAssert.Contains(json, "2001:db8::1");
+        }
+
+        [TestMethod]
+        public void UncompressedLength_IsAlways16()
+        {
+            var rdata = new DnsAAAARecordData(IPAddress.Parse("2001:db8::abcd"));
+
+            Assert.AreEqual(16, rdata.UncompressedLength);
+        }
+
+        private static byte[] Serialize(DnsResourceRecord rr)
+        {
+            using MemoryStream ms = new();
+            rr.WriteTo(ms);
+            return ms.ToArray();
+        }
+    }
+}

TechnitiumLibrary.Tests/TechnitiumLibrary.Net/Dns/ResourceRecords/DnsALIASRecordDataTests.cs

@@ -0,0 +1,114 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System;
+using System.IO;
+using System.Text;
+using TechnitiumLibrary.Net.Dns;
+using TechnitiumLibrary.Net.Dns.ResourceRecords;
+
+namespace TechnitiumLibrary.Tests.TechnitiumLibrary.Net.Dns.ResourceRecords
+{
+    [TestClass]
+    public class DnsALIASRecordDataTests
+    {
+        [TestMethod]
+        public void Constructor_ValidInput_Succeeds()
+        {
+            var rdata = new DnsALIASRecordData(
+                DnsResourceRecordType.A,
+                "example.net.");
+
+            Assert.AreEqual(DnsResourceRecordType.A, rdata.Type);
+            Assert.AreEqual("example.net", rdata.Domain); // It is expected to remove explicit root dot
+        }
+
+        [TestMethod]
+        public void Equals_DifferentType_IsFalse()
+        {
+            var a = new DnsALIASRecordData(
+                DnsResourceRecordType.A,
+                "example.com.");
+
+            var b = new DnsALIASRecordData(
+                DnsResourceRecordType.AAAA,
+                "example.com.");
+
+            Assert.IsFalse(a.Equals(b));
+        }
+
+        [TestMethod]
+        public void Equals_SameTypeAndDomain_IgnoresCase()
+        {
+            var a = new DnsALIASRecordData(
+                DnsResourceRecordType.AAAA,
+                "Example.COM.");
+
+            var b = new DnsALIASRecordData(
+                DnsResourceRecordType.AAAA,
+                "example.com.");
+
+            Assert.IsTrue(a.Equals(b));
+            Assert.AreEqual(a.GetHashCode(), b.GetHashCode());
+        }
+
+        [TestMethod]
+        public void RoundTrip_StreamConstructor_PreservesEquality()
+        {
+            var original = new DnsResourceRecord(
+                "example",
+                DnsResourceRecordType.ALIAS,
+                DnsClass.IN,
+                300,
+                new DnsALIASRecordData(
+                    DnsResourceRecordType.A,
+                    "target.example."));
+
+            byte[] wire = Serialize(original);
+
+            using MemoryStream ms = new(wire);
+            var parsed = new DnsResourceRecord(ms);
+
+            Assert.AreEqual(original, parsed);
+        }
+
+        [TestMethod]
+        public void SerializeTo_ProducesExpectedJson()
+        {
+            var rdata = new DnsALIASRecordData(
+                DnsResourceRecordType.AAAA,
+                "example.net.");
+
+            using MemoryStream ms = new();
+            using var writer = new System.Text.Json.Utf8JsonWriter(ms);
+
+            rdata.SerializeTo(writer);
+            writer.Flush();
+
+            string json = Encoding.UTF8.GetString(ms.ToArray());
+
+            StringAssert.Contains(json, "Type");
+            StringAssert.Contains(json, "AAAA");
+            StringAssert.Contains(json, "Domain");
+            StringAssert.Contains(json, "example.net");
+        }
+
+        [TestMethod]
+        public void UncompressedLength_IncludesTypePrefix()
+        {
+            var rdata = new DnsALIASRecordData(
+                DnsResourceRecordType.A,
+                "example.com.");
+
+            int baseLength = rdata.Domain.Length; // not exact, but sanity check
+
+            Assert.IsTrue(rdata.UncompressedLength > baseLength);
+            Assert.IsTrue(rdata.UncompressedLength >= 2);
+        }
+
+        private static byte[] Serialize(DnsResourceRecord rr)
+        {
+            using MemoryStream ms = new();
+            rr.WriteTo(ms);
+            return ms.ToArray();
+        }
+    }
+}