From f90684dc19f1baf14e020a31998ee4824bdf671c Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Feb 2026 21:36:33 +0000
Subject: [PATCH 1/5] Initial plan


From 8211aa34865dbd10312a1de18c1345315b9b52f7 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Feb 2026 21:39:18 +0000
Subject: [PATCH 2/5] Initial exploration complete

Co-authored-by: gfs <98900+gfs@users.noreply.github.com>
---
 nuget.config     | 11 +++++------
 nuget.config.bak |  7 +++++++
 2 files changed, 12 insertions(+), 6 deletions(-)
 create mode 100644 nuget.config.bak

diff --git a/nuget.config b/nuget.config
index be6dddfa..a0b839c4 100644
--- a/nuget.config
+++ b/nuget.config
@@ -1,7 +1,6 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
-	<packageSources>
-		<clear />
-		<add key="PublicRegistriesFeed" value="https://pkgs.dev.azure.com/microsoft-sdl/General/_packaging/PublicRegistriesFeed/nuget/v3/index.json" />
-	</packageSources>
-</configuration>
\ No newline at end of file
+<packageSources>
+<add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
+</packageSources>
+</configuration>
diff --git a/nuget.config.bak b/nuget.config.bak
new file mode 100644
index 00000000..751d4b6c
--- /dev/null
+++ b/nuget.config.bak
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+<packageSources>
+<clear />
+<add key="PublicRegistriesFeed" value="https://pkgs.dev.azure.com/microsoft-sdl/General/_packaging/PublicRegistriesFeed/nuget/v3/index.json" />
+</packageSources>
+</configuration>

From 73bc3be4018bdcd8d001174d1537445f6e50e57e Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Feb 2026 21:44:58 +0000
Subject: [PATCH 3/5] Add XML suppression comment syntax and comprehensive
 tests

- Added XML language support to comments.json with prefix "<!--" and suffix "-->"
- Added comprehensive unit tests for XML suppression generation
- Added unit tests for XML suppression parsing
- Added integration tests for CLI suppress command with XML files
- Added integration tests for XML suppression with duration and reviewer
- Added analysis test to verify suppressions are respected in XML files
- Restored nuget.config to original private feed configuration

Co-authored-by: gfs <98900+gfs@users.noreply.github.com>
---
 .../SuppressionsTest.cs                       | 234 ++++++++++++++++++
 .../Microsoft.DevSkim/resources/comments.json |   7 +
 nuget.config                                  |  11 +-
 nuget.config.bak                              |   7 -
 4 files changed, 247 insertions(+), 12 deletions(-)
 delete mode 100644 nuget.config.bak

diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
index 9d7cc85d..6af4c94a 100644
--- a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
+++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
@@ -343,5 +343,239 @@ public void DontChangeFilesWithoutSelectedFindings(string lineBreakSequence, boo
             string result = File.ReadAllText(sourceFile);
             Assert.AreEqual(originalContent, result);
         }
