diff --git a/src/DemaConsulting.TestResults/IO/JUnitSerializer.cs b/src/DemaConsulting.TestResults/IO/JUnitSerializer.cs
index 2ec97b4..99ddfe9 100644
--- a/src/DemaConsulting.TestResults/IO/JUnitSerializer.cs
+++ b/src/DemaConsulting.TestResults/IO/JUnitSerializer.cs
@@ -29,6 +29,26 @@ namespace DemaConsulting.TestResults.IO;
 /// </summary>
 public static class JUnitSerializer
 {
+    /// <summary>
+    ///     Default suite name for tests without a class name
+    /// </summary>
+    private const string DefaultSuiteName = "DefaultSuite";
+
+    /// <summary>
+    ///     Format string for time values in seconds with 3 decimal places
+    /// </summary>
+    private const string TimeFormatString = "F3";
+
+    /// <summary>
+    ///     Error message for invalid JUnit XML file
+    /// </summary>
+    private const string InvalidJUnitFileMessage = "Invalid JUnit XML file";
+
+    /// <summary>
+    ///     Attribute name for message in XML elements
+    /// </summary>
+    private const string MessageAttributeName = "message";
+
     /// <summary>
     ///     Serializes the TestResults object to a JUnit XML file
     /// </summary>
@@ -48,77 +68,7 @@ public static string Serialize(TestResults results)
         // Add test suites for each class
         foreach (var suiteGroup in testSuites)
         {
-            var className = string.IsNullOrEmpty(suiteGroup.Key) ? "DefaultSuite" : suiteGroup.Key;
-            var suiteTests = suiteGroup.ToList();
-
-            var testSuite = new XElement("testsuite",
-                new XAttribute("name", className),
-                new XAttribute("tests", suiteTests.Count),
-                new XAttribute("failures", suiteTests.Count(t => t.Outcome == TestOutcome.Failed)),
-                new XAttribute("errors", suiteTests.Count(t => t.Outcome == TestOutcome.Error || t.Outcome == TestOutcome.Timeout || t.Outcome == TestOutcome.Aborted)),
-                new XAttribute("skipped", suiteTests.Count(t => !t.Outcome.IsExecuted())),
-                new XAttribute("time", suiteTests.Sum(t => t.Duration.TotalSeconds).ToString("F3", CultureInfo.InvariantCulture)));
-
-            // Add test cases
-            foreach (var test in suiteTests)
-            {
-                var testCase = new XElement("testcase",
-                    new XAttribute("name", test.Name),
-                    new XAttribute("classname", string.IsNullOrEmpty(test.ClassName) ? "DefaultSuite" : test.ClassName),
-                    new XAttribute("time", test.Duration.TotalSeconds.ToString("F3", CultureInfo.InvariantCulture)));
-
-                // Add failure or error information
-                if (test.Outcome == TestOutcome.Failed)
-                {
-                    var failure = new XElement("failure");
-                    if (!string.IsNullOrEmpty(test.ErrorMessage))
-                    {
-                        failure.Add(new XAttribute("message", test.ErrorMessage));
-                    }
-                    if (!string.IsNullOrEmpty(test.ErrorStackTrace))
-                    {
-                        failure.Add(new XCData(test.ErrorStackTrace));
-                    }
-                    testCase.Add(failure);
-                }
-                else if (test.Outcome == TestOutcome.Error || test.Outcome == TestOutcome.Timeout || test.Outcome == TestOutcome.Aborted)
-                {
-                    var error = new XElement("error");
-                    if (!string.IsNullOrEmpty(test.ErrorMessage))
-                    {
-                        error.Add(new XAttribute("message", test.ErrorMessage));
-                    }
-                    if (!string.IsNullOrEmpty(test.ErrorStackTrace))
-                    {
-                        error.Add(new XCData(test.ErrorStackTrace));
-                    }
-                    testCase.Add(error);
-                }
-                else if (!test.Outcome.IsExecuted())
-                {
-                    var skipped = new XElement("skipped");
-                    if (!string.IsNullOrEmpty(test.ErrorMessage))
-                    {
-                        skipped.Add(new XAttribute("message", test.ErrorMessage));
-                    }
-                    testCase.Add(skipped);
-                }
-
-                // Add system output
-                if (!string.IsNullOrEmpty(test.SystemOutput))
-                {
-                    testCase.Add(new XElement("system-out", new XCData(test.SystemOutput)));
-                }
-
-                // Add system error
-                if (!string.IsNullOrEmpty(test.SystemError))
-                {
-                    testCase.Add(new XElement("system-err", new XCData(test.SystemError)));
-                }
-
-                testSuite.Add(testCase);
-            }
-
+            var testSuite = CreateTestSuiteElement(suiteGroup);
             root.Add(testSuite);
         }
 
@@ -129,6 +79,125 @@ public static string Serialize(TestResults results)
         return writer.ToString();
     }
 
