376Assert.Equal(new[] { null, "value1", "value2" }, e.Value); 381Assert.Equal(new[] { null, "value1", "" }, e.Value);

87Assert.Equal(expectedArgs, sidecarArgs);

179Assert.Equal("--checkpointdir /data/checkpoints --recover --aof --aof-commit-freq 60000".Split(" "), args); 210Assert.Equal("--checkpointdir /data/checkpoints --recover --aof --aof-commit-freq 60000".Split(" "), args); 242Assert.Equal("--checkpointdir /data/checkpoints --recover --aof --aof-commit-freq 10000".Split(" "), args);

318Assert.Equal("--save 60 1".Split(" "), args); 349Assert.Equal("--save 60 1".Split(" "), args); 381Assert.Equal("--save 10 2".Split(" "), args);

179Assert.Equal("--save 60 1".Split(" "), args); 210Assert.Equal("--save 60 1".Split(" "), args); 242Assert.Equal("--save 10 2".Split(" "), args);

154Assert.Equal(new[] { "TrailerValue0", "TrailerValue1" }, response.TrailingHeaders.GetValues("TrailerName"));

743Assert.Equal(data, receivedData);

181Assert.Equal(new[] { "https://localhost:5001" }, options.TokenValidationParameters.ValidAudiences);

448Assert.Collection(call.requirements, req => Assert.Equal(

45Assert.Equal(new string[] 52Assert.Equal(new string[] { "RequiredString:required" }, 57Assert.Equal(new string[] { "IntFrom1To100:range" }, 122Assert.Equal(new[] { "RequiredString:required" }, editContext.GetValidationMessages()); 129Assert.Equal(new string[] 139Assert.Equal(new[] { "IntFrom1To100:range" }, editContext.GetValidationMessages());

140Assert.Equal(new[] 152Assert.Equal(new[] { "Store 2 message 1", }, editContext.GetValidationMessages(field)); 170Assert.Equal(new[] 180Assert.Equal(new[] { "Store 2 field 1 message 1", }, editContext.GetValidationMessages()); 233Assert.Equal(new[] { "Some message" }, editContext.GetValidationMessages());

36Assert.Equal(new[] { "Field 1 message 1", "Field 1 message 2" }, messages[field1]); 37Assert.Equal(new[] { "Field 2 message 1" }, messages[field2]); 53Assert.Equal(entries, messages[field1]); 72Assert.Equal(new[] { "Field 2 message 1" }, messages[field2]);

185Assert.Equal(new long[] { 2, 3, 4 }, renderIds);

148Assert.Equal(new[] { 1, 2, 3, 4 }, sequence);

2247Assert.Equal(new[] { 1, 2 }, childComponentIds); 3321Assert.Equal(new[] { 0 }, onAfterRenderCallCountLog); 3327Assert.Equal(new[] { 0, 1 }, onAfterRenderCallCountLog); 3572Assert.Equal(new[] { exception }, renderer.HandledExceptions); 3605Assert.Equal(new[] { exception }, renderer.HandledExceptions); 3638Assert.Equal(new[] { exception }, renderer.HandledExceptions);

822Assert.Equal(new[] { 0 }, batchBuilder.ComponentDisposalQueue); 936Assert.Equal( 1834Assert.Equal(new[] { 0, 1 }, batchBuilder.ComponentDisposalQueue);

326Assert.Equal(new[] { "Bad date value" }, rootComponent.EditContext.GetValidationMessages(fieldIdentifier)); 355Assert.Equal(new[] { "Bad date value" }, rootComponent.EditContext.GetValidationMessages(fieldIdentifier));

205Assert.Equal(new[] { "Header1" }, kvp.Value); 210Assert.Equal(new[] { "PUT" }, kvp.Value); 215Assert.Equal(new[] { OriginUrl }, kvp.Value); 271Assert.Equal(new[] { "true" }, kvp.Value); 276Assert.Equal(new[] { "X-Test1,X-Test2" }, kvp.Value); 281Assert.Equal(new[] { "PUT" }, kvp.Value); 286Assert.Equal(new[] { OriginUrl }, kvp.Value); 492Assert.Equal(new[] { "Header1" }, kvp.Value); 497Assert.Equal(new[] { "PUT" }, kvp.Value); 502Assert.Equal(new[] { OriginUrl }, kvp.Value);

51Assert.Equal(new[] { "39974d8e-3e53-4d78-b7e9-4ff64a2a5d7b: theElement" }, output); 84Assert.Equal(new[] { "[sink1] 39974d8e-3e53-4d78-b7e9-4ff64a2a5d7b: theElement", "[sink2] 39974d8e-3e53-4d78-b7e9-4ff64a2a5d7b: theElement" }, output);

52Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 95Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy", "ResolveDefaultKeyPolicy" }, callSequence); 145Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy", "CreateNewKey", "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 186Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy", "CreateNewKey", "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 234Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy", "CreateNewKey", "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 268Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 318Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy", "CreateNewKey", "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 356Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 394Assert.Equal(new[] { "GetCacheExpirationToken", "GetAllKeys", "ResolveDefaultKeyPolicy" }, callSequence); 569Assert.Equal(expectedCallSequence, actualCallSequence); 802Assert.Equal(current.Item2, allKeys);

137Assert.Equal(new[] { "element1", "element2", "element3" }, orderedNames);

124Assert.Equal(new[] { "element1", "element2", "element3" }, orderedNames);

434Assert.Equal(new string[] { "Thu, 01 Jan 1970 00:00:00 GMT" }, response.Content.Headers.GetValues(HeaderNames.Expires));

118Assert.Equal(new[] { "test" }, handler.Headers.GetValues("out")); 145Assert.Equal(new[] { "value" }, handler.Headers.GetValues("first")); 147Assert.Equal(new[] { "other" }, handler.Headers.GetValues("second")); 191Assert.Equal(new[] { "test" }, handler.Headers.GetValues("different"));

50Assert.Equal(new[] { "test" }, Handler.Headers.GetValues("out")); 65Assert.Equal(new[] { "one", "two" }, Handler.Headers.GetValues("out")); 79Assert.Equal(new[] { "text/plain; charset=utf-8" }, Handler.Content.Headers.GetValues("Content-Type")); 93Assert.Equal(new[] { "test" }, Handler.Content.Headers.GetValues("Content-Language")); 107Assert.Equal(new[] { "one", "two" }, Handler.Content.Headers.GetValues("Content-Language")); 122Assert.Equal(new[] { "test" }, Handler.Headers.GetValues("out")); 166Assert.Equal(new[] { "test" }, Handler.Headers.GetValues("inout")); 167Assert.Equal(new[] { "test2" }, Handler.Headers.GetValues("another")); 205Assert.Equal(expectedValues, Handler.Headers.GetValues("inout")); 221Assert.Equal(new[] { "value" }, Handler.Headers.GetValues("name")); 237Assert.Equal(new[] { "value" }, Handler.Headers.GetValues("name")); 239Assert.Equal(new[] { "value" }, Handler.Headers.GetValues("name")); 256Assert.Equal(new[] { "value" }, Handler.Headers.GetValues("name"));

45Assert.Equal(availableTransports, responseTransports);

386Assert.Equal(authenticationSchemes ?? new ReadOnlyCollection<string>(new List<string>()), result.AuthenticationSchemes); 398Assert.Equal(authenticationSchemes ?? new ReadOnlyCollection<string>(new List<string>()), result.AuthenticationSchemes); 448Assert.Equal(authenticationSchemes ?? new ReadOnlyCollection<string>(new List<string>()), result.AuthenticationSchemes); 1292Assert.Equal(extensions, result.ProblemDetails.Extensions); 1316Assert.Equal(extensions, result.ProblemDetails.Extensions); 1446Assert.Equal(errors, ((HttpValidationProblemDetails)result.ProblemDetails).Errors); 1454Assert.Equal(extensions, result.ProblemDetails.Extensions);

434Assert.Equal(authenticationSchemes ?? new ReadOnlyCollection<string>(new List<string>()), result.AuthenticationSchemes); 446Assert.Equal(authenticationSchemes ?? new ReadOnlyCollection<string>(new List<string>()), result.AuthenticationSchemes); 458Assert.Equal(authenticationSchemes ?? new ReadOnlyCollection<string>(new List<string>()), result.AuthenticationSchemes); 1108Assert.Equal(extensions, result.ProblemDetails.Extensions); 1228Assert.Equal(errors, result.ProblemDetails.Errors); 1236Assert.Equal(extensions, result.ProblemDetails.Extensions);

30Assert.Equal<string>(new[] { "Header1" }, headers.Keys); 52Assert.Equal(expectedResult, result); 80Assert.Equal<string>(new[] { "Header1" }, headers.Keys);

96Assert.Equal(supportedCultures, options.SupportedCultures.Select(c => c.Name)); 110Assert.Equal(supportedUICultures, options.SupportedUICultures.Select(c => c.Name));

1505Assert.Equal(expected, keys);

93Assert.Equal<string>(new string[] { "Hi There", }, result); 103Assert.Equal<string>(new string[] { "Hi", "There" }, result);

730Assert.Equal(new[] { "text/xml" }, GetSortedMediaTypes(responseType)); 737Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 743Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType));

708Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 722Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 729Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 825Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 832Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 881Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 895Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 902Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 951Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 965Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 972Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1021Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1028Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1035Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1042Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1149Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1169Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType));

932Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 938Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 944Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 950Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 982Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 988Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 1082Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType));

101Assert.Equal<object>((IEnumerable<object>)value1, (IEnumerable<object>)value2);

33Assert.Equal<object>((IEnumerable<object>)value1, (IEnumerable<object>)value2);

33Assert.Equal(new[] { "GetPerson", "ShowPeople", }, actionNames); 95Assert.Equal(new string[] { "POST" }, constraint.HttpMethods); 112Assert.Equal(new string[] { "PUT", "PATCH" }, constraint.HttpMethods); 489Assert.Equal(new[] { "POST" }, methodConstraint.HttpMethods); 514Assert.Equal(new[] { "PUT" }, methodConstraint.HttpMethods);

103Assert.Equal<object>((IEnumerable<object>)value1, (IEnumerable<object>)value2);

44Assert.Equal<object>((IEnumerable<object>)value1, (IEnumerable<object>)value2);

40Assert.Equal<object>((IEnumerable<object>)value1, (IEnumerable<object>)value2);

32Assert.Equal(assembly.DefinedTypes, types);

443Assert.Equal(expected, resultTemporary.RouteValues); 467Assert.Equal(expected, resultTemporary.RouteValues); 491Assert.Equal(expected, resultPermanent.RouteValues); 515Assert.Equal(expected, resultPermanent.RouteValues); 535Assert.Equal(expected, resultTemporary.RouteValues); 555Assert.Equal(expected, resultTemporary.RouteValues); 578Assert.Equal(expectedRouteValues, result.RouteValues); 603Assert.Equal(expectedRouteValues, result.RouteValues); 625Assert.Equal(expected, resultPermanent.RouteValues); 645Assert.Equal(expected, resultPermanent.RouteValues); 668Assert.Equal(expectedRouteValues, result.RouteValues); 697Assert.Equal(expectedRouteValues, result.RouteValues); 718Assert.Equal(expected, resultTemporary.RouteValues); 737Assert.Equal(expected, resultTemporary.RouteValues); 759Assert.Equal(expectedRouteValues, result.RouteValues); 782Assert.Equal(expectedRouteValues, result.RouteValues); 802Assert.Equal(expected, resultPermanent.RouteValues); 821Assert.Equal(expected, resultPermanent.RouteValues); 843Assert.Equal(expectedRouteValues, result.RouteValues); 866Assert.Equal(expectedRouteValues, result.RouteValues); 956Assert.Equal(expected, resultTemporary.RouteValues); 977Assert.Equal(expected, resultTemporary.RouteValues); 998Assert.Equal(expected, resultPermanent.RouteValues); 1243Assert.Equal(expected, resultPermanent.RouteValues); 1264Assert.Equal(expected, resultPermanent.RouteValues); 1285Assert.Equal(expected, resultPermanent.RouteValues); 1423Assert.Equal(expected, result.RouteValues); 1458Assert.Equal(expected, result.RouteValues); 1480Assert.Equal(expected, result.RouteValues); 1617Assert.Equal(expected, result.RouteValues); 1637Assert.Equal(expected, result.RouteValues); 1659Assert.Equal(expected, result.RouteValues);

42Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, badRequest.ContentTypes.OrderBy(c => c)); 64Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, badRequest.ContentTypes.OrderBy(c => c)); 88Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, objectResult.ContentTypes.OrderBy(c => c));

