181Assert.Equal(types, typeSelect.Instance.Values.ToImmutableSortedDictionary() /* sort for equality comparison */ ); 184Assert.Equal(states, stateSelect.Instance.Values.ToImmutableSortedDictionary() /* sort for equality comparison */); 187Assert.Equal(healthStates, healthSelect.Instance.Values.ToImmutableSortedDictionary() /* sort for equality comparison */);

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

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

790Assert.Equal(new[] { "text/xml" }, GetSortedMediaTypes(responseType)); 797Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 803Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType));

738Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 752Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 759Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 855Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 862Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 911Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 925Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 932Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 981Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 995Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1002Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1051Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1058Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1065Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1072Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1179Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1199Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType));

1045Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 1051Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 1057Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 1063Assert.Equal(new[] { "application/problem+json" }, GetSortedMediaTypes(responseType)); 1095Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 1101Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 1195Assert.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));

542Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 564Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 586Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 798Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 804Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 833Assert.Equal(new[] { "text/plain" }, GetSortedMediaTypes(responseType)); 839Assert.Equal(new[] { "application/json" }, GetSortedMediaTypes(responseType)); 939Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1256Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1289Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1295Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1320Assert.Equal(expectedMediaTypes, actualMediaTypes); 1351Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1386Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1421Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1456Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1462Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1496Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1502Assert.Equal(expectedMediaTypes, GetSortedMediaTypes(responseType)); 1533Assert.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);

632Assert.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); 11017Assert.Equal(new[] { "Attr<System.Int32>" }, GetAttributeStrings(attrs)); 11152Assert.Equal(new[] { "Attr<System.String>(Prop = \"a\")" }, GetAttributeStrings(attrs)); 11246Assert.Equal(new[] { "Attr<System.String>(\"a\")" }, GetAttributeStrings(attrs)); 11297Assert.Equal(new[] 11310Assert.Equal(new[] 11369Assert.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); 2376Assert.Equal(new (object, IncrementalStepRunReason)[] 2397Assert.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);

3104Assert.Equal(

1106Assert.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))

211Assert.Equal(expectedDuplicates, duplicates);

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

698Assert.Equal(columnName, new[] { "vendor_id", "rate_code", "passenger_count", "trip_time_in_secs", "Column4", "Column5", "Column6", "Column7" }); 713Assert.Equal(columnName, new[] { "vendor_id", "rate_code", "passenger_count", "trip_time_in_secs", "Column0", "Column1", "Column2", "Column3" }); 1379Assert.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);

66Assert.Equal(embeddings, generatedEmbeddings);