+    /// <summary>
+    ///     Creates a test suite element for a group of tests
+    /// </summary>
+    /// <param name="suiteGroup">A grouping of test results by class name</param>
+    /// <returns>An XElement representing a testsuite with all test cases and statistics</returns>
+    private static XElement CreateTestSuiteElement(IGrouping<string, TestResult> suiteGroup)
+    {
+        var className = string.IsNullOrEmpty(suiteGroup.Key) ? DefaultSuiteName : suiteGroup.Key;
+        var suiteTests = suiteGroup.ToList();
+
+        var testSuite = new XElement("testsuite",
+            new XAttribute("name", className),
+            new XAttribute("tests", suiteTests.Count),
+            new XAttribute("failures", suiteTests.Count(t => t.Outcome == TestOutcome.Failed)),
+            new XAttribute("errors", suiteTests.Count(t => IsErrorOutcome(t.Outcome))),
+            new XAttribute("skipped", suiteTests.Count(t => !t.Outcome.IsExecuted())),
+            new XAttribute("time", suiteTests.Sum(t => t.Duration.TotalSeconds).ToString(TimeFormatString, CultureInfo.InvariantCulture)));
+
+        // Add test cases
+        foreach (var test in suiteTests)
+        {
+            var testCase = CreateTestCaseElement(test);
+            testSuite.Add(testCase);
+        }
+
+        return testSuite;
+    }
+
+    /// <summary>
+    ///     Determines if an outcome represents an error condition
+    /// </summary>
+    /// <param name="outcome">The test outcome to evaluate</param>
+    /// <returns>True if the outcome is Error, Timeout, or Aborted; otherwise false</returns>
+    private static bool IsErrorOutcome(TestOutcome outcome)
+    {
+        return outcome == TestOutcome.Error || outcome == TestOutcome.Timeout || outcome == TestOutcome.Aborted;
+    }
+
+    /// <summary>
+    ///     Creates a test case element
+    /// </summary>
+    /// <param name="test">The test result to serialize</param>
+    /// <returns>An XElement representing a testcase with outcome, system output, and system error</returns>
+    private static XElement CreateTestCaseElement(TestResult test)
+    {
+        var testCase = new XElement("testcase",
+            new XAttribute("name", test.Name),
+            new XAttribute("classname", string.IsNullOrEmpty(test.ClassName) ? DefaultSuiteName : test.ClassName),
+            new XAttribute("time", test.Duration.TotalSeconds.ToString(TimeFormatString, CultureInfo.InvariantCulture)));
+
+        // Add failure or error information based on outcome
+        AddOutcomeElement(testCase, test);
+
+        // Add system output
+        if (!string.IsNullOrEmpty(test.SystemOutput))
+        {
+            testCase.Add(new XElement("system-out", new XCData(test.SystemOutput)));
+        }
+
+        // Add system error
+        if (!string.IsNullOrEmpty(test.SystemError))
+        {
+            testCase.Add(new XElement("system-err", new XCData(test.SystemError)));
+        }
+
+        return testCase;
+    }
+
+    /// <summary>
+    ///     Adds the appropriate outcome element (failure, error, or skipped) to a test case
+    /// </summary>
+    /// <param name="testCase">The testcase element to add the outcome element to</param>
+    /// <param name="test">The test result containing the outcome information</param>
+    private static void AddOutcomeElement(XElement testCase, TestResult test)
+    {
+        if (test.Outcome == TestOutcome.Failed)
+        {
+            var failure = CreateFailureOrErrorElement("failure", test);
+            testCase.Add(failure);
+        }
+        else if (IsErrorOutcome(test.Outcome))
+        {
+            var error = CreateFailureOrErrorElement("error", test);
+            testCase.Add(error);
+        }
+        else if (!test.Outcome.IsExecuted())
+        {
+            var skipped = new XElement("skipped");
+            if (!string.IsNullOrEmpty(test.ErrorMessage))
+            {
+                skipped.Add(new XAttribute(MessageAttributeName, test.ErrorMessage));
+            }
+            testCase.Add(skipped);
+        }
+    }
+
+    /// <summary>
+    ///     Creates a failure or error element with message and stack trace
+    /// </summary>
+    /// <param name="elementName">The name of the element to create ("failure" or "error")</param>
+    /// <param name="test">The test result containing error message and stack trace</param>
+    /// <returns>An XElement with the specified name containing message attribute and stack trace content</returns>
+    private static XElement CreateFailureOrErrorElement(string elementName, TestResult test)
+    {
+        var element = new XElement(elementName);
+
+        if (!string.IsNullOrEmpty(test.ErrorMessage))
+        {
+            element.Add(new XAttribute(MessageAttributeName, test.ErrorMessage));
+        }
+
+        if (!string.IsNullOrEmpty(test.ErrorStackTrace))
+        {
+            element.Add(new XCData(test.ErrorStackTrace));
+        }
+
+        return element;
+    }
+
     /// <summary>
     ///     Deserializes a JUnit XML file to a TestResults object
     /// </summary>
