add tests for IAssemblyModel.Namespaces

src/Main/Base/Test/Dom/AssemblyModelNamespaceTests.cs

@@ -0,0 +1,106 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+
+namespace ICSharpCode.SharpDevelop.Dom
+{
+	[TestFixture]
+	public class AssemblyModelNamespaceTests : CSharpModelTestBase
+	{
+		[Test]
+		public void AddUnnamedNamespace()
+		{
+			var topLevelChangeEventArgs = ListenForChanges(assemblyModel.TopLevelTypeDefinitions);
+			var namespaceChangeEventArgs = ListenForChanges(assemblyModel.Namespaces);
+			
+			AddCodeFile("test.cs", "class Test {}");
+			Assert.AreEqual(1, assemblyModel.TopLevelTypeDefinitions.Count);
+			Assert.AreEqual(1, assemblyModel.Namespaces.Count);
+			var simpleClass = assemblyModel.TopLevelTypeDefinitions.Single();
+			var unnamedNamespace = assemblyModel.Namespaces.Single();
+			Assert.IsNull(unnamedNamespace.ParentNamespace);
+			Assert.IsEmpty(unnamedNamespace.Name);
+			Assert.IsEmpty(topLevelChangeEventArgs.Single().OldItems);
+			Assert.IsEmpty(namespaceChangeEventArgs.Single().OldItems);
+			Assert.AreEqual(new[] { simpleClass }, topLevelChangeEventArgs.Single().NewItems);
+			Assert.AreEqual(new[] { unnamedNamespace }, namespaceChangeEventArgs.Single().NewItems);
+		}
+		
+		[Test]
+		public void MoveFromUnnamedNamespaceToFirstLevel()
+		{
+			AddUnnamedNamespace();
+			MoveToNamespace("test.cs", "FirstLevel");
+		}
+		
+		[Test]
+		public void MoveFromUnnamedNamespaceToSecondLevel()
+		{
+			AddUnnamedNamespace();
+			MoveToNamespace("test.cs", "FirstLevel.SecondLevel");
+		}
+		
+		[Test]
+		public void MoveFromUnnamedNamespaceToThirdLevelSteps()
+		{
+			AddUnnamedNamespace();
+			MoveToNamespace("test.cs", "FirstLevel");
+			MoveToNamespace("test.cs", "FirstLevel.SecondLevel");
+			MoveToNamespace("test.cs", "FirstLevel.SecondLevel.ThirdLevel");
+		}
+		
+		[Test]
+		public void MoveFromUnnamedNamespaceToSecondLevelAndOther()
+		{
+			AddUnnamedNamespace();
+			MoveToNamespace("test.cs", "FirstLevel.SecondLevel");
+			MoveToNamespace("test.cs", "FirstLevel.Nested");
+		}
+		
+		void MoveToNamespace(string filename, string newNamespace)
+		{
+			var topLevelChangeEventArgs = ListenForChanges(assemblyModel.TopLevelTypeDefinitions);
+			var namespaceChangeEventArgs = ListenForChanges(assemblyModel.Namespaces);
+			var oldClass = assemblyModel.TopLevelTypeDefinitions.Single();
+			var oldNamespace = assemblyModel.Namespaces.Single();
+			UpdateCodeFile(filename, "namespace " + newNamespace + " { class Test {} }");
+			Assert.AreEqual(1, assemblyModel.TopLevelTypeDefinitions.Count);
+			Assert.AreEqual(1, assemblyModel.Namespaces.Count);
+			var simpleClass = assemblyModel.TopLevelTypeDefinitions.Single();
+			
+			string[] parts = newNamespace.Split(new[] {'.'}, StringSplitOptions.RemoveEmptyEntries);
+			var simpleNamespace = assemblyModel.Namespaces.Single();
+			
+			Assert.AreEqual(new[] {
+			                	simpleNamespace
+			                }, namespaceChangeEventArgs.Single().NewItems);
+			Assert.AreEqual(new[] {
+			                	oldNamespace
+			                }, namespaceChangeEventArgs.Single().OldItems);
+			
+			Assert.AreEqual(newNamespace, simpleNamespace.FullName);
+			
+			for (int i = parts.Length - 1; i <= 0; i++) {
+				Assert.IsNotNull(simpleNamespace.ParentNamespace);
+				Assert.AreEqual(parts[i], simpleNamespace.Name);
+				if (i == 0) {
+					Assert.IsEmpty(simpleNamespace.ParentNamespace.Name);
+					Assert.IsNull(simpleNamespace.ParentNamespace.ParentNamespace);
+				} else {
+					Assert.AreEqual(new[] { simpleNamespace }, simpleNamespace.ParentNamespace.ChildNamespaces);
+				}
+			}
+
+			Assert.AreEqual(new[] {
+			                	oldClass
+			                }, topLevelChangeEventArgs.Single().OldItems);
+			Assert.AreEqual(new[] {
+			                	simpleClass
+			                }, topLevelChangeEventArgs.Single().NewItems);
+		}
+	}
+}

src/Main/Base/Test/Dom/TopLevelTypeModelsTests.cs

