Task 455 | Step 3 Unit Tests Execution | C# Online Compiler

Task 455 | Step 3 Unit Tests Execution by Jomo Lumina

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Reflection;
using Microsoft.VisualStudio.TestTools.UnitTesting;

public struct DNSHeader
{
    public ushort Id; // Identification number
    public ushort Flags; // Flags
    public ushort QuestionCount; // Number of questions
    public ushort AnswerCount; // Number of answer records
    public ushort AuthorityCount; // Number of authority records
    public ushort AdditionalCount; // Number of additional records
}

public struct DNSQuestion
{
    public string QNAME; // Domain name being queried
    public ushort QTYPE; // Type of the query (A = 1)
    public ushort QCLASS; // Class of the query (IN = 1)
}

public struct DNSAnswer
{
    public string NAME; // Domain name
    public ushort TYPE; // Type of the record (A = 1)
    public ushort CLASS; // Class of the record (IN = 1)
    public uint TTL; // Time to live
    public ushort RDLENGTH; // Length of the RDATA field
    public string RDATA; // The answer (IPv4 address)
}

public class DNSServer
{
    private static Dictionary<string, string> _records = new Dictionary<string, string>()
    {
        { "example.com", "192.168.1.1" },
        { "google.com", "8.8.8.8" },
        { "test.local", "127.0.0.1" }
    };

    public static string DomainNameFromDNSFormat(byte[] data, int offset, out int newOffset)
    {
        if (data == null || data.Length == 0)
        {
            throw new ArgumentException("Data cannot be null or empty", nameof(data));
        }
    
        StringBuilder domainName = new StringBuilder();
        int currentOffset = offset;
        byte length;
    
        while ((length = data[currentOffset++]) != 0)
        {
            if (domainName.Length > 0)
            {
                domainName.Append(".");
            }
            domainName.Append(Encoding.ASCII.GetString(data, currentOffset, length));
            currentOffset += length;
        }
    
        newOffset = currentOffset;
        return domainName.ToString();
    }
    
    
    public static byte[] DomainNameToDNSFormat(string domainName)
    {
        if (string.IsNullOrEmpty(domainName))
        {
            throw new ArgumentNullException(nameof(domainName), "Domain name cannot be null or empty.");
        }
    
        List<byte> dnsFormat = new List<byte>();
        string[] labels = domainName.Split('.');
        foreach (string label in labels)
        {
            dnsFormat.Add((byte)label.Length);
            dnsFormat.AddRange(Encoding.ASCII.GetBytes(label));
        }
        dnsFormat.Add(0); // Null terminator
        return dnsFormat.ToArray();
    }
    
    
    public static byte[] IPAddressToBytes(string ipAddress)
    {
        if (string.IsNullOrEmpty(ipAddress))
        {
            throw new ArgumentNullException(nameof(ipAddress), "IP address cannot be null or empty.");
        }
    
        return IPAddress.Parse(ipAddress).GetAddressBytes();
    }