@@ -143,8 +212,7 @@ public static TestResults Deserialize(string junitContents)
         var results = new TestResults();
 
         // Get the root element (testsuites)
-        var rootElement = doc.Root ??
-                         throw new InvalidOperationException("Invalid JUnit XML file");
+        var rootElement = doc.Root ?? throw new InvalidOperationException(InvalidJUnitFileMessage);
 
         // Get the test suite name (from testsuites or first testsuite)
         results.Name = rootElement.Attribute("name")?.Value ?? string.Empty;
@@ -157,74 +225,117 @@ public static TestResults Deserialize(string junitContents)
         // Process each test suite
         foreach (var testSuiteElement in testSuiteElements)
         {
-            // Get test cases
-            var testCaseElements = testSuiteElement.Elements("testcase");
-
-            foreach (var testCaseElement in testCaseElements)
-            {
-                // Parse test case attributes
-                var name = testCaseElement.Attribute("name")?.Value ?? string.Empty;
-                var className = testCaseElement.Attribute("classname")?.Value ?? string.Empty;
-                var timeStr = testCaseElement.Attribute("time")?.Value ?? "0";
-                var duration = double.TryParse(timeStr, NumberStyles.Float, CultureInfo.InvariantCulture, out var timeValue)
-                    ? TimeSpan.FromSeconds(timeValue)
-                    : TimeSpan.Zero;
-
-                // Determine outcome based on child elements
-                var failureElement = testCaseElement.Element("failure");
-                var errorElement = testCaseElement.Element("error");
-                var skippedElement = testCaseElement.Element("skipped");
-
-                TestOutcome outcome;
-                string errorMessage = string.Empty;
-                string errorStackTrace = string.Empty;
-
-                if (failureElement != null)
-                {
-                    outcome = TestOutcome.Failed;
-                    errorMessage = failureElement.Attribute("message")?.Value ?? string.Empty;
-                    errorStackTrace = failureElement.Value;
-                }
-                else if (errorElement != null)
-                {
-                    outcome = TestOutcome.Error;
-                    errorMessage = errorElement.Attribute("message")?.Value ?? string.Empty;
-                    errorStackTrace = errorElement.Value;
-                }
-                else if (skippedElement != null)
-                {
-                    outcome = TestOutcome.NotExecuted;
-                    errorMessage = skippedElement.Attribute("message")?.Value ?? string.Empty;
-                }
-                else
-                {
-                    outcome = TestOutcome.Passed;
-                }
-
-                // Get system output and error
-                var systemOutput = testCaseElement.Element("system-out")?.Value ?? string.Empty;
-                var systemError = testCaseElement.Element("system-err")?.Value ?? string.Empty;
-
-                // Create test result
-                var testResult = new TestResult
-                {
-                    Name = name,
-                    ClassName = className == "DefaultSuite" ? string.Empty : className,
-                    Duration = duration,
-                    Outcome = outcome,
-                    ErrorMessage = errorMessage,
-                    ErrorStackTrace = errorStackTrace,
-                    SystemOutput = systemOutput,
-                    SystemError = systemError
-                };
-
-                results.Results.Add(testResult);
-            }
+            ParseTestSuite(testSuiteElement, results);
         }
 
         return results;
     }
 