304Assert.Equal(new int[] { 0, 23, 300 }, (IEnumerable<int>)result.Model);

31Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, objectResult.ContentTypes); 58Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, objectResult.ContentTypes); 88Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, objectResult.ContentTypes); 114Assert.Equal(new[] { "application/problem+json", "application/problem+xml" }, objectResult.ContentTypes);

37Assert.Equal(new[] { "foo", "bar", "baz" }, strategy.ElementKeys);

270Assert.Equal(formFiles, bindingContext.Result.Model as IEnumerable<IFormFile>);

85Assert.Equal(headerValue.Split(','), bindingContext.Result.Model as IEnumerable<string>); 214Assert.Equal(headerValue.Split(','), bindingContext.Result.Model as IEnumerable<string>);

100Assert.Equal(expected, result.OrderBy(kvp => kvp.Key));

1483Assert.Equal<string>(keys.OrderBy(k => k).ToList(), modelState.Keys.OrderBy(k => k).ToList());

15Assert.Equal(expectedHttpMethods, httpMethodProvider.HttpMethods);

43Assert.Equal<string>(expected, matched);

16Assert.Equal(numbers, delegatingEnumerable);

332Assert.Equal(expected, json.Properties().OrderBy(p => p.Name).Select(p => p.Name)); 348Assert.Equal(expected, json.Properties().OrderBy(p => p.Name).Select(p => p.Name));

537Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 559Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 581Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 793Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 799Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 828Assert.Equal(new[] { "text/plain" }, GetSortedMediaTypes(responseType)); 834Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 934Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1251Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1284Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1290Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1315Assert.Equal(expectedMediaTypes, actualMediaTypes); 1346Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1381Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1416Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1451Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1457Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1491Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1497Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1528Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType));

137Assert.Equal(new[] { "GET,POST,HEAD" }, h.Value); 142Assert.Equal(new[] { "*" }, h.Value);

125Assert.Equal(new[] { "True" }, response.Headers.GetValues("X-ServiceActionFilter"));

81Assert.Equal(new[] { "camera_spec1.txt", "camera_spec2.txt" }, product.Specs["camera"]); 83Assert.Equal(new[] { "battery_spec1.txt", "battery_spec2.txt" }, product.Specs["battery"]);

749Assert.Equal(new[] { "PageModelFilterValue" }, response.Headers.GetValues("PageModelFilterKey")); 750Assert.Equal(new[] { "PageFilterValue" }, response.Headers.GetValues("PageFilterKey"));

960Assert.Equal(expectedCollection, model);

352Assert.Equal(new double[] { 10.51, 45.44 }, product.Manufacturer.EnumerableOfDoubleProperty); 353Assert.Equal(new CarType[] { CarType.Sedan, CarType.Coupe }, product.Manufacturer.ListOfEnum);

2048Assert.Equal(new[] { 1, 2 }, model); 2100Assert.Equal(new[] { 1, 2 }, model);

1839Assert.Equal(new[] { 1, 2 }, model); 1891Assert.Equal(new[] { 1, 2 }, model);

250Assert.Equal(value, roundTripValue);

304Assert.Equal(new int[] { 0, 23, 300 }, (IEnumerable<int>)result.Model);

300Assert.Equal(value, roundTripValue);

83Assert.Equal(new[] { expectedConfiguration }, parseOptions.PreprocessorSymbolNames); 126Assert.Equal(new[] { "DEBUG" }, parseOptions.PreprocessorSymbolNames);

33Assert.Equal(expected, references);

31Assert.Equal(new[] { item1, item2 }, feature.ViewDescriptors.Select(d => d.Item)); 60Assert.Equal(new[] { item1, item2 }, feature.ViewDescriptors.Select(d => d.Item)); 84Assert.Equal(new[] { item1, item2 }, feature.ViewDescriptors.Select(d => d.Item)); 129Assert.Equal(new[] { item1, item2 }, feature.ViewDescriptors.Select(d => d.Item));

150Assert.Equal(expectedViewLocations, expandedViewLocations); 174Assert.Equal(viewLocations, expandedViewLocations); 203Assert.Equal(viewLocations, expandedViewLocations);

19Assert.Equal(expected, actual); 38Assert.Equal(expected, actual); 59Assert.Equal(expected, actual);

