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

Task 455 | Step 2 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;
using static DNSServer;

public class DNSServer
{
    private const int DNSPort = 53;
    private static Dictionary<string, string> _records; // Domain -> IP

    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 static string ConvertDomainNameFromDNSFormat(byte[] dnsFormat, int startIndex, out int bytesRead)
    {
        StringBuilder domainName = new StringBuilder();
        int index = startIndex;
        byte length;

        while ((length = dnsFormat[index++]) != 0)
        {
            if (domainName.Length > 0)
            {
                domainName.Append('.');
            }
            domainName.Append(Encoding.ASCII.GetString(dnsFormat, index, length));
            index += length;
        }
        bytesRead = index - startIndex;
        return domainName.ToString();
    }

    public static byte[] ConvertDomainNameToDNSFormat(string domainName)
    {
        List<byte> dnsFormat = new List<byte>();
        foreach (string label in domainName.Split('.'))
        {
            dnsFormat.Add((byte)label.Length);
            dnsFormat.AddRange(Encoding.ASCII.GetBytes(label));
        }
        dnsFormat.Add(0); // Null terminator
        return dnsFormat.ToArray();
    }

    public static byte[] ConvertIPv4AddressToBytes(string ipAddress)
    {
        return IPAddress.Parse(ipAddress).GetAddressBytes();
    }
    
    public static string ConvertBytesToIPv4Address(byte[] bytes) {
        return new IPAddress(bytes).ToString();
    }


