Adding extra include tests and enabling some more that were switched off.

maumar · maumar · commit 62fb0b4704b0 · 2016-03-04T15:47:41.000-08:00
CR: Andrew
diff --git a/EntityFramework.sln b/EntityFramework.sln
@@ -1,4 +1,3 @@
-﻿
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 14
 VisualStudioVersion = 14.0.25025.0
diff --git a/test/Microsoft.EntityFrameworkCore.FunctionalTests/ComplexNavigationsQueryTestBase.cs b/test/Microsoft.EntityFrameworkCore.FunctionalTests/ComplexNavigationsQueryTestBase.cs
@@ -228,8 +228,7 @@ public virtual void Multi_level_include_with_short_circuiting()
             }
         }
 
-        // issue #3186
-        ////[ConditionalFact]
+        [ConditionalFact]
         public virtual void Join_navigation_key_access_optional()
         {
             List<Level1> levelOnes;
@@ -295,8 +294,7 @@ join l2 in levelTwos on l1.Id equals l2.OneToOne_Required_FK_Inverse?.Id
             }
         }
 
-        // issue #3186
-        ////[ConditionalFact]
+        [ConditionalFact]
         public virtual void Navigation_key_access_optional_comparison()
         {
             List<Level2> levelTwos;
@@ -1860,13 +1858,124 @@ public virtual void Include_with_optional_navigation()
             }
         }
 
+        [ConditionalFact]
+        public virtual void Include_nested_with_optional_navigation()
+        {
+            List<Level1> expected;
+            using (var context = CreateContext())
+            {
+                expected = (from l1 in context.LevelOne
+                                .Include(e => e.OneToOne_Optional_FK.OneToMany_Required)
+                                .ThenInclude(e => e.OneToOne_Required_FK).ToList()
+                            where l1.OneToOne_Optional_FK?.Name != "L2 09"
+                            select l1).ToList();
+            }
+
+            ClearLog();
+
+            using (var context = CreateContext())
+            {
+                var query = from l1 in context.LevelOne
+                                .Include(e => e.OneToOne_Optional_FK.OneToMany_Required)
+                                .ThenInclude(e => e.OneToOne_Required_FK)
+                            where l1.OneToOne_Optional_FK.Name != "L2 09"
+                            select l1;
+
+                var result = query.ToList();
+
+                Assert.Equal(expected.Count, result.Count);
+                for (var i = 0; i < result.Count; i++)
+                {
+                    var expectedElement = expected.Where(e => e.Id == result[i].Id).Single();
+
+                    Assert.Equal(expectedElement.OneToOne_Optional_FK?.Id, result[i].OneToOne_Optional_FK?.Id);
+                    Assert.Equal(expectedElement.OneToOne_Optional_FK?.Name, result[i].OneToOne_Optional_FK?.Name);
+
+                    var resultCollection = result[i].OneToOne_Optional_FK?.OneToMany_Required;
+                    Assert.Equal(expectedElement.OneToOne_Optional_FK?.OneToMany_Required?.Count, resultCollection?.Count);
+
+                    if (resultCollection != null)
+                    {
+                        foreach (var inner in resultCollection)
+                        {
+                            Assert.True(expectedElement.OneToOne_Optional_FK.OneToMany_Required.Select(e => e.Id).Contains(inner.Id));
+                        }
+                    }
+                }
+            }
+        }
+
+        [ConditionalFact]
+        public virtual void Include_with_groupjoin_skip_and_take()
+        {
+            List<KeyValuePair<Level1, IEnumerable<Level2>>> expected;
+            using (var context = CreateContext())
+            {
+                expected = (from l1 in context.LevelOne
+                                .Include(e => e.OneToMany_Optional)
+                                .ThenInclude(e => e.OneToOne_Optional_FK)
+                                .ToList()
+                            join l2 in context.LevelTwo
+                                .Include(e => e.OneToOne_Required_PK)
+                                .ToList()
+                            on (int?)l1.Id equals (l2 != null ? l2.Level1_Optional_Id : null) into grouping
+                            where l1.Name != "L1 03" || l1.Name == null
+                            select new KeyValuePair<Level1, IEnumerable<Level2>>(l1, grouping)).ToList();
+            }
+
+            ClearLog();
+
+            using (var context = CreateContext())
+            {
+                var query = (from l1 in context.LevelOne
+                                 .Include(e => e.OneToMany_Optional)
+                                 .ThenInclude(e => e.OneToOne_Optional_FK)
+                             join l2 in context.LevelTwo.Include(e => e.OneToOne_Required_PK)
+                             on (int?)l1.Id equals (l2 != null ? l2.Level1_Optional_Id : null) into grouping
+                             where l1.Name != "L1 03"
+                             select new { l1, grouping }).Skip(1).Take(5);
+
+                var result = query.ToList();
+
+                Assert.Equal(5, result.Count);
+                for (var i = 0; i < result.Count; i++)
+                {
+                    var expectedElement = expected.Where(e => e.Key.Id == result[i].l1.Id).Single();
+
+                    var expectedOneToManyOptional = expectedElement.Key.OneToMany_Optional?.ToList();
+                    var actualOneToManyOptional = result[i].l1.OneToMany_Optional?.ToList();
+
+                    Assert.Equal(expectedOneToManyOptional?.Count, actualOneToManyOptional?.Count);
+                    if (expectedOneToManyOptional != null)
+                    {
+                        for (int j = 0; j < expectedOneToManyOptional.Count; j++)
+                        {
+                            Assert.Equal(expectedOneToManyOptional[j].OneToOne_Optional_FK.Id, actualOneToManyOptional[j].OneToOne_Optional_FK.Id);
+                        }
+                    }
+
+                    var expectedGrouping = expectedElement.Value?.ToList();
+                    var actualGrouping = result[i].grouping?.ToList();
+                    Assert.Equal(expectedGrouping?.Count(), result[i].grouping?.Count());
+                    if (expectedGrouping != null)
+                    {
+                        for (int j = 0; j < expectedGrouping.Count(); j++)
+                        {
+                            Assert.Equal(expectedGrouping[j].Id, actualGrouping[j].Id);
+                            Assert.Equal(expectedGrouping[j].OneToOne_Required_PK.Id, actualGrouping[j].OneToOne_Required_PK.Id);
+                        }
+                    }
+                }
+            }
+        }
+
         ////[ConditionalFact]
         public virtual void Join_flattening_bug_4539()
         {
             using (var context = CreateContext())
             {
                 var query = from l1 in context.LevelOne
-                            join l1_Optional in context.LevelTwo on (int?)l1.Id equals EF.Property<int?>(l1_Optional, "Level1_Optional_Id") into grouping
+                            join l1_Optional in context.LevelTwo on (int?)l1.Id equals l1_Optional.Level1_Optional_Id into grouping
                             from l1_Optional in grouping.DefaultIfEmpty()
                             from l2 in context.LevelTwo
                             join l2_Required_Reverse in context.LevelOne on l2.Level1_Required_Id equals l2_Required_Reverse.Id
diff --git a/test/Microsoft.EntityFrameworkCore.FunctionalTests/GearsOfWarQueryTestBase.cs b/test/Microsoft.EntityFrameworkCore.FunctionalTests/GearsOfWarQueryTestBase.cs
@@ -248,8 +248,7 @@ public virtual void Include_navigation_on_derived_type()
             }
         }
 