266Assert.Equal(new[] 288Assert.Equal(new[] { 688Assert.Equal(expectedSeeds, seeds); 700Assert.Equal(expander1Result, seeds); 756Assert.Equal(expectedSeeds, seeds); 768Assert.Equal(expander1Result, seeds); 983Assert.Equal(expandedLocations, result.SearchedLocations); 991Assert.Equal(expandedLocations, result.SearchedLocations); 1042Assert.Equal(expandedLocations, result.SearchedLocations); 1172Assert.Equal(expectedSeeds, seeds); 1231Assert.Equal(expectedSeeds, seeds); 1274Assert.Equal(expected, result.SearchedLocations); 1344Assert.Equal(expected, result.SearchedLocations); 1380Assert.Equal(expected, result.SearchedLocations); 1409Assert.Equal(expected, result.SearchedLocations); 1749Assert.Equal(expected, actual); 1774Assert.Equal(expected, actual); 1799Assert.Equal(expected, actual); 1826Assert.Equal(expected, actual);

202Assert.Equal(new[] { "_ViewStart", pagePath, LayoutPath }, paths);

91Assert.Equal(pageApplicationModel.Filters, actual.FilterDescriptors.Select(f => f.Filter)); 92Assert.Equal(pageApplicationModel.HandlerMethods.Select(p => p.MethodInfo), actual.HandlerMethods.Select(p => p.MethodInfo)); 93Assert.Equal(pageApplicationModel.HandlerProperties.Select(p => p.PropertyName), actual.BoundProperties.Select(p => p.Name));

42Assert.Equal(locations, actual); 64Assert.Equal(locations, actual); 83Assert.Equal(locations, actual);

434Assert.Equal(expected, resultTemporary.RouteValues); 458Assert.Equal(expected, resultTemporary.RouteValues); 482Assert.Equal(expected, resultPermanent.RouteValues); 506Assert.Equal(expected, resultPermanent.RouteValues); 526Assert.Equal(expected, resultTemporary.RouteValues); 546Assert.Equal(expected, resultTemporary.RouteValues); 569Assert.Equal(expectedRouteValues, result.RouteValues); 594Assert.Equal(expectedRouteValues, result.RouteValues); 616Assert.Equal(expected, resultPermanent.RouteValues); 636Assert.Equal(expected, resultPermanent.RouteValues); 659Assert.Equal(expectedRouteValues, result.RouteValues); 688Assert.Equal(expectedRouteValues, result.RouteValues); 709Assert.Equal(expected, resultTemporary.RouteValues); 728Assert.Equal(expected, resultTemporary.RouteValues); 750Assert.Equal(expectedRouteValues, result.RouteValues); 773Assert.Equal(expectedRouteValues, result.RouteValues); 793Assert.Equal(expected, resultPermanent.RouteValues); 812Assert.Equal(expected, resultPermanent.RouteValues); 834Assert.Equal(expectedRouteValues, result.RouteValues); 857Assert.Equal(expectedRouteValues, result.RouteValues); 1263Assert.Equal(expected, resultPermanent.RouteValues); 1284Assert.Equal(expected, resultPermanent.RouteValues); 1305Assert.Equal(expected, resultTemporary.RouteValues); 1326Assert.Equal(expected, resultTemporary.RouteValues); 1347Assert.Equal(expected, resultPermanent.RouteValues); 1368Assert.Equal(expected, resultPermanent.RouteValues);

454Assert.Equal(expected, resultTemporary.RouteValues); 478Assert.Equal(expected, resultTemporary.RouteValues); 502Assert.Equal(expected, resultPermanent.RouteValues); 526Assert.Equal(expected, resultPermanent.RouteValues); 546Assert.Equal(expected, resultTemporary.RouteValues); 566Assert.Equal(expected, resultTemporary.RouteValues); 589Assert.Equal(expectedRouteValues, result.RouteValues); 614Assert.Equal(expectedRouteValues, result.RouteValues); 636Assert.Equal(expected, resultPermanent.RouteValues); 656Assert.Equal(expected, resultPermanent.RouteValues); 679Assert.Equal(expectedRouteValues, result.RouteValues); 708Assert.Equal(expectedRouteValues, result.RouteValues); 729Assert.Equal(expected, resultTemporary.RouteValues); 748Assert.Equal(expected, resultTemporary.RouteValues); 770Assert.Equal(expectedRouteValues, result.RouteValues); 793Assert.Equal(expectedRouteValues, result.RouteValues); 813Assert.Equal(expected, resultPermanent.RouteValues); 832Assert.Equal(expected, resultPermanent.RouteValues); 854Assert.Equal(expectedRouteValues, result.RouteValues); 877Assert.Equal(expectedRouteValues, result.RouteValues); 967Assert.Equal(expected, resultTemporary.RouteValues); 988Assert.Equal(expected, resultTemporary.RouteValues); 1009Assert.Equal(expected, resultPermanent.RouteValues); 1030Assert.Equal(expected, resultPermanent.RouteValues); 1337Assert.Equal(expected, resultPermanent.RouteValues); 1358Assert.Equal(expected, resultPermanent.RouteValues);

224Assert.Equal<KeyValuePair<string, object>>(expectedRouteValues, param.Values as RouteValueDictionary); 283Assert.Equal<KeyValuePair<string, object>>(expectedRouteValues, param.Values as RouteValueDictionary); 356.Callback<UrlActionContext>(param => Assert.Equal(expectedRouteValues, param.Values as RouteValueDictionary)) 410.Callback<UrlRouteContext>(param => Assert.Equal(expectedRouteValues, param.Values as RouteValueDictionary))

349Assert.Equal(savedDisabled, items.Select(item => item.Disabled)); 350Assert.Equal(savedGroup, items.Select(item => item.Group)); 351Assert.Equal(savedSelected, items.Select(item => item.Selected)); 352Assert.Equal(savedText, items.Select(item => item.Text)); 353Assert.Equal(savedValue, items.Select(item => item.Value)); 529Assert.Equal(savedDisabled, items.Select(item => item.Disabled)); 530Assert.Equal(savedGroup, items.Select(item => item.Group)); 531Assert.Equal(savedSelected, items.Select(item => item.Selected)); 532Assert.Equal(savedText, items.Select(item => item.Text)); 533Assert.Equal(savedValue, items.Select(item => item.Value));

59Assert.Equal(new[] { 'a', 'b', 'c', 't' }, page.Take(4)); 145Assert.Equal(new[] { 'a', 'b', 'c' }, page.Take(buffer.Length)); 164page => Assert.Equal(expected, page), 165page => Assert.Equal(expected, page), 196page => Assert.Equal(expected1, page), 226page => Assert.Equal(expected, page), 255page => Assert.Equal(expected, page), 274Assert.Equal(new[] { 'a', 'b', 'c', 'd', 'e', 'f' }, page.Take(buffer.Length)); 290Assert.Equal(new[] { 'b', 'c', 'd' }, page.Take(buffer.Length)); 309page => Assert.Equal(expected, page), 310page => Assert.Equal(expected, page), 346page => Assert.Equal(expected1, page), 376page => Assert.Equal(expected, page), 405page => Assert.Equal(expected, page), 423Assert.Equal(new[] { 'A', 'b', 'c', 'd', 'e' }, page.Take(buffer.Length)); 478Assert.Equal(new[] { 'e', 'f', 'g', 'h' }, buffer.Pages[0].Take(buffer.Length));

75Assert.Equal(expected, GetValues(buffer)); 101Assert.Equal(expected, GetValues(buffer)); 118Assert.Equal<object>(new[] { newLine, newLine }, actual); 134Assert.Equal<object>(new[] { string.Empty }, actual); 157Assert.Equal<object>(new[] { input1, input2, newLine, input3, input4, newLine }, actual);

601Assert.Equal<string>(expected, result); 631Assert.Equal<string>(expected, result); 678Assert.Equal<string>(expected, result); 704Assert.Equal<string>(expected, result); 727Assert.Equal<string>(expected, result); 785Assert.Equal<string>(expected, result); 811Assert.Equal<string>(expected, result); 840Assert.Equal<string>(expected, result); 952Assert.Equal<string>(expected, result);

300Assert.Equal(value, roundTripValue);

132Assert.Equal(expectedLocations, result.SearchedLocations); 167Assert.Equal(expectedLocations, result.SearchedLocations); 202Assert.Equal(expectedLocations, result.SearchedLocations); 276Assert.Equal(new string[] { "location/myview" }, listener.ViewNotFound.SearchedLocations);

338Assert.Equal(savedDisabled, selectList.Select(item => item.Disabled)); 339Assert.Equal(savedGroup, selectList.Select(item => item.Group)); 340Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 341Assert.Equal(savedText, selectList.Select(item => item.Text)); 342Assert.Equal(savedValue, selectList.Select(item => item.Value)); 362Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 402Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 611Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 635Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 659Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 684Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 712Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 735Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 759Assert.Equal(savedDisabled, selectList.Select(item => item.Disabled)); 760Assert.Equal(savedGroup, selectList.Select(item => item.Group)); 761Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 762Assert.Equal(savedText, selectList.Select(item => item.Text)); 763Assert.Equal(savedValue, selectList.Select(item => item.Value)); 784Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 805Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1011Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1032Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1056Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1077Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1105Assert.Equal(savedDisabled, selectList.Select(item => item.Disabled)); 1106Assert.Equal(savedGroup, selectList.Select(item => item.Group)); 1107Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1108Assert.Equal(savedText, selectList.Select(item => item.Text)); 1109Assert.Equal(savedValue, selectList.Select(item => item.Value)); 1133Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1153Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1173Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1198Assert.Equal(savedDisabled, selectList.Select(item => item.Disabled)); 1199Assert.Equal(savedGroup, selectList.Select(item => item.Group)); 1200Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1201Assert.Equal(savedText, selectList.Select(item => item.Text)); 1202Assert.Equal(savedValue, selectList.Select(item => item.Value)); 1224Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1245Assert.Equal(savedSelected, selectList.Select(item => item.Selected)); 1267Assert.Equal(savedSelected, selectList.Select(item => item.Selected));

67Assert.Equal(new[] { "controller/test-view" }, result.SearchedLocations); 156Assert.Equal(new[] { "1", "2", "3", "4", "5" }, result.SearchedLocations); 199Assert.Equal(new[] { expectedViewName }, result.SearchedLocations); 297Assert.Equal(new[] { "1", "2", "3", "4", "5" }, result.SearchedLocations); 334Assert.Equal(new[] { "Shared/partial-view" }, result.SearchedLocations); 423Assert.Equal(new[] { "1", "2", "3", "4", "5" }, result.SearchedLocations);

130Assert.Equal(expectedLocations, result.SearchedLocations); 164Assert.Equal(expectedLocations, result.SearchedLocations); 198Assert.Equal(expectedLocations, result.SearchedLocations); 271Assert.Equal(new string[] { "location/myview" }, listener.ViewNotFound.SearchedLocations);

1056Assert.Equal(initialResponse.Headers.GetValues(header.Key), subsequentResponse.Headers.GetValues(header.Key));

108Assert.Equal(expectedTagHelperOrders, processOrder);

655Assert.Equal(expectedAttributes, attributes.PublicAttributes);

960Assert.Equal(initialResponse.Headers.GetValues(header.Key), subsequentResponse.Headers.GetValues(header.Key));

152Assert.Equal(new string[] { "close" }, response.Headers.GetValues("Connection")); 178Assert.Equal(new string[] { "close" }, response.Headers.GetValues("Connection")); 207Assert.Equal(new string[] { "close" }, response.Headers.GetValues("Connection")); 297Assert.Equal(headers.GetValues(headerName), expectedValue);

283Assert.Equal(new[] { "TrailerValue0", "TrailerValue1" }, response.TrailingHeaders.GetValues("TrailerName")); 311Assert.Equal(values, response.TrailingHeaders.GetValues("ThisIsALongerHeaderNameThatStillWorksForReals")); 336Assert.Equal(headers.GetValues(headerName), expectedValue);

199Assert.Equal(new Exception[] { exception }, aggregateException.InnerExceptions); 225Assert.Equal(inner, exception.InnerExceptions);

848Assert.Equal(expectedHeaderNames, parsedHeaders.Select(t => t.Key)); 849Assert.Equal(expectedHeaderValues, parsedHeaders.Select(t => t.Value));

183Assert.Equal( 201Assert.Equal( 221Assert.Equal<string>( 225Assert.Equal<StringValues>(

77Assert.Equal(input, decoded.Take(decodedByteCount));

273Assert.Equal(TestData, data);

131Assert.Equal(new[] { "one", "two", "three", "four", "five" }, argument.Values); 155Assert.Equal(new[] { "three", "four", "five" }, third.Values);

77Assert.Equal(input, decoded.Take(decodedByteCount));

182Assert.Equal(expectedCallStack, methodNames);

113Assert.Equal(input, data.Take(16));

36Assert.Equal(testData.Encoded, allBytes); 51Assert.Equal(new List<byte>() { 0x0D,

876Assert.Equal(new[] { Create("my_prop", "my_val") }, properties); 913Assert.Equal(new[] { Create("my_prop", "my_other_val") }, properties); 925Assert.Equal(new[] { Create("my_prop", "my_other_val") }, properties);

26Assert.Equal(expected, task.GenerateCommandLineArgsTaskItems(rsp).Select(x => x.ItemSpec)); 39Assert.Equal(expected, compilerTask.CommandLineArgs!.Select(x => x.ItemSpec));

1931Assert.Equal<string>(expected, parsed); 1937Assert.Equal<string>(expected, parsed); 1943Assert.Equal<string>(expected, parsed); 1951Assert.Equal(new[] { "def1", "def2" }, parsed); 2703Assert.Equal(expectedAliases, result.Properties.Aliases);

634Assert.Equal(supportedDiagnostics, supportedDiagnostics.Distinct());

722Assert.Equal(new[] { "MemberReference:Void System.Diagnostics.DebuggerStepThroughAttribute..ctor()" }, getMethodAttributes(main));

152Assert.Equal(new[] 159Assert.Equal(new[]

5237Assert.Equal( 5286Assert.Equal( 5327Assert.Equal( 5540Assert.Equal(new[] { "CompilerGeneratedAttribute", "ConditionalAttribute" }, GetAttributeNames(attrs1)); 5636Assert.Equal(new[] { "CompilerGeneratedAttribute", "Attr" }, GetAttributeNames(attrs1)); 5637Assert.Equal(new[] { "Attr" }, GetAttributeNames(localFn1.GetReturnTypeAttributes())); 5638Assert.Equal(new[] { "Attr" }, GetAttributeNames(localFn1.TypeParameters.Single().GetAttributes())); 5639Assert.Equal(new[] { "Attr" }, GetAttributeNames(localFn1.Parameters.Single().GetAttributes())); 5647Assert.Equal(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(attrs1)); 5752Assert.Equal(new[] { "DllImportAttribute" }, GetAttributeNames(localFunction.GetAttributes())); 5761Assert.Equal( 5827Assert.Equal(new[] { "DllImportAttribute" }, GetAttributeNames(localFunction.GetAttributes())); 5836Assert.Equal(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(attrs1));

499Assert.Equal(new[] { "key", "val" }, typeArg.TupleElementNames); 513Assert.Equal(new[] { "x", "y" }, typeArg.TupleElementNames); 525Assert.Equal(new[] { "key", "val" }, typeArg.TupleElementNames); 537Assert.Equal(new[] { "key", "val" }, typeArg.TupleElementNames); 702Assert.Equal(new[] { "key", "val" }, typeArg.TupleElementNames); 718Assert.Equal(new[] { "key", "val" }, typeArg.TupleElementNames); 5861Assert.Equal(new[] { "System.Int32" }, ElementTypeNames(tupleWithoutNames)); 5881Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tupleWithoutNames)); 5918Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tuple)); 5958Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tupleWithoutNames)); 5976Assert.Equal(new[] { "Alice", "Bob" }, GetTupleElementNames(tupleWithNames)); 5977Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tupleWithNames)); 5995Assert.Equal(new[] { null, "Item2", "Charlie" }, GetTupleElementNames(tupleWithSomeNames)); 5996Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32" }, ElementTypeNames(tupleWithSomeNames)); 6013Assert.Equal(new[] { "Item2", "Item1" }, GetTupleElementNames(tupleWithNames)); 6014Assert.Equal(new[] { "System.Int32", "System.Int32" }, ElementTypeNames(tupleWithNames)); 6039Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String" }, 6065Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String" }, 6089Assert.Equal(new[] { "Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8" }, GetTupleElementNames(tuple8WithNames)); 6091Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String" }, 6116Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32" }, 6139Assert.Equal(new[] { "Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8", "Alice9" }, GetTupleElementNames(tuple9WithNames)); 6141Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32" }, 6171Assert.Equal(new[] { "Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9" }, GetTupleElementNames(tuple9WithNames)); 6173Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.Int32", "System.Int32" }, 6276Assert.Equal(new[] { "123", " ", null }, GetTupleElementNames(tuple2)); 6280Assert.Equal(new[] { "return", "class" }, GetTupleElementNames(tuple3)); 6372Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tupleWithoutNames)); 6397Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tuple)); 6420Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tupleWithoutNames)); 6435Assert.Equal(new[] { "Alice", "Bob" }, GetTupleElementNames(tupleWithNames)); 6436Assert.Equal(new[] { "System.Int32", "System.String" }, ElementTypeNames(tupleWithNames)); 6450Assert.Equal(new[] { "Item2", "Item1" }, GetTupleElementNames(tupleWithNames)); 6451Assert.Equal(new[] { "System.Int32", "System.Int32" }, ElementTypeNames(tupleWithNames)); 6471Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String" }, 6489Assert.Equal(new[] { "Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8" }, GetTupleElementNames(tuple8WithNames)); 6491Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String" }, 6512Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32" }, 6531Assert.Equal(new[] { "Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8", "Alice9" }, GetTupleElementNames(tuple9WithNames)); 6533Assert.Equal(new[] { "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32", "System.String", "System.Int32" }, 6564Assert.Equal(new[] { "123", " " }, GetTupleElementNames(tuple2)); 6568Assert.Equal(new[] { "return", "class" }, GetTupleElementNames(tuple3));

338Assert.Equal(sortedFullNames, getNamesOfForwardedTypes(assembly)); 348Assert.Equal(sortedFullNames, metadataFullNames); 358Assert.Equal(sortedFullNames, getNamesOfForwardedTypes(retargeting));

65Assert.Equal(expected, actualConversionKinds);

620Assert.Equal(new[] { 2, 0, 1 }, attributeData.ConstructorArgumentsSourceIndices); 655Assert.Equal(new object[] { 1, 2, 3 }, attributeData.ConstructorArguments.Single().Values.Select(arg => arg.Value)); 1123Assert.Equal(new[] { 1, 0 }, attributeData.ConstructorArgumentsSourceIndices); 1187Assert.Equal(new[] { 1, 0 }, attributeData.ConstructorArgumentsSourceIndices); 1226Assert.Equal(new[] { 0, 1 }, attributeData.ConstructorArgumentsSourceIndices); 1265Assert.Equal(new[] { 0, 1 }, attributeData.ConstructorArgumentsSourceIndices); 1303Assert.Equal(new[] { 1, 0 }, attributeData.ConstructorArgumentsSourceIndices); 1343Assert.Equal(new[] { 1, 0 }, attributeData.ConstructorArgumentsSourceIndices); 11015Assert.Equal(new[] { "Attr<System.Int32>" }, GetAttributeStrings(attrs)); 11150Assert.Equal(new[] { "Attr<System.String>(Prop = \"a\")" }, GetAttributeStrings(attrs)); 11244Assert.Equal(new[] { "Attr<System.String>(\"a\")" }, GetAttributeStrings(attrs)); 11295Assert.Equal(new[] 11308Assert.Equal(new[] 11367Assert.Equal(new[] { "Attr<Attr<System.String>>" }, GetAttributeStrings(attrs));

652Assert.Equal(new[] { "Attr" }, GetAttributeNames(typeParam.GetAttributes()));

5753Assert.Equal(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(method.GetAttributes()));

1460Assert.Equal(TestResources.General.snMaxSizePublicKey, comp.Assembly.Identity.PublicKey); 1461Assert.Equal<byte>(pubKeyTokenBytes, comp.Assembly.Identity.PublicKeyToken); 1478Assert.Equal(TestResources.General.snMaxSizePublicKey, comp2.Assembly.Identity.PublicKey); 1479Assert.Equal<byte>(pubKeyTokenBytes, comp2.Assembly.Identity.PublicKeyToken); 1488Assert.Equal(TestResources.General.snMaxSizePublicKey, comp3.Assembly.Identity.PublicKey); 1489Assert.Equal<byte>(pubKeyTokenBytes, comp3.Assembly.Identity.PublicKeyToken);

389Assert.Equal(new[] { "AAttribute" }, getParameterAttributes(lambdas[0].Parameters[0])); 390Assert.Equal(new string[0], getParameterAttributes(lambdas[0].Parameters[1])); 391Assert.Equal(new string[0], getParameterAttributes(lambdas[1].Parameters[0])); 392Assert.Equal(new[] { "AAttribute" }, getParameterAttributes(lambdas[1].Parameters[1]));

507Assert.Equal(new[] { "A" }, GetAttributeNames(attributes));

1118Assert.Equal(new[] { 5 }, array.Sizes); 1119Assert.Equal(new[] { 0 }, array.LowerBounds); 1125Assert.Equal(new[] { 5 }, array.Sizes); 1126Assert.Equal(new[] { 0 }, array.LowerBounds); 1132Assert.Equal(new[] { 5, 5 }, array.Sizes); 1139Assert.Equal(new[] { 5 }, array.Sizes); 1140Assert.Equal(new[] { 0, 2 }, array.LowerBounds); 1146Assert.Equal(new[] { 5, 7 }, array.Sizes); 1147Assert.Equal(new[] { 0, 2 }, array.LowerBounds); 1153Assert.Equal(new[] { 5 }, array.Sizes); 1154Assert.Equal(new[] { 1 }, array.LowerBounds); 1160Assert.Equal(new[] { 5 }, array.Sizes); 1161Assert.Equal(new[] { 1 }, array.LowerBounds); 1167Assert.Equal(new[] { 5, 5 }, array.Sizes); 1168Assert.Equal(new[] { 1, 0 }, array.LowerBounds); 1174Assert.Equal(new[] { 5 }, array.Sizes); 1175Assert.Equal(new[] { 1, 2 }, array.LowerBounds); 1181Assert.Equal(new[] { 5, 7 }, array.Sizes); 1182Assert.Equal(new[] { 1, 2 }, array.LowerBounds); 1189Assert.Equal(new[] { 1 }, array.LowerBounds); 1196Assert.Equal(new[] { 1 }, array.LowerBounds); 1203Assert.Equal(new[] { 1, 2 }, array.LowerBounds); 1209Assert.Equal(new[] { 5 }, array.Sizes); 1210Assert.Equal(new[] { 1 }, array.LowerBounds);

58Assert.Equal(expected, actualConversionKinds);

6163Assert.Equal(new[] { "DllImportAttribute" }, GetAttributeNames(localFunction.GetAttributes())); 6179Assert.Equal(new[] { "CompilerGeneratedAttribute" }, programAttributes); 6189Assert.Equal(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(localFn1.GetAttributes().As<CSharpAttributeData>())); 9071Assert.Equal(new[] { "CompilerGeneratedAttribute" }, GetAttributeNames(program.GetAttributes().As<CSharpAttributeData>())); 9517Assert.Equal(new[] { "CompilerGeneratedAttribute", "DebuggerBrowsableAttribute" }, fieldAttributes);

839Assert.Equal<AdditionalText>(texts, passedIn); 2328Assert.Equal(new (object, IncrementalStepRunReason)[] 2349Assert.Equal(new (object, IncrementalStepRunReason)[]

1294Assert.Equal(expectedGeneratedSources, driver.GetRunResult().Results.Single().GeneratedSources.Select(s => (s.HintName, s.SourceText.ToString())));

93Assert.Equal(new[] { 2, 3 }, yieldItems(cachedEntries.Items)); 405Assert.Equal(ImmutableArray.Create(1, 2, 3), (IEnumerable<int>)output.Value); 468Assert.Equal(ImmutableArray.Create(1, 2, 3), (IEnumerable<int>)output.Value); 515Assert.Equal(ImmutableArray.Create(1, 2), (IEnumerable<int>)output.Value); 582Assert.Equal(ImmutableArray.Create(1, 2, 4), (IEnumerable<int>)output.Value);

697Assert.Equal(new[] { "C", "D" }, classDeclarations); 754Assert.Equal(new[] { "C", "D" }, classDeclarations); 965Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, syntaxFilterVisited); 987Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, syntaxFilterVisited); 1326Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, fieldsCalledFor); 1588Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, syntaxCalledFor); 1645Assert.Equal(new[] { "fieldA", "fieldB", "fieldC", "fieldA", "fieldB", "fieldC" }, syntaxCalledFor); 1646Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, noCompareCalledFor); 1647Assert.Equal(new[] { "fieldA", "fieldB", "fieldC" }, compareCalledFor); 1657Assert.Equal(new[] { "fieldD", "fieldE", "fieldF", "fieldD", "fieldE", "fieldF" }, syntaxCalledFor); 1658Assert.Equal(new[] { "fieldD", "fieldE", "fieldF" }, noCompareCalledFor);

135Assert.Equal(QuoteAndEscapingCombinations('a'), new[] 141Assert.Equal(QuoteAndEscapingCombinations('\t'), new[] 148Assert.Equal(QuoteAndEscapingCombinations('\u26f4'), new[] 155Assert.Equal(QuoteAndEscapingCombinations('\u007f'), new[] 162Assert.Equal(QuoteAndEscapingCombinations('\''), new[] 253Assert.Equal(QuoteAndEscapingCombinations(""), new[] { "", "", "\"\"", "\"\"" }); 254Assert.Equal(QuoteAndEscapingCombinations("a"), new[] { "a", "a", "\"a\"", "\"a\"" }); 255Assert.Equal(QuoteAndEscapingCombinations("\t"), new[] { "\t", "\\t", "\"\t\"", "\"\\t\"" }); 256Assert.Equal(QuoteAndEscapingCombinations("\u26F4"), new[] { "\u26F4", "\u26F4", "\"\u26F4\"", "\"\u26F4\"" }); // Miscellaneous symbol 257Assert.Equal(QuoteAndEscapingCombinations("\u007f"), new[] { "\u007f", "\\u007f", "\"\u007f\"", "\"\\u007f\"" }); // Control character 258Assert.Equal(QuoteAndEscapingCombinations("\""), new[] { "\"", "\"", "\"\\\"\"", "\"\\\"\"" }); // Quote

1977Assert.Equal(expectedAttributeNames, GetAttributeNames(definitionPart.GetReturnTypeAttributes())); 1982Assert.Equal(expectedAttributeNames, GetAttributeNames(implementationPart.GetReturnTypeAttributes())); 1990Assert.Equal(expectedAttributeNames, GetAttributeNames(method.GetReturnTypeAttributes()));

1502Assert.Equal(topLevelTypes.OrderBy(s => s), GetNamesOfForwardedTypes(assembly)); 1621Assert.Equal(new[] { "CF1" }, GetNamesOfForwardedTypes(modCompilation.Assembly)); 1630Assert.Equal(new[] { "CF1" }, GetNamesOfForwardedTypes(appCompilation.Assembly));

738Assert.Equal(new[] { source0, source1, source2, source3 }, comp0.SyntaxTrees);

4577Assert.Equal((IEnumerable<byte>)originalFileIdentifier.FilePathChecksumOpt, (IEnumerable<byte>)retargetedFileIdentifier.FilePathChecksumOpt);

3106Assert.Equal(

1105Assert.Equal(analyzer.SupportedDiagnostics.Select(d => d.Id), lowPriorityAnalyzerData.SupportedDiagnosticIds);

495Assert.Equal(expectedSpans, actualSpans);

46=> Assert.Equal(ClassificationTypeNames.AllTypeNames.Distinct(), ClassificationTypeNames.AllTypeNames);

1039Assert.Equal<T>(expected, actual);

268Assert.Equal(empty, empty.Concat(empty)); 269Assert.Equal(a, a.Concat(empty)); 270Assert.Equal(a, empty.Concat(a));

246Assert.Equal<KeyValuePair<int, GenericParameterHelper>>(list, ToListNonGeneric<KeyValuePair<int, GenericParameterHelper>>(map)); 303Assert.Equal(array.Skip(1), nonGeneric.Cast<T>().ToArray());

88Assert.Equal(enumerable, array); 92Assert.Equal(enumerable, array); 96Assert.Equal(enumerable, array); 100Assert.Equal(enumerable.Take(array.Length), array); 108Assert.Equal(enumerable, array); 521Assert.Equal(new[] { 1 }, enumerable.ToList()); // exercises the enumerator 524Assert.Equal(new[] { 1 }, enumerableNonGeneric.Cast<int>().ToList()); // exercises the enumerator

339Assert.Equal(new[] { 1, 3 }, modified2); 529Assert.Equal<int>(new[] { 4, 5, 8 }, System.Collections.Immutable.ImmutableList.Replace((System.Collections.Immutable.IImmutableList<int>)list, 3, 4)); 530Assert.Equal<int>(new[] { 3, 6, 8 }, System.Collections.Immutable.ImmutableList.Replace((System.Collections.Immutable.IImmutableList<int>)list, 5, 6)); 531Assert.Equal<int>(new[] { 3, 5, 9 }, System.Collections.Immutable.ImmutableList.Replace((System.Collections.Immutable.IImmutableList<int>)list, 8, 9)); 537Assert.Equal<int>(new[] { 4, 3, 5 }, System.Collections.Immutable.ImmutableList.Replace((System.Collections.Immutable.IImmutableList<int>)list, 3, 4)); 538Assert.Equal<int>(new[] { 4, 4, 5 }, System.Collections.Immutable.ImmutableList.Replace(System.Collections.Immutable.ImmutableList.Replace((System.Collections.Immutable.IImmutableList<int>)list, 3, 4), 3, 4)); 651Assert.Equal(new[] { 2 }, System.Collections.Immutable.ImmutableList.RemoveRange((System.Collections.Immutable.IImmutableList<int>)list, new[] { 1, 3, 5 })); 661Assert.Equal(new[] { 1, 3 }, System.Collections.Immutable.ImmutableList.RemoveRange((System.Collections.Immutable.IImmutableList<int>)ImmutableSegmentedList.Create(1, 2, 3), new[] { 2 }));

272Assert.Equal<T>(expectedValues, set.ToList()); 453Assert.Equal<T>(values, list);

163Assert.Equal<T>(expectedResults, manualArray);

1158Assert.Equal( 1164Assert.Equal( 1168Assert.Equal( 1172Assert.Equal( 1176Assert.Equal( 1187Assert.Equal( 1191Assert.Equal( 1195Assert.Equal( 1201Assert.Equal( 1205Assert.Equal( 1210Assert.Equal( 1215Assert.Equal( 1219Assert.Equal(

47Assert.Equal(new[] { symbol }, foundSymbols); 73Assert.Equal(new[] { symbol }, foundSymbols); 97Assert.Equal(new[] { symbol }, foundSymbols); 121Assert.Equal(new[] { symbol }, foundSymbols);

338Assert.Equal<byte>(expectedSourceText.GetChecksum(), actualSourceText.GetChecksum());

185Assert.Equal<byte>(expectedChecksum, actualChecksum); 186Assert.Equal<byte>(expectedContentHash, actualContentHash); 358Assert.Equal<byte>(expectedSourceText.GetChecksum(), actualSourceText.GetChecksum()); 375Assert.Equal<byte>(expectedSourceText.GetChecksum(), actualSourceText.GetChecksum());

6968Assert.Equal(New String() {"Alice", "Bob"}, GetTupleElementNames(tupleWithoutNames)) 6989Assert.Equal(New String() {Nothing, "Item2", "Charlie"}, GetTupleElementNames(tupleWithSomeNames)) 7007Assert.Equal(New String() {"Item2", "Item1"}, GetTupleElementNames(tupleWithoutNames)) 7056Assert.Equal(New String() {"Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8"}, GetTupleElementNames(tuple8WithNames)) 7106Assert.Equal(New String() {"Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8", "Alice9"}, GetTupleElementNames(tuple9WithNames)) 7131Assert.Equal(New String() {"Item1", "Item2", "Item3", "Item4", "Item5", "Item6", "Item7", "Item8", "Item9"}, GetTupleElementNames(tuple9WithNames)) 7174Assert.Equal({"123", " ", Nothing}, GetTupleElementNames(tuple2)) 7178Assert.Equal({"return", "class"}, GetTupleElementNames(tuple3)) 7316Assert.Equal(New String() {"Alice", "Bob"}, GetTupleElementNames(tupleWithoutNames)) 7332Assert.Equal(New String() {"Item2", "Item1"}, GetTupleElementNames(tupleWithoutNames)) 7373Assert.Equal(New String() {"Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8"}, GetTupleElementNames(tuple8WithNames)) 7415Assert.Equal(New String() {"Alice1", "Alice2", "Alice3", "Alice4", "Alice5", "Alice6", "Alice7", "Alice8", "Alice9"}, GetTupleElementNames(tuple9WithNames)) 7453Assert.Equal({"123", " "}, GetTupleElementNames(tuple2)) 7457Assert.Equal({"return", "class"}, GetTupleElementNames(tuple3))

203Assert.Equal(expectedDuplicates, duplicates);

1659Assert.Equal(expectedChecksum, document.GetTextSynchronously(default).GetChecksum());

697Assert.Equal(columnName, new[] { "vendor_id", "rate_code", "passenger_count", "trip_time_in_secs", "Column4", "Column5", "Column6", "Column7" }); 712Assert.Equal(columnName, new[] { "vendor_id", "rate_code", "passenger_count", "trip_time_in_secs", "Column0", "Column1", "Column2", "Column3" }); 1322Assert.Equal(_cells[i], df.Rows[i]);

611Assert.Equal(dfColumns, clampedColumns);

64 Assert.Equal(new[] { 0, 1, 2, 3, 4, 5 }, indices); 116 Assert.Equal(new[] { 0, 1, 2, 3, 4, 5 }, indices);

62 Assert.Equal(new[] { 0, 1, 2, 3, 4, 5 }, indices); 114 Assert.Equal(new[] { 0, 1, 2, 3, 4, 5 }, indices); 703 Assert.Equal(expected, actual); 712 var ex = Record.Exception(() => Assert.Equal(expected, actual)); 729 var ex = Record.Exception(() => Assert.Equal(expected, actual)); 957 Assert.Equal(expected, actual); 1023 var ex = Record.Exception(() => Assert.Equal(expected, actual));

1310 Assert.Equal(expected, actual);

92Assert.Equal(actual.Value.Tags, degradedCheckTags); 105Assert.Equal(actual.Value.Tags, healthyCheckTags); 114Assert.Equal(actual.Value.Tags, unhealthyCheckTags); 146Assert.Equal(actual.Value.Tags, exceptionTags); 155Assert.Equal(actual.Value.Tags, operationExceptionTags);

38Assert.Equal<string>(new[] { "tag", }, registration.Tags); 58Assert.Equal<string>(new[] { "tag", }, registration.Tags); 81Assert.Equal<string>(new[] { "tag", }, registration.Tags); 103Assert.Equal<string>(new[] { "tag", }, registration.Tags); 129Assert.Equal<string>(new[] { "tag", }, registration.Tags); 152Assert.Equal<string>(new[] { "tag", }, registration.Tags); 175Assert.Equal<string>(new[] { "tag", }, registration.Tags); 198Assert.Equal<string>(new[] { "tag", }, registration.Tags);

211Assert.Equal(new[] { "one", "two", }, report.Entries.Keys.OrderBy(k => k)); 435Assert.Equal(new[] { "one", "two", }, report.Entries.Keys.OrderBy(k => k));

449Assert.Equal(loggerProvider.LogText, 507Assert.Equal(loggerProvider.LogText, 516Assert.Equal(loggerProvider2.LogText,

629Assert.Equal(new[] { "provider1.Test-Hello" }, store);

337Assert.Equal(new[]

71Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 154Assert.Equal(new (string, object?)[] { ("s1", "val_1"), ("s2", "val_2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 175Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2"), ("s3", "val3"), ("s4", "val4") }, tags); 178Assert.Equal(new (string, object?)[] { ("s1", "val3"), ("s2", "val4"), ("s3", "val5"), ("s4", "val6") }, tags); 199Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2"), ("s3", "val3"), ("s4", "val4") }, tags); 202Assert.Equal(new (string, object?)[] { ("s1", "val3"), ("s2", "val4"), ("s3", "val5"), ("s4", "val6") }, tags); 253Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 259Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 266Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val4") }, measurement.Tags.Select(x => (x.Key, x.Value))); 278Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 284Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 291Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val4") }, measurement.Tags.Select(x => (x.Key, x.Value))); 329Assert.Equal(new (string, object?)[] { ("Dim1", "val1"), ("Dim_2", "val2"), ("Dim_3", "val3") }, measurement.Tags.Select(x => (x.Key, x.Value))); 342Assert.Equal(new (string, object?)[] { ("Dim1", "val1"), ("Dim_2", "val2"), ("Dim_3", "val3") }, measurement.Tags.Select(x => (x.Key, x.Value))); 363Assert.Equal( 407Assert.Equal( 430Assert.Equal( 453Assert.Equal( 506Assert.Equal( 550Assert.Equal( 573Assert.Equal( 595Assert.Equal(

55Assert.Equal(new (string, object?)[] { ("s1", "val1"), ("s2", "val2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 135Assert.Equal(new (string, object?)[] { ("s1", "val_1"), ("s2", "val_2") }, measurement.Tags.Select(x => (x.Key, x.Value))); 170Assert.Equal( 192Assert.Equal( 214Assert.Equal( 263Assert.Equal( 285Assert.Equal( 307Assert.Equal(

83Assert.Equal(new[] { obj2, obj1 }, syncResult.Select(r => r.Value));

77Assert.Equal(keyNames.DenseValues(), actualKeyNames.DenseValues());

597Assert.Equal(new[] { 5, 5, 1, 32 }, type.Dimensions); 612Assert.Equal(new[] { 28, 28, 32 }, type.Dimensions); 627Assert.Equal(new[] { 10 }, type.Dimensions); 646Assert.Equal(new[] { 2, 2 }, type.Dimensions);

143Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 146Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "0:A", "1:B" }); 149Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 152Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[1] { "C" }); 156Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 159Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[6] { "1:2", "0:5", "1:4", "1:6", "0:3", "0:1" }); 162Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 165Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "-1", "1" }); 169Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[3] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 174Assert.Equal(slots.Items().Select(x => x.Value.ToString()).Distinct(), new string[14] { "[0].", "[0].0:A", "[0].0:E", "[0].0:D", "[0].1:A", "[0].1:E", "[0].1:D", "[1].", "[1].0:A", "[1].0:E", "[1].0:D", "[1].1:A", "[1].1:E", "[1].1:D" }); 177Assert.Equal(slotRanges.Items().Select(x => x.Value.ToString()), new string[4] { "0", "65535", "65536", "131071" }); 181Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[3] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 184Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "E", "D" }); 187Assert.Equal(slotRanges.Items().Select(x => x.Value.ToString()), new string[2] { "0", "65535" }); 191Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.KeyValues }); 194Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "0:A", "1:B" }); 197Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.KeyValues }); 200Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[1] { "C" }); 203Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 208Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized });

221Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 224Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "A", "B" }); 227Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 230Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[1] { "C" }); 234Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 237Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "3", "5" }); 240Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 243Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "6", "1" }); 247Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[3] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 250Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[12] { "[0].1", "[0].2", "[0].3", "[0].4", "[0].5", "[0].6", "[1].1", "[1].2", "[1].3", "[1].4", "[1].5", "[1].6" }); 253Assert.Equal(slotRanges.Items().Select(x => x.Value.ToString()), new string[4] { "0", "5", "6", "11" }); 257Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[3] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 260Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "1", "-1" }); 263Assert.Equal(slotRanges.Items().Select(x => x.Value.ToString()), new string[2] { "0", "1" }); 267Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.KeyValues }); 270Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[3] { "A", "D", "E" }); 273Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.KeyValues }); 276Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "D", "E" }); 279Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 282Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[6] { "[0].Bit2", "[0].Bit1", "[0].Bit0", "[1].Bit2", "[1].Bit1", "[1].Bit0" }); 285Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 288Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "Bit1", "Bit0" }); 292Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 295Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[6] { "[0].Bit2", "[0].Bit1", "[0].Bit0", "[1].Bit2", "[1].Bit1", "[1].Bit0" }); 298Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 301Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[3] { "Bit2", "Bit1", "Bit0" });

