Adding regression tests for issues that have been fixed already

Resolves #8723
Resolves #9241
Resolves #10172
Resolves #10210
Resolves #10548
Resolves #11847
Resolves #11933
Resolves #12741
Resolves #15798

test/EFCore.Specification.Tests/Query/ComplexNavigationsQueryTestBase.cs

@@ -5823,7 +5823,7 @@ orderby l4.Id
             }
         }
 
-        [ConditionalTheory(Skip = "issue #15798")]
+        [ConditionalTheory]
         [MemberData(nameof(IsAsyncData))]
         public virtual Task Member_pushdown_with_multiple_collections(bool isAsync)
         {

test/EFCore.Specification.Tests/Query/ComplexNavigationsWeakQueryTestBase.cs

@@ -150,6 +150,12 @@ public override Task Include_collection_with_multiple_orderbys_property(bool isA
             return base.Include_collection_with_multiple_orderbys_property(isAsync);
         }
 
+        [ConditionalTheory(Skip = "Issue#17803")]
+        public override Task Member_pushdown_with_multiple_collections(bool isAsync)
+        {
+            return base.Member_pushdown_with_multiple_collections(isAsync);
+        }
+
         // Cannot create DbSet for Level2
         public override void Join_with_navigations_in_the_result_selector2()
         {

test/EFCore.Specification.Tests/Query/GearsOfWarQueryTestBase.cs

@@ -7611,6 +7611,121 @@ public virtual Task Null_checks_in_correlated_predicate_are_correctly_translated
                 });
         }
 
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task SelectMany_Where_DefaultIfEmpty_with_navigation_in_the_collection_selector(bool isAsync)
+        {
+            var isAutomatic = true;
+
+            return AssertQuery<Gear>(
+                isAsync,
+                gs => from g in gs
+                      from w in g.Weapons.Where(ww => ww.IsAutomatic == isAutomatic).DefaultIfEmpty()
+                      select new
+                      {
+                          g.Nickname,
+                          g.FullName,
+                          Collection = w != null
+                      });
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Join_with_inner_being_a_subquery_projecting_single_property(bool isAsync)
+        {
+            return AssertQuery<Gear>(
+                isAsync,
+                gs => from g in gs
+                      join inner in (
+                          from g2 in gs
+                          select g2.Nickname
+                      ) on g.Nickname equals inner
+                      select g);
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Join_with_inner_being_a_subquery_projecting_anonymous_type_with_single_property(bool isAsync)
+        {
+            return AssertQuery<Gear>(
+                isAsync,
+                gs => from g in gs
+                      join inner in (
+                           from g2 in gs
+                           select new { g2.Nickname }
+                           ) on g.Nickname equals inner.Nickname
+                      select g);
+        }
+
+        [ConditionalTheory(Skip = "issue #17475")]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Navigation_based_on_complex_expression1(bool isAsync)
+        {
+            return AssertQuery<Faction>(
+                isAsync,
+                fs => fs.Where(f => f is LocustHorde ? (f as LocustHorde).Commander != null : false));
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Navigation_based_on_complex_expression2(bool isAsync)
+        {
+            return AssertQuery<Faction>(
+                isAsync,
+                fs => fs.Where(f => f is LocustHorde).Where(f => ((LocustHorde)f).Commander != null));
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Navigation_based_on_complex_expression3(bool isAsync)
+        {
+            return AssertQuery<Faction>(
+                isAsync,
+                fs => fs.Where(f => f is LocustHorde).Select(f => ((LocustHorde)f).Commander));
+        }
+
+        [ConditionalTheory(Skip = "issue #17782")]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Navigation_based_on_complex_expression4(bool isAsync)
+        {
+            return AssertQuery<Faction, LocustLeader>(
+                isAsync,
+                (fs, lls) => from lc1 in fs.Select(f => (f is LocustHorde) ? ((LocustHorde)f).Commander : null)
+                             from lc2 in lls.OfType<LocustCommander>()
+                             select (lc1 ?? lc2).DefeatedBy);
+        }
+
+        [ConditionalTheory(Skip = "issue #17782")]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Navigation_based_on_complex_expression5(bool isAsync)
+        {
+            return AssertQuery<Faction, LocustLeader>(
+                isAsync,
+                (fs, lls) => from lc1 in fs.OfType<LocustHorde>().Select(lh => lh.Commander)
+                             join lc2 in lls.OfType<LocustCommander>() on true equals true
+                             select (lc1 ?? lc2).DefeatedBy);
+        }
+
+        [ConditionalTheory(Skip = "issue #17782")]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Navigation_based_on_complex_expression6(bool isAsync)
+        {
+            return AssertQuery<Faction, LocustLeader>(
+                isAsync,
+                (fs, lls) => from lc1 in fs.OfType<LocustHorde>().Select(lh => lh.Commander)
+                             join lc2 in lls.OfType<LocustCommander>() on true equals true
+                             select (lc1.Name == "Queen Myrrah" ? lc1 : lc2).DefeatedBy);
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Select_as_operator(bool isAsync)
+        {
+            return AssertQuery<LocustLeader>(
+                isAsync,
+                lls => lls.Select(ll => ll as LocustCommander));
+        }
+
         protected GearsOfWarContext CreateContext() => Fixture.CreateContext();
 
         protected virtual void ClearLog()

test/EFCore.Specification.Tests/Query/SimpleQueryTestBase.Select.cs

@@ -8,6 +8,7 @@
 using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.EntityFrameworkCore.TestModels.Northwind;
 using Xunit;
+using Xunit.Sdk;
 
 // ReSharper disable StringStartsWithIsCultureSpecific
 // ReSharper disable InconsistentNaming
@@ -1308,5 +1309,56 @@ public virtual async Task Filtered_collection_projection_with_to_list_is_tracked
                 Assert.Equal(6, context.ChangeTracker.Entries().Count());
             }
         }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task SelectMany_with_collection_being_correlated_subquery_which_references_inner_and_outer_entity(bool isAsync)
+        {
+            return AssertQuery<Customer>(
+                isAsync,
+                cs => cs.SelectMany(c => c.Orders.Select(o => new { OrderProperty = o.CustomerID, CustomerProperty = c.CustomerID })));
+        }
+
+        [ConditionalTheory(Skip = "issue #17763")]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task SelectMany_with_collection_being_correlated_subquery_which_references_non_mapped_properties_from_inner_and_outer_entity(bool isAsync)
+        {
+            return AssertQuery<Customer>(
+                isAsync,
+                cs => cs.SelectMany(c => c.Orders.Select(o => new { OrderProperty = o.ShipName, CustomerProperty = c.ContactName })));
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Select_with_complex_expression_that_can_be_funcletized(bool isAsync)
+        {
+            return AssertQueryScalar<Customer, int>(
+                isAsync,
+                cs => cs.Where(c => c.CustomerID == "ALFKI").Select(c => c.ContactName.IndexOf("")),
+                assertOrder: true);
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Select_chained_entity_navigation_doesnt_materialize_intermittent_entities(bool isAsync)
+        {
+            return AssertQuery<Order>(
+                isAsync,
+                os => os.OrderBy(o => o.OrderID).Select(o => o.Customer.Orders),
+                elementAsserter: CollectionAsserter<Order>(),
+                assertOrder: true,
+                entryCount: 830);
+        }
+
+        [ConditionalTheory]
+        [MemberData(nameof(IsAsyncData))]
+        public virtual Task Select_entity_compared_to_null(bool isAsync)
+        {
+            return AssertQueryScalar<Order, bool>(
+                isAsync,
+                os => from o in os
+                      where o.CustomerID == "ALFKI"
+                      select o.Customer == null);
+        }
     }
 }

test/EFCore.SqlServer.FunctionalTests/Query/ComplexNavigationsQuerySqlServerTest.cs

@@ -4650,7 +4650,28 @@ public override async Task Member_pushdown_with_multiple_collections(bool isAsyn
             await base.Member_pushdown_with_multiple_collections(isAsync);
 
             AssertSql(
-                @"");
+                @"SELECT (
+    SELECT TOP(1) [l].[Name]
+    FROM [LevelThree] AS [l]
+    WHERE (
+        SELECT TOP(1) [l0].[Id]
+        FROM [LevelTwo] AS [l0]
+        WHERE ([l2].[Id] = [l0].[OneToMany_Optional_Inverse2Id]) AND [l0].[OneToMany_Optional_Inverse2Id] IS NOT NULL
+        ORDER BY [l0].[Id]) IS NOT NULL AND ((((
+        SELECT TOP(1) [l1].[Id]
+        FROM [LevelTwo] AS [l1]
+        WHERE ([l2].[Id] = [l1].[OneToMany_Optional_Inverse2Id]) AND [l1].[OneToMany_Optional_Inverse2Id] IS NOT NULL
+        ORDER BY [l1].[Id]) = [l].[OneToMany_Optional_Inverse3Id]) AND ((
+        SELECT TOP(1) [l1].[Id]
+        FROM [LevelTwo] AS [l1]
+        WHERE ([l2].[Id] = [l1].[OneToMany_Optional_Inverse2Id]) AND [l1].[OneToMany_Optional_Inverse2Id] IS NOT NULL
+        ORDER BY [l1].[Id]) IS NOT NULL AND [l].[OneToMany_Optional_Inverse3Id] IS NOT NULL)) OR ((
+        SELECT TOP(1) [l1].[Id]
+        FROM [LevelTwo] AS [l1]
+        WHERE ([l2].[Id] = [l1].[OneToMany_Optional_Inverse2Id]) AND [l1].[OneToMany_Optional_Inverse2Id] IS NOT NULL
+        ORDER BY [l1].[Id]) IS NULL AND [l].[OneToMany_Optional_Inverse3Id] IS NULL))
+    ORDER BY [l].[Id])
+FROM [LevelOne] AS [l2]");
         }
 
         public override async Task Null_check_removal_applied_recursively(bool isAsync)

test/EFCore.SqlServer.FunctionalTests/Query/GearsOfWarQuerySqlServerTest.cs

@@ -7008,6 +7008,128 @@ WHERE [g].[Discriminator] IN (N'Gear', N'Officer')
 ORDER BY [t].[Id], [t0].[Nickname], [t0].[SquadId]");
         }
 
+        public override async Task SelectMany_Where_DefaultIfEmpty_with_navigation_in_the_collection_selector(bool isAsync)
+        {
+            await base.SelectMany_Where_DefaultIfEmpty_with_navigation_in_the_collection_selector(isAsync);
+
+            AssertSql(
+                @"@__isAutomatic_0='True'
+
+SELECT [g].[Nickname], [g].[FullName], CASE
+    WHEN [t].[Id] IS NOT NULL THEN CAST(1 AS bit)
+    ELSE CAST(0 AS bit)
+END AS [Collection]
+FROM [Gears] AS [g]
+LEFT JOIN (
+    SELECT [w].[Id], [w].[AmmunitionType], [w].[IsAutomatic], [w].[Name], [w].[OwnerFullName], [w].[SynergyWithId]
+    FROM [Weapons] AS [w]
+    WHERE ([w].[IsAutomatic] = @__isAutomatic_0) AND @__isAutomatic_0 IS NOT NULL
+) AS [t] ON [g].[FullName] = [t].[OwnerFullName]
+WHERE [g].[Discriminator] IN (N'Gear', N'Officer')");
+        }
+
+        public override async Task Join_with_inner_being_a_subquery_projecting_single_property(bool isAsync)
+        {
+            await base.Join_with_inner_being_a_subquery_projecting_single_property(isAsync);
+
+            AssertSql(
+                @"SELECT [g].[Nickname], [g].[SquadId], [g].[AssignedCityName], [g].[CityOrBirthName], [g].[Discriminator], [g].[FullName], [g].[HasSoulPatch], [g].[LeaderNickname], [g].[LeaderSquadId], [g].[Rank]
+FROM [Gears] AS [g]
+INNER JOIN (
+    SELECT [g0].[Nickname], [g0].[SquadId], [g0].[AssignedCityName], [g0].[CityOrBirthName], [g0].[Discriminator], [g0].[FullName], [g0].[HasSoulPatch], [g0].[LeaderNickname], [g0].[LeaderSquadId], [g0].[Rank]
+    FROM [Gears] AS [g0]
+    WHERE [g0].[Discriminator] IN (N'Gear', N'Officer')
+) AS [t] ON [g].[Nickname] = [t].[Nickname]
+WHERE [g].[Discriminator] IN (N'Gear', N'Officer')");
+        }
+
+        public override async Task Join_with_inner_being_a_subquery_projecting_anonymous_type_with_single_property(bool isAsync)
+        {
+            await base.Join_with_inner_being_a_subquery_projecting_anonymous_type_with_single_property(isAsync);
+
+            AssertSql(
+                @"SELECT [g].[Nickname], [g].[SquadId], [g].[AssignedCityName], [g].[CityOrBirthName], [g].[Discriminator], [g].[FullName], [g].[HasSoulPatch], [g].[LeaderNickname], [g].[LeaderSquadId], [g].[Rank]
+FROM [Gears] AS [g]
+INNER JOIN (
+    SELECT [g0].[Nickname], [g0].[SquadId], [g0].[AssignedCityName], [g0].[CityOrBirthName], [g0].[Discriminator], [g0].[FullName], [g0].[HasSoulPatch], [g0].[LeaderNickname], [g0].[LeaderSquadId], [g0].[Rank]
+    FROM [Gears] AS [g0]
+    WHERE [g0].[Discriminator] IN (N'Gear', N'Officer')
+) AS [t] ON [g].[Nickname] = [t].[Nickname]
+WHERE [g].[Discriminator] IN (N'Gear', N'Officer')");
+        }
+
+        public override async Task Navigation_based_on_complex_expression1(bool isAsync)
+        {
+            await base.Navigation_based_on_complex_expression1(isAsync);
+
+            AssertSql(
+                @"");
+        }
+
+        public override async Task Navigation_based_on_complex_expression2(bool isAsync)
+        {
+            await base.Navigation_based_on_complex_expression2(isAsync);
+
+            AssertSql(
+                @"SELECT [f].[Id], [f].[CapitalName], [f].[Discriminator], [f].[Name], [f].[CommanderName], [f].[Eradicated]
+FROM [Factions] AS [f]
+LEFT JOIN (
+    SELECT [l].[Name], [l].[Discriminator], [l].[LocustHordeId], [l].[ThreatLevel], [l].[DefeatedByNickname], [l].[DefeatedBySquadId], [l].[HighCommandId]
+    FROM [LocustLeaders] AS [l]
+    WHERE [l].[Discriminator] = N'LocustCommander'
+) AS [t] ON [f].[CommanderName] = [t].[Name]
+WHERE (([f].[Discriminator] = N'LocustHorde') AND ([f].[Discriminator] = N'LocustHorde')) AND [t].[Name] IS NOT NULL");
+        }
+
+        public override async Task Navigation_based_on_complex_expression3(bool isAsync)
+        {
+            await base.Navigation_based_on_complex_expression3(isAsync);
+
+            AssertSql(
+                @"SELECT [t].[Name], [t].[Discriminator], [t].[LocustHordeId], [t].[ThreatLevel], [t].[DefeatedByNickname], [t].[DefeatedBySquadId], [t].[HighCommandId]
+FROM [Factions] AS [f]
+LEFT JOIN (
+    SELECT [l].[Name], [l].[Discriminator], [l].[LocustHordeId], [l].[ThreatLevel], [l].[DefeatedByNickname], [l].[DefeatedBySquadId], [l].[HighCommandId]
+    FROM [LocustLeaders] AS [l]
+    WHERE [l].[Discriminator] = N'LocustCommander'
+) AS [t] ON [f].[CommanderName] = [t].[Name]
+WHERE ([f].[Discriminator] = N'LocustHorde') AND ([f].[Discriminator] = N'LocustHorde')");
+        }
+
+        public override async Task Navigation_based_on_complex_expression4(bool isAsync)
+        {
+            await base.Navigation_based_on_complex_expression4(isAsync);
+
+            AssertSql(
+                @"");
+        }
+
+        public override async Task Navigation_based_on_complex_expression5(bool isAsync)
+        {
+            await base.Navigation_based_on_complex_expression5(isAsync);
+
+            AssertSql(
+                @"");
+        }
+
+        public override async Task Navigation_based_on_complex_expression6(bool isAsync)
+        {
+            await base.Navigation_based_on_complex_expression6(isAsync);
+
+            AssertSql(
+                @"");
+        }
+
+        public override async Task Select_as_operator(bool isAsync)
+        {
+            await base.Select_as_operator(isAsync);
+
+            AssertSql(
+                @"SELECT [l].[Name], [l].[Discriminator], [l].[LocustHordeId], [l].[ThreatLevel], [l].[DefeatedByNickname], [l].[DefeatedBySquadId], [l].[HighCommandId]
+FROM [LocustLeaders] AS [l]
+WHERE [l].[Discriminator] IN (N'LocustLeader', N'LocustCommander')");
+        }
+
         private void AssertSql(params string[] expected)
             => Fixture.TestSqlLoggerFactory.AssertBaseline(expected);