-        // TODO: include doesn't work with optional navigations
-        ////[ConditionalFact]
+        [ConditionalFact]
         public virtual void Select_Where_Navigation_Included()
         {
             using (var context = CreateContext())
@@ -400,8 +399,7 @@ public virtual void Include_with_join_and_inheritance3()
             }
         }
 
-        // TODO: include doesn't work with optional navigations
-        ////[ConditionalFact]
+        [ConditionalFact]
         public virtual void Include_with_nested_navigation_in_order_by()
         {
             using (var context = CreateContext())
diff --git a/test/Microsoft.EntityFrameworkCore.FunctionalTests/QueryNavigationsTestBase.cs b/test/Microsoft.EntityFrameworkCore.FunctionalTests/QueryNavigationsTestBase.cs
@@ -177,8 +177,7 @@ from o2 in context.Set<Order>()
             }
         }
 
-        // TODO: include doesn't work with optional navigations
-        ////[ConditionalFact]
+        [ConditionalFact]
         public virtual void Select_Where_Navigation_Included()
         {
             using (var context = CreateContext())
diff --git a/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/ComplexNavigationsQuerySqlServerTest.cs b/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/ComplexNavigationsQuerySqlServerTest.cs
@@ -136,7 +136,14 @@ public override void Join_navigation_key_access_optional()
             base.Join_navigation_key_access_optional();
 
             Assert.Equal(
-                @"", Sql);
+                @"SELECT [e1].[Id], [e2].[Id]
+FROM [Level1] AS [e1]
+INNER JOIN [Level2] AS [e2] ON [e1].[Id] = (
+    SELECT TOP(1) [subQuery0].[Id]
+    FROM [Level1] AS [subQuery0]
+    WHERE [subQuery0].[Id] = [e2].[Level1_Optional_Id]
+)", 
+                Sql);
         }
 
         public override void Join_navigation_key_access_required()