352Assert.Equal(result.Schema["ConvA"].Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 356Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "1", "2" }); 359Assert.Equal(result.Schema["ConvB"].Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.KeyValues }); 362Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "A", "B" });

243Assert.Equal(new[] { 0, 3, 5, 6 }, counter); 244Assert.Equal(new[] { 1, 0, 4, 1 }, values);

89Assert.Equal(keys.Items().Select(x => x.Value.ToString()), new string[2] { "2.5", "3.5" }); 94Assert.Equal(keys.Items().Select(x => x.Value.ToString()), new string[2] { "2.5", "3.5" }); 99Assert.Equal(keys.Items().Select(x => x.Value.ToString()), new string[2] { "0:3.5", "1:2.5" }); 404Assert.Equal(aHashed, dHashed); 405Assert.Equal(aHashed, dHashedCombined);

117Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 120Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[6] { "[0].Bit2", "[0].Bit1", "[0].Bit0", "[1].Bit2", "[1].Bit1", "[1].Bit0" }); 123Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 126Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "Bit1", "Bit0" });

136Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 139Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "A", "B" }); 142Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[3] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 145Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[1] { "C" }); 148Assert.Equal(slotRanges.Items().Select(x => x.Value), new int[2] { 0, 0 }); 152Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[3] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 155Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[4] { "[0].3", "[0].5", "[1].3", "[1].5" }); 158Assert.Equal(slotRanges.Items().Select(x => x.Value), new int[4] { 0, 1, 2, 3 }); 162Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.IsNormalized }); 165Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "6", "1" }); 169Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[2] { AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 172Assert.Equal(slotRanges.Items().Select(x => x.Value), new int[4] { 0, 5, 6, 11 }); 176Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.IsNormalized }); 180Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[1] { AnnotationUtils.Kinds.SlotNames }); 183Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[3] { "A", "D", "E" }); 186Assert.Equal(column.Annotations.Schema.Select(x => x.Name), new string[3] { AnnotationUtils.Kinds.SlotNames, AnnotationUtils.Kinds.CategoricalSlotRanges, AnnotationUtils.Kinds.IsNormalized }); 189Assert.Equal(slots.Items().Select(x => x.Value.ToString()), new string[2] { "D", "E" }); 192Assert.Equal(slotRanges.Items().Select(x => x.Value), new int[2] { 0, 1 });