    public static byte[] CreateResponsePacket(DNSHeader requestHeader, DNSQuestion requestQuestion, string ipAddress)
    {
        // Create the response header
        DNSHeader responseHeader = new DNSHeader
        {
            Id = requestHeader.Id,
            Flags = (ushort)0x8180, // Standard response, no errors
            QuestionCount = 1,
            AnswerCount = 1,
            AuthorityCount = 0,
            AdditionalCount = 0
        };

        // Create the answer record
        DNSAnswer responseAnswer = new DNSAnswer
        {
            NAME = requestQuestion.QNAME,
            TYPE = 1, // A record
            CLASS = 1, // IN class
            TTL = 60, // Time to live (in seconds)
            RDLENGTH = 4, // Length of IPv4 address
            RDATA = ipAddress
        };

        // Convert structures to byte arrays
        byte[] headerBytes = new byte[12];
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.Id).Reverse().ToArray(), 0, headerBytes, 0, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.Flags).Reverse().ToArray(), 0, headerBytes, 2, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.QuestionCount).Reverse().ToArray(), 0, headerBytes, 4, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AnswerCount).Reverse().ToArray(), 0, headerBytes, 6, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AuthorityCount).Reverse().ToArray(), 0, headerBytes, 8, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AdditionalCount).Reverse().ToArray(), 0, headerBytes, 10, 2);


        byte[] questionBytes = ConvertDomainNameToDNSFormat(requestQuestion.QNAME);
        questionBytes = questionBytes.Concat(BitConverter.GetBytes(requestQuestion.QTYPE).Reverse().ToArray()).ToArray();
        questionBytes = questionBytes.Concat(BitConverter.GetBytes(requestQuestion.QCLASS).Reverse().ToArray()).ToArray();
        
        byte[] answerBytes = ConvertDomainNameToDNSFormat(responseAnswer.NAME);
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.TYPE).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.CLASS).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.TTL).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.RDLENGTH).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(ConvertIPv4AddressToBytes(responseAnswer.RDATA)).ToArray();

        // Combine all parts
        return headerBytes.Concat(questionBytes).Concat(answerBytes).ToArray();
    }

    public static DNSHeader ParseDNSHeader(byte[] query) {
      DNSHeader header = new DNSHeader
      {
            Id = (ushort)(query[0] << 8 | query[1]),
            Flags = (ushort)(query[2] << 8 | query[3]),
            QuestionCount = (ushort)(query[4] << 8 | query[5]),
            AnswerCount = (ushort)(query[6] << 8 | query[7]),
            AuthorityCount = (ushort)(query[8] << 8 | query[9]),
            AdditionalCount = (ushort)(query[10] << 8 | query[11])
      };
      return header;
    }

     public static DNSQuestion ParseDNSQuestion(byte[] query, int offset, out int bytesRead)
     {
        
        string qname = ConvertDomainNameFromDNSFormat(query, offset, out bytesRead);
        offset += bytesRead;
        
        DNSQuestion question = new DNSQuestion
        {
            QNAME = qname,
            QTYPE = (ushort)(query[offset] << 8 | query[offset+1]),
            QCLASS = (ushort)(query[offset + 2] << 8 | query[offset + 3])
        };
        bytesRead += 4;
        return question;
    }

    public static void Start()
    {
        _records = new Dictionary<string, string>
        {
            { "example.com", "192.168.1.1" },
            { "google.com", "172.217.160.142" },
            { "microsoft.com", "13.77.161.179" }
        };

        UdpClient udpServer = new UdpClient(DNSPort);
        Console.WriteLine("DNS Server listening on port " + DNSPort);

        while (true)
        {
            IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
            byte[] query = udpServer.Receive(ref remoteEndPoint);

            DNSHeader requestHeader = ParseDNSHeader(query);
            
            int bytesRead;
            DNSQuestion requestQuestion = ParseDNSQuestion(query, 12, out bytesRead);

            Console.WriteLine($"Received query for: {requestQuestion.QNAME}");

            string ipAddress;
            if (_records.TryGetValue(requestQuestion.QNAME, out ipAddress))
            {

                byte[] responsePacket = CreateResponsePacket(requestHeader, requestQuestion, ipAddress);
                udpServer.Send(responsePacket, responsePacket.Length, remoteEndPoint);
                Console.WriteLine($"Sent response for {requestQuestion.QNAME}: {ipAddress}");
            }
            else
            {
                // Handle unknown domain (in a real server, you'd probably forward the query)
                Console.WriteLine($"Unknown domain: {requestQuestion.QNAME}");
            }
        }
    }

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 ConvertDomainNameFromDNSFormat_ValidInput_ReturnsCorrectDomainName()
    {
        // Arrange
        byte[] dnsFormat = { 3, 103, 111, 111, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 }; // "google.com"
        int startIndex = 0;
        int bytesRead;

        // Act
        string domainName = DNSServer.ConvertDomainNameFromDNSFormat(dnsFormat, startIndex, out bytesRead);

        // Assert
        Assert.AreEqual("google.com", domainName);
        Assert.AreEqual(17, bytesRead);
    }

    [TestMethod]
    public void ConvertDomainNameFromDNSFormat_EmptyDomain_ReturnsEmptyString()
    {
      byte[] dnsFormat = { 0 };
      int startIndex = 0;
      int bytesRead;

      string domainName = DNSServer.ConvertDomainNameFromDNSFormat(dnsFormat, startIndex, out bytesRead);

      Assert.AreEqual("", domainName);
      Assert.AreEqual(1, bytesRead);
    }
    
    [TestMethod]
    public void ConvertDomainNameToDNSFormat_ValidDomain_ReturnsCorrectByteArray()
    {
        // Arrange
        string domainName = "example.com";

        // Act
        byte[] dnsFormat = DNSServer.ConvertDomainNameToDNSFormat(domainName);

        // Assert
        byte[] expected = { 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 };
        CollectionAssert.AreEqual(expected, dnsFormat);
    }
     [TestMethod]
    public void ConvertDomainNameToDNSFormat_EmptyDomain_ReturnsCorrectByteArray()
    {
      string domainName = "";
      byte[] dnsFormat = DNSServer.ConvertDomainNameToDNSFormat(domainName);

      byte[] expected = { 0 };
       CollectionAssert.AreEqual(expected, dnsFormat);

    }

    [TestMethod]
    public void ConvertIPv4AddressToBytes_ValidIPAddress_ReturnsCorrectByteArray()
    {
        // Arrange
        string ipAddress = "192.168.1.1";

        // Act
        byte[] ipBytes = DNSServer.ConvertIPv4AddressToBytes(ipAddress);

        // Assert
        byte[] expected = { 192, 168, 1, 1 };
        CollectionAssert.AreEqual(expected, ipBytes);
    }

    [TestMethod]
    public void ConvertBytesToIPv4Address_ValidBytes_ReturnsCorrectIpAddress() {
        byte[] bytes = { 192, 168, 1, 1 };
        string ipAddress = DNSServer.ConvertBytesToIPv4Address(bytes);
        Assert.AreEqual("192.168.1.1", ipAddress);
    }

    [TestMethod]
    public void CreateResponsePacket_ValidInput_ReturnsCorrectlyFormattedPacket()
    {
        // Arrange
        DNSHeader requestHeader = new DNSHeader { Id = 12345 };
        DNSQuestion requestQuestion = new DNSQuestion { QNAME = "example.com", QTYPE = 1, QCLASS = 1 };
        string ipAddress = "192.168.1.1";

        // Act
        byte[] responsePacket = DNSServer.CreateResponsePacket(requestHeader, requestQuestion, ipAddress);

        // Assert (check key parts, not the whole array)
        // Check ID
        Assert.AreEqual(12345, (ushort)(responsePacket[0] << 8 | responsePacket[1]));
        //Check Flags
        Assert.AreEqual(0x8180, (ushort)(responsePacket[2] << 8 | responsePacket[3]));
        // Check Question Count
        Assert.AreEqual(1, (ushort)(responsePacket[4] << 8 | responsePacket[5]));
        // Check Answer Count
        Assert.AreEqual(1, (ushort)(responsePacket[6] << 8 | responsePacket[7]));

        // Check IP Address in the answer
        Assert.AreEqual(192, responsePacket[responsePacket.Length - 4]);
        Assert.AreEqual(168, responsePacket[responsePacket.Length - 3]);
        Assert.AreEqual(1, responsePacket[responsePacket.Length - 2]);
        Assert.AreEqual(1, responsePacket[responsePacket.Length - 1]);
    }
    [TestMethod]
    public void ParseDNSHeader_ValidQuery_ParsesHeaderCorrectly()
    {
      byte[] query = new byte[12] {0x30, 0x39, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

      DNSHeader header = DNSServer.ParseDNSHeader(query);

      Assert.AreEqual(12345, header.Id);
      Assert.AreEqual(256, header.Flags);
      Assert.AreEqual(1, header.QuestionCount);
      Assert.AreEqual(0, header.AnswerCount);
      Assert.AreEqual(0, header.AuthorityCount);
      Assert.AreEqual(0, header.AdditionalCount);

    }
    [TestMethod]
    public void ParseDNSQuestion_ValidQuery_ParsesQuestionCorrectly() {
      byte[] query = {
            // Header (12 bytes, example)
            0x30, 0x39, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            // Question section
            0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // example.com
            0x00, 0x01, // QTYPE (A record)
            0x00, 0x01  // QCLASS (IN class)
        };
      int offset = 12;
      int bytesRead;
      DNSQuestion question = DNSServer.ParseDNSQuestion(query, offset, out bytesRead);

      Assert.AreEqual("example.com", question.QNAME);
      Assert.AreEqual(1, question.QTYPE);
      Assert.AreEqual(1, question.QCLASS);
      Assert.AreEqual(17, bytesRead);

    }
}

