fix: update tests to use overload with context (AzureAD#3130)

omidmloo · omidmloo · commit c23fef024f4f · 2025-03-01T00:43:14.000+03:30
diff --git a/test/Microsoft.IdentityModel.JsonWebTokens.Tests/JsonWebTokenHandlerTests.cs b/test/Microsoft.IdentityModel.JsonWebTokens.Tests/JsonWebTokenHandlerTests.cs
@@ -672,14 +672,13 @@ public void GetEncryptionKeys(CreateTokenTheoryData theoryData)
                 var jwtTokenFromJsonHandlerWithKid = new JsonWebToken(jweFromJsonHandlerWithKid);
                 var encryptionKeysFromJsonHandlerWithKid = theoryData.JsonWebTokenHandler.GetContentEncryptionKeys(jwtTokenFromJsonHandlerWithKid, theoryData.ValidationParameters, theoryData.Configuration);
 
-                Assert.True(IdentityComparer.AreEqual(encryptionKeysFromJsonHandlerWithKid, theoryData.ExpectedDecryptionKeys));
+                IdentityComparer.AreEqual(encryptionKeysFromJsonHandlerWithKid, theoryData.ExpectedDecryptionKeys, context);
                 theoryData.ExpectedException.ProcessNoException(context);
             }
             catch (Exception ex)
             {
                 theoryData.ExpectedException.ProcessException(ex, context);
             }
-
             TestUtilities.AssertFailIfErrors(context);
         }
 
diff --git a/test/Microsoft.IdentityModel.JsonWebTokens.Tests/JsonWebTokenTests.cs b/test/Microsoft.IdentityModel.JsonWebTokens.Tests/JsonWebTokenTests.cs
@@ -288,7 +288,7 @@ public void CompareJwtSecurityTokenWithJsonSecurityTokenMultipleAudiences()
             string header = "{}";
             var jsonWebToken = new JsonWebToken(header, payload);
             var jwtSecurityToken = new JwtSecurityToken($"{Base64UrlEncoder.Encode(header)}.{Base64UrlEncoder.Encode(payload)}.");
-            IdentityComparer.AreEqual(jsonWebToken.Claims, jwtSecurityToken.Claims);
+            IdentityComparer.AreEqual(jsonWebToken.Claims, jwtSecurityToken.Claims, context);
             IdentityComparer.AreEqual(jsonWebToken.Audiences, jwtSecurityToken.Audiences, context);
             TestUtilities.AssertFailIfErrors(context);
         }
diff --git a/test/Microsoft.IdentityModel.Logging.Tests/IdentityModelTelemetryUtilTests.cs b/test/Microsoft.IdentityModel.Logging.Tests/IdentityModelTelemetryUtilTests.cs
@@ -24,8 +24,7 @@ public void SetTelemetry(TelemetryTheoryData theoryData)
             {
                 IdentityModelTelemetryUtil.SetTelemetryData(theoryData.HttpRequestMessage, theoryData.AdditionalHeaders);
                 // check if the resulting headers are as expected
-                if (!IdentityComparer.AreEqual(theoryData.ExpectedHeaders, theoryData.HttpRequestMessage?.Headers))
-                    throw new ArgumentException("resulting headers do not match the expected headers.");
+                IdentityComparer.AreEqual(theoryData.ExpectedHeaders, theoryData.HttpRequestMessage?.Headers, testContext);
 
                 theoryData.ExpectedException.ProcessNoException(testContext);
             }
diff --git a/test/Microsoft.IdentityModel.Protocols.OpenIdConnect.Tests/OpenIdConnectConfigurationRetrieverTests.cs b/test/Microsoft.IdentityModel.Protocols.OpenIdConnect.Tests/OpenIdConnectConfigurationRetrieverTests.cs
@@ -139,6 +139,8 @@ public void Properties()
         private async Task<OpenIdConnectConfiguration> GetConfigurationFromHttpAsync(string uri, ExpectedException expectedException, OpenIdConnectConfiguration expectedConfiguration = null)
         {
             OpenIdConnectConfiguration openIdConnectConfiguration = null;
+            var testContext = new CompareContext($"{this}.GetConfigurationFromHttpAsync");
+
             try
             {
                 openIdConnectConfiguration = await OpenIdConnectConfigurationRetriever.GetAsync(uri, CancellationToken.None);
@@ -151,7 +153,7 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromHttpAsync(str
 
             if (expectedConfiguration != null)
             {
-                Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration));
+                Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration, testContext));
             }
 
             return openIdConnectConfiguration;