449Assert.Equal(expectedIds.Take(expectedIds.Length - 2), tokenizer.EncodeToIds(text, expectedIds.Length - 2, out normalizedText, out length)); 453Assert.Equal(expectedIds.Take(expectedIds.Length - 2), tokenizer.EncodeToIds(text.AsSpan(), expectedIds.Length - 2, out normalizedText, out length));

401Assert.Equal(ids.Take(ids.Length - expectedTokensToExclude), codeGenTokenizer.EncodeToIds(text, ids.Length - 1, out normalizedText, out length)); 406Assert.Equal(ids.Take(ids.Length - expectedTokensToExclude), codeGenTokenizer.EncodeToIds(text.AsSpan(), ids.Length - 1, out normalizedText, out length)); 410Assert.Equal(expectedIds.Take(expectedIds.Length - expectedTokensToExclude), codeGenTokenizer.EncodeToIds(text, expectedIds.Length - 1, addPrefixSpace: false, addBeginningOfSentence: false, addEndOfSentence: false, out normalizedText, out length)); 413Assert.Equal(expectedIds.Take(expectedIds.Length - expectedTokensToExclude), codeGenTokenizer.EncodeToIds(text.AsSpan(), expectedIds.Length - 1, addPrefixSpace: false, addBeginningOfSentence: false, addEndOfSentence: false, out normalizedText, out length)); 417Assert.Equal(expectedIdsWithSpace.Take(expectedIdsWithSpace.Length - expectedTokensToExclude), codeGenTokenizer.EncodeToIds(text, expectedIdsWithSpace.Length - 1, addPrefixSpace: true, addBeginningOfSentence: false, addEndOfSentence: false, out normalizedText, out length)); 420Assert.Equal(expectedIdsWithSpace.Take(expectedIdsWithSpace.Length - expectedTokensToExclude), codeGenTokenizer.EncodeToIds(text.AsSpan(), expectedIdsWithSpace.Length - 1, addPrefixSpace: true, addBeginningOfSentence: false, addEndOfSentence: false, out normalizedText, out length)); 556Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 557Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 561Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 562Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 566Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 567Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 571Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 572Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 580Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 581Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 585Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 586Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 689Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 690Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 694Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 695Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 699Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 700Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 704Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 705Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 713Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 714Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 718Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 719Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 824Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 825Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 830Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 831Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 836Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 837Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 842Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 843Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 854Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 855Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 860Assert.Equal(idList, encoding.Select(t => t.Id).ToArray()); 861Assert.Equal(tokensList, encoding.Select(t => t.Value).ToArray()); 1000Assert.Equal(encodingIds.Take(expectedTokenCount), ids); 1005Assert.Equal(encodingIds.Take(expectedTokenCount), ids);

