public void TestNoSiblingsFound()
        {
            string namespaceUri = "namespaceUri";
              string localName = "localname";
              string qualifiedName = "qualifiedname";
              Mock<IElement> parent = null;
              IList<IElement> children = new List<IElement>();
              AttributeCollection attributes = new AttributeCollection();
              Element element = new Element(namespaceUri, localName, qualifiedName, parent as IElement, children, attributes);
              Assert.IsNull(element.PreviousSibling);
              namespaceUri = "namespaceUri";
              localName = "localname";
              qualifiedName = "qualifiedname";
              parent = new Mock<IElement>();
              children = new List<IElement>();
              attributes = new AttributeCollection();
              element = new Element(namespaceUri, localName, qualifiedName, parent as IElement, children, attributes);

              IList<IElement> parentChildren = new List<IElement>();
              parent.Setup(c => c.ChildElements).Returns(parentChildren);

              var previousSiblingStub = new Mock<IElement>();
              parentChildren.Add(element);
              Assert.IsNull(element.PreviousSibling);
        }

        public void TestParse()
        {
            var saxHandler = new Mock<ISaxHandler>();

              using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream())
              {
            memoryStream.Write(new System.Text.UTF8Encoding().GetBytes(_xmlToParse), 0, _xmlToParse.Length);
            memoryStream.Position = 0;

            SaxReaderImpl saxReaderImpl = new SaxReaderImpl();
            saxReaderImpl.Parse(new System.IO.StreamReader(memoryStream), saxHandler.Object);
              }

              AttributeCollection element3Attributes = new AttributeCollection();
              Attribute attr1Attribute = new Attribute();
              attr1Attribute.LocalName = "attr1";
              attr1Attribute.QName = "attr1";
              attr1Attribute.Uri = string.Empty;
              attr1Attribute.Value = "val1";
              element3Attributes.Add("attr1", attr1Attribute);

              saxHandler.Verify(c => c.StartDocument(), Times.Exactly(1));
              saxHandler.Verify(c => c.EndDocument(), Times.Exactly(1));
              saxHandler.Verify(c => c.StartElement(string.Empty, "root", "root", new AttributeCollection()));
              saxHandler.Verify(c => c.StartElement(string.Empty, "element1", "element1", new AttributeCollection()));
              saxHandler.Verify(c => c.StartElement(string.Empty, "element2", "element2", new AttributeCollection()));
              saxHandler.Verify(c => c.StartElement(string.Empty, "element3", "element3", element3Attributes));
              saxHandler.Verify(c => c.EndElement(string.Empty, "root", "root"));
              saxHandler.Verify(c => c.EndElement(string.Empty, "element1", "element1"));
              saxHandler.Verify(c => c.EndElement(string.Empty, "element2", "element2"));
              saxHandler.Verify(c => c.EndElement(string.Empty, "element3", "element3"));
              saxHandler.Verify(c => c.Characters(It.IsAny<char[]>(), It.IsAny<int>(), It.IsAny<int>()));
        }

        public void CollectionSyncProperties()
        {
            AttributeCollection collection = new AttributeCollection(null);

            Assert.Null(((ICollection)collection).SyncRoot);
            Assert.False(((ICollection)collection).IsSynchronized);
        }

            public static IFormatter CreateFormatter(this ScriptScope scriptScope, string className,
                AttributeCollection attributes)
            {
                if (scriptScope.Engine.Setup.Names.Contains("Python")) return new PythonFormatter(className, attributes);

                return new RubyFormatter(className, attributes);
            }

 /// <summary>
 /// Initialzies a new instance of Berico.LinkAnalysis.Model.Edge with
 /// the provided source and target nodes.  The source and target nodes
 /// can not be null and can not be the same.
 /// </summary>
 /// <param name="initialWeight">The precalculated weight value</param>
 /// <param name="_source">The source Node for this edge</param>
 /// <param name="_target">The target Node for this edge</param>
 /// <param name="_attributes">An existing AttributeCollection instance</param> 
 public SimilarityDataEdge(double initialWeight, INode _sourceNode, INode _targetNode, AttributeCollection _attributes)
     : base(_sourceNode, _targetNode, _attributes)
 {
     // Set the initial weight.  This will be the similarity value that
     // was calculated before this edge was created
     this.weight = initialWeight;
 }

        private PolicyDocumentEntity importFile(baseData vData,string title, string filepath)
        {
            AttributeCollection acoll = new AttributeCollection();
            acoll.GetMulti(AttributeFields.Name == "Literal");
            if (acoll.Count == 0)
                throw new Exception("can't find literal attribute");
            m_literalAttribute = acoll[0];

            XmlDocument doc = new XmlDocument();
            doc.Load(filepath);

            PolicyDocumentEntity pde = new PolicyDocumentEntity();
            pde.LibraryId = vData.Library.Id;
            pde.Name = title;

            PolicyLinkEntity ple = new PolicyLinkEntity();
            ple.Policy = new PolicyEntity();
            ple.Policy.LibraryId = pde.LibraryId;
            pde.PolicyLink = ple;

            XmlNode policySet = doc.SelectSingleNode("policy-set");
            if (policySet != null)
                loadPolicySet(1,title,ple,policySet);
            else
            {
                XmlNode policy = doc.SelectSingleNode("policy");
                loadPolicy(1,title,ple,policy);
            }

            pde.Save(true);

            return pde;
        }

 public AttributeCollection FetchAll()
 {
     AttributeCollection coll = new AttributeCollection();
     Query qry = new Query(Attribute.Schema);
     coll.LoadAndCloseReader(qry.ExecuteReader());
     return coll;
 }

        internal Rule( string name )
        {
            Check.IsNotNullOrWhitespace ( name, () => Name );
            Name = name;

            _attributes = new AttributeCollection ();
        }

 /// <summary> 表示一个可以获取或者设置其内容的对象属性
 /// </summary>
 /// <param name="property">属性信息</param>
 public ObjectProperty(PropertyInfo property)
 {
     Field = false;
     MemberInfo = property; //属性信息
     OriginalType = property.PropertyType;
     var get = property.GetGetMethod(true); //获取属性get方法,不论是否公开
     var set = property.GetSetMethod(true); //获取属性set方法,不论是否公开
     if (set != null) //set方法不为空
     {
         CanWrite = true; //属性可写
         Static = set.IsStatic; //属性是否为静态属性
         IsPublic = set.IsPublic;
     }
     if (get != null) //get方法不为空
     {
         CanRead = true; //属性可读
         Static = get.IsStatic; //get.set只要有一个静态就是静态
         IsPublic = IsPublic || get.IsPublic;
     }
     ID = System.Threading.Interlocked.Increment(ref Literacy.Sequence);
     UID = Guid.NewGuid();
     Init();
     TypeCodes = TypeInfo.TypeCodes;
     Attributes = new AttributeCollection(MemberInfo);
     var mapping = Attributes.First<IMemberMappingAttribute>();
     if (mapping != null)
     {
         MappingName = mapping.Name;
     }
 }

        public void TestTextlessConstructor()
        {
            string namespaceUri = "namespaceUri";
              string localName = "localname";
              string qualifiedName = "qualifiedname";
              var parent = new Mock<IElement>();
              List<IElement> children = new List<IElement>();
              AttributeCollection attributes = new AttributeCollection();
              Element element = new Element(namespaceUri, localName, qualifiedName, parent.Object, children, attributes);

              for (int i = 0; i < 10; i++)
              {
            children.Add(new Mock<IElement>() as IElement);
              }

              IList<IElement> parentChildren = new List<IElement>();
              parent.Setup(c => c.ChildElements).Returns(parentChildren);

              var previousSiblingStub = new Mock<IElement>();
              parentChildren.Add(previousSiblingStub.Object);
              parentChildren.Add(element);

              Assert.AreEqual(element.Attributes, attributes);
              Assert.AreEqual(element.ChildElements, children);
              Assert.AreEqual(element.FirstElement, children[0]);
              Assert.IsTrue(element.HasChildNodes);
              Assert.AreEqual(element.LastElement, children[9]);
              Assert.AreEqual(element.LocalName, localName);
              Assert.AreEqual(element.Name, qualifiedName);
              Assert.AreEqual(element.NamespaceUri, namespaceUri);
              Assert.AreEqual(element.ParentElement, parent.Object);
              Assert.AreEqual(element.PreviousSibling, previousSiblingStub.Object);
              Assert.AreEqual(element.TextContent, string.Empty);
        }

        public void TestAddingExistingAttribute()
        {
            bool exceptionThrown;
            AttributeCollection attributes = new AttributeCollection();
            AttributeValue newAttributeValue = new AttributeValue("Test Value");

            // Add attribute and attribute value
            attributes.Add("Test", newAttributeValue);

            Assert.AreEqual<string>(newAttributeValue.Value, attributes["Test"].Value);

            AttributeValue existingAttributeValue = new AttributeValue("Test Value");

            try
            {
                attributes.Add("Test", existingAttributeValue);
                exceptionThrown = false;
            }
            catch (ArgumentException)
            {
                exceptionThrown = true;
            }

            Assert.IsTrue(exceptionThrown);
        }

        public Element(string name, string text, params IAttribute[] attributes)
        {
            this._Name = name;
            this._Attributes = new AttributeCollection(attributes);
            this._Children = new NodeCollection(new Text(text));

            
        }

	public static AttributeCollection Merge(this AttributeCollection left, AttributeCollection right) {
		var result = new AttributeCollection {
			Base = left.Base.Merge(right.Base),
			Mult = left.Mult.Merge(right.Mult)
		};

		return result;
	}

	public static AttributeCollection Apply(AttributeCollection attributes) {
		AttributeCollection result =  new AttributeCollection().Merge(attributes);

		foreach (var formula in _formulas) {
			result.Base [formula.Key] = result.Base.TryGetValue (formula.Key).GetValueOrDefault (0) + formula.Value (result);
		}

		return result;
	}

		private void EnsureAttributes ()
		{
			if (attributes == null) {
				attrBag = new StateBag (true);
				if (IsTrackingViewState)
					attrBag.TrackViewState ();
				attributes = new AttributeCollection (attrBag);
			}
		}

		public void ContainsKey_SendInDictionaryWithStringKeyAndObjectArrayValueAndCheckForKey_ReturnsTrue() {
			var attributeValueCollection = A.CollectionOfFake<object>(1);
			var dictionary = new Hashtable();
			dictionary.Add("key", attributeValueCollection);

			var collection = new AttributeCollection(dictionary);

			Assert.IsTrue(collection.ContainsKey("key"));
		}

        public void TestAddingAttributeWithValue()
        {
            AttributeCollection attributes = new AttributeCollection();
            AttributeValue comparisonAttributeValue = new AttributeValue("Value");

            attributes.Add("Name", comparisonAttributeValue);

            Assert.AreEqual<string>(comparisonAttributeValue.Value, attributes["Name"].Value);
        }

		public void Index_SendInDictionaryWithStringKeyAndObjectArrayValue_IndexWithKeyContainsValue() {
			var attributeValueCollection = A.CollectionOfFake<object>(1);
			var dictionary = new Hashtable();
			dictionary.Add("key", attributeValueCollection);

			var collection = new AttributeCollection(dictionary);

			Assert.AreEqual(attributeValueCollection, collection["key"]);
		}

		public void Count_SendInDictionaryWithOnePost_ReturnsOne() {
			var attributeValueCollection = A.CollectionOfFake<object>(1);
			var dictionary = new Hashtable();
			dictionary.Add("key", attributeValueCollection);

			var collection = new AttributeCollection(dictionary);

			Assert.AreEqual(1, collection.Count);
		}

        public void ContainsTest(int count)
        {
            var attributes = GetAttributes().Take(count).ToArray();
            var attributeCollection = new AttributeCollection(attributes);

            foreach (Attribute attribute in attributes)
            {
                Assert.True(attributeCollection.Contains(attribute));
            }
        }