3859 references to NotEqual
Binding.Http.IntegrationTests (2)
OperationContextTests.cs (2)
50Assert.NotEqual(currentThreadId, Thread.CurrentThread.ManagedThreadId); 51Assert.NotEqual(currentContext, OperationContext.Current);
Binding.Tcp.IntegrationTests (5)
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);
Client.ClientBase.IntegrationTests (1)
SessionTests.cs (1)
86Assert.NotEqual(sessionId1, sessionId2);
Diagnostics.FunctionalTests (1)
WelcomePageSampleTest.cs (1)
27Assert.NotEqual(0xEF, bytes[0]); // No leading UTF-8 BOM
IIS.FunctionalTests (1)
src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (1)
48Assert.NotEqual(id2, id1);
IISExpress.FunctionalTests (1)
src\Servers\IIS\IIS\test\Common.FunctionalTests\MultiApplicationTests.cs (1)
48Assert.NotEqual(id2, id1);
InMemory.FunctionalTests (15)
EventSourceTests.cs (9)
88Assert.NotEqual(Guid.Empty, connectionStart.ActivityId); 96Assert.NotEqual(Guid.Empty, firstRequestStart.ActivityId); 114Assert.NotEqual(Guid.Empty, secondRequestStart.ActivityId); 213Assert.NotEqual(Guid.Empty, connectionStart.ActivityId); 220Assert.NotEqual(Guid.Empty, tlsHandshakeStart.ActivityId); 240Assert.NotEqual(Guid.Empty, requestStart.ActivityId); 317Assert.NotEqual(Guid.Empty, connectionStart.ActivityId); 324Assert.NotEqual(Guid.Empty, tlsHandshakeStart.ActivityId); 398Assert.NotEqual(Guid.Empty, connectionStart.ActivityId);
Http2\Http2TestBase.cs (1)
1094Assert.NotEqual(0, streamId);
Http3\Http3StreamTests.cs (1)
3309Assert.NotEqual(endstream, context.Features.Get<IHttpRequestBodyDetectionFeature>().CanHaveBody);
KestrelMetricsTests.cs (1)
364Assert.NotEqual(overridenFeature, currentConnectionContext.Features.Get<IConnectionMetricsTagsFeature>());
RequestTests.cs (1)
635Assert.NotEqual(0, read);
ResponseTests.cs (2)
4400Assert.NotEqual(4096, memory.Length); 4499Assert.NotEqual(BodyWriter1, BodyWriter2);
Microsoft.AspNetCore.Antiforgery.Test (5)
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);
Microsoft.AspNetCore.Authentication.Core.Test (4)
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);
Microsoft.AspNetCore.Authentication.JwtBearer.Tools.Tests (1)
UserJwtsTests.cs (1)
664Assert.NotEqual(key, resetKey);
Microsoft.AspNetCore.Authentication.Test (7)
CookieTests.cs (3)
224Assert.NotEqual(key1, key2); 982Assert.NotEqual(lastValidateIssuedDate, firstIssueDate); 983Assert.NotEqual(firstExpiresDate, lastExpiresDate);
JwtBearerTests.cs (2)
954Assert.NotEqual(DateTimeOffset.MinValue, token.ValidTo); 955Assert.NotEqual(DateTimeOffset.MinValue, token.ValidFrom);
JwtBearerTests_Handler.cs (2)
899Assert.NotEqual(DateTimeOffset.MinValue, token.ValidTo); 900Assert.NotEqual(DateTimeOffset.MinValue, token.ValidFrom);
Microsoft.AspNetCore.Components.Endpoints.Tests (12)
EndpointHtmlRendererTest.cs (12)
417Assert.NotEqual(Guid.Empty, serverComponent.InvocationId); 447Assert.NotEqual(default, serverComponent); 451Assert.NotEqual(Guid.Empty, serverComponent.InvocationId); 511Assert.NotEqual(Guid.Empty, firstServerComponent.InvocationId); 568Assert.NotEqual(Guid.Empty, serverComponent.InvocationId); 607Assert.NotEqual(Guid.Empty, serverComponent.InvocationId); 644Assert.NotEqual(default, serverComponent); 648Assert.NotEqual(Guid.Empty, serverComponent.InvocationId); 695Assert.NotEqual(default, serverComponent); 699Assert.NotEqual(Guid.Empty, serverComponent.InvocationId); 1229Assert.NotEqual(Guid.Empty, serverComponent.InvocationId); 1258Assert.NotEqual(Guid.Empty, serverComponent.InvocationId);
Microsoft.AspNetCore.Components.Forms.Tests (3)
FieldIdentifierTest.cs (3)
61Assert.NotEqual(fieldIdentifier1.GetHashCode(), fieldIdentifier2.GetHashCode()); 74Assert.NotEqual(fieldIdentifier1.GetHashCode(), fieldIdentifier2.GetHashCode()); 129Assert.NotEqual(fieldIdentifierLower.GetHashCode(), fieldIdentifierPascal.GetHashCode());
Microsoft.AspNetCore.Components.Server.Tests (2)
Circuits\CircuitRegistryTest.cs (1)
553Assert.NotEqual(differentConnectionId, circuitHost.Client.ConnectionId);
Circuits\ComponentHubTest.cs (1)
275Assert.NotEqual(circuitSecret, result);
Microsoft.AspNetCore.Components.Tests (13)
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());
Microsoft.AspNetCore.Cryptography.Internal.Tests (2)
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
Microsoft.AspNetCore.DataProtection.Tests (13)
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);
Microsoft.AspNetCore.DeveloperCertificates.XPlat.Tests (1)
CertificateManagerTests.cs (1)
312Assert.NotEqual(_manager.Subject, wrongSubjectCertificate.Subject);
Microsoft.AspNetCore.Diagnostics.Middleware.Tests (1)
Latency\RequestLatencyTelemetryExtensionsTests.cs (1)
45Assert.NotEqual(scope1.ServiceProvider.GetService<ILatencyContext>(),
Microsoft.AspNetCore.HeaderParsing.Tests (5)
HostHeaderValueTests.cs (5)
19Assert.NotEqual(differentHost, host1); 20Assert.NotEqual(differentPort, host1); 38Assert.NotEqual(new object(), host1); 67Assert.NotEqual(differentHostHashCode, host1HashCode); 68Assert.NotEqual(differentPortHashCode, host1HashCode);
Microsoft.AspNetCore.Hosting.Tests (4)
HostingApplicationTests.cs (2)
123Assert.NotEqual(Activity.Current, activityFeature.Activity); 161Assert.NotEqual(overridenFeature, contextFeature);
HostingMetricsTests.cs (1)
177Assert.NotEqual(overridenFeature, contextFeature);
WebHostBuilderTests.cs (1)
994Assert.NotEqual(disposables[0], disposables[1]);
Microsoft.AspNetCore.Http.Abstractions.Tests (8)
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);
Microsoft.AspNetCore.Http.Connections.Tests (3)
HttpConnectionDispatcherTests.cs (1)
100Assert.NotEqual(connectionId, connectionToken);
HttpConnectionManagerTests.cs (2)
55Assert.NotEqual(default, connection.LastSeenTicks); 236Assert.NotEqual(connection.ConnectionId, connection.ConnectionToken);
Microsoft.AspNetCore.Http.Results.Tests (19)
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);
Microsoft.AspNetCore.Http.Tests (3)
DefaultHttpContextTests.cs (2)
165Assert.NotEqual(4, features.Count()); 185Assert.NotEqual(4, newFeatures.Count());
Features\HttpRequestIdentifierFeatureTests.cs (1)
38Assert.NotEqual(id1, id2);
Microsoft.AspNetCore.HttpOverrides.Tests (2)
ForwardedHeadersMiddlewareTest.cs (2)
450Assert.NotEqual(hostHeader, context.Request.Host.Value); 552Assert.NotEqual<string>(hostHeader, context.Request.Headers.Host);
Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (1)
UserStoreTest.cs (1)
184Assert.NotEqual(userA.PasswordHash, userB.PasswordHash);
Microsoft.AspNetCore.Identity.FunctionalTests (3)
ManagementTests.cs (1)
376Assert.NotEqual(expectedPrincipalClaim, actualPrincipalClaim);
MapIdentityApiTests.cs (2)
759Assert.NotEqual(accessToken, recoveryAccessToken); 861Assert.NotEqual(accessToken, recoveryAccessToken);
Microsoft.AspNetCore.Identity.Specification.Tests (16)
UserManagerSpecificationTests.cs (16)
275Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 291Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 656Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 676Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 696Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 889Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1004Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1357Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1376Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1442Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1481Assert.NotEqual(token1, token2); 1509Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1532Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1558Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1578Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user)); 1674Assert.NotEqual(stamp, await manager.GetSecurityStampAsync(user));
Microsoft.AspNetCore.Identity.Test (2)
SignInManagerTest.cs (2)
1297Assert.NotEqual(confirmed, result.IsNotAllowed); 1351Assert.NotEqual(confirmed, result.IsNotAllowed);
Microsoft.AspNetCore.Mvc.Abstractions.Test (3)
ModelBinding\ValueProviderResultTest.cs (3)
66Assert.NotEqual(ValueProviderResult.None, result); 81Assert.NotEqual(ValueProviderResult.None, result); 190Assert.NotEqual(expected, result);
Microsoft.AspNetCore.Mvc.Core.Test (36)
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)
2632Assert.NotEqual(0, binder.BindModelCount); 2660Assert.NotEqual(0, binder.BindModelCount); 2687Assert.NotEqual(0, binder.BindModelCount); 2745Assert.NotEqual(0, binder.BindModelCount); 2777Assert.NotEqual(0, binder.BindModelCount); 2811Assert.NotEqual(0, binder.BindModelCount); 2843Assert.NotEqual(0, binder.BindModelCount); 2882Assert.NotEqual(0, binder1.BindModelCount); 2893Assert.NotEqual(0, binder2.BindModelCount); 2928Assert.NotEqual(0, binder.BindModelCount); 2956Assert.NotEqual(0, binder.BindModelCount); 2984Assert.NotEqual(0, binder.BindModelCount);
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);
Microsoft.AspNetCore.Mvc.FunctionalTests (7)
InputObjectValidationTests.cs (1)
153Assert.NotEqual(shouldNotContainMessage, errorMessage);
RazorBuildTest.cs (3)
122Assert.NotEqual(expected1, actual2); 137Assert.NotEqual(actual2, body.Trim()); 161Assert.NotEqual(expected1, actual2);
RazorRuntimeCompilationHostingStartupTest.cs (3)
69Assert.NotEqual(expected1, actual2); 84Assert.NotEqual(actual2, body.Trim()); 107Assert.NotEqual(expected1, actual2);
Microsoft.AspNetCore.Mvc.IntegrationTests (2)
DictionaryModelBinderIntegrationTest.cs (2)
810Assert.NotEqual(ModelValidationState.Unvalidated, kvp.Value.ValidationState); 811Assert.NotEqual(ModelValidationState.Skipped, kvp.Value.ValidationState);
Microsoft.AspNetCore.Mvc.Routing.Abstractions.Tests (6)
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);
Microsoft.AspNetCore.Mvc.TagHelpers.Test (4)
CacheTagKeyTest.cs (4)
89Assert.NotEqual(cacheTagKey1, cacheTagKey2); 143Assert.NotEqual(hashcode1, hashcode2); 470Assert.NotEqual(hashCode1, hashCode2); 502Assert.NotEqual(hashCode1, hashCode2);
Microsoft.AspNetCore.Mvc.ViewFeatures.Test (6)
HtmlAttributePropertyHelperTest.cs (2)
101Assert.NotEqual<object[]>(helpers1, helpers2); 102Assert.NotEqual<object>(helpers1[0], helpers2[0]);
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);
Microsoft.AspNetCore.OpenApi.Tests (3)
Services\CreateSchemaReferenceIdTests.cs (1)
243Assert.NotEqual(((OpenApiSchemaReference)schema).Reference.Id, ((OpenApiSchemaReference)responseSchema).Reference.Id);
Transformers\DocumentTransformerTests.cs (1)
119Assert.NotEqual(description, document.Info.Description);
Transformers\Implementations\OpenApiSchemaReferenceTransformerTests.cs (1)
299Assert.NotEqual(((OpenApiSchemaReference)requestSchema).Reference.Id, ((OpenApiSchemaReference)responseSchema).Reference.Id);
Microsoft.AspNetCore.OutputCaching.Tests (4)
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());
Microsoft.AspNetCore.Owin.Tests (1)
OwinEnvironmentTests.cs (1)
175Assert.NotEqual("owin.RequestProtocol", key);
Microsoft.AspNetCore.ResponseCaching.Tests (2)
ResponseCachingMiddlewareTests.cs (1)
392Assert.NotEqual(timeProvider.GetUtcNow(), context.ResponseTime);
ResponseCachingTests.cs (1)
981Assert.NotEqual(await initialResponse.Content.ReadAsStringAsync(), await subsequentResponse.Content.ReadAsStringAsync());
Microsoft.AspNetCore.Routing.Tests (4)
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);
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (3)
RequestTests.cs (2)
44Assert.NotEqual(0, connectionInfo.RemotePort); 46Assert.NotEqual(0, connectionInfo.LocalPort);
ServerTests.cs (1)
83Assert.NotEqual("0", prefix.Port);
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (28)
Http1\Http1ConnectionTests.cs (4)
684Assert.NotEqual(original, _http1Connection.RequestAborted); 706Assert.NotEqual(original, _http1Connection.RequestAborted); 766Assert.NotEqual(original, _http1Connection.RequestAborted); 784Assert.NotEqual(original, _http1Connection.RequestAborted);
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)
507Assert.NotEqual(0, ((IPEndPoint)transportEndPoint.BoundEndPoint).Port); 535Assert.NotEqual(0, ((IPEndPoint)multiplexedTransportEndPoint.BoundEndPoint).Port);
PipelineExtensionTests.cs (2)
84Assert.NotEqual(bufferLength, writer.Span.Length); 189Assert.NotEqual(bufferLength, writer.Span.Length);
StartLineTests.cs (10)
256Assert.NotEqual(prevRequestUrl, Http1Connection.RawTarget); 257Assert.NotEqual(prevPath, Http1Connection.Path); 258Assert.NotEqual(prevQuery, Http1Connection.QueryString); 349Assert.NotEqual(prevRequestUrl, Http1Connection.RawTarget); 350Assert.NotEqual(prevPath, Http1Connection.Path); 351Assert.NotEqual(prevQuery, Http1Connection.QueryString); 428Assert.NotEqual(prevRequestUrl, Http1Connection.RawTarget); 429Assert.NotEqual(prevPath, Http1Connection.Path); 430Assert.NotEqual(prevQuery, Http1Connection.QueryString); 511Assert.NotEqual(prevRequestUrl, Http1Connection.RawTarget);
Microsoft.AspNetCore.Server.Kestrel.Tests (2)
KestrelConfigurationLoaderTests.cs (2)
325Assert.NotEqual(devCert.SerialNumber, defaultCert.SerialNumber); // Need to be able to distinguish them 546Assert.NotEqual(certificate.SerialNumber, defaultCertificate.SerialNumber);
Microsoft.AspNetCore.SignalR.Client.FunctionalTests (3)
HubConnectionTests.cs (3)
296Assert.NotEqual(originalClientConnectionId, connectionIdFromServer); 2177Assert.NotEqual(initialConnectionId, newConnectionId); 2237Assert.NotEqual(initialConnectionId, newConnectionId);
Microsoft.AspNetCore.SignalR.Specification.Tests (1)
ScaleoutHubLifetimeManagerTests.cs (1)
603Assert.NotEqual(invocation1.InvocationId, invocation2.InvocationId);
Microsoft.AspNetCore.SignalR.Tests (1)
HubConnectionHandlerTestUtils\Hubs.cs (1)
1439Assert.NotEqual(service, service2);
Microsoft.AspNetCore.Tests (4)
WebApplicationTests.cs (4)
2266Assert.NotEqual(nameof(WebApplicationTests), hostEnv.ApplicationName); 2267Assert.NotEqual(envName, hostEnv.EnvironmentName); 2268Assert.NotEqual(contentRoot, hostEnv.ContentRootPath); 2332Assert.NotEqual(value0, value1);
Microsoft.Build.Tasks.CodeAnalysis.UnitTests (4)
TargetTests.cs (4)
41Assert.NotEqual("true", shouldRun); 42Assert.NotEqual("true", hasItems); 66Assert.NotEqual("true", hasItems); 141Assert.NotEqual("true", shouldRun);
Microsoft.CodeAnalysis.CodeStyle.UnitTestUtilities (3)
src\Features\DiagnosticsTestUtilities\CodeActions\CodeFixVerifierHelper.cs (3)
51Assert.NotEqual("", descriptor.Title?.ToString() ?? ""); 64Assert.NotEqual("", descriptor.MessageFormat?.ToString() ?? ""); 89Assert.NotEqual("", descriptor.HelpLinkUri ?? "");
Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (23)
CommandLineTests.cs (12)
1629Assert.NotEqual(LanguageVersion.Default, defaultEffectiveVersion); 1642Assert.NotEqual(LanguageVersion.Latest, latestEffectiveVersion); 4361Assert.NotEqual(0, exitCode); 6943Assert.NotEqual(0, exitCode); 6965Assert.NotEqual(0, exitCode); 7166Assert.NotEqual(0, exitCode); 7170Assert.NotEqual(0, exitCode); 8770Assert.NotEqual(0, exitCode1); 8895Assert.NotEqual(mvid, ReadMvid(fsNewDll)); 9148Assert.NotEqual(0, exitCode); 9610Assert.NotEqual(0, exitCode); 9720Assert.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);
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (19)
CodeActions\MoveType\MoveTypeTests.MoveScope.cs (1)
893Assert.NotEqual(documentToModify.Project.Solution, modifiedSolution);
Completion\CompletionProviders\SymbolCompletionProviderTests_NoInteractive.cs (1)
346Assert.NotEqual(currentDocument, document);
Diagnostics\DiagnosticAnalyzerDriver\DiagnosticAnalyzerDriverTests.cs (1)
327Assert.NotEqual(SyntaxKind.MethodDeclaration, context.Node.Kind());
ExtractMethod\ExtractMethodBase.cs (1)
102Assert.NotEqual(expected, actual);
PdbSourceDocument\PdbSourceDocumentTests.cs (1)
941Assert.NotEqual(fileOne.IdentifierLocation, fileTwo.IdentifierLocation);
QuickInfo\SyntacticQuickInfoSourceTests.cs (1)
572Assert.NotEqual(0, info.RelatedSpans.Length);
SymbolKey\SymbolKeyCompilationsTests.cs (4)
104Assert.NotEqual(SymbolKind.ErrorType, symbol01.Kind); 105Assert.NotEqual(SymbolKind.ErrorType, symbol02.Kind); 217Assert.NotEqual(implementation, definition); 246Assert.NotEqual(implementation, definition);
Workspaces\WorkspaceTests_EditorFeatures.cs (9)
505Assert.NotEqual(TypeKind.Error, classC.TypeKind); 563Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 587Assert.NotEqual(VersionStamp.Default, newVersion); 635Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 1137Assert.NotEqual(oldVersion, await doc.Project.GetSemanticVersionAsync()); 1170Assert.NotEqual(oldVersion, await doc.Project.GetSemanticVersionAsync()); 1482Assert.NotEqual(defaultValue, changedValue); 1528Assert.NotEqual(beforeSolutionForPrimaryWorkspace, primaryWorkspace.CurrentSolution); 1529Assert.NotEqual(beforeSolutionForSecondaryWorkspace, secondaryWorkspace.CurrentSolution);
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (56)
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 (17)
11279Assert.NotEqual(m2Item1.Locations.Single(), m2Item1.TupleUnderlyingField.Locations.Single()); 11779Assert.NotEqual(m3Tuple.TupleUnderlyingType, m3Item8.TupleUnderlyingField.ContainingSymbol); 11780Assert.NotEqual(m3Tuple, m3Item8.TupleUnderlyingField.ContainingSymbol); 11972Assert.NotEqual(m4Tuple.TupleUnderlyingType, m4Item8.TupleUnderlyingField.ContainingSymbol); 11973Assert.NotEqual(m4Tuple, m4Item8.TupleUnderlyingField.ContainingSymbol); 11991Assert.NotEqual(m4Tuple.TupleUnderlyingType, m4h4.TupleUnderlyingField.ContainingSymbol); 11992Assert.NotEqual(m4Tuple, m4h4.TupleUnderlyingField.ContainingSymbol); 12220Assert.NotEqual(m5Tuple.TupleUnderlyingType, m5Item8.TupleUnderlyingField.ContainingSymbol); 12221Assert.NotEqual(m5Tuple, m5Item8.TupleUnderlyingField.ContainingSymbol); 12588Assert.NotEqual(m8Tuple.TupleUnderlyingType, m8Item8.TupleUnderlyingField.ContainingSymbol); 12589Assert.NotEqual(m8Tuple, m8Item8.TupleUnderlyingField.ContainingSymbol); 12608Assert.NotEqual(m8Tuple.TupleUnderlyingType, m8Item1.TupleUnderlyingField.ContainingSymbol); 12609Assert.NotEqual(m8Tuple, m8Item1.TupleUnderlyingField.ContainingSymbol); 12616Assert.NotEqual(m8Item1.Locations.Single(), m8Item1.TupleUnderlyingField.Locations.Single()); 12828Assert.NotEqual(m2Item1.Locations.Single(), m2Item1.TupleUnderlyingField.Locations.Single()); 27477Assert.NotEqual(type, underlyingType); 27501Assert.NotEqual(type, underlyingType);
Emit\CompilationEmitTests.cs (12)
683Assert.NotEqual(Guid.Empty, mvidFromModuleDefinition); 1227Assert.NotEqual(Guid.Empty, mvid1); 2662Assert.NotEqual(0, output.Position); 2663Assert.NotEqual(0, pdbOutput.Position); 2664Assert.NotEqual(0, metadataOutput.Position); 3671Assert.NotEqual(0, peHeaders.PEHeader.ImportAddressTableDirectory.RelativeVirtualAddress); 3672Assert.NotEqual(0, peHeaders.PEHeader.ImportAddressTableDirectory.Size); 3673Assert.NotEqual(0, peHeaders.PEHeader.ImportTableDirectory.RelativeVirtualAddress); 3674Assert.NotEqual(0, peHeaders.PEHeader.ImportTableDirectory.Size); 3675Assert.NotEqual(0, peHeaders.PEHeader.BaseRelocationTableDirectory.RelativeVirtualAddress); 3676Assert.NotEqual(0, peHeaders.PEHeader.BaseRelocationTableDirectory.Size); 5097Assert.NotEqual(0, P1RVA);
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\EmitMetadataTests.cs (7)
1169Assert.NotEqual(Microsoft.Cci.PrimitiveTypeCode.Void, type.PrimitiveTypeCode); 3641Assert.NotEqual(0, module.GetMetadata().Module.PEReaderOpt.PEHeaders.CorHeader.EntryPointTokenOrRelativeVirtualAddress); 3666Assert.NotEqual(0, module.GetMetadata().Module.PEReaderOpt.PEHeaders.CorHeader.EntryPointTokenOrRelativeVirtualAddress); 3702Assert.NotEqual(0, module.GetMetadata().Module.PEReaderOpt.PEHeaders.CorHeader.EntryPointTokenOrRelativeVirtualAddress); 3728Assert.NotEqual(0, module.GetMetadata().Module.PEReaderOpt.PEHeaders.CorHeader.EntryPointTokenOrRelativeVirtualAddress); 3762Assert.NotEqual(0, new PEHeaders(stream).CorHeader.EntryPointTokenOrRelativeVirtualAddress); 3804Assert.NotEqual(0, new PEHeaders(stream).CorHeader.EntryPointTokenOrRelativeVirtualAddress);
Emit\ResourceTests.cs (3)
162Assert.NotEqual(default, stringTable); 166Assert.NotEqual(default, elevenRsrc); 170Assert.NotEqual(default, wevtRsrc);
Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (1)
Emit\EditAndContinue\EditAndContinueTestBase.cs (1)
88Assert.NotEqual(tree1, tree0);
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (97)
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)
1577Assert.NotEqual(analyzerDiagnostic, compilationDiagnostic); 1578Assert.NotEqual(compilationDiagnostic, analyzerDiagnostic);
FlowAnalysis\StructTests.cs (1)
79Assert.NotEqual(sourceConstructor, synthesizedConstructor);
PartialEventsAndConstructorsTests.cs (12)
2001Assert.NotEqual(defSymbol, implSymbol); 2009Assert.NotEqual(defSymbol.Locations.Single(), implSymbol.Locations.Single()); 2019Assert.NotEqual(defSymbol, implSymbol); 2027Assert.NotEqual(defSymbol.Locations.Single(), implSymbol.Locations.Single()); 2040Assert.NotEqual(defSymbol, implSymbol); 2048Assert.NotEqual(defSymbol.Locations.Single(), implSymbol.Locations.Single()); 2077Assert.NotEqual(defSymbol, implSymbol); 2085Assert.NotEqual(defSymbol.Locations.Single(), implSymbol.Locations.Single()); 2108Assert.NotEqual(defSymbol, implSymbol); 2116Assert.NotEqual(defSymbol.Locations.Single(), implSymbol.Locations.Single()); 2154Assert.NotEqual(defSymbol, implSymbol); 2158Assert.NotEqual(defSymbol.Locations.Single(), implSymbol.Locations.Single());
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\ParamsCollectionTests.cs (52)
5894Assert.NotEqual(SpecialType.System_String, model.GetSymbolInfo(f1).Symbol.GetParameters().Single().Type.SpecialType); 5896Assert.NotEqual(SpecialType.System_String, model.GetSymbolInfo(f2).Symbol.GetParameters().Single().Type.SpecialType); 5976Assert.NotEqual(SpecialType.System_String, model.GetSymbolInfo(f1).Symbol.GetParameters().Single().Type.SpecialType); 5978Assert.NotEqual(SpecialType.System_String, model.GetSymbolInfo(f2).Symbol.GetParameters().Single().Type.SpecialType); 9368Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9369Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9370Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9422Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9423Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9424Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9480Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9481Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9482Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9484Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9485Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9486Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9537Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9538Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9539Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9541Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9542Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9543Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9607Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9608Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9609Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9611Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9612Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9613Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9695Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9696Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9697Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9699Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test1").Parameters.Single().EffectiveScope); 9700Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test2").Parameters.Single().EffectiveScope); 9701Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C3.C1.Test3").Parameters.Single().EffectiveScope); 9762Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9763Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9764Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9803Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9804Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9805Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9855Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9856Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9857Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9916Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test1").Parameters.Single().EffectiveScope); 9917Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test2").Parameters.Single().EffectiveScope); 9918Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3.Invoke").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C2.Test3").Parameters.Single().EffectiveScope); 9963Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test1").PartialImplementationPart.Parameters.Single().EffectiveScope); 9964Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test2").PartialImplementationPart.Parameters.Single().EffectiveScope); 9965Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test3").PartialImplementationPart.Parameters.Single().EffectiveScope); 10016Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test1").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test1").PartialImplementationPart.Parameters.Single().EffectiveScope); 10017Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test2").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test2").PartialImplementationPart.Parameters.Single().EffectiveScope); 10018Assert.NotEqual(comp.GetMember<MethodSymbol>("C1.Test3").Parameters.Single().EffectiveScope, comp.GetMember<MethodSymbol>("C1.Test3").PartialImplementationPart.Parameters.Single().EffectiveScope);
Semantics\PatternMatchingTestBase.cs (6)
89Assert.NotEqual(symbol, other); 146Assert.NotEqual(symbol, model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText).Single()); 172Assert.NotEqual(symbol, model.LookupSymbols(declarator.SpanStart, name: declarator.Identifier.ValueText).Single()); 186Assert.NotEqual(symbol, model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText).Single()); 194Assert.NotEqual(SymbolKind.Field, symbol.Kind); 206Assert.NotEqual(LocalDeclarationKind.PatternVariable, symbol.GetSymbol<LocalSymbol>().DeclarationKind);
Semantics\PatternMatchingTests3.cs (1)
63Assert.NotEqual(default, ySymbol);
Semantics\PatternMatchingTests5.cs (2)
1130Assert.NotEqual(default, yxSymbol); 1322Assert.NotEqual(default, yxSymbol);
Semantics\PrimaryConstructorTests.cs (1)
739Assert.NotEqual("class ", keyword);
Microsoft.CodeAnalysis.CSharp.Features.UnitTests (1)
Diagnostics\Suppression\SuppressionTests.cs (1)
507Assert.NotEqual(cs0219EquivalenceKey, cs0168EquivalenceKey);
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (106)
Semantics\AccessCheckTests.cs (1)
970Assert.NotEqual(classC, c2);
Semantics\AmbiguousOverrideTests.cs (8)
529Assert.NotEqual(baseMethod2, derivedMethod.OverriddenMethod); 584Assert.NotEqual(baseMethod2, derivedMethod.OverriddenMethod); 649Assert.NotEqual(baseProperty2, derivedProperty.OverriddenProperty); 717Assert.NotEqual(baseProperty2, derivedProperty.OverriddenProperty); 788Assert.NotEqual(baseProperty2, derivedProperty.OverriddenProperty); 862Assert.NotEqual(baseProperty2, derivedProperty.OverriddenProperty); 941Assert.NotEqual(baseEvent2, derivedEvent.OverriddenEvent); 1024Assert.NotEqual(baseEvent2, derivedEvent.OverriddenEvent);
Semantics\ColorColorTests.cs (15)
600Assert.NotEqual(default, parentInfo); 640Assert.NotEqual(default, info); 647Assert.NotEqual(default, parentInfo); 729Assert.NotEqual(default, info); 1069Assert.NotEqual(default, info); 1115Assert.NotEqual(default, info); 1161Assert.NotEqual(default, info); 1168Assert.NotEqual(default, parentInfo); 1206Assert.NotEqual(default, info); 1213Assert.NotEqual(default, parentInfo); 1247Assert.NotEqual(default, info); 1257Assert.NotEqual(default, parentInfo); 1284Assert.NotEqual(default, info); 1847Assert.NotEqual(default, info); 1854Assert.NotEqual(default, parentInfo);
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)
7409Assert.NotEqual(locationSpecifier, otherLocation); 7411Assert.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)
3058Assert.NotEqual(nameofType, typeofType);
Semantics\NativeIntegerTests.cs (10)
269Assert.NotEqual(underlyingType, nativeIntegerType); 270Assert.NotEqual(nativeIntegerType, underlyingType); 380Assert.NotEqual(underlyingType, nativeIntegerType); 381Assert.NotEqual(nativeIntegerType, underlyingType); 556Assert.NotEqual(member, underlyingMember); 605Assert.NotEqual(containsType(fromMember, useNativeInteger: true), fromMember.Equals(fromUnderlyingMember, TypeCompareKind.ConsiderEverything)); 800Assert.NotEqual(corLibA, corLibB); 910Assert.NotEqual(corLibA, corLibB); 1027Assert.NotEqual(corLibA, corLibB); 1089Assert.NotEqual(f0B.Type.ContainingAssembly, f0.Type.ContainingAssembly);
Semantics\NullableReferenceTypesTests.cs (3)
98921Assert.NotEqual(m, nullableAttribute.AttributeClass.ContainingModule); 105050Assert.NotEqual(m, nullableAttribute.AttributeClass.ContainingModule); 144438Assert.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); 7728Assert.NotEqual(symbols1[i], symbols2[i]); 8139Assert.NotEqual(symbol1.Parameters[0], symbol5.Parameters[1]); 8487Assert.NotEqual(symbol1, symbol3); 8505Assert.NotEqual(symbol1, symbol4); 8519Assert.NotEqual(symbol1, symbol3); 8528Assert.NotEqual(symbol1, symbol4); 8611Assert.NotEqual(symbols1[i], symbols2[i]); 8711Assert.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\StructConstructorTests.cs (1)
3241Assert.NotEqual(corLibA, corLibB);
Semantics\SwitchTests.cs (1)
1159Assert.NotEqual(default, symbolInfo);
Semantics\SyntaxTreeRootTests.cs (1)
49Assert.NotEqual(typeof(CompilationUnitSyntax), root.GetType());
Semantics\TopLevelStatementsTests.cs (2)
363Assert.NotEqual(refMethod, declMethod); 4959Assert.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)
138Assert.NotEqual(compilation, outputCompilation); 233Assert.NotEqual(compilation, outputCompilation1); 234Assert.NotEqual(compilation, outputCompilation2); 235Assert.NotEqual(compilation, outputCompilation3); 3559Assert.NotEqual(TimeSpan.Zero, timing.ElapsedTime); 3563Assert.NotEqual(TimeSpan.Zero, generatorTiming.ElapsedTime); 3599Assert.NotEqual(TimeSpan.Zero, timing.ElapsedTime); 3604Assert.NotEqual(TimeSpan.Zero, timing1.ElapsedTime); 3609Assert.NotEqual(TimeSpan.Zero, timing2.ElapsedTime); 3639Assert.NotEqual(TimeSpan.Zero, timing.ElapsedTime); 3643Assert.NotEqual(TimeSpan.Zero, generatorTiming.ElapsedTime); 3650Assert.NotEqual(TimeSpan.Zero, timing2.ElapsedTime); 3655Assert.NotEqual(TimeSpan.Zero, generatorTiming2.ElapsedTime);
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);
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (385)
Compilation\CompilationAPITests.cs (10)
361Assert.NotEqual(default, comp.SyntaxTrees); 2852Assert.NotEqual(addBuiltInChecked, symbol); 2853Assert.NotEqual(subtractBuiltIn, symbol); 2854Assert.NotEqual(subtractBuiltInChecked, symbol); 2886Assert.NotEqual(addBuiltIn, symbol); 2888Assert.NotEqual(subtractBuiltIn, symbol); 2889Assert.NotEqual(subtractBuiltInChecked, symbol); 2918Assert.NotEqual(addBuiltIn, symbol); 2920Assert.NotEqual(subtractBuiltIn, symbol); 2921Assert.NotEqual(subtractBuiltInChecked, symbol);
Compilation\CSharpCompilationOptionsTests.cs (2)
48Assert.NotEqual(validNonDefaultValue, validDefaultValue); 483Assert.NotEqual(oldOptions, newOptions);
Compilation\GetSemanticInfoTests.cs (11)
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); 5527Assert.NotEqual(otherFuncType, typeInfo.ConvertedType); 5543Assert.NotEqual(otherFuncType, typeInfo.ConvertedType); // Not affected by call to ClassifyConversion.
Compilation\IndexedProperties_BindingTests.cs (2)
151Assert.NotEqual(default, methodGroup); 154Assert.NotEqual(default, indexerGroup);
Compilation\ReferenceManagerTests.cs (3)
1662Assert.NotEqual(comp.Assembly.Identity, actualIdentity); 1795Assert.NotEqual(moduleSymbol1, moduleSymbol2); 1796Assert.NotEqual(moduleTypeSymbol1, moduleTypeSymbol2);
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 (10)
2978Assert.NotEqual(dsyma1, dsyma2); 3934Assert.NotEqual(alias1.Locations.Single(), alias2.Locations.Single()); 4014Assert.NotEqual(typeA, boundType); 4020Assert.NotEqual(typeA, boundType); 4032Assert.NotEqual(typeB, boundType); 4038Assert.NotEqual(typeB, boundType); 4044Assert.NotEqual(typeB, boundType); 4050Assert.NotEqual(typeB, boundType); // unbound generic type not constructed since illegal 4055Assert.NotEqual(typeB, boundType); // unbound generic type not constructed since illegal 4777Assert.NotEqual(structSymbol, interfaceSymbol);
Compilation\SemanticModelGetSemanticInfoTests.cs (7)
3838Assert.NotEqual(CandidateReason.None, semanticInfo.CandidateReason); 3839Assert.NotEqual(0, semanticInfo.CandidateSymbols.Length); 6343Assert.NotEqual(semanticInfo.Type, param.Type); 9273Assert.NotEqual(type, constructedFrom); 9277Assert.NotEqual(type.TypeParameters[0], type.OriginalDefinition.TypeParameters[0]); // alpha renamed 14483Assert.NotEqual(default, typeInfo); 14737Assert.NotEqual(default, info1);
DocumentationComments\CrefTests.cs (10)
1433Assert.NotEqual(expectedOriginalDefinitionSymbol.TypeParameters.Single(), typeArgument); 1458Assert.NotEqual(expectedOriginalDefinitionSymbol.TypeParameters.Single(), typeArgument); 1484Assert.NotEqual(expectedOriginalDefinitionSymbol.TypeParameters.Single(), typeArgument); 1510Assert.NotEqual(expectedOriginalDefinitionSymbol.TypeParameters.Single(), typeArgument); 1578Assert.NotEqual(actualTypeParameters[0], actualTypeParameters[2]); 1581Assert.NotEqual(actualTypeParameters[0].GetHashCode(), actualTypeParameters[2].GetHashCode()); 1607Assert.NotEqual(expectedOriginalDefinitionSymbol.TypeParameters.Single(), typeArgument); 5569Assert.NotEqual(crefTypeParam, sourceTypeParam); 5570Assert.NotEqual(sourceTypeParam, crefTypeParam); 6026Assert.NotEqual(expectedSymbolOriginalDefinition, actualSymbol);
Symbols\AccessorOverriddenOrHiddenMembersTests.cs (2)
353Assert.NotEqual(ilGetter.Name, csharpGetter.Name); //name not copied 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 (107)
164Assert.NotEqual(SymbolKind.ErrorType, retval1.Kind); 195Assert.NotEqual(SymbolKind.ErrorType, retval2.Kind); 216Assert.NotEqual(SymbolKind.ErrorType, retval3.Kind); 221Assert.NotEqual(SymbolKind.ErrorType, retval4.Kind); 226Assert.NotEqual(SymbolKind.ErrorType, retval5.Kind); 254Assert.NotEqual(SymbolKind.ErrorType, retval6.Kind); 279Assert.NotEqual(SymbolKind.ErrorType, retval7.Kind); 284Assert.NotEqual(SymbolKind.ErrorType, retval8.Kind); 289Assert.NotEqual(SymbolKind.ErrorType, retval9.Kind); 304Assert.NotEqual(SymbolKind.ErrorType, retval10.Kind); 309Assert.NotEqual(SymbolKind.ErrorType, retval11.Kind); 314Assert.NotEqual(SymbolKind.ErrorType, retval12.Kind); 319Assert.NotEqual(SymbolKind.ErrorType, retval13.Kind); 324Assert.NotEqual(SymbolKind.ErrorType, retval14.Kind); 378Assert.NotEqual(SymbolKind.ErrorType, retval17.Kind); 405Assert.NotEqual(SymbolKind.ErrorType, retval21.Kind); 410Assert.NotEqual(SymbolKind.ErrorType, retval22.Kind); 475Assert.NotEqual(SymbolKind.ErrorType, retval1.Kind); 497Assert.NotEqual(SymbolKind.ErrorType, retval2.Kind); 518Assert.NotEqual(SymbolKind.ErrorType, retval3.Kind); 523Assert.NotEqual(SymbolKind.ErrorType, retval4.Kind); 528Assert.NotEqual(SymbolKind.ErrorType, retval5.Kind); 546Assert.NotEqual(SymbolKind.ErrorType, retval6.Kind); 571Assert.NotEqual(SymbolKind.ErrorType, retval7.Kind); 576Assert.NotEqual(SymbolKind.ErrorType, retval8.Kind); 581Assert.NotEqual(SymbolKind.ErrorType, retval9.Kind); 596Assert.NotEqual(SymbolKind.ErrorType, retval10.Kind); 601Assert.NotEqual(SymbolKind.ErrorType, retval11.Kind); 606Assert.NotEqual(SymbolKind.ErrorType, retval12.Kind); 611Assert.NotEqual(SymbolKind.ErrorType, retval13.Kind); 616Assert.NotEqual(SymbolKind.ErrorType, retval14.Kind); 644Assert.NotEqual(SymbolKind.ErrorType, retval17.Kind); 671Assert.NotEqual(SymbolKind.ErrorType, retval21.Kind); 676Assert.NotEqual(SymbolKind.ErrorType, retval22.Kind); 747Assert.NotEqual(SymbolKind.ErrorType, retval1.Kind); 843Assert.NotEqual(SymbolKind.ErrorType, retval2.Kind); 864Assert.NotEqual(SymbolKind.ErrorType, retval3.Kind); 869Assert.NotEqual(SymbolKind.ErrorType, retval4.Kind); 874Assert.NotEqual(SymbolKind.ErrorType, retval5.Kind); 984Assert.NotEqual(SymbolKind.ErrorType, retval6.Kind); 1009Assert.NotEqual(SymbolKind.ErrorType, retval7.Kind); 1014Assert.NotEqual(SymbolKind.ErrorType, retval8.Kind); 1019Assert.NotEqual(SymbolKind.ErrorType, retval9.Kind); 1034Assert.NotEqual(SymbolKind.ErrorType, retval10.Kind); 1039Assert.NotEqual(SymbolKind.ErrorType, retval11.Kind); 1044Assert.NotEqual(SymbolKind.ErrorType, retval12.Kind); 1049Assert.NotEqual(SymbolKind.ErrorType, retval13.Kind); 1054Assert.NotEqual(SymbolKind.ErrorType, retval14.Kind); 1107Assert.NotEqual(SymbolKind.ErrorType, retval17.Kind); 1134Assert.NotEqual(SymbolKind.ErrorType, retval21.Kind); 1139Assert.NotEqual(SymbolKind.ErrorType, retval22.Kind); 1195Assert.NotEqual(SymbolKind.ErrorType, retval1.Kind); 1222Assert.NotEqual(SymbolKind.ErrorType, retval2.Kind); 1243Assert.NotEqual(SymbolKind.ErrorType, retval3.Kind); 1248Assert.NotEqual(SymbolKind.ErrorType, retval4.Kind); 1253Assert.NotEqual(SymbolKind.ErrorType, retval5.Kind); 1275Assert.NotEqual(SymbolKind.ErrorType, retval6.Kind); 1300Assert.NotEqual(SymbolKind.ErrorType, retval7.Kind); 1305Assert.NotEqual(SymbolKind.ErrorType, retval8.Kind); 1310Assert.NotEqual(SymbolKind.ErrorType, retval9.Kind); 1325Assert.NotEqual(SymbolKind.ErrorType, retval10.Kind); 1330Assert.NotEqual(SymbolKind.ErrorType, retval11.Kind); 1335Assert.NotEqual(SymbolKind.ErrorType, retval12.Kind); 1340Assert.NotEqual(SymbolKind.ErrorType, retval13.Kind); 1345Assert.NotEqual(SymbolKind.ErrorType, retval14.Kind); 1380Assert.NotEqual(SymbolKind.ErrorType, retval17.Kind); 1407Assert.NotEqual(SymbolKind.ErrorType, retval21.Kind); 1412Assert.NotEqual(SymbolKind.ErrorType, retval22.Kind); 1458Assert.NotEqual(SymbolKind.ErrorType, retval1.Kind); 1517Assert.NotEqual(SymbolKind.ErrorType, retval2.Kind); 1538Assert.NotEqual(SymbolKind.ErrorType, retval3.Kind); 1543Assert.NotEqual(SymbolKind.ErrorType, retval4.Kind); 1548Assert.NotEqual(SymbolKind.ErrorType, retval5.Kind); 1605Assert.NotEqual(SymbolKind.ErrorType, retval6.Kind); 1630Assert.NotEqual(SymbolKind.ErrorType, retval7.Kind); 1635Assert.NotEqual(SymbolKind.ErrorType, retval8.Kind); 1640Assert.NotEqual(SymbolKind.ErrorType, retval9.Kind); 1655Assert.NotEqual(SymbolKind.ErrorType, retval10.Kind); 1660Assert.NotEqual(SymbolKind.ErrorType, retval11.Kind); 1665Assert.NotEqual(SymbolKind.ErrorType, retval12.Kind); 1670Assert.NotEqual(SymbolKind.ErrorType, retval13.Kind); 1675Assert.NotEqual(SymbolKind.ErrorType, retval14.Kind); 1743Assert.NotEqual(SymbolKind.ErrorType, retval17.Kind); 1770Assert.NotEqual(SymbolKind.ErrorType, retval21.Kind); 1775Assert.NotEqual(SymbolKind.ErrorType, retval22.Kind); 1841Assert.NotEqual(SymbolKind.ErrorType, retval1.Kind); 1868Assert.NotEqual(SymbolKind.ErrorType, retval2.Kind); 1889Assert.NotEqual(SymbolKind.ErrorType, retval3.Kind); 1894Assert.NotEqual(SymbolKind.ErrorType, retval4.Kind); 1899Assert.NotEqual(SymbolKind.ErrorType, retval5.Kind); 1921Assert.NotEqual(SymbolKind.ErrorType, retval6.Kind); 1946Assert.NotEqual(SymbolKind.ErrorType, retval7.Kind); 1951Assert.NotEqual(SymbolKind.ErrorType, retval8.Kind); 1956Assert.NotEqual(SymbolKind.ErrorType, retval9.Kind); 1971Assert.NotEqual(SymbolKind.ErrorType, retval10.Kind); 1976Assert.NotEqual(SymbolKind.ErrorType, retval11.Kind); 1981Assert.NotEqual(SymbolKind.ErrorType, retval12.Kind); 1986Assert.NotEqual(SymbolKind.ErrorType, retval13.Kind); 1991Assert.NotEqual(SymbolKind.ErrorType, retval14.Kind); 2028Assert.NotEqual(SymbolKind.ErrorType, retval17.Kind); 2055Assert.NotEqual(SymbolKind.ErrorType, retval21.Kind); 2060Assert.NotEqual(SymbolKind.ErrorType, retval22.Kind); 2334Assert.NotEqual(localC3Foo2, foo2); 2351Assert.NotEqual(localC3Foo2.Parameters[0].Type, x1.Type); 2361Assert.NotEqual(localC3Foo2.Parameters[1].Type, x2.Type); 2528Assert.NotEqual(SymbolKind.ErrorType, typeC5.Kind); 2578Assert.NotEqual(module1, module2);
Symbols\CorLibrary\CorTypes.cs (3)
76Assert.NotEqual(TypeKind.Error, t.TypeKind); 93Assert.NotEqual(TypeKind.Error, t.TypeKind); 151Assert.NotEqual(TypeKind.Error, t.TypeKind);
Symbols\CovariantReturnTests.cs (1)
521Assert.NotEqual(originalCorLib, newCorLib);
Symbols\CustomModifiersTests.cs (2)
299Assert.NotEqual(withoutModifiers, withModifiers); 1466Assert.NotEqual(base1, base2);
Symbols\DefaultInterfaceImplementationTests.cs (13)
214Assert.NotEqual(0, rva); 2135Assert.NotEqual(0, rva); 2719Assert.NotEqual(0, rva); 2725Assert.NotEqual(0, rva); 6440Assert.NotEqual(0, rva); 6446Assert.NotEqual(0, rva); 18344Assert.NotEqual(isAbstract, p1.IsVirtual); 18381Assert.NotEqual(isAbstract || access == Accessibility.Private, m1.IsVirtual); 33078Assert.NotEqual(0, rva); 33906Assert.NotEqual(m1.OriginalDefinition is PEMethodSymbol, m1.IsExtern); 34023Assert.NotEqual(m1 is PEMethodSymbol, m1.IsAsync); 34031Assert.NotEqual(0, rva); 38017Assert.NotEqual(m1.OriginalDefinition is PEPropertySymbol, m1.IsExtern);
Symbols\DestructorTests.cs (1)
417Assert.NotEqual(default, info);
Symbols\ErrorTypeSymbolTests.cs (1)
75Assert.NotEqual(type, constructedFrom);
Symbols\ExtendedPartialMethodsTests.cs (1)
3840Assert.NotEqual(implSymbol, defSymbol);
Symbols\IndexerTests.cs (14)
332Assert.NotEqual(interface1Indexer.MetadataName, interface2Indexer.MetadataName); 333Assert.NotEqual(interface1Indexer.MetadataName, classIndexer.MetadataName); 334Assert.NotEqual(interface2Indexer.MetadataName, classIndexer.MetadataName); 414Assert.NotEqual(interface1Indexer.MetadataName, interface2Indexer.MetadataName); 415Assert.NotEqual(interface1Indexer.MetadataName, classIndexer.MetadataName); 416Assert.NotEqual(interface2Indexer.MetadataName, classIndexer.MetadataName); 623Assert.NotEqual(baseIndexer.MetadataName, derivedIndexer.MetadataName); 680Assert.NotEqual(baseIndexer.MetadataName, derivedIndexer.MetadataName); 749Assert.NotEqual(baseIndexers[0].MetadataName, baseIndexers[1].MetadataName); 750Assert.NotEqual(baseIndexers[0].MetadataName, derivedIndexer.MetadataName); 751Assert.NotEqual(baseIndexers[1].MetadataName, derivedIndexer.MetadataName); 820Assert.NotEqual(baseIndexers[0].MetadataName, baseIndexers[1].MetadataName); 821Assert.NotEqual(baseIndexers[0].MetadataName, derivedIndexer.MetadataName); 822Assert.NotEqual(baseIndexers[1].MetadataName, derivedIndexer.MetadataName);
Symbols\Metadata\PE\BaseTypeResolution.cs (9)
206Assert.NotEqual(SymbolKind.ErrorType, @base.Kind); 227Assert.NotEqual(SymbolKind.ErrorType, base1.Kind); 233Assert.NotEqual(SymbolKind.ErrorType, base2.Kind); 239Assert.NotEqual(SymbolKind.ErrorType, base3.Kind); 245Assert.NotEqual(SymbolKind.ErrorType, base4.Kind); 251Assert.NotEqual(SymbolKind.ErrorType, base5.Kind); 257Assert.NotEqual(SymbolKind.ErrorType, base6.Kind); 263Assert.NotEqual(SymbolKind.ErrorType, base7.Kind); 269Assert.NotEqual(SymbolKind.ErrorType, base8.Kind);
Symbols\Metadata\PE\LoadingEvents.cs (2)
135Assert.NotEqual(mismatchedAddEvent.Type, mismatchedAddEvent.AddMethod.Parameters.Single().Type); 138Assert.NotEqual(mismatchedRemoveEvent.Type, mismatchedRemoveEvent.RemoveMethod.Parameters.Single().Type);
Symbols\Metadata\PE\LoadingIndexers.cs (7)
712Assert.NotEqual(parameterCountIndexer.ParameterCount, parameterCountIndexer.GetMethod.ParameterCount); 717Assert.NotEqual(parameterTypesIndexer.Parameters.Last().Type, parameterTypesIndexer.GetMethod.Parameters.Last().Type); 722Assert.NotEqual(returnTypeIndexer.Type, returnTypeIndexer.GetMethod.ReturnType); 727Assert.NotEqual(parameterModoptIndexer.Parameters.Last().TypeWithAnnotations.CustomModifiers.Length, parameterModoptIndexer.GetMethod.Parameters.Last().TypeWithAnnotations.CustomModifiers.Length); 732Assert.NotEqual(returnTypeModoptIndexer.TypeWithAnnotations.CustomModifiers.Length, returnTypeModoptIndexer.GetMethod.ReturnTypeWithAnnotations.CustomModifiers.Length); 792Assert.NotEqual(property1ParamName, property1.GetMethod.Parameters.Single().Name); 1037Assert.NotEqual(expectIndexer, property.MustCallMethodsDirectly);
Symbols\Metadata\PE\LoadingNamespacesAndTypes.cs (3)
197Assert.NotEqual(someName1_1[0], someName1_2[0]); 205Assert.NotEqual(someName2_1[0], someName2_2[0]); 212Assert.NotEqual(otherName_1[0], otherName_2[0]);
Symbols\Metadata\PE\MissingTypeReferences.cs (8)
297Assert.NotEqual(asm1m2.ReturnType, asm1m1.ReturnType); 298Assert.NotEqual(asm1m3.ReturnType, asm1m1.ReturnType); 299Assert.NotEqual(asm1m4.ReturnType, asm1m1.ReturnType); 301Assert.NotEqual(asm1m5.ReturnType, asm1m4.ReturnType); 302Assert.NotEqual(asm1m6.ReturnType, asm1m4.ReturnType); 370Assert.NotEqual(missingTypes2[j], missingTypes1[i]); 371Assert.NotEqual(missingTypes1[i], missingTypes2[j]); 378Assert.NotEqual(new object(), missingAssembly);
Symbols\Metadata\PE\NoPia.cs (35)
270Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 271Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 604Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 605Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 717Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 718Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 724Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 736Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 737Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 739Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 780Assert.NotEqual(SymbolKind.ErrorType, varI5_2.GetMembers("Foo").OfType<MethodSymbol>().Single().ReturnType.Kind); 794Assert.NotEqual(SymbolKind.ErrorType, varI7_3.GetMembers("Bar").OfType<MethodSymbol>().Single().ReturnType.Kind); 809Assert.NotEqual(SymbolKind.ErrorType, varI7_4.GetMembers("Foo").OfType<MethodSymbol>().Single().ReturnType.Kind); 810Assert.NotEqual(SymbolKind.ErrorType, varI7_4.GetMembers("Bar").OfType<MethodSymbol>().Single().ReturnType.Kind); 858Assert.NotEqual(SymbolKind.ErrorType, varI7_7.GetMembers("Bar").OfType<MethodSymbol>().Single().ReturnType.Kind); 1018Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1019Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1025Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 1037Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1038Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1040Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 1147Assert.NotEqual(SymbolKind.ErrorType, varI5_2.GetMembers("Foo").OfType<MethodSymbol>().Single().ReturnType.Kind); 1161Assert.NotEqual(SymbolKind.ErrorType, varI7_3.GetMembers("Bar").OfType<MethodSymbol>().Single().ReturnType.Kind); 1176Assert.NotEqual(SymbolKind.ErrorType, varI7_4.GetMembers("Foo").OfType<MethodSymbol>().Single().ReturnType.Kind); 1177Assert.NotEqual(SymbolKind.ErrorType, varI7_4.GetMembers("Bar").OfType<MethodSymbol>().Single().ReturnType.Kind); 1225Assert.NotEqual(SymbolKind.ErrorType, varI7_7.GetMembers("Bar").OfType<MethodSymbol>().Single().ReturnType.Kind); 1239Assert.NotEqual(SymbolKind.ErrorType, varI5.Kind); 1240Assert.NotEqual(SymbolKind.ErrorType, varI6.Kind); 1241Assert.NotEqual(SymbolKind.ErrorType, varI5_Foo.ReturnType.Kind); 1242Assert.NotEqual(SymbolKind.ErrorType, ((NamedTypeSymbol)varI5_Foo.ReturnType).TypeArguments()[0].Kind); 1249Assert.NotEqual(SymbolKind.ErrorType, varI7_Foo.ReturnType.Kind); 1250Assert.NotEqual(SymbolKind.ErrorType, ((NamedTypeSymbol)varI7_Foo.ReturnType).TypeArguments()[0].Kind); 1253Assert.NotEqual(SymbolKind.ErrorType, varI7_Bar.ReturnType.Kind); 1254Assert.NotEqual(SymbolKind.ErrorType, ((NamedTypeSymbol)varI7_Bar.ReturnType).TypeArguments()[0].Kind); 1259Assert.NotEqual(SymbolKind.ErrorType, varI1.Kind);
Symbols\Metadata\PE\TypeForwarders.cs (3)
106Assert.NotEqual(TypeKind.Error, funcType.TypeKind); 1498Assert.NotEqual(TypeKind.Error, type.TypeKind); 1767Assert.NotEqual(TypeKind.Error, type.TypeKind);
Symbols\MethodEqualityTests.cs (36)
50Assert.NotEqual<Symbol>(class1, class1Method1); 51Assert.NotEqual<Symbol>(class1Method1, class1); 54Assert.NotEqual(class1Method1, class1Method2); 55Assert.NotEqual(class1Method2, class1Method1); 58Assert.NotEqual(class1Method1, class2Method1); 59Assert.NotEqual(class2Method1, class1Method1); 98Assert.NotEqual(baseClassMethod1, substitutedBaseClassMethod1); 99Assert.NotEqual(substitutedBaseClassMethod1, baseClassMethod1); 102Assert.NotEqual(baseClassMethod1, constructedBaseClassMethod1); 103Assert.NotEqual(constructedBaseClassMethod1, baseClassMethod1); 106Assert.NotEqual(substitutedBaseClassMethod1, constructedBaseClassMethod1); 107Assert.NotEqual(constructedBaseClassMethod1, substitutedBaseClassMethod1); 110Assert.NotEqual(baseClassMethod1, baseClassMethod2); 111Assert.NotEqual(baseClassMethod2, baseClassMethod1); 114Assert.NotEqual(substitutedBaseClassMethod1, substitutedBaseClassMethod2); 115Assert.NotEqual(substitutedBaseClassMethod2, substitutedBaseClassMethod1); 118Assert.NotEqual(constructedBaseClassMethod1, constructedBaseClassMethod2); 119Assert.NotEqual(constructedBaseClassMethod2, constructedBaseClassMethod1); 158Assert.NotEqual(baseClassMethod1, substitutedBaseClassMethod1); 159Assert.NotEqual(substitutedBaseClassMethod1, baseClassMethod1); 162Assert.NotEqual(baseClassMethod1, constructedBaseClassMethod1); 163Assert.NotEqual(constructedBaseClassMethod1, baseClassMethod1); 166Assert.NotEqual(substitutedBaseClassMethod1, constructedBaseClassMethod1); 167Assert.NotEqual(constructedBaseClassMethod1, substitutedBaseClassMethod1); 170Assert.NotEqual(baseClassMethod1, baseClassMethod2); 171Assert.NotEqual(baseClassMethod2, baseClassMethod1); 174Assert.NotEqual(substitutedBaseClassMethod1, substitutedBaseClassMethod2); 175Assert.NotEqual(substitutedBaseClassMethod2, substitutedBaseClassMethod1); 178Assert.NotEqual(constructedBaseClassMethod1, constructedBaseClassMethod2); 179Assert.NotEqual(constructedBaseClassMethod2, constructedBaseClassMethod1); 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\OverriddenOrHiddenMembersTests.cs (1)
4347Assert.NotEqual(aMethod, bMethod);
Symbols\PartialPropertiesTests.cs (4)
5236Assert.NotEqual(defSymbol, implSymbol); 5272Assert.NotEqual(defSymbol, implSymbol); 5319Assert.NotEqual(defSymbol, implSymbol); 5356Assert.NotEqual(defSymbol, implSymbol);
Symbols\Retargeting\NoPia.cs (24)
573Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 574Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 874Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 875Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 1178Assert.NotEqual(SymbolKind.ErrorType, param[0].Type.Kind); 1179Assert.NotEqual(SymbolKind.ErrorType, param[1].Type.Kind); 1349Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1350Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1356Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 1370Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1371Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1373Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 1902Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1903Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1909Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 1923Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1924Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1926Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 1952Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1953Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1959Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind); 1973Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test1").OfType<MethodSymbol>().Single().ReturnType.Kind); 1974Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test2").OfType<MethodSymbol>().Single().ReturnType.Kind); 1976Assert.NotEqual(SymbolKind.ErrorType, localTypes3.GetMembers("Test4").OfType<MethodSymbol>().Single().ReturnType.Kind);
Symbols\Source\BaseClassTests.cs (15)
39Assert.NotEqual(y, x.BaseType()); 40Assert.NotEqual(x, y.BaseType()); 59Assert.NotEqual(y, x.BaseType()); 60Assert.NotEqual(x, y.BaseType()); 107Assert.NotEqual(e, e.BaseType()); 136Assert.NotEqual(d, d.BaseType()); 185Assert.NotEqual(b, b.BaseType()); 186Assert.NotEqual(a, b.BaseType()); 188Assert.NotEqual(ic, a.Interfaces()[0]); 1099Assert.NotEqual(B1, B2); 1225Assert.NotEqual(B1, B2); 1262Assert.NotEqual(d, b.BaseType()); 1322Assert.NotEqual(SymbolKind.ErrorType, d.BaseType().Kind); 1392Assert.NotEqual(a, a2.BaseType()); 1395Assert.NotEqual(b, b2.BaseType());
Symbols\Source\FileModifierTests.cs (2)
4291Assert.NotEqual(types[0], types[1]); 4383Assert.NotEqual(comp.Assembly.CorLibrary, comp2.Assembly.CorLibrary);
Symbols\Source\MethodTests.cs (1)
1384Assert.NotEqual(classBMethodM, classCBaseMethodM);
Symbols\Source\TypeMapTests.cs (1)
79Assert.NotEqual(c, aebfc.ConstructedFrom);
Symbols\SymbolDistinguisherTests.cs (1)
318Assert.NotEqual(TypeKind.Error, validType.TypeKind);
Symbols\SymbolEqualityTests.cs (3)
382Assert.NotEqual(SymbolEqualityComparer.Default.GetHashCode(symbol1), SymbolEqualityComparer.Default.GetHashCode(symbol2)); 385Assert.NotEqual(SymbolEqualityComparer.ConsiderEverything.GetHashCode(symbol1), SymbolEqualityComparer.ConsiderEverything.GetHashCode(symbol2)); 968Assert.NotEqual(lambdas[0], lambdas[1]);
Symbols\TypeTests.cs (4)
645Assert.NotEqual(SymbolKind.ErrorType, objType.Kind); 653Assert.NotEqual(SymbolKind.ErrorType, dynType.Kind); 1811Assert.NotEqual(Object, Dynamic); 1816Assert.NotEqual(Func_Object, Func_Dynamic);
Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (2257)
Diagnostics\DiagnosticTest.cs (1)
220Assert.NotEqual(0, ErrorFacts.GetWarningLevel(errorCode));
Diagnostics\LineSpanDirectiveTests.cs (1)
466Assert.NotEqual(SyntaxKind.None, directive.DirectiveNameToken.Kind());
Diagnostics\LocationsTests.cs (3)
435Assert.NotEqual(loc1, loc3); 436Assert.NotEqual(loc3, loc4); 521Assert.NotEqual(locationWithMapping, locationWithoutMapping);
Generated\Syntax.Test.xml.Generated.cs (494)
3945Assert.NotEqual(oldNode, newNode); 3971Assert.NotEqual(oldNode, newNode); 3997Assert.NotEqual(oldNode, newNode); 4023Assert.NotEqual(oldNode, newNode); 4049Assert.NotEqual(oldNode, newNode); 4075Assert.NotEqual(oldNode, newNode); 4101Assert.NotEqual(oldNode, newNode); 4127Assert.NotEqual(oldNode, newNode); 4153Assert.NotEqual(oldNode, newNode); 4179Assert.NotEqual(oldNode, newNode); 4205Assert.NotEqual(oldNode, newNode); 4231Assert.NotEqual(oldNode, newNode); 4257Assert.NotEqual(oldNode, newNode); 4283Assert.NotEqual(oldNode, newNode); 4309Assert.NotEqual(oldNode, newNode); 4335Assert.NotEqual(oldNode, newNode); 4361Assert.NotEqual(oldNode, newNode); 4387Assert.NotEqual(oldNode, newNode); 4413Assert.NotEqual(oldNode, newNode); 4439Assert.NotEqual(oldNode, newNode); 4465Assert.NotEqual(oldNode, newNode); 4491Assert.NotEqual(oldNode, newNode); 4517Assert.NotEqual(oldNode, newNode); 4543Assert.NotEqual(oldNode, newNode); 4569Assert.NotEqual(oldNode, newNode); 4595Assert.NotEqual(oldNode, newNode); 4621Assert.NotEqual(oldNode, newNode); 4647Assert.NotEqual(oldNode, newNode); 4673Assert.NotEqual(oldNode, newNode); 4699Assert.NotEqual(oldNode, newNode); 4725Assert.NotEqual(oldNode, newNode); 4751Assert.NotEqual(oldNode, newNode); 4777Assert.NotEqual(oldNode, newNode); 4803Assert.NotEqual(oldNode, newNode); 4829Assert.NotEqual(oldNode, newNode); 4855Assert.NotEqual(oldNode, newNode); 4881Assert.NotEqual(oldNode, newNode); 4907Assert.NotEqual(oldNode, newNode); 4933Assert.NotEqual(oldNode, newNode); 4959Assert.NotEqual(oldNode, newNode); 4985Assert.NotEqual(oldNode, newNode); 5011Assert.NotEqual(oldNode, newNode); 5037Assert.NotEqual(oldNode, newNode); 5063Assert.NotEqual(oldNode, newNode); 5089Assert.NotEqual(oldNode, newNode); 5115Assert.NotEqual(oldNode, newNode); 5141Assert.NotEqual(oldNode, newNode); 5167Assert.NotEqual(oldNode, newNode); 5193Assert.NotEqual(oldNode, newNode); 5219Assert.NotEqual(oldNode, newNode); 5245Assert.NotEqual(oldNode, newNode); 5271Assert.NotEqual(oldNode, newNode); 5297Assert.NotEqual(oldNode, newNode); 5323Assert.NotEqual(oldNode, newNode); 5349Assert.NotEqual(oldNode, newNode); 5375Assert.NotEqual(oldNode, newNode); 5401Assert.NotEqual(oldNode, newNode); 5427Assert.NotEqual(oldNode, newNode); 5453Assert.NotEqual(oldNode, newNode); 5479Assert.NotEqual(oldNode, newNode); 5505Assert.NotEqual(oldNode, newNode); 5531Assert.NotEqual(oldNode, newNode); 5557Assert.NotEqual(oldNode, newNode); 5583Assert.NotEqual(oldNode, newNode); 5609Assert.NotEqual(oldNode, newNode); 5635Assert.NotEqual(oldNode, newNode); 5661Assert.NotEqual(oldNode, newNode); 5687Assert.NotEqual(oldNode, newNode); 5713Assert.NotEqual(oldNode, newNode); 5739Assert.NotEqual(oldNode, newNode); 5765Assert.NotEqual(oldNode, newNode); 5791Assert.NotEqual(oldNode, newNode); 5817Assert.NotEqual(oldNode, newNode); 5843Assert.NotEqual(oldNode, newNode); 5869Assert.NotEqual(oldNode, newNode); 5895Assert.NotEqual(oldNode, newNode); 5921Assert.NotEqual(oldNode, newNode); 5947Assert.NotEqual(oldNode, newNode); 5973Assert.NotEqual(oldNode, newNode); 5999Assert.NotEqual(oldNode, newNode); 6025Assert.NotEqual(oldNode, newNode); 6051Assert.NotEqual(oldNode, newNode); 6077Assert.NotEqual(oldNode, newNode); 6103Assert.NotEqual(oldNode, newNode); 6129Assert.NotEqual(oldNode, newNode); 6155Assert.NotEqual(oldNode, newNode); 6181Assert.NotEqual(oldNode, newNode); 6207Assert.NotEqual(oldNode, newNode); 6233Assert.NotEqual(oldNode, newNode); 6259Assert.NotEqual(oldNode, newNode); 6285Assert.NotEqual(oldNode, newNode); 6311Assert.NotEqual(oldNode, newNode); 6337Assert.NotEqual(oldNode, newNode); 6363Assert.NotEqual(oldNode, newNode); 6389Assert.NotEqual(oldNode, newNode); 6415Assert.NotEqual(oldNode, newNode); 6441Assert.NotEqual(oldNode, newNode); 6467Assert.NotEqual(oldNode, newNode); 6493Assert.NotEqual(oldNode, newNode); 6519Assert.NotEqual(oldNode, newNode); 6545Assert.NotEqual(oldNode, newNode); 6571Assert.NotEqual(oldNode, newNode); 6597Assert.NotEqual(oldNode, newNode); 6623Assert.NotEqual(oldNode, newNode); 6649Assert.NotEqual(oldNode, newNode); 6675Assert.NotEqual(oldNode, newNode); 6701Assert.NotEqual(oldNode, newNode); 6727Assert.NotEqual(oldNode, newNode); 6753Assert.NotEqual(oldNode, newNode); 6779Assert.NotEqual(oldNode, newNode); 6805Assert.NotEqual(oldNode, newNode); 6831Assert.NotEqual(oldNode, newNode); 6857Assert.NotEqual(oldNode, newNode); 6883Assert.NotEqual(oldNode, newNode); 6909Assert.NotEqual(oldNode, newNode); 6935Assert.NotEqual(oldNode, newNode); 6961Assert.NotEqual(oldNode, newNode); 6987Assert.NotEqual(oldNode, newNode); 7013Assert.NotEqual(oldNode, newNode); 7039Assert.NotEqual(oldNode, newNode); 7065Assert.NotEqual(oldNode, newNode); 7091Assert.NotEqual(oldNode, newNode); 7117Assert.NotEqual(oldNode, newNode); 7143Assert.NotEqual(oldNode, newNode); 7169Assert.NotEqual(oldNode, newNode); 7195Assert.NotEqual(oldNode, newNode); 7221Assert.NotEqual(oldNode, newNode); 7247Assert.NotEqual(oldNode, newNode); 7273Assert.NotEqual(oldNode, newNode); 7299Assert.NotEqual(oldNode, newNode); 7325Assert.NotEqual(oldNode, newNode); 7351Assert.NotEqual(oldNode, newNode); 7377Assert.NotEqual(oldNode, newNode); 7403Assert.NotEqual(oldNode, newNode); 7429Assert.NotEqual(oldNode, newNode); 7455Assert.NotEqual(oldNode, newNode); 7481Assert.NotEqual(oldNode, newNode); 7507Assert.NotEqual(oldNode, newNode); 7533Assert.NotEqual(oldNode, newNode); 7559Assert.NotEqual(oldNode, newNode); 7585Assert.NotEqual(oldNode, newNode); 7611Assert.NotEqual(oldNode, newNode); 7637Assert.NotEqual(oldNode, newNode); 7663Assert.NotEqual(oldNode, newNode); 7689Assert.NotEqual(oldNode, newNode); 7715Assert.NotEqual(oldNode, newNode); 7741Assert.NotEqual(oldNode, newNode); 7767Assert.NotEqual(oldNode, newNode); 7793Assert.NotEqual(oldNode, newNode); 7819Assert.NotEqual(oldNode, newNode); 7845Assert.NotEqual(oldNode, newNode); 7871Assert.NotEqual(oldNode, newNode); 7897Assert.NotEqual(oldNode, newNode); 7923Assert.NotEqual(oldNode, newNode); 7949Assert.NotEqual(oldNode, newNode); 7975Assert.NotEqual(oldNode, newNode); 8001Assert.NotEqual(oldNode, newNode); 8027Assert.NotEqual(oldNode, newNode); 8053Assert.NotEqual(oldNode, newNode); 8079Assert.NotEqual(oldNode, newNode); 8105Assert.NotEqual(oldNode, newNode); 8131Assert.NotEqual(oldNode, newNode); 8157Assert.NotEqual(oldNode, newNode); 8183Assert.NotEqual(oldNode, newNode); 8209Assert.NotEqual(oldNode, newNode); 8235Assert.NotEqual(oldNode, newNode); 8261Assert.NotEqual(oldNode, newNode); 8287Assert.NotEqual(oldNode, newNode); 8313Assert.NotEqual(oldNode, newNode); 8339Assert.NotEqual(oldNode, newNode); 8365Assert.NotEqual(oldNode, newNode); 8391Assert.NotEqual(oldNode, newNode); 8417Assert.NotEqual(oldNode, newNode); 8443Assert.NotEqual(oldNode, newNode); 8469Assert.NotEqual(oldNode, newNode); 8495Assert.NotEqual(oldNode, newNode); 8521Assert.NotEqual(oldNode, newNode); 8547Assert.NotEqual(oldNode, newNode); 8573Assert.NotEqual(oldNode, newNode); 8599Assert.NotEqual(oldNode, newNode); 8625Assert.NotEqual(oldNode, newNode); 8651Assert.NotEqual(oldNode, newNode); 8677Assert.NotEqual(oldNode, newNode); 8703Assert.NotEqual(oldNode, newNode); 8729Assert.NotEqual(oldNode, newNode); 8755Assert.NotEqual(oldNode, newNode); 8781Assert.NotEqual(oldNode, newNode); 8807Assert.NotEqual(oldNode, newNode); 8833Assert.NotEqual(oldNode, newNode); 8859Assert.NotEqual(oldNode, newNode); 8885Assert.NotEqual(oldNode, newNode); 8911Assert.NotEqual(oldNode, newNode); 8937Assert.NotEqual(oldNode, newNode); 8963Assert.NotEqual(oldNode, newNode); 8989Assert.NotEqual(oldNode, newNode); 9015Assert.NotEqual(oldNode, newNode); 9041Assert.NotEqual(oldNode, newNode); 9067Assert.NotEqual(oldNode, newNode); 9093Assert.NotEqual(oldNode, newNode); 9119Assert.NotEqual(oldNode, newNode); 9145Assert.NotEqual(oldNode, newNode); 9171Assert.NotEqual(oldNode, newNode); 9197Assert.NotEqual(oldNode, newNode); 9223Assert.NotEqual(oldNode, newNode); 9249Assert.NotEqual(oldNode, newNode); 9275Assert.NotEqual(oldNode, newNode); 9301Assert.NotEqual(oldNode, newNode); 9327Assert.NotEqual(oldNode, newNode); 9353Assert.NotEqual(oldNode, newNode); 9379Assert.NotEqual(oldNode, newNode); 9405Assert.NotEqual(oldNode, newNode); 9431Assert.NotEqual(oldNode, newNode); 9457Assert.NotEqual(oldNode, newNode); 9483Assert.NotEqual(oldNode, newNode); 9509Assert.NotEqual(oldNode, newNode); 9535Assert.NotEqual(oldNode, newNode); 9561Assert.NotEqual(oldNode, newNode); 9587Assert.NotEqual(oldNode, newNode); 9613Assert.NotEqual(oldNode, newNode); 9639Assert.NotEqual(oldNode, newNode); 9665Assert.NotEqual(oldNode, newNode); 9691Assert.NotEqual(oldNode, newNode); 9717Assert.NotEqual(oldNode, newNode); 9743Assert.NotEqual(oldNode, newNode); 9769Assert.NotEqual(oldNode, newNode); 9795Assert.NotEqual(oldNode, newNode); 9821Assert.NotEqual(oldNode, newNode); 9847Assert.NotEqual(oldNode, newNode); 9873Assert.NotEqual(oldNode, newNode); 9899Assert.NotEqual(oldNode, newNode); 9925Assert.NotEqual(oldNode, newNode); 9951Assert.NotEqual(oldNode, newNode); 9977Assert.NotEqual(oldNode, newNode); 10003Assert.NotEqual(oldNode, newNode); 10029Assert.NotEqual(oldNode, newNode); 10055Assert.NotEqual(oldNode, newNode); 10081Assert.NotEqual(oldNode, newNode); 10107Assert.NotEqual(oldNode, newNode); 10133Assert.NotEqual(oldNode, newNode); 10159Assert.NotEqual(oldNode, newNode); 10185Assert.NotEqual(oldNode, newNode); 10211Assert.NotEqual(oldNode, newNode); 10237Assert.NotEqual(oldNode, newNode); 10263Assert.NotEqual(oldNode, newNode); 10289Assert.NotEqual(oldNode, newNode); 10315Assert.NotEqual(oldNode, newNode); 10341Assert.NotEqual(oldNode, newNode); 14295Assert.NotEqual(oldNode, newNode); 14321Assert.NotEqual(oldNode, newNode); 14347Assert.NotEqual(oldNode, newNode); 14373Assert.NotEqual(oldNode, newNode); 14399Assert.NotEqual(oldNode, newNode); 14425Assert.NotEqual(oldNode, newNode); 14451Assert.NotEqual(oldNode, newNode); 14477Assert.NotEqual(oldNode, newNode); 14503Assert.NotEqual(oldNode, newNode); 14529Assert.NotEqual(oldNode, newNode); 14555Assert.NotEqual(oldNode, newNode); 14581Assert.NotEqual(oldNode, newNode); 14607Assert.NotEqual(oldNode, newNode); 14633Assert.NotEqual(oldNode, newNode); 14659Assert.NotEqual(oldNode, newNode); 14685Assert.NotEqual(oldNode, newNode); 14711Assert.NotEqual(oldNode, newNode); 14737Assert.NotEqual(oldNode, newNode); 14763Assert.NotEqual(oldNode, newNode); 14789Assert.NotEqual(oldNode, newNode); 14815Assert.NotEqual(oldNode, newNode); 14841Assert.NotEqual(oldNode, newNode); 14867Assert.NotEqual(oldNode, newNode); 14893Assert.NotEqual(oldNode, newNode); 14919Assert.NotEqual(oldNode, newNode); 14945Assert.NotEqual(oldNode, newNode); 14971Assert.NotEqual(oldNode, newNode); 14997Assert.NotEqual(oldNode, newNode); 15023Assert.NotEqual(oldNode, newNode); 15049Assert.NotEqual(oldNode, newNode); 15075Assert.NotEqual(oldNode, newNode); 15101Assert.NotEqual(oldNode, newNode); 15127Assert.NotEqual(oldNode, newNode); 15153Assert.NotEqual(oldNode, newNode); 15179Assert.NotEqual(oldNode, newNode); 15205Assert.NotEqual(oldNode, newNode); 15231Assert.NotEqual(oldNode, newNode); 15257Assert.NotEqual(oldNode, newNode); 15283Assert.NotEqual(oldNode, newNode); 15309Assert.NotEqual(oldNode, newNode); 15335Assert.NotEqual(oldNode, newNode); 15361Assert.NotEqual(oldNode, newNode); 15387Assert.NotEqual(oldNode, newNode); 15413Assert.NotEqual(oldNode, newNode); 15439Assert.NotEqual(oldNode, newNode); 15465Assert.NotEqual(oldNode, newNode); 15491Assert.NotEqual(oldNode, newNode); 15517Assert.NotEqual(oldNode, newNode); 15543Assert.NotEqual(oldNode, newNode); 15569Assert.NotEqual(oldNode, newNode); 15595Assert.NotEqual(oldNode, newNode); 15621Assert.NotEqual(oldNode, newNode); 15647Assert.NotEqual(oldNode, newNode); 15673Assert.NotEqual(oldNode, newNode); 15699Assert.NotEqual(oldNode, newNode); 15725Assert.NotEqual(oldNode, newNode); 15751Assert.NotEqual(oldNode, newNode); 15777Assert.NotEqual(oldNode, newNode); 15803Assert.NotEqual(oldNode, newNode); 15829Assert.NotEqual(oldNode, newNode); 15855Assert.NotEqual(oldNode, newNode); 15881Assert.NotEqual(oldNode, newNode); 15907Assert.NotEqual(oldNode, newNode); 15933Assert.NotEqual(oldNode, newNode); 15959Assert.NotEqual(oldNode, newNode); 15985Assert.NotEqual(oldNode, newNode); 16011Assert.NotEqual(oldNode, newNode); 16037Assert.NotEqual(oldNode, newNode); 16063Assert.NotEqual(oldNode, newNode); 16089Assert.NotEqual(oldNode, newNode); 16115Assert.NotEqual(oldNode, newNode); 16141Assert.NotEqual(oldNode, newNode); 16167Assert.NotEqual(oldNode, newNode); 16193Assert.NotEqual(oldNode, newNode); 16219Assert.NotEqual(oldNode, newNode); 16245Assert.NotEqual(oldNode, newNode); 16271Assert.NotEqual(oldNode, newNode); 16297Assert.NotEqual(oldNode, newNode); 16323Assert.NotEqual(oldNode, newNode); 16349Assert.NotEqual(oldNode, newNode); 16375Assert.NotEqual(oldNode, newNode); 16401Assert.NotEqual(oldNode, newNode); 16427Assert.NotEqual(oldNode, newNode); 16453Assert.NotEqual(oldNode, newNode); 16479Assert.NotEqual(oldNode, newNode); 16505Assert.NotEqual(oldNode, newNode); 16531Assert.NotEqual(oldNode, newNode); 16557Assert.NotEqual(oldNode, newNode); 16583Assert.NotEqual(oldNode, newNode); 16609Assert.NotEqual(oldNode, newNode); 16635Assert.NotEqual(oldNode, newNode); 16661Assert.NotEqual(oldNode, newNode); 16687Assert.NotEqual(oldNode, newNode); 16713Assert.NotEqual(oldNode, newNode); 16739Assert.NotEqual(oldNode, newNode); 16765Assert.NotEqual(oldNode, newNode); 16791Assert.NotEqual(oldNode, newNode); 16817Assert.NotEqual(oldNode, newNode); 16843Assert.NotEqual(oldNode, newNode); 16869Assert.NotEqual(oldNode, newNode); 16895Assert.NotEqual(oldNode, newNode); 16921Assert.NotEqual(oldNode, newNode); 16947Assert.NotEqual(oldNode, newNode); 16973Assert.NotEqual(oldNode, newNode); 16999Assert.NotEqual(oldNode, newNode); 17025Assert.NotEqual(oldNode, newNode); 17051Assert.NotEqual(oldNode, newNode); 17077Assert.NotEqual(oldNode, newNode); 17103Assert.NotEqual(oldNode, newNode); 17129Assert.NotEqual(oldNode, newNode); 17155Assert.NotEqual(oldNode, newNode); 17181Assert.NotEqual(oldNode, newNode); 17207Assert.NotEqual(oldNode, newNode); 17233Assert.NotEqual(oldNode, newNode); 17259Assert.NotEqual(oldNode, newNode); 17285Assert.NotEqual(oldNode, newNode); 17311Assert.NotEqual(oldNode, newNode); 17337Assert.NotEqual(oldNode, newNode); 17363Assert.NotEqual(oldNode, newNode); 17389Assert.NotEqual(oldNode, newNode); 17415Assert.NotEqual(oldNode, newNode); 17441Assert.NotEqual(oldNode, newNode); 17467Assert.NotEqual(oldNode, newNode); 17493Assert.NotEqual(oldNode, newNode); 17519Assert.NotEqual(oldNode, newNode); 17545Assert.NotEqual(oldNode, newNode); 17571Assert.NotEqual(oldNode, newNode); 17597Assert.NotEqual(oldNode, newNode); 17623Assert.NotEqual(oldNode, newNode); 17649Assert.NotEqual(oldNode, newNode); 17675Assert.NotEqual(oldNode, newNode); 17701Assert.NotEqual(oldNode, newNode); 17727Assert.NotEqual(oldNode, newNode); 17753Assert.NotEqual(oldNode, newNode); 17779Assert.NotEqual(oldNode, newNode); 17805Assert.NotEqual(oldNode, newNode); 17831Assert.NotEqual(oldNode, newNode); 17857Assert.NotEqual(oldNode, newNode); 17883Assert.NotEqual(oldNode, newNode); 17909Assert.NotEqual(oldNode, newNode); 17935Assert.NotEqual(oldNode, newNode); 17961Assert.NotEqual(oldNode, newNode); 17987Assert.NotEqual(oldNode, newNode); 18013Assert.NotEqual(oldNode, newNode); 18039Assert.NotEqual(oldNode, newNode); 18065Assert.NotEqual(oldNode, newNode); 18091Assert.NotEqual(oldNode, newNode); 18117Assert.NotEqual(oldNode, newNode); 18143Assert.NotEqual(oldNode, newNode); 18169Assert.NotEqual(oldNode, newNode); 18195Assert.NotEqual(oldNode, newNode); 18221Assert.NotEqual(oldNode, newNode); 18247Assert.NotEqual(oldNode, newNode); 18273Assert.NotEqual(oldNode, newNode); 18299Assert.NotEqual(oldNode, newNode); 18325Assert.NotEqual(oldNode, newNode); 18351Assert.NotEqual(oldNode, newNode); 18377Assert.NotEqual(oldNode, newNode); 18403Assert.NotEqual(oldNode, newNode); 18429Assert.NotEqual(oldNode, newNode); 18455Assert.NotEqual(oldNode, newNode); 18481Assert.NotEqual(oldNode, newNode); 18507Assert.NotEqual(oldNode, newNode); 18533Assert.NotEqual(oldNode, newNode); 18559Assert.NotEqual(oldNode, newNode); 18585Assert.NotEqual(oldNode, newNode); 18611Assert.NotEqual(oldNode, newNode); 18637Assert.NotEqual(oldNode, newNode); 18663Assert.NotEqual(oldNode, newNode); 18689Assert.NotEqual(oldNode, newNode); 18715Assert.NotEqual(oldNode, newNode); 18741Assert.NotEqual(oldNode, newNode); 18767Assert.NotEqual(oldNode, newNode); 18793Assert.NotEqual(oldNode, newNode); 18819Assert.NotEqual(oldNode, newNode); 18845Assert.NotEqual(oldNode, newNode); 18871Assert.NotEqual(oldNode, newNode); 18897Assert.NotEqual(oldNode, newNode); 18923Assert.NotEqual(oldNode, newNode); 18949Assert.NotEqual(oldNode, newNode); 18975Assert.NotEqual(oldNode, newNode); 19001Assert.NotEqual(oldNode, newNode); 19027Assert.NotEqual(oldNode, newNode); 19053Assert.NotEqual(oldNode, newNode); 19079Assert.NotEqual(oldNode, newNode); 19105Assert.NotEqual(oldNode, newNode); 19131Assert.NotEqual(oldNode, newNode); 19157Assert.NotEqual(oldNode, newNode); 19183Assert.NotEqual(oldNode, newNode); 19209Assert.NotEqual(oldNode, newNode); 19235Assert.NotEqual(oldNode, newNode); 19261Assert.NotEqual(oldNode, newNode); 19287Assert.NotEqual(oldNode, newNode); 19313Assert.NotEqual(oldNode, newNode); 19339Assert.NotEqual(oldNode, newNode); 19365Assert.NotEqual(oldNode, newNode); 19391Assert.NotEqual(oldNode, newNode); 19417Assert.NotEqual(oldNode, newNode); 19443Assert.NotEqual(oldNode, newNode); 19469Assert.NotEqual(oldNode, newNode); 19495Assert.NotEqual(oldNode, newNode); 19521Assert.NotEqual(oldNode, newNode); 19547Assert.NotEqual(oldNode, newNode); 19573Assert.NotEqual(oldNode, newNode); 19599Assert.NotEqual(oldNode, newNode); 19625Assert.NotEqual(oldNode, newNode); 19651Assert.NotEqual(oldNode, newNode); 19677Assert.NotEqual(oldNode, newNode); 19703Assert.NotEqual(oldNode, newNode); 19729Assert.NotEqual(oldNode, newNode); 19755Assert.NotEqual(oldNode, newNode); 19781Assert.NotEqual(oldNode, newNode); 19807Assert.NotEqual(oldNode, newNode); 19833Assert.NotEqual(oldNode, newNode); 19859Assert.NotEqual(oldNode, newNode); 19885Assert.NotEqual(oldNode, newNode); 19911Assert.NotEqual(oldNode, newNode); 19937Assert.NotEqual(oldNode, newNode); 19963Assert.NotEqual(oldNode, newNode); 19989Assert.NotEqual(oldNode, newNode); 20015Assert.NotEqual(oldNode, newNode); 20041Assert.NotEqual(oldNode, newNode); 20067Assert.NotEqual(oldNode, newNode); 20093Assert.NotEqual(oldNode, newNode); 20119Assert.NotEqual(oldNode, newNode); 20145Assert.NotEqual(oldNode, newNode); 20171Assert.NotEqual(oldNode, newNode); 20197Assert.NotEqual(oldNode, newNode); 20223Assert.NotEqual(oldNode, newNode); 20249Assert.NotEqual(oldNode, newNode); 20275Assert.NotEqual(oldNode, newNode); 20301Assert.NotEqual(oldNode, newNode); 20327Assert.NotEqual(oldNode, newNode); 20353Assert.NotEqual(oldNode, newNode); 20379Assert.NotEqual(oldNode, newNode); 20405Assert.NotEqual(oldNode, newNode); 20431Assert.NotEqual(oldNode, newNode); 20457Assert.NotEqual(oldNode, newNode); 20483Assert.NotEqual(oldNode, newNode); 20509Assert.NotEqual(oldNode, newNode); 20535Assert.NotEqual(oldNode, newNode); 20561Assert.NotEqual(oldNode, newNode); 20587Assert.NotEqual(oldNode, newNode); 20613Assert.NotEqual(oldNode, newNode); 20639Assert.NotEqual(oldNode, newNode); 20665Assert.NotEqual(oldNode, newNode); 20691Assert.NotEqual(oldNode, newNode);
IncrementalParsing\ChangingAsync.cs (2)
33Assert.NotEqual(default(SyntaxNodeOrToken), newTree.FindNodeOrTokenByKind(SyntaxKind.AwaitExpression)); 53Assert.NotEqual(default(SyntaxNodeOrToken), oldTree.FindNodeOrTokenByKind(SyntaxKind.AwaitExpression));
LexicalAndXml\LexicalTests.cs (233)
108Assert.NotEqual(default, token); 116Assert.NotEqual(default, trivia[0]); 127Assert.NotEqual(default, token); 135Assert.NotEqual(default, trivia[0]); 146Assert.NotEqual(default, token); 154Assert.NotEqual(default, trivia[0]); 187Assert.NotEqual(default, token); 194Assert.NotEqual(default, trivia[0]); 209Assert.NotEqual(default, token); 216Assert.NotEqual(default, trivia[0]); 231Assert.NotEqual(default, token); 238Assert.NotEqual(default, trivia[0]); 249Assert.NotEqual(default, token); 256Assert.NotEqual(default, trivia[0]); 269Assert.NotEqual(default, token); 278Assert.NotEqual(default, trivia[0]); 293Assert.NotEqual(default, token); 302Assert.NotEqual(default, trivia[0]); 317Assert.NotEqual(default, token); 326Assert.NotEqual(default, trivia[0]); 337Assert.NotEqual(default, token); 348Assert.NotEqual(default, trivia[0]); 359Assert.NotEqual(default, token); 370Assert.NotEqual(default, trivia[0]); 381Assert.NotEqual(default, token); 392Assert.NotEqual(default, trivia[0]); 403Assert.NotEqual(default, token); 412Assert.NotEqual(default, trivia[0]); 424Assert.NotEqual(default, token); 440Assert.NotEqual(default, trivia[0]); 451Assert.NotEqual(default, token); 474Assert.NotEqual(default, token); 479Assert.NotEqual(default, token); 491Assert.NotEqual(default, token); 512Assert.NotEqual(default, token); 540Assert.NotEqual(default, token); 566Assert.NotEqual(default, token); 596Assert.NotEqual(default, token); 604Assert.NotEqual(default, trivia[0]); 615Assert.NotEqual(default, token); 630Assert.NotEqual(default, token); 645Assert.NotEqual(default, token); 660Assert.NotEqual(default, token); 675Assert.NotEqual(default, token); 690Assert.NotEqual(default, token); 705Assert.NotEqual(default, token); 720Assert.NotEqual(default, token); 737Assert.NotEqual(default, token); 754Assert.NotEqual(default, token); 771Assert.NotEqual(default, token); 788Assert.NotEqual(default, token); 805Assert.NotEqual(default, token); 822Assert.NotEqual(default, token); 844Assert.NotEqual(default, token); 861Assert.NotEqual('\\', text[0]); 864Assert.NotEqual(default, token); 885Assert.NotEqual(default, token); 964Assert.NotEqual(default, token); 979Assert.NotEqual(default, token); 994Assert.NotEqual(default, token); 1009Assert.NotEqual(default, token); 1024Assert.NotEqual(default, token); 1039Assert.NotEqual(default, token); 1041Assert.NotEqual(text, token.Text); 1055Assert.NotEqual(default, token); 1071Assert.NotEqual(default, token); 1088Assert.NotEqual(default, token); 1104Assert.NotEqual(default, token); 1120Assert.NotEqual(default, token); 1136Assert.NotEqual(default, token); 1155Assert.NotEqual(default, token); 1174Assert.NotEqual(default, token); 1192Assert.NotEqual(default, token); 1208Assert.NotEqual(default, token); 1224Assert.NotEqual(default, token); 1240Assert.NotEqual(default, token); 1256Assert.NotEqual(default, token); 1272Assert.NotEqual(default, token); 1288Assert.NotEqual(default, token); 1304Assert.NotEqual(default, token); 1320Assert.NotEqual(default, token); 1336Assert.NotEqual(default, token); 1353Assert.NotEqual(default, token); 1369Assert.NotEqual(default, token); 1385Assert.NotEqual(default, token); 1401Assert.NotEqual(default, token); 1417Assert.NotEqual(default, token); 1433Assert.NotEqual(default, token); 1449Assert.NotEqual(default, token); 1465Assert.NotEqual(default, token); 1481Assert.NotEqual(default, token); 1497Assert.NotEqual(default, token); 1514Assert.NotEqual(default, token); 1531Assert.NotEqual(default, token); 1547Assert.NotEqual(default, token); 1565Assert.NotEqual(default, token); 1585Assert.NotEqual(default, token); 1600Assert.NotEqual(default, token); 1615Assert.NotEqual(default, token); 1630Assert.NotEqual(default, token); 1645Assert.NotEqual(default, token); 1660Assert.NotEqual(default, token); 1676Assert.NotEqual(default, token); 1692Assert.NotEqual(default, token); 1708Assert.NotEqual(default, token); 1724Assert.NotEqual(default, token); 1741Assert.NotEqual(default, token); 1757Assert.NotEqual(default, token); 1773Assert.NotEqual(default, token); 1789Assert.NotEqual(default, token); 1805Assert.NotEqual(default, token); 1820Assert.NotEqual(default, token); 1834Assert.NotEqual(default, token); 1849Assert.NotEqual(default, token); 1864Assert.NotEqual(default, token); 1879Assert.NotEqual(default, token); 1894Assert.NotEqual(default, token); 1909Assert.NotEqual(default, token); 1932Assert.NotEqual(default, token); 1947Assert.NotEqual(default, token); 1962Assert.NotEqual(default, token); 1977Assert.NotEqual(default, token); 1992Assert.NotEqual(default, token); 2008Assert.NotEqual(default, token); 2024Assert.NotEqual(default, token); 2040Assert.NotEqual(default, token); 2056Assert.NotEqual(default, token); 2072Assert.NotEqual(default, token); 2088Assert.NotEqual(default, token); 2104Assert.NotEqual(default, token); 2120Assert.NotEqual(default, token); 2136Assert.NotEqual(default, token); 2152Assert.NotEqual(default, token); 2168Assert.NotEqual(default, token); 2184Assert.NotEqual(default, token); 2200Assert.NotEqual(default, token); 2216Assert.NotEqual(default, token); 2232Assert.NotEqual(default, token); 2248Assert.NotEqual(default, token); 2264Assert.NotEqual(default, token); 2274Assert.NotEqual(default, token); 2290Assert.NotEqual(default, token); 2300Assert.NotEqual(default, token); 2316Assert.NotEqual(default, token); 2326Assert.NotEqual(default, token); 2342Assert.NotEqual(default, token); 2352Assert.NotEqual(default, token); 2368Assert.NotEqual(default, token); 2378Assert.NotEqual(default, token); 2394Assert.NotEqual(default, token); 2404Assert.NotEqual(default, token); 2419Assert.NotEqual(default, token); 2430Assert.NotEqual(default, token); 2445Assert.NotEqual(default, token); 2456Assert.NotEqual(default, token); 2485Assert.NotEqual(default, token); 2495Assert.NotEqual(default, token); 2511Assert.NotEqual(default, token); 2521Assert.NotEqual(default, token); 2536Assert.NotEqual(default, token); 2547Assert.NotEqual(default, token); 2562Assert.NotEqual(default, token); 2573Assert.NotEqual(default, token); 2587Assert.NotEqual(default, token); 2602Assert.NotEqual(default, token); 2618Assert.NotEqual(default, token); 2634Assert.NotEqual(default, token); 2650Assert.NotEqual(default, token); 2665Assert.NotEqual(default, token); 2680Assert.NotEqual(default, token); 2695Assert.NotEqual(default, token); 2710Assert.NotEqual(default, token); 2725Assert.NotEqual(default, token); 2741Assert.NotEqual(default, token); 2757Assert.NotEqual(default, token); 2773Assert.NotEqual(default, token); 2789Assert.NotEqual(default, token); 2805Assert.NotEqual(default, token); 2821Assert.NotEqual(default, token); 2837Assert.NotEqual(default, token); 2853Assert.NotEqual(default, token); 2869Assert.NotEqual(default, token); 2885Assert.NotEqual(default, token); 2901Assert.NotEqual(default, token); 2917Assert.NotEqual(default, token); 2933Assert.NotEqual(default, token); 2949Assert.NotEqual(default, token); 2965Assert.NotEqual(default, token); 2981Assert.NotEqual(default, token); 2997Assert.NotEqual(default, token); 3013Assert.NotEqual(default, token); 3028Assert.NotEqual(default, token); 3044Assert.NotEqual(default, token); 3060Assert.NotEqual(default, token); 3069Assert.NotEqual(default, token); 3078Assert.NotEqual(default, token); 3087Assert.NotEqual(default, token); 3096Assert.NotEqual(default, token); 3105Assert.NotEqual(default, token); 3114Assert.NotEqual(default, token); 3142Assert.NotEqual(default, token); 3151Assert.NotEqual(default, token); 3160Assert.NotEqual(default, token); 3169Assert.NotEqual(default, token); 3225Assert.NotEqual(default, token); 3232Assert.NotEqual(default, token); 3243Assert.NotEqual(default, token); 3258Assert.NotEqual(default, token); 3269Assert.NotEqual(default, token); 3280Assert.NotEqual(default, token); 3291Assert.NotEqual(default, token); 3302Assert.NotEqual(default, token); 3313Assert.NotEqual(default, token); 3324Assert.NotEqual(default, token); 3335Assert.NotEqual(default, token); 3346Assert.NotEqual(default, token); 3357Assert.NotEqual(default, token); 3368Assert.NotEqual(default, token); 3386Assert.NotEqual(default, token); 3402Assert.NotEqual(default, token); 3418Assert.NotEqual(default, token); 3434Assert.NotEqual(default, token); 3455Assert.NotEqual(default, token); 3466Assert.NotEqual(default, token); 3476Assert.NotEqual(default, token); 3557Assert.NotEqual(default, token); 3570Assert.NotEqual(default, token); 3580Assert.NotEqual(default, token); 3590Assert.NotEqual(default, token); 3601Assert.NotEqual(default, token); 3614Assert.NotEqual(default, token); 3632Assert.NotEqual(default, token); 3652Assert.NotEqual(default, token);
LexicalAndXml\PreprocessorTests.cs (1)
251Assert.NotEqual(SyntaxKind.None, ld.File.Kind());
LexicalAndXml\XmlDocCommentTests.cs (11)
116Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 734Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 741Assert.NotEqual(0, doc.ErrorsAndWarnings().Length); 1297Assert.NotEqual(0, node.ErrorsAndWarnings().Length); 1505Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 1516Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 1527Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 1538Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 1549Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 1616Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length); 1628Assert.NotEqual(0, element.Attributes[0].ErrorsAndWarnings().Length);
Parsing\CSharpParseOptionsTests.cs (1)
142Assert.NotEqual(options1.GetHashCode(), options2.GetHashCode());
Parsing\DeclarationParsingTests.cs (877)
41Assert.NotEqual(default, ea.ExternKeyword); 43Assert.NotEqual(default, ea.AliasKeyword); 46Assert.NotEqual(default, ea.Identifier); 48Assert.NotEqual(default, ea.SemicolonToken); 64Assert.NotEqual(default, ud.UsingKeyword); 70Assert.NotEqual(default, ud.SemicolonToken); 86Assert.NotEqual(default, ud.UsingKeyword); 92Assert.NotEqual(default, ud.SemicolonToken); 153Assert.NotEqual(default, ud.UsingKeyword); 159Assert.NotEqual(default, ud.SemicolonToken); 175Assert.NotEqual(default, ud.UsingKeyword); 181Assert.NotEqual(default, ud.SemicolonToken); 197Assert.NotEqual(default, ud.UsingKeyword); 203Assert.NotEqual(default, ud.SemicolonToken); 219Assert.NotEqual(default, ud.UsingKeyword); 224Assert.NotEqual(default, ud.Alias.EqualsToken); 227Assert.NotEqual(default, ud.SemicolonToken); 243Assert.NotEqual(default, ud.UsingKeyword); 248Assert.NotEqual(default, ud.Alias.EqualsToken); 251Assert.NotEqual(default, ud.SemicolonToken); 268Assert.NotEqual(default, ad.OpenBracketToken); 270Assert.NotEqual(default, ad.Target.Identifier); 272Assert.NotEqual(default, ad.Target.ColonToken); 277Assert.NotEqual(default, ad.CloseBracketToken); 294Assert.NotEqual(default, ad.OpenBracketToken); 296Assert.NotEqual(default, ad.Target.Identifier); 301Assert.NotEqual(default, ad.Target.ColonToken); 306Assert.NotEqual(default, ad.CloseBracketToken); 323Assert.NotEqual(default, ad.OpenBracketToken); 325Assert.NotEqual(default, ad.Target.Identifier); 330Assert.NotEqual(default, ad.Target.ColonToken); 335Assert.NotEqual(default, ad.CloseBracketToken); 352Assert.NotEqual(default, ad.OpenBracketToken); 354Assert.NotEqual(default, ad.Target.Identifier); 357Assert.NotEqual(default, ad.Target.ColonToken); 362Assert.NotEqual(default, ad.CloseBracketToken); 379Assert.NotEqual(default, ad.OpenBracketToken); 381Assert.NotEqual(default, ad.Target.Identifier); 385Assert.NotEqual(default, ad.Target.ColonToken); 390Assert.NotEqual(default, ad.CloseBracketToken); 407Assert.NotEqual(default, ad.OpenBracketToken); 409Assert.NotEqual(default, ad.Target.Identifier); 412Assert.NotEqual(default, ad.Target.ColonToken); 417Assert.NotEqual(default, ad.Attributes[0].ArgumentList.OpenParenToken); 419Assert.NotEqual(default, ad.Attributes[0].ArgumentList.CloseParenToken); 420Assert.NotEqual(default, ad.CloseBracketToken); 437Assert.NotEqual(default, ad.OpenBracketToken); 439Assert.NotEqual(default, ad.Target.Identifier); 441Assert.NotEqual(default, ad.Target.ColonToken); 446Assert.NotEqual(default, ad.Attributes[0].ArgumentList.OpenParenToken); 450Assert.NotEqual(default, ad.Attributes[0].ArgumentList.CloseParenToken); 451Assert.NotEqual(default, ad.CloseBracketToken); 468Assert.NotEqual(default, ad.OpenBracketToken); 470Assert.NotEqual(default, ad.Target.Identifier); 472Assert.NotEqual(default, ad.Target.ColonToken); 477Assert.NotEqual(default, ad.Attributes[0].ArgumentList.OpenParenToken); 483Assert.NotEqual(default, ad.Attributes[0].ArgumentList.Arguments[0].NameEquals.EqualsToken); 486Assert.NotEqual(default, ad.Attributes[0].ArgumentList.CloseParenToken); 487Assert.NotEqual(default, ad.CloseBracketToken); 504Assert.NotEqual(default, ad.OpenBracketToken); 506Assert.NotEqual(default, ad.Target.Identifier); 508Assert.NotEqual(default, ad.Target.ColonToken); 519Assert.NotEqual(default, ad.CloseBracketToken); 535Assert.NotEqual(default, ad.OpenBracketToken); 537Assert.NotEqual(default, ad.Target.Identifier); 539Assert.NotEqual(default, ad.Target.ColonToken); 544Assert.NotEqual(default, ad.CloseBracketToken); 547Assert.NotEqual(default, ad.OpenBracketToken); 549Assert.NotEqual(default, ad.Target.Identifier); 551Assert.NotEqual(default, ad.Target.ColonToken); 556Assert.NotEqual(default, ad.CloseBracketToken); 572Assert.NotEqual(default, ns.NamespaceKeyword); 575Assert.NotEqual(default, ns.OpenBraceToken); 578Assert.NotEqual(default, ns.CloseBraceToken); 594Assert.NotEqual(default, ns.NamespaceKeyword); 597Assert.NotEqual(default, ns.SemicolonToken); 615Assert.NotEqual(default, ns.NamespaceKeyword); 618Assert.NotEqual(default, ns.OpenBraceToken); 621Assert.NotEqual(default, ns.CloseBraceToken); 637Assert.NotEqual(default, ns.NamespaceKeyword); 640Assert.NotEqual(default, ns.OpenBraceToken); 644Assert.NotEqual(default, ns.CloseBraceToken); 660Assert.NotEqual(default, ns.NamespaceKeyword); 663Assert.NotEqual(default, ns.SemicolonToken); 682Assert.NotEqual(default, ns.NamespaceKeyword); 685Assert.NotEqual(default, ns.OpenBraceToken); 689Assert.NotEqual(default, ns.CloseBraceToken); 705Assert.NotEqual(default, ns.NamespaceKeyword); 708Assert.NotEqual(default, ns.SemicolonToken); 727Assert.NotEqual(default, ns.NamespaceKeyword); 730Assert.NotEqual(default, ns.OpenBraceToken); 735Assert.NotEqual(default, ns.CloseBraceToken); 751Assert.NotEqual(default, ns.NamespaceKeyword); 754Assert.NotEqual(default, ns.OpenBraceToken); 759Assert.NotEqual(default, ns2.NamespaceKeyword); 762Assert.NotEqual(default, ns2.OpenBraceToken); 766Assert.NotEqual(default, ns.CloseBraceToken); 784Assert.NotEqual(default, cs.Keyword); 786Assert.NotEqual(default, cs.Identifier); 790Assert.NotEqual(default, cs.OpenBraceToken); 792Assert.NotEqual(default, cs.CloseBraceToken); 811Assert.NotEqual(default, cs.Keyword); 813Assert.NotEqual(default, cs.Identifier); 817Assert.NotEqual(default, cs.OpenBraceToken); 819Assert.NotEqual(default, cs.CloseBraceToken); 838Assert.NotEqual(default, cs.Keyword); 840Assert.NotEqual(default, cs.Identifier); 844Assert.NotEqual(default, cs.OpenBraceToken); 846Assert.NotEqual(default, cs.CloseBraceToken); 865Assert.NotEqual(default, cs.Keyword); 867Assert.NotEqual(default, cs.Identifier); 871Assert.NotEqual(default, cs.OpenBraceToken); 873Assert.NotEqual(default, cs.CloseBraceToken); 892Assert.NotEqual(default, cs.Keyword); 894Assert.NotEqual(default, cs.Identifier); 898Assert.NotEqual(default, cs.OpenBraceToken); 900Assert.NotEqual(default, cs.CloseBraceToken); 919Assert.NotEqual(default, cs.Keyword); 921Assert.NotEqual(default, cs.Identifier); 925Assert.NotEqual(default, cs.OpenBraceToken); 927Assert.NotEqual(default, cs.CloseBraceToken); 946Assert.NotEqual(default, cs.Keyword); 948Assert.NotEqual(default, cs.Identifier); 952Assert.NotEqual(default, cs.OpenBraceToken); 954Assert.NotEqual(default, cs.CloseBraceToken); 973Assert.NotEqual(default, cs.Keyword); 975Assert.NotEqual(default, cs.Identifier); 979Assert.NotEqual(default, cs.OpenBraceToken); 981Assert.NotEqual(default, cs.CloseBraceToken); 1001Assert.NotEqual(default, cs.Keyword); 1003Assert.NotEqual(default, cs.Identifier); 1007Assert.NotEqual(default, cs.OpenBraceToken); 1009Assert.NotEqual(default, cs.CloseBraceToken); 1028Assert.NotEqual(default, cs.Keyword); 1030Assert.NotEqual(default, cs.Identifier); 1034Assert.NotEqual(default, cs.OpenBraceToken); 1036Assert.NotEqual(default, cs.CloseBraceToken); 1054Assert.NotEqual(default, cs.Keyword); 1056Assert.NotEqual(default, cs.Identifier); 1060Assert.NotEqual(default, cs.BaseList.ColonToken); 1065Assert.NotEqual(default, cs.OpenBraceToken); 1067Assert.NotEqual(default, cs.CloseBraceToken); 1085Assert.NotEqual(default, cs.Keyword); 1087Assert.NotEqual(default, cs.Identifier); 1091Assert.NotEqual(default, cs.BaseList.ColonToken); 1097Assert.NotEqual(default, cs.OpenBraceToken); 1099Assert.NotEqual(default, cs.CloseBraceToken); 1117Assert.NotEqual(default, cs.Keyword); 1119Assert.NotEqual(default, cs.Identifier); 1126Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1129Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1137Assert.NotEqual(default, cs.OpenBraceToken); 1139Assert.NotEqual(default, cs.CloseBraceToken); 1159Assert.NotEqual(default, cs.Keyword); 1161Assert.NotEqual(default, cs.Identifier); 1167Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1170Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1178Assert.NotEqual(default, cs.OpenBraceToken); 1180Assert.NotEqual(default, cs.CloseBraceToken); 1220Assert.NotEqual(default, cs.Keyword); 1222Assert.NotEqual(default, cs.Identifier); 1229Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1232Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1237Assert.NotEqual(default, bound.NewKeyword); 1239Assert.NotEqual(default, bound.OpenParenToken); 1241Assert.NotEqual(default, bound.CloseParenToken); 1244Assert.NotEqual(default, cs.OpenBraceToken); 1246Assert.NotEqual(default, cs.CloseBraceToken); 1264Assert.NotEqual(default, cs.Keyword); 1266Assert.NotEqual(default, cs.Identifier); 1273Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1276Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1281Assert.NotEqual(default, bound.ClassOrStructKeyword); 1285Assert.NotEqual(default, cs.OpenBraceToken); 1287Assert.NotEqual(default, cs.CloseBraceToken); 1305Assert.NotEqual(default, cs.Keyword); 1307Assert.NotEqual(default, cs.Identifier); 1314Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1317Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1322Assert.NotEqual(default, bound.ClassOrStructKeyword); 1326Assert.NotEqual(default, cs.OpenBraceToken); 1328Assert.NotEqual(default, cs.CloseBraceToken); 1346Assert.NotEqual(default, cs.Keyword); 1348Assert.NotEqual(default, cs.Identifier); 1355Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1358Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1364Assert.NotEqual(default, classBound.ClassOrStructKeyword); 1375Assert.NotEqual(default, bound.NewKeyword); 1377Assert.NotEqual(default, bound.OpenParenToken); 1379Assert.NotEqual(default, bound.CloseParenToken); 1382Assert.NotEqual(default, cs.OpenBraceToken); 1384Assert.NotEqual(default, cs.CloseBraceToken); 1402Assert.NotEqual(default, cs.Keyword); 1404Assert.NotEqual(default, cs.Identifier); 1411Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1414Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1422Assert.NotEqual(default, cs.ConstraintClauses[1].WhereKeyword); 1425Assert.NotEqual(default, cs.ConstraintClauses[1].ColonToken); 1430Assert.NotEqual(default, bound.NewKeyword); 1432Assert.NotEqual(default, bound.OpenParenToken); 1434Assert.NotEqual(default, bound.CloseParenToken); 1437Assert.NotEqual(default, cs.OpenBraceToken); 1439Assert.NotEqual(default, cs.CloseBraceToken); 1457Assert.NotEqual(default, cs.Keyword); 1459Assert.NotEqual(default, cs.Identifier); 1466Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1469Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1477Assert.NotEqual(default, cs.ConstraintClauses[1].WhereKeyword); 1480Assert.NotEqual(default, cs.ConstraintClauses[1].ColonToken); 1503Assert.NotEqual(default, cs.Keyword); 1505Assert.NotEqual(default, cs.Identifier); 1512Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1515Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1523Assert.NotEqual(default, cs.ConstraintClauses[1].WhereKeyword); 1547Assert.NotEqual(default, cs.Keyword); 1549Assert.NotEqual(default, cs.Identifier); 1554Assert.NotEqual(default, cs.BaseList.ColonToken); 1560Assert.NotEqual(default, cs.ConstraintClauses[0].WhereKeyword); 1563Assert.NotEqual(default, cs.ConstraintClauses[0].ColonToken); 1569Assert.NotEqual(default, classBound.ClassOrStructKeyword); 1580Assert.NotEqual(default, bound.NewKeyword); 1582Assert.NotEqual(default, bound.OpenParenToken); 1584Assert.NotEqual(default, bound.CloseParenToken); 1587Assert.NotEqual(default, cs.OpenBraceToken); 1589Assert.NotEqual(default, cs.CloseBraceToken); 1607Assert.NotEqual(default, cs.Keyword); 1609Assert.NotEqual(default, cs.Identifier); 1613Assert.NotEqual(default, cs.OpenBraceToken); 1614Assert.NotEqual(default, cs.CloseBraceToken); 1632Assert.NotEqual(default, cs.Keyword); 1634Assert.NotEqual(default, cs.Identifier); 1643Assert.NotEqual(default, cs.OpenBraceToken); 1644Assert.NotEqual(default, cs.CloseBraceToken); 1662Assert.NotEqual(default, cs.Keyword); 1664Assert.NotEqual(default, cs.Identifier); 1671Assert.NotEqual(default, gn.Parameters[0].VarianceKeyword); 1675Assert.NotEqual(default, cs.OpenBraceToken); 1676Assert.NotEqual(default, cs.CloseBraceToken); 1694Assert.NotEqual(default, cs.Keyword); 1696Assert.NotEqual(default, cs.Identifier); 1700Assert.NotEqual(default, cs.OpenBraceToken); 1701Assert.NotEqual(default, cs.CloseBraceToken); 1719Assert.NotEqual(default, cs.Keyword); 1721Assert.NotEqual(default, cs.Identifier); 1725Assert.NotEqual(default, cs.OpenBraceToken); 1726Assert.NotEqual(default, cs.CloseBraceToken); 1734Assert.NotEqual(default, cs.Keyword); 1736Assert.NotEqual(default, cs.Identifier); 1740Assert.NotEqual(default, cs.OpenBraceToken); 1741Assert.NotEqual(default, cs.CloseBraceToken); 1759Assert.NotEqual(default, cs.Keyword); 1761Assert.NotEqual(default, cs.Identifier); 1765Assert.NotEqual(default, cs.OpenBraceToken); 1766Assert.NotEqual(default, cs.CloseBraceToken); 1775Assert.NotEqual(default, cs.Keyword); 1777Assert.NotEqual(default, cs.Identifier); 1781Assert.NotEqual(default, cs.OpenBraceToken); 1782Assert.NotEqual(default, cs.CloseBraceToken); 1800Assert.NotEqual(default, cs.Keyword); 1802Assert.NotEqual(default, cs.Identifier); 1806Assert.NotEqual(default, cs.OpenBraceToken); 1807Assert.NotEqual(default, cs.CloseBraceToken); 1816Assert.NotEqual(default, cs.Keyword); 1818Assert.NotEqual(default, cs.Identifier); 1822Assert.NotEqual(default, cs.OpenBraceToken); 1823Assert.NotEqual(default, cs.CloseBraceToken); 1841Assert.NotEqual(default, cs.Keyword); 1843Assert.NotEqual(default, cs.Identifier); 1847Assert.NotEqual(default, cs.OpenBraceToken); 1848Assert.NotEqual(default, cs.CloseBraceToken); 1858Assert.NotEqual(default, cs.Keyword); 1860Assert.NotEqual(default, cs.Identifier); 1864Assert.NotEqual(default, cs.OpenBraceToken); 1865Assert.NotEqual(default, cs.CloseBraceToken); 1883Assert.NotEqual(default, cs.Keyword); 1885Assert.NotEqual(default, cs.Identifier); 1889Assert.NotEqual(default, cs.OpenBraceToken); 1890Assert.NotEqual(default, cs.CloseBraceToken); 1900Assert.NotEqual(default, cs.Keyword); 1902Assert.NotEqual(default, cs.Identifier); 1906Assert.NotEqual(default, cs.OpenBraceToken); 1907Assert.NotEqual(default, cs.CloseBraceToken); 1925Assert.NotEqual(default, cs.Keyword); 1927Assert.NotEqual(default, cs.Identifier); 1931Assert.NotEqual(default, cs.OpenBraceToken); 1932Assert.NotEqual(default, cs.CloseBraceToken); 1941Assert.NotEqual(default, cs.Keyword); 1943Assert.NotEqual(default, cs.Identifier); 1947Assert.NotEqual(default, cs.OpenBraceToken); 1948Assert.NotEqual(default, cs.CloseBraceToken); 1966Assert.NotEqual(default, cs.Keyword); 1968Assert.NotEqual(default, cs.Identifier); 1972Assert.NotEqual(default, cs.OpenBraceToken); 1973Assert.NotEqual(default, cs.CloseBraceToken); 1982Assert.NotEqual(default, cs.Keyword); 1984Assert.NotEqual(default, cs.Identifier); 1988Assert.NotEqual(default, cs.OpenBraceToken); 1989Assert.NotEqual(default, cs.CloseBraceToken); 2005Assert.NotEqual(default, ds.DelegateKeyword); 2008Assert.NotEqual(default, ds.Identifier); 2010Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2013Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2015Assert.NotEqual(default, ds.SemicolonToken); 2032Assert.NotEqual(default, ds.DelegateKeyword); 2035Assert.NotEqual(default, ds.Identifier); 2037Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2040Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2042Assert.NotEqual(default, ds.SemicolonToken); 2060Assert.NotEqual(default, ds.DelegateKeyword); 2063Assert.NotEqual(default, ds.Identifier); 2065Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2068Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2070Assert.NotEqual(default, ds.SemicolonToken); 2107Assert.NotEqual(default, ds.DelegateKeyword); 2110Assert.NotEqual(default, ds.Identifier); 2112Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2115Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2117Assert.NotEqual(default, ds.SemicolonToken); 2153Assert.NotEqual(default, ds.DelegateKeyword); 2156Assert.NotEqual(default, ds.Identifier); 2158Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2166Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2169Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2171Assert.NotEqual(default, ds.SemicolonToken); 2188Assert.NotEqual(default, ds.DelegateKeyword); 2191Assert.NotEqual(default, ds.Identifier); 2193Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2201Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2204Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2206Assert.NotEqual(default, ds.SemicolonToken); 2223Assert.NotEqual(default, ds.DelegateKeyword); 2226Assert.NotEqual(default, ds.Identifier); 2228Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2236Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2243Assert.NotEqual(default, ds.ParameterList.Parameters[1].Identifier); 2246Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2248Assert.NotEqual(default, ds.SemicolonToken); 2265Assert.NotEqual(default, ds.DelegateKeyword); 2268Assert.NotEqual(default, ds.Identifier); 2270Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2279Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2282Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2284Assert.NotEqual(default, ds.SemicolonToken); 2301Assert.NotEqual(default, ds.DelegateKeyword); 2304Assert.NotEqual(default, ds.Identifier); 2306Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2315Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2318Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2320Assert.NotEqual(default, ds.SemicolonToken); 2337Assert.NotEqual(default, ds.DelegateKeyword); 2340Assert.NotEqual(default, ds.Identifier); 2342Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2351Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2354Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2356Assert.NotEqual(default, ds.SemicolonToken); 2374Assert.NotEqual(default, ds.DelegateKeyword); 2377Assert.NotEqual(default, ds.Identifier); 2379Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2386Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2388Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2390Assert.NotEqual(default, ds.SemicolonToken); 2407Assert.NotEqual(default, ds.DelegateKeyword); 2410Assert.NotEqual(default, ds.Identifier); 2412Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2421Assert.NotEqual(default, ds.ParameterList.Parameters[0].Identifier); 2424Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2426Assert.NotEqual(default, ds.SemicolonToken); 2445Assert.NotEqual(default, cs.Keyword); 2447Assert.NotEqual(default, cs.Identifier); 2451Assert.NotEqual(default, cs.OpenBraceToken); 2452Assert.NotEqual(default, cs.CloseBraceToken); 2458Assert.NotEqual(default, ds.DelegateKeyword); 2461Assert.NotEqual(default, ds.Identifier); 2463Assert.NotEqual(default, ds.ParameterList.OpenParenToken); 2466Assert.NotEqual(default, ds.ParameterList.CloseParenToken); 2468Assert.NotEqual(default, ds.SemicolonToken); 2487Assert.NotEqual(default, cs.Keyword); 2489Assert.NotEqual(default, cs.Identifier); 2493Assert.NotEqual(default, cs.OpenBraceToken); 2494Assert.NotEqual(default, cs.CloseBraceToken); 2504Assert.NotEqual(default, ms.Identifier); 2506Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 2509Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 2513Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 2514Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 2533Assert.NotEqual(default, cs.Keyword); 2535Assert.NotEqual(default, cs.Identifier); 2539Assert.NotEqual(default, cs.OpenBraceToken); 2540Assert.NotEqual(default, cs.CloseBraceToken); 2549Assert.NotEqual(default, ms.Identifier); 2551Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 2554Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 2558Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 2559Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 2579Assert.NotEqual(default, cs.Keyword); 2581Assert.NotEqual(default, cs.Identifier); 2585Assert.NotEqual(default, cs.OpenBraceToken); 2586Assert.NotEqual(default, cs.CloseBraceToken); 2595Assert.NotEqual(default, ms.Identifier); 2597Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 2600Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 2604Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 2605Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 2624Assert.NotEqual(default, cs.Keyword); 2626Assert.NotEqual(default, cs.Identifier); 2630Assert.NotEqual(default, cs.OpenBraceToken); 2631Assert.NotEqual(default, cs.CloseBraceToken); 2654Assert.NotEqual(default, cs.Keyword); 2656Assert.NotEqual(default, cs.Identifier); 2660Assert.NotEqual(default, cs.OpenBraceToken); 2661Assert.NotEqual(default, cs.CloseBraceToken); 2682Assert.NotEqual(default, cs.Keyword); 2684Assert.NotEqual(default, cs.Identifier); 2688Assert.NotEqual(default, cs.OpenBraceToken); 2689Assert.NotEqual(default, cs.CloseBraceToken); 2703Assert.NotEqual(default, ms.Identifier); 2705Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 2708Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 2712Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 2713Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 2750Assert.NotEqual(default, cs.Keyword); 2752Assert.NotEqual(default, cs.Identifier); 2756Assert.NotEqual(default, cs.OpenBraceToken); 2757Assert.NotEqual(default, cs.CloseBraceToken); 2768Assert.NotEqual(default, ms.Identifier); 2770Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 2773Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 2777Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 2778Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 2797Assert.NotEqual(default, structDecl.Keyword); 2799Assert.NotEqual(default, structDecl.Identifier); 2803Assert.NotEqual(default, structDecl.OpenBraceToken); 2804Assert.NotEqual(default, structDecl.CloseBraceToken); 2815Assert.NotEqual(default, ms.Identifier); 2817Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 2820Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 2824Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 2825Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 2844Assert.NotEqual(default, structDecl.Keyword); 2846Assert.NotEqual(default, structDecl.Identifier); 2850Assert.NotEqual(default, structDecl.OpenBraceToken); 2851Assert.NotEqual(default, structDecl.CloseBraceToken); 2865Assert.NotEqual(default, ms.Identifier); 2867Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 2870Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 2874Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 2875Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 2894Assert.NotEqual(default, structDecl.Keyword); 2896Assert.NotEqual(default, structDecl.Identifier); 2900Assert.NotEqual(default, structDecl.OpenBraceToken); 2901Assert.NotEqual(default, structDecl.CloseBraceToken); 2912Assert.NotEqual(default, propertySyntax.Identifier); 2915Assert.NotEqual(SyntaxKind.None, propertySyntax.ExpressionBody.ArrowToken.Kind()); 2935Assert.NotEqual(default, structDecl.Keyword); 2937Assert.NotEqual(default, structDecl.Identifier); 2941Assert.NotEqual(default, structDecl.OpenBraceToken); 2942Assert.NotEqual(default, structDecl.CloseBraceToken); 2952Assert.NotEqual(default, propertySyntax.Identifier); 2996Assert.NotEqual(default, cs.Keyword); 2998Assert.NotEqual(default, cs.Identifier); 3002Assert.NotEqual(default, cs.OpenBraceToken); 3003Assert.NotEqual(default, cs.CloseBraceToken); 3013Assert.NotEqual(default, ms.Identifier); 3015Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3022Assert.NotEqual(default, ms.ParameterList.Parameters[0].Identifier); 3024Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3028Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3029Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3048Assert.NotEqual(default, cs.Keyword); 3050Assert.NotEqual(default, cs.Identifier); 3054Assert.NotEqual(default, cs.OpenBraceToken); 3055Assert.NotEqual(default, cs.CloseBraceToken); 3065Assert.NotEqual(default, ms.Identifier); 3067Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3076Assert.NotEqual(default, ms.ParameterList.Parameters[0].Identifier); 3083Assert.NotEqual(default, ms.ParameterList.Parameters[1].Identifier); 3086Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3090Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3091Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3109Assert.NotEqual(default, cs.Keyword); 3111Assert.NotEqual(default, cs.Identifier); 3115Assert.NotEqual(default, cs.OpenBraceToken); 3116Assert.NotEqual(default, cs.CloseBraceToken); 3126Assert.NotEqual(default, ms.Identifier); 3128Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3138Assert.NotEqual(default, ms.ParameterList.Parameters[0].Identifier); 3141Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3145Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3146Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3174Assert.NotEqual(default, cs.Keyword); 3176Assert.NotEqual(default, cs.Identifier); 3180Assert.NotEqual(default, cs.OpenBraceToken); 3181Assert.NotEqual(default, cs.CloseBraceToken); 3191Assert.NotEqual(default, ms.Identifier); 3193Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3201Assert.NotEqual(default, ms.ParameterList.Parameters[0].Identifier); 3204Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3208Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3209Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3248Assert.NotEqual(default, cs.Keyword); 3250Assert.NotEqual(default, cs.Identifier); 3254Assert.NotEqual(default, cs.OpenBraceToken); 3255Assert.NotEqual(default, cs.CloseBraceToken); 3265Assert.NotEqual(default, ms.Identifier); 3267Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3270Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3274Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3275Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3313Assert.NotEqual(default, cs.Keyword); 3315Assert.NotEqual(default, cs.Identifier); 3319Assert.NotEqual(default, cs.OpenBraceToken); 3320Assert.NotEqual(default, cs.CloseBraceToken); 3330Assert.NotEqual(default, ms.Identifier); 3332Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3339Assert.NotEqual(default, ms.ParameterList.Parameters[0].Identifier); 3341Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3345Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3346Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3365Assert.NotEqual(default, cs.Keyword); 3367Assert.NotEqual(default, cs.Identifier); 3371Assert.NotEqual(default, cs.OpenBraceToken); 3372Assert.NotEqual(default, cs.CloseBraceToken); 3382Assert.NotEqual(default, ms.Identifier); 3384Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3387Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3391Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3392Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3411Assert.NotEqual(default, cs.Keyword); 3413Assert.NotEqual(default, cs.Identifier); 3417Assert.NotEqual(default, cs.OpenBraceToken); 3418Assert.NotEqual(default, cs.CloseBraceToken); 3428Assert.NotEqual(default, ms.Identifier); 3432Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 3435Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 3439Assert.NotEqual(default, ms.ConstraintClauses[0].WhereKeyword); 3442Assert.NotEqual(default, ms.ConstraintClauses[0].ColonToken); 3451Assert.NotEqual(SyntaxKind.None, ms.Body.OpenBraceToken.Kind()); 3452Assert.NotEqual(SyntaxKind.None, ms.Body.CloseBraceToken.Kind()); 3492Assert.NotEqual(default, cs.Keyword); 3494Assert.NotEqual(default, cs.Identifier); 3498Assert.NotEqual(SyntaxKind.None, cs.OpenBraceToken.Kind()); 3499Assert.NotEqual(SyntaxKind.None, cs.CloseBraceToken.Kind()); 3509Assert.NotEqual(default, cn.Body.OpenBraceToken); 3510Assert.NotEqual(default, cn.Body.CloseBraceToken); 3527Assert.NotEqual(default, cs.Keyword); 3529Assert.NotEqual(default, cs.Identifier); 3533Assert.NotEqual(SyntaxKind.None, cs.OpenBraceToken.Kind()); 3534Assert.NotEqual(SyntaxKind.None, cs.CloseBraceToken.Kind()); 3545Assert.NotEqual(default, cn.Body.OpenBraceToken); 3546Assert.NotEqual(default, cn.Body.CloseBraceToken); 3574Assert.NotEqual(default, cs.Keyword); 3576Assert.NotEqual(default, cs.Identifier); 3580Assert.NotEqual(SyntaxKind.None, cs.OpenBraceToken.Kind()); 3581Assert.NotEqual(SyntaxKind.None, cs.CloseBraceToken.Kind()); 3588Assert.NotEqual(default, cn.TildeToken); 3592Assert.NotEqual(default, cn.Body.OpenBraceToken); 3593Assert.NotEqual(default, cn.Body.CloseBraceToken); 3611Assert.NotEqual(default, cs.Keyword); 3613Assert.NotEqual(default, cs.Identifier); 3617Assert.NotEqual(default, cs.OpenBraceToken); 3618Assert.NotEqual(default, cs.CloseBraceToken); 3629Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3633Assert.NotEqual(default, fs.SemicolonToken); 3671Assert.NotEqual(default, cs.Keyword); 3673Assert.NotEqual(default, cs.Identifier); 3677Assert.NotEqual(default, cs.OpenBraceToken); 3678Assert.NotEqual(default, cs.CloseBraceToken); 3689Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3693Assert.NotEqual(default, fs.SemicolonToken); 3711Assert.NotEqual(default, cs.Keyword); 3713Assert.NotEqual(default, cs.Identifier); 3717Assert.NotEqual(default, cs.OpenBraceToken); 3718Assert.NotEqual(default, cs.CloseBraceToken); 3730Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3734Assert.NotEqual(default, fs.SemicolonToken); 3765Assert.NotEqual(default, cs.Keyword); 3767Assert.NotEqual(default, cs.Identifier); 3771Assert.NotEqual(default, cs.OpenBraceToken); 3772Assert.NotEqual(default, cs.CloseBraceToken); 3781Assert.NotEqual(default, fs.EventKeyword); 3785Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3789Assert.NotEqual(default, fs.SemicolonToken); 3821Assert.NotEqual(default, cs.Keyword); 3823Assert.NotEqual(default, cs.Identifier); 3827Assert.NotEqual(default, cs.OpenBraceToken); 3828Assert.NotEqual(default, cs.CloseBraceToken); 3840Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3844Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 3847Assert.NotEqual(default, fs.SemicolonToken); 3866Assert.NotEqual(default, cs.Keyword); 3868Assert.NotEqual(default, cs.Identifier); 3872Assert.NotEqual(default, cs.OpenBraceToken); 3873Assert.NotEqual(default, cs.CloseBraceToken); 3884Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3888Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 3891Assert.NotEqual(default, fs.SemicolonToken); 3910Assert.NotEqual(default, cs.Keyword); 3912Assert.NotEqual(default, cs.Identifier); 3916Assert.NotEqual(default, cs.OpenBraceToken); 3917Assert.NotEqual(default, cs.CloseBraceToken); 3928Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3932Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 3936Assert.NotEqual(default, fs.SemicolonToken); 3955Assert.NotEqual(default, cs.Keyword); 3957Assert.NotEqual(default, cs.Identifier); 3961Assert.NotEqual(default, cs.OpenBraceToken); 3962Assert.NotEqual(default, cs.CloseBraceToken); 3975Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 3980Assert.NotEqual(default, fs.Declaration.Variables[1].Identifier); 3985Assert.NotEqual(default, fs.Declaration.Variables[2].Identifier); 3990Assert.NotEqual(default, fs.SemicolonToken); 4009Assert.NotEqual(default, cs.Keyword); 4011Assert.NotEqual(default, cs.Identifier); 4015Assert.NotEqual(default, cs.OpenBraceToken); 4016Assert.NotEqual(default, cs.CloseBraceToken); 4029Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 4033Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 4037Assert.NotEqual(default, fs.Declaration.Variables[1].Identifier); 4041Assert.NotEqual(default, fs.Declaration.Variables[1].Initializer.EqualsToken); 4045Assert.NotEqual(default, fs.Declaration.Variables[2].Identifier); 4049Assert.NotEqual(default, fs.Declaration.Variables[2].Initializer.EqualsToken); 4053Assert.NotEqual(default, fs.SemicolonToken); 4072Assert.NotEqual(default, cs.Keyword); 4074Assert.NotEqual(default, cs.Identifier); 4078Assert.NotEqual(default, cs.OpenBraceToken); 4079Assert.NotEqual(default, cs.CloseBraceToken); 4091Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 4094Assert.NotEqual(default, fs.Declaration.Variables[0].ArgumentList.OpenBracketToken); 4095Assert.NotEqual(default, fs.Declaration.Variables[0].ArgumentList.CloseBracketToken); 4099Assert.NotEqual(default, fs.SemicolonToken); 4118Assert.NotEqual(default, cs.Keyword); 4120Assert.NotEqual(default, cs.Identifier); 4124Assert.NotEqual(default, cs.OpenBraceToken); 4125Assert.NotEqual(default, cs.CloseBraceToken); 4135Assert.NotEqual(default, ps.Identifier); 4138Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4139Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4144Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4147Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 4151Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4154Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 4172Assert.NotEqual(default, cs.Keyword); 4174Assert.NotEqual(default, cs.Identifier); 4178Assert.NotEqual(default, cs.OpenBraceToken); 4179Assert.NotEqual(default, cs.CloseBraceToken); 4189Assert.NotEqual(default, ps.Identifier); 4192Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4193Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4198Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4201Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 4205Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4208Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 4227Assert.NotEqual(default, cs.Keyword); 4229Assert.NotEqual(default, cs.Identifier); 4233Assert.NotEqual(default, cs.OpenBraceToken); 4234Assert.NotEqual(default, cs.CloseBraceToken); 4244Assert.NotEqual(default, ps.Identifier); 4247Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4248Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4253Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4256Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 4260Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4263Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 4300Assert.NotEqual(default, cs.Keyword); 4302Assert.NotEqual(default, cs.Identifier); 4306Assert.NotEqual(default, cs.OpenBraceToken); 4307Assert.NotEqual(default, cs.CloseBraceToken); 4317Assert.NotEqual(default, ps.Identifier); 4320Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4321Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4326Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4329Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 4333Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4336Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 4354Assert.NotEqual(default, cs.Keyword); 4356Assert.NotEqual(default, cs.Identifier); 4360Assert.NotEqual(default, cs.OpenBraceToken); 4361Assert.NotEqual(default, cs.CloseBraceToken); 4371Assert.NotEqual(default, ps.Identifier); 4374Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4375Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4380Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4387Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4408Assert.NotEqual(default, cs.Keyword); 4410Assert.NotEqual(default, cs.Identifier); 4414Assert.NotEqual(default, cs.OpenBraceToken); 4415Assert.NotEqual(default, cs.CloseBraceToken); 4425Assert.NotEqual(default, ps.Identifier); 4428Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4429Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4434Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4440Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4492Assert.NotEqual(default, cs.Keyword); 4494Assert.NotEqual(default, cs.Identifier); 4498Assert.NotEqual(default, cs.OpenBraceToken); 4499Assert.NotEqual(default, cs.CloseBraceToken); 4509Assert.NotEqual(default, ps.Identifier); 4512Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4513Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4519Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4548Assert.NotEqual(default, cs.Keyword); 4550Assert.NotEqual(default, cs.Identifier); 4554Assert.NotEqual(default, cs.OpenBraceToken); 4555Assert.NotEqual(default, cs.CloseBraceToken); 4565Assert.NotEqual(default, es.Identifier); 4568Assert.NotEqual(default, es.AccessorList.OpenBraceToken); 4569Assert.NotEqual(default, es.AccessorList.CloseBraceToken); 4575Assert.NotEqual(default, es.AccessorList.Accessors[0].Keyword); 4604Assert.NotEqual(default, cs.Keyword); 4606Assert.NotEqual(default, cs.Identifier); 4610Assert.NotEqual(default, cs.OpenBraceToken); 4611Assert.NotEqual(default, cs.CloseBraceToken); 4622Assert.NotEqual(default, ps.Identifier); 4625Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4626Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4631Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4634Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 4638Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4641Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 4688Assert.NotEqual(default, cs.Keyword); 4690Assert.NotEqual(default, cs.Identifier); 4694Assert.NotEqual(default, cs.OpenBraceToken); 4695Assert.NotEqual(default, cs.CloseBraceToken); 4705Assert.NotEqual(default, ps.Identifier); 4710Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4711Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4716Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4719Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 4723Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4726Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 4744Assert.NotEqual(default, cs.Keyword); 4746Assert.NotEqual(default, cs.Identifier); 4750Assert.NotEqual(default, cs.OpenBraceToken); 4751Assert.NotEqual(default, cs.CloseBraceToken); 4759Assert.NotEqual(default, es.EventKeyword); 4762Assert.NotEqual(default, es.Identifier); 4765Assert.NotEqual(default, es.AccessorList.OpenBraceToken); 4766Assert.NotEqual(default, es.AccessorList.CloseBraceToken); 4771Assert.NotEqual(default, es.AccessorList.Accessors[0].Keyword); 4778Assert.NotEqual(default, es.AccessorList.Accessors[1].Keyword); 4798Assert.NotEqual(default, cs.Keyword); 4800Assert.NotEqual(default, cs.Identifier); 4804Assert.NotEqual(default, cs.OpenBraceToken); 4805Assert.NotEqual(default, cs.CloseBraceToken); 4814Assert.NotEqual(default, es.EventKeyword); 4817Assert.NotEqual(default, es.Identifier); 4820Assert.NotEqual(default, es.AccessorList.OpenBraceToken); 4821Assert.NotEqual(default, es.AccessorList.CloseBraceToken); 4826Assert.NotEqual(default, es.AccessorList.Accessors[0].Keyword); 4833Assert.NotEqual(default, es.AccessorList.Accessors[1].Keyword); 4881Assert.NotEqual(default, cs.Keyword); 4883Assert.NotEqual(default, cs.Identifier); 4887Assert.NotEqual(default, cs.OpenBraceToken); 4888Assert.NotEqual(default, cs.CloseBraceToken); 4896Assert.NotEqual(default, es.EventKeyword); 4899Assert.NotEqual(default, es.Identifier); 4904Assert.NotEqual(default, es.AccessorList.OpenBraceToken); 4905Assert.NotEqual(default, es.AccessorList.CloseBraceToken); 4910Assert.NotEqual(default, es.AccessorList.Accessors[0].Keyword); 4917Assert.NotEqual(default, es.AccessorList.Accessors[1].Keyword); 4938Assert.NotEqual(default, cs.Keyword); 4940Assert.NotEqual(default, cs.Identifier); 4944Assert.NotEqual(default, cs.OpenBraceToken); 4945Assert.NotEqual(default, cs.CloseBraceToken); 4955Assert.NotEqual(default, ps.ThisKeyword); 4959Assert.NotEqual(default, ps.ParameterList.OpenBracketToken); 4961Assert.NotEqual(default, ps.ParameterList.CloseBracketToken); 4968Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 4971Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 4972Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 4977Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 4980Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 4984Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 4987Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 5005Assert.NotEqual(default, cs.Keyword); 5007Assert.NotEqual(default, cs.Identifier); 5011Assert.NotEqual(default, cs.OpenBraceToken); 5012Assert.NotEqual(default, cs.CloseBraceToken); 5022Assert.NotEqual(default, ps.ThisKeyword); 5026Assert.NotEqual(default, ps.ParameterList.OpenBracketToken); 5028Assert.NotEqual(default, ps.ParameterList.CloseBracketToken); 5035Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 5038Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 5039Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 5044Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 5047Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 5051Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 5054Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 5073Assert.NotEqual(default, cs.Keyword); 5075Assert.NotEqual(default, cs.Identifier); 5079Assert.NotEqual(default, cs.OpenBraceToken); 5080Assert.NotEqual(default, cs.CloseBraceToken); 5090Assert.NotEqual(default, ps.ThisKeyword); 5094Assert.NotEqual(default, ps.ParameterList.OpenBracketToken); 5096Assert.NotEqual(default, ps.ParameterList.CloseBracketToken); 5103Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 5106Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 5107Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 5112Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 5115Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 5119Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 5122Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 5140Assert.NotEqual(default, cs.Keyword); 5142Assert.NotEqual(default, cs.Identifier); 5146Assert.NotEqual(default, cs.OpenBraceToken); 5147Assert.NotEqual(default, cs.CloseBraceToken); 5157Assert.NotEqual(default, ps.ThisKeyword); 5161Assert.NotEqual(default, ps.ParameterList.OpenBracketToken); 5163Assert.NotEqual(default, ps.ParameterList.CloseBracketToken); 5172Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 5179Assert.NotEqual(default, ps.ParameterList.Parameters[1].Identifier); 5182Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 5183Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 5188Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 5191Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 5195Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 5198Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 5216Assert.NotEqual(default, cs.Keyword); 5218Assert.NotEqual(default, cs.Identifier); 5222Assert.NotEqual(default, cs.OpenBraceToken); 5223Assert.NotEqual(default, cs.CloseBraceToken); 5239Assert.NotEqual(default, ps.ParameterList.OpenBracketToken); 5241Assert.NotEqual(default, ps.ParameterList.CloseBracketToken); 5248Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 5251Assert.NotEqual(default, ps.AccessorList.OpenBraceToken); 5252Assert.NotEqual(default, ps.AccessorList.CloseBraceToken); 5257Assert.NotEqual(default, ps.AccessorList.Accessors[0].Keyword); 5260Assert.NotEqual(default, ps.AccessorList.Accessors[0].SemicolonToken); 5264Assert.NotEqual(default, ps.AccessorList.Accessors[1].Keyword); 5267Assert.NotEqual(default, ps.AccessorList.Accessors[1].SemicolonToken); 5284Assert.NotEqual(default, cs.Keyword); 5286Assert.NotEqual(default, cs.Identifier); 5290Assert.NotEqual(default, cs.OpenBraceToken); 5291Assert.NotEqual(default, cs.CloseBraceToken); 5301Assert.NotEqual(default, ps.OperatorKeyword); 5303Assert.NotEqual(default, ps.OperatorToken); 5305Assert.NotEqual(default, ps.ParameterList.OpenParenToken); 5306Assert.NotEqual(default, ps.ParameterList.CloseParenToken); 5315Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 5322Assert.NotEqual(default, ps.ParameterList.Parameters[1].Identifier); 5364Assert.NotEqual(default, cs.Keyword); 5366Assert.NotEqual(default, cs.Identifier); 5370Assert.NotEqual(default, cs.OpenBraceToken); 5371Assert.NotEqual(default, cs.CloseBraceToken); 5381Assert.NotEqual(default, ps.OperatorKeyword); 5383Assert.NotEqual(default, ps.OperatorToken); 5385Assert.NotEqual(default, ps.ParameterList.OpenParenToken); 5386Assert.NotEqual(default, ps.ParameterList.CloseParenToken); 5395Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 5402Assert.NotEqual(default, ps.ParameterList.Parameters[1].Identifier); 5478Assert.NotEqual(default, cs.Keyword); 5480Assert.NotEqual(default, cs.Identifier); 5484Assert.NotEqual(default, cs.OpenBraceToken); 5485Assert.NotEqual(default, cs.CloseBraceToken); 5495Assert.NotEqual(default, ps.OperatorKeyword); 5497Assert.NotEqual(default, ps.OperatorToken); 5499Assert.NotEqual(default, ps.ParameterList.OpenParenToken); 5500Assert.NotEqual(default, ps.ParameterList.CloseParenToken); 5509Assert.NotEqual(default, ps.ParameterList.Parameters[0].Identifier); 5541Assert.NotEqual(default, cs.Keyword); 5543Assert.NotEqual(default, cs.Identifier); 5547Assert.NotEqual(default, cs.OpenBraceToken); 5548Assert.NotEqual(default, cs.CloseBraceToken); 5556Assert.NotEqual(default, ms.ImplicitOrExplicitKeyword); 5558Assert.NotEqual(default, ms.OperatorKeyword); 5562Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 5563Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 5570Assert.NotEqual(default, ms.ParameterList.Parameters[0].Identifier); 5589Assert.NotEqual(default, cs.Keyword); 5591Assert.NotEqual(default, cs.Identifier); 5595Assert.NotEqual(default, cs.OpenBraceToken); 5596Assert.NotEqual(default, cs.CloseBraceToken); 5604Assert.NotEqual(default, ms.ImplicitOrExplicitKeyword); 5606Assert.NotEqual(default, ms.OperatorKeyword); 5610Assert.NotEqual(default, ms.ParameterList.OpenParenToken); 5611Assert.NotEqual(default, ms.ParameterList.CloseParenToken); 5618Assert.NotEqual(default, ms.ParameterList.Parameters[0].Identifier);
Parsing\ExpressionParsingTests.cs (189)
460Assert.NotEqual(default, us.Token); 487Assert.NotEqual(default, token); 492Assert.NotEqual(default, token); 515Assert.NotEqual(default, us.Token); 530Assert.NotEqual(default, us.Token); 545Assert.NotEqual(default, us.Token); 559Assert.NotEqual(default, us.Token); 574Assert.NotEqual(default, us.OperatorToken); 605Assert.NotEqual(default, us.OperatorToken); 631Assert.NotEqual(default, b.OperatorToken); 677Assert.NotEqual(default, a.OperatorToken); 712Assert.NotEqual(default, e.OperatorToken); 797Assert.NotEqual(default, keyword); 803Assert.NotEqual(default, openParen); 805Assert.NotEqual(default, closeParen); 884Assert.NotEqual(default, fs.Keyword); 886Assert.NotEqual(default, fs.OpenParenToken); 888Assert.NotEqual(default, fs.CloseParenToken); 905Assert.NotEqual(default, ts.QuestionToken); 906Assert.NotEqual(default, ts.ColonToken); 935Assert.NotEqual(default, cs.OpenParenToken); 936Assert.NotEqual(default, cs.CloseParenToken); 956Assert.NotEqual(default, cs.ArgumentList.OpenParenToken); 957Assert.NotEqual(default, cs.ArgumentList.CloseParenToken); 977Assert.NotEqual(default, cs.ArgumentList.OpenParenToken); 978Assert.NotEqual(default, cs.ArgumentList.CloseParenToken); 985Assert.NotEqual(default, cs.ArgumentList.Arguments[0].RefOrOutKeyword); 1002Assert.NotEqual(default, cs.ArgumentList.OpenParenToken); 1003Assert.NotEqual(default, cs.ArgumentList.CloseParenToken); 1010Assert.NotEqual(default, cs.ArgumentList.Arguments[0].RefOrOutKeyword); 1027Assert.NotEqual(default, cs.ArgumentList.OpenParenToken); 1028Assert.NotEqual(default, cs.ArgumentList.CloseParenToken); 1037Assert.NotEqual(default, cs.ArgumentList.Arguments[0].NameColon.ColonToken); 1052Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken); 1053Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken); 1073Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken); 1074Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken); 1081Assert.NotEqual(default, ea.ArgumentList.Arguments[0].RefOrOutKeyword); 1098Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken); 1099Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken); 1106Assert.NotEqual(default, ea.ArgumentList.Arguments[0].RefOrOutKeyword); 1123Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken); 1124Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken); 1145Assert.NotEqual(default, oc.ArgumentList.OpenParenToken); 1146Assert.NotEqual(default, oc.ArgumentList.CloseParenToken); 1167Assert.NotEqual(default, oc.ArgumentList.OpenParenToken); 1168Assert.NotEqual(default, oc.ArgumentList.CloseParenToken); 1190Assert.NotEqual(default, oc.ArgumentList.OpenParenToken); 1191Assert.NotEqual(default, oc.ArgumentList.CloseParenToken); 1213Assert.NotEqual(default, oc.ArgumentList.OpenParenToken); 1214Assert.NotEqual(default, oc.ArgumentList.CloseParenToken); 1222Assert.NotEqual(default, oc.Initializer.OpenBraceToken); 1223Assert.NotEqual(default, oc.Initializer.CloseBraceToken); 1245Assert.NotEqual(default, oc.Initializer.OpenBraceToken); 1246Assert.NotEqual(default, oc.Initializer.CloseBraceToken); 1268Assert.NotEqual(default, oc.Initializer.OpenBraceToken); 1269Assert.NotEqual(default, oc.Initializer.CloseBraceToken); 1292Assert.NotEqual(default, oc.Initializer.OpenBraceToken); 1293Assert.NotEqual(default, oc.Initializer.CloseBraceToken); 1318Assert.NotEqual(default, oc.Initializer.OpenBraceToken); 1319Assert.NotEqual(default, oc.Initializer.CloseBraceToken); 1342Assert.NotEqual(default, oc.Initializer.OpenBraceToken); 1343Assert.NotEqual(default, oc.Initializer.CloseBraceToken); 1846Assert.NotEqual(default, ac.Initializer.OpenBraceToken); 1847Assert.NotEqual(default, ac.Initializer.CloseBraceToken); 1868Assert.NotEqual(default, ac.Initializer.OpenBraceToken); 1869Assert.NotEqual(default, ac.Initializer.CloseBraceToken); 1892Assert.NotEqual(default, ac.Initializer.OpenBraceToken); 1893Assert.NotEqual(default, ac.Initializer.CloseBraceToken); 1912Assert.NotEqual(default, ac.Initializer.OpenBraceToken); 1913Assert.NotEqual(default, ac.Initializer.CloseBraceToken); 1931Assert.NotEqual(default, ac.NewKeyword); 1932Assert.NotEqual(default, ac.OpenBraceToken); 1933Assert.NotEqual(default, ac.CloseBraceToken); 1953Assert.NotEqual(default, am.DelegateKeyword); 1957Assert.NotEqual(default, am.ParameterList.OpenParenToken); 1958Assert.NotEqual(default, am.ParameterList.CloseParenToken); 1965Assert.NotEqual(default, am.Block.OpenBraceToken); 1966Assert.NotEqual(default, am.Block.CloseBraceToken); 1984Assert.NotEqual(default, am.DelegateKeyword); 1988Assert.NotEqual(default, am.ParameterList.OpenParenToken); 1989Assert.NotEqual(default, am.ParameterList.CloseParenToken); 1995Assert.NotEqual(default, am.Block.OpenBraceToken); 1996Assert.NotEqual(default, am.Block.CloseBraceToken); 2014Assert.NotEqual(default, am.DelegateKeyword); 2020Assert.NotEqual(default, am.Block.OpenBraceToken); 2021Assert.NotEqual(default, am.Block.CloseBraceToken); 2038Assert.NotEqual(default, lambda.Parameter.Identifier); 2056Assert.NotEqual(default, lambda.Parameter.Identifier); 2074Assert.NotEqual(default, lambda.Parameter.Identifier); 2094Assert.NotEqual(default, lambda.ParameterList.OpenParenToken); 2095Assert.NotEqual(default, lambda.ParameterList.CloseParenToken); 2114Assert.NotEqual(default, lambda.ParameterList.OpenParenToken); 2115Assert.NotEqual(default, lambda.ParameterList.CloseParenToken); 2134Assert.NotEqual(default, lambda.ParameterList.OpenParenToken); 2135Assert.NotEqual(default, lambda.ParameterList.CloseParenToken); 2156Assert.NotEqual(default, lambda.ParameterList.OpenParenToken); 2157Assert.NotEqual(default, lambda.ParameterList.CloseParenToken); 2180Assert.NotEqual(default, lambda.ParameterList.OpenParenToken); 2181Assert.NotEqual(default, lambda.ParameterList.CloseParenToken); 2207Assert.NotEqual(default, lambda.ParameterList.OpenParenToken); 2208Assert.NotEqual(default, lambda.ParameterList.CloseParenToken); 2232Assert.NotEqual(default, lambda.ParameterList.OpenParenToken); 2233Assert.NotEqual(default, lambda.ParameterList.CloseParenToken); 2259Assert.NotEqual(default, tuple.OpenParenToken); 2260Assert.NotEqual(default, tuple.CloseParenToken); 2279Assert.NotEqual(default, tuple.OpenParenToken); 2280Assert.NotEqual(default, tuple.CloseParenToken); 2304Assert.NotEqual(default, fs.FromKeyword); 2309Assert.NotEqual(default, fs.InKeyword); 2315Assert.NotEqual(default, ss.SelectKeyword); 2338Assert.NotEqual(default, fs.FromKeyword); 2343Assert.NotEqual(default, fs.InKeyword); 2349Assert.NotEqual(default, ss.SelectKeyword); 2372Assert.NotEqual(default, fs.FromKeyword); 2376Assert.NotEqual(default, fs.InKeyword); 2382Assert.NotEqual(default, ss.SelectKeyword); 2388Assert.NotEqual(default, qs.Body.Continuation.IntoKeyword); 2399Assert.NotEqual(default, ss.SelectKeyword); 2422Assert.NotEqual(default, fs.FromKeyword); 2426Assert.NotEqual(default, fs.InKeyword); 2432Assert.NotEqual(default, ws.WhereKeyword); 2440Assert.NotEqual(default, ss.SelectKeyword); 2462Assert.NotEqual(default, fs.FromKeyword); 2466Assert.NotEqual(default, fs.InKeyword); 2473Assert.NotEqual(default, fs.FromKeyword); 2477Assert.NotEqual(default, fs.InKeyword); 2483Assert.NotEqual(default, ss.SelectKeyword); 2505Assert.NotEqual(default, fs.FromKeyword); 2509Assert.NotEqual(default, fs.InKeyword); 2516Assert.NotEqual(default, ls.LetKeyword); 2519Assert.NotEqual(default, ls.Identifier); 2521Assert.NotEqual(default, ls.EqualsToken); 2528Assert.NotEqual(default, ss.SelectKeyword); 2550Assert.NotEqual(default, fs.FromKeyword); 2554Assert.NotEqual(default, fs.InKeyword); 2561Assert.NotEqual(default, obs.OrderByKeyword); 2573Assert.NotEqual(default, ss.SelectKeyword); 2595Assert.NotEqual(default, fs.FromKeyword); 2599Assert.NotEqual(default, fs.InKeyword); 2606Assert.NotEqual(default, obs.OrderByKeyword); 2622Assert.NotEqual(default, ss.SelectKeyword); 2644Assert.NotEqual(default, fs.FromKeyword); 2648Assert.NotEqual(default, fs.InKeyword); 2655Assert.NotEqual(default, obs.OrderByKeyword); 2660Assert.NotEqual(default, os.AscendingOrDescendingKeyword); 2670Assert.NotEqual(default, ss.SelectKeyword); 2692Assert.NotEqual(default, fs.FromKeyword); 2696Assert.NotEqual(default, fs.InKeyword); 2703Assert.NotEqual(default, obs.OrderByKeyword); 2708Assert.NotEqual(default, os.AscendingOrDescendingKeyword); 2718Assert.NotEqual(default, ss.SelectKeyword); 2739Assert.NotEqual(default, fs.FromKeyword); 2743Assert.NotEqual(default, fs.InKeyword); 2749Assert.NotEqual(default, gbs.GroupKeyword); 2754Assert.NotEqual(default, gbs.ByKeyword); 2778Assert.NotEqual(default, fs.FromKeyword); 2782Assert.NotEqual(default, fs.InKeyword); 2788Assert.NotEqual(default, gbs.GroupKeyword); 2792Assert.NotEqual(default, gbs.ByKeyword); 2799Assert.NotEqual(default, qs.Body.Continuation.IntoKeyword); 2809Assert.NotEqual(default, ss.SelectKeyword); 2832Assert.NotEqual(default, fs.FromKeyword); 2836Assert.NotEqual(default, fs.InKeyword); 2842Assert.NotEqual(default, js.JoinKeyword); 2846Assert.NotEqual(default, js.Identifier); 2848Assert.NotEqual(default, js.InKeyword); 2852Assert.NotEqual(default, js.OnKeyword); 2857Assert.NotEqual(default, js.EqualsKeyword); 2866Assert.NotEqual(default, ss.SelectKeyword); 2888Assert.NotEqual(default, fs.FromKeyword); 2893Assert.NotEqual(default, fs.InKeyword); 2899Assert.NotEqual(default, js.JoinKeyword); 2903Assert.NotEqual(default, js.Identifier); 2905Assert.NotEqual(default, js.InKeyword); 2909Assert.NotEqual(default, js.OnKeyword); 2913Assert.NotEqual(default, js.EqualsKeyword); 2921Assert.NotEqual(default, ss.SelectKeyword); 2943Assert.NotEqual(default, fs.FromKeyword); 2947Assert.NotEqual(default, fs.InKeyword); 2953Assert.NotEqual(default, js.JoinKeyword); 2956Assert.NotEqual(default, js.Identifier); 2958Assert.NotEqual(default, js.InKeyword); 2962Assert.NotEqual(default, js.OnKeyword); 2966Assert.NotEqual(default, js.EqualsKeyword); 2971Assert.NotEqual(default, js.Into.IntoKeyword); 2973Assert.NotEqual(default, js.Into.Identifier); 2978Assert.NotEqual(default, ss.SelectKeyword); 3044Assert.NotEqual(0, expr.Errors().Length);
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)
4589Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4614Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.Kind()); 4615Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 4642Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4669Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4697Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4724Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4752Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4781Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4810Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4840Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4869Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4897Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4924Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4951Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 4978Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5006Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5033Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5061Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5087Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5117Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5146Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5176Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5829Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5869Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5898Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5927Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5957Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 5986Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6019Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6046Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6073Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6100Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6128Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6155Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6185Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6216Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6244Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6292Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6326Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6358Assert.NotEqual(SyntaxKind.None, ds.Declaration.Variables[0].Initializer.EqualsToken.Kind()); 6408Assert.NotEqual(default, pd.AccessorList.OpenBraceToken); 6410Assert.NotEqual(default, pd.AccessorList.CloseBraceToken); 6433Assert.NotEqual(default, pd.AccessorList.OpenBraceToken); 6435Assert.NotEqual(default, pd.AccessorList.CloseBraceToken); 6458Assert.NotEqual(default, pd.AccessorList.OpenBraceToken); 6460Assert.NotEqual(default, pd.AccessorList.CloseBraceToken); 6465Assert.NotEqual(default, acc.Keyword); 6469Assert.NotEqual(default, acc.SemicolonToken); 6493Assert.NotEqual(default, pd.AccessorList.OpenBraceToken); 6495Assert.NotEqual(default, pd.AccessorList.CloseBraceToken); 6500Assert.NotEqual(default, acc.Keyword); 6504Assert.NotEqual(default, acc.Body.OpenBraceToken); 6507Assert.NotEqual(default, acc.Body.CloseBraceToken); 6532Assert.NotEqual(default, pd.AccessorList.OpenBraceToken); 6534Assert.NotEqual(default, pd.AccessorList.CloseBraceToken); 6539Assert.NotEqual(default, acc.Keyword); 6543Assert.NotEqual(default, acc.Body.OpenBraceToken); 6546Assert.NotEqual(default, acc.Body.CloseBraceToken); 6634Assert.NotEqual(default, md.Body.OpenBraceToken); 6636Assert.NotEqual(default, md.Body.CloseBraceToken); 6650Assert.NotEqual(default, oc.OrderByKeyword); 6679Assert.NotEqual(default, md.Body.OpenBraceToken); 6681Assert.NotEqual(default, md.Body.CloseBraceToken); 6695Assert.NotEqual(default, oc.OrderByKeyword); 6723Assert.NotEqual(default, md.Body.OpenBraceToken); 6725Assert.NotEqual(default, md.Body.CloseBraceToken); 6739Assert.NotEqual(default, oc.OrderByKeyword); 6773Assert.NotEqual(default, md.Body.OpenBraceToken); 6775Assert.NotEqual(default, md.Body.CloseBraceToken); 6789Assert.NotEqual(default, oc.OrderByKeyword); 6821Assert.NotEqual(default, md.Body.OpenBraceToken); 6823Assert.NotEqual(default, md.Body.CloseBraceToken); 6837Assert.NotEqual(default, oc.OrderByKeyword); 6868Assert.NotEqual(default, md.Body.OpenBraceToken); 6870Assert.NotEqual(default, md.Body.CloseBraceToken); 6884Assert.NotEqual(default, oc.OrderByKeyword);
Parsing\RoundTrippingTests.cs (1)
37Assert.NotEqual(0, tree.GetCompilationUnitRoot().ErrorsAndWarnings().Length);
Parsing\StatementParsingTests.cs (331)
68Assert.NotEqual(default, es.SemicolonToken); 88Assert.NotEqual(default, es.SemicolonToken); 107Assert.NotEqual(default, es.SemicolonToken); 127Assert.NotEqual(default, es.SemicolonToken); 147Assert.NotEqual(default, es.SemicolonToken); 163Assert.NotEqual(default, es.SemicolonToken); 198Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 203Assert.NotEqual(default, ds.SemicolonToken); 228Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 233Assert.NotEqual(default, ds.SemicolonToken); 262Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 267Assert.NotEqual(default, ds.SemicolonToken); 303Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 308Assert.NotEqual(default, ds.SemicolonToken); 333Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 338Assert.NotEqual(default, ds.SemicolonToken); 359Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 364Assert.NotEqual(default, ds.SemicolonToken); 385Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 390Assert.NotEqual(default, ds.SemicolonToken); 411Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 416Assert.NotEqual(default, ds.SemicolonToken); 437Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 442Assert.NotEqual(default, ds.SemicolonToken); 463Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 468Assert.NotEqual(default, ds.SemicolonToken); 489Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 494Assert.NotEqual(default, ds.SemicolonToken); 515Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 520Assert.NotEqual(default, ds.Declaration.Variables[1].Identifier); 525Assert.NotEqual(default, ds.Declaration.Variables[2].Identifier); 529Assert.NotEqual(default, ds.SemicolonToken); 550Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 554Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 559Assert.NotEqual(default, ds.SemicolonToken); 580Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 583Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 588Assert.NotEqual(default, ds.Declaration.Variables[1].Identifier); 591Assert.NotEqual(default, ds.Declaration.Variables[1].Initializer.EqualsToken); 596Assert.NotEqual(default, ds.Declaration.Variables[2].Identifier); 599Assert.NotEqual(default, ds.Declaration.Variables[2].Initializer.EqualsToken); 604Assert.NotEqual(default, ds.SemicolonToken); 625Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 629Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 635Assert.NotEqual(default, ds.SemicolonToken); 657Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 661Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 666Assert.NotEqual(default, ds.SemicolonToken); 689Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 693Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 698Assert.NotEqual(default, ds.SemicolonToken); 721Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 725Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 730Assert.NotEqual(default, ds.SemicolonToken); 753Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 757Assert.NotEqual(default, ds.Declaration.Variables[0].Initializer.EqualsToken); 762Assert.NotEqual(default, ds.SemicolonToken); 783Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 788Assert.NotEqual(default, ds.SemicolonToken); 809Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 814Assert.NotEqual(default, initializer.EqualsToken); 819Assert.NotEqual(default, ds.SemicolonToken); 840Assert.NotEqual(default, ds.Declaration.Variables[0].Identifier); 845Assert.NotEqual(default, initializer.EqualsToken); 850Assert.NotEqual(default, ds.Declaration.Variables[1].Identifier); 855Assert.NotEqual(default, initializer.EqualsToken); 860Assert.NotEqual(default, ds.SemicolonToken); 876Assert.NotEqual(default, fs.FixedKeyword); 878Assert.NotEqual(default, fs.OpenParenToken); 903Assert.NotEqual(default, fs.FixedKeyword); 905Assert.NotEqual(default, fs.OpenParenToken); 933Assert.NotEqual(default, fs.FixedKeyword); 935Assert.NotEqual(default, fs.OpenParenToken); 961Assert.NotEqual(default, es.SemicolonToken); 977Assert.NotEqual(default, ls.Identifier); 979Assert.NotEqual(default, ls.ColonToken); 998Assert.NotEqual(default, b.BreakKeyword); 1001Assert.NotEqual(default, b.SemicolonToken); 1017Assert.NotEqual(default, cs.ContinueKeyword); 1020Assert.NotEqual(default, cs.SemicolonToken); 1036Assert.NotEqual(default, gs.GotoKeyword); 1042Assert.NotEqual(default, gs.SemicolonToken); 1058Assert.NotEqual(default, gs.GotoKeyword); 1061Assert.NotEqual(default, gs.CaseOrDefaultKeyword); 1066Assert.NotEqual(default, gs.SemicolonToken); 1082Assert.NotEqual(default, gs.GotoKeyword); 1085Assert.NotEqual(default, gs.CaseOrDefaultKeyword); 1089Assert.NotEqual(default, gs.SemicolonToken); 1105Assert.NotEqual(default, rs.ReturnKeyword); 1109Assert.NotEqual(default, rs.SemicolonToken); 1125Assert.NotEqual(default, rs.ReturnKeyword); 1130Assert.NotEqual(default, rs.SemicolonToken); 1146Assert.NotEqual(default, ys.YieldKeyword); 1149Assert.NotEqual(default, ys.ReturnOrBreakKeyword); 1154Assert.NotEqual(default, ys.SemicolonToken); 1170Assert.NotEqual(default, ys.YieldKeyword); 1173Assert.NotEqual(default, ys.ReturnOrBreakKeyword); 1177Assert.NotEqual(default, ys.SemicolonToken); 1193Assert.NotEqual(default, ts.ThrowKeyword); 1197Assert.NotEqual(default, ts.SemicolonToken); 1213Assert.NotEqual(default, ts.ThrowKeyword); 1218Assert.NotEqual(default, ts.SemicolonToken); 1234Assert.NotEqual(default, ts.TryKeyword); 1239Assert.NotEqual(default, ts.Catches[0].CatchKeyword); 1241Assert.NotEqual(default, ts.Catches[0].Declaration.OpenParenToken); 1244Assert.NotEqual(default, ts.Catches[0].Declaration.Identifier); 1246Assert.NotEqual(default, ts.Catches[0].Declaration.CloseParenToken); 1264Assert.NotEqual(default, ts.TryKeyword); 1269Assert.NotEqual(default, ts.Catches[0].CatchKeyword); 1271Assert.NotEqual(default, ts.Catches[0].Declaration.OpenParenToken); 1275Assert.NotEqual(default, ts.Catches[0].Declaration.CloseParenToken); 1293Assert.NotEqual(default, ts.TryKeyword); 1298Assert.NotEqual(default, ts.Catches[0].CatchKeyword); 1317Assert.NotEqual(default, ts.TryKeyword); 1323Assert.NotEqual(default, ts.Catches[0].CatchKeyword); 1325Assert.NotEqual(default, ts.Catches[0].Declaration.OpenParenToken); 1328Assert.NotEqual(default, ts.Catches[0].Declaration.Identifier); 1330Assert.NotEqual(default, ts.Catches[0].Declaration.CloseParenToken); 1333Assert.NotEqual(default, ts.Catches[1].CatchKeyword); 1335Assert.NotEqual(default, ts.Catches[1].Declaration.OpenParenToken); 1338Assert.NotEqual(default, ts.Catches[1].Declaration.CloseParenToken); 1341Assert.NotEqual(default, ts.Catches[2].CatchKeyword); 1360Assert.NotEqual(default, ts.TryKeyword); 1367Assert.NotEqual(default, ts.Finally.FinallyKeyword); 1383Assert.NotEqual(default, ts.TryKeyword); 1389Assert.NotEqual(default, ts.Catches[0].CatchKeyword); 1391Assert.NotEqual(default, ts.Catches[0].Declaration.OpenParenToken); 1394Assert.NotEqual(default, ts.Catches[0].Declaration.Identifier); 1396Assert.NotEqual(default, ts.Catches[0].Declaration.CloseParenToken); 1399Assert.NotEqual(default, ts.Catches[1].CatchKeyword); 1401Assert.NotEqual(default, ts.Catches[1].Declaration.OpenParenToken); 1404Assert.NotEqual(default, ts.Catches[1].Declaration.CloseParenToken); 1407Assert.NotEqual(default, ts.Catches[2].CatchKeyword); 1412Assert.NotEqual(default, ts.Finally.FinallyKeyword); 1428Assert.NotEqual(default, cs.Keyword); 1445Assert.NotEqual(default, cs.Keyword); 1462Assert.NotEqual(default, us.UnsafeKeyword); 1479Assert.NotEqual(default, ws.WhileKeyword); 1481Assert.NotEqual(default, ws.OpenParenToken); 1483Assert.NotEqual(default, ws.CloseParenToken); 1501Assert.NotEqual(default, ds.DoKeyword); 1504Assert.NotEqual(default, ds.WhileKeyword); 1507Assert.NotEqual(default, ds.OpenParenToken); 1509Assert.NotEqual(default, ds.CloseParenToken); 1511Assert.NotEqual(default, ds.SemicolonToken); 1526Assert.NotEqual(default, fs.ForKeyword); 1529Assert.NotEqual(default, fs.OpenParenToken); 1532Assert.NotEqual(default, fs.FirstSemicolonToken); 1534Assert.NotEqual(default, fs.SecondSemicolonToken); 1536Assert.NotEqual(default, fs.CloseParenToken); 1552Assert.NotEqual(default, fs.ForKeyword); 1555Assert.NotEqual(default, fs.OpenParenToken); 1561Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 1564Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 1569Assert.NotEqual(default, fs.FirstSemicolonToken); 1571Assert.NotEqual(default, fs.SecondSemicolonToken); 1573Assert.NotEqual(default, fs.CloseParenToken); 1589Assert.NotEqual(default, fs.ForKeyword); 1592Assert.NotEqual(default, fs.OpenParenToken); 1600Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 1603Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 1608Assert.NotEqual(default, fs.FirstSemicolonToken); 1610Assert.NotEqual(default, fs.SecondSemicolonToken); 1612Assert.NotEqual(default, fs.CloseParenToken); 1628Assert.NotEqual(default, fs.ForKeyword); 1631Assert.NotEqual(default, fs.OpenParenToken); 1638Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 1641Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 1645Assert.NotEqual(default, fs.Declaration.Variables[1].Identifier); 1648Assert.NotEqual(default, fs.Declaration.Variables[1].Initializer.EqualsToken); 1653Assert.NotEqual(default, fs.FirstSemicolonToken); 1655Assert.NotEqual(default, fs.SecondSemicolonToken); 1657Assert.NotEqual(default, fs.CloseParenToken); 1737Assert.NotEqual(default, fs.ForKeyword); 1740Assert.NotEqual(default, fs.OpenParenToken); 1746Assert.NotEqual(default, fs.FirstSemicolonToken); 1748Assert.NotEqual(default, fs.SecondSemicolonToken); 1750Assert.NotEqual(default, fs.CloseParenToken); 1766Assert.NotEqual(default, fs.ForKeyword); 1769Assert.NotEqual(default, fs.OpenParenToken); 1776Assert.NotEqual(default, fs.FirstSemicolonToken); 1778Assert.NotEqual(default, fs.SecondSemicolonToken); 1780Assert.NotEqual(default, fs.CloseParenToken); 1796Assert.NotEqual(default, fs.ForKeyword); 1799Assert.NotEqual(default, fs.OpenParenToken); 1803Assert.NotEqual(default, fs.FirstSemicolonToken); 1808Assert.NotEqual(default, fs.SecondSemicolonToken); 1810Assert.NotEqual(default, fs.CloseParenToken); 1826Assert.NotEqual(default, fs.ForKeyword); 1829Assert.NotEqual(default, fs.OpenParenToken); 1833Assert.NotEqual(default, fs.FirstSemicolonToken); 1835Assert.NotEqual(default, fs.SecondSemicolonToken); 1840Assert.NotEqual(default, fs.CloseParenToken); 1856Assert.NotEqual(default, fs.ForKeyword); 1859Assert.NotEqual(default, fs.OpenParenToken); 1863Assert.NotEqual(default, fs.FirstSemicolonToken); 1865Assert.NotEqual(default, fs.SecondSemicolonToken); 1871Assert.NotEqual(default, fs.CloseParenToken); 1887Assert.NotEqual(default, fs.ForKeyword); 1890Assert.NotEqual(default, fs.OpenParenToken); 1896Assert.NotEqual(default, fs.Declaration.Variables[0].Identifier); 1899Assert.NotEqual(default, fs.Declaration.Variables[0].Initializer.EqualsToken); 1905Assert.NotEqual(default, fs.FirstSemicolonToken); 1909Assert.NotEqual(default, fs.SecondSemicolonToken); 1914Assert.NotEqual(default, fs.CloseParenToken); 1930Assert.NotEqual(default, fs.ForEachKeyword); 1933Assert.NotEqual(default, fs.OpenParenToken); 1936Assert.NotEqual(default, fs.Identifier); 1938Assert.NotEqual(default, fs.InKeyword); 1943Assert.NotEqual(default, fs.CloseParenToken); 1959Assert.NotEqual(default, fs.ForEachKeyword); 1966Assert.NotEqual(default, fs.OpenParenToken); 1969Assert.NotEqual(default, fs.Identifier); 1971Assert.NotEqual(default, fs.InKeyword); 1976Assert.NotEqual(default, fs.CloseParenToken); 1992Assert.NotEqual(default, fs.ForEachKeyword); 1995Assert.NotEqual(default, fs.OpenParenToken); 2000Assert.NotEqual(default, fs.Identifier); 2002Assert.NotEqual(default, fs.InKeyword); 2007Assert.NotEqual(default, fs.CloseParenToken); 2023Assert.NotEqual(default, ss.IfKeyword); 2025Assert.NotEqual(default, ss.OpenParenToken); 2028Assert.NotEqual(default, ss.CloseParenToken); 2046Assert.NotEqual(default, ss.IfKeyword); 2048Assert.NotEqual(default, ss.OpenParenToken); 2051Assert.NotEqual(default, ss.CloseParenToken); 2055Assert.NotEqual(default, ss.Else.ElseKeyword); 2072Assert.NotEqual(default, ss.IfKeyword); 2074Assert.NotEqual(default, ss.OpenParenToken); 2077Assert.NotEqual(default, ss.CloseParenToken); 2081Assert.NotEqual(default, ss.Else.ElseKeyword); 2086Assert.NotEqual(default, subIf.IfKeyword); 2090Assert.NotEqual(default, subIf.CloseParenToken); 2106Assert.NotEqual(default, ls.LockKeyword); 2108Assert.NotEqual(default, ls.OpenParenToken); 2111Assert.NotEqual(default, ls.CloseParenToken); 2129Assert.NotEqual(default, ss.SwitchKeyword); 2131Assert.NotEqual(default, ss.OpenParenToken); 2134Assert.NotEqual(default, ss.CloseParenToken); 2135Assert.NotEqual(default, ss.OpenBraceToken); 2137Assert.NotEqual(default, ss.CloseBraceToken); 2152Assert.NotEqual(default, ss.SwitchKeyword); 2154Assert.NotEqual(default, ss.OpenParenToken); 2157Assert.NotEqual(default, ss.CloseParenToken); 2158Assert.NotEqual(default, ss.OpenBraceToken); 2162Assert.NotEqual(default, ss.Sections[0].Labels[0].Keyword); 2168Assert.NotEqual(default, caseLabelSyntax.ColonToken); 2172Assert.NotEqual(default, ss.CloseBraceToken); 2187Assert.NotEqual(default, ss.SwitchKeyword); 2189Assert.NotEqual(default, ss.OpenParenToken); 2192Assert.NotEqual(default, ss.CloseParenToken); 2193Assert.NotEqual(default, ss.OpenBraceToken); 2198Assert.NotEqual(default, ss.Sections[0].Labels[0].Keyword); 2204Assert.NotEqual(default, caseLabelSyntax.ColonToken); 2209Assert.NotEqual(default, ss.Sections[1].Labels[0].Keyword); 2215Assert.NotEqual(default, caseLabelSyntax2.ColonToken); 2219Assert.NotEqual(default, ss.CloseBraceToken); 2234Assert.NotEqual(default, ss.SwitchKeyword); 2236Assert.NotEqual(default, ss.OpenParenToken); 2239Assert.NotEqual(default, ss.CloseParenToken); 2240Assert.NotEqual(default, ss.OpenBraceToken); 2245Assert.NotEqual(default, ss.Sections[0].Labels[0].Keyword); 2248Assert.NotEqual(default, ss.Sections[0].Labels[0].ColonToken); 2252Assert.NotEqual(default, ss.CloseBraceToken); 2267Assert.NotEqual(default, ss.SwitchKeyword); 2269Assert.NotEqual(default, ss.OpenParenToken); 2272Assert.NotEqual(default, ss.CloseParenToken); 2273Assert.NotEqual(default, ss.OpenBraceToken); 2278Assert.NotEqual(default, ss.Sections[0].Labels[0].Keyword); 2284Assert.NotEqual(default, ss.Sections[0].Labels[1].Keyword); 2290Assert.NotEqual(default, ss.Sections[0].Labels[0].ColonToken); 2294Assert.NotEqual(default, ss.CloseBraceToken); 2309Assert.NotEqual(default, ss.SwitchKeyword); 2311Assert.NotEqual(default, ss.OpenParenToken); 2314Assert.NotEqual(default, ss.CloseParenToken); 2315Assert.NotEqual(default, ss.OpenBraceToken); 2320Assert.NotEqual(default, ss.Sections[0].Labels[0].Keyword); 2330Assert.NotEqual(default, ss.CloseBraceToken); 2345Assert.NotEqual(default, us.UsingKeyword); 2347Assert.NotEqual(default, us.OpenParenToken); 2351Assert.NotEqual(default, us.CloseParenToken); 2367Assert.NotEqual(default, us.UsingKeyword); 2369Assert.NotEqual(default, us.OpenParenToken); 2375Assert.NotEqual(default, us.Declaration.Variables[0].Identifier); 2379Assert.NotEqual(default, us.Declaration.Variables[0].Initializer.EqualsToken); 2385Assert.NotEqual(default, us.CloseParenToken); 2401Assert.NotEqual(default, us.UsingKeyword); 2408Assert.NotEqual(default, us.Declaration.Variables[0].Identifier); 2412Assert.NotEqual(default, us.Declaration.Variables[0].Initializer.EqualsToken); 2415Assert.NotEqual(default, us.SemicolonToken); 2460Assert.NotEqual(default, us.UsingKeyword); 2462Assert.NotEqual(default, us.OpenParenToken); 2470Assert.NotEqual(default, us.Declaration.Variables[0].Identifier); 2474Assert.NotEqual(default, us.Declaration.Variables[0].Initializer.EqualsToken); 2480Assert.NotEqual(default, us.CloseParenToken); 2496Assert.NotEqual(default, us.UsingKeyword); 2505Assert.NotEqual(default, us.Declaration.Variables[0].Identifier); 2509Assert.NotEqual(default, us.Declaration.Variables[0].Initializer.EqualsToken); 2628Assert.NotEqual(default, us.AwaitKeyword); 2630Assert.NotEqual(default, us.UsingKeyword); 2639Assert.NotEqual(default, us.Declaration.Variables[0].Identifier); 2643Assert.NotEqual(default, us.Declaration.Variables[0].Initializer.EqualsToken); 2800Assert.NotEqual(default, us.UsingKeyword); 2802Assert.NotEqual(default, us.OpenParenToken); 2810Assert.NotEqual(default, us.Declaration.Variables[0].Identifier); 2814Assert.NotEqual(default, us.Declaration.Variables[0].Initializer.EqualsToken); 2818Assert.NotEqual(default, us.Declaration.Variables[1].Identifier); 2822Assert.NotEqual(default, us.Declaration.Variables[1].Initializer.EqualsToken); 2828Assert.NotEqual(default, us.CloseParenToken); 2844Assert.NotEqual(default, us.UsingKeyword); 2853Assert.NotEqual(default, us.Declaration.Variables[0].Identifier); 2857Assert.NotEqual(default, us.Declaration.Variables[0].Initializer.EqualsToken); 2861Assert.NotEqual(default, us.Declaration.Variables[1].Identifier); 2865Assert.NotEqual(default, us.Declaration.Variables[1].Initializer.EqualsToken); 2925Assert.NotEqual(default, us.UsingKeyword); 2927Assert.NotEqual(default, us.OpenParenToken); 2931Assert.NotEqual(default, us.CloseParenToken); 2947Assert.NotEqual(default, us.UsingKeyword); 3008Assert.NotEqual(default, us.UsingKeyword); 3010Assert.NotEqual(default, us.OpenParenToken); 3014Assert.NotEqual(default, us.CloseParenToken); 3030Assert.NotEqual(default, us.UsingKeyword); 3080Assert.NotEqual(default, us.UsingKeyword); 3082Assert.NotEqual(default, us.OpenParenToken); 3086Assert.NotEqual(default, us.CloseParenToken); 3102Assert.NotEqual(default, us.UsingKeyword); 3378Assert.NotEqual(default, fs.ForEachKeyword); 3381Assert.NotEqual(default, fs.OpenParenToken); 3384Assert.NotEqual(default, fs.Identifier); 3386Assert.NotEqual(default, fs.InKeyword); 3391Assert.NotEqual(default, fs.CloseParenToken);
Syntax\GreenNodeTests.cs (1)
20Assert.NotEqual(node, nodeWithDiags);
Syntax\StructuredTriviaTests.cs (1)
66Assert.NotEqual(default(SyntaxTrivia), sTrivia);
Syntax\SyntaxNodeTests.cs (24)
819Assert.NotEqual(tree1.GetCompilationUnitRoot(), tree2.GetCompilationUnitRoot()); 828Assert.NotEqual(tree1.GetCompilationUnitRoot(), tree2.GetCompilationUnitRoot()); 837Assert.NotEqual(tree1.GetCompilationUnitRoot(), tree2.GetCompilationUnitRoot()); 850Assert.NotEqual(m1, m2); 1370Assert.NotEqual(SyntaxKind.None, parentTrivia.Kind()); 1384Assert.NotEqual(def, structure); // these should not be identity equals 1904Assert.NotEqual(list[0], list[1]); 1922Assert.NotEqual(sizes[0], sizes[1]); 1923Assert.NotEqual(sizes[0], sizes[2]); 1924Assert.NotEqual(sizes[0], sizes[3]); 1925Assert.NotEqual(sizes[1], sizes[2]); 1926Assert.NotEqual(sizes[1], sizes[3]); 1927Assert.NotEqual(sizes[2], sizes[3]); 1929Assert.NotEqual(sizes.GetSeparator(0), sizes.GetSeparator(1)); 1930Assert.NotEqual(sizes.GetSeparator(0), sizes.GetSeparator(2)); 1931Assert.NotEqual(sizes.GetSeparator(1), sizes.GetSeparator(2)); 1966Assert.NotEqual(str0, str1); 2003Assert.NotEqual(str0, str1); 3486Assert.NotEqual(0, paramList.Width); 3487Assert.NotEqual(0, paramList.FullWidth); 3604Assert.NotEqual(emptyTokenList[0].TrailingTrivia[0], emptyTokenList[1].TrailingTrivia[0]); 3607Assert.NotEqual(emptyTokenList[0].TrailingTrivia, emptyTokenList[1].TrailingTrivia); 3614Assert.NotEqual(emptyToken.LeadingTrivia[0], emptyToken.TrailingTrivia[0]); 3617Assert.NotEqual(emptyToken.LeadingTrivia, emptyToken.TrailingTrivia);
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);
Microsoft.CodeAnalysis.CSharp.Test.Utilities (1)
CompilationTestUtils.cs (1)
474Assert.NotEqual(CodeAnalysis.NullableFlowState.None, typeInfo.Nullability.FlowState);
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (16)
Emit\CompilationOutputsTests.cs (2)
97Assert.NotEqual(0, currentPEStream!.Length); 114Assert.NotEqual(Guid.Empty, outputs.ReadAssemblyModuleVersionId());
FindSymbols\SymbolTreeInfoTests.cs (4)
33Assert.NotEqual(info1.Checksum, info2.Checksum); 56Assert.NotEqual(info1.Checksum, info2.Checksum); 78Assert.NotEqual(info1.Checksum, info2.Checksum); 100Assert.NotEqual(info1.Checksum, info2.Checksum);
SymbolFinder\SymbolFinderTests.cs (9)
87Assert.NotEqual(baseClassSymbol, derivedClassSymbol.BaseType); 128Assert.NotEqual(baseClassSymbol, derivedClassSymbol.Interfaces[0]); 179Assert.NotEqual(baseClassSymbol, derivedClassSymbol.BaseType); 220Assert.NotEqual(baseClassSymbol, derivedClassSymbol.BaseType); 262Assert.NotEqual(baseClassSymbol, derivedClassSymbol.BaseType); 304Assert.NotEqual(baseClassSymbol, derivedClassSymbol.BaseType); 345Assert.NotEqual(baseInterfaceSymbol, Assert.Single(implementingClassSymbol.Interfaces)); 386Assert.NotEqual(baseInterfaceSymbol, Assert.Single(implementingClassSymbol.Interfaces)); 426Assert.NotEqual(baseInterfaceSymbol, Assert.Single(implementingClassSymbol.Interfaces));
Utilities\SymbolEquivalenceComparerTests.cs (1)
1836Assert.NotEqual(SymbolEquivalenceComparer.Instance.GetHashCode(namespace1),
Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver.UnitTests (1)
VisualBasicParsingTests.cs (1)
31Assert.NotEqual(SyntaxKind.None, kind);
Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (1)
ResultProviderTestBase.cs (1)
497Assert.NotEqual(UnspecifiedValue, actualSuccess.Value);
Microsoft.CodeAnalysis.Features.UnitTests (3)
EditAndContinue\EditAndContinueWorkspaceServiceTests.cs (3)
5397Assert.NotEqual(default, genId); 5425Assert.NotEqual(default, genId1); 5432Assert.NotEqual(default, genId2);
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (28)
CodeLens\AbstractCodeLensTests.cs (1)
91Assert.All(actualCodeLenses, actualCodeLens => Assert.NotEqual(CodeLensHandler.RunTestsCommandIdentifier, actualCodeLens.Command?.CommandIdentifier));
Diagnostics\PullDiagnosticTests.cs (9)
543Assert.NotEqual(originalResultId, results.Single().ResultId); 1580Assert.NotEqual(results[1].ResultId, results2[1].ResultId); 1582Assert.NotEqual(results[2].ResultId, results2[2].ResultId); 1683Assert.NotEqual(previousResultIds[0].resultId, results[0].ResultId); 1687Assert.NotEqual(previousResultIds[2].resultId, results[1].ResultId); 1771Assert.NotEqual(previousResultIds[0].resultId, results[0].ResultId); 1775Assert.NotEqual(previousResultIds[2].resultId, results[1].ResultId); 1779Assert.NotEqual(previousResultIds[4].resultId, results[2].ResultId); 1840Assert.NotEqual(previousResultIds[2].resultId, results[0].ResultId);
DocumentChanges\DocumentChangesTests.cs (1)
233Assert.NotEqual("""
Ordering\RequestOrderingTests.cs (2)
202Assert.NotEqual(expectedSolution, solution); 228Assert.NotEqual(expectedSolution, solution);
References\FindAllReferencesHandlerTests.cs (1)
416Assert.NotEqual(definitionId, referenceItems[i].Id);
SpellCheck\SpellCheckTests.cs (1)
534Assert.NotEqual(results[0].ResultId, results2[0].ResultId);
UriTests.cs (3)
112Assert.NotEqual(testLspServer.GetManager().GetTestAccessor().GetLspMiscellaneousFilesWorkspace(), workspace); 121Assert.NotEqual(expectedDocumentUri.GetRequiredParsedUri().AbsolutePath, lowercaseUri.GetRequiredParsedUri().AbsolutePath); 123Assert.NotEqual(testLspServer.GetManager().GetTestAccessor().GetLspMiscellaneousFilesWorkspace(), workspace);
Workspaces\LspWorkspaceManagerTests.cs (8)
96Assert.NotEqual(firstDocumentInitialVersion, await firstDocumentWithChange.GetSyntaxVersionAsync(CancellationToken.None)); 142Assert.NotEqual(testLspServer.TestWorkspace.CurrentSolution.GetDocument(secondDocument.Id), secondDocument); 188Assert.NotEqual(testLspServer.TestWorkspace.CurrentSolution, openedDocument!.Project.Solution); 208Assert.NotEqual(testLspServer.TestWorkspace.CurrentSolution, openedDocument.Project.Solution); 404Assert.NotEqual(firstDocumentText, changedFirstDocumentText); 459Assert.NotEqual(secondDocument, secondDocumentChangedProject); 481Assert.NotEqual(testLspServerOne.GetManager(), testLspServerTwo.GetManager()); 568Assert.NotEqual(
Workspaces\SourceGeneratedDocumentTests.cs (2)
182Assert.NotEqual(text.ResultId, secondRequest.ResultId); 222Assert.NotEqual(text.ResultId, secondRequest.ResultId);
Microsoft.CodeAnalysis.Rebuild.UnitTests (2)
DeterministicKeyBuilderTests.cs (1)
359Assert.NotEqual(key, compilation.GetDeterministicKey());
RoundTripUtil.cs (1)
174Assert.NotEqual(originalMdv, rebuildMdv);
Microsoft.CodeAnalysis.Remote.ServiceHub.UnitTests (1)
RemoteAnalyzerAssemblyLoaderTests.cs (1)
41Assert.NotEqual(alc1, alc2);
Microsoft.CodeAnalysis.Scripting.Desktop.UnitTests (2)
MetadataShadowCopyProviderTests.cs (2)
91Assert.NotEqual(dll.Path, sc1.PrimaryModule.FullPath); 127Assert.NotEqual(dll.Path, sc1.PrimaryModule.FullPath);
Microsoft.CodeAnalysis.Test.Utilities (20)
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)
742Assert.NotEqual(OperationKind.VariableDeclaration, operation.Resources.Kind); 743Assert.NotEqual(OperationKind.VariableDeclarator, operation.Resources.Kind);
Compilation\TestOperationVisitor.cs (3)
411Assert.NotEqual(OperationKind.YieldReturn, operation.Kind); 466Assert.NotEqual(OperationKind.VariableDeclaration, operation.Resources.Kind); 467Assert.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);
Microsoft.CodeAnalysis.UnitTests (45)
AnalyzerAssemblyLoaderTests.cs (1)
1447Assert.NotEqual(INVALID_FILE_ATTRIBUTES, result);
Analyzers\AnalyzerConfigTests.cs (2)
1240Assert.NotEqual(default, options[i]); 1261Assert.NotEqual(default, options[i]);
Collections\ImmutableSegmentedListTest.cs (1)
120Assert.NotEqual(ImmutableSegmentedList.Create<int>().GetHashCode(), ImmutableSegmentedList.Create(5).GetHashCode());
Collections\List\IList.Generic.Tests.cs (2)
210Assert.NotEqual(default(T), list[0]); 245Assert.NotEqual(default(T), list[lastIndex]);
Collections\List\SegmentedList.Generic.Tests.Misc.cs (1)
727Assert.NotEqual(((object?)arr[0]), list[0]); //"Should NOT be equal."
Collections\SegmentedArrayTests.cs (1)
200Assert.NotEqual(Guid.Empty, data[i]);
Collections\SegmentedCollectionsMarshalTests.cs (4)
166Assert.NotEqual(dict[1].Value, itemRef.Value); 167Assert.NotEqual(dict[1].Property, itemRef.Property); 398Assert.NotEqual(dict[1].Value, itemRef.Value); 399Assert.NotEqual(dict[1].Property, itemRef.Property);
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));
ShadowCopyAnalyzerPathResolverTests.cs (1)
95Assert.NotEqual(group1ShadowPath, group2ShadowPath);
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);
Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (5)
CommandLineTests.vb (2)
7377Assert.NotEqual(0, exitCode) 9049Assert.NotEqual(0, exitCode)
SarifErrorLoggerTests.vb (3)
102Assert.NotEqual(0, exitCode) 144Assert.NotEqual(0, exitCode) 186Assert.NotEqual(0, exitCode)
Microsoft.CodeAnalysis.VisualBasic.Test.Utilities (1)
ParserTestUtilities.vb (1)
341Assert.NotEqual(node.Kind(), SyntaxKind.None)
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (4)
VisualStudioMSBuildWorkspaceTests.cs (4)
409Assert.NotEqual(dversion, dversion1); // new document version 414Assert.NotEqual(latestDV, latestDV1); 423Assert.NotEqual(document1.Project.Version, document2.Project.Version); // project did change, so project versions should be different 430Assert.NotEqual(solution2.Version, solution3.Version); // solution changed, added project.
Microsoft.CodeAnalysis.Workspaces.UnitTests (118)
ChecksumTests.cs (39)
28Assert.NotEqual(checksum1, checksum2); 29Assert.NotEqual(checksum1, checksumA); 30Assert.NotEqual(checksum2, checksumA); 45Assert.NotEqual(checksum1, checksum2); 46Assert.NotEqual(checksum2, checksum3); 47Assert.NotEqual(checksum3, checksum1); 49Assert.NotEqual(checksum1, checksumA); 50Assert.NotEqual(checksum2, checksumA); 51Assert.NotEqual(checksum3, checksumA); 121Assert.NotEqual(checksum1, checksum2); 122Assert.NotEqual(checksum2, checksum3); 123Assert.NotEqual(checksum3, checksum4); 124Assert.NotEqual(checksum4, checksum1); 126Assert.NotEqual(checksum1, checksumA); 127Assert.NotEqual(checksum2, checksumA); 128Assert.NotEqual(checksum3, checksumA); 129Assert.NotEqual(checksum4, checksumA); 150Assert.NotEqual(checksums[i], checksumA); 160Assert.NotEqual(checksum1, checksum2); 161Assert.NotEqual(checksum2, checksum3); 162Assert.NotEqual(checksum3, checksum1); 169Assert.NotEqual(Checksum.Null, Checksum.Create(Array.Empty<string>())); 170Assert.NotEqual(Checksum.Null, Checksum.Create("")); 171Assert.NotEqual(Checksum.Null, Checksum.Create("\0")); 172Assert.NotEqual(Checksum.Null, Checksum.Create((string?)null)); 173Assert.NotEqual(Checksum.Null, Checksum.Create(new MemoryStream())); 174Assert.NotEqual(Checksum.Null, Checksum.Create(stackalloc Checksum[0])); 175Assert.NotEqual(Checksum.Null, Checksum.Create(ImmutableArray<Checksum>.Empty)); 176Assert.NotEqual(Checksum.Null, Checksum.Create(ImmutableArray<byte>.Empty)); 178Assert.NotEqual(Checksum.Null, Checksum.Create([""])); 179Assert.NotEqual(Checksum.Null, Checksum.Create(["\0"])); 180Assert.NotEqual(Checksum.Null, Checksum.Create(new string?[] { null })); 181Assert.NotEqual(Checksum.Null, Checksum.Create(new MemoryStream())); 182Assert.NotEqual(Checksum.Null, Checksum.Create(stackalloc Checksum[] { Checksum.Null })); 183Assert.NotEqual(Checksum.Null, Checksum.Create(ImmutableArray.Create(Checksum.Null))); 184Assert.NotEqual(Checksum.Null, Checksum.Create(ImmutableArray.Create((byte)0))); 185Assert.NotEqual(Checksum.Null, Checksum.Create(Checksum.Null, Checksum.Null)); 186Assert.NotEqual(Checksum.Null, Checksum.Create(Checksum.Null, Checksum.Null, Checksum.Null)); 191Assert.NotEqual(Checksum.Null, Checksum.Create(stream));
FindReferencesTests.cs (2)
585Assert.NotEqual(typeResult.Locations.Single().Location.SourceSpan, constructorResult.Locations.Single().Location.SourceSpan); 620Assert.NotEqual(typeResult.Locations.Single().Location.SourceSpan, constructorResult.Locations.Single().Location.SourceSpan);
Remote\ServiceDescriptorTests.cs (1)
188Assert.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 (46)
446Assert.NotEqual(root1, root2); 465Assert.NotEqual(text1.ToString(), text2.ToString()); 466Assert.NotEqual(version1, version2); 469Assert.NotEqual(root1, root2); 490Assert.NotEqual(root1, root2); 534Assert.NotEqual(root1, root2); 553Assert.NotEqual(text1.ToString(), text2.ToString()); 554Assert.NotEqual(version1, version2); 557Assert.NotEqual(root1, root2); 578Assert.NotEqual(root1, root2); 613Assert.NotEqual(root1, root2); 636Assert.NotEqual(text1.ToString(), text2.ToString()); 637Assert.NotEqual(version1, version2); 640Assert.NotEqual(root1, root2); 664Assert.NotEqual(root1, root2); 699Assert.NotEqual(root1, root2); 719Assert.NotEqual(text1.ToString(), text2.ToString()); 720Assert.NotEqual(version1, version2); 723Assert.NotEqual(root1, root2); 744Assert.NotEqual(root1, root2); 776Assert.NotEqual(root1, root2); 795Assert.NotEqual(text1.ToString(), text2.ToString()); 796Assert.NotEqual(version1, version2); 799Assert.NotEqual(root1, root2); 820Assert.NotEqual(root1, root2); 864Assert.NotEqual(root1.GetType(), root2.GetType()); 882Assert.NotEqual(text1.ToString(), text2.ToString()); 885Assert.NotEqual(version1, version2); 888Assert.NotEqual(root1.GetType(), root2.GetType()); 909Assert.NotEqual(root1.GetType(), root2.GetType()); 3078Assert.NotEqual(oldParseOptions, newUpdatedParseOptions); 3196Assert.NotEqual(solution1, solution2); 4130Assert.NotEqual( 4134Assert.NotEqual( 4155Assert.NotEqual( 4159Assert.NotEqual( 4233Assert.NotEqual( 4241Assert.NotEqual( 4249Assert.NotEqual( 4641Assert.NotEqual(oldVersion, newVersion); 4725Assert.NotEqual(originalCompilation.Options, newCompilation.Options); 4892Assert.NotEqual(originalCompilation.Options, newCompilation.Options); 5765Assert.NotEqual(syntaxTree1, forkedSyntaxTree1); 5768Assert.NotEqual(compilation1, forkedCompilation1); 5806Assert.NotEqual(syntaxTree1, forkedSyntaxTree1); 5810Assert.NotEqual(compilation1, forkedCompilation1);
SolutionTests\SolutionWithSourceGeneratorTests.cs (15)
174Assert.NotEqual(generatedDocuments[0].Id, generatedDocuments[1].Id); 402Assert.NotEqual(generatedDocumentsInFirstProject.Single().Id.Id, generatedDocumentsInSecondProject.Single().Id.Id); 510Assert.NotEqual(DocumentationMode.Diagnose, project.ParseOptions!.DocumentationMode); 956Assert.NotEqual(project0, project1); 957Assert.NotEqual(checksum0, checksum1); 962Assert.NotEqual(project0, project2); 963Assert.NotEqual(project1, project2); 967Assert.NotEqual(checksum1, checksum2); 972Assert.NotEqual(project0, project3); 973Assert.NotEqual(project1, project3); 974Assert.NotEqual(project2, project3); 975Assert.NotEqual(checksum0, checksum3); 976Assert.NotEqual(checksum1, checksum3); 977Assert.NotEqual(checksum2, checksum3); 1064Assert.NotEqual(LanguageVersion.CSharp7, modifiedRoot.SyntaxTree.Options.LanguageVersion());
SolutionTests\SourceGeneratorExecutionVersionMapTests.cs (1)
21Assert.NotEqual(projectId1, projectId2);
SymbolKeyTests.cs (3)
874Assert.NotEqual(default, SymbolKey.Create(xSymbol)); 921Assert.NotEqual(default, SymbolKey.Create(xSymbol)); 1315Assert.NotEqual(symbolKey1.ToString(), symbolKey2.ToString());
SyntaxNodeTests.cs (3)
107Assert.NotEqual(latestMethod, methodDecl); 116Assert.NotEqual(trackedRoot, root2); 125Assert.NotEqual(finalMethodDecl, methodDecl);
UtilityTest\BKTreeTests.cs (3)
64Assert.NotEqual(testValues.Length, items.Length); 77Assert.NotEqual(testValues.Length, items.Length); 91Assert.NotEqual(testValues.Length, items.Length);
WorkspaceServiceTests\GlobalOptionServiceTests.cs (1)
265Assert.NotEqual(optionSet, newOptionSet);
WorkspaceTests\WorkspaceReferenceTests.cs (2)
166Assert.NotEqual(references1, references2); 198Assert.NotEqual(references1, references2);
Microsoft.DotNet.Build.Tasks.Workloads.Tests (1)
MsiTests.cs (1)
58Assert.NotEqual(MsiUtils.GetProperty(msiPath603, MsiProperty.UpgradeCode), MsiUtils.GetProperty(msiPath604, MsiProperty.UpgradeCode));
Microsoft.DotNet.XUnitAssert.Tests (159)
CollectionAssertsTests.cs (20)
1691 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 1707 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 1729 Assert.NotEqual(new object[] { 1, 2, 3 }, new object[] { 1, 2, 3L }); 1843 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 1860 Assert.NotEqual(expected, actual); 1932 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 1949 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 1966 Assert.NotEqual(expected, actual); 1975 Assert.NotEqual(expected, actual); 2000 Assert.NotEqual(expected, actual); 2018 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2044 Assert.NotEqual(expected, actual); 2057 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2074 Assert.NotEqual(expected, actual); 2115 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2156 Assert.NotEqual(expected, actual); 2168 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2190 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2228 Assert.NotEqual(expected, actual); 2238 Assert.NotEqual(expected, actual);
EqualityAssertsTests.cs (138)
2327 var ex = Record.Exception(() => Assert.NotEqual(42, 42)); 2341 Assert.NotEqual(42, 2112); 2545 var ex = Record.Exception(() => Assert.NotEqual(obj1, obj2)); 2562 Assert.NotEqual(obj1, obj2); 2585 assertFailure(() => Assert.NotEqual(expected, actual)); 2586 assertFailure(() => Assert.NotEqual(expected, (IComparable)actual)); 2587 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 2596 Assert.NotEqual(expected, actual); 2597 Assert.NotEqual(expected, (IComparable)actual); 2598 Assert.NotEqual(expected, (object)actual); 2620 assertFailure(() => Assert.NotEqual(expected, (IComparable)actual)); 2621 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 2630 Assert.NotEqual(expected, (IComparable)actual); 2631 Assert.NotEqual(expected, (object)actual); 2640 var ex = Record.Exception(() => Assert.NotEqual(obj1, obj2)); 2657 Assert.NotEqual(obj1, obj2); 2667 var ex = Record.Exception(() => Assert.NotEqual<ComparableBaseClass>(expected, actual)); 2684 Assert.NotEqual<ComparableBaseClass>(expected, actual); 2693 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2710 Assert.NotEqual(expected, actual); 2719 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2736 Assert.NotEqual(expected, actual); 2758 assertFailure(() => Assert.NotEqual(expected, actual)); 2759 assertFailure(() => Assert.NotEqual(expected, (IComparable<ComparableThrower>)actual)); 2760 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 2769 Assert.NotEqual(expected, actual); 2770 Assert.NotEqual(expected, (IComparable<ComparableThrower>)actual); 2771 Assert.NotEqual(expected, (object)actual); 2784 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2801 Assert.NotEqual(expected, actual); 2814 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2831 Assert.NotEqual(expected, actual); 2840 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2857 Assert.NotEqual(expected, actual); 2869 var ex = Record.Exception(() => Assert.NotEqual(nco1, nco2)); 2886 Assert.NotEqual(nco1, nco2); 2898 var ex = Record.Exception(() => Assert.NotEqual(obj1, obj2)); 2915 Assert.NotEqual(obj1, obj2); 2927 var ex = Record.Exception(() => Assert.NotEqual<EquatableBaseClass>(expected, actual)); 2944 Assert.NotEqual<EquatableBaseClass>(expected, actual); 2953 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2970 Assert.NotEqual(expected, actual); 2979 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 2996 Assert.NotEqual(expected, actual); 3009 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3026 Assert.NotEqual(expected, actual); 3039 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3056 Assert.NotEqual(expected, actual); 3085 assertFailure(() => Assert.NotEqual(expected, actual)); 3086 assertFailure(() => Assert.NotEqual(expected, (IStructuralEquatable)actual)); 3087 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3096 Assert.NotEqual(expected, actual); 3097 Assert.NotEqual(expected, (IStructuralEquatable)actual); 3098 Assert.NotEqual(expected, (object)actual); 3120 assertFailure(() => Assert.NotEqual(expected, actual)); 3121 assertFailure(() => Assert.NotEqual(expected, (IStructuralEquatable)actual)); 3122 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3131 Assert.NotEqual(expected, actual); 3132 Assert.NotEqual(expected, (IStructuralEquatable)actual); 3133 Assert.NotEqual(expected, (object)actual); 3142 Assert.NotEqual(expected, actual); 3143 Assert.NotEqual(expected, (IStructuralEquatable)actual); 3144 Assert.NotEqual(expected, (object)actual); 3169 assertFailure(() => Assert.NotEqual(expected, (IReadOnlyCollection<string>)actual)); 3170 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3179 Assert.NotEqual(expected, (IReadOnlyCollection<string>)actual); 3180 Assert.NotEqual(expected, (object)actual); 3189 var ex = Record.Exception(() => Assert.NotEqual(x, y)); 3206 Assert.NotEqual(x, y); 3228 assertFailure(() => Assert.NotEqual(expected, actual)); 3229 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3238 Assert.NotEqual(expected, actual); 3239 Assert.NotEqual(expected, (object)actual); 3248 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3267 Assert.NotEqual(expected, actual); 3278 var ex = Record.Exception(() => Assert.NotEqual(expected, (object)actual)); 3298 Assert.NotEqual(expected, actual); 3307 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3324 Assert.NotEqual(expected, actual); 3369 assertFailure(() => Assert.NotEqual(expected, actual)); 3370 assertFailure(() => Assert.NotEqual(expected, (IDictionary)actual)); 3371 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3380 Assert.NotEqual(expected, actual); 3381 Assert.NotEqual(expected, (IDictionary)actual); 3382 Assert.NotEqual(expected, (object)actual); 3404 assertFailure(() => Assert.NotEqual(expected, (IDictionary)actual)); 3405 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3414 Assert.NotEqual(expected, (IDictionary)actual); 3415 Assert.NotEqual(expected, (object)actual); 3424 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3441 Assert.NotEqual(expected, actual); 3453 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3470 Assert.NotEqual(expected, actual); 3479 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3496 Assert.NotEqual(expected, actual); 3518 assertFailure(() => Assert.NotEqual(expected, (ISet<string>)actual)); 3520 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3530 Assert.NotEqual(expected, actual); 3576 assertFailure(() => Assert.NotEqual(expected, actual)); 3577 assertFailure(() => Assert.NotEqual(expected, (ISet<string>)actual)); 3579 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3589 Assert.NotEqual(expected, actual); 3590 Assert.NotEqual(expected, (ISet<string>)actual); 3592 Assert.NotEqual(expected, (object)actual); 3615 assertFailure(() => Assert.NotEqual(expected, actual)); 3616 assertFailure(() => Assert.NotEqual(expected, (ISet<string>)actual)); 3618 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3628 Assert.NotEqual(expected, actual); 3629 Assert.NotEqual(expected, (ISet<string>)actual); 3631 Assert.NotEqual(expected, (object)actual); 3641 Assert.NotEqual(expected, actual); 3642 Assert.NotEqual(expected, (ISet<string>)actual); 3644 Assert.NotEqual(expected, (object)actual); 3667 assertFailure(() => Assert.NotEqual(expected, actual)); 3668 assertFailure(() => Assert.NotEqual(expected, (ISet<string>)actual)); 3670 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3680 Assert.NotEqual(expected, actual); 3681 Assert.NotEqual(expected, (ISet<string>)actual); 3683 Assert.NotEqual(expected, (object)actual); 3706 assertFailure(() => Assert.NotEqual(expected, actual)); 3707 assertFailure(() => Assert.NotEqual(expected, (ISet<string>)actual)); 3709 assertFailure(() => Assert.NotEqual(expected, (object)actual)); 3719 Assert.NotEqual(expected, actual); 3720 Assert.NotEqual(expected, (ISet<string>)actual); 3722 Assert.NotEqual(expected, (object)actual); 3753 var ex = Record.Exception(() => Assert.NotEqual("actual", "actual")); 3767 Assert.NotEqual("foo", "bar"); 3774 () => Assert.NotEqual( 3799 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3817 Assert.NotEqual(expected, actual); 3827 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3845 Assert.NotEqual(expected, actual); 3858 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3875 Assert.NotEqual(expected, actual); 3888 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3905 Assert.NotEqual(expected, actual); 3925 var ex = Record.Exception(() => Assert.NotEqual(expected, actual)); 3942 Assert.NotEqual(expected, actual);
EquivalenceAssertsTests.cs (1)
1547 Assert.NotEqual(assemblyPath, assemblyParentPath);
Microsoft.Extensions.AI.Abstractions.Tests (8)
ChatCompletion\ChatFinishReasonTests.cs (1)
40Assert.NotEqual(new ChatFinishReason("abc").GetHashCode(), new ChatFinishReason("def").GetHashCode()); // not guaranteed due to possible hash code collisions
ChatCompletion\ChatRoleTests.cs (1)
42Assert.NotEqual(new ChatRole("abc").GetHashCode(), new ChatRole("def").GetHashCode()); // not guaranteed
ChatCompletion\ChatToolModeTests.cs (2)
49Assert.NotEqual(new RequiredChatToolMode("func1").GetHashCode(), new RequiredChatToolMode("func2").GetHashCode()); // technically not guaranteed 52Assert.NotEqual(new RequiredChatToolMode("func1").GetHashCode(), new RequiredChatToolMode("FUNC1").GetHashCode()); // technically not guaranteed
Utilities\AIJsonUtilitiesTests.cs (4)
138Assert.NotEqual(x, y); 139Assert.NotEqual(y, x); 1023Assert.NotEqual(key1, key3); 1024Assert.NotEqual(key1, key5);
Microsoft.Extensions.AI.Evaluation.NLP.Tests (2)
NGramTests.cs (1)
36Assert.NotEqual(a.GetHashCode(), c.GetHashCode());
RationalNumberTests.cs (1)
53Assert.NotEqual(a.GetHashCode(), c.GetHashCode());
Microsoft.Extensions.AI.Evaluation.Reporting.Tests (1)
ScenarioRunResultTests.cs (1)
220Assert.NotEqual(defaultJson, compactJson);
Microsoft.Extensions.AI.Integration.Tests (6)
ChatClientIntegrationTests.cs (5)
644Assert.NotEqual(firstResponse.Text, secondResponse.Text); 669Assert.NotEqual(firstResponse.Messages, thirdResponse.Messages); 708Assert.NotEqual(orig.ToString(), third.ToString()); 949Assert.NotEqual(0, (int)activity.GetTagItem("gen_ai.usage.input_tokens")!); 950Assert.NotEqual(0, (int)activity.GetTagItem("gen_ai.usage.output_tokens")!);
EmbeddingGeneratorIntegrationTests.cs (1)
131Assert.NotEqual(0, (int)activity.GetTagItem("gen_ai.usage.input_tokens")!);
Microsoft.Extensions.AI.Tests (3)
Functions\AIFunctionFactoryTest.cs (3)
850Assert.NotEqual(new StructWithDefaultCtor().Value, default(StructWithDefaultCtor).Value); 861Assert.NotEqual(new StructWithDefaultCtor().Value, default(StructWithDefaultCtor).Value); 894Assert.NotEqual(new StructWithDefaultCtor().Value, default(StructWithDefaultCtor).Value);
Microsoft.Extensions.Caching.Hybrid.Tests (13)
DistributedCacheTests.cs (2)
344Assert.NotEqual(0, segment.Offset); 347Assert.NotEqual(size, segment.Array.Length);
ExpirationTests.cs (1)
50Assert.NotEqual(guid0, await cache.GetOrCreateAsync(key, callback, options));
L2Tests.cs (2)
95Assert.NotEqual(s, t); 153Assert.NotEqual(s.Value, t.Value);
LocalInvalidationTests.cs (3)
40Assert.NotEqual(value, newValue); 102Assert.NotEqual(value, newValue); 114Assert.NotEqual(value, newValue);
SizeTests.cs (2)
81Assert.NotEqual(expected, actual); 140Assert.NotEqual(expected, actual.Value);
StampedeTests.cs (1)
157Assert.NotEqual(first, second);
UnreliableL2Tests.cs (2)
96Assert.NotEqual(x, a); 97Assert.NotEqual(y, b);
Microsoft.Extensions.Compliance.Abstractions.Tests (4)
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());
Microsoft.Extensions.Compliance.Redaction.Tests (2)
ErasingRedactorTests.cs (1)
48Assert.NotEqual(input, bufferString);
HmacRedactorTest.cs (1)
45Assert.NotEqual(0, length);
Microsoft.Extensions.Compliance.Testing.Tests (2)
RedactionFakesEventCollectorTests.cs (2)
48Assert.NotEqual(first.GetHashCode(), third.GetHashCode()); 68Assert.NotEqual(first.GetHashCode(), third.GetHashCode());
Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (3)
ByteArrayEqualityComparerTests.cs (1)
63Assert.NotEqual(_comparer.GetHashCode(x), _comparer.GetHashCode(y));
Linux\AcceptanceTest.cs (2)
37Assert.NotEqual(default, provider.Resources); 38Assert.NotEqual(default, provider.GetSnapshot());
Microsoft.Extensions.FileProviders.Embedded.Tests (4)
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);
Microsoft.Extensions.Telemetry.Tests (2)
Logging\LoggerEnrichmentOptionsTests.cs (2)
42Assert.NotEqual(ValidateOptionsResult.Success, v.Validate(null, o)); 45Assert.NotEqual(ValidateOptionsResult.Success, v.Validate(null, o));
Microsoft.Gen.ContextualOptions.Unit.Tests (1)
SyntaxContextReceiverTests.cs (1)
76Assert.NotEqual(declaration.Value[0], declaration.Value[1]);
Microsoft.Gen.Logging.Generated.Tests (21)
LogMethodTests.cs (12)
235Assert.NotEqual(0, collector.LatestRecord.Id.Id); 243Assert.NotEqual(0, collector.LatestRecord.Id.Id); 251Assert.NotEqual(0, collector.LatestRecord.Id.Id); 259Assert.NotEqual(0, collector.LatestRecord.Id.Id); 267Assert.NotEqual(0, collector.LatestRecord.Id.Id); 275Assert.NotEqual(0, collector.LatestRecord.Id.Id); 286Assert.NotEqual(0, logRecord.Id.Id); 340Assert.NotEqual(0, collector.LatestRecord.Id.Id); 348Assert.NotEqual(0, collector.LatestRecord.Id.Id); 579Assert.NotEqual(0, logRecord.Id.Id); 594Assert.NotEqual(0, firstEventId.Id); 610Assert.NotEqual(thirdEventId.Id, secondEventId.Id); // Different EventName means different generated EventId
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);
Microsoft.JSInterop.Tests (1)
JSRuntimeTest.cs (1)
35Assert.NotEqual(runtime.BeginInvokeCalls[0].AsyncHandle, call.AsyncHandle);
Microsoft.ML.AutoML.Tests (5)
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());
Microsoft.ML.Core.Tests (2)
UnitTests\TestCustomTypeRegister.cs (1)
312Assert.NotEqual(a, DataViewTypeManager.GetDataViewType(typeof(AlienBody), new[] { f }));
UnitTests\TestEntryPoints.cs (1)
4552Assert.NotEqual(0, feat.GetValues()[0]);
Microsoft.ML.IntegrationTests (2)
Debugging.cs (1)
154Assert.NotEqual(0, rowSum);
Training.cs (1)
162Assert.NotEqual(firstModelWeights, secondModelWeights);
Microsoft.ML.Predictor.Tests (1)
TestTransposer.cs (1)
31Assert.NotEqual(0, vecType?.Size);
Microsoft.ML.Tests (16)
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]);
Microsoft.ML.Tokenizers.Tests (16)
CodeGenTests.cs (16)
618Assert.NotEqual(codeGenTokenizer.BeginningOfSentenceId.Value, ids[0]); 620Assert.NotEqual(codeGenTokenizer.BeginningOfSentenceId.Value, ids[0]); 725Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 730Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 735Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 740Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 751Assert.NotEqual(codeGenTokenizer.EndOfSentenceId.Value, ids[ids.Count - 1]); 753Assert.NotEqual(codeGenTokenizer.EndOfSentenceId.Value, ids[ids.Count - 1]); 869Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 875Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 881Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 887Assert.NotEqual(new Range(text.Length, text.Length), encoding[encoding.Count - 1].Offset); 902Assert.NotEqual(codeGenTokenizer.BeginningOfSentenceId.Value, ids[0]); 903Assert.NotEqual(codeGenTokenizer.EndOfSentenceId.Value, ids[ids.Count - 1]); 905Assert.NotEqual(codeGenTokenizer.BeginningOfSentenceId.Value, ids[0]); 906Assert.NotEqual(codeGenTokenizer.EndOfSentenceId.Value, ids[ids.Count - 1]);
Microsoft.Net.Http.Headers.Tests (33)
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());
Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (6)
Options\OptionViewModelTests.cs (2)
65Assert.NotEqual(modifiedPreview, originalPreview); 98Assert.NotEqual(optionStore.GetOption(CSharpFormattingOptions2.SpacingAfterMethodDeclarationName), initial);
PersistentStorage\AbstractPersistentStorageTests.cs (3)
70Assert.NotEqual(s_checksum1, s_checksum2); 1018Assert.NotEqual(NoOpPersistentStorage.TestAccessor.GetStorageInstance(SolutionKey.ToSolutionKey(solution)), storage); 1036Assert.NotEqual(NoOpPersistentStorage.TestAccessor.GetStorageInstance(solutionKey), storage);
ProjectSystemShim\CPS\SourceFileHandlingTests.cs (1)
101Assert.NotEqual(oldVersion, newVersion);
Roslyn.Test.PdbUtilities (3)
Reader\PdbValidation.cs (3)
133Assert.NotEqual(default(DebugInformationFormat), format); 134Assert.NotEqual(DebugInformationFormat.Embedded, format); 238Assert.NotEqual(DebugInformationFormat.Embedded, format);
Roslyn.VisualStudio.Next.UnitTests (5)
Remote\SnapshotSerializationTests.cs (3)
540Assert.NotEqual(source, metadata); 541Assert.NotEqual(source, analyzer); 542Assert.NotEqual(metadata, analyzer);
Services\ServiceHubServicesTests.cs (2)
1567Assert.NotEqual(initialExecutionMap[projectId1], finalExecutionMap[projectId1]); 1568Assert.NotEqual(initialExecutionMap[noCompilationProject.Id], finalExecutionMap[noCompilationProject.Id]);
Shared.Tests (4)
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());
Sockets.FunctionalTests (1)
src\Servers\Kestrel\test\FunctionalTests\ResponseTests.cs (1)
1130Assert.NotEqual(0, received);
System.ServiceModel.Primitives.Tests (9)
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)
123Assert.NotEqual(string.Empty, exception.Reason.ToString()); 173Assert.NotEqual(string.Empty, exception.Reason.ToString());
System.Xaml.Tests (11)
System\Xaml\XamlMemberTests.cs (9)
63Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 87Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 119Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 143Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 178Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 203Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 265Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 288Assert.NotEqual(XamlMemberInvoker.UnknownInvoker, member.Invoker); 713Assert.NotEqual(invoker, member.LookupInvokerEntry());
System\Xaml\XamlTypeTests.cs (2)
96Assert.NotEqual(XamlTypeInvoker.UnknownInvoker, type.Invoker); 119Assert.NotEqual(XamlTypeInvoker.UnknownInvoker, type.Invoker);
Templates.Blazor.WebAssembly.Auth.Tests (1)
src\Shared\E2ETesting\WaitAssert.cs (1)
30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));
Templates.Blazor.WebAssembly.Tests (1)
src\Shared\E2ETesting\WaitAssert.cs (1)
30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));
Templates.Mvc.Tests (1)
src\Shared\E2ETesting\WaitAssert.cs (1)
30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));
Templates.Tests (1)
src\Shared\E2ETesting\WaitAssert.cs (1)
30=> WaitAssertCore(driver, () => Assert.NotEqual(expected, actual()));
VBCSCompiler.UnitTests (1)
CompilerServerTests.cs (1)
454Assert.NotEqual(ProcessorArchitecture.X86,
WindowsBase.Tests (29)
System\Security\RightsManagement\LocalizedNameDescriptionPairTests.cs (1)
52Assert.NotEqual(0, pair.GetHashCode());
System\Security\RightsManagement\UnsignedPublishLicenseTests.cs (1)
12Assert.NotEqual(Guid.Empty, license.ContentId);
System\Windows\AttachedPropertyBrowsableForTypeAttributeTests.cs (1)
52Assert.NotEqual(0, attribute.GetHashCode());
System\Windows\AttachedPropertyBrowsableWhenAttributePresentAttributeTests.cs (1)
51Assert.NotEqual(0, attribute.GetHashCode());
System\Windows\DependencyObjectTests.cs (1)
1257Assert.NotEqual(0, obj.GetHashCode());
System\Windows\DependencyObjectTypeTests.cs (1)
38Assert.NotEqual(type1.Id, type2.Id);
System\Windows\DependencyPropertyChangedEventArgsTests.cs (1)
94Assert.NotEqual(0, args.GetHashCode());
System\Windows\DependencyPropertyTests.cs (4)
210Assert.NotEqual(property1.GlobalIndex, property2.GlobalIndex); 523Assert.NotEqual(property1.GlobalIndex, property2.GlobalIndex); 809Assert.NotEqual(property1.GlobalIndex, property2.GlobalIndex); 1104Assert.NotEqual(property1.GlobalIndex, property2.GlobalIndex);
System\Windows\Int32RectTests.cs (1)
280Assert.NotEqual(0, rect.GetHashCode());
System\Windows\LocalValueEntryTests.cs (2)
96Assert.NotEqual(0, entry.GetHashCode()); 111Assert.NotEqual(0, entry.GetHashCode());
System\Windows\LocalValueEnumeratorTests.cs (2)
229Assert.NotEqual(0, enumerator.GetHashCode()); 241Assert.NotEqual(0, enumerator.GetHashCode());
System\Windows\Markup\Primitives\MarkupObjectTests.cs (1)
129Assert.NotEqual(0, properties[0].Value);
System\Windows\Markup\Primitives\MarkupPropertyTests.cs (1)
116Assert.NotEqual(0, properties[0].Value);
System\Windows\Media\MatrixTests.cs (1)
1174Assert.NotEqual(0, matrix.GetHashCode());
System\Windows\PointTests.cs (1)
267Assert.NotEqual(0, point.GetHashCode());
System\Windows\PropertyMetadataTests.cs (6)
341Assert.NotEqual(propertyChangedCallback1, metadata.PropertyChangedCallback); 342Assert.NotEqual(propertyChangedCallback2, metadata.PropertyChangedCallback); 411Assert.NotEqual(baseMetadata.PropertyChangedCallback, metadata.PropertyChangedCallback); 431Assert.NotEqual(baseMetadata.PropertyChangedCallback, metadata.PropertyChangedCallback); 467Assert.NotEqual(baseMetadata.CoerceValueCallback, metadata.CoerceValueCallback); 487Assert.NotEqual(baseMetadata.CoerceValueCallback, metadata.CoerceValueCallback);
System\Windows\RectTests.cs (1)
1709Assert.NotEqual(0, rect.GetHashCode());
System\Windows\SizeTests.cs (1)
310Assert.NotEqual(0, size.GetHashCode());
System\Windows\VectorTests.cs (1)
292Assert.NotEqual(0, vector.GetHashCode());
xunit.assert (2)
EqualityAsserts.cs (2)
588 NotEqual<object>(expected, actual); 592 NotEqual<object>(expected, actual);