396Assert.NotSame(trailersFirst, trailersLast);

624Assert.NotSame(trailersFirst, trailersLast);

2124Assert.NotSame(initialCustomHeaderValue, customHeaderValue);

1573Assert.NotSame(contexts[0], contexts[1]);

27Assert.NotSame(props.Items, copy.Items); 28Assert.NotSame(props.Parameters, copy.Parameters);

30Assert.NotSame(ticket.Principal, copy.Principal); 31Assert.NotSame(ticket.Properties.Items, copy.Properties.Items); 32Assert.NotSame(ticket.Properties.Parameters, copy.Properties.Parameters);

944Assert.NotSame(authenticateResult, authenticateResultFeature.AuthenticateResult);

387Assert.NotSame(metadata, property.PropertyMetadata);

42Assert.NotSame(actualAuthenticationState1, actualAuthenticationState2);

48Assert.NotSame(originalBuffer, segment.Array); // Since there was a resize

262Assert.NotSame(builder.Buffer, buffer); // Prevents use after free

36Assert.NotSame(thread, capturedThread); 101Assert.NotSame(thread, capturedThread); 458Assert.NotSame(thread, capturedThread); 546Assert.NotSame(thread, await task2); 640Assert.NotSame(thread, capturedThread); 728Assert.NotSame(thread, await task2);

374Assert.NotSame(oldComponent, newComponent);

62Assert.NotSame(routes1, routes2);

21Assert.NotSame(instance1, instance2); 57Assert.NotSame(instance1, instance3); 58Assert.NotSame(instance2, instance3); 85Assert.NotSame(instance2b, instance2);

77Assert.NotSame(singleton.Services[0], singleton.Services[1]);

32Assert.NotSame(originalPolicy.Headers, corsPolicy.Headers); 34Assert.NotSame(originalPolicy.Methods, corsPolicy.Methods); 36Assert.NotSame(originalPolicy.Origins, corsPolicy.Origins); 38Assert.NotSame(originalPolicy.ExposedHeaders, corsPolicy.ExposedHeaders); 61Assert.NotSame(originalPolicy.Origins, corsPolicy.Origins);

24Assert.NotSame(wrOriginal, wr);

822Assert.NotSame(createdKey, fetchedKey); // It's mutable, so we don't want to reuse the same instance 835Assert.NotSame(createdKey, fetchedKey2); // It's mutable, so we don't want to reuse the same instance 836Assert.NotSame(fetchedKey, fetchedKey2); 923Assert.NotSame(fetchedKey, fetchedKey2); // It's mutable, so we don't want to reuse the same instance

86Assert.NotSame(previousContext, context.HttpContext);

55Assert.NotSame(otherStorage, storage);

1458Assert.NotSame(connection.HttpContext, context2);

49Assert.NotSame(property.GetValue(original), property.GetValue(copy));

75Assert.NotSame(session, context.Session);

147Assert.NotSame(query0, query1);

91Assert.NotSame(responseBodyMock.Object, context.Features.Get<IHttpResponseBodyFeature>());

232Assert.NotSame(user1, user2); 261Assert.NotSame(user, user2); 292Assert.NotSame(user1, user2); 322Assert.NotSame(role1, role2); 352Assert.NotSame(role, role2); 383Assert.NotSame(role1, role2);

218Assert.NotSame(targetObject.SimpleObject.StringProperty, targetObject.InheritedObject.StringProperty); 258Assert.NotSame(targetObject.SimpleObject, targetObject.InheritedObject);

233Assert.NotSame(targetObject.SimpleObject.StringProperty, targetObject.InheritedObject.StringProperty); 273Assert.NotSame(targetObject.SimpleObject, targetObject.InheritedObject);

75a => Assert.NotSame(action.ActionConstraints[0], a), // Created by factory 112a => Assert.NotSame(action.ActionConstraints[0], a), // Created by factory 118Assert.NotSame(actionConstraints1, actionConstraints2); 122a => Assert.NotSame(actionConstraints1[0], a), // Created by factory (again)

41Assert.NotSame(action.Parameters, action2.Parameters); 44Assert.NotSame(parameter, action2.Parameters[0]); 45Assert.NotSame(apiExplorer, action2.ApiExplorer); 46Assert.NotSame(action.Selectors, action2.Selectors); 49Assert.NotSame(action.Selectors[0], action2.Selectors[0]); 50Assert.NotSame(route, action2.Selectors[0].AttributeRouteModel); 52Assert.NotSame(action, action2.Parameters[0].Action);

40Assert.NotSame(action, controller2.Actions[0]); 45Assert.NotSame(route, controller2.Selectors[0].AttributeRouteModel); 46Assert.NotSame(apiExplorer, controller2.ApiExplorer); 48Assert.NotSame(controller.Selectors[0].ActionConstraints, controller2.Selectors[0].ActionConstraints); 49Assert.NotSame(controller.Actions, controller2.Actions); 50Assert.NotSame(controller.Attributes, controller2.Attributes); 51Assert.NotSame(controller.Filters, controller2.Filters); 52Assert.NotSame(controller.RouteValues, controller2.RouteValues); 54Assert.NotSame(controller, controller2.Actions[0].Controller); 56Assert.NotSame(controller, controller2.ControllerProperties[0].Controller);

33Assert.NotSame(assembly.DefinedTypes, types);

484Assert.NotSame(authorizeFilter, result); 505Assert.NotSame(authorizeFilter, result); 530Assert.NotSame(policy1, effectivePolicy); 531Assert.NotSame(policy2, effectivePolicy); 566Assert.NotSame(policy1, effectivePolicy); 567Assert.NotSame(policy2, effectivePolicy);

197Assert.NotSame(currentFactoryCreatedFilter, previousFactoryCreatedFilter); // Never Cached 249Assert.NotSame(request1Filter1, request2Filter1); // Created by factory 252Assert.NotSame(request1Filter3, request2Filter3); // Created by custom filter provider again

52Assert.NotSame(oldFormFeature, actualFormFeature);

148Assert.NotSame(reader1, reader2);

129Assert.NotSame(changeToken1, changeToken2); 133Assert.NotSame(collection1, collection2); 146Assert.NotSame(changeToken2, changeToken3); 150Assert.NotSame(collection2, collection3);

223Assert.NotSame(provider, result);

346Assert.NotSame(metadata1, metadata2); 428Assert.NotSame(metadata1, metadata2);

245Assert.NotSame(result1, result2); 444Assert.NotSame(result1, result2); 506Assert.NotSame(result1, result2); 630Assert.NotSame(inner, innerInner);

1470Assert.NotSame(bindingContext.Model, result);

59Assert.NotSame(validators1, validators2); 62Assert.NotSame(validator2, Assert.Single(validators2.OfType<StringLengthAttributeAdapter>())); // not cached

59Assert.NotSame(validators1, validators2);

116Assert.NotSame(endpoints, newEndpoints);

482Assert.NotSame(collection, model.Address); 999Assert.NotSame(collection, model.Address);

148Assert.NotSame(reader1, reader2);

130Assert.NotSame(result1, result2); 156Assert.NotSame(result1, result2); 182Assert.NotSame(result1, result2);

74Assert.NotSame(original, viewDataDictionary); 103Assert.NotSame(original, viewDataDictionary); 132Assert.NotSame(original, viewDataDictionary); 161Assert.NotSame(original, viewDataDictionary);

64Assert.NotSame(viewContext, helper.ViewContext);

46Assert.NotSame(lookup, viewEngine.ViewLookupCache);

133Assert.NotSame(viewData, viewContext.ViewData); 134Assert.NotSame(viewData, instance.ViewData); 187Assert.NotSame(viewData, viewContext.ViewData); 229Assert.NotSame(result1, result3);