209Assert.Equal(new Dictionary<string, long> 569Assert.Equal(new Dictionary<string, long> 670Assert.Equal(new Dictionary<string, long> 905Assert.Equal(new Dictionary<string, long> 1046Assert.Equal(new Dictionary<string, long>

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,

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

310Assert.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(

154Assert.Equal(new List<Range> { new Range(0, 5), new Range(5, 11) }, offsets); 208Assert.Equal(new List<(int, int)> { (0, 12), (12, 5), (17, 6), (23, 10) }, offsets); 251Assert.Equal(new List<(int, int)> { (0, 12), (12, 5), (17, 10), (27, 6) }, offsets); 281Assert.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()); 316Assert.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()); 602Assert.Equal(expectedIds.Take(expectedIds.Length - 4), tokenizer.EncodeToIds(text, expectedIds.Length - 4, out normalizedText, out length)); 606Assert.Equal(expectedIds.Take(expectedIds.Length - 4), tokenizer.EncodeToIds(text.AsSpan(), expectedIds.Length - 4, out normalizedText, out length)); 700Assert.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));

361Assert.Equal(ids, extracted.Ids); 362Assert.Equal(tokens, extracted.Tokens); 363Assert.Equal(offsets, extracted.Offsets); 462Assert.Equal(expectedIds, extracted.Ids); 470Assert.Equal(expectedTokens, extracted.Tokens); 482Assert.Equal(expectedIds, extracted.Ids); 490Assert.Equal(expectedTokens, extracted.Tokens); 519Assert.Equal(ids, ints); 527Assert.Equal(shiftedIds, ints); 535Assert.Equal(ids, ints); 543Assert.Equal(shiftedIds, ints); 552Assert.Equal(ids, ints); 561Assert.Equal(shiftedIds, ints); 570Assert.Equal(ids, ints); 579Assert.Equal(shiftedIds, ints); 584Assert.Equal(ids.Take(i), result); 588Assert.Equal(shiftedIds.Take(i), result); 592Assert.Equal(ids.Take(i), result); 596Assert.Equal(shiftedIds.Take(i), result); 609Assert.Equal(ids.Take(i - 1), ints); // Exclude the counted BoS token 625Assert.Equal(shiftedIds.Take(i - 1), ints); // Exclude the counted BoS token 641Assert.Equal(ids.Take(i - 1), ints); // Exclude the counted BoS token 657Assert.Equal(shiftedIds.Take(i - 1), ints); // Exclude the counted BoS token 676Assert.Equal(expectedIds.Take(i), result); 680Assert.Equal(expectedIds.Take(i), result); 695Assert.Equal(expectedIds.Take(i), result); 699Assert.Equal(expectedIds.Take(i), result); 721Assert.Equal(ids, ids1.Concat(ids2).ToList()); 727Assert.Equal(shiftedIds, ids1.Concat(ids2).ToList()); 733Assert.Equal(ids, ids1.Concat(ids2).ToList()); 739Assert.Equal(shiftedIds, ids1.Concat(ids2).ToList()); 745Assert.Equal(ids, ids1.Concat(ids2).ToList()); 751Assert.Equal(shiftedIds, ids1.Concat(ids2).ToList()); 757Assert.Equal(ids, ids1.Concat(ids2).ToList()); 763Assert.Equal(shiftedIds, ids1.Concat(ids2).ToList());

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

657Assert.Equal(

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

28Assert.Equal(value, collection.Cast<object>()); 51Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>()); 56Assert.Equal(new object[] { value1, value2, null }, collection.Cast<object>()); 67Assert.Equal(value, collection.Cast<object>()); 71Assert.Equal(value.Concat(value), collection.Cast<object>()); 80Assert.Equal(value, collection.Cast<object>()); 84Assert.Equal(value.Concat(value), collection.Cast<object>()); 109Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>()); 114Assert.Equal(new object[] { value2, null, value1 }, collection.Cast<object>());

293Assert.Equal(new IComponent[] { component1, component2 }, host.Container.Components.Cast<IComponent>()); 304Assert.Equal(new IComponent[] { component1, component2, component3 }, host.Container.Components.Cast<IComponent>()); 315Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, host.Container.Components.Cast<IComponent>()); 348Assert.Equal(new IComponent[] { component1, component2 }, host.Container.Components.Cast<IComponent>()); 359Assert.Equal(new IComponent[] { component1, component2, component3 }, host.Container.Components.Cast<IComponent>()); 370Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, host.Container.Components.Cast<IComponent>());

28Assert.Equal(value, collection.Cast<object>()); 51Assert.Equal(new object[] { value1, value2 }, collection.Cast<object>()); 56Assert.Equal(new object[] { value1, value2, null }, collection.Cast<object>()); 67Assert.Equal(value, collection.Cast<object>()); 71Assert.Equal(value.Concat(value), collection.Cast<object>()); 80Assert.Equal(value, collection.Cast<object>()); 84Assert.Equal(value.Concat(value), collection.Cast<object>()); 109Assert.Equal(new object[] { value2, value1 }, collection.Cast<object>()); 114Assert.Equal(new object[] { value2, null, value1 }, collection.Cast<object>());

91Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 101Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 195Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 206Assert.Equal(new IComponent[] { component1, component2, component3 }, container.Components.Cast<IComponent>()); 217Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, container.Components.Cast<IComponent>()); 252Assert.Equal(new IComponent[] { component1, component2 }, container.Components.Cast<IComponent>()); 263Assert.Equal(new IComponent[] { component1, component2, component3 }, container.Components.Cast<IComponent>()); 274Assert.Equal(new IComponent[] { component1, component2, component3, component4 }, container.Components.Cast<IComponent>());

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

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

38Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 62Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 79Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 86Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name)); 102Assert.Equal(new string[] { "EnableInSituEditing", "GridSize", "ObjectBoundSmartTagAutoShow", "ShowGrid", "SnapToGrid", "UseOptimizedCodeGeneration", "UseSmartTags", "UseSnapLines" }, childCollection.Properties.Sort().Cast<PropertyDescriptor>().Select(p => p.Name));

287Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 292Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 339Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 347Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());

265Assert.Equal(properties, binaryFormattedProperties);

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

69Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 84Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 99Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 145Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 150Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>()); 161Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>()); 166Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>()); 176Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>()); 291Assert.Equal(new Control[] { control1 }, collection.Cast<Control>()); 301Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 315Assert.Equal(new Control[] { control1, control2, control3 }, collection.Cast<Control>()); 1232Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1246Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1259Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1358Assert.Equal(new Control[] { child1, child2, child3 }, sourceCollection.Cast<Control>()); 1359Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 1940Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 1950Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 1960Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2004Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2015Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2026Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2074Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2087Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2100Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2156Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2172Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2188Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 2223Assert.Equal(new Control[] { control1 }, collection1.Cast<Control>()); 2224Assert.Equal(new Control[] { control2 }, collection2.Cast<Control>()); 2230Assert.Equal(new Control[] { control1 }, collection1.Cast<Control>()); 2231Assert.Equal(new Control[] { control2 }, collection2.Cast<Control>()); 2874Assert.Equal(new Control[] { child1 }, collection.Cast<Control>()); 2968Assert.Equal(new Control[] { child1, child3 }, collection.Cast<Control>()); 2981Assert.Equal(new Control[] { child1 }, collection.Cast<Control>()); 3027Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3031Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3065Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3075Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3085Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3133Assert.Equal(new Control[] { child2, child3, child1 }, collection.Cast<Control>()); 3143Assert.Equal(new Control[] { child2, child3, child1 }, collection.Cast<Control>()); 3193Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3206Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3219Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3278Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3294Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3310Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3367Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3380Assert.Equal(new Control[] { child2, child1, child3 }, collection.Cast<Control>()); 3393Assert.Equal(new Control[] { child1, child2, child3 }, collection.Cast<Control>()); 3469Assert.Equal(new Control[] { control1, control2 }, collection.Cast<Control>()); 3474Assert.Equal(new Control[] { control1, control2 }, owner.Controls.Cast<Control>()); 3485Assert.Equal(new Control[] { control2, control1 }, collection.Cast<Control>()); 3490Assert.Equal(new Control[] { control2, control1 }, owner.Controls.Cast<Control>()); 3541Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 3551Assert.Equal(new Control[] { child2 }, collection.Cast<Control>()); 3561Assert.Equal(new Control[] { child2 }, collection.Cast<Control>());

141Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 156Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 165Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 183Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 205Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 217Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 238Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 266Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 281Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 305Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 328Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 340Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 1551Assert.Equal(new Control[] { child1, child2 }, control.Controls.Cast<Control>()); 1572Assert.Equal(new Control[] { child1, child2 }, control.Controls.Cast<Control>()); 6995Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7010Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7019Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7037Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7059Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7071Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7092Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7120Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7135Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7159Assert.Equal(new Control[] { child1, child2 }, parent.Controls.Cast<Control>()); 7182Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>()); 7194Assert.Equal(new Control[] { child2, child1 }, parent.Controls.Cast<Control>());

47Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 55Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 75Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 83Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 125Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 133Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 199Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 207Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 233Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 241Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 275Assert.Equal(new DataGridViewColumn[] { column1 }, collection.Cast<DataGridViewColumn>()); 283Assert.Equal(new DataGridViewColumn[] { column1, column2 }, collection.Cast<DataGridViewColumn>()); 294Assert.Equal(new DataGridViewColumn[] { column1, column2, column3 }, collection.Cast<DataGridViewColumn>());

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

457Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 463Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 470Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 477Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 502Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 508Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 515Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 522Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 546Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 571Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 615Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 640Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 672Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 678Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 685Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 692Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 717Assert.Equal(new string[] { "Key1", "Key2" }, collection.Keys.Cast<string>()); 723Assert.Equal(new string[] { "Key1", "Key2", "Key1" }, collection.Keys.Cast<string>()); 730Assert.Equal(new string[] { "Key1", "Key2", "Key1", "" }, collection.Keys.Cast<string>()); 737Assert.Equal(new string[] { "Key1", "Key2", "Key1", string.Empty, string.Empty }, collection.Keys.Cast<string>()); 761Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 786Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 827Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 834Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 852Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 859Assert.Equal(new string[] { string.Empty, string.Empty }, collection.Keys.Cast<string>()); 916Assert.Equal(Enumerable.Repeat(string.Empty, expectedCount), collection.Keys.Cast<string>()); 934Assert.Equal(Enumerable.Repeat(string.Empty, expectedCount), collection.Keys.Cast<string>()); 1552Assert.Equal(expectedKeys, collection.Keys.Cast<string>()); 1557Assert.Equal(expectedKeys, collection.Keys.Cast<string>()); 1574Assert.Equal(expectedKeys, collection.Keys.Cast<string>()); 1579Assert.Equal(expectedKeys, collection.Keys.Cast<string>());

