False

438 references to False

Binding.Http.IntegrationTests (1)

BasicHttpBindingTests.4.0.0.cs (1)

223Assert.False(expectHeaderSent, "Expect header should not have been sent. Header value:" + expectHeader);

Binding.Tcp.IntegrationTests (1)

OperationContextAsyncFlowTests.cs (1)

158Assert.False(asyncFlowDisabled, "DisableAsyncFlow should not be set to true");

Client.TypedClient.IntegrationTests (1)

TypedProxyTests.4.0.0.cs (1)

620Assert.False(opContextReference.TryGetTarget(out OperationContextExtension opContext), "OperationContextExtension should have been collected");

Contract.Message.IntegrationTests (2)

MessageContractTests.4.1.0.cs (2)

43Assert.False(reader.LocalName.Equals(wrapperName), 152Assert.False(header.MustUnderstand, "Expected MustUnderstand to be false, but it was true.");

dotnet-svcutil-lib.Tests (13)

E2ETests.cs (2)

48Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!"); 49Assert.False(options == null, $"{nameof(options)} not initialized!");

GlobalToolTests.cs (2)

18Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!"); 19Assert.False(options == null, $"{nameof(options)} not initialized!");

ProjectUtils.cs (3)

86Assert.False(string.IsNullOrEmpty(options), $"{nameof(options)} not initialized!"); 173Assert.False(string.IsNullOrEmpty(srcParamsFile), $"{nameof(srcParamsFile)} not initialized!"); 174Assert.False(string.IsNullOrEmpty(referenceFolderName), $"{nameof(referenceFolderName)} not initialized!");

TestInit.cs (3)

169Assert.False(string.IsNullOrEmpty(g_SvcutilNugetFeed), $"{nameof(g_SvcutilNugetFeed)} is not initialized!"); 170Assert.False(string.IsNullOrEmpty(g_SvcutilPkgVersion), $"{nameof(g_SvcutilPkgVersion)} is not initialized!"); 240Assert.False(string.IsNullOrWhiteSpace(testCaseName), $"{nameof(testCaseName)} is not initialized!");

UnitTest.cs (3)

19Assert.False(string.IsNullOrWhiteSpace(this_TestCaseName), $"{nameof(this_TestCaseName)} not initialized!"); 20Assert.False(options == null, $"{nameof(options)} not initialized!"); 274Assert.False(cmdOptions.Errors.Count() == 0 ^ expectSuccess, cmderrors);

IIS.ShadowCopy.Tests (4)

ShadowCopyTests.cs (4)

220Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "0")), "Expected 0 shadow copy directory to be skipped"); 262Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "0")), "Expected 0 shadow copy directory to be skipped"); 279Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "1")), "Expected 1 shadow copy directory to be deleted"); 280Assert.False(Directory.Exists(Path.Combine(directory.DirectoryPath, "3")), "Expected 3 shadow copy directory to be deleted");

InMemory.FunctionalTests (11)

ChunkedRequestTests.cs (6)

Http2\Http2StreamTests.cs (1)

3781Assert.False(ConnectionTags.ContainsKey(KestrelMetrics.ErrorTypeAttributeName), "Non-error reason shouldn't be added to error.type");

Http2\Http2TestBase.cs (1)

207Assert.False(context.Request.CheckTrailersAvailable(), "SupportsTrailers");

Http3\Http3ConnectionTests.cs (2)

115Assert.False(requestStream.Disposed, "Request is in progress and shouldn't be disposed."); 828Assert.False(requestStream.Disposed, "Request is in progress and shouldn't be disposed.");

HttpsConnectionMiddlewareTests.cs (1)

645Assert.False(

Interop.FunctionalTests (1)

Http3\Http3RequestTests.cs (1)

2162Assert.False(stopTask.IsCompleted, "Waiting for host which is wating for request.");

Microsoft.Arcade.Test.Common (1)

AssertEx.cs (1)

324Assert.False(AssertEqualityComparer<T>.IsNull(@object), message);

Microsoft.AspNetCore.Authentication.Negotiate.Test (12)

EventTests.cs (4)

446Assert.False(string.IsNullOrEmpty(name), "name"); 546Assert.False(Stage1Complete, nameof(Stage1Complete)); 557Assert.False(Stage1Complete, nameof(Stage1Complete)); 563Assert.False(Stage1Complete, nameof(Stage1Complete));

NegotiateHandlerTests.cs (8)

410Assert.False(context.User.Identity.IsAuthenticated, "Anonymous"); 417Assert.False(context.User.Identity.IsAuthenticated, "Anonymous"); 431Assert.False(string.IsNullOrEmpty(name), "name"); 445Assert.False(string.IsNullOrEmpty(name), "name"); 458Assert.False(string.IsNullOrEmpty(name), "name"); 570Assert.False(Stage1Complete, nameof(Stage1Complete)); 581Assert.False(Stage1Complete, nameof(Stage1Complete)); 587Assert.False(Stage1Complete, nameof(Stage1Complete));

Microsoft.AspNetCore.Components.Server.Tests (4)

Circuits\CircuitIdFactoryTest.cs (2)

66Assert.False(isValid, "Accepted an invalid payload"); 86Assert.False(isValid, "Accepted a tampered payload");

Circuits\CircuitRegistryTest.cs (2)

540Assert.False(registry.ConnectedCircuits.ContainsKey(circuitHost.CircuitId), "Circuit should not be in connected circuits."); 541Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId.Secret, out _), "Circuit should be evicted from disconnected circuits.");

Microsoft.AspNetCore.DataProtection.Extensions.Tests (2)

DataProtectionProviderTests.cs (2)