​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;
using static DNSServer;
​
public class DNSServer
{
    private const int DNSPort = 53;
    private static Dictionary<string, string> _records; // Domain -> IP
​
    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 static string ConvertDomainNameFromDNSFormat(byte[] dnsFormat, int startIndex, out int bytesRead)
    {
        StringBuilder domainName = new StringBuilder();
        int index = startIndex;
        byte length;
​
        while ((length = dnsFormat[index++]) != 0)
        {
            if (domainName.Length > 0)
            {
                domainName.Append('.');
            }
            domainName.Append(Encoding.ASCII.GetString(dnsFormat, index, length));
            index += length;
        }
        bytesRead = index - startIndex;
        return domainName.ToString();
    }
​
    public static byte[] ConvertDomainNameToDNSFormat(string domainName)
    {
        List<byte> dnsFormat = new List<byte>();
        foreach (string label in domainName.Split('.'))
        {
            dnsFormat.Add((byte)label.Length);
            dnsFormat.AddRange(Encoding.ASCII.GetBytes(label));
        }
        dnsFormat.Add(0); // Null terminator
        return dnsFormat.ToArray();
    }
​
    public static byte[] ConvertIPv4AddressToBytes(string ipAddress)
    {
        return IPAddress.Parse(ipAddress).GetAddressBytes();
    }
    
