test: use Arrange/Act/Assert comments in new handled tests

Match the AAA comment convention for the SentryClientExtensions and
MainExceptionProcessor chain-inheritance tests added in this branch.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: vladbrincoveanu

test/Sentry.Tests/Internals/MainExceptionProcessorTests.cs

@@ -106,13 +106,16 @@ public void Process_ExceptionWith_HandledTrue_WhenCaught()
     [Fact]
     public void Process_InnerExceptionChain_UnhandledOuter_PropagatesHandledFalseToInner()
     {
+        // Arrange
         var sut = _fixture.GetSut();
         var evt = new SentryEvent();
         var outer = new Exception("outer", new Exception("inner"));
         outer.Data[Mechanism.HandledKey] = false;
 
+        // Act
         sut.Process(outer, evt);
 
+        // Assert
         Assert.NotNull(evt.SentryExceptions);
         // Discriminating: the default is handled=true, so inner reporting false proves it inherited the outer value.
         Assert.Equal(false, evt.SentryExceptions.Single(e => e.Value == "outer").Mechanism!.Handled);
@@ -122,12 +125,15 @@ public void Process_InnerExceptionChain_UnhandledOuter_PropagatesHandledFalseToI
     [Fact]
     public void Process_InnerExceptionChain_NoExplicitFlag_DefaultsBothToHandledTrue()
     {
+        // Arrange
         var sut = _fixture.GetSut();
         var evt = new SentryEvent();
         var outer = new Exception("outer", new Exception("inner"));
 
+        // Act
         sut.Process(outer, evt);
 
+        // Assert
         Assert.NotNull(evt.SentryExceptions);
         Assert.Equal(true, evt.SentryExceptions.Single(e => e.Value == "outer").Mechanism!.Handled);
         Assert.Equal(true, evt.SentryExceptions.Single(e => e.Value == "inner").Mechanism!.Handled);
@@ -136,15 +142,18 @@ public void Process_InnerExceptionChain_NoExplicitFlag_DefaultsBothToHandledTrue
     [Fact]
     public void Process_InnerExceptionChain_ExplicitFlagOnInner_WinsOverInheritedParentValue()
     {
+        // Arrange
         var sut = _fixture.GetSut();
         var evt = new SentryEvent();
         var inner = new Exception("inner");
         inner.Data[Mechanism.HandledKey] = true;
         var outer = new Exception("outer", inner);
         outer.Data[Mechanism.HandledKey] = false;
 
+        // Act
         sut.Process(outer, evt);
 
+        // Assert
         Assert.NotNull(evt.SentryExceptions);
         // The inner's explicit handled=true wins over the false it would otherwise inherit from the outer.
         Assert.Equal(false, evt.SentryExceptions.Single(e => e.Value == "outer").Mechanism!.Handled);
@@ -154,6 +163,7 @@ public void Process_InnerExceptionChain_ExplicitFlagOnInner_WinsOverInheritedPar
     [Fact]
     public void Process_ThreeLevelChain_ExplicitFlagOnMiddle_PropagatesToItsDescendant()
     {
+        // Arrange
         var sut = _fixture.GetSut();
         var evt = new SentryEvent();
         var deepest = new Exception("deepest");
@@ -162,8 +172,10 @@ public void Process_ThreeLevelChain_ExplicitFlagOnMiddle_PropagatesToItsDescenda
         var outer = new Exception("outer", middle);
         outer.Data[Mechanism.HandledKey] = true;
 
+        // Act
         sut.Process(outer, evt);
 
+        // Assert
         Assert.NotNull(evt.SentryExceptions);
         // Discriminating: default and outer are both true, so deepest reporting false proves it
         // inherited the middle's explicit value rather than the default or the root.

test/Sentry.Tests/SentryClientExtensionsTests.cs

@@ -25,45 +25,57 @@ public void CaptureException_EnabledClient_CapturesEvent()
     [Fact]
     public void CaptureException_ExplicitHandledFalse_SetsFlag()
     {
+        // Arrange
         _ = _sut.IsEnabled.Returns(true);
         var ex = new Exception("caught and rethrown");
 
+        // Act
         _ = _sut.CaptureException(ex, handled: false);
 
+        // Assert
         Assert.Equal(false, ex.Data[Mechanism.HandledKey]);
     }
 
     [Fact]
     public void CaptureException_ExplicitHandledTrue_SetsFlag()
     {
+        // Arrange
         _ = _sut.IsEnabled.Returns(true);
         var ex = new Exception("caught");
 
+        // Act
         _ = _sut.CaptureException(ex, handled: true);
 
+        // Assert
         Assert.Equal(true, ex.Data[Mechanism.HandledKey]);
     }
 
     [Fact]
     public void CaptureException_NoHandledArgument_PreservesPresetFlag()
     {
+        // Arrange
         _ = _sut.IsEnabled.Returns(true);
         var ex = new Exception("preset mechanism");
         ex.SetSentryMechanism("MyHandler", handled: false);
 
+        // Act
         _ = _sut.CaptureException(ex);
 
+        // Assert
         Assert.Equal(false, ex.Data[Mechanism.HandledKey]);
     }
 
     [Fact]
     public void CaptureException_DisabledClientExplicitHandled_DoesNotMutateExceptionData()
     {
+        // Arrange
         _ = _sut.IsEnabled.Returns(false);
         var ex = new Exception("captured while disabled");
 
+        // Act
         var id = _sut.CaptureException(ex, handled: false);
 
+        // Assert
         Assert.False(ex.Data.Contains(Mechanism.HandledKey));
         Assert.Equal(SentryId.Empty, id);
         _ = _sut.DidNotReceive().CaptureEvent(Arg.Any<SentryEvent>());