public void Create()
        {
            var mixer = Mixer.Create("A", "D", 1);

            Assert.That(mixer.MixerPipelineFactory, Is.TypeOf(typeof(MixerPipelineFactory)));
            Assert.That(((MixerPipelineFactory)mixer.MixerPipelineFactory).AssemblyName, Is.EqualTo("A"));

            Assert.That(mixer.AssemblyOutputDirectory, Is.EqualTo("D"));

            Assert.That(mixer.MixedTypeFinder, Is.TypeOf(typeof(MixedTypeFinder)));
            Assert.That(((MixedTypeFinder)mixer.MixedTypeFinder).TypeDiscoveryService, Is.TypeOf(typeof(AssemblyFinderTypeDiscoveryService)));

            var service = (AssemblyFinderTypeDiscoveryService)((MixedTypeFinder)mixer.MixedTypeFinder).TypeDiscoveryService;

            Assert.That(service.AssemblyFinder, Is.TypeOf(typeof(CachingAssemblyFinderDecorator)));

            var assemblyFinder = (AssemblyFinder)((CachingAssemblyFinderDecorator)service.AssemblyFinder).InnerFinder;

            Assert.That(assemblyFinder.RootAssemblyFinder, Is.TypeOf(typeof(SearchPathRootAssemblyFinder)));
            var rootAssemblyFinder = ((SearchPathRootAssemblyFinder)assemblyFinder.RootAssemblyFinder);

            Assert.That(rootAssemblyFinder.BaseDirectory, Is.EqualTo(AppDomain.CurrentDomain.BaseDirectory));
            Assert.That(rootAssemblyFinder.ConsiderDynamicDirectory, Is.False);
            Assert.That(rootAssemblyFinder.AssemblyLoader, Is.TypeOf(typeof(FilteringAssemblyLoader)));
            Assert.That(((FilteringAssemblyLoader)rootAssemblyFinder.AssemblyLoader).Filter, Is.TypeOf(typeof(LoadAllAssemblyLoaderFilter)));

            Assert.That(assemblyFinder.AssemblyLoader, Is.TypeOf(typeof(FilteringAssemblyLoader)));
            Assert.That(((FilteringAssemblyLoader)assemblyFinder.AssemblyLoader).Filter, Is.TypeOf(typeof(LoadAllAssemblyLoaderFilter)));
        }
        public void SavesMixedTypes()
        {
            AppDomainRunner.Run(
                delegate
            {
                using (MixinConfiguration.BuildNew()
                       .ForClass <BaseType1>().AddMixins(typeof(BT1Mixin1))
                       .ForClass <Page> ().AddMixin(typeof(NullMixin))
                       .EnterScope())
                {
                    Mixer mixer = Mixer.Create("Assembly", _assemblyOutputDirectory, 1);
                    mixer.PrepareOutputDirectory();
                    mixer.Execute(MixinConfiguration.ActiveConfiguration);

                    Assembly theAssembly = Assembly.LoadFile(mixer.MixerPipelineFactory.GetModulePaths(_assemblyOutputDirectory).Single());
                    var types            = theAssembly.GetTypes();

                    var concreteType = types.SingleOrDefault(t => t.BaseType == typeof(BaseType1));
                    Assert.NotNull(concreteType);
                    Assert.That(
                        MixinTypeUtility.GetClassContextForConcreteType(concreteType),
                        Is.EqualTo(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType1))));

                    object instance = Activator.CreateInstance(concreteType);
                    Assert.That(Mixin.Get <BT1Mixin1> (instance), Is.Not.Null);

                    var concreteTypeFromSystemAssembly = types.SingleOrDefault(t => t.BaseType == typeof(Page));
                    Assert.That(concreteTypeFromSystemAssembly, Is.Not.Null);

                    SafeServiceLocator.Current.GetInstance <IPipelineRegistry>().DefaultPipeline.CodeManager.LoadFlushedCode(theAssembly);

                    Type concreteTypeFromFactory = TypeFactory.GetConcreteType(typeof(BaseType1));
                    Assert.That(concreteTypeFromFactory, Is.SameAs(concreteType));

                    Assert.That(theAssembly.IsDefined(typeof(NonApplicationAssemblyAttribute), false), Is.True);
                }
            });
        }