@@ -179,6 +181,8 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationAsync(string uri,
         private async Task<OpenIdConnectConfiguration> GetConfigurationFromTextAsync(string primaryDocument, string secondaryDocument, ExpectedException expectedException, OpenIdConnectConfiguration expectedConfiguration = null)
         {
             OpenIdConnectConfiguration openIdConnectConfiguration = null;
+            var testContext = new CompareContext($"{this}.GetConfigurationFromTextAsync");
+
             try
             {
                 openIdConnectConfiguration = await OpenIdConnectConfigurationRetriever.GetAsync(
@@ -192,7 +196,7 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromTextAsync(str
 
             if (expectedConfiguration != null)
             {
-                Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration));
+                Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration, testContext));
             }
 
             return openIdConnectConfiguration;
@@ -201,6 +205,8 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromTextAsync(str
         private async Task<OpenIdConnectConfiguration> GetConfigurationFromMixedAsync(string primaryDocument, ExpectedException expectedException, OpenIdConnectConfiguration expectedConfiguration = null)
         {
             OpenIdConnectConfiguration openIdConnectConfiguration = null;
+            var testContext = new CompareContext($"{this}.GetConfigurationFromMixedAsync");
+
             try
             {
                 openIdConnectConfiguration = await OpenIdConnectConfigurationRetriever.GetAsync("primary",
@@ -214,7 +220,7 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromMixedAsync(st
 
             if (expectedConfiguration != null)
             {
-                Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration));
+                Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration, testContext));
             }
 
             return openIdConnectConfiguration;
diff --git a/test/Microsoft.IdentityModel.Protocols.Tests/ExtensibilityTests.cs b/test/Microsoft.IdentityModel.Protocols.Tests/ExtensibilityTests.cs
@@ -92,13 +92,13 @@ public async Task ConfigurationManagerUsingCustomClass()
                 configManager.RequestRefresh();
                 configuration2 = await configManager.GetConfigurationAsync();
 
-                if (IdentityComparer.AreEqual(configuration.Issuer, configuration2.Issuer))
+                if (IdentityComparer.AreEqual(configuration.Issuer, configuration2.Issuer, CompareContext.Default))
                     await Task.Delay(1000);
                 else
                     break;
             }
 
-            if (IdentityComparer.AreEqual(configuration.Issuer, configuration2.Issuer))
+            if (IdentityComparer.AreEqual(configuration.Issuer, configuration2.Issuer, CompareContext.Default))
                 context.Diffs.Add($"Expected: {configuration.Issuer}, to be different from: {configuration2.Issuer}");
 
             TestUtilities.AssertFailIfErrors(context);
diff --git a/test/Microsoft.IdentityModel.TestUtils/TestUtilities.cs b/test/Microsoft.IdentityModel.TestUtils/TestUtilities.cs
@@ -198,7 +198,7 @@ public static void GetSet(GetSetContext context)
                         {
                             context.Errors.Add(propertyKV.Key + ": initial value != null && expected == null, initial value: " + initialValue.ToString());
                         }
-                        else if (initialValue != null && !IdentityComparer.AreEqual(initialValue, propertyKV.Value[0]))
+                        else if (initialValue != null && !IdentityComparer.AreEqual(initialValue, propertyKV.Value[0], CompareContext.Default))
                         {
                             context.Errors.Add(propertyKV.Key + ", initial value != expected. expected: " + propertyKV.Value[0].ToString() + ", was: " + initialValue.ToString());
                         }
@@ -422,7 +422,6 @@ public static void AssertFailIfErrors(CompareContext context)
         {
             AssertFailIfErrors(context.Title, context.Diffs);
         }
-
         public static void AssertFailIfErrors(string testId, List<string> errors)
         {
             if (errors.Count != 0)
diff --git a/test/Microsoft.IdentityModel.Validators.Tests/MicrosoftIdentityIssuerValidatorTest.cs b/test/Microsoft.IdentityModel.Validators.Tests/MicrosoftIdentityIssuerValidatorTest.cs
@@ -156,7 +156,7 @@ public async Task Validate_NullOrEmptyParameters_ThrowsException()
             ValidationResult<ValidatedIssuer> validatedIssuer = await ValidateIssuerAsync(string.Empty, jwtSecurityToken, validator);
             Assert.False(validatedIssuer.IsValid);
 
-            IdentityComparer.AreEqual(LogMessages.IDX40003, exception.Message);
+            IdentityComparer.AreEqual(LogMessages.IDX40003, exception.Message, context);
 
             Assert.Throws<ArgumentNullException>(ValidatorConstants.SecurityToken, () => validator.Validate(ValidatorConstants.AadIssuer, null, validationParams));
             await Assert.ThrowsAsync<ArgumentNullException>(async () => await ValidateIssuerAsync(ValidatorConstants.AadIssuer, null, validator));
diff --git a/test/Microsoft.IdentityModel.Xml.Tests/DSigSerializerTests.cs b/test/Microsoft.IdentityModel.Xml.Tests/DSigSerializerTests.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Security.Cryptography;
 using System.Text;
 using System.Xml;
@@ -115,7 +116,7 @@ public void WriteKeyInfo(DSigSerializerTheoryData theoryData)
                 theoryData.Serializer.WriteKeyInfo(writer, keyInfo);
                 writer.Flush();
                 var xml = Encoding.UTF8.GetString(ms.ToArray());
-                IdentityComparer.AreEqual(theoryData.Xml, xml);
+                IdentityComparer.AreEqual(theoryData.Xml, xml, context);
             }
             catch (Exception ex)
             {
@@ -251,7 +252,7 @@ public void WriteSignature(DSigSerializerTheoryData theoryData)
                 theoryData.Serializer.WriteSignature(writer, signature);
                 writer.Flush();
                 var xml = Encoding.UTF8.GetString(ms.ToArray());
-                IdentityComparer.AreEqual(theoryData.Xml, xml);
+                IdentityComparer.AreEqual(theoryData.Xml, xml, context);
             }
             catch (Exception ex)
             {
diff --git a/test/System.IdentityModel.Tokens.Jwt.Tests/JwtSecurityTokenHandlerTests.cs b/test/System.IdentityModel.Tokens.Jwt.Tests/JwtSecurityTokenHandlerTests.cs
@@ -801,13 +801,14 @@ public static TheoryData<JwtTheoryData> ActorTheoryData
         public void BootstrapContext(JwtTheoryData theoryData)
         {
             TestUtilities.WriteHeader($"{this}.BootstrapContext", theoryData);
+            var testContext = new CompareContext();
 
             var claimsPrincipal = theoryData.TokenHandler.ValidateToken(theoryData.Token, theoryData.ValidationParameters, out SecurityToken securityToken);
             var bootstrapContext = (claimsPrincipal.Identity as ClaimsIdentity).BootstrapContext as string;
             if (theoryData.ValidationParameters.SaveSigninToken)
             {
                 Assert.NotNull(bootstrapContext);
-                Assert.True(IdentityComparer.AreEqual(claimsPrincipal, theoryData.TokenHandler.ValidateToken(bootstrapContext, theoryData.ValidationParameters, out SecurityToken validatedToken)));
+                Assert.True(IdentityComparer.AreEqual(claimsPrincipal, theoryData.TokenHandler.ValidateToken(bootstrapContext, theoryData.ValidationParameters, out SecurityToken validatedToken), testContext));
             }
             else
             {
@@ -3083,8 +3084,8 @@ public void GetEncryptionKeys(CreateTokenTheoryData theoryData)
 
                 var encryptionKeysFromJwtHandlerWithNoKid = theoryData.JwtSecurityTokenHandler.GetContentEncryptionKeys(jwtTokenFromJwtHandlerWithNoKid, theoryData.ValidationParameters);
 
-                IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithKid, theoryData.ExpectedDecryptionKeys);
-                IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithNoKid, theoryData.ExpectedDecryptionKeys);
+                IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithKid, theoryData.ExpectedDecryptionKeys, context);
+                IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithNoKid, theoryData.ExpectedDecryptionKeys, context);
                 IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithKid, encryptionKeysFromJwtHandlerWithNoKid, context);
                 theoryData.ExpectedException.ProcessNoException(context);
             }