@@ -146,15 +153,20 @@ public override void Join_navigation_key_access_required()
             Assert.Equal(
                 @"SELECT [e1].[Id], [e2].[Id]
 FROM [Level1] AS [e1]
-INNER JOIN [Level2] AS [e2] ON [e1].[Id] = [e2].[Level1_Required_Id]", Sql);
+INNER JOIN [Level2] AS [e2] ON [e1].[Id] = [e2].[Level1_Required_Id]", 
+                Sql);
         }
 
         public override void Navigation_key_access_optional_comparison()
         {
             base.Navigation_key_access_optional_comparison();
 
             Assert.Equal(
-                @"", Sql);
+                @"SELECT [e2].[Id], [e2].[Level1_Optional_Id], [e2].[Level1_Required_Id], [e2].[Name], [e2].[OneToMany_Optional_InverseId], [e2].[OneToMany_Optional_Self_InverseId], [e2].[OneToMany_Required_InverseId], [e2].[OneToMany_Required_Self_InverseId], [e2].[OneToOne_Optional_PK_InverseId], [e2].[OneToOne_Optional_SelfId], [e2.OneToOne_Optional_PK_Inverse].[Id], [e2.OneToOne_Optional_PK_Inverse].[Name], [e2.OneToOne_Optional_PK_Inverse].[OneToMany_Optional_Self_InverseId], [e2.OneToOne_Optional_PK_Inverse].[OneToMany_Required_Self_InverseId], [e2.OneToOne_Optional_PK_Inverse].[OneToOne_Optional_SelfId]
+FROM [Level2] AS [e2]
+LEFT JOIN [Level1] AS [e2.OneToOne_Optional_PK_Inverse] ON [e2].[OneToOne_Optional_PK_InverseId] = [e2.OneToOne_Optional_PK_Inverse].[Id]
+ORDER BY [e2].[OneToOne_Optional_PK_InverseId]", 
+                Sql);
         }
 
         public override void Navigation_key_access_required_comparison()
@@ -846,6 +858,93 @@ FROM [Level1] AS [e]
                 Sql);
         }
 
