public void SimpleBinding_String()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String), "name", "hammett"));
            Assert.AreEqual("hammett", binder.BindParameter(typeof(String), "name", node));
        }
        public void EnumSourceBinding()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(FileAccess), "name", FileAccess.Read));
            Assert.AreEqual(FileAccess.Read, binder.BindParameter(typeof(FileAccess), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "Read"));
            Assert.AreEqual(FileAccess.Read, binder.BindParameter(typeof(FileAccess), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "2"));
            Assert.AreEqual(FileAccess.Write, binder.BindParameter(typeof(FileAccess), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(int), "name", 1));
            Assert.AreEqual(FileAccess.Read, binder.BindParameter(typeof(FileAccess), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(int), "name", 2));
            Assert.AreEqual(FileAccess.Write, binder.BindParameter(typeof(FileAccess), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", ""));
            Assert.AreEqual(null, binder.BindParameter(typeof(FileAccess), "name", node));
        }
        public void SimpleBinding_Int_Invalid()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String), "name", long.MaxValue.ToString()));
            binder.BindParameter(typeof(int), "name", node);
        }
        public CompositeNode BuildNode(XDocument doc)
        {
            var rootNode = new CompositeNode("root");

            rootNode.AddChildNode(ProcessElement(doc.Root));
            return(rootNode);
        }
Exemple #5
0
        public CompositeNode BuildNode(XmlDocument doc)
        {
            CompositeNode rootNode = new CompositeNode("root");

            rootNode.AddChildNode(ProcessElement(doc.DocumentElement));
            return(rootNode);
        }
		private static CompositeNode GetParamsNode(int expectedValue)
		{
			var paramsNode = new CompositeNode("root");
			var listNode = new IndexedNode("myList");
			paramsNode.AddChildNode(listNode);
			listNode.AddChildNode(new LeafNode(typeof (int), "", expectedValue));
			return paramsNode;
		}
        public void DateTimeOffsetAlternativeSourceBinding()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String), "nameday", "24"));
            node.AddChildNode(new LeafNode(typeof(String), "namemonth", "10"));
            node.AddChildNode(new LeafNode(typeof(String), "nameyear", "2009"));

            Assert.AreEqual(new DateTimeOffset(new DateTime(2009, 10, 24)), binder.BindParameter(typeof(DateTimeOffset), "name", node));

            node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(int), "nameday", 24));
            node.AddChildNode(new LeafNode(typeof(int), "namemonth", 10));
            node.AddChildNode(new LeafNode(typeof(int), "nameyear", 2009));

            Assert.AreEqual(new DateTimeOffset(new DateTime(2009, 10, 24)), binder.BindParameter(typeof(DateTimeOffset), "name", node));
        }
        private static CompositeNode GetParamsNode(int expectedValue)
        {
            var paramsNode = new CompositeNode("root");
            var listNode   = new IndexedNode("myList");

            paramsNode.AddChildNode(listNode);
            listNode.AddChildNode(new LeafNode(typeof(int), "", expectedValue));
            return(paramsNode);
        }
		public void ArrayBindingWithIndexedNodes()
		{
			var node = new CompositeNode("unnamed");
			var indexNode = new IndexedNode("emails");
			node.AddChildNode(indexNode);
			indexNode.AddChildNode(new LeafNode(typeof (String), "", "e1"));
			indexNode.AddChildNode(new LeafNode(typeof (String), "", "e2"));
			Assert.AreEqual(new[] {"e1", "e2"}, binder.BindParameter(typeof (String[]), "emails", node));
		}
        public void DateTimeAlternativeSourceBinding()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String), "nameday", "09"));
            node.AddChildNode(new LeafNode(typeof(String), "namemonth", "03"));
            node.AddChildNode(new LeafNode(typeof(String), "nameyear", "2006"));

            Assert.AreEqual(new DateTime(2006, 03, 09), binder.BindParameter(typeof(DateTime), "name", node));

            node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(int), "nameday", 9));
            node.AddChildNode(new LeafNode(typeof(int), "namemonth", 3));
            node.AddChildNode(new LeafNode(typeof(int), "nameyear", 2006));

            Assert.AreEqual(new DateTime(2006, 03, 09), binder.BindParameter(typeof(DateTime), "name", node));
        }
        public void ArrayBindingWithIndexedNodes()
        {
            var node      = new CompositeNode("unnamed");
            var indexNode = new IndexedNode("emails");

            node.AddChildNode(indexNode);
            indexNode.AddChildNode(new LeafNode(typeof(String), "", "e1"));
            indexNode.AddChildNode(new LeafNode(typeof(String), "", "e2"));
            Assert.AreEqual(new[] { "e1", "e2" }, binder.BindParameter(typeof(String[]), "emails", node));
        }
        public void EnumSourceFlagsBinding()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(FileAttributes), "name", FileAttributes.Device | FileAttributes.Directory));
            Assert.AreEqual(FileAttributes.Device | FileAttributes.Directory,
                            binder.BindParameter(typeof(FileAttributes), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "Device", "Directory" }));
            Assert.AreEqual(FileAttributes.Device | FileAttributes.Directory,
                            binder.BindParameter(typeof(FileAttributes), "name", node));
        }
        public Node ProcessElement(XmlElement startEl)
        {
            if (IsComplex(startEl))
            {
                CompositeNode top = new CompositeNode(startEl.LocalName);
                foreach(XmlAttribute attr in startEl.Attributes)
                {
                    LeafNode leaf = new LeafNode(typeof(String), attr.LocalName, attr.Value);
                    top.AddChildNode(leaf);
                }
                foreach(XmlElement childEl in startEl.ChildNodes)
                {
                    Node childNode = ProcessElement(childEl);
                    top.AddChildNode(childNode);
                }

                return top;
            }
            else
            {
                LeafNode top = new LeafNode(typeof(String), "", "");
                return top;
            }
        }
