NotEqual

BrowserSecurityHeadersMiddlewareTests.cs (3)

28Assert.NotEqual(StringValues.Empty, httpContext.Response.Headers.ContentSecurityPolicy); 43Assert.NotEqual(StringValues.Empty, httpContext.Response.Headers.ContentSecurityPolicy); 61Assert.NotEqual(StringValues.Empty, httpContext.Response.Headers.ContentSecurityPolicy);

Integration\FrontendBrowserTokenAuthTests.cs (3)

182Assert.NotEqual(0, uri.Port); 189Assert.NotEqual(0, uri.Port); 196Assert.NotEqual(0, uri.Port);

Integration\StartupTests.cs (6)

570Assert.NotEqual(0, uri.Port); 577Assert.NotEqual(0, uri.Port); 584Assert.NotEqual(0, uri.Port); 659Assert.NotEqual(0, uri.Port); 666Assert.NotEqual(0, uri.Port); 727Assert.NotEqual(0, ipEndPoint.Port);

AzureBicepProvisionerTests.cs (1)

155Assert.NotEqual(checkSum0, checkSum1);

AzureFunctionsTests.cs (2)

107Assert.NotEqual(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, storageResources.Name); 160Assert.NotEqual(AzureFunctionsProjectResourceExtensions.DefaultAzureFunctionsHostStorageName, resource.Name);

KeycloakResourceBuilderTests.cs (1)

124Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", rmq.Resource.AdminPasswordParameter.Default?.GetType().FullName);

AddMySqlTests.cs (1)

33Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", mysql.Resource.PasswordParameter.Default?.GetType().FullName);

AddNatsTests.cs (1)

31Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", nats.Resource.PasswordParameter!.Default?.GetType().FullName);

AddOracleTests.cs (1)

32Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", orcl.Resource.PasswordParameter.Default?.GetType().FullName);

AddPostgresTests.cs (1)

42Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", pg.Resource.PasswordParameter.Default?.GetType().FullName);

AddQdrantTests.cs (1)

35Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", qd.Resource.ApiKeyParameter.Default?.GetType().FullName);

AddRabbitMQTests.cs (1)

31Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", rmq.Resource.PasswordParameter.Default?.GetType().FullName);

RedisFunctionalTests.cs (1)

212Assert.NotEqual(secondRunDatabases.Single().Id, firstRunDatabases.Single().Id);

AddSqlServerTests.cs (1)

32Assert.NotEqual("Aspire.Hosting.ApplicationModel.UserSecretsParameterDefault", sql.Resource.PasswordParameter.Default?.GetType().FullName);

DistributedApplicationTests.cs (2)

380Assert.NotEqual(0, int.Parse(serviceAPortValue, CultureInfo.InvariantCulture)); 385Assert.NotEqual(0, int.Parse(nodeAppPortValue, CultureInfo.InvariantCulture));

Utils\VolumeNameGeneratorTests.cs (1)

69Assert.NotEqual(runVolumeName, publishVolumeName);

Utils\WithAnnotationTests.cs (3)

21Assert.NotEqual(dummyAnnotations.First(), dummyAnnotations.Last()); 35Assert.NotEqual(dummyAnnotations.First(), dummyAnnotations.Last()); 50Assert.NotEqual(firstAnnotation, secondAnnotation);

StarterTemplateRunTestsBase.cs (1)

105Assert.NotEqual(firstLoadText, secondLoadText);

OperationContextTests.cs (2)

50Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 51Assert.NotEqual(currentContext, OperationContext.Current);

OperationContextAsyncFlowTests.cs (5)

37Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 72Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 76Assert.NotEqual(firstContext, OperationContext.Current); 80Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 163Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId);

SessionTests.cs (1)

86Assert.NotEqual(sessionId1, sessionId2);

WelcomePageSampleTest.cs (1)

27Assert.NotEqual(0xEF, bytes[0]); // No leading UTF-8 BOM

src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (1)

49Assert.NotEqual(id2, id1);

src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (1)

49Assert.NotEqual(id2, id1);

EventSourceTests.cs (9)

Http2\Http2TestBase.cs (1)

1094Assert.NotEqual(0, streamId);

KestrelMetricsTests.cs (1)

364Assert.NotEqual(overridenFeature, currentConnectionContext.Features.Get<IConnectionMetricsTagsFeature>());

RequestTests.cs (1)

635Assert.NotEqual(0, read);

ResponseTests.cs (2)

4212Assert.NotEqual(4096, memory.Length); 4311Assert.NotEqual(BodyWriter1, BodyWriter2);

BinaryBlobTest.cs (3)

74Assert.NotEqual(blobA, blobB); 85Assert.NotEqual(blobA, blobB); 96Assert.NotEqual(blobA, blobB);

DefaultAntiforgeryTest.cs (2)

399Assert.NotEqual(headerValue, actualHeaderValue); 417Assert.NotEqual(headerValue, actualHeaderValue);

AuthenticationPropertiesTests.cs (2)

34Assert.NotEqual(props.Items, copy.Items); 35Assert.NotEqual(props.Parameters, copy.Parameters);

AuthenticationTicketTests.cs (2)

38Assert.NotEqual(ticket.Properties.Items, copy.Properties.Items); 39Assert.NotEqual(ticket.Properties.Parameters, copy.Properties.Parameters);

UserJwtsTests.cs (1)

574Assert.NotEqual(key, resetKey);

CookieTests.cs (3)

217Assert.NotEqual(key1, key2); 975Assert.NotEqual(lastValidateIssuedDate, firstIssueDate); 976Assert.NotEqual(firstExpiresDate, lastExpiresDate);

JwtBearerTests.cs (2)

955Assert.NotEqual(DateTimeOffset.MinValue, token.ValidTo); 956Assert.NotEqual(DateTimeOffset.MinValue, token.ValidFrom);

JwtBearerTests_Handler.cs (2)

899Assert.NotEqual(DateTimeOffset.MinValue, token.ValidTo); 900Assert.NotEqual(DateTimeOffset.MinValue, token.ValidFrom);

EndpointHtmlRendererTest.cs (9)

FieldIdentifierTest.cs (3)

61Assert.NotEqual(fieldIdentifier1.GetHashCode(), fieldIdentifier2.GetHashCode()); 74Assert.NotEqual(fieldIdentifier1.GetHashCode(), fieldIdentifier2.GetHashCode()); 129Assert.NotEqual(fieldIdentifierLower.GetHashCode(), fieldIdentifierPascal.GetHashCode());

RendererTest.cs (6)

3003Assert.NotEqual(parentComponentId, diff2.ComponentId); 3019Assert.NotEqual(parentComponentId, diff4.ComponentId); 4363Assert.NotEqual(default, attributeFrame.AttributeEventHandlerId); 4364Assert.NotEqual(eventHandlerId, attributeFrame.AttributeEventHandlerId); 4415Assert.NotEqual(default, attributeFrame.AttributeEventHandlerId); 4416Assert.NotEqual(eventHandlerId, attributeFrame.AttributeEventHandlerId);

RenderTreeDiffBuilderTest.cs (4)

935Assert.NotEqual(default, removedEventHandlerFrame.AttributeEventHandlerId); 1668Assert.NotEqual(default, oldAttributeFrame.AttributeEventHandlerId); 1695Assert.NotEqual(default, oldAttributeFrame.AttributeEventHandlerId); 1855Assert.NotEqual(ref1.Id, ref2.Id);

Routing\RouteKeyTest.cs (3)

40Assert.NotEqual(key1.GetHashCode(), key2.GetHashCode()); 52Assert.NotEqual(key1.GetHashCode(), key2.GetHashCode()); 88Assert.NotEqual(key1.GetHashCode(), key2.GetHashCode());

Cng\BCryptUtilTests.cs (1)

45Assert.NotEqual(Guid.Empty, newGuid);

SafeHandles\SecureLocalAllocHandleTests.cs (1)

28Assert.NotEqual(controlHandle.DangerousGetHandle(), duplicateHandle.DangerousGetHandle()); // shouldn't just point to the same memory location

Cng\CngAuthenticatedEncryptorBaseTests.cs (2)

49Assert.NotEqual(IntPtr.Zero, pbAdditionalAuthenticatedData); // CNG will complain if this pointer is zero 73Assert.NotEqual(IntPtr.Zero, pbCiphertext); // CNG will complain if this pointer is zero

Internal\KeyManagementOptionsPostSetupTest.cs (1)

184Assert.NotEqual(keyDir, (repository as FileSystemXmlRepository)?.Directory.FullName);

Repositories\FileSystemXmlRepositoryTests.cs (1)

113Assert.NotEqual(Guid.Empty, parsedGuid);

Repositories\RegistryXmlRepositoryTests.cs (1)

99Assert.NotEqual(Guid.Empty, parsedGuid);

SecretAssert.cs (1)

32Assert.NotEqual(SecretToBase64String(secret1), SecretToBase64String(secret2));

SecretTests.cs (6)

176Assert.NotEqual(Guid.Empty, pGuids[0]); 177Assert.NotEqual(Guid.Empty, pGuids[1]); 178Assert.NotEqual(pGuids[0], pGuids[1]); 191Assert.NotEqual(Guid.Empty, pGuids[0]); 192Assert.NotEqual(Guid.Empty, pGuids[1]); 193Assert.NotEqual(pGuids[0], pGuids[1]);

TypeForwardingActivatorTests.cs (1)

116Assert.NotEqual(type.AssemblyQualifiedName, newName);

CertificateManagerTests.cs (1)

312Assert.NotEqual(_manager.Subject, wrongSubjectCertificate.Subject);

Latency\RequestLatencyTelemetryExtensionsTests.cs (1)

