transform neg value when integer overflows

Author: daveMueller

Documentation/Changelog.md

@@ -6,7 +6,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
-### Fixed 
+### Fixed
+-Fix negative coverage exceeding int.MaxValue [#1266](https://github.com/coverlet-coverage/coverlet/issues/1266)
 -Fix summary output format for culture de-DE [#1263](https://github.com/coverlet-coverage/coverlet/issues/1263)
 -Fix branch coverage issue for finally block with await [#1233](https://github.com/coverlet-coverage/coverlet/issues/1233)  
 -Fix threshold doesn't work when coverage empty [#1205](https://github.com/coverlet-coverage/coverlet/issues/1205)  

src/coverlet.core/Coverage.cs

@@ -420,11 +420,15 @@ private void CalculateCoverage()
                         var hitLocation = result.HitCandidates[i];
                         var document = documentsList[hitLocation.docIndex];
                         int hits = br.ReadInt32();
+                        hits = hits < 0 ? int.MaxValue : hits;
 
                         if (hitLocation.isBranch)
                         {
                             var branch = document.Branches[new BranchKey(hitLocation.start, hitLocation.end)];
                             branch.Hits += hits;
+
+                            if (branch.Hits < 0)
+                                branch.Hits = int.MaxValue;
                         }
                         else
                         {
@@ -437,6 +441,9 @@ private void CalculateCoverage()
 
                                 var line = document.Lines[j];
                                 line.Hits += hits;
+
+                                if (line.Hits < 0)
+                                    line.Hits = int.MaxValue;
                             }
                         }
                     }

test/coverlet.core.tests/Coverage/CoverageTests.IntegerOverflow.cs

@@ -0,0 +1,38 @@
+using System.IO;
+using System.Threading.Tasks;
+using Coverlet.Core.Samples.Tests;
+using Xunit;
+
+namespace Coverlet.Core.Tests
+{
+    public partial class CoverageTests
+    {
+        [Fact]
+        public void Overflow_Issue_1266()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                FunctionExecutor.Run(async (string[] pathSerialize) =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<IntegerOverflow>(instance =>
+                        {
+                            instance.Test();
+                            return Task.CompletedTask;
+                        },
+                        persistPrepareResultToFile: pathSerialize[0]);
+
+                    return 0;
+                }, new string[] { path });
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                    .Document("Instrumentation.IntegerOverflow.cs")
+                    .AssertLinesCovered(BuildConfiguration.Debug, (16, int.MaxValue), (18, int.MaxValue));
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}

test/coverlet.core.tests/Samples/Instrumentation.IntegerOverflow.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit.Sdk;
+
+namespace Coverlet.Core.Samples.Tests
+{
+    public class IntegerOverflow
+    {
+        const long max = (long)int.MaxValue + 1;
+        
+        public void Test()
+        {
+            for (long i = 0; i < max; i++)
+            {
+                _ = 1;
+            }
+        }
+    }
+}