121Assert.NotSame(modelExplorer, modelExpression.ModelExplorer);

52Assert.NotSame(expected, actual); 303Assert.NotSame(original, actual);

329Assert.NotSame(result1, result2);

360Assert.NotSame(entry1, entry2);

116Assert.NotSame(endpoints, newEndpoints);

35Assert.NotSame(routeData.DataTokens, original.DataTokens); 37Assert.NotSame(routeData.Routers, original.Routers); 39Assert.NotSame(routeData.Values, original.Values);

45Assert.NotSame(dataTokens, pathData.DataTokens);

135Assert.NotSame(differentModel, result1);

48Assert.NotSame(originalViewData, controller.ViewData);

403Assert.NotSame(text1, text2); // not cached 432Assert.NotSame(text1, text2);

320Assert.NotSame(originalTagBuilder.Attributes, clonedTagBuilder.Attributes);

37Assert.NotSame(originalViewData, context.ViewData);

26Assert.NotSame(tempData1, tempData2);

45Assert.NotSame(viewContext, viewComponentContext.ViewContext); 56Assert.NotSame(viewData, viewComponentContext.ViewData);

76Assert.NotSame(viewComponent.ViewData, actualResult.ViewData); 95Assert.NotSame(viewComponent.ViewData, actualResult.ViewData); 113Assert.NotSame(viewComponent.ViewData, actualResult.ViewData); 133Assert.NotSame(viewComponent.ViewData, actualResult.ViewData); 153Assert.NotSame(viewComponent.ViewData, actualResult.ViewData); 172Assert.NotSame(viewComponent.ViewData, actualResult.ViewData); 191Assert.NotSame(viewComponent.ViewData, actualResult.ViewData); 211Assert.NotSame(viewComponent.ViewData, actualResult.ViewData);

50Assert.NotSame(source.TemplateInfo, viewData1.TemplateInfo); 62Assert.NotSame(source.TemplateInfo, viewData2.TemplateInfo); 89Assert.NotSame(source.TemplateInfo, viewData1.TemplateInfo); 101Assert.NotSame(source.TemplateInfo, viewData2.TemplateInfo); 169Assert.NotSame(source.TemplateInfo, viewData.TemplateInfo); 173Assert.NotSame(source.ModelMetadata, viewData.ModelMetadata); 255Assert.NotSame(source.ModelExplorer, viewData.ModelExplorer); 257Assert.NotSame(source.ModelMetadata, viewData.ModelMetadata); 278Assert.NotSame(source.ModelExplorer, viewData.ModelExplorer); 297Assert.NotSame(source.ModelExplorer, viewData.ModelExplorer); 298Assert.NotSame(source.ModelMetadata, viewData.ModelMetadata);

204Assert.NotSame(source.TemplateInfo, viewData.TemplateInfo); 290Assert.NotSame(source.ModelExplorer, viewData.ModelExplorer); 291Assert.NotSame(source.ModelMetadata, viewData.ModelMetadata); 313Assert.NotSame(source.ModelExplorer, viewData.ModelExplorer); 339Assert.NotSame(originalExplorer, viewData.ModelExplorer); 362Assert.NotSame(explorer, viewData.ModelExplorer); 388Assert.NotSame(explorer, viewData.ModelExplorer); 431Assert.NotSame(originalExplorer, viewData.ModelExplorer);

444Assert.NotSame(content1, content2);

540Assert.NotSame(cachedVaryByRules, context.CachedVaryByRules);

135Assert.NotSame(initialRequestDelegate, endpoint.RequestDelegate); 163Assert.NotSame(initialRequestDelegate, endpoint.RequestDelegate); 214Assert.NotSame(initialRequestDelegate, endpoint.RequestDelegate);

31Assert.NotSame(endpoints, dataSource.Endpoints); 57Assert.NotSame(groupedEndpoints, resolvedGroupEndpoints); 178Assert.NotSame(changeToken2, changeToken1); 191Assert.NotSame(changeToken3, changeToken2); 192Assert.NotSame(changeToken3, changeToken1); 217Assert.NotSame(changeToken2, changeToken1); 227Assert.NotSame(changeToken3, changeToken2); 228Assert.NotSame(changeToken3, changeToken1); 252Assert.NotSame(changeToken2, changeToken1); 263Assert.NotSame(changeToken3, changeToken2); 264Assert.NotSame(changeToken3, changeToken1);

598Assert.NotSame(original, actual);

154Assert.NotSame(original.Matcher, actual.Matcher); 155Assert.NotSame(original.Constraints, actual.Constraints);

3442Assert.NotSame(constraint1.Value, constraint2.Value);

78Assert.NotSame(endpoint, httpContext.GetEndpoint()); 196Assert.NotSame(endpoint1, httpContext.GetEndpoint()); 197Assert.NotSame(endpoint2, httpContext.GetEndpoint()); 306Assert.NotSame(endpoint1, httpContext.GetEndpoint()); 307Assert.NotSame(endpoint2, httpContext.GetEndpoint());

37Assert.NotSame(original, table._getDestination);

198Assert.NotSame(actual.Defaults, original.Defaults); 199Assert.NotSame(actual.Parameters, original.Parameters); 200Assert.NotSame(actual.PathSegments, original.PathSegments);

487Assert.NotSame(paramPartB, actual.Parameters[0]); 490Assert.NotSame(paramPartC, actual.Parameters[1]); 527Assert.NotSame(paramPartB, actual.Parameters[0]); 530Assert.NotSame(paramPartC, actual.Parameters[1]);

99Assert.NotSame(state, addressScheme.State); 110Assert.NotSame(state, addressScheme.State); 121Assert.NotSame(state, addressScheme.State);

161Assert.NotSame(oldChangeToken, newChangeToken);

70Assert.NotSame(_collection[type], _collection);

158Assert.NotSame(enumerator0, enumerator1); 423Assert.NotSame(HeaderValue, values.PrevHeaderValue); 426Assert.NotSame(HeaderValue, values.NextHeaderValue); 437Assert.NotSame(values.PrevHeaderValue, values.NextHeaderValue); 458Assert.NotSame(HeaderValue1, values.PrevHeaderValue); 461Assert.NotSame(HeaderValue2, values.NextHeaderValue); 482Assert.NotSame(HeaderValue1, values.PrevHeaderValue); 506Assert.NotSame(HeaderValue, values.PrevHeaderValue); 509Assert.NotSame(HeaderValue, values.NextHeaderValue); 513Assert.NotSame(values.PrevHeaderValue, values.NextHeaderValue); 558Assert.NotSame(headerValueUtf16Latin1CrossOver, prevHeaderValue); 626Assert.NotSame(parsedHeaderValue1, parsedHeaderValue2); 729Assert.NotSame(HeaderValue, values.PrevHeaderValue); 732Assert.NotSame(HeaderValue, values.NextHeaderValue); 736Assert.NotSame(values.PrevHeaderValue, values.NextHeaderValue); 757Assert.NotSame(HeaderValue, prevHeaderValue);

33Assert.NotSame(pool1, pool2);

449Assert.NotSame(options1, options2); 493Assert.NotSame(selectorOptions1, selectorOptions2); 496Assert.NotSame(selectorCertificate, configOptions1.ServerCertificate); 499Assert.NotSame(selectorCertificate, configOptions2.ServerCertificate); 871Assert.NotSame(options, clonedOptions); 877Assert.NotSame(options.ApplicationProtocols, clonedOptions.ApplicationProtocols);

264Assert.NotSame(entries[i].Name, headerField.Name); 267Assert.NotSame(entries[i].Value, headerField.Value);

301Assert.NotSame(originalDestination, actualDestination);