45Assert.NotEqual(scope1.ServiceProvider.GetService<ILatencyContext>(),

HostHeaderValueTests.cs (5)

19Assert.NotEqual(differentHost, host1); 20Assert.NotEqual(differentPort, host1); 38Assert.NotEqual(new object(), host1); 67Assert.NotEqual(differentHostHashCode, host1HashCode); 68Assert.NotEqual(differentPortHashCode, host1HashCode);

HostingMetricsTests.cs (1)

177Assert.NotEqual(overridenFeature, contextFeature);

WebHostBuilderTests.cs (1)

994Assert.NotEqual(disposables[0], disposables[1]);

FragmentStringTests.cs (2)

26Assert.NotEqual(default(FragmentString), fragmentString); 36Assert.NotEqual(fragmentString, FragmentString.Empty);

HostStringTest.cs (2)

115Assert.NotEqual(default(HostString), hostString); 125Assert.NotEqual(hostString, new HostString(string.Empty));

PathStringTests.cs (2)

38Assert.NotEqual(default(PathString), pathString); 48Assert.NotEqual(pathString, PathString.Empty);

QueryStringTests.cs (2)

148Assert.NotEqual(default(QueryString), queryString); 158Assert.NotEqual(queryString, QueryString.Empty);

HttpConnectionDispatcherTests.cs (1)

100Assert.NotEqual(connectionId, connectionToken);

HttpConnectionManagerTests.cs (2)

55Assert.NotEqual(default, connection.LastSeenTicks); 236Assert.NotEqual(connection.ConnectionId, connection.ConnectionToken);

src\Shared\ResultsTests\FileContentResultTestBase.cs (2)

294Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 329Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

286Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 323Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (9)

58Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 89Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 118Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 145Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 174Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 206Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 234Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 261Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 318Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (6)

70Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 209Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 248Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 280Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 311Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 353Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

DefaultHttpContextTests.cs (2)

165Assert.NotEqual(4, features.Count()); 185Assert.NotEqual(4, newFeatures.Count());

Features\HttpRequestIdentifierFeatureTests.cs (1)

38Assert.NotEqual(id1, id2);

ForwardedHeadersMiddlewareTest.cs (2)

450Assert.NotEqual(hostHeader, context.Request.Host.Value); 552Assert.NotEqual<string>(hostHeader, context.Request.Headers.Host);

UserStoreTest.cs (1)

181Assert.NotEqual(userA.PasswordHash, userB.PasswordHash);

ManagementTests.cs (1)

376Assert.NotEqual(expectedPrincipalClaim, actualPrincipalClaim);

MapIdentityApiTests.cs (2)

759Assert.NotEqual(accessToken, recoveryAccessToken); 861Assert.NotEqual(accessToken, recoveryAccessToken);

UserManagerSpecificationTests.cs (16)

SignInManagerTest.cs (2)

959Assert.NotEqual(confirmed, result.IsNotAllowed); 1013Assert.NotEqual(confirmed, result.IsNotAllowed);

ModelBinding\ValueProviderResultTest.cs (3)

66Assert.NotEqual(ValueProviderResult.None, result); 81Assert.NotEqual(ValueProviderResult.None, result); 190Assert.NotEqual(expected, result);

ApplicationModels\ActionModelTest.cs (1)

126Assert.NotEqual(value1, Activator.CreateInstance(property.PropertyType));

ApplicationModels\AttributeRouteModelTests.cs (1)

44Assert.NotEqual(value1, Activator.CreateInstance(property.PropertyType));

ApplicationModels\ControllerModelTest.cs (1)

128Assert.NotEqual(value1, Activator.CreateInstance(property.PropertyType));

ApplicationModels\ParameterModelTest.cs (1)

62Assert.NotEqual(value1, Activator.CreateInstance(property.PropertyType));

ApplicationModels\PropertyModelTest.cs (1)

58Assert.NotEqual(value1, Activator.CreateInstance(property.PropertyType));

ControllerBaseTest.cs (12)

src\Shared\ResultsTests\FileContentResultTestBase.cs (2)

294Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 329Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

src\Shared\ResultsTests\FileStreamResultTestBase.cs (2)

286Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 323Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

src\Shared\ResultsTests\PhysicalFileResultTestBase.cs (9)

58Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 89Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 118Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 145Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 174Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 206Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 234Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 261Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 318Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

src\Shared\ResultsTests\VirtualFileResultTestBase.cs (6)

70Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 209Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 248Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 280Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 311Assert.NotEqual(0, httpResponse.Headers.LastModified.Count); 353Assert.NotEqual(0, httpResponse.Headers.LastModified.Count);

InputObjectValidationTests.cs (1)

153Assert.NotEqual(shouldNotContainMessage, errorMessage);

RazorBuildTest.cs (3)

123Assert.NotEqual(expected1, actual2); 138Assert.NotEqual(actual2, body.Trim()); 162Assert.NotEqual(expected1, actual2);

RazorRuntimeCompilationHostingStartupTest.cs (3)

69Assert.NotEqual(expected1, actual2); 84Assert.NotEqual(actual2, body.Trim()); 107Assert.NotEqual(expected1, actual2);

DictionaryModelBinderIntegrationTest.cs (2)

810Assert.NotEqual(ModelValidationState.Unvalidated, kvp.Value.ValidationState); 811Assert.NotEqual(ModelValidationState.Skipped, kvp.Value.ValidationState);

RouteDataTest.cs (6)

116Assert.NotEqual(routeData.DataTokens, copy.DataTokens); 118Assert.NotEqual(routeData.Routers, copy.Routers); 120Assert.NotEqual(routeData.Values, copy.Values); 149Assert.NotEqual(routeData.DataTokens, copy.DataTokens); 151Assert.NotEqual(routeData.Routers, copy.Routers); 153Assert.NotEqual(routeData.Values, copy.Values);

CacheTagKeyTest.cs (4)

89Assert.NotEqual(cacheTagKey1, cacheTagKey2); 143Assert.NotEqual(hashcode1, hashcode2); 470Assert.NotEqual(hashCode1, hashCode2); 502Assert.NotEqual(hashCode1, hashCode2);

MemberExpressionCacheKeyComparerTest.cs (2)

177Assert.NotEqual(hashCode1, hashCode2); 184Assert.NotEqual(cachedKeyHashCode1, hashCode2);

Rendering\TagBuilderTest.cs (1)

305Assert.NotEqual(originalTagBuilder.InnerHtml, clonedTagBuilder.InnerHtml);

ViewDataDictionaryOfTModelTest.cs (1)

299Assert.NotEqual(source.ModelMetadata.ModelType, viewData.ModelMetadata.ModelType);

Services\CreateSchemaReferenceIdTests.cs (1)

243Assert.NotEqual(schema.Reference.Id, responseSchema.Reference.Id);

Transformers\DocumentTransformerTests.cs (1)

120Assert.NotEqual(description, document.Info.Description);

Transformers\Implementations\OpenApiSchemaReferenceTransformerTests.cs (1)

294Assert.NotEqual(requestSchema.Reference.Id, responseSchema.Reference.Id);

OutputCacheMiddlewareTests.cs (2)

401Assert.NotEqual(timeProvider.GetUtcNow(), context.ResponseTime); 1037Assert.NotEqual(cachedResponse, refreshedResponse);

OutputCachePolicyBuilderTests.cs (1)

363Assert.NotEqual(2, context.ResponseExpirationTimeSpan?.TotalSeconds);

OutputCacheTests.cs (1)

1077Assert.NotEqual(await initialResponse.Content.ReadAsStringAsync(), await subsequentResponse.Content.ReadAsStringAsync());

ResponseCachingMiddlewareTests.cs (1)

392Assert.NotEqual(timeProvider.GetUtcNow(), context.ResponseTime);

ResponseCachingTests.cs (1)

981Assert.NotEqual(await initialResponse.Content.ReadAsStringAsync(), await subsequentResponse.Content.ReadAsStringAsync());

Matching\ILEmitTrieJumpTableTest.cs (1)

210Assert.NotEqual(entry, path.Substring(start, length));

Tree\TreeRouterTest.cs (3)

1769Assert.NotEqual(nestedValues, context.RouteData.Values); 1802Assert.NotEqual(nestedValues, context.RouteData.Values); 1845Assert.NotEqual(nestedValues, context.RouteData.Values);

RequestTests.cs (2)

44Assert.NotEqual(0, connectionInfo.RemotePort); 46Assert.NotEqual(0, connectionInfo.LocalPort);

ServerTests.cs (1)

83Assert.NotEqual("0", prefix.Port);

Http1\Http1HttpProtocolFeatureCollectionTests.cs (4)

54Assert.NotEqual(0, featureCount); 61Assert.NotEqual(0, featureCount); 75Assert.NotEqual(0, featureCount); 218Assert.NotEqual(0, featureCount);

HttpRequestHeadersTests.cs (6)

463Assert.NotEqual(values.PrevHeaderValue, values.NextHeaderValue); 486Assert.NotEqual(values.PrevHeaderValue, values.NextHeaderValue); 755Assert.NotEqual(string.Empty, prevHeaderValue); 769Assert.NotEqual(HeaderValue, nextHeaderValue); 781Assert.NotEqual(HeaderValue, nextHeaderValue); 806Assert.NotEqual(string.Empty, prevHeaderValue.ToString());

KestrelServerTests.cs (2)

505Assert.NotEqual(0, ((IPEndPoint)transportEndPoint.BoundEndPoint).Port); 533Assert.NotEqual(0, ((IPEndPoint)multiplexedTransportEndPoint.BoundEndPoint).Port);

StartLineTests.cs (10)

KestrelConfigurationLoaderTests.cs (2)

298Assert.NotEqual(devCert.SerialNumber, defaultCert.SerialNumber); // Need to be able to distinguish them 519Assert.NotEqual(certificate.SerialNumber, defaultCertificate.SerialNumber);

HubConnectionTests.cs (3)

296Assert.NotEqual(originalClientConnectionId, connectionIdFromServer); 2177Assert.NotEqual(initialConnectionId, newConnectionId); 2237Assert.NotEqual(initialConnectionId, newConnectionId);

ScaleoutHubLifetimeManagerTests.cs (1)

603Assert.NotEqual(invocation1.InvocationId, invocation2.InvocationId);

HubConnectionHandlerTestUtils\Hubs.cs (1)

1434Assert.NotEqual(service, service2);

WebApplicationTests.cs (4)

2266Assert.NotEqual(nameof(WebApplicationTests), hostEnv.ApplicationName); 2267Assert.NotEqual(envName, hostEnv.EnvironmentName); 2268Assert.NotEqual(contentRoot, hostEnv.ContentRootPath); 2332Assert.NotEqual(value0, value1);

Construction\ProjectRootElement_Tests.cs (4)

381Assert.NotEqual("MSB4068", ex.ErrorCode); 1872Assert.NotEqual(version, projectElement.Version); 1881Assert.NotEqual(childrenCount, projectElement.AllChildren.Count()); 1890Assert.NotEqual(xml, projectElement.RawXml);

ObjectModelRemoting\Helpers\ViewValidation.cs (4)

37Assert.NotEqual((object)this.View, (object)other.View); 38Assert.NotEqual((object)this.Real, (object)other.Real); 74Assert.NotEqual(current, newValue); 75Assert.NotEqual(current, newValue1);

ObjectModelRemoting\LinkedEvaluationModify_Tests.cs (1)

46Assert.NotEqual(proj1Path, savedPath);

BackEnd\BuildManager_Tests.cs (1)

455Assert.NotEqual(Process.GetCurrentProcess().Id, processId); // "Build is expected to be out-of-proc. In fact it was in-proc."

BackEnd\BuildRequestConfiguration_Tests.cs (7)

211Assert.NotEqual(config1.GetHashCode(), config3.GetHashCode()); 212Assert.NotEqual(config1.GetHashCode(), config5.GetHashCode()); 213Assert.NotEqual(config4.GetHashCode(), config5.GetHashCode()); 225Assert.NotEqual(config1, config3); 228Assert.NotEqual(config1, config4); 234Assert.NotEqual(config1, config5); 237Assert.NotEqual(config1, config3);

BackEnd\NodeEndpointInProc_Tests.cs (2)

338Assert.NotEqual(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId); 348Assert.NotEqual(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId);

Evaluation\Expander_Tests.cs (2)

1262Assert.NotEqual(-1, e.Message.IndexOf("[System.IO.Path]::Combine(null, '')", StringComparison.OrdinalIgnoreCase)); 1289Assert.NotEqual(-1, e.Message.IndexOf("System.IO.Path::Combine('a','b')", StringComparison.OrdinalIgnoreCase));

FileUtilities_Tests.cs (1)

543Assert.NotEqual("C:\\work\\sdk3\\artifacts\\tmp\\Debug\\SimpleNamesWi---6143883E\\NETFrameworkLibrary\\bin\\Debug\\net462\\NETFrameworkLibrary.dll", FileUtilities.NormalizePath(filePath));

Instance\TaskItem_Tests.cs (8)

117Assert.NotEqual(left, right); 118Assert.NotEqual(right, left); 132Assert.NotEqual(left, right); 133Assert.NotEqual(right, left); 146Assert.NotEqual(left, right); 147Assert.NotEqual(right, left); 162Assert.NotEqual(left, right); 163Assert.NotEqual(right, left);

TargetTests.cs (4)

41Assert.NotEqual("true", shouldRun); 42Assert.NotEqual("true", hasItems); 66Assert.NotEqual("true", hasItems); 141Assert.NotEqual("true", shouldRun);

Copy_Tests.cs (2)

1013Assert.NotEqual(FileAttributes.ReadOnly, File.GetAttributes(destination1) & FileAttributes.ReadOnly); 1014Assert.NotEqual(FileAttributes.ReadOnly, File.GetAttributes(destination2) & FileAttributes.ReadOnly);

FileStateTests.cs (2)

245Assert.NotEqual(time, state.LastWriteTime); 271Assert.NotEqual(time.ToUniversalTime(), state.LastWriteTimeUtcFast);

MockUnmanagedMemoryHelper.cs (1)

100Assert.NotEqual(IntPtr.Zero, _mainAllocationHandle);

NativeMethodsShared_Tests.cs (1)

52Assert.NotEqual(processHandle, NativeMethodsShared.NullIntPtr);

ResolveNonMSBuildProjectOutput_Tests.cs (1)

233Assert.NotEqual("true", ((ITaskItem)resolvedOutputs[Path.Combine("obj", "unmanaged.dll")]).GetMetadata("ManagedAssembly"));

ResolveSDKReference_Tests.cs (3)

539Assert.NotEqual(sdkReference2, sdkReference1); 540Assert.NotEqual(sdkReference2DiffVer, sdkReference1); 541Assert.NotEqual(sdkReference2DiffVer, sdkReference2);

WriteLinesToFile_Tests.cs (1)

91Assert.NotEqual("\uBDEA", r.Lines[0].ItemSpec);

XslTransformation_Tests.cs (2)

977Assert.NotEqual(new FileInfo(xmlMultiPaths[0].ItemSpec).Length, new FileInfo(xmlMultiPaths[1].ItemSpec).Length); 978Assert.NotEqual(new FileInfo(outputMultiPaths[0].ItemSpec).Length, new FileInfo(outputMultiPaths[1].ItemSpec).Length);

ObjectModelHelpers.cs (1)

542Assert.NotEqual(-1, indexOfEquals);

NativeMethodsShared_Tests.cs (1)

52Assert.NotEqual(processHandle, NativeMethodsShared.NullIntPtr);

ToolTask_Tests.cs (1)

673Assert.NotEqual(directoryNamedSameAsTool, task.PathToToolUsed);

src\Features\DiagnosticsTestUtilities\CodeActions\CodeFixVerifierHelper.cs (3)

51Assert.NotEqual("", descriptor.Title?.ToString() ?? ""); 64Assert.NotEqual("", descriptor.MessageFormat?.ToString() ?? ""); 89Assert.NotEqual("", descriptor.HelpLinkUri ?? "");

CommandLineTests.cs (9)

1642Assert.NotEqual(LanguageVersion.Default, defaultEffectiveVersion); 1655Assert.NotEqual(LanguageVersion.Latest, latestEffectiveVersion); 6954Assert.NotEqual(0, exitCode); 6976Assert.NotEqual(0, exitCode); 7177Assert.NotEqual(0, exitCode); 7181Assert.NotEqual(0, exitCode); 8781Assert.NotEqual(0, exitCode1); 8906Assert.NotEqual(mvid, ReadMvid(fsNewDll)); 9159Assert.NotEqual(0, exitCode);

SarifErrorLoggerTests.cs (8)

86Assert.NotEqual(0, exitCode); 121Assert.NotEqual(0, exitCode); 155Assert.NotEqual(0, exitCode); 191Assert.NotEqual(0, exitCode); 226Assert.NotEqual(0, exitCode); 261Assert.NotEqual(0, exitCode); 296Assert.NotEqual(0, exitCode); 328Assert.NotEqual(0, exitCode);

SarifV2ErrorLoggerTests.cs (3)

543Assert.NotEqual(0, exitCode); 613Assert.NotEqual(0, exitCode); 691Assert.NotEqual(0, exitCode);

Completion\CompletionProviders\SymbolCompletionProviderTests_NoInteractive.cs (1)

389Assert.NotEqual(currentDocument, document);

Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (1)

325Assert.NotEqual(SyntaxKind.MethodDeclaration, context.Node.Kind());

ExtractMethod\ExtractMethodBase.cs (1)

97Assert.NotEqual(expected, actual);

Workspaces\WorkspaceTests_EditorFeatures.cs (9)

502Assert.NotEqual(TypeKind.Error, classC.TypeKind); 556Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 580Assert.NotEqual(VersionStamp.Default, newVersion); 624Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 1124Assert.NotEqual(oldVersion, await doc.Project.GetSemanticVersionAsync()); 1157Assert.NotEqual(oldVersion, await doc.Project.GetSemanticVersionAsync()); 1468Assert.NotEqual(defaultValue, changedValue); 1514Assert.NotEqual(beforeSolutionForPrimaryWorkspace, primaryWorkspace.CurrentSolution); 1515Assert.NotEqual(beforeSolutionForSecondaryWorkspace, secondaryWorkspace.CurrentSolution);

CodeGen\CodeGenDeconstructTests.cs (4)

5482Assert.NotEqual(firstX1Symbol, secondX1Symbol); 5514Assert.NotEqual(firstYSymbol, secondYSymbol); 5545Assert.NotEqual(firstXSymbol, secondXSymbol); 6151Assert.NotEqual(symbol0, symbol);

CodeGen\CodeGenFunctionPointersTests.cs (2)

2537Assert.NotEqual(nopiaReference.Display, module.ReferencedAssemblies[0].Name); 2571Assert.NotEqual(nopiaReference.Display, module.ReferencedAssemblies[0].Name);

CodeGen\CodeGenTupleTest.cs (1)

27501Assert.NotEqual(type, underlyingType);

Emit\CompilationEmitTests.cs (12)

Emit\DesktopStrongNameProviderTests.cs (3)

61Assert.NotEqual(provider1, provider2); 71Assert.NotEqual(provider1, provider2); 81Assert.NotEqual(provider1, provider2);

Emit\DeterministicTests.cs (8)

106Assert.NotEqual(mvid1, mvid3); 115Assert.NotEqual(mvid5, mvid7); 118Assert.NotEqual(mvid1, mvid5); 119Assert.NotEqual(mvid3, mvid7); 144Assert.NotEqual(mvid1, mvid3); 145Assert.NotEqual(mvid1, mvid5); 146Assert.NotEqual(mvid3, mvid5); 161Assert.NotEqual(peReader1.PEHeaders.CoffHeader.TimeDateStamp, peReader2.PEHeaders.CoffHeader.TimeDateStamp);

Emit\ResourceTests.cs (3)

162Assert.NotEqual(default, stringTable); 166Assert.NotEqual(default, elevenRsrc); 170Assert.NotEqual(default, wevtRsrc);

Emit\EditAndContinue\EditAndContinueTestBase.cs (1)

88Assert.NotEqual(tree1, tree0);

Attributes\AttributeTests_IsByRefLike.cs (1)

1077Assert.NotEqual("IsByRefLikeAttribute", attr.AttributeClass.Name);

Attributes\AttributeTests_ReadOnlyStruct.cs (1)

646Assert.NotEqual("IsReadOnlyAttribute", attr.AttributeClass.Name);

Attributes\AttributeTests_WellKnownAttributes.cs (15)

56Assert.NotEqual(default, typeDef); 72Assert.NotEqual(default, methodDef); 3337Assert.NotEqual(HandleKind.MethodDefinition, ctor.Kind); 4710Assert.NotEqual("SpecialNameAttribute", name); 4819Assert.NotEqual("SpecialNameAttribute", name); 10713Assert.NotEqual(default, typeC); 10753Assert.NotEqual(default, methodInit); 10754Assert.NotEqual(default, methodSkip); 10755Assert.NotEqual(default, methodInitCopy); 10756Assert.NotEqual(default, methodSkipCopy); 10757Assert.NotEqual(default, methodInitDiff); 10758Assert.NotEqual(default, methodSkipDiff); 10760Assert.NotEqual(methodInit.RelativeVirtualAddress, methodSkip.RelativeVirtualAddress); 10763Assert.NotEqual(methodInit.RelativeVirtualAddress, methodInitDiff.RelativeVirtualAddress); 10764Assert.NotEqual(methodSkip.RelativeVirtualAddress, methodSkipDiff.RelativeVirtualAddress);

Diagnostics\GetDiagnosticsTests.cs (2)

1452Assert.NotEqual(analyzerDiagnostic, compilationDiagnostic); 1453Assert.NotEqual(compilationDiagnostic, analyzerDiagnostic);

Semantics\OutVarTests.cs (3)

976Assert.NotEqual(symbol, other); 1145Assert.NotEqual(symbol, model.LookupSymbols(decl.SpanStart, name: decl.Identifier().ValueText).Single()); 1164Assert.NotEqual(SymbolKind.Field, symbol.Kind);

Semantics\PatternMatchingTestBase.cs (5)

90Assert.NotEqual(symbol, other); 147Assert.NotEqual(symbol, model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText).Single()); 173Assert.NotEqual(symbol, model.LookupSymbols(declarator.SpanStart, name: declarator.Identifier.ValueText).Single()); 187Assert.NotEqual(symbol, model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText).Single()); 195Assert.NotEqual(SymbolKind.Field, symbol.Kind);