+    /// <summary>
+    ///     Parses a test suite element and adds test cases to results
+    /// </summary>
+    /// <param name="testSuiteElement">The testsuite XML element to parse</param>
+    /// <param name="results">The TestResults object to populate with test case data</param>
+    private static void ParseTestSuite(XElement testSuiteElement, TestResults results)
+    {
+        var testCaseElements = testSuiteElement.Elements("testcase");
+
+        foreach (var testCaseElement in testCaseElements)
+        {
+            var testResult = ParseTestCase(testCaseElement);
+            results.Results.Add(testResult);
+        }
+    }
+
+    /// <summary>
+    ///     Parses a test case element
+    /// </summary>
+    /// <param name="testCaseElement">The testcase XML element to parse</param>
+    /// <returns>A TestResult object populated with data from the XML element</returns>
+    private static TestResult ParseTestCase(XElement testCaseElement)
+    {
+        // Parse basic test case attributes
+        var name = testCaseElement.Attribute("name")?.Value ?? string.Empty;
+        var className = testCaseElement.Attribute("classname")?.Value ?? string.Empty;
+        var duration = ParseDuration(testCaseElement.Attribute("time")?.Value);
+
+        // Determine outcome and error information
+        var (outcome, errorMessage, errorStackTrace) = ParseOutcome(testCaseElement);
+
+        // Get system output and error
+        var systemOutput = testCaseElement.Element("system-out")?.Value ?? string.Empty;
+        var systemError = testCaseElement.Element("system-err")?.Value ?? string.Empty;
+
+        // Create test result
+        return new TestResult
+        {
+            Name = name,
+            ClassName = className == DefaultSuiteName ? string.Empty : className,
+            Duration = duration,
+            Outcome = outcome,
+            ErrorMessage = errorMessage,
+            ErrorStackTrace = errorStackTrace,
+            SystemOutput = systemOutput,
+            SystemError = systemError
+        };
+    }
+
+    /// <summary>
+    ///     Parses a duration string to a TimeSpan
+    /// </summary>
+    /// <param name="timeStr">The time string to parse, representing seconds as a decimal number</param>
+    /// <returns>A TimeSpan representing the duration, or TimeSpan.Zero if parsing fails</returns>
+    private static TimeSpan ParseDuration(string? timeStr)
+    {
+        if (string.IsNullOrEmpty(timeStr))
+            return TimeSpan.Zero;
+
+        return double.TryParse(timeStr, NumberStyles.Float, CultureInfo.InvariantCulture, out var timeValue)
+            ? TimeSpan.FromSeconds(timeValue)
+            : TimeSpan.Zero;
+    }
+
+    /// <summary>
+    ///     Parses outcome information from test case child elements
+    /// </summary>
+    /// <param name="testCaseElement">The testcase XML element to parse for outcome information</param>
+    /// <returns>A tuple containing the test outcome, error message, and error stack trace</returns>
+    private static (TestOutcome outcome, string errorMessage, string errorStackTrace) ParseOutcome(XElement testCaseElement)
+    {
+        var failureElement = testCaseElement.Element("failure");
+        var errorElement = testCaseElement.Element("error");
+        var skippedElement = testCaseElement.Element("skipped");
+
+        if (failureElement != null)
+        {
+            return (
+                TestOutcome.Failed,
+                failureElement.Attribute(MessageAttributeName)?.Value ?? string.Empty,
+                failureElement.Value
+            );
+        }
+
+        if (errorElement != null)
+        {
+            return (
+                TestOutcome.Error,
+                errorElement.Attribute(MessageAttributeName)?.Value ?? string.Empty,
+                errorElement.Value
+            );
+        }
+
+        if (skippedElement != null)
+        {
+            return (
+                TestOutcome.NotExecuted,
+                skippedElement.Attribute(MessageAttributeName)?.Value ?? string.Empty,
+                string.Empty
+            );
+        }
+
+        return (TestOutcome.Passed, string.Empty, string.Empty);
+    }
+
     /// <summary>
     ///     String writer that uses UTF-8 encoding
     /// </summary>
diff --git a/src/DemaConsulting.TestResults/IO/TrxSerializer.cs b/src/DemaConsulting.TestResults/IO/TrxSerializer.cs
index 968af4f..6c232bd 100644
--- a/src/DemaConsulting.TestResults/IO/TrxSerializer.cs
+++ b/src/DemaConsulting.TestResults/IO/TrxSerializer.cs
@@ -36,6 +36,36 @@ public static class TrxSerializer
     /// </summary>
     private static readonly XNamespace TrxNamespace = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010";
 
+    /// <summary>
+    ///     Standard test type GUID for unit tests
+    /// </summary>
+    private const string TestTypeGuid = "13CDC9D9-DDB5-4fa4-A97D-D965CCFC6D4B";
+
+    /// <summary>
+    ///     Standard test list ID for all loaded results
+    /// </summary>
+    private const string TestListId = "19431567-8539-422a-85D7-44EE4E166BDA";
+
+    /// <summary>
+    ///     Name for the standard test list
+    /// </summary>
+    private const string TestListName = "All Loaded Results";
+
+    /// <summary>
+    ///     Error message for invalid TRX file
+    /// </summary>
+    private const string InvalidTrxFileMessage = "Invalid TRX file";
+
+    /// <summary>
+    ///     Date/time format string for invariant culture
+    /// </summary>
+    private const string DateTimeFormatString = "o";
+
+    /// <summary>
+    ///     Duration format string for TimeSpan
+    /// </summary>
+    private const string DurationFormatString = "c";
+
     /// <summary>
     ///     Serializes the TestResults object to a TRX file
     /// </summary>
@@ -47,129 +77,227 @@ public static string Serialize(TestResults results)
         var doc = new XDocument();
 
         // Construct the root element
-        var root = new XElement(TrxNamespace + "TestRun",
+        var root = CreateRootElement(results);
+        doc.Add(root);
+
+        // Add results section
+        var resultsElement = CreateResultsElement(results.Results);
+        root.Add(resultsElement);
+
+        // Add definitions section
+        var definitionsElement = CreateDefinitionsElement(results.Results);
+        root.Add(definitionsElement);
+
+        // Add test entries section
+        var entriesElement = CreateTestEntriesElement(results.Results);
+        root.Add(entriesElement);
+
+        // Add test lists section
+        var testListsElement = CreateTestListsElement();
+        root.Add(testListsElement);
+
+        // Add summary section
+        var summaryElement = CreateSummaryElement(results.Results);
+        root.Add(summaryElement);
+
+        // Write the TRX text
+        var writer = new Utf8StringWriter();
+        doc.Save(writer);
+        return writer.ToString();
+    }
+
+    /// <summary>
+    ///     Creates the root TestRun element
+    /// </summary>
+    /// <param name="results">The test results containing test run metadata</param>
+    /// <returns>An XElement representing the TestRun root element</returns>
+    private static XElement CreateRootElement(TestResults results)
+    {
+        return new XElement(TrxNamespace + "TestRun",
             new XAttribute("id", results.Id),
             new XAttribute("name", results.Name),
             new XAttribute("runUser", results.UserName));
-        doc.Add(root);
+    }
 