    public static string BytesToIPAddress(byte[] bytes)
    {
      if(bytes == null)
      {
          throw new ArgumentNullException(nameof(bytes), "IP address cannot be null or empty.");
      }

      return new IPAddress(bytes).ToString();
    }
    
    
    public static byte[] CreateDNSPacket(DNSHeader header, DNSQuestion question, DNSAnswer? answer)
    {
    
      if(question.QNAME == null)
      {
          throw new ArgumentNullException(nameof(question), "DNS Question cannot be null.");
      }
    
      List<byte> packet = new List<byte>();
    
      // Header
      packet.AddRange(BitConverter.GetBytes(header.Id).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.Flags).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.QuestionCount).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.AnswerCount).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.AuthorityCount).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.AdditionalCount).Reverse());
    
      // Question
      packet.AddRange(DomainNameToDNSFormat(question.QNAME));
      packet.AddRange(BitConverter.GetBytes(question.QTYPE).Reverse());
      packet.AddRange(BitConverter.GetBytes(question.QCLASS).Reverse());
    
      // Answer (if present)
      if (answer.HasValue)
      {
            if (answer.Value.NAME == null || answer.Value.RDATA == null)
            {
                throw new ArgumentNullException(nameof(answer), "DNS Answer properties cannot be null when answer is provided.");
            }

          packet.AddRange(DomainNameToDNSFormat(answer.Value.NAME));
          packet.AddRange(BitConverter.GetBytes(answer.Value.TYPE).Reverse());
          packet.AddRange(BitConverter.GetBytes(answer.Value.CLASS).Reverse());
          packet.AddRange(BitConverter.GetBytes(answer.Value.TTL).Reverse());
          packet.AddRange(BitConverter.GetBytes(answer.Value.RDLENGTH).Reverse());
          packet.AddRange(IPAddressToBytes(answer.Value.RDATA));
      }
    
      return packet.ToArray();
    }

    public static DNSHeader ParseDNSHeader(byte[] data)
    {
        if (data == null || data.Length < 12)
        {
            throw new ArgumentException("Invalid DNS header data.", nameof(data));
        }
    
        return new DNSHeader
        {
            Id = BitConverter.ToUInt16(data, 0),
            Flags = BitConverter.ToUInt16(data, 2),
            QuestionCount = BitConverter.ToUInt16(data, 4),
            AnswerCount = BitConverter.ToUInt16(data, 6),
            AuthorityCount = BitConverter.ToUInt16(data, 8),
            AdditionalCount = BitConverter.ToUInt16(data, 10)
        };
    }    

    public static DNSQuestion ParseDNSQuestion(byte[] data, int offset, out int newOffset)
    {
        if(data == null)
        {
            throw new ArgumentNullException(nameof(data), "DNS Question cannot be null.");
        }

        string qname = DomainNameFromDNSFormat(data, offset, out newOffset);
        ushort qtype = BitConverter.ToUInt16(data.Skip(newOffset).Take(2).Reverse().ToArray(), 0);
        newOffset += 2;
        ushort qclass = BitConverter.ToUInt16(data.Skip(newOffset).Take(2).Reverse().ToArray(), 0);
        newOffset += 2;
    
        return new DNSQuestion
        {
            QNAME = qname,
            QTYPE = qtype,
            QCLASS = qclass
        };
    }

    public static DNSAnswer? ResolveDNSQuery(string domainName)
    {
        if (string.IsNullOrEmpty(domainName))
        {
            throw new ArgumentNullException(nameof(domainName), "Domain name cannot be null or empty.");
        }
    
        if (_records.TryGetValue(domainName, out string ipAddress))
        {
            return new DNSAnswer
            {
                NAME = domainName,
                TYPE = 1, // A record
                CLASS = 1, // IN class
                TTL = 60, // 60 seconds
                RDLENGTH = 4, // IPv4 address is 4 bytes
                RDATA = ipAddress
            };
        }
    
        return null; // Not found
    }


	public static void Main()
    {
        Console.WriteLine("🔍 Discovering and Running Tests...\n");

        int totalPassed = 0, totalFailed = 0;

        // Get all classes in the assembly with the [TestClass] attribute
        var testClasses = Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(t => t.GetCustomAttribute<TestClassAttribute>() != null);

        foreach (var testClass in testClasses)
        {
            Console.WriteLine($"📌 Running tests in: {testClass.Name}");
            (int passed, int failed) = RunTests(testClass);
            totalPassed += passed;
            totalFailed += failed;
            Console.WriteLine();
        }

        Console.WriteLine("\n📊 FINAL SUMMARY:");
        Console.WriteLine($"✅ Total Passed: {totalPassed}");
        Console.WriteLine($"❌ Total Failed: {totalFailed}");
        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");

        Console.WriteLine("\n✅ Test execution completed.");
    }

    private static (int passed, int failed) RunTests(Type testClassType)
    {
        object testInstance = Activator.CreateInstance(testClassType);
        MethodInfo[] testMethods = testClassType
            .GetMethods(BindingFlags.Instance | BindingFlags.Public)
            .Where(m => m.GetCustomAttribute<TestMethodAttribute>() != null)
            .ToArray();

        int passed = 0, failed = 0;

        foreach (var method in testMethods)
        {
            try
            {
                method.Invoke(testInstance, null);
                Console.WriteLine($"  ✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");
                failed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");
                failed++;
            }
        }

        return (passed, failed);
    }
}