Semantics\PatternMatchingTests3.cs (1)

63Assert.NotEqual(default, ySymbol);

Semantics\PatternMatchingTests5.cs (2)

1130Assert.NotEqual(default, yxSymbol); 1322Assert.NotEqual(default, yxSymbol);

Semantics\PrimaryConstructorTests.cs (1)

738Assert.NotEqual("class ", keyword);

Semantics\AccessCheckTests.cs (1)

970Assert.NotEqual(classC, c2);

Semantics\ColorColorTests.cs (15)

Semantics\DeconstructionTests.cs (2)

3957Assert.NotEqual(SymbolKind.Local, symbol.Kind); 3971Assert.NotEqual(SymbolKind.Local, symbol.Kind);

Semantics\DynamicTests.cs (2)

2501Assert.NotEqual("+", operatorSyntax); 2502Assert.NotEqual("-", operatorSyntax);

Semantics\ForEachTests.cs (1)

2891Assert.NotEqual(TypeKind.Error, localSymbolType.TypeKind);

Semantics\GlobalUsingDirectiveTests.cs (8)

3851Assert.NotEqual(ext1, ext2); 3877Assert.NotEqual(ext1, ext2); 3908Assert.NotEqual(ext1, ext2); 3941Assert.NotEqual(ext1, ext2); 3961Assert.NotEqual(ext1, ext2); 3986Assert.NotEqual(ext1, ext2); 4120Assert.NotEqual(ext1, ext2); 4142Assert.NotEqual(ext1, ext2);

Semantics\InterceptorsTests.cs (2)

6884Assert.NotEqual(locationSpecifier, otherLocation); 6886Assert.NotEqual(locationSpecifier.GetHashCode(), otherLocation.GetHashCode());

Semantics\LockTests.cs (2)

52Assert.NotEqual(default, lockExprInfo); 57Assert.NotEqual(default, memberAccessInfo);

Semantics\LookupTests.cs (7)

685Assert.NotEqual(0, baseExprLocation); 688Assert.NotEqual(default, baseExprInfo); 1370Assert.NotEqual(0, eof); 2017Assert.NotEqual(default, symbolInfo); 2047Assert.NotEqual(default, symbolInfo); 2077Assert.NotEqual(default, symbolInfo); 2103Assert.NotEqual(default, symbolInfo);

Semantics\NameOfTests.cs (1)

3057Assert.NotEqual(nameofType, typeofType);

Semantics\NativeIntegerTests.cs (3)

264Assert.NotEqual(underlyingType, nativeIntegerType); 265Assert.NotEqual(nativeIntegerType, underlyingType); 600Assert.NotEqual(containsType(fromMember, useNativeInteger: true), fromMember.Equals(fromUnderlyingMember, TypeCompareKind.ConsiderEverything));

Semantics\NullableReferenceTypesTests.cs (1)

144396Assert.NotEqual(directive == "annotations", IsNullableAnalysisEnabled(comp, "D.M"));

Semantics\NullCoalesceAssignmentTests.cs (5)

47Assert.NotEqual(default, typeInfo); 82Assert.NotEqual(default, whenNullTypeInfo); 89Assert.NotEqual(default, typeInfo); 122Assert.NotEqual(default, whenNullTypeInfo); 132Assert.NotEqual(default, typeInfo);

Semantics\OperatorTests.cs (9)

56Assert.NotEqual(insideEnumDefinition, insideMethodBody); 7727Assert.NotEqual(symbols1[i], symbols2[i]); 8138Assert.NotEqual(symbol1.Parameters[0], symbol5.Parameters[1]); 8486Assert.NotEqual(symbol1, symbol3); 8504Assert.NotEqual(symbol1, symbol4); 8518Assert.NotEqual(symbol1, symbol3); 8527Assert.NotEqual(symbol1, symbol4); 8610Assert.NotEqual(symbols1[i], symbols2[i]); 8710Assert.NotEqual(symbols1[i], symbols2[i]);

Semantics\QueryTests.cs (4)

1462Assert.NotEqual(MethodKind.ReducedExtension, ((IMethodSymbol)info0.CastInfo.Symbol).MethodKind); 1471Assert.NotEqual(MethodKind.ReducedExtension, ((IMethodSymbol)info1.OperationInfo.Symbol).MethodKind); 3382Assert.NotEqual(TypeKind.Error, typeInfo2.Type.TypeKind); 3391Assert.NotEqual(TypeKind.Error, typeInfo1.Type.TypeKind);

Semantics\ScriptSemanticsTests.cs (1)

602Assert.NotEqual(TypeKind.Submission, type.TypeKind);

Semantics\SwitchTests.cs (1)

1159Assert.NotEqual(default, symbolInfo);

Semantics\SyntaxTreeRootTests.cs (1)

54Assert.NotEqual(typeof(CompilationUnitSyntax), root.GetType());

Semantics\TopLevelStatementsTests.cs (2)

362Assert.NotEqual(refMethod, declMethod); 4958Assert.NotEqual(symbol1, symbol2);

Semantics\UnsafeTests.cs (2)

8388Assert.NotEqual(SpecialType.System_Void, ((IPointerTypeSymbol)type).PointedAtType.SpecialType); 10636Assert.NotEqual(SpecialType.None, type.SpecialType);