+        public override void Include_nested_with_optional_navigation()
+        {
+            base.Include_nested_with_optional_navigation();
+
+            Assert.Equal(
+                @"SELECT [e].[Id], [e].[Name], [e].[OneToMany_Optional_Self_InverseId], [e].[OneToMany_Required_Self_InverseId], [e].[OneToOne_Optional_SelfId], [e.OneToOne_Optional_FK].[Id], [e.OneToOne_Optional_FK].[Level1_Optional_Id], [e.OneToOne_Optional_FK].[Level1_Required_Id], [e.OneToOne_Optional_FK].[Name], [e.OneToOne_Optional_FK].[OneToMany_Optional_InverseId], [e.OneToOne_Optional_FK].[OneToMany_Optional_Self_InverseId], [e.OneToOne_Optional_FK].[OneToMany_Required_InverseId], [e.OneToOne_Optional_FK].[OneToMany_Required_Self_InverseId], [e.OneToOne_Optional_FK].[OneToOne_Optional_PK_InverseId], [e.OneToOne_Optional_FK].[OneToOne_Optional_SelfId], [l].[Id], [l].[Level1_Optional_Id], [l].[Level1_Required_Id], [l].[Name], [l].[OneToMany_Optional_InverseId], [l].[OneToMany_Optional_Self_InverseId], [l].[OneToMany_Required_InverseId], [l].[OneToMany_Required_Self_InverseId], [l].[OneToOne_Optional_PK_InverseId], [l].[OneToOne_Optional_SelfId]
+FROM [Level1] AS [e]
+LEFT JOIN [Level2] AS [e.OneToOne_Optional_FK] ON [e].[Id] = [e.OneToOne_Optional_FK].[Level1_Optional_Id]
+LEFT JOIN [Level2] AS [l] ON [l].[Level1_Optional_Id] = [e].[Id]
+ORDER BY [e].[Id], [l].[Id]
+
+SELECT [l0].[Id], [l0].[Level2_Optional_Id], [l0].[Level2_Required_Id], [l0].[Name], [l0].[OneToMany_Optional_InverseId], [l0].[OneToMany_Optional_Self_InverseId], [l0].[OneToMany_Required_InverseId], [l0].[OneToMany_Required_Self_InverseId], [l0].[OneToOne_Optional_PK_InverseId], [l0].[OneToOne_Optional_SelfId], [l2].[Id], [l2].[Level3_Optional_Id], [l2].[Level3_Required_Id], [l2].[Name], [l2].[OneToMany_Optional_InverseId], [l2].[OneToMany_Optional_Self_InverseId], [l2].[OneToMany_Required_InverseId], [l2].[OneToMany_Required_Self_InverseId], [l2].[OneToOne_Optional_PK_InverseId], [l2].[OneToOne_Optional_SelfId]
+FROM [Level3] AS [l0]
+INNER JOIN (
+    SELECT DISTINCT [e].[Id], [l].[Id] AS [Id0]
+    FROM [Level1] AS [e]
+    LEFT JOIN [Level2] AS [e.OneToOne_Optional_FK] ON [e].[Id] = [e.OneToOne_Optional_FK].[Level1_Optional_Id]
+    LEFT JOIN [Level2] AS [l] ON [l].[Level1_Optional_Id] = [e].[Id]
+) AS [l1] ON [l0].[OneToMany_Required_InverseId] = [l1].[Id0]
+LEFT JOIN [Level4] AS [l2] ON [l2].[Level3_Required_Id] = [l0].[Id]
+ORDER BY [l1].[Id], [l1].[Id0]",
+                Sql);
+        }
+
+        public override void Include_with_groupjoin_skip_and_take()
+        {
+            base.Include_with_groupjoin_skip_and_take();
+
+            Assert.Equal(
+                @"@__p_0: ?
+@__p_1: ?
+
+SELECT [e].[Id], [e].[Name], [e].[OneToMany_Optional_Self_InverseId], [e].[OneToMany_Required_Self_InverseId], [e].[OneToOne_Optional_SelfId], [t].[Id], [t].[Level1_Optional_Id], [t].[Level1_Required_Id], [t].[Name], [t].[OneToMany_Optional_InverseId], [t].[OneToMany_Optional_Self_InverseId], [t].[OneToMany_Required_InverseId], [t].[OneToMany_Required_Self_InverseId], [t].[OneToOne_Optional_PK_InverseId], [t].[OneToOne_Optional_SelfId], [l1].[Id], [l1].[Level2_Optional_Id], [l1].[Level2_Required_Id], [l1].[Name], [l1].[OneToMany_Optional_InverseId], [l1].[OneToMany_Optional_Self_InverseId], [l1].[OneToMany_Required_InverseId], [l1].[OneToMany_Required_Self_InverseId], [l1].[OneToOne_Optional_PK_InverseId], [l1].[OneToOne_Optional_SelfId]
+FROM [Level1] AS [e]
+LEFT JOIN (
+    SELECT [e1].[Id], [e1].[Level1_Optional_Id], [e1].[Level1_Required_Id], [e1].[Name], [e1].[OneToMany_Optional_InverseId], [e1].[OneToMany_Optional_Self_InverseId], [e1].[OneToMany_Required_InverseId], [e1].[OneToMany_Required_Self_InverseId], [e1].[OneToOne_Optional_PK_InverseId], [e1].[OneToOne_Optional_SelfId]
+    FROM [Level2] AS [e1]
+) AS [t] ON [e].[Id] = [t].[Level1_Optional_Id]
+LEFT JOIN [Level3] AS [l1] ON [l1].[Id] = [t].[Id]
+WHERE ([e].[Name] <> N'L1 03') OR [e].[Name] IS NULL
+ORDER BY [e].[Id]
+OFFSET @__p_0 ROWS FETCH NEXT @__p_1 ROWS ONLY
+
+@__p_0: ?
+@__p_1: ?
+
+SELECT [l].[Id], [l].[Level1_Optional_Id], [l].[Level1_Required_Id], [l].[Name], [l].[OneToMany_Optional_InverseId], [l].[OneToMany_Optional_Self_InverseId], [l].[OneToMany_Required_InverseId], [l].[OneToMany_Required_Self_InverseId], [l].[OneToOne_Optional_PK_InverseId], [l].[OneToOne_Optional_SelfId], [l0].[Id], [l0].[Level2_Optional_Id], [l0].[Level2_Required_Id], [l0].[Name], [l0].[OneToMany_Optional_InverseId], [l0].[OneToMany_Optional_Self_InverseId], [l0].[OneToMany_Required_InverseId], [l0].[OneToMany_Required_Self_InverseId], [l0].[OneToOne_Optional_PK_InverseId], [l0].[OneToOne_Optional_SelfId]
+FROM [Level2] AS [l]
+INNER JOIN (
+    SELECT DISTINCT [t0].*
+    FROM (
+        SELECT [e].[Id]
+        FROM [Level1] AS [e]
+        LEFT JOIN (
+            SELECT [e1].[Id], [e1].[Level1_Optional_Id], [e1].[Level1_Required_Id], [e1].[Name], [e1].[OneToMany_Optional_InverseId], [e1].[OneToMany_Optional_Self_InverseId], [e1].[OneToMany_Required_InverseId], [e1].[OneToMany_Required_Self_InverseId], [e1].[OneToOne_Optional_PK_InverseId], [e1].[OneToOne_Optional_SelfId]
+            FROM [Level2] AS [e1]
+        ) AS [t] ON [e].[Id] = [t].[Level1_Optional_Id]
+        WHERE ([e].[Name] <> N'L1 03') OR [e].[Name] IS NULL
+        ORDER BY [e].[Id]
+        OFFSET @__p_0 ROWS FETCH NEXT @__p_1 ROWS ONLY
+    ) AS [t0]
+) AS [e2] ON [l].[OneToMany_Optional_InverseId] = [e2].[Id]
+LEFT JOIN [Level3] AS [l0] ON [l0].[Level2_Optional_Id] = [l].[Id]
+ORDER BY [e2].[Id]",
+                Sql);
+        }
+
+        public override void Join_flattening_bug_4539()
+        {
+            base.Join_flattening_bug_4539();
+
+            Assert.Equal(
+                @"",
+                Sql);
+
+        }
+
+        public override void Query_source_materialization_bug_4547()
+        {
+            base.Query_source_materialization_bug_4547();
+
+            Assert.Equal(
+                @"",
+                Sql);
+        }
+
+
         // issue #3491
         //[Fact]
         public virtual void Multiple_complex_includes_from_sql()