48Assert.NotSame(rawTarget, Http1Connection.RawTarget); 49Assert.NotSame(path, Http1Connection.Path); 50Assert.NotSame(query, Http1Connection.QueryString); 75Assert.NotSame(rawTarget, Http1Connection.RawTarget); 103Assert.NotSame(rawTarget, Http1Connection.RawTarget); 104Assert.NotSame(path, Http1Connection.Path); 105Assert.NotSame(query, Http1Connection.QueryString); 154Assert.NotSame(rawTarget, Http1Connection.RawTarget); 155Assert.NotSame(path, Http1Connection.Path); 156Assert.NotSame(query, Http1Connection.QueryString); 218Assert.NotSame(rawTarget, Http1Connection.RawTarget); 219Assert.NotSame(path, Http1Connection.Path); 251Assert.NotSame(rawTarget, Http1Connection.RawTarget); 252Assert.NotSame(path, Http1Connection.Path); 253Assert.NotSame(query, Http1Connection.QueryString); 311Assert.NotSame(rawTarget, Http1Connection.RawTarget); 312Assert.NotSame(path, Http1Connection.Path); 344Assert.NotSame(rawTarget, Http1Connection.RawTarget); 345Assert.NotSame(path, Http1Connection.Path); 346Assert.NotSame(query, Http1Connection.QueryString); 423Assert.NotSame(rawTarget, Http1Connection.RawTarget); 424Assert.NotSame(path, Http1Connection.Path); 425Assert.NotSame(query, Http1Connection.QueryString); 473Assert.NotSame(rawTarget, Http1Connection.RawTarget); 505Assert.NotSame(rawTarget, Http1Connection.RawTarget);

1651Assert.NotSame(oldConfigurationLoader, newConfigurationLoader);

61Assert.NotSame(source, holder.ReadDictionary); 88Assert.NotSame(source, holder.ReadDictionary);

264Assert.NotSame(entries[i].Name, headerField.Name); 267Assert.NotSame(entries[i].Value, headerField.Value);

301Assert.NotSame(originalDestination, actualDestination);

796Assert.NotSame(resolvedOptions, originalOptions); 797Assert.NotSame(resolvedOptions.AccessTokenProvider, originalOptions.AccessTokenProvider);

83Assert.NotSame(jsonProtocol1, resolvedProtocol);

907Assert.NotSame(value, capturedValue);

141Assert.NotSame(NullResultMetadataAsSourceFileProvider.NullResult, file);

1541Assert.NotSame(beforeSolutionForPrimaryWorkspace, primaryWorkspace.CurrentSolution); 1542Assert.NotSame(beforeSolutionForSecondaryWorkspace, secondaryWorkspace.CurrentSolution);

6048Assert.NotSame(symbol, symbolClone); 6102Assert.NotSame(symbol.Type, symbol0.Type); 6103Assert.NotSame(symbol, symbol0);

8067Assert.NotSame(unmanagedData, UnmanagedCallersOnlyAttributeData.Uninitialized); 8068Assert.NotSame(unmanagedData, UnmanagedCallersOnlyAttributeData.AttributePresentDataNotBound); 8743Assert.NotSame(unmanagedData, UnmanagedCallersOnlyAttributeData.Uninitialized); 8744Assert.NotSame(unmanagedData, UnmanagedCallersOnlyAttributeData.AttributePresentDataNotBound);

4517Assert.NotSame(vt2, namedTuple); 11243Assert.NotSame(m1Item1, m1Item1.OriginalDefinition); 11263Assert.NotSame(m2Item1, m2Item1.OriginalDefinition); 11603Assert.NotSame(members[i], members[j]); 11613Assert.NotSame(tuple1, tuple2); 11624Assert.NotSame(members1[i], members2[i]); 11640Assert.NotSame(typeParameters1[j], typeParameters2[j]); 11660Assert.NotSame(members1[i], members2[j]); 11684Assert.NotSame(parameters1[j], parameters2[j]); 12742Assert.NotSame(m1Tuple, m1Tuple.ConstructedFrom); 12743Assert.NotSame(m1Tuple, m1Tuple.OriginalDefinition); 12794Assert.NotSame(m1Item1, m1Item1.OriginalDefinition); 12813Assert.NotSame(m2Item1, m2Item1.OriginalDefinition); 12851Assert.NotSame(m1ToString, m1ToString.OriginalDefinition); 13532Assert.NotSame(m9Test, m9Test.OriginalDefinition); 13536Assert.NotSame(m9Test.TypeParameters.Single(), m9Test.TypeParameters.Single().OriginalDefinition); 13919Assert.NotSame(comp2.Assembly, (AssemblySymbol)comp3.GetAssemblyOrModuleSymbol(comp2CompilationRef)); // We are interested in retargeting scenario 14084Assert.NotSame(comp2.Assembly, (AssemblySymbol)comp3.GetAssemblyOrModuleSymbol(comp2CompilationRef)); // We are interested in retargeting scenario 15822Assert.NotSame(m1P1, m1P1.OriginalDefinition); 15853Assert.NotSame(m1this, m1this.OriginalDefinition); 16051Assert.NotSame(m1E1, m1E1.OriginalDefinition); 16092Assert.NotSame(m1E2Add, m1E2.AddMethod); 16094Assert.NotSame(m1E2Remove, m1E2.RemoveMethod); 16101Assert.NotSame(m1E2, m1E2Add.AssociatedSymbol); 16105Assert.NotSame(m1E2, m1E2Remove.AssociatedSymbol);

5049Assert.NotSame(comp.Assembly.CorLibrary, comp.Assembly);

10046Assert.NotSame(compilation1.Assembly, compilation3.SourceModule.ReferencedAssemblySymbols[1]);

357Assert.NotSame(embeddedAttribute, embeddedAttributeFile);

1939Assert.NotSame(addMethod, e.SourcePartialImplementationPart.AddMethod); 1944Assert.NotSame(removeMethod, e.SourcePartialImplementationPart.RemoveMethod);

262Assert.NotSame(symbol, constructed); 269Assert.NotSame(symbol, unbound);

1618Assert.NotSame(methodSymbol, methodSymbol.OriginalDefinition); 1778Assert.NotSame(methodSymbol, methodSymbol.OriginalDefinition); 1939Assert.NotSame(m1InvocationSymbol, m1InvocationSymbol.OriginalDefinition);

7399Assert.NotSame(locationSpecifier, model.GetInterceptableLocation(node));

3047Assert.NotSame(firstGeneric, lastGeneric);

267Assert.NotSame(underlyingType, nativeIntegerType); 379Assert.NotSame(underlyingType, nativeIntegerType); 923Assert.NotSame(f1.Type, f3.Type); 925Assert.NotSame(f2.Type, f4.Type);

7553Assert.NotSame(symbol1, symbol3); 8130Assert.NotSame(symbol1, symbol5);

388Assert.NotSame(c1.Assembly, c1AsmRef); 392Assert.NotSame(mscorlibAssembly, c1.GetReferencedAssemblySymbol(oldMsCorLib));

482Assert.NotSame(oldOptions, newOptions);

4960Assert.NotSame(symbolInfo.Symbol, symbolInfo2.Symbol);

1449Assert.NotSame(withCircularReference1, withCircularReference2); 1464Assert.NotSame(refA2_symbol1, refA2_symbol2); 1844Assert.NotSame(cPublic.Assembly.CorLibrary, cInternal.Assembly.CorLibrary); 1845Assert.NotSame(cAll.Assembly.CorLibrary, cInternal.Assembly.CorLibrary); 1846Assert.NotSame(cAll.Assembly.CorLibrary, cPublic.Assembly.CorLibrary);