294Assert.Equal(expected, properties?.Select(p => p.Name)); 298Assert.Equal(expected, properties?.Select(p => p.Name)); 302Assert.Equal(expected, properties?.Select(p => p.Name)); 306Assert.Equal(expected, properties?.Select(p => p.Name)); 310Assert.Equal(expected, properties?.Select(p => p.Name)); 412Assert.Equal(expected, properties?.Select(p => p.Name)); 416Assert.Equal(expected, properties?.Select(p => p.Name)); 420Assert.Equal(expected, properties?.Select(p => p.Name)); 438Assert.Equal(expected, properties?.Select(p => p.Name));

95Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 101Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 107Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 121Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 122Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 127Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 128Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 133Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 134Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 154Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 163Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 172Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 196Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 197Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 205Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 206Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 214Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 215Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 264Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 271Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 278Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 285Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 307Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 308Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 314Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 315Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 321Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 322Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 328Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 329Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 357Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 367Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 377Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 387Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 419Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 420Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 429Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 430Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 439Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 440Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 449Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 450Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 473Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 480Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 501Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 502Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 508Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 509Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 536Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 546Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 577Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 578Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 587Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 588Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 614Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 621Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 645Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 646Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 652Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 653Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 683Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 693Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 727Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 728Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 737Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 738Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1111Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1118Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1155Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1156Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1162Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1163Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1206Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1216Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1269Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1270Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1279Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1280Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1325Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1332Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1362Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1363Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1369Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1370Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1406Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1416Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1459Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 1460Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1469Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 1470Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 1568Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1574Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1580Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1597Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1598Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1603Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1604Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1609Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1610Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 1635Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1644Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1653Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1680Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 1681Assert.Equal(new int[] { 4, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1689Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 1690Assert.Equal(new int[] { 4, 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 1698Assert.Equal(new int[] { 4, 1, 4 }, collection.Cast<int>()); 1699Assert.Equal(new int[] { 4, 1, 4 }, owner.CustomTabOffsets.Cast<int>()); 1762Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1769Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1776Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1783Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1805Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1806Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 1812Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1813Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1819Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1820Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1826Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1827Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 1855Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1865Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1875Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1885Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1917Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 1918Assert.Equal(new int[] { 2 }, owner.CustomTabOffsets.Cast<int>()); 1927Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1928Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1937Assert.Equal(new int[] { 1, 2 }, collection.Cast<int>()); 1938Assert.Equal(new int[] { 1, 2 }, owner.CustomTabOffsets.Cast<int>()); 1947Assert.Equal(new int[] { 1, 2, 3 }, collection.Cast<int>()); 1948Assert.Equal(new int[] { 1, 2, 3 }, owner.CustomTabOffsets.Cast<int>()); 2348Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2355Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2395Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2396Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2402Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2403Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 2451Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2461Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2517Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2518Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2527Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2528Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 2588Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2595Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2628Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2629Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2635Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2636Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>()); 2677Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2687Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2733Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 2734Assert.Equal(new int[] { 1, 3 }, owner.CustomTabOffsets.Cast<int>()); 2743Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 2744Assert.Equal(new int[] { 1 }, owner.CustomTabOffsets.Cast<int>());

29Assert.Equal(new object[] { 3, 2, 1 }, collection.Cast<object>()); 42Assert.Equal(new object[] { 3, 2, 1 }, collection.Cast<object>()); 171Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 178Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 185Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 192Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 212Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 219Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 226Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 233Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 250Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 251Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 257Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 258Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 264Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 265Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 271Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 272Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 291Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 292Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 298Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 299Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 305Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 306Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 312Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 313Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 514Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 515Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 531Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 532Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 548Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 549Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 565Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 566Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 603Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 604Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 620Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 621Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 637Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 638Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 654Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 655Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 685Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 686Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 693Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 694Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 701Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 702Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 709Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 710Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 734Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 735Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 742Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 743Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 750Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 751Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 758Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 759Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 787Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 788Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 795Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 796Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 803Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 804Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 811Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 812Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 819Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 820Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 827Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 828Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 857Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 858Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 865Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 866Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 873Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 874Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 881Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 882Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 889Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 890Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 897Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 898Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 931Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 932Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 942Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 943Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 953Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 954Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 964Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 965Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1004Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1005Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1015Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1016Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1026Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1027Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1037Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1038Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1081Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1082Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1092Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1093Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1103Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1104Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1114Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1115Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1125Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1126Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1136Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1137Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1181Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1182Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1192Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1193Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1203Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1204Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1214Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 1215Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1225Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1226Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1236Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 1237Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1309Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1317Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1325Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1333Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1350Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1351Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1358Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1359Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 1366Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1367Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 1374Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1375Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 1394Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1402Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1410Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1418Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1438Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1439Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1446Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1447Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 1454Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1455Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 1462Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1463Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 1485Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1498Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1513Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1530Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1564Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1565Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1577Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 1578Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 1592Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 1593Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 1609Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 1610Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 1646Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1659Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1674Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1691Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1728Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 1729Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 1741Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 1742Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 1756Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 1757Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 1773Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 1774Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 1804Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1805Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 1812Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1813Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 1836Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1837Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1844Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1845Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 1872Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1873Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 1880Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1881Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 1888Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1889Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 1916Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1917Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 1923Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1924Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 1930Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 1931Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 1957Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1958Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 1968Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 1969Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2002Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2003Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2013Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2014Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2051Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2052Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2062Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2063Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2073Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2074Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2111Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2112Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 2122Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2123Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2133Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2134Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2227Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2235Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2251Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2252Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2259Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2260Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2278Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2286Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2305Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2306Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2313Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2314Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2335Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2354Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2387Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2388Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2406Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2407Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2442Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2461Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2497Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2498Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2516Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2517Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2546Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2547Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2554Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2555Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2577Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2578Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2585Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2586Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2612Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2613Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2620Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2621Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2647Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2648Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2654Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2655Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2680Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2681Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2691Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2692Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 2724Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2725Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2735Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 2736Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 2772Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2773Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2783Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2784Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 2820Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2821Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2831Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 2832Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 2884Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2894Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2913Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2914Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2923Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 2924Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 2945Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2955Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2977Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2978Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 2987Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 2988Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 3012Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3033Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3069Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3070Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 3090Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 3091Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 3129Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3150Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3189Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3190Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 3210Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 3211Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 3243Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3244Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3253Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3254Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3279Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3280Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3289Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3290Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3319Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3320Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3329Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3330Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3359Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3360Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3368Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3369Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3397Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3398Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3410Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3411Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 3446Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3447Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3459Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 3460Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 3499Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3500Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3512Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3513Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 3552Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3553Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3565Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 3566Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 3629Assert.Equal(new object[] { 1, 1 }, collection.Cast<object>()); 3642Assert.Equal(new object[] { 1, 2, 1 }, collection.Cast<object>()); 4132Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4140Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4148Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4156Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4173Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4174Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4181Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4182Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 4189Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4190Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 4197Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4198Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 4217Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4225Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4233Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4241Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4261Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4262Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4269Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4270Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 4277Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4278Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 4285Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4286Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 4308Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4321Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4336Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4353Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4387Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4388Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4400Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 4401Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 4415Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 4416Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 4432Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 4433Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 4469Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4482Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4497Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4514Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4551Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 4552Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 4564Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 4565Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 4579Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 4580Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 4596Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 4597Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 4627Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4628Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4635Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4636Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4657Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4658Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4663Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4664Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4689Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4690Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4697Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4698Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4705Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4706Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4731Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4732Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 4738Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4739Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 4745Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4746Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 4772Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4773Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4783Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4784Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 4817Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4818Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4828Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 4829Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 4866Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4867Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4877Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4878Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4888Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4889Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 4926Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4927Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 4937Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4938Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 4948Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 4949Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 5071Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5079Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5087Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5115Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5116Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5122Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5123Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5129Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5130Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 5161Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5169Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5177Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5208Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5209Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5215Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5216Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5222Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5223Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 5255Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5270Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5285Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5329Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5330Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5345Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 5346Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 5361Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 5362Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 5407Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5422Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5437Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5484Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5485Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5500Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 5501Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 5516Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 5517Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 5554Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5555Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5562Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5563Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5595Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5596Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5603Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5604Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5640Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5641Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5648Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5649Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5656Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5657Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5692Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5693Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5700Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5701Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5708Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5709Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5749Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5750Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5760Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5761Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5811Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5812Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5822Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 5823Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5872Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5873Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5882Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5883Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5892Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5893Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 5940Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5941Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5950Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 5951Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 5960Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 5961Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6018Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6026Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6054Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6055Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 6061Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6062Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 6093Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6101Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6132Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6133Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 6139Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6140Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 6172Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6187Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6231Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 6232Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 6247Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 6248Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 6293Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6308Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6355Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 6356Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 6371Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 6372Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 6409Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6410Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6417Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6418Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6450Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6451Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6458Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6459Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6495Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6496Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6503Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6504Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6511Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6512Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6547Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6548Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6555Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6556Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6563Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6564Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6604Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6605Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6615Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6616Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6666Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6667Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6677Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 6678Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6727Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6728Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6737Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6738Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6747Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6748Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6795Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6796Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6805Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 6806Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 6815Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 6816Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 6960Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 6967Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 6974Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 6981Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7005Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7012Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7019Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7026Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7045Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7046Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7052Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7053Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7059Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7060Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7066Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7067Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7088Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7089Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7095Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7096Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7102Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7103Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7109Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7110Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7317Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7318Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7334Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7335Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7351Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7352Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7368Assert.Equal(new int[] { 4, 2, 5 }, collection.Cast<int>()); 7369Assert.Equal(new int[] { 4, 2, 5 }, owner.Items.Cast<int>()); 7408Assert.Equal(new int[] { 4, 2, 3 }, collection.Cast<int>()); 7409Assert.Equal(new int[] { 4, 2, 3 }, owner.Items.Cast<int>()); 7425Assert.Equal(new int[] { 4, 1, 3 }, collection.Cast<int>()); 7426Assert.Equal(new int[] { 4, 1, 3 }, owner.Items.Cast<int>()); 7442Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7443Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7459Assert.Equal(new int[] { 4, 1, 5 }, collection.Cast<int>()); 7460Assert.Equal(new int[] { 4, 1, 5 }, owner.Items.Cast<int>()); 7490Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7491Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7498Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7499Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7506Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7507Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7514Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7515Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7539Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7540Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7547Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7548Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7555Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7556Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7563Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7564Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7592Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7593Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7600Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7601Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7608Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7609Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7616Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7617Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7624Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7625Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7632Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7633Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7662Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7663Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7670Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7671Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7678Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7679Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7686Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7687Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7694Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7695Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7702Assert.Equal(new object[] { 2, 4 }, owner.SelectedItems.Cast<object>()); 7703Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7736Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7737Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7747Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7748Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7758Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7759Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7769Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7770Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7809Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7810Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7820Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 7821Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7831Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7832Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7842Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7843Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7886Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7887Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7897Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7898Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7908Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7909Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7919Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 7920Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7930Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7931Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7941Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 7942Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 7986Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7987Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 7997Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 7998Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8008Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 8009Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8019Assert.Equal(new object[] { 2, 3 }, owner.SelectedItems.Cast<object>()); 8020Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8030Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 8031Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8041Assert.Equal(new object[] { 2 }, owner.SelectedItems.Cast<object>()); 8042Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8114Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8122Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8130Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8138Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8155Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8156Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8163Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8164Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 8171Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8172Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 8179Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8180Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 8199Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8207Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8215Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8223Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8243Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8244Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8251Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8252Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 8259Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8260Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 8267Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8268Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 8290Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8303Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8318Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8335Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8369Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8370Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8382Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 8383Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 8397Assert.Equal(new object[] { 2, 1, 1 }, collection.Cast<object>()); 8398Assert.Equal(new object[] { 2, 1, 1 }, owner.Items.Cast<object>()); 8414Assert.Equal(new object[] { 2, 1, 1, 3 }, collection.Cast<object>()); 8415Assert.Equal(new object[] { 2, 1, 1, 3 }, owner.Items.Cast<object>()); 8451Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8464Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8479Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8496Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8533Assert.Equal(new object[] { 2 }, collection.Cast<object>()); 8534Assert.Equal(new object[] { 2 }, owner.Items.Cast<object>()); 8546Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 8547Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 8561Assert.Equal(new object[] { 1, 1, 2 }, collection.Cast<object>()); 8562Assert.Equal(new object[] { 1, 1, 2 }, owner.Items.Cast<object>()); 8578Assert.Equal(new object[] { 1, 1, 2, 3 }, collection.Cast<object>()); 8579Assert.Equal(new object[] { 1, 1, 2, 3 }, owner.Items.Cast<object>()); 8609Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8610Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8617Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8618Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8641Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8642Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8649Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8650Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8677Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8678Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8685Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8686Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8693Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8694Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8721Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8722Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8728Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8729Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 8735Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8736Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 8762Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8763Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8773Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8774Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 8807Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8808Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8818Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 8819Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 8856Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8857Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8867Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8868Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8878Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8879Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 8916Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8917Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 8927Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8928Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 8938Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 8939Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 9454Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9462Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9470Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9478Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9495Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9496Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9503Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9504Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 9511Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9512Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 9519Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9520Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 9539Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9547Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9555Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9563Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9583Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9584Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9591Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9592Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 9599Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9600Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 9607Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9608Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 9630Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9643Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9658Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9675Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9709Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9710Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9722Assert.Equal(new object[] { 2, 1 }, collection.Cast<object>()); 9723Assert.Equal(new object[] { 2, 1 }, owner.Items.Cast<object>()); 9737Assert.Equal(new object[] { 2, 2, 1 }, collection.Cast<object>()); 9738Assert.Equal(new object[] { 2, 2, 1 }, owner.Items.Cast<object>()); 9754Assert.Equal(new object[] { 2, 2, 1, 3 }, collection.Cast<object>()); 9755Assert.Equal(new object[] { 2, 2, 1, 3 }, owner.Items.Cast<object>()); 9791Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9804Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9819Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9836Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9873Assert.Equal(new object[] { 1 }, collection.Cast<object>()); 9874Assert.Equal(new object[] { 1 }, owner.Items.Cast<object>()); 9886Assert.Equal(new object[] { 1, 2 }, collection.Cast<object>()); 9887Assert.Equal(new object[] { 1, 2 }, owner.Items.Cast<object>()); 9901Assert.Equal(new object[] { 1, 2, 2 }, collection.Cast<object>()); 9902Assert.Equal(new object[] { 1, 2, 2 }, owner.Items.Cast<object>()); 9918Assert.Equal(new object[] { 1, 2, 2, 3 }, collection.Cast<object>()); 9919Assert.Equal(new object[] { 1, 2, 2, 3 }, owner.Items.Cast<object>()); 9949Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9950Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 9957Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9958Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 9979Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9980Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 9985Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 9986Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 10011Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10012Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10019Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10020Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10027Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10028Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10053Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10054Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 10060Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10061Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10067Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10068Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10094Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10095Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10105Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10106Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10139Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10140Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 10150Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10151Assert.Equal(new int[] { 1 }, owner.SelectedIndices.Cast<int>()); 10188Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10189Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10199Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10200Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10210Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10211Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10248Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10249Assert.Equal(new int[] { 1, 2 }, owner.SelectedIndices.Cast<int>()); 10259Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10260Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10270Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10271Assert.Equal(new int[] { 1, 3 }, owner.SelectedIndices.Cast<int>()); 10393Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10401Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10409Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10437Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10438Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10444Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10445Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10451Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10452Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 10483Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10491Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10499Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10530Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10531Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10537Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10538Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10544Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10545Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 10577Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10592Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10607Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10651Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10652Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10667Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 10668Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 10683Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 10684Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 10729Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10744Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10759Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10806Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10807Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10822Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 10823Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 10838Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 10839Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 10876Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10877Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10884Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10885Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10917Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10918Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10925Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 10926Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 10962Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10963Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10970Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 10971Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 10978Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 10979Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11014Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11015Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11022Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11023Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11030Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11031Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11071Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11072Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11082Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11083Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11133Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11134Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11144Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11145Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11194Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11195Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11204Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11205Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11214Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11215Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11262Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11263Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11272Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11273Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11282Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11283Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11340Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11348Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11376Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11377Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 11383Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11384Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 11415Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11423Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11454Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11455Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 11461Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11462Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 11494Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11509Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11553Assert.Equal(new int[] { 2, 3 }, collection.Cast<int>()); 11554Assert.Equal(new int[] { 2, 3 }, owner.Items.Cast<int>()); 11569Assert.Equal(new int[] { 2 }, collection.Cast<int>()); 11570Assert.Equal(new int[] { 2 }, owner.Items.Cast<int>()); 11615Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11630Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11677Assert.Equal(new int[] { 1, 3 }, collection.Cast<int>()); 11678Assert.Equal(new int[] { 1, 3 }, owner.Items.Cast<int>()); 11693Assert.Equal(new int[] { 1 }, collection.Cast<int>()); 11694Assert.Equal(new int[] { 1 }, owner.Items.Cast<int>()); 11731Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11732Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11739Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11740Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11772Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11773Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11780Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11781Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11817Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11818Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11825Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11826Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11833Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11834Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11869Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11870Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11877Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 11878Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 11885Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 11886Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11926Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11927Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11937Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11938Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11988Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 11989Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 11999Assert.Equal(new object[] { 1 }, owner.SelectedItems.Cast<object>()); 12000Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 12049Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12050Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12059Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12060Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12069Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 12070Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>()); 12117Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12118Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12127Assert.Equal(new object[] { 1, 3 }, owner.SelectedItems.Cast<object>()); 12128Assert.Equal(new int[] { 0, 1 }, owner.SelectedIndices.Cast<int>()); 12137Assert.Equal(new object[] { 3 }, owner.SelectedItems.Cast<object>()); 12138Assert.Equal(new int[] { 0 }, owner.SelectedIndices.Cast<int>());

1091Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1099Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1180Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1191Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<object>()); 1518Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1524Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1530Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1614Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1623Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 1632Assert.Equal(new string[] { "item1", "item2", "item1" }, control.Items.Cast<string>()); 2424Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 2425Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 2599Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 2600Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 2906Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 2907Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 3112Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3113Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<string>()); 3316Assert.Equal(new int[] { 2 }, control.SelectedIndices.Cast<int>()); 3322Assert.Equal(new int[] { 0, 2 }, control.SelectedIndices.Cast<int>()); 3513Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3514Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3522Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3523Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3531Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3532Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3555Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3556Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3564Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3565Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3573Assert.Equal(new int[] { 0, 1 }, control.SelectedIndices.Cast<int>()); 3574Assert.Equal(new string[] { "item1", "item2" }, control.SelectedItems.Cast<object>()); 3976Assert.Equal(expected, control.Items.Cast<string>()); 3982Assert.Equal(expected, control.Items.Cast<string>()); 3988Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<string>()); 4090Assert.Equal(expected, control.Items.Cast<string>()); 4099Assert.Equal(expected, control.Items.Cast<string>()); 4108Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<string>()); 4563Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<object>()); 4568Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4573Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4578Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4596Assert.Equal(new string[] { "item1", "item2" }, control.Items.Cast<object>()); 4604Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4612Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 4620Assert.Equal(new string[] { "item1", "item2", "item3" }, control.Items.Cast<object>()); 5906Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 5911Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 5958Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 5966Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>()); 6023Assert.Equal(value, control.Items.Cast<object>()); 6028Assert.Equal(value, control.Items.Cast<object>()); 6046Assert.Equal(value, control.Items.Cast<object>()); 6054Assert.Equal(value, control.Items.Cast<object>()); 6076Assert.Equal(new object[] { "item1", "item2" }, control.Items.Cast<object>());

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

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

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

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

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

88Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 89Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 116Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 117Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 227Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 228Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 268Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 269Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 388Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 389Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 422Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 423Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 545Assert.Equal(new Control[] { value1, value2 }, collection.Cast<Control>()); 546Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 592Assert.Equal(new Control[] { value2, value1 }, collection.Cast<Control>()); 593Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 743Assert.Equal(items, collection.Cast<Control>()); 744Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 1369Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 1374Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 1379Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 1407Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 1412Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 1417Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 1438Assert.Equal(items, collection.Cast<Control>()); 1439Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 1447Assert.Equal(items, collection.Cast<Control>()); 1448Assert.Equal(items, owner.TabPages.Cast<TabPage>());

74Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 75Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 76Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 103Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 104Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 105Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 216Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 217Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 218Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 258Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 259Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 260Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 380Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 381Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 382Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 415Assert.Equal(new TabPage[] { value1, value2, value1, }, collection.Cast<TabPage>()); 416Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 417Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 540Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 541Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 542Assert.Equal(new Control[] { value1, value2 }, owner.Controls.Cast<Control>()); 588Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 589Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 590Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 746Assert.Equal(items, collection.Cast<TabPage>()); 747Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 748Assert.Equal(items, owner.Controls.Cast<Control>()); 1021Assert.Equal(new TabPage[] { value1, value2 }, collection.Cast<TabPage>()); 1022Assert.Equal(new TabPage[] { value1, value2 }, owner.TabPages.Cast<TabPage>()); 1049Assert.Equal(new TabPage[] { value1, value2, value1 }, collection.Cast<TabPage>()); 1050Assert.Equal(new TabPage[] { value1, value2, value1 }, owner.TabPages.Cast<TabPage>()); 1116Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>()); 1128Assert.Equal(new TabPage[] { child1, child2, child3, child1, child2, child3 }, collection.Cast<TabPage>()); 1141Assert.Equal(new TabPage[] { child1, child2, child3, child1, child2, child3 }, collection.Cast<TabPage>()); 2016Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2017Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2018Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2047Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2048Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2049Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2153Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2154Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2155Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2197Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2198Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2199Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2323Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2324Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2325Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2360Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2361Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2362Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2489Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 2490Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 2491Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2539Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 2540Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 2541Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 2696Assert.Equal(items, collection.Cast<TabPage>()); 2697Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 2698Assert.Equal(items, owner.Controls.Cast<TabPage>()); 3062Assert.Equal(new TabPage[] { value2, value1 }, collection.Cast<TabPage>()); 3063Assert.Equal(new TabPage[] { value2, value1 }, owner.TabPages.Cast<TabPage>()); 3064Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 3093Assert.Equal(new TabPage[] { value2, value1, value1 }, collection.Cast<TabPage>()); 3094Assert.Equal(new TabPage[] { value2, value1, value1 }, owner.TabPages.Cast<TabPage>()); 3095Assert.Equal(new Control[] { value2, value1 }, owner.Controls.Cast<Control>()); 3380Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3425Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3465Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3521Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3779Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3823Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3862Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 3917Assert.Equal(new Control[] { page1, page2, page3 }, owner.Controls.Cast<Control>()); 4473Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 4478Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 4483Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 4513Assert.Equal(new Control[] { value1, value3, value4 }, collection.Cast<TabPage>()); 4518Assert.Equal(new Control[] { value1, value3 }, collection.Cast<TabPage>()); 4523Assert.Equal(new Control[] { value3 }, collection.Cast<TabPage>()); 4544Assert.Equal(items, collection.Cast<TabPage>()); 4545Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 4553Assert.Equal(items, collection.Cast<TabPage>()); 4554Assert.Equal(items, owner.TabPages.Cast<TabPage>()); 4840Assert.Equal(new TabPage[] { child1 }, collection.Cast<TabPage>()); 4934Assert.Equal(new TabPage[] { child1, child3 }, collection.Cast<TabPage>()); 4947Assert.Equal(new TabPage[] { child1 }, collection.Cast<TabPage>()); 4993Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>()); 4997Assert.Equal(new TabPage[] { child1, child2, child3 }, collection.Cast<TabPage>());

2136Assert.Equal(expectedVisible, control.TabPages.Cast<TabPage>().Select(p => p.Visible)); 2145Assert.Equal(expectedVisible, control.TabPages.Cast<TabPage>().Select(p => p.Visible)); 4891Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>()); 4892Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>()); 4899Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>()); 4900Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>()); 4908Assert.Equal(new Control[] { page1, page2 }, control.Controls.Cast<Control>()); 4909Assert.Equal(new TabPage[] { page1, page2 }, control.TabPages.Cast<TabPage>());