diff --git a/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/GearsOfWarQuerySqlServerTest.cs b/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/GearsOfWarQuerySqlServerTest.cs
@@ -281,15 +281,15 @@ public override void Select_Where_Navigation_Included()
             base.Select_Where_Navigation_Included();
 
             Assert.Equal(
-                @"SELECT [o].[Id], [o].[GearNickName], [o].[GearSquadId], [o].[Note], [g].[Nickname], [g].[SquadId], [g].[AssignedCityName], [g].[CityOrBirthName], [g].[Discriminator], [g].[FullName], [g].[LeaderNickname], [g].[LeaderSquadId], [g].[Rank]
+                @"SELECT [o].[Id], [o].[GearNickName], [o].[GearSquadId], [o].[Note], [o.Gear].[Nickname], [o.Gear].[SquadId], [o.Gear].[AssignedCityName], [o.Gear].[CityOrBirthName], [o.Gear].[Discriminator], [o.Gear].[FullName], [o.Gear].[LeaderNickname], [o.Gear].[LeaderSquadId], [o.Gear].[Rank], [g].[Nickname], [g].[SquadId], [g].[AssignedCityName], [g].[CityOrBirthName], [g].[Discriminator], [g].[FullName], [g].[LeaderNickname], [g].[LeaderSquadId], [g].[Rank]
 FROM [CogTag] AS [o]
-INNER JOIN [Gear] AS [o.Gear] ON ([o].[GearNickName] = [o.Gear].[Nickname]) AND ([o].[GearSquadId] = [o.Gear].[SquadId])
+LEFT JOIN [Gear] AS [o.Gear] ON ([o].[GearNickName] = [o.Gear].[Nickname]) AND ([o].[GearSquadId] = [o.Gear].[SquadId])
 LEFT JOIN (
     SELECT [g].*
     FROM [Gear] AS [g]
     WHERE [g].[Discriminator] IN (N'Officer', N'Gear')
 ) AS [g] ON ([o].[GearNickName] = [g].[Nickname]) AND ([o].[GearSquadId] = [g].[SquadId])
-WHERE [o.Gear].[Nickname] = N'Marcus'",
+ORDER BY [o].[GearNickName], [o].[GearSquadId]",
                 Sql);
         }
 