Exemple #14
0
        public Node ProcessElement(XmlElement startEl)
        {
            if (IsComplex(startEl))
            {
                CompositeNode top = new CompositeNode(startEl.LocalName);
                foreach (XmlAttribute attr in startEl.Attributes)
                {
                    LeafNode leaf = new LeafNode(typeof(String), attr.LocalName, attr.Value);
                    top.AddChildNode(leaf);
                }
                foreach (XmlElement childEl in startEl.ChildNodes)
                {
                    Node childNode = ProcessElement(childEl);
                    top.AddChildNode(childNode);
                }

                return(top);
            }
            else
            {
                LeafNode top = new LeafNode(typeof(String), "", "");
                return(top);
            }
        }
        public void DateTimeArrayBinding()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "03/09/2006", "02/08/2006" }));
            Assert.AreEqual(new[] { new DateTime(2006, 03, 09), new DateTime(2006, 02, 08) },
                            binder.BindParameter(typeof(DateTime[]), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "03/09/2006" }));
            Assert.AreEqual(new[] { new DateTime(2006, 03, 09) },
                            binder.BindParameter(typeof(DateTime[]), "name", node));

            node = new CompositeNode("unnamed");
            Assert.AreEqual(new DateTime[0],
                            binder.BindParameter(typeof(DateTime[]), "name", node));
        }
        public void DateTimeOffsetArrayBinding()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "10/24/2009", "07/17/1965" }));
            Assert.AreEqual(new[] { new DateTimeOffset(new DateTime(2009, 10, 24)), new DateTimeOffset(new DateTime(1965, 07, 17)) },
                            binder.BindParameter(typeof(DateTimeOffset[]), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "10/24/2009" }));
            Assert.AreEqual(new[] { new DateTimeOffset(new DateTime(2009, 10, 24)) },
                            binder.BindParameter(typeof(DateTimeOffset[]), "name", node));

            node = new CompositeNode("unnamed");
            Assert.AreEqual(new DateTimeOffset[0],
                            binder.BindParameter(typeof(DateTimeOffset[]), "name", node));
        }
		public void SimpleBinding_Int()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "200"));
			Assert.AreEqual(200, binder.BindParameter(typeof(int), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(int), "name", 200));
			Assert.AreEqual(200, binder.BindParameter(typeof(int), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(float), "name", 200.1f));
			Assert.AreEqual(200, binder.BindParameter(typeof(int), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", ""));
			Assert.AreEqual(null, binder.BindParameter(typeof(int), "name", node));
		}
		public void ArrayBindingWithSimpleEntries()
		{
			var node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof (String[]), "name", new[] {"1", "2"}));
			Assert.AreEqual(new[] {"1", "2"}, binder.BindParameter(typeof (String[]), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof (String), "name", "1"));
			Assert.AreEqual(new[] {"1"}, binder.BindParameter(typeof (String[]), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof (String[]), "name", new[] {"1", "2"}));
			Assert.AreEqual(new[] {1, 2}, binder.BindParameter(typeof (int[]), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof (String), "name", "1"));
			Assert.AreEqual(new[] {1}, binder.BindParameter(typeof (int[]), "name", node));
		}
