private void SetupContext(F1Context context)
        {
            var drivers = context.Drivers;
            drivers.Load();

            foreach (var driver in drivers.Local.Where(d => d.TeamId == DeletedTeam).ToList())
            {
                drivers.Remove(driver);
            }

            foreach (var driver in drivers.Local.Where(d => d.TeamId == ModifedTeam).ToList())
            {
                driver.Races = 5;
            }

            drivers.Add(
                new Driver
                    {
                        Name = "Pedro de la Rosa",
                        TeamId = AddedTeam,
                        CarNumber = 13
                    });
            drivers.Add(
                new Driver
                    {
                        Name = "Kamui Kobayashi",
                        TeamId = AddedTeam,
                        CarNumber = null
                    });
        }

        public void Lazy_loading_entity_collection_works_on_modified_entity()
        {
            using (var context = new F1Context())
            {
                var team = context.Teams.FirstOrDefault();
                team.Constructor = "Fooblearius Fooblebar";

                Assert.True(team.Drivers.Count > 0);
            }
        }

        public void Lazy_loading_entity_collection_does_not_work_on_deleted_entity()
        {
            using (var context = new F1Context())
            {
                var team = context.Teams.FirstOrDefault();
                var objectContext = ((IObjectContextAdapter)context).ObjectContext;
                objectContext.DeleteObject(team);

                Assert.Equal(0, team.Drivers.Count);
            }
        }

        public void Lazy_loading_of_entity_reference_does_not_work_on_detached_entity()
        {
            using (var context = new F1Context())
            {
                var team = context.Teams.FirstOrDefault();
                var objectContext = ((IObjectContextAdapter)context).ObjectContext;
                objectContext.Detach(team);

                Assert.Null(team.Engine);
            }
        }

        public void Lazy_loading_of_entity_reference_works_on_modified_entity()
        {
            using (var context = new F1Context())
            {
                var teamId = context.Teams.OrderBy(t => t.Id).AsNoTracking().FirstOrDefault().Id;
                var engineId = context.Teams.Where(t => t.Id == teamId).Select(t => t.Engine).AsNoTracking().FirstOrDefault().Id;

                var team = context.Teams.Where(t => t.Id == teamId).AsNoTracking().Single();
                team.Constructor = "Fooblearius Fooblebar";

                Assert.NotNull(team.Engine);
            }
        }

        private void DbSet_Local_contains_Unchanged_Modified_and_Added_entities_but_not_Deleted_entities_implementation(
            Func<F1Context, ObservableCollection<Driver>> getLocal)
        {
            using (var context = new F1Context())
            {
                SetupContext(context);
                var local = getLocal(context);

                Assert.Equal(0, local.Count(d => d.TeamId == DeletedTeam));
                Assert.Equal(ModifiedCount, local.Count(d => d.TeamId == ModifedTeam));
                Assert.Equal(UnchangedCount, local.Count(d => d.TeamId == UnchangedTeam));
                Assert.Equal(AddedCount, local.Count(d => d.TeamId == AddedTeam));
            }
        }

        public void Non_generic_collection_navigation_property_can_be_loaded_and_IsLoaded_is_set()
        {
            using (var context = new F1Context())
            {
                context.Configuration.LazyLoadingEnabled = false;

                var team = context.Teams.Find(Team.McLaren);
                var driversCollection = context.Entry((object)team).Collection("Drivers");

                Assert.False(driversCollection.IsLoaded);
                driversCollection.Load();
                Assert.True(driversCollection.IsLoaded);
                Assert.Equal(3, team.Drivers.Count);
            }
        }

        public void Non_generic_reference_navigation_property_can_be_loaded_and_IsLoaded_is_set()
        {
            using (var context = new F1Context())
            {
                context.Configuration.LazyLoadingEnabled = false;

                var driver = context.Drivers.Single(d => d.Name == "Jenson Button");
                var teamReference = context.Entry((object)driver).Reference("Team");

                Assert.False(teamReference.IsLoaded);
                teamReference.Load();
                Assert.True(teamReference.IsLoaded);
                Assert.Equal(Team.McLaren, driver.Team.Id);
            }
        }

 public void ValidateOnSaveEnabled_flag_is_on_by_default_when_using_ObjectContext_constructor()
 {
     var objectContext = GetObjectContext(new F1Context());
     using (var context = new F1Context(objectContext, dbContextOwnsObjectContext: true))
     {
         Assert.True(context.Configuration.ValidateOnSaveEnabled);
     }
 }

 public void ValidateOnSaveEnabled_is_on_by_default_when_using_String_and_DbCompiledModel_constructor()
 {
     using (var context = new F1Context(DefaultDbName<F1Context>(), CreateF1Model()))
     {
         Assert.True(context.Configuration.ValidateOnSaveEnabled);
     }
 }

        private void TestDetectChangesWithSaveChanges(bool autoDetectChanges)
        {
            using (var context = new F1Context())
            {
                context.Database.Initialize(force: false);

                using (new TransactionScope())
                {
                    context.Configuration.AutoDetectChangesEnabled = autoDetectChanges;

                    var mclaren = context.Teams.Find(Team.McLaren);
                    var larryEntry = context.Entry(new Driver { Name = "Larry David" });
                    mclaren.Drivers.Add(larryEntry.Entity);

                    Assert.Equal(autoDetectChanges ? EntityState.Added : EntityState.Detached, larryEntry.State);

                    context.SaveChanges();

                    Assert.Equal(autoDetectChanges ? EntityState.Unchanged : EntityState.Detached, larryEntry.State);
                }
            }
        }

        public void AutoDetectChangesEnabled_is_on_by_default_and_can_be_changed()
        {
            using (var context = new F1Context())
            {
                Assert.True(context.Configuration.AutoDetectChangesEnabled);

                context.Configuration.AutoDetectChangesEnabled = false;

                Assert.False(context.Configuration.AutoDetectChangesEnabled);
            }
        }

        public void Changing_proxy_creation_flag_after_ObjectContext_is_initialized_causes_proxy_creation_flag_in_DbContext_and_ObjectContext_to_change()
        {
            using (var context = new F1Context())
            {
                ValidateProxyCreation(context, proxyCreationEnabled: true);

                context.Configuration.ProxyCreationEnabled = false;
                ValidateProxyCreation(context, proxyCreationEnabled: false);

                context.Configuration.ProxyCreationEnabled = true;
                ValidateProxyCreation(context, proxyCreationEnabled: true);
            }
        }

        public void Lazy_loading_can_be_switched_off_in_constructor_which_calls_to_base_ObjectContext_constructor()
        {
            var objectContext = GetObjectContext(new F1Context());
            objectContext.ContextOptions.LazyLoadingEnabled = true;

            using (
                var context = new F1Context(objectContext, dbContextOwnsObjectContext: true, lazyLoadingEnabled: false))
            {
                ValidateLazyLoading(context, false);
            }
        }

 public void Proxy_creation_can_be_switched_off_in_constructor_which_calls_to_base_empty_constructor()
 {
     using (var context = new F1Context(proxyCreationEnabled: false))
     {
         ValidateProxyCreation(context, proxyCreationEnabled: false);
     }
 }

        public void Proxy_creation_can_be_switched_off_in_constructor_which_calls_to_base_ObjectContext_constructor()
        {
            var objectContext = GetObjectContext(new F1Context());
            objectContext.ContextOptions.ProxyCreationEnabled = true;

            using (
                var context = new F1Context(objectContext, dbContextOwnsObjectContext: true, proxyCreationEnabled: false)
                )
            {
                ValidateProxyCreation(context, false);
            }
        }

        private void ValidateProxyCreation(F1Context context, bool proxyCreationEnabled)
        {
            Assert.Equal(proxyCreationEnabled, context.Configuration.ProxyCreationEnabled);
            Assert.Equal(proxyCreationEnabled, GetObjectContext(context).ContextOptions.ProxyCreationEnabled);

            context.ChangeTracker.Entries().ToList().ForEach(e => e.State = EntityState.Detached);

            var driver = context.Drivers.First();
            if (proxyCreationEnabled)
            {
                Assert.NotEqual(typeof(Driver), driver.GetType());
            }
            else
            {
                Assert.Equal(typeof(Driver), driver.GetType());
            }
        }

        private void TestDetectChanges(Action<F1Context> setupContext, Action<F1Context> actOnContext,
                                       bool autoDetectChanges, bool? expectDetectChanges = null)
        {
            using (var context = new F1Context())
            {
                context.Configuration.AutoDetectChangesEnabled = autoDetectChanges;

                setupContext(context);

                var mclaren = context.Teams.Find(Team.McLaren);
                var larryEntry = context.Entry(new Driver { Name = "Larry David" });
                mclaren.Drivers.Add(larryEntry.Entity);

                actOnContext(context);

                Assert.Equal(expectDetectChanges ?? autoDetectChanges ? EntityState.Added : EntityState.Detached,
                             larryEntry.State);
            }
        }

 public void Proxy_creation_is_on_by_default_when_using_empty_constructor()
 {
     using (var context = new F1Context())
     {
         ValidateProxyCreation(context, proxyCreationEnabled: true);
     }
 }

 public void ValidateOnSaveEnabled_is_on_by_default_when_using_empty_constructor()
 {
     using (var context = new F1Context())
     {
         Assert.True(context.Configuration.ValidateOnSaveEnabled);
     }
 }