+
+        /// <summary>
+        /// Test that XML suppression comments are generated correctly
+        /// </summary>
+        [TestMethod]
+        public void GenerateXmlSuppression()
+        {
+            // Test basic XML suppression generation
+            string suppression = DevSkimRuleProcessor.GenerateSuppressionByLanguage("xml", "DS123456");
+            Assert.IsTrue(suppression.StartsWith("<!--"), "XML suppression should start with <!--");
+            Assert.IsTrue(suppression.EndsWith("-->"), "XML suppression should end with -->");
+            Assert.IsTrue(suppression.Contains("DevSkim: ignore DS123456"), "XML suppression should contain DevSkim ignore directive");
+        }
+
+        /// <summary>
+        /// Test that XML suppression comments with duration are generated correctly
+        /// </summary>
+        [TestMethod]
+        public void GenerateXmlSuppressionWithDuration()
+        {
+            int duration = 30;
+            DateTime expectedDate = DateTime.Now.AddDays(duration);
+            string expectedDateStr = expectedDate.ToString("yyyy-MM-dd");
+            
+            string suppression = DevSkimRuleProcessor.GenerateSuppressionByLanguage("xml", "DS123456", duration: duration);
+            Assert.IsTrue(suppression.StartsWith("<!--"), "XML suppression should start with <!--");
+            Assert.IsTrue(suppression.EndsWith("-->"), "XML suppression should end with -->");
+            Assert.IsTrue(suppression.Contains($"until {expectedDateStr}"), "XML suppression should contain expiration date");
+        }
+
+        /// <summary>
+        /// Test that XML suppression comments with reviewer are generated correctly
+        /// </summary>
+        [TestMethod]
+        public void GenerateXmlSuppressionWithReviewer()
+        {
+            string suppression = DevSkimRuleProcessor.GenerateSuppressionByLanguage("xml", "DS123456", reviewerName: "TestReviewer");
+            Assert.IsTrue(suppression.StartsWith("<!--"), "XML suppression should start with <!--");
+            Assert.IsTrue(suppression.EndsWith("-->"), "XML suppression should end with -->");
+            Assert.IsTrue(suppression.Contains("by TestReviewer"), "XML suppression should contain reviewer name");
+        }
+
+        /// <summary>
+        /// Test that XML suppression comments are properly recognized by the Suppression parser
+        /// </summary>
+        [TestMethod]
+        public void ParseXmlSuppression()
+        {
+            string xmlLine = "<!-- DevSkim: ignore DS123456 -->";
+            Suppression suppression = new Suppression(xmlLine);
+            
+            Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
+            Assert.AreEqual("DS123456", suppression.GetSuppressedIds.First(), "Suppression should contain the correct rule ID");
+        }
+
+        /// <summary>
+        /// Test that XML suppression comments with expiration are properly recognized by the Suppression parser
+        /// </summary>
+        [TestMethod]
+        public void ParseXmlSuppressionWithExpiration()
+        {
+            string futureDate = DateTime.Now.AddDays(30).ToString("yyyy-MM-dd");
+            string xmlLine = $"<!-- DevSkim: ignore DS123456 until {futureDate} -->";
+            Suppression suppression = new Suppression(xmlLine);
+            
+            Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
+            Assert.AreEqual("DS123456", suppression.GetSuppressedIds.First(), "Suppression should contain the correct rule ID");
+            Assert.AreEqual(DateTime.ParseExact(futureDate, "yyyy-MM-dd", System.Globalization.CultureInfo.InvariantCulture), 
+                suppression.ExpirationDate, "Suppression should have the correct expiration date");
+        }
+
+        /// <summary>
+        /// Test that expired XML suppression comments are not in effect
+        /// </summary>
+        [TestMethod]
+        public void ParseExpiredXmlSuppression()
+        {
+            string pastDate = DateTime.Now.AddDays(-30).ToString("yyyy-MM-dd");
+            string xmlLine = $"<!-- DevSkim: ignore DS123456 until {pastDate} -->";
+            Suppression suppression = new Suppression(xmlLine);
+            
+            Assert.IsFalse(suppression.IsInEffect, "Expired suppression should not be in effect");
+            Assert.IsTrue(suppression.IsExpired, "Suppression should be marked as expired");
+        }
+
+        /// <summary>
+        /// Test that XML suppression comments with reviewer are properly recognized by the Suppression parser
+        /// </summary>
+        [TestMethod]
+        public void ParseXmlSuppressionWithReviewer()
+        {
+            string xmlLine = "<!-- DevSkim: ignore DS123456 by TestReviewer -->";
+            Suppression suppression = new Suppression(xmlLine);
+            
+            Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
+            Assert.AreEqual("DS123456", suppression.GetSuppressedIds.First(), "Suppression should contain the correct rule ID");
+            Assert.AreEqual("TestReviewer", suppression.Reviewer, "Suppression should have the correct reviewer");
+        }
+
+        /// <summary>
+        /// Integration test: Execute suppressions for XML files
+        /// </summary>
+        [TestMethod]
+        public void ExecuteSuppressionsForXml()
+        {
+            // XML content with an MD5 reference that triggers DevSkim rule
+            string xmlContent = @"<config><algorithm>MD5</algorithm></config>";
+
+            (string basePath, string sourceFile, string sarifPath) = runAnalysis(xmlContent, "xml");
+
+            SuppressionCommandOptions opts = new SuppressionCommandOptions
+            {
+                Path = basePath,
+                SarifInput = sarifPath,
+                ApplyAllSuppression = true
+            };
+
+            int resultCode = new SuppressionCommand(opts).Run();
+            Assert.AreEqual(0, resultCode);
+            
+            string result = File.ReadAllText(sourceFile);
+            
+            // Verify that XML-style suppressions were added
+            Assert.IsTrue(result.Contains("<!-- DevSkim: ignore"), "XML suppression comment should be present");
+            Assert.IsTrue(result.Contains("-->"), "XML suppression comment should be properly closed");
+
+            // Verify suppression can be parsed
+            string[] lines = File.ReadAllLines(sourceFile);
+            bool foundSuppression = false;
+            foreach (string line in lines)
+            {
+                if (line.Contains("<!-- DevSkim: ignore"))
+                {
+                    foundSuppression = true;
+                    Suppression suppression = new Suppression(line);
+                    Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
+                    Assert.IsTrue(suppression.GetSuppressedIds.Length > 0, "Should have at least one suppressed rule ID");
+                }
+            }
+            Assert.IsTrue(foundSuppression, "At least one suppression should be found in the file");
+        }
+
+        /// <summary>
+        /// Integration test: Execute suppressions for XML files with reviewer and duration
+        /// </summary>
+        [TestMethod]
+        [DataRow("TestReviewer", 30)]
+        [DataRow("", 30)]
+        [DataRow("TestReviewer", 0)]
+        public void ExecuteSuppressionsForXmlWithReviewerAndDuration(string reviewerName, int duration)
+        {
+            // XML content with an MD5 reference that triggers DevSkim rule
+            string xmlContent = @"<config><algorithm>MD5</algorithm></config>";
+
+            (string basePath, string sourceFile, string sarifPath) = runAnalysis(xmlContent, "xml");
+
+            SuppressionCommandOptions opts = new SuppressionCommandOptions
+            {
+                Path = basePath,
+                SarifInput = sarifPath,
+                ApplyAllSuppression = true,
+                Reviewer = reviewerName,
+                Duration = duration
+            };
+
+            int resultCode = new SuppressionCommand(opts).Run();
+            Assert.AreEqual(0, resultCode);
+            
+            string result = File.ReadAllText(sourceFile);
+            Assert.IsTrue(result.Contains("<!-- DevSkim: ignore"), "XML suppression comment should be present");
+            Assert.IsTrue(result.Contains("-->"), "XML suppression comment should be properly closed");
+
+            // Verify suppression contains expected parts
+            string[] lines = File.ReadAllLines(sourceFile);
+            foreach (string line in lines)
+            {
+                if (line.Contains("<!-- DevSkim: ignore"))
+                {
+                    Suppression suppression = new Suppression(line);
+                    Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
+                    
+                    if (!string.IsNullOrEmpty(reviewerName))
+                    {
+                        Assert.AreEqual(reviewerName, suppression.Reviewer, "Reviewer name should match");
+                    }
+                    
+                    if (duration > 0)
+                    {
+                        DateTime expectedExpiration = DateTime.Now.AddDays(duration);
+                        Assert.AreEqual(expectedExpiration.Date, suppression.ExpirationDate, "Expiration date should match");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Integration test: Verify that analysis respects XML suppressions in files
+        /// </summary>
+        [TestMethod]
+        public void AnalysisRespectsXmlSuppressions()
+        {
+            // XML content with MD5 that already has a suppression comment
+            string xmlContent = @"<config><algorithm>MD5 <!-- DevSkim: ignore DS126858 --></algorithm></config>";
+
+            string tempFileName = $"{Path.GetTempFileName()}.xml";
+            File.WriteAllText(tempFileName, xmlContent);
+
+            DevSkimRuleSet devSkimRuleSet = DevSkimRuleSet.GetDefaultRuleSet();
+            DevSkimRuleProcessor processor = new DevSkimRuleProcessor(devSkimRuleSet, new DevSkimRuleProcessorOptions()
+            {
+                EnableSuppressions = true
+            });
+
+            IEnumerable<Issue> issues = processor.Analyze(xmlContent, tempFileName);
+            
+            // The DS126858 (MD5) issue should be suppressed
+            var unsuppressedIssues = issues.Where(i => !i.IsSuppressionInfo && i.Rule.Id == "DS126858");
+            Assert.AreEqual(0, unsuppressedIssues.Count(), "MD5 issue should be suppressed");
+
+            // Cleanup
+            File.Delete(tempFileName);
+        }
+
+        /// <summary>
+        /// Test that XML suppression is generated correctly via filename-based method
+        /// </summary>
+        [TestMethod]
+        public void GenerateXmlSuppressionByFilename()
+        {
+            string suppression = DevSkimRuleProcessor.GenerateSuppressionByFileName("test.xml", "DS123456");
+            Assert.IsTrue(suppression.StartsWith("<!--"), "XML suppression should start with <!--");
+            Assert.IsTrue(suppression.EndsWith("-->"), "XML suppression should end with -->");
+            Assert.IsTrue(suppression.Contains("DevSkim: ignore DS123456"), "XML suppression should contain DevSkim ignore directive");
+        }
     }
 }
\ No newline at end of file
diff --git a/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json b/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json
index e892c1dd..540ab45f 100644
--- a/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json
+++ b/DevSkim-DotNet/Microsoft.DevSkim/resources/comments.json
@@ -74,5 +74,12 @@
     "inline": "::",
     "prefix": "Rem",
     "suffix": "\n"
+  },
+  {
+    "language": [
+      "xml"
+    ],
+    "prefix": "<!--",
+    "suffix": "-->"
   }
 ]
