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

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);

86Assert.NotEqual(sessionId1, sessionId2);

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

49Assert.NotEqual(id2, id1);

49Assert.NotEqual(id2, id1);

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);

1094Assert.NotEqual(0, streamId);

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

635Assert.NotEqual(0, read);

4400Assert.NotEqual(4096, memory.Length); 4499Assert.NotEqual(BodyWriter1, BodyWriter2);

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

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

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

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

664Assert.NotEqual(key, resetKey);

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

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

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

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);

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

553Assert.NotEqual(differentConnectionId, circuitHost.Client.ConnectionId);

275Assert.NotEqual(circuitSecret, result);

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);

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

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

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

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

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

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

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

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

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

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]);

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

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

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

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

123Assert.NotEqual(Activity.Current, activityFeature.Activity); 161Assert.NotEqual(overridenFeature, contextFeature);

177Assert.NotEqual(overridenFeature, contextFeature);

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

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

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

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

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

100Assert.NotEqual(connectionId, connectionToken);

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

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

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

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);

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);

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

38Assert.NotEqual(id1, id2);

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

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

376Assert.NotEqual(expectedPrincipalClaim, actualPrincipalClaim);

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

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));

1061Assert.NotEqual(confirmed, result.IsNotAllowed); 1115Assert.NotEqual(confirmed, result.IsNotAllowed);

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

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

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

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

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

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

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);

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

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

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);

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);

153Assert.NotEqual(shouldNotContainMessage, errorMessage);

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

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

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

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);

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

101Assert.NotEqual<object[]>(helpers1, helpers2); 102Assert.NotEqual<object>(helpers1[0], helpers2[0]);

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

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

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

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

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

299Assert.NotEqual(((OpenApiSchemaReference)requestSchema).Reference.Id, ((OpenApiSchemaReference)responseSchema).Reference.Id);

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

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

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

175Assert.NotEqual("owin.RequestProtocol", key);

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

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

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

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

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

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

684Assert.NotEqual(original, _http1Connection.RequestAborted); 706Assert.NotEqual(original, _http1Connection.RequestAborted); 766Assert.NotEqual(original, _http1Connection.RequestAborted); 784Assert.NotEqual(original, _http1Connection.RequestAborted);

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

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());

507Assert.NotEqual(0, ((IPEndPoint)transportEndPoint.BoundEndPoint).Port); 535Assert.NotEqual(0, ((IPEndPoint)multiplexedTransportEndPoint.BoundEndPoint).Port);

84Assert.NotEqual(bufferLength, writer.Span.Length); 189Assert.NotEqual(bufferLength, writer.Span.Length);

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);

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

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

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

1439Assert.NotEqual(service, service2);

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

377Assert.NotEqual("MSB4068", ex.ErrorCode); 1868Assert.NotEqual(version, projectElement.Version); 1877Assert.NotEqual(childrenCount, projectElement.AllChildren.Count()); 1886Assert.NotEqual(xml, projectElement.RawXml);

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

46Assert.NotEqual(proj1Path, savedPath);

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

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

342Assert.NotEqual(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId); 352Assert.NotEqual(_host.DataReceivedContext.thread.ManagedThreadId, Thread.CurrentThread.ManagedThreadId);

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

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

115Assert.NotEqual(left, right); 116Assert.NotEqual(right, left); 130Assert.NotEqual(left, right); 131Assert.NotEqual(right, left); 144Assert.NotEqual(left, right); 145Assert.NotEqual(right, left); 160Assert.NotEqual(left, right); 161Assert.NotEqual(right, left);

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

1008Assert.NotEqual(FileAttributes.ReadOnly, File.GetAttributes(destination1) & FileAttributes.ReadOnly); 1009Assert.NotEqual(FileAttributes.ReadOnly, File.GetAttributes(destination2) & FileAttributes.ReadOnly);

244Assert.NotEqual(time, state.LastWriteTime); 270Assert.NotEqual(time.ToUniversalTime(), state.LastWriteTimeUtcFast);

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

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

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

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

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

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

541Assert.NotEqual(-1, indexOfEquals);

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

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

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

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);

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);

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

389Assert.NotEqual(currentDocument, document);

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

102Assert.NotEqual(expected, actual);

217Assert.NotEqual(implementation, definition); 246Assert.NotEqual(implementation, definition);

505Assert.NotEqual(TypeKind.Error, classC.TypeKind); 563Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 587Assert.NotEqual(VersionStamp.Default, newVersion); 635Assert.NotEqual(TypeKind.Error, classCy.TypeKind); 1135Assert.NotEqual(oldVersion, await doc.Project.GetSemanticVersionAsync()); 1168Assert.NotEqual(oldVersion, await doc.Project.GetSemanticVersionAsync()); 1479Assert.NotEqual(defaultValue, changedValue); 1525Assert.NotEqual(beforeSolutionForPrimaryWorkspace, primaryWorkspace.CurrentSolution); 1526Assert.NotEqual(beforeSolutionForSecondaryWorkspace, secondaryWorkspace.CurrentSolution);

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

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

27501Assert.NotEqual(type, underlyingType);

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);

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

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);

3762Assert.NotEqual(0, new PEHeaders(stream).CorHeader.EntryPointTokenOrRelativeVirtualAddress); 3804Assert.NotEqual(0, new PEHeaders(stream).CorHeader.EntryPointTokenOrRelativeVirtualAddress);

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

88Assert.NotEqual(tree1, tree0);

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

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

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);

1577Assert.NotEqual(analyzerDiagnostic, compilationDiagnostic); 1578Assert.NotEqual(compilationDiagnostic, analyzerDiagnostic);

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());

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

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);

63Assert.NotEqual(default, ySymbol);

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

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

970Assert.NotEqual(classC, c2);

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);

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

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

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

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);

7409Assert.NotEqual(locationSpecifier, otherLocation); 7411Assert.NotEqual(locationSpecifier.GetHashCode(), otherLocation.GetHashCode());

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

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);

3058Assert.NotEqual(nameofType, typeofType);

269Assert.NotEqual(underlyingType, nativeIntegerType); 270Assert.NotEqual(nativeIntegerType, underlyingType); 605Assert.NotEqual(containsType(fromMember, useNativeInteger: true), fromMember.Equals(fromUnderlyingMember, TypeCompareKind.ConsiderEverything));

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

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

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]);

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);

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

1159Assert.NotEqual(default, symbolInfo);

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

363Assert.NotEqual(refMethod, declMethod); 4959Assert.NotEqual(symbol1, symbol2);

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

72Assert.NotEqual(default, info);

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);

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

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);

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

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);

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

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

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);

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

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);

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

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

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

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

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

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

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);

417Assert.NotEqual(default, info);

3840Assert.NotEqual(implSymbol, defSymbol);

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

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

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

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);

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

5236Assert.NotEqual(defSymbol, implSymbol); 5272Assert.NotEqual(defSymbol, implSymbol); 5319Assert.NotEqual(defSymbol, implSymbol); 5356Assert.NotEqual(defSymbol, implSymbol);

1099Assert.NotEqual(B1, B2); 1225Assert.NotEqual(B1, B2);

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

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

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

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

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

521Assert.NotEqual(locationWithMapping, locationWithoutMapping);

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);

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);

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

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);

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

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);

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);

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

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);

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

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);