201Assert.Equal(expectedIds.Take(expectedIds.Length - 2), tokenizer.EncodeToIds(text, expectedIds.Length - 2, out normalizedText, out length)); 205Assert.Equal(expectedIds.Take(expectedIds.Length - 2), tokenizer.EncodeToIds(text.AsSpan(), expectedIds.Length - 2, out normalizedText, out length));

267Assert.Equal(ids.Skip(1), bpeTokens.Select(token => token.Id)); 268Assert.Equal(tokens.Skip(1), bpeTokens.Select(token => token.Value)); 273Assert.Equal(ids.Skip(1), encodedIds); 277Assert.Equal(isEmptyInput ? Array.Empty<int>() : ids.Skip(1).Concat(new[] { bpe.EndOfSentenceId }), bpeTokens.Select(token => token.Id)); 278Assert.Equal(isEmptyInput ? Array.Empty<string>() : tokens.Skip(1).Concat(new[] { bpe.EndOfSentenceToken }), bpeTokens.Select(token => token.Value)); 283Assert.Equal(isEmptyInput ? Array.Empty<int>() : ids.Skip(1).Concat(new[] { bpe.EndOfSentenceId }), encodedIds); 287Assert.Equal(isEmptyInput ? Array.Empty<int>() : ids.Concat(new[] { bpe.EndOfSentenceId }), bpeTokens.Select(token => token.Id)); 288Assert.Equal(isEmptyInput ? Array.Empty<string>() : tokens.Concat(new[] { bpe.EndOfSentenceToken }), bpeTokens.Select(token => token.Value)); 293Assert.Equal(isEmptyInput ? Array.Empty<int>() : ids.Concat(new[] { bpe.EndOfSentenceId }), encodedIds); 596Assert.Equal(expectedIds1.Take(expectedIds1.Length - 6), sentencePieceBpe.EncodeToIds( 611Assert.Equal(expectedIds1.Take(expectedIds1.Length - 6), sentencePieceBpe.EncodeToIds(

151Assert.Equal(new List<Range> { new Range(0, 5), new Range(5, 11) }, offsets); 205Assert.Equal(new List<(int, int)> { (0, 12), (12, 5), (17, 6), (23, 10) }, offsets); 248Assert.Equal(new List<(int, int)> { (0, 12), (12, 5), (17, 10), (27, 6) }, offsets); 278Assert.Equal(new List<(int, int)> { (0, 12), (12, 5), (17, 2), (18, 1), (19, 6), (25, 10) }, result.Select(token => (token.Offset.Start.Value, token.Offset.End.Value - token.Offset.Start.Value)).ToArray()); 313Assert.Equal(new List<(int, int)> { (0, 13), (13, 5), (18, 2), (20, 6), (26, 15) }, result.Select(token => (token.Offset.Start.Value, token.Offset.End.Value - token.Offset.Start.Value)).ToArray()); 588Assert.Equal(expectedIds.Take(expectedIds.Length - 4), tokenizer.EncodeToIds(text, expectedIds.Length - 4, out normalizedText, out length)); 592Assert.Equal(expectedIds.Take(expectedIds.Length - 4), tokenizer.EncodeToIds(text.AsSpan(), expectedIds.Length - 4, out normalizedText, out length)); 686Assert.Equal(expectedTokens, result.Select(r => r.Value));

144Assert.Equal(fullIdsList.Take(partialIdsList.Count), partialIdsList); 166Assert.Equal(prefixIds, fullIdsList.Take(prefixIds.Count)); 189Assert.Equal(suffixIds, fullIdsList.Skip(fullIdsList.Count - suffixIds.Count));

917Assert.Equal(expected, result);

13Assert.Equal(expected, app.CommandLineArgs);

142Assert.Equal(sentArgs, receivedArgs.Freeze()); 161Assert.Equal(sentArgs, receivedSorted); 235Assert.Equal(new[] { new[] { "1", "ABC" } }, receivedArgs.Freeze());

13Assert.Equal(value, collection.Cast<string>()); 23Assert.Equal(value, collection.Cast<string>());

1440Assert.Equal(expectedEntries, bitmap.Palette.Entries.Select(c => c.ToArgb()));

383Assert.Equal(blend.Colors.Select(c => Color.FromArgb(c.ToArgb())), brush.InterpolationColors.Colors); 404Assert.Equal(blend.Colors.Select(c => Color.FromArgb(c.ToArgb())), brush.InterpolationColors.Colors); 536Assert.Equal(colors.Take(2).Select(c => Color.FromArgb(c.ToArgb())), brush.LinearColors);

722Assert.Equal(expectedPoints.Select(p => (PointF)p), pointFs); 777Assert.Equal(expectedPoints.Select(p => (PointF)p), pointFs);

654Assert.Equal(

29Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>()); 55Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>());

26Assert.Equal(value, collection.Cast<object>()); 49Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>()); 54Assert.Equal(new object[] { value1, value2, null }, collection.Cast<object>()); 65Assert.Equal(value, collection.Cast<object>()); 69Assert.Equal(value.Concat(value), collection.Cast<object>()); 78Assert.Equal(value, collection.Cast<object>()); 82Assert.Equal(value.Concat(value), collection.Cast<object>()); 107Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>()); 112Assert.Equal(new object[] { value2, null, value1 }, collection.Cast<object>());

291Assert.Equal(new IComponent[] { component1, component2 }, host.Container.Components.Cast<IComponent>()); 302Assert.Equal(new IComponent[] { component1, component2, component3 }, host.Container.Components.Cast<IComponent>()); 313Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, host.Container.Components.Cast<IComponent>()); 346Assert.Equal(new IComponent[] { component1, component2 }, host.Container.Components.Cast<IComponent>()); 357Assert.Equal(new IComponent[] { component1, component2, component3 }, host.Container.Components.Cast<IComponent>()); 368Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, host.Container.Components.Cast<IComponent>());

