From 4869fa32f32806bcd51e615c4cc9b69b408988e2 Mon Sep 17 00:00:00 2001 From: Matt Ward Date: Sun, 6 Dec 2009 14:48:23 +0000 Subject: [PATCH] Improved xml completion when a document uses multiple xml schemas. git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@5295 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61 --- .../XmlEditor/Project/Src/QualifiedName.cs | 5 + .../XmlEditor/Project/Src/XmlElementPath.cs | 16 ++ .../Project/Src/XmlElementPathsByNamespace.cs | 85 +++++++ .../XmlEditor/Project/Src/XmlNamespace.cs | 14 ++ .../Project/Src/XmlNamespaceCollection.cs | 36 +++ .../XmlEditor/Project/Src/XmlParser.cs | 111 +++------ .../Project/Src/XmlSchemaCompletion.cs | 30 ++- .../Src/XmlSchemaCompletionCollection.cs | 83 +++++-- .../XmlEditor/Project/XmlEditor.addin | 17 +- .../XmlEditor/Project/XmlEditor.csproj | 2 + ...paceAttributeValueCompletionTestFixture.cs | 2 +- .../ElementCompletionWindowTestFixture.cs | 2 +- .../ActiveElementStartPathTestFixture.cs | 33 +-- .../Parser/ActiveElementUnderCursorTests.cs | 50 ++-- .../Parser/NamespacesInScopeForPathTests.cs | 48 ++++ .../Parser/ParentElementPathTestFixture.cs | 23 +- .../Parser/XamlMixedNamespaceTestFixture.cs | 24 +- .../ChangeElementPathDefaultNamespaceTests.cs | 16 +- ...EmptyElementPathsByNamespaceTestFixture.cs | 32 +++ .../Test/Paths/NamespacesWithoutPathsTests.cs | 42 ++++ .../Test/Paths/NoElementPathTestFixture.cs | 2 +- .../Paths/OneAndTwoElementPathsTestFixture.cs | 54 +++++ .../Test/Paths/QualifiedNameToStringTests.cs | 8 + ...SingleElementPathByNamespaceTestFixture.cs | 42 ++++ .../Paths/SingleElementPathTestFixture.cs | 8 +- .../Test/Paths/TwoElementPathTestFixture.cs | 47 +++- .../TwoElementPathsByNamespaceTestFixture.cs | 52 ++++ .../Test/Paths/XmlNamespaceCollectionTests.cs | 87 +++++++ .../Test/Paths/XmlNamespaceEqualsTests.cs | 75 ++++++ ...SchemaChildElementCompletionTestFixture.cs | 225 ++++++++++++++++++ .../Test/Schema/AbstractElementTestFixture.cs | 6 +- .../Test/Schema/AllElementTestFixture.cs | 4 +- .../Schema/AttributeAnnotationTestFixture.cs | 4 +- .../Schema/AttributeGroupRefTestFixture.cs | 2 +- .../Test/Schema/AttributeRefTestFixture.cs | 2 +- .../AttributeValueAnnotationTestFixture.cs | 2 +- .../ChildElementAttributesTestFixture.cs | 4 +- .../Test/Schema/ChoiceTestFixture.cs | 10 +- .../ComplexContentExtensionTestFixture.cs | 10 +- .../Schema/DuplicateElementTestFixture.cs | 2 +- .../Schema/ElementAnnotationTestFixture.cs | 2 +- .../Schema/ElementRefAnnotationTestFixture.cs | 2 +- .../ElementWithAttributeSchemaTestFixture.cs | 4 +- .../Schema/EnumAttributeValueTestFixture.cs | 2 +- .../Schema/ExtensionElementTestFixture.cs | 10 +- ...FindAttributeFromComplexTypeTestFixture.cs | 2 +- .../Schema/GroupRefCompositorTestFixture.cs | 4 +- .../Test/Schema/GroupRefTestFixture.cs | 6 +- .../Schema/MissingSchemaElementTestFixture.cs | 4 +- .../NestedAttributeGroupRefTestFixture.cs | 2 +- .../Test/Schema/NestedChoiceTestFixture.cs | 8 +- .../Schema/NestedElementSchemaTestFixture.cs | 2 +- .../Test/Schema/NestedSequenceTestFixture.cs | 10 +- .../Schema/ReferencedElementsTestFixture.cs | 6 +- .../Schema/RestrictionElementTestFixture.cs | 6 +- .../Test/Schema/SequencedChoiceTestFixture.cs | 10 +- .../SimpleContentWithAttributeTestFixture.cs | 2 +- .../Schema/SingleElementSchemaTestFixture.cs | 2 +- .../Schema/TwoElementSchemaTestFixture.cs | 6 +- .../Schema/XhtmlStrictSchemaTestFixture.cs | 6 +- .../Test/Schema/XsdSchemaTestFixture.cs | 44 ++-- .../XmlEditor/Test/XmlEditor.Tests.csproj | 10 + 62 files changed, 1185 insertions(+), 282 deletions(-) create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPathsByNamespace.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespaceCollection.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Parser/NamespacesInScopeForPathTests.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Paths/EmptyElementPathsByNamespaceTestFixture.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NamespacesWithoutPathsTests.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Paths/OneAndTwoElementPathsTestFixture.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathByNamespaceTestFixture.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathsByNamespaceTestFixture.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceCollectionTests.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceEqualsTests.cs create mode 100644 src/AddIns/DisplayBindings/XmlEditor/Test/Schema.Multiple/TwoSchemaChildElementCompletionTestFixture.cs diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/QualifiedName.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/QualifiedName.cs index 02fd6e3838..c99337cde7 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/QualifiedName.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/QualifiedName.cs @@ -33,6 +33,11 @@ namespace ICSharpCode.XmlEditor { } + public QualifiedName(string name, XmlNamespace ns) + : this(name, ns.Name, ns.Prefix) + { + } + public QualifiedName(string name, string namespaceUri, string prefix) { xmlQualifiedName = new XmlQualifiedName(name, namespaceUri); diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPath.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPath.cs index dc80cac2ea..3b07f56465 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPath.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPath.cs @@ -6,6 +6,7 @@ // using System; +using System.Collections.Generic; using System.Text; namespace ICSharpCode.XmlEditor @@ -17,6 +18,7 @@ namespace ICSharpCode.XmlEditor public class XmlElementPath { QualifiedNameCollection elements = new QualifiedNameCollection(); + XmlNamespaceCollection namespacesInScope = new XmlNamespaceCollection(); public XmlElementPath() { @@ -30,6 +32,11 @@ namespace ICSharpCode.XmlEditor get { return elements; } } + public void AddElement(QualifiedName elementName) + { + elements.Add(elementName); + } + public bool IsEmpty { get { return elements.IsEmpty; } } @@ -52,6 +59,15 @@ namespace ICSharpCode.XmlEditor } } + public XmlNamespaceCollection NamespacesInScope { + get { return namespacesInScope; } + } + + public string GetNamespaceForPrefix(string prefix) + { + return namespacesInScope.GetNamespaceForPrefix(prefix); + } + /// /// An xml element path is considered to be equal if /// each path item has the same name and namespace. diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPathsByNamespace.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPathsByNamespace.cs new file mode 100644 index 0000000000..474040c769 --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlElementPathsByNamespace.cs @@ -0,0 +1,85 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; + +namespace ICSharpCode.XmlEditor +{ + public class XmlElementPathsByNamespace : Collection + { + Dictionary pathsByNamespace = new Dictionary(); + XmlNamespaceCollection namespacesWithoutPaths = new XmlNamespaceCollection(); + + public XmlElementPathsByNamespace(XmlElementPath path) + { + SeparateIntoPathsByNamespace(path); + AddSeparatedPathsToCollection(); + FindNamespacesWithoutAssociatedPaths(path.NamespacesInScope); + pathsByNamespace.Clear(); + } + + void SeparateIntoPathsByNamespace(XmlElementPath path) + { + foreach (QualifiedName elementName in path.Elements) { + XmlElementPath matchedPath = FindOrCreatePath(elementName.Namespace); + matchedPath.AddElement(elementName); + } + } + + XmlElementPath FindOrCreatePath(string elementNamespace) + { + XmlElementPath path = FindPath(elementNamespace); + if (path != null) { + return path; + } + return CreatePath(elementNamespace); + } + + XmlElementPath FindPath(string elementNamespace) + { + XmlElementPath path; + if (pathsByNamespace.TryGetValue(elementNamespace, out path)) { + return path; + } + return null; + } + + XmlElementPath CreatePath(string elementNamespace) + { + XmlElementPath path = new XmlElementPath(); + pathsByNamespace.Add(elementNamespace, path); + return path; + } + + void AddSeparatedPathsToCollection() + { + foreach (KeyValuePair dictionaryEntry in pathsByNamespace) { + Add(dictionaryEntry.Value); + } + } + + void FindNamespacesWithoutAssociatedPaths(XmlNamespaceCollection namespacesInScope) + { + foreach (XmlNamespace ns in namespacesInScope) { + if (!HavePathForNamespace(ns)) { + namespacesWithoutPaths.Add(ns); + } + } + } + + bool HavePathForNamespace(XmlNamespace ns) + { + return pathsByNamespace.ContainsKey(ns.Name); + } + + public XmlNamespaceCollection NamespacesWithoutPaths { + get { return namespacesWithoutPaths; } + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespace.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespace.cs index 2e2748673c..083bd98375 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespace.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespace.cs @@ -78,5 +78,19 @@ namespace ICSharpCode.XmlEditor } return new XmlNamespace(); } + + public override bool Equals(object obj) + { + XmlNamespace rhs = obj as XmlNamespace; + if (rhs != null) { + return (Name == rhs.Name) && (Prefix == rhs.Prefix); + } + return false; + } + + public override int GetHashCode() + { + return Name.GetHashCode() ^ Prefix.GetHashCode(); + } } } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespaceCollection.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespaceCollection.cs new file mode 100644 index 0000000000..1aa5c95a65 --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlNamespaceCollection.cs @@ -0,0 +1,36 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; + +namespace ICSharpCode.XmlEditor +{ + public class XmlNamespaceCollection : Collection + { + public XmlNamespaceCollection() + { + } + + public XmlNamespace[] ToArray() + { + List namespaces = new List(this); + return namespaces.ToArray(); + } + + public string GetNamespaceForPrefix(string prefix) + { + foreach (XmlNamespace ns in this) { + if (ns.Prefix == prefix) { + return ns.Name; + } + } + return String.Empty; + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlParser.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlParser.cs index dc75f73a4d..0b55e4a1f3 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlParser.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlParser.cs @@ -30,7 +30,7 @@ namespace ICSharpCode.XmlEditor XmlParser() { } - + /// /// Gets path of the xml element start tag that the specified /// is currently inside. @@ -39,8 +39,11 @@ namespace ICSharpCode.XmlEditor /// is returned. public static XmlElementPath GetActiveElementStartPath(string xml, int index) { - QualifiedNameCollection namespaces = new QualifiedNameCollection(); - return GetActiveElementStartPath(xml, index, namespaces); + string elementText = GetActiveElementStartText(xml, index); + if (elementText != null) { + return GetActiveElementStartPath(xml, index, elementText); + } + return new XmlElementPath(); } /// @@ -53,8 +56,25 @@ namespace ICSharpCode.XmlEditor /// is returned. public static XmlElementPath GetActiveElementStartPathAtIndex(string xml, int index) { - QualifiedNameCollection namespaces = new QualifiedNameCollection(); - return GetActiveElementStartPathAtIndex(xml, index, namespaces); + // Find first non xml element name character to the right of the index. + index = GetCorrectedIndex(xml.Length, index); + if (index < 0) { // can happen when xml.Length==0 + return new XmlElementPath(); + } + + int currentIndex = index; + for (; currentIndex < xml.Length; ++currentIndex) { + char ch = xml[currentIndex]; + if (!IsXmlNameChar(ch)) { + break; + } + } + + string elementText = GetElementNameAtIndex(xml, currentIndex); + if (elementText != null) { + return GetActiveElementStartPath(xml, currentIndex, elementText); + } + return new XmlElementPath(); } /// @@ -62,10 +82,7 @@ namespace ICSharpCode.XmlEditor /// public static XmlElementPath GetParentElementPath(string xml) { - QualifiedNameCollection namespaces = new QualifiedNameCollection(); - XmlElementPath path = GetFullParentElementPath(xml, namespaces); - path.Compact(); - return path; + return GetFullParentElementPath(xml); } /// @@ -158,9 +175,8 @@ namespace ICSharpCode.XmlEditor string name = GetAttributeNameAtIndex(xml, index); QualifiedName qualifiedName = QualifiedName.FromString(name); if (!qualifiedName.IsEmpty && !qualifiedName.HasNamespace && includeNamespace) { - QualifiedNameCollection namespaces = new QualifiedNameCollection(); - XmlElementPath path = GetActiveElementStartPathAtIndex(xml, index, namespaces); - qualifiedName.Namespace = namespaces.GetNamespaceForPrefix(path.Elements.GetLastPrefix()); + XmlElementPath path = GetActiveElementStartPathAtIndex(xml, index); + qualifiedName.Namespace = path.GetNamespaceForPrefix(path.Elements.GetLastPrefix()); } return qualifiedName; } @@ -409,9 +425,8 @@ namespace ICSharpCode.XmlEditor public static int GetActiveElementStartIndex(string xml, int index) { int elementStartIndex = -1; - int currentIndex = index - 1; - + while (currentIndex > -1) { char currentChar = xml[currentIndex]; if (currentChar == '<') { @@ -531,7 +546,7 @@ namespace ICSharpCode.XmlEditor /// /// Gets the active element path given the element text. /// - static XmlElementPath GetActiveElementStartPath(string xml, int index, string elementText, QualifiedNameCollection namespaces) + static XmlElementPath GetActiveElementStartPath(string xml, int index, string elementText) { QualifiedName elementName = GetElementName(elementText); if (elementName.IsEmpty) { @@ -540,24 +555,23 @@ namespace ICSharpCode.XmlEditor XmlNamespace elementNamespace = GetElementNamespace(elementText); - XmlElementPath path = GetFullParentElementPath(xml.Substring(0, index), namespaces); + XmlElementPath path = GetFullParentElementPath(xml.Substring(0, index)); // Try to get a namespace for the active element's prefix. - if (elementName.HasPrefix && elementNamespace.Name.Length == 0) { - elementName.Namespace = namespaces.GetNamespaceForPrefix(elementName.Prefix); + if (elementName.HasPrefix && !elementNamespace.HasName) { + elementName.Namespace = path.GetNamespaceForPrefix(elementName.Prefix); elementNamespace.Name = elementName.Namespace; elementNamespace.Prefix = elementName.Prefix; } - if (elementNamespace.Name.Length == 0) { + if (!elementNamespace.HasName) { if (path.Elements.Count > 0) { QualifiedName parentName = path.Elements[path.Elements.Count - 1]; elementNamespace.Name = parentName.Namespace; elementNamespace.Prefix = parentName.Prefix; } } - path.Elements.Add(new QualifiedName(elementName.Name, elementNamespace.Name, elementNamespace.Prefix)); - path.Compact(); + path.AddElement(new QualifiedName(elementName.Name, elementNamespace)); return path; } @@ -640,10 +654,10 @@ namespace ICSharpCode.XmlEditor /// method does not compact the path so it will include all elements /// including those in another namespace in the path. /// - static XmlElementPath GetFullParentElementPath(string xml, QualifiedNameCollection namespaces) + static XmlElementPath GetFullParentElementPath(string xml) { XmlElementPath path = new XmlElementPath(); - IDictionary namespacesInScope = null; + IDictionary namespacesInScope = null; using (StringReader reader = new StringReader(xml)) { using (XmlTextReader xmlReader = new XmlTextReader(reader)) { try { @@ -653,7 +667,7 @@ namespace ICSharpCode.XmlEditor case XmlNodeType.Element: if (!xmlReader.IsEmptyElement) { QualifiedName elementName = new QualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI, xmlReader.Prefix); - path.Elements.Add(elementName); + path.AddElement(elementName); } break; case XmlNodeType.EndElement: @@ -670,60 +684,13 @@ namespace ICSharpCode.XmlEditor // Add namespaces in scope for the last element read. if (namespacesInScope != null) { foreach (KeyValuePair ns in namespacesInScope) { - namespaces.Add(new QualifiedName(String.Empty, ns.Value, ns.Key)); + path.NamespacesInScope.Add(new XmlNamespace(ns.Key, ns.Value)); } } return path; } - /// - /// Gets path of the xml element start tag that the specified - /// is currently inside. - /// - /// If the index outside the start tag then an empty path - /// is returned. - /// Returns the namespaces that are - /// exist in the xml. - static XmlElementPath GetActiveElementStartPath(string xml, int index, QualifiedNameCollection namespaces) - { - XmlElementPath path = new XmlElementPath(); - string elementText = GetActiveElementStartText(xml, index); - if (elementText != null) { - path = GetActiveElementStartPath(xml, index, elementText, namespaces); - } - return path; - } - - /// - /// Gets path of the xml element start tag that the specified - /// is currently located. This is different to the - /// GetActiveElementStartPath method since the index can be inside the element - /// name. - /// - /// If the index outside the start tag then an empty path - /// is returned. - static XmlElementPath GetActiveElementStartPathAtIndex(string xml, int index, QualifiedNameCollection namespaces) - { - // Find first non xml element name character to the right of the index. - index = GetCorrectedIndex(xml.Length, index); - if (index < 0) // can happen when xml.Length==0 - return new XmlElementPath(); - int currentIndex = index; - for (; currentIndex < xml.Length; ++currentIndex) { - char ch = xml[currentIndex]; - if (!IsXmlNameChar(ch)) { - break; - } - } - - string elementText = GetElementNameAtIndex(xml, currentIndex); - if (elementText != null) { - return GetActiveElementStartPath(xml, currentIndex, elementText, namespaces); - } - return new XmlElementPath(); - } - static bool IsQuoteChar(char ch) { return (ch == '\"') || (ch == '\''); diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletion.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletion.cs index 0db0612a0b..9fee304318 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletion.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletion.cs @@ -28,10 +28,9 @@ namespace ICSharpCode.XmlEditor public class XmlSchemaCompletion { XmlSchema schema; - string namespaceUri = String.Empty; string fileName = String.Empty; bool readOnly; - string namespacePrefix = String.Empty; + XmlNamespace xmlNamespace = new XmlNamespace(); /// /// Stores attributes that have been prohibited whilst the code @@ -44,8 +43,8 @@ namespace ICSharpCode.XmlEditor } public string DefaultNamespacePrefix { - get { return namespacePrefix; } - set { namespacePrefix = value; } + get { return xmlNamespace.Prefix; } + set { xmlNamespace.Prefix = value; } } /// @@ -103,11 +102,15 @@ namespace ICSharpCode.XmlEditor /// Gets the namespace URI for the schema. /// public string NamespaceUri { - get { return namespaceUri; } + get { return xmlNamespace.Name; } } public bool HasNamespaceUri { - get { return !String.IsNullOrWhiteSpace(namespaceUri); } + get { return !String.IsNullOrWhiteSpace(NamespaceUri); } + } + + public XmlNamespace Namespace { + get { return xmlNamespace; } } /// @@ -124,9 +127,14 @@ namespace ICSharpCode.XmlEditor } public XmlCompletionItemCollection GetRootElementCompletion() + { + return GetRootElementCompletion(DefaultNamespacePrefix); + } + + public XmlCompletionItemCollection GetRootElementCompletion(string namespacePrefix) { XmlCompletionItemCollection items = new XmlCompletionItemCollection(); - + foreach (XmlSchemaElement element in schema.Elements.Values) { if (element.Name != null) { AddElement(items, element.Name, namespacePrefix, element.Annotation); @@ -264,7 +272,7 @@ namespace ICSharpCode.XmlEditor /// public XmlSchemaSimpleType FindSimpleType(string name) { - XmlQualifiedName qualifiedName = new XmlQualifiedName(name, namespaceUri); + XmlQualifiedName qualifiedName = new XmlQualifiedName(name, xmlNamespace.Name); return FindSimpleType(qualifiedName); } @@ -320,7 +328,7 @@ namespace ICSharpCode.XmlEditor } // Default behaviour just return the name with the namespace uri. - qualifiedName.Namespace = namespaceUri; + qualifiedName.Namespace = xmlNamespace.Name; return qualifiedName; } @@ -349,7 +357,7 @@ namespace ICSharpCode.XmlEditor /// void ReadSchema(XmlReader reader) { - try { + try { schema = XmlSchema.Read(reader, new ValidationEventHandler(SchemaValidation)); if (schema != null) { XmlSchemaSet schemaSet = new XmlSchemaSet(); @@ -357,7 +365,7 @@ namespace ICSharpCode.XmlEditor schemaSet.Add(schema); schemaSet.Compile(); - namespaceUri = schema.TargetNamespace; + xmlNamespace.Name = schema.TargetNamespace; } } finally { reader.Close(); diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletionCollection.cs b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletionCollection.cs index 2644f626da..9529db565d 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletionCollection.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/Src/XmlSchemaCompletionCollection.cs @@ -7,16 +7,13 @@ using System; using System.Collections.ObjectModel; -using System.Linq; - using ICSharpCode.Core; -using ICSharpCode.SharpDevelop.Editor.CodeCompletion; namespace ICSharpCode.XmlEditor { [Serializable()] - public class XmlSchemaCompletionCollection : Collection - { + public class XmlSchemaCompletionCollection : Collection + { public XmlSchemaCompletionCollection() { } @@ -103,9 +100,6 @@ namespace ICSharpCode.XmlEditor return null; } - /// - /// Finds the schema given the xml element path. - /// public XmlSchemaCompletion FindSchema(XmlElementPath path, XmlSchemaCompletion defaultSchema) { if (path.Elements.HasItems) { @@ -120,6 +114,11 @@ namespace ICSharpCode.XmlEditor return null; } + public XmlCompletionItemCollection GetChildElementCompletion(XmlElementPath path) + { + return GetChildElementCompletion(path, null); + } + public XmlCompletionItemCollection GetChildElementCompletion(XmlElementPath path, XmlSchemaCompletion defaultSchema) { XmlSchemaCompletion schema = FindSchema(path, defaultSchema); @@ -129,20 +128,52 @@ namespace ICSharpCode.XmlEditor return new XmlCompletionItemCollection(); } - public XmlCompletionItemCollection GetAttributeCompletion(XmlElementPath path, XmlSchemaCompletion defaultSchema) + public XmlCompletionItemCollection GetElementCompletionForAllNamespaces(XmlElementPath path, XmlSchemaCompletion defaultSchema) { - XmlSchemaCompletion schema = FindSchema(path, defaultSchema); - if (schema != null) { - return schema.GetAttributeCompletion(path); + XmlElementPathsByNamespace pathsByNamespace = new XmlElementPathsByNamespace(path); + return GetElementCompletion(pathsByNamespace, defaultSchema); + } + + public XmlCompletionItemCollection GetElementCompletion(XmlElementPathsByNamespace pathsByNamespace, XmlSchemaCompletion defaultSchema) + { + XmlCompletionItemCollection items = new XmlCompletionItemCollection(); + foreach (XmlElementPath path in pathsByNamespace) { + items.AddRange(GetChildElementCompletion(path)); } - return new XmlCompletionItemCollection(); + + XmlNamespaceCollection namespaceWithoutPaths = pathsByNamespace.NamespacesWithoutPaths; + if (!IsDefaultSchemaNamespaceDefinedInPathsByNamespace(namespaceWithoutPaths, defaultSchema)) { + namespaceWithoutPaths.Add(defaultSchema.Namespace); + } + items.AddRange(GetRootElementCompletion(namespaceWithoutPaths)); + return items; } - public XmlCompletionItemCollection GetAttributeValueCompletion(XmlElementPath path, string attributeName, XmlSchemaCompletion defaultSchema) + bool IsDefaultSchemaNamespaceDefinedInPathsByNamespace(XmlNamespaceCollection namespaces, XmlSchemaCompletion defaultSchema) + { + if (defaultSchema != null) { + return namespaces.Contains(defaultSchema.Namespace); + } + return true; + } + + public XmlCompletionItemCollection GetRootElementCompletion(XmlNamespaceCollection namespaces) + { + XmlCompletionItemCollection items = new XmlCompletionItemCollection(); + foreach (XmlNamespace ns in namespaces) { + XmlSchemaCompletion schema = this[ns.Name]; + if (schema != null) { + items.AddRange(schema.GetRootElementCompletion(ns.Prefix)); + } + } + return items; + } + + public XmlCompletionItemCollection GetAttributeCompletion(XmlElementPath path, XmlSchemaCompletion defaultSchema) { XmlSchemaCompletion schema = FindSchema(path, defaultSchema); if (schema != null) { - return schema.GetAttributeValueCompletion(path, attributeName); + return schema.GetAttributeCompletion(path); } return new XmlCompletionItemCollection(); } @@ -150,18 +181,14 @@ namespace ICSharpCode.XmlEditor public XmlCompletionItemCollection GetElementCompletion(string textUpToCursor, XmlSchemaCompletion defaultSchema) { XmlElementPath parentPath = XmlParser.GetParentElementPath(textUpToCursor); - if (parentPath.Elements.HasItems) { - return GetChildElementCompletion(parentPath, defaultSchema); - } else if (defaultSchema != null) { - return defaultSchema.GetRootElementCompletion(); - } - return new XmlCompletionItemCollection(); + return GetElementCompletionForAllNamespaces(parentPath, defaultSchema); } public XmlCompletionItemCollection GetAttributeCompletion(string textUpToCursor, XmlSchemaCompletion defaultSchema) { if (!XmlParser.IsInsideAttributeValue(textUpToCursor, textUpToCursor.Length)) { XmlElementPath path = XmlParser.GetActiveElementStartPath(textUpToCursor, textUpToCursor.Length); + path.Compact(); if (path.Elements.HasItems) { return GetAttributeCompletion(path, defaultSchema); } @@ -175,9 +202,7 @@ namespace ICSharpCode.XmlEditor string attributeName = XmlParser.GetAttributeName(textUpToCursor, textUpToCursor.Length); if (attributeName.Length > 0) { XmlElementPath elementPath = XmlParser.GetActiveElementStartPath(textUpToCursor, textUpToCursor.Length); - if (elementPath.Elements.HasItems) { - return GetAttributeValueCompletion(elementPath, attributeName, defaultSchema); - } + return GetAttributeValueCompletion(elementPath, attributeName, defaultSchema); } } return new XmlCompletionItemCollection(); @@ -192,5 +217,15 @@ namespace ICSharpCode.XmlEditor } return new XmlCompletionItemCollection(); } + + public XmlCompletionItemCollection GetAttributeValueCompletion(XmlElementPath path, string attributeName, XmlSchemaCompletion defaultSchema) + { + path.Compact(); + XmlSchemaCompletion schema = FindSchema(path, defaultSchema); + if (schema != null) { + return schema.GetAttributeValueCompletion(path, attributeName); + } + return new XmlCompletionItemCollection(); + } } } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.addin b/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.addin index 371e4b96c4..8f4053f90e 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.addin +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.addin @@ -1,4 +1,5 @@ - - - + - - + + + + + + + + + diff --git a/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.csproj b/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.csproj index 9e034acec2..5b85ed415a 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.csproj +++ b/src/AddIns/DisplayBindings/XmlEditor/Project/XmlEditor.csproj @@ -132,6 +132,7 @@ + @@ -141,6 +142,7 @@ + diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/CtrlSpaceAttributeValueCompletionTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/CtrlSpaceAttributeValueCompletionTestFixture.cs index 618d7a79c3..7f461929a0 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/CtrlSpaceAttributeValueCompletionTestFixture.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/CtrlSpaceAttributeValueCompletionTestFixture.cs @@ -69,7 +69,7 @@ namespace XmlEditor.Tests.Completion ICompletionItem[] GetXsdSchemaElementFormDefaultAttributeValues() { XmlElementPath path = new XmlElementPath(); - path.Elements.Add(new QualifiedName("schema", "http://www.w3.org/2001/XMLSchema", "xs")); + path.AddElement(new QualifiedName("schema", "http://www.w3.org/2001/XMLSchema", "xs")); return xsdSchema.GetAttributeValueCompletion(path, "elementFormDefault").ToArray(); } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/ElementCompletionWindowTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/ElementCompletionWindowTestFixture.cs index 5900ccb54a..b091618cc0 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/ElementCompletionWindowTestFixture.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Completion/ElementCompletionWindowTestFixture.cs @@ -39,7 +39,7 @@ namespace XmlEditor.Tests.Completion textEditor.Caret.Offset = 0; XmlCodeCompletionBinding completionBinding = new XmlCodeCompletionBinding(associations); - keyPressResult = completionBinding.HandleKeyPress(textEditor, '<'); + keyPressResult = completionBinding.HandleKeyPress(textEditor, '<'); } [Test] diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementStartPathTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementStartPathTestFixture.cs index 8ad5f07d7c..ff3f53daa1 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementStartPathTestFixture.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementStartPathTestFixture.cs @@ -20,57 +20,57 @@ namespace XmlEditor.Tests.Parser string namespaceURI = "http://foo.com/foo.xsd"; [Test] - public void PathTest1() + public void GetActiveElementStartPathForRootElement() { string text = "\r\n"+ " [Test] - public void OutOfStartTagPathTest1() + public void GetActiveElementStartPathWhenOutOfStartTagPath() { string text = " "; diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementUnderCursorTests.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementUnderCursorTests.cs index 30cd306811..38583e1efd 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementUnderCursorTests.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/ActiveElementUnderCursorTests.cs @@ -40,8 +40,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.IndexOf("bar ")); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -53,8 +53,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.IndexOf("bar>")); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -66,8 +66,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.IndexOf("ar>")); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -79,8 +79,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.Length - 1); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -92,8 +92,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.IndexOf("='a'")); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -105,8 +105,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.Length - 1); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -118,8 +118,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.Length); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -131,8 +131,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.Length); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -144,8 +144,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.Length); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -157,8 +157,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, text.IndexOf("Id=")); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -170,7 +170,7 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text, 2); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -184,8 +184,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text + text2, text.Length); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } @@ -198,8 +198,8 @@ namespace XmlEditor.Tests.Parser elementPath = XmlParser.GetActiveElementStartPathAtIndex(text + text2, text.Length); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); - expectedElementPath.Elements.Add(new QualifiedName("bar", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/NamespacesInScopeForPathTests.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/NamespacesInScopeForPathTests.cs new file mode 100644 index 0000000000..19761b20ff --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/NamespacesInScopeForPathTests.cs @@ -0,0 +1,48 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Parser +{ + [TestFixture] + public class NamespacesInScopeForPathTests + { + XmlNamespace xmlNamespace; + + [SetUp] + public void Init() + { + xmlNamespace = new XmlNamespace("xml", "http://www.w3.org/XML/1998/namespace"); + } + + [Test] + public void XmlNamespaceInScopeForRootElementWithNoNamespace() + { + string xml = "<"; elementPath = XmlParser.GetParentElementPath(text); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); } [Test] - public void SuccessTest2() + public void GetParentElementPathForRootElementAfterChildElementEnd() { string text = "<"; elementPath = XmlParser.GetParentElementPath(text); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); - } + } [Test] - public void SuccessTest3() + public void GetParentElementPathForRootElementAfterEmptyChildElementEnd() { string text = "<"; elementPath = XmlParser.GetParentElementPath(text); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); - } + } [Test] - public void SuccessTest4() + public void GetParentElementPathForTwoElementsInDifferentNamespaces() { string text = "<"; elementPath = XmlParser.GetParentElementPath(text); expectedElementPath = new XmlElementPath(); - expectedElementPath.Elements.Add(new QualifiedName("foo", namespaceURI)); + expectedElementPath.AddElement(new QualifiedName("bar", "http://test.com")); + expectedElementPath.AddElement(new QualifiedName("foo", namespaceURI)); Assert.IsTrue(elementPath.Equals(expectedElementPath), "Incorrect active element path."); - } + } } } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/XamlMixedNamespaceTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/XamlMixedNamespaceTestFixture.cs index ecebeb80eb..ef96665e1a 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/XamlMixedNamespaceTestFixture.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Parser/XamlMixedNamespaceTestFixture.cs @@ -62,7 +62,17 @@ namespace XmlEditor.Tests.Parser public void DesignSurfacePath() { XmlElementPath expectedPath = new XmlElementPath(); - expectedPath.Elements.Add(new QualifiedName("DesignSurface", "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", "designer")); + + string xamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"; + expectedPath.AddElement(new QualifiedName("Window", xamlNamespace)); + expectedPath.AddElement(new QualifiedName("Grid", xamlNamespace)); + expectedPath.AddElement(new QualifiedName("TabControl", xamlNamespace)); + expectedPath.AddElement(new QualifiedName("TabItem", xamlNamespace)); + + QualifiedName designSurfaceElement = new QualifiedName("DesignSurface", + "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", + "designer"); + expectedPath.AddElement(designSurfaceElement); Assert.AreEqual(expectedPath, designSurfacePath); } @@ -71,7 +81,17 @@ namespace XmlEditor.Tests.Parser public void DesignSurfacePath2() { XmlElementPath expectedPath = new XmlElementPath(); - expectedPath.Elements.Add(new QualifiedName("DesignSurface", "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", "designer")); + + string xamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation"; + expectedPath.AddElement(new QualifiedName("Window", xamlNamespace)); + expectedPath.AddElement(new QualifiedName("Grid", xamlNamespace)); + expectedPath.AddElement(new QualifiedName("TabControl", xamlNamespace)); + expectedPath.AddElement(new QualifiedName("TabItem", xamlNamespace)); + + QualifiedName designSurfaceElement = new QualifiedName("DesignSurface", + "clr-namespace:ICSharpCode.WpfDesign.Designer;assembly=ICSharpCode.WpfDesign.Designer", + "designer"); + expectedPath.AddElement(designSurfaceElement); Assert.AreEqual(expectedPath, designSurfacePath2); } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/ChangeElementPathDefaultNamespaceTests.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/ChangeElementPathDefaultNamespaceTests.cs index ee3ba16303..76b573a7db 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/ChangeElementPathDefaultNamespaceTests.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/ChangeElementPathDefaultNamespaceTests.cs @@ -18,13 +18,13 @@ namespace XmlEditor.Tests.Paths public void ChangeNamespaceForTwoElementsWithoutNamespaceModifiesAllItems() { XmlElementPath path = new XmlElementPath(); - path.Elements.Add(new QualifiedName("root", String.Empty)); - path.Elements.Add(new QualifiedName("child", String.Empty)); + path.AddElement(new QualifiedName("root", String.Empty)); + path.AddElement(new QualifiedName("child", String.Empty)); path.SetNamespaceForUnqualifiedNames("http://test"); XmlElementPath expectedPath = new XmlElementPath(); - expectedPath.Elements.Add(new QualifiedName("root", "http://test")); - expectedPath.Elements.Add(new QualifiedName("child", "http://test")); + expectedPath.AddElement(new QualifiedName("root", "http://test")); + expectedPath.AddElement(new QualifiedName("child", "http://test")); Assert.IsTrue(expectedPath.Equals(path)); } @@ -33,13 +33,13 @@ namespace XmlEditor.Tests.Paths public void ChangeNamespaceForTwoElementsWhereChildElementHasOwnNamespaceOnlyAffectsRootElement() { XmlElementPath path = new XmlElementPath(); - path.Elements.Add(new QualifiedName("root", String.Empty)); - path.Elements.Add(new QualifiedName("child", "has-namespace-already")); + path.AddElement(new QualifiedName("root", String.Empty)); + path.AddElement(new QualifiedName("child", "has-namespace-already")); path.SetNamespaceForUnqualifiedNames("http://test"); XmlElementPath expectedPath = new XmlElementPath(); - expectedPath.Elements.Add(new QualifiedName("root", "http://test")); - expectedPath.Elements.Add(new QualifiedName("child", "has-namespace-already")); + expectedPath.AddElement(new QualifiedName("root", "http://test")); + expectedPath.AddElement(new QualifiedName("child", "has-namespace-already")); Assert.IsTrue(expectedPath.Equals(path)); } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/EmptyElementPathsByNamespaceTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/EmptyElementPathsByNamespaceTestFixture.cs new file mode 100644 index 0000000000..6f1949c2f8 --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/EmptyElementPathsByNamespaceTestFixture.cs @@ -0,0 +1,32 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Paths +{ + [TestFixture] + public class EmptyElementPathsByNamespaceTestFixture + { + XmlElementPathsByNamespace paths; + + [SetUp] + public void Init() + { + XmlElementPath path = new XmlElementPath(); + paths = new XmlElementPathsByNamespace(path); + } + + [Test] + public void HasNoItemsWhenCreated() + { + Assert.AreEqual(0, paths.Count); + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NamespacesWithoutPathsTests.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NamespacesWithoutPathsTests.cs new file mode 100644 index 0000000000..d699723870 --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NamespacesWithoutPathsTests.cs @@ -0,0 +1,42 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Paths +{ + [TestFixture] + public class NamespacesWithoutPathsTests + { + XmlElementPath path; + XmlNamespace fooNamespace; + XmlNamespace barNamespace; + + [SetUp] + public void Init() + { + path = new XmlElementPath(); + fooNamespace = new XmlNamespace("foo", "http://foo"); + barNamespace = new XmlNamespace("bar", "http://bar"); + } + + [Test] + public void TwoNamespacesInScopeAndOneNamespaceUsedInPathNamespacesWithoutPathsReturnsUnusedNamespace() + { + path.AddElement(new QualifiedName("foo-root", "http://foo")); + path.NamespacesInScope.Add(fooNamespace); + path.NamespacesInScope.Add(barNamespace); + + XmlElementPathsByNamespace pathsByNamespaces = new XmlElementPathsByNamespace(path); + + XmlNamespace[] expectedNamespaces = new XmlNamespace[] {barNamespace}; + Assert.AreEqual(expectedNamespaces, pathsByNamespaces.NamespacesWithoutPaths.ToArray()); + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NoElementPathTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NoElementPathTestFixture.cs index 45e4d40f91..bdea5a3b24 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NoElementPathTestFixture.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/NoElementPathTestFixture.cs @@ -52,7 +52,7 @@ namespace XmlEditor.Tests.Paths public void NotEqual() { XmlElementPath newPath = new XmlElementPath(); - newPath.Elements.Add(new QualifiedName("Foo", "bar")); + newPath.AddElement(new QualifiedName("Foo", "bar")); Assert.IsFalse(newPath.Equals(path), "Should not be equal."); } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/OneAndTwoElementPathsTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/OneAndTwoElementPathsTestFixture.cs new file mode 100644 index 0000000000..c08c5ffffc --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/OneAndTwoElementPathsTestFixture.cs @@ -0,0 +1,54 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Paths +{ + [TestFixture] + public class OneAndTwoElementPathsByNamespaceTestFixture + { + XmlElementPathsByNamespace paths; + + [SetUp] + public void Init() + { + XmlElementPath path = new XmlElementPath(); + path.AddElement(new QualifiedName("a", "a-namespace")); + path.AddElement(new QualifiedName("b", "b-namespace")); + path.AddElement(new QualifiedName("aa", "a-namespace")); + paths = new XmlElementPathsByNamespace(path); + } + + [Test] + public void HasTwoXmlElementPaths() + { + Assert.AreEqual(2, paths.Count); + } + + [Test] + public void FirstXmlElementPathHasTwoElements() + { + XmlElementPath expectedPath = new XmlElementPath(); + expectedPath.AddElement(new QualifiedName("a", "a-namespace")); + expectedPath.AddElement(new QualifiedName("aa", "a-namespace")); + + Assert.AreEqual(expectedPath, paths[0]); + } + + [Test] + public void SecondXmlElementPathHasOneElement() + { + XmlElementPath expectedPath = new XmlElementPath(); + expectedPath.AddElement(new QualifiedName("b", "b-namespace")); + + Assert.AreEqual(expectedPath, paths[1]); + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/QualifiedNameToStringTests.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/QualifiedNameToStringTests.cs index d6182d8320..8896900b57 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/QualifiedNameToStringTests.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/QualifiedNameToStringTests.cs @@ -69,5 +69,13 @@ namespace XmlEditor.Tests.Paths QualifiedName name = new QualifiedName("root", "urn:my-uri", null); Assert.AreEqual("root [urn:my-uri]", name.ToString()); } + + [Test] + public void CreateQualifiedNameWithXmlNamespaceObject() + { + XmlNamespace ns = new XmlNamespace("prefix", "namespace"); + QualifiedName name = new QualifiedName("elementName", ns); + Assert.AreEqual("prefix:elementName [namespace]", name.ToString()); + } } } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathByNamespaceTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathByNamespaceTestFixture.cs new file mode 100644 index 0000000000..fa5af9bc7a --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathByNamespaceTestFixture.cs @@ -0,0 +1,42 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Paths +{ + [TestFixture] + public class SingleElementPathByNamespaceTestFixture + { + XmlElementPathsByNamespace paths; + + [SetUp] + public void Init() + { + XmlElementPath path = new XmlElementPath(); + path.AddElement(new QualifiedName("a", "a-namespace")); + paths = new XmlElementPathsByNamespace(path); + } + + [Test] + public void HasSingleXmlElementPath() + { + Assert.AreEqual(1, paths.Count); + } + + [Test] + public void XmlElementPathHasOneElement() + { + XmlElementPath expectedPath = new XmlElementPath(); + expectedPath.AddElement(new QualifiedName("a", "a-namespace")); + + Assert.AreEqual(expectedPath, paths[0]); + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathTestFixture.cs index 26621a0ac4..5c541f1473 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathTestFixture.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/SingleElementPathTestFixture.cs @@ -22,7 +22,7 @@ namespace XmlEditor.Tests.Paths { path = new XmlElementPath(); qualifiedName = new QualifiedName("foo", "http://foo"); - path.Elements.Add(qualifiedName); + path.AddElement(qualifiedName); } [Test] @@ -43,7 +43,7 @@ namespace XmlEditor.Tests.Paths public void Equality() { XmlElementPath newPath = new XmlElementPath(); - newPath.Elements.Add(new QualifiedName("foo", "http://foo")); + newPath.AddElement(new QualifiedName("foo", "http://foo")); Assert.IsTrue(newPath.Equals(path), "Should be equal."); } @@ -52,7 +52,7 @@ namespace XmlEditor.Tests.Paths public void NotEqual() { XmlElementPath newPath = new XmlElementPath(); - newPath.Elements.Add(new QualifiedName("Foo", "bar")); + newPath.AddElement(new QualifiedName("Foo", "bar")); Assert.IsFalse(newPath.Equals(path), "Should not be equal."); } @@ -75,7 +75,7 @@ namespace XmlEditor.Tests.Paths public void TwoElementsPathToString() { QualifiedName qualifiedName = new QualifiedName("bar", "http://foo"); - path.Elements.Add(qualifiedName); + path.AddElement(qualifiedName); Assert.AreEqual("foo [http://foo] > bar [http://foo]", path.ToString()); } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathTestFixture.cs index 277c90282b..0245bc2762 100644 --- a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathTestFixture.cs +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathTestFixture.cs @@ -5,9 +5,9 @@ // $Revision$ // +using System; using ICSharpCode.XmlEditor; using NUnit.Framework; -using System; namespace XmlEditor.Tests.Paths { @@ -23,10 +23,10 @@ namespace XmlEditor.Tests.Paths { path = new XmlElementPath(); firstQualifiedName = new QualifiedName("foo", "http://foo", "f"); - path.Elements.Add(firstQualifiedName); + path.AddElement(firstQualifiedName); secondQualifiedName = new QualifiedName("bar", "http://bar", "b"); - path.Elements.Add(secondQualifiedName); + path.AddElement(secondQualifiedName); } [Test] @@ -61,8 +61,8 @@ namespace XmlEditor.Tests.Paths public void Equality() { XmlElementPath newPath = new XmlElementPath(); - newPath.Elements.Add(new QualifiedName("foo", "http://foo", "f")); - newPath.Elements.Add(new QualifiedName("bar", "http://bar", "b")); + newPath.AddElement(new QualifiedName("foo", "http://foo", "f")); + newPath.AddElement(new QualifiedName("bar", "http://bar", "b")); Assert.IsTrue(newPath.Equals(path), "Should be equal."); } @@ -71,8 +71,8 @@ namespace XmlEditor.Tests.Paths public void NotEqual() { XmlElementPath newPath = new XmlElementPath(); - newPath.Elements.Add(new QualifiedName("aaa", "a", "a")); - newPath.Elements.Add(new QualifiedName("bbb", "b", "b")); + newPath.AddElement(new QualifiedName("aaa", "a", "a")); + newPath.AddElement(new QualifiedName("bbb", "b", "b")); Assert.IsFalse(newPath.Equals(path), "Should not be equal."); } @@ -88,7 +88,7 @@ namespace XmlEditor.Tests.Paths public void CompactPathItem() { XmlElementPath newPath = new XmlElementPath(); - newPath.Elements.Add(new QualifiedName("bar", "http://bar", "b")); + newPath.AddElement(new QualifiedName("bar", "http://bar", "b")); path.Compact(); Assert.IsTrue(newPath.Equals(path), "Should be equal."); @@ -100,5 +100,36 @@ namespace XmlEditor.Tests.Paths string expectedToString = "f:foo [http://foo] > b:bar [http://bar]"; Assert.AreEqual(expectedToString, path.ToString()); } + + [Test] + public void ElementPathsByNamespaceFoo() + { + XmlElementPathsByNamespace paths = new XmlElementPathsByNamespace(path); + XmlElementPath fooPath = paths[0]; + + XmlElementPath expectedPath = new XmlElementPath(); + expectedPath.AddElement(new QualifiedName("foo", "http://foo", "f")); + + Assert.IsTrue(expectedPath.Equals(fooPath)); + } + + [Test] + public void TwoElementPathsByNamespace() + { + XmlElementPathsByNamespace paths = new XmlElementPathsByNamespace(path); + Assert.AreEqual(2, paths.Count); + } + + [Test] + public void ElementPathsByNamespaceBar() + { + XmlElementPathsByNamespace paths = new XmlElementPathsByNamespace(path); + XmlElementPath barPath = paths[1]; + + XmlElementPath expectedPath = new XmlElementPath(); + expectedPath.AddElement(new QualifiedName("bar", "http://bar", "b")); + + Assert.IsTrue(expectedPath.Equals(barPath)); + } } } diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathsByNamespaceTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathsByNamespaceTestFixture.cs new file mode 100644 index 0000000000..b8c36684dd --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/TwoElementPathsByNamespaceTestFixture.cs @@ -0,0 +1,52 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Paths +{ + [TestFixture] + public class TwoElementPathsByNamespaceTestFixture + { + XmlElementPathsByNamespace paths; + + [SetUp] + public void Init() + { + XmlElementPath path = new XmlElementPath(); + path.AddElement(new QualifiedName("a", "a-namespace")); + path.AddElement(new QualifiedName("b", "b-namespace")); + paths = new XmlElementPathsByNamespace(path); + } + + [Test] + public void HasTwoXmlElementPaths() + { + Assert.AreEqual(2, paths.Count); + } + + [Test] + public void FirstXmlElementPathHasOneElement() + { + XmlElementPath expectedPath = new XmlElementPath(); + expectedPath.AddElement(new QualifiedName("a", "a-namespace")); + + Assert.AreEqual(expectedPath, paths[0]); + } + + [Test] + public void SecondXmlElementPathHasOneElement() + { + XmlElementPath expectedPath = new XmlElementPath(); + expectedPath.AddElement(new QualifiedName("b", "b-namespace")); + + Assert.AreEqual(expectedPath, paths[1]); + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceCollectionTests.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceCollectionTests.cs new file mode 100644 index 0000000000..ef73fc0d8f --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceCollectionTests.cs @@ -0,0 +1,87 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Paths +{ + [TestFixture] + public class XmlNamespaceCollectionTests + { + XmlNamespaceCollection namespaceCollection; + + [SetUp] + public void Init() + { + namespaceCollection = new XmlNamespaceCollection(); + } + + [Test] + public void ToArrayReturnsXmlNamespaceItemsInCollection() + { + XmlNamespace a = new XmlNamespace("a", "a-ns"); + XmlNamespace b = new XmlNamespace("b", "b-ns"); + + namespaceCollection.Add(a); + namespaceCollection.Add(b); + + XmlNamespace[] expectedArray = new XmlNamespace[] { a, b }; + + Assert.AreEqual(expectedArray, namespaceCollection.ToArray()); + } + + [Test] + public void GetNamespaceForPrefixReturnsPrefixForKnownNamespaceInCollection() + { + XmlNamespace ns = new XmlNamespace("prefix", "namespace"); + namespaceCollection.Add(ns); + + Assert.AreEqual("namespace", namespaceCollection.GetNamespaceForPrefix("prefix")); + } + + [Test] + public void GetNamespaceForPrefixReturnsEmptyStringForUnknownNamespaceInCollection() + { + XmlNamespace ns = new XmlNamespace("prefix", "namespace"); + namespaceCollection.Add(ns); + + Assert.AreEqual(String.Empty, namespaceCollection.GetNamespaceForPrefix("unknown-prefix")); + } + + [Test] + public void ContainsReturnsFalseForKnownNamespaceWhenPrefixDoesNotMatch() + { + XmlNamespace ns = new XmlNamespace("prefix", "namespace"); + namespaceCollection.Add(ns); + XmlNamespace namespaceWithDifferentPrefix = new XmlNamespace(String.Empty, "namespace"); + + Assert.IsFalse(namespaceCollection.Contains(namespaceWithDifferentPrefix)); + } + + [Test] + public void ContainsReturnsTrueForKnownNamespaceWhenPrefixIsEmptyString() + { + XmlNamespace ns = new XmlNamespace(String.Empty, "namespace"); + namespaceCollection.Add(ns); + + Assert.IsTrue(namespaceCollection.Contains(ns)); + } + + [Test] + public void ContainsReturnsFalseForUnknownNamespace() + { + XmlNamespace ns = new XmlNamespace("prefix", "namespace"); + namespaceCollection.Add(ns); + + XmlNamespace unknownNamespace = new XmlNamespace("prefix", "unknown-namespace"); + + Assert.IsFalse(namespaceCollection.Contains(unknownNamespace)); + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceEqualsTests.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceEqualsTests.cs new file mode 100644 index 0000000000..e93b07de31 --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Paths/XmlNamespaceEqualsTests.cs @@ -0,0 +1,75 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Paths +{ + [TestFixture] + public class XmlNamespaceEqualsTests + { + XmlNamespace lhs; + XmlNamespace rhs; + + [SetUp] + public void Init() + { + lhs = new XmlNamespace(); + rhs = new XmlNamespace(); + } + + [Test] + public void EmptyNamespacesAreEqual() + { + Assert.IsTrue(lhs.Equals(rhs)); + } + + [Test] + public void NullNamespaceIsNotEqual() + { + Assert.IsFalse(lhs.Equals(null)); + } + + [Test] + public void SameNamespaceAndPrefixAreEqual() + { + lhs.Name = "a-ns"; + lhs.Prefix = "a"; + + rhs.Name = "a-ns"; + rhs.Prefix = "a"; + + Assert.IsTrue(lhs.Equals(rhs)); + } + + [Test] + public void DifferentNamespacesAreNotEqual() + { + lhs.Name = "namespace"; + lhs.Prefix = "a"; + + rhs.Name = "different-namespace"; + rhs.Prefix = "a"; + + Assert.IsFalse(lhs.Equals(rhs)); + } + + [Test] + public void SameNamespaceButDifferentPrefixAreNotEqual() + { + lhs.Name = "namespace"; + lhs.Prefix = "a"; + + rhs.Name = "namespace"; + rhs.Prefix = "b"; + + Assert.IsFalse(lhs.Equals(rhs)); + } + } +} diff --git a/src/AddIns/DisplayBindings/XmlEditor/Test/Schema.Multiple/TwoSchemaChildElementCompletionTestFixture.cs b/src/AddIns/DisplayBindings/XmlEditor/Test/Schema.Multiple/TwoSchemaChildElementCompletionTestFixture.cs new file mode 100644 index 0000000000..ca9e4b8ff7 --- /dev/null +++ b/src/AddIns/DisplayBindings/XmlEditor/Test/Schema.Multiple/TwoSchemaChildElementCompletionTestFixture.cs @@ -0,0 +1,225 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.IO; +using ICSharpCode.XmlEditor; +using NUnit.Framework; + +namespace XmlEditor.Tests.Schema.Multiple +{ + [TestFixture] + public class TwoSchemaChildElementCompletionTestFixture + { + XmlSchemaCompletionCollection schemas; + + [SetUp] + public void Init() + { + schemas = new XmlSchemaCompletionCollection(); + foreach (string schema in GetSchemas()) { + StringReader reader = new StringReader(schema); + schemas.Add(new XmlSchemaCompletion(reader)); + } + } + + string[] GetSchemas() + { + return new string[] { GetFooSchema(), GetBarSchema() }; + } + + string GetFooSchema() + { + return + "\r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + ""; + } + + string GetBarSchema() + { + return + "\r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + ""; + } + + [Test] + public void FooSchemaRootElementAndBarRootElementInPath() + { + XmlElementPath path = new XmlElementPath(); + path.AddElement(new QualifiedName("foo-note", "foo")); + path.AddElement(new QualifiedName("bar-note", "bar", "b")); + XmlCompletionItemCollection items = schemas.GetElementCompletionForAllNamespaces(path, null); + items.Sort(); + + XmlCompletionItemCollection expectedItems = new XmlCompletionItemCollection(); + expectedItems.Add(new XmlCompletionItem("b:bar-text", XmlCompletionItemType.XmlElement)); + expectedItems.Add(new XmlCompletionItem("foo-text", XmlCompletionItemType.XmlElement)); + + Assert.AreEqual(expectedItems, items); + } + + [Test] + public void FooSchemaElementAndBarElementInXml() + { + string xml = + "\r\n" + + " \r\n" + + " <"; + + XmlCompletionItemCollection expectedItems = new XmlCompletionItemCollection(); + expectedItems.Add(new XmlCompletionItem("b:bar-text", XmlCompletionItemType.XmlElement)); + expectedItems.Add(new XmlCompletionItem("foo-text", XmlCompletionItemType.XmlElement)); + + XmlCompletionItemCollection items = schemas.GetElementCompletion(xml, null); + items.Sort(); + + Assert.AreEqual(expectedItems, items); + } + + [Test] + public void FooSchemaRootElementOnlyInPath() + { + XmlElementPath path = new XmlElementPath(); + path.NamespacesInScope.Add(new XmlNamespace("b", "bar")); + path.AddElement(new QualifiedName("foo-note", "foo")); + + XmlCompletionItemCollection items = schemas.GetElementCompletionForAllNamespaces(path, null); + items.Sort(); + + XmlCompletionItemCollection expectedItems = new XmlCompletionItemCollection(); + expectedItems.Add(new XmlCompletionItem("b:bar-note", XmlCompletionItemType.XmlElement)); + expectedItems.Add(new XmlCompletionItem("foo-text", XmlCompletionItemType.XmlElement)); + + Assert.AreEqual(expectedItems, items); + } + + [Test] + public void UnusedNamespaceInScopeCannotBeFoundInSchemaCollection() + { + XmlElementPath path = new XmlElementPath(); + path.NamespacesInScope.Add(new XmlNamespace("b", "namespace-which-does-not-exist-in-schema-collection")); + path.AddElement(new QualifiedName("foo-note", "foo")); + + XmlCompletionItemCollection items = schemas.GetElementCompletionForAllNamespaces(path, null); + items.Sort(); + + XmlCompletionItemCollection expectedItems = new XmlCompletionItemCollection(); + expectedItems.Add(new XmlCompletionItem("foo-text", XmlCompletionItemType.XmlElement)); + + Assert.AreEqual(expectedItems, items); + } + + [Test] + public void DefaultSchemaRootElementsReturnedWhenNoNamespaceExplicitlyDefinedInXmlAndXmlIsEmpty() + { + XmlSchemaCompletion defaultSchema = schemas["foo"]; + string xml = "<"; + + XmlCompletionItemCollection items = schemas.GetElementCompletion(xml, defaultSchema); + items.Sort(); + + XmlCompletionItemCollection expectedItems = new XmlCompletionItemCollection(); + expectedItems.Add(new XmlCompletionItem("foo-note", XmlCompletionItemType.XmlElement)); + + Assert.AreEqual(expectedItems, items); + } + + [Test] + public void DefaultSchemaRootElementsReturnedOnceWhenNamespaceDefinedButNoElementsExistForthatNamespace() + { + XmlSchemaCompletion defaultSchema = schemas["foo"]; + string xml = "<"; + + XmlCompletionItemCollection items = schemas.GetElementCompletion(xml, defaultSchema); + items.Sort(); + + XmlCompletionItemCollection expectedItems = new XmlCompletionItemCollection(); + expectedItems.Add(new XmlCompletionItem("b:bar-text", XmlCompletionItemType.XmlElement)); + expectedItems.Add(new XmlCompletionItem("foo-note", XmlCompletionItemType.XmlElement)); + + Assert.AreEqual(expectedItems, items); + } + + [Test] + public void CorrectAttributesReturnedForElementWhenTwoNamespacesInXml() + { + string xml = + "\r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " \r\n" + + " + + + + + + + + + @@ -305,6 +314,7 @@ +