Semantics\UsingStatementTests.cs (1)

72Assert.NotEqual(default, info);

SourceGeneration\GeneratorDriverTests.cs (13)

SourceGeneration\SyntaxAwareGeneratorTests.cs (4)

346Assert.NotEqual(receiver, previousReceiver); 2101Assert.NotEqual(TimeSpan.Zero, timing.ElapsedTime); 2107Assert.NotEqual(TimeSpan.Zero, timing1.ElapsedTime); 2114Assert.NotEqual(TimeSpan.Zero, timing2.ElapsedTime);

Compilation\CompilationAPITests.cs (10)

362Assert.NotEqual(default, comp.SyntaxTrees); 2853Assert.NotEqual(addBuiltInChecked, symbol); 2854Assert.NotEqual(subtractBuiltIn, symbol); 2855Assert.NotEqual(subtractBuiltInChecked, symbol); 2887Assert.NotEqual(addBuiltIn, symbol); 2889Assert.NotEqual(subtractBuiltIn, symbol); 2890Assert.NotEqual(subtractBuiltInChecked, symbol); 2919Assert.NotEqual(addBuiltIn, symbol); 2921Assert.NotEqual(subtractBuiltIn, symbol); 2922Assert.NotEqual(subtractBuiltInChecked, symbol);

Compilation\CSharpCompilationOptionsTests.cs (2)

48Assert.NotEqual(validNonDefaultValue, validDefaultValue); 483Assert.NotEqual(oldOptions, newOptions);

Compilation\GetSemanticInfoTests.cs (9)

601Assert.NotEqual(default, info); 632Assert.NotEqual(default, info); 845Assert.NotEqual(default, info); 872Assert.NotEqual(default, info); 1070Assert.NotEqual(default, bindInfo); 1089Assert.NotEqual(default, bindInfo); 1114Assert.NotEqual(default, bindInfo); 1135Assert.NotEqual(0, root.SpanStart); 5482Assert.NotEqual(0, invocationInfo.CandidateSymbols.Length);

Compilation\IndexedProperties_BindingTests.cs (2)

151Assert.NotEqual(default, methodGroup); 154Assert.NotEqual(default, indexerGroup);

Compilation\ReferenceManagerTests.cs (1)

1662Assert.NotEqual(comp.Assembly.Identity, actualIdentity);

Compilation\SemanticModelAPITests.cs (21)

254Assert.NotEqual(model1, model2); 274Assert.NotEqual(model1, model2); 281Assert.NotEqual(symbol1, symbol2); 293Assert.NotEqual(model1, model2); 313Assert.NotEqual(model1, model2); 320Assert.NotEqual(symbol1, symbol2); 332Assert.NotEqual(model1, model2); 351Assert.NotEqual(model1, model2); 373Assert.NotEqual(model1, model2); 381Assert.NotEqual(symbol1.ContainingSymbol, symbol2.ContainingSymbol); 382Assert.NotEqual(symbol1, symbol2); 873Assert.NotEqual(pType01, pType02); 882Assert.NotEqual(pMethod01, pMethod02); 900Assert.NotEqual(pParam01, pParam02); 975Assert.NotEqual(sym1.Locations[0], sym2.Locations[0]); 1016Assert.NotEqual(sym1.Locations[0], sym2.Locations[0]); 1214Assert.NotEqual(parasym, argsym1); 1215Assert.NotEqual(parasym, argsym2); 2000Assert.NotEqual(default, info); 2043Assert.NotEqual(default, typeInfo); 2050Assert.NotEqual(default, symbolInfo);

Compilation\SemanticModelGetDeclaredSymbolAPITests.cs (3)

2978Assert.NotEqual(dsyma1, dsyma2); 3934Assert.NotEqual(alias1.Locations.Single(), alias2.Locations.Single()); 4777Assert.NotEqual(structSymbol, interfaceSymbol);

Compilation\SemanticModelGetSemanticInfoTests.cs (7)

3843Assert.NotEqual(CandidateReason.None, semanticInfo.CandidateReason); 3844Assert.NotEqual(0, semanticInfo.CandidateSymbols.Length); 6348Assert.NotEqual(semanticInfo.Type, param.Type); 9278Assert.NotEqual(type, constructedFrom); 9282Assert.NotEqual(type.TypeParameters[0], type.OriginalDefinition.TypeParameters[0]); // alpha renamed 14488Assert.NotEqual(default, typeInfo); 14742Assert.NotEqual(default, info1);

DocumentationComments\CrefTests.cs (2)

5569Assert.NotEqual(crefTypeParam, sourceTypeParam); 5570Assert.NotEqual(sourceTypeParam, crefTypeParam);

Symbols\AccessorOverriddenOrHiddenMembersTests.cs (1)

887Assert.NotEqual(MethodKind.Ordinary, m.MethodKind);

Symbols\AnonymousTypesSemanticsTests.cs (1)

84Assert.NotEqual(info0.Type, info1.Type);

Symbols\AnonymousTypesSymbolTests.cs (2)

1000Assert.NotEqual(default, typeDescr); 1698Assert.NotEqual(typeA3.Locations[0], typeA4.Locations[0]);

Symbols\CompilationCreationTests.cs (1)

2528Assert.NotEqual(SymbolKind.ErrorType, typeC5.Kind);

Symbols\CorLibrary\CorTypes.cs (3)

76Assert.NotEqual(TypeKind.Error, t.TypeKind); 93Assert.NotEqual(TypeKind.Error, t.TypeKind); 151Assert.NotEqual(TypeKind.Error, t.TypeKind);

Symbols\DefaultInterfaceImplementationTests.cs (13)

Symbols\DestructorTests.cs (1)

417Assert.NotEqual(default, info);

Symbols\ExtendedPartialMethodsTests.cs (1)

3500Assert.NotEqual(implSymbol, defSymbol);

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

1037Assert.NotEqual(expectIndexer, property.MustCallMethodsDirectly);

Symbols\Metadata\PE\NoPia.cs (3)

1239Assert.NotEqual(SymbolKind.ErrorType, varI5.Kind); 1240Assert.NotEqual(SymbolKind.ErrorType, varI6.Kind); 1259Assert.NotEqual(SymbolKind.ErrorType, varI1.Kind);

Symbols\Metadata\PE\TypeForwarders.cs (2)

1498Assert.NotEqual(TypeKind.Error, type.TypeKind); 1767Assert.NotEqual(TypeKind.Error, type.TypeKind);

Symbols\MethodEqualityTests.cs (6)

226Assert.NotEqual(invokedMethods[0], classMethodDeclaration); 227Assert.NotEqual(invokedMethods[1], classMethodDeclaration); 228Assert.NotEqual(invokedMethods[2], classMethodDeclaration); 231Assert.NotEqual(invokedMethods[5], classMethodDeclaration); 258Assert.NotEqual(method1, method2); 259Assert.NotEqual(method2, method1);

Symbols\MissingSpecialMember.cs (2)

310Assert.NotEqual(Accessibility.NotApplicable, lookupType.DeclaredAccessibility); 541Assert.NotEqual(SymbolKind.ErrorType, symbol.Kind);

Symbols\Source\BaseClassTests.cs (2)

1098Assert.NotEqual(B1, B2); 1224Assert.NotEqual(B1, B2);

Symbols\Source\FileModifierTests.cs (1)

4291Assert.NotEqual(types[0], types[1]);

Symbols\SymbolDistinguisherTests.cs (1)

318Assert.NotEqual(TypeKind.Error, validType.TypeKind);

Symbols\SymbolEqualityTests.cs (2)

382Assert.NotEqual(SymbolEqualityComparer.Default.GetHashCode(symbol1), SymbolEqualityComparer.Default.GetHashCode(symbol2)); 385Assert.NotEqual(SymbolEqualityComparer.ConsiderEverything.GetHashCode(symbol1), SymbolEqualityComparer.ConsiderEverything.GetHashCode(symbol2));

Diagnostics\DiagnosticTest.cs (1)

220Assert.NotEqual(0, ErrorFacts.GetWarningLevel(errorCode));

Diagnostics\LineSpanDirectiveTests.cs (1)

466Assert.NotEqual(SyntaxKind.None, directive.DirectiveNameToken.Kind());

Diagnostics\LocationsTests.cs (1)

521Assert.NotEqual(locationWithMapping, locationWithoutMapping);

Generated\Syntax.Test.xml.Generated.cs (244)

LexicalAndXml\LexicalTests.cs (233)

LexicalAndXml\PreprocessorTests.cs (1)

251Assert.NotEqual(SyntaxKind.None, ld.File.Kind());

LexicalAndXml\XmlDocCommentTests.cs (11)

Parsing\CSharpParseOptionsTests.cs (1)

128Assert.NotEqual(options1.GetHashCode(), options2.GetHashCode());

Parsing\DeclarationParsingTests.cs (877)

Parsing\ExpressionParsingTests.cs (189)

Parsing\NameParsingTests.cs (4)

781Assert.NotEqual(default, tok); 783Assert.NotEqual(text, tok.ValueText); 797Assert.NotEqual(default, tok); 799Assert.NotEqual(text, tok.ValueText);

Parsing\ParsingErrorRecoveryTests.cs (77)

Parsing\RoundTrippingTests.cs (1)

37Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length);

Parsing\StatementParsingTests.cs (331)

Syntax\StructuredTriviaTests.cs (1)

66Assert.NotEqual(default(SyntaxTrivia), sTrivia);

Syntax\SyntaxNodeTests.cs (23)

Syntax\SyntaxRewriterTests.cs (4)

575Assert.NotEqual(expr1, expr2); 582Assert.NotEqual(token1, token2); 621Assert.NotEqual(expr1, expr2); 628Assert.NotEqual(token1, token2);

Syntax\SyntaxTreeTests.cs (1)

236Assert.NotEqual(tree, newTree);

CompilationTestUtils.cs (1)

474Assert.NotEqual(CodeAnalysis.NullableFlowState.None, typeInfo.Nullability.FlowState);

Emit\CompilationOutputsTests.cs (1)

97Assert.NotEqual(0, currentPEStream!.Length);

SymbolFinder\DependentTypeFinderTests.cs (9)

Utilities\SymbolEquivalenceComparerTests.cs (1)