26Assert.Equal(value, collection.Cast<object>()); 49Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>()); 54Assert.Equal(new object[] { value1, value2, null }, collection.Cast<object>()); 65Assert.Equal(value, collection.Cast<object>()); 69Assert.Equal(value.Concat(value), collection.Cast<object>()); 78Assert.Equal(value, collection.Cast<object>()); 82Assert.Equal(value.Concat(value), collection.Cast<object>()); 107Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>()); 112Assert.Equal(new object[] { value2, null, value1 }, collection.Cast<object>());

89Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 99Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 193Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 204Assert.Equal(new IComponent[] { component1, component2, component3 }, container.Components.Cast<IComponent>()); 215Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, container.Components.Cast<IComponent>()); 250Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 261Assert.Equal(new IComponent[] { component1, component2, component3 }, container.Components.Cast<IComponent>()); 272Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, container.Components.Cast<IComponent>());

23Assert.Equal(new string[] { "bmp", "gif", "jpg", "jpeg", "png", "ico" }, extensions);

1366Assert.Equal(new string[] { type.Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName)); 1368Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f)); 1374Assert.Equal(new string[] { type.Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName)); 1376Assert.Equal(new string[] { type.Name, "Filter", "System.Drawing.Design.Tests.ToolboxItemTests+" + type.Name }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString).OrderBy(f => f)); 1403Assert.Equal(new string[] { typeof(object).Assembly.FullName }, item.DependentAssemblies.Select(a => a.FullName)); 1405Assert.Equal(new string[] { "System.Object" }, item.Filter.Cast<ToolboxItemFilterAttribute>().Select(a => a.FilterString));

36Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 60Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 77Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 84Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 100Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name));

285Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 290Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 337Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 345Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());

252Assert.Equal(properties, binaryFormattedProperties);

248Assert.Equal(Enumerable.Repeat(1, 16), dialog.CustomColors);

67Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 82Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 97Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 143Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 148Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>()); 159Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>()); 164Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>()); 174Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>()); 289Assert.Equal(new Control[] { control1 }, collection.Cast<Control>()); 299Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 313Assert.Equal(new Control[] { control1, control2, control3 }, collection.Cast<Control>()); 1230Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1244Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1257Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1356Assert.Equal(new Control[] { child1, child2, child3 }, sourceCollection.Cast<Control>()); 1357Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1938Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 1948Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 1958Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2002Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2013Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2024Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2072Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2085Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2098Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2154Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2170Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2186Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2221Assert.Equal(new Control[] { control1 }, collection1.Cast<Control>()); 2222Assert.Equal(new Control[] { control2 }, collection2.Cast<Control>()); 2228Assert.Equal(new Control[] { control1 }, collection1.Cast<Control>()); 2229Assert.Equal(new Control[] { control2 }, collection2.Cast<Control>()); 2872Assert.Equal(new Control[] { child1 }, collection.Cast<Control>()); 2966Assert.Equal(new Control[] { child1, child3 }, collection.Cast<Control>()); 2979Assert.Equal(new Control[] { child1 }, collection.Cast<Control>()); 3025Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3029Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3063Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3073Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3083Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3131Assert.Equal(new Control[] { child2, child3, child1 }, collection.Cast<Control>()); 3141Assert.Equal(new Control[] { child2, child3, child1 }, collection.Cast<Control>()); 3191Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3204Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3217Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3276Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3292Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3308Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3365Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3378Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3391Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3467Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 3472Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>()); 3483Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>()); 3488Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>()); 3539Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 3549Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 3559Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());

139Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 154Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 163Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 181Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 203Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 215Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 236Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 264Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 279Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 303Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 326Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 338Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 1549Assert.Equal(new Control[] { child1, child2 }, control.Controls.Cast<Control>()); 1570Assert.Equal(new Control[] { child1, child2 }, control.Controls.Cast<Control>()); 6993Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7008Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7017Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7035Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7057Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7069Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7090Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7118Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7133Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7157Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7180Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7192Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());

45Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 53Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 73Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 81Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 123Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 131Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 197Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 205Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 231Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 239Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 273Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 281Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 292Assert.Equal(new DataGridViewColumn[] { column1, column2, column3 }, collection.Cast<DataGridViewColumn>());

3024Assert.Equal(new DataGridViewRow[] { row2, row1 }, control.SelectedRows.Cast<DataGridViewRow>());

455Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 461Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 468Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 475Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 500Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 506Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 513Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 520Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 544Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 569Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 613Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 638Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 670Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 676Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 683Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 690Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 715Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 721Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 728Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 735Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 759Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 784Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 825Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 832Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 850Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 857Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 914Assert.Equal(Enumerable.Repeat(string.Empty, expectedCount), collection.Keys.Cast<string>()); 932Assert.Equal(Enumerable.Repeat(string.Empty, expectedCount), collection.Keys.Cast<string>()); 1550Assert.Equal(expectedKeys, collection.Keys.Cast<string>()); 1555Assert.Equal(expectedKeys, collection.Keys.Cast<string>()); 1572Assert.Equal(expectedKeys, collection.Keys.Cast<string>()); 1577Assert.Equal(expectedKeys, collection.Keys.Cast<string>());

292Assert.Equal(expected, properties?.Select(p => p.Name)); 296Assert.Equal(expected, properties?.Select(p => p.Name)); 300Assert.Equal(expected, properties?.Select(p => p.Name)); 304Assert.Equal(expected, properties?.Select(p => p.Name)); 308Assert.Equal(expected, properties?.Select(p => p.Name)); 410Assert.Equal(expected, properties?.Select(p => p.Name)); 414Assert.Equal(expected, properties?.Select(p => p.Name)); 418Assert.Equal(expected, properties?.Select(p => p.Name)); 436Assert.Equal(expected, properties?.Select(p => p.Name));

93Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 99Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 105Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 119Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 120Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 125Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 126Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 131Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 132Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 152Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 161Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 170Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 194Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 195Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 203Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 204Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 212Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 213Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 262Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 269Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 276Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 283Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 305Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 306Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 312Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 313Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 319Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 320Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 326Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 327Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 355Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 365Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 375Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 385Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 417Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 418Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 427Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 428Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 437Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 438Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 447Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 448Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 471Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 478Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 499Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 500Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 506Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 507Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 534Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 544Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 575Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 576Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 585Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 586Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 612Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 619Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 643Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 644Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 650Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 651Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 681Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 691Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 725Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 726Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 735Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 736Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1109Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1116Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1153Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1154Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1160Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1161Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1204Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1214Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1267Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1268Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1277Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1278Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1323Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1330Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1360Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1361Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1367Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1368Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1404Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1414Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1457Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1458Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1467Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1468Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1566Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1572Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1578Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1595Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1596Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1601Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1602Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1607Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1608Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 1633Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1642Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1651Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1678Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1679Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1687Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1688Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1696Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1697Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 1760Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1767Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1774Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1781Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1803Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1804Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 1810Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1811Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1817Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1818Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1824Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1825Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1853Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1863Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1873Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1883Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1915Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1916Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 1925Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1926Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1935Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1936Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1945Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1946Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 2346Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2353Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2393Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2394Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2400Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2401Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 2449Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2459Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2515Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2516Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2525Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2526Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 2586Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2593Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2626Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2627Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2633Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2634Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 2675Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2685Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2731Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2732Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2741Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2742Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());

