69Assert.True( 124Assert.True( 127Assert.True(

20Assert.True(iSerializable || serializable, "Type should either implement ISerializable or be marked as [Serializable]"); 45Assert.True(

43Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 83Assert.True(result, "Error: expected response from service: 'true' Actual was: 'false'"); 127Assert.True(handlerCalled, "Error: expected client to call intercepting handler"); 128Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 185Assert.True(result == substituteString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 269Assert.True(userAgentHeaderSent, "User-Agent header should have been sent.");

38Assert.True(String.Equals(testString, result), String.Format("Expected result was {0}. Actual was {1}", testString, result));

39Assert.True(asyncFlowDisabled, "Async flow of Operation Context isn't disabled");

34Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

57Assert.True(String.Equals(expectedMessageID, actualMessageID), String.Format("Expected Message ID was {0}. Actual was {1}", expectedMessageID, actualMessageID));

155Assert.True(success, "Test Scenario: TypedProxy_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out"); 220Assert.True(success, "Test Scenario: TypedProxy_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out");

41Assert.True(String.Equals(echoText, result), 90Assert.True(String.Equals(expected, actual), 94Assert.True(String.Equals(expected, actual), 144Assert.True(String.Equals(expected, actual), 148Assert.True(String.Equals(expected, actual), 195Assert.True(eventsCalled.Count == 0, 199Assert.True(proxyEventsCalled.Count == 0, 245Assert.True(CommunicationState.Closed == client.State, 249Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 253Assert.True(CommunicationState.Closed == factory.State,

39Assert.True(property.SuppressEntityBody == false, "Expected SuppressEntityBody to be 'false'"); 42Assert.True(property.Headers.Count > 0, "TestHttpRequestMessageProperty.Headers should not have empty headers"); 86Assert.True(property.SuppressEntityBody == false, "Expected SuppressEntityBody to be 'false'"); 89Assert.True(property.Headers.Count > 0, "TestHttpRequestMessageProperty.Headers should not have empty headers"); 134Assert.True(data.BeforeSendRequestCalled, "BeforeSendRequest should have been called"); 135Assert.True(data.Request != null, "Did not call pass Request to BeforeSendRequest"); 136Assert.True(data.Channel != null, "Did not call pass Channel to BeforeSendRequest"); 137Assert.True(data.AfterReceiveReplyCalled, "AfterReceiveReplyCalled should have been called"); 138Assert.True(data.Reply != null, "Did not call pass Reply to AfterReceiveReplyCalled"); 219Assert.True(CommunicationState.Created == client.State, 222Assert.True(CommunicationState.Created == factory.State, 241Assert.True(CommunicationState.Opened == client.State, 244Assert.True(CommunicationState.Opened == factory.State, 247Assert.True(CommunicationState.Opened == ((ICommunicationObject)serviceProxy).State, 256Assert.True(CommunicationState.Closed == client.State, 260Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 264Assert.True(CommunicationState.Closed == factory.State, 294Assert.True(CommunicationState.Created == client.State, 297Assert.True(CommunicationState.Created == factory.State, 317Assert.True(CommunicationState.Opened == client.State, 320Assert.True(CommunicationState.Opened == factory.State, 323Assert.True(CommunicationState.Opened == ((ICommunicationObject)serviceProxy).State, 333Assert.True(CommunicationState.Closed == client.State, 337Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 341Assert.True(CommunicationState.Closed == factory.State, 373Assert.True(CommunicationState.Created == client.State, 376Assert.True(CommunicationState.Created == factory.State, 396Assert.True(CommunicationState.Opened == client.State, 399Assert.True(CommunicationState.Opened == factory.State, 402Assert.True(CommunicationState.Opened == ((ICommunicationObject)serviceProxy).State, 412Assert.True(CommunicationState.Closed == client.State, 416Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 420Assert.True(CommunicationState.Closed == factory.State, 462Assert.True(CommunicationState.Closed == client.State, 466Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 470Assert.True(CommunicationState.Closed == factory.State, 513Assert.True(CommunicationState.Closed == client.State, 517Assert.True(CommunicationState.Closed == ((ICommunicationObject)serviceProxy).State, 521Assert.True(CommunicationState.Closed == factory.State, 565Assert.True(String.Equals(expected, actual), 569Assert.True(String.Equals(expected, actual), 619Assert.True(String.Equals(expected, actual), 623Assert.True(String.Equals(expected, actual), 668Assert.True(eventsCalled.Count == 0, 672Assert.True(proxyEventsCalled.Count == 0, 799Assert.True(string.Empty == outofScopeResult, string.Format("Expect call out of the OperationContextScope does not have the custom header {0}", customHeaderName));

30Assert.True(cookieManager != null, "cookieManager was null."); 31Assert.True(cookieManager.CookieContainer != null, "cookieManager.CookieContainer was null."); 43Assert.True(cookieSentOut == cookieSentBack, 73Assert.True(cookieManager != null, "cookieManager was null."); 74Assert.True(cookieManager.CookieContainer != null, "cookieManager.CookieContainer was null."); 86Assert.True(cookies != null, "cookies was null."); 89Assert.True(cookie != null, "cookie was null."); 94Assert.True(timeReturned != null, "timeReturned != null"); 95Assert.True(timeSetInCookie != null, "timeSetInCookie != null"); 96Assert.True(timeReturned == timeSetInCookie,

38Assert.True(clientCredentials != null, "ClientCredentials should not be null"); 39Assert.True(clientCredentials.ClientCertificate != null, "ClientCredentials.ClientCertificate should not be null"); 40Assert.True(clientCredentials.ServiceCertificate != null, "ClientCredentials.ServiceCertificate should not be null"); 41Assert.True(clientCredentials.HttpDigest != null, "ClientCredentials.HttpDigest should not be null");

86Assert.True(guid == returnedGuid,

47Assert.True(String.Equals(result1.Result, expectedErrorDescription), String.Format("Expected Error Description: {0}/Actual Error Description: {1}", expectedErrorDescription, result2.Result)); 49Assert.True(returnedErrorCode.Equals(TestTypes.ErrorCode.UserNotAuthenticated), String.Format("Expected Error Code: {0}/nActual Error Code: {1}", TestTypes.ErrorCode.UserNotAuthenticated, returnedErrorCode)); 50Assert.True(result1.HttpStatusCode.Equals(System.Net.HttpStatusCode.Unauthorized), String.Format("Expected HttpStatusCode: {0}/nActual HttpStatusCode: {1}", System.Net.HttpStatusCode.Unauthorized, result2.HttpStatusCode)); 54Assert.True(String.Equals(result2.Result, expectedErrorDescription), String.Format("Expected Error Description: {0}/nActual Error Description: {1}", expectedErrorDescription, result2.Result)); 56Assert.True(returnedErrorCode.Equals(TestTypes.ErrorCode.Ok), String.Format("Expected Error Code: {0}/nActual Error Code: {1}", TestTypes.ErrorCode.Ok, returnedErrorCode)); 57Assert.True(result2.HttpStatusCode.Equals(System.Net.HttpStatusCode.OK), String.Format("Expected HttpStatusCode: {0}/nActual HttpStatusCode: {1}", System.Net.HttpStatusCode.OK, result2.HttpStatusCode)); 96Assert.True(String.Equals(authorizationHeaderValue, accessToken), String.Format("Expected Authorization Header value: {0}/nActual Authorization Header value: {1}", accessToken, authorizationHeaderValue)); 97Assert.True(String.Equals(authTypeHeaderValue, authType.ToString()), String.Format("Expected AuthType Header value: {0}/nActual AuthType Header value: {1}", authType.ToString(), authTypeHeaderValue));

49Assert.True(String.Equals(exception.Message, exceptionMsg), String.Format("Expected exception message: {0}\nActual exception message: {1}", exceptionMsg, exception.Message)); 96Assert.True((watch.ElapsedMilliseconds >= lowRange && watch.ElapsedMilliseconds <= highRange), 143Assert.True((watch.ElapsedMilliseconds >= lowRange && watch.ElapsedMilliseconds <= highRange), 179Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected fault message: {0}\nActual fault message: {1}", faultMsg, exception.Detail.Message)); 214Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected fault message: {0}\nActual fault message: {1}", faultMsg, exception.Detail.Message)); 354Assert.True((String.Equals("test", results[i])), 363Assert.True(toe == null, String.Format("Task [{0}] should not have failed with TimeoutException", i)); 367Assert.True(nFailures > 0, 379Assert.True(elapsedMs < expectedElapsedMs,

51Assert.True(exception.Message.Contains(nonExistentHost), string.Format("Expected exception message to contain: '{0}'\nThe exception message was: {1}", nonExistentHost, exception.Message)); 110Assert.True(result == "Success!", string.Format("Test Case failed, expected the returned string to be: {0}, instead it was: {1}", "Success!", result)); 184Assert.True(exception.Message.Contains(notFoundUrl), string.Format("Expected exception message to contain: '{0}'\nThe exception message was:{1}", notFoundUrl, exception.Message)); 222Assert.True(exception.Message.Contains(protocolExceptionUri), string.Format("Expected exception message to contain: '{0}'\nThe exception was: '{1}'", protocolExceptionUri, exception.Message)); 273Assert.True(String.Equals(exceptionCodeName, exception.Code.Name), String.Format("Expected exception code name: {0}\nActual exception code name: {1}", exceptionCodeName, exception.Code.Name)); 274Assert.True(String.Equals(exceptionReason, exception.Reason.GetMatchingTranslation().Text), String.Format("Expected exception reason: {0}\nActual exception reason: {1}", exceptionReason, exception.Reason.GetMatchingTranslation().Text)); 326Assert.True(String.Equals(exceptionCodeName, exception.Code.Name), String.Format("Expected exception code name: {0}\nActual exception code name: {1}", exceptionCodeName, exception.Code.Name)); 327Assert.True(String.Equals(exceptionReason, exception.Reason.GetMatchingTranslation().Text), String.Format("Expected exception reason: {0}\nActual exception reason: {1}", exceptionReason, exception.Reason.GetMatchingTranslation().Text)); 408Assert.True(exception.Message.Contains(Endpoints.Tcp_RevokedServerCertResource_HostName), 455Assert.True(exception.Message.Contains(Endpoints.Tcp_RevokedServerCertResource_HostName), 604Assert.True((String.Equals("test", results[i])), 613Assert.True(toe == null, String.Format("Task [{0}] should not have failed with TimeoutException", i)); 617Assert.True(nFailures > 0, 621Assert.True(nFailures < operationCount, 631Assert.True(elapsedMs < expectedElapsedMs,

75Assert.True(success, "Test Scenario: TypedProxy_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out"); 110Assert.True(success, "Test Scenario: TypedProxy_AsyncTask_Call_WithSingleThreadedSyncContext timed out"); 139Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 163Assert.True(success, "Test Scenario: TypedProxy_Synchronous_Call_WithSingleThreadedSyncContext timed out"); 195Assert.True(startThread == Environment.CurrentManagedThreadId, String.Format("Expected continuation to happen on thread {0} but actually continued on thread {1}", 201Assert.True(success, String.Format("Test didn't complete within the expected time")); 202Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 252Assert.True(String.Equals(replyMessageAction, action + "Response"), 261Assert.True(String.Equals(actualResponse, expectedResponse), 316Assert.True(String.Equals(replyMessageAction, action + "Response"), 325Assert.True(String.Equals(actualResponse, expectedResponse), 381Assert.True(String.Equals(replyMessageAction, action + "Response"), 390Assert.True(String.Equals(actualResponse, expectedResponse), 481Assert.True(success, String.Format("The AsyncCallback was not called. If the AsyncCallback had been called the waitEvent would have been set to 'True', but the value of waitEvent was: {0}", success)); 482Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 517Assert.True(success, String.Format("The IAsyncResult was not called. If the IAsyncResult had been called the AsyncWaitHandle would have been set to 'True', but the value of AsyncWaitHandle was: {0}", success)); 523Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result)); 556Assert.True(String.Equals(result, "Hello"), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello", result));

29Assert.True(success, "Test Scenario: ServiceContract_TypedProxy_NetTcpBinding_AsyncBeginEnd_Call_WithSingleThreadedSyncContext timed out"); 44Assert.True(success, "Test Scenario: ServiceContract_TypedProxy__NetTcpBinding_AsyncTask_Call_WithSingleThreadedSyncContext timed out"); 75Assert.True(guid == returnedGuid, String.Format("The sent GUID does not match the returned GUID. Sent: {0} Received: {1}", guid, returnedGuid));

43Assert.True(response != null, "GetDataUsingDataContract(request) returned null"); 45Assert.True(String.Equals(response.StringValue, expectedStringValue), String.Format("Expected CompositeType.StringValue \"{0}\", actual was \"{1}\"", 47Assert.True(response.BoolValue == request.BoolValue, String.Format("Expected CompositeType.BoolValue \"{0}\", actual was \"{1}\"",

40Assert.True((guid == returnedType.GuidValue), String.Format("The Guid sent was not the same as the Guid returned.\nSent: {0}\nReturned: {1}", guid, returnedType.GuidValue)); 78Assert.True((guid.ToString() == returnedType.StringValue), String.Format("The Guid to string value sent was not the same as what was returned.\nSent: {0}\nReturned: {1}", guid.ToString(), returnedType.StringValue));

42Assert.True(manager.GetType() == (typeof(Manager)), string.Format("Expected type: {0}, Actual type: {1}", typeof(Manager), manager.GetType())); 43Assert.True(((Manager)manager).Name == "jone", string.Format("Expected Name: {0}, Actual Name: {1}", "jone", ((Manager)manager).Name)); 44Assert.True(((Manager)manager).Age == "10", string.Format("Expected Age: {0}, Actual Age: {1}", "10", ((Manager)manager).Age)); 45Assert.True(((Manager)manager).OfficeId == 1, string.Format("Expected Id: {0}, Actual Id: {1}", 1, ((Manager)manager).OfficeId));

45Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected Fault Message: {0}, actual: {1}", faultMsg, exception.Detail.Message)); 79Assert.True(String.Equals(exception.Detail.Message, faultMsg), String.Format("Expected Fault Message: {0}, actual: {1}", faultMsg, exception.Detail.Message)); 251Assert.True(input.Length == response.Length, String.Format("Expected {0} response items but actual was {1}", input.Length, response.Length)); 252Assert.True(response[0] != null, "Expected response item to be FaultDetail, but actual was null"); 253Assert.True(response[0].GetType() == typeof(FaultDetail), String.Format("Expected response item to be FaultDetail but actual was {0}", response[0].GetType())); 254Assert.True(response[1] != null, "Expected response item to be KnownTypeA, but actual was null"); 255Assert.True(response[1].GetType() == typeof(KnownTypeA), String.Format("Expected response item to be FaultDetail2 but actual was {0}", response[1].GetType()));

42Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp != null, "Expected testFaultWithKnownTypeClientOp is NOT null"); 43Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos.Count == 1, string.Format("expected FaultContractInfos count is 1, actual: {0}", TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos.Count)); 44Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Action == action, string.Format("expected FaultContractInfo Action is {0}, actual: {1}", action, TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Action)); 45Assert.True(TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Detail == detail, string.Format("expected FaultContractInfo Detail is {0}, actual: {1}", detail.ToString(), TestFaultContractInfosBehavior.testFaultWithKnownTypeClientOp.FaultContractInfos[0].Detail.ToString()));

25Assert.True(reader.LocalName.Equals(wrapperName), 28Assert.True(reader.NamespaceURI.Equals(MessageContractConstants.wrapperNamespace), 58Assert.True(reader.LocalName.Equals(wrapperName), 63Assert.True(reader.LocalName.Equals(MessageContractConstants.dateElementName), 70Assert.True(reader.LocalName.Equals(MessageContractConstants.transactionElementName), 77Assert.True(reader.LocalName.Equals(MessageContractConstants.customerElementName), 85Assert.True(reader.IsStartElement() == false && reader.LocalName.Equals(wrapperName), 115Assert.True(elementFound, 133Assert.True(header != null, "There's no header in the message."); 134Assert.True(header.MustUnderstand, "Expected MustUnderstand to be true, but it was false."); 151Assert.True(header != null, "There's no header in the message.");

43Assert.True(String.Equals(requestData.accountName, replyData.accountName), 47Assert.True(requestData.amount == replyData.amount, 51Assert.True(String.Equals(requestData.requestSingleValue, replyData.replySingleValue), 71Assert.True(array2 != null, 74Assert.True(array1.Length == array2.Length, 80Assert.True(array1[i] == array2[i], 109Assert.True(response != null, 112Assert.True(String.Equals(testString, response.TestResult),

50Assert.True(string.Equals(actualResponse, expectedResponse), 93Assert.True(result == expectedResult, string.Format("Error: expected response from service: '{0}' Actual was: '{1}'", expectedResult, result));

49Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 50Assert.True((number == message.Count<char>()), String.Format("The local int variable was not correctly set, expected {0} but got {1}", message.Count<char>(), number)); 96Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 97Assert.True((uniqueType.stringValue == message), 142Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 143Assert.True((number == message.Count<char>()), 190Assert.True(waitEvent.WaitOne(ScenarioTestHelpers.TestTimeout), "AsyncCallback was not called."); 191Assert.True((uniqueType.stringValue == message), 229Assert.True((uniqueType.stringValue == message), 237Assert.True((uniqueType.stringValue == message), 275Assert.True((uniqueType.stringValue == message), 311Assert.True(factory.State == CommunicationState.Opened, 339Assert.True(success, "Test Scenario: BasicHttp_Async_Open_ChannelFactory_WithSingleThreadedSyncContext timed-out."); 365Assert.True(proxyAsCommunicationObject.State == CommunicationState.Opened, 392Assert.True(success, "Test Scenario: BasicHttp_Async_Open_Proxy_WithSingleThreadedSyncContext timed-out."); 420Assert.True(factory.State == CommunicationState.Closed, 443Assert.True(success, "Test Scenario: BasicHttp_Async_Close_ChannelFactory_WithSingleThreadedSyncContext timed-out."); 469Assert.True(proxyAsCommunicationObject.State == CommunicationState.Closed, 493Assert.True(success, "Test Scenario: BasicHttp_Async_Close_Proxy_WithSingleThreadedSyncContext timed-out.");

213Assert.True(success, "Test Scenario: BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed_WithSingleThreadedSyncContext timed-out."); 227Assert.True(success, "Test Scenario: BasicHttp_DefaultSettings_Echo_RoundTrips_String_Streamed_Async_WithSingleThreadedSyncContext timed-out."); 617Assert.True(success, "Test Scenario: NetTcp_NoSecurity_String_Streamed_RoundTrips_WithSingleThreadedSyncContext timed-out."); 631Assert.True(success, "Test Scenario: NetTcp_NoSecurity_Streamed_Async_RoundTrips_String_WithSingleThreadedSyncContext timed-out."); 657Assert.True(string.Equals(result, "Hello " + echoString), String.Format("Expected response from Service: {0} Actual was: {1}", "Hello " + echoString, result)); 702Assert.True(factory.State == CommunicationState.Closed, 733Assert.True(exception1 != null || actualEcho1 != null, "First operation should have thrown Exception or returned an echo"); 734Assert.True(exception2 != null || actualEcho2 != null, "Second operation should have thrown Exception or returned an echo"); 736Assert.True(actualEcho1 == null || String.Equals(expectedEcho1, actualEcho1), 739Assert.True(actualEcho2 == null || String.Equals(expectedEcho2, actualEcho2), 742Assert.True(((ICommunicationObject)serviceProxy1).State == CommunicationState.Closed, 744Assert.True(((ICommunicationObject)serviceProxy2).State == CommunicationState.Closed, 792Assert.True(factory.State == CommunicationState.Closed, 823Assert.True(exception1 != null || actualEcho1 != null, "First operation should have thrown Exception or returned an echo"); 824Assert.True(exception2 != null || actualEcho2!= null, "Second operation should have thrown Exception or returned an echo"); 826Assert.True(actualEcho1 == null || String.Equals(expectedEcho1, actualEcho1), 829Assert.True(actualEcho2 == null || String.Equals(expectedEcho2, actualEcho2), 832Assert.True(((ICommunicationObject)serviceProxy1).State == CommunicationState.Closed, 834Assert.True(((ICommunicationObject)serviceProxy2).State == CommunicationState.Closed, 883Assert.True(factory.State == CommunicationState.Closed, 914Assert.True(exception1 != null || actualEcho1 != null, "First operation should have thrown Exception or returned an echo"); 915Assert.True(exception2 != null || actualEcho2 != null, "Second operation should have thrown Exception or returned an echo"); 917Assert.True(actualEcho1 == null || String.Equals(expectedEcho1, actualEcho1), 920Assert.True(actualEcho2 == null || String.Equals(expectedEcho2, actualEcho2), 923Assert.True(((ICommunicationObject)serviceProxy1).State == CommunicationState.Closed, 925Assert.True(((ICommunicationObject)serviceProxy2).State == CommunicationState.Closed,

90Assert.True(fException.Detail.UsedDataContractSerializer, "The returning Fault Detail should have used the Data Contract Serializer."); 91Assert.True(fException.Detail.UsedXmlSerializer == false, "The returning Fault Detail should NOT have used the Xml Serializer."); 112Assert.True(fException.Detail.UsedDataContractSerializer == false, "The returning Fault Detail should NOT have used the Data Contract Serializer."); 113Assert.True(fException.Detail.UsedXmlSerializer, "The returning Fault Detail should have used the Xml Serializer.");

61Assert.True(method != null, $"No method named {s_serializationModeSetterName}"); 90Assert.True(fException.Detail.UsedDataContractSerializer, "The returning Fault Detail should have used the Data Contract Serializer."); 91Assert.True(fException.Detail.UsedXmlSerializer == false, "The returning Fault Detail should NOT have used the Xml Serializer."); 112Assert.True(fException.Detail.UsedDataContractSerializer == false, "The returning Fault Detail should NOT have used the Data Contract Serializer."); 113Assert.True(fException.Detail.UsedXmlSerializer, "The returning Fault Detail should have used the Xml Serializer.");

42Assert.True(Directory.Exists(this_TestGroupOutputDir), $"{nameof(this_TestGroupOutputDir)} is not initialized!"); 43Assert.True(Directory.Exists(this_TestGroupBaselinesDir), $"{nameof(this_TestGroupBaselinesDir)} is not initialized!"); 180Assert.True(File.Exists(wsdlFile), $"{wsdlFile} not initialized!"); 235Assert.True(result.ExitCode == 0, result.OutputText); 238Assert.True(File.Exists(binProjPath), $"{nameof(binProjPath)} not initialized!"); 239Assert.True(File.Exists(libProjPath), $"{nameof(libProjPath)} not initialized!"); 246Assert.True(ret.ExitCode == 0, ret.OutputText); 369Assert.True(File.Exists(srcParamsFilePath), $"{nameof(srcParamsFilePath)} not initialized!");

15Assert.True(dir.Exists, "Can't copy nonexistant directory.");

159Assert.True(ret.ExitCode == 0, ret.OutputText);

68Assert.True(success, $"Could not add tool package dependency: dotnet-svcutil-lib.{svcutilPkgVersion}"); 73Assert.True(ret.ExitCode == 0, $"Project package restore failed:{Environment.NewLine}{ret.OutputText}{logger}"); 78Assert.True(ret.ExitCode == 0, $"Project build failed:{Environment.NewLine}{ret.OutputText}{logger}"); 87Assert.True(File.Exists(project?.FullPath), $"{nameof(project)} is not initialized!"); 175Assert.True(File.Exists(project?.FullPath), $"{nameof(project)} is not initialized!");

155Assert.True(Directory.Exists(g_RepositoryRoot), $"{nameof(g_RepositoryRoot)} is not initialized!"); 156Assert.True(Directory.Exists(g_TestCasesDir), $"{nameof(g_TestCasesDir)} is not initialized!"); 157Assert.True(Directory.Exists(g_TestResultsDir), $"{nameof(g_TestResultsDir)} is not initialized!"); 158Assert.True(Directory.Exists(g_TestBootstrapDir), $"{nameof(g_TestBootstrapDir)} is not initialized!"); 159Assert.True(Directory.Exists(g_TestOutputDir), $"{nameof(g_TestOutputDir)} is not initialized!"); 160Assert.True(Directory.Exists(g_BaselinesDir), $"{nameof(g_BaselinesDir)} is not initialized!"); 167Assert.True(File.Exists(g_StarterProject.FullPath), $"{nameof(g_StarterProject)} is not initialized!"); 184Assert.True(Directory.GetFiles(pkgPath, "dotnet-svcutil-lib.*.nupkg").Any(), $"dotnet-svcutil-lib*.nupkg not found under {pkgPath}!"); 277Assert.True(Directory.Exists(this_TestCaseOutputDir), $"{nameof(this_TestGroupOutputDir)} is not initialized!"); 278Assert.True(Directory.Exists(this_TestCaseBaselinesDir), $"{nameof(this_TestCaseBaselinesDir)} is not initialized!"); 279Assert.True(this_TestCaseBootstrapDir != null, $"{nameof(this_TestCaseBootstrapDir)} is not initialized!"); 280Assert.True(this_TestCaseLogger != null, $"{nameof(this_TestGroupOutputDir)} is not initialized!"); 281Assert.True(this_FixupUtil != null, $"{nameof(this_FixupUtil)} is not initialized!"); 337Assert.True(isTestSucess, $"{Environment.NewLine}Test failed:{Environment.NewLine}{outputText}{g_GeneralErrMsg}"); 343Assert.True(validationSuccess, $"{Environment.NewLine}Test failed validation!{failureMessage}{g_GeneralErrMsg}"); 540Assert.True(Directory.Exists(vstestDir), $"{nameof(vstestDir)} is not initialized!"); 551Assert.True(nugetFiles.Length <= 1, "There should be one and only one nuget package for testing."); 590Assert.True(rootSolutionFolder != null && File.Exists(rootSolutionFolder), $"Unable to find dotnet-svcutil.sln file, current dir: {parentDir}");

275Assert.True(ValidateOutputs(options, out var failureMessage), failureMessage); 312Assert.True(ValidateOutputs(options, out var failureMessage), failureMessage); 339Assert.True(ValidateJson(options, jsonFileSrcPath, out errorMessage), errorMessage);

40Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 79Assert.True(compositeObject.Equals(result), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", compositeObject, result));

40Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

39Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 75Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

39Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 75Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 111Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 147Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 183Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

114Assert.True(streamLength == ms.Length, 120Assert.True(requestBytes.SequenceEqual(returnedByteArraySegment.Array), "Returned bytes are different than sent bytes");

76Assert.True(clientReceiver.ReceiveStreamInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 88Assert.True(clientReceiver.ReceiveStreamCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 94Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 98Assert.True(clientReceiver.ServerLog.Count > 0, 151Assert.True(clientReceiver.ReceiveDataInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 156Assert.True(clientReceiver.ReceiveDataCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 162Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 166Assert.True(clientReceiver.ServerLog.Count > 0, 219Assert.True(clientReceiver.ReceiveDataInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 224Assert.True(clientReceiver.ReceiveDataCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 230Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 234Assert.True(clientReceiver.ServerLog.Count > 0, 308Assert.True(clientReceiver.ReceiveStreamInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 320Assert.True(clientReceiver.ReceiveStreamCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 326Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 330Assert.True(clientReceiver.ServerLog.Count > 0, 386Assert.True(clientReceiver.ReceiveDataInvoked.WaitOne(ScenarioTestHelpers.TestTimeout), 391Assert.True(clientReceiver.ReceiveDataCompleted.WaitOne(ScenarioTestHelpers.TestTimeout), 397Assert.True(clientReceiver.LogReceived.WaitOne(ScenarioTestHelpers.TestTimeout), 401Assert.True(clientReceiver.ServerLog.Count > 0, 467Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 521Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 575Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 630Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 687Assert.True(!ScenarioTestHelpers.IsLocalHost() || !serverLogItem.Contains(ScenarioTestHelpers.RemoteEndpointMessagePropertyFailure), serverLogItem); 728Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); 768Assert.True(guid == returnedGuid, string.Format("The sent GUID does not match the returned GUID. Sent '{0}', Received: '{1}'", guid, returnedGuid)); 811Assert.True(guid == returnedGuid, 851Assert.True(responseFromService, String.Format("Response from the service was not expected. Expected: 'True' but got {0}", responseFromService));

169Assert.True(task.Wait(4000), "timeout");

118Assert.True(response.Content.Headers.TryGetValues(HeaderNames.ContentLength, out var contentLength), HeaderNames.ContentLength); 136Assert.True(response.Content.Headers.TryGetValues(HeaderNames.ContentLength, out var contentLength), HeaderNames.ContentLength);

45Assert.True(matchedEntries is not null, $"Regex {expectedRegexMatchString[i]} was not found."); 86Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 87Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

322Assert.True(processIdMatch.Success, $"'{processIdPattern}' did not match '{aspnetcorev2Log}'"); 357Assert.True(prefixMatch.Success, $"'{prefixPattern}' did not match '{log}'");

108Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response); 119Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response);

45Assert.True(matchedEntries is not null, $"Regex {expectedRegexMatchString[i]} was not found."); 86Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 87Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode);

45Assert.True(matchedEntries is not null, $"Regex {expectedRegexMatchString[i]} was not found."); 86Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 87Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode);

45Assert.True(matchedEntries is not null, $"Regex {expectedRegexMatchString[i]} was not found."); 86Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 87Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode);

231Assert.True(Directory.Exists(Path.Combine(directory.DirectoryPath, "2")), "Expected 2 shadow copy directory"); 273Assert.True(Directory.Exists(Path.Combine(directory.DirectoryPath, "11")), "Expected 11 shadow copy directory");

45Assert.True(matchedEntries is not null, $"Regex {expectedRegexMatchString[i]} was not found."); 86Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 87Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

33Assert.True(protocol > SslProtocols.None, "Protocol: " + protocol); 34Assert.True(Enum.IsDefined(typeof(SslProtocols), protocol), "Defined: " + protocol); // Mapping is required, make sure it's current 38Assert.True(cipherAlgorithm > CipherAlgorithmType.Null, "Cipher: " + cipherAlgorithm); 41Assert.True(cipherStrength > 0, "CipherStrength: " + cipherStrength); 44Assert.True(hashAlgorithm >= HashAlgorithmType.None, "HashAlgorithm: " + hashAlgorithm); 47Assert.True(hashStrength >= 0, "HashStrength: " + hashStrength); // May be 0 for some algorithms 50Assert.True(keyExchangeAlgorithm >= ExchangeAlgorithmType.None, "KeyExchangeAlgorithm: " + keyExchangeAlgorithm); 53Assert.True(keyExchangeStrength >= 0, "KeyExchangeStrength: " + keyExchangeStrength);

57Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode);

45Assert.True(matchedEntries is not null, $"Regex {expectedRegexMatchString[i]} was not found."); 86Assert.True(matchedEntries.Length > 0, $"No entries matched by '{regexString}'"); 87Assert.True(allowMultiple || matchedEntries.Length < 2, $"Multiple entries matched by '{regexString}': {FormatEntries(matchedEntries)}");

322Assert.True(processIdMatch.Success, $"'{processIdPattern}' did not match '{aspnetcorev2Log}'"); 357Assert.True(prefixMatch.Success, $"'{prefixPattern}' did not match '{log}'");

108Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response); 119Assert.True(string.Equals(400, response.Status), i.ToString("X2", CultureInfo.InvariantCulture) + ";" + response);

420Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode); 577Assert.True(statusCode == 200 || statusCode == 503, "Status code was " + statusCode);

16Assert.True(FrameworkHelper.Current != FrameworkID.None, 25Assert.True(OSHelper.Current != OSID.None, 40Assert.True(formatted.Contains("NetCore") && formatted.Contains("NetNative"), 51Assert.True(formatted.Contains("Windows_7") && formatted.Contains("Ubuntu"),

241Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 248Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 256Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 271Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 272Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 279Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 280Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 287Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 288Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 367Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 374Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 382Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 402Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 403Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 410Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 411Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable"); 418Assert.True(request.SupportsTrailers(), "SupportsTrailers"); 419Assert.True(request.CheckTrailersAvailable(), "CheckTrailersAvailable");

2308Assert.True(context.Response.SupportsTrailers(), "SupportsTrailers");

206Assert.True(context.Request.SupportsTrailers(), "SupportsTrailers"); 215Assert.True(context.Request.SupportsTrailers(), "SupportsTrailers"); 216Assert.True(context.Request.CheckTrailersAvailable(), "SupportsTrailers"); 902Assert.True(padLength >= payloadLength, $"{nameof(padLength)} must be greater than or equal to {nameof(payloadLength)} to create an invalid frame."); 1055Assert.True(padLength >= frameLength, $"{nameof(padLength)} must be greater than or equal to {nameof(frameLength)} to create an invalid frame."); 1360Assert.True(_receivedHeaders.TryGetValue(HeaderNames.Host, out var host), header.Key); 1373Assert.True(_receivedHeaders.TryGetValue(header.Key, out var value), header.Key);

840Assert.True(requestStream.Disposed, "Request is complete and should be disposed.");

148Assert.True(tlsFeature.Protocol > SslProtocols.None, "Protocol"); 149Assert.True(tlsFeature.NegotiatedCipherSuite >= TlsCipherSuite.TLS_NULL_WITH_NULL_NULL, "NegotiatedCipherSuite"); 151Assert.True(tlsFeature.CipherAlgorithm > CipherAlgorithmType.Null, "Cipher"); 152Assert.True(tlsFeature.CipherStrength > 0, "CipherStrength"); 153Assert.True(tlsFeature.HashAlgorithm >= HashAlgorithmType.None, "HashAlgorithm"); // May be None on Linux. 154Assert.True(tlsFeature.HashStrength >= 0, "HashStrength"); // May be 0 for some algorithms 155Assert.True(tlsFeature.KeyExchangeAlgorithm >= ExchangeAlgorithmType.None, "KeyExchangeAlgorithm"); // Maybe None on Windows 7 156Assert.True(tlsFeature.KeyExchangeStrength >= 0, "KeyExchangeStrength"); // May be 0 on mac 187Assert.True(tlsFeature.Protocol > SslProtocols.None, "Protocol"); 189Assert.True(tlsFeature.CipherAlgorithm > CipherAlgorithmType.Null, "Cipher"); 190Assert.True(tlsFeature.CipherStrength > 0, "CipherStrength"); 191Assert.True(tlsFeature.HashAlgorithm >= HashAlgorithmType.None, "HashAlgorithm"); // May be None on Linux. 192Assert.True(tlsFeature.HashStrength >= 0, "HashStrength"); // May be 0 for some algorithms 193Assert.True(tlsFeature.KeyExchangeAlgorithm >= ExchangeAlgorithmType.None, "KeyExchangeAlgorithm"); // Maybe None on Windows 7 194Assert.True(tlsFeature.KeyExchangeStrength >= 0, "KeyExchangeStrength"); // May be 0 on mac

192Assert.True(loggerProvider.ErrorLogger.ErrorMessages.Count == 0, 221Assert.True(loggerProvider.ErrorLogger.ErrorMessages.Count == 0, 743Assert.True(onAuthenticateCalled, "onAuthenticateCalled"); 782Assert.True(onAuthenticateCalled, "onAuthenticateCalled");

37Assert.True(hasValue || value == null, $"ConnectionEndReason '{reason}' doesn't have a mapping.");

2289Assert.True(foundMessage, "Expected log not found");

809Assert.True(

169Assert.True(false, @$"

206Assert.True(errorOut.StartsWith(file + "(1,3):", StringComparison.Ordinal), "Error output should start with file name, line and column"); 207Assert.True(errorOut.Contains("CS1002"), "Error output should include error CS1002"); 262Assert.True(errorOut.StartsWith(typeof(Process).Assembly.Location + "(1,3):", StringComparison.Ordinal), "Error output should start with file name, line and column"); 263Assert.True(errorOut.Contains("CS1056"), "Error output should include error CS1056"); 264Assert.True(errorOut.Contains("CS1002"), "Error output should include error CS1002"); 275Assert.True(errorOut.StartsWith(file.Path + "(1,7):", StringComparison.Ordinal), "Error output should start with file name, line and column"); 276Assert.True(errorOut.Contains("CS7010"), "Error output should include error CS7010");

155Assert.True(ex is WebSocketException || ex is TaskCanceledException, ex.GetType().FullName);

1443Assert.True(!string.IsNullOrEmpty(connectionId1), "ConnectionId should have a value.");

242Assert.True(totalRead <= Repetitions * Content.Length, "Too Long"); 254Assert.True(totalRead == Repetitions * Content.Length, "Too Short");

142Assert.True(expected.Id == actual.Id, 144Assert.True(expectedSpan.Equals(actual.Location.SourceSpan),

142Assert.True(expected.Id == actual.Id, 144Assert.True(expectedSpan.Equals(actual.Location.SourceSpan),

156Assert.True((actual == null) == expected.IsDefault, message); 168Assert.True((expected == null) == actual.IsDefault, message); 253Assert.True(result, message); 260Assert.True(expectedSet.SetEquals(actual), string.Format("Expected: {0}\nActual: {1}", ToString(expected), ToString(actual))); 268Assert.True(none, string.Format( 278Assert.True(any, string.Format("No expected item was found.\nExisting items: {0}", ToString(actual))); 286Assert.True(all, string.Format( 319Assert.True(AssertEqualityComparer<T>.IsNull(@object), message);

126Assert.True(conversionFailureOk, "Failed to convert text to token."); 209Assert.True(routeParameter.IsOptional == parsedRoutePattern.IsOptional, "IsOptional"); 210Assert.True(routeParameter.IsCatchAll == parsedRoutePattern.IsCatchAll, "IsCatchAll"); 211Assert.True(routeParameter.EncodeSlashes == parsedRoutePattern.EncodeSlashes, "EncodeSlashes"); 212Assert.True(Equals(routeParameter.DefaultValue, parsedRoutePattern.Default), "DefaultValue"); 213Assert.True(routeParameter.Policies.Length == parsedRoutePattern.ParameterPolicies.Count, "ParameterPolicies"); 218Assert.True(expected == actual, $"Policy {i}. Expected: '{expected}', Actual: '{actual}'."); 233Assert.True(

138Assert.True(Version.TryParse(assemblyVersion, out _), $"{assemblyVersion} should deserialize to System.Version"); 141Assert.True(Version.TryParse(fileVersion, out _), $"{fileVersion} should deserialize to System.Version"); 151Assert.True(Version.TryParse(fileVersion, out _), $"{fileVersion} should deserialize to System.Version"); 201Assert.True(expectedVersion.Major == assemblyDefinition.Version.Major || 308Assert.True(Version.TryParse(assemblyVersion, out _), $"{assemblyPath} has assembly version {assemblyVersion}. Assembly version must be convertable to System.Version"); 311Assert.True(Version.TryParse(fileVersion, out _), $"{assemblyPath} has file version {fileVersion}. File version must be convertable to System.Version");

98Assert.True(expectedVersion.Major == assemblyDefinition.Version.Major || 127Assert.True(result, $"In {Path.GetFileName(path)}, {reference.GetAssemblyName()} has unexpected version {reference.Version}."); 152Assert.True( 161Assert.True( 214Assert.True(hasRefAssemblyAttribute, $"{path} should have {nameof(ReferenceAssemblyAttribute)}"); 283Assert.True(Version.TryParse(parts[2], out _), "Assembly version must be convertable to System.Version"); 285Assert.True(Version.TryParse(parts[3], out _), "File version must be convertable to System.Version"); 351Assert.True(Version.TryParse(assemblyVersion, out _), $"{assemblyPath} has assembly version {assemblyVersion}. Assembly version must be convertable to System.Version"); 352Assert.True(Version.TryParse(fileVersion, out _), $"{assemblyPath} has file version {fileVersion}. File version must be convertable to System.Version");

551Assert.True(Stage1Complete, nameof(Stage1Complete)); 568Assert.True(Stage1Complete, nameof(Stage1Complete));

456Assert.True(context.User.Identity.IsAuthenticated, "Authenticated"); 575Assert.True(Stage1Complete, nameof(Stage1Complete)); 592Assert.True(Stage1Complete, nameof(Stage1Complete));

464Assert.True(ex.Data.Contains("error"), "error"); 465Assert.True(ex.Data.Contains("error_description"), "error_description"); 466Assert.True(ex.Data.Contains("error_uri"), "error_uri"); 501Assert.True(ex.Data.Contains("error"), "error"); 502Assert.True(ex.Data.Contains("error_description"), "error_description"); 503Assert.True(ex.Data.Contains("error_uri"), "error_uri");

81Assert.True(ex.Data.Contains("error"), "error"); 82Assert.True(ex.Data.Contains("error_description"), "error_description"); 83Assert.True(ex.Data.Contains("error_uri"), "error_uri");

80Assert.True(queryItems["wctx"].ToString().Equals(CustomStateDataFormat.ValidStateData), "wctx does not equal ValidStateData"); 96Assert.True(queryItems["wctx"].ToString().Equals(CustomStateDataFormat.ValidStateData), "wctx does not equal ValidStateData"); 112Assert.True(queryItems["wctx"].ToString().Equals(CustomStateDataFormat.ValidStateData), "wctx does not equal ValidStateData"); 307Assert.True(context.ProtocolMessage.Wctx.Equals("customValue"), "wctx is not my custom value"); 329Assert.True((bool)context.HttpContext.Items["MessageReceived"], "MessageReceived notification not invoked"); 330Assert.True((bool)context.HttpContext.Items["SecurityTokenReceived"], "SecurityTokenReceived notification not invoked");

78Assert.True(queryItems["wctx"].ToString().Equals(CustomStateDataFormat.ValidStateData), "wctx does not equal ValidStateData"); 94Assert.True(queryItems["wctx"].ToString().Equals(CustomStateDataFormat.ValidStateData), "wctx does not equal ValidStateData"); 110Assert.True(queryItems["wctx"].ToString().Equals(CustomStateDataFormat.ValidStateData), "wctx does not equal ValidStateData"); 303Assert.True(context.ProtocolMessage.Wctx.Equals("customValue"), "wctx is not my custom value"); 325Assert.True((bool)context.HttpContext.Items["MessageReceived"], "MessageReceived notification not invoked"); 326Assert.True((bool)context.HttpContext.Items["SecurityTokenReceived"], "SecurityTokenReceived notification not invoked");

194Assert.True(actualSpan.Path == expected.Path || (actualSpan.Path != null && actualSpan.Path.Contains("Test0.") && expected.Path.Contains("Test.")), 258Assert.True(location.IsInSource,

114Assert.True(

194Assert.True(actualSpan.Path == expected.Path || (actualSpan.Path != null && actualSpan.Path.Contains("Test0.") && expected.Path.Contains("Test.")), 258Assert.True(location.IsInSource,

243Assert.True(initializeException is null, $"An exception was thrown in {nameof(TestCircuitHost.InitializeAsync)}(): {initializeException}");

50Assert.True(isValid, "Failed to validate id");

280Assert.True(string.Equals(actual, testData.Binary, StringComparison.Ordinal), $"Binary encoding changed from{Environment.NewLine} [{testData.Binary}]{Environment.NewLine} to{Environment.NewLine} [{actual}]{Environment.NewLine}Please verify the MsgPack output and update the baseline");

887Assert.True(notFoundTriggered, "The OnNotFound event was not triggered as expected.");

5714Assert.True(result.IsCompleted, "Task must complete synchronously."); 5724Assert.True(result.IsCompleted, "Task must complete synchronously."); 5739Assert.True(result.IsCompleted, "Task must complete synchronously."); 5750Assert.True(result.IsCompleted, "Task must complete synchronously."); 5771Assert.True(result.IsCompleted, "Task must complete synchronously.");

35Assert.True(e.Wait(Timeout), "timeout"); 81Assert.True(e2.Wait(Timeout), "timeout"); 85Assert.True(e1.Wait(Timeout), "timeout"); 100Assert.True(e3.Wait(Timeout), "timeout"); 125Assert.True(e2.Wait(Timeout), "timeout"); 129Assert.True(e1.Wait(Timeout), "timeout"); 154Assert.True(e3.Wait(Timeout), "timeout"); 180Assert.True(e2.Wait(Timeout), "timeout"); 184Assert.True(e1.Wait(Timeout), "timeout"); 220Assert.True(e2.Wait(Timeout), "timeout"); 223Assert.True(e1.Wait(Timeout), "timeout"); 230Assert.True(e4.Wait(Timeout), "timeout"); 238Assert.True(e3.Wait(Timeout), "timeout"); 259Assert.True(e5.Wait(Timeout), "timeout"); 260Assert.True(e6.Wait(Timeout), "timeout"); 288Assert.True(e1.Wait(Timeout), "timeout"); 341Assert.True(e2.Wait(Timeout), "timeout"); 345Assert.True(e1.Wait(Timeout), "timeout"); 360Assert.True(e3.Wait(Timeout), "timeout"); 397Assert.True(e1.Wait(Timeout), "timeout"); 438Assert.True(e2.Wait(Timeout), "timeout"); 442Assert.True(e1.Wait(Timeout), "timeout"); 456Assert.True(e3.Wait(Timeout), "timeout"); 527Assert.True(e2.Wait(Timeout), "timeout"); 531Assert.True(e1.Wait(Timeout), "timeout"); 545Assert.True(e3.Wait(Timeout), "timeout"); 619Assert.True(e2.Wait(Timeout), "timeout"); 623Assert.True(e1.Wait(Timeout), "timeout"); 638Assert.True(e3.Wait(Timeout), "timeout"); 709Assert.True(e2.Wait(Timeout), "timeout"); 713Assert.True(e1.Wait(Timeout), "timeout"); 727Assert.True(e3.Wait(Timeout), "timeout");

620Assert.True(exceptionSeen, "We expect exception middleware to have executed");

136Assert.True(certificate.HasPrivateKey, "Cert should have a private key");

698Assert.True(mreForegroundThreadIsCallingGetCurrentKeyRing.Wait(testTimeout), "Test timed out."); 709Assert.True(mreBackgroundThreadHasCalledGetCurrentKeyRing.Wait(testTimeout), "Test timed out.");

575Assert.True(loggerFactory.ToString().Contains("1A2B3C4D"), "The secret '1A2B3C4D' should have been logged.");

118Assert.True(forwarded, "Should have forwarded this type to new version or namespace");

3787Assert.True(body.CanSeek, "Can't get content of a non-seekable stream");

63Assert.True(

379Assert.True(CompareLines(expectedLines, generatedCode, out var errorMessage), errorMessage);

379Assert.True(CompareLines(expectedLines, generatedCode, out var errorMessage), errorMessage);

47Assert.True(httpContext.Response.Headers.ContainsKey("Location"), "Location header not found");

102Assert.True(httpContext.Items.ContainsKey("__RequestUnhandled"), "Request unhandled flag should be set.");

73Assert.True(Environment.CurrentManagedThreadId == _threadId,

67Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist."); 68Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist."); 160Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist"); 161Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist"); 215Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist."); 216Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist."); 221Assert.True(!File.Exists(globalLogPath), $"Expected no global log file {globalLogPath} to exist."); 222Assert.True(!File.Exists(testLog), $"Expected no test log file {testLog} to exist."); 266Assert.True(File.Exists(globalLogPath), $"Expected global log file {globalLogPath} to exist."); 267Assert.True(File.Exists(testLog), $"Expected test log file {testLog} to exist.");

37Assert.True(_conditionalTheoryRuns <= 2, $"Theory should run 2 times, but ran {_conditionalTheoryRuns} times."); 62Assert.True(_conditionalTheoryRuns <= 3, $"Theory should run 2 times, but ran {_conditionalMemberDataRuns} times.");

98Assert.True(listener.IsListening, "IsListening");

19Assert.True( 30Assert.True( 70Assert.True( 86Assert.True(Environment.OSVersion.Version.ToString().StartsWith("6.1", StringComparison.Ordinal),

29Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 49Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 68Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 96Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 123Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 132Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 151Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 171Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 250Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 270Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 289Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 314Assert.True(string.IsNullOrEmpty(message), "Expected no error message");

135Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 153Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 173Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 241Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 296Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 407Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 443Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 462Assert.True(string.IsNullOrEmpty(message), "Expected no error message");

55Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 89Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 133Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 187Assert.True(string.IsNullOrEmpty(message), "Expected no error message");

29Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 69Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 110Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 150Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 239Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message");

32Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 52Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 71Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 99Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 126Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 135Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 154Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 174Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 252Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 272Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 291Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 316Assert.True(string.IsNullOrEmpty(message), "Expected no error message");

273Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message");

135Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 153Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 173Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 241Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 296Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 407Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 443Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 460Assert.True(string.IsNullOrEmpty(message), "Expected no error message");

55Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 88Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 118Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 150Assert.True(string.IsNullOrEmpty(message), "Expected no error message"); 204Assert.True(string.IsNullOrEmpty(message), "Expected no error message");

35Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 75Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 116Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 156Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message"); 240Assert.True(string.IsNullOrEmpty(errorMessage), "Expected no error message");

53Assert.True(result, "Request should have been accepted.");

346Assert.True(

124Assert.True(httpContext.Request.Body.CanRead, "Verify that the request stream hasn't been disposed"); 325Assert.True(result.HasError, "Model should have had an error!"); 351Assert.True(result.HasError, "Model should have had an error!"); 378Assert.True(result.HasError, "Model should have produced an error!"); 485Assert.True(result.HasError, "Model should have had an error!"); 509Assert.True(result.HasError, "Model should have had an error!"); 533Assert.True(result.HasError, "Model should have had an error!");

106Assert.True(body.CanWrite, "Response body should not be disposed.");

111Assert.True(httpContext.Response.Headers.ContainsKey("Location"), "Location header not found");

38Assert.True(result, "Request should have been accepted."); 69Assert.True(result, "Request should have been accepted.");

362Assert.True(dataAnnotationLocalizerProviderWasUsed, "DataAnnotationLocalizerProvider wasn't used by DisplayMetadata");

833Assert.True(modelBindingResult.IsModelSet, "model is set"); 878Assert.True(modelBindingResult.IsModelSet, "model is set");

124Assert.True(httpContext.Request.Body.CanRead, "Verify that the request stream hasn't been disposed"); 325Assert.True(result.HasError, "Model should have had an error!"); 351Assert.True(result.HasError, "Model should have had an error!"); 378Assert.True(result.HasError, "Model should have produced an error!"); 485Assert.True(result.HasError, "Model should have had an error!"); 509Assert.True(result.HasError, "Model should have had an error!"); 533Assert.True(result.HasError, "Model should have had an error!");

106Assert.True(body.CanWrite, "Response body should not be disposed.");

534Assert.True(equals, "CacheTagKeys must be equal");

622Assert.True(

169Assert.True(expected.Headers.Span.SequenceEqual(actual.Headers.Span), "Headers");

122Assert.True(env.TryGetValue("owin.CallCancelled", out value), "owin.CallCancelled"); 123Assert.True(env.TryGetValue("owin.Version", out value), "owin.Version");

173Assert.True(Environment.OSVersion.Version < new Version(10, 0, 22000), "This should be supported on Win 11."); 354Assert.True(checkedDenyGuest && checkedAllowUser, "DACL does not contain the expected ACEs");

165Assert.True(protocol > SslProtocols.None, "Protocol: " + protocol); 166Assert.True(Enum.IsDefined(typeof(SslProtocols), protocol), "Defined: " + protocol); // Mapping is required, make sure it's current 170Assert.True(cipherAlgorithm > CipherAlgorithmType.Null, "Cipher: " + cipherAlgorithm); 174Assert.True(cipherStrength > 0, "CipherStrength: " + cipherStrength); 178Assert.True(hashAlgorithm >= HashAlgorithmType.None, "HashAlgorithm: " + hashAlgorithm); 182Assert.True(hashStrength >= 0, "HashStrength: " + hashStrength); // May be 0 for some algorithms 186Assert.True(keyExchangeAlgorithm >= ExchangeAlgorithmType.None, "KeyExchangeAlgorithm: " + keyExchangeAlgorithm); 190Assert.True(keyExchangeStrength >= 0, "KeyExchangeStrength: " + keyExchangeStrength);

47Assert.True(response.Headers.TransferEncodingChunked.Value, "Chunked"); 96Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked");

270Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked");

100Assert.True(response.Headers.TransferEncodingChunked.Value, "Chunked"); 183Assert.True(callbackCalled, "Callback not called");

482Assert.True(string.Equals("400", responseStatusCode), i.ToString("X2", CultureInfo.InvariantCulture)); 500Assert.True(string.Equals("400", responseStatusCode), i.ToString("X2", CultureInfo.InvariantCulture));

37Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked"); 124Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked"); 156Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked"); 181Assert.True(response.Headers.TransferEncodingChunked.Value, "Chunked"); 203Assert.True(response.Headers.TransferEncodingChunked.Value, "Chunked"); 226Assert.True(response.Content.Headers.TryGetValues("content-length", out contentLength), "Content-Length"); 306Assert.True(response.Content.Headers.TryGetValues("content-length", out contentLength), "Content-Length"); 339Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked"); 367Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked"); 394Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked");

33Assert.True(FileLength > 0, "FileLength is 0"); 75Assert.True(response.Headers.TransferEncodingChunked.Value, "Chunked"); 94Assert.True(response.Headers.TransferEncodingChunked.Value, "Chunked"); 228Assert.True(response.Content.Headers.TryGetValues("content-length", out contentLength), "Content-Length"); 249Assert.True(response.Content.Headers.TryGetValues("content-length", out contentLength), "Content-Length"); 270Assert.True(response.Content.Headers.TryGetValues("content-length", out contentLength), "Content-Length"); 300Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked");

164Assert.True(response.Content.Headers.TryGetValues(HeaderNames.ContentLength, out var contentLength), HeaderNames.ContentLength); 189Assert.True(response.Content.Headers.TryGetValues(HeaderNames.ContentLength, out var contentLength), HeaderNames.ContentLength); 215Assert.True(response.Content.Headers.TryGetValues(HeaderNames.ContentLength, out var contentLength), HeaderNames.ContentLength);

270Assert.True(Task.WaitAll(requestTasks.ToArray(), TimeSpan.FromSeconds(60)), "Timed out"); 285Assert.True(ct.CanBeCanceled, "CanBeCanceled"); 291Assert.True(ct.IsCancellationRequested, "IsCancellationRequested"); 318Assert.True(ct.CanBeCanceled, "CanBeCanceled"); 324Assert.True(ct.IsCancellationRequested, "IsCancellationRequested");

283Assert.True(ipV4Attempt, "Should have attempted to bind to IPAddress.Any"); 284Assert.True(ipV6Attempt, "Should have attempted to bind to IPAddress.IPv6Any");

486Assert.True(expectedPayload[i] == payload[i], $"{expectedPayload[i]} != {payload[i]} at {i} (len {length})");

73Assert.True(length <= 2, "Indexed header should be encoded into 1 or 2 bytes");

857Assert.True(expectedHeaderNames.Count() == expectedHeaderValues.Count(), $"{nameof(expectedHeaderNames)} and {nameof(expectedHeaderValues)} sizes must match");

809Assert.True(

161Assert.True(reader.ReadAsyncCounter is >= 2 && reader.ReadAsyncCounter is <= 4,

37Assert.True(QuicListener.IsSupported, "QuicListener.IsSupported should be true."); 38Assert.True(new MsQuicSupportedAttribute().IsMet, "MsQuicSupported.IsMet should be true.");

19Assert.True(File.Exists(muxerPath), "The file did not exist"); 20Assert.True(Path.IsPathRooted(muxerPath), "The path should be rooted");

187Assert.True(handshakeConnectionErrorLogged, "The connnection error during the handshake wasn't logged."); 526Assert.True(handshakeTimeoutLogged, "The handshake timeout wasn't logged."); 603Assert.True(handshakeCancellationLogged, "The handshake cancellation wasn't logged.");

280Assert.True(string.Equals(actual, testData.Binary, StringComparison.Ordinal), $"Binary encoding changed from{Environment.NewLine} [{testData.Binary}]{Environment.NewLine} to{Environment.NewLine} [{actual}]{Environment.NewLine}Please verify the MsgPack output and update the baseline");

256Assert.True(context.RequestAborted.WaitHandle.WaitOne(interval), "not aborted");

54Assert.True(File.Exists(badLink), "Should have created a symlink");

71Assert.True(app.Properties.ContainsKey("ForwardedHeadersAdded"), "Forwarded Headers");

123Assert.True(failures.Length == 0, "Autobahn results did not meet expectations:" + Environment.NewLine + failures.ToString());

30Assert.True(Wstest.Default != null, $"The 'wstest' executable (Autobahn WebSockets Test Suite) could not be found at '{Wstest.DefaultLocation}'. Run the Build Agent setup scripts to install it or see https://github.com/crossbario/autobahn-testsuite for instructions on manual installation.");

158Assert.True(clientBuf[i] == receiveBuf[i], $"offset {i} not equal: {clientBuf[i]} == {receiveBuf[i]}");

561Assert.True(socketWasAcceptedDidNotTimeout, "Socket was not accepted within the allotted time."); 566Assert.True(firstReceiveOccuredDidNotTimeout, "First receive did not occur within the allotted time."); 569Assert.True(secondReceiveInitiatedDidNotTimeout, "Second receive was not initiated within the allotted time."); 574Assert.True(socketWasAbortedDidNotTimeout, "Abort did not occur within the allotted time."); 628Assert.True(socketWasAcceptedDidNotTimeout, "Socket was not accepted within the allotted time."); 633Assert.True(firstReceiveOccuredDidNotTimeout, "First receive did not occur within the allotted time."); 638Assert.True(operationWasCancelledDidNotTimeout, "Cancel did not occur within the allotted time."); 843Assert.True(ex is ConnectionAbortedException or WebSocketException, ex.GetType().FullName);

422Assert.True(File.Exists(stream.TempFileName), "tempFile should be created"); 451Assert.True(File.Exists(stream.TempFileName), "tempFile should be created");

696Assert.True(result, message);

1553Assert.True(helpMessageLines[i].Length <= 80, $"Line {i + 1} of '{item.Key}' should be no longer than 80 characters.");

192Assert.True(TranslationHelpers.CompareExceptions(value, deserializedValue, out string diffReason), diffReason); 214Assert.True(TranslationHelpers.CompareExceptions(value, deserializedValue, out string diffReason), diffReason); 243Assert.True(TranslationHelpers.CompareExceptions(value, deserializedValue, out string diffReason), diffReason); 282Assert.True(TranslationHelpers.CompareExceptions(remote, deserializedValue, out string diffReason, true), $"Exception type {exceptionType.FullName} not properly de/serialized: {diffReason}"); 303Assert.True(TranslationHelpers.CompareExceptions(value, deserializedValue, out string diffReason, true), diffReason);

379Assert.True(numberProcsOriginally < numberProcsAfterBuild, $"Expected '{numberProcsOriginally}' < '{numberProcsAfterBuild}'"); 453Assert.True(int.TryParse(item[2].ItemSpec, out int processId), $"Process ID passed from the 'test' target is not a valid integer (actual is '{item[2].ItemSpec}')");

333Assert.True(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception, out string diffReason), diffReason); 339Assert.True(TranslationHelpers.CompareExceptions(result["alpha"].Exception, deserializedResult["alpha"].Exception, out diffReason), diffReason); 342Assert.True(TranslationHelpers.CompareExceptions(result["omega"].Exception, deserializedResult["omega"].Exception, out diffReason), diffReason);

105Assert.True(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception, out string diffReason), diffReason); 125Assert.True(TranslationHelpers.CompareExceptions(result.Exception, deserializedResult.Exception, out string diffReason), diffReason);

483Assert.True(NativeMethodsShared.MakeSymbolicLink(symlinkPath, testFile.Path, ref errorMessage), errorMessage); 484Assert.True(NativeMethodsShared.MakeSymbolicLink(symlinkLvl2Path, symlinkPath, ref errorMessage), errorMessage);

1107Assert.True(buildResult, String.Join(Environment.NewLine, logger.Errors.Select(beea => beea.Message)));

50Assert.True(taskRegistry.TaskRegistrations.ContainsKey(new TaskRegistry.RegisteredTaskIdentity(expectedRegisteredTask, null)), 56Assert.True(taskoverrideRegistry.TaskRegistrations.ContainsKey(new TaskRegistry.RegisteredTaskIdentity(expectedRegisteredTask, null)), 175Assert.True(taskRegistry.TaskRegistrations.ContainsKey(new TaskRegistry.RegisteredTaskIdentity(expectedRegisteredTask, null)),

4335Assert.True(

447Assert.True(tree.Evaluate(state), "expected true from '" + expression + "'"); 510Assert.True(caughtException,

148Assert.True(s_dotnetInstallDir is object, $"SDK not found. Use {nameof(ConditionalFactAttribute)}(typeof({nameof(DotNetSdkAvailable)})) to skip the test if the SDK is not found."); 214Assert.True(result.ExitCode == 0, $"MSBuild failed with exit code {result.ExitCode}: {result.Output}");

2829Assert.True((File.GetAttributes(destFile) & FileAttributes.ReparsePoint) != 0, "File was copied but is not a symlink");

80Assert.True(result, "Output:" + Environment.NewLine + logger.FullLog);

1102Assert.True(result, engine.Log);

273Assert.True(engine.Log.Contains("MSB3742"), "Engine Log: " + engine.Log);

361Assert.True(p.Execute(), engine.Log);

968Assert.True(t.Execute(), "CompiledDllWithTwoTypes execution should've passed" + engine.Log); 972Assert.True(File.Exists(tsk.ItemSpec), tsk.ItemSpec + " should exist on output dir");

515Assert.True(

418Assert.True( 422Assert.True( 579Assert.True(FileSystems.Default.FileExists(Path.Combine(TempProjectDir, fileRelativePath)), message); 1655Assert.True(FileSystems.Default.DirectoryExists(rootDirectory), $"Directory {rootDirectory} does not exist");

422Assert.True(currentValue == _originalValue, $"Expected {_name} to be '{_originalValue}', but it was '{currentValue}'"); 709Assert.True(FileSystems.Default.FileExists(Path), $"A file expected as an output does not exist: {Path}");

89Assert.True(CodeFixTestBehaviors.HasFlag(Testing.CodeFixTestBehaviors.FixOne), $"'{nameof(DiagnosticSelector)}' can only be used with '{nameof(Testing.CodeFixTestBehaviors)}.{nameof(Testing.CodeFixTestBehaviors.FixOne)}'");

78Assert.True(CodeFixTestBehaviors.HasFlag(Testing.CodeFixTestBehaviors.FixOne), $"'{nameof(DiagnosticSelector)}' can only be used with '{nameof(Testing.CodeFixTestBehaviors)}.{nameof(Testing.CodeFixTestBehaviors.FixOne)}'");

1894Assert.True(foundIndex > 0, $"Missing version '{version}'"); 4805Assert.True(match.Success, $"Expected pattern:{Environment.NewLine}{pattern}{Environment.NewLine}Actual:{Environment.NewLine}{output}"); 9228Assert.True(cscOutput == string.Empty, "Failed at error code: " + errorCode); 10597Assert.True(

97Assert.True(false, "Can't find proper marks that contains inlined method."); 131Assert.True(false, "Can't find proper marks that contains inlined method.");

53Assert.True(false, "Pull Members Up is provided via quick action");

88Assert.True(expectedFolderPaths.Count() == actualFolderPaths.Count, "Number of available \"Move file\" actions are not equal."); 166Assert.True(changedDocumentIds.Contains(originalDocumentId), "original document was not changed.");

1542Assert.True(completionList.SuggestionModeItem != null, "Expecting a suggestion mode, but none was present");

63Assert.True(false, subjectBuffer.CurrentSnapshot.GetText());

618Assert.True(expectedSpan == span, message);

133Assert.True(false, "Should not reach here.");

112Assert.True(ret, message);

204Assert.True(bodyProject.Id == bodyLocalProjectId, $"Expected {bodyProject.Id} == {bodyLocalProjectId}. {i}");

288Assert.True(snapshot.GetProject(id1).ProjectReferences.Contains(reference), "ProjectReferences did not contain project2"); 719Assert.True(syntaxTree.GetRoot().Width() > 0, "syntaxTree.GetRoot().Width should be > 0"); 818args => Assert.True(args.Document.Id == document.Id, 822args => Assert.True(args.Document.Id == document.Id, 835Assert.True(openWaiter.WaitForEventToFire(longEventTimeout), 839Assert.True(closeWaiter.WaitForEventToFire(longEventTimeout), 884args => Assert.True(args.Document.Id == document.Id, 888args => Assert.True(args.Document.Id == document.Id, 904Assert.True(openWaiter.WaitForEventToFire(longEventTimeout), 908Assert.True(closeWaiter.WaitForEventToFire(longEventTimeout), 948args => Assert.True(args.Document.Id == document.Id, 952args => Assert.True(args.Document.Id == document.Id, 965Assert.True(openWaiter.WaitForEventToFire(longEventTimeout), 969Assert.True(closeWaiter.WaitForEventToFire(longEventTimeout), 1009args => Assert.True(args.Document.Id == document.Id, 1013args => Assert.True(args.Document.Id == document.Id, 1026Assert.True(openWaiter.WaitForEventToFire(longEventTimeout), 1030Assert.True(closeWaiter.WaitForEventToFire(longEventTimeout),

139Assert.True(conversionFailureOk, "Failed to convert text to token.");

98Assert.True(conversionFailureOk, "Failed to convert text to token.");

89Assert.True(keywords == null || !keywords.Any(), "Keywords must be null or empty.");

1007Assert.True(type.IsPrimitive || type == typeof(decimal), string.Format("Type {0} is neither primitive nor decimal", type));

2496Assert.True(m.Success, $"Expected regex to match in {il}"); 2497Assert.True(long.TryParse(m.Groups[1].Value, NumberStyles.HexNumber, null, out long rva), $"Expected {m.Value} to parse as hex long."); 2498Assert.True(rva % expectedAlignment == 0, $"Expected RVA {rva:X8} to be {expectedAlignment}-byte aligned.");

221Assert.True(mdOnlyImage.Length > 0, "no metadata emitted"); 244Assert.True(output.ToArray().Length > 0, "no metadata emitted"); 279Assert.True(mdOnlyImage.Length > 0, "no metadata emitted"); 325Assert.True(mdOnlyImage.Length > 0, "no metadata emitted"); 378Assert.True(mdOnlyImage.Length > 0, "no metadata emitted"); 432Assert.True(mdOnlyImage.Length > 0, "no metadata emitted"); 485Assert.True(mdOnlyImage.Length > 0, "no metadata emitted"); 534Assert.True(mdOnlyImage.Length > 0, "no metadata emitted"); 2715Assert.True(dllImage.Length > 0, "no metadata emitted"); 2737Assert.True(symbolsSynthesizedCount > 0, "Expected more than 0 synthesized method symbols."); 2769Assert.True(output.Length > 0, "no metadata emitted"); 4640Assert.True(result.Success, "Compilation failed"); 4643Assert.True(File.Exists(dllPath), "DLL does not exist"); 4644Assert.True(File.Exists(pdbPath), "PDB does not exist"); 5151Assert.True(firstMatch >= 0, "Couldn't find the expected byte pattern in the output."); 5153Assert.True(secondMatch < 0, "Expected to find just one occurrence of the pattern in the output.");

1056Assert.True(text.StartsWith(expectedSpanResult.TextStart), $"Text doesn't start with {expectedSpanResult.TextStart}. Text is: {text}");

3696Assert.True(expected == instrumented, $"Method '{qualifiedMethodName}' should {(expected ? "be" : "not be")} instrumented. Actual IL:{Environment.NewLine}{il}");

848Assert.True(lib != IntPtr.Zero, String.Format("LoadLibrary failed with HResult: {0:X}", +Marshal.GetLastWin32Error()));

1393Assert.True( 1820Assert.True(expectedStr.Equals(actualStr), AssertEx.GetAssertMessage(expectedStr, actualStr));

55Assert.True(count > 0, "Expected at least one parameter"); 92Assert.True(count > 0, "Expected at least one parameter");

870Assert.True(value is short, "Expected value to be Int16"); 1367Assert.True(sourceMethod.IsPartial, "Not a partial method?"); 1371Assert.True(param.HasOptionalAttribute, "No OptionalAttribute?"); 1375Assert.True(param.HasOptionalAttribute, "No OptionalAttribute?"); 5638Assert.True(typeA.IsWindowsRuntimeImport, "Metadata flag not set for IsWindowsRuntimeImport"); 5645Assert.True(typeA.IsWindowsRuntimeImport, "Metadata flag not set for IsWindowsRuntimeImport"); 5702Assert.True(method.RequiresSecurityObject, "Metadata flag RequiresSecurityObject is not set"); 5711Assert.True(method.RequiresSecurityObject, "Metadata flag RequiresSecurityObject is not set");

404Assert.True(((string)err.Arguments[1]).EndsWith("0x80090016)", StringComparison.Ordinal), (string)err.Arguments[1]); 1616Assert.True(((string)err.Arguments[1]).EndsWith("0x80090016)", StringComparison.Ordinal), (string)err.Arguments[1]);

733Assert.True(false, message); 740Assert.True(false, message);

47Assert.True(expected.All(new HashSet<string>().Add), $"Duplicates were found in '{nameof(expected)}'"); 48Assert.True(actual.All(new HashSet<string>().Add), $"Duplicates were found in '{nameof(actual)}'");

1219Assert.True(actions.Length == 0, "An action was offered when none was expected");

61Assert.True(expected == actual,

24Assert.True(method is IMethodSymbol, "Only methods should have a syntax map.");

27Assert.True(SyntaxFactory.AreEquivalent(oldNode, newNode), $"Node '{oldNode}' not equivalent to '{newNode}'.");

586Assert.True(unmatchedTestNames.Count == 0, $"Unable to match the following test names: {string.Join(", ", unmatchedTestNames)}");

130Assert.True(result is System.Data.DataSet, "Expected DataSet");

302Assert.True(runner.RunInteractive() == 0, userMessage: runner.Console.Error.ToString()); 319Assert.True(runner.RunInteractive() == 0, userMessage: runner.Console.Error.ToString()); 346Assert.True(runner.RunInteractive() == 0, userMessage: runner.Console.Error.ToString()); 780Assert.True(foundIndex > 0, $"Missing version '{version}'");

245Assert.True(e.GetType().GetTypeInfo().IsEnum, "Expected enum"); 1360Assert.True(result is Dictionary<string, int>, "Expected Dictionary<string, int>"); 1437Assert.True(false, "Expected an exception"); 1456Assert.True(false, "Expected an exception"); 1469Assert.True(false, "Expected an exception");

62Assert.True(parens.Count() == 2, "Expect exactly two parenthesized lambda expressions in the syntax tree.");

264Assert.True(!boundInitializers.IsEmpty, "Expected non-null non-empty bound initializers");

473Assert.True(0 < errs.Count(), "Diagnostics not empty"); 474Assert.True(0 < errs.Where(e => e.Code == 1525).Select(e => e).Count(), "Diagnostics contains CS1525"); 852Assert.True(conv.IsAnonymousFunction, "LambdaConversion"); 862Assert.True(conv.IsAnonymousFunction, "LambdaConversion");

3071Assert.True(actualNumExpectedNames == expectedNumExpectedNames, string.Format("Expected {0} sets of expected names, but found {1}", expectedNumExpectedNames, actualNumExpectedNames));

1808Assert.True(expectedType == actualType, $"Unexpected TypeInfo.Type '{actualType}'"); 1818Assert.True(expectedConvertedType == actualConvertedType, $"Unexpected TypeInfo.ConvertedType '{actualConvertedType}'"); 38067Assert.True((object)method != null, $"Could not find method '{memberName}'");

1006var generator = new CallbackGenerator((ic) => ic.RegisterForPostInitialization(postInit), (sgc) => Assert.True(false, "Should not execute"), source = "public class E : D {}"); 1038Assert.True(false, "Should not execute"); 1041var generator = new CallbackGenerator(init, (sgc) => Assert.True(false, "Should not execute"), source = "public class E : D {}"); 1358Assert.True(start >= 0, $"Not found in source: '{x.Location}'");

1286Assert.True(comp.ExternalReferences[2] is CSharpCompilationReference, "Expected compilation reference");

4943Assert.True(symbolInfo.IsDefined, "must be defined"); 4947Assert.True(symbolInfo.IsDefined, "must be defined"); 4951Assert.True(symbolInfo.IsDefined, "must be defined"); 4955Assert.True(symbolInfo.IsDefined, "must be defined"); 5041Assert.True(symbolInfo.IsDefined, "must be defined"); 5057Assert.True(symbolInfo.IsDefined, "must be defined"); 5073Assert.True(symbolInfo.IsDefined, "must be defined"); 5089Assert.True(symbolInfo.IsDefined, "must be defined"); 5122Assert.True(symbolInfo.IsDefined, "must be defined"); 5139Assert.True(symbolInfo.IsDefined, "must be defined"); 5188Assert.True(symbolInfo.IsDefined, "must be defined"); 5205Assert.True(symbolInfo.IsDefined, "must be defined"); 5222Assert.True(symbolInfo.IsDefined, "must be defined"); 5303Assert.True(symbolInfo.IsDefined, "must be defined"); 5320Assert.True(symbolInfo.IsDefined, "must be defined"); 5939Assert.True(exceptionThrown, $"{nameof(comp.GetSpecialType)} did not throw when it should have."); 5962Assert.True(exceptionThrown, $"{nameof(comp.GetSpecialType)} did not throw when it should have.");

162Assert.True(actual_lookupNames.Contains("System"), "LookupNames does not contain System"); 163Assert.True(actual_lookupNames.Contains("Main"), "LookupNames does not contain Main"); 164Assert.True(actual_lookupNames.Contains("IA"), "LookupNames does not contain IA"); 165Assert.True(actual_lookupNames.Contains("A"), "LookupNames does not contain A"); 166Assert.True(actual_lookupNames.Contains("a"), "LookupNames does not contain a"); 173Assert.True(actual_lookupSymbols_as_string.Contains("void B.Main(System.String[] args)"), "LookupSymbols does not contain Main"); 174Assert.True(actual_lookupSymbols_as_string.Contains("System"), "LookupSymbols does not contain System"); 175Assert.True(actual_lookupSymbols_as_string.Contains("IA"), "LookupSymbols does not contain IA"); 176Assert.True(actual_lookupSymbols_as_string.Contains("A"), "LookupSymbols does not contain A");

1406Assert.True(symbolB is Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE.PEAssemblySymbol, "PE symbol expected"); 1411Assert.True(symbolA2 is Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE.PEAssemblySymbol, "PE symbol expected");

1438Assert.True(constantInfo.HasValue, "must be a constant"); 1476Assert.True(constantInfo.HasValue, "must be a constant"); 1524Assert.True(constantInfo.HasValue, "must be a constant"); 1612Assert.True(constantInfo.HasValue, "must be a constant"); 1697Assert.True(constantInfo.HasValue, "must be a constant"); 2272Assert.True(binder.InUnsafeRegion, "must be in unsafe code"); 2273Assert.True(binder.IsSemanticModelBinder, "must be speculative");

4276Assert.True(constantInfo.HasValue, "must be constant"); 4291Assert.True(constantInfo.HasValue, "must be constant"); 4337Assert.True(constantInfo.HasValue, "must be constant"); 4360Assert.True(constantInfo.HasValue, "must be constant"); 4382Assert.True(constantInfo.HasValue, "must be constant");

188Assert.True(false, string.Format("Expected {0} but got {1} when converting {2} -> {3}", kind, result, types[j], types[i]));

626Assert.True(memberNames1.Contains(m), m); 636Assert.True(memberNames2.Contains(m), m); 667Assert.True(memberNames1.Contains(m), m); 678Assert.True(memberNames2.Contains(m), m);

1085Assert.True((object)symbol != null, $"Unexpected null for {wkm}");

210Assert.True(expected == actual, string.Format("expected {0}, actual {1}", expected, actual));

41Assert.True(member is PropertySymbol or FieldSymbol, $"Unexpected member symbol type {member.Kind}");

120Assert.True(!symbol.IsFromCompilation(compilation) || symbol.IsImplicitlyDeclared, "non-implicitly declares source symbol should have declaring location"); 124Assert.True(symbol.IsFromCompilation(compilation) || symbol is MergedNamespaceSymbol, "symbol with declaration should be in source, except for merged namespaces");

1032Assert.True(currentSymbol is NamespaceOrTypeSymbol, string.Format("{0} does not have members", currentSymbol.ToTestDisplayString())); 1035Assert.True(members.Length > 0, string.Format("No members named {0} inside {1}", name, currentSymbol.ToTestDisplayString())); 1036Assert.True(members.Length <= 1, string.Format("Multiple members named {0} inside {1}", name, currentSymbol.ToTestDisplayString()));

59Assert.True(nullableIgnored, "If considerEverything is true, nullableIgnored should be true as well.");

16964Assert.True((TypeSymbol.Equals(classBinN1, (TypeSymbol)errorFieldType.CandidateSymbols[0], TypeCompareKind.ConsiderEverything2) && TypeSymbol.Equals(classBinN2, (TypeSymbol)errorFieldType.CandidateSymbols[1], TypeCompareKind.ConsiderEverything2)) ||

426Assert.True(TypeUnification.CanUnify(t1, t2), string.Format("{0} vs {1}", t1, t2)); 427Assert.True(TypeUnification.CanUnify(t2, t1), string.Format("{0} vs {1}", t2, t1));

60Assert.True(set.Add(value), $"{value} is duplicated!"); 488Assert.True(false, $"Please update this test case with a proper warning level ({ErrorFacts.GetWarningLevel(errorCode)}) for '{errorCodeName}'"); 2414Assert.True(index >= 0, "textToFind not found in the tree"); 2995Assert.True(isBuildOnly, $"Check failed for ErrorCode.{errorCode}");

70Assert.True(index >= 0, "textToFind not found in the tree");

14239Assert.True(newNode.IsMissing, "No tokens => missing"); 14265Assert.True(newNode.IsMissing, "No tokens => missing"); 14291Assert.True(newNode.IsMissing, "No tokens => missing"); 14317Assert.True(newNode.IsMissing, "No tokens => missing"); 14343Assert.True(newNode.IsMissing, "No tokens => missing"); 14369Assert.True(newNode.IsMissing, "No tokens => missing"); 14395Assert.True(newNode.IsMissing, "No tokens => missing"); 14421Assert.True(newNode.IsMissing, "No tokens => missing"); 14447Assert.True(newNode.IsMissing, "No tokens => missing"); 14473Assert.True(newNode.IsMissing, "No tokens => missing"); 14499Assert.True(newNode.IsMissing, "No tokens => missing"); 14525Assert.True(newNode.IsMissing, "No tokens => missing"); 14551Assert.True(newNode.IsMissing, "No tokens => missing"); 14577Assert.True(newNode.IsMissing, "No tokens => missing"); 14603Assert.True(newNode.IsMissing, "No tokens => missing"); 14629Assert.True(newNode.IsMissing, "No tokens => missing"); 14655Assert.True(newNode.IsMissing, "No tokens => missing"); 14681Assert.True(newNode.IsMissing, "No tokens => missing"); 14707Assert.True(newNode.IsMissing, "No tokens => missing"); 14733Assert.True(newNode.IsMissing, "No tokens => missing"); 14759Assert.True(newNode.IsMissing, "No tokens => missing"); 14785Assert.True(newNode.IsMissing, "No tokens => missing"); 14811Assert.True(newNode.IsMissing, "No tokens => missing"); 14837Assert.True(newNode.IsMissing, "No tokens => missing"); 14863Assert.True(newNode.IsMissing, "No tokens => missing"); 14889Assert.True(newNode.IsMissing, "No tokens => missing"); 14915Assert.True(newNode.IsMissing, "No tokens => missing"); 14941Assert.True(newNode.IsMissing, "No tokens => missing"); 14967Assert.True(newNode.IsMissing, "No tokens => missing"); 14993Assert.True(newNode.IsMissing, "No tokens => missing"); 15019Assert.True(newNode.IsMissing, "No tokens => missing"); 15045Assert.True(newNode.IsMissing, "No tokens => missing"); 15071Assert.True(newNode.IsMissing, "No tokens => missing"); 15097Assert.True(newNode.IsMissing, "No tokens => missing"); 15123Assert.True(newNode.IsMissing, "No tokens => missing"); 15149Assert.True(newNode.IsMissing, "No tokens => missing"); 15175Assert.True(newNode.IsMissing, "No tokens => missing"); 15201Assert.True(newNode.IsMissing, "No tokens => missing"); 15227Assert.True(newNode.IsMissing, "No tokens => missing"); 15253Assert.True(newNode.IsMissing, "No tokens => missing"); 15279Assert.True(newNode.IsMissing, "No tokens => missing"); 15305Assert.True(newNode.IsMissing, "No tokens => missing"); 15331Assert.True(newNode.IsMissing, "No tokens => missing"); 15357Assert.True(newNode.IsMissing, "No tokens => missing"); 15383Assert.True(newNode.IsMissing, "No tokens => missing"); 15409Assert.True(newNode.IsMissing, "No tokens => missing"); 15435Assert.True(newNode.IsMissing, "No tokens => missing"); 15461Assert.True(newNode.IsMissing, "No tokens => missing"); 15487Assert.True(newNode.IsMissing, "No tokens => missing"); 15513Assert.True(newNode.IsMissing, "No tokens => missing"); 15539Assert.True(newNode.IsMissing, "No tokens => missing"); 15565Assert.True(newNode.IsMissing, "No tokens => missing"); 15591Assert.True(newNode.IsMissing, "No tokens => missing"); 15617Assert.True(newNode.IsMissing, "No tokens => missing"); 15643Assert.True(newNode.IsMissing, "No tokens => missing"); 15669Assert.True(newNode.IsMissing, "No tokens => missing"); 15695Assert.True(newNode.IsMissing, "No tokens => missing"); 15721Assert.True(newNode.IsMissing, "No tokens => missing"); 15747Assert.True(newNode.IsMissing, "No tokens => missing"); 15773Assert.True(newNode.IsMissing, "No tokens => missing"); 15799Assert.True(newNode.IsMissing, "No tokens => missing"); 15825Assert.True(newNode.IsMissing, "No tokens => missing"); 15851Assert.True(newNode.IsMissing, "No tokens => missing"); 15877Assert.True(newNode.IsMissing, "No tokens => missing"); 15903Assert.True(newNode.IsMissing, "No tokens => missing"); 15929Assert.True(newNode.IsMissing, "No tokens => missing"); 15955Assert.True(newNode.IsMissing, "No tokens => missing"); 15981Assert.True(newNode.IsMissing, "No tokens => missing"); 16007Assert.True(newNode.IsMissing, "No tokens => missing"); 16033Assert.True(newNode.IsMissing, "No tokens => missing"); 16059Assert.True(newNode.IsMissing, "No tokens => missing"); 16085Assert.True(newNode.IsMissing, "No tokens => missing"); 16111Assert.True(newNode.IsMissing, "No tokens => missing"); 16137Assert.True(newNode.IsMissing, "No tokens => missing"); 16163Assert.True(newNode.IsMissing, "No tokens => missing"); 16189Assert.True(newNode.IsMissing, "No tokens => missing"); 16215Assert.True(newNode.IsMissing, "No tokens => missing"); 16241Assert.True(newNode.IsMissing, "No tokens => missing"); 16267Assert.True(newNode.IsMissing, "No tokens => missing"); 16293Assert.True(newNode.IsMissing, "No tokens => missing"); 16319Assert.True(newNode.IsMissing, "No tokens => missing"); 16345Assert.True(newNode.IsMissing, "No tokens => missing"); 16371Assert.True(newNode.IsMissing, "No tokens => missing"); 16397Assert.True(newNode.IsMissing, "No tokens => missing"); 16423Assert.True(newNode.IsMissing, "No tokens => missing"); 16449Assert.True(newNode.IsMissing, "No tokens => missing"); 16475Assert.True(newNode.IsMissing, "No tokens => missing"); 16501Assert.True(newNode.IsMissing, "No tokens => missing"); 16527Assert.True(newNode.IsMissing, "No tokens => missing"); 16553Assert.True(newNode.IsMissing, "No tokens => missing"); 16579Assert.True(newNode.IsMissing, "No tokens => missing"); 16605Assert.True(newNode.IsMissing, "No tokens => missing"); 16631Assert.True(newNode.IsMissing, "No tokens => missing"); 16657Assert.True(newNode.IsMissing, "No tokens => missing"); 16683Assert.True(newNode.IsMissing, "No tokens => missing"); 16709Assert.True(newNode.IsMissing, "No tokens => missing"); 16735Assert.True(newNode.IsMissing, "No tokens => missing"); 16761Assert.True(newNode.IsMissing, "No tokens => missing"); 16787Assert.True(newNode.IsMissing, "No tokens => missing"); 16813Assert.True(newNode.IsMissing, "No tokens => missing"); 16839Assert.True(newNode.IsMissing, "No tokens => missing"); 16865Assert.True(newNode.IsMissing, "No tokens => missing"); 16891Assert.True(newNode.IsMissing, "No tokens => missing"); 16917Assert.True(newNode.IsMissing, "No tokens => missing"); 16943Assert.True(newNode.IsMissing, "No tokens => missing"); 16969Assert.True(newNode.IsMissing, "No tokens => missing"); 16995Assert.True(newNode.IsMissing, "No tokens => missing"); 17021Assert.True(newNode.IsMissing, "No tokens => missing"); 17047Assert.True(newNode.IsMissing, "No tokens => missing"); 17073Assert.True(newNode.IsMissing, "No tokens => missing"); 17099Assert.True(newNode.IsMissing, "No tokens => missing"); 17125Assert.True(newNode.IsMissing, "No tokens => missing"); 17151Assert.True(newNode.IsMissing, "No tokens => missing"); 17177Assert.True(newNode.IsMissing, "No tokens => missing"); 17203Assert.True(newNode.IsMissing, "No tokens => missing"); 17229Assert.True(newNode.IsMissing, "No tokens => missing"); 17255Assert.True(newNode.IsMissing, "No tokens => missing"); 17281Assert.True(newNode.IsMissing, "No tokens => missing"); 17307Assert.True(newNode.IsMissing, "No tokens => missing"); 17333Assert.True(newNode.IsMissing, "No tokens => missing"); 17359Assert.True(newNode.IsMissing, "No tokens => missing"); 17385Assert.True(newNode.IsMissing, "No tokens => missing"); 17411Assert.True(newNode.IsMissing, "No tokens => missing"); 17437Assert.True(newNode.IsMissing, "No tokens => missing"); 17463Assert.True(newNode.IsMissing, "No tokens => missing"); 17489Assert.True(newNode.IsMissing, "No tokens => missing"); 17515Assert.True(newNode.IsMissing, "No tokens => missing"); 17541Assert.True(newNode.IsMissing, "No tokens => missing"); 17567Assert.True(newNode.IsMissing, "No tokens => missing"); 17593Assert.True(newNode.IsMissing, "No tokens => missing"); 17619Assert.True(newNode.IsMissing, "No tokens => missing"); 17645Assert.True(newNode.IsMissing, "No tokens => missing"); 17671Assert.True(newNode.IsMissing, "No tokens => missing"); 17697Assert.True(newNode.IsMissing, "No tokens => missing"); 17723Assert.True(newNode.IsMissing, "No tokens => missing"); 17749Assert.True(newNode.IsMissing, "No tokens => missing"); 17775Assert.True(newNode.IsMissing, "No tokens => missing"); 17801Assert.True(newNode.IsMissing, "No tokens => missing"); 17827Assert.True(newNode.IsMissing, "No tokens => missing"); 17853Assert.True(newNode.IsMissing, "No tokens => missing"); 17879Assert.True(newNode.IsMissing, "No tokens => missing"); 17905Assert.True(newNode.IsMissing, "No tokens => missing"); 17931Assert.True(newNode.IsMissing, "No tokens => missing"); 17957Assert.True(newNode.IsMissing, "No tokens => missing"); 17983Assert.True(newNode.IsMissing, "No tokens => missing"); 18009Assert.True(newNode.IsMissing, "No tokens => missing"); 18035Assert.True(newNode.IsMissing, "No tokens => missing"); 18061Assert.True(newNode.IsMissing, "No tokens => missing"); 18087Assert.True(newNode.IsMissing, "No tokens => missing"); 18113Assert.True(newNode.IsMissing, "No tokens => missing"); 18139Assert.True(newNode.IsMissing, "No tokens => missing"); 18165Assert.True(newNode.IsMissing, "No tokens => missing"); 18191Assert.True(newNode.IsMissing, "No tokens => missing"); 18217Assert.True(newNode.IsMissing, "No tokens => missing"); 18243Assert.True(newNode.IsMissing, "No tokens => missing"); 18269Assert.True(newNode.IsMissing, "No tokens => missing"); 18295Assert.True(newNode.IsMissing, "No tokens => missing"); 18321Assert.True(newNode.IsMissing, "No tokens => missing"); 18347Assert.True(newNode.IsMissing, "No tokens => missing"); 18373Assert.True(newNode.IsMissing, "No tokens => missing"); 18399Assert.True(newNode.IsMissing, "No tokens => missing"); 18425Assert.True(newNode.IsMissing, "No tokens => missing"); 18451Assert.True(newNode.IsMissing, "No tokens => missing"); 18477Assert.True(newNode.IsMissing, "No tokens => missing"); 18503Assert.True(newNode.IsMissing, "No tokens => missing"); 18529Assert.True(newNode.IsMissing, "No tokens => missing"); 18555Assert.True(newNode.IsMissing, "No tokens => missing"); 18581Assert.True(newNode.IsMissing, "No tokens => missing"); 18607Assert.True(newNode.IsMissing, "No tokens => missing"); 18633Assert.True(newNode.IsMissing, "No tokens => missing"); 18659Assert.True(newNode.IsMissing, "No tokens => missing"); 18685Assert.True(newNode.IsMissing, "No tokens => missing"); 18711Assert.True(newNode.IsMissing, "No tokens => missing"); 18737Assert.True(newNode.IsMissing, "No tokens => missing"); 18763Assert.True(newNode.IsMissing, "No tokens => missing"); 18789Assert.True(newNode.IsMissing, "No tokens => missing"); 18815Assert.True(newNode.IsMissing, "No tokens => missing"); 18841Assert.True(newNode.IsMissing, "No tokens => missing"); 18867Assert.True(newNode.IsMissing, "No tokens => missing"); 18893Assert.True(newNode.IsMissing, "No tokens => missing"); 18919Assert.True(newNode.IsMissing, "No tokens => missing"); 18945Assert.True(newNode.IsMissing, "No tokens => missing"); 18971Assert.True(newNode.IsMissing, "No tokens => missing"); 18997Assert.True(newNode.IsMissing, "No tokens => missing"); 19023Assert.True(newNode.IsMissing, "No tokens => missing"); 19049Assert.True(newNode.IsMissing, "No tokens => missing"); 19075Assert.True(newNode.IsMissing, "No tokens => missing"); 19101Assert.True(newNode.IsMissing, "No tokens => missing"); 19127Assert.True(newNode.IsMissing, "No tokens => missing"); 19153Assert.True(newNode.IsMissing, "No tokens => missing"); 19179Assert.True(newNode.IsMissing, "No tokens => missing"); 19205Assert.True(newNode.IsMissing, "No tokens => missing"); 19231Assert.True(newNode.IsMissing, "No tokens => missing"); 19257Assert.True(newNode.IsMissing, "No tokens => missing"); 19283Assert.True(newNode.IsMissing, "No tokens => missing"); 19309Assert.True(newNode.IsMissing, "No tokens => missing"); 19335Assert.True(newNode.IsMissing, "No tokens => missing"); 19361Assert.True(newNode.IsMissing, "No tokens => missing"); 19387Assert.True(newNode.IsMissing, "No tokens => missing"); 19413Assert.True(newNode.IsMissing, "No tokens => missing"); 19439Assert.True(newNode.IsMissing, "No tokens => missing"); 19465Assert.True(newNode.IsMissing, "No tokens => missing"); 19491Assert.True(newNode.IsMissing, "No tokens => missing"); 19517Assert.True(newNode.IsMissing, "No tokens => missing"); 19543Assert.True(newNode.IsMissing, "No tokens => missing"); 19569Assert.True(newNode.IsMissing, "No tokens => missing"); 19595Assert.True(newNode.IsMissing, "No tokens => missing"); 19621Assert.True(newNode.IsMissing, "No tokens => missing"); 19647Assert.True(newNode.IsMissing, "No tokens => missing"); 19673Assert.True(newNode.IsMissing, "No tokens => missing"); 19699Assert.True(newNode.IsMissing, "No tokens => missing"); 19725Assert.True(newNode.IsMissing, "No tokens => missing"); 19751Assert.True(newNode.IsMissing, "No tokens => missing"); 19777Assert.True(newNode.IsMissing, "No tokens => missing"); 19803Assert.True(newNode.IsMissing, "No tokens => missing"); 19829Assert.True(newNode.IsMissing, "No tokens => missing"); 19855Assert.True(newNode.IsMissing, "No tokens => missing"); 19881Assert.True(newNode.IsMissing, "No tokens => missing"); 19907Assert.True(newNode.IsMissing, "No tokens => missing"); 19933Assert.True(newNode.IsMissing, "No tokens => missing"); 19959Assert.True(newNode.IsMissing, "No tokens => missing"); 19985Assert.True(newNode.IsMissing, "No tokens => missing"); 20011Assert.True(newNode.IsMissing, "No tokens => missing"); 20037Assert.True(newNode.IsMissing, "No tokens => missing"); 20063Assert.True(newNode.IsMissing, "No tokens => missing"); 20089Assert.True(newNode.IsMissing, "No tokens => missing"); 20115Assert.True(newNode.IsMissing, "No tokens => missing"); 20141Assert.True(newNode.IsMissing, "No tokens => missing"); 20167Assert.True(newNode.IsMissing, "No tokens => missing"); 20193Assert.True(newNode.IsMissing, "No tokens => missing"); 20219Assert.True(newNode.IsMissing, "No tokens => missing"); 20245Assert.True(newNode.IsMissing, "No tokens => missing"); 20271Assert.True(newNode.IsMissing, "No tokens => missing"); 20297Assert.True(newNode.IsMissing, "No tokens => missing"); 20323Assert.True(newNode.IsMissing, "No tokens => missing"); 20349Assert.True(newNode.IsMissing, "No tokens => missing"); 20375Assert.True(newNode.IsMissing, "No tokens => missing"); 20401Assert.True(newNode.IsMissing, "No tokens => missing"); 20427Assert.True(newNode.IsMissing, "No tokens => missing"); 20453Assert.True(newNode.IsMissing, "No tokens => missing"); 20479Assert.True(newNode.IsMissing, "No tokens => missing"); 20505Assert.True(newNode.IsMissing, "No tokens => missing"); 20531Assert.True(newNode.IsMissing, "No tokens => missing"); 20557Assert.True(newNode.IsMissing, "No tokens => missing"); 20583Assert.True(newNode.IsMissing, "No tokens => missing"); 20609Assert.True(newNode.IsMissing, "No tokens => missing");

3487Assert.True(oldRoot.ContainsAnnotations, "Should contain annotations."); 3496Assert.True(oldClassC.ContainsAnnotations, "Should contain annotations"); 3507Assert.True(oldToken.ContainsAnnotations, "Should contain annotations");

61Assert.True(false, "More than one token was lexed: " + token); 66Assert.True(false, "No tokens were lexed");

286Assert.True(false, String.Format("You are expecting some text in the directive, but this method doesn't know how to verify it for `{0}`.", exp.Kind)); 350Assert.True(false, "Warning ID must be an identifier or numeric literal");

3001Assert.True(false, source); 3006Assert.True(false, source);

49Assert.True(listOf2 != listOf1, $"{i} iterations"); 74Assert.True(listOf3 != listOf2, $"{i} iterations");

473Assert.True(compilationUnit.ContainsDirective(directiveKind), directiveKind.ToString());

325Assert.True(node1.SyntaxTree.HasCompilationUnitRoot, "how did we get a non-CompilationUnit root?"); 341Assert.True(newRoot.SyntaxTree.HasCompilationUnitRoot, "how did we get a non-CompilationUnit root?"); 353Assert.True(newRoot.SyntaxTree.HasCompilationUnitRoot, "how did we get a non-CompilationUnit root?"); 544Assert.True(rewrittenRoot.SyntaxTree.HasCompilationUnitRoot, "how did we get a non-CompilationUnit root?");

273Assert.True(SyntaxFacts.IsAttributeTargetSpecifier(kind), $$"""IsAttributeTargetSpecific({{kind}}) should be true"""); 292Assert.True(Enum.IsDefined(typeof(SyntaxKind), kind), $"Nonexistent kind '{kind}' returned from method '{method.Name}'");

503Assert.True(expr != null, $"VerifyTypes could not find a matching expression for annotation '{text}'.");

1536Assert.True(expectedBlobs.ContainsKey(s), "Expecting marshalling blob for " + (isField ? "field " : "parameter ") + s); 2139Assert.True(compilation.SyntaxTrees.Length > treeIndex, "Compilation has enough trees"); 2160Assert.True(compilation.SyntaxTrees.Length > treeIndex, "Compilation has enough trees"); 2215Assert.True(end > start, "Bind Pos: end > start");

104Assert.True( 151Assert.True(experr.Line == acterr.Line, String.Format("Line {0}!={1}", experr.Line, acterr.Line)); 152Assert.True(experr.Column == acterr.Column, String.Format("Col {0}!={1}", experr.Column, acterr.Column)); 155Assert.True(experr.IsWarning == acterr.IsWarning, String.Format("IsWarning {0}!={1}", experr.IsWarning, acterr.IsWarning)); 160Assert.True(experr.Parameters.SequenceEqual(acterr.Parameters), String.Format("Param: {0}!={1}", experr.Parameters.Count(), acterr.Parameters.Count()));

228Assert.True(false, string.Format("Could not find member named '{0}'. Available members:\r\n{1}", 290Assert.True(false, "Found multiple members of specified name:\r\n" + string.Join("\r\n", members)); 306Assert.True(false, "Found multiple members of specified name:\r\n" + string.Join("\r\n", members));

296Assert.True(false, $"Cannot have a return ref kind of {signature.RefKind}"); 326Assert.True(false, $"Cannot have a return ref kind of {parameter.RefKind}");

461Assert.True(false, "Dump is different. To investigate compare files:\r\n\"" + fileExpected + "\" \"" + fileActual + "\"");

40Assert.True(CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(value) == expectedResult, 50Assert.True(CSharpFormattingOptions2.ParseEditorConfigSpacingAroundBinaryOperator(value) == BinaryOperatorSpacingOptions.Single, 60Assert.True(CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(value) == expectedValue, 70Assert.True(CSharpFormattingOptions2.ParseEditorConfigLabelPositioning(value) == LabelPositionOptions.NoIndent, 117Assert.True(CSharpFormattingOptions2.DetermineIfIgnoreSpacesAroundVariableDeclarationIsSet(value),

90Assert.True(cursorPosition == firstSpan.Start || cursorPosition == firstSpan.End

52Assert.True(expectedPosition == caretPosition,

86Assert.True(indentation == virtualCaret.VirtualSpaces, $"Expected indentation was {indentation}, but the actual indentation was {virtualCaret.VirtualSpaces}");

103Assert.True(testDocument.CursorPosition.HasValue || testDocument.SelectedSpans.Any(), "No caret position or selected spans are set!"); 127Assert.True(expectedPosition == endCaretPosition,

1297Assert.True(isTextualTriggerCharacterResult, assertText); 1338Assert.True(CommitManager.IsCommitCharacter(

135Assert.True(testDocument.CursorPosition.HasValue, "No caret position set!");

45Assert.True(expectedPosition == caretPosition,

153Assert.True(expectedPosition == caretPosition, 270Assert.True(expectedPosition == caretPosition,

175Assert.True(expectedItem.PatternMatch.Kind == actualItem.PatternMatch.Kind, string.Format("pattern: {0} expected: {1} actual: {2}", expectedItem.Name, expectedItem.PatternMatch.Kind, actualItem.PatternMatch.Kind)); 176Assert.True(expectedItem.PatternMatch.IsCaseSensitive == actualItem.PatternMatch.IsCaseSensitive, string.Format("pattern: {0} expected: {1} actual: {2}", expectedItem.Name, expectedItem.PatternMatch.IsCaseSensitive, actualItem.PatternMatch.IsCaseSensitive));

80Assert.True(remainingErrors.Contains(error), $"Error '{error}' was unexpected");

134Assert.True(signatureHelpProvider.TriggerCharacters.Contains(expectedTriggerCharacter), "Expected '" + expectedTriggerCharacter + "' to be a trigger character"); 184Assert.True(expectedTestItems.Count() == actualSignatureHelpItems.Items.Count, $"Expected {expectedTestItems.Count()} items, but got {actualSignatureHelpItems.Items.Count}"); 239Assert.True(expectedTestItem.CurrentParameterIndex == items.SemanticParameterIndex, $"The current parameter is {items.SemanticParameterIndex}, but we expected {expectedTestItem.CurrentParameterIndex}"); 429Assert.True(expectedOrderedItemsOrNull.Count(i => i.IsSelected) == 1, "Only one expected item can be marked with 'IsSelected'"); 430Assert.True(selectedItemIndex != null, "Expected an item to be selected, but no item was actually selected"); 437Assert.True(selectedItemIndex == counter, 442Assert.True(selectedItemIndex != counter,

53Assert.True(expectedRegions.Length == actualRegions.Length, $"Expected {expectedRegions.Length} regions but there were {actualRegions.Length}"); 73Assert.True(actualRegions.Length == 0, $"Expected no regions but found {actualRegions.Length}."); 88Assert.True(spans.ContainsKey(textSpanName) && spans[textSpanName].Length == 1, $"Test did not specify '{textSpanName}' span."); 89Assert.True(spans.ContainsKey(hintSpanName) && spans[hintSpanName].Length == 1, $"Test did not specify '{hintSpanName}' span.");

44Assert.True(failureMessage.Length == passLength, failureMessage.ToString()); 82Assert.True(failureMessage.Length == passLength, failureMessage.ToString()); 109Assert.True(failureMessage.Length == passLength, failureMessage.ToString()); 136Assert.True(failureMessage.Length == passLength, failureMessage.ToString());

74Assert.True(cs != null || csSimple != null || vb != null || vbSimple != null,

261Assert.True(exception != null && exception.Message.StartsWith(expectedMessage, StringComparison.Ordinal),

80Assert.True(helpLinkUri == string.Empty, $"Expected empty help link for {diagnosticId}"); 92Assert.True(false, $"Invalid help link for {diagnosticId}");

107Assert.True(false, PrintDifference());

120Assert.True(File.Exists(portableExecutable.FilePath), $"'{portableExecutable.FilePath}' does not exist for reference '{portableExecutable.Display}'"); 121Assert.True(Path.IsPathRooted(portableExecutable.FilePath), $"'{portableExecutable.FilePath}' is not a fully-qualified file name"); 125Assert.True(File.Exists(reference.Display), $"'{reference.Display}' does not exist"); 126Assert.True(Path.IsPathRooted(reference.Display), $"'{reference.Display}' is not a fully-qualified file name");

458Assert.True(transitiveDerived.All(d => d.GetBaseTypes().Contains(rootType)), "All results must transitively derive from the type"); 459Assert.True(transitiveDerived.Any(d => !Equals(d.BaseType, rootType)), "At least one result must not immediately derive from the type"); 507Assert.True(transitiveDerived.All(d => d.AllInterfaces.Contains(rootType)), "All results must transitively derive from the type"); 508Assert.True(transitiveDerived.Any(d => !d.Interfaces.Contains(rootType)), "At least one result must not immediately derive from the type"); 559Assert.True(transitiveImpls.All(d => d.AllInterfaces.Contains(rootType)), "All results must transitively derive from the type"); 560Assert.True(transitiveImpls.Any(d => !d.Interfaces.Contains(rootType)), "At least one result must not immediately derive from the type"); 588Assert.True(delegates.Any(i => i.Locations.Any(loc => loc.IsInMetadata)), "We should find a metadata delegate"); 618Assert.True(enums.Any(i => i.Locations.Any(loc => loc.IsInMetadata)), "We should find a metadata enum");

96Assert.True(done, "The operation should have completed"); 128Assert.True(done, "Should have waited for the queued operation to finish!"); 160Assert.True(done, "Cancelling should have completed the current task."); 193Assert.True(innerDone, "Should have completed the inner task"); 194Assert.True(outerDone, "Should have completed the outer task"); 237Assert.True(outerDone, "The outer task should have finished!"); 238Assert.True(firstQueuedDone, "The first queued task should have finished"); 239Assert.True(secondQueuedDone, "The second queued task should have finished"); 282Assert.True(done.Task.IsCompleted, "Cancelling should have completed the current task."); 283Assert.True(queuedFinished.Task.IsCompleted, "Continued didn't run, but it was supposed to ignore the cancel."); 320Assert.True(firstDone, "First didn't finish"); 321Assert.True(secondDone, "Should have waited for the second task"); 330Assert.True(signal.Wait(s_unexpectedDelay), "Shouldn't have hit timeout waiting for task to begin"); 332Assert.True(waitTask.Wait(s_unexpectedDelay), "Wait shouldn't have needed to timeout"); 341Assert.True(signal1.Wait(s_unexpectedDelay), "Shouldn't have hit timeout waiting for task to begin"); 342Assert.True(signal2.Wait(s_unexpectedDelay), "Shouldn't have hit timeout waiting for task to begin"); 345Assert.True(waitTask.Wait(s_unexpectedDelay), "Wait shouldn't have needed to timeout");

79Assert.True(falsePositivePercentage < (d * 1.5), string.Format("falsePositivePercentage={0}, d={1}", falsePositivePercentage, d)); 199Assert.True(falsePositivePercentage < (d * 1.5), string.Format("falsePositivePercentage={0}, d={1}", falsePositivePercentage, d)); 270Assert.True(falsePositivePercentage < (d * 1.5), string.Format("falsePositivePercentage={0}, d={1}", falsePositivePercentage, d));

44Assert.True(expected.ChildCount == actual.ChildCount, PrintChildDifference(expected, actual)); 126Assert.True(actual.IsDefault, diffMessage); 131Assert.True(expected.Length == actual.Length, diffMessage);

45Assert.True(itemInfo.Length == items.Length, $"GetTrackedItemsAsync\n\texpected: [{string.Join(",", itemInfo.Select(p => p.text))}]\n\t actual: [{string.Join(",", items)}]"); 58Assert.True(childInfo.Length == children.Length, $"GetTrackedItemsAsync on [{item}]\n\texpected: [{string.Join(",", childInfo.Select(p => p.text))}]\n\t actual: [{string.Join(",", children)}]");

37Assert.True(classificationType != null, $"{nameof(ClassificationTypeNames)}.{fieldName} has value \"{classificationTypeName}\", but no matching {nameof(ClassificationTypeDefinition)} was exported."); 42=> Assert.True(ClassificationTypeNames.AllTypeNames.Contains(fieldName), $"Missing token type {fieldName}.");

46Assert.True(failureMessage.Length == passLength, failureMessage.ToString());

449Assert.True(false, $"Content of document should never be loaded");

98Assert.True(Encoding.UTF8.GetByteCount(projectName) <= 20, "Use shorter project names in tests");

76Assert.True(false, $"Message format string was not supplied enough arguments.\nRudeEditKind: {RudeEditKind}\nArguments supplied: {_arguments.Length}\nFormat string: {format}");

69Assert.True(isValidSnippetLocation, "Snippet is unexpectedly invalid on a given position"); 86Assert.True(false, "Expected placeholder locations contains span with invalid annotation"); 97Assert.True(false, $"Placeholder location for index {i} was not specified");

66Assert.True(service.HasFlag(flag), $"Capability '{name}' was not parsed correctly, so it's impossible for a runtime to enable it!");

93Assert.True(d.GetMessage().Contains("<1>"), kind.ToString()); 94Assert.True(d.GetMessage().Contains("<2>"), kind.ToString()); 101Assert.True(d.GetMessage().Contains("<1>"), kind.ToString()); 102Assert.True(d.GetMessage().Contains("<2>"), kind.ToString()); 103Assert.True(d.GetMessage().Contains("<3>"), kind.ToString()); 110Assert.True(d.GetMessage().Contains("<1>"), kind.ToString());

93Assert.True(tokens[i] >= 0, "The line offset should never be negative."); 97Assert.True(tokens[i + 1] >= 0, "The character offset should never be negative."); 106Assert.True(currentChar >= 0, "The first token on the line can't be a negative position, but applying an offset took us there."); 111Assert.True(tokenLength >= 0, "The token cannot have a negative length."); 119Assert.True(currentChar + tokenLength <= lineLength,

211Assert.True(false, $"Could not find reference with MVID {expectedMvid}");

178Assert.True(false, $@" 192Assert.True(false, $@"

27Assert.True(names.Length >= 1, "At least 1 mscorlib"); 34Assert.True(names.Length >= 1, "At least one 32bit mscorlib"); 41Assert.True(names.Length >= 1, "At least 1 mscorlib"); 48Assert.True(names.Length >= 1, "At least System.Core"); 53Assert.True(name.GetDisplayName().Contains("PublicKeyToken=b77a5c561934e089"), "PublicKeyToken matches"); 57Assert.True(names.Length >= 1, "At least System.Core"); 68Assert.True(names.Length >= 1, "At least System.Core"); 100Assert.True(name.Version >= new Version("2.0.0.0"), "netstandard version must be >= 2.0.0.0"); 108Assert.True(names.Length > 100, "There are at least 100 assemblies in the GAC"); 115Assert.True(gacLocationsUpper.Any(gac => location.StartsWith(gac, StringComparison.OrdinalIgnoreCase)), "Path within some GAC root");

174Assert.True((actual == null) == expected.IsDefault, message); 189Assert.True(expected is null == actual is null, message); 219Assert.True(false, message.ToString()); 246Assert.True(false, GetAssertMessage(expected, actual, comparer, message, itemInspector, itemSeparator, expectedValueSourcePath, expectedValueSourceLine)); 262Assert.True(false, GetAssertMessage(expected, actual, comparer, message, itemInspector, itemSeparator, expectedValueSourcePath, expectedValueSourceLine)); 309Assert.True(false, messageBuilder.ToString()); 483Assert.True(result, GetAssertMessage( 499Assert.True(false, message); 510Assert.True(none, string.Format( 520Assert.True(any, string.Format("No expected item was found.\nExisting items: {0}", ToString(actual))); 528Assert.True(all, string.Format( 578Assert.True(false, GetAssertMessage(expected, actual, message, escapeQuotes, expectedValueSourcePath, expectedValueSourceLine)); 604Assert.True(false, message); 955Assert.True(false, builder.ToString());

52Assert.True(false, message +

89Assert.True(expectedOutput == null || 137Assert.True(expectedBlobs.ContainsKey(s), "Expecting marshalling blob for " + (isField ? "field " : "parameter ") + s);

99Assert.True(sequencePointMarkers.Count > 0, $"No sequence points found in:{Environment.NewLine}{actualPdb}");

90Assert.True(emitResult.Success, "Diagnostics:\r\n" + string.Join("\r\n", emitResult.Diagnostics.Select(d => d.ToString()))); 104Assert.True(emitResult.Success, "Diagnostics: " + string.Join(", ", emitResult.Diagnostics.Select(d => d.ToString()))); 302Assert.True(node == operation.Syntax, $"Expected : {node} - Actual : {operation.Syntax}"); 304Assert.True(operation.Type == null || !operation.MustHaveNullType(), $"Unexpected non-null type: {operation.Type}");

1634Assert.True(CanBeInControlFlowGraph(root), $"Unexpected node kind OperationKind.{root.Kind}"); 1642Assert.True(CanBeInControlFlowGraph(operation), $"Unexpected node kind OperationKind.{operation.Kind}"); 1686Assert.True(false, $"{(symbol.Kind == SymbolKind.Local ? "Local" : "Method")} without owning region {symbol.ToTestDisplayString()} in [{getBlockId(block)}]\n{finalGraph()}"); 1691Assert.True(false, $"Capture [{referencedCaptureIds.First().Value}] without owning region in [{getBlockId(block)}]\n{finalGraph()}"); 1791Assert.True(value, $"{message}\n{finalGraph()}"); 1985Assert.True(false, $"Unhandled node kind OperationKind.{n.Kind}");

321Assert.True(operation.Type == null || !operation.MustHaveNullType(), $"Unexpected non-null type: {operation.Type}");

589Assert.True(operation.Descendants().All(n => n.IsImplicit), $"Explicit node in default argument value ({operation.Syntax.RawKind}): {operation.Syntax.ToString()}"); 1497Assert.True(false, $"Unexpected symbol {operation.DeconstructSymbol}"); 1541Assert.True(false, $"Unexpected symbol {symbol}");

325Assert.True(found, "Could not find type named " + typeName); 694Assert.True(false, builder.ToString());

1131Assert.True(Environment.ProcessorCount > 1, "This analyzer is intended to be used only in a concurrent environment."); 1147Assert.True(context.Compilation.Options.ConcurrentBuild, "This analyzer is intended to be used only when concurrent build is enabled.");

561Assert.True(false, "Diagnostic messages should never contain unsubstituted placeholders.\n " + message);

99Assert.True(false, text);

21Assert.True(match.Success, "Could not find a match for \"" + pattern + "\" in:" + Environment.NewLine + source); 28Assert.True(expectedDiagnosticIds.SequenceEqual(actualDiagnosticIds),

68Assert.True(_mismatchedOptions.Count == 0,

1396Assert.True(spans.Length > 0, "Must specify a span within which to generate diagnostics on each token");

99Assert.True(!handled.Any(h => h == false) && handled.Any(h => true), Environment.NewLine +

102Assert.True(expectedMissingSyntaxKinds.Count == 0, "AllInOne test contains ignored SyntaxKinds: " + string.Join(", ", expectedMissingSyntaxKinds)); 166Assert.True(expected.SequenceEqual(actual), 176Assert.True(missingElements.Count == 0,

147Assert.True(expectedRetCode == process.ExitCode, $"Unexpected exit code: {process.ExitCode} (expecting {expectedRetCode}). Process output: {result}. Process error: {error}");

403Assert.True(expectedSourceSnippet == null,

172Assert.True(false, "\n\nExpected:" + expectedText + "\n\nActual:" + actualText + "\n\nDifferences:\n" + diffText);

44Assert.True(false, "not impl");

106Assert.True(_strongReference != null, "Reference should still be held.");

1386Assert.True(ex is MissingMethodException or TargetInvocationException, $@"Unexpected exception type: ""{ex.GetType()}""");

32Assert.True(a.MoveNext(), "actual has fewer elements"); 58Assert.True(a.MoveNext(), "actual has fewer elements");

257Assert.True(itemFound, "itemFound");

378Assert.True(list.Exists(expectedItemDelegate), 383Assert.True((0 < items.Length) == list.Exists((T? item) => { return true; }), 387Assert.True(!list.Exists((T? item) => { return false; }), 392Assert.True(list.Exists((T? item) => { return item == null ? default(T) == null : item.Equals(default(T)); }), 413Assert.True(list.Exists(expectedItemDelegate), 421Assert.True(list.Exists(expectedItemDelegate), 425Assert.True(list.Exists((T item) => { return item != null && (item.Equals(items[0]) || item.Equals(items[1])); }), 688Assert.True(list.TrueForAll(delegate (T item) { return true; }), 692Assert.True((0 == items.Length) == list.TrueForAll(delegate (T item) { return false; }),

225Assert.True(seen.Contains(succ), message);

85Assert.True(false, "Didn't return an error"); 990Assert.True(false, "Didn't throw an exception");

24Assert.True(CS.CSharpExtensions.IsCSharpKind((int)kind), kind + " should be C# kind"); 34Assert.True(VB.VisualBasicExtensions.IsVisualBasicKind((int)kind), kind + " should be VB kind");

29Assert.True(analyzers != null && analyzers.Length > 0, "Must specify at least one diagnostic analyzer to test suppression");

1341Assert.True(pos != null || spans.Count > 0, "Must specify a position or spans marking expected symbols for resolution"); 1373Assert.True(false, 1379Assert.True(expectedSymbol == symbol, 1387Assert.True(expectedSymbols.Contains(symbol), 1419Assert.True(symbols.FirstOrDefault() == null,

341Assert.True(isValid == PathUtilities.IsValidFilePath(path), $"Expected {isValid} for \"{path}\"");

57Assert.True(AssemblyIdentity.IsFullName(parts2), "Expected full name");

147Assert.True(ReferenceEquals(dn1, dn2), "cached full name expected");

386Assert.True(equivalent, "Expected equivalent"); 392Assert.True(equivalent, "Expected equivalent");

97Assert.True(a.IsImageOwner, "Assembly should own the image"); 98Assert.True(m1.IsImageOwner, "Module should own the image"); 99Assert.True(m2.IsImageOwner, "Module should own the image"); 100Assert.True(m3.IsImageOwner, "Module should own the image");

554Assert.True(eq, string.Format("expected '{0}' == '{1}'", r.Display, s.Display));

145Assert.True(m.IsImageOwner, "Metadata should own the image");

52Assert.True(s1.Equals(s2), s1.ToString() + " : " + s2.ToString()); 53Assert.True(s1 == s2, s1.ToString() + " : " + s2.ToString()); 68Assert.True(s1 != s2, s1.ToString() + " : " + s2.ToString()); 82Assert.True(s1 != s2, s1.ToString() + " : " + s2.ToString()); 206Assert.True(span1 == span2, span1.ToString() + " : " + span2.ToString()); 211Assert.True(span2 == span1, span2.ToString() + " : " + span1.ToString()); 225Assert.True(span1 != span2, span1.ToString() + " : " + span2.ToString()); 226Assert.True(span1 != span3, span1.ToString() + " : " + span3.ToString()); 227Assert.True(span2 != span3, span2.ToString() + " : " + span3.ToString());

9573Assert.True(File.Exists(Path.Combine(dir.Path, expectedFile)), "Expected to find: " & expectedFile)

749Assert.True(False, "Should not have any diagnostics") 769Assert.True(False, "Should not have any errors")

86Assert.True(root.ContainsDiagnostics, "Tree was expected to contain errors.") 385Assert.True(0 <> node.Span.Length OrElse node.Kind = SyntaxKind.CompilationUnit, "Unexpected 0 width node: " & node.Kind.ToString & node.Span.ToString) 449Assert.True(node.SpanStart >= node.Parent.SpanStart AndAlso 797Assert.True(0 <> node.Span.Length, "Unexpected 0 width node: " & node.Kind().ToString & node.Span.ToString) 802Assert.True(0 <> node.Span.Length OrElse node.IsKind(SyntaxKind.EndOfFileToken) OrElse node.IsKind(SyntaxKind.StatementTerminatorToken) OrElse node.IsKind(SyntaxKind.ColonToken), "Unexpected 0 width token: " & node.Kind().ToString & node.Span.ToString) 804Assert.True(0 <> tr.Span.Length, "Unexpected 0 width trivia: " & node.Kind().ToString & node.Span.ToString) 810Assert.True(0 <> tr.Span.Length, "Unexpected 0 width trivia: " & node.Kind().ToString & node.Span.ToString) 839Assert.True(prev.Value.Kind <> tr.Kind, 854Assert.True(node.SpanStart >= node.Parent.SpanStart AndAlso

49Assert.True(restoreResult.ExitCode == 0, $"{dotNetExeName} failed with exit code {restoreResult.ExitCode}: {restoreResult.Output}"); 282Assert.True(false, $"Unexpected project: {project.Name}"); 359Assert.True(false, $"Encountered unexpected project: {project.FilePath}"); 369Assert.True(actualNames.SetEquals(expectedNames), $"Project names differ!{Environment.NewLine}Actual: {{{actualNames.Join(",")}}}{Environment.NewLine}Expected: {{{expectedNames.Join(",")}}}"); 389Assert.True(false, "OutputFilePath with expected TFM not found."); 554Assert.True(File.Exists(depsJsonFile), $"{depsJsonFile} should exist, or it won't load on some runtimes.");

32Assert.True(expectedResultCount == actualResultCount, 49Assert.True(expectedResultCount == actualResultCount, 69Assert.True(

645Assert.True(expectedMatchedLines.Remove(line), $"An unexpected reference was found on line number {line}.");

23Assert.True(false, $"'{nameof(FunctionId)}.{name}' cannot have the same value as '{nameof(FunctionId)}.{existingName}'");

40Assert.True(result.Value == isEnabled, 42Assert.True(result.Notification.Severity == severity,

2556Assert.True(solution.ProjectIds.Any(), "Solution was expected to have projects"); 2601Assert.True(solution.ContainsProject(pid), "Solution was expected to have project " + pid); 2602Assert.True(project.HasDocuments, "Project was expected to have documents"); 2606Assert.True(project.ContainsDocument(did), "Project was expected to have document " + did); 2623Assert.True(project2.ContainsDocument(did2), "Project was expected to have document " + did2); 2865Assert.True(solution.ContainsProject(project.Id), "Solution was expected to have project " + project.Id); 2880Assert.True(compilation.References.Contains(meta), "Compilation references were expected to contain " + meta); 2908Assert.True(trees.Contains(await doc.GetSyntaxTreeAsync()), "trees list was expected to contain the syntax tree of doc"); 3087Assert.True(sol.ProjectIds.Any(), "Solution was expected to have projects"); 3117Assert.True(sol2.ContainsProject(pid2), "sol2 was expected to contain project " + pid2); 3119Assert.True(sol2.GetProject(pid2).AllProjectReferences.Any(r => r.ProjectId == pid), "sol2 project pid2 was expected to contain project reference " + pid); 3142Assert.True(sol2.ContainsProject(pid2), "sol2 was expected to contain project " + pid2); 3144Assert.True(sol2.GetProject(pid2).AllProjectReferences.Any(r => r.ProjectId == pid), "sol2 pid2 was expected to contain " + pid); 3148Assert.True(sol3.ContainsProject(pid), "sol3 was expected to contain " + pid); 3149Assert.True(sol3.ContainsProject(pid2), "sol3 was expected to contain " + pid2);

46Assert.True(false, "Should not get here because an exception should be thrown before this point."); 54Assert.True(false, "Should have returned in the catch block before this point.");

71Assert.True(0 == result, "Server failed to shut down properly");

52Assert.True(task.Execute(), "Task failed"); 56Assert.True(File.Exists(actualFile), "Actual file does not exist");

64Assert.True(exists, $"File should exist: {target}");

172Assert.True((actual == null) == expected.IsDefault, message); 184Assert.True((expected == null) == actual.IsDefault, message); 269Assert.True(result, message); 276Assert.True(expectedSet.SetEquals(actual), string.Format("Expected: {0}\nActual: {1}", ToString(expected), ToString(actual))); 284Assert.True(none, string.Format( 294Assert.True(any, string.Format("No expected item was found.\nExisting items: {0}", ToString(actual))); 302Assert.True(all, string.Format( 335Assert.True(AssertEqualityComparer<T>.IsNull(@object), message);

373Assert.True(_error.ToString().Contains("Aborting to avoid conflicts."), "Should have aborted to avoid conflicts");

38Assert.True(firstWriteTime < secondWriteTime, $"File wasn't updated! {firstWriteTime} {secondWriteTime}"); 68Assert.True(firstWriteTime < secondWriteTime, $"File wasn't updated! {firstWriteTime} {secondWriteTime}");

111Assert.True(string.IsNullOrEmpty(_error.ToString()), $"Threw error: {_error}");

95 var ex = Record.Exception(() => Assert.True(false, "Custom User Message"));

810Assert.True(totalSchemaNodes > 0, "TransformSchema was not invoked."); 886Assert.True(DeepEquals(element1, element2), $"""

176Assert.True(

185Assert.True(response.Text.IndexOf("net", StringComparison.OrdinalIgnoreCase) >= 0, response.Text); 203Assert.True(response.Text.IndexOf("hello", StringComparison.OrdinalIgnoreCase) >= 0, response.Text); 425Assert.True(

12Assert.True(result.ExitCode == 0, $"Expected an exit code of zero, got {result.ExitCode}"); 19Assert.True(string.IsNullOrWhiteSpace(standardError), $"Standard error output was unexpectedly non-empty:\n{standardError}");

441Assert.True(DeepEquals(element1, element2), $"""

54Assert.True(cacheItem.NeedsEvictionCallback, "should be pooled memory"); 212Assert.True(cacheItem.NeedsEvictionCallback, "should be pooled memory");

18Assert.True(work, "we didn't expect this to be invoked");

457Assert.True(key.Equals(key), "typed equality self"); 458Assert.True(key.Equals((object)key), "object equality self");

40Assert.True(Source.IsEnabled(), "should report as enabled"); 144Assert.True(_counters.TryGetValue(name, out var pair), $"counter not found: {name}");

21Assert.True(validationResult.Failed, "Validator passed when it should fail."); 42Assert.True(validationResult.Failed, validationResult.FailureMessage);

76Assert.True(changed.WaitOne(AsyncTestHelper.UnexpectedTimeout), "FileLoader ChangeToken didn't fire before the allotted time.");

55Assert.True(changed.WaitOne(AsyncTestHelper.UnexpectedTimeout), "UriLoader ChangeToken didn't fire before the allotted time.");

496Assert.True(true, "Yay, we didn't enter an infinite loop!");

139Assert.True(expected.Id == actual.Id, 142Assert.True(expectedSpan.Equals(actual.Location.SourceSpan), 166Assert.True(expected.Id == d.Id, 169Assert.True(expectedSpan.Equals(d.Location.SourceSpan),

28Assert.True(descriptor.IsEnabledByDefault, descriptor.Id + " should be enabled by default");

139Assert.True(expected.Id == actual.Id, 142Assert.True(expectedSpan.Equals(actual.Location.SourceSpan), 166Assert.True(expected.Id == d.Id, 169Assert.True(expectedSpan.Equals(d.Location.SourceSpan),

29Assert.True(descriptor.IsEnabledByDefault, descriptor.Id + " should be enabled by default");

139Assert.True(expected.Id == actual.Id, 142Assert.True(expectedSpan.Equals(actual.Location.SourceSpan), 166Assert.True(expected.Id == d.Id, 169Assert.True(expectedSpan.Equals(d.Location.SourceSpan),

139Assert.True(expected.Id == actual.Id, 142Assert.True(expectedSpan.Equals(actual.Location.SourceSpan), 166Assert.True(expected.Id == d.Id, 169Assert.True(expectedSpan.Equals(d.Location.SourceSpan),

28Assert.True(descriptor.IsEnabledByDefault, descriptor.Id + " should be enabled by default");

139Assert.True(expected.Id == actual.Id, 142Assert.True(expectedSpan.Equals(actual.Location.SourceSpan), 166Assert.True(expected.Id == d.Id, 169Assert.True(expectedSpan.Equals(d.Location.SourceSpan),

139Assert.True(expected.Id == actual.Id, 142Assert.True(expectedSpan.Equals(actual.Location.SourceSpan), 166Assert.True(expected.Id == d.Id, 169Assert.True(expectedSpan.Equals(d.Location.SourceSpan),

682Assert.True(containsMessage,

59Assert.True(summary.Reports.Any(), "The \"Summary\" should contain at least one \"BenchmarkReport\" in the \"Reports\" collection"); 61Assert.True(summary.Reports.All(r => r.BuildResult.IsBuildSuccess), 65Assert.True(summary.Reports.All(r => r.ExecuteResults != null), 69Assert.True(summary.Reports.All(r => r.ExecuteResults.Any(er => er.FoundExecutable && er.Results.Any())), 72Assert.True(summary.Reports.All(report => report.AllMeasurements.Any()),

27Assert.True(fileSource.Count == 2, $"Error passing multiple paths to {nameof(MultiFileSource)}"); 39Assert.True(fileSource.Count == 2, $"Error passing concatenated paths to {nameof(MultiFileSource)}"); 42Assert.True(fileSource.Count == 2, $"Error passing concatenated paths to {nameof(MultiFileSource)}"); 74Assert.True(fileSource.Count == 2, $"Error passing concatenated paths to {nameof(MultiFileSource)}"); 77Assert.True(fileSource.Count == 2, $"Error passing concatenated paths to {nameof(MultiFileSource)}");

33Assert.True(caught, "Exception was not caught at all"); 45Assert.True(caught, "Exception was not caught at all");

1632Assert.True(scoreCol.HasValue, "Data scored with binary ensemble does not have a score column"); 1634Assert.True(type is TextDataViewType, "Binary ensemble scored data does not have correct type of metadata."); 1637Assert.True(ReadOnlyMemoryUtils.EqualsStr(AnnotationUtils.Const.ScoreColumnKind.BinaryClassification, kind), 1641Assert.True(scoreCol.HasValue, "Data scored with regression ensemble does not have a score column"); 1643Assert.True(type is TextDataViewType, "Regression ensemble scored data does not have correct type of metadata."); 1645Assert.True(ReadOnlyMemoryUtils.EqualsStr(AnnotationUtils.Const.ScoreColumnKind.Regression, kind), 1649Assert.True(scoreCol.HasValue, "Data scored with anomaly detection ensemble does not have a score column"); 1651Assert.True(type is TextDataViewType, "Anomaly detection ensemble scored data does not have correct type of metadata."); 1653Assert.True(ReadOnlyMemoryUtils.EqualsStr(AnnotationUtils.Const.ScoreColumnKind.AnomalyDetection, kind),

765Assert.True(b.IsDense, "Result was not dense, as expected"); 796Assert.True(b.IsDense || !a.IsDense, "Density of a did not imply density of b"); 809Assert.True(bIndices.Remove(i), $"Slot {i} not explicitly represented"); 813Assert.True(aIndices.SetEquals(bIndices), "Indices disagreed on explicit representation"); 1040Assert.True(result, $"Value [{i}] mismatch on expected {expected.GetValues()[i]} vs. actual {actual.GetValues()[i]}");

78Assert.True(typeof(T) == type.ItemType.RawType, $"{desc} had wrong type for slot cursor"); 79Assert.True(type.Size > 0, $"{desc} expected to be known sized vector but is not"); 81Assert.True(0 != valueCount, $"{desc} expected to have fixed size, but does not"); 93Assert.True(offset < vals.Length, $"{desc} slot cursor went further than it should have"); 95Assert.True(rc == temp.Length, $"{desc} slot cursor yielded vector with unexpected length"); 99Assert.True(valueCount == offset / rc, $"{desc} slot cursor yielded fewer than expected values"); 188Assert.True(trueIndex == index, $"Transpose schema had column '{names[i]}' at unexpected index");

1236Assert.True(row < rows, "row cursor cursor returned more rows than expected");

164Assert.True(d.IsCompatibleWith(p), $"Mismatch on {p.Name}, there was a mismatch, or some unexpected annotations was present."); 168Assert.True(p.IsCompatibleWith(d), $"Mismatch on {p.Name}, something was promised in the annotations but not delivered.");

90Assert.True(sch1.Count == sch2.Count, $"column count mismatch: {sch1.Count} vs {sch2.Count}"); 96Assert.True(name1 == name2, $"column name mismatch at index {col}: {name1} vs {name2}"); 100Assert.True(EqualTypes(type1, type2, exactTypes), $"column type mismatch at index {col}"); 108Assert.True(f1, "TryGetColumnIndex unexpectedly failed"); 109Assert.True(f2, "TryGetColumnIndex unexpectedly failed"); 110Assert.True(col1 == col2, $"TryGetColumnIndex on '{name1}' produced different results: '{col1}' vs '{col2}'"); 250Assert.True(EqualTypes(t1, t2, exactTypes), $"Different {kind} metadata types: {t1} vs {t2}"); 260Assert.True((int)size == t1.GetVectorSize(), $"{kind} metadata type wrong size: {t1.GetVectorSize()} vs {size}"); 264Assert.True(CompareVec(in names1, in names2, (int)size, (a, b) => a.Span.SequenceEqual(b.Span)), $"Different {kind} metadata values");

65Assert.True(onnxOut.Count == 3, "Output missing data.");

504Assert.True(idsTest1.Count() > 0, $"CV Split 0 for Column {colname} was empty"); 505Assert.True(idsTest2.Count() > 0, $"CV Split 1 for Column {colname} was empty");

1416Assert.True(threwException, "Invalid file should have thrown an exception");

67Assert.True(encoding.Count >= splitParts.Length, $"Expected to have {encoding.Count} >= {splitParts.Length}");

15Assert.True(cacheControl.NoCache, "NoCache"); 17Assert.True(cacheControl.NoStore, "NoStore"); 19Assert.True(cacheControl.MaxStale, "MaxStale"); 21Assert.True(cacheControl.NoTransform, "NoTransform"); 23Assert.True(cacheControl.OnlyIfCached, "OnlyIfCached"); 25Assert.True(cacheControl.Public, "Public"); 27Assert.True(cacheControl.Private, "Private"); 29Assert.True(cacheControl.MustRevalidate, "MustRevalidate"); 31Assert.True(cacheControl.ProxyRevalidate, "ProxyRevalidate");

469Assert.True(contentDisposition1.Equals(contentDisposition4), "Different casing."); 470Assert.True(contentDisposition2.Equals(contentDisposition5), "Different casing in name."); 692Assert.True(ContentDispositionHeaderValue.TryParse(input, out var result), input);

20Assert.True(range.HasLength, "HasLength"); 40Assert.True(range.HasRange, "HasRange"); 64Assert.True(range.HasRange, "HasRange"); 65Assert.True(range.HasLength, "HasLength"); 136Assert.True(range1.Equals(range4), "bytes 1-2/5 vs. BYTES 1-2/5"); 137Assert.True(range4.Equals(range1), "BYTES 1-2/5 vs. bytes 1-2/5");

44Assert.True(etag.IsWeak, "IsWeak"); 94Assert.True(etag1.Equals(etag5), "tag vs. tag..");

382Assert.True(mediaType1.Equals(mediaType4), "Different casing."); 383Assert.True(mediaType2.Equals(mediaType5), "Different casing in charset.");

220Assert.True(nameValue1.Equals(nameValue2), "<null> vs. <null>."); 236Assert.True(nameValue1.Equals(nameValue2), "<null> vs. string.Empty."); 240Assert.True(nameValue1.Equals(nameValue2), "token vs. TOKEN."); 244Assert.True(nameValue1.Equals(nameValue2), "token vs. token."); 252Assert.True(nameValue1.Equals(nameValue2), "\"quoted string\" vs. \"quoted string\"."); 262Assert.True(nameValue1.Equals(nameValue2), "text vs. TEXT.");

84Assert.True(rangeCondition1!.Equals(rangeCondition2), "\"x\" vs. \"x\""); 88Assert.True(rangeCondition3.Equals(rangeCondition5), "date vs. date");

81Assert.True(range1!.Equals(range2), "bytes=1-2 vs. BYTES=1-2"); 85Assert.True(range5.Equals(range6), "bytes=1-2,3-4 vs. bytes=3-4,1-2");

84Assert.True(rangeItem1.Equals(rangeItem5), "1-2 vs. 1-2."); 131Assert.True(RangeHeaderValue.TryParse("byte=" + input, out result), input); 145Assert.True(RangeHeaderValue.TryParse("byte=" + input, out result), input);

92Assert.True(value1!.Equals(value2), "t; q=0.123 vs. t; q=0.123"); 93Assert.True(value1.Equals(value3), "t; q=0.123 vs. T; q=0.123"); 99Assert.True(value4.Equals(value8), "t vs. T");

227Assert.True(testObject.Parent is CodeClass, testObject.Parent.GetType().ToString());

145Assert.True(assertMessage == "", assertMessage); 214Assert.True(isInException || _hasVerified, "No Verify call since the last AddGeneration call.");

328var converter = new PdbConverter(diagnostic => Assert.True(false, diagnostic.ToString())); 593Assert.True(paddedPathLength >= 260, "Path should be at least MAX_PATH long"); 655Assert.True(methodStartTags.Length == 1, "There must be one and only one method start tag per test input.");

294Assert.True(set.Add(groupName), $"Group {groupName} doesn't have a unique name.");

138Assert.True(ex is OperationCanceledException, $"cancellationToken : {source.Token.IsCancellationRequested}/r/n{ex}");

80Assert.True(String.Equals(result, testString), String.Format(" Error: expected response from service: '{0}' Actual was: '{1}'", testString, result));

64Assert.True(result == testString, string.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 126Assert.True(expectHeaderSent, "Expect header should have been sent but wasn't");

78Assert.True(String.Equals(result, testString), 163Assert.True(exception.Message.ToLower().Contains(message), string.Format("Expected exception message to contain: '{0}', actual message is: '{1}'", message, exception.Message)); 202Assert.True(exception.Message.ToLower().Contains(paraMessage), string.Format("Expected exception message to contain: '{0}', actual: '{1}'", paraMessage, exception.Message));

53Assert.True(result == testString, String.Format("Error: expected response from service: '{0}' Actual was: '{1}'", testString, result)); 103Assert.True(errorBuilder.Length == 0, "Test case FAILED with errors: " + errorBuilder.ToString()); 142Assert.True(errorBuilder.Length == 0, "Test case FAILED with errors: " + errorBuilder.ToString()); 181Assert.True(errorBuilder.Length == 0, "Test case FAILED with errors: " + errorBuilder.ToString()); 220Assert.True(errorBuilder.Length == 0, "Test case FAILED with errors: " + errorBuilder.ToString()); 257Assert.True(myX509CertificateValidator.validateMethodWasCalled, "The Validate method of the X509CertificateValidator was NOT called."); 437Assert.True(expectHeaderSent, "Expect header should have been sent but wasn't"); 560Assert.True(myX509CertificateValidator.validateMethodWasCalled, "The Validate method of the X509CertificateValidator was NOT called.");

109Assert.True(communicationException != null, "Expected CommunicationException but no exception was thrown."); 110Assert.True(communicationException.GetType().Name == "SecurityNegotiationException",

67Assert.True(shouldCallSucceed, errorBuilder.ToString()); 88Assert.True(!shouldCallSucceed, errorBuilder.ToString()); 143Assert.True(shouldCallSucceed, errorBuilder.ToString()); 164Assert.True(!shouldCallSucceed, errorBuilder.ToString()); 229Assert.True(shouldCallSucceed, errorBuilder.ToString()); 248Assert.True(!shouldCallSucceed, errorBuilder.ToString());

103Assert.True(myX509CertificateValidator.validateMethodWasCalled, "The Validate method of the X509CertificateValidator was NOT called.");

108Assert.True(communicationException != null, "Expected CommunicationException but no exception was thrown."); 109Assert.True(communicationException.GetType().Name == "SecurityNegotiationException", 263Assert.True(guid == returnedGuid,

42Assert.True(exception.Message.Contains(Endpoints.Tcp_VerifyDNS_HostName), string.Format("Expected exception message contains: '{0}', actual: '{1}')", Endpoints.Tcp_VerifyDNS_HostName, exception.Message));

242Assert.True(watch.ElapsedMilliseconds >= 4985 && watch.ElapsedMilliseconds < 6000, 283Assert.True(String.Equals(testString, result), String.Format("Error: Expected test string: '{0}' but got '{1}'", testString, result)); 325Assert.True(String.Equals(testString, result), String.Format("Error: Expected test string: '{0}' but got '{1}'", testString, result)); 367Assert.True(String.Equals(testString, result), String.Format("Error: Expected test string: '{0}' but got '{1}'", testString, result)); 396Assert.True(success, "Test Scenario: NetTcp_TransportSecurity_String_Streamed_RoundTrips_WithSingleThreadedSyncContext timed-out."); 415Assert.True(success, "Test Scenario: NetTcp_TransportSecurity_Streamed_Async_RoundTrips_String_WithSingleThreadedSyncContext timed-out.");

77Assert.True(f.SequenceNum < Capacity, $"{i}");

43Assert.True(wasCalled, $"Expected {nameof(SocketTransportOptions.CreateBoundListenSocket)} to be called.");

73Assert.True(SslApplicationProtocol.Http2.Protocol.Span.SequenceEqual(tlsFeature.ApplicationProtocol.Span), 101Assert.True(SslApplicationProtocol.Http2.Protocol.Span.SequenceEqual(tlsFeature.ApplicationProtocol.Span),

71Assert.True(contentLength % bufferLength == 0, $"{nameof(contentLength)} sent must be evenly divisible by {bufferLength}."); 72Assert.True(bufferLength % 256 == 0, $"{nameof(bufferLength)} must be evenly divisible by 256"); 99Assert.True((byte)((total + i) % 256) == receivedBytes[i], "Data received is incorrect"); 569Assert.True(await requestStarted.WaitAsync(TestConstants.DefaultTimeout), "request should have started"); 574Assert.True(await connectionReadFin.WaitAsync(TestConstants.DefaultTimeout), "Connection close event should have been logged"); 584Assert.True(await connectionReset.WaitAsync(TestConstants.DefaultTimeout), "Connection reset event should have been logged");

1117Assert.True(totalReceived < totalBytes, $"{nameof(AssertStreamAborted)} Stream completed successfully.");

907Assert.True(g.Clip.IsInfinite(g), message + ".Clip.IsInfinite"); 917Assert.True(g.Transform.IsIdentity, message + ".Transform.IsIdentity");

27Assert.True(converter.GetStandardValuesSupported(), "standard values supported");

37Assert.True(_icoConv.CanConvertFrom(typeof(byte[])), "byte[] (no context)"); 38Assert.True(_icoConv.CanConvertFrom(null, typeof(byte[])), "byte[]"); 39Assert.True(_icoConv.CanConvertFrom(null, _iconBytes.GetType()), "_iconBytes.GetType()"); 50Assert.True(_icoConvFrmTD.CanConvertFrom(typeof(byte[])), "TD byte[] (no context)"); 51Assert.True(_icoConvFrmTD.CanConvertFrom(null, typeof(byte[])), "TD byte[]"); 52Assert.True(_icoConvFrmTD.CanConvertFrom(null, _iconBytes.GetType()), "TD _iconBytes.GetType()"); 67Assert.True(_icoConv.CanConvertTo(typeof(string)), "string (no context)"); 68Assert.True(_icoConv.CanConvertTo(null, typeof(string)), "string"); 69Assert.True(_icoConv.CanConvertTo(null, _iconStr.GetType()), "_iconStr.GetType()"); 70Assert.True(_icoConv.CanConvertTo(typeof(byte[])), "byte[] (no context)"); 71Assert.True(_icoConv.CanConvertTo(null, typeof(byte[])), "byte[]"); 72Assert.True(_icoConv.CanConvertTo(null, _iconBytes.GetType()), "_iconBytes.GetType()"); 73Assert.True(_icoConv.CanConvertTo(typeof(Image)), "Image (no context)"); 74Assert.True(_icoConv.CanConvertTo(null, typeof(Image)), "Image"); 75Assert.True(_icoConv.CanConvertTo(typeof(Bitmap)), "Bitmap (no context)"); 76Assert.True(_icoConv.CanConvertTo(null, typeof(Bitmap)), "Bitmap"); 85Assert.True(_icoConvFrmTD.CanConvertTo(typeof(string)), "TD string (no context)"); 86Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(string)), "TD string"); 87Assert.True(_icoConvFrmTD.CanConvertTo(null, _iconStr.GetType()), "TD _iconStr.GetType()"); 88Assert.True(_icoConvFrmTD.CanConvertTo(typeof(byte[])), "TD byte[] (no context)"); 89Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(byte[])), "TD byte[]"); 90Assert.True(_icoConvFrmTD.CanConvertTo(null, _iconBytes.GetType()), "TD _iconBytes.GetType()"); 91Assert.True(_icoConvFrmTD.CanConvertTo(typeof(Image)), "TD Image (no context)"); 92Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(Image)), "TD Image"); 93Assert.True(_icoConvFrmTD.CanConvertTo(typeof(Bitmap)), "TD Bitmap (no context)"); 94Assert.True(_icoConvFrmTD.CanConvertTo(null, typeof(Bitmap)), "TD Bitmap");

844Assert.True(count is 7 or 5, $"count was {count}, expected 5 or 7");

61Assert.True(_imgConv.CanConvertFrom(typeof(byte[])), "byte[] (no context)"); 62Assert.True(_imgConv.CanConvertFrom(null, typeof(byte[])), "byte[]"); 63Assert.True(_imgConv.CanConvertFrom(null, _imageBytes.GetType()), "_imageBytes.GetType()"); 64Assert.True(_imgConv.CanConvertFrom(typeof(Icon)), "Icon (no context)"); 65Assert.True(_imgConv.CanConvertFrom(null, typeof(Icon)), "Icon"); 76Assert.True(_imgConvFrmTD.CanConvertFrom(typeof(byte[])), "TD byte[] (no context)"); 77Assert.True(_imgConvFrmTD.CanConvertFrom(null, typeof(byte[])), "TD byte[]"); 78Assert.True(_imgConvFrmTD.CanConvertFrom(null, _imageBytes.GetType()), "TD _imageBytes.GetType()"); 93Assert.True(_imgConv.CanConvertTo(typeof(string)), "stirng (no context)"); 94Assert.True(_imgConv.CanConvertTo(null, typeof(string)), "string"); 95Assert.True(_imgConv.CanConvertTo(null, _imageStr.GetType()), "_imageStr.GetType()"); 96Assert.True(_imgConv.CanConvertTo(typeof(byte[])), "byte[] (no context)"); 97Assert.True(_imgConv.CanConvertTo(null, typeof(byte[])), "byte[]"); 98Assert.True(_imgConv.CanConvertTo(null, _imageBytes.GetType()), "_imageBytes.GetType()"); 107Assert.True(_imgConvFrmTD.CanConvertTo(typeof(string)), "TD string (no context)"); 108Assert.True(_imgConvFrmTD.CanConvertTo(null, typeof(string)), "TD string"); 109Assert.True(_imgConvFrmTD.CanConvertTo(null, _imageStr.GetType()), "TD _imageStr.GetType()"); 110Assert.True(_imgConvFrmTD.CanConvertTo(typeof(byte[])), "TD byte[] (no context)"); 111Assert.True(_imgConvFrmTD.CanConvertTo(null, typeof(byte[])), "TD byte[]"); 112Assert.True(_imgConvFrmTD.CanConvertTo(null, _imageBytes.GetType()), "TD _imageBytes.GetType()"); 219Assert.True(_imgConv.GetPropertiesSupported(), "GetPropertiesSupported()"); 220Assert.True(_imgConv.GetPropertiesSupported(null), "GetPropertiesSupported(null)");

29Assert.True(_imgFmtConv.CanConvertFrom(typeof(string)), "string (no context)"); 30Assert.True(_imgFmtConv.CanConvertFrom(null, typeof(string)), "string"); 36Assert.True(_imgFmtConvFrmTD.CanConvertFrom(typeof(string)), "TD string (no context)"); 37Assert.True(_imgFmtConvFrmTD.CanConvertFrom(null, typeof(string)), "TD string"); 47Assert.True(_imgFmtConv.CanConvertTo(typeof(string)), "string (no context)"); 48Assert.True(_imgFmtConv.CanConvertTo(null, typeof(string)), "string"); 54Assert.True(_imgFmtConvFrmTD.CanConvertTo(typeof(string)), "TD string (no context)"); 55Assert.True(_imgFmtConvFrmTD.CanConvertTo(null, typeof(string)), "TD string"); 160Assert.True(_imgFmtConv.GetStandardValuesSupported(), "GetStandardValuesSupported()"); 161Assert.True(_imgFmtConv.GetStandardValuesSupported(null), "GetStandardValuesSupported(null)"); 228Assert.True(memorybmp, "MemoryBMP"); 229Assert.True(bmp, "Bmp"); 230Assert.True(emf, "Emf"); 231Assert.True(wmf, "Wmf"); 232Assert.True(gif, "Gif"); 233Assert.True(jpeg, "Jpeg"); 234Assert.True(png, "Png"); 235Assert.True(tiff, "Tiff"); 236Assert.True(exif, "Exif"); 237Assert.True(icon, "Icon"); 239Assert.True(heif, "Heif"); 240Assert.True(webp, "Webp");

194Assert.True(validValues.Contains(printerSettings.LandscapeAngle), $"PrinterSettings.LandscapeAngle ({printerSettings.LandscapeAngle}) must be 0, 90, or 270 degrees."); 201Assert.True(printerSettings.MaximumCopies >= 0, $"PrinterSettings.MaximumCopies ({printerSettings.MaximumCopies}) should not be negative.");

40Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, new XmlDictionaryReaderQuotas()), "XmlDictionaryReaderQuotas"); 65Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, new XmlDictionaryReaderQuotas()), "XmlDictionaryReaderQuotas"); 89Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, new XmlDictionaryReaderQuotas()), "XmlDictionaryReaderQuotas"); 210Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, maxQuota), "Setting Max ReaderQuota failed");

38Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, new XmlDictionaryReaderQuotas()), "XmlDictionaryReaderQuotas"); 63Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, new XmlDictionaryReaderQuotas()), "XmlDictionaryReaderQuotas"); 200Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, maxQuota), "Setting Max ReaderQuota failed");

25Assert.True(securityBindingElement == null, string.Format("securityBindingElement should be null when BasicHttpSecurityMode is '{0}'", securityMode)); 27Assert.True(binding.CanBuildChannelFactory<IRequestChannel>(), string.Format("CanBuildChannelFactory should return true for BasicHttpSecurityMode:'{0}'", securityMode));

19Assert.True(String.Equals(element.Scheme, "net.tcp"), String.Format("Scheme property expected '{0}' but actual was '{1}'", "net.tcp", element.Scheme)); 23Assert.True(element.ConnectionPoolSettings != null, "ConnectionPoolSettings should not be null.");

16Assert.True(msot != null, "MessageSecurityOverTcp default ctor failed"); 50Assert.True(actual == credentialType,

24Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, new XmlDictionaryReaderQuotas()), "XmlDictionaryReaderQuotas");

19Assert.True(transport.ClientCredentialType == TcpClientCredentialType.Windows,

45Assert.True(String.Equals(testMessageBody, result), 48Assert.True(TestOperationBehaviorAttribute.operationBehaviorSet, "TestOperationBehavior attribute on IBehaviorExtensionServerInterface.Process operation should have triggered ApplyClientBehavior() call"); 79Assert.True(String.Equals(testMessageBody, result), 82Assert.True(TestContractBehaviorAttribute.contractBehaviorSet, "TestContractBehavior attribute on IBehaviorExtensionServerInterface2 constract should have triggered ApplyClientBehavior() call");

24Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(bindingElement.ReaderQuotas, new XmlDictionaryReaderQuotas()),

35Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 41Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 71Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 77Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 99Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 103Assert.True(mco.State == CommunicationState.Closed, 127Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 133Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 162Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 168Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 188Assert.True(data.StateAfterCreate == CommunicationState.Created, 192Assert.True(data.StateEnterOnOpening == CommunicationState.Opening, 195Assert.True(data.StateLeaveOnOpening == CommunicationState.Opening, 199Assert.True(data.StateEnterOnOpen == CommunicationState.Opening, 202Assert.True(data.StateLeaveOnOpen == CommunicationState.Opening, 206Assert.True(data.StateEnterOnOpened == CommunicationState.Opening, 209Assert.True(data.StateLeaveOnOpened == CommunicationState.Opened, 213Assert.True(data.StateEnterOnClosing == CommunicationState.Closing, 216Assert.True(data.StateLeaveOnClosing == CommunicationState.Closing, 220Assert.True(data.StateEnterOnClose == CommunicationState.Closing, 223Assert.True(data.StateLeaveOnClose == CommunicationState.Closing, 227Assert.True(data.StateEnterOnClosed == CommunicationState.Closing, 230Assert.True(data.StateLeaveOnClosed == CommunicationState.Closed, 255Assert.True(data.StateAfterCreate == CommunicationState.Created, 259Assert.True(data.StateEnterOnOpening == CommunicationState.Opening, 262Assert.True(data.StateLeaveOnOpening == CommunicationState.Opening, 266Assert.True(data.StateEnterOnBeginOpen == CommunicationState.Opening, 269Assert.True(data.StateLeaveOnBeginOpen == CommunicationState.Opening, 273Assert.True(data.StateEnterOnOpened == CommunicationState.Opening, 276Assert.True(data.StateLeaveOnOpened == CommunicationState.Opened, 280Assert.True(data.StateEnterOnClosing == CommunicationState.Closing, 283Assert.True(data.StateLeaveOnClosing == CommunicationState.Closing, 287Assert.True(data.StateEnterOnBeginClose == CommunicationState.Closing, 290Assert.True(data.StateLeaveOnBeginClose == CommunicationState.Closing, 294Assert.True(data.StateEnterOnClosed == CommunicationState.Closing, 297Assert.True(data.StateLeaveOnClosed == CommunicationState.Closed, 322Assert.True(String.Equals(exceptionMessage, actualException.Message), 349Assert.True(String.Equals(exceptionMessage, actualException.Message), 376Assert.True(String.Equals(exceptionMessage, actualException.Message), 407Assert.True(String.Equals(exceptionMessage, actualException.Message),

75Assert.True(String.Equals(testMessageBody, result), 82Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 87Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 92Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 97Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 101Assert.True(factory.State == CommunicationState.Closed, 104Assert.True(((ICommunicationObject)channel).State == CommunicationState.Closed, 172Assert.True(String.Equals(testMessageBody, result), 179Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 184Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 189Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 194Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 198Assert.True(factory.State == CommunicationState.Closed, 201Assert.True(((ICommunicationObject)channel).State == CommunicationState.Closed, 251Assert.True(String.Equals(expectedExceptionMessage, actualException.Message), 306Assert.True(String.Equals(expectedExceptionMessage, actualException.Message), 365Assert.True(String.Equals(testMessageBody, result), 372Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 377Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 382Assert.True(String.Equals(expectedOpens, actualOpens, StringComparison.Ordinal), 387Assert.True(String.Equals(expectedCloses, actualCloses, StringComparison.Ordinal), 391Assert.True(factory.State == CommunicationState.Closed, 394Assert.True(((ICommunicationObject)channel).State == CommunicationState.Closed, 433Assert.True(initializeCalled, "Initialize was not called."); 471Assert.True(String.Equals(caughtException.Message, thrownException.Message), 523Assert.True(beginInitializeCalled, "BeginDisplayInitializationUI was not called."); 524Assert.True(endInitializeCalled, "EndDisplayInitializationUI was not called."); 574Assert.True(beginInitializeCalled, "BeginDisplayInitializationUI was not called."); 575Assert.True(endInitializeCalled, "EndDisplayInitializationUI was not called."); 725Assert.True(string.Equals(thrownException.Message, caughtException.Message),

70Assert.True(results == null, results); 126Assert.True(results == null, results); 166Assert.True(results == null, results); 189Assert.True(operation != null, "Failed to find Hello operation in contract."); 190Assert.True(operation.IsOneWay, "Expected Hello operation to be IsOneWay."); 193Assert.True(operation != null, "Failed to find Reply operation in contract."); 194Assert.True(operation.IsOneWay, "Expected Reply operation to be IsOneWay.");

37Assert.True(MyOperationBehavior.errorBuilder.Length == 0, "Test case FAILED with errors: " + MyOperationBehavior.errorBuilder.ToString()); 38Assert.True(waitAll, "None of the IOperationBehavior methods were called.");

21Assert.True(oca.IsInitiating, "IsInitiating should have been true"); 22Assert.True(!oca.IsTerminating, "IsTerminating should have been false");

39Assert.True(typeof(IRequestChannel).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), 43Assert.True(typeof(IRequestChannel).GetTypeInfo().IsAssignableFrom(channel2.GetType().GetTypeInfo()), 96Assert.True(typeof(IRequestChannel).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), 100Assert.True(typeof(IRequestChannel).GetTypeInfo().IsAssignableFrom(channel2.GetType().GetTypeInfo()), 152Assert.True(typeof(IRequestChannel).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), 196Assert.True(typeof(IWcfServiceGenerated).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), 218Assert.True(CommunicationState.Created == factory.State, 222Assert.True(CommunicationState.Opened == factory.State, 226Assert.True(CommunicationState.Closed == factory.State, 257Assert.True(allowCookies == (cookieManager != null), 262Assert.True(allowCookies == (cookieManager.CookieContainer != null),

109Assert.True(exception.Message.Contains("BasicHttpBinding"), 229Assert.True(typeof(IWcfDuplexService).GetTypeInfo().IsAssignableFrom(channel.GetType().GetTypeInfo()), 233Assert.True(typeof(IWcfDuplexService).GetTypeInfo().IsAssignableFrom(channel2.GetType().GetTypeInfo()),

22Assert.True(collection.Count == 2, $"Expected the collection to contain 2 items, instead it contained '{collection.Count}' items."); 28Assert.True(myCollection.Count == 2, $"Expected the collection to contain 2 items of type 'IMyExtension', instead it contained: '{myCollection.Count}' items.");

35Assert.True(String.Equals(name, attribute.Name), 137Assert.True(results == null, results); 214Assert.True(hasProperty, String.Format("Expected message property '{0}'", TestTypeConstants_4_4_0.MessageContract_Request_PropertyName)); 215Assert.True(String.Equals(request.requestTestProperty, propertyValue), 293Assert.True(String.Equals(request.requestTestProperty, reply.requestTestProperty), 305Assert.True(hasHeader, String.Format("Expected header '{0}'", name)); 314Assert.True(values.Length == headerValues.Count, 319Assert.True(headerValues.Contains(value), 327Assert.True(array2 != null, 330Assert.True(array1.Length == array2.Length, 336Assert.True(array1[i] == array2[i],

22Assert.True(messageCA.WrapperName == null, "WrapperName should be null"); 23Assert.True(messageCA.WrapperNamespace == null, "WrapperNamespace should be null");

21Assert.True(coll.Count == size, string.Format("collection count was wrong! Expected: {0} got: {1}", size, coll.Count)); 25Assert.True(coll[i] == i, string.Format("coll element {0} was wrong! Expected: {1} got: {2} ", i, i, coll[i])); 26Assert.True(coll.IndexOf(i) == i, string.Format("coll IndexOf wasn't right! Expected: {0} got: {1}" , i, coll.IndexOf(i))); 27Assert.True(coll.Contains(i), string.Format("coll Contains failed to find the value {0}.", i)); 33Assert.True(coll2[i] == i, string.Format("coll2 element was wrong! expected: {0} got: {1} ", i, coll2[i])); 39Assert.True(coll3[i] == i + 1, string.Format("coll3 element {0} was wrong! expected: {1} got: {2}", i, i+1, coll3[i])); 49Assert.True(e.Current.Equals(n++), string.Format("Expected: {0}, got:{1}", n-1, e.Current)); 52Assert.True(n == 100, string.Format("Expect number of elements: {0}, got:{1}", 100, n)); 58Assert.True(array[i + 1] == i, string.Format("After CopyTo, Element {0} was wrong! Expected: {1} got: {2}", i, i+1, array[i + 1])); 65Assert.True(coll.Count == size, string.Format("Expect number of elements after modification: {0}, got: {1}", size, coll.Count)); 69Assert.True(coll[i] == i, string.Format("coll element was wrong after modification! Expected: {0} got: {1} ", i, coll[i])); 73Assert.True(coll.Count == 0, string.Format("Clear operation failed!, expected: 0, actual {0}", coll.Count));

19Assert.True(String.Equals(element.Scheme, "net.uds"), String.Format("Scheme property expected '{0}' but actual was '{1}'", "net.uds", element.Scheme)); 23Assert.True(element.ConnectionPoolSettings != null, "ConnectionPoolSettings should not be null.");

25Assert.True(TestHelpers.XmlDictionaryReaderQuotasAreEqual(binding.ReaderQuotas, new XmlDictionaryReaderQuotas()), "XmlDictionaryReaderQuotas");

19Assert.True(transport.ClientCredentialType == UnixDomainSocketClientCredentialType.Default,

24Assert.True(forwardedTypes.Contains(designer.FullName), $"{designer.FullName} must be type forwarded");

37Assert.True(forwardedTypes.Contains(editor.FullName), $"{editor.FullName} must be type forwarded");

21Assert.True(File.Exists(resxFileName), $@"RESX file ""{resxFileName}"" not found, make sure it's in the root folder of the unit test project"); 41Assert.True(File.Exists(resxFileName), $@"RESX file ""{resxFileName}"" not found, make sure it's in the root folder of the unit test project");

31Assert.True(ex is null, $"Expected no exception, but got: {ex.Message}"); // Actually need to check whether GC.Collect() does not throw exception.

100Assert.True(Application.UseVisualStyles, "New Visual Styles will not be applied on WinForms app. This is a high priority bug and must be looked into");

368Assert.True(type == typeof(DataGridViewBand) || type == typeof(DataGridViewColumn) ||

3957Assert.True(foundTypeForward, "Did not find TypeForwardedAttribute.");

127Assert.True(control.Renderer is ToolStripSystemRenderer or ToolStripProfessionalRenderer, "Renderer is not one of the expected types.");

361Assert.True(InputLanguage.CurrentInputLanguage.LayoutName == "US", "Please, switch to the US input language");

110Assert.True(File.Exists(Path.Combine(publishDir, "service-worker.js")), "service-worker.js should be published"); 111Assert.True(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "service-worker-assets.js should be published"); 130Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}"); 168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 173Assert.True(string.Equals(anchor.Href, expectedLink), $"Expected next link to be {expectedLink} but it was {anchor.Href}."); 185Assert.True(IsSuccessStatusCode(result), $"{anchor.Href} is a broken link!"); 276Assert.True(statusCode == response.StatusCode, $"Expected {requestUrl} to have status '{statusCode}' but it was '{response.StatusCode}'.");

110Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

28Assert.True(await Semaphore.WaitAsync(timeout.Value), $"Unable to acquire process lock for process {Name}");

126Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create", this, createResult)); 144Assert.True(0 == restoreResult.ExitCode, ErrorMessages.GetFailedProcessMessage("restore", this, restoreResult)); 170Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", this, result)); 193Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("build", this, result)); 244Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", this, processResult)); 264Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", this, processResult)); 304Assert.True(doesExist, "Expected file to exist, but it doesn't: " + path); 424Assert.True(result.ExitCode == 0, result.GetFormattedOutput()); 534Assert.True(File.Exists(sourceFile), $"Log for '{ProjectName}' not found in '{sourceFile}'. Execution output: {result.Output}");

111Assert.True(result.ExitCode == 0, result.GetFormattedOutput());

162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}"); 168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 173Assert.True(string.Equals(anchor.Href, expectedLink), $"Expected next link to be {expectedLink} but it was {anchor.Href}."); 185Assert.True(IsSuccessStatusCode(result), $"{anchor.Href} is a broken link!"); 276Assert.True(statusCode == response.StatusCode, $"Expected {requestUrl} to have status '{statusCode}' but it was '{response.StatusCode}'.");

110Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

28Assert.True(await Semaphore.WaitAsync(timeout.Value), $"Unable to acquire process lock for process {Name}");

126Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create", this, createResult)); 144Assert.True(0 == restoreResult.ExitCode, ErrorMessages.GetFailedProcessMessage("restore", this, restoreResult)); 170Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", this, result)); 193Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("build", this, result)); 244Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", this, processResult)); 264Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", this, processResult)); 304Assert.True(doesExist, "Expected file to exist, but it doesn't: " + path); 424Assert.True(result.ExitCode == 0, result.GetFormattedOutput()); 534Assert.True(File.Exists(sourceFile), $"Log for '{ProjectName}' not found in '{sourceFile}'. Execution output: {result.Output}");

111Assert.True(result.ExitCode == 0, result.GetFormattedOutput());

39=> WaitAssertCore(driver, () => Assert.True(actual(), message), timeout);

162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}"); 168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 173Assert.True(string.Equals(anchor.Href, expectedLink), $"Expected next link to be {expectedLink} but it was {anchor.Href}."); 185Assert.True(IsSuccessStatusCode(result), $"{anchor.Href} is a broken link!"); 276Assert.True(statusCode == response.StatusCode, $"Expected {requestUrl} to have status '{statusCode}' but it was '{response.StatusCode}'.");

110Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

28Assert.True(await Semaphore.WaitAsync(timeout.Value), $"Unable to acquire process lock for process {Name}");

126Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create", this, createResult)); 144Assert.True(0 == restoreResult.ExitCode, ErrorMessages.GetFailedProcessMessage("restore", this, restoreResult)); 170Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", this, result)); 193Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("build", this, result)); 244Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", this, processResult)); 264Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", this, processResult)); 304Assert.True(doesExist, "Expected file to exist, but it doesn't: " + path); 424Assert.True(result.ExitCode == 0, result.GetFormattedOutput()); 534Assert.True(File.Exists(sourceFile), $"Log for '{ProjectName}' not found in '{sourceFile}'. Execution output: {result.Output}");

111Assert.True(result.ExitCode == 0, result.GetFormattedOutput());

39=> WaitAssertCore(driver, () => Assert.True(actual(), message), timeout);

313Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}"); 168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 173Assert.True(string.Equals(anchor.Href, expectedLink), $"Expected next link to be {expectedLink} but it was {anchor.Href}."); 185Assert.True(IsSuccessStatusCode(result), $"{anchor.Href} is a broken link!"); 276Assert.True(statusCode == response.StatusCode, $"Expected {requestUrl} to have status '{statusCode}' but it was '{response.StatusCode}'.");

110Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

28Assert.True(await Semaphore.WaitAsync(timeout.Value), $"Unable to acquire process lock for process {Name}");

126Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create", this, createResult)); 144Assert.True(0 == restoreResult.ExitCode, ErrorMessages.GetFailedProcessMessage("restore", this, restoreResult)); 170Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", this, result)); 193Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("build", this, result)); 244Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", this, processResult)); 264Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", this, processResult)); 304Assert.True(doesExist, "Expected file to exist, but it doesn't: " + path); 424Assert.True(result.ExitCode == 0, result.GetFormattedOutput()); 534Assert.True(File.Exists(sourceFile), $"Log for '{ProjectName}' not found in '{sourceFile}'. Execution output: {result.Output}");

111Assert.True(result.ExitCode == 0, result.GetFormattedOutput());

39=> WaitAssertCore(driver, () => Assert.True(actual(), message), timeout);

128Assert.True(doesExist, "Expected file to exist, but it doesn't: " + path);

106Assert.True(serverProcess.Process.HasExited, "built"); 124Assert.True(aspNetProcess.Process.HasExited, "published");

155Assert.True(response?.StatusCode == HttpStatusCode.OK, $"Couldn't find file '{file}'"); 164Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

162Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}"); 168Assert.True(anchor.PathName.EndsWith(expectedLink, StringComparison.Ordinal), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}: {html.Source.Text}"); 173Assert.True(string.Equals(anchor.Href, expectedLink), $"Expected next link to be {expectedLink} but it was {anchor.Href}."); 185Assert.True(IsSuccessStatusCode(result), $"{anchor.Href} is a broken link!"); 276Assert.True(statusCode == response.StatusCode, $"Expected {requestUrl} to have status '{statusCode}' but it was '{response.StatusCode}'.");

110Assert.True(doesExist, $"Expected file to exist, but it doesn't: {path}");

28Assert.True(await Semaphore.WaitAsync(timeout.Value), $"Unable to acquire process lock for process {Name}");

126Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create", this, createResult)); 144Assert.True(0 == restoreResult.ExitCode, ErrorMessages.GetFailedProcessMessage("restore", this, restoreResult)); 170Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", this, result)); 193Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("build", this, result)); 244Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", this, processResult)); 264Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", this, processResult)); 304Assert.True(doesExist, "Expected file to exist, but it doesn't: " + path); 424Assert.True(result.ExitCode == 0, result.GetFormattedOutput()); 534Assert.True(File.Exists(sourceFile), $"Log for '{ProjectName}' not found in '{sourceFile}'. Execution output: {result.Output}");

111Assert.True(result.ExitCode == 0, result.GetFormattedOutput());

39=> WaitAssertCore(driver, () => Assert.True(actual(), message), timeout);

113Assert.True(false, $"Expected:\r\n{expectedMetricsText}\r\n\r\nActual:\r\n{actualMetricsText}");

26Assert.True(false, message);

42Assert.True(false, "Should not reach compilation"); 86Assert.True(false, "Should not reach compilation when compilations are disallowed");