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

Task 455 | Step 1 Unit Tests Execution by Jomo Lumina

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

namespace DNSResolver
{
	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 readonly Dictionary<string, string> dnsRecords = new Dictionary<string, string>
		{
			{
				"example.com",
				"127.0.0.1"
			},
			{
				"google.com",
				"142.250.184.142"
			},
			{
				"test.example.com",
				"192.168.1.1"
			}
		};
		public static void StartServer()
		{
			UdpClient udpServer = new UdpClient(53);
			IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
			Console.WriteLine("DNS Server started. Listening on port 53...");
			while (true)
			{
				try
				{
					byte[] receivedBytes = udpServer.Receive(ref remoteEP);
					Console.WriteLine("Received query from " + remoteEP.Address.ToString());
					DNSHeader header = ParseHeader(receivedBytes);
					DNSQuestion question = ParseQuestion(receivedBytes, 12); // Start parsing question after the header (12 bytes)
					if (question.QTYPE == 1 && question.QCLASS == 1) // A record query
					{
						if (dnsRecords.ContainsKey(question.QNAME))
						{
							byte[] response = ConstructResponse(header, question);
							udpServer.Send(response, response.Length, remoteEP);
							Console.WriteLine("Responded with " + dnsRecords[question.QNAME]);
						}
						else
						{
							Console.WriteLine("Domain not found: " + question.QNAME);
						// Optionally send an error response.  For simplicity, we don't here.
						}
					}
					else
					{
						Console.WriteLine("Unsupported query type or class.");
					}
				}
				catch (Exception e)
				{
					Console.WriteLine("Exception: " + e.Message);
				}
			}
		}