diff --git a/test/System.IdentityModel.Tokens.Jwt.Tests/JwtSecurityTokenTests.cs b/test/System.IdentityModel.Tokens.Jwt.Tests/JwtSecurityTokenTests.cs
@@ -185,6 +185,7 @@ public void EmbeddedTokenConstructor1(string testId, JwtSecurityTokenTestVariati
         {
             JwtSecurityToken outerJwt = null;
             JwtSecurityToken innerJwt = null;
+            var testContext = new CompareContext($"{this}.EmbeddedTokenConstructor1");
 
             // create inner token
             try
@@ -229,7 +230,7 @@ public void EmbeddedTokenConstructor1(string testId, JwtSecurityTokenTestVariati
 
                 if (null != outerTokenVariation.ExpectedJwtSecurityToken)
                 {
-                    Assert.True(IdentityComparer.AreEqual(outerTokenVariation.ExpectedJwtSecurityToken, outerJwt));
+                    Assert.True(IdentityComparer.AreEqual(outerTokenVariation.ExpectedJwtSecurityToken, outerJwt, testContext));
                 }
             }
             catch (Exception ex)
@@ -247,7 +248,7 @@ public void EmbeddedTokenConstructor1(string testId, JwtSecurityTokenTestVariati
 
                 if (null != innerTokenVariation && null != innerTokenVariation.ExpectedJwtSecurityToken)
                 {
-                    Assert.True(IdentityComparer.AreEqual(innerTokenVariation.ExpectedJwtSecurityToken, innerJwt));
+                    Assert.True(IdentityComparer.AreEqual(innerTokenVariation.ExpectedJwtSecurityToken, innerJwt, testContext));
                 }
             }
             catch (Exception ex)
@@ -394,6 +395,8 @@ private static void ParseJweParts(string jwe, out string headerPart, out string
         private void RunConstructionTest(JwtSecurityTokenTestVariation variation)
         {
             JwtSecurityToken jwt = null;
+            var testContext = new CompareContext($"{this}.RunConstructionTest");
+
             try
             {
                 jwt = CreateToken(variation);
@@ -414,7 +417,7 @@ private void RunConstructionTest(JwtSecurityTokenTestVariation variation)
 
                 if (null != variation.ExpectedJwtSecurityToken)
                 {
-                    Assert.True(IdentityComparer.AreEqual(variation.ExpectedJwtSecurityToken, jwt));
+                    Assert.True(IdentityComparer.AreEqual(variation.ExpectedJwtSecurityToken, jwt, testContext));
                 }
             }
             catch (Exception ex)

Original file line number	Diff line number	Diff line change
`@@ -672,14 +672,13 @@ public void GetEncryptionKeys(CreateTokenTheoryData theoryData)`
`672`	`672`	`var jwtTokenFromJsonHandlerWithKid = new JsonWebToken(jweFromJsonHandlerWithKid);`
`673`	`673`	`var encryptionKeysFromJsonHandlerWithKid = theoryData.JsonWebTokenHandler.GetContentEncryptionKeys(jwtTokenFromJsonHandlerWithKid, theoryData.ValidationParameters, theoryData.Configuration);`
`674`	`674`
`675`		`- Assert.True(IdentityComparer.AreEqual(encryptionKeysFromJsonHandlerWithKid, theoryData.ExpectedDecryptionKeys));`
	`675`	`+ IdentityComparer.AreEqual(encryptionKeysFromJsonHandlerWithKid, theoryData.ExpectedDecryptionKeys, context);`
`676`	`676`	`theoryData.ExpectedException.ProcessNoException(context);`
`677`	`677`	`}`
`678`	`678`	`catch (Exception ex)`
`679`	`679`	`{`
`680`	`680`	`theoryData.ExpectedException.ProcessException(ex, context);`
`681`	`681`	`}`
`682`		`-`
`683`	`682`	`TestUtilities.AssertFailIfErrors(context);`
`684`	`683`	`}`
`685`	`684`
Original file line number	Diff line number	Diff line change
`@@ -288,7 +288,7 @@ public void CompareJwtSecurityTokenWithJsonSecurityTokenMultipleAudiences()`
`288`	`288`	`string header = "{}";`
`289`	`289`	`var jsonWebToken = new JsonWebToken(header, payload);`
`290`	`290`	`var jwtSecurityToken = new JwtSecurityToken($"{Base64UrlEncoder.Encode(header)}.{Base64UrlEncoder.Encode(payload)}.");`
`291`		`- IdentityComparer.AreEqual(jsonWebToken.Claims, jwtSecurityToken.Claims);`
	`291`	`+ IdentityComparer.AreEqual(jsonWebToken.Claims, jwtSecurityToken.Claims, context);`
`292`	`292`	`IdentityComparer.AreEqual(jsonWebToken.Audiences, jwtSecurityToken.Audiences, context);`
`293`	`293`	`TestUtilities.AssertFailIfErrors(context);`
`294`	`294`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,7 @@ public void SetTelemetry(TelemetryTheoryData theoryData)`
`24`	`24`	`{`
`25`	`25`	`IdentityModelTelemetryUtil.SetTelemetryData(theoryData.HttpRequestMessage, theoryData.AdditionalHeaders);`
`26`	`26`	`// check if the resulting headers are as expected`
`27`		`- if (!IdentityComparer.AreEqual(theoryData.ExpectedHeaders, theoryData.HttpRequestMessage?.Headers))`
`28`		`- throw new ArgumentException("resulting headers do not match the expected headers.");`
	`27`	`+ IdentityComparer.AreEqual(theoryData.ExpectedHeaders, theoryData.HttpRequestMessage?.Headers, testContext);`
`29`	`28`
`30`	`29`	`theoryData.ExpectedException.ProcessNoException(testContext);`
`31`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -139,6 +139,8 @@ public void Properties()`
`139`	`139`	`private async Task<OpenIdConnectConfiguration> GetConfigurationFromHttpAsync(string uri, ExpectedException expectedException, OpenIdConnectConfiguration expectedConfiguration = null)`
`140`	`140`	`{`
`141`	`141`	`OpenIdConnectConfiguration openIdConnectConfiguration = null;`
	`142`	`+ var testContext = new CompareContext($"{this}.GetConfigurationFromHttpAsync");`
	`143`	`+`
`142`	`144`	`try`
`143`	`145`	`{`
`144`	`146`	`openIdConnectConfiguration = await OpenIdConnectConfigurationRetriever.GetAsync(uri, CancellationToken.None);`
`@@ -151,7 +153,7 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromHttpAsync(str`
`151`	`153`
`152`	`154`	`if (expectedConfiguration != null)`
`153`	`155`	`{`
`154`		`- Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration));`
	`156`	`+ Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration, testContext));`
`155`	`157`	`}`
`156`	`158`
`157`	`159`	`return openIdConnectConfiguration;`
`@@ -179,6 +181,8 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationAsync(string uri,`
`179`	`181`	`private async Task<OpenIdConnectConfiguration> GetConfigurationFromTextAsync(string primaryDocument, string secondaryDocument, ExpectedException expectedException, OpenIdConnectConfiguration expectedConfiguration = null)`
`180`	`182`	`{`
`181`	`183`	`OpenIdConnectConfiguration openIdConnectConfiguration = null;`
	`184`	`+ var testContext = new CompareContext($"{this}.GetConfigurationFromTextAsync");`
	`185`	`+`
`182`	`186`	`try`
`183`	`187`	`{`
`184`	`188`	`openIdConnectConfiguration = await OpenIdConnectConfigurationRetriever.GetAsync(`
`@@ -192,7 +196,7 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromTextAsync(str`
`192`	`196`
`193`	`197`	`if (expectedConfiguration != null)`
`194`	`198`	`{`
`195`		`- Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration));`
	`199`	`+ Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration, testContext));`
`196`	`200`	`}`
`197`	`201`
`198`	`202`	`return openIdConnectConfiguration;`
`@@ -201,6 +205,8 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromTextAsync(str`
`201`	`205`	`private async Task<OpenIdConnectConfiguration> GetConfigurationFromMixedAsync(string primaryDocument, ExpectedException expectedException, OpenIdConnectConfiguration expectedConfiguration = null)`
`202`	`206`	`{`
`203`	`207`	`OpenIdConnectConfiguration openIdConnectConfiguration = null;`
	`208`	`+ var testContext = new CompareContext($"{this}.GetConfigurationFromMixedAsync");`
	`209`	`+`
`204`	`210`	`try`
`205`	`211`	`{`
`206`	`212`	`openIdConnectConfiguration = await OpenIdConnectConfigurationRetriever.GetAsync("primary",`
`@@ -214,7 +220,7 @@ private async Task<OpenIdConnectConfiguration> GetConfigurationFromMixedAsync(st`
`214`	`220`
`215`	`221`	`if (expectedConfiguration != null)`
`216`	`222`	`{`
`217`		`- Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration));`
	`223`	`+ Assert.True(IdentityComparer.AreEqual(openIdConnectConfiguration, expectedConfiguration, testContext));`
`218`	`224`	`}`
`219`	`225`
`220`	`226`	`return openIdConnectConfiguration;`
Original file line number	Diff line number	Diff line change
`@@ -198,7 +198,7 @@ public static void GetSet(GetSetContext context)`
`198`	`198`	`{`
`199`	`199`	`context.Errors.Add(propertyKV.Key + ": initial value != null && expected == null, initial value: " + initialValue.ToString());`
`200`	`200`	`}`
`201`		`- else if (initialValue != null && !IdentityComparer.AreEqual(initialValue, propertyKV.Value[0]))`
	`201`	`+ else if (initialValue != null && !IdentityComparer.AreEqual(initialValue, propertyKV.Value[0], CompareContext.Default))`
`202`	`202`	`{`
`203`	`203`	`context.Errors.Add(propertyKV.Key + ", initial value != expected. expected: " + propertyKV.Value[0].ToString() + ", was: " + initialValue.ToString());`
`204`	`204`	`}`
`@@ -422,7 +422,6 @@ public static void AssertFailIfErrors(CompareContext context)`
`422`	`422`	`{`
`423`	`423`	`AssertFailIfErrors(context.Title, context.Diffs);`
`424`	`424`	`}`
`425`		`-`
`426`	`425`	`public static void AssertFailIfErrors(string testId, List<string> errors)`
`427`	`426`	`{`
`428`	`427`	`if (errors.Count != 0)`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using System.IO;`
	`7`	`+using System.Linq;`
`7`	`8`	`using System.Security.Cryptography;`
`8`	`9`	`using System.Text;`
`9`	`10`	`using System.Xml;`
`@@ -115,7 +116,7 @@ public void WriteKeyInfo(DSigSerializerTheoryData theoryData)`
`115`	`116`	`theoryData.Serializer.WriteKeyInfo(writer, keyInfo);`
`116`	`117`	`writer.Flush();`
`117`	`118`	`var xml = Encoding.UTF8.GetString(ms.ToArray());`
`118`		`- IdentityComparer.AreEqual(theoryData.Xml, xml);`
	`119`	`+ IdentityComparer.AreEqual(theoryData.Xml, xml, context);`
`119`	`120`	`}`
`120`	`121`	`catch (Exception ex)`
`121`	`122`	`{`
`@@ -251,7 +252,7 @@ public void WriteSignature(DSigSerializerTheoryData theoryData)`
`251`	`252`	`theoryData.Serializer.WriteSignature(writer, signature);`
`252`	`253`	`writer.Flush();`
`253`	`254`	`var xml = Encoding.UTF8.GetString(ms.ToArray());`
`254`		`- IdentityComparer.AreEqual(theoryData.Xml, xml);`
	`255`	`+ IdentityComparer.AreEqual(theoryData.Xml, xml, context);`
`255`	`256`	`}`
`256`	`257`	`catch (Exception ex)`
`257`	`258`	`{`
Original file line number	Diff line number	Diff line change
`@@ -801,13 +801,14 @@ public static TheoryData<JwtTheoryData> ActorTheoryData`
`801`	`801`	`public void BootstrapContext(JwtTheoryData theoryData)`
`802`	`802`	`{`
`803`	`803`	`TestUtilities.WriteHeader($"{this}.BootstrapContext", theoryData);`
	`804`	`+ var testContext = new CompareContext();`
`804`	`805`
`805`	`806`	`var claimsPrincipal = theoryData.TokenHandler.ValidateToken(theoryData.Token, theoryData.ValidationParameters, out SecurityToken securityToken);`
`806`	`807`	`var bootstrapContext = (claimsPrincipal.Identity as ClaimsIdentity).BootstrapContext as string;`
`807`	`808`	`if (theoryData.ValidationParameters.SaveSigninToken)`
`808`	`809`	`{`
`809`	`810`	`Assert.NotNull(bootstrapContext);`
`810`		`- Assert.True(IdentityComparer.AreEqual(claimsPrincipal, theoryData.TokenHandler.ValidateToken(bootstrapContext, theoryData.ValidationParameters, out SecurityToken validatedToken)));`
	`811`	`+ Assert.True(IdentityComparer.AreEqual(claimsPrincipal, theoryData.TokenHandler.ValidateToken(bootstrapContext, theoryData.ValidationParameters, out SecurityToken validatedToken), testContext));`
`811`	`812`	`}`
`812`	`813`	`else`
`813`	`814`	`{`
`@@ -3083,8 +3084,8 @@ public void GetEncryptionKeys(CreateTokenTheoryData theoryData)`
`3083`	`3084`
`3084`	`3085`	`var encryptionKeysFromJwtHandlerWithNoKid = theoryData.JwtSecurityTokenHandler.GetContentEncryptionKeys(jwtTokenFromJwtHandlerWithNoKid, theoryData.ValidationParameters);`
`3085`	`3086`
`3086`		`- IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithKid, theoryData.ExpectedDecryptionKeys);`
`3087`		`- IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithNoKid, theoryData.ExpectedDecryptionKeys);`
	`3087`	`+ IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithKid, theoryData.ExpectedDecryptionKeys, context);`
	`3088`	`+ IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithNoKid, theoryData.ExpectedDecryptionKeys, context);`
`3088`	`3089`	`IdentityComparer.AreEqual(encryptionKeysFromJwtHandlerWithKid, encryptionKeysFromJwtHandlerWithNoKid, context);`
`3089`	`3090`	`theoryData.ExpectedException.ProcessNoException(context);`
`3090`	`3091`	`}`
Original file line number	Diff line number	Diff line change
`@@ -185,6 +185,7 @@ public void EmbeddedTokenConstructor1(string testId, JwtSecurityTokenTestVariati`
`185`	`185`	`{`
`186`	`186`	`JwtSecurityToken outerJwt = null;`
`187`	`187`	`JwtSecurityToken innerJwt = null;`
	`188`	`+ var testContext = new CompareContext($"{this}.EmbeddedTokenConstructor1");`
`188`	`189`
`189`	`190`	`// create inner token`
`190`	`191`	`try`
`@@ -229,7 +230,7 @@ public void EmbeddedTokenConstructor1(string testId, JwtSecurityTokenTestVariati`
`229`	`230`
`230`	`231`	`if (null != outerTokenVariation.ExpectedJwtSecurityToken)`
`231`	`232`	`{`
`232`		`- Assert.True(IdentityComparer.AreEqual(outerTokenVariation.ExpectedJwtSecurityToken, outerJwt));`
	`233`	`+ Assert.True(IdentityComparer.AreEqual(outerTokenVariation.ExpectedJwtSecurityToken, outerJwt, testContext));`
`233`	`234`	`}`
`234`	`235`	`}`
`235`	`236`	`catch (Exception ex)`
`@@ -247,7 +248,7 @@ public void EmbeddedTokenConstructor1(string testId, JwtSecurityTokenTestVariati`
`247`	`248`
`248`	`249`	`if (null != innerTokenVariation && null != innerTokenVariation.ExpectedJwtSecurityToken)`
`249`	`250`	`{`
`250`		`- Assert.True(IdentityComparer.AreEqual(innerTokenVariation.ExpectedJwtSecurityToken, innerJwt));`
	`251`	`+ Assert.True(IdentityComparer.AreEqual(innerTokenVariation.ExpectedJwtSecurityToken, innerJwt, testContext));`
`251`	`252`	`}`
`252`	`253`	`}`
`253`	`254`	`catch (Exception ex)`
`@@ -394,6 +395,8 @@ private static void ParseJweParts(string jwe, out string headerPart, out string`
`394`	`395`	`private void RunConstructionTest(JwtSecurityTokenTestVariation variation)`
`395`	`396`	`{`
`396`	`397`	`JwtSecurityToken jwt = null;`
	`398`	`+ var testContext = new CompareContext($"{this}.RunConstructionTest");`
	`399`	`+`
`397`	`400`	`try`
`398`	`401`	`{`
`399`	`402`	`jwt = CreateToken(variation);`
`@@ -414,7 +417,7 @@ private void RunConstructionTest(JwtSecurityTokenTestVariation variation)`
`414`	`417`
`415`	`418`	`if (null != variation.ExpectedJwtSecurityToken)`
`416`	`419`	`{`
`417`		`- Assert.True(IdentityComparer.AreEqual(variation.ExpectedJwtSecurityToken, jwt));`
	`420`	`+ Assert.True(IdentityComparer.AreEqual(variation.ExpectedJwtSecurityToken, jwt, testContext));`
`418`	`421`	`}`
`419`	`422`	`}`
`420`	`423`	`catch (Exception ex)`