From bb7ee3358f99bb17df7599ae667794d9074d31ab Mon Sep 17 00:00:00 2001 From: Shay Rojansky Date: Mon, 28 Jul 2025 09:20:02 +0200 Subject: [PATCH] Remove sync from primitive collection tests --- .../PrimitiveCollectionsQueryCosmosTest.cs | 1921 +++++++---------- ...itiveCollectionsQueryRelationalTestBase.cs | 28 +- .../PrimitiveCollectionsQueryTestBase.cs | 836 +++---- .../Query/QueryTestBase.cs | 5 + ...imitiveCollectionsQueryOldSqlServerTest.cs | 548 ++--- ...imitiveCollectionsQuerySqlServer160Test.cs | 548 ++--- ...veCollectionsQuerySqlServerJsonTypeTest.cs | 516 ++--- .../PrimitiveCollectionsQuerySqlServerTest.cs | 548 ++--- .../PrimitiveCollectionsQuerySqliteTest.cs | 569 +++-- 9 files changed, 2473 insertions(+), 3046 deletions(-) diff --git a/test/EFCore.Cosmos.FunctionalTests/Query/PrimitiveCollectionsQueryCosmosTest.cs b/test/EFCore.Cosmos.FunctionalTests/Query/PrimitiveCollectionsQueryCosmosTest.cs index 6b09305e63d..b57c27b9de1 100644 --- a/test/EFCore.Cosmos.FunctionalTests/Query/PrimitiveCollectionsQueryCosmosTest.cs +++ b/test/EFCore.Cosmos.FunctionalTests/Query/PrimitiveCollectionsQueryCosmosTest.cs @@ -3,6 +3,7 @@ using System.Net; using Microsoft.Azure.Cosmos; +using Microsoft.EntityFrameworkCore.Cosmos.Diagnostics.Internal; using Microsoft.EntityFrameworkCore.Cosmos.Extensions; using Microsoft.EntityFrameworkCore.Cosmos.Internal; using Xunit.Sdk; @@ -19,56 +20,48 @@ public PrimitiveCollectionsQueryCosmosTest(PrimitiveCollectionsQueryCosmosFixtur Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override Task Inline_collection_of_ints_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_of_ints_Contains(a); + public override async Task Inline_collection_of_ints_Contains() + { + await base.Inline_collection_of_ints_Contains(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE c["Int"] IN (10, 999) """); - }); + } - public override Task Inline_collection_of_nullable_ints_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_of_nullable_ints_Contains(a); + public override async Task Inline_collection_of_nullable_ints_Contains() + { + await base.Inline_collection_of_nullable_ints_Contains(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE c["NullableInt"] IN (10, 999) """); - }); + } - public override Task Inline_collection_of_nullable_ints_Contains_null(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_of_nullable_ints_Contains_null(a); + public override async Task Inline_collection_of_nullable_ints_Contains_null() + { + await base.Inline_collection_of_nullable_ints_Contains_null(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE c["NullableInt"] IN (null, 999) """); - }); + } - public override Task Inline_collection_Count_with_zero_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Count_with_zero_values(a); + public override async Task Inline_collection_Count_with_zero_values() + { + await base.Inline_collection_Count_with_zero_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( @@ -76,16 +69,14 @@ SELECT VALUE COUNT(1) FROM a IN (SELECT VALUE []) WHERE (a > c["Id"])) = 1) """); - }); + } - public override Task Inline_collection_Count_with_one_value(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Count_with_one_value(a); + public override async Task Inline_collection_Count_with_one_value() + { + await base.Inline_collection_Count_with_one_value(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( @@ -93,16 +84,14 @@ SELECT VALUE COUNT(1) FROM a IN (SELECT VALUE [2]) WHERE (a > c["Id"])) = 1) """); - }); + } - public override Task Inline_collection_Count_with_two_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Count_with_two_values(a); + public override async Task Inline_collection_Count_with_two_values() + { + await base.Inline_collection_Count_with_two_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( @@ -110,16 +99,14 @@ SELECT VALUE COUNT(1) FROM a IN (SELECT VALUE [2, 999]) WHERE (a > c["Id"])) = 1) """); - }); + } - public override Task Inline_collection_Count_with_three_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Count_with_three_values(a); + public override async Task Inline_collection_Count_with_three_values() + { + await base.Inline_collection_Count_with_three_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( @@ -127,67 +114,57 @@ SELECT VALUE COUNT(1) FROM a IN (SELECT VALUE [2, 999, 1000]) WHERE (a > c["Id"])) = 2) """); - }); + } - public override Task Inline_collection_Contains_with_zero_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_zero_values(a); + public override async Task Inline_collection_Contains_with_zero_values() + { + await base.Inline_collection_Contains_with_zero_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE false """); - }); + } - public override Task Inline_collection_Contains_with_one_value(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_one_value(a); + public override async Task Inline_collection_Contains_with_one_value() + { + await base.Inline_collection_Contains_with_one_value(); - AssertSql("ReadItem(None, 2)"); - }); + AssertSql("ReadItem(None, 2)"); + } - public override Task Inline_collection_Contains_with_two_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_two_values(a); + public override async Task Inline_collection_Contains_with_two_values() + { + await base.Inline_collection_Contains_with_two_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE c["Id"] IN (2, 999) """); - }); + } - public override Task Inline_collection_Contains_with_three_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_three_values(a); + public override async Task Inline_collection_Contains_with_three_values() + { + await base.Inline_collection_Contains_with_three_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE c["Id"] IN (2, 999, 1000) """); - }); + } - public override Task Inline_collection_Contains_with_all_parameters(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_all_parameters(a); + public override async Task Inline_collection_Contains_with_all_parameters() + { + await base.Inline_collection_Contains_with_all_parameters(); - AssertSql( - """ + AssertSql( + """ @i='2' @j='999' @@ -195,156 +172,136 @@ SELECT VALUE c FROM root c WHERE c["Id"] IN (@i, @j) """); - }); + } - public override Task Inline_collection_Contains_with_constant_and_parameter(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_constant_and_parameter(a); + public override async Task Inline_collection_Contains_with_constant_and_parameter() + { + await base.Inline_collection_Contains_with_constant_and_parameter(); - AssertSql( - """ + AssertSql( + """ @j='999' SELECT VALUE c FROM root c WHERE c["Id"] IN (2, @j) """); - }); + } - public override Task Inline_collection_Contains_with_mixed_value_types(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_mixed_value_types(a); + public override async Task Inline_collection_Contains_with_mixed_value_types() + { + await base.Inline_collection_Contains_with_mixed_value_types(); - AssertSql( - """ + AssertSql( + """ @i='11' SELECT VALUE c FROM root c WHERE c["Int"] IN (999, @i, c["Id"], (c["Id"] + c["Int"])) """); - }); + } - public override Task Inline_collection_List_Contains_with_mixed_value_types(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_List_Contains_with_mixed_value_types(a); + public override async Task Inline_collection_List_Contains_with_mixed_value_types() + { + await base.Inline_collection_List_Contains_with_mixed_value_types(); - AssertSql( - """ + AssertSql( + """ @i='11' SELECT VALUE c FROM root c WHERE c["Int"] IN (999, @i, c["Id"], (c["Id"] + c["Int"])) """); - }); + } - public override Task Inline_collection_Contains_as_Any_with_predicate(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_as_Any_with_predicate(a); + public override async Task Inline_collection_Contains_as_Any_with_predicate() + { + await base.Inline_collection_Contains_as_Any_with_predicate(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE c["Id"] IN (2, 999) """); - }); + } - public override Task Inline_collection_negated_Contains_as_All(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_negated_Contains_as_All(a); + public override async Task Inline_collection_negated_Contains_as_All() + { + await base.Inline_collection_negated_Contains_as_All(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE c["Id"] NOT IN (2, 999) """); - }); + } - public override Task Inline_collection_Min_with_two_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Min_with_two_values(a); + public override async Task Inline_collection_Min_with_two_values() + { + await base.Inline_collection_Min_with_two_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( SELECT VALUE MIN(a) FROM a IN (SELECT VALUE [30, c["Int"]])) = 30) """); - }); + } - public override Task Inline_collection_List_Min_with_two_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_List_Min_with_two_values(a); + public override async Task Inline_collection_List_Min_with_two_values() + { + await base.Inline_collection_List_Min_with_two_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( SELECT VALUE MIN(a) FROM a IN (SELECT VALUE [30, c["Int"]])) = 30) """); - }); + } - public override Task Inline_collection_Max_with_two_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Max_with_two_values(a); + public override async Task Inline_collection_Max_with_two_values() + { + await base.Inline_collection_Max_with_two_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( SELECT VALUE MAX(a) FROM a IN (SELECT VALUE [30, c["Int"]])) = 30) """); - }); + } - public override Task Inline_collection_List_Max_with_two_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_List_Max_with_two_values(a); + public override async Task Inline_collection_List_Max_with_two_values() + { + await base.Inline_collection_List_Max_with_two_values(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( SELECT VALUE MAX(a) FROM a IN (SELECT VALUE [30, c["Int"]])) = 30) """); - }); + } - public override Task Inline_collection_Min_with_three_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Min_with_three_values(a); + public override async Task Inline_collection_Min_with_three_values() + { + await base.Inline_collection_Min_with_three_values(); - AssertSql( - """ + AssertSql( + """ @i='25' SELECT VALUE c @@ -353,16 +310,14 @@ FROM root c SELECT VALUE MIN(a) FROM a IN (SELECT VALUE [30, c["Int"], @i])) = 25) """); - }); + } - public override Task Inline_collection_List_Min_with_three_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_List_Min_with_three_values(a); + public override async Task Inline_collection_List_Min_with_three_values() + { + await base.Inline_collection_List_Min_with_three_values(); - AssertSql( - """ + AssertSql( + """ @i='25' SELECT VALUE c @@ -371,16 +326,14 @@ FROM root c SELECT VALUE MIN(a) FROM a IN (SELECT VALUE [30, c["Int"], @i])) = 25) """); - }); + } - public override Task Inline_collection_Max_with_three_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Max_with_three_values(a); + public override async Task Inline_collection_Max_with_three_values() + { + await base.Inline_collection_Max_with_three_values(); - AssertSql( - """ + AssertSql( + """ @i='35' SELECT VALUE c @@ -389,16 +342,14 @@ FROM root c SELECT VALUE MAX(a) FROM a IN (SELECT VALUE [30, c["Int"], @i])) = 35) """); - }); + } - public override Task Inline_collection_List_Max_with_three_values(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_List_Max_with_three_values(a); + public override async Task Inline_collection_List_Max_with_three_values() + { + await base.Inline_collection_List_Max_with_three_values(); - AssertSql( - """ + AssertSql( + """ @i='35' SELECT VALUE c @@ -407,16 +358,14 @@ FROM root c SELECT VALUE MAX(a) FROM a IN (SELECT VALUE [30, c["Int"], @i])) = 35) """); - }); + } - public override Task Inline_collection_of_nullable_value_type_Min(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_of_nullable_value_type_Min(a); + public override async Task Inline_collection_of_nullable_value_type_Min() + { + await base.Inline_collection_of_nullable_value_type_Min(); - AssertSql( - """ + AssertSql( + """ @i='25' SELECT VALUE c @@ -425,16 +374,14 @@ FROM root c SELECT VALUE MIN(a) FROM a IN (SELECT VALUE [30, c["Int"], @i])) = 25) """); - }); + } - public override Task Inline_collection_of_nullable_value_type_Max(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_of_nullable_value_type_Max(a); + public override async Task Inline_collection_of_nullable_value_type_Max() + { + await base.Inline_collection_of_nullable_value_type_Max(); - AssertSql( - """ + AssertSql( + """ @i='35' SELECT VALUE c @@ -443,20 +390,17 @@ FROM root c SELECT VALUE MAX(a) FROM a IN (SELECT VALUE [30, c["Int"], @i])) = 35) """); - }); + } - public override async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Min() { - // Always throws for sync. - if (async) - { - // Cosmos MIN()/MAX() sort nulls as smaller than ints (https://learn.microsoft.com/azure/cosmos-db/nosql/query/min); - // since some of the columns included contain null, MIN() returns null as opposed to the smallest number. - // In relational, aggregate MIN()/MAX() ignores nulls. - await Assert.ThrowsAsync(() => base.Inline_collection_of_nullable_value_type_with_null_Min(async)); + // Cosmos MIN()/MAX() sort nulls as smaller than ints (https://learn.microsoft.com/azure/cosmos-db/nosql/query/min); + // since some of the columns included contain null, MIN() returns null as opposed to the smallest number. + // In relational, aggregate MIN()/MAX() ignores nulls. + await Assert.ThrowsAsync(base.Inline_collection_of_nullable_value_type_with_null_Min); - AssertSql( - """ + AssertSql( + """ @i=null SELECT VALUE c @@ -465,17 +409,14 @@ FROM root c SELECT VALUE MIN(a) FROM a IN (SELECT VALUE [30, c["NullableInt"], @i])) = 30) """); - } } - public override Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_of_nullable_value_type_with_null_Max(a); + public override async Task Inline_collection_of_nullable_value_type_with_null_Max() + { + await base.Inline_collection_of_nullable_value_type_with_null_Max(); - AssertSql( - """ + AssertSql( + """ @i=null SELECT VALUE c @@ -484,28 +425,24 @@ FROM root c SELECT VALUE MAX(a) FROM a IN (SELECT VALUE [30, c["NullableInt"], @i])) = 30) """); - }); + } - public override Task Inline_collection_with_single_parameter_element_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_with_single_parameter_element_Contains(a); + public override async Task Inline_collection_with_single_parameter_element_Contains() + { + await base.Inline_collection_with_single_parameter_element_Contains(); - AssertSql( - """ + AssertSql( + """ ReadItem(None, 2) """); - }); + } - public override Task Inline_collection_with_single_parameter_element_Count(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_with_single_parameter_element_Count(a); + public override async Task Inline_collection_with_single_parameter_element_Count() + { + await base.Inline_collection_with_single_parameter_element_Count(); - AssertSql( - """ + AssertSql( + """ @i='2' SELECT VALUE c @@ -515,32 +452,28 @@ SELECT VALUE COUNT(1) FROM a IN (SELECT VALUE [@i]) WHERE (a > c["Id"])) = 1) """); - }); + } - public override Task Inline_collection_Contains_with_EF_Parameter(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Contains_with_EF_Parameter(async); + public override async Task Inline_collection_Contains_with_EF_Parameter() + { + await base.Inline_collection_Contains_with_EF_Parameter(); - AssertSql( - """ + AssertSql( + """ @p='[2,999,1000]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@p, c["Id"]) """); - }); + } - public override Task Inline_collection_Count_with_column_predicate_with_EF_Parameter(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(async); + public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter() + { + await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(); - AssertSql( - """ + AssertSql( + """ @p='[2,999,1000]' SELECT VALUE c @@ -550,16 +483,14 @@ SELECT VALUE COUNT(1) FROM p IN (SELECT VALUE @p) WHERE (p > c["Id"])) = 2) """); - }); + } - public override Task Parameter_collection_Count(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_Count(a); + public override async Task Parameter_collection_Count() + { + await base.Parameter_collection_Count(); - AssertSql( - """ + AssertSql( + """ @ids='[2,999]' SELECT VALUE c @@ -569,464 +500,416 @@ SELECT VALUE COUNT(1) FROM i IN (SELECT VALUE @ids) WHERE (i > c["Id"])) = 1) """); - }); + } - public override Task Parameter_collection_of_ints_Contains_int(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_ints_Contains_int(a); + public override async Task Parameter_collection_of_ints_Contains_int() + { + await base.Parameter_collection_of_ints_Contains_int(); - AssertSql( - """ + AssertSql( + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@ints, c["Int"]) """, - // - """ + // + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@ints, c["Int"])) """); - }); + } - public override Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_HashSet_of_ints_Contains_int(a); + public override async Task Parameter_collection_HashSet_of_ints_Contains_int() + { + await base.Parameter_collection_HashSet_of_ints_Contains_int(); - AssertSql( - """ + AssertSql( + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@ints, c["Int"]) """, - // - """ + // + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@ints, c["Int"])) """); - }); + } - public override Task Parameter_collection_ImmutableArray_of_ints_Contains_int(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(a); + public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int() + { + await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(); - AssertSql( - """ + AssertSql( + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@ints, c["Int"]) """, - // - """ + // + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@ints, c["Int"])) """); - }); + } - public override Task Parameter_collection_of_ints_Contains_nullable_int(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_ints_Contains_nullable_int(a); + public override async Task Parameter_collection_of_ints_Contains_nullable_int() + { + await base.Parameter_collection_of_ints_Contains_nullable_int(); - AssertSql( - """ + AssertSql( + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@ints, c["NullableInt"]) """, - // - """ + // + """ @ints='[10,999]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@ints, c["NullableInt"])) """); - }); + } - public override Task Parameter_collection_of_nullable_ints_Contains_int(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_nullable_ints_Contains_int(a); + public override async Task Parameter_collection_of_nullable_ints_Contains_int() + { + await base.Parameter_collection_of_nullable_ints_Contains_int(); - AssertSql( - """ + AssertSql( + """ @nullableInts='[10,999]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@nullableInts, c["Int"]) """, - // - """ + // + """ @nullableInts='[10,999]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@nullableInts, c["Int"])) """); - }); + } - public override Task Parameter_collection_of_nullable_ints_Contains_nullable_int(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(a); + public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int() + { + await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(); - AssertSql( - """ + AssertSql( + """ @nullableInts='[null,999]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@nullableInts, c["NullableInt"]) """, - // - """ + // + """ @nullableInts='[null,999]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@nullableInts, c["NullableInt"])) """); - }); + } - public override Task Parameter_collection_of_strings_Contains_string(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_strings_Contains_string(a); + public override async Task Parameter_collection_of_strings_Contains_string() + { + await base.Parameter_collection_of_strings_Contains_string(); - AssertSql( - """ + AssertSql( + """ @strings='["10","999"]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@strings, c["String"]) """, - // - """ + // + """ @strings='["10","999"]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@strings, c["String"])) """); - }); + } - public override Task Parameter_collection_of_strings_Contains_nullable_string(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_strings_Contains_nullable_string(a); + public override async Task Parameter_collection_of_strings_Contains_nullable_string() + { + await base.Parameter_collection_of_strings_Contains_nullable_string(); - AssertSql( - """ + AssertSql( + """ @strings='["10","999"]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@strings, c["NullableString"]) """, - // - """ + // + """ @strings='["10","999"]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@strings, c["NullableString"])) """); - }); + } - public override Task Parameter_collection_of_nullable_strings_Contains_string(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_nullable_strings_Contains_string(a); + public override async Task Parameter_collection_of_nullable_strings_Contains_string() + { + await base.Parameter_collection_of_nullable_strings_Contains_string(); - AssertSql( - """ + AssertSql( + """ @strings='["10",null]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@strings, c["String"]) """, - // - """ + // + """ @strings='["10",null]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@strings, c["String"])) """); - }); + } - public override Task Parameter_collection_of_nullable_strings_Contains_nullable_string(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(a); + public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string() + { + await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(); - AssertSql( - """ + AssertSql( + """ @strings='["999",null]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@strings, c["NullableString"]) """, - // - """ + // + """ @strings='["999",null]' SELECT VALUE c FROM root c WHERE NOT(ARRAY_CONTAINS(@strings, c["NullableString"])) """); - }); + } - public override Task Parameter_collection_of_DateTimes_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_DateTimes_Contains(a); + public override async Task Parameter_collection_of_DateTimes_Contains() + { + await base.Parameter_collection_of_DateTimes_Contains(); - AssertSql( - """ + AssertSql( + """ @dateTimes='["2020-01-10T12:30:00Z","9999-01-01T00:00:00Z"]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@dateTimes, c["DateTime"]) """); - }); + } - public override Task Parameter_collection_of_bools_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_bools_Contains(a); + public override async Task Parameter_collection_of_bools_Contains() + { + await base.Parameter_collection_of_bools_Contains(); - AssertSql( - """ + AssertSql( + """ @bools='[true]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@bools, c["Bool"]) """); - }); + } - public override Task Parameter_collection_of_enums_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_of_enums_Contains(a); + public override async Task Parameter_collection_of_enums_Contains() + { + await base.Parameter_collection_of_enums_Contains(); - AssertSql( - """ + AssertSql( + """ @enums='[0,3]' SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@enums, c["Enum"]) """); - }); + } - public override Task Parameter_collection_null_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_null_Contains(a); + public override async Task Parameter_collection_null_Contains() + { + await base.Parameter_collection_null_Contains(); - AssertSql( - """ + AssertSql( + """ @ints=null SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@ints, c["Int"]) """); - }); + } - public override async Task Parameter_collection_Contains_with_EF_Constant(bool async) + public override async Task Parameter_collection_Contains_with_EF_Constant() { // #34327 - var exception = await Assert.ThrowsAsync( - () => base.Parameter_collection_Contains_with_EF_Constant(async)); + var exception = await Assert.ThrowsAsync(base.Parameter_collection_Contains_with_EF_Constant); Assert.Equal(CoreStrings.EFConstantNotSupported, exception.Message); } - public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any() { // #34327 - var exception = await Assert.ThrowsAsync( - () => base.Parameter_collection_Where_with_EF_Constant_Where_Any(async)); + var exception = await Assert.ThrowsAsync(base.Parameter_collection_Where_with_EF_Constant_Where_Any); Assert.Equal(CoreStrings.EFConstantNotSupported, exception.Message); } - public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant() { // #34327 var exception = await Assert.ThrowsAsync( - () => base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(async)); + base.Parameter_collection_Count_with_column_predicate_with_EF_Constant); Assert.Equal(CoreStrings.EFConstantNotSupported, exception.Message); } // nothing to test here - public override Task Parameter_collection_Count_with_huge_number_of_values(bool async) - => base.Parameter_collection_Count_with_huge_number_of_values(async); + public override Task Parameter_collection_Count_with_huge_number_of_values() + => base.Parameter_collection_Count_with_huge_number_of_values(); // nothing to test here - public override Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(bool async) - => base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(async); + public override Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values() + => base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(); - public override Task Column_collection_of_ints_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_of_ints_Contains(a); + public override async Task Column_collection_of_ints_Contains() + { + await base.Column_collection_of_ints_Contains(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(c["Ints"], 10) """); - }); + } - public override Task Column_collection_of_nullable_ints_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_of_nullable_ints_Contains(a); + public override async Task Column_collection_of_nullable_ints_Contains() + { + await base.Column_collection_of_nullable_ints_Contains(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(c["NullableInts"], 10) """); - }); + } - public override Task Column_collection_of_nullable_ints_Contains_null(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_of_nullable_ints_Contains_null(a); + public override async Task Column_collection_of_nullable_ints_Contains_null() + { + await base.Column_collection_of_nullable_ints_Contains_null(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(c["NullableInts"], null) """); - }); + } - public override Task Column_collection_of_strings_contains_null(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_of_strings_contains_null(a); + public override async Task Column_collection_of_strings_contains_null() + { + await base.Column_collection_of_strings_contains_null(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(c["Strings"], null) """); - }); + } - public override Task Column_collection_of_nullable_strings_contains_null(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_of_nullable_strings_contains_null(a); + public override async Task Column_collection_of_nullable_strings_contains_null() + { + await base.Column_collection_of_nullable_strings_contains_null(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(c["NullableStrings"], null) """); - }); + } - public override Task Column_collection_of_bools_Contains(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_of_bools_Contains(a); + public override async Task Column_collection_of_bools_Contains() + { + await base.Column_collection_of_bools_Contains(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(c["Bools"], true) """); - }); + } - public override Task Column_collection_Count_method(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Count_method(a); + public override async Task Column_collection_Count_method() + { + await base.Column_collection_Count_method(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(c["Ints"]) = 2) """); - }); + } - public override Task Column_collection_Length(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Length(a); + public override async Task Column_collection_Length() + { + await base.Column_collection_Length(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(c["Ints"]) = 2) """); - }); + } - public override Task Column_collection_Count_with_predicate(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Count_with_predicate(a); + public override async Task Column_collection_Count_with_predicate() + { + await base.Column_collection_Count_with_predicate(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( @@ -1034,16 +917,14 @@ SELECT VALUE COUNT(1) FROM i IN c["Ints"] WHERE (i > 1)) = 2) """); - }); + } - public override Task Column_collection_Where_Count(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Where_Count(a); + public override async Task Column_collection_Where_Count() + { + await base.Column_collection_Where_Count(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( @@ -1051,313 +932,261 @@ SELECT VALUE COUNT(1) FROM i IN c["Ints"] WHERE (i > 1)) = 2) """); - }); + } - public override Task Column_collection_index_int(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_index_int(a); + public override async Task Column_collection_index_int() + { + await base.Column_collection_index_int(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["Ints"][1] = 10) """); - }); + } - public override Task Column_collection_index_string(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_index_string(a); + public override async Task Column_collection_index_string() + { + await base.Column_collection_index_string(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["Strings"][1] = "10") """); - }); + } - public override Task Column_collection_index_datetime(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_index_datetime(a); + public override async Task Column_collection_index_datetime() + { + await base.Column_collection_index_datetime(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["DateTimes"][1] = "2020-01-10T12:30:00Z") """); - }); + } - public override Task Column_collection_index_beyond_end(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_index_beyond_end(a); + public override async Task Column_collection_index_beyond_end() + { + await base.Column_collection_index_beyond_end(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["Ints"][999] = 10) """); - }); + } - public override async Task Nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Nullable_reference_column_collection_index_equals_nullable_column() { - // Always throws for sync. - if (async) - { - await Assert.ThrowsAsync(() => base.Nullable_reference_column_collection_index_equals_nullable_column(async)); + await Assert.ThrowsAsync(base.Nullable_reference_column_collection_index_equals_nullable_column); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["NullableStrings"][2] = c["NullableString"]) """); - } } - public override Task Non_nullable_reference_column_collection_index_equals_nullable_column(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Non_nullable_reference_column_collection_index_equals_nullable_column(a); + public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column() + { + await base.Non_nullable_reference_column_collection_index_equals_nullable_column(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ((ARRAY_LENGTH(c["Strings"]) > 0) AND (c["Strings"][1] = c["NullableString"])) """); - }); + } - public override async Task Inline_collection_index_Column(bool async) + public override async Task Inline_collection_index_Column() { - // Always throws for sync. - if (async) - { - // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos - var exception = await Assert.ThrowsAsync(() => base.Inline_collection_index_Column(async)); + // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos + var exception = await Assert.ThrowsAsync(base.Inline_collection_index_Column); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ([1, 2, 3][c["Int"]] = 1) """); - } } - public override async Task Inline_collection_value_index_Column(bool async) + public override async Task Inline_collection_value_index_Column() { - // Always throws for sync. - if (async) - { - // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos - var exception = await Assert.ThrowsAsync(() => base.Inline_collection_value_index_Column(async)); + // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos + var exception = await Assert.ThrowsAsync(base.Inline_collection_value_index_Column); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ([1, c["Int"], 3][c["Int"]] = 1) """); - } } - public override async Task Inline_collection_List_value_index_Column(bool async) + public override async Task Inline_collection_List_value_index_Column() { - // Always throws for sync. - if (async) - { - // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos - var exception = await Assert.ThrowsAsync(() => base.Inline_collection_List_value_index_Column(async)); + // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos + var exception = await Assert.ThrowsAsync(base.Inline_collection_List_value_index_Column); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ([1, c["Int"], 3][c["Int"]] = 1) """); - } } - public override async Task Parameter_collection_index_Column_equal_Column(bool async) + public override async Task Parameter_collection_index_Column_equal_Column() { - // Always throws for sync. - if (async) - { - // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos - var exception = await Assert.ThrowsAsync(() => base.Parameter_collection_index_Column_equal_Column(async)); + // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos + var exception = await Assert.ThrowsAsync(base.Parameter_collection_index_Column_equal_Column); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ @ints='[0,2,3]' SELECT VALUE c FROM root c WHERE (@ints[c["Int"]] = c["Int"]) """); - } } - public override async Task Parameter_collection_index_Column_equal_constant(bool async) + public override async Task Parameter_collection_index_Column_equal_constant() { - // Always throws for sync. - if (async) - { - // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos - var exception = await Assert.ThrowsAsync(() => base.Parameter_collection_index_Column_equal_constant(async)); + // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos + var exception = await Assert.ThrowsAsync(base.Parameter_collection_index_Column_equal_constant); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ @ints='[1,2,3]' SELECT VALUE c FROM root c WHERE (@ints[c["Int"]] = 1) """); - } } - public override Task Column_collection_ElementAt(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_ElementAt(a); + public override async Task Column_collection_ElementAt() + { + await base.Column_collection_ElementAt(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["Ints"][1] = 10) """); - }); + } - public override Task Column_collection_First(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_First(a); + public override async Task Column_collection_First() + { + await base.Column_collection_First(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["Ints"][0] = 1) """); - }); + } - public override Task Column_collection_FirstOrDefault(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_FirstOrDefault(a); + public override async Task Column_collection_FirstOrDefault() + { + await base.Column_collection_FirstOrDefault(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ((c["Ints"][0] ?? 0) = 1) """); - }); + } - public override Task Column_collection_Single(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Single(a); + public override async Task Column_collection_Single() + { + await base.Column_collection_Single(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["Ints"][0] = 1) """); - }); + } - public override Task Column_collection_SingleOrDefault(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_SingleOrDefault(a); + public override async Task Column_collection_SingleOrDefault() + { + await base.Column_collection_SingleOrDefault(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ((c["Ints"][0] ?? 0) = 1) """); - }); + } - public override Task Column_collection_Skip(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Skip(a); + public override async Task Column_collection_Skip() + { + await base.Column_collection_Skip(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(ARRAY_SLICE(c["Ints"], 1)) = 2) """); - }); + } - public override Task Column_collection_Take(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Take(a); + public override async Task Column_collection_Take() + { + await base.Column_collection_Take(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(ARRAY_SLICE(c["Ints"], 0, 2), 11) """); - }); + } - public override Task Column_collection_Skip_Take(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Skip_Take(a); + public override async Task Column_collection_Skip_Take() + { + await base.Column_collection_Skip_Take(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(ARRAY_SLICE(c["Ints"], 1, 2), 11) """); - }); + } - public override Task Column_collection_Where_Skip(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Where_Skip(a); + public override async Task Column_collection_Where_Skip() + { + await base.Column_collection_Where_Skip(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(ARRAY_SLICE(ARRAY( @@ -1365,16 +1194,14 @@ SELECT VALUE i FROM i IN c["Ints"] WHERE (i > 1)), 1)) = 3) """); - }); + } - public override Task Column_collection_Where_Take(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Where_Take(a); + public override async Task Column_collection_Where_Take() + { + await base.Column_collection_Where_Take(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(ARRAY_SLICE(ARRAY( @@ -1382,16 +1209,14 @@ SELECT VALUE i FROM i IN c["Ints"] WHERE (i > 1)), 0, 2)) = 2) """); - }); + } - public override Task Column_collection_Where_Skip_Take(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Where_Skip_Take(a); + public override async Task Column_collection_Where_Skip_Take() + { + await base.Column_collection_Where_Skip_Take(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(ARRAY_SLICE(ARRAY( @@ -1399,16 +1224,14 @@ SELECT VALUE i FROM i IN c["Ints"] WHERE (i > 1)), 1, 2)) = 1) """); - }); + } - public override Task Column_collection_Contains_over_subquery(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Contains_over_subquery(a); + public override async Task Column_collection_Contains_over_subquery() + { + await base.Column_collection_Contains_over_subquery(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE EXISTS ( @@ -1416,20 +1239,17 @@ SELECT 1 FROM i IN c["Ints"] WHERE ((i > 1) AND (i = 11))) """); - }); + } - public override async Task Column_collection_OrderByDescending_ElementAt(bool async) + public override async Task Column_collection_OrderByDescending_ElementAt() { - // Always throws for sync. - if (async) - { - // 'ORDER BY' is not supported in subqueries. - var exception = await Assert.ThrowsAsync(() => base.Column_collection_OrderByDescending_ElementAt(async)); + // 'ORDER BY' is not supported in subqueries. + var exception = await Assert.ThrowsAsync(base.Column_collection_OrderByDescending_ElementAt); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY( @@ -1437,17 +1257,14 @@ SELECT VALUE i FROM i IN c["Ints"] ORDER BY i DESC)[0] = 111) """); - } } - public override Task Column_collection_Where_ElementAt(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Where_ElementAt(a); + public override async Task Column_collection_Where_ElementAt() + { + await base.Column_collection_Where_ElementAt(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY( @@ -1455,52 +1272,46 @@ SELECT VALUE i FROM i IN c["Ints"] WHERE (i > 1))[0] = 11) """); - }); + } - public override Task Column_collection_Any(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Any(a); + public override async Task Column_collection_Any() + { + await base.Column_collection_Any(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(c["Ints"]) > 0) """); - }); + } - public override async Task Column_collection_Distinct(bool async) + public override async Task Column_collection_Distinct() { // TODO: Subquery pushdown, #33968 - await AssertTranslationFailed(() => base.Column_collection_Distinct(async)); + await AssertTranslationFailed(base.Column_collection_Distinct); AssertSql(); } - public override Task Column_collection_SelectMany(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_SelectMany(a); + public override async Task Column_collection_SelectMany() + { + await base.Column_collection_SelectMany(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE i FROM root c JOIN i IN c["Ints"] """); - }); + } - public override Task Column_collection_SelectMany_with_filter(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_SelectMany_with_filter(a); + public override async Task Column_collection_SelectMany_with_filter() + { + await base.Column_collection_SelectMany_with_filter(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE j FROM root c JOIN ( @@ -1508,135 +1319,115 @@ SELECT VALUE i FROM i IN c["Ints"] WHERE (i > 1)) j """); - }); + } - public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) + public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type() { - // Always throws for sync. - if (async) - { - // TODO: #34004 - var exception = await Assert.ThrowsAsync( - () => base.Column_collection_SelectMany_with_Select_to_anonymous_type(async)); + // TODO: #34004 + var exception = await Assert.ThrowsAsync( + base.Column_collection_SelectMany_with_Select_to_anonymous_type); - Assert.Equal(CosmosStrings.ComplexProjectionInSubqueryNotSupported, exception.Message); - } + Assert.Equal(CosmosStrings.ComplexProjectionInSubqueryNotSupported, exception.Message); } - public override Task Column_collection_projection_from_top_level(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_projection_from_top_level(a); + public override async Task Column_collection_projection_from_top_level() + { + await base.Column_collection_projection_from_top_level(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c["Ints"] FROM root c ORDER BY c["Id"] """); - }); + } - public override async Task Column_collection_Join_parameter_collection(bool async) + public override async Task Column_collection_Join_parameter_collection() { // Cosmos join support. Issue #16920. - await AssertTranslationFailed(() => base.Column_collection_Join_parameter_collection(async)); + await AssertTranslationFailed(base.Column_collection_Join_parameter_collection); AssertSql(); } - public override async Task Inline_collection_Join_ordered_column_collection(bool async) + public override async Task Inline_collection_Join_ordered_column_collection() { // Cosmos join support. Issue #16920. - await AssertTranslationFailed(() => base.Column_collection_Join_parameter_collection(async)); + await AssertTranslationFailed(base.Column_collection_Join_parameter_collection); AssertSql(); } - public override Task Parameter_collection_Concat_column_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_Concat_column_collection(a); + public override async Task Parameter_collection_Concat_column_collection() + { + await base.Parameter_collection_Concat_column_collection(); - AssertSql( - """ + AssertSql( + """ @ints='[11,111]' SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(ARRAY_CONCAT(@ints, c["Ints"])) = 2) """); - }); + } - public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) + public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression() { - // Always throws for sync. - if (async) - { - // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos - var exception = await Assert.ThrowsAsync( - () => base.Parameter_collection_with_type_inference_for_JsonScalarExpression(async)); + // Member indexer (c.Array[c.SomeMember]) isn't supported by Cosmos + var exception = await Assert.ThrowsAsync( + base.Parameter_collection_with_type_inference_for_JsonScalarExpression); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ @values='["one","two"]' SELECT VALUE ((c["Id"] != 0) ? @values[(c["Int"] % 2)] : "foo") FROM root c """); - } } - public override Task Column_collection_Union_parameter_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Union_parameter_collection(a); + public override async Task Column_collection_Union_parameter_collection() + { + await base.Column_collection_Union_parameter_collection(); - AssertSql( - """ + AssertSql( + """ @ints='[11,111]' SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(SetUnion(c["Ints"], @ints)) = 2) """); - }); + } - public override Task Column_collection_Intersect_inline_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Intersect_inline_collection(a); + public override async Task Column_collection_Intersect_inline_collection() + { + await base.Column_collection_Intersect_inline_collection(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(SetIntersect(c["Ints"], [11, 111])) = 2) """); - }); + } - public override async Task Inline_collection_Except_column_collection(bool async) + public override async Task Inline_collection_Except_column_collection() { - await AssertTranslationFailedWithDetails( - () => base.Inline_collection_Except_column_collection(async), - CosmosStrings.ExceptNotSupported); + await AssertTranslationFailedWithDetails(base.Inline_collection_Except_column_collection, CosmosStrings.ExceptNotSupported); AssertSql(); } - public override Task Column_collection_Where_Union(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Where_Union(a); + public override async Task Column_collection_Where_Union() + { + await base.Column_collection_Where_Union(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(SetUnion(ARRAY( @@ -1644,62 +1435,54 @@ SELECT VALUE i FROM i IN c["Ints"] WHERE (i > 100)), [50])) = 2) """); - }); + } - public override Task Column_collection_equality_parameter_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_equality_parameter_collection(a); + public override async Task Column_collection_equality_parameter_collection() + { + await base.Column_collection_equality_parameter_collection(); - AssertSql( - """ + AssertSql( + """ @ints='[1,10]' SELECT VALUE c FROM root c WHERE (c["Ints"] = @ints) """); - }); + } - public override Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Concat_parameter_collection_equality_inline_collection(a); + public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection() + { + await base.Column_collection_Concat_parameter_collection_equality_inline_collection(); - AssertSql( - """ + AssertSql( + """ @ints='[1,10]' SELECT VALUE c FROM root c WHERE (ARRAY_CONCAT(c["Ints"], @ints) = [1,11,111,1,10]) """); - }); + } - public override Task Column_collection_equality_inline_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_equality_inline_collection(a); + public override async Task Column_collection_equality_inline_collection() + { + await base.Column_collection_equality_inline_collection(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (c["Ints"] = [1,10]) """); - }); + } - public override Task Column_collection_equality_inline_collection_with_parameters(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_equality_inline_collection_with_parameters(a); + public override async Task Column_collection_equality_inline_collection_with_parameters() + { + await base.Column_collection_equality_inline_collection_with_parameters(); - AssertSql( - """ + AssertSql( + """ @i='1' @j='10' @@ -1707,16 +1490,14 @@ SELECT VALUE c FROM root c WHERE (c["Ints"] = [@i, @j]) """); - }); + } - public override Task Column_collection_Where_equality_inline_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Column_collection_Where_equality_inline_collection(a); + public override async Task Column_collection_Where_equality_inline_collection() + { + await base.Column_collection_Where_equality_inline_collection(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (ARRAY( @@ -1724,40 +1505,40 @@ SELECT VALUE i FROM i IN c["Ints"] WHERE (i != 11)) = [1,111]) """); - }); + } - public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query() { // TODO: #33931 // The ToList inside the query gets executed separately during shaper generation - and synchronously (even in the async // variant of the test), but Cosmos doesn't support sync I/O. So both sync and async variants fail because of unsupported // sync I/O. - await CosmosTestHelpers.Instance.NoSyncTest( - async: false, a => base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(a)); + var exception = await Assert.ThrowsAsync( + base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query); + + Assert.Equal(SyncNotSupportedMessage, exception.Message); AssertSql(); } - public override Task Parameter_collection_in_subquery_Union_column_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Parameter_collection_in_subquery_Union_column_collection(a); + public override async Task Parameter_collection_in_subquery_Union_column_collection() + { + await base.Parameter_collection_in_subquery_Union_column_collection(); - AssertSql( - """ + AssertSql( + """ @Skip='[111]' SELECT VALUE c FROM root c WHERE (ARRAY_LENGTH(SetUnion(@Skip, c["Ints"])) = 3) """); - }); + } - public override async Task Parameter_collection_in_subquery_Union_column_collection_nested(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_nested() { // TODO: Subquery pushdown - await AssertTranslationFailed(() => base.Parameter_collection_in_subquery_Union_column_collection_nested(async)); + await AssertTranslationFailed(base.Parameter_collection_in_subquery_Union_column_collection_nested); AssertSql(); } @@ -1766,73 +1547,74 @@ public override void Parameter_collection_in_subquery_and_Convert_as_compiled_qu { // Array indexer over a parameter array ([1,2,3][0]) isn't supported by Cosmos. // TODO: general OFFSET/LIMIT support - AssertTranslationFailed(() => base.Parameter_collection_in_subquery_and_Convert_as_compiled_query()); + AssertTranslationFailed(base.Parameter_collection_in_subquery_and_Convert_as_compiled_query); AssertSql(); } - public override async Task Parameter_collection_in_subquery_Count_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Count_as_compiled_query() { // TODO: #33931 // The ToList inside the query gets executed separately during shaper generation - and synchronously (even in the async // variant of the test), but Cosmos doesn't support sync I/O. So both sync and async variants fail because of unsupported // sync I/O. - await CosmosTestHelpers.Instance.NoSyncTest( - async: false, a => base.Parameter_collection_in_subquery_Count_as_compiled_query(a)); + var exception = await Assert.ThrowsAsync( + base.Parameter_collection_in_subquery_Count_as_compiled_query); + + Assert.Equal(SyncNotSupportedMessage, exception.Message); AssertSql(); } - public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { // TODO: #33931 // The ToList inside the query gets executed separately during shaper generation - and synchronously (even in the async // variant of the test), but Cosmos doesn't support sync I/O. So both sync and async variants fail because of unsupported // sync I/O. - await CosmosTestHelpers.Instance.NoSyncTest( - async: false, a => base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(a)); + var exception = await Assert.ThrowsAsync( + base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query); + + Assert.Equal(SyncNotSupportedMessage, exception.Message); AssertSql(); } - public override async Task Column_collection_in_subquery_Union_parameter_collection(bool async) + public override async Task Column_collection_in_subquery_Union_parameter_collection() { - // TODO: #33931 - // The ToList inside the query gets executed separately during shaper generation - and synchronously (even in the async - // variant of the test), but Cosmos doesn't support sync I/O. So both sync and async variants fail because of unsupported - // sync I/O. - await CosmosTestHelpers.Instance.NoSyncTest( - async: false, a => base.Column_collection_in_subquery_Union_parameter_collection(a)); + await base.Column_collection_in_subquery_Union_parameter_collection(); - AssertSql(); + AssertSql( + """ +@ints='[10,111]' + +SELECT VALUE c +FROM root c +WHERE (ARRAY_LENGTH(SetUnion(ARRAY_SLICE(c["Ints"], 1), @ints)) = 3) +"""); } - public override Task Project_collection_of_ints_simple(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_collection_of_ints_simple(a); + public override async Task Project_collection_of_ints_simple() + { + await base.Project_collection_of_ints_simple(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c["Ints"] FROM root c ORDER BY c["Id"] """); - }); + } - public override async Task Project_collection_of_ints_ordered(bool async) + public override async Task Project_collection_of_ints_ordered() { - // Always throws for sync. - if (async) - { - // 'ORDER BY' is not supported in subqueries. - var exception = await Assert.ThrowsAsync(() => base.Project_collection_of_ints_ordered(async)); + // 'ORDER BY' is not supported in subqueries. + var exception = await Assert.ThrowsAsync(base.Project_collection_of_ints_ordered); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ SELECT VALUE ARRAY( SELECT VALUE i FROM i IN c["Ints"] @@ -1840,17 +1622,14 @@ FROM i IN c["Ints"] FROM root c ORDER BY c["Id"] """); - } } - public override Task Project_collection_of_datetimes_filtered(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_collection_of_datetimes_filtered(a); + public override async Task Project_collection_of_datetimes_filtered() + { + await base.Project_collection_of_datetimes_filtered(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE ARRAY( SELECT VALUE d FROM d IN c["DateTimes"] @@ -1858,82 +1637,84 @@ FROM d IN c["DateTimes"] FROM root c ORDER BY c["Id"] """); - }); + } - public override async Task Project_collection_of_nullable_ints_with_paging(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging() { - // TODO: #33931 - // The ToList inside the query gets executed separately during shaper generation - and synchronously (even in the async - // variant of the test), but Cosmos doesn't support sync I/O. So both sync and async variants fail because of unsupported - // sync I/O. - await CosmosTestHelpers.Instance.NoSyncTest( - async: false, a => base.Project_collection_of_nullable_ints_with_paging(a)); + await base.Project_collection_of_nullable_ints_with_paging(); - AssertSql(); + AssertSql( + """ +SELECT VALUE ARRAY( + SELECT VALUE i + FROM i IN (SELECT VALUE ARRAY_SLICE(c["NullableInts"], 0, 20))) +FROM root c +ORDER BY c["Id"] +"""); } - public override async Task Project_collection_of_nullable_ints_with_paging2(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging2() { - // TODO: #33931 - // The ToList inside the query gets executed separately during shaper generation - and synchronously (even in the async - // variant of the test), but Cosmos doesn't support sync I/O. So both sync and async variants fail because of unsupported - // sync I/O. - await CosmosTestHelpers.Instance.NoSyncTest( - async: false, a => base.Project_collection_of_nullable_ints_with_paging2(a)); + // 'ORDER BY' is not supported in subqueries. + var exception = await Assert.ThrowsAsync(base.Project_collection_of_nullable_ints_with_paging2); - AssertSql(); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + + AssertSql( + """ +SELECT VALUE ARRAY_SLICE(ARRAY( + SELECT VALUE n + FROM n IN c["NullableInts"] + ORDER BY n), 1) +FROM root c +ORDER BY c["Id"] +"""); } - public override async Task Project_collection_of_nullable_ints_with_paging3(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging3() { - // TODO: #33931 - // The ToList inside the query gets executed separately during shaper generation - and synchronously (even in the async - // variant of the test), but Cosmos doesn't support sync I/O. So both sync and async variants fail because of unsupported - // sync I/O. - await CosmosTestHelpers.Instance.NoSyncTest( - async: false, a => base.Project_collection_of_nullable_ints_with_paging3(a)); + await base.Project_collection_of_nullable_ints_with_paging3(); - AssertSql(); + AssertSql( + """ +SELECT VALUE ARRAY_SLICE(c["NullableInts"], 2) +FROM root c +ORDER BY c["Id"] +"""); } - public override Task Project_collection_of_ints_with_distinct(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_collection_of_ints_with_distinct(a); + public override async Task Project_collection_of_ints_with_distinct() + { + await base.Project_collection_of_ints_with_distinct(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE ARRAY( SELECT DISTINCT VALUE i FROM i IN c["Ints"]) FROM root c ORDER BY c["Id"] """); - }); + } - public override Task Project_collection_of_nullable_ints_with_distinct(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_collection_of_nullable_ints_with_distinct(a); + public override async Task Project_collection_of_nullable_ints_with_distinct() + { + await base.Project_collection_of_nullable_ints_with_distinct(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE {"c" : [c["String"], "foo"]} FROM root c WHERE (c["$type"] = "PrimitiveCollectionsEntity") """); - }); + } - public override Task Project_collection_of_ints_with_ToList_and_FirstOrDefault(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(a); + public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault() + { + await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE ARRAY( SELECT VALUE i FROM i IN c["Ints"]) @@ -1941,16 +1722,14 @@ FROM root c ORDER BY c["Id"] OFFSET 0 LIMIT 1 """); - }); + } - public override Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(a); + public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls() + { + await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE { "c" : ARRAY( @@ -1965,19 +1744,16 @@ FROM n0 IN c["NullableInts"] FROM root c ORDER BY c["Id"] """); - }); + } - public override async Task Project_multiple_collections(bool async) + public override async Task Project_multiple_collections() { - // Always throws for sync. - if (async) - { - var exception = await Assert.ThrowsAsync(() => base.Project_multiple_collections(async)); + var exception = await Assert.ThrowsAsync(base.Project_multiple_collections); - Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); + Assert.Equal(HttpStatusCode.BadRequest, exception.StatusCode); - AssertSql( - """ + AssertSql( + """ SELECT VALUE { "c" : ARRAY( @@ -1999,17 +1775,14 @@ FROM d0 IN c["DateTimes"] FROM root c ORDER BY c["Id"] """); - } } - public override Task Project_primitive_collections_element(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_primitive_collections_element(a); + public override async Task Project_primitive_collections_element() + { + await base.Project_primitive_collections_element(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE { "Indexer" : c["Ints"][0], @@ -2020,50 +1793,34 @@ FROM root c WHERE (c["Id"] < 4) ORDER BY c["Id"] """); - }); + } - public override Task Project_inline_collection(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Project_inline_collection(a); + public override async Task Project_inline_collection() + { + await base.Project_inline_collection(); - // The following should be SELECT VALUE [c["String"], "foo"], #33779 - AssertSql( - """ + // The following should be SELECT VALUE [c["String"], "foo"], #33779 + AssertSql( + """ SELECT VALUE [c["String"], "foo"] FROM root c """); - }); + } // Non-correlated queries not supported by Cosmos - public override async Task Project_inline_collection_with_Union(bool async) - { - // Always throws for sync. - if (async) - { - await AssertTranslationFailed(() => base.Project_inline_collection_with_Union(async)); - } - } + public override Task Project_inline_collection_with_Union() + => AssertTranslationFailed(base.Project_inline_collection_with_Union); // Non-correlated queries not supported by Cosmos - public override async Task Project_inline_collection_with_Concat(bool async) - { - // Always throws for sync. - if (async) - { - await AssertTranslationFailed(() => base.Project_inline_collection_with_Concat(async)); - } - } + public override Task Project_inline_collection_with_Concat() + => AssertTranslationFailed(base.Project_inline_collection_with_Concat); - public override Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(a); + public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping() + { + await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(); - AssertSql( - """ + AssertSql( + """ @strings='["one","two","three"]' @ints='[1,2,3]' @@ -2071,16 +1828,14 @@ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@strings, (ARRAY_CONTAINS(@ints, c["Int"]) ? "one" : "two")) """); - }); + } - public override Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(a); + public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping() + { + await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(); - AssertSql( - """ + AssertSql( + """ @strings='["one","two","three"]' @ints='[1,2,3]' @@ -2088,16 +1843,14 @@ SELECT VALUE c FROM root c WHERE ARRAY_CONTAINS(@strings, (ARRAY_CONTAINS(@ints, c["Int"]) ? "one" : "two")) """); - }); + } - public override Task Values_of_enum_casted_to_underlying_value(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await base.Values_of_enum_casted_to_underlying_value(a); + public override async Task Values_of_enum_casted_to_underlying_value() + { + await base.Values_of_enum_casted_to_underlying_value(); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE (( @@ -2105,124 +1858,90 @@ SELECT VALUE COUNT(1) FROM a IN (SELECT VALUE [0, 1, 2, 3]) WHERE (a = c["Int"])) > 0) """); - }); + } #region Cosmos-specific tests - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task IsDefined(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await AssertQuery( - a, - ss => ss.Set().Where(e => EF.Functions.IsDefined(e.Ints[2])), - ss => ss.Set().Where(e => e.Ints.Length >= 3)); + [ConditionalFact] + public virtual async Task IsDefined() + { + await AssertQuery( + ss => ss.Set().Where(e => EF.Functions.IsDefined(e.Ints[2])), + ss => ss.Set().Where(e => e.Ints.Length >= 3)); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE IS_DEFINED(c["Ints"][2]) """); - }); + } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task CoalesceUndefined(bool async) - => CosmosTestHelpers.Instance.NoSyncTest( - async, async a => - { - await AssertQuery( - a, - ss => ss.Set().Where(e => EF.Functions.CoalesceUndefined(e.Ints[2], 999) == 999), - ss => ss.Set().Where(e => e.Ints.Length < 3)); + [ConditionalFact] + public virtual async Task CoalesceUndefined() + { + await AssertQuery( + ss => ss.Set().Where(e => EF.Functions.CoalesceUndefined(e.Ints[2], 999) == 999), + ss => ss.Set().Where(e => e.Ints.Length < 3)); - AssertSql( - """ + AssertSql( + """ SELECT VALUE c FROM root c WHERE ((c["Ints"][2] ?? 999) = 999) """); - }); + } #endregion Cosmos-specific tests - public override async Task Parameter_collection_of_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_struct() { - // Always throws for sync before getting to the exception to test. - if (async) - { - // Requires collections of converted elements - await Assert.ThrowsAsync(() => base.Parameter_collection_of_structs_Contains_struct(async)); + // Requires collections of converted elements + await Assert.ThrowsAsync(base.Parameter_collection_of_structs_Contains_struct); - AssertSql(); - } + AssertSql(); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct() { - // Always throws for sync before getting to the exception to test. - if (async) - { - // Requires collections of converted elements - await Assert.ThrowsAsync(() => base.Parameter_collection_of_structs_Contains_nullable_struct(async)); + // Requires collections of converted elements + await Assert.ThrowsAsync(base.Parameter_collection_of_structs_Contains_nullable_struct); - AssertSql(); - } + AssertSql(); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer() { - // Always throws for sync before getting to the exception to test. - if (async) - { - // Requires collections of converted elements - await Assert.ThrowsAsync( - () => base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(async)); + // Requires collections of converted elements + await Assert.ThrowsAsync( + base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer); - AssertSql(); - } + AssertSql(); } - public override async Task Parameter_collection_of_nullable_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_struct() { - // Always throws for sync before getting to the exception to test. - if (async) - { - // Requires collections of converted elements - await Assert.ThrowsAsync( - () => base.Parameter_collection_of_nullable_structs_Contains_struct(async)); + // Requires collections of converted elements + await Assert.ThrowsAsync(base.Parameter_collection_of_nullable_structs_Contains_struct); - AssertSql(); - } + AssertSql(); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct() { - // Always throws for sync before getting to the exception to test. - if (async) - { - // Requires collections of converted elements - await Assert.ThrowsAsync( - () => base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(async)); + // Requires collections of converted elements + await Assert.ThrowsAsync(base.Parameter_collection_of_nullable_structs_Contains_nullable_struct); - AssertSql(); - } + AssertSql(); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer() { - // Always throws for sync before getting to the exception to test. - if (async) - { - // Requires collections of converted elements - await Assert.ThrowsAsync( - () => base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(async)); + // Requires collections of converted elements + await Assert.ThrowsAsync( + base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer); - AssertSql(); - } + AssertSql(); } [ConditionalFact] @@ -2253,4 +1972,10 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); + + private static readonly string SyncNotSupportedMessage + = CoreStrings.WarningAsErrorTemplate( + CosmosEventId.SyncNotSupported.ToString(), + CosmosResources.LogSyncNotSupported(new TestLogger()).GenerateMessage(), + "CosmosEventId.SyncNotSupported"); } diff --git a/test/EFCore.Relational.Specification.Tests/Query/PrimitiveCollectionsQueryRelationalTestBase.cs b/test/EFCore.Relational.Specification.Tests/Query/PrimitiveCollectionsQueryRelationalTestBase.cs index f4315a0b31d..cfe5406116c 100644 --- a/test/EFCore.Relational.Specification.Tests/Query/PrimitiveCollectionsQueryRelationalTestBase.cs +++ b/test/EFCore.Relational.Specification.Tests/Query/PrimitiveCollectionsQueryRelationalTestBase.cs @@ -8,20 +8,19 @@ namespace Microsoft.EntityFrameworkCore.Query; public class PrimitiveCollectionsQueryRelationalTestBase(TFixture fixture) : PrimitiveCollectionsQueryTestBase(fixture) where TFixture : PrimitiveCollectionsQueryTestBase.PrimitiveCollectionsQueryFixtureBase, new() { - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public override async Task Inline_collection_Count_with_zero_values(bool async) + [ConditionalFact] + public override async Task Inline_collection_Count_with_zero_values() { - var exception = await Assert.ThrowsAsync(() => base.Inline_collection_Count_with_zero_values(async)); + var exception = await Assert.ThrowsAsync(() => base.Inline_collection_Count_with_zero_values()); Assert.Equal(RelationalStrings.EmptyCollectionNotSupportedAsInlineQueryRoot, exception.Message); } - public override Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) - => AssertTranslationFailed(() => base.Column_collection_Concat_parameter_collection_equality_inline_collection(async)); + public override Task Column_collection_Concat_parameter_collection_equality_inline_collection() + => AssertTranslationFailed(base.Column_collection_Concat_parameter_collection_equality_inline_collection); - public override Task Column_collection_equality_inline_collection_with_parameters(bool async) - => AssertTranslationFailed(() => base.Column_collection_equality_inline_collection_with_parameters(async)); + public override Task Column_collection_equality_inline_collection_with_parameters() + => AssertTranslationFailed(base.Column_collection_equality_inline_collection_with_parameters); [ConditionalFact] public override void Parameter_collection_in_subquery_and_Convert_as_compiled_query() @@ -36,24 +35,23 @@ public override void Parameter_collection_in_subquery_and_Convert_as_compiled_qu Assert.Contains("in the SQL tree does not have a type mapping assigned", exception.Message); } - public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { var message = (await Assert.ThrowsAsync( - () => base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(async))).Message; + base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query)).Message; Assert.Equal(RelationalStrings.SetOperationsRequireAtLeastOneSideWithValidTypeMapping("Union"), message); } - public override async Task Project_inline_collection_with_Concat(bool async) + public override async Task Project_inline_collection_with_Concat() { - var message = (await Assert.ThrowsAsync( - () => base.Project_inline_collection_with_Concat(async))).Message; + var message = (await Assert.ThrowsAsync(base.Project_inline_collection_with_Concat)).Message; Assert.Equal(RelationalStrings.InsufficientInformationToIdentifyElementOfCollectionJoin, message); } // TODO: Requires converting the results of a subquery (relational rowset) to a primitive collection for comparison, // not yet supported (#33792) - public override async Task Column_collection_Where_equality_inline_collection(bool async) - => await AssertTranslationFailed(() => base.Column_collection_Where_equality_inline_collection(async)); + public override async Task Column_collection_Where_equality_inline_collection() + => await AssertTranslationFailed(base.Column_collection_Where_equality_inline_collection); } diff --git a/test/EFCore.Specification.Tests/Query/PrimitiveCollectionsQueryTestBase.cs b/test/EFCore.Specification.Tests/Query/PrimitiveCollectionsQueryTestBase.cs index 6c4b2596051..1cdc5d16e96 100644 --- a/test/EFCore.Specification.Tests/Query/PrimitiveCollectionsQueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/PrimitiveCollectionsQueryTestBase.cs @@ -10,130 +10,100 @@ public abstract class PrimitiveCollectionsQueryTestBase(TFixture fixtu { public virtual int? NumberOfValuesForHugeParameterCollectionTests { get; } = null; - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_of_ints_Contains(bool async) + [ConditionalFact] + public virtual Task Inline_collection_of_ints_Contains() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 10, 999 }.Contains(c.Int))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_of_nullable_ints_Contains(bool async) + [ConditionalFact] + public virtual Task Inline_collection_of_nullable_ints_Contains() => AssertQuery( - async, ss => ss.Set().Where(c => new int?[] { 10, 999 }.Contains(c.NullableInt))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_of_nullable_ints_Contains_null(bool async) + [ConditionalFact] + public virtual Task Inline_collection_of_nullable_ints_Contains_null() => AssertQuery( - async, ss => ss.Set().Where(c => new int?[] { null, 999 }.Contains(c.NullableInt))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Count_with_zero_values(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Count_with_zero_values() => AssertQuery( - async, // ReSharper disable once UseArrayEmptyMethod ss => ss.Set().Where(c => new int[0].Count(i => i > c.Id) == 1), assertEmpty: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Count_with_one_value(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Count_with_one_value() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2 }.Count(i => i > c.Id) == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Count_with_two_values(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Count_with_two_values() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2, 999 }.Count(i => i > c.Id) == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Count_with_three_values(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Count_with_three_values() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2, 999, 1000 }.Count(i => i > c.Id) == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_with_zero_values(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_with_zero_values() => AssertQuery( - async, // ReSharper disable once UseArrayEmptyMethod ss => ss.Set().Where(c => new int[0].Contains(c.Id)), assertEmpty: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_with_one_value(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_with_one_value() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2 }.Contains(c.Id))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_with_two_values(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_with_two_values() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2, 999 }.Contains(c.Id))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_with_three_values(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_with_three_values() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2, 999, 1000 }.Contains(c.Id))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_with_all_parameters(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_with_all_parameters() { var (i, j) = (2, 999); return AssertQuery( - async, ss => ss.Set().Where(c => new[] { i, j }.Contains(c.Id))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_with_constant_and_parameter(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_with_constant_and_parameter() { var j = 999; return AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2, j }.Contains(c.Id))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_Contains_with_mixed_value_types(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_Contains_with_mixed_value_types() { // Note: see many nullability-related variations on this in NullSemanticsQueryTestBase var i = 11; await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 999, i, c.Id, c.Id + c.Int }.Contains(c.Int))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_List_Contains_with_mixed_value_types(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_List_Contains_with_mixed_value_types() { var i = 11; await AssertQuery( - async, ss => ss.Set().Where( c => new List { @@ -144,67 +114,51 @@ await AssertQuery( }.Contains(c.Int))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_as_Any_with_predicate(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_as_Any_with_predicate() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2, 999 }.Any(i => i == c.Id))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_negated_Contains_as_All(bool async) + [ConditionalFact] + public virtual Task Inline_collection_negated_Contains_as_All() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 2, 999 }.All(i => i != c.Id))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_Min_with_two_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_Min_with_two_values() => await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.Int }.Min() == 30)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_List_Min_with_two_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_List_Min_with_two_values() => await AssertQuery( - async, ss => ss.Set().Where(c => new List { 30, c.Int }.Min() == 30)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_Max_with_two_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_Max_with_two_values() => await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.Int }.Max() == 30)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_List_Max_with_two_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_List_Max_with_two_values() => await AssertQuery( - async, ss => ss.Set().Where(c => new List { 30, c.Int }.Max() == 30)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_Min_with_three_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_Min_with_three_values() { var i = 25; await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.Int, i }.Min() == 25)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_List_Min_with_three_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_List_Min_with_three_values() { var i = 25; await AssertQuery( - async, ss => ss.Set().Where( c => new List { @@ -215,25 +169,21 @@ await AssertQuery( == 25)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_Max_with_three_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_Max_with_three_values() { var i = 35; await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.Int, i }.Max() == 35)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_List_Max_with_three_values(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_List_Max_with_three_values() { var i = 35; await AssertQuery( - async, ss => ss.Set().Where( c => new List { @@ -244,231 +194,187 @@ await AssertQuery( == 35)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_of_nullable_value_type_Min(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_of_nullable_value_type_Min() { int? i = 25; await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.Int, i }.Min() == 25)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_of_nullable_value_type_Max(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_of_nullable_value_type_Max() { int? i = 35; await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.Int, i }.Max() == 35)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_of_nullable_value_type_with_null_Min() { int? i = null; await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.NullableInt, i }.Min() == 30)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) + [ConditionalFact] + public virtual async Task Inline_collection_of_nullable_value_type_with_null_Max() { int? i = null; await AssertQuery( - async, ss => ss.Set().Where(c => new[] { 30, c.NullableInt, i }.Max() == 30)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_with_single_parameter_element_Contains(bool async) + [ConditionalFact] + public virtual Task Inline_collection_with_single_parameter_element_Contains() { var i = 2; return AssertQuery( - async, ss => ss.Set().Where(c => new[] { i }.Contains(c.Id)), ss => ss.Set().Where(c => new[] { i }.Contains(c.Id))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_with_single_parameter_element_Count(bool async) + [ConditionalFact] + public virtual Task Inline_collection_with_single_parameter_element_Count() { var i = 2; return AssertQuery( - async, ss => ss.Set().Where(c => new[] { i }.Count(i => i > c.Id) == 1), ss => ss.Set().Where(c => new[] { i }.Count(i => i > c.Id) == 1)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Contains_with_EF_Parameter(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Contains_with_EF_Parameter() => AssertQuery( - async, ss => ss.Set().Where(c => EF.Parameter(new[] { 2, 999, 1000 }).Contains(c.Id)), ss => ss.Set().Where(c => new[] { 2, 999, 1000 }.Contains(c.Id))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Count_with_column_predicate_with_EF_Parameter(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Count_with_column_predicate_with_EF_Parameter() => AssertQuery( - async, ss => ss.Set().Where(c => EF.Parameter(new[] { 2, 999, 1000 }).Count(i => i > c.Id) == 2), ss => ss.Set().Where(c => new[] { 2, 999, 1000 }.Count(i => i > c.Id) == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_Count(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_Count() { var ids = new[] { 2, 999 }; return AssertQuery( - async, ss => ss.Set().Where(c => ids.Count(i => i > c.Id) == 1)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_ints_Contains_int(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_ints_Contains_int() { var ints = new[] { 10, 999 }; await AssertQuery( - async, ss => ss.Set().Where(c => ints.Contains(c.Int))); await AssertQuery( - async, ss => ss.Set().Where(c => !ints.Contains(c.Int))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_HashSet_of_ints_Contains_int() { var ints = new HashSet { 10, 999 }; await AssertQuery( - async, ss => ss.Set().Where(c => ints.Contains(c.Int))); await AssertQuery( - async, ss => ss.Set().Where(c => !ints.Contains(c.Int))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_ImmutableArray_of_ints_Contains_int(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_ImmutableArray_of_ints_Contains_int() { var ints = ImmutableArray.Create([10, 999]); await AssertQuery( - async, ss => ss.Set().Where(c => ints.Contains(c.Int))); await AssertQuery( - async, ss => ss.Set().Where(c => !ints.Contains(c.Int))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_ints_Contains_nullable_int(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_ints_Contains_nullable_int() { var ints = new[] { 10, 999 }; await AssertQuery( - async, ss => ss.Set().Where(c => ints.Contains(c.NullableInt!.Value)), ss => ss.Set().Where(c => c.NullableInt != null && ints.Contains(c.NullableInt!.Value))); await AssertQuery( - async, ss => ss.Set().Where(c => !ints.Contains(c.NullableInt!.Value)), ss => ss.Set().Where(c => c.NullableInt == null || !ints.Contains(c.NullableInt!.Value))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_nullable_ints_Contains_int(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_nullable_ints_Contains_int() { var nullableInts = new int?[] { 10, 999 }; await AssertQuery( - async, ss => ss.Set().Where(c => nullableInts.Contains(c.Int))); await AssertQuery( - async, ss => ss.Set().Where(c => !nullableInts.Contains(c.Int))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_nullable_ints_Contains_nullable_int(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_nullable_ints_Contains_nullable_int() { var nullableInts = new int?[] { null, 999 }; await AssertQuery( - async, ss => ss.Set().Where(c => nullableInts.Contains(c.NullableInt))); await AssertQuery( - async, ss => ss.Set().Where(c => !nullableInts.Contains(c.NullableInt))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_structs_Contains_struct(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_structs_Contains_struct() { var values = new List { new(22), new(33) }; await AssertQuery( - async, ss => ss.Set().Where(c => values.Contains(c.WrappedId))); values = new List { new(11), new(44) }; await AssertQuery( - async, ss => ss.Set().Where(c => !values.Contains(c.WrappedId))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_structs_Contains_nullable_struct(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_structs_Contains_nullable_struct() { var values = new List { new(22), new(33) }; await AssertQuery( - async, ss => ss.Set().Where(c => values.Contains(c.NullableWrappedId!.Value)), ss => ss.Set().Where(c => c.NullableWrappedId != null && values.Contains(c.NullableWrappedId.Value))); values = new List { new(11), new(44) }; await AssertQuery( - async, ss => ss.Set().Where(c => !values.Contains(c.NullableWrappedId!.Value)), ss => ss.Set().Where(c => c.NullableWrappedId == null || !values.Contains(c.NullableWrappedId!.Value))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] // Issue #35117 - public virtual async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + [ConditionalFact] // Issue #35117 + public virtual async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer() { var values = new List { new(22), new(33) }; await AssertQuery( - async, ss => ss.Set().Where(c => values.Contains(c.NullableWrappedIdWithNullableComparer!.Value)), ss => ss.Set().Where( c => c.NullableWrappedIdWithNullableComparer != null && values.Contains(c.NullableWrappedIdWithNullableComparer.Value))); @@ -476,124 +382,101 @@ await AssertQuery( values = new List { new(11), new(44) }; await AssertQuery( - async, ss => ss.Set().Where(c => !values.Contains(c.NullableWrappedId!.Value)), ss => ss.Set().Where( c => c.NullableWrappedIdWithNullableComparer == null || !values.Contains(c.NullableWrappedIdWithNullableComparer!.Value))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_nullable_structs_Contains_struct(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_nullable_structs_Contains_struct() { var values = new List { null, new(22) }; await AssertQuery( - async, ss => ss.Set().Where(c => values.Contains(c.WrappedId))); values = new List { new(11), new(44) }; await AssertQuery( - async, ss => ss.Set().Where(c => !values.Contains(c.WrappedId))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct() { var values = new List { null, new(22) }; await AssertQuery( - async, ss => ss.Set().Where(c => values.Contains(c.NullableWrappedId))); values = new List { new(11), new(44) }; await AssertQuery( - async, ss => ss.Set().Where(c => !values.Contains(c.NullableWrappedId))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer() { var values = new List { null, new(22) }; await AssertQuery( - async, ss => ss.Set().Where(c => values.Contains(c.NullableWrappedIdWithNullableComparer))); values = new List { new(11), new(44) }; await AssertQuery( - async, ss => ss.Set().Where(c => !values.Contains(c.NullableWrappedIdWithNullableComparer))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_strings_Contains_string(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_strings_Contains_string() { var strings = new[] { "10", "999" }; await AssertQuery( - async, ss => ss.Set().Where(c => strings.Contains(c.String))); await AssertQuery( - async, ss => ss.Set().Where(c => !strings.Contains(c.String))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_strings_Contains_nullable_string(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_strings_Contains_nullable_string() { string?[] strings = ["10", "999"]; await AssertQuery( - async, ss => ss.Set().Where(c => strings.Contains(c.NullableString))); await AssertQuery( - async, ss => ss.Set().Where(c => !strings.Contains(c.NullableString))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_nullable_strings_Contains_string(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_nullable_strings_Contains_string() { var strings = new[] { "10", null }; await AssertQuery( - async, ss => ss.Set().Where(c => strings.Contains(c.String))); await AssertQuery( - async, ss => ss.Set().Where(c => !strings.Contains(c.String))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_nullable_strings_Contains_nullable_string(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_nullable_strings_Contains_nullable_string() { var strings = new[] { "999", null }; await AssertQuery( - async, ss => ss.Set().Where(c => strings.Contains(c.NullableString))); await AssertQuery( - async, ss => ss.Set().Where(c => !strings.Contains(c.NullableString))); } // See more nullability-related tests in NullSemanticsQueryTestBase - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_of_DateTimes_Contains(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_of_DateTimes_Contains() { var dateTimes = new[] { @@ -601,84 +484,70 @@ public virtual Task Parameter_collection_of_DateTimes_Contains(bool async) }; return AssertQuery( - async, ss => ss.Set().Where(c => dateTimes.Contains(c.DateTime))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_of_bools_Contains(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_of_bools_Contains() { var bools = new[] { true }; return AssertQuery( - async, ss => ss.Set().Where(c => bools.Contains(c.Bool))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_of_enums_Contains(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_of_enums_Contains() { var enums = new[] { MyEnum.Value1, MyEnum.Value4 }; return AssertQuery( - async, ss => ss.Set().Where(c => enums.Contains(c.Enum))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_null_Contains(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_null_Contains() { int[]? ints = null; await AssertQuery( - async, ss => ss.Set().Where(c => ints!.Contains(c.Int)), ss => ss.Set().Where(c => false), assertEmpty: true); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_Contains_with_EF_Constant(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_Contains_with_EF_Constant() { var ids = new[] { 2, 999, 1000 }; return AssertQuery( - async, ss => ss.Set().Where(c => EF.Constant(ids).Contains(c.Id)), ss => ss.Set().Where(c => ids.Contains(c.Id))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_Where_with_EF_Constant_Where_Any() { var ids = new[] { 2, 999, 1000 }; return AssertQuery( - async, ss => ss.Set().Where(c => EF.Constant(ids).Where(x => x > 0).Any()), ss => ss.Set().Where(c => ids.Where(x => x > 0).Any())); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_Count_with_column_predicate_with_EF_Constant() { var ids = new[] { 2, 999, 1000 }; return AssertQuery( - async, ss => ss.Set().Where(c => EF.Constant(ids).Count(i => i > c.Id) == 2), ss => ss.Set().Where(c => ids.Count(i => i > c.Id) == 2)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_Count_with_huge_number_of_values(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_Count_with_huge_number_of_values() { if (NumberOfValuesForHugeParameterCollectionTests is null) { @@ -689,13 +558,11 @@ public virtual Task Parameter_collection_Count_with_huge_number_of_values(bool a var ids = new[] { 2, 999 }.Concat(extra).ToArray(); return AssertQuery( - async, ss => ss.Set().Where(c => ids.Count(i => i > c.Id) > 0)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values() { if (NumberOfValuesForHugeParameterCollectionTests is null) { @@ -706,162 +573,122 @@ public virtual async Task Parameter_collection_of_ints_Contains_int_with_huge_nu var ints = new[] { 10, 999 }.Concat(extra).ToArray(); await AssertQuery( - async, ss => ss.Set().Where(c => ints.Contains(c.Int))); await AssertQuery( - async, ss => ss.Set().Where(c => !ints.Contains(c.Int))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_of_ints_Contains(bool async) + [ConditionalFact] + public virtual Task Column_collection_of_ints_Contains() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Contains(10))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_of_nullable_ints_Contains(bool async) + [ConditionalFact] + public virtual Task Column_collection_of_nullable_ints_Contains() => AssertQuery( - async, ss => ss.Set().Where(c => c.NullableInts.Contains(10))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_of_nullable_ints_Contains_null(bool async) + [ConditionalFact] + public virtual Task Column_collection_of_nullable_ints_Contains_null() => AssertQuery( - async, ss => ss.Set().Where(c => c.NullableInts.Contains(null))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_of_strings_contains_null(bool async) + [ConditionalFact] + public virtual Task Column_collection_of_strings_contains_null() => AssertQuery( - async, ss => ss.Set().Where(c => ((string?[])c.Strings).Contains(null)), assertEmpty: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_of_nullable_strings_contains_null(bool async) + [ConditionalFact] + public virtual Task Column_collection_of_nullable_strings_contains_null() => AssertQuery( - async, ss => ss.Set().Where(c => c.NullableStrings.Contains(null))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_of_bools_Contains(bool async) + [ConditionalFact] + public virtual Task Column_collection_of_bools_Contains() => AssertQuery( - async, ss => ss.Set().Where(c => c.Bools.Contains(true))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Count_method(bool async) + [ConditionalFact] + public virtual Task Column_collection_Count_method() => AssertQuery( - async, // ReSharper disable once UseCollectionCountProperty ss => ss.Set().Where(c => c.Ints.Count() == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Length(bool async) + [ConditionalFact] + public virtual Task Column_collection_Length() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Length == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Count_with_predicate(bool async) + [ConditionalFact] + public virtual Task Column_collection_Count_with_predicate() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Count(i => i > 1) == 2)); - [ConditionalTheory] // #33932 - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Where_Count(bool async) + [ConditionalFact] // #33932 + public virtual Task Column_collection_Where_Count() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Where(i => i > 1).Count() == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_index_int(bool async) + [ConditionalFact] + public virtual Task Column_collection_index_int() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints[1] == 10), ss => ss.Set().Where(c => (c.Ints.Length >= 2 ? c.Ints[1] : -1) == 10)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_index_string(bool async) + [ConditionalFact] + public virtual Task Column_collection_index_string() => AssertQuery( - async, ss => ss.Set().Where(c => c.Strings[1] == "10"), ss => ss.Set().Where(c => (c.Strings.Length >= 2 ? c.Strings[1] : "-1") == "10")); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_index_datetime(bool async) + [ConditionalFact] + public virtual Task Column_collection_index_datetime() => AssertQuery( - async, ss => ss.Set().Where( c => c.DateTimes[1] == new DateTime(2020, 1, 10, 12, 30, 0, DateTimeKind.Utc)), ss => ss.Set().Where( c => (c.DateTimes.Length >= 2 ? c.DateTimes[1] : default) == new DateTime(2020, 1, 10, 12, 30, 0, DateTimeKind.Utc))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_index_beyond_end(bool async) + [ConditionalFact] + public virtual Task Column_collection_index_beyond_end() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints[999] == 10), ss => ss.Set().Where(c => false), assertEmpty: true); // TODO: This test is incorrect, see #33784 - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Nullable_reference_column_collection_index_equals_nullable_column(bool async) + [ConditionalFact] + public virtual Task Nullable_reference_column_collection_index_equals_nullable_column() => AssertQuery( - async, ss => ss.Set() .Where(c => c.NullableStrings[2] == c.NullableString), ss => ss.Set() .Where(c => (c.NullableStrings.Length > 2 ? c.NullableStrings[2] : default) == c.NullableString)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Non_nullable_reference_column_collection_index_equals_nullable_column(bool async) + [ConditionalFact] + public virtual Task Non_nullable_reference_column_collection_index_equals_nullable_column() => AssertQuery( - async, ss => ss.Set() .Where(c => c.Strings.Any() && c.Strings[1] == c.NullableString), ss => ss.Set() .Where(c => c.Strings.Any() && (c.Strings.Length > 1 ? c.Strings[1] : default) == c.NullableString)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_index_Column(bool async) + [ConditionalFact] + public virtual Task Inline_collection_index_Column() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 1, 2, 3 }[c.Int] == 1), ss => ss.Set().Where(c => (c.Int <= 2 ? new[] { 1, 2, 3 }[c.Int] : -1) == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_value_index_Column(bool async) + [ConditionalFact] + public virtual Task Inline_collection_value_index_Column() => AssertQuery( - async, ss => ss.Set().Where(c => new[] { 1, c.Int, 3 }[c.Int] == 1), ss => ss.Set().Where(c => (c.Int <= 2 ? new[] { 1, c.Int, 3 }[c.Int] : -1) == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_List_value_index_Column(bool async) + [ConditionalFact] + public virtual Task Inline_collection_List_value_index_Column() => AssertQuery( - async, ss => ss.Set().Where( c => new List { @@ -883,145 +710,111 @@ public virtual Task Inline_collection_List_value_index_Column(bool async) // The JsonScalarExpression (ints[c.Int]) should get inferred from the column on the other side (c.Int), and that should propagate to // ints - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_index_Column_equal_Column(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_index_Column_equal_Column() { var ints = new[] { 0, 2, 3 }; return AssertQuery( - async, ss => ss.Set().Where(c => ints[c.Int] == c.Int), ss => ss.Set().Where(c => (c.Int <= 2 ? ints[c.Int] : -1) == c.Int)); } // Since the JsonScalarExpression (ints[c.Int]) is being compared to a constant, there's nothing to infer the type mapping from. // ints should get the default type mapping for based on its CLR type. - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_index_Column_equal_constant(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_index_Column_equal_constant() { var ints = new[] { 1, 2, 3 }; return AssertQuery( - async, ss => ss.Set().Where(c => ints[c.Int] == 1), ss => ss.Set().Where(c => (c.Int <= 2 ? ints[c.Int] : -1) == 1)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_ElementAt(bool async) + [ConditionalFact] + public virtual Task Column_collection_ElementAt() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.ElementAt(1) == 10), ss => ss.Set().Where(c => (c.Ints.Length >= 2 ? c.Ints.ElementAt(1) : -1) == 10)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_First(bool async) + [ConditionalFact] + public virtual Task Column_collection_First() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.First() == 1), ss => ss.Set().Where(c => (c.Ints.Length >= 1 ? c.Ints.First() : -1) == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_FirstOrDefault(bool async) + [ConditionalFact] + public virtual Task Column_collection_FirstOrDefault() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.FirstOrDefault() == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Single(bool async) + [ConditionalFact] + public virtual Task Column_collection_Single() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Single() == 1), ss => ss.Set().Where(c => (c.Ints.Length >= 1 ? c.Ints.First() : -1) == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_SingleOrDefault(bool async) + [ConditionalFact] + public virtual Task Column_collection_SingleOrDefault() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.SingleOrDefault() == 1), ss => ss.Set().Where(c => (c.Ints.Length >= 1 ? c.Ints[0] : -1) == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Skip(bool async) + [ConditionalFact] + public virtual Task Column_collection_Skip() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Skip(1).Count() == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Take(bool async) + [ConditionalFact] + public virtual Task Column_collection_Take() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Take(2).Contains(11))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Skip_Take(bool async) + [ConditionalFact] + public virtual Task Column_collection_Skip_Take() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Skip(1).Take(2).Contains(11))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Where_Skip(bool async) + [ConditionalFact] + public virtual Task Column_collection_Where_Skip() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Where(i => i > 1).Skip(1).Count() == 3)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Where_Take(bool async) + [ConditionalFact] + public virtual Task Column_collection_Where_Take() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Where(i => i > 1).Take(2).Count() == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Where_Skip_Take(bool async) + [ConditionalFact] + public virtual Task Column_collection_Where_Skip_Take() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Where(i => i > 1).Skip(1).Take(2).Count() == 1)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Contains_over_subquery(bool async) + [ConditionalFact] + public virtual Task Column_collection_Contains_over_subquery() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Where(i => i > 1).Contains(11))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_OrderByDescending_ElementAt(bool async) + [ConditionalFact] + public virtual Task Column_collection_OrderByDescending_ElementAt() => AssertQuery( - async, ss => ss.Set() .Where(c => c.Ints.OrderByDescending(i => i).ElementAt(0) == 111), ss => ss.Set() .Where(c => c.Ints.Length > 0 && c.Ints.OrderByDescending(i => i).ElementAt(0) == 111)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Where_ElementAt(bool async) + [ConditionalFact] + public virtual Task Column_collection_Where_ElementAt() => AssertQuery( - async, ss => ss.Set() .Where(c => c.Ints.Where(i => i > 1).ElementAt(0) == 11), ss => ss.Set() .Where(c => c.Ints.Where(i => i > 1).FirstOrDefault(0) == 11)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Any(bool async) + [ConditionalFact] + public virtual Task Column_collection_Any() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Any())); // If this test is failing because of DistinctAfterOrderByWithoutRowLimitingOperatorWarning, this is because EF warns/errors by @@ -1029,175 +822,138 @@ public virtual Task Column_collection_Any(bool async) // ordering has been added by the provider as part of the collection translation. // Consider overriding RelationalQueryableMethodTranslatingExpressionVisitor.IsNaturallyOrdered() to identify such naturally-ordered // collections, exempting them from the warning. - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Distinct(bool async) + [ConditionalFact] + public virtual Task Column_collection_Distinct() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Distinct().Count() == 3)); - [ConditionalTheory] // #32505 - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_SelectMany(bool async) + [ConditionalFact] // #32505 + public virtual Task Column_collection_SelectMany() => AssertQuery( - async, ss => ss.Set().SelectMany(c => c.Ints)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_SelectMany_with_filter(bool async) + [ConditionalFact] + public virtual Task Column_collection_SelectMany_with_filter() => AssertQuery( - async, ss => ss.Set().SelectMany(c => c.Ints.Where(i => i > 1))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) + [ConditionalFact] + public virtual Task Column_collection_SelectMany_with_Select_to_anonymous_type() => AssertQuery( - async, ss => ss.Set().SelectMany(c => c.Ints.Select(i => new { Original = i, Incremented = i + 1 }))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_projection_from_top_level(bool async) + [ConditionalFact] + public virtual Task Column_collection_projection_from_top_level() => AssertQuery( - async, ss => ss.Set().OrderBy(c => c.Id).Select(c => c.Ints), elementAsserter: (a, b) => Assert.Equivalent(a, b), assertOrder: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Join_parameter_collection(bool async) + [ConditionalFact] + public virtual Task Column_collection_Join_parameter_collection() { var ints = new[] { 11, 111 }; return AssertQuery( - async, ss => ss.Set() .Where(c => c.Ints.Join(ints, i => i, j => j, (i, j) => new { I = i, J = j }).Count() == 2)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Join_ordered_column_collection(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Join_ordered_column_collection() => AssertQuery( - async, ss => ss.Set() .Where(c => new[] { 11, 111 }.Join(c.Ints, i => i, j => j, (i, j) => new { I = i, J = j }).Count() == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_Concat_column_collection(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_Concat_column_collection() { int[] ints = [11, 111]; return AssertQuery( - async, ss => ss.Set().Where(c => ints.Concat(c.Ints).Count() == 2)); } - [ConditionalTheory] // #33582 - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) + [ConditionalFact] // #33582 + public virtual Task Parameter_collection_with_type_inference_for_JsonScalarExpression() { string[] values = ["one", "two"]; return AssertQuery( - async, ss => ss.Set().Select(c => c.Id != 0 ? values[c.Int % 2] : "foo")); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Union_parameter_collection(bool async) + [ConditionalFact] + public virtual Task Column_collection_Union_parameter_collection() { var ints = new[] { 11, 111 }; return AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Union(ints).Count() == 2)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Intersect_inline_collection(bool async) + [ConditionalFact] + public virtual Task Column_collection_Intersect_inline_collection() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Intersect(new[] { 11, 111 }).Count() == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Inline_collection_Except_column_collection(bool async) + [ConditionalFact] + public virtual Task Inline_collection_Except_column_collection() // Note that in relational, since the VALUES is on the left side of the set operation, it must assign column names, otherwise the // column coming out of the set operation has undetermined naming. => AssertQuery( - async, ss => ss.Set().Where( c => new[] { 11, 111 }.Except(c.Ints).Count(i => i % 2 == 1) == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Where_Union(bool async) + [ConditionalFact] + public virtual Task Column_collection_Where_Union() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Where(i => i > 100).Union(new[] { 50 }).Count() == 2)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_equality_parameter_collection(bool async) + [ConditionalFact] + public virtual Task Column_collection_equality_parameter_collection() { var ints = new[] { 1, 10 }; return AssertQuery( - async, ss => ss.Set().Where(c => c.Ints == ints), ss => ss.Set().Where(c => c.Ints.SequenceEqual(ints))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) + [ConditionalFact] + public virtual async Task Column_collection_Concat_parameter_collection_equality_inline_collection() { var ints = new[] { 1, 10 }; await AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Concat(ints) == new[] { 1, 11, 111, 1, 10 }), ss => ss.Set().Where(c => c.Ints.Concat(ints).SequenceEqual(new[] { 1, 11, 111, 1, 10 }))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_equality_inline_collection(bool async) + [ConditionalFact] + public virtual Task Column_collection_equality_inline_collection() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints == new[] { 1, 10 }), ss => ss.Set().Where(c => c.Ints.SequenceEqual(new[] { 1, 10 }))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Column_collection_equality_inline_collection_with_parameters(bool async) + [ConditionalFact] + public virtual async Task Column_collection_equality_inline_collection_with_parameters() { var (i, j) = (1, 10); await AssertQuery( - async, ss => ss.Set().Where(c => c.Ints == new[] { i, j }), ss => ss.Set().Where(c => c.Ints.SequenceEqual(new[] { i, j }))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_Where_equality_inline_collection(bool async) + [ConditionalFact] + public virtual Task Column_collection_Where_equality_inline_collection() => AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Where(i => i != 11) == new[] { 1, 111 }), ss => ss.Set().Where(c => c.Ints.Where(i => i != 11).SequenceEqual(new[] { 1, 111 }))); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_in_subquery_Count_as_compiled_query(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_in_subquery_Count_as_compiled_query() { // The Skip causes a pushdown into a subquery before the Union, and so the projection on the left side of the union points to the // subquery as its table, and not directly to the parameter's table. @@ -1214,9 +970,8 @@ public virtual async Task Parameter_collection_in_subquery_Count_as_compiled_que var results = compiledQuery(context, ints); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query() { // The Skip causes a pushdown into a subquery before the Union, and so the projection on the left side of the union points to the // subquery as its table, and not directly to the parameter's table. @@ -1233,25 +988,21 @@ public virtual async Task Parameter_collection_in_subquery_Union_column_collecti var results = compiledQuery(context, ints).ToList(); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_in_subquery_Union_column_collection(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_in_subquery_Union_column_collection() { var ints = new[] { 10, 111 }; return AssertQuery( - async, ss => ss.Set().Where(p => ints.Skip(1).Union(p.Ints).Count() == 3)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Parameter_collection_in_subquery_Union_column_collection_nested(bool async) + [ConditionalFact] + public virtual Task Parameter_collection_in_subquery_Union_column_collection_nested() { var ints = new[] { 10, 111 }; return AssertQuery( - async, ss => ss.Set().Where( p => ints.Skip(1).Union(p.Ints.OrderBy(x => x).Skip(1).Distinct().OrderByDescending(x => x).Take(20)).Count() == 3)); } @@ -1268,9 +1019,8 @@ public virtual void Parameter_collection_in_subquery_and_Convert_as_compiled_que _ = query(context, ["foo"]).ToList(); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + [ConditionalFact] + public virtual async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { var compiledQuery = EF.CompileQuery( (PrimitiveCollectionsContext context, int[] ints1, int[] ints2) @@ -1283,104 +1033,82 @@ public virtual async Task Parameter_collection_in_subquery_Union_another_paramet _ = compiledQuery(context, ints1, ints2).ToList(); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Column_collection_in_subquery_Union_parameter_collection(bool async) + [ConditionalFact] + public virtual Task Column_collection_in_subquery_Union_parameter_collection() { var ints = new[] { 10, 111 }; // The Skip causes a pushdown into a subquery before the Union. This creates an initially untyped ColumnExpression referencing the // pushed-down subquery; it must also be inferred return AssertQuery( - async, ss => ss.Set().Where(c => c.Ints.Skip(1).Union(ints).Count() == 3)); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_ints_simple(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_ints_simple() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.Ints), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, ordered: true)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_ints_ordered(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_ints_ordered() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.Ints.OrderByDescending(xx => xx).ToList()), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, ordered: true)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_datetimes_filtered(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_datetimes_filtered() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.DateTimes.Where(xx => xx.Day != 1).ToList()), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, elementSorter: ee => ee)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_nullable_ints_with_paging(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_nullable_ints_with_paging() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.NullableInts.Take(20).ToList()), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, elementSorter: ee => ee)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_nullable_ints_with_paging2(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_nullable_ints_with_paging2() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.NullableInts.OrderBy(x => x).Skip(1).ToList()), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, elementSorter: ee => ee)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_nullable_ints_with_paging3(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_nullable_ints_with_paging3() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.NullableInts.Skip(2).ToList()), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, elementSorter: ee => ee)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_ints_with_distinct(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_ints_with_distinct() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.Ints.Distinct().ToList()), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, elementSorter: ee => ee)); - [ConditionalTheory(Skip = "issue #31277")] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_nullable_ints_with_distinct(bool async) + [ConditionalFact(Skip = "issue #31277")] + public virtual Task Project_collection_of_nullable_ints_with_distinct() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.NullableInts.Distinct().ToList()), assertOrder: true, elementAsserter: (e, a) => AssertCollection(e, a, elementSorter: ee => ee)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_collection_of_ints_with_ToList_and_FirstOrDefault(bool async) + [ConditionalFact] + public virtual Task Project_collection_of_ints_with_ToList_and_FirstOrDefault() => AssertFirstOrDefault( - async, ss => ss.Set().OrderBy(x => x.Id).Select(x => x.Ints.ToList()), asserter: (e, a) => AssertCollection(e, a, elementSorter: ee => ee)); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls(bool async) + [ConditionalFact] + public virtual Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select( x => new { @@ -1393,11 +1121,9 @@ public virtual Task Project_empty_collection_of_nullables_and_collection_only_co AssertCollection(e.OnlyNull, a.OnlyNull, ordered: true); }); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_multiple_collections(bool async) + [ConditionalFact] + public virtual Task Project_multiple_collections() => AssertQuery( - async, ss => ss.Set().OrderBy(x => x.Id).Select( x => new { @@ -1415,11 +1141,9 @@ public virtual Task Project_multiple_collections(bool async) }, assertOrder: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_primitive_collections_element(bool async) + [ConditionalFact] + public virtual Task Project_primitive_collections_element() => AssertQuery( - async, ss => ss.Set().Where(x => x.Id < 4).OrderBy(x => x.Id).Select( x => new { @@ -1435,20 +1159,16 @@ public virtual Task Project_primitive_collections_element(bool async) }, assertOrder: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_inline_collection(bool async) + [ConditionalFact] + public virtual Task Project_inline_collection() => AssertQuery( - async, ss => ss.Set().Select(x => new[] { x.String, "foo" }), elementAsserter: (e, a) => AssertCollection(e, a, ordered: true), assertOrder: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_inline_collection_with_Union(bool async) + [ConditionalFact] + public virtual Task Project_inline_collection_with_Union() => AssertQuery( - async, ss => ss.Set() .Select( x => new @@ -1465,11 +1185,9 @@ public virtual Task Project_inline_collection_with_Union(bool async) }, assertOrder: true); - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Project_inline_collection_with_Concat(bool async) + [ConditionalFact] + public virtual Task Project_inline_collection_with_Concat() => AssertQuery( - async, ss => ss.Set() .Select( x => new @@ -1486,9 +1204,8 @@ public virtual Task Project_inline_collection_with_Concat(bool async) }, assertOrder: true); - [ConditionalTheory] // #32208, #32215 - [MemberData(nameof(IsAsyncData))] - public virtual Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async) + [ConditionalFact] // #32208, #32215 + public virtual Task Nested_contains_with_Lists_and_no_inferred_type_mapping() { var ints = new List { @@ -1506,13 +1223,11 @@ public virtual Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool // Note that in this query, the outer Contains really has no type mapping, neither for its source (collection parameter), nor // for its item (the conditional expression returns constants). The default type mapping must be applied. return AssertQuery( - async, ss => ss.Set().Where(e => strings.Contains(ints.Contains(e.Int) ? "one" : "two"))); } - [ConditionalTheory] // #32208, #32215 - [MemberData(nameof(IsAsyncData))] - public virtual Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async) + [ConditionalFact] // #32208, #32215 + public virtual Task Nested_contains_with_arrays_and_no_inferred_type_mapping() { var ints = new[] { 1, 2, 3 }; var strings = new[] { "one", "two", "three" }; @@ -1520,15 +1235,12 @@ public virtual Task Nested_contains_with_arrays_and_no_inferred_type_mapping(boo // Note that in this query, the outer Contains really has no type mapping, neither for its source (collection parameter), nor // for its item (the conditional expression returns constants). The default type mapping must be applied. return AssertQuery( - async, ss => ss.Set().Where(e => strings.Contains(ints.Contains(e.Int) ? "one" : "two"))); } - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public virtual Task Values_of_enum_casted_to_underlying_value(bool async) + [ConditionalFact] + public virtual Task Values_of_enum_casted_to_underlying_value() => AssertQuery( - async, ss => ss.Set().Where(x => Enum.GetValues().Cast().Count(y => y == x.Int) > 0)); public abstract class PrimitiveCollectionsQueryFixtureBase : SharedStoreFixtureBase, IQueryFixtureBase diff --git a/test/EFCore.Specification.Tests/Query/QueryTestBase.cs b/test/EFCore.Specification.Tests/Query/QueryTestBase.cs index ce4ee35feae..8f452a5e099 100644 --- a/test/EFCore.Specification.Tests/Query/QueryTestBase.cs +++ b/test/EFCore.Specification.Tests/Query/QueryTestBase.cs @@ -283,6 +283,11 @@ protected Task AssertFirst( => TestOutputWrapper( () => QueryAsserter.AssertFirst(actualQuery, expectedQuery, actualPredicate, expectedPredicate, asserter, async)); + protected Task AssertFirstOrDefault( + Func> query, + Action? asserter = null) + => AssertFirstOrDefault(async: true, query, asserter); + protected Task AssertFirstOrDefault( bool async, Func> query, diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQueryOldSqlServerTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQueryOldSqlServerTest.cs index 795d7894553..4d85180064d 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQueryOldSqlServerTest.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQueryOldSqlServerTest.cs @@ -26,9 +26,9 @@ public PrimitiveCollectionsQueryOldSqlServerTest( Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override async Task Inline_collection_of_ints_Contains(bool async) + public override async Task Inline_collection_of_ints_Contains() { - await base.Inline_collection_of_ints_Contains(async); + await base.Inline_collection_of_ints_Contains(); AssertSql( """ @@ -38,9 +38,9 @@ WHERE [p].[Int] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains() { - await base.Inline_collection_of_nullable_ints_Contains(async); + await base.Inline_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -50,9 +50,9 @@ WHERE [p].[NullableInt] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains_null() { - await base.Inline_collection_of_nullable_ints_Contains_null(async); + await base.Inline_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -62,16 +62,16 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Count_with_zero_values(bool async) + public override async Task Inline_collection_Count_with_zero_values() { - await base.Inline_collection_Count_with_zero_values(async); + await base.Inline_collection_Count_with_zero_values(); AssertSql(); } - public override async Task Inline_collection_Count_with_one_value(bool async) + public override async Task Inline_collection_Count_with_one_value() { - await base.Inline_collection_Count_with_one_value(async); + await base.Inline_collection_Count_with_one_value(); AssertSql( """ @@ -84,9 +84,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_two_values(bool async) + public override async Task Inline_collection_Count_with_two_values() { - await base.Inline_collection_Count_with_two_values(async); + await base.Inline_collection_Count_with_two_values(); AssertSql( """ @@ -99,9 +99,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_three_values(bool async) + public override async Task Inline_collection_Count_with_three_values() { - await base.Inline_collection_Count_with_three_values(async); + await base.Inline_collection_Count_with_three_values(); AssertSql( """ @@ -114,9 +114,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_zero_values(bool async) + public override async Task Inline_collection_Contains_with_zero_values() { - await base.Inline_collection_Contains_with_zero_values(async); + await base.Inline_collection_Contains_with_zero_values(); AssertSql( """ @@ -126,9 +126,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_one_value(bool async) + public override async Task Inline_collection_Contains_with_one_value() { - await base.Inline_collection_Contains_with_one_value(async); + await base.Inline_collection_Contains_with_one_value(); AssertSql( """ @@ -138,9 +138,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_two_values(bool async) + public override async Task Inline_collection_Contains_with_two_values() { - await base.Inline_collection_Contains_with_two_values(async); + await base.Inline_collection_Contains_with_two_values(); AssertSql( """ @@ -150,9 +150,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_Contains_with_three_values(bool async) + public override async Task Inline_collection_Contains_with_three_values() { - await base.Inline_collection_Contains_with_three_values(async); + await base.Inline_collection_Contains_with_three_values(); AssertSql( """ @@ -162,9 +162,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Inline_collection_Contains_with_all_parameters(bool async) + public override async Task Inline_collection_Contains_with_all_parameters() { - await base.Inline_collection_Contains_with_all_parameters(async); + await base.Inline_collection_Contains_with_all_parameters(); AssertSql( """ @@ -177,9 +177,9 @@ WHERE [p].[Id] IN (@i, @j) """); } - public override async Task Inline_collection_Contains_with_constant_and_parameter(bool async) + public override async Task Inline_collection_Contains_with_constant_and_parameter() { - await base.Inline_collection_Contains_with_constant_and_parameter(async); + await base.Inline_collection_Contains_with_constant_and_parameter(); AssertSql( """ @@ -191,9 +191,9 @@ WHERE [p].[Id] IN (2, @j) """); } - public override async Task Inline_collection_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_Contains_with_mixed_value_types() { - await base.Inline_collection_Contains_with_mixed_value_types(async); + await base.Inline_collection_Contains_with_mixed_value_types(); AssertSql( """ @@ -205,9 +205,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_List_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_List_Contains_with_mixed_value_types() { - await base.Inline_collection_List_Contains_with_mixed_value_types(async); + await base.Inline_collection_List_Contains_with_mixed_value_types(); AssertSql( """ @@ -219,9 +219,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_Contains_as_Any_with_predicate(bool async) + public override async Task Inline_collection_Contains_as_Any_with_predicate() { - await base.Inline_collection_Contains_as_Any_with_predicate(async); + await base.Inline_collection_Contains_as_Any_with_predicate(); AssertSql( """ @@ -231,9 +231,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_negated_Contains_as_All(bool async) + public override async Task Inline_collection_negated_Contains_as_All() { - await base.Inline_collection_negated_Contains_as_All(async); + await base.Inline_collection_negated_Contains_as_All(); AssertSql( """ @@ -243,9 +243,9 @@ WHERE [p].[Id] NOT IN (2, 999) """); } - public override async Task Inline_collection_Min_with_two_values(bool async) + public override async Task Inline_collection_Min_with_two_values() { - await base.Inline_collection_Min_with_two_values(async); + await base.Inline_collection_Min_with_two_values(); AssertSql( """ @@ -257,9 +257,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_List_Min_with_two_values(bool async) + public override async Task Inline_collection_List_Min_with_two_values() { - await base.Inline_collection_List_Min_with_two_values(async); + await base.Inline_collection_List_Min_with_two_values(); AssertSql( """ @@ -271,9 +271,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_Max_with_two_values(bool async) + public override async Task Inline_collection_Max_with_two_values() { - await base.Inline_collection_Max_with_two_values(async); + await base.Inline_collection_Max_with_two_values(); AssertSql( """ @@ -285,9 +285,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_List_Max_with_two_values(bool async) + public override async Task Inline_collection_List_Max_with_two_values() { - await base.Inline_collection_List_Max_with_two_values(async); + await base.Inline_collection_List_Max_with_two_values(); AssertSql( """ @@ -299,9 +299,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_Min_with_three_values(bool async) + public override async Task Inline_collection_Min_with_three_values() { - await base.Inline_collection_Min_with_three_values(async); + await base.Inline_collection_Min_with_three_values(); AssertSql( """ @@ -315,9 +315,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_List_Min_with_three_values(bool async) + public override async Task Inline_collection_List_Min_with_three_values() { - await base.Inline_collection_List_Min_with_three_values(async); + await base.Inline_collection_List_Min_with_three_values(); AssertSql( """ @@ -331,9 +331,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_Max_with_three_values(bool async) + public override async Task Inline_collection_Max_with_three_values() { - await base.Inline_collection_Max_with_three_values(async); + await base.Inline_collection_Max_with_three_values(); AssertSql( """ @@ -347,9 +347,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_List_Max_with_three_values(bool async) + public override async Task Inline_collection_List_Max_with_three_values() { - await base.Inline_collection_List_Max_with_three_values(async); + await base.Inline_collection_List_Max_with_three_values(); AssertSql( """ @@ -363,9 +363,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_Min() { - await base.Inline_collection_of_nullable_value_type_Min(async); + await base.Inline_collection_of_nullable_value_type_Min(); AssertSql( """ @@ -379,9 +379,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_Max() { - await base.Inline_collection_of_nullable_value_type_Max(async); + await base.Inline_collection_of_nullable_value_type_Max(); AssertSql( """ @@ -395,9 +395,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Min() { - await base.Inline_collection_of_nullable_value_type_with_null_Min(async); + await base.Inline_collection_of_nullable_value_type_with_null_Min(); AssertSql( """ @@ -409,9 +409,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Max() { - await base.Inline_collection_of_nullable_value_type_with_null_Max(async); + await base.Inline_collection_of_nullable_value_type_with_null_Max(); AssertSql( """ @@ -423,9 +423,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_with_single_parameter_element_Contains(bool async) + public override async Task Inline_collection_with_single_parameter_element_Contains() { - await base.Inline_collection_with_single_parameter_element_Contains(async); + await base.Inline_collection_with_single_parameter_element_Contains(); AssertSql( """ @@ -437,9 +437,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_with_single_parameter_element_Count(bool async) + public override async Task Inline_collection_with_single_parameter_element_Count() { - await base.Inline_collection_with_single_parameter_element_Count(async); + await base.Inline_collection_with_single_parameter_element_Count(); AssertSql( """ @@ -454,15 +454,15 @@ SELECT COUNT(*) """); } - public override Task Inline_collection_Contains_with_EF_Parameter(bool async) - => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Contains_with_EF_Parameter(async)); + public override Task Inline_collection_Contains_with_EF_Parameter() + => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Contains_with_EF_Parameter()); - public override Task Inline_collection_Count_with_column_predicate_with_EF_Parameter(bool async) - => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(async)); + public override Task Inline_collection_Count_with_column_predicate_with_EF_Parameter() + => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Count_with_column_predicate_with_EF_Parameter()); - public override async Task Parameter_collection_Count(bool async) + public override async Task Parameter_collection_Count() { - await base.Parameter_collection_Count(async); + await base.Parameter_collection_Count(); AssertSql( """ @@ -478,9 +478,9 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_int() { - await base.Parameter_collection_of_ints_Contains_int(async); + await base.Parameter_collection_of_ints_Contains_int(); AssertSql( """ @@ -502,9 +502,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_HashSet_of_ints_Contains_int() { - await base.Parameter_collection_HashSet_of_ints_Contains_int(async); + await base.Parameter_collection_HashSet_of_ints_Contains_int(); AssertSql( """ @@ -526,9 +526,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int() { - await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(async); + await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(); AssertSql( """ @@ -550,9 +550,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_of_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_nullable_int() { - await base.Parameter_collection_of_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_ints_Contains_nullable_int(); AssertSql( """ @@ -574,9 +574,9 @@ WHERE [p].[NullableInt] NOT IN (@ints1, @ints2) OR [p].[NullableInt] IS NULL """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_int() { - await base.Parameter_collection_of_nullable_ints_Contains_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_int(); AssertSql( """ @@ -598,9 +598,9 @@ WHERE [p].[Int] NOT IN (@nullableInts1, @nullableInts2) """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int() { - await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(); AssertSql( """ @@ -620,9 +620,9 @@ WHERE [p].[NullableInt] IS NOT NULL AND [p].[NullableInt] <> @nullableInts1 """); } - public override async Task Parameter_collection_of_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_string() { - await base.Parameter_collection_of_strings_Contains_string(async); + await base.Parameter_collection_of_strings_Contains_string(); AssertSql( """ @@ -644,9 +644,9 @@ WHERE [p].[String] NOT IN (@strings1, @strings2) """); } - public override async Task Parameter_collection_of_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_nullable_string() { - await base.Parameter_collection_of_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_strings_Contains_nullable_string(); AssertSql( """ @@ -668,9 +668,9 @@ WHERE [p].[NullableString] NOT IN (@strings1, @strings2) OR [p].[NullableString] """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_string() { - await base.Parameter_collection_of_nullable_strings_Contains_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_string(); AssertSql( """ @@ -690,9 +690,9 @@ WHERE [p].[String] <> @strings1 """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string() { - await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(); AssertSql( """ @@ -712,9 +712,9 @@ WHERE [p].[NullableString] IS NOT NULL AND [p].[NullableString] <> @strings1 """); } - public override async Task Parameter_collection_of_DateTimes_Contains(bool async) + public override async Task Parameter_collection_of_DateTimes_Contains() { - await base.Parameter_collection_of_DateTimes_Contains(async); + await base.Parameter_collection_of_DateTimes_Contains(); AssertSql( """ @@ -727,9 +727,9 @@ WHERE [p].[DateTime] IN (@dateTimes1, @dateTimes2) """); } - public override async Task Parameter_collection_of_bools_Contains(bool async) + public override async Task Parameter_collection_of_bools_Contains() { - await base.Parameter_collection_of_bools_Contains(async); + await base.Parameter_collection_of_bools_Contains(); AssertSql( """ @@ -741,9 +741,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Parameter_collection_of_enums_Contains(bool async) + public override async Task Parameter_collection_of_enums_Contains() { - await base.Parameter_collection_of_enums_Contains(async); + await base.Parameter_collection_of_enums_Contains(); AssertSql( """ @@ -756,9 +756,9 @@ WHERE [p].[Enum] IN (@enums1, @enums2) """); } - public override async Task Parameter_collection_null_Contains(bool async) + public override async Task Parameter_collection_null_Contains() { - await base.Parameter_collection_null_Contains(async); + await base.Parameter_collection_null_Contains(); AssertSql( """ @@ -768,9 +768,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Parameter_collection_Contains_with_EF_Constant(bool async) + public override async Task Parameter_collection_Contains_with_EF_Constant() { - await base.Parameter_collection_Contains_with_EF_Constant(async); + await base.Parameter_collection_Contains_with_EF_Constant(); AssertSql( """ @@ -780,9 +780,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any() { - await base.Parameter_collection_Where_with_EF_Constant_Where_Any(async); + await base.Parameter_collection_Where_with_EF_Constant_Where_Any(); AssertSql( """ @@ -795,9 +795,9 @@ SELECT 1 """); } - public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant() { - await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(async); + await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(); AssertSql( """ @@ -810,38 +810,38 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_Count_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_Count_with_huge_number_of_values() { - await base.Parameter_collection_Count_with_huge_number_of_values(async); + await base.Parameter_collection_Count_with_huge_number_of_values(); Assert.Contains("VALUES", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); } - public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values() { - await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(async); + await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(); Assert.DoesNotContain("OPENJSON", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); Assert.DoesNotContain("OPENJSON", Fixture.TestSqlLoggerFactory.SqlStatements[1], StringComparison.Ordinal); } - public override Task Column_collection_of_ints_Contains(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_ints_Contains(async)); + public override Task Column_collection_of_ints_Contains() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_ints_Contains()); - public override Task Column_collection_of_nullable_ints_Contains(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_nullable_ints_Contains(async)); + public override Task Column_collection_of_nullable_ints_Contains() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_nullable_ints_Contains()); - public override Task Column_collection_of_nullable_ints_Contains_null(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_nullable_ints_Contains_null(async)); + public override Task Column_collection_of_nullable_ints_Contains_null() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_nullable_ints_Contains_null()); - public override Task Column_collection_of_strings_contains_null(bool async) - => AssertTranslationFailed(() => base.Column_collection_of_strings_contains_null(async)); + public override Task Column_collection_of_strings_contains_null() + => AssertTranslationFailed(() => base.Column_collection_of_strings_contains_null()); - public override Task Column_collection_of_nullable_strings_contains_null(bool async) - => AssertTranslationFailed(() => base.Column_collection_of_strings_contains_null(async)); + public override Task Column_collection_of_nullable_strings_contains_null() + => AssertTranslationFailed(() => base.Column_collection_of_strings_contains_null()); - public override Task Column_collection_of_bools_Contains(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_bools_Contains(async)); + public override Task Column_collection_of_bools_Contains() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_of_bools_Contains()); [ConditionalFact] public virtual async Task Json_representation_of_bool_array() @@ -854,39 +854,39 @@ await context.Database.SqlQuery($"SELECT [Bools] AS [Value] FROM [Primit .SingleAsync()); } - public override Task Column_collection_Count_method(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Count_method(async)); + public override Task Column_collection_Count_method() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Count_method()); - public override Task Column_collection_Length(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Length(async)); + public override Task Column_collection_Length() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Length()); - public override Task Column_collection_Count_with_predicate(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Count_with_predicate(async)); + public override Task Column_collection_Count_with_predicate() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Count_with_predicate()); - public override Task Column_collection_Where_Count(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Count(async)); + public override Task Column_collection_Where_Count() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Count()); - public override Task Column_collection_index_int(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_int(async)); + public override Task Column_collection_index_int() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_int()); - public override Task Column_collection_index_string(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_string(async)); + public override Task Column_collection_index_string() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_string()); - public override Task Column_collection_index_datetime(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_datetime(async)); + public override Task Column_collection_index_datetime() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_datetime()); - public override Task Column_collection_index_beyond_end(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_beyond_end(async)); + public override Task Column_collection_index_beyond_end() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_beyond_end()); - public override Task Nullable_reference_column_collection_index_equals_nullable_column(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_beyond_end(async)); + public override Task Nullable_reference_column_collection_index_equals_nullable_column() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_beyond_end()); - public override Task Non_nullable_reference_column_collection_index_equals_nullable_column(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_beyond_end(async)); + public override Task Non_nullable_reference_column_collection_index_equals_nullable_column() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_index_beyond_end()); - public override async Task Inline_collection_index_Column(bool async) + public override async Task Inline_collection_index_Column() { - await base.Inline_collection_index_Column(async); + await base.Inline_collection_index_Column(); AssertSql( """ @@ -900,9 +900,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_value_index_Column(bool async) + public override async Task Inline_collection_value_index_Column() { - await base.Inline_collection_value_index_Column(async); + await base.Inline_collection_value_index_Column(); AssertSql( """ @@ -916,9 +916,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_List_value_index_Column(bool async) + public override async Task Inline_collection_List_value_index_Column() { - await base.Inline_collection_List_value_index_Column(async); + await base.Inline_collection_List_value_index_Column(); AssertSql( """ @@ -932,9 +932,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Parameter_collection_index_Column_equal_Column(bool async) + public override async Task Parameter_collection_index_Column_equal_Column() { - await base.Parameter_collection_index_Column_equal_Column(async); + await base.Parameter_collection_index_Column_equal_Column(); AssertSql( """ @@ -952,9 +952,9 @@ ORDER BY [i].[_ord] """); } - public override async Task Parameter_collection_index_Column_equal_constant(bool async) + public override async Task Parameter_collection_index_Column_equal_constant() { - await base.Parameter_collection_index_Column_equal_constant(async); + await base.Parameter_collection_index_Column_equal_constant(); AssertSql( """ @@ -972,66 +972,66 @@ ORDER BY [i].[_ord] """); } - public override Task Column_collection_ElementAt(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_ElementAt(async)); + public override Task Column_collection_ElementAt() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_ElementAt()); - public override Task Column_collection_First(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_First(async)); + public override Task Column_collection_First() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_First()); - public override Task Column_collection_FirstOrDefault(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_FirstOrDefault(async)); + public override Task Column_collection_FirstOrDefault() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_FirstOrDefault()); - public override Task Column_collection_Single(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Single(async)); + public override Task Column_collection_Single() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Single()); - public override Task Column_collection_SingleOrDefault(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_SingleOrDefault(async)); + public override Task Column_collection_SingleOrDefault() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_SingleOrDefault()); - public override Task Column_collection_Skip(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Skip(async)); + public override Task Column_collection_Skip() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Skip()); - public override Task Column_collection_Take(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Take(async)); + public override Task Column_collection_Take() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Take()); - public override Task Column_collection_Skip_Take(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Skip_Take(async)); + public override Task Column_collection_Skip_Take() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Skip_Take()); - public override Task Column_collection_Where_Skip(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Skip(async)); + public override Task Column_collection_Where_Skip() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Skip()); - public override Task Column_collection_Where_Take(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Take(async)); + public override Task Column_collection_Where_Take() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Take()); - public override Task Column_collection_Where_Skip_Take(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Skip_Take(async)); + public override Task Column_collection_Where_Skip_Take() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Where_Skip_Take()); - public override Task Column_collection_Contains_over_subquery(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Skip_Take(async)); + public override Task Column_collection_Contains_over_subquery() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Skip_Take()); - public override Task Column_collection_OrderByDescending_ElementAt(bool async) - => AssertTranslationFailed(() => base.Column_collection_OrderByDescending_ElementAt(async)); + public override Task Column_collection_OrderByDescending_ElementAt() + => AssertTranslationFailed(() => base.Column_collection_OrderByDescending_ElementAt()); - public override Task Column_collection_Where_ElementAt(bool async) - => AssertTranslationFailed(() => base.Column_collection_Where_ElementAt(async)); + public override Task Column_collection_Where_ElementAt() + => AssertTranslationFailed(() => base.Column_collection_Where_ElementAt()); - public override Task Column_collection_Any(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Any(async)); + public override Task Column_collection_Any() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Any()); - public override Task Column_collection_Distinct(bool async) - => AssertTranslationFailed(() => base.Column_collection_Distinct(async)); + public override Task Column_collection_Distinct() + => AssertTranslationFailed(() => base.Column_collection_Distinct()); - public override Task Column_collection_SelectMany(bool async) - => AssertTranslationFailed(() => base.Column_collection_SelectMany(async)); + public override Task Column_collection_SelectMany() + => AssertTranslationFailed(() => base.Column_collection_SelectMany()); - public override Task Column_collection_SelectMany_with_filter(bool async) - => AssertTranslationFailed(() => base.Column_collection_SelectMany_with_filter(async)); + public override Task Column_collection_SelectMany_with_filter() + => AssertTranslationFailed(() => base.Column_collection_SelectMany_with_filter()); - public override Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) - => AssertTranslationFailed(() => base.Column_collection_SelectMany_with_Select_to_anonymous_type(async)); + public override Task Column_collection_SelectMany_with_Select_to_anonymous_type() + => AssertTranslationFailed(() => base.Column_collection_SelectMany_with_Select_to_anonymous_type()); - public override async Task Column_collection_projection_from_top_level(bool async) + public override async Task Column_collection_projection_from_top_level() { - await base.Column_collection_projection_from_top_level(async); + await base.Column_collection_projection_from_top_level(); AssertSql( """ @@ -1041,33 +1041,33 @@ ORDER BY [p].[Id] """); } - public override Task Column_collection_Join_parameter_collection(bool async) - => AssertTranslationFailed(() => base.Column_collection_Join_parameter_collection(async)); + public override Task Column_collection_Join_parameter_collection() + => AssertTranslationFailed(() => base.Column_collection_Join_parameter_collection()); - public override Task Inline_collection_Join_ordered_column_collection(bool async) - => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Join_ordered_column_collection(async)); + public override Task Inline_collection_Join_ordered_column_collection() + => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Join_ordered_column_collection()); - public override Task Parameter_collection_Concat_column_collection(bool async) - => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_Concat_column_collection(async)); + public override Task Parameter_collection_Concat_column_collection() + => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_Concat_column_collection()); - public override Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) - => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_Concat_column_collection(async)); + public override Task Parameter_collection_with_type_inference_for_JsonScalarExpression() + => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_Concat_column_collection()); - public override Task Column_collection_Union_parameter_collection(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Union_parameter_collection(async)); + public override Task Column_collection_Union_parameter_collection() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Union_parameter_collection()); - public override Task Column_collection_Intersect_inline_collection(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_Intersect_inline_collection(async)); + public override Task Column_collection_Intersect_inline_collection() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_Intersect_inline_collection()); - public override Task Inline_collection_Except_column_collection(bool async) - => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Except_column_collection(async)); + public override Task Inline_collection_Except_column_collection() + => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Except_column_collection()); - public override Task Column_collection_Where_Union(bool async) - => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Except_column_collection(async)); + public override Task Column_collection_Where_Union() + => AssertCompatibilityLevelTooLow(() => base.Inline_collection_Except_column_collection()); - public override async Task Column_collection_equality_parameter_collection(bool async) + public override async Task Column_collection_equality_parameter_collection() { - await base.Column_collection_equality_parameter_collection(async); + await base.Column_collection_equality_parameter_collection(); AssertSql( """ @@ -1079,16 +1079,16 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) + public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection() { - await base.Column_collection_Concat_parameter_collection_equality_inline_collection(async); + await base.Column_collection_Concat_parameter_collection_equality_inline_collection(); AssertSql(); } - public override async Task Column_collection_equality_inline_collection(bool async) + public override async Task Column_collection_equality_inline_collection() { - await base.Column_collection_equality_inline_collection(async); + await base.Column_collection_equality_inline_collection(); AssertSql( """ @@ -1098,37 +1098,37 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_equality_inline_collection_with_parameters(bool async) + public override async Task Column_collection_equality_inline_collection_with_parameters() { - await base.Column_collection_equality_inline_collection_with_parameters(async); + await base.Column_collection_equality_inline_collection_with_parameters(); AssertSql(); } - public override async Task Column_collection_Where_equality_inline_collection(bool async) + public override async Task Column_collection_Where_equality_inline_collection() { - await base.Column_collection_Where_equality_inline_collection(async); + await base.Column_collection_Where_equality_inline_collection(); AssertSql(); } - public override Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(bool async) - => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(async)); + public override Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query() + => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query()); - public override Task Parameter_collection_in_subquery_Union_column_collection(bool async) - => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_in_subquery_Union_column_collection(async)); + public override Task Parameter_collection_in_subquery_Union_column_collection() + => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_in_subquery_Union_column_collection()); - public override Task Parameter_collection_in_subquery_Union_column_collection_nested(bool async) - => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_in_subquery_Union_column_collection_nested(async)); + public override Task Parameter_collection_in_subquery_Union_column_collection_nested() + => AssertCompatibilityLevelTooLow(() => base.Parameter_collection_in_subquery_Union_column_collection_nested()); public override void Parameter_collection_in_subquery_and_Convert_as_compiled_query() { // Base implementation asserts that a different exception is thrown } - public override async Task Parameter_collection_in_subquery_Count_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Count_as_compiled_query() { - await base.Parameter_collection_in_subquery_Count_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Count_as_compiled_query(); AssertSql( """ @@ -1149,19 +1149,19 @@ OFFSET 1 ROWS """); } - public override Task Column_collection_in_subquery_Union_parameter_collection(bool async) - => AssertCompatibilityLevelTooLow(() => base.Column_collection_in_subquery_Union_parameter_collection(async)); + public override Task Column_collection_in_subquery_Union_parameter_collection() + => AssertCompatibilityLevelTooLow(() => base.Column_collection_in_subquery_Union_parameter_collection()); - public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(); AssertSql(); } - public override async Task Project_collection_of_ints_simple(bool async) + public override async Task Project_collection_of_ints_simple() { - await base.Project_collection_of_ints_simple(async); + await base.Project_collection_of_ints_simple(); AssertSql( """ @@ -1171,17 +1171,17 @@ ORDER BY [p].[Id] """); } - public override Task Project_collection_of_ints_ordered(bool async) + public override Task Project_collection_of_ints_ordered() // we don't propagate error details from projection - => AssertTranslationFailed(() => base.Project_collection_of_ints_ordered(async)); + => AssertTranslationFailed(() => base.Project_collection_of_ints_ordered()); - public override Task Project_collection_of_datetimes_filtered(bool async) + public override Task Project_collection_of_datetimes_filtered() // we don't propagate error details from projection - => AssertTranslationFailed(() => base.Project_collection_of_datetimes_filtered(async)); + => AssertTranslationFailed(() => base.Project_collection_of_datetimes_filtered()); - public override async Task Project_collection_of_nullable_ints_with_paging(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging() { - await base.Project_collection_of_nullable_ints_with_paging(async); + await base.Project_collection_of_nullable_ints_with_paging(); // client eval AssertSql( @@ -1192,13 +1192,13 @@ ORDER BY [p].[Id] """); } - public override Task Project_collection_of_nullable_ints_with_paging2(bool async) + public override Task Project_collection_of_nullable_ints_with_paging2() // we don't propagate error details from projection - => AssertTranslationFailed(() => base.Project_collection_of_nullable_ints_with_paging2(async)); + => AssertTranslationFailed(() => base.Project_collection_of_nullable_ints_with_paging2()); - public override async Task Project_collection_of_nullable_ints_with_paging3(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging3() { - await base.Project_collection_of_nullable_ints_with_paging3(async); + await base.Project_collection_of_nullable_ints_with_paging3(); // client eval AssertSql( @@ -1209,9 +1209,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_ints_with_distinct(bool async) + public override async Task Project_collection_of_ints_with_distinct() { - await base.Project_collection_of_ints_with_distinct(async); + await base.Project_collection_of_ints_with_distinct(); // client eval AssertSql( @@ -1222,16 +1222,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_nullable_ints_with_distinct(bool async) + public override async Task Project_collection_of_nullable_ints_with_distinct() { - await base.Project_collection_of_nullable_ints_with_distinct(async); + await base.Project_collection_of_nullable_ints_with_distinct(); AssertSql(""); } - public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault(bool async) + public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault() { - await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(async); + await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(); AssertSql( """ @@ -1241,17 +1241,17 @@ ORDER BY [p].[Id] """); } - public override Task Project_multiple_collections(bool async) + public override Task Project_multiple_collections() // we don't propagate error details from projection - => AssertTranslationFailed(() => base.Project_multiple_collections(async)); + => AssertTranslationFailed(() => base.Project_multiple_collections()); - public override Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls(bool async) + public override Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls() // we don't propagate error details from projection - => AssertTranslationFailed(() => base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(async)); + => AssertTranslationFailed(() => base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls()); - public override async Task Project_primitive_collections_element(bool async) + public override async Task Project_primitive_collections_element() { - await base.Project_primitive_collections_element(async); + await base.Project_primitive_collections_element(); AssertSql( """ @@ -1262,9 +1262,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection(bool async) + public override async Task Project_inline_collection() { - await base.Project_inline_collection(async); + await base.Project_inline_collection(); AssertSql( """ @@ -1273,9 +1273,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Project_inline_collection_with_Union(bool async) + public override async Task Project_inline_collection_with_Union() { - await base.Project_inline_collection_with_Union(async); + await base.Project_inline_collection_with_Union(); AssertSql( """ @@ -1292,16 +1292,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection_with_Concat(bool async) + public override async Task Project_inline_collection_with_Concat() { - await base.Project_inline_collection_with_Concat(async); + await base.Project_inline_collection_with_Concat(); AssertSql(); } - public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping() { - await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(); AssertSql( """ @@ -1321,9 +1321,9 @@ END IN (@strings1, @strings2, @strings3) """); } - public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping() { - await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(); AssertSql( """ @@ -1343,9 +1343,9 @@ END IN (@strings1, @strings2, @strings3) """); } - public override async Task Parameter_collection_of_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_struct() { - await base.Parameter_collection_of_structs_Contains_struct(async); + await base.Parameter_collection_of_structs_Contains_struct(); AssertSql( """ @@ -1367,9 +1367,9 @@ WHERE [p].[WrappedId] NOT IN (@values1, @values2) """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct(); AssertSql( """ @@ -1391,9 +1391,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -1415,9 +1415,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_struct(); AssertSql( """ @@ -1438,9 +1438,9 @@ WHERE [p].[WrappedId] NOT IN (@values1, @values2) """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(); AssertSql( """ @@ -1461,9 +1461,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -1484,9 +1484,9 @@ WHERE [p].[NullableWrappedIdWithNullableComparer] NOT IN (@values1, @values2) OR """); } - public override async Task Values_of_enum_casted_to_underlying_value(bool async) + public override async Task Values_of_enum_casted_to_underlying_value() { - await base.Values_of_enum_casted_to_underlying_value(async); + await base.Values_of_enum_casted_to_underlying_value(); AssertSql( """ diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServer160Test.cs b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServer160Test.cs index b57e0e025c2..061226598ea 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServer160Test.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServer160Test.cs @@ -16,9 +16,9 @@ public PrimitiveCollectionsQuerySqlServer160Test(PrimitiveCollectionsQuerySqlSer Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override async Task Inline_collection_of_ints_Contains(bool async) + public override async Task Inline_collection_of_ints_Contains() { - await base.Inline_collection_of_ints_Contains(async); + await base.Inline_collection_of_ints_Contains(); AssertSql( """ @@ -28,9 +28,9 @@ WHERE [p].[Int] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains() { - await base.Inline_collection_of_nullable_ints_Contains(async); + await base.Inline_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -40,9 +40,9 @@ WHERE [p].[NullableInt] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains_null() { - await base.Inline_collection_of_nullable_ints_Contains_null(async); + await base.Inline_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -52,16 +52,16 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Count_with_zero_values(bool async) + public override async Task Inline_collection_Count_with_zero_values() { - await base.Inline_collection_Count_with_zero_values(async); + await base.Inline_collection_Count_with_zero_values(); AssertSql(); } - public override async Task Inline_collection_Count_with_one_value(bool async) + public override async Task Inline_collection_Count_with_one_value() { - await base.Inline_collection_Count_with_one_value(async); + await base.Inline_collection_Count_with_one_value(); AssertSql( """ @@ -74,9 +74,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_two_values(bool async) + public override async Task Inline_collection_Count_with_two_values() { - await base.Inline_collection_Count_with_two_values(async); + await base.Inline_collection_Count_with_two_values(); AssertSql( """ @@ -89,9 +89,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_three_values(bool async) + public override async Task Inline_collection_Count_with_three_values() { - await base.Inline_collection_Count_with_three_values(async); + await base.Inline_collection_Count_with_three_values(); AssertSql( """ @@ -104,9 +104,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_zero_values(bool async) + public override async Task Inline_collection_Contains_with_zero_values() { - await base.Inline_collection_Contains_with_zero_values(async); + await base.Inline_collection_Contains_with_zero_values(); AssertSql( """ @@ -116,9 +116,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_one_value(bool async) + public override async Task Inline_collection_Contains_with_one_value() { - await base.Inline_collection_Contains_with_one_value(async); + await base.Inline_collection_Contains_with_one_value(); AssertSql( """ @@ -128,9 +128,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_two_values(bool async) + public override async Task Inline_collection_Contains_with_two_values() { - await base.Inline_collection_Contains_with_two_values(async); + await base.Inline_collection_Contains_with_two_values(); AssertSql( """ @@ -140,9 +140,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_Contains_with_three_values(bool async) + public override async Task Inline_collection_Contains_with_three_values() { - await base.Inline_collection_Contains_with_three_values(async); + await base.Inline_collection_Contains_with_three_values(); AssertSql( """ @@ -152,9 +152,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Inline_collection_Contains_with_all_parameters(bool async) + public override async Task Inline_collection_Contains_with_all_parameters() { - await base.Inline_collection_Contains_with_all_parameters(async); + await base.Inline_collection_Contains_with_all_parameters(); AssertSql( """ @@ -167,9 +167,9 @@ WHERE [p].[Id] IN (@i, @j) """); } - public override async Task Inline_collection_Contains_with_constant_and_parameter(bool async) + public override async Task Inline_collection_Contains_with_constant_and_parameter() { - await base.Inline_collection_Contains_with_constant_and_parameter(async); + await base.Inline_collection_Contains_with_constant_and_parameter(); AssertSql( """ @@ -181,9 +181,9 @@ WHERE [p].[Id] IN (2, @j) """); } - public override async Task Inline_collection_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_Contains_with_mixed_value_types() { - await base.Inline_collection_Contains_with_mixed_value_types(async); + await base.Inline_collection_Contains_with_mixed_value_types(); AssertSql( """ @@ -195,9 +195,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_List_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_List_Contains_with_mixed_value_types() { - await base.Inline_collection_List_Contains_with_mixed_value_types(async); + await base.Inline_collection_List_Contains_with_mixed_value_types(); AssertSql( """ @@ -209,9 +209,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_Contains_as_Any_with_predicate(bool async) + public override async Task Inline_collection_Contains_as_Any_with_predicate() { - await base.Inline_collection_Contains_as_Any_with_predicate(async); + await base.Inline_collection_Contains_as_Any_with_predicate(); AssertSql( """ @@ -221,9 +221,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_negated_Contains_as_All(bool async) + public override async Task Inline_collection_negated_Contains_as_All() { - await base.Inline_collection_negated_Contains_as_All(async); + await base.Inline_collection_negated_Contains_as_All(); AssertSql( """ @@ -233,9 +233,9 @@ WHERE [p].[Id] NOT IN (2, 999) """); } - public override async Task Inline_collection_Min_with_two_values(bool async) + public override async Task Inline_collection_Min_with_two_values() { - await base.Inline_collection_Min_with_two_values(async); + await base.Inline_collection_Min_with_two_values(); AssertSql( """ @@ -245,9 +245,9 @@ WHERE LEAST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_List_Min_with_two_values(bool async) + public override async Task Inline_collection_List_Min_with_two_values() { - await base.Inline_collection_List_Min_with_two_values(async); + await base.Inline_collection_List_Min_with_two_values(); AssertSql( """ @@ -257,9 +257,9 @@ WHERE LEAST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_Max_with_two_values(bool async) + public override async Task Inline_collection_Max_with_two_values() { - await base.Inline_collection_Max_with_two_values(async); + await base.Inline_collection_Max_with_two_values(); AssertSql( """ @@ -269,9 +269,9 @@ WHERE GREATEST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_List_Max_with_two_values(bool async) + public override async Task Inline_collection_List_Max_with_two_values() { - await base.Inline_collection_List_Max_with_two_values(async); + await base.Inline_collection_List_Max_with_two_values(); AssertSql( """ @@ -281,9 +281,9 @@ WHERE GREATEST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_Min_with_three_values(bool async) + public override async Task Inline_collection_Min_with_three_values() { - await base.Inline_collection_Min_with_three_values(async); + await base.Inline_collection_Min_with_three_values(); AssertSql( """ @@ -295,9 +295,9 @@ WHERE LEAST(30, [p].[Int], @i) = 25 """); } - public override async Task Inline_collection_List_Min_with_three_values(bool async) + public override async Task Inline_collection_List_Min_with_three_values() { - await base.Inline_collection_List_Min_with_three_values(async); + await base.Inline_collection_List_Min_with_three_values(); AssertSql( """ @@ -309,9 +309,9 @@ WHERE LEAST(30, [p].[Int], @i) = 25 """); } - public override async Task Inline_collection_Max_with_three_values(bool async) + public override async Task Inline_collection_Max_with_three_values() { - await base.Inline_collection_Max_with_three_values(async); + await base.Inline_collection_Max_with_three_values(); AssertSql( """ @@ -323,9 +323,9 @@ WHERE GREATEST(30, [p].[Int], @i) = 35 """); } - public override async Task Inline_collection_List_Max_with_three_values(bool async) + public override async Task Inline_collection_List_Max_with_three_values() { - await base.Inline_collection_List_Max_with_three_values(async); + await base.Inline_collection_List_Max_with_three_values(); AssertSql( """ @@ -337,9 +337,9 @@ WHERE GREATEST(30, [p].[Int], @i) = 35 """); } - public override async Task Inline_collection_of_nullable_value_type_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_Min() { - await base.Inline_collection_of_nullable_value_type_Min(async); + await base.Inline_collection_of_nullable_value_type_Min(); AssertSql( """ @@ -351,9 +351,9 @@ WHERE LEAST(30, [p].[Int], @i) = 25 """); } - public override async Task Inline_collection_of_nullable_value_type_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_Max() { - await base.Inline_collection_of_nullable_value_type_Max(async); + await base.Inline_collection_of_nullable_value_type_Max(); AssertSql( """ @@ -365,9 +365,9 @@ WHERE GREATEST(30, [p].[Int], @i) = 35 """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Min() { - await base.Inline_collection_of_nullable_value_type_with_null_Min(async); + await base.Inline_collection_of_nullable_value_type_with_null_Min(); AssertSql( """ @@ -377,9 +377,9 @@ WHERE LEAST(30, [p].[NullableInt], NULL) = 30 """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Max() { - await base.Inline_collection_of_nullable_value_type_with_null_Max(async); + await base.Inline_collection_of_nullable_value_type_with_null_Max(); AssertSql( """ @@ -389,9 +389,9 @@ WHERE GREATEST(30, [p].[NullableInt], NULL) = 30 """); } - public override async Task Inline_collection_with_single_parameter_element_Contains(bool async) + public override async Task Inline_collection_with_single_parameter_element_Contains() { - await base.Inline_collection_with_single_parameter_element_Contains(async); + await base.Inline_collection_with_single_parameter_element_Contains(); AssertSql( """ @@ -403,9 +403,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_with_single_parameter_element_Count(bool async) + public override async Task Inline_collection_with_single_parameter_element_Count() { - await base.Inline_collection_with_single_parameter_element_Count(async); + await base.Inline_collection_with_single_parameter_element_Count(); AssertSql( """ @@ -420,9 +420,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_EF_Parameter(bool async) + public override async Task Inline_collection_Contains_with_EF_Parameter() { - await base.Inline_collection_Contains_with_EF_Parameter(async); + await base.Inline_collection_Contains_with_EF_Parameter(); AssertSql( """ @@ -437,9 +437,9 @@ FROM OPENJSON(@p) WITH ([value] int '$') AS [p0] """); } - public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter(bool async) + public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter() { - await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(async); + await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(); AssertSql( """ @@ -454,9 +454,9 @@ FROM OPENJSON(@p) WITH ([value] int '$') AS [p0] """); } - public override async Task Parameter_collection_Count(bool async) + public override async Task Parameter_collection_Count() { - await base.Parameter_collection_Count(async); + await base.Parameter_collection_Count(); AssertSql( """ @@ -472,9 +472,9 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_int() { - await base.Parameter_collection_of_ints_Contains_int(async); + await base.Parameter_collection_of_ints_Contains_int(); AssertSql( """ @@ -496,9 +496,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_HashSet_of_ints_Contains_int() { - await base.Parameter_collection_HashSet_of_ints_Contains_int(async); + await base.Parameter_collection_HashSet_of_ints_Contains_int(); AssertSql( """ @@ -520,9 +520,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int() { - await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(async); + await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(); AssertSql( """ @@ -544,9 +544,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_of_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_nullable_int() { - await base.Parameter_collection_of_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_ints_Contains_nullable_int(); AssertSql( """ @@ -568,9 +568,9 @@ WHERE [p].[NullableInt] NOT IN (@ints1, @ints2) OR [p].[NullableInt] IS NULL """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_int() { - await base.Parameter_collection_of_nullable_ints_Contains_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_int(); AssertSql( """ @@ -592,9 +592,9 @@ WHERE [p].[Int] NOT IN (@nullableInts1, @nullableInts2) """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int() { - await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(); AssertSql( """ @@ -614,9 +614,9 @@ WHERE [p].[NullableInt] IS NOT NULL AND [p].[NullableInt] <> @nullableInts1 """); } - public override async Task Parameter_collection_of_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_string() { - await base.Parameter_collection_of_strings_Contains_string(async); + await base.Parameter_collection_of_strings_Contains_string(); AssertSql( """ @@ -638,9 +638,9 @@ WHERE [p].[String] NOT IN (@strings1, @strings2) """); } - public override async Task Parameter_collection_of_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_nullable_string() { - await base.Parameter_collection_of_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_strings_Contains_nullable_string(); AssertSql( """ @@ -662,9 +662,9 @@ WHERE [p].[NullableString] NOT IN (@strings1, @strings2) OR [p].[NullableString] """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_string() { - await base.Parameter_collection_of_nullable_strings_Contains_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_string(); AssertSql( """ @@ -684,9 +684,9 @@ WHERE [p].[String] <> @strings1 """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string() { - await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(); AssertSql( """ @@ -706,9 +706,9 @@ WHERE [p].[NullableString] IS NOT NULL AND [p].[NullableString] <> @strings1 """); } - public override async Task Parameter_collection_of_DateTimes_Contains(bool async) + public override async Task Parameter_collection_of_DateTimes_Contains() { - await base.Parameter_collection_of_DateTimes_Contains(async); + await base.Parameter_collection_of_DateTimes_Contains(); AssertSql( """ @@ -721,9 +721,9 @@ WHERE [p].[DateTime] IN (@dateTimes1, @dateTimes2) """); } - public override async Task Parameter_collection_of_bools_Contains(bool async) + public override async Task Parameter_collection_of_bools_Contains() { - await base.Parameter_collection_of_bools_Contains(async); + await base.Parameter_collection_of_bools_Contains(); AssertSql( """ @@ -735,9 +735,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Parameter_collection_of_enums_Contains(bool async) + public override async Task Parameter_collection_of_enums_Contains() { - await base.Parameter_collection_of_enums_Contains(async); + await base.Parameter_collection_of_enums_Contains(); AssertSql( """ @@ -750,9 +750,9 @@ WHERE [p].[Enum] IN (@enums1, @enums2) """); } - public override async Task Parameter_collection_null_Contains(bool async) + public override async Task Parameter_collection_null_Contains() { - await base.Parameter_collection_null_Contains(async); + await base.Parameter_collection_null_Contains(); AssertSql( """ @@ -762,9 +762,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Parameter_collection_Contains_with_EF_Constant(bool async) + public override async Task Parameter_collection_Contains_with_EF_Constant() { - await base.Parameter_collection_Contains_with_EF_Constant(async); + await base.Parameter_collection_Contains_with_EF_Constant(); AssertSql( """ @@ -774,9 +774,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any() { - await base.Parameter_collection_Where_with_EF_Constant_Where_Any(async); + await base.Parameter_collection_Where_with_EF_Constant_Where_Any(); AssertSql( """ @@ -789,9 +789,9 @@ SELECT 1 """); } - public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant() { - await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(async); + await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(); AssertSql( """ @@ -804,24 +804,24 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_Count_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_Count_with_huge_number_of_values() { - await base.Parameter_collection_Count_with_huge_number_of_values(async); + await base.Parameter_collection_Count_with_huge_number_of_values(); Assert.Contains("OPENJSON(@ids) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); } - public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values() { - await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(async); + await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(); Assert.Contains("OPENJSON(@ints) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); Assert.Contains("OPENJSON(@ints) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[1], StringComparison.Ordinal); } - public override async Task Column_collection_of_ints_Contains(bool async) + public override async Task Column_collection_of_ints_Contains() { - await base.Column_collection_of_ints_Contains(async); + await base.Column_collection_of_ints_Contains(); AssertSql( """ @@ -834,9 +834,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_of_nullable_ints_Contains(bool async) + public override async Task Column_collection_of_nullable_ints_Contains() { - await base.Column_collection_of_nullable_ints_Contains(async); + await base.Column_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -849,9 +849,9 @@ FROM OPENJSON([p].[NullableInts]) WITH ([value] int '$') AS [n] """); } - public override async Task Column_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Column_collection_of_nullable_ints_Contains_null() { - await base.Column_collection_of_nullable_ints_Contains_null(async); + await base.Column_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -864,9 +864,9 @@ FROM OPENJSON([p].[NullableInts]) WITH ([value] int '$') AS [n] """); } - public override async Task Column_collection_of_strings_contains_null(bool async) + public override async Task Column_collection_of_strings_contains_null() { - await base.Column_collection_of_strings_contains_null(async); + await base.Column_collection_of_strings_contains_null(); AssertSql( """ @@ -876,9 +876,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_of_nullable_strings_contains_null(bool async) + public override async Task Column_collection_of_nullable_strings_contains_null() { - await base.Column_collection_of_nullable_strings_contains_null(async); + await base.Column_collection_of_nullable_strings_contains_null(); AssertSql( """ @@ -891,9 +891,9 @@ FROM OPENJSON([p].[NullableStrings]) WITH ([value] nvarchar(max) '$') AS [n] """); } - public override async Task Column_collection_of_bools_Contains(bool async) + public override async Task Column_collection_of_bools_Contains() { - await base.Column_collection_of_bools_Contains(async); + await base.Column_collection_of_bools_Contains(); AssertSql( """ @@ -917,9 +917,9 @@ await context.Database.SqlQuery($"SELECT [Bools] AS [Value] FROM [Primit .SingleAsync()); } - public override async Task Column_collection_Count_method(bool async) + public override async Task Column_collection_Count_method() { - await base.Column_collection_Count_method(async); + await base.Column_collection_Count_method(); AssertSql( """ @@ -931,9 +931,9 @@ FROM OPENJSON([p].[Ints]) AS [i]) = 2 """); } - public override async Task Column_collection_Length(bool async) + public override async Task Column_collection_Length() { - await base.Column_collection_Length(async); + await base.Column_collection_Length(); AssertSql( """ @@ -945,9 +945,9 @@ FROM OPENJSON([p].[Ints]) AS [i]) = 2 """); } - public override async Task Column_collection_Count_with_predicate(bool async) + public override async Task Column_collection_Count_with_predicate() { - await base.Column_collection_Count_with_predicate(async); + await base.Column_collection_Count_with_predicate(); AssertSql( """ @@ -960,9 +960,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_Where_Count(bool async) + public override async Task Column_collection_Where_Count() { - await base.Column_collection_Where_Count(async); + await base.Column_collection_Where_Count(); AssertSql( """ @@ -975,9 +975,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_index_int(bool async) + public override async Task Column_collection_index_int() { - await base.Column_collection_index_int(async); + await base.Column_collection_index_int(); AssertSql( """ @@ -987,9 +987,9 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[1]') AS int) = 10 """); } - public override async Task Column_collection_index_string(bool async) + public override async Task Column_collection_index_string() { - await base.Column_collection_index_string(async); + await base.Column_collection_index_string(); AssertSql( """ @@ -999,9 +999,9 @@ WHERE JSON_VALUE([p].[Strings], '$[1]') = N'10' """); } - public override async Task Column_collection_index_datetime(bool async) + public override async Task Column_collection_index_datetime() { - await base.Column_collection_index_datetime(async); + await base.Column_collection_index_datetime(); AssertSql( """ @@ -1011,9 +1011,9 @@ WHERE CAST(JSON_VALUE([p].[DateTimes], '$[1]') AS datetime2) = '2020-01-10T12:30 """); } - public override async Task Column_collection_index_beyond_end(bool async) + public override async Task Column_collection_index_beyond_end() { - await base.Column_collection_index_beyond_end(async); + await base.Column_collection_index_beyond_end(); AssertSql( """ @@ -1023,10 +1023,10 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[999]') AS int) = 10 """); } - public override async Task Nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Nullable_reference_column_collection_index_equals_nullable_column() { // TODO: This test is incorrect, see #33784 - await base.Nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1036,9 +1036,9 @@ WHERE JSON_VALUE([p].[NullableStrings], '$[2]') = [p].[NullableString] OR (JSON_ """); } - public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column() { - await base.Non_nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Non_nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1050,9 +1050,9 @@ FROM OPENJSON([p].[Strings]) AS [s]) AND JSON_VALUE([p].[Strings], '$[1]') = [p] """); } - public override async Task Inline_collection_index_Column(bool async) + public override async Task Inline_collection_index_Column() { - await base.Inline_collection_index_Column(async); + await base.Inline_collection_index_Column(); AssertSql( """ @@ -1066,9 +1066,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_value_index_Column(bool async) + public override async Task Inline_collection_value_index_Column() { - await base.Inline_collection_value_index_Column(async); + await base.Inline_collection_value_index_Column(); AssertSql( """ @@ -1082,9 +1082,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_List_value_index_Column(bool async) + public override async Task Inline_collection_List_value_index_Column() { - await base.Inline_collection_List_value_index_Column(async); + await base.Inline_collection_List_value_index_Column(); AssertSql( """ @@ -1099,9 +1099,9 @@ ORDER BY [v].[_ord] } [SqlServerCondition(SqlServerCondition.SupportsJsonPathExpressions)] - public override async Task Parameter_collection_index_Column_equal_Column(bool async) + public override async Task Parameter_collection_index_Column_equal_Column() { - await base.Parameter_collection_index_Column_equal_Column(async); + await base.Parameter_collection_index_Column_equal_Column(); AssertSql( """ @@ -1114,9 +1114,9 @@ WHERE CAST(JSON_VALUE(@ints, '$[' + CAST([p].[Int] AS nvarchar(max)) + ']') AS i } [SqlServerCondition(SqlServerCondition.SupportsJsonPathExpressions)] - public override async Task Parameter_collection_index_Column_equal_constant(bool async) + public override async Task Parameter_collection_index_Column_equal_constant() { - await base.Parameter_collection_index_Column_equal_constant(async); + await base.Parameter_collection_index_Column_equal_constant(); AssertSql( """ @@ -1128,9 +1128,9 @@ WHERE CAST(JSON_VALUE(@ints, '$[' + CAST([p].[Int] AS nvarchar(max)) + ']') AS i """); } - public override async Task Column_collection_ElementAt(bool async) + public override async Task Column_collection_ElementAt() { - await base.Column_collection_ElementAt(async); + await base.Column_collection_ElementAt(); AssertSql( """ @@ -1140,9 +1140,9 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[1]') AS int) = 10 """); } - public override async Task Column_collection_First(bool async) + public override async Task Column_collection_First() { - await base.Column_collection_First(async); + await base.Column_collection_First(); AssertSql( """ @@ -1155,9 +1155,9 @@ ORDER BY CAST([i].[key] AS int)) = 1 """); } - public override async Task Column_collection_FirstOrDefault(bool async) + public override async Task Column_collection_FirstOrDefault() { - await base.Column_collection_FirstOrDefault(async); + await base.Column_collection_FirstOrDefault(); AssertSql( """ @@ -1170,9 +1170,9 @@ ORDER BY CAST([i].[key] AS int)), 0) = 1 """); } - public override async Task Column_collection_Single(bool async) + public override async Task Column_collection_Single() { - await base.Column_collection_Single(async); + await base.Column_collection_Single(); AssertSql( """ @@ -1185,9 +1185,9 @@ ORDER BY CAST([i].[key] AS int)) = 1 """); } - public override async Task Column_collection_SingleOrDefault(bool async) + public override async Task Column_collection_SingleOrDefault() { - await base.Column_collection_SingleOrDefault(async); + await base.Column_collection_SingleOrDefault(); AssertSql( """ @@ -1200,9 +1200,9 @@ ORDER BY CAST([i].[key] AS int)), 0) = 1 """); } - public override async Task Column_collection_Skip(bool async) + public override async Task Column_collection_Skip() { - await base.Column_collection_Skip(async); + await base.Column_collection_Skip(); AssertSql( """ @@ -1219,9 +1219,9 @@ OFFSET 1 ROWS """); } - public override async Task Column_collection_Take(bool async) + public override async Task Column_collection_Take() { - await base.Column_collection_Take(async); + await base.Column_collection_Take(); AssertSql( """ @@ -1235,9 +1235,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Skip_Take(bool async) + public override async Task Column_collection_Skip_Take() { - await base.Column_collection_Skip_Take(async); + await base.Column_collection_Skip_Take(); AssertSql( """ @@ -1252,9 +1252,9 @@ OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY """); } - public override async Task Column_collection_Where_Skip(bool async) + public override async Task Column_collection_Where_Skip() { - await base.Column_collection_Where_Skip(async); + await base.Column_collection_Where_Skip(); AssertSql( """ @@ -1272,9 +1272,9 @@ OFFSET 1 ROWS """); } - public override async Task Column_collection_Where_Take(bool async) + public override async Task Column_collection_Where_Take() { - await base.Column_collection_Where_Take(async); + await base.Column_collection_Where_Take(); AssertSql( """ @@ -1291,9 +1291,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Where_Skip_Take(bool async) + public override async Task Column_collection_Where_Skip_Take() { - await base.Column_collection_Where_Skip_Take(async); + await base.Column_collection_Where_Skip_Take(); AssertSql( """ @@ -1311,9 +1311,9 @@ OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY """); } - public override async Task Column_collection_Contains_over_subquery(bool async) + public override async Task Column_collection_Contains_over_subquery() { - await base.Column_collection_Contains_over_subquery(async); + await base.Column_collection_Contains_over_subquery(); AssertSql( """ @@ -1327,9 +1327,9 @@ WHERE [i].[value] > 1 """); } - public override async Task Column_collection_OrderByDescending_ElementAt(bool async) + public override async Task Column_collection_OrderByDescending_ElementAt() { - await base.Column_collection_OrderByDescending_ElementAt(async); + await base.Column_collection_OrderByDescending_ElementAt(); AssertSql( """ @@ -1343,9 +1343,9 @@ ORDER BY [i].[value] DESC """); } - public override async Task Column_collection_Where_ElementAt(bool async) + public override async Task Column_collection_Where_ElementAt() { - await base.Column_collection_Where_ElementAt(async); + await base.Column_collection_Where_ElementAt(); AssertSql( """ @@ -1360,9 +1360,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Any(bool async) + public override async Task Column_collection_Any() { - await base.Column_collection_Any(async); + await base.Column_collection_Any(); AssertSql( """ @@ -1374,9 +1374,9 @@ FROM OPENJSON([p].[Ints]) AS [i]) """); } - public override async Task Column_collection_Distinct(bool async) + public override async Task Column_collection_Distinct() { - await base.Column_collection_Distinct(async); + await base.Column_collection_Distinct(); AssertSql( """ @@ -1391,9 +1391,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_SelectMany(bool async) + public override async Task Column_collection_SelectMany() { - await base.Column_collection_SelectMany(async); + await base.Column_collection_SelectMany(); AssertSql( """ @@ -1403,9 +1403,9 @@ CROSS APPLY OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_SelectMany_with_filter(bool async) + public override async Task Column_collection_SelectMany_with_filter() { - await base.Column_collection_SelectMany_with_filter(async); + await base.Column_collection_SelectMany_with_filter(); AssertSql( """ @@ -1419,9 +1419,9 @@ WHERE [i].[value] > 1 """); } - public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) + public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type() { - await base.Column_collection_SelectMany_with_Select_to_anonymous_type(async); + await base.Column_collection_SelectMany_with_Select_to_anonymous_type(); AssertSql( """ @@ -1431,9 +1431,9 @@ CROSS APPLY OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_projection_from_top_level(bool async) + public override async Task Column_collection_projection_from_top_level() { - await base.Column_collection_projection_from_top_level(async); + await base.Column_collection_projection_from_top_level(); AssertSql( """ @@ -1443,9 +1443,9 @@ ORDER BY [p].[Id] """); } - public override async Task Column_collection_Join_parameter_collection(bool async) + public override async Task Column_collection_Join_parameter_collection() { - await base.Column_collection_Join_parameter_collection(async); + await base.Column_collection_Join_parameter_collection(); AssertSql( """ @@ -1461,9 +1461,9 @@ INNER JOIN (VALUES (@ints1), (@ints2)) AS [i0]([Value]) ON [i].[value] = [i0].[V """); } - public override async Task Inline_collection_Join_ordered_column_collection(bool async) + public override async Task Inline_collection_Join_ordered_column_collection() { - await base.Inline_collection_Join_ordered_column_collection(async); + await base.Inline_collection_Join_ordered_column_collection(); AssertSql( """ @@ -1476,9 +1476,9 @@ INNER JOIN OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] ON [v].[Value] = [ """); } - public override async Task Parameter_collection_Concat_column_collection(bool async) + public override async Task Parameter_collection_Concat_column_collection() { - await base.Parameter_collection_Concat_column_collection(async); + await base.Parameter_collection_Concat_column_collection(); AssertSql( """ @@ -1499,9 +1499,9 @@ FROM OPENJSON([p].[Ints]) AS [i0] """); } - public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) + public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression() { - await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(async); + await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(); AssertSql( """ @@ -1515,9 +1515,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_Union_parameter_collection(bool async) + public override async Task Column_collection_Union_parameter_collection() { - await base.Column_collection_Union_parameter_collection(async); + await base.Column_collection_Union_parameter_collection(); AssertSql( """ @@ -1538,9 +1538,9 @@ SELECT [i0].[Value] AS [value] """); } - public override async Task Column_collection_Intersect_inline_collection(bool async) + public override async Task Column_collection_Intersect_inline_collection() { - await base.Column_collection_Intersect_inline_collection(async); + await base.Column_collection_Intersect_inline_collection(); AssertSql( """ @@ -1558,9 +1558,9 @@ SELECT [v].[Value] AS [value] """); } - public override async Task Inline_collection_Except_column_collection(bool async) + public override async Task Inline_collection_Except_column_collection() { - await base.Inline_collection_Except_column_collection(async); + await base.Inline_collection_Except_column_collection(); AssertSql( """ @@ -1579,9 +1579,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_Where_Union(bool async) + public override async Task Column_collection_Where_Union() { - await base.Column_collection_Where_Union(async); + await base.Column_collection_Where_Union(); AssertSql( """ @@ -1600,9 +1600,9 @@ SELECT [v].[Value] AS [value] """); } - public override async Task Column_collection_equality_parameter_collection(bool async) + public override async Task Column_collection_equality_parameter_collection() { - await base.Column_collection_equality_parameter_collection(async); + await base.Column_collection_equality_parameter_collection(); AssertSql( """ @@ -1614,16 +1614,16 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) + public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection() { - await base.Column_collection_Concat_parameter_collection_equality_inline_collection(async); + await base.Column_collection_Concat_parameter_collection_equality_inline_collection(); AssertSql(); } - public override async Task Column_collection_equality_inline_collection(bool async) + public override async Task Column_collection_equality_inline_collection() { - await base.Column_collection_equality_inline_collection(async); + await base.Column_collection_equality_inline_collection(); AssertSql( """ @@ -1633,23 +1633,23 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_equality_inline_collection_with_parameters(bool async) + public override async Task Column_collection_equality_inline_collection_with_parameters() { - await base.Column_collection_equality_inline_collection_with_parameters(async); + await base.Column_collection_equality_inline_collection_with_parameters(); AssertSql(); } - public override async Task Column_collection_Where_equality_inline_collection(bool async) + public override async Task Column_collection_Where_equality_inline_collection() { - await base.Column_collection_Where_equality_inline_collection(async); + await base.Column_collection_Where_equality_inline_collection(); AssertSql(); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(); AssertSql( """ @@ -1675,9 +1675,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i0] """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection() { - await base.Parameter_collection_in_subquery_Union_column_collection(async); + await base.Parameter_collection_in_subquery_Union_column_collection(); AssertSql( """ @@ -1697,9 +1697,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_nested(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_nested() { - await base.Parameter_collection_in_subquery_Union_column_collection_nested(async); + await base.Parameter_collection_in_subquery_Union_column_collection_nested(); AssertSql( """ @@ -1738,9 +1738,9 @@ public override void Parameter_collection_in_subquery_and_Convert_as_compiled_qu AssertSql(); } - public override async Task Parameter_collection_in_subquery_Count_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Count_as_compiled_query() { - await base.Parameter_collection_in_subquery_Count_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Count_as_compiled_query(); // TODO: the subquery projection contains extra columns which we should remove AssertSql( @@ -1762,16 +1762,16 @@ OFFSET 1 ROWS """); } - public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(); AssertSql(); } - public override async Task Column_collection_in_subquery_Union_parameter_collection(bool async) + public override async Task Column_collection_in_subquery_Union_parameter_collection() { - await base.Column_collection_in_subquery_Union_parameter_collection(async); + await base.Column_collection_in_subquery_Union_parameter_collection(); AssertSql( """ @@ -1797,9 +1797,9 @@ SELECT [i0].[Value] AS [value] """); } - public override async Task Project_collection_of_ints_simple(bool async) + public override async Task Project_collection_of_ints_simple() { - await base.Project_collection_of_ints_simple(async); + await base.Project_collection_of_ints_simple(); AssertSql( """ @@ -1809,9 +1809,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_ints_ordered(bool async) + public override async Task Project_collection_of_ints_ordered() { - await base.Project_collection_of_ints_ordered(async); + await base.Project_collection_of_ints_ordered(); AssertSql( """ @@ -1822,9 +1822,9 @@ OUTER APPLY OPENJSON([p].[Ints]) AS [i] """); } - public override async Task Project_collection_of_datetimes_filtered(bool async) + public override async Task Project_collection_of_datetimes_filtered() { - await base.Project_collection_of_datetimes_filtered(async); + await base.Project_collection_of_datetimes_filtered(); AssertSql( """ @@ -1839,9 +1839,9 @@ WHERE DATEPART(day, CAST([d].[value] AS datetime2)) <> 1 """); } - public override async Task Project_collection_of_nullable_ints_with_paging(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging() { - await base.Project_collection_of_nullable_ints_with_paging(async); + await base.Project_collection_of_nullable_ints_with_paging(); AssertSql( """ @@ -1856,9 +1856,9 @@ ORDER BY CAST([n].[key] AS int) """); } - public override async Task Project_collection_of_nullable_ints_with_paging2(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging2() { - await base.Project_collection_of_nullable_ints_with_paging2(async); + await base.Project_collection_of_nullable_ints_with_paging2(); AssertSql( """ @@ -1874,9 +1874,9 @@ OFFSET 1 ROWS """); } - public override async Task Project_collection_of_nullable_ints_with_paging3(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging3() { - await base.Project_collection_of_nullable_ints_with_paging3(async); + await base.Project_collection_of_nullable_ints_with_paging3(); AssertSql( """ @@ -1892,9 +1892,9 @@ OFFSET 2 ROWS """); } - public override async Task Project_collection_of_ints_with_distinct(bool async) + public override async Task Project_collection_of_ints_with_distinct() { - await base.Project_collection_of_ints_with_distinct(async); + await base.Project_collection_of_ints_with_distinct(); AssertSql( """ @@ -1908,16 +1908,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_nullable_ints_with_distinct(bool async) + public override async Task Project_collection_of_nullable_ints_with_distinct() { - await base.Project_collection_of_nullable_ints_with_distinct(async); + await base.Project_collection_of_nullable_ints_with_distinct(); AssertSql(""); } - public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault(bool async) + public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault() { - await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(async); + await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(); AssertSql( """ @@ -1932,9 +1932,9 @@ OUTER APPLY OPENJSON([p0].[Ints]) AS [i] """); } - public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls(bool async) + public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls() { - await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(async); + await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(); AssertSql( """ @@ -1954,9 +1954,9 @@ WHERE [n0].[value] IS NULL """); } - public override async Task Project_multiple_collections(bool async) + public override async Task Project_multiple_collections() { - await base.Project_multiple_collections(async); + await base.Project_multiple_collections(); AssertSql( """ @@ -1978,9 +1978,9 @@ WHERE CAST([d0].[value] AS datetime2) > '2000-01-01T00:00:00.0000000' """); } - public override async Task Project_primitive_collections_element(bool async) + public override async Task Project_primitive_collections_element() { - await base.Project_primitive_collections_element(async); + await base.Project_primitive_collections_element(); AssertSql( """ @@ -1991,9 +1991,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection(bool async) + public override async Task Project_inline_collection() { - await base.Project_inline_collection(async); + await base.Project_inline_collection(); AssertSql( """ @@ -2002,9 +2002,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Project_inline_collection_with_Union(bool async) + public override async Task Project_inline_collection_with_Union() { - await base.Project_inline_collection_with_Union(async); + await base.Project_inline_collection_with_Union(); AssertSql( """ @@ -2021,16 +2021,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection_with_Concat(bool async) + public override async Task Project_inline_collection_with_Concat() { - await base.Project_inline_collection_with_Concat(async); + await base.Project_inline_collection_with_Concat(); AssertSql(); } - public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping() { - await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(); AssertSql( """ @ints1='1' @@ -2049,9 +2049,9 @@ END IN (@strings1, @strings2, @strings3) """); } - public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping() { - await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(); AssertSql( """ @@ -2071,9 +2071,9 @@ END IN (@strings1, @strings2, @strings3) """); } - public override async Task Parameter_collection_of_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_struct() { - await base.Parameter_collection_of_structs_Contains_struct(async); + await base.Parameter_collection_of_structs_Contains_struct(); AssertSql( """ @@ -2095,9 +2095,9 @@ WHERE [p].[WrappedId] NOT IN (@values1, @values2) """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct(); AssertSql( """ @@ -2119,9 +2119,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -2143,9 +2143,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_struct(); AssertSql( """ @@ -2166,9 +2166,9 @@ WHERE [p].[WrappedId] NOT IN (@values1, @values2) """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(); AssertSql( """ @@ -2189,9 +2189,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -2212,9 +2212,9 @@ WHERE [p].[NullableWrappedIdWithNullableComparer] NOT IN (@values1, @values2) OR """); } - public override async Task Values_of_enum_casted_to_underlying_value(bool async) + public override async Task Values_of_enum_casted_to_underlying_value() { - await base.Values_of_enum_casted_to_underlying_value(async); + await base.Values_of_enum_casted_to_underlying_value(); AssertSql( """ diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerJsonTypeTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerJsonTypeTest.cs index 338bad1c1ff..540a875ecd7 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerJsonTypeTest.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerJsonTypeTest.cs @@ -24,9 +24,9 @@ public PrimitiveCollectionsQuerySqlServerJsonTypeTest( public virtual void Check_all_tests_overridden() => TestHelpers.AssertAllMethodsOverridden(GetType()); - public override async Task Inline_collection_with_single_parameter_element_Contains(bool async) + public override async Task Inline_collection_with_single_parameter_element_Contains() { - await base.Inline_collection_with_single_parameter_element_Contains(async); + await base.Inline_collection_with_single_parameter_element_Contains(); AssertSql( """ @@ -38,9 +38,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_with_single_parameter_element_Count(bool async) + public override async Task Inline_collection_with_single_parameter_element_Count() { - await base.Inline_collection_with_single_parameter_element_Count(async); + await base.Inline_collection_with_single_parameter_element_Count(); AssertSql( """ @@ -55,9 +55,9 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_Contains_with_EF_Constant(bool async) + public override async Task Parameter_collection_Contains_with_EF_Constant() { - await base.Parameter_collection_Contains_with_EF_Constant(async); + await base.Parameter_collection_Contains_with_EF_Constant(); AssertSql( """ @@ -67,9 +67,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any() { - await base.Parameter_collection_Where_with_EF_Constant_Where_Any(async); + await base.Parameter_collection_Where_with_EF_Constant_Where_Any(); AssertSql( """ @@ -82,9 +82,9 @@ SELECT 1 """); } - public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant() { - await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(async); + await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(); AssertSql( """ @@ -97,24 +97,24 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_Count_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_Count_with_huge_number_of_values() { - await base.Parameter_collection_Count_with_huge_number_of_values(async); + await base.Parameter_collection_Count_with_huge_number_of_values(); Assert.Contains("OPENJSON(@ids) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); } - public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values() { - await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(async); + await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(); Assert.Contains("OPENJSON(@ints) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); Assert.Contains("OPENJSON(@ints) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[1], StringComparison.Ordinal); } - public override async Task Inline_collection_of_ints_Contains(bool async) + public override async Task Inline_collection_of_ints_Contains() { - await base.Inline_collection_of_ints_Contains(async); + await base.Inline_collection_of_ints_Contains(); AssertSql( """ @@ -124,9 +124,9 @@ WHERE [p].[Int] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains() { - await base.Inline_collection_of_nullable_ints_Contains(async); + await base.Inline_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -136,9 +136,9 @@ WHERE [p].[NullableInt] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains_null() { - await base.Inline_collection_of_nullable_ints_Contains_null(async); + await base.Inline_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -148,16 +148,16 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Count_with_zero_values(bool async) + public override async Task Inline_collection_Count_with_zero_values() { - await base.Inline_collection_Count_with_zero_values(async); + await base.Inline_collection_Count_with_zero_values(); AssertSql(); } - public override async Task Inline_collection_Count_with_one_value(bool async) + public override async Task Inline_collection_Count_with_one_value() { - await base.Inline_collection_Count_with_one_value(async); + await base.Inline_collection_Count_with_one_value(); AssertSql( """ @@ -170,9 +170,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_two_values(bool async) + public override async Task Inline_collection_Count_with_two_values() { - await base.Inline_collection_Count_with_two_values(async); + await base.Inline_collection_Count_with_two_values(); AssertSql( """ @@ -185,9 +185,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_three_values(bool async) + public override async Task Inline_collection_Count_with_three_values() { - await base.Inline_collection_Count_with_three_values(async); + await base.Inline_collection_Count_with_three_values(); AssertSql( """ @@ -200,9 +200,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_zero_values(bool async) + public override async Task Inline_collection_Contains_with_zero_values() { - await base.Inline_collection_Contains_with_zero_values(async); + await base.Inline_collection_Contains_with_zero_values(); AssertSql( """ @@ -212,9 +212,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_one_value(bool async) + public override async Task Inline_collection_Contains_with_one_value() { - await base.Inline_collection_Contains_with_one_value(async); + await base.Inline_collection_Contains_with_one_value(); AssertSql( """ @@ -224,9 +224,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_two_values(bool async) + public override async Task Inline_collection_Contains_with_two_values() { - await base.Inline_collection_Contains_with_two_values(async); + await base.Inline_collection_Contains_with_two_values(); AssertSql( """ @@ -236,9 +236,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_Contains_with_three_values(bool async) + public override async Task Inline_collection_Contains_with_three_values() { - await base.Inline_collection_Contains_with_three_values(async); + await base.Inline_collection_Contains_with_three_values(); AssertSql( """ @@ -248,9 +248,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Inline_collection_Contains_with_all_parameters(bool async) + public override async Task Inline_collection_Contains_with_all_parameters() { - await base.Inline_collection_Contains_with_all_parameters(async); + await base.Inline_collection_Contains_with_all_parameters(); AssertSql( """ @@ -263,9 +263,9 @@ WHERE [p].[Id] IN (@i, @j) """); } - public override async Task Inline_collection_Contains_with_constant_and_parameter(bool async) + public override async Task Inline_collection_Contains_with_constant_and_parameter() { - await base.Inline_collection_Contains_with_constant_and_parameter(async); + await base.Inline_collection_Contains_with_constant_and_parameter(); AssertSql( """ @@ -277,9 +277,9 @@ WHERE [p].[Id] IN (2, @j) """); } - public override async Task Inline_collection_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_Contains_with_mixed_value_types() { - await base.Inline_collection_Contains_with_mixed_value_types(async); + await base.Inline_collection_Contains_with_mixed_value_types(); AssertSql( """ @@ -291,9 +291,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_List_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_List_Contains_with_mixed_value_types() { - await base.Inline_collection_List_Contains_with_mixed_value_types(async); + await base.Inline_collection_List_Contains_with_mixed_value_types(); AssertSql( """ @@ -305,9 +305,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_Contains_as_Any_with_predicate(bool async) + public override async Task Inline_collection_Contains_as_Any_with_predicate() { - await base.Inline_collection_Contains_as_Any_with_predicate(async); + await base.Inline_collection_Contains_as_Any_with_predicate(); AssertSql( """ @@ -317,9 +317,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_negated_Contains_as_All(bool async) + public override async Task Inline_collection_negated_Contains_as_All() { - await base.Inline_collection_negated_Contains_as_All(async); + await base.Inline_collection_negated_Contains_as_All(); AssertSql( """ @@ -329,9 +329,9 @@ WHERE [p].[Id] NOT IN (2, 999) """); } - public override async Task Inline_collection_Min_with_two_values(bool async) + public override async Task Inline_collection_Min_with_two_values() { - await base.Inline_collection_Min_with_two_values(async); + await base.Inline_collection_Min_with_two_values(); AssertSql( """ @@ -341,9 +341,9 @@ WHERE LEAST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_List_Min_with_two_values(bool async) + public override async Task Inline_collection_List_Min_with_two_values() { - await base.Inline_collection_List_Min_with_two_values(async); + await base.Inline_collection_List_Min_with_two_values(); AssertSql( """ @@ -353,9 +353,9 @@ WHERE LEAST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_Max_with_two_values(bool async) + public override async Task Inline_collection_Max_with_two_values() { - await base.Inline_collection_Max_with_two_values(async); + await base.Inline_collection_Max_with_two_values(); AssertSql( """ @@ -365,9 +365,9 @@ WHERE GREATEST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_List_Max_with_two_values(bool async) + public override async Task Inline_collection_List_Max_with_two_values() { - await base.Inline_collection_List_Max_with_two_values(async); + await base.Inline_collection_List_Max_with_two_values(); AssertSql( """ @@ -377,9 +377,9 @@ WHERE GREATEST(30, [p].[Int]) = 30 """); } - public override async Task Inline_collection_Min_with_three_values(bool async) + public override async Task Inline_collection_Min_with_three_values() { - await base.Inline_collection_Min_with_three_values(async); + await base.Inline_collection_Min_with_three_values(); AssertSql( """ @@ -391,9 +391,9 @@ WHERE LEAST(30, [p].[Int], @i) = 25 """); } - public override async Task Inline_collection_List_Min_with_three_values(bool async) + public override async Task Inline_collection_List_Min_with_three_values() { - await base.Inline_collection_List_Min_with_three_values(async); + await base.Inline_collection_List_Min_with_three_values(); AssertSql( """ @@ -405,9 +405,9 @@ WHERE LEAST(30, [p].[Int], @i) = 25 """); } - public override async Task Inline_collection_Max_with_three_values(bool async) + public override async Task Inline_collection_Max_with_three_values() { - await base.Inline_collection_Max_with_three_values(async); + await base.Inline_collection_Max_with_three_values(); AssertSql( """ @@ -419,9 +419,9 @@ WHERE GREATEST(30, [p].[Int], @i) = 35 """); } - public override async Task Inline_collection_List_Max_with_three_values(bool async) + public override async Task Inline_collection_List_Max_with_three_values() { - await base.Inline_collection_List_Max_with_three_values(async); + await base.Inline_collection_List_Max_with_three_values(); AssertSql( """ @@ -433,9 +433,9 @@ WHERE GREATEST(30, [p].[Int], @i) = 35 """); } - public override async Task Inline_collection_of_nullable_value_type_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_Min() { - await base.Inline_collection_of_nullable_value_type_Min(async); + await base.Inline_collection_of_nullable_value_type_Min(); AssertSql( """ @@ -447,9 +447,9 @@ WHERE LEAST(30, [p].[Int], @i) = 25 """); } - public override async Task Inline_collection_of_nullable_value_type_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_Max() { - await base.Inline_collection_of_nullable_value_type_Max(async); + await base.Inline_collection_of_nullable_value_type_Max(); AssertSql( """ @@ -461,9 +461,9 @@ WHERE GREATEST(30, [p].[Int], @i) = 35 """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Min() { - await base.Inline_collection_of_nullable_value_type_with_null_Min(async); + await base.Inline_collection_of_nullable_value_type_with_null_Min(); AssertSql( """ @@ -473,9 +473,9 @@ WHERE LEAST(30, [p].[NullableInt], NULL) = 30 """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Max() { - await base.Inline_collection_of_nullable_value_type_with_null_Max(async); + await base.Inline_collection_of_nullable_value_type_with_null_Max(); AssertSql( """ @@ -485,9 +485,9 @@ WHERE GREATEST(30, [p].[NullableInt], NULL) = 30 """); } - public override async Task Parameter_collection_Count(bool async) + public override async Task Parameter_collection_Count() { - await base.Parameter_collection_Count(async); + await base.Parameter_collection_Count(); AssertSql( """ @@ -502,9 +502,9 @@ FROM OPENJSON(@ids) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_int() { - await base.Parameter_collection_of_ints_Contains_int(async); + await base.Parameter_collection_of_ints_Contains_int(); AssertSql( """ @@ -530,9 +530,9 @@ FROM OPENJSON(@ints) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_HashSet_of_ints_Contains_int() { - await base.Parameter_collection_HashSet_of_ints_Contains_int(async); + await base.Parameter_collection_HashSet_of_ints_Contains_int(); AssertSql( """ @@ -558,9 +558,9 @@ FROM OPENJSON(@ints) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int() { - await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(async); + await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(); AssertSql( """ @@ -586,9 +586,9 @@ FROM OPENJSON(@ints) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_of_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_nullable_int() { - await base.Parameter_collection_of_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_ints_Contains_nullable_int(); AssertSql( """ @@ -614,9 +614,9 @@ FROM OPENJSON(@ints) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_int() { - await base.Parameter_collection_of_nullable_ints_Contains_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_int(); AssertSql( """ @@ -642,9 +642,9 @@ FROM OPENJSON(@nullableInts) WITH ([value] int '$') AS [n] """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int() { - await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(); AssertSql( """ @@ -670,9 +670,9 @@ FROM OPENJSON(@nullableInts_without_nulls) AS [n] """); } - public override async Task Parameter_collection_of_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_string() { - await base.Parameter_collection_of_strings_Contains_string(async); + await base.Parameter_collection_of_strings_Contains_string(); AssertSql( """ @@ -698,9 +698,9 @@ FROM OPENJSON(@strings) WITH ([value] nvarchar(max) '$') AS [s] """); } - public override async Task Parameter_collection_of_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_nullable_string() { - await base.Parameter_collection_of_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_strings_Contains_nullable_string(); AssertSql( """ @@ -726,9 +726,9 @@ FROM OPENJSON(@strings) WITH ([value] nvarchar(max) '$') AS [s] """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_string() { - await base.Parameter_collection_of_nullable_strings_Contains_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_string(); AssertSql( """ @@ -754,9 +754,9 @@ FROM OPENJSON(@strings_without_nulls) AS [s] """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string() { - await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(); AssertSql( """ @@ -782,9 +782,9 @@ FROM OPENJSON(@strings_without_nulls) AS [s] """); } - public override async Task Parameter_collection_of_DateTimes_Contains(bool async) + public override async Task Parameter_collection_of_DateTimes_Contains() { - await base.Parameter_collection_of_DateTimes_Contains(async); + await base.Parameter_collection_of_DateTimes_Contains(); AssertSql( """ @@ -799,9 +799,9 @@ FROM OPENJSON(@dateTimes) WITH ([value] datetime '$') AS [d] """); } - public override async Task Parameter_collection_of_bools_Contains(bool async) + public override async Task Parameter_collection_of_bools_Contains() { - await base.Parameter_collection_of_bools_Contains(async); + await base.Parameter_collection_of_bools_Contains(); AssertSql( """ @@ -816,9 +816,9 @@ FROM OPENJSON(@bools) WITH ([value] bit '$') AS [b] """); } - public override async Task Parameter_collection_of_enums_Contains(bool async) + public override async Task Parameter_collection_of_enums_Contains() { - await base.Parameter_collection_of_enums_Contains(async); + await base.Parameter_collection_of_enums_Contains(); AssertSql( """ @@ -833,9 +833,9 @@ FROM OPENJSON(@enums) WITH ([value] int '$') AS [e] """); } - public override async Task Parameter_collection_null_Contains(bool async) + public override async Task Parameter_collection_null_Contains() { - await base.Parameter_collection_null_Contains(async); + await base.Parameter_collection_null_Contains(); AssertSql( """ @@ -848,9 +848,9 @@ FROM OPENJSON(NULL) AS [i] """); } - public override async Task Column_collection_of_ints_Contains(bool async) + public override async Task Column_collection_of_ints_Contains() { - await base.Column_collection_of_ints_Contains(async); + await base.Column_collection_of_ints_Contains(); AssertSql( """ @@ -863,9 +863,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_of_nullable_ints_Contains(bool async) + public override async Task Column_collection_of_nullable_ints_Contains() { - await base.Column_collection_of_nullable_ints_Contains(async); + await base.Column_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -878,9 +878,9 @@ FROM OPENJSON(CAST([p].[NullableInts] AS nvarchar(max))) WITH ([value] int '$') """); } - public override async Task Column_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Column_collection_of_nullable_ints_Contains_null() { - await base.Column_collection_of_nullable_ints_Contains_null(async); + await base.Column_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -893,9 +893,9 @@ FROM OPENJSON(CAST([p].[NullableInts] AS nvarchar(max))) WITH ([value] int '$') """); } - public override async Task Column_collection_of_strings_contains_null(bool async) + public override async Task Column_collection_of_strings_contains_null() { - await base.Column_collection_of_strings_contains_null(async); + await base.Column_collection_of_strings_contains_null(); AssertSql( """ @@ -905,9 +905,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_of_nullable_strings_contains_null(bool async) + public override async Task Column_collection_of_nullable_strings_contains_null() { - await base.Column_collection_of_nullable_strings_contains_null(async); + await base.Column_collection_of_nullable_strings_contains_null(); AssertSql( """ @@ -920,9 +920,9 @@ FROM OPENJSON(CAST([p].[NullableStrings] AS nvarchar(max))) WITH ([value] nvarch """); } - public override async Task Column_collection_of_bools_Contains(bool async) + public override async Task Column_collection_of_bools_Contains() { - await base.Column_collection_of_bools_Contains(async); + await base.Column_collection_of_bools_Contains(); AssertSql( """ @@ -946,9 +946,9 @@ await context.Database.SqlQuery($"SELECT [Bools] AS [Value] FROM [Primit .SingleAsync()); } - public override async Task Column_collection_Count_method(bool async) + public override async Task Column_collection_Count_method() { - await base.Column_collection_Count_method(async); + await base.Column_collection_Count_method(); AssertSql( """ @@ -960,9 +960,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) AS [i]) = 2 """); } - public override async Task Column_collection_Length(bool async) + public override async Task Column_collection_Length() { - await base.Column_collection_Length(async); + await base.Column_collection_Length(); AssertSql( """ @@ -974,9 +974,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) AS [i]) = 2 """); } - public override async Task Column_collection_Count_with_predicate(bool async) + public override async Task Column_collection_Count_with_predicate() { - await base.Column_collection_Count_with_predicate(async); + await base.Column_collection_Count_with_predicate(); AssertSql( """ @@ -989,9 +989,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_Where_Count(bool async) + public override async Task Column_collection_Where_Count() { - await base.Column_collection_Where_Count(async); + await base.Column_collection_Where_Count(); AssertSql( """ @@ -1004,9 +1004,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_index_int(bool async) + public override async Task Column_collection_index_int() { - await base.Column_collection_index_int(async); + await base.Column_collection_index_int(); AssertSql( """ @@ -1016,9 +1016,9 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[1]') AS int) = 10 """); } - public override async Task Column_collection_index_string(bool async) + public override async Task Column_collection_index_string() { - await base.Column_collection_index_string(async); + await base.Column_collection_index_string(); AssertSql( """ @@ -1028,9 +1028,9 @@ WHERE JSON_VALUE([p].[Strings], '$[1]') = N'10' """); } - public override async Task Column_collection_index_datetime(bool async) + public override async Task Column_collection_index_datetime() { - await base.Column_collection_index_datetime(async); + await base.Column_collection_index_datetime(); AssertSql( """ @@ -1040,9 +1040,9 @@ WHERE CAST(JSON_VALUE([p].[DateTimes], '$[1]') AS datetime2) = '2020-01-10T12:30 """); } - public override async Task Column_collection_index_beyond_end(bool async) + public override async Task Column_collection_index_beyond_end() { - await base.Column_collection_index_beyond_end(async); + await base.Column_collection_index_beyond_end(); AssertSql( """ @@ -1052,10 +1052,10 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[999]') AS int) = 10 """); } - public override async Task Nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Nullable_reference_column_collection_index_equals_nullable_column() { // TODO: This test is incorrect, see #33784 - await base.Nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1065,9 +1065,9 @@ WHERE JSON_VALUE([p].[NullableStrings], '$[2]') = [p].[NullableString] OR (JSON_ """); } - public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column() { - await base.Non_nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Non_nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1079,9 +1079,9 @@ FROM OPENJSON(CAST([p].[Strings] AS nvarchar(max))) AS [s]) AND JSON_VALUE([p].[ """); } - public override async Task Inline_collection_index_Column(bool async) + public override async Task Inline_collection_index_Column() { - await base.Inline_collection_index_Column(async); + await base.Inline_collection_index_Column(); AssertSql( """ @@ -1095,9 +1095,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_value_index_Column(bool async) + public override async Task Inline_collection_value_index_Column() { - await base.Inline_collection_value_index_Column(async); + await base.Inline_collection_value_index_Column(); AssertSql( """ @@ -1111,9 +1111,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_List_value_index_Column(bool async) + public override async Task Inline_collection_List_value_index_Column() { - await base.Inline_collection_List_value_index_Column(async); + await base.Inline_collection_List_value_index_Column(); AssertSql( """ @@ -1128,9 +1128,9 @@ ORDER BY [v].[_ord] } [SqlServerCondition(SqlServerCondition.SupportsJsonPathExpressions)] - public override async Task Parameter_collection_index_Column_equal_Column(bool async) + public override async Task Parameter_collection_index_Column_equal_Column() { - await base.Parameter_collection_index_Column_equal_Column(async); + await base.Parameter_collection_index_Column_equal_Column(); AssertSql( """ @@ -1143,9 +1143,9 @@ WHERE CAST(JSON_VALUE(@ints, '$[' + CAST([p].[Int] AS nvarchar(max)) + ']') AS i } [SqlServerCondition(SqlServerCondition.SupportsJsonPathExpressions)] - public override async Task Parameter_collection_index_Column_equal_constant(bool async) + public override async Task Parameter_collection_index_Column_equal_constant() { - await base.Parameter_collection_index_Column_equal_constant(async); + await base.Parameter_collection_index_Column_equal_constant(); AssertSql( """ @@ -1157,9 +1157,9 @@ WHERE CAST(JSON_VALUE(@ints, '$[' + CAST([p].[Int] AS nvarchar(max)) + ']') AS i """); } - public override async Task Column_collection_ElementAt(bool async) + public override async Task Column_collection_ElementAt() { - await base.Column_collection_ElementAt(async); + await base.Column_collection_ElementAt(); AssertSql( """ @@ -1169,9 +1169,9 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[1]') AS int) = 10 """); } - public override async Task Column_collection_First(bool async) + public override async Task Column_collection_First() { - await base.Column_collection_First(async); + await base.Column_collection_First(); AssertSql( """ @@ -1184,9 +1184,9 @@ ORDER BY CAST([i].[key] AS int)) = 1 """); } - public override async Task Column_collection_FirstOrDefault(bool async) + public override async Task Column_collection_FirstOrDefault() { - await base.Column_collection_FirstOrDefault(async); + await base.Column_collection_FirstOrDefault(); AssertSql( """ @@ -1199,9 +1199,9 @@ ORDER BY CAST([i].[key] AS int)), 0) = 1 """); } - public override async Task Column_collection_Single(bool async) + public override async Task Column_collection_Single() { - await base.Column_collection_Single(async); + await base.Column_collection_Single(); AssertSql( """ @@ -1214,9 +1214,9 @@ ORDER BY CAST([i].[key] AS int)) = 1 """); } - public override async Task Column_collection_SingleOrDefault(bool async) + public override async Task Column_collection_SingleOrDefault() { - await base.Column_collection_SingleOrDefault(async); + await base.Column_collection_SingleOrDefault(); AssertSql( """ @@ -1229,9 +1229,9 @@ ORDER BY CAST([i].[key] AS int)), 0) = 1 """); } - public override async Task Column_collection_Skip(bool async) + public override async Task Column_collection_Skip() { - await base.Column_collection_Skip(async); + await base.Column_collection_Skip(); AssertSql( """ @@ -1248,9 +1248,9 @@ OFFSET 1 ROWS """); } - public override async Task Column_collection_Take(bool async) + public override async Task Column_collection_Take() { - await base.Column_collection_Take(async); + await base.Column_collection_Take(); AssertSql( """ @@ -1264,9 +1264,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Skip_Take(bool async) + public override async Task Column_collection_Skip_Take() { - await base.Column_collection_Skip_Take(async); + await base.Column_collection_Skip_Take(); AssertSql( """ @@ -1281,9 +1281,9 @@ OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY """); } - public override async Task Column_collection_Where_Skip(bool async) + public override async Task Column_collection_Where_Skip() { - await base.Column_collection_Where_Skip(async); + await base.Column_collection_Where_Skip(); AssertSql( """ @@ -1301,9 +1301,9 @@ OFFSET 1 ROWS """); } - public override async Task Column_collection_Where_Take(bool async) + public override async Task Column_collection_Where_Take() { - await base.Column_collection_Where_Take(async); + await base.Column_collection_Where_Take(); AssertSql( """ @@ -1320,9 +1320,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Where_Skip_Take(bool async) + public override async Task Column_collection_Where_Skip_Take() { - await base.Column_collection_Where_Skip_Take(async); + await base.Column_collection_Where_Skip_Take(); AssertSql( """ @@ -1340,9 +1340,9 @@ OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY """); } - public override async Task Column_collection_Contains_over_subquery(bool async) + public override async Task Column_collection_Contains_over_subquery() { - await base.Column_collection_Contains_over_subquery(async); + await base.Column_collection_Contains_over_subquery(); AssertSql( """ @@ -1356,9 +1356,9 @@ WHERE [i].[value] > 1 """); } - public override async Task Column_collection_OrderByDescending_ElementAt(bool async) + public override async Task Column_collection_OrderByDescending_ElementAt() { - await base.Column_collection_OrderByDescending_ElementAt(async); + await base.Column_collection_OrderByDescending_ElementAt(); AssertSql( """ @@ -1372,9 +1372,9 @@ ORDER BY [i].[value] DESC """); } - public override async Task Column_collection_Where_ElementAt(bool async) + public override async Task Column_collection_Where_ElementAt() { - await base.Column_collection_Where_ElementAt(async); + await base.Column_collection_Where_ElementAt(); AssertSql( """ @@ -1389,9 +1389,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Any(bool async) + public override async Task Column_collection_Any() { - await base.Column_collection_Any(async); + await base.Column_collection_Any(); AssertSql( """ @@ -1403,9 +1403,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) AS [i]) """); } - public override async Task Column_collection_Distinct(bool async) + public override async Task Column_collection_Distinct() { - await base.Column_collection_Distinct(async); + await base.Column_collection_Distinct(); AssertSql( """ @@ -1420,9 +1420,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_SelectMany(bool async) + public override async Task Column_collection_SelectMany() { - await base.Column_collection_SelectMany(async); + await base.Column_collection_SelectMany(); AssertSql( """ @@ -1432,9 +1432,9 @@ CROSS APPLY OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') A """); } - public override async Task Column_collection_SelectMany_with_filter(bool async) + public override async Task Column_collection_SelectMany_with_filter() { - await base.Column_collection_SelectMany_with_filter(async); + await base.Column_collection_SelectMany_with_filter(); AssertSql( """ @@ -1448,9 +1448,9 @@ WHERE [i].[value] > 1 """); } - public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) + public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type() { - await base.Column_collection_SelectMany_with_Select_to_anonymous_type(async); + await base.Column_collection_SelectMany_with_Select_to_anonymous_type(); AssertSql( """ @@ -1460,9 +1460,9 @@ CROSS APPLY OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') A """); } - public override async Task Column_collection_projection_from_top_level(bool async) + public override async Task Column_collection_projection_from_top_level() { - await base.Column_collection_projection_from_top_level(async); + await base.Column_collection_projection_from_top_level(); AssertSql( """ @@ -1472,9 +1472,9 @@ ORDER BY [p].[Id] """); } - public override async Task Column_collection_Join_parameter_collection(bool async) + public override async Task Column_collection_Join_parameter_collection() { - await base.Column_collection_Join_parameter_collection(async); + await base.Column_collection_Join_parameter_collection(); AssertSql( """ @@ -1489,9 +1489,9 @@ INNER JOIN OPENJSON(@ints) WITH ([value] int '$') AS [i0] ON [i].[value] = [i0]. """); } - public override async Task Inline_collection_Join_ordered_column_collection(bool async) + public override async Task Inline_collection_Join_ordered_column_collection() { - await base.Inline_collection_Join_ordered_column_collection(async); + await base.Inline_collection_Join_ordered_column_collection(); AssertSql( """ @@ -1504,9 +1504,9 @@ INNER JOIN OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS """); } - public override async Task Parameter_collection_Concat_column_collection(bool async) + public override async Task Parameter_collection_Concat_column_collection() { - await base.Parameter_collection_Concat_column_collection(async); + await base.Parameter_collection_Concat_column_collection(); AssertSql( """ @@ -1526,9 +1526,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) AS [i0] """); } - public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) + public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression() { - await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(async); + await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(); AssertSql( """ @@ -1542,9 +1542,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_Union_parameter_collection(bool async) + public override async Task Column_collection_Union_parameter_collection() { - await base.Column_collection_Union_parameter_collection(async); + await base.Column_collection_Union_parameter_collection(); AssertSql( """ @@ -1564,9 +1564,9 @@ FROM OPENJSON(@ints) WITH ([value] int '$') AS [i0] """); } - public override async Task Column_collection_Intersect_inline_collection(bool async) + public override async Task Column_collection_Intersect_inline_collection() { - await base.Column_collection_Intersect_inline_collection(async); + await base.Column_collection_Intersect_inline_collection(); AssertSql( """ @@ -1584,9 +1584,9 @@ SELECT [v].[Value] AS [value] """); } - public override async Task Inline_collection_Except_column_collection(bool async) + public override async Task Inline_collection_Except_column_collection() { - await base.Inline_collection_Except_column_collection(async); + await base.Inline_collection_Except_column_collection(); AssertSql( """ @@ -1605,9 +1605,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_Where_Union(bool async) + public override async Task Column_collection_Where_Union() { - await base.Column_collection_Where_Union(async); + await base.Column_collection_Where_Union(); AssertSql( """ @@ -1626,12 +1626,12 @@ SELECT [v].[Value] AS [value] """); } - public override async Task Column_collection_equality_parameter_collection(bool async) + public override async Task Column_collection_equality_parameter_collection() { // TODO:SQLJSON Json type is not comparable Assert.Equal( "The JSON data type cannot be compared or sorted, except when using the IS NULL operator.", - (await Assert.ThrowsAsync(() => base.Column_collection_equality_parameter_collection(async))).Message); + (await Assert.ThrowsAsync(() => base.Column_collection_equality_parameter_collection())).Message); AssertSql( """ @@ -1643,19 +1643,19 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) + public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection() { - await base.Column_collection_Concat_parameter_collection_equality_inline_collection(async); + await base.Column_collection_Concat_parameter_collection_equality_inline_collection(); AssertSql(); } - public override async Task Column_collection_equality_inline_collection(bool async) + public override async Task Column_collection_equality_inline_collection() { // TODO:SQLJSON Json type is not comparable Assert.Equal( "The data types json and varchar are incompatible in the equal to operator.", - (await Assert.ThrowsAsync(() => base.Column_collection_equality_inline_collection(async))).Message); + (await Assert.ThrowsAsync(() => base.Column_collection_equality_inline_collection())).Message); AssertSql( """ @@ -1665,23 +1665,23 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_equality_inline_collection_with_parameters(bool async) + public override async Task Column_collection_equality_inline_collection_with_parameters() { - await base.Column_collection_equality_inline_collection_with_parameters(async); + await base.Column_collection_equality_inline_collection_with_parameters(); AssertSql(); } - public override async Task Column_collection_Where_equality_inline_collection(bool async) + public override async Task Column_collection_Where_equality_inline_collection() { - await base.Column_collection_Where_equality_inline_collection(async); + await base.Column_collection_Where_equality_inline_collection(); AssertSql(); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(); AssertSql( """ @@ -1706,9 +1706,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS [i0] """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection() { - await base.Parameter_collection_in_subquery_Union_column_collection(async); + await base.Parameter_collection_in_subquery_Union_column_collection(); AssertSql( """ @@ -1728,9 +1728,9 @@ FROM OPENJSON(CAST([p].[Ints] AS nvarchar(max))) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_nested(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_nested() { - await base.Parameter_collection_in_subquery_Union_column_collection_nested(async); + await base.Parameter_collection_in_subquery_Union_column_collection_nested(); AssertSql( """ @@ -1769,9 +1769,9 @@ public override void Parameter_collection_in_subquery_and_Convert_as_compiled_qu AssertSql(); } - public override async Task Parameter_collection_in_subquery_Count_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Count_as_compiled_query() { - await base.Parameter_collection_in_subquery_Count_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Count_as_compiled_query(); // TODO: the subquery projection contains extra columns which we should remove AssertSql( @@ -1792,16 +1792,16 @@ OFFSET 1 ROWS """); } - public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(); AssertSql(); } - public override async Task Column_collection_in_subquery_Union_parameter_collection(bool async) + public override async Task Column_collection_in_subquery_Union_parameter_collection() { - await base.Column_collection_in_subquery_Union_parameter_collection(async); + await base.Column_collection_in_subquery_Union_parameter_collection(); AssertSql( """ @@ -1826,9 +1826,9 @@ FROM OPENJSON(@ints) WITH ([value] int '$') AS [i0] """); } - public override async Task Project_collection_of_ints_simple(bool async) + public override async Task Project_collection_of_ints_simple() { - await base.Project_collection_of_ints_simple(async); + await base.Project_collection_of_ints_simple(); AssertSql( """ @@ -1838,9 +1838,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_ints_ordered(bool async) + public override async Task Project_collection_of_ints_ordered() { - await base.Project_collection_of_ints_ordered(async); + await base.Project_collection_of_ints_ordered(); AssertSql( """ @@ -1851,9 +1851,9 @@ OUTER APPLY OPENJSON(CAST([p].[Ints] AS nvarchar(max))) AS [i] """); } - public override async Task Project_collection_of_datetimes_filtered(bool async) + public override async Task Project_collection_of_datetimes_filtered() { - await base.Project_collection_of_datetimes_filtered(async); + await base.Project_collection_of_datetimes_filtered(); AssertSql( """ @@ -1868,9 +1868,9 @@ WHERE DATEPART(day, CAST([d].[value] AS datetime2)) <> 1 """); } - public override async Task Project_collection_of_nullable_ints_with_paging(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging() { - await base.Project_collection_of_nullable_ints_with_paging(async); + await base.Project_collection_of_nullable_ints_with_paging(); AssertSql( """ @@ -1885,9 +1885,9 @@ ORDER BY CAST([n].[key] AS int) """); } - public override async Task Project_collection_of_nullable_ints_with_paging2(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging2() { - await base.Project_collection_of_nullable_ints_with_paging2(async); + await base.Project_collection_of_nullable_ints_with_paging2(); AssertSql( """ @@ -1903,9 +1903,9 @@ OFFSET 1 ROWS """); } - public override async Task Project_collection_of_nullable_ints_with_paging3(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging3() { - await base.Project_collection_of_nullable_ints_with_paging3(async); + await base.Project_collection_of_nullable_ints_with_paging3(); AssertSql( """ @@ -1921,9 +1921,9 @@ OFFSET 2 ROWS """); } - public override async Task Project_collection_of_ints_with_distinct(bool async) + public override async Task Project_collection_of_ints_with_distinct() { - await base.Project_collection_of_ints_with_distinct(async); + await base.Project_collection_of_ints_with_distinct(); AssertSql( """ @@ -1937,16 +1937,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_nullable_ints_with_distinct(bool async) + public override async Task Project_collection_of_nullable_ints_with_distinct() { - await base.Project_collection_of_nullable_ints_with_distinct(async); + await base.Project_collection_of_nullable_ints_with_distinct(); AssertSql(""); } - public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault(bool async) + public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault() { - await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(async); + await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(); AssertSql( """ @@ -1961,9 +1961,9 @@ OUTER APPLY OPENJSON(CAST([p0].[Ints] AS nvarchar(max))) AS [i] """); } - public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls(bool async) + public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls() { - await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(async); + await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(); AssertSql( """ @@ -1983,9 +1983,9 @@ WHERE [n0].[value] IS NULL """); } - public override async Task Project_multiple_collections(bool async) + public override async Task Project_multiple_collections() { - await base.Project_multiple_collections(async); + await base.Project_multiple_collections(); AssertSql( """ @@ -2007,9 +2007,9 @@ WHERE CAST([d0].[value] AS datetime2) > '2000-01-01T00:00:00.0000000' """); } - public override async Task Project_primitive_collections_element(bool async) + public override async Task Project_primitive_collections_element() { - await base.Project_primitive_collections_element(async); + await base.Project_primitive_collections_element(); AssertSql( """ @@ -2020,9 +2020,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection(bool async) + public override async Task Project_inline_collection() { - await base.Project_inline_collection(async); + await base.Project_inline_collection(); AssertSql( """ @@ -2031,9 +2031,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Project_inline_collection_with_Union(bool async) + public override async Task Project_inline_collection_with_Union() { - await base.Project_inline_collection_with_Union(async); + await base.Project_inline_collection_with_Union(); AssertSql( """ @@ -2050,16 +2050,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection_with_Concat(bool async) + public override async Task Project_inline_collection_with_Concat() { - await base.Project_inline_collection_with_Concat(async); + await base.Project_inline_collection_with_Concat(); AssertSql(); } - public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping() { - await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(); AssertSql( """ @@ -2081,9 +2081,9 @@ FROM OPENJSON(@strings) WITH ([value] nvarchar(max) '$') AS [s] """); } - public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping() { - await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(); AssertSql( """ @@ -2105,9 +2105,9 @@ FROM OPENJSON(@strings) WITH ([value] nvarchar(max) '$') AS [s] """); } - public override async Task Values_of_enum_casted_to_underlying_value(bool async) + public override async Task Values_of_enum_casted_to_underlying_value() { - await base.Values_of_enum_casted_to_underlying_value(async); + await base.Values_of_enum_casted_to_underlying_value(); AssertSql( """ diff --git a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerTest.cs b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerTest.cs index c0164a1fe15..597ee0976cd 100644 --- a/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerTest.cs +++ b/test/EFCore.SqlServer.FunctionalTests/Query/PrimitiveCollectionsQuerySqlServerTest.cs @@ -15,9 +15,9 @@ public PrimitiveCollectionsQuerySqlServerTest(PrimitiveCollectionsQuerySqlServer Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override async Task Inline_collection_of_ints_Contains(bool async) + public override async Task Inline_collection_of_ints_Contains() { - await base.Inline_collection_of_ints_Contains(async); + await base.Inline_collection_of_ints_Contains(); AssertSql( """ @@ -27,9 +27,9 @@ WHERE [p].[Int] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains() { - await base.Inline_collection_of_nullable_ints_Contains(async); + await base.Inline_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -39,9 +39,9 @@ WHERE [p].[NullableInt] IN (10, 999) """); } - public override async Task Inline_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains_null() { - await base.Inline_collection_of_nullable_ints_Contains_null(async); + await base.Inline_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -51,16 +51,16 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Count_with_zero_values(bool async) + public override async Task Inline_collection_Count_with_zero_values() { - await base.Inline_collection_Count_with_zero_values(async); + await base.Inline_collection_Count_with_zero_values(); AssertSql(); } - public override async Task Inline_collection_Count_with_one_value(bool async) + public override async Task Inline_collection_Count_with_one_value() { - await base.Inline_collection_Count_with_one_value(async); + await base.Inline_collection_Count_with_one_value(); AssertSql( """ @@ -73,9 +73,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_two_values(bool async) + public override async Task Inline_collection_Count_with_two_values() { - await base.Inline_collection_Count_with_two_values(async); + await base.Inline_collection_Count_with_two_values(); AssertSql( """ @@ -88,9 +88,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_three_values(bool async) + public override async Task Inline_collection_Count_with_three_values() { - await base.Inline_collection_Count_with_three_values(async); + await base.Inline_collection_Count_with_three_values(); AssertSql( """ @@ -103,9 +103,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_zero_values(bool async) + public override async Task Inline_collection_Contains_with_zero_values() { - await base.Inline_collection_Contains_with_zero_values(async); + await base.Inline_collection_Contains_with_zero_values(); AssertSql( """ @@ -115,9 +115,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_one_value(bool async) + public override async Task Inline_collection_Contains_with_one_value() { - await base.Inline_collection_Contains_with_one_value(async); + await base.Inline_collection_Contains_with_one_value(); AssertSql( """ @@ -127,9 +127,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_Contains_with_two_values(bool async) + public override async Task Inline_collection_Contains_with_two_values() { - await base.Inline_collection_Contains_with_two_values(async); + await base.Inline_collection_Contains_with_two_values(); AssertSql( """ @@ -139,9 +139,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_Contains_with_three_values(bool async) + public override async Task Inline_collection_Contains_with_three_values() { - await base.Inline_collection_Contains_with_three_values(async); + await base.Inline_collection_Contains_with_three_values(); AssertSql( """ @@ -151,9 +151,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Inline_collection_Contains_with_all_parameters(bool async) + public override async Task Inline_collection_Contains_with_all_parameters() { - await base.Inline_collection_Contains_with_all_parameters(async); + await base.Inline_collection_Contains_with_all_parameters(); AssertSql( """ @@ -166,9 +166,9 @@ WHERE [p].[Id] IN (@i, @j) """); } - public override async Task Inline_collection_Contains_with_constant_and_parameter(bool async) + public override async Task Inline_collection_Contains_with_constant_and_parameter() { - await base.Inline_collection_Contains_with_constant_and_parameter(async); + await base.Inline_collection_Contains_with_constant_and_parameter(); AssertSql( """ @@ -180,9 +180,9 @@ WHERE [p].[Id] IN (2, @j) """); } - public override async Task Inline_collection_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_Contains_with_mixed_value_types() { - await base.Inline_collection_Contains_with_mixed_value_types(async); + await base.Inline_collection_Contains_with_mixed_value_types(); AssertSql( """ @@ -194,9 +194,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_List_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_List_Contains_with_mixed_value_types() { - await base.Inline_collection_List_Contains_with_mixed_value_types(async); + await base.Inline_collection_List_Contains_with_mixed_value_types(); AssertSql( """ @@ -208,9 +208,9 @@ WHERE [p].[Int] IN (999, @i, [p].[Id], [p].[Id] + [p].[Int]) """); } - public override async Task Inline_collection_Contains_as_Any_with_predicate(bool async) + public override async Task Inline_collection_Contains_as_Any_with_predicate() { - await base.Inline_collection_Contains_as_Any_with_predicate(async); + await base.Inline_collection_Contains_as_Any_with_predicate(); AssertSql( """ @@ -220,9 +220,9 @@ WHERE [p].[Id] IN (2, 999) """); } - public override async Task Inline_collection_negated_Contains_as_All(bool async) + public override async Task Inline_collection_negated_Contains_as_All() { - await base.Inline_collection_negated_Contains_as_All(async); + await base.Inline_collection_negated_Contains_as_All(); AssertSql( """ @@ -232,9 +232,9 @@ WHERE [p].[Id] NOT IN (2, 999) """); } - public override async Task Inline_collection_Min_with_two_values(bool async) + public override async Task Inline_collection_Min_with_two_values() { - await base.Inline_collection_Min_with_two_values(async); + await base.Inline_collection_Min_with_two_values(); AssertSql( """ @@ -246,9 +246,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_List_Min_with_two_values(bool async) + public override async Task Inline_collection_List_Min_with_two_values() { - await base.Inline_collection_List_Min_with_two_values(async); + await base.Inline_collection_List_Min_with_two_values(); AssertSql( """ @@ -260,9 +260,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_Max_with_two_values(bool async) + public override async Task Inline_collection_Max_with_two_values() { - await base.Inline_collection_Max_with_two_values(async); + await base.Inline_collection_Max_with_two_values(); AssertSql( """ @@ -274,9 +274,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_List_Max_with_two_values(bool async) + public override async Task Inline_collection_List_Max_with_two_values() { - await base.Inline_collection_List_Max_with_two_values(async); + await base.Inline_collection_List_Max_with_two_values(); AssertSql( """ @@ -288,9 +288,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_Min_with_three_values(bool async) + public override async Task Inline_collection_Min_with_three_values() { - await base.Inline_collection_Min_with_three_values(async); + await base.Inline_collection_Min_with_three_values(); AssertSql( """ @@ -304,9 +304,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_List_Min_with_three_values(bool async) + public override async Task Inline_collection_List_Min_with_three_values() { - await base.Inline_collection_List_Min_with_three_values(async); + await base.Inline_collection_List_Min_with_three_values(); AssertSql( """ @@ -320,9 +320,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_Max_with_three_values(bool async) + public override async Task Inline_collection_Max_with_three_values() { - await base.Inline_collection_Max_with_three_values(async); + await base.Inline_collection_Max_with_three_values(); AssertSql( """ @@ -336,9 +336,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_List_Max_with_three_values(bool async) + public override async Task Inline_collection_List_Max_with_three_values() { - await base.Inline_collection_List_Max_with_three_values(async); + await base.Inline_collection_List_Max_with_three_values(); AssertSql( """ @@ -352,9 +352,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_Min() { - await base.Inline_collection_of_nullable_value_type_Min(async); + await base.Inline_collection_of_nullable_value_type_Min(); AssertSql( """ @@ -368,9 +368,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_Max() { - await base.Inline_collection_of_nullable_value_type_Max(async); + await base.Inline_collection_of_nullable_value_type_Max(); AssertSql( """ @@ -384,9 +384,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Min() { - await base.Inline_collection_of_nullable_value_type_with_null_Min(async); + await base.Inline_collection_of_nullable_value_type_with_null_Min(); AssertSql( """ @@ -398,9 +398,9 @@ SELECT MIN([v].[Value]) """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Max() { - await base.Inline_collection_of_nullable_value_type_with_null_Max(async); + await base.Inline_collection_of_nullable_value_type_with_null_Max(); AssertSql( """ @@ -412,9 +412,9 @@ SELECT MAX([v].[Value]) """); } - public override async Task Inline_collection_with_single_parameter_element_Contains(bool async) + public override async Task Inline_collection_with_single_parameter_element_Contains() { - await base.Inline_collection_with_single_parameter_element_Contains(async); + await base.Inline_collection_with_single_parameter_element_Contains(); AssertSql( """ @@ -426,9 +426,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Inline_collection_with_single_parameter_element_Count(bool async) + public override async Task Inline_collection_with_single_parameter_element_Count() { - await base.Inline_collection_with_single_parameter_element_Count(async); + await base.Inline_collection_with_single_parameter_element_Count(); AssertSql( """ @@ -443,9 +443,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_EF_Parameter(bool async) + public override async Task Inline_collection_Contains_with_EF_Parameter() { - await base.Inline_collection_Contains_with_EF_Parameter(async); + await base.Inline_collection_Contains_with_EF_Parameter(); AssertSql( """ @@ -460,9 +460,9 @@ FROM OPENJSON(@p) WITH ([value] int '$') AS [p0] """); } - public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter(bool async) + public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter() { - await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(async); + await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(); AssertSql( """ @@ -477,9 +477,9 @@ FROM OPENJSON(@p) WITH ([value] int '$') AS [p0] """); } - public override async Task Parameter_collection_Count(bool async) + public override async Task Parameter_collection_Count() { - await base.Parameter_collection_Count(async); + await base.Parameter_collection_Count(); AssertSql( """ @@ -495,9 +495,9 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_int() { - await base.Parameter_collection_of_ints_Contains_int(async); + await base.Parameter_collection_of_ints_Contains_int(); AssertSql( """ @@ -519,9 +519,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_HashSet_of_ints_Contains_int() { - await base.Parameter_collection_HashSet_of_ints_Contains_int(async); + await base.Parameter_collection_HashSet_of_ints_Contains_int(); AssertSql( """ @@ -543,9 +543,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int() { - await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(async); + await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(); AssertSql( """ @@ -567,9 +567,9 @@ WHERE [p].[Int] NOT IN (@ints1, @ints2) """); } - public override async Task Parameter_collection_of_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_nullable_int() { - await base.Parameter_collection_of_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_ints_Contains_nullable_int(); AssertSql( """ @@ -591,9 +591,9 @@ WHERE [p].[NullableInt] NOT IN (@ints1, @ints2) OR [p].[NullableInt] IS NULL """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_int() { - await base.Parameter_collection_of_nullable_ints_Contains_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_int(); AssertSql( """ @@ -615,9 +615,9 @@ WHERE [p].[Int] NOT IN (@nullableInts1, @nullableInts2) """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int() { - await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(); AssertSql( """ @@ -637,9 +637,9 @@ WHERE [p].[NullableInt] IS NOT NULL AND [p].[NullableInt] <> @nullableInts1 """); } - public override async Task Parameter_collection_of_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_string() { - await base.Parameter_collection_of_strings_Contains_string(async); + await base.Parameter_collection_of_strings_Contains_string(); AssertSql( """ @@ -661,9 +661,9 @@ WHERE [p].[String] NOT IN (@strings1, @strings2) """); } - public override async Task Parameter_collection_of_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_nullable_string() { - await base.Parameter_collection_of_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_strings_Contains_nullable_string(); AssertSql( """ @@ -685,9 +685,9 @@ WHERE [p].[NullableString] NOT IN (@strings1, @strings2) OR [p].[NullableString] """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_string() { - await base.Parameter_collection_of_nullable_strings_Contains_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_string(); AssertSql( """ @@ -707,9 +707,9 @@ WHERE [p].[String] <> @strings1 """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string() { - await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(); AssertSql( """ @@ -729,9 +729,9 @@ WHERE [p].[NullableString] IS NOT NULL AND [p].[NullableString] <> @strings1 """); } - public override async Task Parameter_collection_of_DateTimes_Contains(bool async) + public override async Task Parameter_collection_of_DateTimes_Contains() { - await base.Parameter_collection_of_DateTimes_Contains(async); + await base.Parameter_collection_of_DateTimes_Contains(); AssertSql( """ @@ -744,9 +744,9 @@ WHERE [p].[DateTime] IN (@dateTimes1, @dateTimes2) """); } - public override async Task Parameter_collection_of_bools_Contains(bool async) + public override async Task Parameter_collection_of_bools_Contains() { - await base.Parameter_collection_of_bools_Contains(async); + await base.Parameter_collection_of_bools_Contains(); AssertSql( """ @@ -758,9 +758,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Parameter_collection_of_enums_Contains(bool async) + public override async Task Parameter_collection_of_enums_Contains() { - await base.Parameter_collection_of_enums_Contains(async); + await base.Parameter_collection_of_enums_Contains(); AssertSql( """ @@ -773,9 +773,9 @@ WHERE [p].[Enum] IN (@enums1, @enums2) """); } - public override async Task Parameter_collection_null_Contains(bool async) + public override async Task Parameter_collection_null_Contains() { - await base.Parameter_collection_null_Contains(async); + await base.Parameter_collection_null_Contains(); AssertSql( """ @@ -785,9 +785,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Parameter_collection_Contains_with_EF_Constant(bool async) + public override async Task Parameter_collection_Contains_with_EF_Constant() { - await base.Parameter_collection_Contains_with_EF_Constant(async); + await base.Parameter_collection_Contains_with_EF_Constant(); AssertSql( """ @@ -797,9 +797,9 @@ WHERE [p].[Id] IN (2, 999, 1000) """); } - public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any() { - await base.Parameter_collection_Where_with_EF_Constant_Where_Any(async); + await base.Parameter_collection_Where_with_EF_Constant_Where_Any(); AssertSql( """ @@ -812,9 +812,9 @@ SELECT 1 """); } - public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant() { - await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(async); + await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(); AssertSql( """ @@ -827,24 +827,24 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_Count_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_Count_with_huge_number_of_values() { - await base.Parameter_collection_Count_with_huge_number_of_values(async); + await base.Parameter_collection_Count_with_huge_number_of_values(); Assert.Contains("OPENJSON(@ids) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); } - public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(bool async) + public override async Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values() { - await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(async); + await base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(); Assert.Contains("OPENJSON(@ints) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[0], StringComparison.Ordinal); Assert.Contains("OPENJSON(@ints) WITH ([value] int '$')", Fixture.TestSqlLoggerFactory.SqlStatements[1], StringComparison.Ordinal); } - public override async Task Column_collection_of_ints_Contains(bool async) + public override async Task Column_collection_of_ints_Contains() { - await base.Column_collection_of_ints_Contains(async); + await base.Column_collection_of_ints_Contains(); AssertSql( """ @@ -857,9 +857,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_of_nullable_ints_Contains(bool async) + public override async Task Column_collection_of_nullable_ints_Contains() { - await base.Column_collection_of_nullable_ints_Contains(async); + await base.Column_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -872,9 +872,9 @@ FROM OPENJSON([p].[NullableInts]) WITH ([value] int '$') AS [n] """); } - public override async Task Column_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Column_collection_of_nullable_ints_Contains_null() { - await base.Column_collection_of_nullable_ints_Contains_null(async); + await base.Column_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -887,9 +887,9 @@ FROM OPENJSON([p].[NullableInts]) WITH ([value] int '$') AS [n] """); } - public override async Task Column_collection_of_strings_contains_null(bool async) + public override async Task Column_collection_of_strings_contains_null() { - await base.Column_collection_of_strings_contains_null(async); + await base.Column_collection_of_strings_contains_null(); AssertSql( """ @@ -899,9 +899,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_of_nullable_strings_contains_null(bool async) + public override async Task Column_collection_of_nullable_strings_contains_null() { - await base.Column_collection_of_nullable_strings_contains_null(async); + await base.Column_collection_of_nullable_strings_contains_null(); AssertSql( """ @@ -914,9 +914,9 @@ FROM OPENJSON([p].[NullableStrings]) WITH ([value] nvarchar(max) '$') AS [n] """); } - public override async Task Column_collection_of_bools_Contains(bool async) + public override async Task Column_collection_of_bools_Contains() { - await base.Column_collection_of_bools_Contains(async); + await base.Column_collection_of_bools_Contains(); AssertSql( """ @@ -940,9 +940,9 @@ await context.Database.SqlQuery($"SELECT [Bools] AS [Value] FROM [Primit .SingleAsync()); } - public override async Task Column_collection_Count_method(bool async) + public override async Task Column_collection_Count_method() { - await base.Column_collection_Count_method(async); + await base.Column_collection_Count_method(); AssertSql( """ @@ -954,9 +954,9 @@ FROM OPENJSON([p].[Ints]) AS [i]) = 2 """); } - public override async Task Column_collection_Length(bool async) + public override async Task Column_collection_Length() { - await base.Column_collection_Length(async); + await base.Column_collection_Length(); AssertSql( """ @@ -968,9 +968,9 @@ FROM OPENJSON([p].[Ints]) AS [i]) = 2 """); } - public override async Task Column_collection_Count_with_predicate(bool async) + public override async Task Column_collection_Count_with_predicate() { - await base.Column_collection_Count_with_predicate(async); + await base.Column_collection_Count_with_predicate(); AssertSql( """ @@ -983,9 +983,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_Where_Count(bool async) + public override async Task Column_collection_Where_Count() { - await base.Column_collection_Where_Count(async); + await base.Column_collection_Where_Count(); AssertSql( """ @@ -998,9 +998,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_index_int(bool async) + public override async Task Column_collection_index_int() { - await base.Column_collection_index_int(async); + await base.Column_collection_index_int(); AssertSql( """ @@ -1010,9 +1010,9 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[1]') AS int) = 10 """); } - public override async Task Column_collection_index_string(bool async) + public override async Task Column_collection_index_string() { - await base.Column_collection_index_string(async); + await base.Column_collection_index_string(); AssertSql( """ @@ -1022,9 +1022,9 @@ WHERE JSON_VALUE([p].[Strings], '$[1]') = N'10' """); } - public override async Task Column_collection_index_datetime(bool async) + public override async Task Column_collection_index_datetime() { - await base.Column_collection_index_datetime(async); + await base.Column_collection_index_datetime(); AssertSql( """ @@ -1034,9 +1034,9 @@ WHERE CAST(JSON_VALUE([p].[DateTimes], '$[1]') AS datetime2) = '2020-01-10T12:30 """); } - public override async Task Column_collection_index_beyond_end(bool async) + public override async Task Column_collection_index_beyond_end() { - await base.Column_collection_index_beyond_end(async); + await base.Column_collection_index_beyond_end(); AssertSql( """ @@ -1046,10 +1046,10 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[999]') AS int) = 10 """); } - public override async Task Nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Nullable_reference_column_collection_index_equals_nullable_column() { // TODO: This test is incorrect, see #33784 - await base.Nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1059,9 +1059,9 @@ WHERE JSON_VALUE([p].[NullableStrings], '$[2]') = [p].[NullableString] OR (JSON_ """); } - public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column() { - await base.Non_nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Non_nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1073,9 +1073,9 @@ FROM OPENJSON([p].[Strings]) AS [s]) AND JSON_VALUE([p].[Strings], '$[1]') = [p] """); } - public override async Task Inline_collection_index_Column(bool async) + public override async Task Inline_collection_index_Column() { - await base.Inline_collection_index_Column(async); + await base.Inline_collection_index_Column(); AssertSql( """ @@ -1089,9 +1089,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_value_index_Column(bool async) + public override async Task Inline_collection_value_index_Column() { - await base.Inline_collection_value_index_Column(async); + await base.Inline_collection_value_index_Column(); AssertSql( """ @@ -1105,9 +1105,9 @@ ORDER BY [v].[_ord] """); } - public override async Task Inline_collection_List_value_index_Column(bool async) + public override async Task Inline_collection_List_value_index_Column() { - await base.Inline_collection_List_value_index_Column(async); + await base.Inline_collection_List_value_index_Column(); AssertSql( """ @@ -1122,9 +1122,9 @@ ORDER BY [v].[_ord] } [SqlServerCondition(SqlServerCondition.SupportsJsonPathExpressions)] - public override async Task Parameter_collection_index_Column_equal_Column(bool async) + public override async Task Parameter_collection_index_Column_equal_Column() { - await base.Parameter_collection_index_Column_equal_Column(async); + await base.Parameter_collection_index_Column_equal_Column(); AssertSql( """ @@ -1137,9 +1137,9 @@ WHERE CAST(JSON_VALUE(@ints, '$[' + CAST([p].[Int] AS nvarchar(max)) + ']') AS i } [SqlServerCondition(SqlServerCondition.SupportsJsonPathExpressions)] - public override async Task Parameter_collection_index_Column_equal_constant(bool async) + public override async Task Parameter_collection_index_Column_equal_constant() { - await base.Parameter_collection_index_Column_equal_constant(async); + await base.Parameter_collection_index_Column_equal_constant(); AssertSql( """ @@ -1151,9 +1151,9 @@ WHERE CAST(JSON_VALUE(@ints, '$[' + CAST([p].[Int] AS nvarchar(max)) + ']') AS i """); } - public override async Task Column_collection_ElementAt(bool async) + public override async Task Column_collection_ElementAt() { - await base.Column_collection_ElementAt(async); + await base.Column_collection_ElementAt(); AssertSql( """ @@ -1163,9 +1163,9 @@ WHERE CAST(JSON_VALUE([p].[Ints], '$[1]') AS int) = 10 """); } - public override async Task Column_collection_First(bool async) + public override async Task Column_collection_First() { - await base.Column_collection_First(async); + await base.Column_collection_First(); AssertSql( """ @@ -1178,9 +1178,9 @@ ORDER BY CAST([i].[key] AS int)) = 1 """); } - public override async Task Column_collection_FirstOrDefault(bool async) + public override async Task Column_collection_FirstOrDefault() { - await base.Column_collection_FirstOrDefault(async); + await base.Column_collection_FirstOrDefault(); AssertSql( """ @@ -1193,9 +1193,9 @@ ORDER BY CAST([i].[key] AS int)), 0) = 1 """); } - public override async Task Column_collection_Single(bool async) + public override async Task Column_collection_Single() { - await base.Column_collection_Single(async); + await base.Column_collection_Single(); AssertSql( """ @@ -1208,9 +1208,9 @@ ORDER BY CAST([i].[key] AS int)) = 1 """); } - public override async Task Column_collection_SingleOrDefault(bool async) + public override async Task Column_collection_SingleOrDefault() { - await base.Column_collection_SingleOrDefault(async); + await base.Column_collection_SingleOrDefault(); AssertSql( """ @@ -1223,9 +1223,9 @@ ORDER BY CAST([i].[key] AS int)), 0) = 1 """); } - public override async Task Column_collection_Skip(bool async) + public override async Task Column_collection_Skip() { - await base.Column_collection_Skip(async); + await base.Column_collection_Skip(); AssertSql( """ @@ -1242,9 +1242,9 @@ OFFSET 1 ROWS """); } - public override async Task Column_collection_Take(bool async) + public override async Task Column_collection_Take() { - await base.Column_collection_Take(async); + await base.Column_collection_Take(); AssertSql( """ @@ -1258,9 +1258,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Skip_Take(bool async) + public override async Task Column_collection_Skip_Take() { - await base.Column_collection_Skip_Take(async); + await base.Column_collection_Skip_Take(); AssertSql( """ @@ -1275,9 +1275,9 @@ OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY """); } - public override async Task Column_collection_Where_Skip(bool async) + public override async Task Column_collection_Where_Skip() { - await base.Column_collection_Where_Skip(async); + await base.Column_collection_Where_Skip(); AssertSql( """ @@ -1295,9 +1295,9 @@ OFFSET 1 ROWS """); } - public override async Task Column_collection_Where_Take(bool async) + public override async Task Column_collection_Where_Take() { - await base.Column_collection_Where_Take(async); + await base.Column_collection_Where_Take(); AssertSql( """ @@ -1314,9 +1314,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Where_Skip_Take(bool async) + public override async Task Column_collection_Where_Skip_Take() { - await base.Column_collection_Where_Skip_Take(async); + await base.Column_collection_Where_Skip_Take(); AssertSql( """ @@ -1334,9 +1334,9 @@ OFFSET 1 ROWS FETCH NEXT 2 ROWS ONLY """); } - public override async Task Column_collection_Contains_over_subquery(bool async) + public override async Task Column_collection_Contains_over_subquery() { - await base.Column_collection_Contains_over_subquery(async); + await base.Column_collection_Contains_over_subquery(); AssertSql( """ @@ -1350,9 +1350,9 @@ WHERE [i].[value] > 1 """); } - public override async Task Column_collection_OrderByDescending_ElementAt(bool async) + public override async Task Column_collection_OrderByDescending_ElementAt() { - await base.Column_collection_OrderByDescending_ElementAt(async); + await base.Column_collection_OrderByDescending_ElementAt(); AssertSql( """ @@ -1366,9 +1366,9 @@ ORDER BY [i].[value] DESC """); } - public override async Task Column_collection_Where_ElementAt(bool async) + public override async Task Column_collection_Where_ElementAt() { - await base.Column_collection_Where_ElementAt(async); + await base.Column_collection_Where_ElementAt(); AssertSql( """ @@ -1383,9 +1383,9 @@ ORDER BY CAST([i].[key] AS int) """); } - public override async Task Column_collection_Any(bool async) + public override async Task Column_collection_Any() { - await base.Column_collection_Any(async); + await base.Column_collection_Any(); AssertSql( """ @@ -1397,9 +1397,9 @@ FROM OPENJSON([p].[Ints]) AS [i]) """); } - public override async Task Column_collection_Distinct(bool async) + public override async Task Column_collection_Distinct() { - await base.Column_collection_Distinct(async); + await base.Column_collection_Distinct(); AssertSql( """ @@ -1414,9 +1414,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_SelectMany(bool async) + public override async Task Column_collection_SelectMany() { - await base.Column_collection_SelectMany(async); + await base.Column_collection_SelectMany(); AssertSql( """ @@ -1426,9 +1426,9 @@ CROSS APPLY OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_SelectMany_with_filter(bool async) + public override async Task Column_collection_SelectMany_with_filter() { - await base.Column_collection_SelectMany_with_filter(async); + await base.Column_collection_SelectMany_with_filter(); AssertSql( """ @@ -1442,9 +1442,9 @@ WHERE [i].[value] > 1 """); } - public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) + public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type() { - await base.Column_collection_SelectMany_with_Select_to_anonymous_type(async); + await base.Column_collection_SelectMany_with_Select_to_anonymous_type(); AssertSql( """ @@ -1454,9 +1454,9 @@ CROSS APPLY OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_projection_from_top_level(bool async) + public override async Task Column_collection_projection_from_top_level() { - await base.Column_collection_projection_from_top_level(async); + await base.Column_collection_projection_from_top_level(); AssertSql( """ @@ -1466,9 +1466,9 @@ ORDER BY [p].[Id] """); } - public override async Task Column_collection_Join_parameter_collection(bool async) + public override async Task Column_collection_Join_parameter_collection() { - await base.Column_collection_Join_parameter_collection(async); + await base.Column_collection_Join_parameter_collection(); AssertSql( """ @@ -1484,9 +1484,9 @@ INNER JOIN (VALUES (@ints1), (@ints2)) AS [i0]([Value]) ON [i].[value] = [i0].[V """); } - public override async Task Inline_collection_Join_ordered_column_collection(bool async) + public override async Task Inline_collection_Join_ordered_column_collection() { - await base.Inline_collection_Join_ordered_column_collection(async); + await base.Inline_collection_Join_ordered_column_collection(); AssertSql( """ @@ -1499,9 +1499,9 @@ INNER JOIN OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] ON [v].[Value] = [ """); } - public override async Task Parameter_collection_Concat_column_collection(bool async) + public override async Task Parameter_collection_Concat_column_collection() { - await base.Parameter_collection_Concat_column_collection(async); + await base.Parameter_collection_Concat_column_collection(); AssertSql( """ @@ -1523,9 +1523,9 @@ FROM OPENJSON([p].[Ints]) AS [i0] } [SqlServerCondition(SqlServerCondition.SupportsJsonPathExpressions)] - public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) + public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression() { - await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(async); + await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(); AssertSql( """ @@ -1539,9 +1539,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_Union_parameter_collection(bool async) + public override async Task Column_collection_Union_parameter_collection() { - await base.Column_collection_Union_parameter_collection(async); + await base.Column_collection_Union_parameter_collection(); AssertSql( """ @@ -1562,9 +1562,9 @@ SELECT [i0].[Value] AS [value] """); } - public override async Task Column_collection_Intersect_inline_collection(bool async) + public override async Task Column_collection_Intersect_inline_collection() { - await base.Column_collection_Intersect_inline_collection(async); + await base.Column_collection_Intersect_inline_collection(); AssertSql( """ @@ -1582,9 +1582,9 @@ SELECT [v].[Value] AS [value] """); } - public override async Task Inline_collection_Except_column_collection(bool async) + public override async Task Inline_collection_Except_column_collection() { - await base.Inline_collection_Except_column_collection(async); + await base.Inline_collection_Except_column_collection(); AssertSql( """ @@ -1603,9 +1603,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Column_collection_Where_Union(bool async) + public override async Task Column_collection_Where_Union() { - await base.Column_collection_Where_Union(async); + await base.Column_collection_Where_Union(); AssertSql( """ @@ -1624,9 +1624,9 @@ SELECT [v].[Value] AS [value] """); } - public override async Task Column_collection_equality_parameter_collection(bool async) + public override async Task Column_collection_equality_parameter_collection() { - await base.Column_collection_equality_parameter_collection(async); + await base.Column_collection_equality_parameter_collection(); AssertSql( """ @@ -1638,16 +1638,16 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) + public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection() { - await base.Column_collection_Concat_parameter_collection_equality_inline_collection(async); + await base.Column_collection_Concat_parameter_collection_equality_inline_collection(); AssertSql(); } - public override async Task Column_collection_equality_inline_collection(bool async) + public override async Task Column_collection_equality_inline_collection() { - await base.Column_collection_equality_inline_collection(async); + await base.Column_collection_equality_inline_collection(); AssertSql( """ @@ -1657,23 +1657,23 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Column_collection_equality_inline_collection_with_parameters(bool async) + public override async Task Column_collection_equality_inline_collection_with_parameters() { - await base.Column_collection_equality_inline_collection_with_parameters(async); + await base.Column_collection_equality_inline_collection_with_parameters(); AssertSql(); } - public override async Task Column_collection_Where_equality_inline_collection(bool async) + public override async Task Column_collection_Where_equality_inline_collection() { - await base.Column_collection_Where_equality_inline_collection(async); + await base.Column_collection_Where_equality_inline_collection(); AssertSql(); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(); AssertSql( """ @@ -1699,9 +1699,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i0] """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection() { - await base.Parameter_collection_in_subquery_Union_column_collection(async); + await base.Parameter_collection_in_subquery_Union_column_collection(); AssertSql( """ @@ -1721,9 +1721,9 @@ FROM OPENJSON([p].[Ints]) WITH ([value] int '$') AS [i] """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_nested(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_nested() { - await base.Parameter_collection_in_subquery_Union_column_collection_nested(async); + await base.Parameter_collection_in_subquery_Union_column_collection_nested(); AssertSql( """ @@ -1762,9 +1762,9 @@ public override void Parameter_collection_in_subquery_and_Convert_as_compiled_qu AssertSql(); } - public override async Task Parameter_collection_in_subquery_Count_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Count_as_compiled_query() { - await base.Parameter_collection_in_subquery_Count_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Count_as_compiled_query(); // TODO: the subquery projection contains extra columns which we should remove AssertSql( @@ -1786,16 +1786,16 @@ OFFSET 1 ROWS """); } - public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(); AssertSql(); } - public override async Task Column_collection_in_subquery_Union_parameter_collection(bool async) + public override async Task Column_collection_in_subquery_Union_parameter_collection() { - await base.Column_collection_in_subquery_Union_parameter_collection(async); + await base.Column_collection_in_subquery_Union_parameter_collection(); AssertSql( """ @@ -1821,9 +1821,9 @@ SELECT [i0].[Value] AS [value] """); } - public override async Task Project_collection_of_ints_simple(bool async) + public override async Task Project_collection_of_ints_simple() { - await base.Project_collection_of_ints_simple(async); + await base.Project_collection_of_ints_simple(); AssertSql( """ @@ -1833,9 +1833,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_ints_ordered(bool async) + public override async Task Project_collection_of_ints_ordered() { - await base.Project_collection_of_ints_ordered(async); + await base.Project_collection_of_ints_ordered(); AssertSql( """ @@ -1846,9 +1846,9 @@ OUTER APPLY OPENJSON([p].[Ints]) AS [i] """); } - public override async Task Project_collection_of_datetimes_filtered(bool async) + public override async Task Project_collection_of_datetimes_filtered() { - await base.Project_collection_of_datetimes_filtered(async); + await base.Project_collection_of_datetimes_filtered(); AssertSql( """ @@ -1863,9 +1863,9 @@ WHERE DATEPART(day, CAST([d].[value] AS datetime2)) <> 1 """); } - public override async Task Project_collection_of_nullable_ints_with_paging(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging() { - await base.Project_collection_of_nullable_ints_with_paging(async); + await base.Project_collection_of_nullable_ints_with_paging(); AssertSql( """ @@ -1880,9 +1880,9 @@ ORDER BY CAST([n].[key] AS int) """); } - public override async Task Project_collection_of_nullable_ints_with_paging2(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging2() { - await base.Project_collection_of_nullable_ints_with_paging2(async); + await base.Project_collection_of_nullable_ints_with_paging2(); AssertSql( """ @@ -1898,9 +1898,9 @@ OFFSET 1 ROWS """); } - public override async Task Project_collection_of_nullable_ints_with_paging3(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging3() { - await base.Project_collection_of_nullable_ints_with_paging3(async); + await base.Project_collection_of_nullable_ints_with_paging3(); AssertSql( """ @@ -1916,9 +1916,9 @@ OFFSET 2 ROWS """); } - public override async Task Project_collection_of_ints_with_distinct(bool async) + public override async Task Project_collection_of_ints_with_distinct() { - await base.Project_collection_of_ints_with_distinct(async); + await base.Project_collection_of_ints_with_distinct(); AssertSql( """ @@ -1932,16 +1932,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_collection_of_nullable_ints_with_distinct(bool async) + public override async Task Project_collection_of_nullable_ints_with_distinct() { - await base.Project_collection_of_nullable_ints_with_distinct(async); + await base.Project_collection_of_nullable_ints_with_distinct(); AssertSql(""); } - public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault(bool async) + public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault() { - await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(async); + await base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(); AssertSql( """ @@ -1956,9 +1956,9 @@ OUTER APPLY OPENJSON([p0].[Ints]) AS [i] """); } - public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls(bool async) + public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls() { - await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(async); + await base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(); AssertSql( """ @@ -1978,9 +1978,9 @@ WHERE [n0].[value] IS NULL """); } - public override async Task Project_multiple_collections(bool async) + public override async Task Project_multiple_collections() { - await base.Project_multiple_collections(async); + await base.Project_multiple_collections(); AssertSql( """ @@ -2002,9 +2002,9 @@ WHERE CAST([d0].[value] AS datetime2) > '2000-01-01T00:00:00.0000000' """); } - public override async Task Project_primitive_collections_element(bool async) + public override async Task Project_primitive_collections_element() { - await base.Project_primitive_collections_element(async); + await base.Project_primitive_collections_element(); AssertSql( """ @@ -2015,9 +2015,9 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection(bool async) + public override async Task Project_inline_collection() { - await base.Project_inline_collection(async); + await base.Project_inline_collection(); AssertSql( """ @@ -2026,9 +2026,9 @@ FROM [PrimitiveCollectionsEntity] AS [p] """); } - public override async Task Project_inline_collection_with_Union(bool async) + public override async Task Project_inline_collection_with_Union() { - await base.Project_inline_collection_with_Union(async); + await base.Project_inline_collection_with_Union(); AssertSql( """ @@ -2045,16 +2045,16 @@ ORDER BY [p].[Id] """); } - public override async Task Project_inline_collection_with_Concat(bool async) + public override async Task Project_inline_collection_with_Concat() { - await base.Project_inline_collection_with_Concat(async); + await base.Project_inline_collection_with_Concat(); AssertSql(); } - public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping() { - await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(); AssertSql( """ @@ -2074,9 +2074,9 @@ END IN (@strings1, @strings2, @strings3) """); } - public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping() { - await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(); AssertSql( """ @@ -2096,9 +2096,9 @@ END IN (@strings1, @strings2, @strings3) """); } - public override async Task Parameter_collection_of_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_struct() { - await base.Parameter_collection_of_structs_Contains_struct(async); + await base.Parameter_collection_of_structs_Contains_struct(); AssertSql( """ @@ -2120,9 +2120,9 @@ WHERE [p].[WrappedId] NOT IN (@values1, @values2) """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct(); AssertSql( """ @@ -2144,9 +2144,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -2168,9 +2168,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_struct(); AssertSql( """ @@ -2191,9 +2191,9 @@ WHERE [p].[WrappedId] NOT IN (@values1, @values2) """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(); AssertSql( """ @@ -2214,9 +2214,9 @@ WHERE [p].[NullableWrappedId] NOT IN (@values1, @values2) OR [p].[NullableWrappe """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -2237,9 +2237,9 @@ WHERE [p].[NullableWrappedIdWithNullableComparer] NOT IN (@values1, @values2) OR """); } - public override async Task Values_of_enum_casted_to_underlying_value(bool async) + public override async Task Values_of_enum_casted_to_underlying_value() { - await base.Values_of_enum_casted_to_underlying_value(async); + await base.Values_of_enum_casted_to_underlying_value(); AssertSql( """ diff --git a/test/EFCore.Sqlite.FunctionalTests/Query/PrimitiveCollectionsQuerySqliteTest.cs b/test/EFCore.Sqlite.FunctionalTests/Query/PrimitiveCollectionsQuerySqliteTest.cs index cc161920c78..fb1ae264fae 100644 --- a/test/EFCore.Sqlite.FunctionalTests/Query/PrimitiveCollectionsQuerySqliteTest.cs +++ b/test/EFCore.Sqlite.FunctionalTests/Query/PrimitiveCollectionsQuerySqliteTest.cs @@ -19,9 +19,9 @@ public PrimitiveCollectionsQuerySqliteTest(PrimitiveCollectionsQuerySqlServerFix Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override async Task Inline_collection_of_ints_Contains(bool async) + public override async Task Inline_collection_of_ints_Contains() { - await base.Inline_collection_of_ints_Contains(async); + await base.Inline_collection_of_ints_Contains(); AssertSql( """ @@ -31,9 +31,9 @@ public override async Task Inline_collection_of_ints_Contains(bool async) """); } - public override async Task Inline_collection_of_nullable_ints_Contains(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains() { - await base.Inline_collection_of_nullable_ints_Contains(async); + await base.Inline_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -43,9 +43,9 @@ public override async Task Inline_collection_of_nullable_ints_Contains(bool asyn """); } - public override async Task Inline_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Inline_collection_of_nullable_ints_Contains_null() { - await base.Inline_collection_of_nullable_ints_Contains_null(async); + await base.Inline_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -55,16 +55,16 @@ public override async Task Inline_collection_of_nullable_ints_Contains_null(bool """); } - public override async Task Inline_collection_Count_with_zero_values(bool async) + public override async Task Inline_collection_Count_with_zero_values() { - await base.Inline_collection_Count_with_zero_values(async); + await base.Inline_collection_Count_with_zero_values(); AssertSql(); } - public override async Task Inline_collection_Count_with_one_value(bool async) + public override async Task Inline_collection_Count_with_one_value() { - await base.Inline_collection_Count_with_one_value(async); + await base.Inline_collection_Count_with_one_value(); AssertSql( """ @@ -77,9 +77,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_two_values(bool async) + public override async Task Inline_collection_Count_with_two_values() { - await base.Inline_collection_Count_with_two_values(async); + await base.Inline_collection_Count_with_two_values(); AssertSql( """ @@ -92,9 +92,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Count_with_three_values(bool async) + public override async Task Inline_collection_Count_with_three_values() { - await base.Inline_collection_Count_with_three_values(async); + await base.Inline_collection_Count_with_three_values(); AssertSql( """ @@ -107,9 +107,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_zero_values(bool async) + public override async Task Inline_collection_Contains_with_zero_values() { - await base.Inline_collection_Contains_with_zero_values(async); + await base.Inline_collection_Contains_with_zero_values(); AssertSql( """ @@ -119,9 +119,9 @@ WHERE 0 """); } - public override async Task Inline_collection_Contains_with_one_value(bool async) + public override async Task Inline_collection_Contains_with_one_value() { - await base.Inline_collection_Contains_with_one_value(async); + await base.Inline_collection_Contains_with_one_value(); AssertSql( """ @@ -131,9 +131,9 @@ public override async Task Inline_collection_Contains_with_one_value(bool async) """); } - public override async Task Inline_collection_Contains_with_two_values(bool async) + public override async Task Inline_collection_Contains_with_two_values() { - await base.Inline_collection_Contains_with_two_values(async); + await base.Inline_collection_Contains_with_two_values(); AssertSql( """ @@ -143,9 +143,9 @@ public override async Task Inline_collection_Contains_with_two_values(bool async """); } - public override async Task Inline_collection_Contains_with_three_values(bool async) + public override async Task Inline_collection_Contains_with_three_values() { - await base.Inline_collection_Contains_with_three_values(async); + await base.Inline_collection_Contains_with_three_values(); AssertSql( """ @@ -155,9 +155,9 @@ public override async Task Inline_collection_Contains_with_three_values(bool asy """); } - public override async Task Inline_collection_Contains_with_all_parameters(bool async) + public override async Task Inline_collection_Contains_with_all_parameters() { - await base.Inline_collection_Contains_with_all_parameters(async); + await base.Inline_collection_Contains_with_all_parameters(); AssertSql( """ @@ -170,9 +170,9 @@ public override async Task Inline_collection_Contains_with_all_parameters(bool a """); } - public override async Task Inline_collection_Contains_with_constant_and_parameter(bool async) + public override async Task Inline_collection_Contains_with_constant_and_parameter() { - await base.Inline_collection_Contains_with_constant_and_parameter(async); + await base.Inline_collection_Contains_with_constant_and_parameter(); AssertSql( """ @@ -184,9 +184,9 @@ public override async Task Inline_collection_Contains_with_constant_and_paramete """); } - public override async Task Inline_collection_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_Contains_with_mixed_value_types() { - await base.Inline_collection_Contains_with_mixed_value_types(async); + await base.Inline_collection_Contains_with_mixed_value_types(); AssertSql( """ @@ -198,9 +198,9 @@ public override async Task Inline_collection_Contains_with_mixed_value_types(boo """); } - public override async Task Inline_collection_List_Contains_with_mixed_value_types(bool async) + public override async Task Inline_collection_List_Contains_with_mixed_value_types() { - await base.Inline_collection_List_Contains_with_mixed_value_types(async); + await base.Inline_collection_List_Contains_with_mixed_value_types(); AssertSql( """ @@ -212,9 +212,9 @@ public override async Task Inline_collection_List_Contains_with_mixed_value_type """); } - public override async Task Inline_collection_Contains_as_Any_with_predicate(bool async) + public override async Task Inline_collection_Contains_as_Any_with_predicate() { - await base.Inline_collection_Contains_as_Any_with_predicate(async); + await base.Inline_collection_Contains_as_Any_with_predicate(); AssertSql( """ @@ -224,9 +224,9 @@ public override async Task Inline_collection_Contains_as_Any_with_predicate(bool """); } - public override async Task Inline_collection_negated_Contains_as_All(bool async) + public override async Task Inline_collection_negated_Contains_as_All() { - await base.Inline_collection_negated_Contains_as_All(async); + await base.Inline_collection_negated_Contains_as_All(); AssertSql( """ @@ -236,9 +236,9 @@ public override async Task Inline_collection_negated_Contains_as_All(bool async) """); } - public override async Task Inline_collection_Min_with_two_values(bool async) + public override async Task Inline_collection_Min_with_two_values() { - await base.Inline_collection_Min_with_two_values(async); + await base.Inline_collection_Min_with_two_values(); AssertSql( """ @@ -248,9 +248,9 @@ WHERE min(30, "p"."Int") = 30 """); } - public override async Task Inline_collection_List_Min_with_two_values(bool async) + public override async Task Inline_collection_List_Min_with_two_values() { - await base.Inline_collection_List_Min_with_two_values(async); + await base.Inline_collection_List_Min_with_two_values(); AssertSql( """ @@ -260,9 +260,9 @@ WHERE min(30, "p"."Int") = 30 """); } - public override async Task Inline_collection_Max_with_two_values(bool async) + public override async Task Inline_collection_Max_with_two_values() { - await base.Inline_collection_Max_with_two_values(async); + await base.Inline_collection_Max_with_two_values(); AssertSql( """ @@ -272,9 +272,9 @@ WHERE max(30, "p"."Int") = 30 """); } - public override async Task Inline_collection_List_Max_with_two_values(bool async) + public override async Task Inline_collection_List_Max_with_two_values() { - await base.Inline_collection_List_Max_with_two_values(async); + await base.Inline_collection_List_Max_with_two_values(); AssertSql( """ @@ -284,9 +284,9 @@ WHERE max(30, "p"."Int") = 30 """); } - public override async Task Inline_collection_Min_with_three_values(bool async) + public override async Task Inline_collection_Min_with_three_values() { - await base.Inline_collection_Min_with_three_values(async); + await base.Inline_collection_Min_with_three_values(); AssertSql( """ @@ -298,9 +298,9 @@ WHERE min(30, "p"."Int", @i) = 25 """); } - public override async Task Inline_collection_List_Min_with_three_values(bool async) + public override async Task Inline_collection_List_Min_with_three_values() { - await base.Inline_collection_List_Min_with_three_values(async); + await base.Inline_collection_List_Min_with_three_values(); AssertSql( """ @@ -312,9 +312,9 @@ WHERE min(30, "p"."Int", @i) = 25 """); } - public override async Task Inline_collection_Max_with_three_values(bool async) + public override async Task Inline_collection_Max_with_three_values() { - await base.Inline_collection_Max_with_three_values(async); + await base.Inline_collection_Max_with_three_values(); AssertSql( """ @@ -326,9 +326,9 @@ WHERE max(30, "p"."Int", @i) = 35 """); } - public override async Task Inline_collection_List_Max_with_three_values(bool async) + public override async Task Inline_collection_List_Max_with_three_values() { - await base.Inline_collection_List_Max_with_three_values(async); + await base.Inline_collection_List_Max_with_three_values(); AssertSql( """ @@ -340,9 +340,9 @@ WHERE max(30, "p"."Int", @i) = 35 """); } - public override async Task Inline_collection_of_nullable_value_type_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_Min() { - await base.Inline_collection_of_nullable_value_type_Min(async); + await base.Inline_collection_of_nullable_value_type_Min(); AssertSql( """ @@ -356,9 +356,9 @@ SELECT MIN("v"."Value") """); } - public override async Task Inline_collection_of_nullable_value_type_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_Max() { - await base.Inline_collection_of_nullable_value_type_Max(async); + await base.Inline_collection_of_nullable_value_type_Max(); AssertSql( """ @@ -372,9 +372,9 @@ SELECT MAX("v"."Value") """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Min() { - await base.Inline_collection_of_nullable_value_type_with_null_Min(async); + await base.Inline_collection_of_nullable_value_type_with_null_Min(); AssertSql( """ @@ -386,9 +386,9 @@ SELECT MIN("v"."Value") """); } - public override async Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) + public override async Task Inline_collection_of_nullable_value_type_with_null_Max() { - await base.Inline_collection_of_nullable_value_type_with_null_Max(async); + await base.Inline_collection_of_nullable_value_type_with_null_Max(); AssertSql( """ @@ -400,9 +400,9 @@ SELECT MAX("v"."Value") """); } - public override async Task Inline_collection_with_single_parameter_element_Contains(bool async) + public override async Task Inline_collection_with_single_parameter_element_Contains() { - await base.Inline_collection_with_single_parameter_element_Contains(async); + await base.Inline_collection_with_single_parameter_element_Contains(); AssertSql( """ @@ -414,9 +414,9 @@ public override async Task Inline_collection_with_single_parameter_element_Conta """); } - public override async Task Inline_collection_with_single_parameter_element_Count(bool async) + public override async Task Inline_collection_with_single_parameter_element_Count() { - await base.Inline_collection_with_single_parameter_element_Count(async); + await base.Inline_collection_with_single_parameter_element_Count(); AssertSql( """ @@ -431,9 +431,9 @@ SELECT COUNT(*) """); } - public override async Task Inline_collection_Contains_with_EF_Parameter(bool async) + public override async Task Inline_collection_Contains_with_EF_Parameter() { - await base.Inline_collection_Contains_with_EF_Parameter(async); + await base.Inline_collection_Contains_with_EF_Parameter(); AssertSql( """ @@ -448,9 +448,9 @@ FROM json_each(@p) AS "p0" """); } - public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter(bool async) + public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter() { - await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(async); + await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(); AssertSql( """ @@ -465,9 +465,9 @@ FROM json_each(@p) AS "p0" """); } - public override async Task Parameter_collection_Count(bool async) + public override async Task Parameter_collection_Count() { - await base.Parameter_collection_Count(async); + await base.Parameter_collection_Count(); AssertSql( """ @@ -483,9 +483,9 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_int() { - await base.Parameter_collection_of_ints_Contains_int(async); + await base.Parameter_collection_of_ints_Contains_int(); AssertSql( """ @@ -507,9 +507,9 @@ public override async Task Parameter_collection_of_ints_Contains_int(bool async) """); } - public override async Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_HashSet_of_ints_Contains_int() { - await base.Parameter_collection_HashSet_of_ints_Contains_int(async); + await base.Parameter_collection_HashSet_of_ints_Contains_int(); AssertSql( """ @@ -531,9 +531,9 @@ public override async Task Parameter_collection_HashSet_of_ints_Contains_int(boo """); } - public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int(bool async) + public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_int() { - await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(async); + await base.Parameter_collection_ImmutableArray_of_ints_Contains_int(); AssertSql( """ @@ -555,9 +555,9 @@ public override async Task Parameter_collection_ImmutableArray_of_ints_Contains_ """); } - public override async Task Parameter_collection_of_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_ints_Contains_nullable_int() { - await base.Parameter_collection_of_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_ints_Contains_nullable_int(); AssertSql( """ @@ -579,9 +579,9 @@ public override async Task Parameter_collection_of_ints_Contains_nullable_int(bo """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_int() { - await base.Parameter_collection_of_nullable_ints_Contains_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_int(); AssertSql( """ @@ -603,9 +603,9 @@ public override async Task Parameter_collection_of_nullable_ints_Contains_int(bo """); } - public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int(bool async) + public override async Task Parameter_collection_of_nullable_ints_Contains_nullable_int() { - await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(async); + await base.Parameter_collection_of_nullable_ints_Contains_nullable_int(); AssertSql( """ @@ -625,9 +625,9 @@ public override async Task Parameter_collection_of_nullable_ints_Contains_nullab """); } - public override async Task Parameter_collection_of_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_string() { - await base.Parameter_collection_of_strings_Contains_string(async); + await base.Parameter_collection_of_strings_Contains_string(); AssertSql( """ @@ -649,9 +649,9 @@ public override async Task Parameter_collection_of_strings_Contains_string(bool """); } - public override async Task Parameter_collection_of_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_strings_Contains_nullable_string() { - await base.Parameter_collection_of_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_strings_Contains_nullable_string(); AssertSql( """ @@ -673,9 +673,9 @@ public override async Task Parameter_collection_of_strings_Contains_nullable_str """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_string() { - await base.Parameter_collection_of_nullable_strings_Contains_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_string(); AssertSql( """ @@ -695,9 +695,9 @@ public override async Task Parameter_collection_of_nullable_strings_Contains_str """); } - public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string(bool async) + public override async Task Parameter_collection_of_nullable_strings_Contains_nullable_string() { - await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(async); + await base.Parameter_collection_of_nullable_strings_Contains_nullable_string(); AssertSql( """ @@ -717,9 +717,9 @@ public override async Task Parameter_collection_of_nullable_strings_Contains_nul """); } - public override async Task Parameter_collection_of_DateTimes_Contains(bool async) + public override async Task Parameter_collection_of_DateTimes_Contains() { - await base.Parameter_collection_of_DateTimes_Contains(async); + await base.Parameter_collection_of_DateTimes_Contains(); AssertSql( """ @@ -732,9 +732,9 @@ public override async Task Parameter_collection_of_DateTimes_Contains(bool async """); } - public override async Task Parameter_collection_of_bools_Contains(bool async) + public override async Task Parameter_collection_of_bools_Contains() { - await base.Parameter_collection_of_bools_Contains(async); + await base.Parameter_collection_of_bools_Contains(); AssertSql( """ @@ -746,9 +746,9 @@ public override async Task Parameter_collection_of_bools_Contains(bool async) """); } - public override async Task Parameter_collection_of_enums_Contains(bool async) + public override async Task Parameter_collection_of_enums_Contains() { - await base.Parameter_collection_of_enums_Contains(async); + await base.Parameter_collection_of_enums_Contains(); AssertSql( """ @@ -761,9 +761,9 @@ public override async Task Parameter_collection_of_enums_Contains(bool async) """); } - public override async Task Parameter_collection_null_Contains(bool async) + public override async Task Parameter_collection_null_Contains() { - await base.Parameter_collection_null_Contains(async); + await base.Parameter_collection_null_Contains(); AssertSql( """ @@ -773,9 +773,9 @@ WHERE 0 """); } - public override async Task Parameter_collection_Contains_with_EF_Constant(bool async) + public override async Task Parameter_collection_Contains_with_EF_Constant() { - await base.Parameter_collection_Contains_with_EF_Constant(async); + await base.Parameter_collection_Contains_with_EF_Constant(); AssertSql( """ @@ -785,9 +785,9 @@ public override async Task Parameter_collection_Contains_with_EF_Constant(bool a """); } - public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any() { - await base.Parameter_collection_Where_with_EF_Constant_Where_Any(async); + await base.Parameter_collection_Where_with_EF_Constant_Where_Any(); AssertSql( """ @@ -800,9 +800,9 @@ SELECT 1 """); } - public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant() { - await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(async); + await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(); AssertSql( """ @@ -816,16 +816,16 @@ SELECT COUNT(*) } // nothing to test here - public override Task Parameter_collection_Count_with_huge_number_of_values(bool async) - => base.Parameter_collection_Count_with_huge_number_of_values(async); + public override Task Parameter_collection_Count_with_huge_number_of_values() + => base.Parameter_collection_Count_with_huge_number_of_values(); // nothing to test here - public override Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(bool async) - => base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(async); + public override Task Parameter_collection_of_ints_Contains_int_with_huge_number_of_values() + => base.Parameter_collection_of_ints_Contains_int_with_huge_number_of_values(); - public override async Task Column_collection_of_ints_Contains(bool async) + public override async Task Column_collection_of_ints_Contains() { - await base.Column_collection_of_ints_Contains(async); + await base.Column_collection_of_ints_Contains(); AssertSql( """ @@ -838,9 +838,9 @@ FROM json_each("p"."Ints") AS "i" """); } - public override async Task Column_collection_of_nullable_ints_Contains(bool async) + public override async Task Column_collection_of_nullable_ints_Contains() { - await base.Column_collection_of_nullable_ints_Contains(async); + await base.Column_collection_of_nullable_ints_Contains(); AssertSql( """ @@ -853,9 +853,9 @@ FROM json_each("p"."NullableInts") AS "n" """); } - public override async Task Column_collection_of_nullable_ints_Contains_null(bool async) + public override async Task Column_collection_of_nullable_ints_Contains_null() { - await base.Column_collection_of_nullable_ints_Contains_null(async); + await base.Column_collection_of_nullable_ints_Contains_null(); AssertSql( """ @@ -868,9 +868,9 @@ FROM json_each("p"."NullableInts") AS "n" """); } - public override async Task Column_collection_of_strings_contains_null(bool async) + public override async Task Column_collection_of_strings_contains_null() { - await base.Column_collection_of_strings_contains_null(async); + await base.Column_collection_of_strings_contains_null(); AssertSql( """ @@ -880,9 +880,9 @@ WHERE 0 """); } - public override async Task Column_collection_of_nullable_strings_contains_null(bool async) + public override async Task Column_collection_of_nullable_strings_contains_null() { - await base.Column_collection_of_nullable_strings_contains_null(async); + await base.Column_collection_of_nullable_strings_contains_null(); AssertSql( """ @@ -895,9 +895,9 @@ FROM json_each("p"."NullableStrings") AS "n" """); } - public override async Task Column_collection_of_bools_Contains(bool async) + public override async Task Column_collection_of_bools_Contains() { - await base.Column_collection_of_bools_Contains(async); + await base.Column_collection_of_bools_Contains(); AssertSql( """ @@ -910,9 +910,9 @@ FROM json_each("p"."Bools") AS "b" """); } - public override async Task Column_collection_Count_method(bool async) + public override async Task Column_collection_Count_method() { - await base.Column_collection_Count_method(async); + await base.Column_collection_Count_method(); AssertSql( """ @@ -922,9 +922,9 @@ WHERE json_array_length("p"."Ints") = 2 """); } - public override async Task Column_collection_Length(bool async) + public override async Task Column_collection_Length() { - await base.Column_collection_Length(async); + await base.Column_collection_Length(); AssertSql( """ @@ -934,9 +934,9 @@ WHERE json_array_length("p"."Ints") = 2 """); } - public override async Task Column_collection_Count_with_predicate(bool async) + public override async Task Column_collection_Count_with_predicate() { - await base.Column_collection_Count_with_predicate(async); + await base.Column_collection_Count_with_predicate(); AssertSql( """ @@ -950,9 +950,9 @@ FROM json_each("p"."Ints") AS "i" } // #33932 - public override async Task Column_collection_Where_Count(bool async) + public override async Task Column_collection_Where_Count() { - await base.Column_collection_Where_Count(async); + await base.Column_collection_Where_Count(); AssertSql( """ @@ -965,9 +965,9 @@ FROM json_each("p"."Ints") AS "i" """); } - public override async Task Column_collection_index_int(bool async) + public override async Task Column_collection_index_int() { - await base.Column_collection_index_int(async); + await base.Column_collection_index_int(); AssertSql( """ @@ -977,9 +977,9 @@ public override async Task Column_collection_index_int(bool async) """); } - public override async Task Column_collection_index_string(bool async) + public override async Task Column_collection_index_string() { - await base.Column_collection_index_string(async); + await base.Column_collection_index_string(); AssertSql( """ @@ -989,9 +989,9 @@ public override async Task Column_collection_index_string(bool async) """); } - public override async Task Column_collection_index_datetime(bool async) + public override async Task Column_collection_index_datetime() { - await base.Column_collection_index_datetime(async); + await base.Column_collection_index_datetime(); AssertSql( """ @@ -1001,9 +1001,9 @@ public override async Task Column_collection_index_datetime(bool async) """); } - public override async Task Column_collection_index_beyond_end(bool async) + public override async Task Column_collection_index_beyond_end() { - await base.Column_collection_index_beyond_end(async); + await base.Column_collection_index_beyond_end(); AssertSql( """ @@ -1013,9 +1013,9 @@ public override async Task Column_collection_index_beyond_end(bool async) """); } - public override async Task Nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Nullable_reference_column_collection_index_equals_nullable_column() { - await base.Nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1025,9 +1025,9 @@ public override async Task Nullable_reference_column_collection_index_equals_nul """); } - public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column(bool async) + public override async Task Non_nullable_reference_column_collection_index_equals_nullable_column() { - await base.Non_nullable_reference_column_collection_index_equals_nullable_column(async); + await base.Non_nullable_reference_column_collection_index_equals_nullable_column(); AssertSql( """ @@ -1037,10 +1037,10 @@ WHERE json_array_length("p"."Strings") > 0 AND "p"."Strings" ->> 1 = "p"."Nullab """); } - public override async Task Inline_collection_index_Column(bool async) + public override async Task Inline_collection_index_Column() { // SQLite doesn't support correlated subqueries where the outer column is used as the LIMIT/OFFSET (see OFFSET "p"."Int" below) - await Assert.ThrowsAsync(() => base.Inline_collection_index_Column(async)); + await Assert.ThrowsAsync(() => base.Inline_collection_index_Column()); AssertSql( """ @@ -1054,10 +1054,10 @@ ORDER BY "v"."_ord" """); } - public override async Task Inline_collection_value_index_Column(bool async) + public override async Task Inline_collection_value_index_Column() { // SQLite doesn't support correlated subqueries where the outer column is used as the LIMIT/OFFSET (see OFFSET "p"."Int" below) - await Assert.ThrowsAsync(() => base.Inline_collection_value_index_Column(async)); + await Assert.ThrowsAsync(() => base.Inline_collection_value_index_Column()); AssertSql( """ @@ -1071,10 +1071,10 @@ ORDER BY "v"."_ord" """); } - public override async Task Inline_collection_List_value_index_Column(bool async) + public override async Task Inline_collection_List_value_index_Column() { // SQLite doesn't support correlated subqueries where the outer column is used as the LIMIT/OFFSET (see OFFSET "p"."Int" below) - await Assert.ThrowsAsync(() => base.Inline_collection_List_value_index_Column(async)); + await Assert.ThrowsAsync(() => base.Inline_collection_List_value_index_Column()); AssertSql( """ @@ -1088,9 +1088,9 @@ ORDER BY "v"."_ord" """); } - public override async Task Parameter_collection_index_Column_equal_Column(bool async) + public override async Task Parameter_collection_index_Column_equal_Column() { - await base.Parameter_collection_index_Column_equal_Column(async); + await base.Parameter_collection_index_Column_equal_Column(); AssertSql( """ @@ -1102,9 +1102,9 @@ public override async Task Parameter_collection_index_Column_equal_Column(bool a """); } - public override async Task Parameter_collection_index_Column_equal_constant(bool async) + public override async Task Parameter_collection_index_Column_equal_constant() { - await base.Parameter_collection_index_Column_equal_constant(async); + await base.Parameter_collection_index_Column_equal_constant(); AssertSql( """ @@ -1116,9 +1116,9 @@ public override async Task Parameter_collection_index_Column_equal_constant(bool """); } - public override async Task Column_collection_ElementAt(bool async) + public override async Task Column_collection_ElementAt() { - await base.Column_collection_ElementAt(async); + await base.Column_collection_ElementAt(); AssertSql( """ @@ -1128,9 +1128,9 @@ public override async Task Column_collection_ElementAt(bool async) """); } - public override async Task Column_collection_First(bool async) + public override async Task Column_collection_First() { - await base.Column_collection_First(async); + await base.Column_collection_First(); AssertSql( """ @@ -1144,9 +1144,9 @@ ORDER BY "i"."key" """); } - public override async Task Column_collection_FirstOrDefault(bool async) + public override async Task Column_collection_FirstOrDefault() { - await base.Column_collection_FirstOrDefault(async); + await base.Column_collection_FirstOrDefault(); AssertSql( """ @@ -1160,9 +1160,9 @@ ORDER BY "i"."key" """); } - public override async Task Column_collection_Single(bool async) + public override async Task Column_collection_Single() { - await base.Column_collection_Single(async); + await base.Column_collection_Single(); AssertSql( """ @@ -1176,9 +1176,9 @@ ORDER BY "i"."key" """); } - public override async Task Column_collection_SingleOrDefault(bool async) + public override async Task Column_collection_SingleOrDefault() { - await base.Column_collection_SingleOrDefault(async); + await base.Column_collection_SingleOrDefault(); AssertSql( """ @@ -1192,9 +1192,9 @@ ORDER BY "i"."key" """); } - public override async Task Column_collection_Skip(bool async) + public override async Task Column_collection_Skip() { - await base.Column_collection_Skip(async); + await base.Column_collection_Skip(); AssertSql( """ @@ -1211,9 +1211,9 @@ ORDER BY "i"."key" """); } - public override async Task Column_collection_Take(bool async) + public override async Task Column_collection_Take() { - await base.Column_collection_Take(async); + await base.Column_collection_Take(); AssertSql( """ @@ -1228,9 +1228,9 @@ LIMIT 2 """); } - public override async Task Column_collection_Skip_Take(bool async) + public override async Task Column_collection_Skip_Take() { - await base.Column_collection_Skip_Take(async); + await base.Column_collection_Skip_Take(); AssertSql( """ @@ -1245,9 +1245,9 @@ LIMIT 2 OFFSET 1 """); } - public override async Task Column_collection_Where_Skip(bool async) + public override async Task Column_collection_Where_Skip() { - await base.Column_collection_Where_Skip(async); + await base.Column_collection_Where_Skip(); AssertSql( """ @@ -1265,9 +1265,9 @@ ORDER BY "i"."key" """); } - public override async Task Column_collection_Where_Take(bool async) + public override async Task Column_collection_Where_Take() { - await base.Column_collection_Where_Take(async); + await base.Column_collection_Where_Take(); AssertSql( """ @@ -1285,9 +1285,9 @@ LIMIT 2 """); } - public override async Task Column_collection_Where_Skip_Take(bool async) + public override async Task Column_collection_Where_Skip_Take() { - await base.Column_collection_Where_Skip_Take(async); + await base.Column_collection_Where_Skip_Take(); AssertSql( """ @@ -1305,9 +1305,9 @@ LIMIT 2 OFFSET 1 """); } - public override async Task Column_collection_Contains_over_subquery(bool async) + public override async Task Column_collection_Contains_over_subquery() { - await base.Column_collection_Contains_over_subquery(async); + await base.Column_collection_Contains_over_subquery(); AssertSql( """ @@ -1321,9 +1321,9 @@ FROM json_each("p"."Ints") AS "i" """); } - public override async Task Column_collection_OrderByDescending_ElementAt(bool async) + public override async Task Column_collection_OrderByDescending_ElementAt() { - await base.Column_collection_OrderByDescending_ElementAt(async); + await base.Column_collection_OrderByDescending_ElementAt(); AssertSql( """ @@ -1337,9 +1337,9 @@ ORDER BY "i"."value" DESC """); } - public override async Task Column_collection_Where_ElementAt(bool async) + public override async Task Column_collection_Where_ElementAt() { - await base.Column_collection_Where_ElementAt(async); + await base.Column_collection_Where_ElementAt(); AssertSql( """ @@ -1354,9 +1354,9 @@ ORDER BY "i"."key" """); } - public override async Task Column_collection_Any(bool async) + public override async Task Column_collection_Any() { - await base.Column_collection_Any(async); + await base.Column_collection_Any(); AssertSql( """ @@ -1366,9 +1366,9 @@ WHERE json_array_length("p"."Ints") > 0 """); } - public override async Task Column_collection_Distinct(bool async) + public override async Task Column_collection_Distinct() { - await base.Column_collection_Distinct(async); + await base.Column_collection_Distinct(); AssertSql( """ @@ -1383,27 +1383,27 @@ FROM json_each("p"."Ints") AS "i" """); } - public override async Task Column_collection_SelectMany(bool async) + public override async Task Column_collection_SelectMany() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Column_collection_SelectMany(async))).Message); + () => base.Column_collection_SelectMany())).Message); - public override async Task Column_collection_SelectMany_with_filter(bool async) + public override async Task Column_collection_SelectMany_with_filter() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Column_collection_SelectMany_with_filter(async))).Message); + () => base.Column_collection_SelectMany_with_filter())).Message); - public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) + public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Column_collection_SelectMany_with_Select_to_anonymous_type(async))).Message); + () => base.Column_collection_SelectMany_with_Select_to_anonymous_type())).Message); - public override async Task Column_collection_projection_from_top_level(bool async) + public override async Task Column_collection_projection_from_top_level() { - await base.Column_collection_projection_from_top_level(async); + await base.Column_collection_projection_from_top_level(); AssertSql( """ @@ -1413,9 +1413,9 @@ ORDER BY "p"."Id" """); } - public override async Task Column_collection_Join_parameter_collection(bool async) + public override async Task Column_collection_Join_parameter_collection() { - await base.Column_collection_Join_parameter_collection(async); + await base.Column_collection_Join_parameter_collection(); AssertSql( """ @@ -1431,9 +1431,9 @@ INNER JOIN (SELECT @ints1 AS "Value" UNION ALL VALUES (@ints2)) AS "i0" ON "i"." """); } - public override async Task Inline_collection_Join_ordered_column_collection(bool async) + public override async Task Inline_collection_Join_ordered_column_collection() { - await base.Inline_collection_Join_ordered_column_collection(async); + await base.Inline_collection_Join_ordered_column_collection(); AssertSql( """ @@ -1446,12 +1446,12 @@ INNER JOIN json_each("p"."Ints") AS "i" ON "v"."Value" = "i"."value") = 2 """); } - [ConditionalTheory] - public override async Task Parameter_collection_Concat_column_collection(bool async) + [ConditionalFact] + public override async Task Parameter_collection_Concat_column_collection() { // Issue #32561 await Assert.ThrowsAsync( - () => base.Parameter_collection_Concat_column_collection(async)); + () => base.Parameter_collection_Concat_column_collection()); AssertSql( """ @@ -1474,9 +1474,9 @@ FROM json_each("p"."Ints") AS "i0" """); } - public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) + public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression() { - await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(async); + await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(); AssertSql( """ @@ -1490,9 +1490,9 @@ SELECT CASE """); } - public override async Task Column_collection_Union_parameter_collection(bool async) + public override async Task Column_collection_Union_parameter_collection() { - await base.Column_collection_Union_parameter_collection(async); + await base.Column_collection_Union_parameter_collection(); AssertSql( """ @@ -1514,9 +1514,9 @@ FROM json_each("p"."Ints") AS "i" """); } - public override async Task Column_collection_Intersect_inline_collection(bool async) + public override async Task Column_collection_Intersect_inline_collection() { - await base.Column_collection_Intersect_inline_collection(async); + await base.Column_collection_Intersect_inline_collection(); AssertSql( """ @@ -1535,9 +1535,9 @@ SELECT CAST(11 AS INTEGER) AS "Value" UNION ALL VALUES (111) """); } - public override async Task Inline_collection_Except_column_collection(bool async) + public override async Task Inline_collection_Except_column_collection() { - await base.Inline_collection_Except_column_collection(async); + await base.Inline_collection_Except_column_collection(); AssertSql( """ @@ -1557,9 +1557,9 @@ FROM json_each("p"."Ints") AS "i" """); } - public override async Task Column_collection_Where_Union(bool async) + public override async Task Column_collection_Where_Union() { - await base.Column_collection_Where_Union(async); + await base.Column_collection_Where_Union(); AssertSql( """ @@ -1577,9 +1577,9 @@ SELECT CAST(50 AS INTEGER) AS "Value" """); } - public override async Task Column_collection_equality_parameter_collection(bool async) + public override async Task Column_collection_equality_parameter_collection() { - await base.Column_collection_equality_parameter_collection(async); + await base.Column_collection_equality_parameter_collection(); AssertSql( """ @@ -1591,16 +1591,16 @@ public override async Task Column_collection_equality_parameter_collection(bool """); } - public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection(bool async) + public override async Task Column_collection_Concat_parameter_collection_equality_inline_collection() { - await base.Column_collection_Concat_parameter_collection_equality_inline_collection(async); + await base.Column_collection_Concat_parameter_collection_equality_inline_collection(); AssertSql(); } - public override async Task Column_collection_equality_inline_collection(bool async) + public override async Task Column_collection_equality_inline_collection() { - await base.Column_collection_equality_inline_collection(async); + await base.Column_collection_equality_inline_collection(); AssertSql( """ @@ -1610,23 +1610,23 @@ public override async Task Column_collection_equality_inline_collection(bool asy """); } - public override async Task Column_collection_equality_inline_collection_with_parameters(bool async) + public override async Task Column_collection_equality_inline_collection_with_parameters() { - await base.Column_collection_equality_inline_collection_with_parameters(async); + await base.Column_collection_equality_inline_collection_with_parameters(); AssertSql(); } - public override async Task Column_collection_Where_equality_inline_collection(bool async) + public override async Task Column_collection_Where_equality_inline_collection() { - await base.Column_collection_Where_equality_inline_collection(async); + await base.Column_collection_Where_equality_inline_collection(); AssertSql(); } - public override async Task Parameter_collection_in_subquery_Count_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Count_as_compiled_query() { - await base.Parameter_collection_in_subquery_Count_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Count_as_compiled_query(); AssertSql( """ @@ -1647,16 +1647,16 @@ ORDER BY "i"."_ord" """); } - public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_another_parameter_collection_as_compiled_query(); AssertSql(); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_as_compiled_query() { - await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(async); + await base.Parameter_collection_in_subquery_Union_column_collection_as_compiled_query(); AssertSql( """ @@ -1682,9 +1682,9 @@ FROM json_each("p"."Ints") AS "i0" """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection() { - await base.Parameter_collection_in_subquery_Union_column_collection(async); + await base.Parameter_collection_in_subquery_Union_column_collection(); AssertSql( """ @@ -1703,9 +1703,9 @@ FROM json_each("p"."Ints") AS "i" """); } - public override async Task Parameter_collection_in_subquery_Union_column_collection_nested(bool async) + public override async Task Parameter_collection_in_subquery_Union_column_collection_nested() { - await base.Parameter_collection_in_subquery_Union_column_collection_nested(async); + await base.Parameter_collection_in_subquery_Union_column_collection_nested(); AssertSql( """ @@ -1744,9 +1744,9 @@ public override void Parameter_collection_in_subquery_and_Convert_as_compiled_qu AssertSql(); } - public override async Task Column_collection_in_subquery_Union_parameter_collection(bool async) + public override async Task Column_collection_in_subquery_Union_parameter_collection() { - await base.Column_collection_in_subquery_Union_parameter_collection(async); + await base.Column_collection_in_subquery_Union_parameter_collection(); AssertSql( """ @@ -1773,9 +1773,9 @@ ORDER BY "i"."key" """); } - public override async Task Project_collection_of_ints_simple(bool async) + public override async Task Project_collection_of_ints_simple() { - await base.Project_collection_of_ints_simple(async); + await base.Project_collection_of_ints_simple(); AssertSql( """ @@ -1785,63 +1785,63 @@ ORDER BY "p"."Id" """); } - public override async Task Project_collection_of_ints_ordered(bool async) + public override async Task Project_collection_of_ints_ordered() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_ints_ordered(async))).Message); + () => base.Project_collection_of_ints_ordered())).Message); - public override async Task Project_collection_of_datetimes_filtered(bool async) + public override async Task Project_collection_of_datetimes_filtered() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_datetimes_filtered(async))).Message); + () => base.Project_collection_of_datetimes_filtered())).Message); - public override async Task Project_collection_of_nullable_ints_with_paging(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_nullable_ints_with_paging(async))).Message); + () => base.Project_collection_of_nullable_ints_with_paging())).Message); - public override async Task Project_collection_of_nullable_ints_with_paging2(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging2() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_nullable_ints_with_paging2(async))).Message); + () => base.Project_collection_of_nullable_ints_with_paging2())).Message); - public override async Task Project_collection_of_nullable_ints_with_paging3(bool async) + public override async Task Project_collection_of_nullable_ints_with_paging3() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_nullable_ints_with_paging3(async))).Message); + () => base.Project_collection_of_nullable_ints_with_paging3())).Message); - public override async Task Project_collection_of_ints_with_distinct(bool async) + public override async Task Project_collection_of_ints_with_distinct() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_ints_with_distinct(async))).Message); + () => base.Project_collection_of_ints_with_distinct())).Message); - public override async Task Project_collection_of_nullable_ints_with_distinct(bool async) + public override async Task Project_collection_of_nullable_ints_with_distinct() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_nullable_ints_with_distinct(async))).Message); + () => base.Project_collection_of_nullable_ints_with_distinct())).Message); - public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault(bool async) + public override async Task Project_collection_of_ints_with_ToList_and_FirstOrDefault() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_collection_of_ints_with_ToList_and_FirstOrDefault(async))).Message); + () => base.Project_collection_of_ints_with_ToList_and_FirstOrDefault())).Message); - public override async Task Project_multiple_collections(bool async) + public override async Task Project_multiple_collections() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_multiple_collections(async))).Message); + () => base.Project_multiple_collections())).Message); - public override async Task Project_primitive_collections_element(bool async) + public override async Task Project_primitive_collections_element() { - await base.Project_primitive_collections_element(async); + await base.Project_primitive_collections_element(); AssertSql( """ @@ -1852,9 +1852,9 @@ ORDER BY "p"."Id" """); } - public override async Task Project_inline_collection(bool async) + public override async Task Project_inline_collection() { - await base.Project_inline_collection(async); + await base.Project_inline_collection(); AssertSql( """ @@ -1863,28 +1863,28 @@ public override async Task Project_inline_collection(bool async) """); } - public override async Task Project_inline_collection_with_Union(bool async) + public override async Task Project_inline_collection_with_Union() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_inline_collection_with_Union(async))).Message); + () => base.Project_inline_collection_with_Union())).Message); - public override async Task Project_inline_collection_with_Concat(bool async) + public override async Task Project_inline_collection_with_Concat() { - await base.Project_inline_collection_with_Concat(async); + await base.Project_inline_collection_with_Concat(); AssertSql(); } - public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls(bool async) + public override async Task Project_empty_collection_of_nullables_and_collection_only_containing_nulls() => Assert.Equal( SqliteStrings.ApplyNotSupported, (await Assert.ThrowsAsync( - () => base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls(async))).Message); + () => base.Project_empty_collection_of_nullables_and_collection_only_containing_nulls())).Message); - public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_Lists_and_no_inferred_type_mapping() { - await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_Lists_and_no_inferred_type_mapping(); AssertSql( """ @@ -1904,9 +1904,9 @@ END IN (@strings1, @strings2, @strings3) """); } - public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping(bool async) + public override async Task Nested_contains_with_arrays_and_no_inferred_type_mapping() { - await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(async); + await base.Nested_contains_with_arrays_and_no_inferred_type_mapping(); AssertSql( """ @@ -1926,10 +1926,8 @@ END IN (@strings1, @strings2, @strings3) """); } - [ConditionalTheory] - [InlineData(false)] - [InlineData(true)] // Issue #32896 - public async Task Empty_string_used_for_primitive_collection_throws(bool async) + [ConditionalFact] + public async Task Empty_string_used_for_primitive_collection_throws() { await using var connection = new SqliteConnection("DataSource=:memory:"); await connection.OpenAsync(); @@ -1942,18 +1940,7 @@ public async Task Empty_string_used_for_primitive_collection_throws(bool async) var set = context.SimpleEntities; - var message = await Assert.ThrowsAsync( - async () => - { - if (async) - { - await set.FirstAsync(); - } - else - { - set.First(); - } - }); + var message = await Assert.ThrowsAsync(() => set.FirstAsync()); Assert.Equal(CoreStrings.EmptyJsonString, message.Message); } @@ -1969,9 +1956,9 @@ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) public record SimpleEntity(int Id, IEnumerable List); - public override async Task Parameter_collection_of_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_struct() { - await base.Parameter_collection_of_structs_Contains_struct(async); + await base.Parameter_collection_of_structs_Contains_struct(); AssertSql( """ @@ -1993,9 +1980,9 @@ public override async Task Parameter_collection_of_structs_Contains_struct(bool """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct(); AssertSql( """ @@ -2017,9 +2004,9 @@ public override async Task Parameter_collection_of_structs_Contains_nullable_str """); } - public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -2041,9 +2028,9 @@ public override async Task Parameter_collection_of_structs_Contains_nullable_str """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_struct(); AssertSql( """ @@ -2064,9 +2051,9 @@ public override async Task Parameter_collection_of_nullable_structs_Contains_str """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct(); AssertSql( """ @@ -2087,9 +2074,9 @@ public override async Task Parameter_collection_of_nullable_structs_Contains_nul """); } - public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(bool async) + public override async Task Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer() { - await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(async); + await base.Parameter_collection_of_nullable_structs_Contains_nullable_struct_with_nullable_comparer(); AssertSql( """ @@ -2110,9 +2097,9 @@ public override async Task Parameter_collection_of_nullable_structs_Contains_nul """); } - public override async Task Values_of_enum_casted_to_underlying_value(bool async) + public override async Task Values_of_enum_casted_to_underlying_value() { - await base.Values_of_enum_casted_to_underlying_value(async); + await base.Values_of_enum_casted_to_underlying_value(); AssertSql( """