177Assert.False(certWithoutKey.HasPrivateKey, "Cert should not have private key"); 189Assert.False(certInStore.HasPrivateKey, "Cert should not have private key");

Microsoft.AspNetCore.DataProtection.Tests (2)

KeyManagement\XmlKeyManagerTests.cs (1)

551Assert.False(loggerFactory.ToString().Contains("1A2B3C4D"), "The secret '1A2B3C4D' should not have been logged.");

TypeForwardingActivatorTests.cs (1)

95Assert.False(forwarded, "Should not have forwarded types that are not in Microsoft.AspNetCore.DataProjection");

Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (2)

src\Identity\test\Shared\ApiConsistencyTestBase.cs (2)

29Assert.False( 52Assert.False(

Microsoft.AspNetCore.Identity.InMemory.Test (2)

src\Identity\test\Shared\ApiConsistencyTestBase.cs (2)

29Assert.False( 52Assert.False(

Microsoft.AspNetCore.Identity.Test (2)

src\Identity\test\Shared\ApiConsistencyTestBase.cs (2)

29Assert.False( 52Assert.False(

Microsoft.AspNetCore.InternalTesting.Tests (14)

MinimumOSVersionTest.cs (3)

18Assert.False( 29Assert.False( 68Assert.False(

OSSkipConditionTest.cs (11)

15Assert.False( 24Assert.False( 33Assert.False( 42Assert.False( 45Assert.False( 55Assert.False( 65Assert.False( 75Assert.False( 85Assert.False( 88Assert.False( 100Assert.False(

Microsoft.AspNetCore.Mvc.Core.Test (1)

ActionConstraints\HttpMethodActionConstraintTest.cs (1)

37Assert.False(result, "Request should have been rejected.");

Microsoft.AspNetCore.Mvc.Cors.Test (1)

CorsHttpMethodActionConstraintTest.cs (1)

53Assert.False(result, "Request should have been rejected.");

Microsoft.AspNetCore.Mvc.IntegrationTests (2)

ActionParametersIntegrationTest.cs (2)

834Assert.False(modelState.IsValid, "model is valid"); 879Assert.False(modelState.IsValid, "model is valid");

Microsoft.AspNetCore.Mvc.TagHelpers.Test (2)

CacheTagKeyTest.cs (2)

469Assert.False(equals, "CacheTagKeys must not be equal"); 501Assert.False(equals, "CacheTagKeys must not be equal");

Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (28)

Listener\ResponseBodyTests.cs (3)

46Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 70Assert.False(response.Content.Headers.TryGetValues("content-length", out contentLength), "Content-Length"); 95Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length");

Listener\ServerTests.cs (4)

72Assert.False(ct.CanBeCanceled, "CanBeCanceled"); 74Assert.False(ct.IsCancellationRequested, "IsCancellationRequested"); 76Assert.False(canceled.Task.IsCompleted, "canceled"); 95Assert.False(ct.IsCancellationRequested, "IsCancellationRequested");

OpaqueUpgradeTests.cs (2)

41Assert.False(response.Headers.TransferEncodingChunked.HasValue, "Chunked"); 69Assert.False(response.Headers.TransferEncodingChunked.HasValue, "Chunked");

RequestTests.cs (1)

398Assert.False(errorLogs.Any(), string.Join(" ", errorLogs));

ResponseBodyTests.cs (8)

36Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 123Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 155Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 180Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 202Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 338Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 366Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length"); 393Assert.False(response.Content.Headers.TryGetValues("content-length", out ignored), "Content-Length");

ResponseSendFileTests.cs (8)

ServerTests.cs (2)

286Assert.False(ct.IsCancellationRequested, "IsCancellationRequested"); 319Assert.False(ct.IsCancellationRequested, "IsCancellationRequested");

Microsoft.AspNetCore.Server.Kestrel.Core.Tests (2)

PipelineExtensionTests.cs (2)

91Assert.False(written.IsSingleSegment, "The buffer should cross spans"); 195Assert.False(written.IsSingleSegment, "The buffer should cross spans");

Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (2)

QuicConnectionListenerTests.cs (2)

93Assert.False(acceptTask2.IsCompleted, "Accept doesn't return for failed client connection."); 261Assert.False(acceptTask.IsCompleted, "Still waiting for non-errored connection.");

Microsoft.AspNetCore.TestHost.Tests (2)

ClientHandlerTests.cs (2)

323Assert.False(responseTask.IsCompleted, "HttpResponse.StartAsync does not return response"); 479Assert.False(readTask.IsCompleted, "Not Completed");

Microsoft.AspNetCore.WebUtilities.Tests (2)

FileBufferingReadStreamTests.cs (2)

419Assert.False(File.Exists(stream.TempFileName), "tempFile should not be created as yet"); 448Assert.False(File.Exists(stream.TempFileName), "tempFile should not be created as yet");

Microsoft.Build.Engine.OM.UnitTests (1)

Definition\DefinitionEditing_Tests.cs (1)

2604Assert.False(project.IsDirty, "project should not be dirty after item splitting threw exception");

Microsoft.Build.Engine.UnitTests (7)

BackEnd\MSBuild_Tests.cs (2)

1385Assert.False(success, "Iteration of i " + i + " Build Succeeded. See 'Standard Out' tab for details."); 1737Assert.False(success, "Iteration of i:" + i + "Build Succeeded. See 'Standard Out' tab for details.");

Definition\ToolsVersion_Tests.cs (4)

62Assert.False(taskRegistry.TaskRegistrations.ContainsKey(new TaskRegistry.RegisteredTaskIdentity(unexpectedRegisteredTask, null)), 68Assert.False(taskoverrideRegistry.TaskRegistrations.ContainsKey(new TaskRegistry.RegisteredTaskIdentity(unexpectedRegisteredTask, null)), 180Assert.False(taskRegistry.TaskRegistrations.ContainsKey(new TaskRegistry.RegisteredTaskIdentity(unexpectedRegisteredTask, null)), 205Assert.False(taskRegistry.TaskRegistrations.ContainsKey(new TaskRegistry.RegisteredTaskIdentity(unexpectedRegisteredTask, null)),

ExpressionTreeExpression_Tests.cs (1)

471Assert.False(tree.Evaluate(state), "expected false from '" + expression + "' and got true");

Microsoft.Build.Tasks.UnitTests (6)

MSBuild_Tests.cs (2)

1017Assert.False(success, "Iteration of i " + i + " Build Succeeded. See 'Standard Out' tab for details."); 1289Assert.False(success, "Iteration of i:" + i + "Build Succeeded. See 'Standard Out' tab for details.");

NativeMethodsShared_Tests.cs (1)

134Assert.False(Directory.Exists(nonexistentDirectory),

WriteCodeFragment_Tests.cs (1)

1156Assert.False(result, engine.Log);

XslTransformation_Tests.cs (2)

1019Assert.False(t.Execute(), "CompiledDllWithTwoTypes execution should've failed" + engine.Log); 1031Assert.False(t.Execute(), "CompiledDllWithTwoTypes execution should've failed" + engine.Log);

Microsoft.Build.Utilities.UnitTests (1)

NativeMethodsShared_Tests.cs (1)

134Assert.False(Directory.Exists(nonexistentDirectory),

Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (3)

CommandLineTests.cs (3)

6010Assert.False(result.ContainsErrors, $"Compilation error(s) occurred: {result.Output} {result.Errors}"); 6044Assert.False(result.ContainsErrors, $"Compilation error(s) occurred: {result.Output} {result.Errors}"); 6069Assert.False(result.ContainsErrors, $"Compilation error(s) occurred: {result.Output} {result.Errors}");

Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (14)

CodeActions\SyncNamespace\CSharpSyncNamespaceTestsBase.cs (2)

100Assert.False(renameFileAction, "Move File to match namespace code action was not expected, but shows up."); 214Assert.False(hasChangeNamespaceAction, "Change namespace to match folder action was not expected, but shows up.");

Completion\CompletionProviders\ObjectInitializerCompletionProviderTests.cs (1)

697Assert.False(CommitManager.SendEnterThroughToEditor(service.GetRules(CompletionOptions.Default), item, string.Empty), "Expected false from SendEnterThroughToEditor()");

RawStringLiteral\RawStringLiteralCommandHandlerTests.cs (1)

82Assert.False(handled, "Return key should have been handled");

SymbolKey\SymbolKeyTestBase.cs (1)

116Assert.False(ret, message);

Workspaces\WorkspaceTests_EditorFeatures.cs (9)

Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests (6)

EmbeddedLanguages\Json\CSharpJsonParserTests.cs (1)

342Assert.False(true, "Incorrect trivia kind");

EmbeddedLanguages\Json\CSharpJsonParserTests_NstTests.cs (1)

46Assert.False(true, "Unexpected test name.");

EmbeddedLanguages\RegularExpressions\CSharpRegexParserTests.cs (2)

145Assert.False(true, "Expected diagnostics: \r\n" + expectedDiagnostics.ToString().Replace(@"""", @"""""")); 286Assert.False(true, "Incorrect trivia kind");

Recommendations\RecommenderTests.cs (2)

74Assert.False(true, "Wanted keyword, but in non-user code position: " + KeywordText); 96Assert.False(true, "No recommender for: " + KeywordText);

Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (1)

Emit\EmitMetadataTests.cs (1)

1321Assert.False(accessor.IsImplicitlyDeclared, "MethodSymbol.IsImplicitlyDeclared should be false for auto property accessors");

Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (2)

Emit\RuntimeProbing\ModuleCancellationTests.cs (1)

39Assert.False(isInstrumented,

Emit\RuntimeProbing\StackOverflowProbingTests.cs (1)

32Assert.False(isInstrumented,

Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (2)

Attributes\AttributeTests_StructLayout.cs (1)

209Assert.False(expectedPack == 0 && expectedSize == 0, "Either expectedPack or expectedSize should be non-zero");

Diagnostics\GetDiagnosticsTests.cs (1)

467Assert.False(compilationStartedFired, "Unexpected multiple compilation stated events");

Microsoft.CodeAnalysis.CSharp.EndToEnd.UnitTests (1)

EndToEndTests.cs (1)

67Assert.False(true, exception.ToString());

Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (4)

Semantics\LookupPositionTests.cs (2)

3100Assert.False(keyPositionBuilder.Contains(position), "Duplicate position " + position); 3109Assert.False(keyPositionBuilder.Contains(position), "Duplicate position " + position);

Semantics\SemanticErrorTests.cs (2)

3345Assert.False(model.IsAccessible(callPosition, typeArgSymbol), "Protected inner class is inaccessible"); 3349Assert.False(model.IsAccessible(callPosition, typeArgSymbol), "Type should be inaccessible since type argument is inaccessible");

Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (30)

Compilation\CompilationAPITests.cs (1)

912Assert.False(withExpressionRootTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?");

Compilation\GetSemanticInfoTests.cs (16)

Compilation\SemanticModelGetSemanticInfoTests.cs (2)

10111Assert.False(SyntaxFacts.IsAttributeName(((SourceNamedTypeSymbol)((CSharp.Symbols.PublicModel.NamedTypeSymbol)semanticInfo.Symbol).UnderlyingNamedTypeSymbol).SyntaxReferences.First().GetSyntax()), 10148Assert.False(SyntaxFacts.IsAttributeName(((SourceNamedTypeSymbol)((CSharp.Symbols.PublicModel.NamedTypeSymbol)semanticInfo.Symbol).UnderlyingNamedTypeSymbol).SyntaxReferences.First().GetSyntax()),

Symbols\AnonymousTypesSymbolTests.cs (2)

1645Assert.False(sym.Symbol.Locations.IsEmpty, "Symbol Location"); 1654Assert.False(m.Locations.IsEmpty, String.Format("No Location: {0}", m));

Symbols\InterfaceImplementationTests.cs (3)

909Assert.False(comp.GetDiagnostics().Any(), string.Join("\n", comp.GetDiagnostics())); 970Assert.False(comp1.GetDiagnostics().Any(), string.Join("\n", comp1.GetDiagnostics())); 976Assert.False(comp2.GetDiagnostics().Any(), string.Join("\n", comp2.GetDiagnostics()));

Symbols\Metadata\PE\LoadingEvents.cs (1)

105Assert.False(true, string.Format("Accessor {0} has unexpected MethodKind {1}", accessor, accessor.MethodKind));

Symbols\Metadata\PE\LoadingMethods.cs (1)

1002Assert.False(true, "Unexpected enum value " + expectedVirtualness);

Symbols\Retargeting\RetargetCustomModifiers.cs (1)

207Assert.False(p1.HasExplicitDefaultValue, "Parameter has default value");

Symbols\TypeTests.cs (1)

1459Assert.False(errSymbol.IsImplicitClass, "ImplicitClass");

Symbols\TypeUnificationTests.cs (2)

432Assert.False(TypeUnification.CanUnify(t1, t2), string.Format("{0} vs {1}", t1, t2)); 433Assert.False(TypeUnification.CanUnify(t2, t1), string.Format("{0} vs {1}", t2, t1));

Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (12)

Diagnostics\DiagnosticTest.cs (2)

46Assert.False(string.IsNullOrEmpty(ErrorFacts.GetMessage(code, CultureInfo.InvariantCulture)), $"Message for error {code} is null or empty."); 2999Assert.False(isBuildOnly, $"Check failed for ErrorCode.{errorCode}");

IncrementalParsing\IncrementalParsingTests.cs (2)

3497Assert.False(newClassC.ContainsAnnotations, "Annotations should have been removed."); 3508Assert.False(newToken.ContainsAnnotations, "Annotations should have been removed.");

Parsing\ParsingTests.cs (2)

47Assert.False(hasNext, $"Test contains unconsumed syntax left over from UsingNode()\r\n{(this._output as TestOutputHelper)?.Output}"); 305Assert.False(true, "Found unexpected node or token of kind: " + tk);

Syntax\SyntaxRewriterTests.cs (5)

316Assert.False(node.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); 329Assert.False(node2.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); 559Assert.False(expr1.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); 577Assert.False(expr2.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?"); 623Assert.False(expr2.SyntaxTree.HasCompilationUnitRoot, "how did we get a CompilationUnit root?");

Syntax\SyntaxTests.cs (1)

277Assert.False(SyntaxFacts.IsAttributeTargetSpecifier(kind), $$"""IsAttributeTargetSpecific({{kind}}) should be false""");

Microsoft.CodeAnalysis.CSharp.Test.Utilities (1)

CSharpTestBase.cs (1)

2013Assert.False(true, string.Format("Expected exception {0}({1})", typeof(T).Name, expectedMessage));

Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (1)

Formatting\EditorConfigOptionParserTests.cs (1)

127Assert.False(CSharpFormattingOptions2.DetermineIfIgnoreSpacesAroundVariableDeclarationIsSet(value),

Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (6)

AbstractCommandHandlerTestState.cs (1)

234Assert.False(provider.HasPendingWaiter(FeatureAttribute.EventHookup, FeatureAttribute.CompletionSet, FeatureAttribute.SignatureHelp), "IAsyncTokens unexpectedly alive. Call WaitForAsynchronousOperationsAsync before this method");

Completion\AbstractCompletionProviderTests.cs (2)

1302Assert.False(isTextualTriggerCharacterResult, assertText); 1344Assert.False(CommitManager.IsCommitCharacter(

KeywordHighlighting\AbstractKeywordHighlighterTests.cs (2)

76Assert.False(true, $"Unexpected highlight at {actualLineSpan}: '{actualText}'"); 82Assert.False(true, $"Missing highlight at {expectedLineSpan}: '{expectedText}'");

SignatureHelp\AbstractSignatureHelpProviderTests.cs (1)

139Assert.False(signatureHelpProvider.TriggerCharacters.Contains(unexpectedTriggerCharacter), "Expected '" + unexpectedTriggerCharacter + "' to NOT be a trigger character");

Microsoft.CodeAnalysis.EditorFeatures.UnitTests (12)

Diagnostics\IDEDiagnosticIDConfigurationTests.cs (8)

135Assert.False(true, $@"Missing entry: 145Assert.False(true, $@"Mismatch for '{diagnosticId}' 156Assert.False(true, $"Test Baseline:{baseline}"); 169Assert.False(true, $@"Unexpected entries:{extraEntitiesBuilder.ToString()}"); 735Assert.False(true, 749Assert.False(true, 776Assert.False(true, $@"Missing entry: {diagnosticId}, {optionName}, {optionValue}"); 782Assert.False(true, $@"Mismatch for: {diagnosticId}, {optionName}, {optionValue}");

Options\GlobalOptionsTests.cs (1)

128Assert.False(Equals(value, defaultValue), $"{type.FullName}.{property.Name} not initialized from global options");

Utilities\AsynchronousOperationListenerTests.cs (2)

161Assert.False(continued, "Continued Task when it shouldn't have."); 284Assert.False(cancelledFinished.Task.IsCompleted, "We waited for the cancelled task to finish.");

Utilities\StackFrameUtils.cs (1)

130Assert.False(actual.IsDefault, diffMessage);

Microsoft.CodeAnalysis.Features.Test.Utilities (1)

Snippets\AbstractSnippetProviderTests.cs (1)

146Assert.False(isValidSnippetLocation, "Snippet is unexpectedly valid on a given position");

Microsoft.CodeAnalysis.Features.UnitTests (4)

EditAndContinue\RudeEditDiagnosticTests.cs (4)

87Assert.False(d.GetMessage().Contains("{"), kind.ToString()); 95Assert.False(d.GetMessage().Contains("{"), kind.ToString()); 104Assert.False(d.GetMessage().Contains("{"), kind.ToString()); 111Assert.False(d.GetMessage().Contains("{"), kind.ToString());

Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (2)

Diagnostics\AbstractPullDiagnosticTestsBase.cs (1)

255Assert.False(category == PublicDocumentNonLocalDiagnosticSourceProvider.NonLocal, "NonLocalDiagnostics are only supported for public DocumentPullHandler");

ProtocolConversionsTests.cs (1)

184Assert.False(containsFunction && containsMethod, "Don't use Method and Function completion item kinds as it causes user confusion.");

Microsoft.CodeAnalysis.Scripting.Desktop.UnitTests (2)

MetadataShadowCopyProviderTests.cs (2)

49Assert.False(Directory.Exists(_provider.ShadowCopyDirectory), "Shadow copy directory should have been deleted"); 93Assert.False(sc1.Metadata.IsImageOwner, "Copy expected");

Microsoft.CodeAnalysis.Scripting.TestUtilities (1)

ScriptingTestHelpers.cs (1)

89Assert.False(true, "Unexpected exception: " + e);

Microsoft.CodeAnalysis.Test.Utilities (19)

Assert\AssertEx.cs (1)

561Assert.False(AssertEqualityComparer<T>.IsNull(@object), message);

Compilation\CompilationExtensions.cs (2)

288Assert.False(stopWatch.ElapsedMilliseconds > timeout, $"ValidateIOperations took too long: {stopWatch.ElapsedMilliseconds} ms"); 341Assert.False(true, $"Duplicate explicit node for syntax ({operation.Syntax.RawKind}): {operation.Syntax.ToString()}");

Compilation\ControlFlowGraphVerifier.cs (5)

167Assert.False(true, $"Unexpected block kind {block.Kind}"); 1463Assert.False(true, $"Unexpected region kind {region.EnclosingRegion.Kind}"); 1493Assert.False(true, $"Unexpected region kind {region.Kind}"); 1549Assert.False(true, $"Unexpected region kind {region.EnclosingRegion.Kind}"); 1562Assert.False(true, $"Unexpected region kind {region.Kind}");

Compilation\OperationTreeVerifier.cs (1)

304Assert.False(true, $"Duplicate explicit node for syntax ({operation.Syntax.RawKind}): {operation.Syntax.ToString()}");

Compilation\TestOperationVisitor.cs (4)

205Assert.False(true, $"Duplicate explicit node for syntax ({descendant.Syntax.RawKind}): {descendant.Syntax.ToString()}"); 559Assert.False(operation.Instance.IsImplicit, $"Implicit {nameof(IInstanceReferenceOperation)} on {operation.Syntax}"); 669Assert.False(operation.Instance.IsImplicit, $"Implicit {nameof(IInstanceReferenceOperation)} on {operation.Syntax}"); 1719Assert.False(true, $"A {operation.Value.Kind} node should not be spilled or captured.");

Diagnostics\SuppressMessageAttributeTests.cs (1)

1376Assert.False(string.IsNullOrWhiteSpace(rootNamespace), string.Format("Invalid root namespace '{0}'", rootNamespace));

Metadata\MetadataSignatureUnitTestHelper.cs (2)

78Assert.False(string.IsNullOrWhiteSpace(fullyQualifiedTypeName), "'fullyQualifiedTypeName' can't be null or empty"); 79Assert.False(string.IsNullOrWhiteSpace(memberName), "'memberName' can't be null or empty");

Metadata\MetadataValidation.cs (2)

89Assert.False(descriptor.IsNil, "Expecting record in FieldMarshal table"); 122Assert.False(descriptor.IsNil, "Expecting record in FieldMarshal table");

ObjectReference.cs (1)

93Assert.False(_weakReference.IsAlive, "Reference should have been released but was not.");

Microsoft.CodeAnalysis.UnitTests (19)

Collections\List\CollectionAsserts.cs (2)

43Assert.False(a.MoveNext(), "actual has more elements"); 69Assert.False(a.MoveNext(), "actual has more elements");

Collections\List\IEnumerable.Generic.Tests.cs (1)

280Assert.False(enumerator.MoveNext(), "enumerator.MoveNext() returned true past the expected end.");

Collections\List\SegmentedList.Generic.Tests.Misc.cs (1)

586Assert.False(_ilist.Contains(new LinkedListNode<string>("rah")),

CommonSyntaxTests.cs (2)

28Assert.False(VB.VisualBasicExtensions.IsVisualBasicKind((int)kind), kind + " should not be VB kind"); 38Assert.False(CS.CSharpExtensions.IsCSharpKind((int)kind), kind + " should not be C# kind");

MetadataReferences\AssemblyMetadataTests.cs (2)

103Assert.False(copy1.IsImageOwner, "Assembly should not own the image"); 113Assert.False(copy2.IsImageOwner, "Assembly should not own the image");

MetadataReferences\MetadataReferenceTests.cs (1)

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

MetadataReferences\ModuleMetadataTests.cs (2)

146Assert.False(copy1.IsImageOwner, "Copy should not own the image"); 147Assert.False(copy2.IsImageOwner, "Copy should not own the image");

Text\TextSpanTest.cs (8)

54Assert.False(s1 != s2, s1.ToString() + " : " + s2.ToString()); 66Assert.False(s1.Equals(s2), s1.ToString() + " : " + s2.ToString()); 67Assert.False(s1 == s2, s1.ToString() + " : " + s2.ToString()); 80Assert.False(s1.Equals(s2), s1.ToString() + " : " + s2.ToString()); 81Assert.False(s1 == s2, s1.ToString() + " : " + s2.ToString()); 207Assert.False(span1 != span2, span1.ToString() + " : " + span2.ToString()); 212Assert.False(span2 != span1, span2.ToString() + " : " + span1.ToString()); 228Assert.False(span1 == span2, span1.ToString() + " : " + span2.ToString());

Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (3)

CommandLineTests.vb (3)

677Assert.False(result.ContainsErrors, $"Compilation error(s) occurred: {result.Output} {result.Errors}") 718Assert.False(result.ContainsErrors, $"Compilation error(s) occurred: {result.Output} {result.Errors}") 9559Assert.False(File.Exists(Path.Combine(dir.Path, unexpectedFile)), "Didn't expect to find: " & unexpectedFile)

Microsoft.CodeAnalysis.VisualBasic.Test.Utilities (3)

ParserTestUtilities.vb (3)

375Assert.False(node.IsMissing, "Unexpected missing node: " & node.Kind.ToString & node.Span.ToString) 775Assert.False(node.IsMissing, "Unexpected missing node: " & node.Kind().ToString & node.Span.ToString) 780Assert.False(node.IsMissing AndAlso Not node.IsKind(SyntaxKind.StatementTerminatorToken) AndAlso

Microsoft.CodeAnalysis.Workspaces.Test.Utilities (3)

Options\OptionsTestInfo.cs (1)

53Assert.False(type.IsGenericType, "Option should not be defined in a generic type");

TestErrorReportingService.cs (1)

23public Action<string> OnError { get; set; } = message => Assert.False(true, message);

Workspaces\TestWorkspace`1.cs (1)

626Assert.False(projectNameToTestHostProject.ContainsKey(project.Name), $"The workspace XML already contains a project with name {project.Name}");

Microsoft.CodeAnalysis.Workspaces.UnitTests (2)

Remote\ServiceDescriptorTests.cs (1)

359Assert.False(string.IsNullOrEmpty(expectedName), $"Service name for '{serviceInterface.GetType()}' not available.");

UtilityTest\AsyncLazyTests.cs (1)

112Assert.False(asyncContinuationRanSynchronously.Value, "The continuation did not run asynchronously.");

Microsoft.DotNet.NuGetRepack.Tests (1)

TestHelpers\AssertEx.cs (1)

340Assert.False(AssertEqualityComparer<T>.IsNull(@object), message);

Microsoft.DotNet.XUnitAssert.Tests (2)

BooleanAssertsTests.cs (1)

47 var ex = Record.Exception(() => Assert.False(true, "Custom User Message"));

EqualityAssertsTests.cs (1)

4645 Assert.False(_called, "GetEnumerator() was called more than once");

Microsoft.Extensions.AI.Evaluation.Integration.Tests (14)

AgentQualityEvaluatorTests.cs (3)

98Assert.False( 131Assert.False( 194Assert.False(

QualityEvaluatorTests.cs (2)

100Assert.False( 139Assert.False(

SafetyEvaluatorTests.cs (9)

162Assert.False( 237Assert.False( 282Assert.False( 318Assert.False( 367Assert.False( 429Assert.False( 464Assert.False( 505Assert.False( 539Assert.False(

Microsoft.Extensions.Caching.Hybrid.Tests (5)

BufferReleaseTests.cs (4)

79Assert.False(cacheItem.NeedsEvictionCallback, "should be recycled now"); 149Assert.False(cacheItem.NeedsEvictionCallback, "should NOT be pooled memory"); 177Assert.False(cacheItem.NeedsEvictionCallback, "should still not need recycling"); 239Assert.False(cacheItem.NeedsEvictionCallback, "should be recycled by now");

SerializerTests.cs (1)

317Assert.False(result.IsSingleSegment, "should be multi-segment");

Microsoft.Extensions.Compliance.Testing.Tests (1)

FakeRedactorOptionsValidatorTests.cs (1)

22Assert.False(validationResult.Succeeded, "Validator passed when it should fail.");

Microsoft.Extensions.ML.Tests (1)

UriLoaderTests.cs (1)

77Assert.False(changed.WaitOne(100), "UriLoader ChangeToken fired but shouldn't have.");

Microsoft.Extensions.ObjectPool.Tests (1)

ThreadingTest.cs (1)

53Assert.False(_foundError, "Race condition found. An item was shared across threads.");

Microsoft.ML.Benchmarks.Tests (1)

BenchmarksTest.cs (1)

57Assert.False(summary.HasCriticalValidationErrors, "The \"Summary\" should have NOT \"HasCriticalValidationErrors\"");

Microsoft.ML.TestFrameworkCommon (3)

TestCommon.cs (3)

239Assert.False((t1 == null) != (t2 == null), $"Different null-ness of {kind} metadata types"); 249Assert.False(size > int.MaxValue, $"{nameof(KeyDataViewType)}.{nameof(KeyDataViewType.Count)} is larger than int.MaxValue"); 257Assert.False(mustBeText, $"Unexpected {kind} metadata type");

Microsoft.ML.Tests (1)

ImagesTests.cs (1)

1217Assert.False(disposed, "The last in memory image had been disposed by running ResizeImageTransformer");

Microsoft.Net.Http.Headers.Tests (66)

CacheControlHeaderValueTest.cs (1)

343Assert.False(cacheControl1.Equals(null), "Compare with 'null'");

ContentDispositionHeaderValueTest.cs (8)

464Assert.False(contentDisposition1.Equals(contentDisposition2), "No params vs. name."); 465Assert.False(contentDisposition2.Equals(contentDisposition1), "name vs. no params."); 466Assert.False(contentDisposition1.Equals(null), "No params vs. <null>."); 467Assert.False(contentDisposition1!.Equals(contentDisposition3), "No params vs. custom param."); 468Assert.False(contentDisposition2.Equals(contentDisposition3), "name vs. custom param."); 471Assert.False(contentDisposition5.Equals(contentDisposition6), "name vs. custom param."); 472Assert.False(contentDisposition1.Equals(contentDisposition7), "inline vs. text/other."); 698Assert.False(ContentDispositionHeaderValue.TryParse(input, out var result), input);

ContentRangeHeaderValueTest.cs (14)

19Assert.False(range.HasRange, "HasRange"); 41Assert.False(range.HasLength, "HasLength"); 132Assert.False(range1.Equals(null), "bytes 1-2/5 vs. <null>"); 133Assert.False(range1!.Equals(range2), "bytes 1-2/5 vs. bytes 1-2/*"); 134Assert.False(range1.Equals(range3), "bytes 1-2/5 vs. bytes */5"); 135Assert.False(range2.Equals(range3), "bytes 1-2/* vs. bytes */5"); 138Assert.False(range1.Equals(range5), "bytes 1-2/5 vs. myunit 1-2/5"); 139Assert.False(range1.Equals(range6), "bytes 1-2/5 vs. bytes 1-3/5"); 140Assert.False(range1.Equals(range7), "bytes 1-2/5 vs. bytes 2-2/5"); 141Assert.False(range1.Equals(range8), "bytes 1-2/5 vs. bytes 1-2/6"); 163Assert.False(result.HasRange, "HasRange"); 164Assert.False(result.HasLength, "HasLength"); 194Assert.False(result.HasRange, "HasRange"); 195Assert.False(result.HasLength, "HasLength");

EntityTagHeaderValueTest.cs (8)

36Assert.False(etag.IsWeak, "IsWeak"); 87Assert.False(etag1.Equals(etag2), "Different casing."); 88Assert.False(etag2.Equals(etag1), "Different casing."); 89Assert.False(etag1.Equals(null), "tag vs. <null>."); 90Assert.False(etag1!.Equals(etag3), "strong vs. weak."); 91Assert.False(etag3.Equals(etag1), "weak vs. strong."); 92Assert.False(etag1.Equals(etag4), "tag vs. tag1."); 93Assert.False(etag1.Equals(etag6), "tag vs. *.");

MediaTypeHeaderValueTest.cs (7)

377Assert.False(mediaType1.Equals(mediaType2), "No params vs. charset."); 378Assert.False(mediaType2.Equals(mediaType1), "charset vs. no params."); 379Assert.False(mediaType1.Equals(null), "No params vs. <null>."); 380Assert.False(mediaType1!.Equals(mediaType3), "No params vs. custom param."); 381Assert.False(mediaType2.Equals(mediaType3), "charset vs. custom param."); 384Assert.False(mediaType5.Equals(mediaType6), "charset vs. custom param."); 385Assert.False(mediaType1.Equals(mediaType7), "text/plain vs. text/other.");

NameValueHeaderValueTest.cs (5)

224Assert.False(nameValue1.Equals(nameValue2), "token vs. <null>."); 228Assert.False(nameValue1.Equals(nameValue2), "<null> vs. token."); 232Assert.False(nameValue1.Equals(nameValue2), "string.Empty vs. token."); 248Assert.False(nameValue1.Equals(nameValue2), "\"quoted string\" vs. \"QUOTED STRING\"."); 254Assert.False(nameValue1.Equals(null), "\"quoted string\" vs. <null>.");

RangeConditionHeaderValueTest.cs (5)

83Assert.False(rangeCondition1.Equals(null), "\"x\" vs. <null>"); 85Assert.False(rangeCondition1.Equals(rangeCondition3), "\"x\" vs. date"); 86Assert.False(rangeCondition3.Equals(rangeCondition1), "date vs. \"x\""); 87Assert.False(rangeCondition3.Equals(rangeCondition4), "date vs. different date"); 89Assert.False(rangeCondition1.Equals(rangeCondition6), "\"x\" vs. W/\"x\"");

RangeHeaderValueTest.cs (5)

80Assert.False(range1.Equals(null), "bytes=1-2 vs. <null>"); 82Assert.False(range1.Equals(range3), "bytes=1-2 vs. bytes=1-"); 83Assert.False(range1.Equals(range4), "bytes=1-2 vs. bytes=-2"); 84Assert.False(range1.Equals(range5), "bytes=1-2 vs. bytes=1-2,3-4"); 86Assert.False(range1.Equals(range7), "bytes=1-2 vs. other=1-2");

RangeItemHeaderValueTest.cs (6)

78Assert.False(rangeItem1.Equals(rangeItem2), "1-2 vs. 1-."); 79Assert.False(rangeItem2.Equals(rangeItem1), "1- vs. 1-2."); 80Assert.False(rangeItem1.Equals(null), "1-2 vs. null."); 81Assert.False(rangeItem1!.Equals(rangeItem3), "1-2 vs. -2."); 82Assert.False(rangeItem3.Equals(rangeItem1), "-2 vs. 1-2."); 83Assert.False(rangeItem1.Equals(rangeItem4), "1-2 vs. 2-2.");

StringWithQualityHeaderValueTest.cs (7)

91Assert.False(value1.Equals(null), "t; q=0.123 vs. <null>"); 94Assert.False(value1.Equals(value4), "t; q=0.123 vs. t"); 95Assert.False(value4.Equals(value1), "t vs. t; q=0.123"); 96Assert.False(value1.Equals(value5), "t; q=0.123 vs. x; q=0.123"); 97Assert.False(value1.Equals(value6), "t; q=0.123 vs. t; q=0.5"); 98Assert.False(value1.Equals(value7), "t; q=0.123 vs. t; q=0.1234"); 100Assert.False(value4.Equals(value9), "t vs. T");

Sockets.FunctionalTests (3)

src\Servers\Kestrel\test\FunctionalTests\RequestTests.cs (1)

590Assert.False(loggedHigherThanDebug, "Logged event should not have been higher than debug.");

src\Servers\Kestrel\test\FunctionalTests\UnixDomainSocketsTests.cs (2)

186Assert.False(httpStatusStart == 0, $"Space not found in '{httpResponse}'."); 188Assert.False(httpStatusEnd == -1, $"Second space not found in '{httpResponse}'.");

System.ServiceModel.Primitives.Tests (4)

Channels\CustomChannelTest.cs (4)

626Assert.False(beginInitializeCalled, "BeginDisplayInitializationUI should not have been called."); 627Assert.False(endInitializeCalled, "EndDisplayInitializationUI should not have been called."); 679Assert.False(beginInitializeCalled, "BeginDisplayInitializationUI should not have been called."); 680Assert.False(endInitializeCalled, "EndDisplayInitializationUI should not have been called.");

Templates.Blazor.Tests (8)

BlazorTemplateTest.cs (1)

325Assert.False(

BlazorWasmTemplateTest.cs (4)

30Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js"); 35Assert.False( 61Assert.False( 109Assert.False(File.Exists(Path.Combine(publishDir, "service-worker.published.js")), "service-worker.published.js should not be published");

BlazorWebTemplateTest.cs (2)

72Assert.False( 83Assert.False(

src\ProjectTemplates\Shared\Project.cs (1)

308Assert.False(doesExist, "Expected file not to exist, but it does: " + path);

Templates.Blazor.WebAssembly.Auth.Tests (3)

src\ProjectTemplates\Shared\Project.cs (1)

308Assert.False(doesExist, "Expected file not to exist, but it does: " + path);

src\Shared\E2ETesting\BrowserFixture.cs (1)

37Assert.False(

src\Shared\E2ETesting\WaitAssert.cs (1)

44=> WaitAssertCore(driver, () => Assert.False(actual(), message));

Templates.Blazor.WebAssembly.Tests (7)

BlazorWasmTemplateTest.cs (4)

src\ProjectTemplates\Shared\Project.cs (1)

308Assert.False(doesExist, "Expected file not to exist, but it does: " + path);

src\Shared\E2ETesting\BrowserFixture.cs (1)

37Assert.False(

src\Shared\E2ETesting\WaitAssert.cs (1)

44=> WaitAssertCore(driver, () => Assert.False(actual(), message));

Templates.Mvc.Tests (17)

BlazorTemplateTest.cs (1)

101Assert.False(

MvcTemplateTest.cs (5)

114Assert.False( 123Assert.False( 254Assert.False( 263Assert.False( 310Assert.False(

RazorPagesTemplateTest.cs (4)

102Assert.False( 111Assert.False( 243Assert.False( 252Assert.False(

src\ProjectTemplates\Shared\Project.cs (1)

308Assert.False(doesExist, "Expected file not to exist, but it does: " + path);

src\Shared\E2ETesting\BrowserFixture.cs (1)

37Assert.False(

src\Shared\E2ETesting\WaitAssert.cs (1)

44=> WaitAssertCore(driver, () => Assert.False(actual(), message));

WebApiTemplateTest.cs (4)

172Assert.False( 207Assert.False( 260Assert.False( 271Assert.False(

Templates.Tests (14)

BaselineTest.cs (1)

132Assert.False(doesExist, "Expected file not to exist, but it does: " + path);

EmptyWebTemplateTest.cs (2)

104Assert.False( 113Assert.False(

GrpcTemplateTest.cs (2)

112Assert.False( 130Assert.False(

IdentityUIPackageTest.cs (2)

127Assert.False( 139Assert.False(

src\ProjectTemplates\Shared\Project.cs (1)

308Assert.False(doesExist, "Expected file not to exist, but it does: " + path);

src\Shared\E2ETesting\BrowserFixture.cs (1)

37Assert.False(

src\Shared\E2ETesting\WaitAssert.cs (1)

44=> WaitAssertCore(driver, () => Assert.False(actual(), message));

WebApiNativeAotTemplateTest.cs (2)

120Assert.False( 128Assert.False(

WorkerTemplateTest.cs (2)

77Assert.False( 84Assert.False(