@@ -30,6 +30,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 		public void EmptyProject()
 		{
 			Assert.AreEqual(0, assemblyModel.TopLevelTypeDefinitions.Count);
+			Assert.AreEqual(0, assemblyModel.Namespaces.Count);
 			Assert.IsNull(assemblyModel.TopLevelTypeDefinitions[new TopLevelTypeName("MissingClass")]);
 		}
 		

src/Main/Base/Test/ICSharpCode.SharpDevelop.Tests.csproj

@@ -82,6 +82,7 @@
   <ItemGroup>
     <Compile Include="AssemblyInfo.cs" />
     <Compile Include="CodeConverterTests.cs" />
+    <Compile Include="Dom\AssemblyModelNamespaceTests.cs" />
     <Compile Include="Dom\CSharpModelTestBase.cs" />
     <Compile Include="Dom\ProjectEntityModelContextTests.cs" />
     <Compile Include="Dom\TopLevelTypeModelsTests.cs" />

src/Main/SharpDevelop/Dom/NamespaceModel.cs

@@ -34,7 +34,7 @@ namespace ICSharpCode.SharpDevelop.Dom
 			get {
 				if (parent == null || string.IsNullOrEmpty(parent.name))
 					return name;
-				return parent.name + "." + name;
+				return parent.FullName + "." + name;
 			}
 		}
 		

src/Main/SharpDevelop/Dom/ProjectAssemblyModel.cs

@@ -60,41 +60,58 @@ namespace ICSharpCode.SharpDevelop.Dom
 		
 		void TypeDeclarationsCollectionChanged(IReadOnlyCollection<ITypeDefinitionModel> removedItems, IReadOnlyCollection<ITypeDefinitionModel> addedItems)
 		{
-			NamespaceModel ns;
+			List<IDisposable> batchList = new List<IDisposable>();
-			foreach (ITypeDefinitionModel addedItem in addedItems) {
+			try {
-				if (!namespaces.TryGetValue(addedItem.Namespace, out ns)) {
+				NamespaceModel ns;
-					string[] parts = addedItem.Namespace.Split('.');
+				foreach (ITypeDefinitionModel addedItem in addedItems) {
-					int level = 0;
+					if (!namespaces.TryGetValue(addedItem.Namespace, out ns)) {
-					ns = rootNamespace;
+						string[] parts = addedItem.Namespace.Split(new[] {'.'}, StringSplitOptions.RemoveEmptyEntries);
-					while (level < parts.Length) {
+						int level = 0;
-						var nextNS = ns.ChildNamespaces
+						ns = rootNamespace;
-							.FirstOrDefault(n => n.Name == parts[level]);
+						while (level < parts.Length) {
-						if (nextNS == null) break;
+							var nextNS = ns.ChildNamespaces
-						ns = nextNS;
+								.FirstOrDefault(n => n.Name == parts[level]);
-						level++;
+							if (nextNS == null) break;
+							ns = nextNS;
+							level++;
+						}
+						while (level < parts.Length) {
+							var child = new NamespaceModel(context, ns, parts[level]);
+							batchList.AddIfNotNull(ns.ChildNamespaces.BatchUpdate());
+							ns.ChildNamespaces.Add(child);
+							ns = child;
+							level++;
+						}
+						if (!namespaces.Contains(ns)) {
+							batchList.AddIfNotNull(namespaces.BatchUpdate());
+							namespaces.Add(ns);
+						}
+						batchList.AddIfNotNull(ns.Types.BatchUpdate());
+						ns.Types.Add(addedItem);
 					}
-					while (level < parts.Length) {
-						var child = new NamespaceModel(context, ns, parts[level]);
-						ns.ChildNamespaces.Add(child);
-						ns = child;
-						level++;
-					}
-					if (!namespaces.Contains(ns))
-						namespaces.Add(ns);
-					ns.Types.Add(addedItem);
 				}
-			}
+				foreach (ITypeDefinitionModel removedItem in removedItems) {
-			foreach (ITypeDefinitionModel removedItem in removedItems) {
+					if (namespaces.TryGetValue(removedItem.Namespace, out ns)) {
-				if (namespaces.TryGetValue(removedItem.Namespace, out ns)) {
+						batchList.AddIfNotNull(ns.Types.BatchUpdate());
-					ns.Types.Remove(removedItem);
+						ns.Types.Remove(removedItem);
-					if (ns.Types.Count == 0)
+						if (ns.Types.Count == 0) {
-						namespaces.Remove(ns);
+							batchList.AddIfNotNull(namespaces.BatchUpdate());
-					while (ns.ParentNamespace != null) {
+							namespaces.Remove(ns);
-						if (ns.ChildNamespaces.Count == 0 && ns.Types.Count == 0)
+						}
-							((NamespaceModel)ns.ParentNamespace).ChildNamespaces.Remove(ns);
+						while (ns.ParentNamespace != null) {
-						ns = (NamespaceModel)ns.ParentNamespace;
+							var p = ((NamespaceModel)ns.ParentNamespace);
+							if (ns.ChildNamespaces.Count == 0 && ns.Types.Count == 0) {
+								batchList.AddIfNotNull(p.ChildNamespaces.BatchUpdate());
+								p.ChildNamespaces.Remove(ns);
+							}
+							ns = p;
+						}
 					}
 				}
+			} finally {
+				batchList.Reverse();
+				foreach (IDisposable d in batchList)
+					d.Dispose();
 			}
 		}
 	}