public void TheFactoryReturnsTheMessage()
        {
            var sut = new Factory(new FakeMessageTypeProvider(), new ObjectCreatorActivator());
            var message = sut.GetMessage(1);

            Assert.IsType<SimpleMessage>(message);
        }

        public override void Initialize()
        {
            using (var fac = new Factory())
            {
                using (var tmpDevice = new Device(fac.GetAdapter(0), DriverType.Hardware, DeviceCreationFlags.None))
                {
                    using (var rf = new RenderForm())
                    {
                        var desc = new SwapChainDescription
                        {
                            BufferCount = 1,
                            Flags = SwapChainFlags.None,
                            IsWindowed = true,
                            ModeDescription = new ModeDescription(100, 100, new Rational(60, 1), Format.R8G8B8A8_UNorm),
                            OutputHandle = rf.Handle,
                            SampleDescription = new SampleDescription(1, 0),
                            SwapEffect = SwapEffect.Discard,
                            Usage = Usage.RenderTargetOutput
                        };
                        using (var sc = new SwapChain(fac, tmpDevice, desc))
                        {
                            PresentPointer = Pulse.Magic.GetObjectVtableFunction(sc.ComPointer, VMT_PRESENT);
                            ResetTargetPointer = Pulse.Magic.GetObjectVtableFunction(sc.ComPointer, VMT_RESIZETARGET);
                        }
                    }
                }
            }

            _presentDelegate = Pulse.Magic.RegisterDelegate<Direct3D10Present>(PresentPointer);
            _presentHook = Pulse.Magic.Detours.CreateAndApply(_presentDelegate, new Direct3D10Present(Callback), "D10Present");
        }

        protected override void ClassProperties(Factory factory)
        {
            factory.RegisterInt("number", "Number");
            factory.RegisterString("flag", "Flag");

            base.ClassProperties(factory);
        }

 public MeshCompiler()
 {
     ImporterFactory = new Factory<string, IMeshImporter>();
     ImporterFactory.Add(".xml", () => new Meshes.Converters.OgreXmlConverter());
     ImporterFactory.Add(".dae", () => new Meshes.Converters.AssimpConverter());
     ImporterFactory.Add(".fbx", () => new Meshes.Converters.AssimpConverter());
 }

        protected override void ClassProperties(Factory factory)
        {
            factory.RegisterInt("number", "Number");
            factory.RegisterInt("subtractrollnumber", "SubtractRollNumber");

            base.ClassProperties(factory);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        private static Adapter GetBestAdapter()
        {
            using (var f = new Factory())
            {
                Adapter bestAdapter = null;
                long bestVideoMemory = 0;
                long bestSystemMemory = 0;

                foreach (var item in f.Adapters)
                {
                    var level = global::SharpDX.Direct3D11.Device.GetSupportedFeatureLevel(item);

                    if (level < DefaultEffectsManager.MinimumFeatureLevel)
                    {
                        continue;
                    }

                    long videoMemory = item.Description.DedicatedVideoMemory;
                    long systemMemory = item.Description.DedicatedSystemMemory;

                    if ((bestAdapter == null) || (videoMemory > bestVideoMemory) || ((videoMemory == bestVideoMemory) && (systemMemory > bestSystemMemory)))
                    {
                        bestAdapter = item;
                        bestVideoMemory = videoMemory;
                        bestSystemMemory = systemMemory;
                    }
                }

                return bestAdapter;
            }
        }

        public D3D11RenderingPane( Factory dxgiFactory, SlimDX.Direct3D11.Device d3D11Device, DeviceContext d3D11DeviceContext, D3D11HwndDescription d3D11HwndDescription )
        {
            mDxgiFactory = dxgiFactory;
            mD3D11Device = d3D11Device;
            mD3D11DeviceContext = d3D11DeviceContext;

            var swapChainDescription = new SwapChainDescription
                                       {
                                           BufferCount = 1,
                                           ModeDescription =
                                               new ModeDescription( d3D11HwndDescription.Width,
                                                                    d3D11HwndDescription.Height,
                                                                    new Rational( 60, 1 ),
                                                                    Format.R8G8B8A8_UNorm ),
                                           IsWindowed = true,
                                           OutputHandle = d3D11HwndDescription.Handle,
                                           SampleDescription = new SampleDescription( 1, 0 ),
                                           SwapEffect = SwapEffect.Discard,
                                           Usage = Usage.RenderTargetOutput
                                       };

            mSwapChain = new SwapChain( mDxgiFactory, mD3D11Device, swapChainDescription );
            mDxgiFactory.SetWindowAssociation( d3D11HwndDescription.Handle, WindowAssociationFlags.IgnoreAll );

            CreateD3D11Resources( d3D11HwndDescription.Width, d3D11HwndDescription.Height );

            PauseRendering = false;
        }

            public TopToRight()
            {
                var f = new Factory(KnownAssets.Path.Pipe.TopToRight, this.Container);

                this.Outline = f.ToImage("outline");

                this.Brown = f.ToImage("brown");
                this.Brown.Visibility = Visibility.Hidden;

                this.Green = f.ToImage("green");
                this.Green.Visibility = Visibility.Hidden;

                this.Yellow = f.ToImage("yellow");

                this.Water = f.ToWaterImages(
                    "0_8",
                    "8_16",
                    "16_24",
                    "24_32",
                    "32_40",
                    "40_48",
                    "48_56",
                    "56_64"
                );

                this.OverlayBlack = f.ToImage("black");
                this.OverlayBlack.Visibility = Visibility.Hidden;

                this.Glow = f.ToImage("glow");
            }

		public void CollapsesPreviousWhiteSpace()
		{
			var factory = new Factory();
			
			// "Hello {{~test}}"
			var document = factory.Document(
				factory.Text("Hello"),
				factory.WhiteSpace(1),
				factory.Expression(
					factory.MetaCode("{{", T.OpenTag),
					factory.MetaCode("~", T.Tilde),
					factory.Span(SpanKind.Expression, factory.Symbol("this", T.Identifier)),
					factory.MetaCode("}}", T.CloseTag)));

			factory = new Factory();

			// "Hello{{~test}}"
			var expected = factory.Document(
				factory.Text("Hello"),
				factory.WhiteSpace(1, collapsed: true),
				factory.Expression(
					factory.MetaCode("{{", T.OpenTag),
					factory.MetaCode("~", T.Tilde),
					factory.Span(SpanKind.Expression, factory.Symbol("this", T.Identifier)),
					factory.MetaCode("}}", T.CloseTag)));

			var visitor = new WhiteSpaceCollapsingParserVisitor();
			visitor.VisitBlock(document);

			var builder = new StringBuilder();
			var comparer = new EquivalanceComparer(builder, 0);

			Assert.True(comparer.Equals(expected, document), builder.ToString());
		}

		public  VTSListPresenter (Factory factory, ILocalizeService localaize)
		{	
			_vtsListViewModel = factory.Get<VTSViewModel> ();
			_vtsListViewModel.Server = ConfigurationManager.SERVER;

			Label header = new Label {
				Text = localaize.Data.vacations,// "Vacations",
				Font = Font.SystemFontOfSize (30),
				TextColor = Color.FromHex ("#000"),
				HorizontalOptions = LayoutOptions.Center
			};

			_listView = new ListView {
				ItemsSource = null,
				ItemTemplate = new DataTemplate (typeof(VTSListViewTemplate))
			};

			this.Padding = new Thickness (10, Device.OnPlatform (20, 0, 0), 10, 5);

			this.Content = new StackLayout {
				BackgroundColor = Color.FromHex ("#FFF"),
				Children = {
					header,
					_listView
				}
			};

			changeListView();
		}

 public void FactoryPropertiesAreInitializedWhenFactryIsCreated()
 {
     var factory = new Factory();
     Assert.IsNotNull(factory.CommandLineParser);
     Assert.IsNotNull(factory.FileSystem);
     Assert.IsNotNull(factory.ConsoleService);
 }

        public Order Load(int id)
        {
            var record = _context.Orders.Include(p => p.Lines)
                                        .Include(p => p.BillingContact)
                                        .Include(p => p.ShippingContact)
                                        .Include(p => p.ShippingMethod)
                                        .FirstOrDefault(o => o.OrderID == id);

            if (record == null)
                return null;

            var shippingMethodRepository = new ShippingMethodRepository(_context);

            var factory = new Factory(shippingMethodRepository);

            var shippingMethods = shippingMethodRepository.LoadAll().Select(sm => {
                var shippingMethod = sm.MapTo<ShippingMethod>();
                shippingMethod.SetPrivatePropertyValue("ShippingZone", sm.ShippingZone.MapTo<ShippingZone>());
                return shippingMethod;
            });

            var entity = record.MapTo<Order>(factory, shippingMethods);

            var lines = record.Lines.Select(l => {
                var line = l.MapTo<OrderLine>(factory);
                line.SetPrivatePropertyValue("ProductOption", l.ProductOption.MapTo<ProductOption>());
                return line;
            });

            entity.SetPrivateFieldValue("_lines", lines.ToList());
            
            return entity;
        }

		public static Response<Infante> Post(this Infante request, Factory factory,IHttpRequest httpRequest)
		{  
            request.CheckId(Operaciones.Create);
            factory.Execute(proxy=>{

                if(request.IdTerceroFactura.HasValue && request.IdTerceroFactura.Value!=default(int))
                {
                    var tercero= proxy.FirstOrDefault<Tercero>(q=>q.Id==request.IdTerceroFactura.Value);
                    tercero.AssertExists(request.IdTerceroFactura.Value);
                    request.NombreTercero=tercero.Nombre;
                    request.DocumentoTercero=tercero.Documento;
                    request.DVTercero=tercero.DigitoVerificacion;
					request.TelefonoTercero= tercero.Telefono;
					request.MailTercero= tercero.Mail;
                }

                proxy.Create<Infante>(request);
            });
		
			List<Infante> data = new List<Infante>();
			data.Add(request);
			
			return new Response<Infante>(){
				Data=data
			};	
			
		}

         public static Response<PedidoItem> Get(this PedidoItem request,Factory factory,
                                           IAuthSession authSession)
        {
            try{
            var data = factory.Execute(proxy=>{
                var visitor = ReadExtensions.CreateExpression<PedidoItem>();
                visitor.Where(r=>r.IdPedido==request.IdPedido);
                return proxy.Get(visitor);
            });
                        
            return new Response<PedidoItem>(){
                Data=data

            };
            }
            catch(Exception e){
                ResponseStatus rs = new ResponseStatus(){
                    Message= e.Message,
                    StackTrace=e.StackTrace,
                    ErrorCode= e.ToString()
                };
                return new Response<PedidoItem>(){
                    ResponseStatus=rs
                };
            }
        }

			public LeftToRight()
			{
				var f = new Factory(KnownAssets.Path.Pipe.LeftToRight, this.Container);

				this.Outline = f.ToImage("outline");

				this.Brown = f.ToImage("brown");
				this.Brown.Visibility = Visibility.Hidden;

				this.Green = f.ToImage("green");
				this.Green.Visibility = Visibility.Hidden;

				this.Yellow = f.ToImage("yellow");


			
				this.Water = f.ToWaterImages(
					"water",
					"water"
				);

				this.OverlayBlack = f.ToImage("black");
				this.OverlayBlack.Visibility = Visibility.Hidden;

				this.Glow = f.ToImage("glow");

			

			}

        public void CreateNew_ShouldInvokePassedCallbackWithNewEntity()
        {
            var factory = new Factory();
            var entity = factory.Create<TestEntity>(e => e.Name = "Explicit Value");

            Assert.Equal("Explicit Value", entity.Name);
        }

        public static void Initialize( out Factory dxgiFactory, out SlimDX.Direct3D11.Device d3d11Device )
        {
            dxgiFactory = new Factory();

            Adapter adapter = null;
            long videoMemory = 0;

            for ( var i = 0; i < dxgiFactory.GetAdapterCount(); i++ )
            {
                var tmpAdapter = dxgiFactory.GetAdapter( i );

                if ( tmpAdapter.Description.DedicatedVideoMemory > videoMemory )
                {
                    adapter = tmpAdapter;
                    videoMemory = tmpAdapter.Description.DedicatedVideoMemory;
                }
            }

            d3d11Device = null;

            try
            {
                d3d11Device = Constants.DEBUG_D3D11_DEVICE
                                  ? new SlimDX.Direct3D11.Device( adapter,
                                                                  DeviceCreationFlags.Debug,
                                                                  new[] { FeatureLevel.Level_11_0, FeatureLevel.Level_10_1, FeatureLevel.Level_10_0 } )
                                  : new SlimDX.Direct3D11.Device( adapter,
                                                                  DeviceCreationFlags.None,
                                                                  new[] { FeatureLevel.Level_11_0, FeatureLevel.Level_10_1, FeatureLevel.Level_10_0 } );
            }
            catch ( Exception e )
            {
                Console.WriteLine( "\nError: Couldn't create Direct3D 11 device (exception: " + e.Source + ", " + e.Message + ").\n" );
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DeviceContext10"/> class.
        /// </summary>
        /// <param name="handle">The window handle to associate with the device.</param>
        /// <param name="settings">The settings used to configure the device.</param>
        internal DeviceContext10(IntPtr handle, DeviceSettings10 settings)
        {
            if (handle == IntPtr.Zero)
                throw new ArgumentException("Value must be a valid window handle.", "handle");
            if (settings == null)
                throw new ArgumentNullException("settings");

            this.settings = settings;

            factory = new Factory();
            device = new Direct3D10.Device(factory.GetAdapter(settings.AdapterOrdinal), Direct3D10.DriverType.Hardware, settings.CreationFlags);

            swapChain = new SwapChain(factory, device, new SwapChainDescription
            {
                BufferCount = 1,
                Flags = SwapChainFlags.None,
                IsWindowed = true,
                ModeDescription = new ModeDescription(settings.Width, settings.Height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
                OutputHandle = handle,
                SampleDescription = new SampleDescription(1, 0),
                SwapEffect = SwapEffect.Discard,
                Usage = Usage.RenderTargetOutput
            });

            factory.SetWindowAssociation(handle, WindowAssociationFlags.IgnoreAll | WindowAssociationFlags.IgnoreAltEnter);
        }

 public Form1()
 {
     InitializeComponent();
     f = new Factory();
     f.toCompile = "C:\\lavoro-temp\\p.exe";
     f.CompilerPath = DodoPseudoCompiler.Properties.Resources.NetPath;
 }

        void ILoader.loadDico(LanguageDictionary dico, Factory factory)
        {
            // chargement du dico à partir d'une base SQLite

            // --  chargement des mots  ---------------------------------------

            List<Dictionary<string, object>> words = this.db.select("words", new string[] { "word", "type", "attributs", "definition" });
            for (int i = 0; i < words.Count; i++)
            {
                string w = (string)words[i]["word"];
                string t = (string)words[i]["type"];
                string a = (string)words[i]["attributs"];
                string d = (string)words[i]["definition"];

                if (a == null) a = "";
                if (d == null) d = "";

                Word word = factory.create(w, t, a.Split(new char[] {','}, StringSplitOptions.RemoveEmptyEntries), d);

                if (word.IsTypeOf(typeof(VerbType)))
                {
                    //charger la table de conjugaison
                    Word[] verbsConjugated = this.getConjugatedVerbsFor(word.word, factory);
                    ConjugationTable table = new ConjugationTable(word);
                    table.AddRange(verbsConjugated); // ajout des verbes à la table de conjugaison
                    dico.conjugaisonTables.Add(table); // ajout de la table de conjugaison au dictionnaire
                    dico.AddRange(verbsConjugated); // ajout des verbes au dictionnaire
                }

                dico.Add(word);
            }
        }