-        // Construct the results
+    /// <summary>
+    ///     Creates the Results section with all test results
+    /// </summary>
+    /// <param name="testResults">The collection of test results to serialize</param>
+    /// <returns>An XElement containing all UnitTestResult elements</returns>
+    private static XElement CreateResultsElement(List<TestResult> testResults)
+    {
         var resultsElement = new XElement(TrxNamespace + "Results");
-        root.Add(resultsElement);
-        foreach (var c in results.Results)
+
+        foreach (var test in testResults)
         {
-            // Construct the result
-            var resultElement = new XElement(TrxNamespace + "UnitTestResult",
-                new XAttribute("executionId", c.ExecutionId),
-                new XAttribute("testId", c.TestId),
-                new XAttribute("testName", c.Name),
-                new XAttribute("computerName", c.ComputerName),
-                new XAttribute("testType", "13CDC9D9-DDB5-4fa4-A97D-D965CCFC6D4B"),
-                new XAttribute("outcome", c.Outcome),
-                new XAttribute("duration", c.Duration.ToString("c")),
-                new XAttribute("startTime", c.StartTime.ToString("o", CultureInfo.InvariantCulture)),
-                new XAttribute("endTime", (c.StartTime + c.Duration).ToString("o", CultureInfo.InvariantCulture)),
-                new XAttribute("testListId", "19431567-8539-422a-85D7-44EE4E166BDA"));
+            var resultElement = CreateUnitTestResultElement(test);
             resultsElement.Add(resultElement);
+        }
+
+        return resultsElement;
+    }
 