27Assert.Equal(new object[] { 3, 2, 1 }, collection.Cast<object>()); 40Assert.Equal(new object[] { 3, 2, 1 }, collection.Cast<object>()); 169Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 176Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 183Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 190Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 210Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 217Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 224Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 231Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 248Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 249Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 255Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 256Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 262Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 263Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 269Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 270Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 289Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 290Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 296Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 297Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 303Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 304Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 310Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 311Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 512Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 513Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 529Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 530Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 546Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 547Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 563Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 564Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 601Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 602Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 618Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 619Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 635Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 636Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 652Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 653Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 683Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 684Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 691Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 692Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 699Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 700Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 707Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 708Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 732Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 733Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 740Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 741Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 748Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 749Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 756Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 757Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 785Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 786Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 793Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 794Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 801Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 802Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 809Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 810Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 817Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 818Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 825Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 826Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 855Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 856Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 863Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 864Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 871Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 872Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 879Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 880Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 887Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 888Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 895Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 896Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 929Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 930Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 940Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 941Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 951Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 952Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 962Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 963Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1002Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1003Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1013Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1014Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1024Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1025Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1035Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1036Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1079Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1080Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1090Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1091Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1101Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1102Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1112Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1113Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1123Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1124Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1134Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1135Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1179Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1180Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1190Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1191Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1201Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1202Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1212Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1213Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1223Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1224Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1234Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1235Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1307Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1315Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1323Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1331Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1348Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1349Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1356Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1357Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 1364Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1365Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 1372Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1373Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 1392Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1400Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1408Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1416Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1436Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1437Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1444Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1445Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 1452Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1453Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 1460Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1461Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 1483Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1496Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1511Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1528Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1562Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1563Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1575Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1576Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 1590Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1591Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 1607Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1608Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 1644Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1657Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1672Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1689Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1726Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1727Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1739Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1740Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 1754Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1755Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 1771Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1772Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 1802Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1803Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 1810Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1811Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 1834Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1835Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1842Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1843Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1870Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1871Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 1878Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1879Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 1886Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1887Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 1914Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1915Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1921Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1922Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 1928Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1929Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 1955Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1956Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 1966Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1967Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2000Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2001Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2011Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2012Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2049Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2050Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2060Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2061Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2071Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2072Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2109Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2110Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 2120Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2121Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2131Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2132Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2225Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2233Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2249Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2250Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2257Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2258Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2276Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2284Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2303Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2304Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2311Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2312Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2333Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2352Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2385Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2386Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2404Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2405Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2440Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2459Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2495Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2496Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2514Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2515Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2544Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2545Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2552Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2553Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2575Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2576Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2583Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2584Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2610Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2611Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2618Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2619Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2645Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2646Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2652Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2653Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2678Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2679Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2689Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2690Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2722Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2723Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2733Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2734Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2770Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2771Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2781Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2782Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2818Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2819Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2829Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2830Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2882Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2892Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2911Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2912Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2921Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2922Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2943Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2953Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2975Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2976Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2985Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2986Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 3010Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3031Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3067Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3068Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 3088Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3089Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 3127Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3148Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3187Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3188Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 3208Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3209Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 3241Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3242Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3251Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3252Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3277Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3278Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3287Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3288Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3317Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3318Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3327Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3328Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3357Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3358Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3366Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3367Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3395Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3396Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3408Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3409Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3444Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3445Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3457Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3458Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3497Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3498Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3510Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3511Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3550Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3551Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3563Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3564Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3627Assert.Equal(new object[] { 1, 1 }, collection.Cast<object>()); 3640Assert.Equal(new object[] { 1, 2, 1 }, collection.Cast<object>()); 4130Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4138Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4146Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4154Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4171Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4172Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4179Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4180Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 4187Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4188Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 4195Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4196Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 4215Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4223Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4231Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4239Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4259Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4260Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4267Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4268Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 4275Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4276Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 4283Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4284Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 4306Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4319Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4334Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4351Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4385Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4386Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4398Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4399Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 4413Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4414Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 4430Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4431Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 4467Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4480Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4495Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4512Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4549Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4550Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4562Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4563Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 4577Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4578Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 4594Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4595Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 4625Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4626Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4633Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4634Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4655Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4656Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4661Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4662Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4687Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4688Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4695Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4696Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4703Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4704Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4729Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4730Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 4736Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4737Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 4743Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4744Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 4770Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4771Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4781Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4782Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4815Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4816Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4826Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4827Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4864Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4865Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4875Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4876Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4886Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4887Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4924Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4925Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 4935Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4936Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 4946Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4947Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 5069Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5077Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5085Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5113Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5114Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5120Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5121Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5127Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5128Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 5159Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5167Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5175Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5206Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5207Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5213Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5214Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5220Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5221Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 5253Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5268Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5283Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5327Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5328Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5343Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5344Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5359Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5360Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 5405Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5420Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5435Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5482Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5483Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5498Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5499Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5514Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5515Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 5552Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5553Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5560Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5561Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5593Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5594Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5601Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5602Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5638Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5639Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5646Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5647Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5654Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5655Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5690Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5691Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5698Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5699Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5706Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5707Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5747Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5748Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5758Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5759Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5809Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5810Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5820Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5821Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5870Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5871Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5880Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5881Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5890Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5891Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5938Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5939Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5948Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5949Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5958Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5959Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6016Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6024Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6052Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6053Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 6059Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6060Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 6091Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6099Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6130Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6131Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 6137Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6138Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 6170Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6185Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6229Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6230Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 6245Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6246Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 6291Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6306Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6353Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6354Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 6369Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6370Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 6407Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6408Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6415Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6416Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6448Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6449Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6456Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6457Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6493Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6494Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6501Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6502Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6509Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6510Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6545Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6546Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6553Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6554Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6561Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6562Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6602Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6603Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6613Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6614Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6664Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6665Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6675Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6676Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6725Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6726Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6735Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6736Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6745Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6746Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6793Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6794Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6803Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6804Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6813Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6814Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6958Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 6965Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 6972Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 6979Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7003Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7010Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7017Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7024Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7043Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7044Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7050Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7051Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7057Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7058Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7064Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7065Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7086Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7087Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7093Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7094Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7100Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7101Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7107Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7108Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7315Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7316Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7332Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7333Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7349Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7350Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7366Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7367Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7406Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7407Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7423Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7424Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7440Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7441Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7457Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7458Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7488Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7489Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7496Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7497Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7504Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7505Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7512Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7513Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7537Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7538Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7545Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7546Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7553Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7554Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7561Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7562Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7590Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7591Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7598Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7599Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7606Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7607Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7614Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7615Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7622Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7623Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7630Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7631Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7660Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7661Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7668Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7669Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7676Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7677Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7684Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7685Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7692Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7693Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7700Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7701Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7734Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7735Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7745Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7746Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7756Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7757Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7767Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7768Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7807Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7808Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7818Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7819Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7829Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7830Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7840Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7841Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7884Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7885Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7895Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7896Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7906Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7907Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7917Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7918Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7928Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7929Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7939Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7940Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7984Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7985Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7995Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7996Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8006Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 8007Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8017Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 8018Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8028Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 8029Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8039Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 8040Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8112Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8120Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8128Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8136Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8153Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8154Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8161Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8162Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 8169Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8170Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 8177Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8178Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 8197Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8205Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8213Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8221Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8241Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8242Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8249Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8250Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 8257Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8258Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 8265Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8266Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 8288Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8301Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8316Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8333Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8367Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8368Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8380Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8381Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 8395Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8396Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 8412Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8413Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 8449Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8462Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8477Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8494Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8531Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8532Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8544Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8545Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 8559Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8560Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 8576Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8577Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 8607Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8608Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8615Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8616Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8639Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8640Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8647Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8648Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8675Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8676Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8683Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8684Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8691Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8692Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8719Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8720Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8726Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8727Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 8733Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8734Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 8760Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8761Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8771Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8772Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8805Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8806Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8816Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8817Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8854Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8855Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8865Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8866Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8876Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8877Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8914Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8915Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8925Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8926Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 8936Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8937Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 9452Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9460Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9468Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9476Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9493Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9494Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9501Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9502Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 9509Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9510Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 9517Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9518Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 9537Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9545Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9553Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9561Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9581Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9582Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9589Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9590Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 9597Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9598Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 9605Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9606Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 9628Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9641Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9656Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9673Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9707Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9708Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9720Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9721Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 9735Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9736Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 9752Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9753Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 9789Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9802Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9817Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9834Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9871Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9872Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9884Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9885Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 9899Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9900Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 9916Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9917Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 9947Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9948Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 9955Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9956Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 9977Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9978Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 9983Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9984Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 10009Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10010Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10017Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10018Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10025Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10026Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10051Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10052Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 10058Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10059Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10065Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10066Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10092Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10093Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10103Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10104Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10137Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10138Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 10148Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10149Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 10186Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10187Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10197Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10198Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10208Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10209Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10246Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10247Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 10257Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10258Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10268Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10269Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10391Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10399Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10407Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10435Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10436Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10442Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10443Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10449Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10450Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 10481Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10489Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10497Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10528Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10529Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10535Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10536Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10542Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10543Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 10575Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10590Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10605Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10649Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10650Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10665Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10666Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10681Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10682Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 10727Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10742Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10757Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10804Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10805Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10820Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10821Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10836Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10837Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 10874Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10875Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10882Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10883Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10915Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10916Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10923Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10924Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10960Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10961Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10968Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10969Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10976Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 10977Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11012Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11013Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11020Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11021Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11028Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11029Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11069Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11070Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11080Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11081Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11131Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11132Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11142Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11143Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11192Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11193Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11202Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11203Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11212Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11213Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11260Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11261Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11270Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11271Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11280Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11281Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11338Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11346Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11374Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11375Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 11381Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11382Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 11413Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11421Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11452Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11453Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 11459Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11460Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 11492Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11507Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11551Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11552Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 11567Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11568Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 11613Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11628Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11675Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11676Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 11691Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11692Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 11729Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11730Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11737Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11738Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11770Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11771Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11778Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11779Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11815Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11816Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11823Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11824Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11831Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11832Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11867Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11868Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11875Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11876Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11883Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11884Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11924Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11925Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11935Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11936Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11986Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11987Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11997Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11998Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 12047Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12048Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12057Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12058Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12067Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 12068Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 12115Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12116Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12125Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12126Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12135Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 12136Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());

1089Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1097Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1178Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1189Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1516Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1522Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1528Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1612Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1621Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1630Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 2422Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 2423Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 2597Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 2598Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 2904Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 2905Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 3110Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3111Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 3314Assert.Equal(new int[] { 2 }, control.SelectedIndices.Cast<int>()); 3320Assert.Equal(new int[] { 0, 2 }, control.SelectedIndices.Cast<int>()); 3511Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3512Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3520Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3521Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3529Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3530Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3553Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3554Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3562Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3563Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3571Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3572Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3974Assert.Equal(expected, control.Items.Cast<string>()); 3980Assert.Equal(expected, control.Items.Cast<string>()); 3986Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<string>()); 4088Assert.Equal(expected, control.Items.Cast<string>()); 4097Assert.Equal(expected, control.Items.Cast<string>()); 4106Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<string>()); 4561Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<object>()); 4566Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4571Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4576Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4594Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<object>()); 4602Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4610Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4618Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 5904Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 5909Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 5956Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 5964Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 6021Assert.Equal(value, control.Items.Cast<object>()); 6026Assert.Equal(value, control.Items.Cast<object>()); 6044Assert.Equal(value, control.Items.Cast<object>()); 6052Assert.Equal(value, control.Items.Cast<object>()); 6074Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());

380Assert.Equal(new ListViewGroup[] { group1, group2 }, collection.Cast<ListViewGroup>()); 399Assert.Equal(new ListViewGroup[] { group1, group2 }, collection.Cast<ListViewGroup>());

283Assert.Equal(expected, converter.GetStandardValues(mockContext.Object)?.Cast<object>());

1350Assert.Equal(group.Items.Cast<ListViewItem>().Select(i => i.Text), result.Items.Cast<ListViewItem>().Select(i => i.Text));

878Assert.Equal(new ListViewItem[] { item1, item2 }, listView.Items.Cast<ListViewItem>()); 1051Assert.Equal(new ListViewItem[] { item1, item2 }, listView.Items.Cast<ListViewItem>());

73Assert.Equal(expected, converter.GetStandardValues(null).Cast<Environment.SpecialFolder>()); 82Assert.Equal(new Environment.SpecialFolder[] { Environment.SpecialFolder.Personal }, converter.GetStandardValues(null).Cast<Environment.SpecialFolder>()); 91Assert.Equal(new CustomEnum[] { CustomEnum.Value }, converter.GetStandardValues(null).Cast<CustomEnum>());

86Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 87Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 114Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 115Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 225Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 226Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 266Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 267Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 386Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 387Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 420Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 421Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 543Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 544Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 590Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 591Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 741Assert.Equal(items, collection.Cast<Control>()); 742Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 1367Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 1372Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 1377Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 1405Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 1410Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 1415Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 1436Assert.Equal(items, collection.Cast<Control>()); 1437Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 1445Assert.Equal(items, collection.Cast<Control>()); 1446Assert.Equal(items, owner.TabPages.Cast<TabPage>());

72Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 73Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 74Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 101Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 102Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 103Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 214Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 215Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 216Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 256Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 257Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 258Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 378Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 379Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 380Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 413Assert.Equal(new TabPage[] { value1, value2, value1, }, collection.Cast<TabPage>()); 414Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 415Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 538Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 539Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 540Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 586Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 587Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 588Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 744Assert.Equal(items, collection.Cast<TabPage>()); 745Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 746Assert.Equal(items, owner.Controls.Cast<Control>()); 1019Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 1020Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 1047Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 1048Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 1114Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>()); 1126Assert.Equal(new TabPage[] { child1, child2, child3, child1, child2, child3 }, collection.Cast<TabPage>()); 1139Assert.Equal(new TabPage[] { child1, child2, child3, child1, child2, child3 }, collection.Cast<TabPage>()); 2014Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2015Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2016Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2045Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2046Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2047Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2151Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2152Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2153Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2195Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2196Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2197Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2321Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2322Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2323Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2358Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2359Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2360Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2487Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2488Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2489Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2537Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2538Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2539Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2694Assert.Equal(items, collection.Cast<TabPage>()); 2695Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 2696Assert.Equal(items, owner.Controls.Cast<TabPage>()); 3060Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 3061Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 3062Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 3091Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 3092Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 3093Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 3378Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3423Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3463Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3519Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3777Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3821Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3860Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3915Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 4471Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 4476Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 4481Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 4511Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 4516Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 4521Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 4542Assert.Equal(items, collection.Cast<TabPage>()); 4543Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 4551Assert.Equal(items, collection.Cast<TabPage>()); 4552Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 4838Assert.Equal(new TabPage[] { child1 }, collection.Cast<TabPage>()); 4932Assert.Equal(new TabPage[] { child1, child3 }, collection.Cast<TabPage>()); 4945Assert.Equal(new TabPage[] { child1 }, collection.Cast<TabPage>()); 4991Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>()); 4995Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>());

2134Assert.Equal(expectedVisible, control.TabPages.Cast<TabPage>().Select(p => p.Visible)); 2143Assert.Equal(expectedVisible, control.TabPages.Cast<TabPage>().Select(p => p.Visible)); 4889Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>()); 4890Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>()); 4897Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>()); 4898Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>()); 4906Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>()); 4907Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>());

62Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 67Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>()); 78Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>()); 83Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>()); 93Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>());

341Assert.Equal(expectedDropDownItems, item.DropDownItems.Cast<ToolStripItem>());

3580Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>()); 3599Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>());

273Assert.Equal(items, control.Items.Cast<ToolStripItem>()); 4734Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>()); 4753Assert.Equal(new ToolStripItem[] { item1, item2 }, control.Items.Cast<ToolStripItem>());

125Assert.Equal(children, node.Nodes.Cast<TreeNode>()); 216Assert.Equal(children, node.Nodes.Cast<TreeNode>());

217Assert.Equal(new Type[] { typeof(string) }, Assert.IsAssignableFrom<ConstructorInfo>(descriptor.MemberInfo).GetParameters().Select(p => p.ParameterType));

178Assert.Equal(new Type[] { typeof(Type) }, Assert.IsAssignableFrom<ConstructorInfo>(descriptor.MemberInfo).GetParameters().Select(p => p.ParameterType));

219Assert.Equal(new[] { "test.cs" }, _parsedArgs); 230Assert.Equal(new[] { "test.cs" }, _parsedArgs); 235Assert.Equal(new[] { "test.cs" }, _parsedArgs); 240Assert.Equal(new[] { "test.cs" }, _parsedArgs); 260Assert.Equal(new[] { optionPrefix + "sharedstart", "test.cs" }, _parsedArgs); 271Assert.Equal(new[] { "test.cs" }, _parsedArgs); 277Assert.Equal(new[] { "test.cs" }, _parsedArgs); 305Assert.Equal(new[] { optionPrefix + "keepalivestart", "test.cs" }, _parsedArgs); 315Assert.Equal(new[] { "test.cs" }, _parsedArgs); 321Assert.Equal(new[] { "test.cs" }, _parsedArgs);