public void ClassObjectHasTestList()
{
StubExecutorWrapper wrapper = CreateStubExecutor();
TestAssembly assembly = TestAssemblyBuilder.Build(wrapper);
TestClass testClass = assembly.EnumerateClasses().First();
IEnumerable <TestMethod> testMethods = testClass.EnumerateTestMethods();
Assert.True(testMethods.Any(tm => tm.TestClass == testClass &&
tm.MethodName == "NonSkipMethod" &&
tm.DisplayName == "ThisIsTheType.NonSkipMethod" &&
tm.RunResults.Count == 0 &&
tm.Traits.Count == 0));
Assert.True(testMethods.Any(tm => tm.TestClass == testClass &&
tm.MethodName == "TestMethodWithTraits" &&
tm.DisplayName == "This is a custom display name" &&
tm.RunResults.Count == 0 &&
tm.Traits["Category"].FirstOrDefault() == "Foo" &&
tm.Traits["Author"].FirstOrDefault() == "Dumb Attribute"));
Assert.True(testMethods.Any(tm => tm.TestClass == testClass &&
tm.MethodName == "SkipMethod" &&
tm.DisplayName == "ThisIsTheType.SkipMethod" &&
tm.RunResults.Count == 1 &&
((TestSkippedResult)tm.RunResults[0]).Reason == "Skip Reason" &&
tm.Traits.Count == 0));
}
public void TestFixtureSetUp()
{
NamingConventionDialogTypeLocator.Cache.Clear();
var assemblyBuilder = new TestAssemblyBuilder("TestAssembly");
// Create types used in tests
assemblyBuilder.CreateType("TestAssembly.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Dialog");
assemblyBuilder.CreateType("TestAssembly.ViewModels.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Views.Dialog");
assemblyBuilder.CreateType("TestAssembly.ViewModels.Module.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Views.Module.Dialog");
assemblyBuilder.CreateType("TestAssembly.Module.ViewModels.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Module.Views.Dialog");
assemblyBuilder.CreateType("TestAssembly.ModuleWithoutViewNamespace.ViewModel.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.UnconventionalNamespace.DialogViewModel", typeof(ViewModelBase));
// Create assembly
testAssembly = assemblyBuilder.Build();
}
public NamingConventionDialogTypeLocatorTest()
{
NamingConventionDialogTypeLocator.Cache.Clear();
var assemblyBuilder = new TestAssemblyBuilder("TestAssembly");
// Create types used in tests
assemblyBuilder.CreateType("TestAssembly.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Dialog");
assemblyBuilder.CreateType("TestAssembly.ViewModels.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Views.Dialog");
assemblyBuilder.CreateType("TestAssembly.ViewModels.Module.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Views.Module.Dialog");
assemblyBuilder.CreateType("TestAssembly.Module.ViewModels.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.Module.Views.Dialog");
assemblyBuilder.CreateType("TestAssembly.ModuleWithoutViewNamespace.ViewModel.DialogViewModel", typeof(ViewModelBase));
assemblyBuilder.CreateType("TestAssembly.UnconventionalNamespace.DialogViewModel", typeof(ViewModelBase));
// Create assembly
testAssembly = assemblyBuilder.Build();
}
/// <summary>
/// Build a suite based on a TestPackage
/// </summary>
/// <param name="package">The TestPackage</param>
/// <returns>A TestSuite</returns>
public TestSuite Build(TestPackage package)
{
bool autoNamespaceSuites = package.GetSetting("AutoNamespaceSuites", true);
bool mergeAssemblies = package.GetSetting("MergeAssemblies", false);
if (package.IsSingleAssembly)
{
return(BuildSingleAssembly(package));
}
string targetAssemblyName = null;
if (package.TestName != null && package.Assemblies.Contains(package.TestName))
{
targetAssemblyName = package.TestName;
package.TestName = null;
}
TestSuite rootSuite = new TestSuite(package.FullName);
NamespaceTreeBuilder namespaceTree =
new NamespaceTreeBuilder(rootSuite);
builders.Clear();
foreach (string assemblyName in package.Assemblies)
{
if (targetAssemblyName == null || targetAssemblyName == assemblyName)
{
TestAssemblyBuilder builder = new TestAssemblyBuilder();
builders.Add(builder);
Test testAssembly = builder.Build(assemblyName, package.TestName, autoNamespaceSuites && !mergeAssemblies);
if (testAssembly != null)
{
if (!mergeAssemblies)
{
rootSuite.Add(testAssembly);
}
else if (autoNamespaceSuites)
{
namespaceTree.Add(testAssembly.Tests);
rootSuite = namespaceTree.RootSuite;
}
else
{
foreach (Test test in testAssembly.Tests)
{
rootSuite.Add(test);
}
}
}
}
}
if (rootSuite.Tests.Count == 0)
{
return(null);
}
return(rootSuite);
}
public void ExcludingCategoryDoesNotRunExplicitTestFixtures()
{
TestFilter filter = new NotFilter(new CategoryFilter("MockCategory"));
TestAssemblyBuilder builder = new TestAssemblyBuilder();
TestSuite suite = builder.Build("mock-assembly.dll", true);
TestResult result = suite.Run(NullListener.NULL, filter);
ResultSummarizer summarizer = new ResultSummarizer(result);
Assert.AreEqual(MockAssembly.Tests - MockAssembly.NotRun - 2, summarizer.ResultCount);
}
public void CreatesAssemblyObjectWithAssemblyInformation()
{
StubExecutorWrapper wrapper = CreateStubExecutor(@"C:\Foo\Bar.dll", @"C:\Biff\Baz.config");
TestAssembly assembly = TestAssemblyBuilder.Build(wrapper);
Assert.Equal(@"C:\Foo\Bar.dll", assembly.AssemblyFilename);
Assert.Equal(@"C:\Biff\Baz.config", assembly.ConfigFilename);
Assert.Equal(wrapper.XunitVersion, assembly.XunitVersion);
Assert.Same(wrapper, assembly.ExecutorWrapper);
}
private TestSuite BuildSingleAssembly(TestPackage package)
{
TestAssemblyBuilder builder = new TestAssemblyBuilder();
builders.Clear();
builders.Add(builder);
return((TestSuite)builder.Build(
package.FullName,
package.TestName, package.GetSetting("AutoNamespaceSuites", true)));
}
public void AssemblyMetadataTreeViewItemTest()
{
AssemblyMetadataTreeViewItem viewItem = new AssemblyMetadataTreeViewItem(TestAssemblyBuilder.GetTestAssemblyMetadata())
{
IsExpanded = true
};
string name = "TPA.ApplicationArchitecture.dll";
int childNumber = 4;
Assert.IsTrue(viewItem.Name == name);
Assert.IsTrue(viewItem.Children.Count == childNumber);
}
public void ExcludingCategoryDoesNotRunExplicitTestFixtures()
{
NotFilter filter = new NotFilter(new CategoryFilter("MockCategory"));
filter.TopLevel = true;
TestAssemblyBuilder builder = new TestAssemblyBuilder();
TestSuite suite = builder.Build(MockAssembly.AssemblyPath, true, false);
TestResult result = suite.Run(NullListener.NULL, filter);
ResultSummarizer summarizer = new ResultSummarizer(result);
Assert.AreEqual(MockAssembly.TestsRun - 2, summarizer.TestsRun);
}
public void AssemblyObjectHasClassList()
{
StubExecutorWrapper wrapper = CreateStubExecutor();
TestAssembly assembly = TestAssemblyBuilder.Build(wrapper);
var testClasses = assembly.EnumerateClasses();
Assert.Equal(2, testClasses.Count());
TestClass testClass = testClasses.First();
Assert.Equal("ThisIsTheType", testClass.TypeName);
}
public void ExcludingCategoryDoesNotRunExplicitTestFixtures()
{
TestFilter filter = new NotFilter(new CategoryFilter("MockCategory"));
TestAssemblyBuilder builder = new TestAssemblyBuilder();
TestSuite suite = builder.Build("mock-assembly.dll", true);
TestResult result = suite.Run(NullListener.NULL, filter);
ResultSummarizer summarizer = new ResultSummarizer(result);
Assert.AreEqual(MockAssembly.Tests - MockAssembly.NotRun - 2, summarizer.ResultCount);
Console.WriteLine("{0} ignored, {1} explicit, {2} not run",
MockAssembly.Ignored, MockAssembly.Explicit, MockAssembly.NotRun);
Console.WriteLine("{0} tests were run out of {1}",
MockAssembly.Tests - MockAssembly.NotRun - 2, MockAssembly.Tests);
}
public static int Main(string[] args)
{
var testAssembly = TestAssemblyBuilder.Build(
new ExecutorWrapper(args[0], null, false));
var tests = testAssembly.EnumerateTestMethods(x => x
.DisplayName
.ToLowerInvariant();
var testMethods = (args.Length > 1 && !string.IsNullOrEmpty(args[1])
? tests.Contains(args[1].ToLowerInvariant())).ToList()
: tests.ToList();
if (testMethods.Count == 0)
return 0;
var runnerCallback = new TestMethodRunnerCallback();
testAssembly.Run(testMethods, runnerCallback);
return runnerCallback.FailedCount;
}
private TestSuite BuildSingleAssembly(TestPackage package)
{
TestAssemblyBuilder builder = new TestAssemblyBuilder();
builders.Clear();
builders.Add(builder);
TestSuite suite = (TestSuite)builder.Build(
package.FullName,
package.TestName, package.GetSetting("AutoNamespaceSuites", true),
package.GetSetting("NUnit3Compatibility", false));
ProviderCache.Clear();
return(suite);
}
public void CanLoadAssemblyAtRelativeDirectoryLocation()
{
DirectoryInfo current = new DirectoryInfo(Environment.CurrentDirectory);
string dir = current.Name;
string parentDir = current.Parent.FullName;
try
{
Environment.CurrentDirectory = parentDir;
TestAssemblyBuilder builder = new TestAssemblyBuilder();
Assert.IsNotNull(builder.Build(dir + Path.DirectorySeparatorChar + "mock-assembly.dll", false));
}
finally
{
Environment.CurrentDirectory = current.FullName;
}
}
/// <summary>
/// Executes the build task.
/// </summary>
/// <returns></returns>
public override bool Execute()
{
var projDir = Path.GetDirectoryName(ProjectPath);
var sourceList = ParsePaths(SourceList, projDir);
var builder = new TestAssemblyBuilder(sourceList);
// preserve the generated blade assembly
var bladeDllPath = Path.ChangeExtension(OutputPath, "client.dll");
if (File.Exists(bladeDllPath))
File.Delete(bladeDllPath);
File.Move(OutputPath, bladeDllPath);
// create the new output assembly for mstest to use
builder.CreateAssembly(new TestAssemblyInfo
{
OutputPath = OutputPath,
ProjectDir = projDir
});
// log any build warnings
foreach (var item in builder.Warnings)
Log.LogWarning(null, item.ErrorNumber, null, null, 0, 0, 0, 0, item.ErrorText);
// log and stop on errors
if (builder.HasErrors)
{
foreach (var item in builder.Errors)
Log.LogError(null, item.ErrorNumber, null, null, 0, 0, 0, 0, item.ErrorText);
return false;
}
var webDir = Path.Combine(projDir, @"Web");
// build test script file
WriteJsTestFile(bladeDllPath, Path.Combine(webDir, @"scripts\test.js"),
String.IsNullOrEmpty(FrameworkPath) ? null : new[] { FrameworkPath });
// copy the required Blade Tools assembly
DeployThisAssembly(Path.GetDirectoryName(OutputPath), Path.Combine(webDir, @"Bin"));
return true;
}
public static int Main(string[] args)
{
var testAssembly = TestAssemblyBuilder.Build(new ExecutorWrapper(args[0], null, false));
var testMethods = testAssembly.EnumerateTestMethods(x => x.DisplayName.ToLowerInvariant().Contains(args[1].ToLowerInvariant())).ToList();
if (testMethods.Count == 0)
{
return(0);
}
var callback = new TestMethodRunnerCallback();
testAssembly.Run(testMethods, callback);
if (callback.FailedCount > 0)
{
return(1);
}
return(0);
}
public void DoRunTests()
{
var executingAssembly = System.Reflection.Assembly.GetExecutingAssembly();
try
{
using (var wrapper = new ExecutorWrapper(executingAssembly.Location, null, true))
{
var assembly = TestAssemblyBuilder.Build(wrapper);
var methods = assembly
.EnumerateTestMethods()
.ToList();
var activeMethods = methods
.Where(m =>
UseFirefox && m.TestClass.TypeName.Contains("Firefox") ||
UseChrome && m.TestClass.TypeName.Contains("Chrome") ||
UseInternetExplorer && m.TestClass.TypeName.Contains("Internet") ||
UsePhantomJs && m.TestClass.TypeName.Contains("Phantom")
)
.ToList();
if (activeMethods.Count > 0)
{
assembly.Run(activeMethods, this);
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error");
}
finally
{
Application.Current.Dispatcher.BeginInvoke((Action)(DoDone));
}
}
public void MethodTreeViewItemTest()
{
IEnumerable <MethodTreeViewItem> viewItems = from TypeMetadata _nm in TestAssemblyBuilder.GetTestTypetadata()
from MethodMetadata _p in _nm.Methods
select new MethodTreeViewItem(_p);
List <string> ExpectedNames = new List <string> {
"Public Linq2SQL get_Linq2SQL()",
"Public Void set_Linq2SQL(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public ServiceB get_ServiceB()",
"Public Void set_ServiceB(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public ServiceC get_ServiceC()",
"Public Void set_ServiceC(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public ServiceA get_ServiceA()",
"Public Void set_ServiceA(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Model get_Model()",
"Public Void set_Model(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public String get_Property1()",
"Public Void set_Property1(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Abstract Virtual Void AbstractMethod()",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Virtual Void AbstractMethod()",
"Public String get_Property1()",
"Public Void set_Property1(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Virtual String ToString()",
"Public Virtual String ToString(Logic.ReflectionMetadata.ParameterMetadata ,Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 CompareTo(Logic.ReflectionMetadata.ParameterMetadata)",
"Public String ToString(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Boolean HasFlag(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual TypeCode GetTypeCode()",
"Public Type GetType()",
"Public T get_GenericProperty()",
"Public Void set_GenericProperty(Logic.ReflectionMetadata.ParameterMetadata)",
"Public T GenericMethod(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Abstract Virtual Void MethodA()",
"Public Abstract Virtual Single MethodB()",
"Public Virtual Void MethodA()",
"Public Virtual Single MethodB()",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Void Connect()",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Static Int32 get_StaticProperty()",
"Public Static Void set_StaticProperty(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Static Void StaticMethod1()",
"Public Static Single StaticMethod2()",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Virtual String ToString()",
"Public Type GetType()",
"Public ClassB get_ClassB()",
"Public Void set_ClassB(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public ClassA get_ClassA()",
"Public Void set_ClassA(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()",
"Public Virtual String ToString()",
"Public Virtual Boolean Equals(Logic.ReflectionMetadata.ParameterMetadata)",
"Public Virtual Int32 GetHashCode()",
"Public Type GetType()"
};
List <int> ExpectedChildernCounts = Enumerable.Repeat(1, 110).ToList();
IEnumerable <string> Names = from MethodTreeViewItem _pt in viewItems
select _pt.Name;
IEnumerable <int> ChilsernCounts = from MethodTreeViewItem _pt in viewItems
select _pt.Children.Count;
CollectionAssert.AreEquivalent(ExpectedChildernCounts, ChilsernCounts.ToList());
CollectionAssert.AreEquivalent(ExpectedNames, Names.ToList());
}
public void CanLoadAssemblyInCurrentDirectory()
{
TestAssemblyBuilder builder = new TestAssemblyBuilder();
Assert.IsNotNull(builder.Build("mock-assembly.dll", false));
}
public void NamesapceTreeViewItemTest()
{
IEnumerable <NamesapceTreeViewItem> viewItems = from NamespaceMetadata _nm in TestAssemblyBuilder.GetTestNamespaces()
select new NamesapceTreeViewItem(_nm);
List <string> ExpectedNames = new List <string> {
"Namesapce TPA.ApplicationArchitecture.BusinessLogic",
"Namesapce TPA.ApplicationArchitecture.Data",
"Namesapce TPA.ApplicationArchitecture.Data.CircularReference",
"Namesapce TPA.ApplicationArchitecture.Presentation"
};
List <int> ExpectedChildernCounts = new List <int> {
1, 1, 1, 1
};
IEnumerable <string> Names = from NamesapceTreeViewItem _nt in viewItems
select _nt.Name;
IEnumerable <int> ChilsernCounts = from NamesapceTreeViewItem _nt in viewItems
select _nt.Children.Count;
CollectionAssert.AreEquivalent(ExpectedChildernCounts, ChilsernCounts.ToList());
CollectionAssert.AreEquivalent(ExpectedNames, Names.ToList());
}
/// <summary>
/// Build a suite based on a TestPackage
/// </summary>
/// <param name="package">The TestPackage</param>
/// <returns>A TestSuite</returns>
public TestSuite Build(TestPackage package)
{
bool autoNamespaceSuites = package.GetSetting("AutoNamespaceSuites", true);
bool mergeAssemblies = package.GetSetting("MergeAssemblies", false);
bool checkCompatibility = package.GetSetting("NUnit3Compatibility", false);
TestExecutionContext.CurrentContext.TestCaseTimeout = package.GetSetting("DefaultTimeout", 0);
if (package.IsSingleAssembly)
{
return(BuildSingleAssembly(package));
}
string targetAssemblyName = null;
if (package.TestName != null && package.Assemblies.Contains(package.TestName))
{
targetAssemblyName = package.TestName;
package.TestName = null;
}
TestSuite rootSuite = new ProjectRootSuite(package.FullName);
NamespaceTreeBuilder namespaceTree =
new NamespaceTreeBuilder(rootSuite);
builders.Clear();
foreach (string assemblyName in package.Assemblies)
{
if (targetAssemblyName == null || targetAssemblyName == assemblyName)
{
TestAssemblyBuilder builder = new TestAssemblyBuilder();
builders.Add(builder);
Test testAssembly = builder.Build(assemblyName, package.TestName, autoNamespaceSuites && !mergeAssemblies, checkCompatibility);
if (testAssembly != null)
{
if (!mergeAssemblies)
{
rootSuite.Add(testAssembly);
}
else if (autoNamespaceSuites)
{
namespaceTree.Add(testAssembly.Tests);
rootSuite = namespaceTree.RootSuite;
}
else
{
foreach (Test test in testAssembly.Tests)
{
rootSuite.Add(test);
}
}
}
}
}
ProviderCache.Clear();
if (rootSuite.Tests.Count == 0)
{
return(null);
}
return(rootSuite);
}
public void TypeMetadataTreeViewItemTest()
{
IEnumerable <TypeMetadataTreeViewItem> viewItems = from TypeMetadata _nm in TestAssemblyBuilder.GetTestTypetadata()
select new TypeMetadataTreeViewItem(_nm);
List <string> ExpectedNames = new List <string> {
"Private Class Model",
"Private Class ServiceA",
"Private Class ServiceB",
"Private Class ServiceC",
"Private Class ViewModel",
"Public Abstract Class AbstractClass",
"Public Class ClassWithAttribute",
"Public Class DerivedClass",
"Private Seald Enum Enum",
"Public Class GenericClass`1<Logic.ReflectionMetadata.TypeMetadata>",
"Public Abstract Interface IExample",
"Public Class ImplementationOfIExample",
"Private Class Linq2SQL",
"Public Class OuterClass",
"Public Seald Abstract Class StaticClass",
"Public Seald Struct Structure",
"Public Class ClassA",
"Public Class ClassB",
"Private Class View"
};
List <int> ExpectedChildernCounts = Enumerable.Repeat(1, 19).ToList();
IEnumerable <string> Names = from TypeMetadataTreeViewItem _nt in viewItems
select _nt.Name;
IEnumerable <int> ChilsernCounts = from TypeMetadataTreeViewItem _nt in viewItems
select _nt.Children.Count;
CollectionAssert.AreEquivalent(ExpectedChildernCounts, ChilsernCounts.ToList());
CollectionAssert.AreEquivalent(ExpectedNames, Names.ToList());
}
public void PropertyMetadaTreeViewItemTest()
{
IEnumerable <PropertyMetadaTreeViewItem> viewItems = from TypeMetadata _nm in TestAssemblyBuilder.GetTestTypetadata()
from PropertyMetadata _p in _nm.Properties
select new PropertyMetadaTreeViewItem(_p);
List <string> ExpectedNames = new List <string> {
"Property: Linq2SQL Linq2SQL",
"Property: ServiceB ServiceB",
"Property: ServiceC ServiceC",
"Property: ServiceA ServiceA",
"Property: Model Model",
"Property: String Property1",
"Property: String Property1",
"Property: T GenericProperty",
"Property: Int32 StaticProperty",
"Property: ClassB ClassB",
"Property: ClassA ClassA"
};
List <int> ExpectedChildernCounts = Enumerable.Repeat(1, 11).ToList();
IEnumerable <string> Names = from PropertyMetadaTreeViewItem _pt in viewItems
select _pt.Name;
IEnumerable <int> ChilsernCounts = from PropertyMetadaTreeViewItem _pt in viewItems
select _pt.Children.Count;
CollectionAssert.AreEquivalent(ExpectedChildernCounts, ChilsernCounts.ToList());
CollectionAssert.AreEquivalent(ExpectedNames, Names.ToList());
}