    public static string ConvertBytesToIPv4Address(byte[] bytes) {
        return new IPAddress(bytes).ToString();
    }
​
​
    public static byte[] CreateResponsePacket(DNSHeader requestHeader, DNSQuestion requestQuestion, string ipAddress)
    {
        // Create the response header
        DNSHeader responseHeader = new DNSHeader
        {
            Id = requestHeader.Id,
            Flags = (ushort)0x8180, // Standard response, no errors
            QuestionCount = 1,
            AnswerCount = 1,
            AuthorityCount = 0,
            AdditionalCount = 0
        };
​
        // Create the answer record
        DNSAnswer responseAnswer = new DNSAnswer
        {
            NAME = requestQuestion.QNAME,
            TYPE = 1, // A record
            CLASS = 1, // IN class
            TTL = 60, // Time to live (in seconds)
            RDLENGTH = 4, // Length of IPv4 address
            RDATA = ipAddress
        };
​
        // Convert structures to byte arrays
        byte[] headerBytes = new byte[12];
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.Id).Reverse().ToArray(), 0, headerBytes, 0, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.Flags).Reverse().ToArray(), 0, headerBytes, 2, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.QuestionCount).Reverse().ToArray(), 0, headerBytes, 4, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AnswerCount).Reverse().ToArray(), 0, headerBytes, 6, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AuthorityCount).Reverse().ToArray(), 0, headerBytes, 8, 2);
        Buffer.BlockCopy(BitConverter.GetBytes(responseHeader.AdditionalCount).Reverse().ToArray(), 0, headerBytes, 10, 2);
​
​
        byte[] questionBytes = ConvertDomainNameToDNSFormat(requestQuestion.QNAME);
        questionBytes = questionBytes.Concat(BitConverter.GetBytes(requestQuestion.QTYPE).Reverse().ToArray()).ToArray();
        questionBytes = questionBytes.Concat(BitConverter.GetBytes(requestQuestion.QCLASS).Reverse().ToArray()).ToArray();
        
        byte[] answerBytes = ConvertDomainNameToDNSFormat(responseAnswer.NAME);
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.TYPE).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.CLASS).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.TTL).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(BitConverter.GetBytes(responseAnswer.RDLENGTH).Reverse().ToArray()).ToArray();
        answerBytes = answerBytes.Concat(ConvertIPv4AddressToBytes(responseAnswer.RDATA)).ToArray();
​
        // Combine all parts
        return headerBytes.Concat(questionBytes).Concat(answerBytes).ToArray();
    }
​
    public static DNSHeader ParseDNSHeader(byte[] query) {
      DNSHeader header = new DNSHeader
      {
            Id = (ushort)(query[0] << 8 | query[1]),
            Flags = (ushort)(query[2] << 8 | query[3]),
            QuestionCount = (ushort)(query[4] << 8 | query[5]),
            AnswerCount = (ushort)(query[6] << 8 | query[7]),
            AuthorityCount = (ushort)(query[8] << 8 | query[9]),
            AdditionalCount = (ushort)(query[10] << 8 | query[11])
      };
      return header;
    }
​
     public static DNSQuestion ParseDNSQuestion(byte[] query, int offset, out int bytesRead)
     {
        
        string qname = ConvertDomainNameFromDNSFormat(query, offset, out bytesRead);
        offset += bytesRead;
        
        DNSQuestion question = new DNSQuestion
        {
            QNAME = qname,
            QTYPE = (ushort)(query[offset] << 8 | query[offset+1]),
            QCLASS = (ushort)(query[offset + 2] << 8 | query[offset + 3])
        };
        bytesRead += 4;
        return question;
    }