-            // Construct the output element
-            var outputElement = new XElement(TrxNamespace + "Output");
-            resultElement.Add(outputElement);
-
-            // Construct the stdout output
-            if (!string.IsNullOrEmpty(c.SystemOutput))
-            {
-                outputElement.Add(
-                    new XElement(TrxNamespace + "StdOut",
-                        new XCData(c.SystemOutput)));
-            }
-
-            // Construct the stderr output
-            if (!string.IsNullOrEmpty(c.SystemError))
-            {
-                outputElement.Add(
-                    new XElement(TrxNamespace + "StdErr",
-                        new XCData(c.SystemError)));
-            }
-
-            // Skip writing the error info element if there is no error information
-            if (string.IsNullOrEmpty(c.ErrorMessage) &&
-                string.IsNullOrEmpty(c.ErrorStackTrace))
-            {
-                continue;
-            }
-
-            // Construct the error info element
-            var errorInfoElement = new XElement(TrxNamespace + "ErrorInfo");
+    /// <summary>
+    ///     Creates a single UnitTestResult element
+    /// </summary>
+    /// <param name="test">The test result to serialize</param>
+    /// <returns>An XElement representing a UnitTestResult with all test attributes and output</returns>
+    private static XElement CreateUnitTestResultElement(TestResult test)
+    {
+        var resultElement = new XElement(TrxNamespace + "UnitTestResult",
+            new XAttribute("executionId", test.ExecutionId),
+            new XAttribute("testId", test.TestId),
+            new XAttribute("testName", test.Name),
+            new XAttribute("computerName", test.ComputerName),
+            new XAttribute("testType", TestTypeGuid),
+            new XAttribute("outcome", test.Outcome),
+            new XAttribute("duration", test.Duration.ToString(DurationFormatString)),
+            new XAttribute("startTime", test.StartTime.ToString(DateTimeFormatString, CultureInfo.InvariantCulture)),
+            new XAttribute("endTime", (test.StartTime + test.Duration).ToString(DateTimeFormatString, CultureInfo.InvariantCulture)),
+            new XAttribute("testListId", TestListId));
+
+        var outputElement = CreateOutputElement(test);
+        resultElement.Add(outputElement);
+
+        return resultElement;
+    }
+
+    /// <summary>
+    ///     Creates the Output element with stdout, stderr, and error information
+    /// </summary>
+    /// <param name="test">The test result containing output and error information</param>
+    /// <returns>An XElement containing StdOut, StdErr, and ErrorInfo child elements as appropriate</returns>
+    private static XElement CreateOutputElement(TestResult test)
+    {
+        var outputElement = new XElement(TrxNamespace + "Output");
+
+        // Add stdout if present
+        if (!string.IsNullOrEmpty(test.SystemOutput))
+        {
+            outputElement.Add(
+                new XElement(TrxNamespace + "StdOut",
+                    new XCData(test.SystemOutput)));
+        }
+
+        // Add stderr if present
+        if (!string.IsNullOrEmpty(test.SystemError))
+        {
+            outputElement.Add(
+                new XElement(TrxNamespace + "StdErr",
+                    new XCData(test.SystemError)));
+        }
+
+        // Add error info if present
+        if (!string.IsNullOrEmpty(test.ErrorMessage) || !string.IsNullOrEmpty(test.ErrorStackTrace))
+        {
+            var errorInfoElement = CreateErrorInfoElement(test);
             outputElement.Add(errorInfoElement);
+        }
 
-            // Construct the error message
-            if (!string.IsNullOrEmpty(c.ErrorMessage))
-            {
-                errorInfoElement.Add(
-                    new XElement(TrxNamespace + "Message",
-                        new XCData(c.ErrorMessage)));
-            }
-
-            // Construct the stack trace
-            if (!string.IsNullOrEmpty(c.ErrorStackTrace))
-            {
-                errorInfoElement.Add(
-                    new XElement(TrxNamespace + "StackTrace",
-                        new XCData(c.ErrorStackTrace)));
-            }
+        return outputElement;
+    }
+
+    /// <summary>
+    ///     Creates the ErrorInfo element with message and stack trace
+    /// </summary>
+    /// <param name="test">The test result containing error message and stack trace</param>
+    /// <returns>An XElement containing Message and StackTrace child elements</returns>
+    private static XElement CreateErrorInfoElement(TestResult test)
+    {
+        var errorInfoElement = new XElement(TrxNamespace + "ErrorInfo");
+
+        if (!string.IsNullOrEmpty(test.ErrorMessage))
+        {
+            errorInfoElement.Add(
+                new XElement(TrxNamespace + "Message",
+                    new XCData(test.ErrorMessage)));
         }
 
-        // Construct definitions
+        if (!string.IsNullOrEmpty(test.ErrorStackTrace))
+        {
+            errorInfoElement.Add(
+                new XElement(TrxNamespace + "StackTrace",
+                    new XCData(test.ErrorStackTrace)));
+        }
+
+        return errorInfoElement;
+    }
+
+    /// <summary>
+    ///     Creates the TestDefinitions section with all unit test definitions
+    /// </summary>
+    /// <param name="testResults">The collection of test results to create definitions for</param>
+    /// <returns>An XElement containing all UnitTest definition elements</returns>
+    private static XElement CreateDefinitionsElement(List<TestResult> testResults)
+    {
         var definitionsElement = new XElement(TrxNamespace + "TestDefinitions");
-        root.Add(definitionsElement);
-        foreach (var c in results.Results)
+
+        foreach (var test in testResults)
         {
             definitionsElement.Add(
                 new XElement(TrxNamespace + "UnitTest",
-                    new XAttribute("name", c.Name),
-                    new XAttribute("id", c.TestId),
+                    new XAttribute("name", test.Name),
+                    new XAttribute("id", test.TestId),
                     new XElement(TrxNamespace + "Execution",
-                        new XAttribute("id", c.ExecutionId)),
+                        new XAttribute("id", test.ExecutionId)),
                     new XElement(TrxNamespace + "TestMethod",
-                        new XAttribute("codeBase", c.CodeBase),
-                        new XAttribute("className", c.ClassName),
-                        new XAttribute("name", c.Name))));
+                        new XAttribute("codeBase", test.CodeBase),
+                        new XAttribute("className", test.ClassName),
+                        new XAttribute("name", test.Name))));
         }
 
-        // Construct the Test Entries
+        return definitionsElement;
+    }
+
+    /// <summary>
+    ///     Creates the TestEntries section with all test entry mappings
+    /// </summary>
+    /// <param name="testResults">The collection of test results to create entries for</param>
+    /// <returns>An XElement containing all TestEntry mapping elements</returns>
+    private static XElement CreateTestEntriesElement(List<TestResult> testResults)
+    {
         var entriesElement = new XElement(TrxNamespace + "TestEntries");
-        root.Add(entriesElement);
-        foreach (var c in results.Results)
+
+        foreach (var test in testResults)
+        {
             entriesElement.Add(
                 new XElement(TrxNamespace + "TestEntry",
-                    new XAttribute("testId", c.TestId),
-                    new XAttribute("executionId", c.ExecutionId),
-                    new XAttribute("testListId", "19431567-8539-422a-85D7-44EE4E166BDA")));
-
-        // Construct the test lists
-        root.Add(
-            new XElement(TrxNamespace + "TestLists",
-                new XElement(TrxNamespace + "TestList",
-                    new XAttribute("name", "All Loaded Results"),
-                    new XAttribute("id", "19431567-8539-422a-85D7-44EE4E166BDA"))));
-
-        // Construct the summary
-        root.Add(
-            new XElement(
-                TrxNamespace + "ResultSummary",
-                new XAttribute("outcome", "Completed"),
-                new XElement(
-                    TrxNamespace + "Counters",
-                    new XAttribute("total", results.Results.Count),
-                    new XAttribute("executed", results.Results.Count(c => c.Outcome.IsExecuted())),
-                    new XAttribute("passed", results.Results.Count(c => c.Outcome.IsPassed())),
-                    new XAttribute("failed", results.Results.Count(c => c.Outcome.IsFailed())))));
+                    new XAttribute("testId", test.TestId),
+                    new XAttribute("executionId", test.ExecutionId),
+                    new XAttribute("testListId", TestListId)));
+        }
 
