public void HashCodeTest()
		{
			QualifiedName name1 = new QualifiedName("foo", "http://foo.com", "f");
			XmlQualifiedName xmlQualifiedName = new XmlQualifiedName("foo", "http://foo.com");

			Assert.AreEqual(name1.GetHashCode(), xmlQualifiedName.GetHashCode());
		}

		public void EqualsTest3()
		{
			QualifiedName name1 = new QualifiedName("foo", "http://foo.com", "f");
			QualifiedName name2 = new QualifiedName("foo", "http://foo.com", "ggg");
			
			Assert.IsTrue(name1 == name2, "Should be the same.");
		}	

		public void NotEqualsTest2()
		{
			QualifiedName name1 = new QualifiedName("foo", "http://foo.com", "f");
			QualifiedName name2 = null; 
			
			Assert.IsFalse(name1 == name2, "Should not be the same.");
		}		

		public void SuccessTest8()
		{
			string text = "<a type='a";
			QualifiedName expectedName = new QualifiedName("type", String.Empty);
			QualifiedName name = XmlParser.GetQualifiedAttributeNameAtIndex(text, text.Length);
			Assert.AreEqual(expectedName, name);
		}

		public void EqualsTest2()
		{
			QualifiedName name1 = new QualifiedName("foo", "http://foo.com", "f");
			QualifiedName name2 = new QualifiedName("foo", "http://foo.com", "f");
			
			Assert.AreEqual(name1, name2, "Should be the same.");
		}		

 public void AttributeWithPrefix()
 {
     string text = " a:test=";
     QualifiedName expectedName = new QualifiedName("test", String.Empty, "a");
     QualifiedName name = XmlParser.GetQualifiedAttributeName(text, text.Length);
     Assert.AreEqual(expectedName, name);
 }

 public void AttributeNameWithPrefix2()
 {
     string text = "<a xab:test=";
     QualifiedName expectedName = new QualifiedName("test", String.Empty, "xab");
     QualifiedName name = XmlParser.GetQualifiedAttributeNameAtIndex(text, text.IndexOf("xa"));
     Assert.AreEqual(expectedName, name);
 }

		public void SuccessTest5()
		{
			string text = "<a foo=";
			QualifiedName expectedName = new QualifiedName("foo", String.Empty);
			QualifiedName name = XmlParser.GetQualifiedAttributeNameAtIndex(text, 3);
			Assert.AreEqual(expectedName, name);
		}

		public void SuccessTest6()
		{
			string text = " foo = '#";
			QualifiedName expectedName = new QualifiedName("foo", String.Empty);
			QualifiedName name = XmlParser.GetQualifiedAttributeName(text, text.Length);
			Assert.AreEqual(expectedName, name, "Should have retrieved the attribute name 'foo'");
		}	

        public void CreateQualifiedNameCollectionInstanceUsingQualifiedNameCollection()
        {
            QualifiedName[] array = new QualifiedName[] { firstName, secondName };
            QualifiedNameCollection oldCollection = new QualifiedNameCollection(array);
            QualifiedNameCollection newCollection = new QualifiedNameCollection(oldCollection);

            Assert.AreSame(firstName, newCollection[0]);
        }

		public void Init()
		{
			firstName = new QualifiedName("first", "first-ns", "first-prefix");
			secondName = new QualifiedName("second", "second-ns", "second-prefix");	
			
			QualifiedName[] array = new QualifiedName[] { firstName, secondName };
			qualifiedNameCollection = new QualifiedNameCollection(array);
		}

		public void Init()
		{
			path = new XmlElementPath();
			firstQualifiedName = new QualifiedName("foo", "http://foo", "f");
			path.AddElement(firstQualifiedName);
			
			secondQualifiedName = new QualifiedName("bar", "http://bar", "b");
			path.AddElement(secondQualifiedName);
		}

        public override void FixtureInit()
        {
            // Note element path.
            noteElementPath = new XmlElementPath();
            QualifiedName noteQualifiedName = new QualifiedName("note", "http://www.w3schools.com");
            noteElementPath.Elements.Add(noteQualifiedName);

            // Text element path.
            textElementPath = new XmlElementPath();
            textElementPath.Elements.Add(noteQualifiedName);
            textElementPath.Elements.Add(new QualifiedName("text", "http://www.w3schools.com"));
        }

        public override void FixtureInit()
        {
            // Get shipto attributes.
            shipToPath = new XmlElementPath();
            QualifiedName shipOrderName = new QualifiedName("shiporder", "http://www.w3schools.com");
            shipToPath.Elements.Add(shipOrderName);
            shipToPath.Elements.Add(new QualifiedName("shipto", "http://www.w3schools.com"));

            shipToAttributes = SchemaCompletionData.GetAttributeCompletionData(shipToPath);

            // Get shiporder attributes.
            shipOrderPath = new XmlElementPath();
            shipOrderPath.Elements.Add(shipOrderName);

            shipOrderAttributes = SchemaCompletionData.GetAttributeCompletionData(shipOrderPath);
        }

		XmlSchemaObject FindSchemaObjectType(QualifiedName qualifiedName, string elementName, XmlSchemaCompletion schema)
		{
			switch (elementName) {
				case "element":
					return schema.FindComplexType(qualifiedName);
				case "attribute":
					return schema.FindSimpleType(qualifiedName.Name);
			}
			return null;
		}

		XmlSchemaCompletion GetSchemaForQualifiedName(QualifiedName name)
		{
			XmlSchemaCompletion schema = schemas[name.Namespace];
			if (schema != null) {
				return schema;
			}
			return currentSchema;
		}

		XmlSchemaObject FindSchemaObjectReference(QualifiedName qualifiedName, string elementName, XmlSchemaCompletion schema)
		{
			switch (elementName) {
				case "element":
					return schema.FindRootElement(qualifiedName);
				case "attribute":
					return schema.FindAttribute(qualifiedName.Name);
				case "group":
					return schema.FindGroup(qualifiedName.Name);
				case "attributeGroup":
					return schema.FindAttributeGroup(qualifiedName.Name);
			}
			return null;
		}

		/// <summary>
		/// Gets the parent element path based on the index position. This
		/// method does not compact the path so it will include all elements
		/// including those in another namespace in the path.
		/// </summary>
		static XmlElementPath GetFullParentElementPath(string xml)
		{
			XmlElementPath path = new XmlElementPath();
			IDictionary<string, string> namespacesInScope = null;
			using (StringReader reader = new StringReader(xml)) {
				using (XmlTextReader xmlReader = new XmlTextReader(reader)) {
					try {
						xmlReader.XmlResolver = null; // prevent XmlTextReader from loading external DTDs
						while (xmlReader.Read()) {
							switch (xmlReader.NodeType) {
								case XmlNodeType.Element:
									if (!xmlReader.IsEmptyElement) {
										QualifiedName elementName = new QualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI, xmlReader.Prefix);
										path.AddElement(elementName);
									}
									break;
								case XmlNodeType.EndElement:
									path.Elements.RemoveLast();
									break;
							}
						}
					} catch (XmlException) {
						namespacesInScope = xmlReader.GetNamespacesInScope(XmlNamespaceScope.All);
					}
				}
			}
			
			// Add namespaces in scope for the last element read.
			if (namespacesInScope != null) {
				foreach (KeyValuePair<string, string> ns in namespacesInScope) {
					path.NamespacesInScope.Add(new XmlNamespace(ns.Key, ns.Value));
				}
			}
			
			return path;
		}

        public void DesignSurfaceNameAttribute()
        {
            QualifiedName expectedName = new QualifiedName("Name", "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", String.Empty);

            Assert.AreEqual(expectedName, designSurfaceNameAttribute);
        }

		/// <summary>
		/// Finds an element in the schema.
		/// </summary>
		/// <remarks>
		/// Only looks at the elements that are defined in the
		/// root of the schema so it will not find any elements
		/// that are defined inside any complex types.
		/// </remarks>
		public XmlSchemaElement FindRootElement(QualifiedName name)
		{
			foreach (XmlSchemaElement element in schema.Elements.Values) {
				if (name.Equals(element.QualifiedName)) {
					return element;
				}
			}
			return null;
		}