Exemple #19
0
        CompositeNode GetOrCreateIndexedNode(CompositeNode parent, string nodeName)
        {
            nodeName = NormalizeKey(nodeName);
            var node = parent.GetChildNode(nodeName);

            if (node != null && node.NodeType != NodeType.Indexed)
            {
                throw new BindingException("Attempt to create or obtain an indexed node " +
                                           "named {0}, but a node with the same exists with the type {1}", nodeName, node.NodeType);
            }

            if (node == null)
            {
                node = new IndexedNode(nodeName);
                parent.AddChildNode(node);
            }

            return((IndexedNode)node);
        }
        public void ArrayBindingWithSimpleEntries()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "1", "2" }));
            Assert.AreEqual(new[] { "1", "2" }, binder.BindParameter(typeof(String[]), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "1"));
            Assert.AreEqual(new[] { "1" }, binder.BindParameter(typeof(String[]), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "1", "2" }));
            Assert.AreEqual(new[] { 1, 2 }, binder.BindParameter(typeof(int[]), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "1"));
            Assert.AreEqual(new[] { 1 }, binder.BindParameter(typeof(int[]), "name", node));
        }
        public void SimpleBinding_Int()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String), "name", "200"));
            Assert.AreEqual(200, binder.BindParameter(typeof(int), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(int), "name", 200));
            Assert.AreEqual(200, binder.BindParameter(typeof(int), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(float), "name", 200.1f));
            Assert.AreEqual(200, binder.BindParameter(typeof(int), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", ""));
            Assert.AreEqual(null, binder.BindParameter(typeof(int), "name", node));
        }
        public void SimpleBinding_Decimal()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String), "name", "12.2"));
            Assert.AreEqual((decimal)12.2, binder.BindParameter(typeof(decimal), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(double), "name", 12.2));
            Assert.AreEqual((decimal)12.2, binder.BindParameter(typeof(decimal), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(float), "name", 12.2f));
            Assert.AreEqual((decimal)12.2, binder.BindParameter(typeof(decimal), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", ""));
            Assert.AreEqual(null, binder.BindParameter(typeof(decimal), "name", node));
        }
        public void SimpleBinding_Bool()
        {
            var node = new CompositeNode("unnamed");

            node.AddChildNode(new LeafNode(typeof(String), "name", "1"));
            Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "0"));
            Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "1", "0" }));
            Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "0", "0" }));
            Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "yes"));
            Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "true"));
            Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", "false"));
            Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(int), "name", 1));
            Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            node.AddChildNode(new LeafNode(typeof(String), "name", ""));
            Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));

            node = new CompositeNode("unnamed");
            Assert.AreEqual(null, binder.BindParameter(typeof(bool), "name", node));
        }
		public void DateTimeAlternativeSourceBindingWithNullableDateTime()
		{
			CompositeNode node = new CompositeNode("unnamed");

			node.AddChildNode(new LeafNode(typeof(String), "nameday", "09"));
			node.AddChildNode(new LeafNode(typeof(String), "namemonth", "03"));
			node.AddChildNode(new LeafNode(typeof(String), "nameyear", "2006"));

			Assert.AreEqual(new DateTime?(new DateTime(2006, 03, 09)),
							binder.BindParameter(typeof(DateTime?), "name", node));

			node = new CompositeNode("unnamed");

			node.AddChildNode(new LeafNode(typeof(int), "nameday", 9));
			node.AddChildNode(new LeafNode(typeof(int), "namemonth", 3));
			node.AddChildNode(new LeafNode(typeof(int), "nameyear", 2006));

			Assert.AreEqual(new DateTime?(new DateTime(2006, 03, 09)),
							binder.BindParameter(typeof(DateTime?), "name", node));
		}
		public void DateTimeOffsetArrayBinding()
		{
			var node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "10/24/2009", "07/17/1965" }));
			Assert.AreEqual(new[] { new DateTimeOffset(new DateTime(2009, 10, 24)), new DateTimeOffset(new DateTime(1965, 07, 17)) },
											binder.BindParameter(typeof(DateTimeOffset[]), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String[]), "name", new[] { "10/24/2009" }));
			Assert.AreEqual(new[] { new DateTimeOffset(new DateTime(2009, 10, 24)) },
											binder.BindParameter(typeof(DateTimeOffset[]), "name", node));

			node = new CompositeNode("unnamed");
			Assert.AreEqual(new DateTimeOffset[0],
											binder.BindParameter(typeof(DateTimeOffset[]), "name", node));
		}
		public void SimpleBinding_Int_Invalid()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", long.MaxValue.ToString()));
			binder.BindParameter(typeof(int), "name", node);
		}
		public void SimpleBinding_Bool()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "1"));
			Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "0"));
			Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String[]), "name", new string[] { "1", "0" }));
			Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String[]), "name", new string[] { "0", "0" }));
			Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "yes"));
			Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "true"));
			Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "false"));
			Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(int), "name", 1));
			Assert.AreEqual(true, binder.BindParameter(typeof(bool), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", ""));
			Assert.AreEqual(false, binder.BindParameter(typeof(bool), "name", node));

			node = new CompositeNode("unnamed");
			Assert.AreEqual(null, binder.BindParameter(typeof(bool), "name", node));
		}
		public void DateTimeArrayBinding()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String[]), "name", new String[] {"03/09/2006", "02/08/2006"}));
			Assert.AreEqual(new DateTime[] {new DateTime(2006, 03, 09), new DateTime(2006, 02, 08)},
			                binder.BindParameter(typeof(DateTime[]), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String[]), "name", new String[] {"03/09/2006"}));
			Assert.AreEqual(new DateTime[] {new DateTime(2006, 03, 09)},
			                binder.BindParameter(typeof(DateTime[]), "name", node));

			node = new CompositeNode("unnamed");
			Assert.AreEqual(new DateTime[0],
				binder.BindParameter(typeof(DateTime[]), "name", node));
		}
		public void SimpleBinding_String()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "hammett"));
			Assert.AreEqual("hammett", binder.BindParameter(typeof(String), "name", node));
		}
		public void SimpleBinding_Decimal()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "12.2"));
			Assert.AreEqual((decimal)12.2, binder.BindParameter(typeof(decimal), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(double), "name", 12.2));
			Assert.AreEqual((decimal)12.2, binder.BindParameter(typeof(decimal), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(float), "name", 12.2f));
			Assert.AreEqual((decimal)12.2, binder.BindParameter(typeof(decimal), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", ""));
			Assert.AreEqual(null, binder.BindParameter(typeof(decimal), "name", node));
		}
		public void DateTimeOffsetAlternativeSourceBindingWithNullableDateTime()
		{
			var node = new CompositeNode("unnamed");

			node.AddChildNode(new LeafNode(typeof(String), "nameday", "24"));
			node.AddChildNode(new LeafNode(typeof(String), "namemonth", "10"));
			node.AddChildNode(new LeafNode(typeof(String), "nameyear", "2009"));

			Assert.AreEqual(new DateTimeOffset(new DateTime(2009, 10, 24)),
											binder.BindParameter(typeof(DateTimeOffset?), "name", node));

			node = new CompositeNode("unnamed");

			node.AddChildNode(new LeafNode(typeof(int), "nameday", 24));
			node.AddChildNode(new LeafNode(typeof(int), "namemonth", 10));
			node.AddChildNode(new LeafNode(typeof(int), "nameyear", 2009));

			Assert.AreEqual(new DateTimeOffset(new DateTime(2009, 10, 24)),
											binder.BindParameter(typeof(DateTimeOffset?), "name", node));
		}
 public void AddToRoot(CompositeNode rootNode, XmlDocument doc)
 {
     Node top = ProcessElement(doc.DocumentElement);
     rootNode.AddChildNode(top);
 }
        public void AddToRoot(CompositeNode rootNode, XDocument doc)
        {
            var top = ProcessElement(doc.Root);

            rootNode.AddChildNode(top);
        }
		public void EnumSourceBinding()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(FileAccess), "name", FileAccess.Read));
			Assert.AreEqual(FileAccess.Read, binder.BindParameter(typeof(FileAccess), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "Read"));
			Assert.AreEqual(FileAccess.Read, binder.BindParameter(typeof(FileAccess), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", "2"));
			Assert.AreEqual(FileAccess.Write, binder.BindParameter(typeof(FileAccess), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(int), "name", 1));
			Assert.AreEqual(FileAccess.Read, binder.BindParameter(typeof(FileAccess), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(int), "name", 2));
			Assert.AreEqual(FileAccess.Write, binder.BindParameter(typeof(FileAccess), "name", node));

			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String), "name", ""));
			Assert.AreEqual(null, binder.BindParameter(typeof(FileAccess), "name", node));
		}
Exemple #35
0
        public void AddToRoot(CompositeNode rootNode, XmlDocument doc)
        {
            Node top = ProcessElement(doc.DocumentElement);

            rootNode.AddChildNode(top);
        }
		public void EnumSourceFlagsBinding()
		{
			CompositeNode node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(FileAttributes), "name", FileAttributes.Device|FileAttributes.Directory));
			Assert.AreEqual(FileAttributes.Device|FileAttributes.Directory, binder.BindParameter(typeof(FileAttributes), "name", node));
			
			node = new CompositeNode("unnamed");
			node.AddChildNode(new LeafNode(typeof(String[]), "name", new String[] { "Device", "Directory" }));
			Assert.AreEqual(FileAttributes.Device|FileAttributes.Directory, binder.BindParameter(typeof(FileAttributes), "name", node));
		}
        public CompositeNode BuildNode(XmlDocument doc)
        {
            CompositeNode rootNode = new CompositeNode("root");
			rootNode.AddChildNode(ProcessElement(doc.DocumentElement));
            return rootNode;
        }
Exemple #38
0
 void AddLeafNode(CompositeNode parent, Type type, string nodeName, object value)
 {
     parent.AddChildNode(new LeafNode(type, NormalizeKey(nodeName), value));
 }