[TestClass]
public class DNSServerTests
{
    [TestMethod]
    public void DomainNameFromDNSFormat_ValidInput_ReturnsCorrectDomainName()
    {
        byte[] data = { 3, 116, 101, 115, 116, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 };
        int offset = 0;
        int newOffset;
        string expected = "test.example.com";
        string actual = DNSServer.DomainNameFromDNSFormat(data, offset, out newOffset);
        Assert.AreEqual(expected, actual);
        Assert.AreEqual(18, newOffset);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void DomainNameFromDNSFormat_NullData_ThrowsArgumentException()
    {
        byte[] data = null;
        int offset = 0;
        int newOffset;
        DNSServer.DomainNameFromDNSFormat(data, offset, out newOffset);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void DomainNameFromDNSFormat_EmptyData_ThrowsArgumentException()
    {
        byte[] data = new byte[0];
        int offset = 0;
        int newOffset;
        DNSServer.DomainNameFromDNSFormat(data, offset, out newOffset);
    }
    
    [TestMethod]
    public void DomainNameToDNSFormat_ValidInput_ReturnsCorrectBytes()
    {
        string domainName = "test.example.com";
        byte[] expected = { 3, 116, 101, 115, 116, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 };
        byte[] actual = DNSServer.DomainNameToDNSFormat(domainName);
        CollectionAssert.AreEqual(expected, actual);
    }
    
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void DomainNameToDNSFormat_NullDomainName_ThrowsArgumentNullException()
    {
        DNSServer.DomainNameToDNSFormat(null);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void DomainNameToDNSFormat_EmptyDomainName_ThrowsArgumentNullException()
    {
        DNSServer.DomainNameToDNSFormat("");
    }

    [TestMethod]
    public void IPAddressToBytes_ValidIP_ReturnsCorrectBytes()
    {
        string ipAddress = "192.168.1.1";
        byte[] expected = { 192, 168, 1, 1 };
        byte[] actual = DNSServer.IPAddressToBytes(ipAddress);
        CollectionAssert.AreEqual(expected, actual);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void IPAddressToBytes_NullIP_ThrowsArgumentNullException()
    {
        DNSServer.IPAddressToBytes(null);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void IPAddressToBytes_EmptyIP_ThrowsArgumentNullException()
    {
        DNSServer.IPAddressToBytes("");
    }

    [TestMethod]
    [ExpectedException(typeof(FormatException))]
    public void IPAddressToBytes_InvalidIP_ThrowsFormatException()
    {
        DNSServer.IPAddressToBytes("invalid ip");
    }
    
    [TestMethod]
    public void BytesToIPAddress_ValidBytes_ReturnsCorrectIPAddress()
    {
        byte[] bytes = { 192, 168, 1, 1 };
        string expected = "192.168.1.1";
        string actual = DNSServer.BytesToIPAddress(bytes);
        Assert.AreEqual(expected, actual);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void BytesToIPAddress_NullBytes_ThrowsArgumentNullException()
    {
        DNSServer.BytesToIPAddress(null);
    }
    
    [TestMethod]
    public void CreateDNSPacket_ValidInputWithAnswer_ReturnsCorrectPacket()
    {
      DNSHeader header = new DNSHeader { Id = 1, Flags = 0, QuestionCount = 1, AnswerCount = 1, AuthorityCount = 0, AdditionalCount = 0 };
      DNSQuestion question = new DNSQuestion { QNAME = "example.com", QTYPE = 1, QCLASS = 1 };
      DNSAnswer answer = new DNSAnswer { NAME = "example.com", TYPE = 1, CLASS = 1, TTL = 60, RDLENGTH = 4, RDATA = "192.168.1.1" };
      byte[] packet = DNSServer.CreateDNSPacket(header, question, answer);
      
      Assert.IsNotNull(packet);
      Assert.IsTrue(packet.Length > 0);
    }

    [TestMethod]
    public void CreateDNSPacket_ValidInputWithoutAnswer_ReturnsCorrectPacket()
    {
        DNSHeader header = new DNSHeader { Id = 1, Flags = 0, QuestionCount = 1, AnswerCount = 0, AuthorityCount = 0, AdditionalCount = 0 };
        DNSQuestion question = new DNSQuestion { QNAME = "example.com", QTYPE = 1, QCLASS = 1 };
        
        byte[] packet = DNSServer.CreateDNSPacket(header, question, null);

        Assert.IsNotNull(packet);
        Assert.IsTrue(packet.Length > 0);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void CreateDNSPacket_NullQuestion_ThrowsArgumentNullException()
    {
        DNSHeader header = new DNSHeader();
        DNSAnswer answer = new DNSAnswer();
        DNSServer.CreateDNSPacket(header, default, answer);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void CreateDNSPacket_NullAnswerProperties_ThrowsArgumentNullException()
    {
        DNSHeader header = new DNSHeader();
        DNSQuestion question = new DNSQuestion { QNAME = "example.com" };
        DNSAnswer answer = new DNSAnswer { NAME = null, RDATA = null };
        DNSServer.CreateDNSPacket(header, question, answer);
    }

    [TestMethod]
    public void ParseDNSHeader_ValidData_ReturnsCorrectHeader()
    {
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C };
        DNSHeader expected = new DNSHeader { Id = 0x0201, Flags = 0x0403, QuestionCount = 0x0605, AnswerCount = 0x0807, AuthorityCount = 0x0A09, AdditionalCount = 0x0C0B };
        DNSHeader actual = DNSServer.ParseDNSHeader(data);
        Assert.AreEqual(expected.Id, BitConverter.ToUInt16(BitConverter.GetBytes(actual.Id).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.Flags, BitConverter.ToUInt16(BitConverter.GetBytes(actual.Flags).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.QuestionCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.QuestionCount).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.AnswerCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.AnswerCount).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.AuthorityCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.AuthorityCount).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.AdditionalCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.AdditionalCount).Reverse().ToArray(), 0));
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ParseDNSHeader_NullData_ThrowsArgumentException()
    {
        DNSServer.ParseDNSHeader(null);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ParseDNSHeader_ShortData_ThrowsArgumentException()
    {
        byte[] data = new byte[11];
        DNSServer.ParseDNSHeader(data);
    }


    [TestMethod]
    public void ParseDNSQuestion_ValidData_ReturnsCorrectQuestion()
    {
      byte[] data = { 3, 116, 101, 115, 116, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0, 0, 1, 0, 1 };
      int offset = 0;
      int newOffset;

      DNSQuestion expected = new DNSQuestion { QNAME = "test.example.com", QTYPE = 1, QCLASS = 1 };
      DNSQuestion actual = DNSServer.ParseDNSQuestion(data, offset, out newOffset);

      Assert.AreEqual(expected.QNAME, actual.QNAME);
      Assert.AreEqual(expected.QTYPE, actual.QTYPE);
      Assert.AreEqual(expected.QCLASS, actual.QCLASS);
      Assert.AreEqual(22, newOffset);
    }

    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void ParseDNSQuestion_NullData_ThrowsArgumentNullException()
    {
      DNSServer.ParseDNSQuestion(null, 0, out _);
    }

    [TestMethod]
    public void ResolveDNSQuery_ExistingDomain_ReturnsCorrectAnswer()
    {
        string domainName = "example.com";
        DNSAnswer? expected = new DNSAnswer { NAME = "example.com", TYPE = 1, CLASS = 1, TTL = 60, RDLENGTH = 4, RDATA = "192.168.1.1" };
        DNSAnswer? actual = DNSServer.ResolveDNSQuery(domainName);
        Assert.AreEqual(expected.Value.NAME, actual.Value.NAME);
        Assert.AreEqual(expected.Value.TYPE, actual.Value.TYPE);
        Assert.AreEqual(expected.Value.CLASS, actual.Value.CLASS);
        Assert.AreEqual(expected.Value.TTL, actual.Value.TTL);
        Assert.AreEqual(expected.Value.RDLENGTH, actual.Value.RDLENGTH);
        Assert.AreEqual(expected.Value.RDATA, actual.Value.RDATA);
    }

    [TestMethod]
    public void ResolveDNSQuery_NonExistingDomain_ReturnsNull()
    {
        string domainName = "nonexistent.com";
        DNSAnswer? actual = DNSServer.ResolveDNSQuery(domainName);
        Assert.IsNull(actual);
    }
        [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void ResolveDNSQuery_NullDomainName_ThrowsArgumentNullException()
    {
      DNSServer.ResolveDNSQuery(null);
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Reflection;
using Microsoft.VisualStudio.TestTools.UnitTesting;
​
public struct DNSHeader
{
    public ushort Id; // Identification number
    public ushort Flags; // Flags
    public ushort QuestionCount; // Number of questions
    public ushort AnswerCount; // Number of answer records
    public ushort AuthorityCount; // Number of authority records
    public ushort AdditionalCount; // Number of additional records
}
​
public struct DNSQuestion
{
    public string QNAME; // Domain name being queried
    public ushort QTYPE; // Type of the query (A = 1)
    public ushort QCLASS; // Class of the query (IN = 1)
}
​
public struct DNSAnswer
{
    public string NAME; // Domain name
    public ushort TYPE; // Type of the record (A = 1)
    public ushort CLASS; // Class of the record (IN = 1)
    public uint TTL; // Time to live
    public ushort RDLENGTH; // Length of the RDATA field
    public string RDATA; // The answer (IPv4 address)
}
​
public class DNSServer
{
    private static Dictionary<string, string> _records = new Dictionary<string, string>()
    {
        { "example.com", "192.168.1.1" },
        { "google.com", "8.8.8.8" },
        { "test.local", "127.0.0.1" }
    };
​
    public static string DomainNameFromDNSFormat(byte[] data, int offset, out int newOffset)
    {
        if (data == null || data.Length == 0)
        {
            throw new ArgumentException("Data cannot be null or empty", nameof(data));
        }
    
        StringBuilder domainName = new StringBuilder();
        int currentOffset = offset;
        byte length;
    
        while ((length = data[currentOffset++]) != 0)
        {
            if (domainName.Length > 0)
            {
                domainName.Append(".");
            }
            domainName.Append(Encoding.ASCII.GetString(data, currentOffset, length));
            currentOffset += length;
        }
    
        newOffset = currentOffset;
        return domainName.ToString();
    }
    
    
    public static byte[] DomainNameToDNSFormat(string domainName)
    {
        if (string.IsNullOrEmpty(domainName))
        {
            throw new ArgumentNullException(nameof(domainName), "Domain name cannot be null or empty.");
        }
    
        List<byte> dnsFormat = new List<byte>();
        string[] labels = domainName.Split('.');
        foreach (string label in labels)
        {
            dnsFormat.Add((byte)label.Length);
            dnsFormat.AddRange(Encoding.ASCII.GetBytes(label));
        }
        dnsFormat.Add(0); // Null terminator
        return dnsFormat.ToArray();
    }
    
    
    public static byte[] IPAddressToBytes(string ipAddress)
    {
        if (string.IsNullOrEmpty(ipAddress))
        {
            throw new ArgumentNullException(nameof(ipAddress), "IP address cannot be null or empty.");
        }
    
        return IPAddress.Parse(ipAddress).GetAddressBytes();
    }
​
    public static string BytesToIPAddress(byte[] bytes)
    {
      if(bytes == null)
      {
          throw new ArgumentNullException(nameof(bytes), "IP address cannot be null or empty.");
      }
​
      return new IPAddress(bytes).ToString();
    }
    
    
    public static byte[] CreateDNSPacket(DNSHeader header, DNSQuestion question, DNSAnswer? answer)
    {
    
      if(question.QNAME == null)
      {
          throw new ArgumentNullException(nameof(question), "DNS Question cannot be null.");
      }
    
      List<byte> packet = new List<byte>();
    
      // Header
      packet.AddRange(BitConverter.GetBytes(header.Id).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.Flags).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.QuestionCount).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.AnswerCount).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.AuthorityCount).Reverse());
      packet.AddRange(BitConverter.GetBytes(header.AdditionalCount).Reverse());
    
      // Question
      packet.AddRange(DomainNameToDNSFormat(question.QNAME));
      packet.AddRange(BitConverter.GetBytes(question.QTYPE).Reverse());
      packet.AddRange(BitConverter.GetBytes(question.QCLASS).Reverse());
    
      // Answer (if present)
      if (answer.HasValue)
      {
            if (answer.Value.NAME == null || answer.Value.RDATA == null)
            {
                throw new ArgumentNullException(nameof(answer), "DNS Answer properties cannot be null when answer is provided.");
            }
​
          packet.AddRange(DomainNameToDNSFormat(answer.Value.NAME));
          packet.AddRange(BitConverter.GetBytes(answer.Value.TYPE).Reverse());
          packet.AddRange(BitConverter.GetBytes(answer.Value.CLASS).Reverse());
          packet.AddRange(BitConverter.GetBytes(answer.Value.TTL).Reverse());
          packet.AddRange(BitConverter.GetBytes(answer.Value.RDLENGTH).Reverse());
          packet.AddRange(IPAddressToBytes(answer.Value.RDATA));
      }
    
      return packet.ToArray();
    }
​
    public static DNSHeader ParseDNSHeader(byte[] data)
    {
        if (data == null || data.Length < 12)
        {
            throw new ArgumentException("Invalid DNS header data.", nameof(data));
        }
    
        return new DNSHeader
        {
            Id = BitConverter.ToUInt16(data, 0),
            Flags = BitConverter.ToUInt16(data, 2),
            QuestionCount = BitConverter.ToUInt16(data, 4),
            AnswerCount = BitConverter.ToUInt16(data, 6),
            AuthorityCount = BitConverter.ToUInt16(data, 8),
            AdditionalCount = BitConverter.ToUInt16(data, 10)
        };
    }    
​
    public static DNSQuestion ParseDNSQuestion(byte[] data, int offset, out int newOffset)
    {
        if(data == null)
        {
            throw new ArgumentNullException(nameof(data), "DNS Question cannot be null.");
        }
​
        string qname = DomainNameFromDNSFormat(data, offset, out newOffset);
        ushort qtype = BitConverter.ToUInt16(data.Skip(newOffset).Take(2).Reverse().ToArray(), 0);
        newOffset += 2;
        ushort qclass = BitConverter.ToUInt16(data.Skip(newOffset).Take(2).Reverse().ToArray(), 0);
        newOffset += 2;
    
        return new DNSQuestion
        {
            QNAME = qname,
            QTYPE = qtype,
            QCLASS = qclass
        };
    }
​
    public static DNSAnswer? ResolveDNSQuery(string domainName)
    {
        if (string.IsNullOrEmpty(domainName))
        {
            throw new ArgumentNullException(nameof(domainName), "Domain name cannot be null or empty.");
        }
    
        if (_records.TryGetValue(domainName, out string ipAddress))
        {
            return new DNSAnswer
            {
                NAME = domainName,
                TYPE = 1, // A record
                CLASS = 1, // IN class
                TTL = 60, // 60 seconds
                RDLENGTH = 4, // IPv4 address is 4 bytes
                RDATA = ipAddress
            };
        }
    
        return null; // Not found
    }
​
​
    public static void Main()
    {
        Console.WriteLine("🔍 Discovering and Running Tests...\n");
​
        int totalPassed = 0, totalFailed = 0;
​
        // Get all classes in the assembly with the [TestClass] attribute
        var testClasses = Assembly.GetExecutingAssembly()
            .GetTypes()
            .Where(t => t.GetCustomAttribute<TestClassAttribute>() != null);
​
        foreach (var testClass in testClasses)
        {
            Console.WriteLine($"📌 Running tests in: {testClass.Name}");
            (int passed, int failed) = RunTests(testClass);
            totalPassed += passed;
            totalFailed += failed;
            Console.WriteLine();
        }
​
        Console.WriteLine("\n📊 FINAL SUMMARY:");
        Console.WriteLine($"✅ Total Passed: {totalPassed}");
        Console.WriteLine($"❌ Total Failed: {totalFailed}");
        Console.WriteLine($"📌 Total Tests: {totalPassed + totalFailed}");
​
        Console.WriteLine("\n✅ Test execution completed.");
    }
​
    private static (int passed, int failed) RunTests(Type testClassType)
    {
        object testInstance = Activator.CreateInstance(testClassType);
        MethodInfo[] testMethods = testClassType
            .GetMethods(BindingFlags.Instance | BindingFlags.Public)
            .Where(m => m.GetCustomAttribute<TestMethodAttribute>() != null)
            .ToArray();
​
        int passed = 0, failed = 0;
​
        foreach (var method in testMethods)
        {
            try
            {
                method.Invoke(testInstance, null);
                Console.WriteLine($"  ✅ {method.Name} PASSED");
                passed++;
            }
            catch (TargetInvocationException ex)
            {
                Console.WriteLine($"  ❌ {method.Name} FAILED: {ex.InnerException?.Message ?? ex.Message}");
                failed++;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"  ⚠️ {method.Name} ERROR: {ex.Message}");
                failed++;
            }
        }
​
        return (passed, failed);
    }
}
​
[TestClass]
public class DNSServerTests
{
    [TestMethod]
    public void DomainNameFromDNSFormat_ValidInput_ReturnsCorrectDomainName()
    {
        byte[] data = { 3, 116, 101, 115, 116, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 };
        int offset = 0;
        int newOffset;
        string expected = "test.example.com";
        string actual = DNSServer.DomainNameFromDNSFormat(data, offset, out newOffset);
        Assert.AreEqual(expected, actual);
        Assert.AreEqual(18, newOffset);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void DomainNameFromDNSFormat_NullData_ThrowsArgumentException()
    {
        byte[] data = null;
        int offset = 0;
        int newOffset;
        DNSServer.DomainNameFromDNSFormat(data, offset, out newOffset);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void DomainNameFromDNSFormat_EmptyData_ThrowsArgumentException()
    {
        byte[] data = new byte[0];
        int offset = 0;
        int newOffset;
        DNSServer.DomainNameFromDNSFormat(data, offset, out newOffset);
    }
    
    [TestMethod]
    public void DomainNameToDNSFormat_ValidInput_ReturnsCorrectBytes()
    {
        string domainName = "test.example.com";
        byte[] expected = { 3, 116, 101, 115, 116, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 };
        byte[] actual = DNSServer.DomainNameToDNSFormat(domainName);
        CollectionAssert.AreEqual(expected, actual);
    }
    
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void DomainNameToDNSFormat_NullDomainName_ThrowsArgumentNullException()
    {
        DNSServer.DomainNameToDNSFormat(null);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void DomainNameToDNSFormat_EmptyDomainName_ThrowsArgumentNullException()
    {
        DNSServer.DomainNameToDNSFormat("");
    }
​
    [TestMethod]
    public void IPAddressToBytes_ValidIP_ReturnsCorrectBytes()
    {
        string ipAddress = "192.168.1.1";
        byte[] expected = { 192, 168, 1, 1 };
        byte[] actual = DNSServer.IPAddressToBytes(ipAddress);
        CollectionAssert.AreEqual(expected, actual);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void IPAddressToBytes_NullIP_ThrowsArgumentNullException()
    {
        DNSServer.IPAddressToBytes(null);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void IPAddressToBytes_EmptyIP_ThrowsArgumentNullException()
    {
        DNSServer.IPAddressToBytes("");
    }
​
    [TestMethod]
    [ExpectedException(typeof(FormatException))]
    public void IPAddressToBytes_InvalidIP_ThrowsFormatException()
    {
        DNSServer.IPAddressToBytes("invalid ip");
    }
    
    [TestMethod]
    public void BytesToIPAddress_ValidBytes_ReturnsCorrectIPAddress()
    {
        byte[] bytes = { 192, 168, 1, 1 };
        string expected = "192.168.1.1";
        string actual = DNSServer.BytesToIPAddress(bytes);
        Assert.AreEqual(expected, actual);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void BytesToIPAddress_NullBytes_ThrowsArgumentNullException()
    {
        DNSServer.BytesToIPAddress(null);
    }
    
    [TestMethod]
    public void CreateDNSPacket_ValidInputWithAnswer_ReturnsCorrectPacket()
    {
      DNSHeader header = new DNSHeader { Id = 1, Flags = 0, QuestionCount = 1, AnswerCount = 1, AuthorityCount = 0, AdditionalCount = 0 };
      DNSQuestion question = new DNSQuestion { QNAME = "example.com", QTYPE = 1, QCLASS = 1 };
      DNSAnswer answer = new DNSAnswer { NAME = "example.com", TYPE = 1, CLASS = 1, TTL = 60, RDLENGTH = 4, RDATA = "192.168.1.1" };
      byte[] packet = DNSServer.CreateDNSPacket(header, question, answer);
      
      Assert.IsNotNull(packet);
      Assert.IsTrue(packet.Length > 0);
    }
​
    [TestMethod]
    public void CreateDNSPacket_ValidInputWithoutAnswer_ReturnsCorrectPacket()
    {
        DNSHeader header = new DNSHeader { Id = 1, Flags = 0, QuestionCount = 1, AnswerCount = 0, AuthorityCount = 0, AdditionalCount = 0 };
        DNSQuestion question = new DNSQuestion { QNAME = "example.com", QTYPE = 1, QCLASS = 1 };
        
        byte[] packet = DNSServer.CreateDNSPacket(header, question, null);
​
        Assert.IsNotNull(packet);
        Assert.IsTrue(packet.Length > 0);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void CreateDNSPacket_NullQuestion_ThrowsArgumentNullException()
    {
        DNSHeader header = new DNSHeader();
        DNSAnswer answer = new DNSAnswer();
        DNSServer.CreateDNSPacket(header, default, answer);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void CreateDNSPacket_NullAnswerProperties_ThrowsArgumentNullException()
    {
        DNSHeader header = new DNSHeader();
        DNSQuestion question = new DNSQuestion { QNAME = "example.com" };
        DNSAnswer answer = new DNSAnswer { NAME = null, RDATA = null };
        DNSServer.CreateDNSPacket(header, question, answer);
    }
​
    [TestMethod]
    public void ParseDNSHeader_ValidData_ReturnsCorrectHeader()
    {
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C };
        DNSHeader expected = new DNSHeader { Id = 0x0201, Flags = 0x0403, QuestionCount = 0x0605, AnswerCount = 0x0807, AuthorityCount = 0x0A09, AdditionalCount = 0x0C0B };
        DNSHeader actual = DNSServer.ParseDNSHeader(data);
        Assert.AreEqual(expected.Id, BitConverter.ToUInt16(BitConverter.GetBytes(actual.Id).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.Flags, BitConverter.ToUInt16(BitConverter.GetBytes(actual.Flags).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.QuestionCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.QuestionCount).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.AnswerCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.AnswerCount).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.AuthorityCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.AuthorityCount).Reverse().ToArray(), 0));
        Assert.AreEqual(expected.AdditionalCount, BitConverter.ToUInt16(BitConverter.GetBytes(actual.AdditionalCount).Reverse().ToArray(), 0));
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ParseDNSHeader_NullData_ThrowsArgumentException()
    {
        DNSServer.ParseDNSHeader(null);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentException))]
    public void ParseDNSHeader_ShortData_ThrowsArgumentException()
    {
        byte[] data = new byte[11];
        DNSServer.ParseDNSHeader(data);
    }
​
​
    [TestMethod]
    public void ParseDNSQuestion_ValidData_ReturnsCorrectQuestion()
    {
      byte[] data = { 3, 116, 101, 115, 116, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0, 0, 1, 0, 1 };
      int offset = 0;
      int newOffset;
​
      DNSQuestion expected = new DNSQuestion { QNAME = "test.example.com", QTYPE = 1, QCLASS = 1 };
      DNSQuestion actual = DNSServer.ParseDNSQuestion(data, offset, out newOffset);
​
      Assert.AreEqual(expected.QNAME, actual.QNAME);
      Assert.AreEqual(expected.QTYPE, actual.QTYPE);
      Assert.AreEqual(expected.QCLASS, actual.QCLASS);
      Assert.AreEqual(22, newOffset);
    }
​
    [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void ParseDNSQuestion_NullData_ThrowsArgumentNullException()
    {
      DNSServer.ParseDNSQuestion(null, 0, out _);
    }
​
    [TestMethod]
    public void ResolveDNSQuery_ExistingDomain_ReturnsCorrectAnswer()
    {
        string domainName = "example.com";
        DNSAnswer? expected = new DNSAnswer { NAME = "example.com", TYPE = 1, CLASS = 1, TTL = 60, RDLENGTH = 4, RDATA = "192.168.1.1" };
        DNSAnswer? actual = DNSServer.ResolveDNSQuery(domainName);
        Assert.AreEqual(expected.Value.NAME, actual.Value.NAME);
        Assert.AreEqual(expected.Value.TYPE, actual.Value.TYPE);
        Assert.AreEqual(expected.Value.CLASS, actual.Value.CLASS);
        Assert.AreEqual(expected.Value.TTL, actual.Value.TTL);
        Assert.AreEqual(expected.Value.RDLENGTH, actual.Value.RDLENGTH);
        Assert.AreEqual(expected.Value.RDATA, actual.Value.RDATA);
    }
​
    [TestMethod]
    public void ResolveDNSQuery_NonExistingDomain_ReturnsNull()
    {
        string domainName = "nonexistent.com";
        DNSAnswer? actual = DNSServer.ResolveDNSQuery(domainName);
        Assert.IsNull(actual);
    }
        [TestMethod]
    [ExpectedException(typeof(ArgumentNullException))]
    public void ResolveDNSQuery_NullDomainName_ThrowsArgumentNullException()
    {
      DNSServer.ResolveDNSQuery(null);
    }
}
​

Hello world!

Cached Result
Last Run:	7:54:54 pm
Compile:	0.106s
Execute:	0s
Memory:	0b
CPU:	0.016s

View IL Code