		private static DNSHeader ParseHeader(byte[] data)
		{
			DNSHeader header = new DNSHeader();
			header.Id = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 0));
			header.Flags = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 2));
			header.QuestionCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 4));
			header.AnswerCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 6));
			header.AuthorityCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 8));
			header.AdditionalCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 10));
			return header;
		}

		private static DNSQuestion ParseQuestion(byte[] data, int offset)
		{
			DNSQuestion question = new DNSQuestion();
			question.QNAME = ConvertDnsNameToString(data, offset, out int endOfName);
			question.QTYPE = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, endOfName));
			question.QCLASS = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, endOfName + 2));
			return question;
		}

		private static byte[] ConstructResponse(DNSHeader header, DNSQuestion question)
		{
			// Construct header
			header.Flags |= 0x8000; // Set the "Response" flag.  Could be more sophisticated.
			header.AnswerCount = 1; // Indicate that we have one answer.
			byte[] headerBytes = new byte[12];
			Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.Id)), 0, headerBytes, 0, 2);
			Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.Flags)), 0, headerBytes, 2, 2);
			Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.QuestionCount)), 0, headerBytes, 4, 2);
			Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.AnswerCount)), 0, headerBytes, 6, 2);
			Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.AuthorityCount)), 0, headerBytes, 8, 2);
			Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.AdditionalCount)), 0, headerBytes, 10, 2);
			// Construct answer
			DNSAnswer answer = new DNSAnswer();
			answer.NAME = question.QNAME;
			answer.TYPE = 1; // A record
			answer.CLASS = 1; // IN class
			answer.TTL = 60; // 60 seconds
			answer.RDATA = dnsRecords[question.QNAME];
			answer.RDLENGTH = 4; // IPv4 address is 4 bytes
			// Construct the response packet
			List<byte> response = new List<byte>();
			response.AddRange(headerBytes);
			// Add the question (copy it from the request for simplicity)
			response.AddRange(ConvertStringToDnsName(question.QNAME));
			response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)question.QTYPE)));
			response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)question.QCLASS)));
			// Add the answer record
			response.AddRange(ConvertStringToDnsName(answer.NAME)); // Domain name in DNS format
			response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)answer.TYPE))); // Type
			response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)answer.CLASS))); // Class
			response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)answer.TTL))); // TTL
			response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)answer.RDLENGTH))); // RDLENGTH
			response.AddRange(IPAddress.Parse(answer.RDATA).GetAddressBytes()); // RDATA
			return response.ToArray();
		}

		public static byte[] ConvertStringToDnsName(string domain)
		{
			List<byte> dnsName = new List<byte>();
			string[] labels = domain.Split('.');
			foreach (string label in labels)
			{
				dnsName.Add((byte)label.Length);
				dnsName.AddRange(Encoding.ASCII.GetBytes(label));
			}

			dnsName.Add(0x00); // Null terminator
			return dnsName.ToArray();
		}

		public static string ConvertDnsNameToString(byte[] data, int offset, out int endOfName)
		{
			StringBuilder domainName = new StringBuilder();
			int current = offset;
			int labelLength = data[current];
			while (labelLength != 0)
			{
				for (int i = 0; i < labelLength; i++)
				{
					domainName.Append((char)data[current + i + 1]);
				}

				current += labelLength + 1;
				labelLength = data[current];
				if (labelLength != 0)
				{
					domainName.Append('.');
				}
			}

			endOfName = current + 1; // Position after the null terminator
			return domainName.ToString();
		}

		public static string ConvertIPAddressToString(byte[] ipBytes)
		{
			return new IPAddress(ipBytes).ToString();
		}

		public static byte[] ConvertStringToIPAddress(string ipString)
		{
			return IPAddress.Parse(ipString).GetAddressBytes();
		}

		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 ConvertStringToDnsName_ValidDomain_ReturnsDnsNameBytes()
		{
			string domain = "test.example.com";
			byte[] expected = new byte[]
			{
				4,
				(byte)'t',
				(byte)'e',
				(byte)'s',
				(byte)'t',
				7,
				(byte)'e',
				(byte)'x',
				(byte)'a',
				(byte)'m',
				(byte)'p',
				(byte)'l',
				(byte)'e',
				3,
				(byte)'c',
				(byte)'o',
				(byte)'m',
				0
			};
			byte[] actual = DNSServer.ConvertStringToDnsName(domain);
			CollectionAssert.AreEqual(expected, actual);
		}

		[TestMethod]
		public void ConvertStringToDnsName_RootDomain_ReturnsDnsNameBytes()
		{
			string domain = "com";
			byte[] expected = new byte[]
			{
				3,
				(byte)'c',
				(byte)'o',
				(byte)'m',
				0
			};
			byte[] actual = DNSServer.ConvertStringToDnsName(domain);
			CollectionAssert.AreEqual(expected, actual);
		}

		[TestMethod]
		public void ConvertDnsNameToString_ValidDnsName_ReturnsDomainString()
		{
			byte[] dnsName = new byte[]
			{
				4,
				(byte)'t',
				(byte)'e',
				(byte)'s',
				(byte)'t',
				7,
				(byte)'e',
				(byte)'x',
				(byte)'a',
				(byte)'m',
				(byte)'p',
				(byte)'l',
				(byte)'e',
				3,
				(byte)'c',
				(byte)'o',
				(byte)'m',
				0
			};
			string expected = "test.example.com";
			string actual = DNSServer.ConvertDnsNameToString(dnsName, 0, out int endOfName);
			Assert.AreEqual(expected, actual);
			Assert.AreEqual(dnsName.Length, endOfName);
		}

		[TestMethod]
		public void ConvertDnsNameToString_RootDomainName_ReturnsDomainString()
		{
			byte[] dnsName = new byte[]
			{
				3,
				(byte)'c',
				(byte)'o',
				(byte)'m',
				0
			};
			string expected = "com";
			string actual = DNSServer.ConvertDnsNameToString(dnsName, 0, out int endOfName);
			Assert.AreEqual(expected, actual);
			Assert.AreEqual(dnsName.Length, endOfName);
		}

		[TestMethod]
		public void ConvertIPAddressToString_ValidIPAddressBytes_ReturnsIPAddressString()
		{
			byte[] ipBytes = new byte[]
			{
				127,
				0,
				0,
				1
			};
			string expected = "127.0.0.1";
			string actual = DNSServer.ConvertIPAddressToString(ipBytes);
			Assert.AreEqual(expected, actual);
		}

		[TestMethod]
		public void ConvertStringToIPAddress_ValidIPAddressString_ReturnsIPAddressBytes()
		{
			string ipString = "192.168.1.1";
			byte[] expected = new byte[]
			{
				192,
				168,
				1,
				1
			};
			byte[] actual = DNSServer.ConvertStringToIPAddress(ipString);
			CollectionAssert.AreEqual(expected, actual);
		}
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Linq;
using System.Reflection;
using Microsoft.VisualStudio.TestTools.UnitTesting;
​
namespace DNSResolver
{
    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 readonly Dictionary<string, string> dnsRecords = new Dictionary<string, string>
        {
            {
                "example.com",
                "127.0.0.1"
            },
            {
                "google.com",
                "142.250.184.142"
            },
            {
                "test.example.com",
                "192.168.1.1"
            }
        };
        public static void StartServer()
        {
            UdpClient udpServer = new UdpClient(53);
            IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0);
            Console.WriteLine("DNS Server started. Listening on port 53...");
            while (true)
            {
                try
                {
                    byte[] receivedBytes = udpServer.Receive(ref remoteEP);
                    Console.WriteLine("Received query from " + remoteEP.Address.ToString());
                    DNSHeader header = ParseHeader(receivedBytes);
                    DNSQuestion question = ParseQuestion(receivedBytes, 12); // Start parsing question after the header (12 bytes)
                    if (question.QTYPE == 1 && question.QCLASS == 1) // A record query
                    {
                        if (dnsRecords.ContainsKey(question.QNAME))
                        {
                            byte[] response = ConstructResponse(header, question);
                            udpServer.Send(response, response.Length, remoteEP);
                            Console.WriteLine("Responded with " + dnsRecords[question.QNAME]);
                        }
                        else
                        {
                            Console.WriteLine("Domain not found: " + question.QNAME);
                        // Optionally send an error response.  For simplicity, we don't here.
                        }
                    }
                    else
                    {
                        Console.WriteLine("Unsupported query type or class.");
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine("Exception: " + e.Message);
                }
            }
        }
​
        private static DNSHeader ParseHeader(byte[] data)
        {
            DNSHeader header = new DNSHeader();
            header.Id = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 0));
            header.Flags = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 2));
            header.QuestionCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 4));
            header.AnswerCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 6));
            header.AuthorityCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 8));
            header.AdditionalCount = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, 10));
            return header;
        }