@@ -468,16 +468,18 @@ public override void Include_with_nested_navigation_in_order_by()
             base.Include_with_nested_navigation_in_order_by();
 
             Assert.Equal(
-                @"SELECT [w].[Id], [w].[AmmunitionType], [w].[IsAutomatic], [w].[Name], [w].[OwnerFullName], [w].[SynergyWithId], [g].[Nickname], [g].[SquadId], [g].[AssignedCityName], [g].[CityOrBirthName], [g].[Discriminator], [g].[FullName], [g].[LeaderNickname], [g].[LeaderSquadId], [g].[Rank]
+                @"SELECT [w.Owner.CityOfBirth].[Name], [w.Owner.CityOfBirth].[Location]
+FROM [City] AS [w.Owner.CityOfBirth]
+
+SELECT [w].[Id], [w].[AmmunitionType], [w].[IsAutomatic], [w].[Name], [w].[OwnerFullName], [w].[SynergyWithId], [w.Owner].[Nickname], [w.Owner].[SquadId], [w.Owner].[AssignedCityName], [w.Owner].[CityOrBirthName], [w.Owner].[Discriminator], [w.Owner].[FullName], [w.Owner].[LeaderNickname], [w.Owner].[LeaderSquadId], [w.Owner].[Rank], [g].[Nickname], [g].[SquadId], [g].[AssignedCityName], [g].[CityOrBirthName], [g].[Discriminator], [g].[FullName], [g].[LeaderNickname], [g].[LeaderSquadId], [g].[Rank]
 FROM [Weapon] AS [w]
-INNER JOIN [Gear] AS [w.Owner] ON [w].[OwnerFullName] = [w.Owner].[FullName]
-INNER JOIN [City] AS [w.Owner.CityOfBirth] ON [w.Owner].[CityOrBirthName] = [w.Owner.CityOfBirth].[Name]
+LEFT JOIN [Gear] AS [w.Owner] ON [w].[OwnerFullName] = [w.Owner].[FullName]
 LEFT JOIN (
     SELECT [g].*
     FROM [Gear] AS [g]
     WHERE [g].[Discriminator] IN (N'Officer', N'Gear')
 ) AS [g] ON [w].[OwnerFullName] = [g].[FullName]
-ORDER BY [w.Owner.CityOfBirth].[Name]",
+ORDER BY [w].[OwnerFullName]",
                 Sql);
         }
 
diff --git a/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/QueryNavigationsSqlServerTest.cs b/test/Microsoft.EntityFrameworkCore.SqlServer.FunctionalTests/QueryNavigationsSqlServerTest.cs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-`
`2`	`1`	`Microsoft Visual Studio Solution File, Format Version 12.00`
`3`	`2`	`# Visual Studio 14`
`4`	`3`	`VisualStudioVersion = 14.0.25025.0`
Original file line number	Diff line number	Diff line change
`@@ -248,8 +248,7 @@ public virtual void Include_navigation_on_derived_type()`
`248`	`248`	`}`
`249`	`249`	`}`
`250`	`250`
`251`		`- // TODO: include doesn't work with optional navigations`
`252`		`- ////[ConditionalFact]`
	`251`	`+ [ConditionalFact]`
`253`	`252`	`public virtual void Select_Where_Navigation_Included()`
`254`	`253`	`{`
`255`	`254`	`using (var context = CreateContext())`
`@@ -400,8 +399,7 @@ public virtual void Include_with_join_and_inheritance3()`
`400`	`399`	`}`
`401`	`400`	`}`
`402`	`401`
`403`		`- // TODO: include doesn't work with optional navigations`
`404`		`- ////[ConditionalFact]`
	`402`	`+ [ConditionalFact]`
`405`	`403`	`public virtual void Include_with_nested_navigation_in_order_by()`
`406`	`404`	`{`
`407`	`405`	`using (var context = CreateContext())`
Original file line number	Diff line number	Diff line change
`@@ -177,8 +177,7 @@ from o2 in context.Set<Order>()`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`- // TODO: include doesn't work with optional navigations`
`181`		`- ////[ConditionalFact]`
	`180`	`+ [ConditionalFact]`
`182`	`181`	`public virtual void Select_Where_Navigation_Included()`
`183`	`182`	`{`
`184`	`183`	`using (var context = CreateContext())`