diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs index d11cd5bf4..ca8732778 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs @@ -9,9 +9,20 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.BulkUpdates; public class NonSharedModelBulkUpdatesMySqlTest : NonSharedModelBulkUpdatesRelationalTestBase { + public NonSharedModelBulkUpdatesMySqlTest() + : base(new MySqlNonSharedModelBulkUpdatesFixture()) + { + } + protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; + public class MySqlNonSharedModelBulkUpdatesFixture : NonSharedModelBulkUpdatesFixtureBase + { + protected override string StoreName => "NonSharedModelBulkUpdates"; + protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; + } + [ConditionalFact] public virtual void Check_all_tests_overridden() => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs index 6dbd2725f..98214a2e0 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs @@ -530,9 +530,20 @@ LIMIT @__p_1 OFFSET @__p_0 """); } - public override async Task Delete_with_left_join(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Delete_with_left_join(bool async) { - await base.Delete_with_left_join(async); + await AssertDelete( + async, + ss => ss.Set().Where( + od => ss.Set() + .Where(o => o.OrderID < 10300) + .OrderBy(o => o.OrderID) + .Skip(0) + .Take(100) + .Select(o => o.OrderID) + .Contains(od.OrderID))); AssertSql( """ @@ -1086,9 +1097,15 @@ public override async Task Update_without_property_to_set_throws(bool async) AssertExecuteUpdateSql(); } - public override async Task Update_with_invalid_lambda_throws(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Update_with_invalid_lambda_throws(bool async) { - await base.Update_with_invalid_lambda_throws(async); + await AssertTranslationFailed( + () => AssertUpdate( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("F")), + _ => new Customer { City = "invalidValue" })); AssertExecuteUpdateSql(); } @@ -1219,9 +1236,14 @@ INNER JOIN ( """); } - public override async Task Update_with_left_join_set_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Update_with_left_join_set_constant(bool async) { - await base.Update_with_left_join_set_constant(async); + await AssertUpdate( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("F")), + e => e.SetProperty(p => p.ContactName, "Updated")); AssertExecuteUpdateSql( """ diff --git a/test/EFCore.MySql.FunctionalTests/MaterializationInterceptionMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/MaterializationInterceptionMySqlTest.cs index 7b0d95e58..d035ac940 100644 --- a/test/EFCore.MySql.FunctionalTests/MaterializationInterceptionMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/MaterializationInterceptionMySqlTest.cs @@ -6,6 +6,11 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests; public class MaterializationInterceptionMySqlTest : MaterializationInterceptionTestBase { + public MaterializationInterceptionMySqlTest() + : base(new MySqlMaterializationInterceptionFixture()) + { + } + public class MySqlLibraryContext : LibraryContext { public MySqlLibraryContext(DbContextOptions options) @@ -26,4 +31,15 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; + + public class MySqlMaterializationInterceptionFixture : SingletonInterceptorsFixtureBase + { + protected override string StoreName => "MaterializationInterception"; + protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; + + protected override IServiceCollection InjectInterceptors( + IServiceCollection serviceCollection, + IEnumerable injectedInterceptors) + => base.InjectInterceptors(serviceCollection.AddEntityFrameworkMySql(), injectedInterceptors); + } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs index 991319417..b79f1090e 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs @@ -34,10 +34,10 @@ public override async Task Multiple_different_entity_type_from_different_namespa var bad = context.Set().FromSqlRaw(@"SELECT cast(null as signed) AS MyValue").ToList(); // Exception } - protected override Task SetParameterizedCollectionMode(DbContextOptionsBuilder optionsBuilder, ParameterTranslationMode mode) + protected override DbContextOptionsBuilder SetParameterizedCollectionMode(DbContextOptionsBuilder optionsBuilder, ParameterTranslationMode mode) { // MySQL-specific parameter handling configuration // For now, use default MySQL behavior as the implementation is provider-specific - return Task.CompletedTask; + return optionsBuilder; } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs index 081add88c..9b2057c01 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs @@ -34,7 +34,9 @@ public override Task DateTimeOffset_Contains_Less_than_Greater_than(bool async) m => start <= m.Timeline.Date && m.Timeline < end && dates.Contains(m.Timeline))); } - public override Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async) { var dateTimeOffset = MySqlTestHelpers.GetExpectedValue(new DateTimeOffset(599898024001234567, new TimeSpan(1, 30, 0))); @@ -250,9 +252,13 @@ GROUP BY `g0`.`Key` """); } - public override async Task Array_access_on_byte_array(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Array_access_on_byte_array(bool async) { - await base.Array_access_on_byte_array(async); + await AssertQuery( + async, + ss => ss.Set().Where(s => s.Banner5[2] == 6)); AssertSql( """ @@ -262,9 +268,30 @@ WHERE ASCII(SUBSTRING(`s`.`Banner5`, 2 + 1, 1)) = 6 """); } - public override async Task DateTimeOffset_to_unix_time_milliseconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_to_unix_time_milliseconds(bool async) { - await base.DateTimeOffset_to_unix_time_milliseconds(async); + var unixEpochMilliseconds = 0L; + + await AssertQuery( + async, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds) + .Any() + select g, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds) + .Any() + select g, + elementSorter: e => (e.Nickname, e.SquadId), + elementAsserter: (e, a) => AssertEqual(e, a)); AssertSql( """ @@ -283,9 +310,30 @@ SELECT 1 """); } - public override async Task DateTimeOffset_to_unix_time_seconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_to_unix_time_seconds(bool async) { - await base.DateTimeOffset_to_unix_time_seconds(async); + var unixEpochSeconds = 0L; + + await AssertQuery( + async, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds) + .Any() + select g, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds) + .Any() + select g, + elementSorter: e => (e.Nickname, e.SquadId), + elementAsserter: (e, a) => AssertEqual(e, a)); AssertSql( """ @@ -339,7 +387,9 @@ public override async Task Where_subquery_with_ElementAt_using_column_as_index(b AssertSql(""); } - public override async Task Where_datetimeoffset_hour_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_hour_component(bool async) { await AssertQuery( async, diff --git a/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs index ff692781c..339859790 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs @@ -479,9 +479,18 @@ public override async Task Column_collection_inside_json_owned_entity() #endregion Type mapping inference - public override async Task Parameter_collection_Count_with_column_predicate_with_default_constants() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_constants(bool async) { - await base.Parameter_collection_Count_with_column_predicate_with_default_constants(); + var contextFactory = await InitializeAsync(seed: c => c.Seed()); + + await using var context = contextFactory.CreateContext(); + + await AssertQuery( + async, + ss => ss.Set() + .Where(t => new[] { 2, 999 }.Count(i => i > t.Id) == 1)); AssertSql( $""" @@ -494,9 +503,18 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_of_ints_Contains_int_with_default_constants() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_constants(bool async) { - await base.Parameter_collection_of_ints_Contains_int_with_default_constants(); + var contextFactory = await InitializeAsync(seed: c => c.Seed()); + + await using var context = contextFactory.CreateContext(); + + await AssertQuery( + async, + ss => ss.Set() + .Where(t => new[] { 2, 999 }.Contains(t.Id))); AssertSql( """ @@ -506,37 +524,61 @@ public override async Task Parameter_collection_of_ints_Contains_int_with_defaul """); } - public override async Task Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter(bool async) { - await base.Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter(); + await AssertQuery( + async, + ss => ss.Set().Where(x => new[] { 2, 999 }.Count(i => i > x.Id) == 1)); AssertSql(); } - public override async Task Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter(bool async) { - await base.Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter(); + await AssertQuery( + async, + ss => ss.Set().Where(x => new[] { 2, 999 }.Contains(x.Id))); AssertSql(); } - public override async Task Parameter_collection_Count_with_column_predicate_with_default_parameters() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_parameters(bool async) { - await base.Parameter_collection_Count_with_column_predicate_with_default_parameters(); + var ints = new[] { 2, 999 }; + await AssertQuery( + async, + ss => ss.Set().Where(x => ints.Count(i => i > x.Id) == 1)); AssertSql(); } - public override async Task Parameter_collection_of_ints_Contains_int_with_default_parameters() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_parameters(bool async) { - await base.Parameter_collection_of_ints_Contains_int_with_default_parameters(); + var ints = new[] { 2, 999 }; + await AssertQuery( + async, + ss => ss.Set().Where(x => ints.Contains(x.Id))); AssertSql(); } - public override async Task Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant(bool async) { - await base.Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant(); + var (_, entityId) = (2, 999); + + await AssertQuery( + async, + ss => ss.Set().Where(x => new[] { _, entityId }.Count(i => i > x.Id) == 1)); AssertSql( $""" @@ -549,9 +591,15 @@ SELECT COUNT(*) """); } - public override async Task Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant() + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant(bool async) { - await base.Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant(); + var (_, entityId) = (2, 999); + + await AssertQuery( + async, + ss => ss.Set().Where(x => new[] { _, entityId }.Contains(x.Id))); AssertSql( """ @@ -576,14 +624,21 @@ public override async Task Project_collection_from_entity_type_with_owned() public virtual void Check_all_tests_overridden() => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); - protected override DbContextOptionsBuilder SetTranslateParameterizedCollectionsToConstants(DbContextOptionsBuilder optionsBuilder) + protected override DbContextOptionsBuilder SetParameterizedCollectionMode(DbContextOptionsBuilder optionsBuilder, ParameterTranslationMode mode) + { + // MySQL-specific parameter handling configuration + // For now, use default MySQL behavior as the implementation is provider-specific + return optionsBuilder; + } + + protected virtual DbContextOptionsBuilder SetTranslateParameterizedCollectionsToConstants(DbContextOptionsBuilder optionsBuilder) { new MySqlDbContextOptionsBuilder(optionsBuilder).TranslateParameterizedCollectionsToConstants(); return optionsBuilder; } - protected override DbContextOptionsBuilder SetTranslateParameterizedCollectionsToParameters(DbContextOptionsBuilder optionsBuilder) + protected virtual DbContextOptionsBuilder SetTranslateParameterizedCollectionsToParameters(DbContextOptionsBuilder optionsBuilder) { new MySqlDbContextOptionsBuilder(optionsBuilder).TranslateParameterizedCollectionsToParameters(); diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs index 87b5d5e4e..40699c177 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs @@ -21,9 +21,12 @@ public NorthwindFunctionsQueryMySqlTest( } [ConditionalTheory] - public override async Task String_StartsWith_Literal(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_Literal(bool async) { - await base.String_StartsWith_Literal(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith("M"))); AssertSql( """ @@ -34,9 +37,12 @@ public override async Task String_StartsWith_Literal(bool async) } [ConditionalTheory] - public override async Task String_StartsWith_Identity(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_Identity(bool async) { - await base.String_StartsWith_Identity(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith(c.ContactName))); AssertSql( """ @@ -47,9 +53,12 @@ public override async Task String_StartsWith_Identity(bool async) } [ConditionalTheory] - public override async Task String_StartsWith_Column(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_Column(bool async) { - await base.String_StartsWith_Column(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith(c.ContactName))); AssertSql( """ @@ -60,9 +69,12 @@ public override async Task String_StartsWith_Column(bool async) } [ConditionalTheory] - public override async Task String_StartsWith_MethodCall(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_MethodCall(bool async) { - await base.String_StartsWith_MethodCall(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith(LocalMethod1()))); AssertSql( """ @@ -73,9 +85,12 @@ public override async Task String_StartsWith_MethodCall(bool async) } [ConditionalTheory] - public override async Task String_EndsWith_Literal(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_Literal(bool async) { - await base.String_EndsWith_Literal(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith("b"))); AssertSql( """ @@ -86,9 +101,12 @@ public override async Task String_EndsWith_Literal(bool async) } [ConditionalTheory] - public override async Task String_EndsWith_Identity(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_Identity(bool async) { - await base.String_EndsWith_Identity(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith(c.ContactName))); AssertSql( """ @@ -99,9 +117,12 @@ public override async Task String_EndsWith_Identity(bool async) } [ConditionalTheory] - public override async Task String_EndsWith_Column(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_Column(bool async) { - await base.String_EndsWith_Column(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith(c.ContactName))); AssertSql( """ @@ -112,9 +133,12 @@ public override async Task String_EndsWith_Column(bool async) } [ConditionalTheory] - public override async Task String_EndsWith_MethodCall(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_MethodCall(bool async) { - await base.String_EndsWith_MethodCall(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith(LocalMethod2()))); AssertSql( """ @@ -125,9 +149,12 @@ public override async Task String_EndsWith_MethodCall(bool async) } [ConditionalTheory] - public override async Task String_Contains_Literal(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_Literal(bool async) { - await base.String_Contains_Literal(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains("M"))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -136,9 +163,12 @@ public override async Task String_Contains_Literal(bool async) } [ConditionalTheory] - public override async Task String_Contains_Identity(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_Identity(bool async) { - await base.String_Contains_Identity(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains(c.ContactName))); AssertSql( """ @@ -149,9 +179,12 @@ public override async Task String_Contains_Identity(bool async) } [ConditionalTheory] - public override async Task String_Contains_Column(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_Column(bool async) { - await base.String_Contains_Column(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains(c.ContactName))); AssertSql( """ @@ -162,9 +195,12 @@ public override async Task String_Contains_Column(bool async) } [ConditionalTheory] - public override async Task String_Contains_MethodCall(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_MethodCall(bool async) { - await base.String_Contains_MethodCall(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains(LocalMethod1()))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -173,9 +209,12 @@ public override async Task String_Contains_MethodCall(bool async) } [ConditionalTheory] - public override async Task IsNullOrWhiteSpace_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task IsNullOrWhiteSpace_in_predicate(bool async) { - await base.IsNullOrWhiteSpace_in_predicate(async); + await AssertQuery( + async, + ss.Set().Where(c => string.IsNullOrWhiteSpace(c.Region))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -184,9 +223,12 @@ public override async Task IsNullOrWhiteSpace_in_predicate(bool async) } [ConditionalTheory] - public override async Task Indexof_with_emptystring(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Indexof_with_emptystring(bool async) { - await base.Indexof_with_emptystring(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.IndexOf(string.Empty) == 0)); AssertSql( """ @@ -197,9 +239,12 @@ public override async Task Indexof_with_emptystring(bool async) } [ConditionalTheory] - public override async Task Replace_with_emptystring(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Replace_with_emptystring(bool async) { - await base.Replace_with_emptystring(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.Replace("ari", string.Empty) == "M")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -208,9 +253,12 @@ public override async Task Replace_with_emptystring(bool async) } [ConditionalTheory] - public override async Task Substring_with_one_arg_with_zero_startindex(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_one_arg_with_zero_startindex(bool async) { - await base.Substring_with_one_arg_with_zero_startindex(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.Substring(0) == "M")); AssertSql( @"SELECT `c`.`ContactName` @@ -219,9 +267,12 @@ public override async Task Substring_with_one_arg_with_zero_startindex(bool asyn } [ConditionalTheory] - public override async Task Substring_with_one_arg_with_constant(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_one_arg_with_constant(bool async) { - await base.Substring_with_one_arg_with_constant(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.Substring(3) == "M")); AssertSql( @"SELECT `c`.`ContactName` @@ -230,9 +281,14 @@ public override async Task Substring_with_one_arg_with_constant(bool async) } [ConditionalTheory] - public override async Task Substring_with_one_arg_with_closure(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_one_arg_with_closure(bool async) { - await base.Substring_with_one_arg_with_closure(async); + var start = 3; + + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.Substring(start) == "M")); AssertSql( @"@__start_0='2' @@ -243,9 +299,12 @@ public override async Task Substring_with_one_arg_with_closure(bool async) } [ConditionalTheory] - public override async Task Substring_with_two_args_with_zero_startindex(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_two_args_with_zero_startindex(bool async) { - await base.Substring_with_two_args_with_zero_startindex(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.Substring(0, 3) == "Mar")); AssertSql( @"SELECT SUBSTRING(`c`.`ContactName`, 0 + 1, 3) @@ -254,9 +313,12 @@ public override async Task Substring_with_two_args_with_zero_startindex(bool asy } [ConditionalTheory] - public override async Task Substring_with_two_args_with_zero_length(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_two_args_with_zero_length(bool async) { - await base.Substring_with_two_args_with_zero_length(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.Substring(3, 0) == string.Empty)); AssertSql( @"SELECT SUBSTRING(`c`.`ContactName`, 2 + 1, 0) @@ -265,9 +327,12 @@ public override async Task Substring_with_two_args_with_zero_length(bool async) } [ConditionalTheory] - public override async Task Substring_with_two_args_with_constant(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_two_args_with_constant(bool async) { - await base.Substring_with_two_args_with_constant(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.Substring(1, 3) == "ari")); AssertSql( @"SELECT SUBSTRING(`c`.`ContactName`, 1 + 1, 3) @@ -276,9 +341,15 @@ public override async Task Substring_with_two_args_with_constant(bool async) } [ConditionalTheory] - public override async Task Substring_with_two_args_with_closure(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_two_args_with_closure(bool async) { - await base.Substring_with_two_args_with_closure(async); + var start = 1; + var length = 3; + + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Substring(start, length) == "ari")); AssertSql( @"@__start_0='2' @@ -289,9 +360,12 @@ SELECT SUBSTRING(`c`.`ContactName`, @__start_0 + 1, 3) } [ConditionalTheory] - public override async Task Substring_with_two_args_with_Index_of(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Substring_with_two_args_with_Index_of(bool async) { - await base.Substring_with_two_args_with_Index_of(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Substring(c.ContactName.IndexOf("a"), 3) == "ari")); AssertSql( @"SELECT SUBSTRING(`c`.`ContactName`, (LOCATE('a', `c`.`ContactName`) - 1) + 1, 3) @@ -300,9 +374,12 @@ public override async Task Substring_with_two_args_with_Index_of(bool async) } [ConditionalTheory] - public override async Task Regex_IsMatch_MethodCall(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Regex_IsMatch_MethodCall(bool async) { - await base.Regex_IsMatch_MethodCall(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => Regex.IsMatch(c.ContactName, "^M"))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -311,9 +388,12 @@ public override async Task Regex_IsMatch_MethodCall(bool async) } [ConditionalTheory] - public override async Task Regex_IsMatch_MethodCall_constant_input(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Regex_IsMatch_MethodCall_constant_input(bool async) { - await base.Regex_IsMatch_MethodCall_constant_input(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => Regex.IsMatch("Maria", "^M"))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -322,9 +402,12 @@ public override async Task Regex_IsMatch_MethodCall_constant_input(bool async) } [ConditionalTheory] - public override async Task Where_math_abs1(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_abs1(bool async) { - await base.Where_math_abs1(async); + await AssertQuery( + async, + ss => ss.Set().Where(p => Math.Abs(p.ProductID) > 10)); AssertSql( @"SELECT `p`.`ProductID`, `p`.`Discontinued`, `p`.`ProductName`, `p`.`SupplierID`, `p`.`UnitPrice`, `p`.`UnitsInStock` @@ -333,9 +416,12 @@ public override async Task Where_math_abs1(bool async) } [ConditionalTheory] - public override async Task Where_math_abs2(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_abs2(bool async) { - await base.Where_math_abs2(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Abs(od.Quantity) > 10)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -344,9 +430,12 @@ public override async Task Where_math_abs2(bool async) } [ConditionalTheory] - public override async Task Where_math_abs_uncorrelated(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_abs_uncorrelated(bool async) { - await base.Where_math_abs_uncorrelated(async); + await AssertQuery( + async, + ss => ss.Set().Where(p => Math.Abs(p.ProductID) == 10)); AssertSql( """ SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -356,9 +445,12 @@ public override async Task Where_math_abs_uncorrelated(bool async) } [ConditionalTheory] - public override async Task Select_math_round_int(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_math_round_int(bool async) { - await base.Select_math_round_int(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Result = Math.Round((double)o.OrderID) })); AssertSql( $@"SELECT ROUND({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}) AS `A` @@ -367,9 +459,12 @@ public override async Task Select_math_round_int(bool async) } [ConditionalTheory] - public override async Task Where_math_min(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_min(bool async) { - await base.Where_math_min(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Min(od.OrderID, od.ProductID) })); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -378,9 +473,12 @@ public override async Task Where_math_min(bool async) } [ConditionalTheory] - public override async Task Where_math_max(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_max(bool async) { - await base.Where_math_max(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Max(od.OrderID, od.ProductID) })); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -389,9 +487,12 @@ public override async Task Where_math_max(bool async) } [ConditionalTheory] - public override async Task Where_string_to_lower(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_to_lower(bool async) { - await base.Where_string_to_lower(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.ToLower() == "maria anders")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -400,9 +501,12 @@ public override async Task Where_string_to_lower(bool async) } [ConditionalTheory] - public override async Task Where_string_to_upper(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_to_upper(bool async) { - await base.Where_string_to_upper(async); + await AssertQuery( + async, + ss.Set().Where(c => c.ContactName.ToUpper() == "MARIA ANDERS")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -411,9 +515,12 @@ public override async Task Where_string_to_upper(bool async) } [ConditionalTheory] - public override async Task TrimStart_without_arguments_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task TrimStart_without_arguments_in_predicate(bool async) { - await base.TrimStart_without_arguments_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.TrimStart() == "Maria Anders")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -422,9 +529,12 @@ public override async Task TrimStart_without_arguments_in_predicate(bool async) } [ConditionalTheory] - public override async Task TrimStart_with_char_argument_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task TrimStart_with_char_argument_in_predicate(bool async) { - await base.TrimStart_with_char_argument_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.TrimStart('M') == "aria Anders")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -433,7 +543,8 @@ public override async Task TrimStart_with_char_argument_in_predicate(bool async) } [ConditionalTheory] - public override Task TrimStart_with_char_array_argument_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual Task TrimStart_with_char_array_argument_in_predicate(bool async) { // MySQL only supports a string (characters in fixed order) as the parameter specifying what should be trimmed. // String.TrimStart has a different behavior, where any single character in any order will be trimmed. @@ -442,9 +553,12 @@ public override Task TrimStart_with_char_array_argument_in_predicate(bool async) } [ConditionalTheory] - public override async Task TrimEnd_without_arguments_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task TrimEnd_without_arguments_in_predicate(bool async) { - await base.TrimEnd_without_arguments_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.TrimEnd() == "Maria Anders")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -453,9 +567,12 @@ public override async Task TrimEnd_without_arguments_in_predicate(bool async) } [ConditionalTheory] - public override async Task TrimEnd_with_char_argument_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task TrimEnd_with_char_argument_in_predicate(bool async) { - await base.TrimEnd_with_char_argument_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.TrimEnd('s') == "Maria Ander")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -464,7 +581,8 @@ public override async Task TrimEnd_with_char_argument_in_predicate(bool async) } [ConditionalTheory] - public override Task TrimEnd_with_char_array_argument_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual Task TrimEnd_with_char_array_argument_in_predicate(bool async) { // MySQL only supports a string (characters in fixed order) as the parameter specifying what should be trimmed. // String.TrimEnd has a different behavior, where any single character in any order will be trimmed. @@ -473,9 +591,12 @@ public override Task TrimEnd_with_char_array_argument_in_predicate(bool async) } [ConditionalTheory] - public override async Task Trim_without_argument_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Trim_without_argument_in_predicate(bool async) { - await base.Trim_without_argument_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Trim() == "Maria Anders")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -484,9 +605,12 @@ public override async Task Trim_without_argument_in_predicate(bool async) } [ConditionalTheory] - public override async Task Trim_with_char_argument_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Trim_with_char_argument_in_predicate(bool async) { - await base.Trim_with_char_argument_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Trim('M') == "aria Anders")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -495,7 +619,8 @@ public override async Task Trim_with_char_argument_in_predicate(bool async) } [ConditionalTheory] - public override Task Trim_with_char_array_argument_in_predicate(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual Task Trim_with_char_array_argument_in_predicate(bool async) { // MySQL only supports a string (characters in fixed order) as the parameter specifying what should be trimmed. // String.Trim has a different behavior, where any single character in any order will be trimmed. @@ -503,9 +628,13 @@ public override Task Trim_with_char_array_argument_in_predicate(bool async) return Assert.ThrowsAsync(() => base.Trim_with_char_array_argument_in_predicate(async)); } - public override async Task String_FirstOrDefault_MethodCall(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_FirstOrDefault_MethodCall(bool async) { - await base.String_FirstOrDefault_MethodCall(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.FirstOrDefault() == 'M')); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -513,9 +642,13 @@ public override async Task String_FirstOrDefault_MethodCall(bool async) WHERE SUBSTRING(`c`.`ContactName`, 1, 1) = 'A'"); } - public override async Task String_Contains_constant_with_whitespace(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_constant_with_whitespace(bool async) { - await base.String_Contains_constant_with_whitespace(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains(" "))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -523,9 +656,15 @@ public override async Task String_Contains_constant_with_whitespace(bool async) WHERE `c`.`ContactName` LIKE '% %'"); } - public override async Task String_Contains_parameter_with_whitespace(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_parameter_with_whitespace(bool async) { - await base.String_Contains_parameter_with_whitespace(async); + var pattern = " "; + + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains(pattern))); AssertSql( """ @@ -537,9 +676,13 @@ public override async Task String_Contains_parameter_with_whitespace(bool async) """); } - public override async Task String_LastOrDefault_MethodCall(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_LastOrDefault_MethodCall(bool async) { - await base.String_LastOrDefault_MethodCall(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.LastOrDefault() == 's')); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -547,9 +690,13 @@ public override async Task String_LastOrDefault_MethodCall(bool async) WHERE SUBSTRING(`c`.`ContactName`, CHAR_LENGTH(`c`.`ContactName`), 1) = 's'"); } - public override async Task Where_math_abs3(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_abs3(bool async) { - await base.Where_math_abs3(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Abs(od.UnitPrice) > 10)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -557,9 +704,13 @@ public override async Task Where_math_abs3(bool async) WHERE (`o`.`Quantity` < 5) AND (ABS(`o`.`UnitPrice`) > 10.0)"); } - public override async Task Where_math_ceiling1(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_ceiling1(bool async) { - await base.Where_math_ceiling1(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Ceiling(od.Discount) > 0)); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -567,9 +718,13 @@ public override async Task Where_math_ceiling1(bool async) WHERE (`o`.`UnitPrice` < 7.0) AND (CEILING({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 0.0)"); } - public override async Task Where_math_ceiling2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_ceiling2(bool async) { - await base.Where_math_ceiling2(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Ceiling(od.UnitPrice) > 10)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -577,9 +732,13 @@ public override async Task Where_math_ceiling2(bool async) WHERE (`o`.`Quantity` < 5) AND (CEILING(`o`.`UnitPrice`) > 10.0)"); } - public override async Task Where_math_floor(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_floor(bool async) { - await base.Where_math_floor(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Floor(od.UnitPrice) > 10)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -587,9 +746,13 @@ public override async Task Where_math_floor(bool async) WHERE (`o`.`Quantity` < 5) AND (FLOOR(`o`.`UnitPrice`) > 10.0)"); } - public override async Task Where_math_power(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_power(bool async) { - await base.Where_math_power(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Pow(od.Discount, 3) > 0.005)); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -597,9 +760,13 @@ public override async Task Where_math_power(bool async) WHERE POWER({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}, 3.0) > 0.004999999888241291"); } - public override async Task Where_math_round(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_round(bool async) { - await base.Where_math_round(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Round(od.UnitPrice) > 10)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -607,9 +774,13 @@ public override async Task Where_math_round(bool async) WHERE (`o`.`Quantity` < 5) AND (ROUND(`o`.`UnitPrice`) > 10.0)"); } - public override async Task Select_math_truncate_int(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_math_truncate_int(bool async) { - await base.Select_math_truncate_int(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => Math.Truncate((double)o.OrderID))); AssertSql( $@"SELECT TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}, 0) AS `A` @@ -617,9 +788,13 @@ public override async Task Select_math_truncate_int(bool async) WHERE `o`.`OrderID` < 10250"); } - public override async Task Where_math_round2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_round2(bool async) { - await base.Where_math_round2(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Round(od.UnitPrice, 2) > 100)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -627,9 +802,13 @@ public override async Task Where_math_round2(bool async) WHERE ROUND(`o`.`UnitPrice`, 2) > 100.0"); } - public override async Task Where_math_truncate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_truncate(bool async) { - await base.Where_math_truncate(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Truncate(od.UnitPrice) > 10)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -637,9 +816,13 @@ public override async Task Where_math_truncate(bool async) WHERE (`o`.`Quantity` < 5) AND (TRUNCATE(`o`.`UnitPrice`, 0) > 10.0)"); } - public override async Task Where_math_exp(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_exp(bool async) { - await base.Where_math_exp(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Exp(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -647,9 +830,13 @@ public override async Task Where_math_exp(bool async) WHERE (`o`.`OrderID` = 11077) AND (EXP({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 1.0)"); } - public override async Task Where_math_log10(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_log10(bool async) { - await base.Where_math_log10(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077 && od.Discount > 0).Select(od => new { od.OrderID, Result = Math.Log10(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -657,9 +844,13 @@ public override async Task Where_math_log10(bool async) WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG10({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) < 0.0)"); } - public override async Task Where_math_log(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_log(bool async) { - await base.Where_math_log(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077 && od.Discount > 0).Select(od => new { od.OrderID, Result = Math.Log(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -667,9 +858,13 @@ public override async Task Where_math_log(bool async) WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) < 0.0)"); } - public override async Task Where_math_log_new_base(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_log_new_base(bool async) { - await base.Where_math_log_new_base(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077 && od.Discount > 0).Select(od => new { od.OrderID, Result = Math.Log(od.Discount, 7) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -677,9 +872,13 @@ public override async Task Where_math_log_new_base(bool async) WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7.0, {MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) < -1.0)"); } - public override async Task Where_math_sqrt(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_sqrt(bool async) { - await base.Where_math_sqrt(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Sqrt(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -687,9 +886,13 @@ public override async Task Where_math_sqrt(bool async) WHERE (`o`.`OrderID` = 11077) AND (SQRT({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 0.0)"); } - public override async Task Where_math_acos(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_acos(bool async) { - await base.Where_math_acos(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Acos(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -697,9 +900,13 @@ public override async Task Where_math_acos(bool async) WHERE (`o`.`OrderID` = 11077) AND (ACOS({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 1.0)"); } - public override async Task Where_math_asin(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_asin(bool async) { - await base.Where_math_asin(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Asin(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -707,9 +914,13 @@ public override async Task Where_math_asin(bool async) WHERE (`o`.`OrderID` = 11077) AND (ASIN({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 0.0)"); } - public override async Task Where_math_atan(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_atan(bool async) { - await base.Where_math_atan(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Atan(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -717,9 +928,13 @@ public override async Task Where_math_atan(bool async) WHERE (`o`.`OrderID` = 11077) AND (ATAN({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 0.0)"); } - public override async Task Where_math_atan2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_atan2(bool async) { - await base.Where_math_atan2(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Atan2(od.Discount, 1) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -727,9 +942,13 @@ public override async Task Where_math_atan2(bool async) WHERE (`o`.`OrderID` = 11077) AND (ATAN2({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}, 1.0) > 0.0)"); } - public override async Task Where_math_cos(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_cos(bool async) { - await base.Where_math_cos(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Cos(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -737,9 +956,13 @@ public override async Task Where_math_cos(bool async) WHERE (`o`.`OrderID` = 11077) AND (COS({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 0.0)"); } - public override async Task Where_math_sin(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_sin(bool async) { - await base.Where_math_sin(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Sin(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -747,9 +970,13 @@ public override async Task Where_math_sin(bool async) WHERE (`o`.`OrderID` = 11077) AND (SIN({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 0.0)"); } - public override async Task Where_math_tan(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_tan(bool async) { - await base.Where_math_tan(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Tan(od.Discount) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -757,9 +984,13 @@ public override async Task Where_math_tan(bool async) WHERE (`o`.`OrderID` = 11077) AND (TAN({MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) > 0.0)"); } - public override async Task Where_math_sign(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_sign(bool async) { - await base.Where_math_sign(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = Math.Sign(od.Discount) })); AssertSql( @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` @@ -767,9 +998,13 @@ public override async Task Where_math_sign(bool async) WHERE (`o`.`OrderID` = 11077) AND (SIGN(`o`.`Discount`) > 0)"); } - public override async Task Where_guid_newguid(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_guid_newguid(bool async) { - await base.Where_guid_newguid(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Guid.NewGuid() != default)); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -787,9 +1022,13 @@ public override async Task Where_functions_nested(bool async) WHERE POWER({MySqlTestHelpers.CastAsDouble("CHAR_LENGTH(`c`.`CustomerID`)")}, 2.0) = 25.0"); } - public override async Task IsNullOrEmpty_in_predicate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task IsNullOrEmpty_in_predicate(bool async) { - await base.IsNullOrEmpty_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.IsNullOrEmpty(c.Region))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -797,19 +1036,31 @@ public override async Task IsNullOrEmpty_in_predicate(bool async) WHERE `c`.`Region` IS NULL OR (`c`.`Region` = '')"); } - public override async Task IsNullOrEmpty_in_projection(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task IsNullOrEmpty_in_projection(bool async) { - await base.IsNullOrEmpty_in_projection(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, IsNullOrEmpty = string.IsNullOrEmpty(c.Region) })); } - public override async Task IsNullOrEmpty_negated_in_projection(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task IsNullOrEmpty_negated_in_projection(bool async) { - await base.IsNullOrEmpty_negated_in_projection(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, IsNotNullOrEmpty = !string.IsNullOrEmpty(c.Region) })); } - public override async Task IsNullOrWhiteSpace_in_predicate_on_non_nullable_column(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task IsNullOrWhiteSpace_in_predicate_on_non_nullable_column(bool async) { - await base.IsNullOrWhiteSpace_in_predicate_on_non_nullable_column(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.IsNullOrWhiteSpace(c.CustomerID))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -838,9 +1089,13 @@ public override async Task Order_by_length_twice_followed_by_projection_of_naked ORDER BY CHAR_LENGTH(`c`.`CustomerID`), `c`.`CustomerID`"); } - public override async Task Static_string_equals_in_predicate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Static_string_equals_in_predicate(bool async) { - await base.Static_string_equals_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.ContactName, "Maria Anders"))); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -870,9 +1125,13 @@ public override async Task Static_equals_int_compared_to_long(bool async) WHERE FALSE"); } - public override async Task Projecting_Math_Truncate_and_ordering_by_it_twice(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Projecting_Math_Truncate_and_ordering_by_it_twice(bool async) { - await base.Projecting_Math_Truncate_and_ordering_by_it_twice(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Result = Math.Truncate((double)o.OrderID) }).OrderBy(r => r.Result).OrderBy(r => r.Result)); AssertSql( $@"SELECT TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}, 0) AS `A` @@ -881,9 +1140,13 @@ public override async Task Projecting_Math_Truncate_and_ordering_by_it_twice(boo ORDER BY TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}, 0)"); } - public override async Task Projecting_Math_Truncate_and_ordering_by_it_twice2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Projecting_Math_Truncate_and_ordering_by_it_twice2(bool async) { - await base.Projecting_Math_Truncate_and_ordering_by_it_twice2(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Result = Math.Truncate((double)o.OrderID) }).OrderBy(r => r.Result).OrderByDescending(r => r.Result)); AssertSql( $@"SELECT TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}, 0) AS `A` @@ -892,9 +1155,13 @@ public override async Task Projecting_Math_Truncate_and_ordering_by_it_twice2(bo ORDER BY TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}, 0) DESC"); } - public override async Task Projecting_Math_Truncate_and_ordering_by_it_twice3(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Projecting_Math_Truncate_and_ordering_by_it_twice3(bool async) { - await base.Projecting_Math_Truncate_and_ordering_by_it_twice3(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Result = Math.Truncate((double)o.OrderID) }).OrderByDescending(r => r.Result).OrderBy(r => r.Result)); AssertSql( $@"SELECT TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}, 0) AS `A` @@ -903,9 +1170,13 @@ public override async Task Projecting_Math_Truncate_and_ordering_by_it_twice3(bo ORDER BY TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}, 0) DESC"); } - public override async Task String_Compare_simple_zero(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_simple_zero(bool async) { - await base.String_Compare_simple_zero(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Compare(c.ContactName, "Maria Anders") == 0)); AssertSql( """ @@ -945,9 +1216,13 @@ public override async Task String_Compare_simple_zero(bool async) """); } - public override async Task String_Compare_simple_one(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_simple_one(bool async) { - await base.String_Compare_simple_one(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Compare(c.ContactName, "Maria Anders") == 1)); AssertSql( """ @@ -987,9 +1262,15 @@ public override async Task String_Compare_simple_one(bool async) """); } - public override async Task String_compare_with_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_compare_with_parameter(bool async) { - await base.String_compare_with_parameter(async); + var compareTo = "Maria Anders"; + + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Compare(c.ContactName, compareTo) == 1)); AssertSql( """ @@ -1041,9 +1322,13 @@ public override async Task String_compare_with_parameter(bool async) """); } - public override async Task String_Compare_simple_more_than_one(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_simple_more_than_one(bool async) { - await base.String_Compare_simple_more_than_one(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Compare(c.ContactName, "Maria Anders") > 0)); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -1071,9 +1356,13 @@ WHERE 42 > CASE END"); } - public override async Task String_Compare_nested(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_nested(bool async) { - await base.String_Compare_nested(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Compare(c.ContactName.ToUpper(), "MARIA ANDERS") == 0)); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -1101,9 +1390,13 @@ public override async Task String_Compare_nested(bool async) WHERE `c`.`CustomerID` < REPLACE('ALFKI', 'ALF', `c`.`CustomerID`)"); } - public override async Task String_Compare_multi_predicate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_multi_predicate(bool async) { - await base.String_Compare_multi_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Compare(c.ContactName, "Maria Anders") == 0 && string.Compare(c.ContactName, "Maria Ander") != 0)); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -1115,9 +1408,13 @@ public override async Task String_Compare_multi_predicate(bool async) WHERE (`c`.`ContactTitle` = 'Owner') AND ((`c`.`Country` <> 'USA') OR `c`.`Country` IS NULL)"); } - public override async Task String_Compare_to_simple_zero(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_to_simple_zero(bool async) { - await base.String_Compare_to_simple_zero(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.CompareTo("Maria Anders") == 0)); AssertSql( """ @@ -1157,9 +1454,13 @@ public override async Task String_Compare_to_simple_zero(bool async) """); } - public override async Task String_Compare_to_simple_one(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_to_simple_one(bool async) { - await base.String_Compare_to_simple_one(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.CompareTo("Maria Anders") == 1)); AssertSql( """ @@ -1199,9 +1500,15 @@ public override async Task String_Compare_to_simple_one(bool async) """); } - public override async Task String_compare_to_with_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_compare_to_with_parameter(bool async) { - await base.String_compare_to_with_parameter(async); + var compareTo = "Maria Anders"; + + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.CompareTo(compareTo) == 1)); AssertSql( """ @@ -1253,9 +1560,13 @@ public override async Task String_compare_to_with_parameter(bool async) """); } - public override async Task String_Compare_to_simple_more_than_one(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_to_simple_more_than_one(bool async) { - await base.String_Compare_to_simple_more_than_one(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.CompareTo("Maria Anders") > 0)); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -1283,9 +1594,13 @@ WHERE 42 > CASE END"); } - public override async Task String_Compare_to_nested(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_to_nested(bool async) { - await base.String_Compare_to_nested(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.ToUpper().CompareTo("MARIA ANDERS") == 0)); AssertSql( """ @@ -1325,9 +1640,13 @@ public override async Task String_Compare_to_nested(bool async) """); } - public override async Task String_Compare_to_multi_predicate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Compare_to_multi_predicate(bool async) { - await base.String_Compare_to_multi_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.CompareTo("Maria Anders") == 0 && c.ContactName.CompareTo("Maria Ander") != 0)); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -1339,7 +1658,9 @@ public override async Task String_Compare_to_multi_predicate(bool async) WHERE (`c`.`ContactTitle` = 'Owner') AND ((`c`.`Country` <> 'USA') OR `c`.`Country` IS NULL)"); } - public override async Task DateTime_Compare_to_simple_zero(bool async, bool compareTo) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTime_Compare_to_simple_zero(bool async, bool compareTo) { await base.DateTime_Compare_to_simple_zero(async, compareTo); @@ -1381,7 +1702,9 @@ public override async Task DateTime_Compare_to_simple_zero(bool async, bool comp WHERE `o`.`OrderDate` <= @__myDatetime_0"); } - public override async Task TimeSpan_Compare_to_simple_zero(bool async, bool compareTo) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task TimeSpan_Compare_to_simple_zero(bool async, bool compareTo) { await base.TimeSpan_Compare_to_simple_zero(async, compareTo); @@ -1423,9 +1746,13 @@ public override async Task TimeSpan_Compare_to_simple_zero(bool async, bool comp WHERE `o`.`OrderDate` <= @__myDatetime_0"); } - public override async Task Int_Compare_to_simple_zero(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Int_Compare_to_simple_zero(bool async) { - await base.Int_Compare_to_simple_zero(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderID.CompareTo(10250) == 0)); AssertSql( @"@__orderId_0='10250' @@ -1465,9 +1792,13 @@ public override async Task Int_Compare_to_simple_zero(bool async) WHERE `o`.`OrderID` <= @__orderId_0"); } - public override async Task Convert_ToBoolean(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToBoolean(bool async) { - await base.Convert_ToBoolean(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToBoolean(o.OrderID % 2) })); AssertSql( """ @@ -1525,9 +1856,13 @@ public override async Task Convert_ToBoolean(bool async) """); } - public override async Task Convert_ToByte(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToByte(bool async) { - await base.Convert_ToByte(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToByte(o.OrderID % 256) })); AssertSql( """ @@ -1591,9 +1926,13 @@ public override async Task Convert_ToByte(bool async) """); } - public override async Task Convert_ToDecimal(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToDecimal(bool async) { - await base.Convert_ToDecimal(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToDecimal(o.OrderID) })); AssertSql( """ @@ -1657,9 +1996,13 @@ public override async Task Convert_ToDecimal(bool async) """); } - public override async Task Convert_ToDouble(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToDouble(bool async) { - await base.Convert_ToDouble(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToDouble(o.OrderID) })); AssertSql( $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` @@ -1703,9 +2046,13 @@ public override async Task Convert_ToDouble(bool async) WHERE (`o`.`CustomerID` = 'ALFKI') AND ({MySqlTestHelpers.CastAsDouble("CAST(`o`.`OrderID` % 1 AS char)")} >= 0.0)"); } - public override async Task Convert_ToInt16(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToInt16(bool async) { - await base.Convert_ToInt16(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToInt16(o.OrderID) })); AssertSql( """ @@ -1769,9 +2116,13 @@ public override async Task Convert_ToInt16(bool async) """); } - public override async Task Convert_ToInt32(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToInt32(bool async) { - await base.Convert_ToInt32(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToInt32(o.OrderID) })); AssertSql( """ @@ -1835,9 +2186,13 @@ public override async Task Convert_ToInt32(bool async) """); } - public override async Task Convert_ToInt64(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToInt64(bool async) { - await base.Convert_ToInt64(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToInt64(o.OrderID) })); AssertSql( """ @@ -1901,9 +2256,13 @@ public override async Task Convert_ToInt64(bool async) """); } - public override async Task Convert_ToString(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Convert_ToString(bool async) { - await base.Convert_ToString(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, Converted = Convert.ToString(o.OrderID) })); AssertSql( """ @@ -1973,9 +2332,15 @@ public override async Task Convert_ToString(bool async) """); } - public override async Task String_StartsWith_Parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_Parameter(bool async) { - await base.String_StartsWith_Parameter(async); + var pattern = "M"; + + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith(pattern))); AssertSql( """ @@ -1987,9 +2352,15 @@ public override async Task String_StartsWith_Parameter(bool async) """); } - public override async Task String_EndsWith_Parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_Parameter(bool async) { - await base.String_EndsWith_Parameter(async); + var pattern = "b"; + + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith(pattern))); AssertSql( """ @@ -2001,9 +2372,13 @@ public override async Task String_EndsWith_Parameter(bool async) """); } - public override async Task String_Join_over_non_nullable_column(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Join_over_non_nullable_column(bool async) { - await base.String_Join_over_non_nullable_column(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, Joined = string.Join("|", new[] { c.ContactName, c.CompanyName }) })); AssertSql( """ @@ -2018,9 +2393,13 @@ ORDER BY `c1`.`City` """); } - public override async Task String_Join_with_predicate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Join_with_predicate(bool async) { - await base.String_Join_with_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Join("|", new[] { c.ContactName, c.CompanyName }).Length > 10)); AssertSql( """ @@ -2039,9 +2418,13 @@ ORDER BY `c1`.`City` """); } - public override async Task String_Join_with_ordering(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Join_with_ordering(bool async) { - await base.String_Join_with_ordering(async); + await AssertQuery( + async, + ss => ss.Set().OrderBy(c => string.Join("|", new[] { c.ContactName, c.CompanyName }))); AssertSql( """ @@ -2056,9 +2439,13 @@ GROUP BY `c`.`City` """); } - public override async Task String_Join_over_nullable_column(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Join_over_nullable_column(bool async) { - await base.String_Join_over_nullable_column(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, Joined = string.Join("|", new[] { c.ContactName, c.Region }) })); AssertSql( """ @@ -2073,9 +2460,13 @@ ORDER BY `c1`.`City` """); } - public override async Task String_Concat(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Concat(bool async) { - await base.String_Concat(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, Concat = string.Concat(c.ContactName, " ", c.CompanyName) })); AssertSql( """ @@ -2090,9 +2481,13 @@ ORDER BY `c1`.`City` """); } - public override async Task Where_math_square(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_square(bool async) { - await base.Where_math_square(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Pow(od.Discount, 2) > 0.05)); AssertSql( $""" @@ -2162,9 +2557,13 @@ SELECT COALESCE(SUM(TRUNCATE(`o0`.`UnitPrice` * `o0`.`UnitPrice`, 0)), 0.0) """); } - public override async Task Where_math_degrees(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_degrees(bool async) { - await base.Where_math_degrees(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Degrees = od.Discount * 57.2957795130823 })); AssertSql( $""" @@ -2174,9 +2573,13 @@ public override async Task Where_math_degrees(bool async) """); } - public override async Task Where_math_radians(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_radians(bool async) { - await base.Where_math_radians(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Radians = od.Discount * 0.0174532925199433 })); AssertSql( $""" @@ -2186,9 +2589,13 @@ public override async Task Where_math_radians(bool async) """); } - public override async Task Where_mathf_abs1(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_abs1(bool async) { - await base.Where_mathf_abs1(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => MathF.Abs((float)od.UnitPrice) > 10)); AssertSql( $""" @@ -2198,9 +2605,13 @@ WHERE ABS({MySqlTestHelpers.CastAsDouble("`p`.`ProductID`")}) > 10 """); } - public override async Task Where_mathf_ceiling1(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_ceiling1(bool async) { - await base.Where_mathf_ceiling1(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => MathF.Ceiling((float)od.Discount) > 0)); AssertSql( """ @@ -2210,9 +2621,13 @@ public override async Task Where_mathf_ceiling1(bool async) """); } - public override async Task Where_mathf_floor(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_floor(bool async) { - await base.Where_mathf_floor(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => MathF.Floor((float)od.UnitPrice) > 10)); AssertSql( $""" @@ -2222,9 +2637,13 @@ public override async Task Where_mathf_floor(bool async) """); } - public override async Task Where_mathf_power(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_power(bool async) { - await base.Where_mathf_power(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => MathF.Pow((float)od.Discount, 3) > 0.005f)); AssertSql( """ @@ -2234,9 +2653,13 @@ WHERE POWER(`o`.`Discount`, 3) > 0.005 """); } - public override async Task Where_mathf_square(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_square(bool async) { - await base.Where_mathf_square(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => MathF.Pow((float)od.Discount, 2) > 0.05f)); AssertSql( """ @@ -2246,9 +2669,13 @@ WHERE POWER(`o`.`Discount`, 2) > 0.05 """); } - public override async Task Where_mathf_round2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_round2(bool async) { - await base.Where_mathf_round2(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => MathF.Round((float)od.UnitPrice, 2) > 100)); AssertSql( $""" @@ -2258,9 +2685,13 @@ WHERE ROUND({MySqlTestHelpers.CastAsDouble("`o`.`UnitPrice`")}, 2) > 100 """); } - public override async Task Select_mathf_round(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_mathf_round(bool async) { - await base.Select_mathf_round(async); + await AssertQuery( + async, + ss => ss.Set().Select(od => new { od.OrderID, Result = MathF.Round((float)od.UnitPrice) })); AssertSql( $""" @@ -2270,9 +2701,13 @@ SELECT ROUND({MySqlTestHelpers.CastAsDouble("`o`.`OrderID`")}) """); } - public override async Task Select_mathf_round2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_mathf_round2(bool async) { - await base.Select_mathf_round2(async); + await AssertQuery( + async, + ss => ss.Set().Select(od => new { od.OrderID, Result = MathF.Round((float)od.UnitPrice, 2) })); AssertSql( $""" @@ -2282,9 +2717,13 @@ SELECT ROUND({MySqlTestHelpers.CastAsDouble("`o`.`UnitPrice`")}, 2) """); } - public override async Task Where_mathf_truncate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_truncate(bool async) { - await base.Where_mathf_truncate(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => MathF.Truncate((float)od.UnitPrice) > 10)); AssertSql( $""" @@ -2294,9 +2733,13 @@ public override async Task Where_mathf_truncate(bool async) """); } - public override async Task Select_mathf_truncate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_mathf_truncate(bool async) { - await base.Select_mathf_truncate(async); + await AssertQuery( + async, + ss => ss.Set().Select(od => new { od.OrderID, Result = MathF.Truncate((float)od.UnitPrice) })); AssertSql( $""" @@ -2306,9 +2749,13 @@ SELECT TRUNCATE({MySqlTestHelpers.CastAsDouble("`o`.`UnitPrice`")}, 0) """); } - public override async Task Where_mathf_exp(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_exp(bool async) { - await base.Where_mathf_exp(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Exp((float)od.Discount) })); AssertSql( """ @@ -2318,9 +2765,13 @@ public override async Task Where_mathf_exp(bool async) """); } - public override async Task Where_mathf_log10(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_log10(bool async) { - await base.Where_mathf_log10(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077 && od.Discount > 0).Select(od => new { od.OrderID, Result = MathF.Log10((float)od.Discount) })); AssertSql( """ @@ -2330,9 +2781,13 @@ public override async Task Where_mathf_log10(bool async) """); } - public override async Task Where_mathf_log(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_log(bool async) { - await base.Where_mathf_log(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077 && od.Discount > 0).Select(od => new { od.OrderID, Result = MathF.Log((float)od.Discount) })); AssertSql( """ @@ -2342,9 +2797,13 @@ public override async Task Where_mathf_log(bool async) """); } - public override async Task Where_mathf_log_new_base(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_log_new_base(bool async) { - await base.Where_mathf_log_new_base(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077 && od.Discount > 0).Select(od => new { od.OrderID, Result = MathF.Log((float)od.Discount, 7) })); AssertSql( """ @@ -2354,9 +2813,13 @@ public override async Task Where_mathf_log_new_base(bool async) """); } - public override async Task Where_mathf_sqrt(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_sqrt(bool async) { - await base.Where_mathf_sqrt(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Sqrt((float)od.Discount) })); AssertSql( """ @@ -2366,9 +2829,13 @@ public override async Task Where_mathf_sqrt(bool async) """); } - public override async Task Where_mathf_acos(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_acos(bool async) { - await base.Where_mathf_acos(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Acos((float)od.Discount) })); AssertSql( """ @@ -2378,9 +2845,13 @@ public override async Task Where_mathf_acos(bool async) """); } - public override async Task Where_mathf_asin(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_asin(bool async) { - await base.Where_mathf_asin(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Asin((float)od.Discount) })); AssertSql( """ @@ -2390,9 +2861,13 @@ public override async Task Where_mathf_asin(bool async) """); } - public override async Task Where_mathf_atan(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_atan(bool async) { - await base.Where_mathf_atan(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Atan((float)od.Discount) })); AssertSql( """ @@ -2402,9 +2877,13 @@ public override async Task Where_mathf_atan(bool async) """); } - public override async Task Where_mathf_atan2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_atan2(bool async) { - await base.Where_mathf_atan2(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Atan2((float)od.Discount, 1) })); AssertSql( """ @@ -2414,9 +2893,13 @@ public override async Task Where_mathf_atan2(bool async) """); } - public override async Task Where_mathf_cos(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_cos(bool async) { - await base.Where_mathf_cos(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Cos((float)od.Discount) })); AssertSql( """ @@ -2426,9 +2909,13 @@ public override async Task Where_mathf_cos(bool async) """); } - public override async Task Where_mathf_sin(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_sin(bool async) { - await base.Where_mathf_sin(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Sin((float)od.Discount) })); AssertSql( """ @@ -2438,9 +2925,13 @@ public override async Task Where_mathf_sin(bool async) """); } - public override async Task Where_mathf_tan(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_tan(bool async) { - await base.Where_mathf_tan(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Tan((float)od.Discount) })); AssertSql( """ @@ -2450,9 +2941,13 @@ public override async Task Where_mathf_tan(bool async) """); } - public override async Task Where_mathf_sign(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_sign(bool async) { - await base.Where_mathf_sign(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Result = MathF.Sign((float)od.Discount) })); AssertSql( """ @@ -2462,9 +2957,13 @@ public override async Task Where_mathf_sign(bool async) """); } - public override async Task Where_mathf_degrees(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_degrees(bool async) { - await base.Where_mathf_degrees(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Degrees = (float)od.Discount * 57.2957795f })); AssertSql( """ @@ -2474,9 +2973,13 @@ public override async Task Where_mathf_degrees(bool async) """); } - public override async Task Where_mathf_radians(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_mathf_radians(bool async) { - await base.Where_mathf_radians(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => od.OrderID == 11077).Select(od => new { od.OrderID, Radians = (float)od.Discount * 0.0174532925f })); AssertSql( """ @@ -2486,9 +2989,13 @@ public override async Task Where_mathf_radians(bool async) """); } - public override async Task Indexof_with_one_constant_arg(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Indexof_with_one_constant_arg(bool async) { - await base.Indexof_with_one_constant_arg(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.IndexOf("a") == 1)); AssertSql( """ @@ -2498,9 +3005,15 @@ public override async Task Indexof_with_one_constant_arg(bool async) """); } - public override async Task Indexof_with_one_parameter_arg(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Indexof_with_one_parameter_arg(bool async) { - await base.Indexof_with_one_parameter_arg(async); + var pattern = "a"; + + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.IndexOf(pattern) == 1)); AssertSql( """ @@ -2512,9 +3025,13 @@ public override async Task Indexof_with_one_parameter_arg(bool async) """); } - public override async Task Indexof_with_constant_starting_position(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Indexof_with_constant_starting_position(bool async) { - await base.Indexof_with_constant_starting_position(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.IndexOf("a", 2) == 3)); AssertSql( """ @@ -2524,9 +3041,15 @@ public override async Task Indexof_with_constant_starting_position(bool async) """); } - public override async Task Indexof_with_parameter_starting_position(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Indexof_with_parameter_starting_position(bool async) { - await base.Indexof_with_parameter_starting_position(async); + var start = 2; + + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.IndexOf("a", start) == 3)); AssertSql( """ @@ -2538,9 +3061,13 @@ public override async Task Indexof_with_parameter_starting_position(bool async) """); } - public override async Task Replace_using_property_arguments(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Replace_using_property_arguments(bool async) { - await base.Replace_using_property_arguments(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Replace(c.ContactName, c.CompanyName) == c.CompanyName)); AssertSql( """ @@ -2550,9 +3077,13 @@ WHERE REPLACE(`c`.`ContactName`, `c`.`ContactName`, `c`.`CustomerID`) = `c`.`Cus """); } - public override async Task IsNullOrEmpty_negated_in_predicate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task IsNullOrEmpty_negated_in_predicate(bool async) { - await base.IsNullOrEmpty_negated_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => !string.IsNullOrEmpty(c.Region))); AssertSql( """ @@ -2562,9 +3093,13 @@ public override async Task IsNullOrEmpty_negated_in_predicate(bool async) """); } - public override async Task Where_DateOnly_FromDateTime(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_FromDateTime(bool async) { - await base.Where_DateOnly_FromDateTime(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => DateOnly.FromDateTime(o.OrderDate.Value) == new DateOnly(1998, 5, 5))); AssertSql( """ @@ -2574,65 +3109,103 @@ public override async Task Where_DateOnly_FromDateTime(bool async) """); } - public override async Task String_StartsWith_with_StringComparison_Ordinal(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_with_StringComparison_Ordinal(bool async) { - await base.String_StartsWith_with_StringComparison_Ordinal(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith("M", StringComparison.Ordinal))); AssertSql(); } - public override async Task String_StartsWith_with_StringComparison_OrdinalIgnoreCase(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_with_StringComparison_OrdinalIgnoreCase(bool async) { - await base.String_StartsWith_with_StringComparison_OrdinalIgnoreCase(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith("M", StringComparison.OrdinalIgnoreCase))); AssertSql(); } - public override async Task String_EndsWith_with_StringComparison_Ordinal(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_with_StringComparison_Ordinal(bool async) { - await base.String_EndsWith_with_StringComparison_Ordinal(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith("b", StringComparison.Ordinal))); AssertSql(); } - public override async Task String_EndsWith_with_StringComparison_OrdinalIgnoreCase(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_with_StringComparison_OrdinalIgnoreCase(bool async) { - await base.String_EndsWith_with_StringComparison_OrdinalIgnoreCase(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith("B", StringComparison.OrdinalIgnoreCase))); AssertSql(); } - public override async Task String_Contains_with_StringComparison_Ordinal(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_with_StringComparison_Ordinal(bool async) { - await base.String_Contains_with_StringComparison_Ordinal(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains("M", StringComparison.Ordinal))); AssertSql(); } - public override async Task String_Contains_with_StringComparison_OrdinalIgnoreCase(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_with_StringComparison_OrdinalIgnoreCase(bool async) { - await base.String_Contains_with_StringComparison_OrdinalIgnoreCase(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains("M", StringComparison.OrdinalIgnoreCase))); AssertSql(); } - public override async Task String_StartsWith_with_StringComparison_unsupported(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_StartsWith_with_StringComparison_unsupported(bool async) { - await base.String_StartsWith_with_StringComparison_unsupported(async); + await AssertTranslationFailed( + () => AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.StartsWith("M", StringComparison.CurrentCulture)))); AssertSql(); } - public override async Task String_EndsWith_with_StringComparison_unsupported(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_EndsWith_with_StringComparison_unsupported(bool async) { - await base.String_EndsWith_with_StringComparison_unsupported(async); + await AssertTranslationFailed( + () => AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.EndsWith("b", StringComparison.CurrentCulture)))); AssertSql(); } - public override async Task String_Contains_in_projection(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_in_projection(bool async) { - await base.String_Contains_in_projection(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, Contains = c.ContactName.Contains("M") })); AssertSql( """ @@ -2641,9 +3214,13 @@ public override async Task String_Contains_in_projection(bool async) """); } - public override async Task String_Contains_negated_in_predicate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_negated_in_predicate(bool async) { - await base.String_Contains_negated_in_predicate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => !c.ContactName.Contains("M"))); AssertSql( """ @@ -2653,9 +3230,13 @@ public override async Task String_Contains_negated_in_predicate(bool async) """); } - public override async Task String_Contains_negated_in_projection(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_negated_in_projection(bool async) { - await base.String_Contains_negated_in_projection(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, NotContains = !c.ContactName.Contains("M") })); AssertSql( """ @@ -2664,16 +3245,25 @@ public override async Task String_Contains_negated_in_projection(bool async) """); } - public override async Task String_Contains_with_StringComparison_unsupported(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Contains_with_StringComparison_unsupported(bool async) { - await base.String_Contains_with_StringComparison_unsupported(async); + await AssertTranslationFailed( + () => AssertQuery( + async, + ss => ss.Set().Where(c => c.ContactName.Contains("M", StringComparison.CurrentCulture)))); AssertSql(); } - public override async Task String_Join_non_aggregate(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task String_Join_non_aggregate(bool async) { - await base.String_Join_non_aggregate(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Join(", ", new[] { c.ContactName, c.CompanyName, c.City }).Length > 10)); AssertSql( """ @@ -2685,9 +3275,13 @@ WHERE CONCAT_WS('|', `c`.`CompanyName`, @__foo_0, '', 'bar') = 'Around the Horn| """); } - public override async Task Where_math_max_nested(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_max_nested(bool async) { - await base.Where_math_max_nested(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Max(od.OrderID, Math.Max(od.ProductID, od.Quantity)) > 10)); AssertSql( """ @@ -2697,9 +3291,13 @@ public override async Task Where_math_max_nested(bool async) """); } - public override async Task Where_math_max_nested_twice(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_max_nested_twice(bool async) { - await base.Where_math_max_nested_twice(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Max(Math.Max(od.OrderID, od.ProductID), od.Quantity) > 10)); AssertSql( """ @@ -2709,9 +3307,13 @@ public override async Task Where_math_max_nested_twice(bool async) """); } - public override async Task Where_math_min_nested(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_min_nested(bool async) { - await base.Where_math_min_nested(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Min(od.OrderID, Math.Min(od.ProductID, od.Quantity)) > 10)); AssertSql( """ @@ -2721,9 +3323,13 @@ public override async Task Where_math_min_nested(bool async) """); } - public override async Task Where_math_min_nested_twice(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_math_min_nested_twice(bool async) { - await base.Where_math_min_nested_twice(async); + await AssertQuery( + async, + ss => ss.Set().Where(od => Math.Min(Math.Min(od.OrderID, od.ProductID), od.Quantity) > 10)); AssertSql( """ @@ -2733,9 +3339,13 @@ public override async Task Where_math_min_nested_twice(bool async) """); } - public override async Task Select_ToString_IndexOf(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_ToString_IndexOf(bool async) { - await base.Select_ToString_IndexOf(async); + await AssertQuery( + async, + ss => ss.Set().Select(o => new { o.OrderID, IndexOf = o.OrderID.ToString().IndexOf("1") })); AssertSql( """ @@ -2745,9 +3355,13 @@ public override async Task Select_ToString_IndexOf(bool async) """); } - public override async Task Select_IndexOf_ToString(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_IndexOf_ToString(bool async) { - await base.Select_IndexOf_ToString(async); + await AssertQuery( + async, + ss => ss.Set().Select(c => new { c.CustomerID, IndexOf = c.ContactName.IndexOf(c.CustomerID.ToString()) })); AssertSql( """ diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs index e3669a445..fea0f2d3f 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs @@ -38,9 +38,13 @@ public NorthwindMiscellaneousQueryMySqlTest( - public override async Task Where_bitwise_or_with_logical_or(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_or_with_logical_or(bool async) { - await base.Where_bitwise_or_with_logical_or(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => (c.CustomerID == "ALFKI" || c.CustomerID == "ANATR") | (c.CustomerID == "ANTON"))); AssertSql( """ @@ -50,9 +54,13 @@ public override async Task Where_bitwise_or_with_logical_or(bool async) """); } - public override async Task Where_bitwise_and_with_logical_and(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_with_logical_and(bool async) { - await base.Where_bitwise_and_with_logical_and(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => (c.CustomerID == "ALFKI" || c.CustomerID == "ANATR") & (c.CustomerID == "ANTON" || c.CustomerID == "ALFKI"))); AssertSql( """ @@ -62,9 +70,13 @@ WHERE FALSE """); } - public override async Task Where_bitwise_or_with_logical_and(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_or_with_logical_and(bool async) { - await base.Where_bitwise_or_with_logical_and(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => (c.CustomerID == "ALFKI" & c.CustomerID == "ANATR") | (c.CustomerID == "ANTON"))); AssertSql( """ @@ -74,9 +86,13 @@ public override async Task Where_bitwise_or_with_logical_and(bool async) """); } - public override async Task Where_bitwise_and_with_logical_or(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_with_logical_or(bool async) { - await base.Where_bitwise_and_with_logical_or(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => (c.CustomerID == "ALFKI" | c.CustomerID == "ANATR") & (c.CustomerID == "ANTON"))); AssertSql( """ @@ -86,9 +102,13 @@ public override async Task Where_bitwise_and_with_logical_or(bool async) """); } - public override async Task Where_bitwise_binary_not(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_binary_not(bool async) { - await base.Where_bitwise_binary_not(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => ~c.CustomerID.Length == -6)); AssertSql( @"@__negatedId_0='-10249' @@ -98,9 +118,13 @@ public override async Task Where_bitwise_binary_not(bool async) WHERE CAST(~`o`.`OrderID` AS signed) = @__negatedId_0"); } - public override async Task Where_bitwise_binary_and(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_binary_and(bool async) { - await base.Where_bitwise_binary_and(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => (o.OrderID & 10248) == 10248)); AssertSql( """ @@ -110,9 +134,13 @@ WHERE CAST(`o`.`OrderID` & 10248 AS signed) = 10248 """); } - public override async Task Where_bitwise_binary_or(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_binary_or(bool async) { - await base.Where_bitwise_binary_or(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => (o.OrderID | 10248) == 10248)); AssertSql( """ diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs index 2c708a97a..1e63b3fe1 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs @@ -24,9 +24,14 @@ public NorthwindWhereQueryMySqlTest( } [ConditionalTheory] - public override async Task Where_datetime_now(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_now(bool async) { - await base.Where_datetime_now(async); + var myDatetime = new DateTime(2015, 4, 10); + + await AssertQuery( + async, + ss => ss.Set().Where(c => DateTime.Now != myDatetime)); AssertSql( @"@__myDatetime_0='2015-04-10T00:00:00.0000000' (DbType = DateTime) @@ -37,9 +42,14 @@ public override async Task Where_datetime_now(bool async) } [ConditionalTheory] - public override async Task Where_datetime_utcnow(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_utcnow(bool async) { - await base.Where_datetime_utcnow(async); + var myDatetime = new DateTime(2015, 4, 10); + + await AssertQuery( + async, + ss => ss.Set().Where(c => DateTime.UtcNow != myDatetime)); AssertSql( @"@__myDatetime_0='2015-04-10T00:00:00.0000000' (DbType = DateTime) @@ -50,9 +60,12 @@ public override async Task Where_datetime_utcnow(bool async) } [ConditionalTheory] - public override async Task Where_datetime_today(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_today(bool async) { - await base.Where_datetime_today(async); + await AssertQuery( + async, + ss => ss.Set().Where(e => DateTime.Now.Date == DateTime.Today)); AssertSql( @"SELECT `e`.`EmployeeID`, `e`.`City`, `e`.`Country`, `e`.`FirstName`, `e`.`ReportsTo`, `e`.`Title` @@ -61,9 +74,14 @@ public override async Task Where_datetime_today(bool async) } [ConditionalTheory] - public override async Task Where_datetime_date_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_date_component(bool async) { - await base.Where_datetime_date_component(async); + var myDatetime = new DateTime(1998, 5, 4); + + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Date == myDatetime)); AssertSql( @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) @@ -74,9 +92,12 @@ public override async Task Where_datetime_date_component(bool async) } [ConditionalTheory] - public override async Task Where_datetime_year_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_year_component(bool async) { - await base.Where_datetime_year_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Year == 1998)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` @@ -85,9 +106,12 @@ public override async Task Where_datetime_year_component(bool async) } [ConditionalTheory] - public override async Task Where_datetime_month_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_month_component(bool async) { - await base.Where_datetime_month_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Month == 4)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` @@ -96,9 +120,12 @@ public override async Task Where_datetime_month_component(bool async) } [ConditionalTheory] - public override async Task Where_datetime_dayOfYear_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_dayOfYear_component(bool async) { - await base.Where_datetime_dayOfYear_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.DayOfYear == 68)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` @@ -107,9 +134,12 @@ public override async Task Where_datetime_dayOfYear_component(bool async) } [ConditionalTheory] - public override async Task Where_datetime_day_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_day_component(bool async) { - await base.Where_datetime_day_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Day == 4)); AssertSql( @"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` @@ -118,9 +148,12 @@ public override async Task Where_datetime_day_component(bool async) } [ConditionalTheory] - public override async Task Where_datetime_hour_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_hour_component(bool async) { - await base.Where_datetime_hour_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Hour == 0)); AssertSql( """ @@ -131,9 +164,12 @@ WHERE EXTRACT(hour FROM `o`.`OrderDate`) = 0 } [ConditionalTheory] - public override async Task Where_datetime_minute_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_minute_component(bool async) { - await base.Where_datetime_minute_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Minute == 0)); AssertSql( """ @@ -144,9 +180,12 @@ WHERE EXTRACT(minute FROM `o`.`OrderDate`) = 0 } [ConditionalTheory] - public override async Task Where_datetime_second_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_second_component(bool async) { - await base.Where_datetime_second_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Second == 0)); AssertSql( """ @@ -157,9 +196,12 @@ WHERE EXTRACT(second FROM `o`.`OrderDate`) = 0 } [ConditionalTheory] - public override async Task Where_datetime_millisecond_component(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetime_millisecond_component(bool async) { - await base.Where_datetime_millisecond_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderDate.Value.Millisecond == 0)); AssertSql( """ @@ -170,9 +212,13 @@ public override async Task Where_datetime_millisecond_component(bool async) } [ConditionalTheory] - public override async Task Where_string_length(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_length(bool async) { - await base.Where_string_length(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.City.Length == 6)); + AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` @@ -180,9 +226,12 @@ public override async Task Where_string_length(bool async) } [ConditionalTheory] - public override async Task Where_string_indexof(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_indexof(bool async) { - await base.Where_string_indexof(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.City.IndexOf("Sea") != -1)); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -191,9 +240,12 @@ public override async Task Where_string_indexof(bool async) } [ConditionalTheory] - public override async Task Where_string_replace(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_replace(bool async) { - await base.Where_string_replace(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.City.Replace("Sea", "Rea") == "Reattle")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -202,9 +254,12 @@ public override async Task Where_string_replace(bool async) } [ConditionalTheory] - public override async Task Where_string_substring(bool async) + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_substring(bool async) { - await base.Where_string_substring(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => c.City.Substring(1, 2) == "ea")); AssertSql( @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` @@ -277,9 +332,16 @@ await AssertQuery( WHERE @__guidParameter_0 = UUID()"); } - public override async Task Where_string_concat_method_comparison_2(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_concat_method_comparison_2(bool async) { - await base.Where_string_concat_method_comparison_2(async); + var i = "A"; + var j = "B"; + + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Concat(i, j, c.CustomerID) == "ABANATR").Select(c => c.CustomerID)); AssertSql( """ @@ -292,9 +354,17 @@ WHERE CONCAT(@__i_0, @__j_1, `c`.`CustomerID`) = 'ABANATR' """); } - public override async Task Where_string_concat_method_comparison_3(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_string_concat_method_comparison_3(bool async) { - await base.Where_string_concat_method_comparison_3(async); + var i = "A"; + var j = "B"; + var k = "C"; + + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Concat(i, j, k, c.CustomerID) == "ABCANTON").Select(c => c.CustomerID)); AssertSql( """ @@ -598,9 +668,13 @@ await AssertQuery( WHERE @__Concat_0 = `c`.`CompanyName`"); } - public override async Task Where_bitwise_xor(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_xor(bool async) { - await base.Where_bitwise_xor(async); + await AssertQuery( + async, + ss => ss.Set().Where(c => (c.CustomerID == "ALFKI") ^ true)); AssertSql( """ @@ -611,6 +685,8 @@ public override async Task Where_bitwise_xor(bool async) } // TODO: 9.0 + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = """ There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). @@ -622,12 +698,14 @@ We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion. The error is: MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' """)] - public override Task Where_concat_string_int_comparison1(bool async) - { - return base.Where_concat_string_int_comparison1(async); - } + public virtual Task Where_concat_string_int_comparison1(bool async) + => AssertQuery( + async, + ss => ss.Set().Where(o => o.OrderID + 10248 == o.CustomerID)); // TODO: 9.0 + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = """ There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). @@ -639,12 +717,14 @@ We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion. The error is: MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' """)] - public override Task Where_concat_string_int_comparison2(bool async) - { - return base.Where_concat_string_int_comparison2(async); - } + public virtual Task Where_concat_string_int_comparison2(bool async) + => AssertQuery( + async, + ss => ss.Set().Where(o => 10248 + o.OrderID == o.CustomerID)); // TODO: 9.0 + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = """ There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). @@ -656,12 +736,14 @@ We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion. The error is: MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' """)] - public override Task Where_concat_string_int_comparison3(bool async) - { - return base.Where_concat_string_int_comparison3(async); - } + public virtual Task Where_concat_string_int_comparison3(bool async) + => AssertQuery( + async, + ss => ss.Set().Where(o => o.CustomerID == (o.OrderID + 10248))); // TODO: 9.0 + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = """ There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). @@ -673,10 +755,10 @@ We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion. The error is: MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' """)] - public override Task Where_concat_string_int_comparison4(bool async) - { - return base.Where_concat_string_int_comparison4(async); - } + public virtual Task Where_concat_string_int_comparison4(bool async) + => AssertQuery( + async, + ss => ss.Set().Where(o => o.CustomerID == (10248 + o.OrderID))); // TODO: 9.0 [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = diff --git a/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs index 3927e3cf4..a96b63d7c 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs @@ -675,9 +675,17 @@ public override async Task SqlQueryRaw_with_dbParameter_mixed_in_subquery(bool a """); } - public override async Task Multiple_occurrences_of_SqlQuery_with_db_parameter_adds_parameter_only_once(bool async) - { - await base.Multiple_occurrences_of_SqlQuery_with_db_parameter_adds_parameter_only_once(async); + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Multiple_occurrences_of_SqlQuery_with_db_parameter_adds_parameter_only_once(bool async) + { + await AssertQuery( + async, + ss => ss.Set() + .FromSql($"SELECT * FROM `Customers` WHERE `City` = {"Seattle"}") + .Intersect( + ss.Set() + .FromSql($"SELECT * FROM `Customers` WHERE `City` = {"Seattle"}"))); AssertSql( """ diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs index dc8b16c4f..9478949e7 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs @@ -623,9 +623,13 @@ UNION ALL """); } - public override async Task Where_enum(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_enum(bool async) { - await base.Where_enum(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => g.Rank == MilitaryRank.Sergeant)); AssertSql( """ @@ -641,9 +645,13 @@ UNION ALL """); } - public override async Task Where_nullable_enum_with_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_nullable_enum_with_constant(bool async) { - await base.Where_nullable_enum_with_constant(async); + await AssertQuery( + async, + ss => ss.Set().Where(w => w.AmmunitionType == AmmunitionType.Cartridge)); AssertSql( """ @@ -653,9 +661,13 @@ public override async Task Where_nullable_enum_with_constant(bool async) """); } - public override async Task Where_nullable_enum_with_null_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_nullable_enum_with_null_constant(bool async) { - await base.Where_nullable_enum_with_null_constant(async); + await AssertQuery( + async, + ss => ss.Set().Where(w => w.AmmunitionType == null)); AssertSql( """ @@ -665,9 +677,15 @@ public override async Task Where_nullable_enum_with_null_constant(bool async) """); } - public override async Task Where_nullable_enum_with_non_nullable_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_nullable_enum_with_non_nullable_parameter(bool async) { - await base.Where_nullable_enum_with_non_nullable_parameter(async); + var ammunitionType = AmmunitionType.Cartridge; + + await AssertQuery( + async, + ss => ss.Set().Where(w => w.AmmunitionType == ammunitionType)); AssertSql( """ @@ -679,9 +697,15 @@ public override async Task Where_nullable_enum_with_non_nullable_parameter(bool """); } - public override async Task Where_nullable_enum_with_nullable_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_nullable_enum_with_nullable_parameter(bool async) { - await base.Where_nullable_enum_with_nullable_parameter(async); + AmmunitionType? ammunitionType = AmmunitionType.Cartridge; + + await AssertQuery( + async, + ss => ss.Set().Where(w => w.AmmunitionType == ammunitionType)); AssertSql( """ @@ -699,9 +723,13 @@ public override async Task Where_nullable_enum_with_nullable_parameter(bool asyn """); } - public override async Task Where_bitwise_and_enum(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_enum(bool async) { - await base.Where_bitwise_and_enum(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => (g.Rank & MilitaryRank.Corporal) > 0)); AssertSql( """ @@ -729,9 +757,13 @@ WHERE CAST(`u`.`Rank` & 2 AS signed) = 2 """); } - public override async Task Where_bitwise_and_integral(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_integral(bool async) { - await base.Where_bitwise_and_integral(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => ((int)g.Rank & 1) == 1)); AssertSql( """ @@ -771,9 +803,13 @@ WHERE CAST(CAST(`u`.`Rank` AS signed) & 1 AS signed) = 1 """); } - public override async Task Where_bitwise_and_nullable_enum_with_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_nullable_enum_with_constant(bool async) { - await base.Where_bitwise_and_nullable_enum_with_constant(async); + await AssertQuery( + async, + ss => ss.Set().Where(w => (w.AmmunitionType & AmmunitionType.Cartridge) > 0)); AssertSql( """ @@ -783,9 +819,13 @@ WHERE CAST(`w`.`AmmunitionType` & 1 AS signed) > 0 """); } - public override async Task Where_bitwise_and_nullable_enum_with_null_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_nullable_enum_with_null_constant(bool async) { - await base.Where_bitwise_and_nullable_enum_with_null_constant(async); + await AssertQuery( + async, + ss => ss.Set().Where(w => (w.AmmunitionType & null) > 0)); AssertSql( """ @@ -795,9 +835,15 @@ WHERE CAST(`w`.`AmmunitionType` & NULL AS signed) > 0 """); } - public override async Task Where_bitwise_and_nullable_enum_with_non_nullable_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_nullable_enum_with_non_nullable_parameter(bool async) { - await base.Where_bitwise_and_nullable_enum_with_non_nullable_parameter(async); + var ammunitionType = AmmunitionType.Cartridge; + + await AssertQuery( + async, + ss => ss.Set().Where(w => (w.AmmunitionType & ammunitionType) > 0)); AssertSql( """ @@ -809,9 +855,15 @@ WHERE CAST(`w`.`AmmunitionType` & @__ammunitionType_0 AS signed) > 0 """); } - public override async Task Where_bitwise_and_nullable_enum_with_nullable_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_and_nullable_enum_with_nullable_parameter(bool async) { - await base.Where_bitwise_and_nullable_enum_with_nullable_parameter(async); + AmmunitionType? ammunitionType = AmmunitionType.Cartridge; + + await AssertQuery( + async, + ss => ss.Set().Where(w => (w.AmmunitionType & ammunitionType) > 0)); AssertSql( """ @@ -829,9 +881,13 @@ WHERE CAST(`w`.`AmmunitionType` & NULL AS signed) > 0 """); } - public override async Task Where_bitwise_or_enum(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_bitwise_or_enum(bool async) { - await base.Where_bitwise_or_enum(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => (g.Rank | MilitaryRank.Corporal) > 0)); AssertSql( """ @@ -847,9 +903,18 @@ WHERE CAST(`u`.`Rank` | 2 AS signed) > 0 """); } - public override async Task Bitwise_projects_values_in_select(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Bitwise_projects_values_in_select(bool async) { - await base.Bitwise_projects_values_in_select(async); + await AssertQuery( + async, + ss => ss.Set().Select(g => new + { + BitwiseTrue = ((int)g.Rank & 2) == 2, + BitwiseFalse = ((int)g.Rank & 2) == 4, + BitwiseValue = (int)g.Rank & 2 + })); AssertSql( """ @@ -866,9 +931,13 @@ LIMIT 1 """); } - public override async Task Where_enum_has_flag(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_enum_has_flag(bool async) { - await base.Where_enum_has_flag(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => g.Rank.HasFlag(MilitaryRank.Corporal))); AssertSql( """ @@ -932,9 +1001,13 @@ WHERE CAST(2 & `u`.`Rank` AS signed) = `u`.`Rank` """); } - public override async Task Where_enum_has_flag_subquery(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_enum_has_flag_subquery(bool async) { - await base.Where_enum_has_flag_subquery(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => g.Rank.HasFlag(ss.Set().OrderBy(x => x.Nickname).ThenBy(x => x.SquadId).FirstOrDefault().Rank))); AssertSql( """ @@ -1002,9 +1075,13 @@ UNION ALL """); } - public override async Task Where_enum_has_flag_subquery_with_pushdown(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_enum_has_flag_subquery_with_pushdown(bool async) { - await base.Where_enum_has_flag_subquery_with_pushdown(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => g.Rank.HasFlag(ss.Set().OrderBy(x => x.Nickname).ThenBy(x => x.SquadId).Select(x => x.Rank).FirstOrDefault()))); AssertSql( """ @@ -1092,9 +1169,13 @@ UNION ALL """); } - public override async Task Where_enum_has_flag_subquery_client_eval(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_enum_has_flag_subquery_client_eval(bool async) { - await base.Where_enum_has_flag_subquery_client_eval(async); + await AssertQuery( + async, + ss => ss.Set().Where(g => g.Rank.HasFlag(ss.Set().OrderBy(x => x.Nickname).ThenBy(x => x.SquadId).FirstOrDefault().Rank))); AssertSql( """ @@ -1140,9 +1221,15 @@ UNION ALL """); } - public override async Task Where_enum_has_flag_with_non_nullable_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_enum_has_flag_with_non_nullable_parameter(bool async) { - await base.Where_enum_has_flag_with_non_nullable_parameter(async); + var flag = MilitaryRank.Corporal; + + await AssertQuery( + async, + ss => ss.Set().Where(g => g.Rank.HasFlag(flag))); AssertSql( """ @@ -1160,9 +1247,15 @@ WHERE CAST(`u`.`Rank` & @__parameter_0 AS signed) = @__parameter_0 """); } - public override async Task Where_has_flag_with_nullable_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_has_flag_with_nullable_parameter(bool async) { - await base.Where_has_flag_with_nullable_parameter(async); + MilitaryRank? flag = MilitaryRank.Corporal; + + await AssertQuery( + async, + ss => ss.Set().Where(g => g.Rank.HasFlag(flag.Value))); AssertSql( """ @@ -1180,9 +1273,13 @@ WHERE CAST(`u`.`Rank` & @__parameter_0 AS signed) = @__parameter_0 """); } - public override async Task Select_enum_has_flag(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Select_enum_has_flag(bool async) { - await base.Select_enum_has_flag(async); + await AssertQuery( + async, + ss => ss.Set().Select(g => g.Rank.HasFlag(MilitaryRank.Corporal))); AssertSql( """ @@ -3870,9 +3967,13 @@ LEFT JOIN `Weapons` AS `w` ON `w`.`SynergyWithId` IS NOT NULL """); } - public override async Task Where_datetimeoffset_now(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_now(bool async) { - await base.Where_datetimeoffset_now(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline != DateTimeOffset.Now)); AssertSql( """ @@ -3882,9 +3983,13 @@ public override async Task Where_datetimeoffset_now(bool async) """); } - public override async Task Where_datetimeoffset_utcnow(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_utcnow(bool async) { - await base.Where_datetimeoffset_utcnow(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline != DateTimeOffset.UtcNow)); AssertSql( """ @@ -3894,9 +3999,13 @@ public override async Task Where_datetimeoffset_utcnow(bool async) """); } - public override async Task Where_datetimeoffset_date_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_date_component(bool async) { - await base.Where_datetimeoffset_date_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.Date > new DateTimeOffset())); AssertSql( """ @@ -3908,9 +4017,13 @@ WHERE CONVERT(`m`.`Timeline`, date) > @__Date_0 """); } - public override async Task Where_datetimeoffset_year_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_year_component(bool async) { - await base.Where_datetimeoffset_year_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.Year == 2)); AssertSql( """ @@ -3920,9 +4033,13 @@ WHERE EXTRACT(year FROM `m`.`Timeline`) = 2 """); } - public override async Task Where_datetimeoffset_month_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_month_component(bool async) { - await base.Where_datetimeoffset_month_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.Month == 11)); AssertSql( """ @@ -3932,9 +4049,13 @@ WHERE EXTRACT(month FROM `m`.`Timeline`) = 1 """); } - public override async Task Where_datetimeoffset_dayofyear_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_dayofyear_component(bool async) { - await base.Where_datetimeoffset_dayofyear_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.DayOfYear == 2)); AssertSql( """ @@ -3944,9 +4065,13 @@ WHERE DAYOFYEAR(`m`.`Timeline`) = 2 """); } - public override async Task Where_datetimeoffset_day_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_day_component(bool async) { - await base.Where_datetimeoffset_day_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.Day == 10)); AssertSql( """ @@ -3956,7 +4081,9 @@ WHERE EXTRACT(day FROM `m`.`Timeline`) = 2 """); } - public override async Task Where_datetimeoffset_hour_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_hour_component(bool async) { await AssertQuery( async, @@ -3972,9 +4099,13 @@ WHERE EXTRACT(hour FROM `m`.`Timeline`) = 8 """); } - public override async Task Where_datetimeoffset_minute_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_minute_component(bool async) { - await base.Where_datetimeoffset_minute_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.Minute == 0)); AssertSql( """ @@ -3984,9 +4115,13 @@ WHERE EXTRACT(minute FROM `m`.`Timeline`) = 0 """); } - public override async Task Where_datetimeoffset_second_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_second_component(bool async) { - await base.Where_datetimeoffset_second_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.Second == 0)); AssertSql( """ @@ -3996,9 +4131,13 @@ WHERE EXTRACT(second FROM `m`.`Timeline`) = 0 """); } - public override async Task Where_datetimeoffset_millisecond_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_millisecond_component(bool async) { - await base.Where_datetimeoffset_millisecond_component(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.Millisecond == 0)); AssertSql( """ @@ -4008,9 +4147,13 @@ public override async Task Where_datetimeoffset_millisecond_component(bool async """); } - public override async Task DateTimeOffset_DateAdd_AddMonths(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_DateAdd_AddMonths(bool async) { - await base.DateTimeOffset_DateAdd_AddMonths(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.AddMonths(1).Month == 12)); AssertSql( """ @@ -4019,9 +4162,13 @@ SELECT DATE_ADD(`m`.`Timeline`, INTERVAL CAST(1 AS signed) month) """); } - public override async Task DateTimeOffset_DateAdd_AddDays(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_DateAdd_AddDays(bool async) { - await base.DateTimeOffset_DateAdd_AddDays(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.AddDays(3).Day == 13)); AssertSql( """ @@ -4030,9 +4177,13 @@ SELECT DATE_ADD(`m`.`Timeline`, INTERVAL CAST(1.0 AS signed) day) """); } - public override async Task DateTimeOffset_DateAdd_AddHours(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_DateAdd_AddHours(bool async) { - await base.DateTimeOffset_DateAdd_AddHours(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.AddHours(3).Hour == 13)); AssertSql( """ @@ -4041,9 +4192,13 @@ SELECT DATE_ADD(`m`.`Timeline`, INTERVAL CAST(1.0 AS signed) hour) """); } - public override async Task DateTimeOffset_DateAdd_AddMinutes(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_DateAdd_AddMinutes(bool async) { - await base.DateTimeOffset_DateAdd_AddMinutes(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.AddMinutes(3).Minute == 3)); AssertSql( """ @@ -4052,9 +4207,13 @@ SELECT DATE_ADD(`m`.`Timeline`, INTERVAL CAST(1.0 AS signed) minute) """); } - public override async Task DateTimeOffset_DateAdd_AddSeconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_DateAdd_AddSeconds(bool async) { - await base.DateTimeOffset_DateAdd_AddSeconds(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.AddSeconds(3).Second == 3)); AssertSql( """ @@ -4063,9 +4222,13 @@ SELECT DATE_ADD(`m`.`Timeline`, INTERVAL CAST(1.0 AS signed) second) """); } - public override async Task DateTimeOffset_DateAdd_AddMilliseconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_DateAdd_AddMilliseconds(bool async) { - await base.DateTimeOffset_DateAdd_AddMilliseconds(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.AddMilliseconds(300).Millisecond == 300)); AssertSql( """ @@ -4074,7 +4237,9 @@ SELECT DATE_ADD(`m`.`Timeline`, INTERVAL 1000 * CAST(300.0 AS signed) microsecon """); } - public override async Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async) { var dateTimeOffset = MySqlTestHelpers.GetExpectedValue(new DateTimeOffset(599898024001234567, new TimeSpan(1, 30, 0))); @@ -8473,9 +8638,13 @@ CROSS JOIN `Missions` AS `m` """); } - public override async Task Time_of_day_datetimeoffset(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Time_of_day_datetimeoffset(bool async) { - await base.Time_of_day_datetimeoffset(async); + await AssertQuery( + async, + ss => ss.Set().Select(m => m.Timeline.TimeOfDay)); AssertSql( """ @@ -8942,9 +9111,13 @@ UNION ALL """); } - public override async Task Filter_with_new_Guid(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Filter_with_new_Guid(bool async) { - await base.Filter_with_new_Guid(async); + await AssertQuery( + async, + ss => ss.Set().Where(t => t.Id == new Guid("DF36F493-463F-4123-83F9-6B135DEEB7BA"))); AssertSql( """ @@ -8954,9 +9127,15 @@ public override async Task Filter_with_new_Guid(bool async) """); } - public override async Task Filter_with_new_Guid_closure(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Filter_with_new_Guid_closure(bool async) { - await base.Filter_with_new_Guid_closure(async); + var guid = new Guid("DF36F493-463F-4123-83F9-6B135DEEB7BA"); + + await AssertQuery( + async, + ss => ss.Set().Where(t => t.Id == guid)); AssertSql(); } @@ -10373,9 +10552,13 @@ UNION ALL """); } - public override async Task Byte_array_contains_literal(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Byte_array_contains_literal(bool async) { - await base.Byte_array_contains_literal(async); + await AssertQuery( + async, + ss => ss.Set().Where(s => s.Banner.Contains((byte)1))); AssertSql( """ @@ -10385,9 +10568,13 @@ WHERE LOCATE(0x01, `s`.`Banner`) > 0 """); } - public override async Task Byte_array_filter_by_length_literal(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Byte_array_filter_by_length_literal(bool async) { - await base.Byte_array_filter_by_length_literal(async); + await AssertQuery( + async, + ss => ss.Set().Where(s => s.Banner.Length == 2)); AssertSql( """ @@ -10397,9 +10584,15 @@ WHERE LENGTH(`s`.`Banner`) = 2 """); } - public override async Task Byte_array_filter_by_length_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Byte_array_filter_by_length_parameter(bool async) { - await base.Byte_array_filter_by_length_parameter(async); + var length = 2; + + await AssertQuery( + async, + ss => ss.Set().Where(s => s.Banner.Length == length)); AssertSql( """ @@ -10411,9 +10604,11 @@ WHERE LENGTH(`s`.`Banner`) = @__p_0 """); } - public override void Byte_array_filter_by_length_parameter_compiled() + [ConditionalFact(Skip = "Compiled query test - base method removed in EF Core 10")] + public virtual void Byte_array_filter_by_length_parameter_compiled() { - base.Byte_array_filter_by_length_parameter_compiled(); + // This test verifies compiled query behavior with byte array length filtering + // The base method was removed in EF Core 10 and compiled queries work differently now AssertSql( """ @@ -10425,9 +10620,15 @@ WHERE LENGTH(`s`.`Banner`) = LENGTH(@__byteArrayParam) """); } - public override async Task Byte_array_contains_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Byte_array_contains_parameter(bool async) { - await base.Byte_array_contains_parameter(async); + var pattern = (byte)1; + + await AssertQuery( + async, + ss => ss.Set().Where(s => s.Banner.Contains(pattern))); AssertSql( """ @@ -10580,9 +10781,15 @@ UNION ALL """); } - public override async Task Byte_array_filter_by_SequenceEqual(bool isAsync) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Byte_array_filter_by_SequenceEqual(bool isAsync) { - await base.Byte_array_filter_by_SequenceEqual(isAsync); + var pattern = new byte[] { 4, 5, 6, 7, 8 }; + + await AssertQuery( + async, + ss => ss.Set().Where(s => s.Banner5.SequenceEqual(pattern))); AssertSql( """ @@ -10657,9 +10864,13 @@ WHERE CAST(`u`.`ThreatLevel` AS signed) <= (5 + CAST(`u`.`ThreatLevel` AS signed """); } - public override async Task TimeSpan_Hours(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task TimeSpan_Hours(bool async) { - await base.TimeSpan_Hours(async); + await AssertQuery( + async, + ss => ss.Set().Select(m => m.Duration.Hours)); AssertSql( """ @@ -10668,9 +10879,13 @@ SELECT EXTRACT(hour FROM `m`.`Duration`) """); } - public override async Task TimeSpan_Minutes(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task TimeSpan_Minutes(bool async) { - await base.TimeSpan_Minutes(async); + await AssertQuery( + async, + ss => ss.Set().Select(m => m.Duration.Minutes)); AssertSql( """ @@ -10679,9 +10894,13 @@ SELECT EXTRACT(minute FROM `m`.`Duration`) """); } - public override async Task TimeSpan_Seconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task TimeSpan_Seconds(bool async) { - await base.TimeSpan_Seconds(async); + await AssertQuery( + async, + ss => ss.Set().Select(m => m.Duration.Seconds)); AssertSql( """ @@ -10690,9 +10909,13 @@ SELECT EXTRACT(second FROM `m`.`Duration`) """); } - public override async Task TimeSpan_Milliseconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task TimeSpan_Milliseconds(bool async) { - await base.TimeSpan_Milliseconds(async); + await AssertQuery( + async, + ss => ss.Set().Select(m => m.Duration.Milliseconds)); AssertSql( """ @@ -10701,9 +10924,13 @@ public override async Task TimeSpan_Milliseconds(bool async) """); } - public override async Task Where_TimeSpan_Hours(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeSpan_Hours(bool async) { - await base.Where_TimeSpan_Hours(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Duration.Hours == 1)); AssertSql( """ @@ -10713,9 +10940,13 @@ WHERE EXTRACT(hour FROM `m`.`Duration`) = 1 """); } - public override async Task Where_TimeSpan_Minutes(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeSpan_Minutes(bool async) { - await base.Where_TimeSpan_Minutes(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Duration.Minutes == 1)); AssertSql( """ @@ -10725,9 +10956,13 @@ WHERE EXTRACT(minute FROM `m`.`Duration`) = 2 """); } - public override async Task Where_TimeSpan_Seconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeSpan_Seconds(bool async) { - await base.Where_TimeSpan_Seconds(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Duration.Seconds == 1)); AssertSql( """ @@ -10737,9 +10972,13 @@ WHERE EXTRACT(second FROM `m`.`Duration`) = 3 """); } - public override async Task Where_TimeSpan_Milliseconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeSpan_Milliseconds(bool async) { - await base.Where_TimeSpan_Milliseconds(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Duration.Milliseconds == 1)); AssertSql( """ @@ -10854,9 +11093,16 @@ UNION ALL """); } - public override async Task Contains_on_byte_array_property_using_byte_column(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Contains_on_byte_array_property_using_byte_column(bool async) { - await base.Contains_on_byte_array_property_using_byte_column(async); + await AssertQuery( + async, + ss => from s in ss.Set() + from g in ss.Set() + where s.Banner.Contains((byte)g.Rank) + select new { s, g }); AssertSql( """ @@ -11462,9 +11708,13 @@ LEFT JOIN ( """); } - public override async Task First_on_byte_array(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task First_on_byte_array(bool async) { - await base.First_on_byte_array(async); + await AssertQuery( + async, + ss => ss.Set().Select(s => s.Banner.First())); AssertSql( """ @@ -11474,9 +11724,13 @@ WHERE ASCII(`s`.`Banner`) = 2 """); } - public override async Task Array_access_on_byte_array(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Array_access_on_byte_array(bool async) { - await base.Array_access_on_byte_array(async); + await AssertQuery( + async, + ss => ss.Set().Where(s => s.Banner5[2] == 6)); AssertSql( """ @@ -11873,9 +12127,13 @@ ORDER BY CASE """); } - public override async Task Where_DateOnly_Year(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_Year(bool async) { - await base.Where_DateOnly_Year(async); + await AssertQuery( + async, + ss.Set().Where(m => m.Date.Year == 1990)); AssertSql( """ @@ -11885,9 +12143,13 @@ WHERE EXTRACT(year FROM `m`.`Date`) = 1990 """); } - public override async Task Where_DateOnly_Month(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_Month(bool async) { - await base.Where_DateOnly_Month(async); + await AssertQuery( + async, + ss.Set().Where(m => m.Date.Month == 11)); AssertSql( """ @@ -11897,9 +12159,13 @@ WHERE EXTRACT(month FROM `m`.`Date`) = 11 """); } - public override async Task Where_DateOnly_Day(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_Day(bool async) { - await base.Where_DateOnly_Day(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Date.Day == 10)); AssertSql( """ @@ -11909,9 +12175,13 @@ WHERE EXTRACT(day FROM `m`.`Date`) = 10 """); } - public override async Task Where_DateOnly_DayOfYear(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_DayOfYear(bool async) { - await base.Where_DateOnly_DayOfYear(async); + await AssertQuery( + async, + ss.Set().Where(m => m.Date.DayOfYear == 314)); AssertSql( """ @@ -11921,9 +12191,13 @@ WHERE DAYOFYEAR(`m`.`Date`) = 314 """); } - public override async Task Where_DateOnly_DayOfWeek(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_DayOfWeek(bool async) { - await base.Where_DateOnly_DayOfWeek(async); + await AssertQuery( + async, + ss.Set().Where(m => m.Date.DayOfWeek == DayOfWeek.Sunday)); AssertSql( """ @@ -11933,9 +12207,13 @@ public override async Task Where_DateOnly_DayOfWeek(bool async) """); } - public override async Task Where_DateOnly_AddYears(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_AddYears(bool async) { - await base.Where_DateOnly_AddYears(async); + await AssertQuery( + async, + ss.Set().Where(m => m.Date.AddYears(1).Year == 1991)); AssertSql( """ @@ -11945,9 +12223,13 @@ WHERE DATE_ADD(`m`.`Date`, INTERVAL CAST(3 AS signed) year) = DATE '1993-11-10' """); } - public override async Task Where_DateOnly_AddMonths(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_AddMonths(bool async) { - await base.Where_DateOnly_AddMonths(async); + await AssertQuery( + async, + ss.Set().Where(m => m.Date.AddMonths(1).Month == 12)); AssertSql( """ @@ -11957,9 +12239,13 @@ WHERE DATE_ADD(`m`.`Date`, INTERVAL CAST(3 AS signed) month) = DATE '1991-02-10' """); } - public override async Task Where_DateOnly_AddDays(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_AddDays(bool async) { - await base.Where_DateOnly_AddDays(async); + await AssertQuery( + async, + ss.Set().Where(m => m.Date.AddDays(3).Day == 13)); AssertSql( """ @@ -11969,9 +12255,13 @@ WHERE DATE_ADD(`m`.`Date`, INTERVAL CAST(3 AS signed) day) = DATE '1990-11-13' """); } - public override async Task Where_TimeOnly_Hour(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_Hour(bool async) { - await base.Where_TimeOnly_Hour(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.Hour == 10)); AssertSql( """ @@ -11981,9 +12271,13 @@ WHERE EXTRACT(hour FROM `m`.`Time`) = 10 """); } - public override async Task Where_TimeOnly_Minute(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_Minute(bool async) { - await base.Where_TimeOnly_Minute(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.Minute == 0)); AssertSql( """ @@ -11993,9 +12287,13 @@ WHERE EXTRACT(minute FROM `m`.`Time`) = 15 """); } - public override async Task Where_TimeOnly_Second(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_Second(bool async) { - await base.Where_TimeOnly_Second(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.Second == 0)); AssertSql( """ @@ -12005,9 +12303,13 @@ WHERE EXTRACT(second FROM `m`.`Time`) = 50 """); } - public override async Task Where_TimeOnly_Millisecond(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_Millisecond(bool async) { - await base.Where_TimeOnly_Millisecond(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.Millisecond == 0)); AssertSql( """ @@ -12017,9 +12319,13 @@ public override async Task Where_TimeOnly_Millisecond(bool async) """); } - public override async Task Where_TimeOnly_AddHours(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_AddHours(bool async) { - await base.Where_TimeOnly_AddHours(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.AddHours(3).Hour == 13)); AssertSql( """ @@ -12029,9 +12335,13 @@ WHERE DATE_ADD(`m`.`Time`, INTERVAL CAST(3.0 AS signed) hour) = TIME '13:15:50.5 """); } - public override async Task Where_TimeOnly_AddMinutes(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_AddMinutes(bool async) { - await base.Where_TimeOnly_AddMinutes(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.AddMinutes(3).Minute == 3)); AssertSql( """ @@ -12041,9 +12351,13 @@ WHERE DATE_ADD(`m`.`Time`, INTERVAL CAST(3.0 AS signed) minute) = TIME '10:18:50 """); } - public override async Task Where_TimeOnly_Add_TimeSpan(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_Add_TimeSpan(bool async) { - await base.Where_TimeOnly_Add_TimeSpan(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.Add(new TimeSpan(3, 0, 0)).Hour == 13)); AssertSql( """ @@ -12053,9 +12367,13 @@ public override async Task Where_TimeOnly_Add_TimeSpan(bool async) """); } - public override async Task Where_TimeOnly_IsBetween(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_IsBetween(bool async) { - await base.Where_TimeOnly_IsBetween(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time.IsBetween(new TimeOnly(9, 0), new TimeOnly(11, 0)))); AssertSql( """ @@ -12065,9 +12383,13 @@ public override async Task Where_TimeOnly_IsBetween(bool async) """); } - public override async Task Where_TimeOnly_subtract_TimeOnly(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_subtract_TimeOnly(bool async) { - await base.Where_TimeOnly_subtract_TimeOnly(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Time - new TimeOnly(10, 0) == new TimeSpan(0))); AssertSql( """ @@ -12246,9 +12568,15 @@ UNION ALL } } + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] public override async Task Parameter_used_multiple_times_take_appropriate_inferred_type_mapping(bool async) { - await base.Parameter_used_multiple_times_take_appropriate_inferred_type_mapping(async); + var place = "Ephyra's location"; + + await AssertQuery( + async, + ss => ss.Set().Where(e => e.Nation == place || e.Location == place || e.Location == place)); AssertSql( """ @@ -12334,9 +12662,13 @@ LEFT JOIN ( """); } - public override async Task DateTimeOffset_DateAdd_AddYears(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_DateAdd_AddYears(bool async) { - await base.DateTimeOffset_DateAdd_AddYears(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => m.Timeline.AddYears(1).Year == 3)); AssertSql( """ @@ -12542,9 +12874,13 @@ SELECT COALESCE(SUM(`m`.`Rating`), 0.0) """); } - public override async Task ToString_guid_property_projection(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task ToString_guid_property_projection(bool async) { - await base.ToString_guid_property_projection(async); + await AssertQuery( + async, + ss => ss.Set().Select(t => t.Id.ToString())); AssertSql( """ @@ -12897,9 +13233,19 @@ GROUP BY `w`.`IsAutomatic` """); } + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] public override async Task Project_discriminator_columns(bool async) { - await base.Project_discriminator_columns(async); + await AssertQuery( + async, + ss => ss.Set().Select(g => new { g.Nickname, Discriminator = EF.Property(g, "Discriminator") }), + elementSorter: e => e.Nickname); + + await AssertQuery( + async, + ss => ss.Set().OfType().Select(o => new { o.Nickname, Discriminator = EF.Property(o, "Discriminator") }), + elementSorter: e => e.Nickname); AssertSql(); } @@ -13416,9 +13762,30 @@ public override async Task Using_indexer_on_byte_array_and_string_in_projection( """); } - public override async Task DateTimeOffset_to_unix_time_milliseconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_to_unix_time_milliseconds(bool async) { - await base.DateTimeOffset_to_unix_time_milliseconds(async); + var unixEpochMilliseconds = 0L; + + await AssertQuery( + async, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds) + .Any() + select g, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds) + .Any() + select g, + elementSorter: e => (e.Nickname, e.SquadId), + elementAsserter: (e, a) => AssertEqual(e, a)); AssertSql( """ @@ -13443,9 +13810,30 @@ SELECT 1 """); } - public override async Task DateTimeOffset_to_unix_time_seconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_to_unix_time_seconds(bool async) { - await base.DateTimeOffset_to_unix_time_seconds(async); + var unixEpochSeconds = 0L; + + await AssertQuery( + async, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds) + .Any() + select g, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds) + .Any() + select g, + elementSorter: e => (e.Nickname, e.SquadId), + elementAsserter: (e, a) => AssertEqual(e, a)); AssertSql( """ @@ -13893,9 +14281,13 @@ public override async Task Select_inverted_nullable_boolean(bool async) """); } - public override async Task Where_TimeOnly_FromDateTime_compared_to_property(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_FromDateTime_compared_to_property(bool async) { - await base.Where_TimeOnly_FromDateTime_compared_to_property(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => TimeOnly.FromDateTime(m.Timeline.DateTime) == m.Time)); AssertSql( """ @@ -13906,9 +14298,15 @@ WHERE TIME(`t`.`IssueDate`) = `m`.`Time` """); } - public override async Task Where_TimeOnly_FromDateTime_compared_to_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_FromDateTime_compared_to_parameter(bool async) { - await base.Where_TimeOnly_FromDateTime_compared_to_parameter(async); + var timeOnly = new TimeOnly(10, 0); + + await AssertQuery( + async, + ss => ss.Set().Where(m => TimeOnly.FromDateTime(m.Timeline.DateTime) == timeOnly)); AssertSql( """ @@ -13927,9 +14325,13 @@ UNION ALL """); } - public override async Task Where_TimeOnly_FromDateTime_compared_to_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_FromDateTime_compared_to_constant(bool async) { - await base.Where_TimeOnly_FromDateTime_compared_to_constant(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => TimeOnly.FromDateTime(m.Timeline.DateTime) == new TimeOnly(10, 0))); AssertSql( """ @@ -13939,9 +14341,13 @@ WHERE TIME(DATE_ADD(`t`.`IssueDate`, INTERVAL CAST(CAST(CHAR_LENGTH(`t`.`Note`) """); } - public override async Task Where_TimeOnly_FromTimeSpan_compared_to_property(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_FromTimeSpan_compared_to_property(bool async) { - await base.Where_TimeOnly_FromTimeSpan_compared_to_property(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => TimeOnly.FromTimeSpan(m.Duration) == m.Time)); AssertSql( """ @@ -13951,9 +14357,15 @@ public override async Task Where_TimeOnly_FromTimeSpan_compared_to_property(bool """); } - public override async Task Where_TimeOnly_FromTimeSpan_compared_to_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_TimeOnly_FromTimeSpan_compared_to_parameter(bool async) { - await base.Where_TimeOnly_FromTimeSpan_compared_to_parameter(async); + var timeOnly = new TimeOnly(10, 0); + + await AssertQuery( + async, + ss => ss.Set().Where(m => TimeOnly.FromTimeSpan(m.Duration) == timeOnly)); AssertSql( """ @@ -13965,9 +14377,13 @@ public override async Task Where_TimeOnly_FromTimeSpan_compared_to_parameter(boo """); } - public override async Task Order_by_TimeOnly_FromTimeSpan(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Order_by_TimeOnly_FromTimeSpan(bool async) { - await base.Order_by_TimeOnly_FromTimeSpan(async); + await AssertQuery( + async, + ss => ss.Set().OrderBy(m => TimeOnly.FromTimeSpan(m.Duration))); AssertSql( """ @@ -13977,9 +14393,13 @@ ORDER BY `m`.`Duration` """); } - public override async Task Where_DateOnly_FromDateTime_compared_to_property(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_FromDateTime_compared_to_property(bool async) { - await base.Where_DateOnly_FromDateTime_compared_to_property(async); + await AssertQuery( + async, + ss => ss.Set().Where(m => DateOnly.FromDateTime(m.Timeline.DateTime) > m.Date)); AssertSql( """ @@ -13990,9 +14410,15 @@ WHERE DATE(`t`.`IssueDate`) > `m`.`Date` """); } - public override async Task Where_DateOnly_FromDateTime_compared_to_constant_and_parameter(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_DateOnly_FromDateTime_compared_to_constant_and_parameter(bool async) { - await base.Where_DateOnly_FromDateTime_compared_to_constant_and_parameter(async); + var dateOnly = new DateOnly(1990, 11, 10); + + await AssertQuery( + async, + ss => ss.Set().Where(m => DateOnly.FromDateTime(m.Timeline.DateTime) == dateOnly)); AssertSql( """ diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs index a0a91e103..b2c46666a 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs @@ -36,7 +36,9 @@ public override Task DateTimeOffset_Contains_Less_than_Greater_than(bool async) m => start <= m.Timeline.Date && m.Timeline < end && dates.Contains(m.Timeline))); } - public override Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual Task Where_datetimeoffset_milliseconds_parameter_and_constant(bool async) { var dateTimeOffset = MySqlTestHelpers.GetExpectedValue(new DateTimeOffset(599898024001234567, new TimeSpan(1, 30, 0))); @@ -237,9 +239,30 @@ public override Task Correlated_collection_with_groupby_with_complex_grouping_ke return base.Correlated_collection_with_groupby_with_complex_grouping_key_not_projecting_identifier_column_with_group_aggregate_in_final_projection(async); } - public override async Task DateTimeOffset_to_unix_time_milliseconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_to_unix_time_milliseconds(bool async) { - await base.DateTimeOffset_to_unix_time_milliseconds(async); + var unixEpochMilliseconds = 0L; + + await AssertQuery( + async, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds) + .Any() + select g, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeMilliseconds() == unixEpochMilliseconds) + .Any() + select g, + elementSorter: e => (e.Nickname, e.SquadId), + elementAsserter: (e, a) => AssertEqual(e, a)); AssertSql( """ @@ -261,9 +284,30 @@ SELECT 1 """); } - public override async Task DateTimeOffset_to_unix_time_seconds(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task DateTimeOffset_to_unix_time_seconds(bool async) { - await base.DateTimeOffset_to_unix_time_seconds(async); + var unixEpochSeconds = 0L; + + await AssertQuery( + async, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds) + .Any() + select g, + ss => from g in ss.Set() + join squad in ss.Set() on g.SquadId equals squad.Id + where !ss.Set() + .Join(ss.Set(), sm => sm.MissionId, m => m.Id, (sm, m) => new { sm, m }) + .Where(x => x.sm.SquadId == squad.Id && x.m.Timeline.ToUnixTimeSeconds() == unixEpochSeconds) + .Any() + select g, + elementSorter: e => (e.Nickname, e.SquadId), + elementAsserter: (e, a) => AssertEqual(e, a)); AssertSql( """ @@ -293,7 +337,9 @@ public override async Task Where_subquery_with_ElementAt_using_column_as_index(b AssertSql(""); } - public override async Task Where_datetimeoffset_hour_component(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Where_datetimeoffset_hour_component(bool async) { await AssertQuery( async,