​
        private static DNSQuestion ParseQuestion(byte[] data, int offset)
        {
            DNSQuestion question = new DNSQuestion();
            question.QNAME = ConvertDnsNameToString(data, offset, out int endOfName);
            question.QTYPE = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, endOfName));
            question.QCLASS = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(data, endOfName + 2));
            return question;
        }
​
        private static byte[] ConstructResponse(DNSHeader header, DNSQuestion question)
        {
            // Construct header
            header.Flags |= 0x8000; // Set the "Response" flag.  Could be more sophisticated.
            header.AnswerCount = 1; // Indicate that we have one answer.
            byte[] headerBytes = new byte[12];
            Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.Id)), 0, headerBytes, 0, 2);
            Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.Flags)), 0, headerBytes, 2, 2);
            Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.QuestionCount)), 0, headerBytes, 4, 2);
            Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.AnswerCount)), 0, headerBytes, 6, 2);
            Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.AuthorityCount)), 0, headerBytes, 8, 2);
            Array.Copy(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)header.AdditionalCount)), 0, headerBytes, 10, 2);
            // Construct answer
            DNSAnswer answer = new DNSAnswer();
            answer.NAME = question.QNAME;
            answer.TYPE = 1; // A record
            answer.CLASS = 1; // IN class
            answer.TTL = 60; // 60 seconds
            answer.RDATA = dnsRecords[question.QNAME];
            answer.RDLENGTH = 4; // IPv4 address is 4 bytes
            // Construct the response packet
            List<byte> response = new List<byte>();
            response.AddRange(headerBytes);
            // Add the question (copy it from the request for simplicity)
            response.AddRange(ConvertStringToDnsName(question.QNAME));
            response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)question.QTYPE)));
            response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)question.QCLASS)));
            // Add the answer record
            response.AddRange(ConvertStringToDnsName(answer.NAME)); // Domain name in DNS format
            response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)answer.TYPE))); // Type
            response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)answer.CLASS))); // Class
            response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((int)answer.TTL))); // TTL
            response.AddRange(BitConverter.GetBytes(IPAddress.HostToNetworkOrder((short)answer.RDLENGTH))); // RDLENGTH
            response.AddRange(IPAddress.Parse(answer.RDATA).GetAddressBytes()); // RDATA
            return response.ToArray();
        }
​
        public static byte[] ConvertStringToDnsName(string domain)
        {
            List<byte> dnsName = new List<byte>();
            string[] labels = domain.Split('.');
            foreach (string label in labels)
            {
                dnsName.Add((byte)label.Length);
                dnsName.AddRange(Encoding.ASCII.GetBytes(label));
            }
​
            dnsName.Add(0x00); // Null terminator
            return dnsName.ToArray();
        }