1726Assert.NotEqual(SymbolEquivalenceComparer.Instance.GetHashCode(namespace1),

VisualBasicParsingTests.cs (1)

31Assert.NotEqual(SyntaxKind.None, kind);

ResultProviderTestBase.cs (1)

498Assert.NotEqual(UnspecifiedValue, actualSuccess.Value);

DocumentChanges\DocumentChangesTests.cs (1)

244Assert.NotEqual(expected, documentTextFromWorkspace);

References\FindAllReferencesHandlerTests.cs (1)

377Assert.NotEqual(definitionId, referenceItems[i].Id);

UriTests.cs (1)

119Assert.NotEqual(expectedDocumentUri.AbsolutePath, lowercaseUri.AbsolutePath);

Workspaces\LspWorkspaceManagerTests.cs (1)

562Assert.NotEqual(

DeterministicKeyBuilderTests.cs (1)

359Assert.NotEqual(key, compilation.GetDeterministicKey());

RoundTripUtil.cs (1)

174Assert.NotEqual(originalMdv, rebuildMdv);

RemoteAnalyzerAssemblyLoaderTests.cs (1)

36Assert.NotEqual(alc1, alc2);

MetadataShadowCopyProviderTests.cs (2)

92Assert.NotEqual(dll.Path, sc1.PrimaryModule.FullPath); 128Assert.NotEqual(dll.Path, sc1.PrimaryModule.FullPath);

Assert\AssertEx.cs (1)

1057Assert.NotEqual<T>(expected, actual);

Compilation\ControlFlowGraphVerifier.cs (8)

131Assert.NotEqual(0, i); 132Assert.NotEqual(blocks.Length - 1, i); 202Assert.NotEqual(ControlFlowConditionKind.None, predecessor.ConditionKind); 254Assert.NotEqual(ControlFlowBranchSemantics.Return, conditionalBranch.Semantics); 255Assert.NotEqual(ControlFlowBranchSemantics.Throw, conditionalBranch.Semantics); 256Assert.NotEqual(ControlFlowBranchSemantics.StructuredExceptionHandling, conditionalBranch.Semantics); 311Assert.NotEqual(ControlFlowBranchSemantics.Return, nextBranch.Semantics); 312Assert.NotEqual(ControlFlowBranchSemantics.Throw, nextBranch.Semantics);

Compilation\OperationTreeVerifier.cs (2)

760Assert.NotEqual(OperationKind.VariableDeclaration, operation.Resources.Kind); 761Assert.NotEqual(OperationKind.VariableDeclarator, operation.Resources.Kind);

Compilation\TestOperationVisitor.cs (3)

410Assert.NotEqual(OperationKind.YieldReturn, operation.Kind); 465Assert.NotEqual(OperationKind.VariableDeclaration, operation.Resources.Kind); 466Assert.NotEqual(OperationKind.VariableDeclarator, operation.Resources.Kind);

Metadata\EncValidation.cs (1)

41Assert.NotEqual(default(Guid), currentReader.GetGuid(currentModule.GenerationId));

Metadata\MetadataValidation.cs (3)

72Assert.NotEqual("MarshalAsAttribute", GetAttributeName(metadataReader, ca)); 91Assert.NotEqual(0, (int)(field.Attributes & FieldAttributes.HasFieldMarshal)); 118Assert.NotEqual(0, (int)(paramRow.Attributes & ParameterAttributes.HasFieldMarshal));

PDB\DeterministicBuildCompilationTestHelpers.cs (2)

116Assert.NotEqual(-1, terminatorIndex); 124Assert.NotEqual(-1, terminatorIndex);

AnalyzerAssemblyLoaderTests.cs (1)

1478Assert.NotEqual(INVALID_FILE_ATTRIBUTES, result);

Analyzers\AnalyzerConfigTests.cs (2)

1241Assert.NotEqual(default, options[i]); 1262Assert.NotEqual(default, options[i]);

Collections\List\IList.Generic.Tests.cs (2)

210Assert.NotEqual(default(T), list[0]); 245Assert.NotEqual(default(T), list[lastIndex]);

CorLibTypesTests.cs (2)

86Assert.NotEqual(SymbolKind.ErrorType, symbol.Kind); 231Assert.NotEqual(cv1.GetHashCode(), cv2.GetHashCode());

Emit\EmitOptionsTests.cs (1)

30Assert.NotEqual(validNonDefaultValue, validDefaultValue);

FileLinePositionSpanTests.cs (5)

71Assert.NotEqual(hash1, hash2); 72Assert.NotEqual(hash1, hash3); 73Assert.NotEqual(hash3, hash4); 74Assert.NotEqual(hash4, hash5); 75Assert.NotEqual(hash5, hash6);

InternalUtilities\AdditionalTextComparerTests.cs (4)

19Assert.NotEqual(text1, text2); 31Assert.NotEqual(hash1, hash2); 48Assert.NotEqual(comparerHash1, comparerHash2); 61Assert.NotEqual(comparerHash1, comparerHash2);

LinePositionTests.cs (6)

65Assert.NotEqual(hash1, hash2); 66Assert.NotEqual(hash1, hash3); 67Assert.NotEqual(hash1, hash4); 68Assert.NotEqual(hash2, hash3); 69Assert.NotEqual(hash2, hash4); 70Assert.NotEqual(hash3, hash4);

MetadataReferences\AssemblyPortabilityPolicyTests.cs (2)

390Assert.NotEqual(IntPtr.Zero, policy.ConfigCookie); 428Assert.NotEqual(policy1, policy2);

MetadataReferences\MetadataNameLimitTests.cs (1)

52Assert.NotEqual(withinLimit, MetadataWriter.IsTooLongInternal(fullName, maxLength));

StringTableTests.cs (1)

36Assert.NotEqual((object)s1, (object)s2);

Symbols\NullabilityInfoTests.cs (2)

40Assert.NotEqual(n1, n2); 41Assert.NotEqual(n1.GetHashCode(), n2.GetHashCode());

Text\LargeTextTests.cs (1)

147Assert.NotEqual(first, second);

Text\SourceTextTests.cs (1)

194Assert.NotEqual(text, changed);

Text\StringTextTest.cs (1)

100Assert.NotEqual(first, second);

Text\TextSpanTest.cs (5)

69Assert.NotEqual(s1, s2); 83Assert.NotEqual(s1, s2); 205Assert.NotEqual(default, span1); 210Assert.NotEqual(default, span2); 230Assert.NotEqual<object>(new string('a', 3), span1);

CommandLineTests.vb (2)

7392Assert.NotEqual(0, exitCode) 9064Assert.NotEqual(0, exitCode)

SarifErrorLoggerTests.vb (3)

101Assert.NotEqual(0, exitCode) 143Assert.NotEqual(0, exitCode) 185Assert.NotEqual(0, exitCode)

CodeGen\CodeGenTuples.vb (1)

23212Assert.NotEqual(type, underlyingType)

Semantics\QueryExpressions_FlowAnalysis.vb (1)

367Assert.NotEqual(ss(0), ss(1))

ParserTestUtilities.vb (1)

344Assert.NotEqual(node.Kind(), SyntaxKind.None)

VisualStudioMSBuildWorkspaceTests.cs (4)

401Assert.NotEqual(dversion, dversion1); // new document version 406Assert.NotEqual(latestDV, latestDV1); 415Assert.NotEqual(document1.Project.Version, document2.Project.Version); // project did change, so project versions should be different 422Assert.NotEqual(solution2.Version, solution3.Version); // solution changed, added project.

FindReferencesTests.cs (2)

555Assert.NotEqual(typeResult.Locations.Single().Location.SourceSpan, constructorResult.Locations.Single().Location.SourceSpan); 588Assert.NotEqual(typeResult.Locations.Single().Location.SourceSpan, constructorResult.Locations.Single().Location.SourceSpan);

Remote\ServiceDescriptorTests.cs (1)

191Assert.NotEqual(original, deserialized);

SolutionTests\ProjectSemanticVersionTests.cs (1)

263Assert.NotEqual(await project1.GetSemanticVersionAsync(), await project2.GetSemanticVersionAsync());

SolutionTests\SolutionTestHelpers.cs (1)

27Assert.NotEqual(getter(instance), validNonDefaultValue);

SolutionTests\SolutionTests.cs (19)

467Assert.NotEqual(text1.ToString(), text2.ToString()); 555Assert.NotEqual(text1.ToString(), text2.ToString()); 638Assert.NotEqual(text1.ToString(), text2.ToString()); 721Assert.NotEqual(text1.ToString(), text2.ToString()); 797Assert.NotEqual(text1.ToString(), text2.ToString()); 884Assert.NotEqual(text1.ToString(), text2.ToString()); 3049Assert.NotEqual(oldParseOptions, newUpdatedParseOptions); 3167Assert.NotEqual(solution1, solution2); 4085Assert.NotEqual( 4089Assert.NotEqual( 4110Assert.NotEqual( 4114Assert.NotEqual( 4196Assert.NotEqual( 4204Assert.NotEqual( 4602Assert.NotEqual(oldVersion, newVersion); 4696Assert.NotEqual(originalCompilation.Options, newCompilation.Options); 4863Assert.NotEqual(originalCompilation.Options, newCompilation.Options); 5719Assert.NotEqual(syntaxTree1, forkedSyntaxTree1); 5722Assert.NotEqual(compilation1, forkedCompilation1);

SolutionTests\SolutionWithSourceGeneratorTests.cs (7)

509Assert.NotEqual(DocumentationMode.Diagnose, project.ParseOptions!.DocumentationMode); 955Assert.NotEqual(project0, project1); 961Assert.NotEqual(project0, project2); 962Assert.NotEqual(project1, project2); 971Assert.NotEqual(project0, project3); 972Assert.NotEqual(project1, project3); 973Assert.NotEqual(project2, project3);

SolutionTests\SourceGeneratorExecutionVersionMapTests.cs (1)

21Assert.NotEqual(projectId1, projectId2);

SymbolKeyTests.cs (1)

1316Assert.NotEqual(symbolKey1.ToString(), symbolKey2.ToString());

SyntaxNodeTests.cs (3)

111Assert.NotEqual(latestMethod, methodDecl); 120Assert.NotEqual(trackedRoot, root2); 129Assert.NotEqual(finalMethodDecl, methodDecl);

UtilityTest\BKTreeTests.cs (3)

63Assert.NotEqual(testValues.Length, items.Length); 76Assert.NotEqual(testValues.Length, items.Length); 90Assert.NotEqual(testValues.Length, items.Length);

WorkspaceTests\WorkspaceReferenceTests.cs (2)

167Assert.NotEqual(references1, references2); 197Assert.NotEqual(references1, references2);

MsiTests.cs (1)

58Assert.NotEqual(MsiUtils.GetProperty(msiPath603, MsiProperty.UpgradeCode), MsiUtils.GetProperty(msiPath604, MsiProperty.UpgradeCode));

CollectionAssertsTests.cs (20)

EqualityAssertsTests.cs (138)

EquivalenceAssertsTests.cs (1)

1547 Assert.NotEqual(assemblyPath, assemblyParentPath);

DistributedCacheTests.cs (2)

345Assert.NotEqual(0, segment.Offset); 348Assert.NotEqual(size, segment.Array.Length);

SizeTests.cs (2)

52Assert.NotEqual(expected, actual); 87Assert.NotEqual(expected, actual.Value);

StampedeTests.cs (1)

139Assert.NotEqual(first, second);

Classification\DataClassificationSetTests.cs (2)

27Assert.NotEqual(dc1, dc6); 49Assert.NotEqual(dc1, dc6);

Classification\DataClassificationTests.cs (2)

33Assert.NotEqual(dc.GetHashCode(), new DataClassification(TaxonomyName + "X", Value).GetHashCode()); 34Assert.NotEqual(dc.GetHashCode(), new DataClassification(TaxonomyName, Value + 1).GetHashCode());

ErasingRedactorTests.cs (1)

48Assert.NotEqual(input, bufferString);

HmacRedactorTest.cs (1)

45Assert.NotEqual(0, length);

RedactionFakesEventCollectorTests.cs (2)

48Assert.NotEqual(first.GetHashCode(), third.GetHashCode()); 68Assert.NotEqual(first.GetHashCode(), third.GetHashCode());

ByteArrayEqualityComparerTests.cs (1)

63Assert.NotEqual(_comparer.GetHashCode(x), _comparer.GetHashCode(y));

Linux\AcceptanceTest.cs (2)

36Assert.NotEqual(default, provider.Resources); 37Assert.NotEqual(default, provider.GetSnapshot());

EmbeddedFileProviderTests.cs (4)

51Assert.NotEqual(default(DateTimeOffset), fileInfo.LastModified); 117Assert.NotEqual(default(DateTimeOffset), fileInfo.LastModified); 155Assert.NotEqual(default(DateTimeOffset), fileInfo.LastModified); 193Assert.NotEqual(default(DateTimeOffset), fileInfo.LastModified);

Logging\LoggerEnrichmentOptionsTests.cs (2)

42Assert.NotEqual(ValidateOptionsResult.Success, v.Validate(null, o)); 45Assert.NotEqual(ValidateOptionsResult.Success, v.Validate(null, o));

SyntaxContextReceiverTests.cs (1)

76Assert.NotEqual(declaration.Value[0], declaration.Value[1]);

LogMethodTests.cs (10)

LogPropertiesTests.cs (4)

473Assert.NotEqual(0, latestRecord.Id.Id); 524Assert.NotEqual(0, latestRecord.Id.Id); 549Assert.NotEqual(0, latestRecord.Id.Id); 575Assert.NotEqual(0, latestRecord.Id.Id);

TagProviderTests.cs (5)

83Assert.NotEqual(0, latestRecord.Id.Id); 106Assert.NotEqual(0, latestRecord.Id.Id); 127Assert.NotEqual(0, latestRecord.Id.Id); 138Assert.NotEqual(0, latestRecord.Id.Id); 188Assert.NotEqual(0, latestRecord.Id.Id);

JSRuntimeTest.cs (1)

35Assert.NotEqual(runtime.BeginInvokeCalls[0].AsyncHandle, call.AsyncHandle);

AutoFitTests.cs (1)

557Assert.NotEqual(0, metrices.MeanSquaredError);

InferredPipelineTests.cs (3)

40Assert.NotEqual(inferredPipeline1.GetHashCode(), inferredPipeline2.GetHashCode()); 49Assert.NotEqual(inferredPipeline1.GetHashCode(), inferredPipeline2.GetHashCode()); 67Assert.NotEqual(inferredPipeline1.GetHashCode(), inferredPipeline2.GetHashCode());

SweeperTests.cs (1)

258Assert.NotEqual(parameterSet.GetHashCode(), parameterSetNewHash.GetHashCode());

UnitTests\TestCustomTypeRegister.cs (1)

312Assert.NotEqual(a, DataViewTypeManager.GetDataViewType(typeof(AlienBody), new[] { f }));

UnitTests\TestEntryPoints.cs (1)

4552Assert.NotEqual(0, feat.GetValues()[0]);

Debugging.cs (1)

154Assert.NotEqual(0, rowSum);

Training.cs (1)

162Assert.NotEqual(firstModelWeights, secondModelWeights);

TestTransposer.cs (1)

31Assert.NotEqual(0, vecType?.Size);

ImagesTests.cs (2)

1191Assert.NotEqual(100, dataObjects[0].LoadedImage.Height); 1200Assert.NotEqual(100, prediction.LoadedImage.Height);

Scenarios\Api\TestApi.cs (2)

372Assert.NotEqual(simpleTestWorkClass, simpleWithSeedTestWorkClass); 400Assert.NotEqual(uniqueTest, uniqueSeedTest);

TextLoaderTests.cs (3)

1100Assert.NotEqual(Single.NaN, featuresPeriodArray[i]); 1113Assert.NotEqual(Single.NaN, featuresCommaArray[i]); 1118Assert.NotEqual(Single.NaN, featuresPeriodArray[i]);

TrainerEstimators\TreeEnsembleFeaturizerTest.cs (2)

704Assert.NotEqual(metrics.MeanAbsoluteError, secondMetrics.MeanAbsoluteError); 705Assert.NotEqual(metrics.MeanSquaredError, secondMetrics.MeanSquaredError);

Transformers\CountTargetEncodingTests.cs (1)

110Assert.NotEqual(weights, weightsNoNoise);

Transformers\NormalizerTests.cs (6)

923Assert.NotEqual(0f, transformParams.Mean); 924Assert.NotEqual(0f, transformParams.StandardDeviation); 928Assert.NotEqual(0f, noCdfParams.Scale); 966Assert.NotEqual(0f, transformParams.Mean[i]); 967Assert.NotEqual(0f, transformParams.StandardDeviation[i]); 971Assert.NotEqual(0f, noCdfParams.Scale[i]);

CodeGenTests.cs (16)

CacheControlHeaderValueTest.cs (1)

557Assert.NotEqual(x.GetHashCode(), y.GetHashCode());

ContentDispositionHeaderValueTest.cs (3)

441Assert.NotEqual(contentDisposition1.GetHashCode(), contentDisposition2.GetHashCode()); 442Assert.NotEqual(contentDisposition1.GetHashCode(), contentDisposition3.GetHashCode()); 443Assert.NotEqual(contentDisposition2.GetHashCode(), contentDisposition3.GetHashCode());

ContentRangeHeaderValueTest.cs (4)

111Assert.NotEqual(range1.GetHashCode(), range2.GetHashCode()); 112Assert.NotEqual(range1.GetHashCode(), range3.GetHashCode()); 113Assert.NotEqual(range2.GetHashCode(), range3.GetHashCode()); 115Assert.NotEqual(range1.GetHashCode(), range5.GetHashCode());

EntityTagHeaderValueTest.cs (4)

70Assert.NotEqual(etag1.GetHashCode(), etag2.GetHashCode()); 71Assert.NotEqual(etag1.GetHashCode(), etag3.GetHashCode()); 72Assert.NotEqual(etag1.GetHashCode(), etag4.GetHashCode()); 73Assert.NotEqual(etag1.GetHashCode(), etag6.GetHashCode());

MediaTypeHeaderValueTest.cs (3)

354Assert.NotEqual(mediaType1.GetHashCode(), mediaType2.GetHashCode()); 355Assert.NotEqual(mediaType1.GetHashCode(), mediaType3.GetHashCode()); 356Assert.NotEqual(mediaType2.GetHashCode(), mediaType3.GetHashCode());

NameValueHeaderValueTest.cs (4)

177Assert.NotEqual(nameValue1.GetHashCode(), nameValue2.GetHashCode()); 181Assert.NotEqual(nameValue1.GetHashCode(), nameValue2.GetHashCode()); 197Assert.NotEqual(nameValue1.GetHashCode(), nameValue2.GetHashCode()); 645Assert.NotEqual(input, actual);

RangeConditionHeaderValueTest.cs (3)

63Assert.NotEqual(rangeCondition1.GetHashCode(), rangeCondition3.GetHashCode()); 64Assert.NotEqual(rangeCondition3.GetHashCode(), rangeCondition4.GetHashCode()); 66Assert.NotEqual(rangeCondition1.GetHashCode(), rangeCondition6.GetHashCode());

RangeHeaderValueTest.cs (3)

57Assert.NotEqual(range1.GetHashCode(), range3.GetHashCode()); 58Assert.NotEqual(range1.GetHashCode(), range4.GetHashCode()); 59Assert.NotEqual(range1.GetHashCode(), range5.GetHashCode());

RangeItemHeaderValueTest.cs (3)

63Assert.NotEqual(rangeItem1.GetHashCode(), rangeItem2.GetHashCode()); 64Assert.NotEqual(rangeItem1.GetHashCode(), rangeItem3.GetHashCode()); 65Assert.NotEqual(rangeItem1.GetHashCode(), rangeItem4.GetHashCode());

StringWithQualityHeaderValueTest.cs (5)

70Assert.NotEqual(value1.GetHashCode(), value4.GetHashCode()); 71Assert.NotEqual(value1.GetHashCode(), value5.GetHashCode()); 72Assert.NotEqual(value1.GetHashCode(), value6.GetHashCode()); 73Assert.NotEqual(value1.GetHashCode(), value7.GetHashCode()); 75Assert.NotEqual(value4.GetHashCode(), value9.GetHashCode());

InteractionTests.cs (1)

53Assert.NotEqual(2, process.ExitCode);

Microsoft\VisualBasic\MyServices\Internal\ProgressDialogTests.cs (1)

18Assert.NotEqual(2, process.ExitCode);

Options\OptionViewModelTests.cs (1)

65Assert.NotEqual(modifiedPreview, originalPreview);

ProjectSystemShim\CPS\SourceFileHandlingTests.cs (1)

101Assert.NotEqual(oldVersion, newVersion);

Reader\PdbValidation.cs (3)

133Assert.NotEqual(default(DebugInformationFormat), format); 134Assert.NotEqual(DebugInformationFormat.Embedded, format); 238Assert.NotEqual(DebugInformationFormat.Embedded, format);

Data.Validation\LengthAttributeTests.cs (1)

375Assert.NotEqual(ValidationResult.Success, result);

Data.Validation\TimeSpanAttributeTests.cs (1)

252Assert.NotEqual(ValidationResult.Success, result);

Memoization\MemoizeTests.cs (2)

168Assert.NotEqual(Args(0).GetHashCode(), Args(1).GetHashCode()); 226Assert.NotEqual(Args(0, 0).GetHashCode(), Args(0, 1).GetHashCode());

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

1129Assert.NotEqual(0, received);

System\Drawing\BitmapTests.cs (2)

601Assert.NotEqual(IntPtr.Zero, handle); 698Assert.NotEqual(IntPtr.Zero, handle);

System\Drawing\Drawing2D\GraphicsPathTests.cs (1)

1047Assert.NotEqual(gp1.PointCount, gp3.PointCount);

System\Drawing\Drawing2D\HatchBrushTests.cs (3)

21Assert.NotEqual(foreColor, brush.ForegroundColor); 40Assert.NotEqual(foreColor, brush.ForegroundColor); 43Assert.NotEqual(backColor, brush.BackgroundColor);

System\Drawing\Drawing2D\PathGradientBrushTests.cs (2)

181Assert.NotEqual(Color.FromArgb(255, 0, 0, 255), brush.SurroundColors[0]); 554Assert.NotEqual(Color.Pink, brush.InterpolationColors.Colors[0]);

System\Drawing\FontConverterTests.cs (1)

229Assert.NotEqual(GraphicsUnit.Display, item);

System\Drawing\FontTests.cs (6)

816Assert.NotEqual(IntPtr.Zero, hfont); 817Assert.NotEqual(hfont, font.ToHfont()); 829Assert.NotEqual(IntPtr.Zero, hfont); 830Assert.NotEqual(hfont, font.ToHfont()); 833Assert.NotEqual(font.Name, newFont.Name); 888Assert.NotEqual(font1.GetHashCode(), font2.GetHashCode());

System\Drawing\GraphicsTests.cs (3)

26Assert.NotEqual(IntPtr.Zero, hdc); 176Assert.NotEqual(hdc1, hdc2); 1574Assert.NotEqual(color, imageColor);

System\Drawing\IconTests.cs (5)

227Assert.NotEqual(sourceIcon.Handle, icon.Handle); 239Assert.NotEqual(sourceIcon.Handle, icon.Handle); 284Assert.NotEqual(icon.Handle, clone.Handle); 296Assert.NotEqual(icon.Handle, clone.Handle); 325Assert.NotEqual(IntPtr.Zero, handle);

System\Drawing\Imaging\MetafileTests.cs (1)

908Assert.NotEqual(IntPtr.Zero, metafile.GetHenhmetafile());

System\Drawing\Printing\PrinterSettingsTests.cs (3)

514Assert.NotEqual(IntPtr.Zero, handle); 525Assert.NotEqual(IntPtr.Zero, handle); 542Assert.NotEqual(IntPtr.Zero, handle);

System\Drawing\RegionTests.cs (5)

914Assert.NotEqual(IntPtr.Zero, handle1); 915Assert.NotEqual(handle1, handle2); 919Assert.NotEqual(handle3, handle1); 938Assert.NotEqual(IntPtr.Zero, handle); 953Assert.NotEqual(IntPtr.Zero, handle);

System\Drawing\SolidBrushTests.cs (2)

32Assert.NotEqual(Color.PeachPuff, clone.Color); 36Assert.NotEqual(Color.PapayaWhip, clone.Color);

ServiceModel\ClientBaseTest.cs (7)

40Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory); 61Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory); 88Assert.NotEqual(client1.ChannelFactory, client4.ChannelFactory); 118Assert.NotEqual(client1.ChannelFactory, client3.ChannelFactory); 128Assert.NotEqual(existingChannelFactory, client4.ChannelFactory); 146Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory); 167Assert.NotEqual(client1.ChannelFactory, client2.ChannelFactory);

ServiceModel\FaultExceptionTest.cs (2)

121Assert.NotEqual(string.Empty, exception.Reason.ToString()); 171Assert.NotEqual(string.Empty, exception.Reason.ToString());

System\ComponentModel\Design\ByteViewerTests.cs (9)

232Assert.NotEqual(IntPtr.Zero, control.Handle); 285Assert.NotEqual(IntPtr.Zero, control.Handle); 357Assert.NotEqual(IntPtr.Zero, control.Handle); 473Assert.NotEqual(IntPtr.Zero, control.Handle); 548Assert.NotEqual(IntPtr.Zero, control.Handle); 651Assert.NotEqual(IntPtr.Zero, control.Handle); 764Assert.NotEqual(IntPtr.Zero, control.Handle); 948Assert.NotEqual(IntPtr.Zero, control.Handle); 976Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Drawing\Design\ToolboxItemTests.cs (2)

1355Assert.NotEqual(bitmap, item.Bitmap); 1398Assert.NotEqual(bitmap, item.Bitmap);

System\Windows\Forms\Design\Behavior\SnapLineTests.cs (1)

103Assert.NotEqual(snapLine.IsHorizontal, snapLine.IsVertical);

Interop\Oleaut32\ITypeInfoTests.cs (4)

55Assert.NotEqual(0u, index); 113Assert.NotEqual(IntPtr.Zero, (IntPtr)pFuncDesc->lprgelemdescParam); 217Assert.NotEqual(0u, refType); 234Assert.NotEqual(0u, refType);

Interop\Shell32\ShellItemTests.cs (1)

20Assert.NotEqual(0, (nint)ppidl);

Windows\Win32\AgileComPointerTests.cs (2)

40Assert.NotEqual(originalPtr, (nint)proxyStreamPtr.Value); 47Assert.NotEqual((nint)originalUnknownPtr.Value, proxyUnknownPtr);

CheckedListBoxTests.cs (4)

190Assert.NotEqual(IntPtr.Zero, control.Handle); 298Assert.NotEqual(IntPtr.Zero, control.Handle); 328Assert.NotEqual(IntPtr.Zero, control.Handle); 433Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\AccessibleObjects\AccessibleObjectTests.cs (4)

1198Assert.NotEqual(0, iAccessible.accNavigate(navDir, varChild)); 2641Assert.NotEqual(0, ((int)accessible.accState & 0x100000)); // STATE_SYSTEM_FOCUSABLE 2672Assert.NotEqual(0, ((int)accessible.accState & 0x100000)); // STATE_SYSTEM_FOCUSABLE 2729Assert.NotEqual(expectedIdChild, idChild);

System\Windows\Forms\AccessibleObjects\ComboBox.ComboBoxAccessibleObjectTests.cs (6)

42Assert.NotEqual(AccessibleStates.Collapsed, accessibleObject.State & AccessibleStates.Collapsed); 47Assert.NotEqual(AccessibleStates.Expanded, accessibleObject.State & AccessibleStates.Expanded); 67Assert.NotEqual(AccessibleStates.Collapsed, accessibleObject.State & AccessibleStates.Collapsed); 68Assert.NotEqual(AccessibleStates.Expanded, accessibleObject.State & AccessibleStates.Expanded); 72Assert.NotEqual(AccessibleStates.Collapsed, accessibleObject.State & AccessibleStates.Collapsed); 73Assert.NotEqual(AccessibleStates.Expanded, accessibleObject.State & AccessibleStates.Expanded);

System\Windows\Forms\AccessibleObjects\Control.ControlAccessibleObjectTests.cs (4)

75Assert.NotEqual(IntPtr.Zero, ownerControl.Handle); 180Assert.NotEqual(IntPtr.Zero, controlAccessibleObject.Handle); 1064Assert.NotEqual(IntPtr.Zero, ownerControl.Handle); 1083Assert.NotEqual(IntPtr.Zero, ownerControl.Handle);

System\Windows\Forms\AccessibleObjects\DataGridViewColumnHeaderCellAccessibleObjectTests.cs (1)

79Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);

System\Windows\Forms\AccessibleObjects\DataGridViewRowHeaderCellAccessibleObjectTests.cs (1)

130Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);

System\Windows\Forms\AccessibleObjects\DataGridViewTopLeftHeaderCellAccessibleObjectTests.cs (1)

56Assert.NotEqual(Rectangle.Empty, cell.AccessibilityObject.Bounds);

System\Windows\Forms\AccessibleObjects\ErrorProvider.ControlItem.ControlItemAccessibleObjectTests.cs (1)

56Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);

System\Windows\Forms\AccessibleObjects\ErrorProviderAccessibleObjectTests.cs (3)

156Assert.NotEqual(errorWindowControlType, actualWindowAccessibleName); 160Assert.NotEqual(controlItemControlType, actualItemAccessibleName); 162Assert.NotEqual(actualWindowAccessibleName, actualItemAccessibleName);

System\Windows\Forms\AccessibleObjects\ListVIew.ListViewAccessibleObjectTests.cs (3)

102Assert.NotEqual(firstChild, lastChild); 132Assert.NotEqual(firstChild, lastChild); 173Assert.NotEqual(firstChild, lastChild);

System\Windows\Forms\AccessibleObjects\ListViewGroup.ListViewGroupAccessibleObjectTests.cs (11)

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemAccessibleObjectTests.cs (7)

72Assert.NotEqual(IntPtr.Zero, listView.Handle); 652Assert.NotEqual(IntPtr.Zero, listView.Handle); 714Assert.NotEqual(IntPtr.Zero, listView.Handle); 848Assert.NotEqual(IntPtr.Zero, listView.Handle); 896Assert.NotEqual(IntPtr.Zero, listView.Handle); 931Assert.NotEqual(IntPtr.Zero, listView.Handle); 1789Assert.NotEqual(2, accessibleObject.GetChildCount());

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewItemWithImageAccessibleObjectTests.cs (1)

42Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\AccessibleObjects\ListViewItem.ListViewSubItem.ListViewSubItemAccessibleObjectTests.cs (7)

228Assert.NotEqual(Rectangle.Empty, subItemAccObj1.Bounds); 229Assert.NotEqual(Rectangle.Empty, subItemAccObj2.Bounds); 230Assert.NotEqual(Rectangle.Empty, subItemAccObj3.Bounds); 232Assert.NotEqual(Rectangle.Empty, subItemAccObjInGroup1.Bounds); 233Assert.NotEqual(Rectangle.Empty, subItemAccObjInGroup2.Bounds); 234Assert.NotEqual(Rectangle.Empty, subItemAccObjInGroup3.Bounds); 906Assert.NotEqual(itemAccessibleObject.Bounds, subItemAccessibleObject.Bounds);

System\Windows\Forms\AccessibleObjects\ScrollBar.ScrollBarChildAccessibleObjectTests.cs (1)

48Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarFirstButtonAccessibleObjectTests.cs (1)

19Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarLastButtonAccessibleObjectTests.cs (1)

19Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);

System\Windows\Forms\AccessibleObjects\TrackBar.TrackBarThumbAccessibleObjectTests.cs (1)

30Assert.NotEqual(Rectangle.Empty, accessibleObject.Bounds);

System\Windows\Forms\Application.ComponentManagerTests.cs (3)

76Assert.NotEqual(UIntPtr.Zero, id); 80Assert.NotEqual(UIntPtr.Zero, newId); 82Assert.NotEqual(id, newId);

System\Windows\Forms\ApplicationContextTests.cs (4)

79Assert.NotEqual(IntPtr.Zero, mainForm.Handle); 108Assert.NotEqual(IntPtr.Zero, mainForm.Handle); 111Assert.NotEqual(IntPtr.Zero, newMainForm.Handle); 142Assert.NotEqual(IntPtr.Zero, mainForm.Handle);

System\Windows\Forms\AxHost.AxPropertyDescriptorTests.cs (20)

System\Windows\Forms\AxHost.PropertyBagStreamTests.cs (2)

27Assert.NotEqual(0, stream.Length); 78Assert.NotEqual(0, stream.Length);

System\Windows\Forms\AxHostTests.cs (31)

System\Windows\Forms\ButtonBaseTests.cs (99)

System\Windows\Forms\ButtonTests.cs (27)

System\Windows\Forms\ColorDialogTests.cs (3)

25Assert.NotEqual(IntPtr.Zero, dialog.Instance); 50Assert.NotEqual(IntPtr.Zero, dialog.Instance); 347Assert.NotEqual(IntPtr.Zero, dialog.Instance);

System\Windows\Forms\ColumnHeaderCollectionTests.cs (4)

458Assert.NotEqual(IntPtr.Zero, listView.Handle); 509Assert.NotEqual(IntPtr.Zero, listView.Handle); 975Assert.NotEqual(IntPtr.Zero, listView.Handle); 1014Assert.NotEqual(IntPtr.Zero, listView.Handle);

System\Windows\Forms\ColumnHeaderTests.cs (21)

System\Windows\Forms\ColumnStyleTests.cs (1)

101Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\ComboBoxTests.cs (12)

System\Windows\Forms\CommonDialogTests.cs (2)

189Assert.NotEqual(IntPtr.Zero, owner.Handle); 211Assert.NotEqual(IntPtr.Zero, owner.Handle);

System\Windows\Forms\ComponentModel\Com2Interop\COM2FontConverterTests.cs (1)

46Assert.NotEqual(font, Control.DefaultFont);

System\Windows\Forms\ComponentModel\Com2Interop\ComNativeDescriptorTests.cs (1)

60Assert.NotEqual(0, handleProperty.GetValue(iPictureDisp));

System\Windows\Forms\ContainerControlTests.cs (3)

1222Assert.NotEqual(IntPtr.Zero, control.Handle); 1259Assert.NotEqual(IntPtr.Zero, control.Handle); 1290Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\Control.ActiveXFontMarshallerTests.cs (1)

24Assert.NotEqual(0, native);

System\Windows\Forms\ControlTests.ControlCollection.cs (19)

System\Windows\Forms\ControlTests.cs (1)

597Assert.NotEqual(IntPtr.Zero, parent.Handle);

System\Windows\Forms\ControlTests.Handlers.cs (45)

System\Windows\Forms\ControlTests.Internals.cs (1)

92Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\ControlTests.Methods.cs (142)

System\Windows\Forms\ControlTests.Properties.cs (84)

System\Windows\Forms\CursorConverterTests.cs (1)

39Assert.NotEqual(IntPtr.Zero, cursor.Handle);

System\Windows\Forms\CursorsTests.cs (2)

52Assert.NotEqual(IntPtr.Zero, cursor.Handle); 79Assert.NotEqual("[Cursor: System.Windows.Forms.Cursor]", cursor.ToString());

System\Windows\Forms\CursorTests.cs (7)

68Assert.NotEqual(IntPtr.Zero, cursor.Handle); 119Assert.NotEqual(IntPtr.Zero, cursor.Handle); 156Assert.NotEqual(IntPtr.Zero, cursor.Handle); 230Assert.NotEqual(IntPtr.Zero, cursor.Handle); 329Assert.NotEqual(IntPtr.Zero, handle); 330Assert.NotEqual(sourceCursor.Handle, handle); 359Assert.NotEqual(IntPtr.Zero, cursor.Handle);

System\Windows\Forms\DataGridViewCellTests.cs (11)

509Assert.NotEqual(IntPtr.Zero, control.Handle); 568Assert.NotEqual(IntPtr.Zero, control.Handle); 1125Assert.NotEqual(IntPtr.Zero, control.Handle); 1169Assert.NotEqual(IntPtr.Zero, control.Handle); 4522Assert.NotEqual(IntPtr.Zero, control.Handle); 4582Assert.NotEqual(IntPtr.Zero, control.Handle); 5270Assert.NotEqual(0, height); 5273Assert.NotEqual(0, height); 5342Assert.NotEqual(Size.Empty, DataGridViewCell.MeasureTextPreferredSize(graphics, text, SystemFonts.DefaultFont, 0.2f, flags)); 5398Assert.NotEqual(Size.Empty, DataGridViewCell.MeasureTextSize(graphics, text, SystemFonts.DefaultFont, flags)); 5444Assert.NotEqual(0, DataGridViewCell.MeasureTextWidth(graphics, text, SystemFonts.DefaultFont, 10, flags));

System\Windows\Forms\DataGridViewHeaderCellTests.cs (11)

System\Windows\Forms\DataGridViewRowTests.cs (2)

1226Assert.NotEqual(IntPtr.Zero, control.Handle); 2029Assert.NotEqual(oldApplicationDefaultFont, Application.DefaultFont);

System\Windows\Forms\DataGridViewTests.cs (15)

System\Windows\Forms\DataGridViewTests.Rendering.cs (1)

165Assert.NotEqual(IntPtr.Zero, dataGridView.Handle);

System\Windows\Forms\DataGridViewTextBoxEditingControlTests.cs (4)

420Assert.NotEqual(IntPtr.Zero, control.Handle); 489Assert.NotEqual(IntPtr.Zero, control.Handle); 1167Assert.NotEqual(IntPtr.Zero, control.Handle); 1276Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\Design\ComponentEditorFormTests.cs (2)

287Assert.NotEqual(IntPtr.Zero, control.Handle); 342Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\Design\ComponentEditorPageTests.cs (1)

400Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\DockPaddingEdgesTests.cs (2)

307Assert.NotEqual(0, padding.GetHashCode()); 320Assert.NotEqual(0, padding.GetHashCode());

System\Windows\Forms\DragDropFormatTests.cs (1)

110Assert.NotEqual(medium.unionmember, data.hGlobal);

System\Windows\Forms\ErrorProviderTests.cs (1)

1181Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\FileDialogTests.cs (3)

34Assert.NotEqual(IntPtr.Zero, dialog.Instance); 72Assert.NotEqual(IntPtr.Zero, dialog.Instance); 628Assert.NotEqual(IntPtr.Zero, dialog.Instance);

System\Windows\Forms\FormTests.cs (32)

System\Windows\Forms\GroupBoxTests.cs (18)

System\Windows\Forms\HtmlDocumentTests.cs (2)

1828Assert.NotEqual(0, document.GetHashCode()); 1830Assert.NotEqual(document.GetHashCode(), newDocument.GetHashCode());

System\Windows\Forms\HtmlElementTests.cs (4)

806Assert.NotEqual(Rectangle.Empty, result); 1155Assert.NotEqual(Rectangle.Empty, result); 1977Assert.NotEqual(0, element1.GetHashCode()); 1980Assert.NotEqual(element1.GetHashCode(), element3.GetHashCode());

System\Windows\Forms\ImageList.ImageCollectionTests.cs (20)

System\Windows\Forms\ImageListTests.cs (28)

System\Windows\Forms\InputLanguageTests.cs (2)

186Assert.NotEqual(IntPtr.Zero, language.Handle); 194Assert.NotEqual(IntPtr.Zero, language.Handle);

System\Windows\Forms\LabelTests.cs (4)

187Assert.NotEqual(IntPtr.Zero, control.Handle); 204Assert.NotEqual(IntPtr.Zero, control.Handle); 233Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle 876Assert.NotEqual(defaultSize, label.PreferredSize);

System\Windows\Forms\ListBox.IntegerCollectionTests.cs (28)

System\Windows\Forms\ListBox.ObjectCollectionTests.cs (105)

System\Windows\Forms\ListBoxTests.cs (67)

System\Windows\Forms\ListViewGroupCollectionTests.cs (8)

61Assert.NotEqual(IntPtr.Zero, listView.Handle); 95Assert.NotEqual(IntPtr.Zero, listView.Handle); 388Assert.NotEqual(IntPtr.Zero, listView.Handle); 424Assert.NotEqual(IntPtr.Zero, listView.Handle); 614Assert.NotEqual(IntPtr.Zero, listView.Handle); 753Assert.NotEqual(IntPtr.Zero, listView.Handle); 785Assert.NotEqual(IntPtr.Zero, listView.Handle); 938Assert.NotEqual(IntPtr.Zero, listView.Handle);

System\Windows\Forms\ListViewGroupTests.cs (18)

System\Windows\Forms\ListViewInsertionMarkTests.cs (17)

System\Windows\Forms\ListViewSubItemTests.cs (1)

209Assert.NotEqual(IntPtr.Zero, listView.Handle);

System\Windows\Forms\ListViewTests.cs (58)

System\Windows\Forms\MdiClientTests.cs (9)

333Assert.NotEqual(IntPtr.Zero, control.Handle); 358Assert.NotEqual(IntPtr.Zero, control.Handle); 383Assert.NotEqual(IntPtr.Zero, control.Handle); 428Assert.NotEqual(IntPtr.Zero, control.Handle); 630Assert.NotEqual(IntPtr.Zero, control.Handle); 756Assert.NotEqual(IntPtr.Zero, parent.Handle); 908Assert.NotEqual(IntPtr.Zero, parent.Handle); 1070Assert.NotEqual(IntPtr.Zero, parent.Handle); 1209Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\MenuStripTests.cs (7)

184Assert.NotEqual(IntPtr.Zero, control.Handle); 270Assert.NotEqual(IntPtr.Zero, control.Handle); 377Assert.NotEqual(IntPtr.Zero, control.Handle); 578Assert.NotEqual(IntPtr.Zero, control.Handle); 644Assert.NotEqual(IntPtr.Zero, control.Handle); 769Assert.NotEqual(IntPtr.Zero, control.Handle); 794Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\MessageTests.cs (1)

178Assert.NotEqual(0, message.GetHashCode());

System\Windows\Forms\MonthCalendarTests.cs (63)

System\Windows\Forms\NativeWindowTests.cs (6)

109Assert.NotEqual(IntPtr.Zero, window1.Handle); 117Assert.NotEqual(IntPtr.Zero, window2.Handle); 118Assert.NotEqual(window1.Handle, window2.Handle); 152Assert.NotEqual(IntPtr.Zero, window.Handle); 207Assert.NotEqual(IntPtr.Zero, window1.Handle); 280Assert.NotEqual(IntPtr.Zero, window.Handle);

System\Windows\Forms\PanelTests.cs (8)

372Assert.NotEqual(IntPtr.Zero, control.Handle); 420Assert.NotEqual(IntPtr.Zero, parent.Handle); 493Assert.NotEqual(IntPtr.Zero, parent.Handle); 576Assert.NotEqual(IntPtr.Zero, control.Handle); 678Assert.NotEqual(IntPtr.Zero, control.Handle); 770Assert.NotEqual(IntPtr.Zero, control.Handle); 1025Assert.NotEqual(IntPtr.Zero, control.Handle); 1091Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\PictureBoxTests.cs (21)

System\Windows\Forms\ProfessionalColorsTests.cs (1)

100Assert.NotEqual(ProfessionalColors.ImageMarginGradientEnd, ProfessionalColors.ImageMarginGradientEnd);

System\Windows\Forms\ProfessionalColorTableTests.cs (1)

129Assert.NotEqual(table.ImageMarginGradientEnd, table.ImageMarginGradientEnd);

System\Windows\Forms\ProgressBarTests.cs (25)

System\Windows\Forms\PropertyGridInternal\PropertiesTabTests.cs (1)

20Assert.NotEqual(tab.TabName, tab.HelpKeyword);

System\Windows\Forms\PropertyGridTests.cs (41)

System\Windows\Forms\RadioButtonTests.cs (16)

System\Windows\Forms\RichTextBoxTests.cs (190)

System\Windows\Forms\RowStyleTests.cs (1)

101Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\ScreenTests.cs (3)

69Assert.NotEqual(IntPtr.Zero, createdControl.Handle); 209Assert.NotEqual(0, screen.Bounds.Width); 210Assert.NotEqual(0, screen.Bounds.Height);

System\Windows\Forms\ScrollableControlTests.cs (18)

System\Windows\Forms\ScrollBarTests.cs (21)

System\Windows\Forms\SplitterPanelTests.cs (5)

246Assert.NotEqual(IntPtr.Zero, control.Handle); 280Assert.NotEqual(IntPtr.Zero, parent.Handle); 350Assert.NotEqual(IntPtr.Zero, control.Handle); 956Assert.NotEqual(IntPtr.Zero, control.Handle); 1048Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\SplitterTests.cs (15)

System\Windows\Forms\StatusStripTests.cs (1)

800Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\StatusStripTests.Rendering.cs (2)

25Assert.NotEqual(IntPtr.Zero, form.Handle); 26Assert.NotEqual(IntPtr.Zero, statusStrip.Handle);

System\Windows\Forms\SystemInformationTests.cs (2)

792Assert.NotEqual(0, screen.Width); 793Assert.NotEqual(0, screen.Height);

System\Windows\Forms\TabControl.ControlCollectionTests.cs (16)

System\Windows\Forms\TabControl.TabPageCollectionTests.cs (45)

System\Windows\Forms\TabControlTests.cs (73)

System\Windows\Forms\TableLayoutPanelTests.cs (5)

174Assert.NotEqual(IntPtr.Zero, control.Handle); 255Assert.NotEqual(IntPtr.Zero, control.Handle); 1242Assert.NotEqual(IntPtr.Zero, control.Handle); 1295Assert.NotEqual(IntPtr.Zero, control.Handle); 1367Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\TableLayoutStyleTests.cs (1)

78Assert.NotEqual(IntPtr.Zero, control.Handle);

System\Windows\Forms\TabPageTests.cs (38)

System\Windows\Forms\TextBoxBase.TextBoxBaseUiaTextProviderTests.cs (1)

922Assert.NotEqual(IntPtr.Zero, textBoxBase.Handle);

System\Windows\Forms\ToolStripButtonTests.cs (3)

696Assert.NotEqual(IntPtr.Zero, owner.Handle); 769Assert.NotEqual(IntPtr.Zero, parent.Handle); 908Assert.NotEqual(IntPtr.Zero, owner.Handle);

System\Windows\Forms\ToolStripContentPanelTests.cs (10)

System\Windows\Forms\ToolStripDropDownTests.cs (27)

System\Windows\Forms\ToolStripItemTests.cs (93)

System\Windows\Forms\ToolStripSeparatorTests.cs (2)

978Assert.NotEqual(IntPtr.Zero, owner.Handle); 1053Assert.NotEqual(IntPtr.Zero, parent.Handle);

System\Windows\Forms\ToolStripTests.cs (33)

System\Windows\Forms\ToolStripTests.Rendering.cs (2)

23Assert.NotEqual(IntPtr.Zero, form.Handle); 24Assert.NotEqual(IntPtr.Zero, toolStrip.Handle);

System\Windows\Forms\ToolTipBufferTests.cs (3)

26Assert.NotEqual(memory1, memory2); 41Assert.NotEqual(memory1, memory2); 58Assert.NotEqual(IntPtr.Zero, memory2);

System\Windows\Forms\ToolTipTests.cs (3)

792Assert.NotEqual(IntPtr.Zero, toolTip.Handle); // A workaround to create the toolTip native window Handle 846Assert.NotEqual(IntPtr.Zero, tabControl.InternalHandle); 889Assert.NotEqual(IntPtr.Zero, tabControl.InternalHandle);

System\Windows\Forms\TreeNodeTests.cs (94)

System\Windows\Forms\TreeViewTests.cs (99)

System\Windows\Forms\UpDownBaseTests.cs (24)

System\Windows\Forms\UserControlTests.cs (11)

System\Windows\Forms\VisualStyles\VisualStyleInformationTests.cs (8)

35Assert.NotEqual(scheme, VisualStyleInformation.Size); 36Assert.NotEqual(scheme, VisualStyleInformation.Version); 55Assert.NotEqual(Color.Empty, color); 124Assert.NotEqual(size, VisualStyleInformation.ColorScheme); 125Assert.NotEqual(size, VisualStyleInformation.Version); 142Assert.NotEqual(Color.Empty, color); 170Assert.NotEqual(version, VisualStyleInformation.ColorScheme); 171Assert.NotEqual(version, VisualStyleInformation.Size);

System\Windows\Forms\VisualStyles\VisualStyleRendererTests.cs (5)

33Assert.NotEqual(IntPtr.Zero, renderer.Handle); 67Assert.NotEqual(IntPtr.Zero, renderer.Handle); 382Assert.NotEqual(IntPtr.Zero, childControl.Handle); 521Assert.NotEqual(IntPtr.Zero, renderer.Handle); 542Assert.NotEqual(IntPtr.Zero, renderer.Handle);

System\Windows\Forms\WebBrowserTests.cs (11)

TextBoxBaseTests.cs (92)

TextBoxTests.cs (6)

162Assert.NotEqual(IntPtr.Zero, control.Handle); 200Assert.NotEqual(IntPtr.Zero, control.Handle); 238Assert.NotEqual(IntPtr.Zero, control.Handle); 311Assert.NotEqual(IntPtr.Zero, control.Handle); 563Assert.NotEqual(IntPtr.Zero, control.Handle); 633Assert.NotEqual(IntPtr.Zero, control.Handle);

TextBoxTests.Rendering.cs (2)

26Assert.NotEqual(IntPtr.Zero, form.Handle); 27Assert.NotEqual(IntPtr.Zero, textBox.Handle);

TrackBarTests.cs (36)

WebBrowserBaseTests.cs (2)

182Assert.NotEqual(IntPtr.Zero, control.Handle); 686Assert.NotEqual(IntPtr.Zero, control.Handle);

AnchorLayoutTests.cs (2)

227Assert.NotEqual(bounds, button.Bounds); // Bounds Specified is None. 231Assert.NotEqual(bounds, button.Bounds);

Dpi\FormDpiTests.cs (6)

41Assert.NotEqual(initialBounds.Width, form.Bounds.Width); 42Assert.NotEqual(initialBounds.Height, form.Bounds.Height); 43Assert.NotEqual(initialFontSize, form.Font.Size); 112Assert.NotEqual(form.MinimumSize, minSize); 113Assert.NotEqual(form.MaximumSize, maxSize); 149Assert.NotEqual(form.Size, nonLinearSize);

Dpi\SplitContainerTests.cs (2)

65Assert.NotEqual(90, splitContainer.SplitterDistance); 66Assert.NotEqual(2, splitContainer.SplitterWidth);

MonthCalendarTests.cs (4)

97Assert.NotEqual(0, callDateSelectedCount); 98Assert.NotEqual(0, callDateChangedCount); 119Assert.NotEqual(0, callDateSelectedCount); 120Assert.NotEqual(0, callDateChangedCount);

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

30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));

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

30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));

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

30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));

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

30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));

CompilerServerTests.cs (1)

454Assert.NotEqual(ProcessorArchitecture.X86,

EqualityAsserts.cs (2)

588 NotEqual<object>(expected, actual); 592 NotEqual<object>(expected, actual);