25295 references to True
Aspire.Components.Common.Tests (2)
Aspire.Confluent.Kafka.Tests (4)
Aspire.Dashboard.Components.Tests (26)
Aspire.Dashboard.Tests (32)
ResourceOutgoingPeerResolverTests.cs (7)
72Assert.True(TryResolvePeerName(resources, [KeyValuePair.Create("peer.service", "localhost:5000")], out var value));
86Assert.True(TryResolvePeerName(resources, [KeyValuePair.Create("peer.service", "127.0.0.1:5000")], out var value));
100Assert.True(TryResolvePeerName(resources, [KeyValuePair.Create("peer.service", "127.0.0.1,5000")], out var value));
114Assert.True(TryResolvePeerName(resources, [KeyValuePair.Create("server.address", "localhost"), KeyValuePair.Create("server.port", "5000")], out var value));
173Assert.True(TryResolvePeerName(resources, [KeyValuePair.Create("server.address", "localhost"), KeyValuePair.Create("server.port", "5000")], out var value));
188Assert.True(TryResolvePeerName(resources, [KeyValuePair.Create("server.address", "localhost"), KeyValuePair.Create("server.port", "5000")], out var value1));
191Assert.True(TryResolvePeerName(resources, [KeyValuePair.Create("server.address", "localhost"), KeyValuePair.Create("server.port", "5001")], out var value2));
TelemetryRepositoryTests\LogTests.cs (5)
249Assert.True(unviewedCounts1.TryGetValue(new ApplicationKey("TestService", "1"), out var unviewedCount1));
252Assert.True(unviewedCounts1.TryGetValue(new ApplicationKey("TestService", "2"), out var unviewedCount2));
261Assert.True(unviewedCounts2.TryGetValue(new ApplicationKey("TestService", "2"), out unviewedCount2));
373Assert.True(unviewedCounts.TryGetValue(new ApplicationKey("TestService", "2"), out var unviewedCount));
410Assert.True(unviewedCounts.TryGetValue(new ApplicationKey("TestService", "1"), out var unviewedCount));
Aspire.Hosting.Azure.Tests (44)
Aspire.Hosting.Containers.Tests (1)
Aspire.Hosting.Elasticsearch.Tests (3)
Aspire.Hosting.Garnet.Tests (4)
Aspire.Hosting.MySql.Tests (8)
Aspire.Hosting.PostgreSQL.Tests (5)
Aspire.Hosting.Redis.Tests (3)
Aspire.Hosting.Sdk.Tests (1)
Aspire.Hosting.SqlServer.Tests (4)
Aspire.Hosting.Testing.Tests (9)
Aspire.Hosting.Tests (74)
Dcp\DcpExecutorTests.cs (23)
122Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
130Assert.True(svc.Status?.EffectivePort >= TestKubernetesService.StartOfAutoPortRange);
154Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
186Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
194Assert.True(svc.Status?.EffectivePort >= TestKubernetesService.StartOfAutoPortRange);
219Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
276Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
310Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
344Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
481Assert.True(watchSubscribersEnumerator.Current.AnySubscribers);
490Assert.True(await moveNextTask);
501Assert.True(await moveNextTask);
505Assert.True(logLine.IsErrorMessage);
577Assert.True(watchSubscribersEnumerator.Current.AnySubscribers);
674Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
682Assert.True(svc.Status?.EffectivePort >= TestKubernetesService.StartOfAutoPortRange);
719Assert.True(dcpExe.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
752Assert.True(dcpCtr.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
760Assert.True(svc.Status?.EffectivePort >= TestKubernetesService.StartOfAutoPortRange);
787Assert.True(dcpCtr.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
868Assert.True(dcpCtr.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
904Assert.True(dcpCtr.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
941Assert.True(dcpCtr.TryGetAnnotationAsObjectList<ServiceProducerAnnotation>(CustomResource.ServiceProducerAnnotation, out var spAnnList));
Aspire.Hosting.Valkey.Tests (4)
Aspire.NATS.Net.Tests (2)
Aspire.Npgsql.Tests (1)
Aspire.OpenAI.Tests (2)
Aspire.RabbitMQ.Client.Tests (1)
Aspire.RabbitMQ.Client.v7.Tests (1)
Aspire.Workload.Tests (3)
Binding.ReliableSession.IntegrationTests (4)
Client.ChannelLayer.IntegrationTests (4)
Client.ClientBase.IntegrationTests (2)
Client.ExpectedExceptions.IntegrationTests (2)
ComDisabled.Tests (2)
ConfigurationSchemaGenerator.Tests (1)
Contract.XmlSerializer.IntegrationTests (7)
Diagnostics.EFCore.FunctionalTests (6)
Diagnostics.FunctionalTests (1)
dotnet-svcutil.xmlserializer.IntegrationTests (9)
IdeBenchmarks (1)
IIS.Common.TestLib (1)
IIS.FunctionalTests (27)
IIS.LongTests (9)
IIS.NewHandler.FunctionalTests (10)
IIS.NewShim.FunctionalTests (9)
IIS.ShadowCopy.Tests (24)
IIS.Tests (5)
IISExpress.FunctionalTests (29)
InMemory.FunctionalTests (191)
Http2\Http2ConnectionTests.cs (28)
604Assert.True(output._disposed);
711Assert.True(((Http2OutputProducer)pooledStream.Output)._disposed);
792Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray()));
820Assert.True(_maxData.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray()));
917Assert.True(_maxData.AsSpan().SequenceEqual(frame.PayloadSequence.ToArray()));
986Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray()));
1050Assert.True(_helloBytes.AsSpan().SequenceEqual(stream1DataFrame1.PayloadSequence.ToArray()));
1051Assert.True(_worldBytes.AsSpan().SequenceEqual(stream1DataFrame2.PayloadSequence.ToArray()));
1052Assert.True(_helloBytes.AsSpan().SequenceEqual(stream3DataFrame1.PayloadSequence.ToArray()));
1053Assert.True(_worldBytes.AsSpan().SequenceEqual(stream3DataFrame2.PayloadSequence.ToArray()));
1165Assert.True(_maxData.AsSpan().SequenceEqual(frame.PayloadSequence.ToArray()));
1270Assert.True(_helloWorldBytes.AsSpan().SequenceEqual(dataFrame.PayloadSequence.ToArray()));
1310Assert.True(dataSent >= frame.PayloadLength);
1340Assert.True(_maxData.AsSpan().SequenceEqual(dataFrame3.PayloadSequence.ToArray()));
1475Assert.True(_maxData.AsSpan().SequenceEqual(frame.PayloadSequence.ToArray()));
2250Assert.True(_receivedTrailers.ContainsKey(header.Key));
2363Assert.True(integerDecoder.BeginTryDecode((byte)(headerFrame.Payload.Span[0] & ~DynamicTableSizeUpdateMask), prefixLength: 5, out var result));
3375Assert.True(_helloWorldBytes.AsSpan(0, initialWindowSize).SequenceEqual(dataFrame.PayloadSequence.ToArray()));
4047Assert.True(integerDecoder.TryDecode(headerFrame.Payload.Span[3], out var result));
4382Assert.True(_helloWorldBytes.AsSpan(0, initialWindowSize).SequenceEqual(dataFrame.PayloadSequence.ToArray()));
4710Assert.True(_helloWorldBytes.AsSpan(0, initialWindowSize).SequenceEqual(dataFrame1.PayloadSequence.ToArray()));
4711Assert.True(_helloWorldBytes.AsSpan(initialWindowSize, initialWindowSize).SequenceEqual(dataFrame2.PayloadSequence.ToArray()));
4765Assert.True(_helloWorldBytes.AsSpan(0, 6).SequenceEqual(dataFrame1.PayloadSequence.ToArray()));
4766Assert.True(_helloWorldBytes.AsSpan(6, 3).SequenceEqual(dataFrame2.PayloadSequence.ToArray()));
4767Assert.True(_helloWorldBytes.AsSpan(9, 3).SequenceEqual(dataFrame3.PayloadSequence.ToArray()));
4882Assert.True(_receivedTrailers.ContainsKey("trailer-1"));
4883Assert.True(_receivedTrailers.ContainsKey("trailer-2"));
5678Assert.True(result.IsCompleted);
InProcessWebSite (6)
InteractiveHost.UnitTests (32)
Interop.FunctionalTests (26)
Microsoft.Analyzers.Extra.Tests (1)
Microsoft.Analyzers.Local.Tests (42)
Microsoft.AspNetCore.Analyzers.Test (10)
Microsoft.AspNetCore.Antiforgery.Test (36)
Microsoft.AspNetCore.App.Analyzers.Test (14)
Microsoft.AspNetCore.App.UnitTests (1)
Microsoft.AspNetCore.AsyncState.Tests (3)
Microsoft.AspNetCore.Authentication.Core.Test (14)
Microsoft.AspNetCore.Authentication.JwtBearer.Tools.Tests (13)
Microsoft.AspNetCore.Authentication.Negotiate.Test (4)
Microsoft.AspNetCore.Authentication.Test (65)
Microsoft.AspNetCore.Authorization.Test (64)
DefaultAuthorizationServiceTests.cs (29)
47Assert.True(allowed.Succeeded);
68Assert.True(allowed.Succeeded);
90Assert.True(allowed.Succeeded);
111Assert.True(allowed.Failure.FailCalled);
112Assert.True(handler1.Invoked);
113Assert.True(handler2.Invoked);
138Assert.True(handler1.Invoked);
329Assert.True(allowed.Succeeded);
364Assert.True(allowed.Succeeded);
385Assert.True(allowed.Succeeded);
402Assert.True(allowed.Succeeded);
419Assert.True(allowed.Succeeded);
435Assert.True(allowed.Succeeded);
530Assert.True(allowed.Succeeded);
552Assert.True(allowed.Succeeded);
574Assert.True(allowed.Succeeded);
599Assert.True(allowed.Succeeded);
673Assert.True(allowed.Succeeded);
742Assert.True(allowed.Succeeded);
858Assert.True((await authorizationService.AuthorizeAsync(user, null, Operations.Edit)).Succeeded);
859Assert.True((await authorizationService.AuthorizeAsync(user, null, Operations.Delete)).Succeeded);
860Assert.True((await authorizationService.AuthorizeAsync(user, null, Operations.Create)).Succeeded);
901Assert.True((await authorizationService.AuthorizeAsync(user, 2, Operations.Edit)).Succeeded);
937Assert.True((await authorizationService.AuthorizeAsync(user, new ExpenseReport(), Operations.Edit)).Succeeded);
973Assert.True(allowed.Succeeded);
992Assert.True(allowed.Succeeded);
1069Assert.True((await authorizationService.AuthorizeAsync(user, "1")).Succeeded);
1070Assert.True((await authorizationService.AuthorizeAsync(user, "2")).Succeeded);
1088Assert.True(result.Succeeded);
Microsoft.AspNetCore.AzureAppServices.SiteExtension.Tests (1)
Microsoft.AspNetCore.Components.Authorization.Tests (5)
Microsoft.AspNetCore.Components.Endpoints.Tests (30)
Microsoft.AspNetCore.Components.Forms.Tests (23)
Microsoft.AspNetCore.Components.Server.Tests (43)
Circuits\ServerComponentDeserializerTest.cs (17)
33Assert.True(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors));
48Assert.True(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors));
67Assert.True(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors));
86Assert.True(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors));
108Assert.True(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors));
138Assert.True(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors));
252Assert.True(serverComponentDeserializer.TryDeserializeComponentDescriptorCollection(markers, out var descriptors));
314Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(markers[0], out var descriptor));
328Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(markers[0], out var firstDescriptor));
329Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(markers[1], out var secondDescriptor));
349Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(markers[1], out _));
350Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(markers[0], out _));
363Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(firstInvocationMarkers[0], out _));
364Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(secondInvocationMarkers[0], out _));
375Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(markers[0], out _));
389Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(firstInvocationMarkers[0], out _));
390Assert.True(serverComponentDeserializer.TryDeserializeWebRootComponentDescriptor(secondInvocationMarkers[0], out _));
Microsoft.AspNetCore.Components.Tests (148)
Microsoft.AspNetCore.Components.Web.Tests (11)
Microsoft.AspNetCore.Components.WebAssembly.Server.Tests (14)
ContentEncodingNegotiatorTests.cs (14)
29Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding));
31Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
72Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding));
74Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
95Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding));
97Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
118Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding));
120Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
141Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding));
143Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
164Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding));
166Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
207Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.ContentEncoding, out var selectedEncoding));
209Assert.True(httpContext.Response.Headers.TryGetValue(HeaderNames.Vary, out var varyHeader));
Microsoft.AspNetCore.Components.WebAssembly.Tests (3)
Microsoft.AspNetCore.Components.WebView.Test (5)
Microsoft.AspNetCore.ConcurrencyLimiter.Tests (26)
Microsoft.AspNetCore.CookiePolicy.Test (74)
Microsoft.AspNetCore.Cors.Test (17)
Microsoft.AspNetCore.Cryptography.Internal.Tests (6)
Microsoft.AspNetCore.DataProtection.Tests (76)
KeyManagement\KeyRingProviderTests.cs (16)
49Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
92Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
140Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
142Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
229Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
231Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
313Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
315Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
353Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
391Assert.True(CacheableKeyRing.IsValid(cacheableKeyRing, now));
439Assert.True(activation1 < now); // Key1 is active
440Assert.True(now < activation2); // Key2 is not yet active
441Assert.True(now < expiration1); // Key1 is not expired (also implies activation1 < expiration1)
442Assert.True(activation2 < expiration2); // Key2 is not well-formed (also implies Key2 is unexpired, now < expiration2)
443Assert.True(activation2 < expiration1); // Key1 and Key2 have overlapping activation periods - the alternative is covered in other tests
799Assert.True(resolveDefaultKeyPolicyReturnValuesEnumerator.MoveNext());
Microsoft.AspNetCore.DeveloperCertificates.XPlat.Tests (12)
Microsoft.AspNetCore.Diagnostics.Middleware.Tests (65)
Microsoft.AspNetCore.Diagnostics.Tests (35)
ExceptionHandlerTest.cs (23)
160Assert.True(httpContext.Response.Body.CanSeek);
186Assert.True(response.Headers.CacheControl.NoCache);
187Assert.True(response.Headers.CacheControl.NoStore);
188Assert.True(response.Headers.TryGetValues("Pragma", out values));
191Assert.True(response.Content.Headers.TryGetValues("Expires", out values));
242Assert.True(response.Headers.CacheControl.NoCache);
243Assert.True(response.Headers.CacheControl.NoStore);
244Assert.True(response.Headers.TryGetValues("Pragma", out values));
247Assert.True(response.Content.Headers.TryGetValues("Expires", out values));
297Assert.True(response.Headers.TryGetValues("Cache-Control", out values));
300Assert.True(response.Headers.TryGetValues("Pragma", out values));
303Assert.True(response.Content.Headers.TryGetValues("Expires", out values));
306Assert.True(response.Headers.TryGetValues("ETag", out values));
369Assert.True(response.Headers.CacheControl.NoCache);
370Assert.True(response.Headers.CacheControl.NoStore);
371Assert.True(response.Headers.TryGetValues("Pragma", out values));
439Assert.True(response.Headers.TryGetValues("Cache-Control", out values));
442Assert.True(response.Headers.TryGetValues("Pragma", out values));
445Assert.True(response.Content.Headers.TryGetValues("Expires", out values));
448Assert.True(response.Headers.TryGetValues("ETag", out values));
1038Assert.True(m.Value > 0);
1108Assert.True(m.Value > 0);
1170Assert.True(m.Value > 0);
Microsoft.AspNetCore.FunctionalTests (8)
Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests (9)
Microsoft.AspNetCore.Grpc.Swagger.Tests (21)
Microsoft.AspNetCore.HeaderParsing.Tests (39)
Microsoft.AspNetCore.HeaderPropagation.Tests (17)
Microsoft.AspNetCore.HostFiltering.Tests (8)
Microsoft.AspNetCore.Hosting.Tests (80)
Microsoft.AspNetCore.Http.Abstractions.Tests (62)
Microsoft.AspNetCore.Http.Connections.Tests (50)
HttpConnectionDispatcherTests.cs (38)
98Assert.True(manager.TryGetConnection(connectionToken, out var connectionContext));
125Assert.True(manager.TryGetConnection(connectionToken, out var connection));
244Assert.True(connection.Transport.Input.TryRead(out var result));
480Assert.True(result.IsCompleted);
544Assert.True(result.IsCompleted);
612Assert.True(connection.Transport.Input.TryRead(out var result));
790Assert.True(task.IsCompleted);
1174Assert.True(measurement.Value > 0);
1495Assert.True(request1.IsCompleted);
1562Assert.True(request1.IsCompleted);
1725Assert.True(task.IsCompleted);
1766Assert.True(task1.IsCompleted);
1971Assert.True(((WindowsIdentity)connection.User.Identity).AccessToken.IsClosed);
1999Assert.True(connection.HasInherentKeepAlive);
2002Assert.True(connection.Features.Get<IConnectionInherentKeepAliveFeature>().HasInherentKeepAlive);
2070Assert.True(pollTask.IsCompleted);
2175Assert.True(pollTask.IsCompleted);
2201Assert.True(manager.TryGetConnection(connection.ConnectionId, out _));
2305Assert.True(manager.TryGetConnection(negotiateResponse["connectionToken"].ToString(), out var connection));
2334Assert.True(manager.TryGetConnection(negotiateResponse["connectionToken"].ToString(), out var connection));
2361Assert.True((bool)negotiateResponse["useStatefulReconnect"]);
2363Assert.True(manager.TryGetConnection(negotiateResponse["connectionToken"].ToString(), out var connection));
2781Assert.True(pollTask.IsCompleted);
2809Assert.True(manager.TryGetConnection(connection.ConnectionId, out _));
3280Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context));
3282Assert.True(context.AuthenticationExpiration > DateTimeOffset.UtcNow);
3283Assert.True(context.AuthenticationExpiration < DateTimeOffset.MaxValue);
3342Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context));
3344Assert.True(context.AuthenticationExpiration > DateTimeOffset.UtcNow);
3345Assert.True(context.AuthenticationExpiration < DateTimeOffset.MaxValue);
3442Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context));
3444Assert.True(context.AuthenticationExpiration > DateTimeOffset.UtcNow);
3445Assert.True(context.AuthenticationExpiration < DateTimeOffset.MaxValue);
3481Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context));
3522Assert.True(((HttpRequestTimeoutFeature)c.Features.Get<IHttpRequestTimeoutFeature>()).Enabled);
3559Assert.True(manager.TryGetConnection(negotiateResponse.ConnectionToken, out var context));
3584Assert.True(((HttpRequestTimeoutFeature)context.Features.Get<IHttpRequestTimeoutFeature>()).Enabled);
3591Assert.True(((HttpRequestTimeoutFeature)context.Features.Get<IHttpRequestTimeoutFeature>()).Enabled);
Microsoft.AspNetCore.Http.Extensions.Tests (47)
Microsoft.AspNetCore.Http.Microbenchmarks (1)
Microsoft.AspNetCore.Http.Results.Tests (43)
Microsoft.AspNetCore.Http.Tests (22)
Microsoft.AspNetCore.HttpLogging.Tests (16)
Microsoft.AspNetCore.HttpOverrides.Tests (23)
Microsoft.AspNetCore.Identity.EntityFrameworkCore.Test (61)
MaxKeyLengthSchemaTest.cs (10)
67Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUsers", "Id", "UserName", "Email", "PasswordHash", "SecurityStamp",
70Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetRoles", "Id", "Name", "NormalizedName", "ConcurrencyStamp"));
71Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserRoles", "UserId", "RoleId"));
72Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserClaims", "Id", "UserId", "ClaimType", "ClaimValue"));
73Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserLogins", "UserId", "ProviderKey", "LoginProvider", "ProviderDisplayName"));
74Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserTokens", "UserId", "LoginProvider", "Name", "Value"));
76Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUsers", 256, "UserName", "Email", "NormalizedUserName", "NormalizedEmail"));
77Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetRoles", 256, "Name", "NormalizedName"));
78Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserLogins", 128, "LoginProvider", "ProviderKey"));
79Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserTokens", 128, "LoginProvider", "Name"));
SqlStoreOnlyUsersTestBase.cs (5)
85Assert.True(DbUtil.VerifyColumns(db, "AspNetUsers", "Id", "UserName", "Email", "PasswordHash", "SecurityStamp",
90Assert.True(DbUtil.VerifyColumns(db, "AspNetUserClaims", "Id", "UserId", "ClaimType", "ClaimValue"));
91Assert.True(DbUtil.VerifyColumns(db, "AspNetUserLogins", "UserId", "ProviderKey", "LoginProvider", "ProviderDisplayName"));
92Assert.True(DbUtil.VerifyColumns(db, "AspNetUserTokens", "UserId", "LoginProvider", "Name", "Value"));
127Assert.True(db.Users.Any(u => u.UserName == user.UserName));
SqlStoreTestBase.cs (9)
135Assert.True(DbUtil.VerifyColumns(db, "AspNetUsers", "Id", "UserName", "Email", "PasswordHash", "SecurityStamp",
138Assert.True(DbUtil.VerifyColumns(db, "AspNetRoles", "Id", "Name", "NormalizedName", "ConcurrencyStamp"));
139Assert.True(DbUtil.VerifyColumns(db, "AspNetUserRoles", "UserId", "RoleId"));
140Assert.True(DbUtil.VerifyColumns(db, "AspNetUserClaims", "Id", "UserId", "ClaimType", "ClaimValue"));
141Assert.True(DbUtil.VerifyColumns(db, "AspNetUserLogins", "UserId", "ProviderKey", "LoginProvider", "ProviderDisplayName"));
142Assert.True(DbUtil.VerifyColumns(db, "AspNetUserTokens", "UserId", "LoginProvider", "Name", "Value"));
144Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUsers", 256, "UserName", "Email", "NormalizedUserName", "NormalizedEmail"));
145Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetRoles", 256, "Name", "NormalizedName"));
226Assert.True(db.Users.Any(u => u.UserName == user.UserName));
UserStoreEncryptPersonalDataTest.cs (7)
221Assert.True(FindInk(connection, "PhoneNumber", guid));
222Assert.True(FindInk(connection, "Email", guid));
223Assert.True(FindInk(connection, "UserName", guid));
224Assert.True(FindInk(connection, "PersonalData1", guid));
225Assert.True(FindInk(connection, "PersonalData2", guid));
226Assert.True(FindAuthenticatorKeyInk(connection, guid));
227Assert.True(FindTokenInk(connection, guid, "loginProvider", "token"));
VersionOneSchemaTest.cs (10)
53Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUsers", "Id", "UserName", "Email", "PasswordHash", "SecurityStamp",
56Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetRoles", "Id", "Name", "NormalizedName", "ConcurrencyStamp"));
57Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserRoles", "UserId", "RoleId"));
58Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserClaims", "Id", "UserId", "ClaimType", "ClaimValue"));
59Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserLogins", "UserId", "ProviderKey", "LoginProvider", "ProviderDisplayName"));
60Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserTokens", "UserId", "LoginProvider", "Name", "Value"));
62Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUsers", 256, "UserName", "Email", "NormalizedUserName", "NormalizedEmail"));
63Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetRoles", 256, "Name", "NormalizedName"));
64Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserLogins", 128, "LoginProvider", "ProviderKey"));
65Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserTokens", 128, "LoginProvider", "Name"));
VersionTwoSchemaTest.cs (10)
53Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUsers", "Id", "UserName", "Email", "PasswordHash", "SecurityStamp",
56Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetRoles", "Id", "Name", "NormalizedName", "ConcurrencyStamp"));
57Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserRoles", "UserId", "RoleId"));
58Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserClaims", "Id", "UserId", "ClaimType", "ClaimValue"));
59Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserLogins", "UserId", "ProviderKey", "LoginProvider", "ProviderDisplayName"));
60Assert.True(DbUtil.VerifyColumns(sqlConn, "AspNetUserTokens", "UserId", "LoginProvider", "Name", "Value"));
62Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUsers", 256, "UserName", "Email", "NormalizedUserName", "NormalizedEmail", "PhoneNumber"));
63Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetRoles", 256, "Name", "NormalizedName"));
64Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserLogins", 128, "LoginProvider", "ProviderKey"));
65Assert.True(DbUtil.VerifyMaxLength(dbContext, "AspNetUserTokens", 128, "LoginProvider", "Name"));
Microsoft.AspNetCore.Identity.FunctionalTests (33)
Microsoft.AspNetCore.Identity.InMemory.Test (1)
Microsoft.AspNetCore.Identity.Specification.Tests (50)
UserManagerSpecificationTests.cs (39)
326Assert.True(await manager.CheckPasswordAsync(user, "password"));
333Assert.True(await manager.CheckPasswordAsync(user, "New"));
512Assert.True(await manager.CheckPasswordAsync(user, password));
604Assert.True(await manager.HasPasswordAsync(user));
609Assert.True(await manager.CheckPasswordAsync(user, "password"));
622Assert.True(await manager.HasPasswordAsync(user));
695Assert.True(await manager.CheckPasswordAsync(user, newPassword));
1003Assert.True(await manager.CheckPasswordAsync(user, newPassword));
1029Assert.True(await manager.CheckPasswordAsync(user, password));
1051Assert.True(await manager.CheckPasswordAsync(user, password));
1071Assert.True(await manager.VerifyUserTokenAsync(user, "Static", "test", token));
1100Assert.True(await manager.IsEmailConfirmedAsync(user));
1156Assert.True(await mgr.GetLockoutEnabledAsync(user));
1159Assert.True(await mgr.IsLockedOutAsync(user));
1160Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55));
1178Assert.True(await mgr.GetLockoutEnabledAsync(user));
1185Assert.True(await mgr.IsLockedOutAsync(user));
1186Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55));
1203Assert.True(await mgr.GetLockoutEnabledAsync(user));
1234Assert.True(await mgr.GetLockoutEnabledAsync(user));
1241Assert.True(await mgr.IsLockedOutAsync(user));
1242Assert.True(await mgr.GetLockoutEndDateAsync(user) > DateTimeOffset.UtcNow.AddMinutes(55));
1257Assert.True(await mgr.GetLockoutEnabledAsync(user));
1291Assert.True(await mgr.GetLockoutEnabledAsync(user));
1305Assert.True(await mgr.GetLockoutEnabledAsync(user));
1321Assert.True(await mgr.GetLockoutEnabledAsync(user));
1322Assert.True(await mgr.IsLockedOutAsync(user));
1335Assert.True(await mgr.GetLockoutEnabledAsync(user));
1338Assert.True(await mgr.IsLockedOutAsync(user));
1374Assert.True(await manager.IsPhoneNumberConfirmedAsync(user));
1390Assert.True(int.TryParse(token1, out _));
1440Assert.True(await manager.IsPhoneNumberConfirmedAsync(user));
1482Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token1, num1));
1483Assert.True(await manager.VerifyChangePhoneNumberTokenAsync(user, token2, num2));
1507Assert.True(await manager.IsEmailConfirmedAsync(user));
1530Assert.True(await manager.IsEmailConfirmedAsync(user));
1556Assert.True(await manager.IsEmailConfirmedAsync(user));
1675Assert.True(await manager.GetTwoFactorEnabledAsync(user));
1715Assert.True(!factors.Any());
Microsoft.AspNetCore.Identity.Test (47)
Microsoft.AspNetCore.InternalTesting.Tests (36)
Microsoft.AspNetCore.JsonPatch.Tests (35)
Microsoft.AspNetCore.Mvc.Abstractions.Test (21)
Microsoft.AspNetCore.Mvc.ApiExplorer.Test (28)
Microsoft.AspNetCore.Mvc.Core.Test (459)
Infrastructure\AsyncEnumerableReaderTest.cs (14)
41Assert.True(result);
59Assert.True(result);
75Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader1));
76Assert.True(readerFactory.TryGetReader(asyncEnumerable2.GetType(), out var reader2));
92Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader1));
93Assert.True(readerFactory.TryGetReader(asyncEnumerable2.GetType(), out var reader2));
110Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader));
127Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader));
144Assert.True(readerFactory.TryGetReader(enumerable1.GetType(), out var reader1));
145Assert.True(readerFactory.TryGetReader(enumerable2.GetType(), out var reader2));
164Assert.True(result);
182Assert.True(readerFactory.TryGetReader(enumerable.GetType(), out var reader));
198Assert.True(readerFactory.TryGetReader(enumerable.GetType(), out var reader));
213Assert.True(readerFactory.TryGetReader(enumerable.GetType(), out var reader));
Microsoft.AspNetCore.Mvc.Core.TestCommon (7)
Microsoft.AspNetCore.Mvc.DataAnnotations.Test (20)
Microsoft.AspNetCore.Mvc.Formatters.Xml.Test (7)
Microsoft.AspNetCore.Mvc.FunctionalTests (63)
Microsoft.AspNetCore.Mvc.IntegrationTests (802)
Microsoft.AspNetCore.Mvc.NewtonsoftJson.Test (34)
src\Mvc\Mvc.Core\test\Infrastructure\AsyncEnumerableReaderTest.cs (14)
41Assert.True(result);
59Assert.True(result);
75Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader1));
76Assert.True(readerFactory.TryGetReader(asyncEnumerable2.GetType(), out var reader2));
92Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader1));
93Assert.True(readerFactory.TryGetReader(asyncEnumerable2.GetType(), out var reader2));
110Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader));
127Assert.True(readerFactory.TryGetReader(asyncEnumerable1.GetType(), out var reader));
144Assert.True(readerFactory.TryGetReader(enumerable1.GetType(), out var reader1));
145Assert.True(readerFactory.TryGetReader(enumerable2.GetType(), out var reader2));
164Assert.True(result);
182Assert.True(readerFactory.TryGetReader(enumerable.GetType(), out var reader));
198Assert.True(readerFactory.TryGetReader(enumerable.GetType(), out var reader));
213Assert.True(readerFactory.TryGetReader(enumerable.GetType(), out var reader));
Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation.Test (18)
Microsoft.AspNetCore.Mvc.Razor.Test (27)
Microsoft.AspNetCore.Mvc.RazorPages.Test (138)
Microsoft.AspNetCore.Mvc.TagHelpers.Test (77)
Microsoft.AspNetCore.Mvc.Test (10)
Microsoft.AspNetCore.Mvc.ViewFeatures.Test (36)
Microsoft.AspNetCore.OpenApi.Tests (90)
Services\OpenApiSchemaService\OpenApiSchemaService.ParameterSchemas.cs (6)
163[(bool id = true) => { }, (JsonNode defaultValue) => Assert.True(defaultValue.GetValue<bool>())],
170[([DefaultValue(true)] bool id) => { }, (JsonNode defaultValue) => Assert.True(defaultValue.GetValue<bool>())],
173[([DefaultValue(null)] int? id) => { }, (JsonNode defaultValue) => Assert.True(defaultValue is null)],
175[([DefaultValue(null)] string? id) => { }, (JsonNode defaultValue) => Assert.True(defaultValue is null)],
177[([DefaultValue(null)] TaskStatus? status) => { }, (JsonNode defaultValue) => Assert.True(defaultValue is null)],
692Assert.True(response.Content.TryGetValue("application/json", out var mediaType));
Services\OpenApiSchemaService\OpenApiSchemaService.PolymorphicSchemas.cs (25)
25Assert.True(requestBody.TryGetValue("application/json", out var mediaType));
39Assert.True(document.Components.Schemas.TryGetValue("ShapeTriangle", out var triangleSchema));
42Assert.True(document.Components.Schemas.TryGetValue("ShapeSquare", out var squareSchema));
62Assert.True(requestBody.TryGetValue("application/json", out var mediaType));
78Assert.True(document.Components.Schemas.TryGetValue("WeatherForecastBaseWeatherForecastWithCity", out var citySchema));
82Assert.True(document.Components.Schemas.TryGetValue("WeatherForecastBaseWeatherForecastWithTimeSeries", out var timeSeriesSchema));
86Assert.True(document.Components.Schemas.TryGetValue("WeatherForecastBaseWeatherForecastWithLocalNews", out var newsSchema));
107Assert.True(requestBody.TryGetValue("application/json", out var mediaType));
121Assert.True(document.Components.Schemas.TryGetValue("PersonStudent", out var citySchema));
125Assert.True(document.Components.Schemas.TryGetValue("PersonTeacher", out var timeSeriesSchema));
146Assert.True(requestBody.TryGetValue("application/json", out var mediaType));
157Assert.True(document.Components.Schemas.TryGetValue("ColorPaintColor", out var paintSchema));
161Assert.True(document.Components.Schemas.TryGetValue("ColorFabricColor", out var fabricSchema));
165Assert.True(document.Components.Schemas.TryGetValue("ColorBase", out var colorSchema));
185Assert.True(requestBody.TryGetValue("application/json", out var mediaType));
209Assert.True(document.Components.Schemas.TryGetValue("PetDog", out var dogSchema));
213Assert.True(document.Components.Schemas.TryGetValue("PetCat", out var catSchema));
217Assert.True(document.Components.Schemas.TryGetValue("PetPet", out var petSchema));
238Assert.True(requestBody.TryGetValue("application/json", out var mediaType));
249Assert.True(document.Components.Schemas.TryGetValue("OrganismAnimal", out var animalSchema));
251Assert.True(document.Components.Schemas.TryGetValue("OrganismPlant", out var plantSchema));
253Assert.True(document.Components.Schemas.TryGetValue("OrganismBase", out var baseSchema));
273Assert.True(requestBody.TryGetValue("application/json", out var mediaType));
291Assert.True(document.Components.Schemas.TryGetValue("EmployeeManager", out var managerSchema));
293Assert.True(document.Components.Schemas.TryGetValue("EmployeeEmployee", out var employeeSchema));
Microsoft.AspNetCore.OutputCaching.Tests (65)
Microsoft.AspNetCore.Owin.Tests (4)
Microsoft.AspNetCore.RateLimiting.Tests (9)
Microsoft.AspNetCore.Razor.Runtime.Test (4)
Microsoft.AspNetCore.Razor.Test (27)
Microsoft.AspNetCore.ResponseCaching.Tests (26)
Microsoft.AspNetCore.ResponseCompression.Tests (13)
Microsoft.AspNetCore.Rewrite.Tests (14)
Microsoft.AspNetCore.Routing.FunctionalTests (3)
Microsoft.AspNetCore.Routing.Tests (262)
Microsoft.AspNetCore.Server.HttpSys.FunctionalTests (106)
Microsoft.AspNetCore.Server.IISIntegration.Tests (4)
Microsoft.AspNetCore.Server.Kestrel.Core.Tests (201)
Http3\Http3QPackEncoderTests.cs (7)
22Assert.True(QPackHeaderWriter.BeginEncodeHeaders(418, enumerator, buffer, ref totalHeaderSize, out var length));
39Assert.True(QPackHeaderWriter.BeginEncodeHeaders(200, enumerator, buffer, ref totalHeaderSize, out var length));
70Assert.True(QPackHeaderWriter.BeginEncodeHeaders(statusCode, enumerator, buffer, ref totalHeaderSize, out var length));
88Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length));
107Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length));
126Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length));
145Assert.True(QPackHeaderWriter.BeginEncodeHeaders(enumerator, buffer, ref totalHeaderSize, out var length));
HttpParserTests.cs (14)
41Assert.True(ParseRequestLine(parser, requestHandler, buffer, out var consumed, out var examined));
48Assert.True(buffer.Slice(consumed).IsEmpty);
49Assert.True(buffer.Slice(examined).IsEmpty);
74Assert.True(buffer.Slice(examined).IsEmpty);
108Assert.True(ParseRequestLine(parser, requestHandler, buffer, out var consumed, out var examined));
472Assert.True(parser.ParseHeaders(requestHandler, ref reader2));
474Assert.True(buffer2.Slice(reader2.Position).IsEmpty);
648Assert.True(result);
694Assert.True(result);
710Assert.True(result);
733Assert.True(result);
831Assert.True(buffer.Slice(reader.Position).IsEmpty);
843Assert.True(parser.ParseHeaders(requestHandler, ref reader));
850Assert.True(buffer.Slice(reader.Position).IsEmpty);
HttpRequestHeadersTests.cs (35)
77Assert.True(headers.TryGetValue("host", out value));
82Assert.True(headers.TryGetValue("host", out value));
83Assert.True(headers.TryGetValue("custom", out value));
87Assert.True(headers.TryGetValue("host", out value));
88Assert.True(headers.TryGetValue("custom", out value));
89Assert.True(headers.TryGetValue("Content-Length", out value));
249Assert.True(headers.ContainsKey("host"));
252Assert.True(headers.Contains(kv1));
260Assert.True(headers.ContainsKey("host"));
261Assert.True(headers.ContainsKey("custom"));
263Assert.True(headers.Contains(kv1));
264Assert.True(headers.Contains(kv2));
271Assert.True(headers.ContainsKey("host"));
272Assert.True(headers.ContainsKey("custom"));
273Assert.True(headers.ContainsKey("Content-Length"));
274Assert.True(headers.Contains(kv1));
275Assert.True(headers.Contains(kv2));
276Assert.True(headers.Contains(kv3));
295Assert.True(headers.TryGetValue("host", out value));
296Assert.True(headers.TryGetValue("custom", out value));
297Assert.True(headers.TryGetValue("Content-Length", out value));
302Assert.True(headers.TryGetValue("host", out value));
303Assert.True(headers.TryGetValue("custom", out value));
304Assert.True(headers.TryGetValue("Content-Length", out value));
317Assert.True(headers.TryGetValue("host", out value));
318Assert.True(headers.TryGetValue("custom", out value));
319Assert.True(headers.TryGetValue("Content-Length", out value));
339Assert.True(headers.TryGetValue("host", out value));
340Assert.True(headers.TryGetValue("custom", out value));
341Assert.True(headers.TryGetValue("Content-Length", out value));
343Assert.True(headers.Remove("host"));
348Assert.True(headers.TryGetValue("custom", out value));
350Assert.True(headers.Remove("custom"));
356Assert.True(headers.TryGetValue("Content-Length", out value));
358Assert.True(headers.Remove("Content-Length"));
StartLineTests.cs (15)
40Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
67Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
95Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
122Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
146Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
191Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
209Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
221Assert.True(query.Length == 0 || !ReferenceEquals(query, Http1Connection.QueryString));
285Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
302Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
314Assert.True(query.Length == 0 || !ReferenceEquals(query, Http1Connection.QueryString));
366Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
383Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
448Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
465Assert.True(Parser.ParseRequestLine(ParsingHandler, ref reader));
Microsoft.AspNetCore.Server.Kestrel.Tests (50)
Microsoft.AspNetCore.Server.Kestrel.Transport.Quic.Tests (14)
Microsoft.AspNetCore.Session.Tests (7)
Microsoft.AspNetCore.Shared.Tests (110)
Microsoft.AspNetCore.SignalR.Client.FunctionalTests (17)
Microsoft.AspNetCore.SignalR.Client.Tests (29)
Microsoft.AspNetCore.SignalR.Common.Tests (25)
Internal\Protocol\JsonHubProtocolTestsBase.cs (5)
236Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var message));
442Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var message));
455Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out message));
474Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var hubMessage));
490Assert.True(JsonHubProtocol.TryParseMessage(ref data, binder, out var hubMessage));
Microsoft.AspNetCore.SignalR.Tests (51)
Internal\MessageBufferTests.cs (25)
37Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
62Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
76Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
103Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
112Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
137Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
152Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
161Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
186Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
199Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
210Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
231Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
263Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
274Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
300Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
314Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
344Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
353Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
380Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
392Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
424Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
432Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
471Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out var message));
481Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
490Assert.True(protocol.TryParseMessage(ref buffer, new TestBinder(), out message));
Microsoft.AspNetCore.StaticAssets.Tests (1)
Microsoft.AspNetCore.StaticFiles.FunctionalTests (5)
Microsoft.AspNetCore.StaticFiles.Tests (40)
Microsoft.AspNetCore.TestHost.Tests (14)
Microsoft.AspNetCore.Testing.Tests (4)
Microsoft.AspNetCore.Tests (8)
Microsoft.AspNetCore.WebSockets.Tests (47)
Microsoft.AspNetCore.WebUtilities.Tests (50)
Microsoft.Build.BuildCheck.UnitTests (103)
Microsoft.Build.CommandLine.UnitTests (51)
CommandLineSwitches_Tests.cs (51)
263Assert.True(CommandLineSwitches.IsParameterizedSwitch(null, out parameterizedSwitch, out duplicateSwitchErrorMessage, out multipleParametersAllowed, out missingParametersErrorMessage, out unquoteParameters, out emptyParametersAllowed));
268Assert.True(unquoteParameters);
752Assert.True(switches.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.NoLogo));
753Assert.True(switches[CommandLineSwitches.ParameterlessSwitch.NoLogo]);
759Assert.True(switches.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.NoLogo));
760Assert.True(switches[CommandLineSwitches.ParameterlessSwitch.NoLogo]);
773Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Verbosity, "/v:q", "q", false, true, false));
776Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Verbosity));
786Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Verbosity, "/verbosity:\"diag\";minimal", "\"diag\";minimal", true, true, false));
789Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Verbosity));
820Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
832Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
858Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Logger, "/l:\"", "\"", false, false, false));
861Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Logger));
871Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Logger, "/LOGGER:\"\",asm;\"p,a;r\"", "\"\",asm;\"p,a;r\"", true, false, false));
874Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Logger));
891Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.WarningsAsErrors, "/warnaserror", "", multipleParametersAllowed: true, unquoteParameters: false, emptyParametersAllowed: true));
893Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.WarningsAsErrors));
899Assert.True(parameters.Length > 0);
920Assert.True(switchesLeft.HaveErrors());
925Assert.True(switchesLeft.HaveErrors());
932Assert.True(switchesLeft.HaveErrors());
933Assert.True(switchesRight.HaveErrors());
951Assert.True(switchesLeft.HaveErrors());
952Assert.True(switchesRight.HaveErrors());
970Assert.True(switchesLeft.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.Help));
978Assert.True(switchesRight1.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.NoConsoleLogger));
983Assert.True(switchesLeft.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.NoConsoleLogger));
984Assert.True(switchesLeft[CommandLineSwitches.ParameterlessSwitch.NoConsoleLogger]);
988Assert.True(switchesLeft.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.Help));
989Assert.True(switchesLeft[CommandLineSwitches.ParameterlessSwitch.Help]);
996Assert.True(switchesRight2.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.NoConsoleLogger));
1001Assert.True(switchesLeft.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.NoConsoleLogger));
1002Assert.True(switchesLeft[CommandLineSwitches.ParameterlessSwitch.NoConsoleLogger]);
1005Assert.True(switchesLeft.IsParameterlessSwitchSet(CommandLineSwitches.ParameterlessSwitch.Help));
1006Assert.True(switchesLeft[CommandLineSwitches.ParameterlessSwitch.Help]);
1018Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
1026Assert.True(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
1031Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
1040Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
1056Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
1062Assert.True(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
1067Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
1123Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
1129Assert.True(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
1134Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
1142Assert.True(switchesLeft.HaveErrors());
1214Assert.True(switches.HaveAnySwitchesBeenSet());
1220Assert.True(switches.HaveAnySwitchesBeenSet());
1232Assert.True(nodeReuse);
1625Assert.True(caughtError);
Microsoft.Build.Engine.OM.UnitTests (299)
Definition\DefinitionEditing_Tests.cs (17)
484Assert.True(object.ReferenceEquals(item1, item2));
547Assert.True(object.ReferenceEquals(item1, item2));
899Assert.True(object.ReferenceEquals(item.Xml, newItemElement));
927Assert.True(object.ReferenceEquals(item.Xml, newItemElement));
953Assert.True(object.ReferenceEquals(item.Xml, newItemElement));
1190Assert.True(object.ReferenceEquals(itemGroupElement, item.Xml.Parent));
1198Assert.True(object.ReferenceEquals(item, Helpers.GetFirst(project.GetItems("j"))));
1199Assert.True(object.ReferenceEquals(item, Helpers.GetFirst(project.GetItemsIgnoringCondition("j"))));
1200Assert.True(object.ReferenceEquals(item, Helpers.GetFirst(project.GetItemsByEvaluatedInclude("i1"))));
1237Assert.True(object.ReferenceEquals(itemElement, metadatumElement1.Parent));
1284Assert.True(object.ReferenceEquals(itemGroupElement, item.Xml.Parent));
1285Assert.True(object.ReferenceEquals(itemGroupElement, Helpers.GetFirst(project.GetItems("i")).Xml.Parent));
1575Assert.True(project.IsDirty);
1942Assert.True(object.ReferenceEquals(metadatum1, metadatum2));
1955Assert.True(object.ReferenceEquals(items[0].Xml, items[1].Xml));
2405Assert.True(object.ReferenceEquals(item1, item2));
2464Assert.True(object.ReferenceEquals(item1, item2));
Definition\ProjectCollection_Tests.cs (44)
73Assert.True(ReferenceEquals(project, project2));
102Assert.True(ReferenceEquals(project, project2));
131Assert.True(ReferenceEquals(project, project2));
151Assert.True(ReferenceEquals(project, project2));
328Assert.True(ReferenceEquals(project2, collection.LoadProject("c:\\1")));
350Assert.True(ReferenceEquals(project1.Xml, project1b.Xml));
425Assert.True(ReferenceEquals(project1, ProjectCollection.GlobalProjectCollection.LoadProject(projectDirectory, globalProperties1, ObjectModelHelpers.MSBuildDefaultToolsVersion)));
426Assert.True(ReferenceEquals(project2, ProjectCollection.GlobalProjectCollection.LoadProject(projectDirectory, globalProperties2, ObjectModelHelpers.MSBuildDefaultToolsVersion)));
487Assert.True(exceptionCaught); // "Should have caused the two projects to be identical, causing an exception to be thrown"
513Assert.True(ReferenceEquals(project1, ProjectCollection.GlobalProjectCollection.LoadProject("c:\\1", null, "2.0")));
514Assert.True(ReferenceEquals(project2, ProjectCollection.GlobalProjectCollection.LoadProject("c:\\1", null, ObjectModelHelpers.MSBuildDefaultToolsVersion)));
536Assert.True(ReferenceEquals(project, project2));
558Assert.True(ReferenceEquals(project, project2));
575Assert.True(ReferenceEquals(project, newProject));
624Assert.True(project1.IsDirty);
643Assert.True(project1.IsDirty);
647Assert.True(project2.IsDirty);
660Assert.True(project1.IsDirty);
661Assert.True(project2.IsDirty);
689Assert.True(project1.IsDirty);
794Assert.True(ReferenceEquals(project, Helpers.MakeList(ProjectCollection.GlobalProjectCollection.LoadedProjects)[0]));
958Assert.True(collection.ContainsToolset("x"));
1039Assert.True(collection.RemoveToolset("x"));
1189Assert.True(dirtyRaised);
1194Assert.True(dirtyRaised);
1199Assert.True(dirtyRaised);
1204Assert.True(dirtyRaised);
1209Assert.True(dirtyRaised);
1214Assert.True(dirtyRaised);
1220Assert.True(dirtyRaised);
1225Assert.True(dirtyRaised);
1230Assert.True(dirtyRaised);
1235Assert.True(dirtyRaised);
1240Assert.True(dirtyRaised);
1245Assert.True(dirtyRaised);
1250Assert.True(dirtyRaised);
1255Assert.True(dirtyRaised);
1361Assert.True(dirtyRaised);
1366Assert.True(dirtyRaised);
1382Assert.True(dirtyRaised);
1426Assert.True(dirtyRaised);
1430Assert.True(dirtyRaised);
1434Assert.True(dirtyRaised);
1438Assert.True(dirtyRaised);
Definition\ProjectItem_Tests.cs (23)
82Assert.True(Object.ReferenceEquals(project, item.Project));
172Assert.True(Object.ReferenceEquals(m0, idm0));
1208Assert.True(Object.ReferenceEquals(item1.GetMetadata("m").Xml, item2.GetMetadata("m").Xml));
1406Assert.True(Object.ReferenceEquals(project.GetItems("i").First().GetMetadata("l").Xml, project.GetItems("m").First().GetMetadata("l").Xml));
1407Assert.True(Object.ReferenceEquals(project.GetItems("i").First().GetMetadata("m").Xml, project.GetItems("m").First().GetMetadata("m").Xml));
1408Assert.True(Object.ReferenceEquals(project.GetItems("i").First().GetMetadata("n").Xml, project.GetItems("m").First().GetMetadata("n").Xml));
1409Assert.True(Object.ReferenceEquals(project.GetItems("j").First().GetMetadata("o").Xml, project.GetItems("k").First().GetMetadata("o").Xml));
1410Assert.True(Object.ReferenceEquals(project.GetItems("k").First().GetMetadata("p").Xml, project.GetItems("m").First().GetMetadata("p").Xml));
1411Assert.True(!Object.ReferenceEquals(project.GetItems("j").First().GetMetadata("p").Xml, project.GetItems("m").First().GetMetadata("p").Xml));
1504Assert.True(Object.ReferenceEquals(project.GetItems("i").First().GetMetadata("l").Xml, project.GetItems("m").First().GetMetadata("l").Xml));
1505Assert.True(Object.ReferenceEquals(project.GetItems("i").First().GetMetadata("m").Xml, project.GetItems("m").First().GetMetadata("m").Xml));
1506Assert.True(Object.ReferenceEquals(project.GetItems("i").First().GetMetadata("n").Xml, project.GetItems("m").First().GetMetadata("n").Xml));
1507Assert.True(Object.ReferenceEquals(project.GetItems("j").First().GetMetadata("o").Xml, project.GetItems("k").First().GetMetadata("o").Xml));
1508Assert.True(Object.ReferenceEquals(project.GetItems("k").First().GetMetadata("p").Xml, project.GetItems("m").First().GetMetadata("p").Xml));
1509Assert.True(!Object.ReferenceEquals(project.GetItems("j").First().GetMetadata("p").Xml, project.GetItems("m").First().GetMetadata("p").Xml));
1878Assert.True(found);
1879Assert.True(project.IsDirty);
1898Assert.True(found);
1902Assert.True(project.IsDirty);
1974Assert.True(project.IsDirty);
2028Assert.True(project.IsDirty);
2226Assert.True(project.IsDirty);
2286Assert.True(project.IsDirty);
Microsoft.Build.Engine.UnitTests (865)
AssemblyNameEx_Tests.cs (54)
210Assert.True(a1.Version.Equals(newVersion));
356Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
357Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
362Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
363Assert.True(extension.CultureInfo is null);
368Assert.True(extension.Version is null);
369Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
374Assert.True(extension.Version is null);
375Assert.True(extension.CultureInfo is null);
380Assert.True(extension.Version is null);
381Assert.True(extension.CultureInfo is null);
392Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
393Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
396Assert.True(extension.HasProcessorArchitectureInFusionName);
400Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
401Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
420Assert.True(assemblyNameToMatch.PartialNameCompare(assemblyToCompare));
421Assert.True(assemblyNameToMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName));
445Assert.True(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare));
446Assert.True(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version));
452Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
453Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version));
465Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
466Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version));
489Assert.True(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare));
490Assert.True(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture));
496Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
497Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture));
509Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
510Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture));
533Assert.True(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare));
534Assert.True(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken));
540Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
541Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken));
553Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
554Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken));
575Assert.True(assemblyNameToMatchRetargetable.PartialNameCompare(assemblyToCompare));
576Assert.True(assemblyNameToMatchRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true));
578Assert.True(assemblyToCompare.PartialNameCompare(assemblyNameToNotMatch));
584Assert.True(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare));
595Assert.True(match);
601Assert.True(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true));
603Assert.True(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare));
604Assert.True(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true));
623Assert.True(AssemblyNameComparer.GenericComparer.Equals(a, b));
627Assert.True(AssemblyNameComparer.GenericComparerConsiderRetargetable.Equals(a, c));
632Assert.True(AssemblyNameComparer.Comparer.Compare(a, d) > 0);
633Assert.True(AssemblyNameComparer.Comparer.Compare(a, e) < 0);
636Assert.True(AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, b) > 0);
637Assert.True(AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, d) > 0);
638Assert.True(AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, e) < 0);
669Assert.True(assemblies[0].Equals(x));
670Assert.True(assemblies[1].Equals(z));
671Assert.True(assemblies[2].Equals(y));
BackEnd\AssemblyTaskFactory_Tests.cs (4)
134Assert.True(_taskFactory.TaskNameCreatableByFactory("TaskToTestFactories", null, String.Empty, null, ElementLocation.Create(".", 1, 1)));
185Assert.True(_taskFactory.TaskNameCreatableByFactory("TaskToTestFactories", taskIdentityParameters, String.Empty, null, ElementLocation.Create(".", 1, 1)));
235Assert.True(foundExpectedParameter);
692Assert.True(_loadedType.Assembly.Equals(_loadInfo)); // "Expected the AssemblyLoadInfo to be equal"
BackEnd\BinaryTranslator_Tests.cs (6)
380Assert.True(TranslationHelpers.CompareCollections(value, deserializedValue, DerivedClass.Comparer));
395Assert.True(TranslationHelpers.CompareCollections(value, deserializedValue, DerivedClass.Comparer));
410Assert.True(TranslationHelpers.CompareCollections(value, deserializedValue, BaseClass.Comparer));
425Assert.True(TranslationHelpers.CompareCollections(value, deserializedValue, BaseClass.Comparer));
836Assert.True(TranslationHelpers.CompareCollections(value, deserializedValue, comparer));
850Assert.True(TranslationHelpers.CompareCollections(value, deserializedValue, comparer));
BackEnd\BuildManager_Tests.cs (34)
143Assert.True(properties.TryGetValue("InitialProperty1", out string propertyValue));
146Assert.True(properties.TryGetValue("InitialProperty2", out propertyValue));
149Assert.True(properties.TryGetValue("InitialProperty3", out propertyValue));
391Assert.True(numberProcsAfterShutdown <= numberProcsOriginally);
577Assert.True(properties.TryGetValue("InitialProperty1", out string propertyValue));
580Assert.True(properties.TryGetValue("InitialProperty2", out propertyValue));
583Assert.True(properties.TryGetValue("InitialProperty3", out propertyValue));
617Assert.True(properties.TryGetValue("InitialProperty1", out string propertyValue));
620Assert.True(properties.TryGetValue("InitialProperty2", out propertyValue));
623Assert.True(properties.TryGetValue("InitialProperty3", out propertyValue));
661Assert.True(properties.TryGetValue("InitialProperty1", out string propertyValue));
664Assert.True(properties.TryGetValue("InitialProperty2", out propertyValue));
667Assert.True(properties.TryGetValue("InitialProperty3", out propertyValue));
725Assert.True(properties.TryGetValue("InitialProperty3", out string propertyValue));
802Assert.True(properties.TryGetValue("InitialProperty3", out string propertyValue));
1280Assert.True(submission1.IsCompleted);
1309Assert.True(callbackFinished.WaitOne(5000)); // "Build is hung."
1783Assert.True(result1.HasResultsForTarget("target1")); // "Results for target1 missing"
1785Assert.True(result2.HasResultsForTarget("target2")); // "Results for target2 missing"
1818Assert.True(result1.HasResultsForTarget("target1")); // "Results for target1 missing"
1820Assert.True(result2.HasResultsForTarget("target2")); // "Results for target2 missing"
1852Assert.True(result1.HasResultsForTarget("target1")); // "Results for target1 missing"
1854Assert.True(result2.HasResultsForTarget("target1")); // "Results for target1 (second call) missing"
2119Assert.True(preRoot.IsExplicitlyLoaded);
2120Assert.True(preImported.IsExplicitlyLoaded);
2134Assert.True(preRoot.IsExplicitlyLoaded);
2135Assert.True(preImported.IsExplicitlyLoaded);
2363Assert.True(Directory.Exists(outerBuildCacheDirectory)); // "Outer build cache directory doesn't exist after inner build manager was disposed."
3418Assert.True(result1.HasResultsForTarget("target1"));
3448Assert.True(result1.HasResultsForTarget("target1"));
3479Assert.True(buildResult.HasResultsForTarget("target1"));
3480Assert.True(buildResult.HasResultsForTarget("target2"));
3876Assert.True(results.OverallResult == BuildResultCode.Success);
3967Assert.True(_logger.AllBuildEvents.OfType<ProjectEvaluationStartedEventArgs>().GroupBy(args => args.BuildEventContext.EvaluationId).All(g => g.Count() == 1));
BackEnd\TaskExecutionHost_Tests.cs (25)
146Assert.True(_host.SetTaskParameters(parameters));
148Assert.True(_parametersSetOnTask.ContainsKey("ExecuteReturnParam"));
340Assert.True(_parametersSetOnTask.ContainsKey("IntArrayParam"));
611Assert.True(_host.SetTaskParameters(parameters));
615Assert.True(executeValue);
627Assert.True(_host.SetTaskParameters(parameters));
648Assert.True(_host.SetTaskParameters(parameters));
1299Assert.True(_host.GatherTaskOutputs(outputName, ElementLocation.Create(".", 1, 1), true, "output"));
1300Assert.True(_outputsReadFromTask.ContainsKey(outputName));
1311Assert.True(_host.GatherTaskOutputs(outputName, ElementLocation.Create(".", 1, 1), true, "output"));
1312Assert.True(_outputsReadFromTask.ContainsKey(outputName));
1323Assert.True(_host.GatherTaskOutputs(outputName, ElementLocation.Create(".", 1, 1), true, "output"));
1324Assert.True(_outputsReadFromTask.ContainsKey(outputName));
1338Assert.True(_host.GatherTaskOutputs(outputName, ElementLocation.Create(".", 1, 1), true, "output"));
1339Assert.True(_outputsReadFromTask.ContainsKey(outputName));
1353Assert.True(_host.GatherTaskOutputs(outputName, ElementLocation.Create(".", 1, 1), false, "output"));
1354Assert.True(_outputsReadFromTask.ContainsKey(outputName));
1367Assert.True(_parametersSetOnTask.ContainsKey(parameterName));
1378Assert.True(_parametersSetOnTask.ContainsKey(parameterName));
1392Assert.True(_parametersSetOnTask.ContainsKey(parameterName));
1405Assert.True(_parametersSetOnTask.ContainsKey(parameterName));
1419Assert.True(_parametersSetOnTask.ContainsKey(parameterName));
1437Assert.True(_parametersSetOnTask.ContainsKey(parameterName));
1455Assert.True(_parametersSetOnTask.ContainsKey(parameterName));
1486Assert.True(success);
Collections\MSBuildNameIgnoreCaseComparer_Tests.cs (11)
26Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals("FOO", "foo"));
32Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals("", ""));
35Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals((string)null, (string)null));
54Assert.True(Object.ReferenceEquals(p, value)); // "Should have returned the same object as was inserted"
116Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals("bbb", "abbbaaa", 1, 3));
125Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals("A", "babbbb", 1, 1));
134Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals("b", "aabaa", 2, 1));
143Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals("a", "ab", 0, 1));
152Assert.True(MSBuildNameIgnoreCaseComparer.Default.Equals("aab", "aabaa", 0, 3));
161Assert.True(0 == MSBuildNameIgnoreCaseComparer.Default.GetHashCode((string)null));
177Assert.True(0 == comparer.GetHashCode((string)null));
Definition\ItemDefinitionGroup_Tests.cs (40)
45Assert.True(ContainsMetadata(p.ItemDefinitions["Compile"].Metadata, "First", "1st"));
46Assert.True(ContainsMetadata(p.ItemDefinitions["Compile"].Metadata, "Second", "2nd"));
73Assert.True(ContainsMetadata(p.ItemDefinitions["Compile"].Metadata, "First", "1st"));
74Assert.True(ContainsMetadata(p.ItemDefinitions["Compile"].Metadata, "Second", "2nd"));
75Assert.True(ContainsMetadata(p.ItemDefinitions["Link"].Metadata, "Third", "3rd"));
76Assert.True(ContainsMetadata(p.ItemDefinitions["Link"].Metadata, "Fourth", "4th"));
106Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "First", "1st"));
107Assert.True(ItemContainsMetadata(p, "Compile", "b.cs", "First", "1st"));
108Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Second", "2nd"));
109Assert.True(ItemContainsMetadata(p, "Compile", "b.cs", "Second", "2nd"));
149Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "First", "Not1st"));
150Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Second", "2nd"));
151Assert.True(ItemContainsMetadata(p, "Compile", "b.cs", "First", "1st"));
152Assert.True(ItemContainsMetadata(p, "Compile", "b.cs", "Second", "2nd"));
153Assert.True(ItemContainsMetadata(p, "Link", "a.o", "Third", "3rd"));
154Assert.True(ItemContainsMetadata(p, "Link", "a.o", "Fourth", "4th"));
279Assert.True(ItemContainsMetadata(p, "Link", "a.o", "Third", "----"));
320Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Foo", "Bar"));
321Assert.True(ItemContainsMetadata(p, "Compile", "b.cs", "Foo", "Bar"));
438Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Foo", "Bar"));
464Assert.True(p.ItemDefinitions.ContainsKey("Compile"));
465Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Foo", "Bar"));
466Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "First", "1st"));
492Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Foo", "Bar"));
518Assert.True(p.ItemDefinitions.ContainsKey("Compile"));
519Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Foo", "Bar"));
520Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "First", "1st"));
545Assert.True(p.ItemDefinitions.ContainsKey("Compile"));
546Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Foo", "Bar"));
572Assert.True(p.ItemDefinitions.ContainsKey("Compile"));
573Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "Foo", "Bar"));
574Assert.True(ItemContainsMetadata(p, "Compile", "a.cs", "First", "1st"));
594Assert.True(p.ItemDefinitions.ContainsKey("ItemA"));
630Assert.True(p.ItemDefinitions.ContainsKey("ItemA"));
672Assert.True(p.ItemDefinitions.ContainsKey("ItemA"));
1269Assert.True(ItemContainsMetadata(p, "i", "i1", "m", "m1"));
1298Assert.True(ItemContainsMetadata(p, "i", "i1", "m", "m1"));
1299Assert.True(ItemContainsMetadata(p, "i", "i2", "m", "m2"));
1737Assert.True(ItemContainsMetadata(p, "CppCompile", "a.cpp", "Defines", "CODEANALYSIS;RETAIL"));
1742Assert.True(ItemContainsMetadata(p, "CppCompile", "a.cpp", "Defines", "CODEANALYSIS;DEBUG"));
XmakeAttributes_Tests.cs (25)
20Assert.True(XMakeAttributes.IsSpecialTaskAttribute(XMakeAttributes.xmlns));
21Assert.True(XMakeAttributes.IsSpecialTaskAttribute(XMakeAttributes.continueOnError));
22Assert.True(XMakeAttributes.IsSpecialTaskAttribute(XMakeAttributes.condition));
23Assert.True(XMakeAttributes.IsSpecialTaskAttribute(XMakeAttributes.msbuildArchitecture));
24Assert.True(XMakeAttributes.IsSpecialTaskAttribute(XMakeAttributes.msbuildRuntime));
36Assert.True(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute("continueOnError"));
37Assert.True(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute("condition"));
38Assert.True(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute("MsbuildRuntime"));
39Assert.True(XMakeAttributes.IsBadlyCasedSpecialTaskAttribute("msbuildarchitecture"));
46Assert.True(XMakeAttributes.IsNonBatchingTargetAttribute(XMakeAttributes.dependsOnTargets));
47Assert.True(XMakeAttributes.IsNonBatchingTargetAttribute(XMakeAttributes.name));
48Assert.True(XMakeAttributes.IsNonBatchingTargetAttribute(XMakeAttributes.condition));
54Assert.True(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.any, XMakeAttributes.MSBuildRuntimeValues.currentRuntime));
55Assert.True(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.any, XMakeAttributes.MSBuildRuntimeValues.net));
56Assert.True(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.any, XMakeAttributes.MSBuildRuntimeValues.clr4));
57Assert.True(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.clr2, XMakeAttributes.MSBuildRuntimeValues.any));
59Assert.True(XMakeAttributes.RuntimeValuesMatch(XMakeAttributes.MSBuildRuntimeValues.currentRuntime, XMakeAttributes.MSBuildRuntimeValues.net));
135Assert.True(XMakeAttributes.ArchitectureValuesMatch(XMakeAttributes.MSBuildArchitectureValues.any, XMakeAttributes.MSBuildArchitectureValues.currentArchitecture));
136Assert.True(XMakeAttributes.ArchitectureValuesMatch(XMakeAttributes.MSBuildArchitectureValues.any, XMakeAttributes.MSBuildArchitectureValues.x64));
137Assert.True(XMakeAttributes.ArchitectureValuesMatch(XMakeAttributes.MSBuildArchitectureValues.x86, XMakeAttributes.MSBuildArchitectureValues.any));
138Assert.True(XMakeAttributes.ArchitectureValuesMatch(XMakeAttributes.MSBuildArchitectureValues.currentArchitecture, currentArchitecture));
151Assert.True(XMakeAttributes.TryMergeArchitectureValues(XMakeAttributes.MSBuildArchitectureValues.any, XMakeAttributes.MSBuildArchitectureValues.currentArchitecture, out mergedArchitecture));
154Assert.True(XMakeAttributes.TryMergeArchitectureValues(XMakeAttributes.MSBuildArchitectureValues.any, XMakeAttributes.MSBuildArchitectureValues.x64, out mergedArchitecture));
157Assert.True(XMakeAttributes.TryMergeArchitectureValues(XMakeAttributes.MSBuildArchitectureValues.x86, XMakeAttributes.MSBuildArchitectureValues.any, out mergedArchitecture));
160Assert.True(XMakeAttributes.TryMergeArchitectureValues(XMakeAttributes.MSBuildArchitectureValues.currentArchitecture, currentArchitecture, out mergedArchitecture));
Microsoft.Build.Tasks.CodeAnalysis.UnitTests (36)
Microsoft.Build.Tasks.UnitTests (475)
AssemblyDependency\SuggestedRedirects.cs (11)
67Assert.True(ContainsItem(t.ResolvedDependencyFiles, s_myLibraries_V2_DDllPath));
68Assert.True(ContainsItem(t.ResolvedDependencyFiles, s_myLibraries_V1_DDllPath));
69Assert.True(ContainsItem(t.ResolvedDependencyFiles, s_myLibraries_V2_GDllPath));
72Assert.True(ContainsItem(t.SuggestedRedirects, @"D, Culture=neutral, PublicKeyToken=aaaaaaaaaaaaaaaa")); // "Expected to find suggested redirect, but didn't"
110Assert.True(ContainsItem(t.SuggestedRedirects, @"D, Culture=neutral, PublicKeyToken=aaaaaaaaaaaaaaaa")); // "Expected to find suggested redirect, but didn't"
211Assert.True(ContainsItem(t.ResolvedFiles, s_myLibraries_V1_DDllPath)); // "Expected to find assembly, but didn't."
256Assert.True(ContainsItem(t.ResolvedFiles, s_myLibraries_V1_DDllPath)); // "Expected to find assembly, but didn't."
415Assert.True(ContainsItem(t.ResolvedDependencyFiles, @"c:\Regress387218\v2\D.dll")); // "Expected to find assembly, but didn't."
416Assert.True(ContainsItem(t.ResolvedDependencyFiles, @"c:\Regress387218\v1\D.dll")); // "Expected to find assembly, but didn't."
458Assert.True(ContainsItem(t.ResolvedDependencyFiles, @"c:\Regress390219\v2\D.dll")); // "Expected to find assembly, but didn't."
459Assert.True(ContainsItem(t.ResolvedDependencyFiles, @"c:\Regress390219\v1\D.dll")); // "Expected to find assembly, but didn't."
AssemblyNameEx_Tests.cs (54)
210Assert.True(a1.Version.Equals(newVersion));
356Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
357Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
362Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
363Assert.True(extension.CultureInfo is null);
368Assert.True(extension.Version is null);
369Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
374Assert.True(extension.Version is null);
375Assert.True(extension.CultureInfo is null);
380Assert.True(extension.Version is null);
381Assert.True(extension.CultureInfo is null);
392Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
393Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
396Assert.True(extension.HasProcessorArchitectureInFusionName);
400Assert.True(extension.Version.Equals(new Version("2.0.0.0")));
401Assert.True(extension.CultureInfo.Equals(new CultureInfo("en")));
420Assert.True(assemblyNameToMatch.PartialNameCompare(assemblyToCompare));
421Assert.True(assemblyNameToMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName));
445Assert.True(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare));
446Assert.True(assemblyNameToMatchVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version));
452Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
453Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version));
465Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
466Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Version));
489Assert.True(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare));
490Assert.True(assemblyNameToMatchCulture.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture));
496Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
497Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture));
509Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
510Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.Culture));
533Assert.True(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare));
534Assert.True(assemblyNameToMatchPublicToken.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken));
540Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
541Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken));
553Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare));
554Assert.True(assemblyMatchNoVersion.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName | PartialComparisonFlags.PublicKeyToken));
575Assert.True(assemblyNameToMatchRetargetable.PartialNameCompare(assemblyToCompare));
576Assert.True(assemblyNameToMatchRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true));
578Assert.True(assemblyToCompare.PartialNameCompare(assemblyNameToNotMatch));
584Assert.True(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare));
595Assert.True(match);
601Assert.True(assemblyNameToNotMatch.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true));
603Assert.True(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare));
604Assert.True(assemblyMatchNoRetargetable.PartialNameCompare(assemblyToCompare, PartialComparisonFlags.SimpleName, true));
623Assert.True(AssemblyNameComparer.GenericComparer.Equals(a, b));
627Assert.True(AssemblyNameComparer.GenericComparerConsiderRetargetable.Equals(a, c));
632Assert.True(AssemblyNameComparer.Comparer.Compare(a, d) > 0);
633Assert.True(AssemblyNameComparer.Comparer.Compare(a, e) < 0);
636Assert.True(AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, b) > 0);
637Assert.True(AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, d) > 0);
638Assert.True(AssemblyNameComparer.ComparerConsiderRetargetable.Compare(a, e) < 0);
669Assert.True(assemblies[0].Equals(x));
670Assert.True(assemblies[1].Equals(z));
671Assert.True(assemblies[2].Equals(y));
GetInstalledSDKLocations_Tests.cs (16)
260Assert.True(success);
284Assert.True(success);
331Assert.True(success);
342Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=1.0"));
348Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=2.0"));
354Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=3.0"));
361Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=4.0"));
367Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=5.0"));
373Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=6.0"));
405Assert.True(success);
416Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=1.0"));
422Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=2.0"));
428Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=3.0"));
435Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=4.0"));
441Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=5.0"));
447Assert.True(extensionSDKs.ContainsKey("MyAssembly, Version=6.0"));
PropertyParser_Tests.cs (10)
17Assert.True(PropertyParser.GetTable(null, "Properties", null, out Dictionary<string, string> propertiesTable));
28Assert.True(PropertyParser.GetTable(null, "Properties",
45Assert.True(PropertyParser.GetTable(null, "Properties",
66Assert.True(PropertyParser.GetTable(null, "Properties",
85Assert.True(PropertyParser.GetTable(null, "Properties",
123Assert.True(PropertyParser.GetTable(null, "Properties",
140Assert.True(PropertyParser.GetTable(null, "Properties",
155Assert.True(PropertyParser.GetTableWithEscaping(null, "Properties", "Properties",
172Assert.True(PropertyParser.GetTableWithEscaping(null, "Properties", "Properties",
189Assert.True(PropertyParser.GetTableWithEscaping(null, "Properties", "Properties",
Microsoft.Build.UnitTests.Shared (7)
Microsoft.Build.Utilities.UnitTests (8)
Microsoft.CodeAnalysis.CSharp.CodeStyle.UnitTests (1)
Microsoft.CodeAnalysis.CSharp.CommandLine.UnitTests (123)
CommandLineTests.cs (123)
154Assert.True(File.Exists(exePath));
307Assert.True(compilerTreeOptions.TryGetDiagnosticValue(tree, "cs0169", CancellationToken.None, out var severity));
309Assert.True(compilerTreeOptions.TryGetDiagnosticValue(tree, "warning01", CancellationToken.None, out severity));
846Assert.True(parsedArgs.NoWin32Manifest);
938Assert.True(desc.IsPublic);
1030Assert.True(desc.IsPublic);
1482Assert.True(parsedArgs.SourceFiles.Any());
1487Assert.True(parsedArgs.SourceFiles.Any());
1491Assert.True(parsedArgs.DisplayHelp);
1496Assert.True(parsedArgs.DisplayVersion);
1501Assert.True(parsedArgs.DisplayLangVersions);
1512Assert.True(parsedArgs.DisplayVersion);
1513Assert.True(parsedArgs.SourceFiles.Any());
1517Assert.True(parsedArgs.DisplayVersion);
1522Assert.True(parsedArgs.DisplayHelp);
1528Assert.True(parsedArgs.SourceFiles.Any());
1541Assert.True(parsedArgs.SourceFiles.Any());
1554Assert.True(parsedArgs.SourceFiles.Any());
1559Assert.True(parsedArgs.SourceFiles.Any());
1564Assert.True(parsedArgs.SourceFiles.Any());
1571Assert.True(parsedArgs.SourceFiles.Any());
1576Assert.True(parsedArgs.SourceFiles.Any());
1581Assert.True(parsedArgs.SourceFiles.Any());
1722Assert.True(args.DisplayLangVersions);
1866Assert.True(LanguageVersionFacts.TryParse("ISO-1", out var version));
1892Assert.True(Array.IndexOf(acceptableSurroundingChar, actual[foundIndex - 1]) >= 0);
1893Assert.True(Array.IndexOf(acceptableSurroundingChar, actual[foundIndex + version.Length]) >= 0);
1980Assert.True(parsedArgs.EmitPdb);
1981Assert.True(parsedArgs.EmitPdbFile);
1986Assert.True(parsedArgs.CompilationOptions.DebugPlusMode);
1987Assert.True(parsedArgs.EmitPdb);
1988Assert.True(parsedArgs.EmitPdbFile);
2001Assert.True(parsedArgs.EmitPdb);
2007Assert.True(parsedArgs.EmitPdb);
2014Assert.True(parsedArgs.EmitPdb);
2020Assert.True(parsedArgs.EmitPdb);
2027Assert.True(parsedArgs.EmitPdb);
2034Assert.True(parsedArgs.EmitPdb);
2040Assert.True(parsedArgs.EmitPdb);
2046Assert.True(parsedArgs.EmitPdb);
2058Assert.True(parsedArgs.EmitPdb);
2063Assert.True(parsedArgs.CompilationOptions.DebugPlusMode);
2064Assert.True(parsedArgs.EmitPdb);
2069Assert.True(parsedArgs.CompilationOptions.DebugPlusMode);
2070Assert.True(parsedArgs.EmitPdb);
2108Assert.True(parsedArgs.EmitPdbFile);
2425Assert.True(embed_cs.Length >= EmbeddedText.CompressionThreshold);
2426Assert.True(embed2_cs.Length < EmbeddedText.CompressionThreshold);
2501Assert.True(expectedEmbeddedMap.Remove(docPath));
2528Assert.True(expectedEmbeddedMap.Remove(docPath));
2550Assert.True(expectedFilesMap.Remove(dirPath));
2618Assert.True(parsedArgs.CompilationOptions.Deterministic);
2622Assert.True(parsedArgs.CompilationOptions.Deterministic);
2842Assert.True(parsedArgs.CompilationOptions.SpecificDiagnosticOptions["CA1012"] == ReportDiagnostic.Error);
2844Assert.True(parsedArgs.CompilationOptions.SpecificDiagnosticOptions["CA1013"] == ReportDiagnostic.Warn);
2846Assert.True(parsedArgs.CompilationOptions.SpecificDiagnosticOptions["CA1014"] == ReportDiagnostic.Suppress);
2847Assert.True(parsedArgs.CompilationOptions.GeneralDiagnosticOption == ReportDiagnostic.Warn);
2929Assert.True(outWriter.ToString().Contains("a.cs(2,7): warning Warning01: Throwing a diagnostic for types declared"));
2931Assert.True(outWriter.ToString().Contains("warning CS8032"));
2965Assert.True(outWriter.ToString().Contains("a.cs(2,7): error Warning01: Throwing a diagnostic for types declared"));
4000Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray<InstrumentationKind>.Empty));
4006Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray<InstrumentationKind>.Empty));
4012Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray<InstrumentationKind>.Empty));
4018Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray<InstrumentationKind>.Empty));
4024Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray<InstrumentationKind>.Empty));
4029Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray<InstrumentationKind>.Empty));
4034Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray<InstrumentationKind>.Empty));
4039Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
4043Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
4047Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
4051Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
4055Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
4059Assert.True(parsedArgs.EmitOptions.InstrumentationKinds.SequenceEqual(ImmutableArray.Create(InstrumentationKind.TestCoverage)));
4505Assert.True(peReader.IsAssembly);
5608Assert.True((bool)parsedArgs.CompilationOptions.DelaySign);
5613Assert.True((bool)parsedArgs.CompilationOptions.DelaySign);
5986Assert.True((bool)parsedArgs.Utf8Output);
5990Assert.True((bool)parsedArgs.Utf8Output);
6107Assert.True(result.ContainsErrors);
7094Assert.True(peReader.IsAssembly);
8263Assert.True(File.Exists(Path.Combine(dir.ToString(), "a.xml")));
8794Assert.True(new FileInfo(exe.Path).Length < oldSize);
8795Assert.True(new FileInfo(pdb.Path).Length < oldSize);
8817Assert.True(false);
9674Assert.True(text.StartsWith(".>", StringComparison.Ordinal));
9682Assert.True(text.StartsWith("http://goo.bar/baz.aspx", StringComparison.Ordinal));
10532Assert.True(sourceOutputRan);
10608Assert.True(errorlog);
10649Assert.True(string.IsNullOrEmpty(output));
10653Assert.True(string.IsNullOrEmpty(output));
10686Assert.True(string.IsNullOrEmpty(output));
10694Assert.True(string.IsNullOrEmpty(output));
10727Assert.True(string.IsNullOrEmpty(output));
10731Assert.True(string.IsNullOrEmpty(output));
10757Assert.True(string.IsNullOrEmpty(output));
10765Assert.True(string.IsNullOrEmpty(output));
10953Assert.True(string.IsNullOrEmpty(output));
11379Assert.True(File.Exists(Path.Combine(dir.ToString(), "doc.xml")));
11631Assert.True(File.Exists(exePath));
11632Assert.True(File.Exists(pdbPath));
11811Assert.True(File.Exists(exe));
11820Assert.True(File.Exists(doc));
11844Assert.True(File.Exists(refDll));
11927Assert.True(File.Exists(refDll));
11941Assert.True(File.Exists(doc));
12302Assert.True(File.Exists(exePath));
12322Assert.True(!comp.SignUsingBuilder);
12411Assert.True(args.Errors.Length > 0);
13489Assert.True(File.Exists(binaryPath) == !warnAsError);
13492Assert.True(File.Exists(pdbPath) == !warnAsError);
13495Assert.True(File.Exists(xmlDocFilePath) == !warnAsError);
13535Assert.True(File.Exists(binaryPath) == !analyzerConfigSetToError);
13538Assert.True(File.Exists(pdbPath) == !analyzerConfigSetToError);
13541Assert.True(File.Exists(xmlDocFilePath) == !analyzerConfigSetToError);
13585Assert.True(File.Exists(binaryPath) == !rulesetSetToError);
13588Assert.True(File.Exists(pdbPath) == !rulesetSetToError);
13591Assert.True(File.Exists(xmlDocFilePath) == !rulesetSetToError);
13616Assert.True(File.Exists(binaryPath) == !warnAsError);
14695Assert.True(globalOptions.TryGetValue("key1", out var keyValue));
14706Assert.True(classOptions.TryGetValue("key1", out keyValue));
14710Assert.True(classOptions.TryGetValue("key4", out keyValue));
15316Assert.True(!expectError || !expectWarning);
15416Assert.True(result.Success);
Microsoft.CodeAnalysis.CSharp.EditorFeatures.UnitTests (46)
Microsoft.CodeAnalysis.CSharp.EditorFeatures2.UnitTests (7)
Microsoft.CodeAnalysis.CSharp.Emit.UnitTests (505)
CodeGen\CodeGenTupleTest.cs (314)
491Assert.True(iface.IsGenericType);
494Assert.True(typeArg.IsTupleType);
506Assert.True(iface.IsGenericType);
509Assert.True(typeArg.IsTupleType);
518Assert.True(iface.IsGenericType);
521Assert.True(typeArg.IsTupleType);
530Assert.True(iface.IsGenericType);
533Assert.True(typeArg.IsTupleType);
693Assert.True(constraint.IsGenericType);
696Assert.True(typeArg.IsTupleType);
709Assert.True(constraint.IsGenericType);
712Assert.True(typeArg.IsTupleType);
1003Assert.True(field2Type.IsGenericType);
3349Assert.True(mTuple.IsTupleType);
3366Assert.True(mFirst.Equals(mFirst));
3371Assert.True(mFirst.GetAttributes().IsEmpty);
3384Assert.True(mItem1.Equals(mItem1));
3389Assert.True(mItem1.GetAttributes().IsEmpty);
3392Assert.True(mItem1.IsImplicitlyDeclared);
3647Assert.True(item.IsExplicitlyNamedTupleElement);
3694Assert.True(yType.TupleElements[0].IsExplicitlyNamedTupleElement);
3702Assert.True(yType.TupleElements[2].IsExplicitlyNamedTupleElement);
4476Assert.True(vt2.IsTupleType);
4477Assert.True(vt2.IsDefinition);
4503Assert.True(unnamedTuple.IsDefinition);
4504Assert.True(unnamedTuple.IsTupleType);
4515Assert.True(namedTuple.IsTupleType);
4521Assert.True(namedTuple.Equals(namedTuple.TupleUnderlyingType, TypeCompareKind.IgnoreTupleNames));
4527Assert.True(errorField.IsDefinition);
4528Assert.True(errorField.TupleElementIndex != -1);
4601Assert.True(mItem1.Equals(mItem1));
4607Assert.True(mItem1.GetAttributes().IsEmpty);
4612Assert.True(mItem1.IsImplicitlyDeclared);
5818Assert.True(tupleWithoutNames.IsTupleType);
5822Assert.True(GetTupleElementNames(tupleWithoutNames).IsDefault);
5858Assert.True(tupleWithoutNames.IsTupleType);
5860Assert.True(GetTupleElementNames(tupleWithoutNames).IsDefault);
5876Assert.True(tupleWithoutNames.IsTupleType);
5880Assert.True(GetTupleElementNames(tupleWithoutNames).IsDefault);
5915Assert.True(tuple.IsTupleType);
5953Assert.True(tupleWithoutNames.IsTupleType);
5957Assert.True(GetTupleElementNames(tupleWithoutNames).IsDefault);
5974Assert.True(tupleWithNames.IsTupleType);
5993Assert.True(tupleWithSomeNames.IsTupleType);
6011Assert.True(tupleWithNames.IsTupleType);
6032Assert.True(tuple8WithoutNames.IsTupleType);
6037Assert.True(GetTupleElementNames(tuple8WithoutNames).IsDefault);
6059Assert.True(tuple8WithoutNames.IsTupleType);
6063Assert.True(GetTupleElementNames(tuple8WithoutNames).IsDefault);
6085Assert.True(tuple8WithNames.IsTupleType);
6110Assert.True(tuple9WithoutNames.IsTupleType);
6114Assert.True(GetTupleElementNames(tuple9WithoutNames).IsDefault);
6135Assert.True(tuple9WithNames.IsTupleType);
6156Assert.True(originalVT2.IsDefinition);
6167Assert.True(tuple9WithNames.IsTupleType);
6369Assert.True(tupleWithoutNames.IsTupleType);
6371Assert.True(GetTupleElementNames(tupleWithoutNames).IsDefault);
6374Assert.True(tupleWithoutNames.GetMembers("Item1").Single().Locations.IsEmpty);
6394Assert.True(tuple.IsTupleType);
6396Assert.True(GetTupleElementNames(tuple).IsDefault);
6417Assert.True(tupleWithoutNames.IsTupleType);
6419Assert.True(GetTupleElementNames(tupleWithoutNames).IsDefault);
6433Assert.True(tupleWithNames.IsTupleType);
6448Assert.True(tupleWithNames.IsTupleType);
6465Assert.True(tuple8WithoutNames.IsTupleType);
6469Assert.True(GetTupleElementNames(tuple8WithoutNames).IsDefault);
6485Assert.True(tuple8WithNames.IsTupleType);
6505Assert.True(tuple9WithoutNames.IsTupleType);
6510Assert.True(GetTupleElementNames(tuple9WithoutNames).IsDefault);
6526Assert.True(tuple9WithNames.IsTupleType);
6615Assert.True(tuple1.Equals(tuple2));
6616Assert.True(tuple1.Equals(tuple2, TypeCompareKind.IgnoreDynamicAndTupleNames));
6619Assert.True(tuple1.Equals(tuple3, TypeCompareKind.IgnoreDynamicAndTupleNames));
6622Assert.True(tuple1.Equals(tuple4, TypeCompareKind.IgnoreDynamicAndTupleNames));
6640Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6643Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6646Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6649Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6652Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6655Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6658Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6661Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6682Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6685Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6688Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6691Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6694Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6697Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6700Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6703Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6720Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6723Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6726Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6729Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6732Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6735Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6738Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6741Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6761Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6764Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6767Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6770Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6773Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6776Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6779Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6782Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6800Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6808Assert.True(tuple1.Equals(tuple2, TypeCompareKind.ConsiderEverything));
6814Assert.True(tuple1.Equals(tuple2));
6821Assert.True(tuple1.Equals(tuple2));
6839Assert.True(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames));
6846Assert.True(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames));
6851Assert.True(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
6869Assert.True(tuple1.Equals(tuple2));
6877Assert.True(tuple1.Equals(tuple2));
6883Assert.True(tuple1.Equals(tuple2));
6890Assert.True(tuple1.Equals(tuple2));
6908Assert.True(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames));
6915Assert.True(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames));
6920Assert.True(TypeEquals(tuple1, tuple2, TypeCompareKind.IgnoreTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes));
11156Assert.True(m1Tuple.IsTupleType);
11157Assert.True(m1Tuple.Equals(m1Tuple.TupleUnderlyingType, TypeCompareKind.ConsiderEverything));
11208Assert.True(m1Tuple.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.All(t => t.CustomModifiers.IsEmpty));
11211Assert.True(m1Tuple.GetAttributes().IsEmpty);
11214Assert.True(m1Tuple.GetTypeMembers().IsEmpty);
11215Assert.True(m1Tuple.GetTypeMembers("C9").IsEmpty);
11216Assert.True(m1Tuple.GetTypeMembers("C9", 0).IsEmpty);
11219Assert.True(m1Tuple.GetTypeMembersUnordered().IsEmpty);
11246Assert.True(m1Item1.ContainingType.OriginalDefinition.TupleElements[0].Equals(m1Item1.OriginalDefinition, TypeCompareKind.ConsiderEverything));
11247Assert.True(m1Item1.Equals(m1Item1));
11253Assert.True(m1Item1.GetAttributes().IsEmpty);
11258Assert.True(m1Item1.IsImplicitlyDeclared);
11266Assert.True(m2Item1.ContainingType.OriginalDefinition.TupleElements[0].Equals(m2Item1.OriginalDefinition, TypeCompareKind.ConsiderEverything));
11267Assert.True(m2Item1.Equals(m2Item1));
11274Assert.True(m2Item1.GetAttributes().IsEmpty);
11282Assert.True(m2Item1.IsImplicitlyDeclared);
11286Assert.True(m2a2.IsDefinition);
11287Assert.True(m2a2.Equals(m2a2));
11289Assert.True(m2a2.ContainingType.OriginalDefinition.TupleElements[0].Equals(m1Item1.OriginalDefinition, TypeCompareKind.ConsiderEverything));
11295Assert.True(m2a2.GetAttributes().IsEmpty);
11420Assert.True(m1Tuple.IsTupleType);
11427Assert.True(m1Tuple.TupleUnderlyingType.Equals(m1Tuple, TypeCompareKind.ConsiderEverything));
11497Assert.True(m1Tuple.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.All(t => t.CustomModifiers.IsEmpty));
11501Assert.True(m1Tuple.GetAttributes().IsEmpty);
11506Assert.True(m1Tuple.GetTypeMembers().IsEmpty);
11507Assert.True(m1Tuple.GetTypeMembers("C9").IsEmpty);
11508Assert.True(m1Tuple.GetTypeMembers("C9", 0).IsEmpty);
11512Assert.True(m1Tuple.GetTypeMembersUnordered().IsEmpty);
11541Assert.True(m1Item9.Equals(m1Item9));
11548Assert.True(m1Item9.GetAttributes().IsEmpty);
11553Assert.True(m1Item9.IsImplicitlyDeclared);
11557Assert.True(m2Item9.Equals(m2Item9));
11563Assert.True(m2Item9.GetAttributes().IsEmpty);
11570Assert.True(m2Item9.IsImplicitlyDeclared);
11574Assert.True(m2i2.Equals(m2i2));
11580Assert.True(m2i2.GetAttributes().IsEmpty);
11591Assert.True(tuple.Equals(tuple));
11592Assert.True(tuple.Equals(tuple, TypeCompareKind.ConsiderEverything));
11593Assert.True(tuple.Equals(tuple, TypeCompareKind.IgnoreDynamicAndTupleNames));
11617Assert.True(tuple2.Equals(tuple1));
11625Assert.True(members1[i].Equals(members2[i]));
11626Assert.True(members2[i].Equals(members1[i]));
11641Assert.True(typeParameters1[j].Equals(typeParameters2[j]));
11642Assert.True(typeParameters2[j].Equals(typeParameters1[j]));
11685Assert.True(parameters1[j].Equals(parameters2[j]));
11686Assert.True(parameters2[j].Equals(parameters1[j]));
11775Assert.True(m3Item8.Equals(m3Item8));
11782Assert.True(m3Item8.GetAttributes().IsEmpty);
11787Assert.True(m3Item8.IsImplicitlyDeclared);
11810Assert.True(m3TupleRestTuple.IsTupleType);
11968Assert.True(m4Item8.Equals(m4Item8));
11975Assert.True(m4Item8.GetAttributes().IsEmpty);
11979Assert.True(m4Item8.IsImplicitlyDeclared);
11987Assert.True(m4h4.Equals(m4h4));
11994Assert.True(m4h4.GetAttributes().IsEmpty);
12215Assert.True(m5Item8.Equals(m5Item8));
12223Assert.True(m5Item8.GetAttributes().IsEmpty);
12583Assert.True(m8Item8.Equals(m8Item8));
12591Assert.True(m8Item8.GetAttributes().IsEmpty);
12595Assert.True(m8Item8.IsImplicitlyDeclared);
12603Assert.True(m8Item1.Equals(m8Item1));
12611Assert.True(m8Item1.GetAttributes().IsEmpty);
12755Assert.True(m1Tuple.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics.All(t => t.CustomModifiers.IsEmpty));
12795Assert.True(m1Item1.ContainingType.OriginalDefinition.TupleElements[0].Equals(m1Item1.OriginalDefinition, TypeCompareKind.ConsiderEverything));
12798Assert.True(m1Item1.Equals(m1Item1));
12804Assert.True(m1Item1.GetAttributes().IsEmpty);
12809Assert.True(m1Item1.IsImplicitlyDeclared);
12814Assert.True(m2Item1.ContainingType.OriginalDefinition.TupleElements[0].Equals(m2Item1.OriginalDefinition, TypeCompareKind.ConsiderEverything));
12817Assert.True(m2Item1.Equals(m2Item1));
12823Assert.True(m2Item1.GetAttributes().IsEmpty);
12831Assert.True(m2Item1.IsImplicitlyDeclared);
12836Assert.True(m2a2.Equals(m2a2));
12842Assert.True(m2a2.GetAttributes().IsEmpty);
12945Assert.True(m9Tuple.Equals(m9Tuple.TupleUnderlyingType, TypeCompareKind.ConsiderEverything));
13454Assert.True(sym.TupleElementIndex < 0);
13460Assert.True(sym.IsVirtualTupleField);
13463Assert.True(sym.TupleElementIndex >= 0);
13472Assert.True(sym.TupleElementIndex >= 0);
13475Assert.True(sym.TupleElementIndex < NamedTypeSymbol.ValueTupleRestPosition - 1);
13592Assert.True(t1.Equals(t2));
13600Assert.True(t1.Equals(t3, TypeCompareKind.IgnoreDynamicAndTupleNames));
13601Assert.True(t3.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13604Assert.True(t3.Equals(t4));
13608Assert.True(t5.Equals(t3, TypeCompareKind.IgnoreDynamicAndTupleNames));
13609Assert.True(t3.Equals(t5, TypeCompareKind.IgnoreDynamicAndTupleNames));
13615Assert.True(t6.Equals(t7));
13619Assert.True(t1.Equals(t6, TypeCompareKind.IgnoreDynamicAndTupleNames));
13620Assert.True(t6.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13626Assert.True(t1.Equals(t8, TypeCompareKind.IgnoreDynamicAndTupleNames));
13627Assert.True(t8.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13631Assert.True(t6.Equals(t8, TypeCompareKind.IgnoreDynamicAndTupleNames));
13632Assert.True(t8.Equals(t6, TypeCompareKind.IgnoreDynamicAndTupleNames));
13641Assert.True(t1.Equals(t2));
13652Assert.True(t1.Equals(t3, TypeCompareKind.IgnoreDynamicAndTupleNames));
13653Assert.True(t3.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13656Assert.True(t3.Equals(t4));
13660Assert.True(t5.Equals(t3, TypeCompareKind.IgnoreDynamicAndTupleNames));
13661Assert.True(t3.Equals(t5, TypeCompareKind.IgnoreDynamicAndTupleNames));
13669Assert.True(t6.Equals(t7));
13673Assert.True(t1.Equals(t6, TypeCompareKind.IgnoreDynamicAndTupleNames));
13674Assert.True(t6.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13681Assert.True(t1.Equals(t8, TypeCompareKind.IgnoreDynamicAndTupleNames));
13682Assert.True(t8.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13686Assert.True(t6.Equals(t8, TypeCompareKind.IgnoreDynamicAndTupleNames));
13687Assert.True(t8.Equals(t6, TypeCompareKind.IgnoreDynamicAndTupleNames));
13695Assert.True(t9.Equals(t10));
13706Assert.True(t1.Equals(t11, TypeCompareKind.IgnoreDynamicAndTupleNames));
13707Assert.True(t11.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13709Assert.True(t1.Equals(t11, TypeCompareKind.IgnoreDynamicAndTupleNames));
13711Assert.True(t11.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13763Assert.True(t1.Equals(t12, TypeCompareKind.IgnoreDynamicAndTupleNames));
13764Assert.True(t12.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13766Assert.True(t1.TupleUnderlyingType.Equals(t12.TupleUnderlyingType, TypeCompareKind.IgnoreDynamicAndTupleNames));
13768Assert.True(t12.TupleUnderlyingType.Equals(t1.TupleUnderlyingType, TypeCompareKind.IgnoreDynamicAndTupleNames));
13771Assert.True(t1.Equals(t12, TypeCompareKind.IgnoreDynamicAndTupleNames));
13773Assert.True(t12.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13831Assert.True(t1.Equals(t2));
13839Assert.True(t1.Equals(t3, TypeCompareKind.IgnoreDynamicAndTupleNames));
13840Assert.True(t3.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13843Assert.True(t3.Equals(t4));
13847Assert.True(t5.Equals(t3, TypeCompareKind.IgnoreDynamicAndTupleNames));
13848Assert.True(t3.Equals(t5, TypeCompareKind.IgnoreDynamicAndTupleNames));
13854Assert.True(t6.Equals(t7));
13858Assert.True(t1.Equals(t6, TypeCompareKind.IgnoreDynamicAndTupleNames));
13859Assert.True(t6.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13865Assert.True(t1.Equals(t8, TypeCompareKind.IgnoreDynamicAndTupleNames));
13866Assert.True(t8.Equals(t1, TypeCompareKind.IgnoreDynamicAndTupleNames));
13870Assert.True(t6.Equals(t8, TypeCompareKind.IgnoreDynamicAndTupleNames));
13871Assert.True(t8.Equals(t6, TypeCompareKind.IgnoreDynamicAndTupleNames));
13936Assert.True(m1Tuple.IsTupleType);
13977Assert.True(((ITypeSymbol)nameofArgSymbolInfo.Symbol).IsTupleType);
13994Assert.True(typeInfo.Type.IsTupleType);
13999Assert.True(typeInfo.Type.IsTupleType);
14006Assert.True(((INamedTypeSymbol)typeInfo.Type).IsUnboundGenericType);
14100Assert.True(m1Tuple.IsTupleType);
14248Assert.True(m1Tuple.IsTupleType);
14255Assert.True(m1Tuple.IsTupleType);
14264Assert.True(m2Tuple.IsTupleType);
14278Assert.True(f1Tuple.IsTupleType);
14292Assert.True(p1Tuple.IsTupleType);
14309Assert.True(m3TupleArray.ElementType.IsTupleType);
14327Assert.True(m4TupleList.TypeArguments[0].IsTupleType);
14334Assert.True(m5Tuple.IsTupleType);
14344Assert.True(m6Tuple.IsTupleType);
14349Assert.True(m6Tuple.IsTupleType);
14436Assert.True(e1Tuple.IsTupleType);
14450Assert.True(m5TuplePointer.PointedAtType.IsTupleType);
14468Assert.True(v2Type.Interfaces.IsEmpty);
15823Assert.True(m1P1.Equals(m1P1));
15831Assert.True(m1P1Get.Equals(m1P1.GetMethod, TypeCompareKind.ConsiderEverything));
15832Assert.True(m1P1Set.Equals(m1P1.SetMethod, TypeCompareKind.ConsiderEverything));
15838Assert.True(m1P1.Equals(m1P1Get.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
15841Assert.True(m1P1.Equals(m1P1Set.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
15845Assert.True(m1P1.Equals(m1P1BackingField.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
15854Assert.True(m1this.Equals(m1this));
15861Assert.True(m1thisGet.Equals(m1this.GetMethod, TypeCompareKind.ConsiderEverything));
16054Assert.True(m1E1.Equals(m1E1));
16059Assert.True(m1E1.DeclaringSyntaxReferences.SequenceEqual(m1E1.DeclaringSyntaxReferences, SyntaxReferenceEqualityComparer.Instance));
16061Assert.True(m1E1Add.Equals(m1E1.AddMethod, TypeCompareKind.ConsiderEverything));
16062Assert.True(m1E1Remove.Equals(m1E1.RemoveMethod, TypeCompareKind.ConsiderEverything));
16067Assert.True(m1E1.Equals(m1E1Add.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
16070Assert.True(m1E1.Equals(m1E1Remove.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
16076Assert.True(m1E1.Equals(m1E1BackingField.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
16090Assert.True(m1E2.DeclaringSyntaxReferences.SequenceEqual(m1E2.DeclaringSyntaxReferences, SyntaxReferenceEqualityComparer.Instance));
16093Assert.True(m1E2Add.Equals(m1E2.AddMethod, TypeCompareKind.ConsiderEverything));
16095Assert.True(m1E2Remove.Equals(m1E2.RemoveMethod, TypeCompareKind.ConsiderEverything));
16102Assert.True(m1E2.Equals(m1E2Add.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
16106Assert.True(m1E2.Equals(m1E2Remove.AssociatedSymbol, TypeCompareKind.ConsiderEverything));
16570Assert.True(xSymbol.IsTupleType);
16575Assert.True(xSymbol.IsReferenceType);
16607Assert.True(xSymbol.IsTupleType);
16612Assert.True(xSymbol.IsReferenceType);
26900Assert.True(tuple.IsTupleType);
26967Assert.True(tuple1.IsTupleType);
26983Assert.True(tuple2.IsTupleType);
27478Assert.True(type.Equals(underlyingType, TypeCompareKind.AllIgnoreOptions));
27484Assert.True(type.Equals(underlyingType, TypeCompareKind.ConsiderEverything));
27568Assert.True(model.GetSymbolInfo(literal).IsEmpty);
27926Assert.True(field.RequiresCompletion);
27927Assert.True(underlyingField.RequiresCompletion);
27933Assert.True(field.RequiresCompletion);
27934Assert.True(underlyingField.RequiresCompletion);
27935Assert.True(field.HasComplete(CompletionPart.All));
27936Assert.True(underlyingField.HasComplete(CompletionPart.All));
28003Assert.True(field.IsDefinition);
28004Assert.True(field.HasUseSiteError);
28005Assert.True(field.IsTupleElement());
28006Assert.True(field.IsDefaultTupleElement);
28072Assert.All(fields, f => Assert.True(f.HasUseSiteError));
28250Assert.True(namedType.IsTupleType);
28420Assert.True(namedType.IsTupleType);
28842Assert.True(tuple2.TupleUnderlyingType.Equals(tuple1, TypeCompareKind.ConsiderEverything));
28873Assert.True(tuple3.TupleUnderlyingType.Equals(tuple1, TypeCompareKind.ConsiderEverything));
28916Assert.True(tuple4.TupleUnderlyingType.Equals(tuple1, TypeCompareKind.ConsiderEverything));
Emit\EmitMetadataTests.cs (23)
361Assert.True(i1.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i2, i3, i4, i5, i6, i7)));
362Assert.True(i2.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i3, i4)));
365Assert.True(i5.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i6, i7)));
369Assert.True(c.Interfaces().SequenceEqual(ImmutableArray.Create<NamedTypeSymbol>(i1, i2, i3, i4, i5, i6, i7)));
435Assert.True(method1Ret.IsSZArray);
604Assert.True(ctor.IsDefinition);
612Assert.True(ctor.ReturnsVoid);
625Assert.True(cctor.IsDefinition);
626Assert.True(cctor.IsStatic);
633Assert.True(cctor.ReturnsVoid);
680Assert.True(field.IsStatic);
681Assert.True(field.IsConst);
1237Assert.True(getMethodA.IsVirtual);
1245Assert.True(getMethodC.IsOverride);
1297Assert.True(sourceProperty.IsAutoProperty);
1373Assert.True(field.IsStatic);
1374Assert.True(field.IsConst);
1394Assert.True(type.IsSealed);
2303Assert.True(peHeaders.TryGetDirectoryOffset(peHeader.ImportAddressTableDirectory, out importAddressTableDirectoryOffset));
2316Assert.True(peHeaders.TryGetDirectoryOffset(peHeader.ImportTableDirectory, out importTableDirectoryOffset));
3631Assert.True(emitResult.Success);
3673Assert.True(emitResult.Success);
3714Assert.True(emitResult.Success);
Microsoft.CodeAnalysis.CSharp.Emit2.UnitTests (16)
Microsoft.CodeAnalysis.CSharp.Emit3.UnitTests (837)
Attributes\AttributeTests.cs (26)
56Assert.True(predefined.IsPossibleMatch(typeForwardedTo, QuickAttributes.TypeForwardedTo));
61Assert.True(predefined.IsPossibleMatch(typeIdentifier, QuickAttributes.TypeIdentifier));
66Assert.True(checker1.IsPossibleMatch(alias1, QuickAttributes.TypeForwardedTo));
70Assert.True(checker1a.IsPossibleMatch(alias1, QuickAttributes.TypeForwardedTo));
71Assert.True(checker1a.IsPossibleMatch(alias1, QuickAttributes.TypeIdentifier));
75Assert.True(checker1b.IsPossibleMatch(alias1, QuickAttributes.TypeForwardedTo));
78Assert.True(checker1b.IsPossibleMatch(alias2, QuickAttributes.TypeIdentifier));
82Assert.True(checker3.IsPossibleMatch(alias3, QuickAttributes.TypeForwardedTo));
83Assert.True(checker3.IsPossibleMatch(alias3, QuickAttributes.TypeIdentifier));
651Assert.True(attributeData.HasErrors);
754Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.ArgumentList.Position, newAttrSyntax, out var speculativeModel));
775Assert.True(result.OpenParenToken.IsMissing);
777Assert.True(result.CloseParenToken.IsMissing);
785Assert.True(result.OpenParenToken.IsMissing);
787Assert.True(result.CloseParenToken.IsMissing);
819Assert.True(semanticModel.TryGetSpeculativeSemanticModel(interpolationSyntax.Position, newAttrSyntax, out var speculativeModel));
860Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.ArgumentList.Position, newAttrSyntax, out var speculativeModel));
901Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.ArgumentList.Position, newAttrSyntax, out var speculativeModel));
940Assert.True(semanticModel.TryGetSpeculativeSemanticModel(attrSyntax.Position, newAttrSyntax, out var speculativeModel));
5425Assert.True(typesym.HasSpecialName);
5429Assert.True(idxsym.HasSpecialName);
5433Assert.True(etsym.HasSpecialName);
9916Assert.True(typeInAttribute.IsUnboundGenericType);
9917Assert.True(((NamedTypeSymbol)type.GetAttributes()[0].ConstructorArguments.First().ValueInternal).IsUnboundGenericType);
9926Assert.True(typeInAttribute.IsUnboundGenericType);
9927Assert.True(((NamedTypeSymbol)type.GetAttributes()[0].ConstructorArguments.First().ValueInternal).IsUnboundGenericType);
FieldKeywordTests.cs (170)
922Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: true, BackingField: { } });
923Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: true, BackingField: { } });
924Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
925Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
926Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
927Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
1025Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "Q1", IsAutoProperty: true, BackingField: { } });
1026Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "Q2", IsAutoProperty: true, BackingField: { } });
1027Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "Q3", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
1028Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "Q4", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
1521Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
1522Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
1523Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
1524Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
1525Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
1526Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
1527Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
1691Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1692Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1693Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1694Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1695Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1696Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1697Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1698Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "P8", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1699Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "P9", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1858Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1859Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1860Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1861Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1862Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1863Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1864Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1865Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "P8", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1866Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "P9", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1964Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1965Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1966Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1967Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1968Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1969Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1970Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
1971Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "P8", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
1972Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "P9", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
2048Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
2049Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
2050Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
2051Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
2052Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
2053Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
2054Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
2055Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "P8", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
2056Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "P9", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
2169Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
2170Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
2171Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
2172Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
2173Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
2174Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
2175Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
2176Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "P8", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
2177Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "P9", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
2251Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
2252Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
2253Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
2254Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
2255Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
2256Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
2257Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
2258Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "P8", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
2259Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "P9", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
8399Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
8400Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
8473Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
8474Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
8475Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
8476Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
8477Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
8561Assert.True(false);
8568Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
8569Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
8641Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
8642Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
8704Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
8705Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
8758Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
8759Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
8836Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
8837Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
8838Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
8839Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { HasInitializer: true } });
8911Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
8912Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
8913Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
8914Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { HasInitializer: true } });
8937Assert.True(otherPart.IsPartial);
9011Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9012Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9087Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9088Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
9089Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9090Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
9091Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9092Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
9164Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9165Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9166Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9167Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "Q1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9168Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "Q2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9169Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "Q3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9287Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9288Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9289Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
9290Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
9291Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9292Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P6", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
9293Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P7", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
9294Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "Q1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9295Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "Q2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9296Assert.True(actualProperties[9] is SourcePropertySymbol { Name: "Q3", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
9297Assert.True(actualProperties[10] is SourcePropertySymbol { Name: "Q4", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
9298Assert.True(actualProperties[11] is SourcePropertySymbol { Name: "Q5", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9299Assert.True(actualProperties[12] is SourcePropertySymbol { Name: "Q6", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
9300Assert.True(actualProperties[13] is SourcePropertySymbol { Name: "Q7", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
9372Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9373Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9374Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: { } });
9441Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9442Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9443Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
9444Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
9445Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P5", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9570Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9571Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9572Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9573Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9574Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
9575Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
9576Assert.True(actualProperties[6] is SourcePropertySymbol { Name: "P5", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9577Assert.True(actualProperties[7] is SourcePropertySymbol { Name: "P6", IsPartialDefinition: false, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9578Assert.True(actualProperties[8] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: false, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9579Assert.True(actualProperties[9] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: false, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9580Assert.True(actualProperties[10] is SourcePropertySymbol { Name: "P5", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
9581Assert.True(actualProperties[11] is SourcePropertySymbol { Name: "P6", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9861Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9862Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9863Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9864Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9938Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9939Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
9940Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
9941Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "P4", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: true, BackingField: { } });
10012Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
10013Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10014Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
10015Assert.True(actualProperties[3] is SourcePropertySymbol { Name: "Q1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
10016Assert.True(actualProperties[4] is SourcePropertySymbol { Name: "Q2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10017Assert.True(actualProperties[5] is SourcePropertySymbol { Name: "Q3", IsPartialDefinition: true, IsAutoProperty: true, UsesFieldKeyword: false, BackingField: { } });
10100Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10101Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10102Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10167Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10168Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P2", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10169Assert.True(actualProperties[2] is SourcePropertySymbol { Name: "P3", IsPartialDefinition: true, IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10365Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
10369Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P1", IsAutoProperty: false, UsesFieldKeyword: true, BackingField: { } });
10461Assert.True(actualProperties[0] is SourcePropertySymbol { Name: "P2", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
10462Assert.True(actualProperties[1] is SourcePropertySymbol { Name: "P3", IsAutoProperty: false, UsesFieldKeyword: false, BackingField: null });
10494Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(previousAccessor.Body.SpanStart, modifiedAccessor, out var speculativeModel));
10528Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(previousAccessor.Body.SpanStart, modifiedAccessor, out var speculativeModel));
Semantics\OutVarTests.cs (59)
983Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier().ValueText));
993Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier().ValueText));
1034Assert.True(model.GetConversion(decl).IsIdentity);
1038Assert.True(SyntaxFacts.IsInNamespaceOrTypeContext(typeSyntax));
1039Assert.True(SyntaxFacts.IsInTypeOnlyContext(typeSyntax));
1056Assert.True(model.GetConversion(typeSyntax).IsIdentity);
1112Assert.True(dataFlow.Succeeded);
1113Assert.True(dataFlow.VariablesDeclared.Contains(symbol, ReferenceEqualityComparer.Instance));
1117Assert.True(dataFlow.AlwaysAssigned.Contains(symbol, ReferenceEqualityComparer.Instance));
1118Assert.True(dataFlow.WrittenInside.Contains(symbol, ReferenceEqualityComparer.Instance));
1146Assert.True(model.LookupNames(decl.SpanStart).Contains(decl.Identifier().ValueText));
1167Assert.True(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText));
1198Assert.True(model.LookupNames(reference.SpanStart).Contains(reference.Identifier.ValueText));
3465Assert.True(success);
3506Assert.True(success);
4005Assert.True(success);
5111Assert.True(success);
8805Assert.True(success);
9644Assert.True(success);
10212Assert.True(success);
10861Assert.True(success);
13341Assert.True(success);
13740Assert.True(success);
15261Assert.True(success);
16539Assert.True(success);
17098Assert.True(success);
17534Assert.True(success);
17753Assert.True(dataFlow.Succeeded);
18791Assert.True(analyzer.ActionFired);
19689Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error);
19732Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error);
20662Assert.True(compilation.GetSemanticModel(tree).GetTypeInfo(x4Ref).Type.TypeKind == TypeKind.Error);
20777Assert.True(model.GetTypeInfo(x1Ref).Type.TypeKind == TypeKind.Error);
20780Assert.True(model.GetTypeInfo(x2Ref).Type.TypeKind == TypeKind.Error);
20783Assert.True(model.GetTypeInfo(x3Ref).Type.TypeKind == TypeKind.Error);
20786Assert.True(model.GetTypeInfo(x4Ref).Type.TypeKind == TypeKind.Error);
20954Assert.True(decl.Ancestors().OfType<VariableDeclaratorSyntax>().First().ArgumentList.Contains(decl));
21300Assert.True(success);
32743Assert.True(symbols.Count() > 1);
32772Assert.True(symbols.Count() > 1);
32782Assert.True(model.LookupNames(reference.SpanStart).Contains(decl.Identifier().ValueText));
33076Assert.True(model.GetConversion(declaration1.Type).IsIdentity);
33092Assert.True(model.GetConversion(declaration2.Type).IsIdentity);
33148Assert.True(model.GetConversion(declaration1.Type).IsIdentity);
33190Assert.True(model.GetConversion(declaration1.Type).IsIdentity);
33206Assert.True(model.GetConversion(declaration2.Type).IsIdentity);
33254Assert.True(model.GetConversion(declaration1.Type).IsIdentity);
33272Assert.True(model.GetConversion(declaration2.Type).IsIdentity);
35667Assert.True(success);
36324Assert.True(model.GetSymbolInfo(node).IsEmpty);
36364Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));
36371Assert.True(model.TryGetSpeculativeSemanticModel(method.Body.SpanStart + 1, method.DescendantNodes().OfType<AttributeSyntax>().Single(), out speculativeModel));
36410Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));
36450Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));
36458Assert.True(model.TryGetSpeculativeSemanticModel(equalsValue.Value.SpanStart, equalsValue, out speculativeModel));
36492Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));
36527Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));
36536Assert.True(model.TryGetSpeculativeSemanticModel(equalsValue.Value.SpanStart, equalsValue, out speculativeModel));
36565Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(method.Body.SpanStart, method, out var speculativeModel));
Semantics\PrimaryConstructorTests.cs (100)
141Assert.True(false);
741Assert.True(c.Equals(ctor.Parameters[0].Type, TypeCompareKind.ConsiderEverything));
822Assert.All(c.GetMembers(), m => Assert.True(m is MethodSymbol { MethodKind: MethodKind.Constructor }));
2180Assert.True(model.TryGetSpeculativeSemanticModel(baseWithargs.SpanStart, speculativePrimaryInitializer, out speculativeModel));
2185Assert.True(model.TryGetSpeculativeSemanticModel(baseWithargs.ArgumentList.OpenParenToken.SpanStart, speculativePrimaryInitializer, out speculativeModel));
3223Assert.True(c.HasPrimaryConstructor);
3225Assert.True(c.Constructors.Where(ctor => ctor != c.PrimaryConstructor).All(ctor => ctor.GetAttributes().IsEmpty));
3251Assert.True(c.Constructors.All(ctor => ctor.GetAttributes().IsEmpty));
3252Assert.True(c.Constructors.All(ctor => ctor.GetReturnTypeAttributes().IsEmpty));
3327Assert.True(e.Constructors.All(ctor => ctor.GetAttributes().IsEmpty));
3328Assert.True(e.Constructors.All(ctor => ctor.GetReturnTypeAttributes().IsEmpty));
3359Assert.True(c.Constructors.All(ctor => ctor.GetAttributes().IsEmpty));
3360Assert.True(c.Constructors.All(ctor => ctor.GetReturnTypeAttributes().IsEmpty));
3381Assert.True(c.Constructors.All(ctor => ctor.GetAttributes().IsEmpty));
3402Assert.True(c.Constructors.All(ctor => ctor.GetAttributes().IsEmpty));
3444Assert.True(c1.HasPrimaryConstructor);
3446Assert.True(c1.Constructors.Where(ctor => ctor != c1.PrimaryConstructor).All(ctor => ctor.GetAttributes().IsEmpty));
3450Assert.True(c2.HasPrimaryConstructor);
3452Assert.True(c2.Constructors.Where(ctor => ctor != c2.PrimaryConstructor).All(ctor => ctor.GetAttributes().IsEmpty));
3506Assert.True(c1.HasPrimaryConstructor);
3508Assert.True(c1.Constructors.Where(ctor => ctor != c1.PrimaryConstructor).All(ctor => ctor.GetAttributes().IsEmpty));
3512Assert.True(c2.HasPrimaryConstructor);
3514Assert.True(c2.Constructors.Where(ctor => ctor != c2.PrimaryConstructor).All(ctor => ctor.GetAttributes().IsEmpty));
3559Assert.True(c.AnyMemberHasAttributes);
3608Assert.True(c1.AnyMemberHasAttributes);
3799Assert.True(false);
3825Assert.True(false);
3843Assert.True(false);
3869Assert.True(false);
3874Assert.True(false);
3901Assert.True(false);
3927Assert.True(false);
3965Assert.True(false);
3976Assert.True(false);
3985Assert.True(false);
4011Assert.True(false);
4031Assert.True(false);
4109Assert.True(false);
4207Assert.True(false);
4340Assert.True(false);
4380Assert.True(false);
4426Assert.True(false);
4448Assert.True(false);
4455Assert.True(false);
4559Assert.True(false);
4701Assert.True(false);
4767Assert.True(false);
4834Assert.True(false);
4845Assert.True(false);
4856Assert.True(false);
4867Assert.True(false);
4872Assert.True(false);
4979Assert.True(false);
4990Assert.True(false);
5001Assert.True(false);
5012Assert.True(false);
5017Assert.True(false);
5047Assert.True(false);
5058Assert.True(false);
5069Assert.True(false);
5080Assert.True(false);
5085Assert.True(false);
5165Assert.True(false);
5175Assert.True(false);
5194Assert.True(false);
5288Assert.True(false);
5306Assert.True(false);
5324Assert.True(false);
5339Assert.True(false);
5353Assert.True(false);
5386Assert.True(false);
5395Assert.True(false);
5417Assert.True(false);
5433Assert.True(false);
5512Assert.True(false);
5611Assert.True(false);
5702Assert.True(false);
5709Assert.True(false);
5725Assert.True(false);
5739Assert.True(false);
5746Assert.True(false);
5799Assert.True(false);
5853Assert.True(false);
5864Assert.True(false);
5869Assert.True(false);
5945Assert.True(false);
5956Assert.True(false);
5967Assert.True(false);
5972Assert.True(false);
6003Assert.True(false);
6014Assert.True(false);
6025Assert.True(false);
6030Assert.True(false);
6098Assert.True(symbolInfo.IsEmpty);
14620Assert.All(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetBackingFields(), f => Assert.True(f.IsReadOnly));
14816Assert.All(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetBackingFields(), f => Assert.True(f.IsReadOnly));
15017Assert.All(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetBackingFields(), f => Assert.True(f.IsReadOnly));
15243Assert.All(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetBackingFields(), f => Assert.True(f.IsReadOnly));
15554Assert.All(comp.GetTypeByMetadataName("S1").InstanceConstructors.OfType<SynthesizedPrimaryConstructor>().Single().GetBackingFields(), f => Assert.True(f.IsReadOnly));
20152Assert.True(false);
Microsoft.CodeAnalysis.CSharp.EndToEnd.UnitTests (1)
Microsoft.CodeAnalysis.CSharp.Features.UnitTests (13)
Microsoft.CodeAnalysis.CSharp.IOperation.UnitTests (5)
Microsoft.CodeAnalysis.CSharp.Scripting.Desktop.UnitTests (8)
Microsoft.CodeAnalysis.CSharp.Scripting.UnitTests (23)
Microsoft.CodeAnalysis.CSharp.Semantic.UnitTests (950)
Semantics\AccessCheckTests.cs (54)
771Assert.True(Symbol.IsSymbolAccessible(classA.GetSymbol(), classB.GetSymbol()));
772Assert.True(compilation.IsSymbolAccessibleWithin(classA, classB));
773Assert.True(Symbol.IsSymbolAccessible(aliasA.GetSymbol(), classB.GetSymbol()));
774Assert.True(compilation.IsSymbolAccessibleWithin(aliasA, classB));
775Assert.True(Symbol.IsSymbolAccessible(pubField.GetSymbol(), classB.GetSymbol()));
776Assert.True(compilation.IsSymbolAccessibleWithin(pubField, classB));
781Assert.True(Symbol.IsSymbolAccessible(aarrayType.GetSymbol(), classB.GetSymbol()));
782Assert.True(compilation.IsSymbolAccessibleWithin(aarrayType, classB));
785Assert.True(Symbol.IsSymbolAccessible(aptrType.GetSymbol(), classB.GetSymbol()));
786Assert.True(compilation.IsSymbolAccessibleWithin(aptrType, classB));
793Assert.True(Symbol.IsSymbolAccessible(afuncptrType.GetSymbol(), classB.GetSymbol()));
794Assert.True(compilation.IsSymbolAccessibleWithin(afuncptrType, classB));
797Assert.True(Symbol.IsSymbolAccessible(adiscard.GetSymbol(), classB.GetSymbol()));
798Assert.True(compilation.IsSymbolAccessibleWithin(adiscard, classB));
801Assert.True(Symbol.IsSymbolAccessible(aenumType.GetSymbol(), classB.GetSymbol()));
802Assert.True(compilation.IsSymbolAccessibleWithin(aenumType, classB));
803Assert.True(Symbol.IsSymbolAccessible(unknownType.GetSymbol(), classB.GetSymbol()));
804Assert.True(compilation.IsSymbolAccessibleWithin(unknownType, classB));
805Assert.True(Symbol.IsSymbolAccessible(globalNS.GetSymbol(), classB.GetSymbol()));
806Assert.True(compilation.IsSymbolAccessibleWithin(globalNS, classB));
807Assert.True(Symbol.IsSymbolAccessible(protField.GetSymbol(), classA.GetSymbol()));
808Assert.True(compilation.IsSymbolAccessibleWithin(protField, classA));
809Assert.True(Symbol.IsSymbolAccessible(protField.GetSymbol(), classA.GetSymbol(), classADerived.GetSymbol()));
810Assert.True(compilation.IsSymbolAccessibleWithin(protField, classA, classADerived));
815Assert.True(Symbol.IsSymbolAccessible(protField.GetSymbol(), classA.GetSymbol()));
816Assert.True(compilation.IsSymbolAccessibleWithin(protField, classA));
817Assert.True(Symbol.IsSymbolAccessible(protField.GetSymbol(), classADerived.GetSymbol(), classADerived.GetSymbol()));
818Assert.True(compilation.IsSymbolAccessibleWithin(protField, classADerived, classADerived));
822Assert.True(Symbol.IsSymbolAccessible(classA.GetSymbol(), sourceAssem.GetSymbol()));
823Assert.True(compilation.IsSymbolAccessibleWithin(classA, sourceAssem));
824Assert.True(Symbol.IsSymbolAccessible(aliasA.GetSymbol(), sourceAssem.GetSymbol()));
825Assert.True(compilation.IsSymbolAccessibleWithin(aliasA, sourceAssem));
826Assert.True(Symbol.IsSymbolAccessible(aarrayType.GetSymbol(), sourceAssem.GetSymbol()));
827Assert.True(compilation.IsSymbolAccessibleWithin(aarrayType, sourceAssem));
830Assert.True(Symbol.IsSymbolAccessible(aptrType.GetSymbol(), sourceAssem.GetSymbol()));
831Assert.True(compilation.IsSymbolAccessibleWithin(aptrType, sourceAssem));
832Assert.True(Symbol.IsSymbolAccessible(afuncptrType.GetSymbol(), sourceAssem.GetSymbol()));
833Assert.True(compilation.IsSymbolAccessibleWithin(afuncptrType, sourceAssem));
842Assert.True(Symbol.IsSymbolAccessible(adiscard.GetSymbol(), sourceAssem.GetSymbol()));
843Assert.True(compilation.IsSymbolAccessibleWithin(adiscard, sourceAssem));
850Assert.True(Symbol.IsSymbolAccessible(unknownType.GetSymbol(), sourceAssem.GetSymbol()));
851Assert.True(compilation.IsSymbolAccessibleWithin(unknownType, sourceAssem));
852Assert.True(Symbol.IsSymbolAccessible(mscorlibAssem.GetSymbol(), sourceAssem.GetSymbol()));
853Assert.True(compilation.IsSymbolAccessibleWithin(mscorlibAssem, sourceAssem));
914Assert.True(compilation1.IsSymbolAccessibleWithin(SomeAlias, Outer));
915Assert.True(compilation1.IsSymbolAccessibleWithin(Outer_Pointer.Type, Outer));
917Assert.True(compilation1.IsSymbolAccessibleWithin(IntegerPlus, Other));
918Assert.True(compilation1.IsSymbolAccessibleWithin(IntegerPlus, sourceAssem));
923Assert.True(compilation1.IsSymbolAccessibleWithin(Outer_ProtectedInternal, Derived, Outer));
925Assert.True(compilation1.IsSymbolAccessibleWithin(Outer_Protected, Derived));
926Assert.True(compilation1.IsSymbolAccessibleWithin(Outer_ProtectedInternal, Derived));
927Assert.True(compilation1.IsSymbolAccessibleWithin(Outer_PrivateProtected, Derived));
929Assert.True(compilation1.IsSymbolAccessibleWithin(Outer_Protected, Outer_Inner));
961Assert.True(compilation.IsSymbolAccessibleWithin(classC, classQ));
Semantics\DynamicTests.cs (9)
10042Assert.True(model.GetDeconstructionInfo(assignment) is { Method: null, Conversion: null, Nested: [{ Method: null, Conversion: { IsIdentity: true }, Nested: [] }, _] });
10170Assert.True(model.GetDeconstructionInfo(assignment) is { Method: null, Conversion: null, Nested: [{ Method: null, Conversion: { IsIdentity: true }, Nested: [] }, _] });
10298Assert.True(model.GetDeconstructionInfo(assignment) is { Method: null, Conversion: null, Nested: [{ Method: null, Conversion: { IsIdentity: true }, Nested: [] }, _] });
10452Assert.True(model.GetDeconstructionInfo(assignment) is { Method: null, Conversion: null, Nested: [{ Method: null, Conversion: { IsIdentity: true }, Nested: [] }, _] });
10586Assert.True(model.GetDeconstructionInfo(assignment) is { Method: not null, Conversion: null, Nested: [{ Method: null, Conversion: { IsBoxing: true }, Nested: [] }, _] });
10734Assert.True(model.GetDeconstructionInfo(assignment) is { Method: not null, Conversion: null, Nested: [{ Method: null, Conversion: { IsBoxing: true }, Nested: [] }, _] });
11004Assert.True(model.GetDeconstructionInfo(assignment) is { Method: not null, Conversion: null, Nested: [{ Method: null, Conversion: { IsBoxing: true }, Nested: [] }, _] });
11127Assert.True(model.GetDeconstructionInfo(assignment) is { Method: null, Conversion: null, Nested: [{ Method: null, Conversion: null, Nested: [{ Method: null, Conversion: { IsIdentity: true }, Nested: [] }, _] }, _] });
11211Assert.True(model.GetDeconstructionInfo(assignment) is { Method: null, Conversion: null, Nested: [{ Method: not null, Conversion: null, Nested: [{ Method: null, Conversion: { IsBoxing: true }, Nested: [] }, _] }, _] });
Semantics\NameOfTests.cs (9)
1000Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2));
1006Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty);
1071Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2));
1077Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty);
1157Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2));
1163Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty);
1235Assert.True(model.TryGetSpeculativeSemanticModel(initializer.Position, initializer, out var model2));
1241Assert.True(model.GetSpeculativeSymbolInfo(argument2.Position, argument2, SpeculativeBindingOption.BindAsTypeOrNamespace).IsEmpty);
3059Assert.True(nameofType.IsDefinition);
Semantics\NullableReferenceTypesTests.cs (137)
12338Assert.True(e3.TypeWithAnnotations.Equals(e3.OverriddenEvent.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
12347Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
12348Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
12706Assert.True(impl.TypeWithAnnotations.Equals(e3.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
12715Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
12716Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
12794Assert.True(impl.TypeWithAnnotations.Equals(e3.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
12803Assert.True(ev.TypeWithAnnotations.Equals(ev.AddMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
12804Assert.True(ev.TypeWithAnnotations.Equals(ev.RemoveMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
12890Assert.True(member.TypeWithAnnotations.Equals(member.OverriddenProperty.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
12899Assert.True(property.TypeWithAnnotations.Equals(property.GetMethod.ReturnTypeWithAnnotations, TypeCompareKind.ConsiderEverything));
12900Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
13042Assert.True(impl.TypeWithAnnotations.Equals(member.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
13051Assert.True(property.TypeWithAnnotations.Equals(property.GetMethod.ReturnTypeWithAnnotations, TypeCompareKind.ConsiderEverything));
13052Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
13133Assert.True(impl.TypeWithAnnotations.Equals(member.TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
13142Assert.True(property.TypeWithAnnotations.Equals(property.GetMethod.ReturnTypeWithAnnotations, TypeCompareKind.ConsiderEverything));
13143Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
13335Assert.True(implementing.ReturnTypeWithAnnotations.Equals(implemented.ReturnTypeWithAnnotations,
14033Assert.True(m3.ReturnTypeWithAnnotations.Equals(m3.OverriddenMethod.ConstructIfGeneric(m3.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).ReturnTypeWithAnnotations,
14140Assert.True(m3.Parameters[0].TypeWithAnnotations.Equals(m3.OverriddenMethod.ConstructIfGeneric(m3.TypeParameters.SelectAsArray(t => TypeWithAnnotations.Create(t))).Parameters[0].TypeWithAnnotations,
16512Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations,
16641Assert.True(member.Parameters[0].TypeWithAnnotations.Equals(member.OverriddenProperty.Parameters[0].TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
16650Assert.True(property.TypeWithAnnotations.Equals(property.GetMethod.ReturnTypeWithAnnotations, TypeCompareKind.ConsiderEverything));
16651Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
16726Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
16735Assert.True(property.TypeWithAnnotations.Equals(property.GetMethod.ReturnTypeWithAnnotations, TypeCompareKind.ConsiderEverything));
16736Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
16811Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations, TypeCompareKind.AllIgnoreOptions & ~TypeCompareKind.AllNullableIgnoreOptions));
16820Assert.True(property.TypeWithAnnotations.Equals(property.GetMethod.ReturnTypeWithAnnotations, TypeCompareKind.ConsiderEverything));
16821Assert.True(property.TypeWithAnnotations.Equals(property.SetMethod.Parameters.Last().TypeWithAnnotations, TypeCompareKind.ConsiderEverything));
17742Assert.True(implementing.Parameters[0].TypeWithAnnotations.Equals(implemented.Parameters[0].TypeWithAnnotations,
17810Assert.True(implementing.ReturnTypeWithAnnotations.Equals(implemented.ReturnTypeWithAnnotations,
17885Assert.True(m1Impl.Parameters[3].TypeWithAnnotations.Equals(m1Def.Parameters[3].TypeWithAnnotations,
65897Assert.True(model1.TryGetSpeculativeSemanticModel(function1.SpanStart, function2, out var model2));
98985Assert.True(t11.IsReferenceType);
100341Assert.True(t1.HasNotNullConstraint);
100498Assert.True(t1.IsValueType);
100499Assert.True(t1.HasNotNullConstraint);
100506Assert.True(t2.IsValueType);
100507Assert.True(t2.HasNotNullConstraint);
100542Assert.True(t1.IsReferenceType);
100549Assert.True(t2.IsReferenceType);
100587Assert.True(t1.IsReferenceType);
100594Assert.True(t2.IsReferenceType);
100626Assert.True(t1.IsReferenceType);
100771Assert.True(at1.IsReferenceType);
100799Assert.True(tf1.IsReferenceType);
100859Assert.True(at1.IsReferenceType);
100884Assert.True(tf1.IsReferenceType);
100920Assert.True(t1.IsReferenceType);
100944Assert.True(t1.IsReferenceType);
100945Assert.True(t1.HasNotNullConstraint);
100969Assert.True(t1.IsReferenceType);
100996Assert.True(t1.IsReferenceType);
101045Assert.True(at1.IsReferenceType);
101070Assert.True(tf1.IsReferenceType);
101127Assert.True(at1.IsReferenceType);
101152Assert.True(tf1.IsReferenceType);
103190Assert.True(tf1.HasNotNullConstraint);
103216Assert.True(tf1.HasConstructorConstraint);
103239Assert.True(tf1.HasNotNullConstraint);
103241Assert.True(tf1.HasConstructorConstraint);
103264Assert.True(tf1.HasNotNullConstraint);
103290Assert.True(tf1.HasConstructorConstraint);
103341Assert.True(tf1.HasConstructorConstraint);
103366Assert.True(tf1.HasNotNullConstraint);
103368Assert.True(tf1.HasConstructorConstraint);
103419Assert.True(tf1.HasConstructorConstraint);
103476Assert.True(tf1.HasConstructorConstraint);
103506Assert.True(tf2.HasConstructorConstraint);
103557Assert.True(tf1.HasConstructorConstraint);
103584Assert.True(tf2.HasConstructorConstraint);
103638Assert.True(tf1.HasConstructorConstraint);
103666Assert.True(tf2.HasConstructorConstraint);
103726Assert.True(tf1.HasConstructorConstraint);
103757Assert.True(tf2.HasConstructorConstraint);
103814Assert.True(tf1.HasConstructorConstraint);
103844Assert.True(tf2.HasConstructorConstraint);
103895Assert.True(tf1.HasConstructorConstraint);
103922Assert.True(tf2.HasConstructorConstraint);
103982Assert.True(tf1.HasConstructorConstraint);
104013Assert.True(tf2.HasConstructorConstraint);
104069Assert.True(tf1.HasConstructorConstraint);
104098Assert.True(tf2.HasConstructorConstraint);
112499Assert.True(diagnostic.Equals(diagnostic));
113129Assert.True(method1.Equals(method1));
113136Assert.True(method1.Equals(method2));
113137Assert.True(method2.Equals(method1));
113142Assert.True(method1.Equals(method2, SymbolEqualityComparer.IncludeNullability.CompareKind));
113143Assert.True(method2.Equals(method1, SymbolEqualityComparer.IncludeNullability.CompareKind));
114030Assert.True(model.TryGetSpeculativeSemanticModel(decl.Identifier.SpanStart, type, out model, SpeculativeBindingOption.BindAsTypeOrNamespace));
115704Assert.True(implicitOp.IsDefinition);
115705Assert.True(explicitOp.IsDefinition);
115706Assert.True(getDefault.IsDefinition);
115883Assert.True(cDefinition.Equals(c4, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds));
115891Assert.True(iDefinition.Equals(i4, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds));
115897Assert.True(c.Equals(c2));
115898Assert.True(c.Equals(c2, SymbolEqualityComparer.Default.CompareKind));
115901Assert.True(c.Equals(c2, TypeCompareKind.AllIgnoreOptions));
136988Assert.True(t.HasConstructorConstraint);
137020Assert.True(t.HasConstructorConstraint);
137021Assert.True(t.HasReferenceTypeConstraint);
137116Assert.True(t.HasConstructorConstraint);
137117Assert.True(t.HasReferenceTypeConstraint);
137139Assert.True(t.HasConstructorConstraint);
137140Assert.True(t.HasReferenceTypeConstraint);
137161Assert.True(t.HasConstructorConstraint);
137162Assert.True(t.HasReferenceTypeConstraint);
137183Assert.True(t.HasConstructorConstraint);
137184Assert.True(t.HasReferenceTypeConstraint);
137209Assert.True(t.HasConstructorConstraint);
137210Assert.True(t.HasReferenceTypeConstraint);
137235Assert.True(t.HasConstructorConstraint);
137236Assert.True(t.HasReferenceTypeConstraint);
139422Assert.True(dGoo.Parameters[0].TypeWithAnnotations.NullableAnnotation == NullableAnnotation.Annotated);
144235Assert.True(IsNullableAnalysisEnabled(comp, "C.M"));
144423Assert.True(IsNullableAnalysisEnabled(comp, "C.M"));
146459Assert.True(model.TryGetSpeculativeSemanticModel(
157589Assert.True(field2.Equals(field3, SymbolEqualityComparer.Default));
157591Assert.True(field3.Equals(field2, SymbolEqualityComparer.Default));
157595Assert.True(field1.Equals(field2, SymbolEqualityComparer.Default));
157597Assert.True(field2.Equals(field1, SymbolEqualityComparer.Default));
157601Assert.True(field1.Equals(field3, SymbolEqualityComparer.Default));
157602Assert.True(field1.Equals(field3, SymbolEqualityComparer.IncludeNullability));
157603Assert.True(field3.Equals(field1, SymbolEqualityComparer.Default));
157604Assert.True(field3.Equals(field1, SymbolEqualityComparer.IncludeNullability));
157630Assert.True(method1.IsDefinition);
157637Assert.True(method3.IsDefinition);
157653Assert.True(method1.Equals(method3, SymbolEqualityComparer.Default));
157654Assert.True(method1.Equals(method3, SymbolEqualityComparer.IncludeNullability));
157655Assert.True(method3.Equals(method1, SymbolEqualityComparer.Default));
157656Assert.True(method3.Equals(method1, SymbolEqualityComparer.IncludeNullability));
158272Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Item"));
158312Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Item"));
158348Assert.True(model.LookupNames(item.SpanStart, t.GetPublicSymbol()).Contains("Item"));
158482Assert.True(model.LookupNames(item.SpanStart, i3.GetPublicSymbol()).Contains("Get"));
Semantics\ReadOnlyStructsTests.cs (14)
1194Assert.True(getMethod(s1, "M2").IsReadOnly);
1196Assert.True(getProperty(s1, "P1").GetMethod.IsReadOnly);
1199Assert.True(getProperty(s1, "P2").GetMethod.IsReadOnly);
1201Assert.True(getProperty(s1, "P3").GetMethod.IsReadOnly);
1203Assert.True(getProperty(s1, "P4").SetMethod.IsReadOnly);
1208Assert.True(getEvent(s1, "E").AddMethod.IsReadOnly);
1209Assert.True(getEvent(s1, "E").RemoveMethod.IsReadOnly);
1212Assert.True(getMethod(s2, "M1").IsReadOnly);
1215Assert.True(getProperty(s2, "P1").GetMethod.IsReadOnly);
1217Assert.True(getProperty(s2, "P2").GetMethod.IsReadOnly);
1219Assert.True(getProperty(s2, "P3").SetMethod.IsReadOnly);
1224Assert.True(getEvent(s2, "E").AddMethod.IsReadOnly);
1225Assert.True(getEvent(s2, "E").RemoveMethod.IsReadOnly);
1324Assert.True(property.IsReadOnly);
Semantics\SimpleLambdaParametersWithModifiersTests.cs (31)
68Assert.True(symbol.Parameters is [{ Type.SpecialType: SpecialType.System_String, RefKind: RefKind.None }, { Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.Ref }]);
100Assert.True(symbol.Parameters is [
169Assert.True(symbol.Parameters is [{ Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.Ref, IsOptional: false }]);
201Assert.True(
204Assert.True(
327Assert.True(symbol.Parameters.Single().IsOptional);
386Assert.True(symbol.Parameters is [
420Assert.True(symbol.Parameters is [{ Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.None, IsOptional: true }]);
452Assert.True(symbol.Parameters is [{ Type: IErrorTypeSymbol, RefKind: RefKind.None, IsOptional: false }]);
481Assert.True(symbol.Parameters is [{ Name: "", Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.Ref, IsOptional: false }]);
513Assert.True(symbol.Parameters is [{ Name: "", Type: IErrorTypeSymbol { Name: "x" }, RefKind: RefKind.Ref, IsOptional: false }]);
546Assert.True(symbol.Parameters is [{ Name: "", Type: IErrorTypeSymbol { Name: "x" }, RefKind: RefKind.Ref, IsOptional: false }]);
579Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.Ref, IsOptional: false }]);
612Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, IsOptional: false } parameter] &&
641Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_String, RefKind: RefKind.Ref, IsOptional: false }]);
669Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.In, IsOptional: false }]);
701Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.In, IsOptional: false }]);
730Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.Out, IsOptional: false }]);
759Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.Out, IsOptional: false }]);
790Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, RefKind: RefKind.Ref, IsOptional: false }]);
824Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_String, Type.NullableAnnotation: CodeAnalysis.NullableAnnotation.Annotated, RefKind: RefKind.Ref, IsOptional: false }]);
858Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_String, Type.NullableAnnotation: CodeAnalysis.NullableAnnotation.NotAnnotated, RefKind: RefKind.Ref, IsOptional: false }]);
890Assert.True(symbol.Parameters is [{ Name: "x", Type.TypeKind: TypeKind.Dynamic, RefKind: RefKind.Ref, IsOptional: false }]);
936Assert.True(symbol.Parameters is [{ Name: "x", Type: IArrayTypeSymbol { ElementType.SpecialType: SpecialType.System_Int32 }, IsParams: true }]);
964Assert.True(symbol.Parameters is [{ Name: "x", Type: IArrayTypeSymbol { ElementType.SpecialType: SpecialType.System_Int32 }, IsParams: false }]);
1005Assert.True(operation.Body.Operations.Single() is IReturnOperation { ReturnedValue: null });
1040Assert.True(symbol.Parameters is [{ Name: "x", Type: IArrayTypeSymbol { ElementType.SpecialType: SpecialType.System_Int32 }, RefKind: RefKind.Ref, IsParams: true }]);
1075Assert.True(symbol.Parameters is [{ Name: "x", Type: IArrayTypeSymbol { ElementType.SpecialType: SpecialType.System_Int32 }, RefKind: RefKind.Ref, IsParams: true }]);
1104Assert.True(symbol.Parameters is [{ Name: "x", Type: IErrorTypeSymbol, RefKind: RefKind.Out, IsParams: false }]);
1133Assert.True(symbol.Parameters is [{ Name: "x", Type: IErrorTypeSymbol, RefKind: RefKind.Ref, IsParams: false }]);
1223Assert.True(symbol.Parameters is [{ Name: "x", Type.SpecialType: SpecialType.System_Int32, IsParams: true }]);
SourceGeneration\GeneratorDriverTests_Attributes_FullyQualifiedName.cs (56)
83step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C1" }));
162step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C2" }));
192step => Assert.True(step.Outputs.Single().Value is CompilationUnitSyntax c && c.SyntaxTree == compilation.SyntaxTrees.Single()));
222step => Assert.True(step.Outputs.Single().Value is CompilationUnitSyntax c && c.SyntaxTree == compilation.SyntaxTrees.Single()));
249step => Assert.True(step.Outputs.Single().Value is CompilationUnitSyntax c && c.SyntaxTree == compilation.SyntaxTrees.First()));
276step => Assert.True(step.Outputs.Single().Value is CompilationUnitSyntax c && c.SyntaxTree == compilation.SyntaxTrees.Last()));
304step => Assert.True(step.Outputs.Single().Value is CompilationUnitSyntax c && c.SyntaxTree == compilation.SyntaxTrees.First()),
305step => Assert.True(step.Outputs.Single().Value is CompilationUnitSyntax c && c.SyntaxTree == compilation.SyntaxTrees.Last()));
335step => Assert.True(step.Outputs.Single().Value is LocalFunctionStatementSyntax { Identifier.ValueText: "LocalFunc" }));
371step => Assert.True(step.Outputs.Single().Value is LocalFunctionStatementSyntax { Identifier.ValueText: "LocalFunc" }));
410step => Assert.True(step.Outputs.Single().Value is LocalFunctionStatementSyntax { Identifier.ValueText: "LocalFunc" }));
439step => Assert.True(step.Outputs.Single().Value is TypeParameterSyntax { Identifier.ValueText: "T" }));
472step => Assert.True(step.Outputs.Single().Value is MethodDeclarationSyntax { Identifier.ValueText: "M" }));
505step => Assert.True(step.Outputs.Single().Value is MethodDeclarationSyntax { Identifier.ValueText: "M" }));
537step => Assert.True(step.Outputs.Single().Value is MethodDeclarationSyntax { Identifier.ValueText: "M", Body: null, ExpressionBody: null }));
569step => Assert.True(step.Outputs.Single().Value is MethodDeclarationSyntax { Identifier.ValueText: "M", Body: not null }));
600step => Assert.True(step.Outputs.Single().Value is VariableDeclaratorSyntax { Identifier.ValueText: "m" }));
632v => Assert.True(v.Value is VariableDeclaratorSyntax { Identifier.ValueText: "m" }),
633v => Assert.True(v.Value is VariableDeclaratorSyntax { Identifier.ValueText: "n" })));
664step => Assert.True(step.Outputs.Single().Value is VariableDeclaratorSyntax { Identifier.ValueText: "m" }));
696v => Assert.True(v.Value is VariableDeclaratorSyntax { Identifier.ValueText: "m" }),
697v => Assert.True(v.Value is VariableDeclaratorSyntax { Identifier.ValueText: "n" })));
724step => Assert.True(step.Outputs.Single().Value is LambdaExpressionSyntax));
758step => Assert.True(step.Outputs.Single().Value is AccessorDeclarationSyntax { RawKind: (int)SyntaxKind.GetAccessorDeclaration }));
787step => Assert.True(step.Outputs.Single().Value is TypeParameterSyntax { Identifier.ValueText: "T" }));
824step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C1" }));
861step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C2" }));
898step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C1" }));
935step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C2" }));
1032Assert.True(ctx.Attributes.Length == 2);
1043step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1069Assert.True(ctx.Attributes.Length == 2);
1080step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1107Assert.True(ctx.Attributes.Length == 1);
1118step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1145Assert.True(ctx.Attributes.Length == 1);
1156step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1183Assert.True(ctx.Attributes.Length == 1);
1194step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1221Assert.True(ctx.Attributes.Length == 1);
1232step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1344step => Assert.True(
1390step => Assert.True(
1429step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1436step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1476step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1483step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1523step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1529step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1575step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1624t => Assert.True(t.Value is ClassDeclarationSyntax { Identifier.ValueText: "C1" }),
1625t => Assert.True(t.Value is ClassDeclarationSyntax { Identifier.ValueText: "C2" })));
1676step => Assert.Collection(step.Outputs, t => Assert.True(t.Value is ClassDeclarationSyntax { Identifier.ValueText: "C1" })),
1677step => Assert.Collection(step.Outputs, t => Assert.True(t.Value is ClassDeclarationSyntax { Identifier.ValueText: "C2" })));
1740step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
1788step => Assert.True(step.Outputs.Single().Value is ClassDeclarationSyntax { Identifier.ValueText: "C" }));
SourceGeneration\StateTableTests.cs (13)
96Assert.True(didRemoveEntries);
166Assert.True(didRemoveEntries);
188Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 2), TimeSpan.Zero, default, EntryState.Modified));
189Assert.True(builder.TryModifyEntries(ImmutableArray<int>.Empty, TimeSpan.Zero, default, EntryState.Modified));
190Assert.True(builder.TryModifyEntries(ImmutableArray.Create(3, 5), TimeSpan.Zero, default, EntryState.Modified));
212Assert.True(builder.TryModifyEntry(1, TimeSpan.Zero, default, EntryState.Modified));
213Assert.True(builder.TryModifyEntry(2, TimeSpan.Zero, default, EntryState.Modified));
214Assert.True(builder.TryModifyEntry(5, TimeSpan.Zero, default, EntryState.Modified));
215Assert.True(builder.TryModifyEntry(4, TimeSpan.Zero, default, EntryState.Modified));
236Assert.True(builder.TryModifyEntry(1, TimeSpan.Zero, default, EntryState.Modified)); // ((1, EntryState.Cached))
237Assert.True(builder.TryModifyEntry(4, TimeSpan.Zero, default, EntryState.Modified)); // ((4, EntryState.Modified))
238Assert.True(builder.TryModifyEntry(5, TimeSpan.Zero, default, EntryState.Modified)); // ((3, EntryState.Cached))
316Assert.True(newTable.HasTrackedSteps);
Utilities\ValueSetTests.cs (23)
346Assert.True(ForDouble.Related(Equal, double.NaN).Any(Equal, double.NaN));
347Assert.True(ForFloat.Related(Equal, float.NaN).Any(Equal, float.NaN));
358Assert.True(neg.Any(LessThan, double.MinValue));
363Assert.True(mi.Any(LessThan, 0.0));
365Assert.True(mi.Any(LessThanOrEqual, 0.0));
377Assert.True(i.Any(GreaterThan, 0.0));
379Assert.True(i.Any(GreaterThanOrEqual, 0.0));
583Assert.True(ForDecimal.Related(LessThanOrEqual, d).Any(Equal, d));
585Assert.True(ForDecimal.Related(GreaterThanOrEqual, d).Any(Equal, d));
631Assert.True(s2.Any(Equal, value));
642Assert.True(s2.Any(Equal, value));
722Assert.True(s1.Any(LessThan, i + 1));
725Assert.True(s1.Any(LessThanOrEqual, i + 1));
726Assert.True(s1.Any(LessThanOrEqual, i));
730Assert.True(s1.Any(GreaterThan, i - 1));
732Assert.True(s1.Any(GreaterThanOrEqual, i));
733Assert.True(s1.Any(GreaterThanOrEqual, i - 1));
744Assert.True(s1.Any(LessThan, j + 1));
747Assert.True(s1.Any(LessThanOrEqual, j + 1));
748Assert.True(s1.Any(LessThanOrEqual, j));
752Assert.True(s1.Any(GreaterThan, j - 1));
754Assert.True(s1.Any(GreaterThanOrEqual, j));
755Assert.True(s1.Any(GreaterThanOrEqual, j - 1));
Microsoft.CodeAnalysis.CSharp.Symbol.UnitTests (1397)
Compilation\GetImportScopesTests.cs (78)
55Assert.True(scopes.Single().Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
56Assert.True(scopes.Single().Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax);
71Assert.True(scopes.Single().Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
72Assert.True(scopes.Single().Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax);
102Assert.True(scopes.Single().Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
103Assert.True(scopes.Single().Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax);
130Assert.True(scopes.Single().Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
131Assert.True(scopes.Single().Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax);
147Assert.True(scopes.Single().Imports.Any(i => i.NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) }));
148Assert.True(scopes.Single().Imports.Any(i => i.NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(Microsoft) }));
149Assert.True(scopes.Single().Imports.Any(i => i.DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } }));
150Assert.True(scopes.Single().Imports.Any(i => i.DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(Microsoft) } }));
175Assert.True(scopes.Single().Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
176Assert.True(scopes.Single().Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } });
198Assert.True(scopes[0].Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(Microsoft) });
199Assert.True(scopes[0].Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(Microsoft) } });
200Assert.True(scopes[1].Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
201Assert.True(scopes[1].Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } });
226Assert.True(scopes[0].Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(Microsoft) });
227Assert.True(scopes[0].Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(Microsoft) } });
228Assert.True(scopes[1].Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
229Assert.True(scopes[1].Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } });
244Assert.True(scopes.Single().Aliases.Single() is { Name: "S", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) } });
245Assert.True(scopes.Single().Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax);
260Assert.True(scopes.Single().Aliases.Single() is { Name: "S", Target: { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) } });
261Assert.True(scopes.Single().Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax);
291Assert.True(scopes.Single().Aliases.Single() is { Name: "S", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) } });
292Assert.True(scopes.Single().Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax);
319Assert.True(scopes.Single().Aliases.Single() is { Name: "S", Target: { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) } });
320Assert.True(scopes.Single().Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax);
336Assert.True(scopes.Single().Aliases.Any(a => a is { Name: "S", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) } }));
337Assert.True(scopes.Single().Aliases.Any(a => a is { Name: "M", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(Microsoft) } }));
338Assert.True(scopes.Single().Aliases.Any(a => a.DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } }));
339Assert.True(scopes.Single().Aliases.Any(a => a.DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(Microsoft) } }));
364Assert.True(scopes.Single().Aliases.Single() is { Name: "S", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) } });
365Assert.True(scopes.Single().Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } });
387Assert.True(scopes[0].Aliases.Single() is { Name: "M", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(Microsoft) } });
388Assert.True(scopes[0].Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(Microsoft) } });
389Assert.True(scopes[1].Aliases.Single() is { Name: "S", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) } });
390Assert.True(scopes[1].Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } });
418Assert.True(scopes.Single().ExternAliases.Single() is { Name: "CORE" });
419Assert.True(scopes.Single().ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax);
437Assert.True(scopes.Single().ExternAliases.Single() is { Name: "CORE", Target: INamespaceSymbol { IsGlobalNamespace: true } });
438Assert.True(scopes.Single().ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax);
459Assert.True(scopes.Single().ExternAliases.Single() is { Name: "CORE", Target: INamespaceSymbol { IsGlobalNamespace: true } });
460Assert.True(scopes.Single().ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax);
480Assert.True(scopes.Single().ExternAliases.Single() is { Name: "CORE", Target: INamespaceSymbol { IsGlobalNamespace: true } });
481Assert.True(scopes.Single().ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax);
499Assert.True(scopes.Single().ExternAliases.Single() is { Name: "CORE", Target: INamespaceSymbol { IsGlobalNamespace: true } });
500Assert.True(scopes.Single().ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax);
516Assert.True(scopes.Single().ExternAliases.Single() is { Name: "CORE", Target: INamespaceSymbol { IsGlobalNamespace: true } });
517Assert.True(scopes.Single().ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax);
536Assert.True(scopes.Single().ExternAliases.Any(a => a is { Name: "CORE1", Target: INamespaceSymbol { IsGlobalNamespace: true } }));
537Assert.True(scopes.Single().ExternAliases.Any(a => a is { Name: "CORE2", Target: INamespaceSymbol { IsGlobalNamespace: true } }));
538Assert.True(scopes.Single().ExternAliases.Any(a => a.DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax { Identifier.Text: "CORE1" }));
539Assert.True(scopes.Single().ExternAliases.Any(a => a.DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax { Identifier.Text: "CORE2" }));
567Assert.True(scopes.Single().ExternAliases.Single() is { Name: "CORE1", Target: INamespaceSymbol { IsGlobalNamespace: true } });
568Assert.True(scopes.Single().ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax { Identifier.Text: "CORE1" });
593Assert.True(scopes[0].ExternAliases.Single() is { Name: "CORE2", Target: INamespaceSymbol { IsGlobalNamespace: true } });
594Assert.True(scopes[0].ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax { Identifier.Text: "CORE2" });
595Assert.True(scopes[1].ExternAliases.Single() is { Name: "CORE1", Target: INamespaceSymbol { IsGlobalNamespace: true } });
596Assert.True(scopes[1].ExternAliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is ExternAliasDirectiveSyntax { Identifier.Text: "CORE1" });
622Assert.True(scopes.Single().Aliases.Single() is { Name: "M", Target: INamespaceSymbol { Name: nameof(Microsoft) } });
623Assert.True(scopes.Single().Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Alias.Name.Identifier.Text: "M" });
625Assert.True(scopes.Single().Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
626Assert.True(scopes.Single().Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } });
648Assert.True(scopes.Single().Imports.Single().NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) });
649Assert.True(scopes.Single().Imports.Single().DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax);
652Assert.True(scopes.Single().Aliases.Single() is { Name: "M", Target: INamespaceSymbol { Name: nameof(Microsoft) } });
653Assert.True(scopes.Single().Aliases.Single().DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Alias.Name.Identifier.Text: "M" });
682Assert.True(scopes.Single().Imports.Any(i => i.NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(System) }));
683Assert.True(scopes.Single().Imports.Any(i => i.DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(System) } }));
684Assert.True(scopes.Single().Imports.Any(i => i.NamespaceOrType is INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: false, Name: nameof(System.IO) }));
685Assert.True(scopes.Single().Imports.Any(i => i.DeclaringSyntaxReference!.GetSyntax() is UsingDirectiveSyntax { Name: QualifiedNameSyntax { Right: IdentifierNameSyntax { Identifier.Text: nameof(System.IO) } } }));
688Assert.True(scopes.Single().Aliases.Any(i => i is { Name: "M", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: true, Name: nameof(Microsoft) } }));
689Assert.True(scopes.Single().Aliases.Any(i => i.DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Name: IdentifierNameSyntax { Identifier.Text: nameof(Microsoft) } }));
690Assert.True(scopes.Single().Aliases.Any(i => i is { Name: "T", Target: INamespaceSymbol { ContainingNamespace.IsGlobalNamespace: false, Name: nameof(System.Threading) } }));
691Assert.True(scopes.Single().Aliases.Any(i => i.DeclaringSyntaxReferences.Single().GetSyntax() is UsingDirectiveSyntax { Name: QualifiedNameSyntax { Right: IdentifierNameSyntax { Identifier.Text: nameof(System.Threading) } } }));
Compilation\SemanticModelAPITests.cs (81)
146Assert.True(propertySymbol.IsIndexer);
207Assert.True(rxSymbol.IsRef);
239Assert.True(rxSymbol.IsRef);
1273Assert.True(aliasTarget.IsGlobalNamespace);
1426Assert.True(success);
1428Assert.True(speculativeModel.IsSpeculativeSemanticModel);
1466Assert.True(success);
1481Assert.True(speculativeModel.IgnoresAccessibility);
1515Assert.True(success);
1563Assert.True(success);
1603Assert.True(success);
1685Assert.True(success);
1687Assert.True(speculativeModel.IsSpeculativeSemanticModel);
1782Assert.True(success);
1836Assert.True(success);
1849Assert.True(success);
1883Assert.True(success);
1921Assert.True(success);
1959Assert.True(success);
1996Assert.True(success);
2036Assert.True(success);
2038Assert.True(speculativeModel.IsSpeculativeSemanticModel);
2078Assert.True(success);
2095Assert.True(success);
2111Assert.True(success);
2228Assert.True(success);
2265Assert.True(success);
2357Assert.True(success);
2453Assert.True(success);
2495Assert.True(success);
2540Assert.True(success);
2572Assert.True(success);
2587Assert.True(success);
2601Assert.True(success);
2644Assert.True(success);
2680Assert.True(success);
2704Assert.True(success);
2708Assert.True(speculativeModel.IsSpeculativeSemanticModel);
2780Assert.True(success);
2786Assert.True(constantVal.HasValue);
2842Assert.True(speculativeModel.IgnoresAccessibility);
2899Assert.True(success);
2933Assert.True(success);
2973Assert.True(success);
3018Assert.True(success);
3046Assert.True(success);
3129Assert.True(model.TryGetSpeculativeSemanticModel(methodDeclLocation, returnStatement, out var speculativeModel));
3193Assert.True(success);
3228Assert.True(success);
3258Assert.True(success);
3299Assert.True(success);
3340Assert.True(success);
3416Assert.True(success);
3457Assert.True(success);
3498Assert.True(success);
3620Assert.True(success);
3659Assert.True(newSymbol.Equals(oldSymbol));
3820Assert.True(model.TryGetSpeculativeSemanticModel(localFunctionBody.Block!.Statements[0].SpanStart + 1, @return, out var specModel));
3884Assert.True(target.IsGlobalNamespace);
3945Assert.True(value0.HasValue);
3947Assert.True(typeInfo0.Type != null && typeInfo0.Type.SpecialType == SpecialType.System_Int16);
3956Assert.True(typeInfo1.Type != null && typeInfo1.Type.Equals(type1));
3963Assert.True(typeInfo2.Type != null && typeInfo2.Type.Equals(type2));
4139Assert.True(model.GetConstantValue(actual[0]).HasValue);
4219Assert.True(model.GetConstantValue(actual[0]).HasValue);
4244Assert.True(model.GetConstantValue(actual[0]).HasValue);
4248Assert.True(model.GetConstantValue(actual[1]).HasValue);
4272Assert.True(model.GetConstantValue(actual[0]).HasValue);
4413Assert.True(semanticModel.IsAccessible(positionInN, fieldX));
4416Assert.True(semanticModel.IsAccessible(positionInB, fieldX));
4417Assert.True(semanticModel.IsAccessible(positionInB, fieldY));
4418Assert.True(semanticModel.IsAccessible(positionInB, fieldZ));
4419Assert.True(semanticModel.IsAccessible(positionInBGoo, fieldX));
4420Assert.True(semanticModel.IsAccessible(positionInBGoo, fieldY));
4421Assert.True(semanticModel.IsAccessible(positionInBGoo, fieldZ));
4422Assert.True(semanticModel.IsAccessible(positionInCGoo, fieldX));
4461Assert.True(model.TryGetSpeculativeSemanticModel(ifStatement.SpanStart, replacementIfStatement, out var specModel));
4532Assert.True(type.IsTupleType);
4610Assert.True(type.IsTupleType);
4663Assert.True(alias1.Equals(alias2));
4794Assert.True(preprocessingSymbol.CanBeReferencedByName);
DeclarationTests.cs (7)
129Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "C", "D" }));
160Assert.True(table.TypeNames.Distinct().OrderBy(s => s).SequenceEqual(new[] { "C", "D" }));
236Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B" }));
239Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B", "C", "D" }));
242Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B" }));
245Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "A", "B", "C", "D" }));
248Assert.True(table.TypeNames.OrderBy(s => s).SequenceEqual(new[] { "C", "D" }));
Symbols\ConversionTests.cs (28)
247Assert.True(f1Type.Equals(f2Type, TypeCompareKind.AllIgnoreOptions));
248Assert.True(f2Type.Equals(f1Type, TypeCompareKind.AllIgnoreOptions));
249Assert.True(f1Type.Equals(f1Type, TypeCompareKind.AllIgnoreOptions));
250Assert.True(f2Type.Equals(f2Type, TypeCompareKind.AllIgnoreOptions));
253Assert.True(f3Type.Equals(f4Type, TypeCompareKind.AllIgnoreOptions));
254Assert.True(f4Type.Equals(f3Type, TypeCompareKind.AllIgnoreOptions));
261Assert.True(f6Type.Equals(f7Type, TypeCompareKind.AllIgnoreOptions));
262Assert.True(f7Type.Equals(f6Type, TypeCompareKind.AllIgnoreOptions));
263Assert.True(f6Type.Equals(f6Type, TypeCompareKind.AllIgnoreOptions));
264Assert.True(f7Type.Equals(f7Type, TypeCompareKind.AllIgnoreOptions));
265Assert.True(f8Type.Equals(f7Type, TypeCompareKind.AllIgnoreOptions));
266Assert.True(f7Type.Equals(f8Type, TypeCompareKind.AllIgnoreOptions));
267Assert.True(f8Type.Equals(f8Type, TypeCompareKind.AllIgnoreOptions));
268Assert.True(f7Type.Equals(f7Type, TypeCompareKind.AllIgnoreOptions));
269Assert.True(f8Type.Equals(f6Type, TypeCompareKind.AllIgnoreOptions));
270Assert.True(f6Type.Equals(f8Type, TypeCompareKind.AllIgnoreOptions));
271Assert.True(f8Type.Equals(f8Type, TypeCompareKind.AllIgnoreOptions));
272Assert.True(f6Type.Equals(f6Type, TypeCompareKind.AllIgnoreOptions));
278Assert.True(g1Type.Equals(g2Type, TypeCompareKind.AllIgnoreOptions));
279Assert.True(g2Type.Equals(g1Type, TypeCompareKind.AllIgnoreOptions));
280Assert.True(g1Type.Equals(g1Type, TypeCompareKind.AllIgnoreOptions));
281Assert.True(g2Type.Equals(g2Type, TypeCompareKind.AllIgnoreOptions));
403Assert.True(conversion.IsImplicit);
404Assert.True(conversion.IsNumeric);
416Assert.True(conversion.IsImplicit);
417Assert.True(conversion.IsNumeric);
425Assert.True(conversion.IsExplicit);
426Assert.True(conversion.IsNumeric);
Symbols\Source\NullablePublicAPITests.cs (28)
1169Assert.True(syntaxContext.SemanticModel.TryGetSpeculativeSemanticModel(syntaxContext.Node.SpanStart, newSource, out var specModel));
1395Assert.True(model.TryGetSpeculativeSemanticModel(spanStart, newSource, out var speculativeModel));
1444Assert.True(model.TryGetSpeculativeSemanticModel(returnStatement.SpanStart, newSource, out var specModel));
1765Assert.True(isNullableAnalysisEnabled(comp));
2138Assert.True(model.TryGetSpeculativeSemanticModel(s2Assignment.SpanStart, newDeclaration, out var specModel));
2142Assert.True(model.TryGetSpeculativeSemanticModel(lastDeclaration.SpanStart, newDeclaration, out specModel));
2634Assert.True(info.CandidateSymbols.IsEmpty);
2843Assert.True(event1.Equals(event2, SymbolEqualityComparer.Default));
3272Assert.True(propertySymbol.IsIndexer);
3323Assert.True(propertySymbol.IsIndexer);
3701Assert.True(model.TryGetSpeculativeSemanticModel(localFunctionBody.Body!.OpenBraceToken.SpanStart + 1, @return, out var specModel));
3736Assert.True(model.TryGetSpeculativeSemanticModel(localFunctionBody.Block!.OpenBraceToken.SpanStart + 1, @return, out var specModel));
3781Assert.True(model.TryGetSpeculativeSemanticModel(lambda.Body.SpanStart, newStatement, out var speculativeModel));
4063Assert.True(model.TryGetSpeculativeSemanticModel(localFunction.SpanStart, speculativeAttribute, out var speculativeModel));
4068Assert.True(model.TryGetSpeculativeSemanticModel(localFunction.ParameterList.Parameters[0].Default.SpanStart, speculativeInitializer, out speculativeModel));
4211Assert.True(model.TryGetSpeculativeSemanticModel(attributeUsage.SpanStart, newAttributeUsage, out var specModel));
4365Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel));
4393Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel));
4423Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel));
4453Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel));
4483Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, statement, out var speculativeModel));
4515Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(type.SpanStart, methodDeclaration, out var speculativeModel));
4548Assert.True(model.TryGetSpeculativeSemanticModelForMethodBody(type.SpanStart, methodDeclaration, out var speculativeModel));
4576Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, arrow, out var speculativeModel));
4606Assert.True(model.TryGetSpeculativeSemanticModel(type.SpanStart, arrow, out var speculativeModel));
4637Assert.True(model.TryGetSpeculativeSemanticModel(initializer.SpanStart, newInitializer, out var speculativeModel));
4670Assert.True(model.TryGetSpeculativeSemanticModel(initializer.SpanStart, newInitializer, out var speculativeModel));
4909Assert.True(model.TryGetSpeculativeSemanticModel(spanStart, newBody, out var speculativeModel));
Symbols\SymbolEqualityTests.cs (20)
205Assert.True(field1.Equals(field1));
206Assert.True(field2.Equals(field2));
387Assert.True(SymbolEqualityComparer.Default.Equals(symbol2, symbol3));
388Assert.True(SymbolEqualityComparer.Default.Equals(symbol3, symbol2));
390Assert.True(SymbolEqualityComparer.ConsiderEverything.Equals(symbol2, symbol3));
391Assert.True(SymbolEqualityComparer.ConsiderEverything.Equals(symbol3, symbol2));
419Assert.True(member1.Equals(member1));
420Assert.True(member2.Equals(member2));
427Assert.True(field1.Equals(field1));
428Assert.True(field2.Equals(field2));
974Assert.True(symbol1.Equals(symbol1));
975Assert.True(symbol2.Equals(symbol2));
976Assert.True(symbol1.Equals(symbol2));
977Assert.True(symbol2.Equals(symbol1));
980Assert.True(symbol1.Equals(symbol1, SymbolEqualityComparer.Default));
981Assert.True(symbol2.Equals(symbol2, SymbolEqualityComparer.Default));
982Assert.True(symbol1.Equals(symbol2, SymbolEqualityComparer.Default));
983Assert.True(symbol2.Equals(symbol1, SymbolEqualityComparer.Default));
986Assert.True(symbol1.Equals(symbol1, SymbolEqualityComparer.IncludeNullability));
987Assert.True(symbol2.Equals(symbol2, SymbolEqualityComparer.IncludeNullability));
Microsoft.CodeAnalysis.CSharp.Syntax.UnitTests (496)
Microsoft.CodeAnalysis.CSharp.Test.Utilities (17)
Microsoft.CodeAnalysis.CSharp.WinRT.UnitTests (24)
Microsoft.CodeAnalysis.CSharp.Workspaces.UnitTests (22)
Microsoft.CodeAnalysis.EditorFeatures.Test.Utilities (7)
Microsoft.CodeAnalysis.EditorFeatures.UnitTests (227)
Extensions\EnumerableExtensionTests.cs (8)
28Assert.True(elements.SequenceEqual(result));
35Assert.True(Enumerable(1, 2, 3, 4).SequenceEqual(elements.Concat(4)));
52Assert.True(Enumerable<bool>().All());
53Assert.True(Enumerable(true).All());
54Assert.True(Enumerable(true, true).All());
75Assert.True(sequence.Flatten().SequenceEqual(Enumerable("a", "b", "c", "d", "e", "f")));
85Assert.True(seq.SequenceEqual(seq, equality));
88Assert.True(seq.SequenceEqual(new int[] { 1, 2, 3 }, equality));
Utilities\SymbolEquivalenceComparerTests.cs (93)
68Assert.True(SymbolEquivalenceComparer.Instance.Equals(intField1.Type, intField1.Type));
69Assert.True(SymbolEquivalenceComparer.Instance.Equals(intField1.Type, intField2.Type));
73Assert.True(SymbolEquivalenceComparer.Instance.Equals(intArrayField1.Type, intArrayField1.Type));
74Assert.True(SymbolEquivalenceComparer.Instance.Equals(intArrayField1.Type, intArrayField2.Type));
78Assert.True(SymbolEquivalenceComparer.Instance.Equals(stringArrayField1.Type, stringArrayField1.Type));
79Assert.True(SymbolEquivalenceComparer.Instance.Equals(stringArrayField1.Type, stringArrayField2.Type));
81Assert.True(SymbolEquivalenceComparer.Instance.Equals(intArrayArrayField1.Type, intArrayArrayField1.Type));
82Assert.True(SymbolEquivalenceComparer.Instance.Equals(intArrayArrayField1.Type, intArrayArrayField2.Type));
84Assert.True(SymbolEquivalenceComparer.Instance.Equals(intArrayRank2Field1.Type, intArrayRank2Field1.Type));
85Assert.True(SymbolEquivalenceComparer.Instance.Equals(intArrayRank2Field1.Type, intArrayRank2Field2.Type));
87Assert.True(SymbolEquivalenceComparer.Instance.Equals(int32Field1.Type, int32Field1.Type));
88Assert.True(SymbolEquivalenceComparer.Instance.Equals(int32Field1.Type, int32Field2.Type));
96Assert.True(SymbolEquivalenceComparer.Instance.Equals(int32Field1.Type, intField1.Type));
141Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpIntField1.Type, vbIntField1.Type));
142Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayField1.Type, vbIntArrayField1.Type));
143Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpStringArrayField1.Type, vbStringArrayField1.Type));
144Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpIntArrayArrayField1.Type, vbIntArrayArrayField1.Type));
145Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpInt32Field1.Type, vbInt32Field1.Type));
153Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpInt32Field1.Type, vbIntField1.Type));
161Assert.True(SymbolEquivalenceComparer.Instance.Equals(vbInt32Field1.Type, csharpIntField1.Type));
208Assert.True(SymbolEquivalenceComparer.Instance.Equals(field1_v1, field1_v2));
213Assert.True(SymbolEquivalenceComparer.Instance.Equals(field3_v1, field3_v2));
259Assert.True(SymbolEquivalenceComparer.Instance.Equals(field1_v1, field1_v2));
261Assert.True(SymbolEquivalenceComparer.Instance.Equals(field3_v1, field3_v2));
303Assert.True(SymbolEquivalenceComparer.Instance.Equals(goo, goo_instanceInstantiation));
307Assert.True(SymbolEquivalenceComparer.Instance.Equals(goo_intInstantiation1, goo_intInstantiation2));
434Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
461Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
488Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
515Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
565Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
628Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, vbGooMethod));
673Assert.True(SymbolEquivalenceComparer.Instance.Equals(csharpGooMethod, vbGooMethod));
728Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
729Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v2, method_v1));
796Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
797Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v2, method_v1));
868Assert.True(SymbolEquivalenceComparer.Instance.Equals(outer1, outer2));
872Assert.True(SymbolEquivalenceComparer.Instance.Equals(inner1, inner2));
876Assert.True(SymbolEquivalenceComparer.Instance.Equals(outerType1, outerType2));
880Assert.True(SymbolEquivalenceComparer.Instance.Equals(innerType1, innerType2));
889Assert.True(SymbolEquivalenceComparer.Instance.Equals(outer1, inner1.ContainingSymbol));
893Assert.True(SymbolEquivalenceComparer.Instance.Equals(outer1, innerType1.ContainingSymbol.ContainingSymbol));
897Assert.True(SymbolEquivalenceComparer.Instance.Equals(inner1, innerType1.ContainingSymbol));
901Assert.True(SymbolEquivalenceComparer.Instance.Equals(outer1, outerType1.ContainingSymbol));
938Assert.True(SymbolEquivalenceComparer.Instance.Equals(type1_v1, type1_v2));
939Assert.True(SymbolEquivalenceComparer.Instance.Equals(type1_v2, type1_v1));
943Assert.True(SymbolEquivalenceComparer.Instance.Equals(type2_v1, type2_v2));
944Assert.True(SymbolEquivalenceComparer.Instance.Equals(type2_v2, type2_v1));
1087Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
1088Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v2, method_v1));
1125Assert.True(falseComp.Equals(method_v1, method_v2));
1126Assert.True(falseComp.Equals(method_v2, method_v1));
1218Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
1219Assert.True(SymbolEquivalenceComparer.TupleNamesMustMatchInstance.Equals(method_v1, method_v2));
1249Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
1280Assert.True(SymbolEquivalenceComparer.Instance.Equals(method_v1, method_v2));
1361Assert.True(ignoreComparer.Equals(a1, a2));
1362Assert.True(ignoreComparer.Equals(b1, b2));
1363Assert.True(ignoreComparer.Equals(c1, c2));
1364Assert.True(ignoreComparer.Equals(d1, d2));
1425Assert.True(ignoreComparer.Equals(a1, a2));
1426Assert.True(ignoreComparer.Equals(b1, b2));
1427Assert.True(ignoreComparer.Equals(c1, c2));
1428Assert.True(ignoreComparer.Equals(d1, d2));
1429Assert.True(notIgnoreComparer.Equals(a1, a2));
1430Assert.True(notIgnoreComparer.Equals(b1, b2));
1431Assert.True(notIgnoreComparer.Equals(c1, c2));
1432Assert.True(notIgnoreComparer.Equals(d1, d2));
1488Assert.True(ignoreComparer.Equals(a1, a2));
1489Assert.True(ignoreComparer.Equals(b1, b2));
1490Assert.True(ignoreComparer.Equals(c1, c2));
1491Assert.True(ignoreComparer.Equals(d1, d2));
1551Assert.True(ignoreComparer.Equals(a1, a2));
1552Assert.True(ignoreComparer.Equals(b1, b2));
1553Assert.True(ignoreComparer.Equals(c1, c2));
1554Assert.True(ignoreComparer.Equals(d1, d2));
1721Assert.True(SymbolEquivalenceComparer.IgnoreAssembliesInstance.Equals(namespace1, namespace2));
1755Assert.True(SymbolEquivalenceComparer.IgnoreAssembliesInstance.Equals(ta1, ta2));
1756Assert.True(SymbolEquivalenceComparer.Instance.Equals(ta1, ta2));
1757Assert.True(identityComparer.Equals(ta1, ta2));
1760Assert.True(SymbolEquivalenceComparer.IgnoreAssembliesInstance.Equals(ta1, tb1));
1765Assert.True(SymbolEquivalenceComparer.IgnoreAssembliesInstance.Equals(tb1, tb2));
1766Assert.True(SymbolEquivalenceComparer.Instance.Equals(tb1, tb2));
1770Assert.True(SymbolEquivalenceComparer.IgnoreAssembliesInstance.Equals(tb2, tb3));
1771Assert.True(SymbolEquivalenceComparer.Instance.Equals(tb2, tb3));
1772Assert.True(identityComparer.Equals(tb2, tb3));
1843Assert.True(identityComparer.Equals(f1[0], f2[0]));
1849Assert.True(identityComparer.Equals(f1[1], f2[1]));
1855Assert.True(identityComparer.Equals(f1[2], f2[2]));
1861Assert.True(identityComparer.Equals(f1[3], f2[3]));
1876Assert.True(SymbolEquivalenceComparer.Instance.Equals(method1, method2));
1881Assert.True(SymbolEquivalenceComparer.Instance.Equals(cfmethod1, cfmethod2));
Microsoft.CodeAnalysis.ExpressionEvaluator.FunctionResolver.UnitTests (4)
Microsoft.CodeAnalysis.ExpressionEvaluator.ResultProvider.Utilities (2)
Microsoft.CodeAnalysis.Features.Test.Utilities (5)
Microsoft.CodeAnalysis.Features.UnitTests (10)
Microsoft.CodeAnalysis.LanguageServer.Protocol.UnitTests (67)
Microsoft.CodeAnalysis.LanguageServer.UnitTests (3)
Microsoft.CodeAnalysis.Rebuild.UnitTests (8)
Microsoft.CodeAnalysis.Remote.ServiceHub.UnitTests (1)
Microsoft.CodeAnalysis.Scripting.Desktop.UnitTests (2)
Microsoft.CodeAnalysis.Scripting.UnitTests (9)
Microsoft.CodeAnalysis.Test.Utilities (59)
Microsoft.CodeAnalysis.UnitTests (800)
Collections\ImmutableArrayExtensionsTests.cs (51)
55Assert.True(nullOrEmpty.IsDefault);
56Assert.True(nullOrEmpty.IsDefaultOrEmpty);
60Assert.True(nullOrEmpty.IsEmpty);
181Assert.True(roaNull == null);
183Assert.True(null == roaNull);
187Assert.True(copy == roaNull);
192Assert.True(notnull != null);
194Assert.True(null != notnull);
271Assert.True(a.Concat(a).SequenceEqual(ImmutableArray.Create<int>(0, 2, 4, 0, 2, 4)));
283Assert.True(a.AddRange(a).SequenceEqual(ImmutableArray.Create<int>(0, 2, 4, 0, 2, 4)));
287Assert.True(a.SequenceEqual(empty.AddRange((IEnumerable<int>)a)));
288Assert.True(a.AddRange((IEnumerable<int>)a).SequenceEqual(ImmutableArray.Create<int>(0, 2, 4, 0, 2, 4)));
300Assert.True(a.SequenceEqual(empty.InsertRange(0, a)));
301Assert.True(a.InsertRange(2, a).SequenceEqual(ImmutableArray.Create<int>(0, 2, 0, 2, 4, 4)));
342Assert.True(a.SequenceEqual(b, StringComparer.OrdinalIgnoreCase));
349Assert.True(r.SequenceEqual(Enumerable.Range(1, 3)));
354Assert.True(r.SequenceEqual(s, (x, y) => 10 * x == y));
361Assert.True(empty.SequenceEqual(empty.SelectAsArray(item => item)));
362Assert.True(empty.SequenceEqual(empty.SelectAsArray((item, arg) => item, 1)));
363Assert.True(empty.SequenceEqual(empty.SelectAsArray((item, arg) => arg, 2)));
364Assert.True(empty.SequenceEqual(empty.SelectAsArray((item, index, arg) => item, 1)));
365Assert.True(empty.SequenceEqual(empty.SelectAsArray((item, index, arg) => arg, 2)));
366Assert.True(empty.SequenceEqual(empty.SelectAsArray((item, index, arg) => index, 3)));
371Assert.True(a.SequenceEqual(a.SelectAsArray(item => item)));
372Assert.True(a.SequenceEqual(a.SelectAsArray((item, arg) => item, 1)));
373Assert.True(c.SequenceEqual(a.SelectAsArray((item, arg) => arg, 2)));
374Assert.True(a.SequenceEqual(a.SelectAsArray((item, index, arg) => item, 1)));
375Assert.True(c.SequenceEqual(a.SelectAsArray((item, index, arg) => arg, 2)));
376Assert.True(b.SequenceEqual(a.SelectAsArray((item, index, arg) => index, 3)));
400Assert.True(empty.SequenceEqual(empty.ZipAsArray(empty, (item1, item2) => item1)));
405Assert.True(single3.SequenceEqual(single1.ZipAsArray(single2, (item1, item2) => item1 + item2)));
410Assert.True(pair3.SequenceEqual(pair1.ZipAsArray(pair2, (item1, item2) => item1 + item2)));
415Assert.True(triple3.SequenceEqual(triple1.ZipAsArray(triple2, (item1, item2) => item1 + item2)));
420Assert.True(quad3.SequenceEqual(quad1.ZipAsArray(quad2, (item1, item2) => item1 + item2)));
425Assert.True(quin3.SequenceEqual(quin1.ZipAsArray(quin2, (item1, item2) => item1 + item2)));
432Assert.True(empty.SequenceEqual(empty.ZipAsArray(empty, (item1, item2) => item1)));
437Assert.True(single3.SequenceEqual(single1.ZipAsArray(single2, 2, (item1, item2, i, arg) => item1 + item2 + i + arg)));
442Assert.True(pair3.SequenceEqual(pair1.ZipAsArray(pair2, 2, (item1, item2, i, arg) => item1 + item2 + i + arg)));
447Assert.True(triple3.SequenceEqual(triple1.ZipAsArray(triple2, 2, (item1, item2, i, arg) => item1 + item2 + i + arg)));
452Assert.True(quad3.SequenceEqual(quad1.ZipAsArray(quad2, 2, (item1, item2, i, arg) => item1 + item2 + i + arg)));
457Assert.True(quin3.SequenceEqual(quin1.ZipAsArray(quin2, 2, (item1, item2, i, arg) => item1 + item2 + i + arg)));
473Assert.True(a.WhereAsArray(i => false).SequenceEqual(ImmutableArray.Create<int>()));
475Assert.True(a.WhereAsArray(i => i > 0).SequenceEqual(ImmutableArray.Create<int>(1, 2, 3, 4, 5)));
477Assert.True(a.WhereAsArray(i => i < 5).SequenceEqual(ImmutableArray.Create<int>(0, 1, 2, 3, 4)));
479Assert.True(a.WhereAsArray(i => i == 0).SequenceEqual(ImmutableArray.Create<int>(0)));
481Assert.True(a.WhereAsArray(i => i == 5).SequenceEqual(ImmutableArray.Create<int>(5)));
483Assert.True(a.WhereAsArray(i => i < 3).SequenceEqual(ImmutableArray.Create<int>(0, 1, 2)));
485Assert.True(a.WhereAsArray(i => i > 2).SequenceEqual(ImmutableArray.Create<int>(3, 4, 5)));
487Assert.True(a.WhereAsArray(i => i % 2 == 0).SequenceEqual(ImmutableArray.Create<int>(0, 2, 4)));
489Assert.True(a.WhereAsArray(i => i % 2 == 1).SequenceEqual(ImmutableArray.Create<int>(1, 3, 5)));
519Assert.True(arrayOfD2.Equals(arrayOfD));
Collections\ImmutableDictionaryTestBase.cs (19)
54Assert.True(IsSame(map, sameMap));
134Assert.True(dictionary.IsReadOnly);
143Assert.True(dictionary.IsSynchronized);
173Assert.True(dictionary.Contains("c"));
176Assert.True(dictionary.IsFixedSize);
177Assert.True(dictionary.IsReadOnly);
191Assert.True(enumerator.MoveNext());
209Assert.True(enumerator.MoveNext());
227Assert.True(dictionary.TryGetKey("a", out string actualKey));
230Assert.True(dictionary.TryGetKey("A", out actualKey));
240Assert.True(IsSame(empty, empty.Clear()));
259Assert.True(GetValueComparer(map).Equals(value1, value2));
262Assert.True(IsSame(map, map.Add(key, value2)));
263Assert.True(IsSame(map, map.AddRange(new[] { new KeyValuePair<TKey, TValue>(key, value2) })));
295Assert.True(map.Add(key, value).ContainsKey(key));
303Assert.True(map.Add(key, value).Contains(new KeyValuePair<TKey, TValue>(key, value)));
304Assert.True(map.Add(key, value).Contains(key, value));
311Assert.True(IsSame(map, map.Remove(key)));
312Assert.True(IsSame(map, map.RemoveRange(Enumerable.Empty<TKey>())));
Collections\ImmutableDictionaryTestBase.nonnetstandard.cs (17)
72Assert.True(Empty<int, int>().Equals(Empty<int, int>()));
79Assert.True(Empty<int, int>().ToReadOnlyDictionary().Equals(Empty<int, int>()));
80Assert.True(Empty<int, int>().Equals(Empty<int, int>().ToReadOnlyDictionary()));
81Assert.True(Empty<int, int>().ToReadOnlyDictionary().Equals(Empty<int, int>().ToReadOnlyDictionary()));
98Assert.True(IsSame(map, jointMap));
101Assert.True(IsSame(map, jointMap));
104Assert.True(IsSame(map, jointMap));
134Assert.True(addedMap.ContainsKey(key));
152Assert.True(map.ContainsKey(i));
166Assert.True(map.ContainsKey(i));
183Assert.True(map.ContainsKey(inputs[i]));
198Assert.True(IsSame(empty, empty.RemoveRange(Enumerable.Empty<int>())));
199Assert.True(IsSame(empty, empty.AddRange(Enumerable.Empty<KeyValuePair<int, int>>())));
204Assert.True(halfRemoved.ContainsKey(8));
289Assert.True(collection.Contains(containedValue));
296Assert.True(nonGeneric.IsSynchronized);
297Assert.True(collection.IsReadOnly);
Collections\ImmutableSegmentedDictionaryTest.cs (9)
43Assert.True(map.ContainsKey("Johnny"));
163Assert.True(IsSame(dictionary, result));
273Assert.True(IsSame(ImmutableSegmentedDictionary<string, int>.Empty, dictionary.Clear()));
290Assert.True(clearedDictionary.ContainsKey("A"));
311Assert.True(map.Keys.All((key, arg) => key.Length == arg, 1));
313Assert.True(ImmutableSegmentedDictionary<int, int>.Empty.Keys.All((_, _) => false, 0));
324Assert.True(map.Values.All((key, arg) => key.Length == arg, 1));
326Assert.True(ImmutableSegmentedDictionary<int, int>.Empty.Values.All((_, _) => false, 0));
348Assert.True(map.Add(key, value).ContainsValue(value));
Collections\ImmutableSegmentedListTest.cs (22)
108Assert.True(IsSame(empty, ImmutableSegmentedList<GenericParameterHelper>.Empty));
109Assert.True(IsSame(empty, empty.Clear()));
110Assert.True(IsSame(empty, ((System.Collections.Immutable.IImmutableList<GenericParameterHelper>)empty).Clear()));
111Assert.True(empty.IsEmpty);
173Assert.True(IsSame(emptyList, emptyList.AddRange(new string[0])));
177Assert.True(IsSame(nonEmptyListDefaultComparer, emptyList.AddRange(nonEmptyListDefaultComparer)));
181Assert.True(IsSame(nonEmptyListDefaultComparer, emptyList.AddRange(builderOfNonEmptyListDefaultComparer)));
319Assert.True(list.Contains(null));
324Assert.True(list.IsEmpty);
397Assert.True(IsSame(list, list.Remove(3)));
455Assert.True(list.Contains(newElement));
462Assert.True(list.Contains(existingElement));
570Assert.True(ImmutableSegmentedList<int>.Empty.Equals(ImmutableSegmentedList<int>.Empty));
606Assert.True(IsSame(list, list.ToImmutableSegmentedList()));
618Assert.True(ImmutableSegmentedList<int>.Empty.RemoveRange(0, 0).IsEmpty);
653Assert.True(IsSame(list, list.RemoveRange(new[] { 5 })));
654Assert.True(IsSame(ImmutableSegmentedList.Create<int>(), ImmutableSegmentedList.Create<int>().RemoveRange(new[] { 1 })));
715Assert.True(IsSame(emptyList, emptyList.Reverse()));
739Assert.True(collection.IsSynchronized);
746Assert.True(list.IsReadOnly);
747Assert.True(list.IsFixedSize);
760Assert.True(list.IsReadOnly);
Collections\ImmutableSetTest.cs (28)
55Assert.True(IsSame(emptySet, emptySet.Remove(5)));
69Assert.True(IsSame(set, setAfterRemoval));
78Assert.True(IsSame(set, empty2.Union(set))); // "Filling an empty immutable set with the contents of another immutable set with the exact same comparer should return the other set."
97Assert.True(enumerated);
103Assert.True(this.Empty<int>().SetEquals(this.Empty<int>()));
105Assert.True(nonEmptySet.SetEquals(nonEmptySet));
145Assert.True(Empty<int>().Equals(Empty<int>()));
165Assert.True(IsSame(originalSet, clearedSet));
186Assert.True(set.IsReadOnly);
202Assert.True(builder.IsSynchronized);
212Assert.True(set.Contains(null));
213Assert.True(set.TryGetValue(null, out var @null));
218Assert.True(set.IsSupersetOf(new[] { null, "a" }));
219Assert.True(set.IsSubsetOf(new[] { null, "a" }));
220Assert.True(set.IsProperSupersetOf(new[] { (string?)null }));
221Assert.True(set.IsProperSubsetOf(new[] { null, "a", "b" }));
222Assert.True(set.Overlaps(new[] { null, "b" }));
223Assert.True(set.SetEquals(new[] { null, null, "a", "a" }));
291Assert.True(IsSame(emptySet, emptySet.Clear()));
392Assert.True(IsSame(set, set.Except(Enumerable.Empty<T>())));
403Assert.True(IsSame(nextSet, nextSet.Remove(value))); //, "Removing a non-existing element should not change the set reference.");
425Assert.True(set.Contains(value));
479Assert.True(enumerator.MoveNext());
488Assert.True(IsSame(set, set.Union(Enumerable.Empty<T>())));
497Assert.True(enumerateAddSet.Contains(value));
505Assert.True(nextSet.Count > 0);
514Assert.True(nextSet.Contains(value));
521Assert.True(IsSame(nextSet, nextSet.Add(value))); //, "Adding duplicate value {0} should keep the original reference.", value);
Collections\SegmentedCollectionsMarshalTests.cs (70)
67Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
123Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
202Assert.True(Unsafe.IsNullRef(ref Unsafe.AsRef(in SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3))));
249Assert.True(Unsafe.IsNullRef(ref Unsafe.AsRef(in SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3))));
303Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
357Assert.True(Unsafe.IsNullRef(ref SegmentedCollectionsMarshal.GetValueRefOrNullRef(dict, 3)));
407Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<int>(null).IsDefault);
408Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<int?>(null).IsDefault);
409Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<Guid>(null).IsDefault);
410Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<Guid?>(null).IsDefault);
411Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<string>(null).IsDefault);
412Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<CustomClass>(null).IsDefault);
413Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<ManagedCustomStruct>(null).IsDefault);
414Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<ManagedCustomStruct?>(null).IsDefault);
415Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<UnmanagedCustomStruct>(null).IsDefault);
416Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList<UnmanagedCustomStruct?>(null).IsDefault);
422Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<int>(0)).IsEmpty);
423Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<int?>(0)).IsEmpty);
424Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<Guid>(0)).IsEmpty);
425Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<Guid?>(0)).IsEmpty);
426Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<string>(0)).IsEmpty);
427Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<CustomClass>(0)).IsEmpty);
428Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<ManagedCustomStruct>(0)).IsEmpty);
429Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<ManagedCustomStruct?>(0)).IsEmpty);
430Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<UnmanagedCustomStruct>(0)).IsEmpty);
431Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedList(new SegmentedList<UnmanagedCustomStruct?>(0)).IsEmpty);
448Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
515Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
533Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<int>(null).IsDefault);
534Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<int?>(null).IsDefault);
535Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<Guid>(null).IsDefault);
536Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<Guid?>(null).IsDefault);
537Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<string>(null).IsDefault);
538Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<CustomClass>(null).IsDefault);
539Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<ManagedCustomStruct>(null).IsDefault);
540Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<ManagedCustomStruct?>(null).IsDefault);
541Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<UnmanagedCustomStruct>(null).IsDefault);
542Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet<UnmanagedCustomStruct?>(null).IsDefault);
548Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<int>(0)).IsEmpty);
549Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<int?>(0)).IsEmpty);
550Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<Guid>(0)).IsEmpty);
551Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<Guid?>(0)).IsEmpty);
552Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<string>(0)).IsEmpty);
553Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<CustomClass>(0)).IsEmpty);
554Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<ManagedCustomStruct>(0)).IsEmpty);
555Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<ManagedCustomStruct?>(0)).IsEmpty);
556Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<UnmanagedCustomStruct>(0)).IsEmpty);
557Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedHashSet(new SegmentedHashSet<UnmanagedCustomStruct?>(0)).IsEmpty);
669Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<int, int>(null).IsDefault);
670Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<int, int?>(null).IsDefault);
671Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<Guid, Guid>(null).IsDefault);
672Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<Guid, Guid?>(null).IsDefault);
673Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<string, string>(null).IsDefault);
674Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<CustomClass, CustomClass>(null).IsDefault);
675Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct>(null).IsDefault);
676Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct?>(null).IsDefault);
677Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct>(null).IsDefault);
678Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct?>(null).IsDefault);
684Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<int, int>(0)).IsEmpty);
685Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<int, int?>(0)).IsEmpty);
686Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<Guid, Guid>(0)).IsEmpty);
687Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<Guid, Guid?>(0)).IsEmpty);
688Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<string, string>(0)).IsEmpty);
689Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<CustomClass, CustomClass>(0)).IsEmpty);
690Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct>(0)).IsEmpty);
691Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<ManagedCustomStruct, ManagedCustomStruct?>(0)).IsEmpty);
692Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct>(0)).IsEmpty);
693Assert.True(SegmentedCollectionsMarshal.AsImmutableSegmentedDictionary(new SegmentedDictionary<UnmanagedCustomStruct, UnmanagedCustomStruct?>(0)).IsEmpty);
710Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
777Assert.True(Unsafe.AreSame(ref expectedRef, ref actualRef));
CryptoBlobParserTests.cs (13)
30Assert.True(CryptoBlobParser.TryParseKey(key, out _, out privateKeyOpt));
64Assert.True(key.Skip(HEADER_LEN + MOD_LEN * 2 + HALF_LEN * 5).ToArray().Length == 0);
73Assert.True(CryptoBlobParser.TryParseKey(key, out _, out privateKeyOpt));
74Assert.True(privateKeyOpt.HasValue);
107Assert.True(key.Skip(HEADER_LEN + MOD_LEN * 2 + HALF_LEN * 5).ToArray().Length == 0);
116Assert.True(CryptoBlobParser.TryParseKey(key, out pubKey, out _));
117Assert.True(CryptoBlobParser.IsValidPublicKey(pubKey));
127Assert.True(CryptoBlobParser.TryParseKey(key, out pubKey, out _));
128Assert.True(CryptoBlobParser.IsValidPublicKey(pubKey));
138Assert.True(CryptoBlobParser.TryParseKey(key, out pubKey, out _));
139Assert.True(CryptoBlobParser.IsValidPublicKey(pubKey));
156Assert.True(CryptoBlobParser.TryParseKey(publicKeyBlob, out pubKey, out _));
157Assert.True(CryptoBlobParser.IsValidPublicKey(pubKey));
FileSystem\PathUtilitiesTests.cs (32)
179Assert.True(
181Assert.True(
185Assert.True(
192Assert.True(
194Assert.True(
198Assert.True(
205Assert.True(
207Assert.True(
211Assert.True(
231Assert.True(
233Assert.True(
237Assert.True(
261Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\", @"C:"));
262Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\", @"C:\"));
263Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:", @"C:"));
264Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:", @"C:\"));
266Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH", @"C:"));
267Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH", @"C:\"));
269Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH\", @"C:"));
270Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH\", @"C:\"));
272Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH", @"C:\ABCD"));
273Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH", @"C:\ABCD\"));
275Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH\", @"C:\ABCD"));
276Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH\", @"C:\ABCD\"));
278Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH", @"C:\ABCD\EFGH"));
279Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH", @"C:\ABCD\EFGH\"));
281Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH\", @"C:\ABCD\EFGH"));
282Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\ABCD\EFGH\", @"C:\ABCD\EFGH\"));
298Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\a\B\C", @"C:\A\B", StringComparison.OrdinalIgnoreCase));
299Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"C:\A\b\C", @"C:\A\B", StringComparison.OrdinalIgnoreCase));
308Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"/a/B/C", @"/A/B", StringComparison.OrdinalIgnoreCase));
309Assert.True(PathUtilities.IsSameDirectoryOrChildOf(@"/A/b/C", @"/A/B", StringComparison.OrdinalIgnoreCase));
InternalUtilities\EnumerableExtensionsTests.cs (3)
20Assert.True(EnumerableExtensions.SequenceEqual((IEnumerable<int>)null, null, comparer));
24Assert.True(EnumerableExtensions.SequenceEqual(new[] { 1 }, new[] { 1 }, comparer));
28Assert.True(EnumerableExtensions.SequenceEqual(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }, comparer));
InternalUtilities\OneOrManyTests.cs (30)
33Assert.True(actual.SequenceEqual(expected));
80Assert.True(OneOrMany.Create(1).Contains(1));
85Assert.True(OneOrMany.Create(ImmutableArray.Create(1)).Contains(1));
88Assert.True(OneOrMany.Create(ImmutableArray.Create(1, 2)).Contains(1));
89Assert.True(OneOrMany.Create(ImmutableArray.Create(1, 2)).Contains(2));
150Assert.True(OneOrMany<int>.Empty.All(_ => false));
151Assert.True(OneOrMany<int>.Empty.All(_ => true));
163Assert.True(OneOrMany<int>.Empty.All((_, _) => false, 0));
164Assert.True(OneOrMany<int>.Empty.All((_, _) => true, 0));
177Assert.True(OneOrMany.Create(1).Any());
178Assert.True(OneOrMany.Create(1, 2).Any());
188Assert.True(OneOrMany.Create(1).Any(i => i > 0));
191Assert.True(OneOrMany.Create(1, 2).Any(i => i > 1));
201Assert.True(OneOrMany.Create(1).Any((i, a) => i > a, 0));
204Assert.True(OneOrMany.Create(1, 2).Any((i, a) => i > a, 1));
223Assert.True(OneOrMany<int>.Empty.SequenceEqual(OneOrMany<int>.Empty));
228Assert.True(OneOrMany.Create(1).SequenceEqual(OneOrMany.Create(1)));
230Assert.True(OneOrMany.Create(1, 2).SequenceEqual(OneOrMany.Create(1, 2)));
234Assert.True(OneOrMany.Create(1).SequenceEqual(OneOrMany.Create(ImmutableArray.Create(1))));
236Assert.True(OneOrMany<int>.Empty.SequenceEqual(new int[0]));
239Assert.True(OneOrMany.Create(1).SequenceEqual(new[] { 1 }));
241Assert.True(OneOrMany.Create(1, 2).SequenceEqual(new[] { 1, 2 }));
245Assert.True(new int[0].SequenceEqual(OneOrMany<int>.Empty));
248Assert.True(new[] { 1 }.SequenceEqual(OneOrMany.Create(1)));
250Assert.True(new[] { 1, 2 }.SequenceEqual(OneOrMany.Create(1, 2)));
254Assert.True(ImmutableArray<int>.Empty.SequenceEqual(OneOrMany<int>.Empty));
257Assert.True(ImmutableArray.Create(1).SequenceEqual(OneOrMany.Create(1)));
259Assert.True(ImmutableArray.Create(1, 2).SequenceEqual(OneOrMany.Create(1, 2)));
268Assert.True(OneOrMany.Create(1).SequenceEqual(new[] { 11 }, comparer));
269Assert.True(OneOrMany.Create(1, 2).SequenceEqual(new[] { 11, 32 }, comparer));
LinePositionTests.cs (8)
81Assert.True(new LinePosition(1, 1) < new LinePosition(1, 2));
84Assert.True(new LinePosition(1, 2) < new LinePosition(2, 1));
85Assert.True(new LinePosition(1, 2) <= new LinePosition(1, 2));
86Assert.True(new LinePosition(1, 2) <= new LinePosition(2, 1));
89Assert.True(new LinePosition(1, 2) > new LinePosition(1, 1));
92Assert.True(new LinePosition(2, 1) > new LinePosition(1, 2));
93Assert.True(new LinePosition(2, 1) >= new LinePosition(2, 1));
94Assert.True(new LinePosition(2, 1) >= new LinePosition(1, 2));
MetadataReferences\AssemblyIdentityMapTests.cs (7)
27Assert.True(map.Contains(new AssemblyIdentity("a", new Version(1, 0, 0, 0))));
28Assert.True(map.TryGetValue(new AssemblyIdentity("a", new Version(1, 0, 0, 0)), out value));
31Assert.True(map.Contains(new AssemblyIdentity("a", new Version(1, 1, 0, 0))));
32Assert.True(map.TryGetValue(new AssemblyIdentity("a", new Version(1, 1, 0, 0)), out value));
35Assert.True(map.Contains(new AssemblyIdentity("a", new Version(1, 0, 0, 0)), allowHigherVersion: false));
36Assert.True(map.TryGetValue(new AssemblyIdentity("a", new Version(1, 0, 0, 0)), out value, allowHigherVersion: false));
47Assert.True(map.TryGetValue(new AssemblyIdentity("b", new Version(1, 0, 0, 0)), out value));
Microsoft.CodeAnalysis.VisualBasic.CommandLine.UnitTests (76)
Microsoft.CodeAnalysis.VisualBasic.Emit.UnitTests (30)
Microsoft.CodeAnalysis.VisualBasic.Scripting.UnitTests (4)
Microsoft.CodeAnalysis.VisualBasic.Semantic.UnitTests (115)
Microsoft.CodeAnalysis.VisualBasic.Symbol.UnitTests (2)
Microsoft.CodeAnalysis.VisualBasic.Syntax.UnitTests (18)
Microsoft.CodeAnalysis.VisualBasic.Workspaces.UnitTests (43)
Microsoft.CodeAnalysis.Workspaces.MSBuild.UnitTests (13)
Microsoft.CodeAnalysis.Workspaces.Test.Utilities (2)
Microsoft.CodeAnalysis.Workspaces.UnitTests (285)
EditorConfigParsing\EditorConfigFileParserTests.cs (19)
38Assert.True(parseResults.TryGetSectionForLanguage(Language.CSharp, out var section));
42Assert.True(parseResults.TryGetSectionForLanguage(Language.VisualBasic, out section));
46Assert.True(parseResults.TryGetSectionForLanguage((Language.CSharp | Language.VisualBasic), out section));
78Assert.True(parseResults.TryGetSectionForLanguage(Language.CSharp, SectionMatch.ExactLanguageMatchWithOthers, out var section));
94Assert.True(parseResults.TryGetSectionForLanguage(Language.CSharp, SectionMatch.Any, out var section));
98Assert.True(parseResults.TryGetSectionForLanguage(Language.VisualBasic, SectionMatch.Any, out section));
102Assert.True(parseResults.TryGetSectionForLanguage((Language.CSharp | Language.VisualBasic), SectionMatch.Any, out section));
120Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\CSharp\Program.cs", out var section));
124Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\VisualBasic\Program.vb", out section));
159Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\CSharp\Program.cs", SectionMatch.Any, out var section));
163Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\VisualBasic\Program.vb", SectionMatch.Any, out section));
178Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\CSharp\Program.cs", SectionMatch.Any, out var section));
182Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\VisualBasic\Program.vb", SectionMatch.Any, out section));
204Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\CSharp\Program.cs", SectionMatch.Any, out var section));
208Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\VisualBasic\Program.vb", SectionMatch.Any, out section));
221Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\CSharp\Program.cs", SectionMatch.Any, out var section));
225Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\VisualBasic\Program.vb", SectionMatch.Any, out section));
237Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\CSharp\Program.cs", SectionMatch.Any, out var section));
241Assert.True(parseResults.TryGetSectionForFilePath(@"C:\dev\sources\VisualBasic\Program.vb", SectionMatch.Any, out section));
SolutionTests\SolutionTests.cs (48)
58Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution
80Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution
310Assert.True(newSolution1.GetDocument(documentId)!.TryGetSyntaxRoot(out var actualRoot));
377Assert.True(newSolution1.GetDocument(documentId)!.TryGetText(out var actualText));
378Assert.True(newSolution1.GetDocument(documentId)!.TryGetTextVersion(out var actualVersion));
841Assert.True(workspace.TryApplyChanges(workspace.CurrentSolution
923Assert.True(newSolution1.GetAdditionalDocument(documentId)!.TryGetText(out var actualText));
945Assert.True(newSolution1.GetAdditionalDocument(documentId)!.TryGetText(out var actualText));
946Assert.True(newSolution1.GetAdditionalDocument(documentId)!.TryGetTextVersion(out var actualVersion));
969Assert.True(newSolution1.GetAnalyzerConfigDocument(documentId)!.TryGetText(out var actualText));
991Assert.True(newSolution1.GetAnalyzerConfigDocument(documentId)!.TryGetText(out var actualText));
992Assert.True(newSolution1.GetAnalyzerConfigDocument(documentId)!.TryGetTextVersion(out var actualVersion));
2303Assert.True(workspace.TryApplyChanges(solution3));
3152Assert.True(document.TryGetSyntaxRoot(out root));
3210Assert.True(annotatedRoot.IsEquivalentTo(root2));
3211Assert.True(root2.HasAnnotation(annotation));
3447Assert.True(tree.IsEquivalentTo(docTree));
3808Assert.True(newRoot.ContainsDirectives);
4317Assert.True(frozenCompilation.ContainsSyntaxTree(await frozenDocument.GetSyntaxTreeAsync()));
4318Assert.True(frozenCompilation.ContainsSyntaxTree(await originalProject.Documents.Single().GetSyntaxTreeAsync()));
4345Assert.True(frozenCompilation.ContainsSyntaxTree(await frozenDocument.GetSyntaxTreeAsync()));
4346Assert.True(frozenCompilation.ContainsSyntaxTree(await originalProject.Documents.Single().GetSyntaxTreeAsync()));
4462Assert.True(frozenDoc1Root.DescendantNodes().Any(n => n.RawKind == ClassDeclaration));
4478Assert.True(frozenDoc1Root.DescendantNodes().Any(n => n.RawKind == StructDeclaration));
4543Assert.True(exceptionThrown);
4557Assert.True(exceptionThrown);
4717Assert.True(provider.TryGetDiagnosticValue(newSyntaxTree, "CA1234", CancellationToken.None, out var severity));
4746Assert.True(provider.TryGetDiagnosticValue(syntaxTreeAfterAddingEditorConfig, "CA1234", CancellationToken.None, out var severity));
4759Assert.True(finalCompilation.ContainsSyntaxTree(syntaxTreeAfterRemovingEditorConfig));
4787Assert.True(provider.TryGetDiagnosticValue(syntaxTreeBeforeEditorConfigChange, "CA1234", CancellationToken.None, out var severity));
4800Assert.True(provider.TryGetDiagnosticValue(syntaxTreeBeforeEditorConfigChange, "CA6789", CancellationToken.None, out severity));
4805Assert.True(finalCompilation.ContainsSyntaxTree(syntaxTreeAfterEditorConfigChange));
4831Assert.True(newProvider.TryGetGlobalDiagnosticValue("CA1234", default, out var severity));
5014Assert.True(solution.GetProject(projectId1).ProjectReferences.Contains(p => p.ProjectId == projectId2));
5019Assert.True(compilation1.References.Any(r => r is CompilationReference compilationReference && compilationReference.Compilation == compilation2));
5042Assert.True(solution.GetProject(projectId2).ProjectReferences.Contains(p => p.ProjectId == projectId1));
5047Assert.True(compilation2.References.Any(r => r is CompilationReference compilationReference && compilationReference.Compilation == compilation1));
5144Assert.True(compilation1New.References.Any(r => r is CompilationReference compilationReference && compilationReference.Compilation == compilation2));
5145Assert.True(compilation1New.References.Any(r => r is CompilationReference compilationReference && compilationReference.Compilation == compilation3));
5192Assert.True(compilation1.References.Any(r => r is CompilationReference compilationReference && compilationReference.Compilation == compilation2));
5193Assert.True(compilation1.References.Any(r => r is CompilationReference compilationReference && compilationReference.Compilation == compilation3));
5208Assert.True(compilation1New.References.All(r => r is not CompilationReference));
5642Assert.True(frozenCompilation.ContainsSyntaxTree(await frozenProject.Documents.Single().GetSyntaxTreeAsync()));
5667Assert.True(frozenCompilation1.ContainsSyntaxTree(await frozenProject1.Documents.Single().GetSyntaxTreeAsync()));
5694Assert.True(frozenCompilation1.ContainsSyntaxTree(await frozenProject1.Documents.Single().GetSyntaxTreeAsync()));
5724Assert.True(frozenCompilation1.ContainsSyntaxTree(await frozenProject1.Documents.Single().GetSyntaxTreeAsync()));
5731Assert.True(frozenCompilation2.ContainsSyntaxTree(await frozenProject2.Documents.Single().GetSyntaxTreeAsync()));
5758Assert.True(forkedCompilation1.ContainsSyntaxTree(forkedSyntaxTree1));
SyntaxPathTests.cs (23)
24Assert.True(path.TryResolve(node, out SyntaxNode recovered));
43Assert.True(path.TryResolve(node, out SyntaxNode recovered));
73Assert.True(path.TryResolve(root, out ArgumentListSyntax recovered));
83Assert.True(path.TryResolve(tree, CancellationToken.None, out SyntaxNode node));
97Assert.True(path.TryResolve(newTree, CancellationToken.None, out SyntaxNode node));
111Assert.True(path.TryResolve(newTree, CancellationToken.None, out SyntaxNode node));
124Assert.True(path.TryResolve(tree, CancellationToken.None, out SyntaxNode node));
159Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
160Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
161Assert.True(path3.TryResolve(tree, CancellationToken.None, out SyntaxNode n3));
193Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
194Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
228Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
229Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
258Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
288Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
317Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
318Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
346Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
347Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
385Assert.True(path1.TryResolve(tree, CancellationToken.None, out SyntaxNode n1));
386Assert.True(path2.TryResolve(tree, CancellationToken.None, out SyntaxNode n2));
404Assert.True(path.TryResolve(newTree, CancellationToken.None, out SyntaxNode node));
UtilityTest\IntervalTreeTests.cs (20)
95Assert.True(Set("A").SetEquals(spans));
106Assert.True(Set("A").SetEquals(spans));
117Assert.True(Set("A").SetEquals(spans));
128Assert.True(Set("A").SetEquals(spans));
139Assert.True(Set("A").SetEquals(spans));
150Assert.True(Set("A").SetEquals(spans));
161Assert.True(Set("A").SetEquals(spans));
176Assert.True(Set("A").SetEquals(GetIntervalsThatOverlapWith(tree, 6, 2).Select(i => i.Item3)));
177Assert.True(Set("B").SetEquals(GetIntervalsThatOverlapWith(tree, 16, 2).Select(i => i.Item3)));
180Assert.True(Set("A", "B").SetEquals(GetIntervalsThatOverlapWith(tree, 2, 20).Select(i => i.Item3)));
181Assert.True(Set("A", "B").SetEquals(GetIntervalsThatOverlapWith(tree, 2, 14).Select(i => i.Item3)));
182Assert.True(Set("A", "B").SetEquals(GetIntervalsThatOverlapWith(tree, 6, 10).Select(i => i.Item3)));
183Assert.True(Set("A", "B").SetEquals(GetIntervalsThatOverlapWith(tree, 6, 20).Select(i => i.Item3)));
218Assert.True(HasIntervalThatIntersectsWith(tree, 0));
219Assert.True(HasIntervalThatIntersectsWith(tree, 1));
220Assert.True(HasIntervalThatIntersectsWith(tree, 2));
326Assert.True(set1.SetEquals(set2));
333Assert.True(set3.SetEquals(set4));
338Assert.True(new HashSet<string>(spans.Select(t => t.Item3)).SetEquals(tree.Select(i => i.Item3)));
440Assert.True(tree.SequenceEqual(allInts));
Microsoft.CommonLanguageServerProtocol.Framework.UnitTests (2)
Microsoft.Data.Analysis.Tests (321)
Microsoft.DotNet.Arcade.Sdk.Tests (8)
Microsoft.DotNet.Build.Tasks.Feed.Tests (6)
Microsoft.DotNet.Build.Tasks.Templating.Tests (3)
Microsoft.DotNet.Build.Tasks.VisualStudio.Tests (6)
Microsoft.DotNet.Build.Tasks.Workloads.Tests (4)
Microsoft.DotNet.NuGetRepack.Tests (1)
Microsoft.DotNet.Open.Api.Tools.Tests (11)
Microsoft.DotNet.RemoteExecutor.Tests (3)
Microsoft.DotNet.VersionTools.Tests (4)
Microsoft.DotNet.XUnitAssert.Tests (19)
Microsoft.DotNet.XUnitExtensions.Tests (1)
Microsoft.Extensions.AI.Abstractions.Tests (51)
Microsoft.Extensions.AI.Integration.Tests (25)
EmbeddingGeneratorIntegrationTests.cs (17)
130Assert.True(activity.Duration.TotalMilliseconds > 0);
160Assert.True(distances[0, 1] < distances[0, 2]);
161Assert.True(distances[0, 1] < distances[0, 3]);
162Assert.True(distances[0, 1] < distances[1, 2]);
163Assert.True(distances[0, 1] < distances[1, 3]);
165Assert.True(distances[2, 3] < distances[0, 2]);
166Assert.True(distances[2, 3] < distances[0, 3]);
167Assert.True(distances[2, 3] < distances[1, 2]);
168Assert.True(distances[2, 3] < distances[1, 3]);
197Assert.True(distances[0, 1] > distances[0, 2]);
198Assert.True(distances[0, 1] > distances[0, 3]);
199Assert.True(distances[0, 1] > distances[1, 2]);
200Assert.True(distances[0, 1] > distances[1, 3]);
202Assert.True(distances[2, 3] > distances[0, 2]);
203Assert.True(distances[2, 3] > distances[0, 3]);
204Assert.True(distances[2, 3] > distances[1, 2]);
205Assert.True(distances[2, 3] > distances[1, 3]);
Microsoft.Extensions.AI.OpenAI.Tests (6)
Microsoft.Extensions.AI.Tests (30)
Microsoft.Extensions.ApiDescription.Client.Tests (11)
Microsoft.Extensions.ApiDescription.Tool.Tests (4)
Microsoft.Extensions.AsyncState.Tests (9)
Microsoft.Extensions.Caching.Hybrid.Tests (49)
Microsoft.Extensions.Compliance.Abstractions.Tests (8)
Redaction\RedactorTest.cs (3)
23Assert.True(r.TryRedact<object?>(null, new char[0], out _, string.Empty.AsSpan()));
298Assert.True(r.TryRedact(Array.Empty<char>(), buffer, out int charsWritten, string.Empty.AsSpan(), null));
314Assert.True(r.TryRedact(new char[0], buffer, out int charsWritten, string.Empty.AsSpan(), null));
Microsoft.Extensions.Compliance.Redaction.Tests (2)
Microsoft.Extensions.Compliance.Testing.Tests (10)
Microsoft.Extensions.Configuration.KeyPerFile.Tests (1)
Microsoft.Extensions.Diagnostics.HealthChecks.Common.Tests (1)
Microsoft.Extensions.Diagnostics.HealthChecks.Tests (21)
Microsoft.Extensions.Diagnostics.Probes.Tests (12)
Microsoft.Extensions.Diagnostics.ResourceMonitoring.Tests (31)
Microsoft.Extensions.Diagnostics.Testing.Tests (29)
Microsoft.Extensions.FileProviders.Embedded.Tests (17)
Microsoft.Extensions.Hosting.Testing.Tests (2)
Microsoft.Extensions.Http.Diagnostics.Tests (9)
Microsoft.Extensions.Http.Polly.Tests (7)
Microsoft.Extensions.Http.Resilience.Tests (17)
Microsoft.Extensions.ML.Tests (1)
Microsoft.Extensions.ObjectPool.DependencyInjection.Tests (1)
Microsoft.Extensions.SecretManager.Tools.Tests (2)
Microsoft.Extensions.ServiceDiscovery.Dns.Tests (3)
Microsoft.Extensions.Telemetry.Abstractions.Tests (27)
Microsoft.Extensions.Telemetry.Tests (114)
Microsoft.Extensions.TimeProvider.Testing.Tests (10)
Microsoft.Gen.ComplianceReports.Unit.Tests (2)
Microsoft.Gen.ContextualOptions.Unit.Tests (6)
Microsoft.Gen.Logging.Unit.Tests (3)
Microsoft.Gen.MetadataExtractor.Unit.Tests (2)
Microsoft.Gen.Metrics.Unit.Tests (1)
Microsoft.Gen.MetricsReports.Unit.Tests (2)
Microsoft.JSInterop.Tests (24)
Microsoft.ML.AutoML.Tests (59)
MetricsAgentsTests.cs (18)
51Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.Accuracy));
52Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.AreaUnderRocCurve));
53Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.AreaUnderPrecisionRecallCurve));
54Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.F1Score));
55Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.NegativePrecision));
56Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.NegativeRecall));
57Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.PositivePrecision));
58Assert.True(IsPerfectModel(metrics, BinaryClassificationMetric.PositiveRecall));
87Assert.True(IsPerfectModel(metrics, MulticlassClassificationMetric.MicroAccuracy));
88Assert.True(IsPerfectModel(metrics, MulticlassClassificationMetric.MacroAccuracy));
89Assert.True(IsPerfectModel(metrics, MulticlassClassificationMetric.LogLoss));
90Assert.True(IsPerfectModel(metrics, MulticlassClassificationMetric.LogLossReduction));
91Assert.True(IsPerfectModel(metrics, MulticlassClassificationMetric.TopKAccuracy));
118Assert.True(IsPerfectModel(metrics, RegressionMetric.MeanAbsoluteError));
119Assert.True(IsPerfectModel(metrics, RegressionMetric.MeanSquaredError));
120Assert.True(IsPerfectModel(metrics, RegressionMetric.RootMeanSquaredError));
121Assert.True(IsPerfectModel(metrics, RegressionMetric.RSquared));
157Assert.True(IsPerfectModel(metrics, RankingMetric.Ndcg, 3));
Microsoft.ML.CodeAnalyzer.Tests (2)
Microsoft.ML.Core.Tests (176)
UnitTests\TestEntryPoints.cs (98)
370Assert.True(weightType.Equals(typeof(string)));
373Assert.True(instance.ExampleWeightColumnName == null);
389Assert.True(EntryPointUtils.IsValueWithinRange(range, 5.1));
390Assert.True(EntryPointUtils.IsValueWithinRange(range, 5.0));
394Assert.True(EntryPointUtils.IsValueWithinRange(range, 5.1));
400Assert.True(EntryPointUtils.IsValueWithinRange(range, 5.0));
401Assert.True(EntryPointUtils.IsValueWithinRange(range, 4.9));
406Assert.True(EntryPointUtils.IsValueWithinRange(range, 4.9));
411Assert.True(EntryPointUtils.IsValueWithinRange(range, 0.0));
1743Assert.True(Single.IsNaN(scoreBin) && Single.IsNaN(score) || scoreBin == score);
1744Assert.True(Single.IsNaN(scoreBinCali) && Single.IsNaN(score) || scoreBinCali == score);
1745Assert.True(Single.IsNaN(scoreSaved) && Single.IsNaN(score) || CompareNumbersWithTolerance(scoreSaved, score, null, 5));
1746Assert.True(Single.IsNaN(scoreAnom) && Single.IsNaN(score) || scoreAnom == score);
1750Assert.True(Single.IsNaN(avg) && Single.IsNaN(score) || avg == score);
1963Assert.True(Single.IsNaN(scoreBin) && Single.IsNaN(score) || scoreBin == score);
1964Assert.True(Single.IsNaN(scoreBinCali) && Single.IsNaN(score) || scoreBinCali == score);
1965Assert.True(Single.IsNaN(scoreSaved) && Single.IsNaN(score) || scoreSaved == score);
1969Assert.True(Single.IsNaN(avg) && Single.IsNaN(score) || avg == score);
2112Assert.True(CompareVBuffers(in scoreSaved, in score, ref dense1, ref dense2));
2114Assert.True(CompareVBuffers(in avg, in score, ref dense1, ref dense2));
2550Assert.True(1 <= catKey && catKey <= 3);
3336Assert.True(success);
3393Assert.True(success);
3623Assert.True(auc > 0.99);
3728Assert.True(auc > 0.99);
3894Assert.True(auc > 0.99);
4086Assert.True(auc > 0.99);
4210Assert.True(float.IsNaN(nodes[0].Cost));
4211Assert.True(nodes[0].StageId == "5063dee8f19c4dd89a1fc3a9da5351a7");
4214Assert.True(nodes[1].Cost > 2);
4215Assert.True(nodes[1].StageId == "2");
4218Assert.True(nodes[2].Cost > 3);
4219Assert.True(nodes[2].StageId == "");
4431Assert.True(ReadOnlyMemoryUtils.EqualsStr("Iris-setosa", predictedLabel)
4481Assert.True(treesCol.HasValue);
4484Assert.True(leavesCol.HasValue);
4487Assert.True(pathsCol.HasValue);
5000Assert.True(aucCol.HasValue);
5005Assert.True(b);
5174Assert.True(metricCol.HasValue);
5176Assert.True(foldCol.HasValue);
5178Assert.True(isWeightedCol.HasValue);
5193Assert.True(b);
5199Assert.True(ReadOnlyMemoryUtils.EqualsStr("Average", fold));
5201Assert.True(isWeighted == (w == 1));
5205Assert.True(b);
5209Assert.True(ReadOnlyMemoryUtils.EqualsStr("Standard Deviation", fold));
5215Assert.True(isWeighted == (w == 1));
5224Assert.True(b);
5232Assert.True(ReadOnlyMemoryUtils.EqualsStr("Fold " + f, fold));
5234Assert.True(isWeighted == (w == 1));
5358Assert.True(metricCol.HasValue);
5360Assert.True(foldCol.HasValue);
5369Assert.True(b);
5373Assert.True(ReadOnlyMemoryUtils.EqualsStr("Average", fold));
5377Assert.True(b);
5381Assert.True(ReadOnlyMemoryUtils.EqualsStr("Standard Deviation", fold));
5389Assert.True(b);
5393Assert.True(ReadOnlyMemoryUtils.EqualsStr("Fold " + f, fold));
5403Assert.True(countCol.HasValue);
5405Assert.True(foldCol.HasValue);
5407Assert.True(type is VectorDataViewType vecType && vecType.ItemType is TextDataViewType && vecType.Size == 10);
5413Assert.True(ReadOnlyMemoryUtils.EqualsStr(i.ToString(), slotNameValues[i]));
5428Assert.True(ReadOnlyMemoryUtils.EqualsStr(foldCur, foldIndex));
5586Assert.True(warningCol.HasValue);
5592Assert.True(b);
5597Assert.True(b);
5766Assert.True(metricCol.HasValue);
5768Assert.True(foldCol.HasValue);
5778Assert.True(b);
5782Assert.True(ReadOnlyMemoryUtils.EqualsStr("Average", fold));
5786Assert.True(b);
5790Assert.True(ReadOnlyMemoryUtils.EqualsStr("Standard Deviation", fold));
5798Assert.True(b);
5802Assert.True(ReadOnlyMemoryUtils.EqualsStr("Fold " + f, fold));
6066Assert.True(metricCol.HasValue);
6068Assert.True(foldCol.HasValue);
6078Assert.True(b);
6082Assert.True(ReadOnlyMemoryUtils.EqualsStr("Average", fold));
6086Assert.True(b);
6090Assert.True(ReadOnlyMemoryUtils.EqualsStr("Standard Deviation", fold));
6102Assert.True(b);
6106Assert.True(ReadOnlyMemoryUtils.EqualsStr("Fold " + f, fold));
6121Assert.True(nameCol.HasValue);
6285Assert.True(accCol.HasValue);
6291Assert.True(b);
6457Assert.True(accCol.HasValue);
6463Assert.True(b);
6891Assert.True(ndcgArray[0] > 0);
6892Assert.True(ndcgArray[1] > 0);
6893Assert.True(ndcgArray[2] > 0);
6894Assert.True(ndcgArray[3] > 0);
6895Assert.True(ndcgArray[4] > 0);
6896Assert.True(ndcgArray[5] > 0);
6897Assert.True(ndcgArray[6] > 0);
6898Assert.True(ndcgArray[7] > 0);
6899Assert.True(ndcgArray[8] > 0);
6900Assert.True(ndcgArray[9] > 0);
UnitTests\TestUtilities.cs (21)
28Assert.True(Utils.IsMonotonicallyIncreasing(x));
35Assert.True(Utils.IsMonotonicallyIncreasing(x));
46Assert.True(Utils.IsMonotonicallyIncreasing(nullX));
55Assert.True(Utils.IsMonotonicallyIncreasing(x));
62Assert.True(Utils.IsMonotonicallyIncreasing(x));
80Assert.True(Utils.IsMonotonicallyIncreasing(nullX));
89Assert.True(Utils.IsMonotonicallyIncreasing(x));
96Assert.True(Utils.IsMonotonicallyIncreasing(x));
114Assert.True(Utils.IsMonotonicallyIncreasing(nullX));
123Assert.True(Utils.IsIncreasing(0, x, 10));
129Assert.True(Utils.IsIncreasing(0, x, 0, 10));
130Assert.True(Utils.IsIncreasing(0, x, 1, 10));
131Assert.True(Utils.IsIncreasing(0, x, 5, 10));
132Assert.True(Utils.IsIncreasing(0, x, 10, 10));
141Assert.True(Utils.IsIncreasing(0, x, 7, 10));
148Assert.True(Utils.IsIncreasing(0, x, 7, 10));
153Assert.True(Utils.IsIncreasing(0, nullX, 10));
166Assert.True(Utils.AreEqual(x, y));
202Assert.True(Utils.AreEqual(x, y));
238Assert.True(Utils.AreEqual(x, y));
274Assert.True(Utils.AreEqual(x, y));
UnitTests\TestVBuffer.cs (23)
103Assert.True(CompareNumbersWithTolerance(sum, VectorUtils.Sum(in a), digitsOfPrecision: tol));
104Assert.True(CompareNumbersWithTolerance(l1, VectorUtils.L1Norm(in a), digitsOfPrecision: tol));
105Assert.True(CompareNumbersWithTolerance(l2Squared, VectorUtils.NormSquared(in a), digitsOfPrecision: tol));
106Assert.True(CompareNumbersWithTolerance(l2, VectorUtils.Norm(in a), digitsOfPrecision: tol));
107Assert.True(CompareNumbersWithTolerance(infNorm, VectorUtils.MaxNorm(in a), digitsOfPrecision: tol));
313Assert.True(a.IsDense);
315Assert.True(a.GetIndices().IsEmpty);
836Assert.True(CompareNumbersWithTolerance(l1Dist, VectorUtils.L1Distance(in a, in b), digitsOfPrecision: tol));
837Assert.True(CompareNumbersWithTolerance(l2Dist2, VectorUtils.L2DistSquared(in a, in b), digitsOfPrecision: tol));
838Assert.True(CompareNumbersWithTolerance(l2Dist, VectorUtils.Distance(in a, in b), digitsOfPrecision: tol));
839Assert.True(CompareNumbersWithTolerance(dot, VectorUtils.DotProduct(in a, in b), digitsOfPrecision: tol));
897Assert.True(slotsDropped + nonExistentSlotsDropped > 0);
901Assert.True(expectedLength >= 1);
913Assert.True(logicalIndex - slotsDroppedSoFar >= 0);
928Assert.True(expectedIndices.Count <= a.GetValues().Length);
1183Assert.True(equalityFunc(expected.GetValues()[i], actual.GetValues()[i]));
1194Assert.True(equalityFunc(expected.GetValues()[i], actual.GetValues()[jj]));
1198Assert.True(equalityFunc(expected.GetValues()[i], default(T)));
1210Assert.True(equalityFunc(expected.GetValues()[ii], actual.GetValues()[j]));
1214Assert.True(equalityFunc(actual.GetValues()[j], default(T)));
1230Assert.True(equalityFunc(expected.GetValues()[ii], actual.GetValues()[jj]));
1236Assert.True(equalityFunc(expected.GetValues()[ii], default(T)));
1242Assert.True(equalityFunc(actual.GetValues()[ii], default(T)));
Microsoft.ML.IntegrationTests (42)
Microsoft.ML.OnnxTransformerTest (6)
Microsoft.ML.Predictor.Tests (45)
Microsoft.ML.Sweeper.Tests (17)
Microsoft.ML.TensorFlow.Tests (35)
Microsoft.ML.TestFramework (36)
Microsoft.ML.TestFrameworkCommon (6)
Microsoft.ML.Tests (372)
Microsoft.ML.TimeSeries.Tests (11)
Microsoft.ML.Tokenizers.Tests (71)
CodeGenTests.cs (18)
316Assert.True(idsConsumed < ids.Length);
317Assert.True(idsConsumed >= lastIdsConsumed);
318Assert.True(charactersWritten < expectedDecoded.Length);
319Assert.True(charactersWritten >= lastCharactersWritten);
550Assert.True(codeGenTokenizer.BeginningOfSentenceToken is not null);
551Assert.True(codeGenTokenizer.BeginningOfSentenceId.HasValue);
592Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
597Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
602Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
607Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
683Assert.True(codeGenTokenizer.EndOfSentenceToken is not null);
684Assert.True(codeGenTokenizer.EndOfSentenceId.HasValue);
816Assert.True(codeGenTokenizer.BeginningOfSentenceToken is not null);
817Assert.True(codeGenTokenizer.BeginningOfSentenceId.HasValue);
868Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
874Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
880Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
886Assert.True(!encoding[0].Offset.Equals(new Range(0, 0)) || !encoding[1].Offset.Equals(new Range(0, 0)));
Microsoft.ML.TorchSharp.Tests (7)
Microsoft.Net.Http.Headers.Tests (50)
Microsoft.VisualBasic.IntegrationTests (5)
Microsoft.VisualBasic.Tests (58)
Microsoft\VisualBasic\ApplicationServices\SingleInstanceTests.cs (11)
84Assert.True(TryCreatePipeServer(GetUniqueName(), out var pipeServer));
122Assert.True(created >= 1);
129Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
138Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, sentArgs[i]));
150Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
157var tasks = Enumerable.Range(0, n).Select(i => Task.Factory.StartNew(() => { Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, sentArgs[i])); }, cancellationToken: default, creationOptions: default, scheduler: TaskScheduler.Default)).ToArray();
170Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
176Assert.True(SendSecondInstanceArgs(pipeName, SendTimeout, expectedArgs));
211Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
225Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
244Assert.True(TryCreatePipeServer(pipeName, out var pipeServer));
Microsoft\VisualBasic\MyServices\FileSystemProxyTests.cs (42)
67Assert.True(HasExpectedData(CurrentFile, SourceData));
92Assert.True(HasExpectedData(CurrentFile, SourceData));
102Assert.True(HasExpectedData(CurrentFile, CurrentFile.EndsWith('0') ? DestData : SourceData));
123Assert.True(HasExpectedData(CurrentFile, SourceData));
139Assert.True(HasExpectedData(testFileDest, DestData));
146Assert.True(HasExpectedData(testFileDest, SourceData));
161Assert.True(HasExpectedData(testFileDest, DestData));
176Assert.True(HasExpectedData(testFileDest, SourceData));
185Assert.True(Directory.Exists(FullPathToNewDirectory));
210Assert.True(Directory.Exists(FullPathToNewDirectory));
212Assert.True(File.Exists(testFileSource));
222Assert.True(Directory.Exists(FullPathToNewDirectory));
225Assert.True(File.Exists(testFileSource));
227Assert.True(Directory.Exists(FullPathToNewDirectory));
228Assert.True(File.Exists(testFileSource));
236Assert.True(File.Exists(testFileSource));
244Assert.True(_fileSystem.DirectoryExists(TestDirectory));
255Assert.True(_fileSystem.FileExists(testFileSource));
361Assert.True(Drives.Length > 0);
375Assert.True(info.Exists);
378Assert.True(info.CreationTime > DateTime.MinValue);
437Assert.True(File.Exists(FileList[i]));
483Assert.True(File.Exists(TempFile));
505Assert.True(HasExpectedData(CurrentFile, SourceData));
531Assert.True(HasExpectedData(CurrentFile, SourceData));
542Assert.True(HasExpectedData(RemainingSourceFilesWithPath[0], SourceData));
548Assert.True(HasExpectedData(CurrentFile, CurrentFile.EndsWith('0') ? DestData : SourceData));
570Assert.True(HasExpectedData(CurrentFile, SourceData));
581Assert.True(File.Exists(DestinationFileNameWithPath));
582Assert.True(HasExpectedData(DestinationFileNameWithPath, SourceData));
588Assert.True(HasExpectedData(DestinationFileNameWithPath, DestData));
589Assert.True(File.Exists(SourceFileNameWithPath));
599Assert.True(File.Exists(DestinationFileNameWithPath));
600Assert.True(HasExpectedData(DestinationFileNameWithPath, SourceData));
605Assert.True(HasExpectedData(DestinationFileNameWithPath, DestData));
606Assert.True(File.Exists(SourceFileNameWithPath));
616Assert.True(File.Exists(DestinationFileNameWithPath));
617Assert.True(HasExpectedData(DestinationFileNameWithPath, SourceData));
620Assert.True(File.Exists(SourceFileNameWithPath));
622Assert.True(HasExpectedData(SourceFileNameWithPath, SourceData));
651Assert.True(Directory.Exists(NewFDirectoryPath));
674Assert.True(File.Exists(NewFileWithPath));
Microsoft.VisualStudio.LanguageServices.CSharp.UnitTests (38)
Microsoft.Web.Xdt.Extensions.Tests (4)
Mvc.Analyzers.Test (18)
Mvc.Api.Analyzers.Test (58)
SymbolApiResponseMetadataProviderTest.cs (23)
20Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
28metadata => Assert.True(metadata.IsImplicit));
38Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
46metadata => Assert.True(metadata.IsImplicit));
56Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
64metadata => Assert.True(metadata.IsImplicit));
74Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
97Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
120Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
143Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
166Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
188Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
208Assert.True(metadata.IsDefault);
219Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
241Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
249metadata => Assert.True(metadata.IsImplicit));
274Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
297Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
319Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
409Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
427Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
445Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
463Assert.True(ApiControllerSymbolCache.TryCreate(compilation, out var symbolCache));
PresentationCore.Tests (2)
Roslyn.VisualStudio.Next.UnitTests (31)
ServerComparison.FunctionalTests (1)
Shared.Tests (52)
Data.Validation\LengthAttributeTests.cs (15)
34Assert.True(Validator.TryValidateObject(options, context, results, true));
46Assert.True(Validator.TryValidateObject(options, context, results, true));
67Assert.True(Validator.TryValidateObject(options, context, results, true));
90Assert.True(Validator.TryValidateObject(options, context, results, true));
102Assert.True(Validator.TryValidateObject(options, context, results, true));
124Assert.True(Validator.TryValidateObject(options, context, results, true));
161Assert.True(Validator.TryValidateObject(options, context, results, true));
178Assert.True(Validator.TryValidateObject(options, context, results, true));
196Assert.True(Validator.TryValidateObject(options, context, results, true));
218Assert.True(Validator.TryValidateObject(options, context, results, true));
229Assert.True(Validator.TryValidateObject(options, context, results, true));
241Assert.True(Validator.TryValidateObject(options, context, results, true));
268Assert.True(Validator.TryValidateObject(options, context, results, true));
285Assert.True(Validator.TryValidateObject(options, context, results, true));
303Assert.True(Validator.TryValidateObject(options, context, results, true));
Data.Validation\TimeSpanAttributeTests.cs (13)
32Assert.True(Validator.TryValidateObject(options, context, results, true));
51Assert.True(Validator.TryValidateObject(options, context, results, true));
56Assert.True(Validator.TryValidateObject(options, context, results, true));
69Assert.True(Validator.TryValidateObject(options, context, results, true));
74Assert.True(Validator.TryValidateObject(options, context, results, true));
97Assert.True(Validator.TryValidateObject(options, context, results, true));
116Assert.True(Validator.TryValidateObject(options, context, results, true));
137Assert.True(Validator.TryValidateObject(options, context, results, true));
160Assert.True(Validator.TryValidateObject(options, context, results, true));
179Assert.True(Validator.TryValidateObject(options, context, results, true));
184Assert.True(Validator.TryValidateObject(options, context, results, true));
197Assert.True(Validator.TryValidateObject(options, context, results, true));
202Assert.True(Validator.TryValidateObject(options, context, results, true));
Sockets.FunctionalTests (13)
System.Drawing.Common.Tests (146)
System\Drawing\Drawing2D\GraphicsPathTests.cs (25)
2245Assert.True(gp.IsOutlineVisible(10, 1, Pens.Red, graphics));
2246Assert.True(gp.IsOutlineVisible(10, 2, pen, graphics));
2249Assert.True(gp.IsOutlineVisible(11.0f, 1.0f, Pens.Red, graphics));
2250Assert.True(gp.IsOutlineVisible(11.0f, 1.0f, pen, graphics));
2255Assert.True(gp.IsOutlineVisible(point, pen, graphics));
2258Assert.True(gp.IsOutlineVisible(point, Pens.Red, graphics));
2262Assert.True(gp.IsOutlineVisible(fPoint, pen, graphics));
2265Assert.True(gp.IsOutlineVisible(fPoint, Pens.Red, graphics));
2273Assert.True(gp.IsOutlineVisible(10, 10, Pens.Red, graphics));
2274Assert.True(gp.IsOutlineVisible(10, 11, pen, graphics));
2277Assert.True(gp.IsOutlineVisible(11.0f, 10.0f, Pens.Red, graphics));
2278Assert.True(gp.IsOutlineVisible(11.0f, 11.0f, pen, graphics));
2282Assert.True(gp.IsOutlineVisible(point, Pens.Red, graphics));
2283Assert.True(gp.IsOutlineVisible(point, pen, graphics));
2290Assert.True(gp.IsOutlineVisible(fPoint, pen, graphics));
2293Assert.True(gp.IsOutlineVisible(fPoint, pen, graphics));
2301Assert.True(gp.IsVisible(10, 10, graphics));
2302Assert.True(gp.IsVisible(20, 20, graphics));
2303Assert.True(gp.IsVisible(29, 29, graphics));
2308Assert.True(gp.IsVisible(9.5f, 9.5f, graphics));
2309Assert.True(gp.IsVisible(10f, 10f, graphics));
2310Assert.True(gp.IsVisible(20f, 20f, graphics));
2311Assert.True(gp.IsVisible(29.4f, 29.4f, graphics));
2322Assert.True(gp.IsVisible(20, 20, graphics));
2325Assert.True(gp.IsVisible(20f, 20f, graphics));
System.Private.Windows.Core.Tests (117)
System.Private.Windows.Core.TestUtilities (3)
System.ServiceModel.Http.Tests (2)
System.ServiceModel.Primitives.Tests (18)
System.Windows.Forms.Analyzers.CSharp.Tests (6)
System.Windows.Forms.Analyzers.VisualBasic.Tests (1)
System.Windows.Forms.Design.Tests (257)
System.Windows.Forms.Primitives.Tests (81)
System.Windows.Forms.Primitives.TestUtilities (4)
System.Windows.Forms.Primitives.TestUtilities.Tests (1)
System.Windows.Forms.PrivateSourceGenerators.Tests (1)
System.Windows.Forms.Tests (8215)
System\Windows\Forms\AccessibleObjects\MonthCalendar.CalendarButtonAccessibleObjectTests.cs (1)
69Assert.True(actual);
System\Windows\Forms\AccessibleObjects\UpDownBase.UpDownButtons.UpDownButtonsAccessibleObject.DirectionButtonAccessibleObjectTests.cs (1)
25Assert.True(actual);
System\Windows\Forms\Application.ComponentManagerTests.cs (31)
21Assert.True(manager.FDebugMessage(0, 0, default, default));
35Assert.True(obj is null);
75Assert.True(manager.FRegisterComponent(component, &info, &id));
79Assert.True(manager.FRegisterComponent(component, &info, &newId));
96Assert.True(manager.FRegisterComponent(component, &info, &id));
97Assert.True(manager.FRevokeComponent(id));
111Assert.True(manager.FRegisterComponent(component, &info, &id));
126Assert.True(manager.FRegisterComponent(component, &info, &id));
127Assert.True(manager.FUpdateComponentRegistration(id, &info));
156Assert.True(manager.FRegisterComponent(component, &info, &id));
158Assert.True(manager.FSetTrackingComponent(id, true));
163Assert.True(manager.FSetTrackingComponent(id, false));
167Assert.True(manager.FSetTrackingComponent(id, true));
188Assert.True(manager.FRegisterComponent(component, &info, &id));
219Assert.True(manager.FRegisterComponent(component, &info, &id));
236Assert.True(manager.FInState(0, null));
239Assert.True(manager.FInState(msocstate.Modal, null));
241Assert.True(manager.FInState(msocstate.Recording, null));
243Assert.True(manager.FInState(0, null));
272Assert.True(obj is null);
286Assert.True(obj is null);
308Assert.True(manager.FRegisterComponent(component1, &info, &firstId));
311Assert.True(manager.FRegisterComponent(component2, &info, &secondId));
316Assert.True(manager.FOnComponentActivate(firstId));
318Assert.True(manager.FGetActiveComponent(msogac.Active, null, &info, 0));
320Assert.True(manager.FGetActiveComponent(msogac.TrackingOrActive, null, &info, 0));
324Assert.True(manager.FSetTrackingComponent(secondId, true));
325Assert.True(manager.FGetActiveComponent(msogac.Tracking, null, &info, 0));
327Assert.True(manager.FGetActiveComponent(msogac.Active, null, &info, 0));
329Assert.True(manager.FGetActiveComponent(msogac.TrackingOrActive, null, &info, 0));
335Assert.True(manager.FGetActiveComponent(msogac.Tracking, component, &info, 0));
System\Windows\Forms\CursorTests.cs (21)
46Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
70Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
121Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
158Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
184Assert.True(clip.Width >= 0);
185Assert.True(clip.Height >= 0);
202Assert.True(Cursor.Clip.X >= 0);
203Assert.True(Cursor.Clip.Y >= 0);
204Assert.True(Cursor.Clip.Width >= 0);
205Assert.True(Cursor.Clip.Height >= 0);
232Assert.True(hotSpot.X >= 0 && hotSpot.X <= cursor.Size.Width);
233Assert.True(hotSpot.Y >= 0 && hotSpot.Y <= cursor.Size.Height);
234Assert.True(cursor.Size == new Size(32, 32) || cursor.Size == new Size(64, 64));
266Assert.True(position.X >= virtualScreen.X);
267Assert.True(position.Y >= virtualScreen.Y);
268Assert.True(position.X <= virtualScreen.Right);
269Assert.True(position.Y <= virtualScreen.Bottom);
280Assert.True(position.X >= 0);
281Assert.True(position.Y >= 0);
286Assert.True(position.X >= virtualScreen.X);
287Assert.True(position.Y >= virtualScreen.Y);
System\Windows\Forms\DataGridViewCellTests.cs (65)
519Assert.True(control.IsHandleCreated);
592Assert.True(control.IsHandleCreated);
1138Assert.True(control.IsHandleCreated);
1147Assert.True(control.IsHandleCreated);
1182Assert.True(control.IsHandleCreated);
1191Assert.True(control.IsHandleCreated);
1688Assert.True(cell.ReadOnly);
1769Assert.True(cell.ReadOnly);
1772Assert.True(cell.ReadOnly);
1935Assert.True(cell.ReadOnly);
1940Assert.True(cell.ReadOnly);
1951Assert.True(cell.ReadOnly);
2218Assert.True(cell.Selected);
2223Assert.True(cell.Selected);
2234Assert.True(cell.Selected);
2255Assert.True(cell.HasStyle);
2260Assert.True(cell.HasStyle);
2277Assert.True(cell.HasStyle);
2282Assert.True(cell.HasStyle);
2295Assert.True(cell.HasStyle);
2300Assert.True(cell.HasStyle);
2320Assert.True(cell.HasStyle);
2325Assert.True(cell.HasStyle);
2338Assert.True(cell.HasStyle);
2343Assert.True(cell.HasStyle);
2363Assert.True(cell.HasStyle);
2368Assert.True(cell.HasStyle);
2386Assert.True(cell.HasStyle);
2391Assert.True(cell.HasStyle);
2414Assert.True(cell.HasStyle);
2419Assert.True(cell.HasStyle);
2452Assert.True(cell.HasStyle);
2458Assert.True(cell.HasStyle);
2468Assert.True(cell.HasStyle);
2474Assert.True(cell.HasStyle);
2480Assert.True(cell.HasStyle);
2486Assert.True(cell.HasStyle);
2493Assert.True(cell.HasStyle);
3347Assert.True(cell.HasStyle);
3516Assert.True(menu.IsDisposed);
3553Assert.True(menu.IsDisposed);
4532Assert.True(control.IsHandleCreated);
4592Assert.True(control.IsHandleCreated);
4750Assert.True(dataGridView.AccessibilityObject is Control.ControlAccessibleObject);
4809Assert.True(neighbors00.Contains(control.Rows[0].Cells[1].AccessibilityObject.Bounds));
4814Assert.True(neighbors21.Contains(control.Rows[1].Cells[2].AccessibilityObject.Bounds));
4815Assert.True(neighbors21.Contains(control.Rows[2].Cells[0].AccessibilityObject.Bounds));
4816Assert.True(neighbors21.Contains(control.Rows[2].Cells[1].AccessibilityObject.Bounds));
4817Assert.True(neighbors21.Contains(control.Rows[3].Cells[1].AccessibilityObject.Bounds));
4821Assert.True(neighbors33.Contains(control.Rows[2].Cells[3].AccessibilityObject.Bounds));
4822Assert.True(neighbors33.Contains(control.Rows[3].Cells[2].AccessibilityObject.Bounds));
5283Assert.True(widthTruncated);
5294Assert.True(widthTruncated);
5307Assert.True(widthTruncated);
5319Assert.True(widthTruncated);
6254Assert.True(cell.SetValue(rowIndex, value));
6258Assert.True(cell.SetValue(rowIndex, value));
6270Assert.True(cell.SetValue(rowIndex, value));
6274Assert.True(cell.SetValue(rowIndex, value));
6287Assert.True(cell.SetValue(-1, value));
6291Assert.True(cell.SetValue(-1, value));
6309Assert.True(cell.SetValue(0, value));
6313Assert.True(cell.SetValue(0, value));
6331Assert.True(cell.SetValue(0, value));
6335Assert.True(cell.SetValue(0, value));
System.Windows.Forms.TestUtilities (1)
System.Windows.Forms.UI.IntegrationTests (49)
System.Xaml.Tests (82)
Templates.Blazor.Tests (3)
Templates.Blazor.WebAssembly.Auth.Tests (3)
Templates.Blazor.WebAssembly.Tests (3)
Templates.Mvc.Tests (3)
Templates.Tests (3)
VBCSCompiler.UnitTests (64)
BuildClientTests.cs (26)
86Assert.True(holdsMutex);
97Assert.True(ranLocal);
107Assert.True(createdNew);
121Assert.True(ranLocal);
133Assert.True(clientMutexName.StartsWith(GlobalPrefix));
136Assert.True(serverMutexName.StartsWith(GlobalPrefix));
158Assert.True(await tryConnectToNamedPipe(Timeout.Infinite, cancellationToken: default));
186Assert.True(ranLocal);
187Assert.True(ranServer);
216Assert.True(Parse(optionPrefix + "shared", "test.cs"));
217Assert.True(_hasShared);
227Assert.True(Parse(optionPrefix + "shared:pipe", "test.cs"));
228Assert.True(_hasShared);
232Assert.True(Parse(optionPrefix + "shared:1:2", "test.cs"));
233Assert.True(_hasShared);
237Assert.True(Parse(optionPrefix + "shared=1:2", "test.cs"));
238Assert.True(_hasShared);
258Assert.True(Parse(optionPrefix + "sharedstart", "test.cs"));
268Assert.True(Parse("test.cs"));
273Assert.True(Parse(optionPrefix + "keepalive:100", "/shared", "test.cs"));
274Assert.True(_hasShared);
303Assert.True(Parse(optionPrefix + "keepalivestart", "test.cs"));
313Assert.True(Parse(optionPrefix + "keepalive:100", optionPrefix + "shared", "test.cs"));
316Assert.True(_hasShared);
319Assert.True(Parse(optionPrefix + "keepalive=100", optionPrefix + "shared", "test.cs"));
322Assert.True(_hasShared);
WindowsBase.Tests (692)
System\Windows\NameScopeTests.cs (25)
131Assert.True(nameScope.ContainsKey(name));
132Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
144Assert.True(nameScope.ContainsKey(name));
145Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
229Assert.True(property.GlobalIndex >= 0);
252Assert.True(nameScope.ContainsKey(name));
253Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
265Assert.True(nameScope.ContainsKey(name));
266Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
346Assert.True(nameScope.ContainsKey(name));
347Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
359Assert.True(nameScope.ContainsKey(name));
360Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
565Assert.True(nameScope.Contains(new KeyValuePair<string, object>("name", scopedElement)));
566Assert.True(nameScope.Contains(new KeyValuePair<string, object>("name", 1)));
567Assert.True(nameScope.Contains(new KeyValuePair<string, object>("name", new object())));
625Assert.True(nameScope.ContainsKey("name"));
626Assert.True(nameScope.ContainsKey("name"));
738Assert.True(enumerator.MoveNext());
794Assert.True(enumerator.MoveNext());
849Assert.True(nameScope.ContainsKey(name));
850Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
862Assert.True(nameScope.ContainsKey(name));
863Assert.True(nameScope.Contains(new KeyValuePair<string, object>(name, scopedElement)));
1076Assert.True(nameScope.TryGetValue("name", out object value));