​
        public static string ConvertDnsNameToString(byte[] data, int offset, out int endOfName)
        {
            StringBuilder domainName = new StringBuilder();
            int current = offset;
            int labelLength = data[current];
            while (labelLength != 0)
            {
                for (int i = 0; i < labelLength; i++)
                {
                    domainName.Append((char)data[current + i + 1]);
                }
​
                current += labelLength + 1;
                labelLength = data[current];
                if (labelLength != 0)
                {
                    domainName.Append('.');
                }
            }
​
            endOfName = current + 1; // Position after the null terminator
            return domainName.ToString();
        }
​
        public static string ConvertIPAddressToString(byte[] ipBytes)
        {
            return new IPAddress(ipBytes).ToString();
        }
​
        public static byte[] ConvertStringToIPAddress(string ipString)
        {
            return IPAddress.Parse(ipString).GetAddressBytes();
        }
​
        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 ConvertStringToDnsName_ValidDomain_ReturnsDnsNameBytes()
        {
            string domain = "test.example.com";
            byte[] expected = new byte[]
            {
                4,
                (byte)'t',
                (byte)'e',
                (byte)'s',
                (byte)'t',
                7,
                (byte)'e',
                (byte)'x',
                (byte)'a',
                (byte)'m',
                (byte)'p',
                (byte)'l',
                (byte)'e',
                3,
                (byte)'c',
                (byte)'o',
                (byte)'m',
                0
            };
            byte[] actual = DNSServer.ConvertStringToDnsName(domain);
            CollectionAssert.AreEqual(expected, actual);
        }
​
        [TestMethod]
        public void ConvertStringToDnsName_RootDomain_ReturnsDnsNameBytes()
        {
            string domain = "com";
            byte[] expected = new byte[]
            {
                3,
                (byte)'c',
                (byte)'o',
                (byte)'m',
                0
            };
            byte[] actual = DNSServer.ConvertStringToDnsName(domain);
            CollectionAssert.AreEqual(expected, actual);
        }
​
        [TestMethod]
        public void ConvertDnsNameToString_ValidDnsName_ReturnsDomainString()
        {
            byte[] dnsName = new byte[]
            {
                4,
                (byte)'t',
                (byte)'e',
                (byte)'s',
                (byte)'t',
                7,
                (byte)'e',
                (byte)'x',
                (byte)'a',
                (byte)'m',
                (byte)'p',
                (byte)'l',
                (byte)'e',
                3,
                (byte)'c',
                (byte)'o',
                (byte)'m',
                0
            };
            string expected = "test.example.com";
            string actual = DNSServer.ConvertDnsNameToString(dnsName, 0, out int endOfName);
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(dnsName.Length, endOfName);
        }
​
        [TestMethod]
        public void ConvertDnsNameToString_RootDomainName_ReturnsDomainString()
        {
            byte[] dnsName = new byte[]
            {
                3,
                (byte)'c',
                (byte)'o',
                (byte)'m',
                0
            };
            string expected = "com";
            string actual = DNSServer.ConvertDnsNameToString(dnsName, 0, out int endOfName);
            Assert.AreEqual(expected, actual);
            Assert.AreEqual(dnsName.Length, endOfName);
        }
​
        [TestMethod]
        public void ConvertIPAddressToString_ValidIPAddressBytes_ReturnsIPAddressString()
        {
            byte[] ipBytes = new byte[]
            {
                127,
                0,
                0,
                1
            };
            string expected = "127.0.0.1";
            string actual = DNSServer.ConvertIPAddressToString(ipBytes);
            Assert.AreEqual(expected, actual);
        }
​
        [TestMethod]
        public void ConvertStringToIPAddress_ValidIPAddressString_ReturnsIPAddressBytes()
        {
            string ipString = "192.168.1.1";
            byte[] expected = new byte[]
            {
                192,
                168,
                1,
                1
            };
            byte[] actual = DNSServer.ConvertStringToIPAddress(ipString);
            CollectionAssert.AreEqual(expected, actual);
        }
    }
}

Trees
Tree
Fishes
wineries
shoes
samples
kisses
countries

Cached Result
Last Run:	7:11:43 pm
Compile:	0.16s
Execute:	0s
Memory:	8kb
CPU:	0s

View IL Code