​
    public static void Start()
    {
        _records = new Dictionary<string, string>
        {
            { "example.com", "192.168.1.1" },
            { "google.com", "172.217.160.142" },
            { "microsoft.com", "13.77.161.179" }
        };
​
        UdpClient udpServer = new UdpClient(DNSPort);
        Console.WriteLine("DNS Server listening on port " + DNSPort);
​
        while (true)
        {
            IPEndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0);
            byte[] query = udpServer.Receive(ref remoteEndPoint);
​
            DNSHeader requestHeader = ParseDNSHeader(query);
            
            int bytesRead;
            DNSQuestion requestQuestion = ParseDNSQuestion(query, 12, out bytesRead);
​
            Console.WriteLine($"Received query for: {requestQuestion.QNAME}");
​
            string ipAddress;
            if (_records.TryGetValue(requestQuestion.QNAME, out ipAddress))
            {
​
                byte[] responsePacket = CreateResponsePacket(requestHeader, requestQuestion, ipAddress);
                udpServer.Send(responsePacket, responsePacket.Length, remoteEndPoint);
                Console.WriteLine($"Sent response for {requestQuestion.QNAME}: {ipAddress}");
            }
            else
            {
                // Handle unknown domain (in a real server, you'd probably forward the query)
                Console.WriteLine($"Unknown domain: {requestQuestion.QNAME}");
            }
        }
    }
​
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 ConvertDomainNameFromDNSFormat_ValidInput_ReturnsCorrectDomainName()
    {
        // Arrange
        byte[] dnsFormat = { 3, 103, 111, 111, 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 }; // "google.com"
        int startIndex = 0;
        int bytesRead;
​
        // Act
        string domainName = DNSServer.ConvertDomainNameFromDNSFormat(dnsFormat, startIndex, out bytesRead);
​
        // Assert
        Assert.AreEqual("google.com", domainName);
        Assert.AreEqual(17, bytesRead);
    }
​
    [TestMethod]
    public void ConvertDomainNameFromDNSFormat_EmptyDomain_ReturnsEmptyString()
    {
      byte[] dnsFormat = { 0 };
      int startIndex = 0;
      int bytesRead;
​
      string domainName = DNSServer.ConvertDomainNameFromDNSFormat(dnsFormat, startIndex, out bytesRead);
​
      Assert.AreEqual("", domainName);
      Assert.AreEqual(1, bytesRead);
    }
    
    [TestMethod]
    public void ConvertDomainNameToDNSFormat_ValidDomain_ReturnsCorrectByteArray()
    {
        // Arrange
        string domainName = "example.com";
​
        // Act
        byte[] dnsFormat = DNSServer.ConvertDomainNameToDNSFormat(domainName);
​
        // Assert
        byte[] expected = { 7, 101, 120, 97, 109, 112, 108, 101, 3, 99, 111, 109, 0 };
        CollectionAssert.AreEqual(expected, dnsFormat);
    }
     [TestMethod]
    public void ConvertDomainNameToDNSFormat_EmptyDomain_ReturnsCorrectByteArray()
    {
      string domainName = "";
      byte[] dnsFormat = DNSServer.ConvertDomainNameToDNSFormat(domainName);
​
      byte[] expected = { 0 };
       CollectionAssert.AreEqual(expected, dnsFormat);
​
    }
​
    [TestMethod]
    public void ConvertIPv4AddressToBytes_ValidIPAddress_ReturnsCorrectByteArray()
    {
        // Arrange
        string ipAddress = "192.168.1.1";
​
        // Act
        byte[] ipBytes = DNSServer.ConvertIPv4AddressToBytes(ipAddress);
​
        // Assert
        byte[] expected = { 192, 168, 1, 1 };
        CollectionAssert.AreEqual(expected, ipBytes);
    }
​
    [TestMethod]
    public void ConvertBytesToIPv4Address_ValidBytes_ReturnsCorrectIpAddress() {
        byte[] bytes = { 192, 168, 1, 1 };
        string ipAddress = DNSServer.ConvertBytesToIPv4Address(bytes);
        Assert.AreEqual("192.168.1.1", ipAddress);
    }