-        // Write the TRX text
-        var writer = new Utf8StringWriter();
-        doc.Save(writer);
-        return writer.ToString();
+        return entriesElement;
+    }
+
+    /// <summary>
+    ///     Creates the TestLists section
+    /// </summary>
+    /// <returns>An XElement containing the standard TestList with the "All Loaded Results" list</returns>
+    private static XElement CreateTestListsElement()
+    {
+        return new XElement(TrxNamespace + "TestLists",
+            new XElement(TrxNamespace + "TestList",
+                new XAttribute("name", TestListName),
+                new XAttribute("id", TestListId)));
+    }
+
+    /// <summary>
+    ///     Creates the ResultSummary section with test statistics
+    /// </summary>
+    /// <param name="testResults">The collection of test results to calculate statistics from</param>
+    /// <returns>An XElement containing the ResultSummary with Counters for total, executed, passed, and failed tests</returns>
+    private static XElement CreateSummaryElement(List<TestResult> testResults)
+    {
+        return new XElement(
+            TrxNamespace + "ResultSummary",
+            new XAttribute("outcome", "Completed"),
+            new XElement(
+                TrxNamespace + "Counters",
+                new XAttribute("total", testResults.Count),
+                new XAttribute("executed", testResults.Count(t => t.Outcome.IsExecuted())),
+                new XAttribute("passed", testResults.Count(t => t.Outcome.IsPassed())),
+                new XAttribute("failed", testResults.Count(t => t.Outcome.IsFailed()))));
     }
 
     /// <summary>
@@ -187,73 +315,100 @@ public static TestResults Deserialize(string trxContents)
         // Construct the results
         var results = new TestResults();
 
-        // Get the run element
+        // Parse the run element
+        ParseRunElement(doc, nsMgr, results);
+
+        // Parse all test results
+        ParseTestResults(doc, nsMgr, results);
+
+        // Return the results
+        return results;
+    }
+
+    /// <summary>
+    ///     Parses the TestRun element and populates basic result properties
+    /// </summary>
+    /// <param name="doc">The XML document containing the TRX file</param>
+    /// <param name="nsMgr">The namespace manager with TRX namespace mappings</param>
+    /// <param name="results">The TestResults object to populate with run metadata</param>
+    private static void ParseRunElement(XDocument doc, XmlNamespaceManager nsMgr, TestResults results)
+    {
         var runElement = doc.XPathSelectElement("/trx:TestRun", nsMgr) ??
-                         throw new InvalidOperationException("Invalid TRX file");
+                         throw new InvalidOperationException(InvalidTrxFileMessage);
         results.Id = Guid.Parse(runElement.Attribute("id")?.Value ?? Guid.NewGuid().ToString());
         results.Name = runElement.Attribute("name")?.Value ?? string.Empty;
         results.UserName = runElement.Attribute("runUser")?.Value ?? string.Empty;
+    }
 