\ No newline at end of file
diff --git a/nuget.config b/nuget.config
index a0b839c4..be6dddfa 100644
--- a/nuget.config
+++ b/nuget.config
@@ -1,6 +1,7 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
-<packageSources>
-<add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
-</packageSources>
-</configuration>
+	<packageSources>
+		<clear />
+		<add key="PublicRegistriesFeed" value="https://pkgs.dev.azure.com/microsoft-sdl/General/_packaging/PublicRegistriesFeed/nuget/v3/index.json" />
+	</packageSources>
+</configuration>
\ No newline at end of file
diff --git a/nuget.config.bak b/nuget.config.bak
deleted file mode 100644
index 751d4b6c..00000000
--- a/nuget.config.bak
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-<packageSources>
-<clear />
-<add key="PublicRegistriesFeed" value="https://pkgs.dev.azure.com/microsoft-sdl/General/_packaging/PublicRegistriesFeed/nuget/v3/index.json" />
-</packageSources>
-</configuration>

From f9ee44ce70edab6911990fd7b25d0e78b3e6d392 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Feb 2026 22:43:04 +0000
Subject: [PATCH 4/5] Refactor: use explicit .Where() filtering instead of
 implicit if-statements in foreach loops

Co-authored-by: gfs <98900+gfs@users.noreply.github.com>
---
 .../SuppressionsTest.cs                       | 44 ++++++++-----------
 1 file changed, 19 insertions(+), 25 deletions(-)

diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
index 6af4c94a..222b44fe 100644
--- a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
+++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
@@ -471,18 +471,14 @@ public void ExecuteSuppressionsForXml()
 
             // Verify suppression can be parsed
             string[] lines = File.ReadAllLines(sourceFile);
-            bool foundSuppression = false;
-            foreach (string line in lines)
+            var suppressionLines = lines.Where(line => line.Contains("<!-- DevSkim: ignore"));
+            Assert.IsTrue(suppressionLines.Any(), "At least one suppression should be found in the file");
+            foreach (string line in suppressionLines)
             {
-                if (line.Contains("<!-- DevSkim: ignore"))
-                {
-                    foundSuppression = true;
-                    Suppression suppression = new Suppression(line);
-                    Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
-                    Assert.IsTrue(suppression.GetSuppressedIds.Length > 0, "Should have at least one suppressed rule ID");
-                }
+                Suppression suppression = new Suppression(line);
+                Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
+                Assert.IsTrue(suppression.GetSuppressedIds.Length > 0, "Should have at least one suppressed rule ID");
             }
-            Assert.IsTrue(foundSuppression, "At least one suppression should be found in the file");
         }
 
         /// <summary>
@@ -517,23 +513,21 @@ public void ExecuteSuppressionsForXmlWithReviewerAndDuration(string reviewerName
 
             // Verify suppression contains expected parts
             string[] lines = File.ReadAllLines(sourceFile);
-            foreach (string line in lines)
+            var suppressionLines = lines.Where(line => line.Contains("<!-- DevSkim: ignore"));
+            foreach (string line in suppressionLines)
             {
-                if (line.Contains("<!-- DevSkim: ignore"))
+                Suppression suppression = new Suppression(line);
+                Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
+                
+                if (!string.IsNullOrEmpty(reviewerName))
+                {
+                    Assert.AreEqual(reviewerName, suppression.Reviewer, "Reviewer name should match");
+                }
+                
+                if (duration > 0)
                 {
-                    Suppression suppression = new Suppression(line);
-                    Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
-                    
-                    if (!string.IsNullOrEmpty(reviewerName))
-                    {
-                        Assert.AreEqual(reviewerName, suppression.Reviewer, "Reviewer name should match");
-                    }
-                    
-                    if (duration > 0)
-                    {
-                        DateTime expectedExpiration = DateTime.Now.AddDays(duration);
-                        Assert.AreEqual(expectedExpiration.Date, suppression.ExpirationDate, "Expiration date should match");
-                    }
+                    DateTime expectedExpiration = DateTime.Now.AddDays(duration);
+                    Assert.AreEqual(expectedExpiration.Date, suppression.ExpirationDate, "Expiration date should match");
                 }
             }
         }