​
    [TestMethod]
    public void CreateResponsePacket_ValidInput_ReturnsCorrectlyFormattedPacket()
    {
        // Arrange
        DNSHeader requestHeader = new DNSHeader { Id = 12345 };
        DNSQuestion requestQuestion = new DNSQuestion { QNAME = "example.com", QTYPE = 1, QCLASS = 1 };
        string ipAddress = "192.168.1.1";
​
        // Act
        byte[] responsePacket = DNSServer.CreateResponsePacket(requestHeader, requestQuestion, ipAddress);
​
        // Assert (check key parts, not the whole array)
        // Check ID
        Assert.AreEqual(12345, (ushort)(responsePacket[0] << 8 | responsePacket[1]));
        //Check Flags
        Assert.AreEqual(0x8180, (ushort)(responsePacket[2] << 8 | responsePacket[3]));
        // Check Question Count
        Assert.AreEqual(1, (ushort)(responsePacket[4] << 8 | responsePacket[5]));
        // Check Answer Count
        Assert.AreEqual(1, (ushort)(responsePacket[6] << 8 | responsePacket[7]));
​
        // Check IP Address in the answer
        Assert.AreEqual(192, responsePacket[responsePacket.Length - 4]);
        Assert.AreEqual(168, responsePacket[responsePacket.Length - 3]);
        Assert.AreEqual(1, responsePacket[responsePacket.Length - 2]);
        Assert.AreEqual(1, responsePacket[responsePacket.Length - 1]);
    }
    [TestMethod]
    public void ParseDNSHeader_ValidQuery_ParsesHeaderCorrectly()
    {
      byte[] query = new byte[12] {0x30, 0x39, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
​
      DNSHeader header = DNSServer.ParseDNSHeader(query);
​
      Assert.AreEqual(12345, header.Id);
      Assert.AreEqual(256, header.Flags);
      Assert.AreEqual(1, header.QuestionCount);
      Assert.AreEqual(0, header.AnswerCount);
      Assert.AreEqual(0, header.AuthorityCount);
      Assert.AreEqual(0, header.AdditionalCount);
​
    }
    [TestMethod]
    public void ParseDNSQuestion_ValidQuery_ParsesQuestionCorrectly() {
      byte[] query = {
            // Header (12 bytes, example)
            0x30, 0x39, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
            // Question section
            0x07, 0x65, 0x78, 0x61, 0x6d, 0x70, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, // example.com
            0x00, 0x01, // QTYPE (A record)
            0x00, 0x01  // QCLASS (IN class)
        };
      int offset = 12;
      int bytesRead;
      DNSQuestion question = DNSServer.ParseDNSQuestion(query, offset, out bytesRead);
​
      Assert.AreEqual("example.com", question.QNAME);
      Assert.AreEqual(1, question.QTYPE);
      Assert.AreEqual(1, question.QCLASS);
      Assert.AreEqual(17, bytesRead);
​
    }
}

🔍 Discovering and Running Tests...

📌 Running tests in: DNSServerTests
  ❌ ConvertDomainNameFromDNSFormat_ValidInput_ReturnsCorrectDomainName FAILED: Assert.AreEqual failed. Expected:<google.com>. Actual:<goo.example.com>.
  ✅ ConvertDomainNameFromDNSFormat_EmptyDomain_ReturnsEmptyString PASSED
  ✅ ConvertDomainNameToDNSFormat_ValidDomain_ReturnsCorrectByteArray PASSED
  ❌ ConvertDomainNameToDNSFormat_EmptyDomain_ReturnsCorrectByteArray FAILED: CollectionAssert.AreEqual failed. Different number of elements.
  ✅ ConvertIPv4AddressToBytes_ValidIPAddress_ReturnsCorrectByteArray PASSED
  ✅ ConvertBytesToIPv4Address_ValidBytes_ReturnsCorrectIpAddress PASSED
  ✅ CreateResponsePacket_ValidInput_ReturnsCorrectlyFormattedPacket PASSED
  ✅ ParseDNSHeader_ValidQuery_ParsesHeaderCorrectly PASSED
  ✅ ParseDNSQuestion_ValidQuery_ParsesQuestionCorrectly PASSED

📊 FINAL SUMMARY:
✅ Total Passed: 7
❌ Total Failed: 2
📌 Total Tests: 9

✅ Test execution completed.

Cached Result
Last Run:	10:26:57 am
Compile:	0.046s
Execute:	0.09s
Memory:	6.59Mb
CPU:	0.136s

View IL Code