-        // Get the results
+    /// <summary>
+    ///     Parses all test result elements and adds them to the results collection
+    /// </summary>
+    /// <param name="doc">The XML document containing the TRX file</param>
+    /// <param name="nsMgr">The namespace manager with TRX namespace mappings</param>
+    /// <param name="results">The TestResults object to populate with test result data</param>
+    private static void ParseTestResults(XDocument doc, XmlNamespaceManager nsMgr, TestResults results)
+    {
         var resultElements = doc.XPathSelectElements(
             "/trx:TestRun/trx:Results/trx:UnitTestResult",
             nsMgr);
+
         foreach (var resultElement in resultElements)
         {
-            // Get the test ID
-            var testId = resultElement.Attribute("testId") ??
-                         throw new InvalidOperationException("Invalid TRX file");
-
-            // Get the test method element
-            var methodElement =
-                doc.XPathSelectElement(
-                    $"/trx:TestRun/trx:TestDefinitions/trx:UnitTest[@id='{testId.Value}']/trx:TestMethod",
-                    nsMgr) ??
-                throw new InvalidOperationException("Invalid TRX File");
-
-            // Get the output element
-            var outputElement = resultElement.Element(TrxNamespace + "Output");
-
-            // Get the errorInfo element
-            var errorInfoElement = outputElement?.Element(TrxNamespace + "ErrorInfo");
-
-            // Add the test result
-            results.Results.Add(
-                new TestResult
-                {
-                    TestId = Guid.Parse(testId.Value),
-                    ExecutionId = Guid.Parse(
-                        resultElement.Attribute("executionId")?.Value ?? Guid.NewGuid().ToString()),
-                    Name = methodElement.Attribute("name")?.Value ?? string.Empty,
-                    CodeBase = methodElement.Attribute("codeBase")?.Value ?? string.Empty,
-                    ClassName = methodElement.Attribute("className")?.Value ?? string.Empty,
-                    ComputerName = resultElement.Attribute("computerName")?.Value ?? string.Empty,
-                    Outcome = Enum.Parse<TestOutcome>(resultElement.Attribute("outcome")?.Value ?? "Failed"),
-                    StartTime = DateTime.Parse(
-                        resultElement.Attribute("startTime")?.Value ??
-                        DateTime.UtcNow.ToString(CultureInfo.InvariantCulture),
-                        CultureInfo.InvariantCulture,
-                        DateTimeStyles.AdjustToUniversal),
-                    Duration = TimeSpan.Parse(
-                        resultElement.Attribute("duration")?.Value ?? "0",
-                        CultureInfo.InvariantCulture),
-                    SystemOutput = outputElement
-                        ?.Element(TrxNamespace + "StdOut")
-                        ?.Value ?? string.Empty,
-                    SystemError = outputElement
-                        ?.Element(TrxNamespace + "StdErr")
-                        ?.Value ?? string.Empty,
-                    ErrorMessage = errorInfoElement
-                        ?.Element(TrxNamespace + "Message")
-                        ?.Value ?? string.Empty,
-                    ErrorStackTrace = errorInfoElement
-                        ?.Element(TrxNamespace + "StackTrace")
-                        ?.Value ?? string.Empty
-                });
+            var testResult = ParseTestResult(doc, nsMgr, resultElement);
+            results.Results.Add(testResult);
         }
+    }
 
-        // Return the results
-        return results;
+    /// <summary>
+    ///     Parses a single UnitTestResult element
+    /// </summary>
+    /// <param name="doc">The XML document containing the TRX file</param>
+    /// <param name="nsMgr">The namespace manager with TRX namespace mappings</param>
+    /// <param name="resultElement">The UnitTestResult element to parse</param>
+    /// <returns>A TestResult object populated with data from the XML element</returns>
+    private static TestResult ParseTestResult(XDocument doc, XmlNamespaceManager nsMgr, XElement resultElement)
+    {
+        var testId = resultElement.Attribute("testId") ??
+                     throw new InvalidOperationException(InvalidTrxFileMessage);
+
+        var methodElement = doc.XPathSelectElement(
+            $"/trx:TestRun/trx:TestDefinitions/trx:UnitTest[@id='{testId.Value}']/trx:TestMethod",
+            nsMgr) ?? throw new InvalidOperationException(InvalidTrxFileMessage);
+
+        var outputElement = resultElement.Element(TrxNamespace + "Output");
+        var errorInfoElement = outputElement?.Element(TrxNamespace + "ErrorInfo");
+
+        return new TestResult
+        {
+            TestId = Guid.Parse(testId.Value),
+            ExecutionId = Guid.Parse(
+                resultElement.Attribute("executionId")?.Value ?? Guid.NewGuid().ToString()),
+            Name = methodElement.Attribute("name")?.Value ?? string.Empty,
+            CodeBase = methodElement.Attribute("codeBase")?.Value ?? string.Empty,
+            ClassName = methodElement.Attribute("className")?.Value ?? string.Empty,
+            ComputerName = resultElement.Attribute("computerName")?.Value ?? string.Empty,
+            Outcome = Enum.Parse<TestOutcome>(resultElement.Attribute("outcome")?.Value ?? "Failed"),
+            StartTime = DateTime.Parse(
+                resultElement.Attribute("startTime")?.Value ??
+                DateTime.UtcNow.ToString(CultureInfo.InvariantCulture),
+                CultureInfo.InvariantCulture,
+                DateTimeStyles.AdjustToUniversal),
+            Duration = TimeSpan.Parse(
+                resultElement.Attribute("duration")?.Value ?? "0",
+                CultureInfo.InvariantCulture),
+            SystemOutput = outputElement
+                ?.Element(TrxNamespace + "StdOut")
+                ?.Value ?? string.Empty,
+            SystemError = outputElement
+                ?.Element(TrxNamespace + "StdErr")
+                ?.Value ?? string.Empty,
+            ErrorMessage = errorInfoElement
+                ?.Element(TrxNamespace + "Message")
+                ?.Value ?? string.Empty,
+            ErrorStackTrace = errorInfoElement
+                ?.Element(TrxNamespace + "StackTrace")
+                ?.Value ?? string.Empty
+        };
     }
 
     /// <summary>