From b0d611f4df185dd5e775cd7788b4ddc8b8ec4b56 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Wed, 4 Feb 2026 22:59:56 +0000
Subject: [PATCH 5/5] Address code review feedback: move DateTime calculation,
 add try-finally cleanup, use Select() for mapping

Co-authored-by: gfs <98900+gfs@users.noreply.github.com>
---
 .../SuppressionsTest.cs                       | 40 +++++++++++--------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
index 222b44fe..5f03d871 100644
--- a/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
+++ b/DevSkim-DotNet/Microsoft.DevSkim.Tests/SuppressionsTest.cs
@@ -471,11 +471,12 @@ public void ExecuteSuppressionsForXml()
 
             // Verify suppression can be parsed
             string[] lines = File.ReadAllLines(sourceFile);
-            var suppressionLines = lines.Where(line => line.Contains("<!-- DevSkim: ignore"));
-            Assert.IsTrue(suppressionLines.Any(), "At least one suppression should be found in the file");
-            foreach (string line in suppressionLines)
+            var suppressions = lines
+                .Where(line => line.Contains("<!-- DevSkim: ignore"))
+                .Select(line => new Suppression(line));
+            Assert.IsTrue(suppressions.Any(), "At least one suppression should be found in the file");
+            foreach (Suppression suppression in suppressions)
             {
-                Suppression suppression = new Suppression(line);
                 Assert.IsTrue(suppression.IsInEffect, "Suppression should be in effect");
                 Assert.IsTrue(suppression.GetSuppressedIds.Length > 0, "Should have at least one suppressed rule ID");
             }
@@ -504,6 +505,7 @@ public void ExecuteSuppressionsForXmlWithReviewerAndDuration(string reviewerName
                 Duration = duration
             };
 
+            DateTime expectedExpiration = DateTime.Now.AddDays(duration);
             int resultCode = new SuppressionCommand(opts).Run();
             Assert.AreEqual(0, resultCode);
             
@@ -526,7 +528,6 @@ public void ExecuteSuppressionsForXmlWithReviewerAndDuration(string reviewerName
                 
                 if (duration > 0)
                 {
-                    DateTime expectedExpiration = DateTime.Now.AddDays(duration);
                     Assert.AreEqual(expectedExpiration.Date, suppression.ExpirationDate, "Expiration date should match");
                 }
             }
@@ -544,20 +545,27 @@ public void AnalysisRespectsXmlSuppressions()
             string tempFileName = $"{Path.GetTempFileName()}.xml";
             File.WriteAllText(tempFileName, xmlContent);
 
-            DevSkimRuleSet devSkimRuleSet = DevSkimRuleSet.GetDefaultRuleSet();
-            DevSkimRuleProcessor processor = new DevSkimRuleProcessor(devSkimRuleSet, new DevSkimRuleProcessorOptions()
+            try
             {
-                EnableSuppressions = true
-            });
+                DevSkimRuleSet devSkimRuleSet = DevSkimRuleSet.GetDefaultRuleSet();
+                DevSkimRuleProcessor processor = new DevSkimRuleProcessor(devSkimRuleSet, new DevSkimRuleProcessorOptions()
+                {
+                    EnableSuppressions = true
+                });
 
-            IEnumerable<Issue> issues = processor.Analyze(xmlContent, tempFileName);
-            
-            // The DS126858 (MD5) issue should be suppressed
-            var unsuppressedIssues = issues.Where(i => !i.IsSuppressionInfo && i.Rule.Id == "DS126858");
-            Assert.AreEqual(0, unsuppressedIssues.Count(), "MD5 issue should be suppressed");
+                IEnumerable<Issue> issues = processor.Analyze(xmlContent, tempFileName);
 
-            // Cleanup
-            File.Delete(tempFileName);
+                // The DS126858 (MD5) issue should be suppressed
+                var unsuppressedIssues = issues.Where(i => !i.IsSuppressionInfo && i.Rule.Id == "DS126858");
+                Assert.AreEqual(0, unsuppressedIssues.Count(), "MD5 issue should be suppressed");
+            }
+            finally
+            {
+                if (File.Exists(tempFileName))
+                {
+                    File.Delete(tempFileName);
+                }
+            }
         }
 
         /// <summary>