260Assert.NotSame(symbol1, symbol2); 280Assert.NotSame(symbol1, symbol2); 299Assert.NotSame(symbol1, symbol2); 319Assert.NotSame(symbol1, symbol2); 357Assert.NotSame(symbol1, symbol2); 380Assert.NotSame(symbol1, symbol2); 887Assert.NotSame(pmSym01, pmSym02); 904Assert.NotSame(ppSym01, ppSym02);

422Assert.NotSame(type1.MergedDeclaration.Declarations[0].MemberNames, type3.MergedDeclaration.Declarations[0].MemberNames);

5540Assert.NotSame(symbol1, symbol2); // Not required, just documenting.

1697Assert.NotSame(typeA3, typeA4);

154Assert.NotSame(asm2[1], asm1[1]); 184Assert.NotSame(asm3[1], asm1[1]); 185Assert.NotSame(asm3[1], asm2[1]); 199Assert.NotSame(asm3[2], asm2[2]); 200Assert.NotSame(((PEAssemblySymbol)asm3[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 242Assert.NotSame(asm4[1], asm1[1]); 243Assert.NotSame(asm4[1], asm2[1]); 244Assert.NotSame(asm4[1], asm3[1]); 258Assert.NotSame(asm4[2], asm2[2]); 259Assert.NotSame(asm4[2], asm3[2]); 260Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 261Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm3[2]).Assembly); 267Assert.NotSame(asm4[3], asm3[3]); 355Assert.NotSame(asm7[2], asm3[3]); 356Assert.NotSame(asm7[2], asm4[3]); 357Assert.NotSame(asm7[3], asm4[4]); 465Assert.NotSame(asm2[1], asm1[1]); 486Assert.NotSame(asm3[1], asm1[1]); 487Assert.NotSame(asm3[1], asm2[1]); 501Assert.NotSame(asm3[2], asm2[2]); 502Assert.NotSame(((PEAssemblySymbol)asm3[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 534Assert.NotSame(asm4[1], asm1[1]); 535Assert.NotSame(asm4[1], asm2[1]); 536Assert.NotSame(asm4[1], asm3[1]); 550Assert.NotSame(asm4[2], asm2[2]); 551Assert.NotSame(asm4[2], asm3[2]); 552Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 553Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm3[2]).Assembly); 559Assert.NotSame(asm4[3], asm3[3]); 621Assert.NotSame(asm7[2], asm3[3]); 622Assert.NotSame(asm7[2], asm4[3]); 623Assert.NotSame(asm7[3], asm4[4]); 813Assert.NotSame(asm_MTTestLib3[1], varC_MTTestLib2.SourceAssembly()); 814Assert.NotSame(asm_MTTestLib3[2], varC_MTTestLib1_V1.SourceAssembly()); 847Assert.NotSame(asm3[2], asm2[2]); 848Assert.NotSame(asm3[2].DeclaringCompilation, asm2[2].DeclaringCompilation); 948Assert.NotSame(asm_MTTestLib4[1], varC_MTTestLib2.SourceAssembly()); 950Assert.NotSame(asm_MTTestLib4[3], varC_MTTestLib3.SourceAssembly()); 972Assert.NotSame(asm4[1], varC_MTTestLib2.SourceAssembly()); 973Assert.NotSame(asm4[1], asm2[1]); 974Assert.NotSame(asm4[1], asm3[1]); 988Assert.NotSame(asm4[2], asm2[2]); 989Assert.NotSame(asm4[2], asm3[2]); 990Assert.NotSame(asm4[2].DeclaringCompilation, asm2[2].DeclaringCompilation); 991Assert.NotSame(asm4[2].DeclaringCompilation, asm3[2].DeclaringCompilation); 997Assert.NotSame(asm4[3], asm3[3]); 1083Assert.NotSame(asm7[2], asm3[3]); 1084Assert.NotSame(asm7[2], asm4[3]); 1085Assert.NotSame(asm7[3], asm4[4]); 1204Assert.NotSame(asm_MTTestLib3[1], varC_MTTestLib2.SourceAssembly()); 1205Assert.NotSame(asm_MTTestLib3[2], varC_MTTestLib1_V1.SourceAssembly()); 1226Assert.NotSame(asm3[2], asm2[2]); 1227Assert.NotSame(asm3[2].DeclaringCompilation, asm2[2].DeclaringCompilation); 1263Assert.NotSame(asm4[1], varC_MTTestLib2.SourceAssembly()); 1264Assert.NotSame(asm4[1], asm2[1]); 1265Assert.NotSame(asm4[1], asm3[1]); 1279Assert.NotSame(asm4[2], asm2[2]); 1280Assert.NotSame(asm4[2], asm3[2]); 1281Assert.NotSame(asm4[2].DeclaringCompilation, asm2[2].DeclaringCompilation); 1282Assert.NotSame(asm4[2].DeclaringCompilation, asm3[2].DeclaringCompilation); 1288Assert.NotSame(asm4[3], asm3[3]); 1356Assert.NotSame(asm7[2], asm3[3]); 1357Assert.NotSame(asm7[2], asm4[3]); 1358Assert.NotSame(asm7[3], asm4[4]); 1482Assert.NotSame(asm_MTTestLib3[1], varC_MTTestLib2.SourceAssembly()); 1483Assert.NotSame(asm_MTTestLib3[2], asm_MTTestLib2[1]); 1521Assert.NotSame(asm3[2], asm2[2]); 1522Assert.NotSame(asm3[2], asm2[2]); 1523Assert.NotSame(((PEAssemblySymbol)asm3[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 1568Assert.NotSame(asm_MTTestLib4[1], varC_MTTestLib2.SourceAssembly()); 1569Assert.NotSame(asm_MTTestLib4[2], asm3[2]); 1570Assert.NotSame(asm_MTTestLib4[2], asm2[2]); 1571Assert.NotSame(asm_MTTestLib4[3], varC_MTTestLib3.SourceAssembly()); 1593Assert.NotSame(asm4[1], varC_MTTestLib2.SourceAssembly()); 1594Assert.NotSame(asm4[1], asm2[1]); 1595Assert.NotSame(asm4[1], asm3[1]); 1609Assert.NotSame(asm4[2], asm2[2]); 1610Assert.NotSame(asm4[2], asm3[2]); 1611Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 1612Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm3[2]).Assembly); 1618Assert.NotSame(asm4[3], asm3[3]); 1715Assert.NotSame(asm7[2], asm3[3]); 1716Assert.NotSame(asm7[2], asm4[3]); 1717Assert.NotSame(asm7[3], asm4[4]); 1850Assert.NotSame(asm_MTTestLib3[1], varC_MTTestLib2.SourceAssembly()); 1851Assert.NotSame(asm_MTTestLib3[2], asm_MTTestLib2[1]); 1872Assert.NotSame(asm3[2], asm2[2]); 1873Assert.NotSame(((PEAssemblySymbol)asm3[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 1909Assert.NotSame(asm4[1], varC_MTTestLib2.SourceAssembly()); 1910Assert.NotSame(asm4[1], asm2[1]); 1911Assert.NotSame(asm4[1], asm3[1]); 1925Assert.NotSame(asm4[2], asm2[2]); 1926Assert.NotSame(asm4[2], asm3[2]); 1927Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm2[2]).Assembly); 1928Assert.NotSame(((PEAssemblySymbol)asm4[2]).Assembly, ((PEAssemblySymbol)asm3[2]).Assembly); 1934Assert.NotSame(asm4[3], asm3[3]); 2002Assert.NotSame(asm7[2], asm3[3]); 2003Assert.NotSame(asm7[2], asm4[3]); 2004Assert.NotSame(asm7[3], asm4[4]); 2264Assert.NotSame(asm5[1], asm3);

1471Assert.NotSame(base1, base3); 1534Assert.NotSame(compilation1.SourceModule.CorLibrary(), compilation2.SourceModule.CorLibrary());

34853Assert.NotSame(test1i1, test1i1m1.ContainingType); 34854Assert.NotSame(test1i1, test1i1m2.ContainingType); 34855Assert.NotSame(test2i1, test2i1m1.ContainingType); 34856Assert.NotSame(test2i1, test2i1m2.ContainingType); 34857Assert.NotSame(test2i2, test2i2m1.ContainingType); 34858Assert.NotSame(test2i2, test2i2m2.ContainingType); 39147Assert.NotSame(test1i1, test1i1m1.ContainingType); 39148Assert.NotSame(test2i1, test2i1m1.ContainingType); 39149Assert.NotSame(test2i2, test2i2m1.ContainingType); 41823Assert.NotSame(test1i1, test1i1m1.ContainingType); 41824Assert.NotSame(test2i1, test2i1m1.ContainingType); 41825Assert.NotSame(test2i2, test2i2m1.ContainingType);

1964Assert.NotSame(testConvention!.ContainingAssembly.CorLibrary, mainComp.Assembly.CorLibrary);

139Assert.NotSame(classImplicitImplementation, classExplicitImplementation); 140Assert.NotSame(classImplicitImplementation, classExplicitImplementationBase); 190Assert.NotSame(classImplicitImplementation, classExplicitImplementation); 191Assert.NotSame(classImplicitImplementation, classExplicitImplementationBase); 448Assert.NotSame(baseClassImplicitImplementation, baseClassExplicitImplementation); 449Assert.NotSame(baseClassImplicitImplementation, baseClassExplicitImplementationBase); 692Assert.NotSame(baseClassMethod, class1ImplementingMethod); 700Assert.NotSame(class2Method, class1ImplementingMethod); 769Assert.NotSame(baseClassMethodVirtual, class1ImplementingMethodVirtual); 773Assert.NotSame(baseClassMethodNonVirtual, class1ImplementingMethodNonVirtual); 787Assert.NotSame(class2MethodVirtual, class2ImplementingMethodVirtual); 791Assert.NotSame(class2MethodNonVirtual, class2ImplementingMethodNonVirtual);

316Assert.NotSame(asm1m4.ReturnType, asm2m4.ReturnType);

101Assert.NotSame(localTypes1_1, localTypes1_2); 102Assert.NotSame(localTypes2_1, localTypes2_2); 132Assert.NotSame(localTypes1_1, localTypes1_3); 133Assert.NotSame(localTypes2_1, localTypes2_3); 134Assert.NotSame(localTypes1_2, localTypes1_3); 135Assert.NotSame(localTypes2_2, localTypes2_3); 136Assert.NotSame(pia1_1, pia1_3); 337Assert.NotSame(library1_9, library1_10); 338Assert.NotSame(localTypes1_9, localTypes1_10); 391Assert.NotSame(localTypes1Asm, localTypes1_1); 396Assert.NotSame(localTypes2Asm, localTypes2_1); 442Assert.NotSame(localTypes1_1, localTypes1_2); 443Assert.NotSame(localTypes2_1, localTypes2_2); 472Assert.NotSame(localTypes1_1, localTypes1_3); 473Assert.NotSame(localTypes2_1, localTypes2_3); 474Assert.NotSame(localTypes1_2, localTypes1_3); 475Assert.NotSame(localTypes2_2, localTypes2_3); 674Assert.NotSame(library1_9, library1_10); 675Assert.NotSame(localTypes1_9, localTypes1_10); 698Assert.NotSame(tc1.GetReferencedAssemblySymbol(localTypes1Ref), 777Assert.NotSame(pia5Asm1, pia5Asm2); 804Assert.NotSame(pia5Asm3, pia5Asm4); 806Assert.NotSame(library2Asm3, library2Asm4); 823Assert.NotSame(library2Asm5, library2Asm3); 824Assert.NotSame(library2Asm5, library2Asm4); 852Assert.NotSame(library2Asm7, library2Asm3); 853Assert.NotSame(library2Asm7, library2Asm4); 854Assert.NotSame(library2Asm7, library2Asm5); 908Assert.NotSame(varC1, varC4); 909Assert.NotSame(varB1, varB4); // Link and Ref use different symbols. 918Assert.NotSame(varA1, varA5); // Link and Ref use different symbols. 919Assert.NotSame(varC1, varC5); 920Assert.NotSame(varC4, varC5); 929Assert.NotSame(varC1, varC6); // Link and Ref use different symbols. 930Assert.NotSame(varC4, varC6); // Link and Ref use different symbols. 931Assert.NotSame(varC5, varC6); // Link and Ref use different symbols. 1144Assert.NotSame(pia5Asm1, pia5Asm2); 1171Assert.NotSame(pia5Asm3, pia5Asm4); 1173Assert.NotSame(library2Asm3, library2Asm4); 1190Assert.NotSame(library2Asm5, library2Asm3); 1191Assert.NotSame(library2Asm5, library2Asm4); 1219Assert.NotSame(library2Asm7, library2Asm3); 1220Assert.NotSame(library2Asm7, library2Asm4); 1221Assert.NotSame(library2Asm7, library2Asm5); 1313Assert.NotSame(varC1, varC4); 1314Assert.NotSame(varB1, varB4); // Link and Ref use different symbols. 1323Assert.NotSame(varA1, varA5); // Link and Ref use different symbols. 1324Assert.NotSame(varC1, varC5); 1325Assert.NotSame(varC4, varC5); 1334Assert.NotSame(varC1, varC6); // Link and Ref use different symbols. 1335Assert.NotSame(varC4, varC6); // Link and Ref use different symbols. 1336Assert.NotSame(varC5, varC6); // Link and Ref use different symbols.

411Assert.NotSame(localTypes1_1, localTypes1_2); 412Assert.NotSame(localTypes2_1, localTypes2_2); 440Assert.NotSame(localTypes1_1, localTypes1_3); 441Assert.NotSame(localTypes2_1, localTypes2_3); 442Assert.NotSame(localTypes1_2, localTypes1_3); 443Assert.NotSame(localTypes2_2, localTypes2_3); 444Assert.NotSame(pia1_1, pia1_3); 636Assert.NotSame(library1_9, library1_10); 637Assert.NotSame(localTypes1_9, localTypes1_10); 712Assert.NotSame(localTypes1_1, localTypes1_2); 713Assert.NotSame(localTypes2_1, localTypes2_2); 741Assert.NotSame(localTypes1_1, localTypes1_3); 742Assert.NotSame(localTypes2_1, localTypes2_3); 743Assert.NotSame(localTypes1_2, localTypes1_3); 744Assert.NotSame(localTypes2_2, localTypes2_3); 745Assert.NotSame(pia1_1, pia1_3); 937Assert.NotSame(library1_9, library1_10); 938Assert.NotSame(localTypes1_9, localTypes1_10); 1016Assert.NotSame(localTypes1_1, localTypes1_2); 1017Assert.NotSame(localTypes2_1, localTypes2_2); 1045Assert.NotSame(localTypes1_1, localTypes1_3); 1046Assert.NotSame(localTypes2_1, localTypes2_3); 1047Assert.NotSame(localTypes1_2, localTypes1_3); 1048Assert.NotSame(localTypes2_2, localTypes2_3); 1049Assert.NotSame(pia1_1, pia1_3); 1241Assert.NotSame(library1_9, library1_10); 1242Assert.NotSame(localTypes1_9, localTypes1_10); 1269Assert.NotSame(tc1.GetReferencedAssemblySymbol(localTypes1Ref), 1295Assert.NotSame(tc1.GetReferencedAssemblySymbol(localTypes1Ref), 1325Assert.NotSame(tc1.GetReferencedAssemblySymbol(localTypes1Ref), 2673Assert.NotSame(compilation1.SourceAssembly.CorLibrary, compilation2.SourceAssembly.CorLibrary);

78Assert.NotSame(c1Assembly, c1AsmRef); 82Assert.NotSame(c1MscorLibAssemblyRef, c2MscorlibAssemblyRef); 86Assert.NotSame(oldMsCorLib_systemType, newMsCorLib_systemType); 90Assert.NotSame(oldMsCorLib_debuggerTypeProxyAttributeType, newMsCorLib_debuggerTypeProxyAttributeType); 98Assert.NotSame(oldMsCorLib_debuggerTypeProxyAttributeCtor, newMsCorLib_debuggerTypeProxyAttributeCtor);

41Assert.NotSame(mscorlibAssembly, c1.GetReferencedAssemblySymbol(oldMsCorLib)); 155Assert.NotSame(c1Assembly, c1AsmRef); 159Assert.NotSame(mscorlibAssembly, c1.GetReferencedAssemblySymbol(oldMsCorLib));

125Assert.NotSame(interfaceV1, interfaceV2); 161Assert.NotSame(interfaceV1Method1, retargetedClassCMethod1Impl); 190Assert.NotSame(interfaceV1Method4, retargetedClassCMethod4Impl); 200Assert.NotSame(interfaceV1Property1, retargetedClassCProperty1Impl); 227Assert.NotSame(interfaceV1Property4, retargetedClassCProperty4Impl); 238Assert.NotSame(interfaceV1Indexer1, retargetedClassCIndexer1Impl); 265Assert.NotSame(interfaceV1Indexer4, retargetedClassCIndexer4Impl); 276Assert.NotSame(interfaceV1Event1, retargetedClassCEvent1Impl); 303Assert.NotSame(interfaceV1Event4, retargetedClassCEvent4Impl); 463Assert.NotSame(compilation2.GetTypeByMetadataName("C1`1"), compilation3.GetTypeByMetadataName("C1`1"));

845Assert.NotSame(originalComp.Assembly, mRetargeted.ContainingAssembly); 846Assert.NotSame(retargetedAssembly1, retargetedAssembly2); 863Assert.NotSame(ptrOriginal, ptrRetargeted); 1076Assert.NotSame(containingAssembly, beforeRetargeting.Assembly);

2137Assert.NotSame(constructedMethod1, constructedMethod2); 2142Assert.NotSame(substitutedParameter1, substitutedParameter2); 2162Assert.NotSame(reducedMethod1, reducedMethod2); 2167Assert.NotSame(extensionParameter1, extensionParameter2);

582Assert.NotSame(type, type.ConstructedFrom);

83Assert.NotSame(c2TestClass, c3TestClass);

66Assert.NotSame(b1.TypeParameters[0], b2.TypeParameters[0]); // they've been alpha renamed independently

127Assert.NotSame(diagnostic, other);

3500Assert.NotSame(oldClassC, newClassC); 3511Assert.NotSame(oldToken, newToken);

166Assert.NotSame(ImmutableDictionary<string, ReportDiagnostic>.Empty, tree.DiagnosticOptions); 224Assert.NotSame(tree.DiagnosticOptions, newTree.DiagnosticOptions);

73Assert.NotSame(latestA, newA); // not the same reference 158Assert.NotSame(id, currentId);

61Assert.NotSame(defaultValue, codeStyleOption); 77Assert.NotSame(defaultValue, codeStyleOption);

160=> Assert.NotSame(a.FilePath, b.FilePath);

171Assert.NotSame(document, c.SpansToTag.First().Document);

70Assert.NotSame(workspace.CurrentSolution, originalDocumentWithChanges.Project.Solution);

76Assert.NotSame(text, newText); 81Assert.NotSame(document, newDocument);

93Assert.NotSame(text, text2); 113Assert.NotSame(text, text2);

139Assert.NotSame(compileTimeSolution1, compileTimeSolution2);

216Assert.NotSame(document1, document2); 3595Assert.NotSame(newBaselineA1, newBaselineA2); 3596Assert.NotSame(newBaselineB1, newBaselineB2);

72Assert.NotSame(serverOne.GetRequiredLspService<LspWorkspaceManager>(), serverTwo.GetRequiredLspService<LspWorkspaceManager>());

74Assert.NotSame(testLspServer.TestWorkspace.CurrentSolution.GetDocument(firstDocument.Id), firstDocument); 731Assert.NotSame(testLspServer.TestWorkspace.CurrentSolution, sourceGeneratedDocument.Project.Solution); 755Assert.NotSame(testLspServer.TestWorkspace.CurrentSolution, sourceGeneratedDocument.Project.Solution);

173Assert.NotSame(modifiedMetadata3, metadata2); 178Assert.NotSame(metadata2.GetModules()[i], modifiedMetadata3.GetModules()[i]);

659Assert.NotSame(model, ((Operation)operation).OwningSemanticModel);

309Assert.NotSame(semanticModel, ((Operation)operation).OwningSemanticModel);

19Assert.NotSame(Boxes.Box(true), Boxes.Box(false)); 23Assert.NotSame(Boxes.Box((byte)3), Boxes.Box((byte)3)); 27Assert.NotSame(Boxes.Box((sbyte)3), Boxes.Box((sbyte)3)); 31Assert.NotSame(Boxes.Box((short)3), Boxes.Box((short)3)); 35Assert.NotSame(Boxes.Box((ushort)3), Boxes.Box((ushort)3)); 42Assert.NotSame(Boxes.Box(3), Boxes.Box(3)); 46Assert.NotSame(Boxes.Box(3u), Boxes.Box(3u)); 50Assert.NotSame(Boxes.Box(3L), Boxes.Box(3L)); 54Assert.NotSame(Boxes.Box(3UL), Boxes.Box(3UL)); 58Assert.NotSame(Boxes.Box(0.0f), Boxes.Box(-0.0f)); 59Assert.NotSame(Boxes.Box(1.0f), Boxes.Box(1.0f)); 63Assert.NotSame(Boxes.Box(0.0), Boxes.Box(-0.0)); 64Assert.NotSame(Boxes.Box(1.0), Boxes.Box(1.0)); 68Assert.NotSame(Boxes.Box(0m), Boxes.Box(decimal.Negate(0m))); 71Assert.NotSame(Boxes.Box(decimal.Zero), Boxes.Box(strangeDecimalZero)); 77Assert.NotSame(Boxes.Box('\u1234'), Boxes.Box('\u1234')); // non ASCII

317Assert.NotSame(addedMap, removedMap);

131Assert.NotSame(map, addedMap);

556Assert.NotSame(iface, updatedIface);

399Assert.NotSame(set, nextSet); 419Assert.NotSame(set, newSet); 431Assert.NotSame(set, newSet);

168Assert.NotSame(collection1.SyncRoot, collection2.SyncRoot);

86Assert.NotSame(resizedSegments[resizedSegmentCount - 1], oldSegments[oldSegmentCount - 1]);

605Assert.NotSame(largeText, newText); 647Assert.NotSame(largeText, newText); 651Assert.NotSame(chunk1, GetChunks(newText)[0]);

123Assert.NotSame(p0, p1); 166Assert.NotSame(p1Sys1, p1Sys2); 167Assert.NotSame(p2Sys1, p2Sys3); 2220Assert.NotSame(originalSolution, args.NewSolution); 2250Assert.NotSame(originalSolution, args.NewSolution);

713Assert.NotSame(GooString, string1); 714Assert.NotSame(BarString, string2); 715Assert.NotSame(largeString, string3); 727Assert.NotSame(largeString, string4); 728Assert.NotSame(BarString, string5); 729Assert.NotSame(GooString, string6);

622Assert.NotSame(dependencyGraph, solution.SolutionState.GetProjectDependencyGraph());

68Assert.NotSame(mutableItems, items);

312Assert.NotSame(root, actualRoot); 1017Assert.NotSame(newSolution1, newSolution2); 1039Assert.NotSame(newSolution1, newSolution2); 1061Assert.NotSame(newSolution1, newSolution2); 2651Assert.NotSame(document1, document2); 2677Assert.NotSame(document1, document2); 2678Assert.NotSame(document1.Project, document2.Project); 3233Assert.NotSame(tree, tree2); 3234Assert.NotSame(annotatedRoot, root2); 4125Assert.NotSame(frozenDocument, documentToFreeze); 4150Assert.NotSame(frozenDocument, documentToFreeze); 4184Assert.NotSame(frozenDocument, documentToFreezeChanged); 4229Assert.NotSame(frozenDocument, documentToFreezeChanged); 4479Assert.NotSame(doc1Root, doc2Root); 4489Assert.NotSame(frozenDoc1Root, frozenDoc2Root); 4504Assert.NotSame(frozenDoc1Root, frozenDoc2Root); 4724Assert.NotSame(originalCompilation, newCompilation); 4891Assert.NotSame(originalCompilation, newCompilation); 5118Assert.NotSame(compilation1, compilation1New); 5150Assert.NotSame(compilation1, compilation1New); 5218Assert.NotSame(compilation1, compilation1New); 5484Assert.NotSame(root, newRoot); 5486Assert.NotSame(doc, newDoc); 5813Assert.NotSame(generatedDocuments.Single(), forkedGeneratedDocuments.Single());

67Assert.NotSame(originalCompilation, newCompilation); 353Assert.NotSame(partialProject, project); 380Assert.NotSame(generatedDocumentBeforeChange, generatedDocumentAfterChange); 515Assert.NotSame(generatedTreeBeforeChange, generatedTreeAfterChange); 602Assert.NotSame(workspace.CurrentSolution, generatedDocument.Project.Solution); 739Assert.NotSame(frozenDocument, documentToFreeze);

264Assert.NotSame(optionSet, newOptionSet);

82Assert.NotSame(text, text2);

346Assert.NotSame(root, newRoot); 348Assert.NotSame(doc, newDoc);

285Assert.NotSame(column, clonedColumn); 305Assert.NotSame(column, clonedColumn); 327Assert.NotSame(column, clonedColumn); 348Assert.NotSame(column, clonedColumn); 369Assert.NotSame(column, clonedColumn); 390Assert.NotSame(column, clonedColumn); 411Assert.NotSame(column, clonedColumn); 432Assert.NotSame(column, clonedColumn); 453Assert.NotSame(column, clonedColumn);

28Assert.NotSame(stringColumn, clonedColumn); 44Assert.NotSame(stringColumn, clonedColumn); 60Assert.NotSame(stringColumn, clonedColumn); 76Assert.NotSame(stringColumn, clonedColumn); 93Assert.NotSame(stringColumn, clonedColumn);

14 var ex = Record.Exception(() => Assert.NotSame(actual, actual)); 23 Assert.NotSame("bob", "jim");

187Assert.NotSame(contents, message.Contents);

188Assert.NotSame(stopSequences, deserialized.StopSequences);

42Assert.NotSame(messages, response.Messages);

1075Assert.NotSame(expectedPerson, response.Result);

62Assert.NotSame(providedOptions, options);

193Assert.NotSame(ex1, ex2); 456Assert.NotSame(result1, result2); 505Assert.NotSame(ex1, ex2); 728Assert.NotSame(result2.Messages.Last().Contents[0], expectedResponse.Messages.Last().Contents[0]); 729Assert.NotSame(result2.Messages.Last().Contents[1], expectedResponse.Messages.Last().Contents[1]);

52Assert.NotSame(providedOptions, options);

38Assert.NotSame(additionalValues, generator.CacheKeyAdditionalValues); 198Assert.NotSame(ex1, ex2);

414Assert.NotSame(mft, result?.Item1); 461Assert.NotSame(d1, d2); 480Assert.NotSame(d1, d2); 499Assert.NotSame(d1, d2);

63Assert.NotSame(providedOptions, options);

60Assert.NotSame(first, second); 155Assert.NotSame(first, second); 218Assert.NotSame(first, second);

72Assert.NotSame(s, x); 120Assert.NotSame(s, x); 130Assert.NotSame(s, x); 142Assert.NotSame(s, x);

26Assert.NotSame(x, y); 46Assert.NotSame(x, y); 66Assert.NotSame(x, y);

191Assert.NotSame(first, second); 257Assert.NotSame(first, second);

356Assert.NotSame(first, second); 396Assert.NotSame(first, second); 438Assert.NotSame(first, second); 444Assert.NotSame(x, y);

124Assert.NotSame(result1, result2); 241Assert.NotSame(result1, result2); 261Assert.NotSame(result1, result2);

291Assert.NotSame(resolved1, resolved2); 292Assert.NotSame(resolved3, resolved4); 350Assert.NotSame(resolved1, resolved3);

69Assert.NotSame(list1, list2); 81Assert.NotSame(r, p.Get());

57Assert.NotSame(list1, list2);

26Assert.NotSame(lcp.CreateContext(), lcp.CreateContext());

291Assert.NotSame(obj1Ref, runtime.GetObjectReference(2));

131Assert.NotSame(mediaType0, mediaType1); 133Assert.NotSame(mediaType0.Parameters, mediaType1.Parameters); 142Assert.NotSame(mediaType0, mediaType1); 144Assert.NotSame(mediaType0.Parameters, mediaType1.Parameters); 158Assert.NotSame(mediaType0, mediaType1); 160Assert.NotSame(mediaType0.Parameters, mediaType1.Parameters); 164Assert.NotSame(pair0, pair1); 175Assert.NotSame(mediaType0, mediaType1); 180Assert.NotSame(mediaType0.Parameters, mediaType1.Parameters); 190Assert.NotSame(pair0, pair1); 205Assert.NotSame(mediaType2, mediaType1); 209Assert.NotSame(mediaType2.Parameters, mediaType1.Parameters); 213Assert.NotSame(pair2, pair1);

62Assert.NotSame(pair0, pair1); 78Assert.NotSame(pair0, pair1); 97Assert.NotSame(pair0, pair1); 112Assert.NotSame(pair0, pair1); 131Assert.NotSame(pair0, pair1);

143Assert.NotSame(sb, sb2); 217Assert.NotSame(s, s2);

67Assert.NotSame(referenceAssemblies, context.ReferenceAssemblies); 95Assert.NotSame(referenceAssemblies, context.ReferenceAssemblies);

688Assert.NotSame(result1, result2);

1331Assert.NotSame(freezable, clone); 1352Assert.NotSame(freezable, clone); 1353Assert.NotSame(clone, clone2); 1421Assert.NotSame(freezable, clone); 1427Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 1430Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 1433Assert.NotSame(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 1490Assert.NotSame(freezable, clone); 1496Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 1499Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 1502Assert.NotSame(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 1540Assert.NotSame(freezable, clone); 1610Assert.NotSame(freezable, clone); 1643Assert.NotSame(freezable, clone); 1723Assert.NotSame(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 1726Assert.NotSame(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 1729Assert.NotSame(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 1827Assert.NotSame(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 1830Assert.NotSame(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 1833Assert.NotSame(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 2217Assert.NotSame(freezable, clone); 2238Assert.NotSame(freezable, clone); 2239Assert.NotSame(clone, clone2); 2307Assert.NotSame(freezable, clone); 2313Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 2316Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 2319Assert.NotSame(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 2376Assert.NotSame(freezable, clone); 2382Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 2385Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 2388Assert.NotSame(anotherFreezable3, ((SubFreezable)clone.GetValue(SubFreezable.Property8))); 2426Assert.NotSame(freezable, clone); 2493Assert.NotSame(freezable, clone); 2526Assert.NotSame(freezable, clone); 2606Assert.NotSame(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 2609Assert.NotSame(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 2612Assert.NotSame(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 2710Assert.NotSame(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 2713Assert.NotSame(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 2716Assert.NotSame(anotherFreezable3, ((SubFreezable)freezable.GetValue(SubFreezable.Property8))); 4363Assert.NotSame(freezable, clone); 4383Assert.NotSame(freezable, clone); 4384Assert.NotSame(clone, clone2); 4450Assert.NotSame(freezable, clone); 4456Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 4459Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 4518Assert.NotSame(freezable, clone); 4524Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 4527Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 4719Assert.NotSame(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 4722Assert.NotSame(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7))); 5216Assert.NotSame(freezable, clone); 5236Assert.NotSame(freezable, clone); 5237Assert.NotSame(clone, clone2); 5303Assert.NotSame(freezable, clone); 5309Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 5312Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 5371Assert.NotSame(freezable, clone); 5377Assert.NotSame(anotherFreezable1, ((SubFreezable)clone.GetValue(SubFreezable.Property6))); 5380Assert.NotSame(anotherFreezable2, ((SubFreezable)clone.GetValue(SubFreezable.Property7))); 5572Assert.NotSame(anotherFreezable1, ((SubFreezable)freezable.GetValue(SubFreezable.Property6))); 5575Assert.NotSame(anotherFreezable2, ((SubFreezable)freezable.GetValue(SubFreezable.Property7)));

25Assert.NotSame(obj.Properties, obj.Properties); 39Assert.NotSame(obj.Properties, obj.Properties); 73Assert.NotSame(obj.Properties, obj.Properties); 93Assert.NotSame(properties[0].Items, properties[0].Items); 108Assert.NotSame(obj.Properties, obj.Properties); 127Assert.NotSame(obj, Assert.Single(properties[0].Items)); 128Assert.NotSame(properties[0].Items, properties[0].Items); 147Assert.NotSame(properties[1].Items, properties[1].Items); 167Assert.NotSame(obj.Properties, obj.Properties); 187Assert.NotSame(properties[0].Items, properties[0].Items); 203Assert.NotSame(obj.Properties, obj.Properties); 223Assert.NotSame(properties[0].Items, properties[0].Items); 241Assert.NotSame(obj.Properties, obj.Properties); 260Assert.NotSame(obj, Assert.Single(properties[0].Items)); 261Assert.NotSame(properties[0].Items, properties[0].Items); 280Assert.NotSame(obj.Properties, obj.Properties); 299Assert.NotSame(obj, Assert.Single(properties[0].Items)); 300Assert.NotSame(properties[0].Items, properties[0].Items); 319Assert.NotSame(obj.Properties, obj.Properties); 338Assert.NotSame(obj, Assert.Single(properties[0].Items)); 339Assert.NotSame(properties[0].Items, properties[0].Items); 363Assert.NotSame(obj.Properties, obj.Properties); 382Assert.NotSame(obj, Assert.Single(properties[0].Items)); 383Assert.NotSame(properties[0].Items, properties[0].Items); 398Assert.NotSame(obj.Properties, obj.Properties); 412Assert.NotSame(obj.Properties, obj.Properties); 431Assert.NotSame(obj, Assert.Single(properties[0].Items)); 432Assert.NotSame(properties[0].Items, properties[0].Items); 450Assert.NotSame(obj, Assert.Single(properties[1].Items)); 451Assert.NotSame(properties[1].Items, properties[1].Items);

26Assert.NotSame(obj.Properties, obj.Properties); 60Assert.NotSame(obj.Properties, obj.Properties); 80Assert.NotSame(properties[0].Items, properties[0].Items); 95Assert.NotSame(obj.Properties, obj.Properties); 114Assert.NotSame(obj, Assert.Single(properties[0].Items)); 115Assert.NotSame(properties[0].Items, properties[0].Items); 134Assert.NotSame(properties[1].Items, properties[1].Items); 154Assert.NotSame(obj.Properties, obj.Properties); 174Assert.NotSame(properties[0].Items, properties[0].Items); 190Assert.NotSame(obj.Properties, obj.Properties); 210Assert.NotSame(properties[0].Items, properties[0].Items); 228Assert.NotSame(obj.Properties, obj.Properties); 247Assert.NotSame(obj, Assert.Single(properties[0].Items)); 248Assert.NotSame(properties[0].Items, properties[0].Items); 267Assert.NotSame(obj.Properties, obj.Properties); 286Assert.NotSame(obj, Assert.Single(properties[0].Items)); 287Assert.NotSame(properties[0].Items, properties[0].Items); 306Assert.NotSame(obj.Properties, obj.Properties); 325Assert.NotSame(obj, Assert.Single(properties[0].Items)); 326Assert.NotSame(properties[0].Items, properties[0].Items); 350Assert.NotSame(obj.Properties, obj.Properties); 369Assert.NotSame(obj, Assert.Single(properties[0].Items)); 370Assert.NotSame(properties[0].Items, properties[0].Items); 385Assert.NotSame(obj.Properties, obj.Properties); 404Assert.NotSame(obj, Assert.Single(properties[0].Items)); 405Assert.NotSame(properties[0].Items, properties[0].Items); 423Assert.NotSame(obj, Assert.Single(properties[1].Items)); 424Assert.NotSame(properties[1].Items, properties[1].Items);

134Assert.NotSame(nameScope.Keys, nameScope.Keys); 137Assert.NotSame(nameScope.Values, nameScope.Values); 147Assert.NotSame(nameScope.Keys, nameScope.Keys); 150Assert.NotSame(nameScope.Values, nameScope.Values); 255Assert.NotSame(nameScope.Keys, nameScope.Keys); 258Assert.NotSame(nameScope.Values, nameScope.Values); 268Assert.NotSame(nameScope.Keys, nameScope.Keys); 271Assert.NotSame(nameScope.Values, nameScope.Values); 349Assert.NotSame(nameScope.Keys, nameScope.Keys); 352Assert.NotSame(nameScope.Values, nameScope.Values); 362Assert.NotSame(nameScope.Keys, nameScope.Keys); 365Assert.NotSame(nameScope.Values, nameScope.Values); 852Assert.NotSame(nameScope.Keys, nameScope.Keys); 855Assert.NotSame(nameScope.Values, nameScope.Values); 865Assert.NotSame(nameScope.Keys, nameScope.Keys); 868Assert.NotSame(nameScope.Values, nameScope.Values);

380Assert.NotSame(propertyChangedCallback, metadata.PropertyChangedCallback);

61Assert.NotSame(context, copy); 71Assert.NotSame(context, copy);

763Assert.NotSame(list, manager.NewListenerList()); 1142Assert.NotSame(list2, list1); 1510Assert.NotSame(list2, list1); 1922Assert.NotSame(list3, list1); 1934Assert.NotSame(list3, list1); 2352Assert.NotSame(list3, list1); 2364Assert.NotSame(list3, list1); 3118Assert.NotSame(originalList, list); 3124Assert.NotSame(originalList, list); 3221Assert.NotSame(originalList, list); 3294Assert.NotSame(originalList, list); 3933Assert.NotSame(list, newList); 3950Assert.NotSame(list, newList); 3978Assert.NotSame(list, newList); 4014Assert.NotSame(list, newList); 5695Assert.NotSame(list, newList); 5712Assert.NotSame(list, newList); 5740Assert.NotSame(list, newList); 5776Assert.NotSame(list, newList);