static AgentClientTest()
{
rsa1Key = KeyGenerator.CreateKey(SshVersion.SSH1,
PublicKeyAlgorithm.SSH_RSA, "SSH1 RSA test key");
rsaKey = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.SSH_RSA, "SSH2 RSA test key");
dsaKey = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.SSH_DSS, "SSH2 DSA test key");
ecdsa256Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ECDSA_SHA2_NISTP256, "SSH2 ECDSA 256 test key");
ecdsa384Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ECDSA_SHA2_NISTP384, "SSH2 ECDSA 384 test key");
ecdsa521Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ECDSA_SHA2_NISTP521, "SSH2 ECDSA 521 test key");
ed25519Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ED25519, "SSH2 Ed25519 test key");
List<SshKey> keyList = new List<SshKey>();
keyList.Add(rsa1Key);
keyList.Add(rsaKey);
keyList.Add(dsaKey);
keyList.Add(ecdsa256Key);
keyList.Add(ecdsa384Key);
keyList.Add(ecdsa521Key);
keyList.Add(ed25519Key);
allKeys = keyList.AsReadOnly();
}
public void ArrangeNestedRegionTest()
{
List<ICodeElement> elements = new List<ICodeElement>();
TypeElement type = new TypeElement();
type.Type = TypeElementType.Class;
type.Name = "TestClass";
FieldElement field = new FieldElement();
field.Name = "val";
field.Type = "int";
type.AddChild(field);
elements.Add(type);
// Create a configuration with a nested region
CodeConfiguration codeConfiguration = new CodeConfiguration();
ElementConfiguration typeConfiguration = new ElementConfiguration();
typeConfiguration.ElementType = ElementType.Type;
RegionConfiguration regionConfiguration1 = new RegionConfiguration();
regionConfiguration1.Name = "Region1";
RegionConfiguration regionConfiguration2 = new RegionConfiguration();
regionConfiguration2.Name = "Region2";
ElementConfiguration fieldConfiguration = new ElementConfiguration();
fieldConfiguration.ElementType = ElementType.Field;
regionConfiguration2.Elements.Add(fieldConfiguration);
regionConfiguration1.Elements.Add(regionConfiguration2);
typeConfiguration.Elements.Add(regionConfiguration1);
codeConfiguration.Elements.Add(typeConfiguration);
CodeArranger arranger = new CodeArranger(codeConfiguration);
ReadOnlyCollection<ICodeElement> arrangedElements = arranger.Arrange(elements.AsReadOnly());
Assert.AreEqual(1, arrangedElements.Count, "Unexpected number of arranged elements.");
TypeElement arrangedType = arrangedElements[0] as TypeElement;
Assert.IsNotNull(arrangedType, "Expected a type element after arranging.");
Assert.AreEqual(1, arrangedType.Children.Count, "Unexpected number of arranged child elements.");
RegionElement arrangedRegion1 = arrangedType.Children[0] as RegionElement;
Assert.IsNotNull(arrangedRegion1, "Expected a region element after arranging.");
Assert.AreEqual(regionConfiguration1.Name, arrangedRegion1.Name);
Assert.AreEqual(1, arrangedRegion1.Children.Count, "Unexpected number of arranged child elements.");
RegionElement arrangedRegion2 = arrangedRegion1.Children[0] as RegionElement;
Assert.IsNotNull(arrangedRegion2, "Expected a region element after arranging.");
Assert.AreEqual(regionConfiguration2.Name, arrangedRegion2.Name);
Assert.AreEqual(1, arrangedRegion2.Children.Count, "Unexpected number of arranged child elements.");
FieldElement arrangedFieldElement = arrangedRegion2.Children[0] as FieldElement;
Assert.IsNotNull(arrangedFieldElement, "Expected a field element after arranging.");
}
public SlicerPlaneTests()
{
List<IVolumeSlicerParams> slicings = new List<IVolumeSlicerParams>();
slicings.Add(VolumeSlicerParams.Identity);
slicings.Add(VolumeSlicerParams.OrthogonalX);
slicings.Add(VolumeSlicerParams.OrthogonalY);
slicings.Add(new VolumeSlicerParams(0, 90, 45));
slicings.Add(new VolumeSlicerParams(32, -62, 69));
slicings.Add(new VolumeSlicerParams(60, 0, -30));
slicings.Add(new VolumeSlicerParams(-15, 126, -30));
_slicings = slicings.AsReadOnly();
}
public void LoadsRecentAccounts()
{
var values = new List<RecentAccountInformation>
{
CreateRecentAccountInformation("C:\test\test.txt", new DateTime(2014, 4, 1)),
CreateRecentAccountInformation("C:\test2\test2.txt", new DateTime(2014, 8, 14))
};
ApplicationContext.RecentAccounts.Returns(values.AsReadOnly());
var viewModel = new AccountManagementPageViewModel(Application);
Assert.That(viewModel.Accounts.Count, Is.EqualTo(2));
Assert.That(viewModel.Accounts[0].LastAccessDate, Is.EqualTo(new DateTime(2014, 4, 1)));
Assert.That(viewModel.Accounts[0].Path, Is.EqualTo("C:\test\test.txt"));
Assert.That(viewModel.Accounts[1].LastAccessDate, Is.EqualTo(new DateTime(2014, 8, 14)));
Assert.That(viewModel.Accounts[1].Path, Is.EqualTo("C:\test2\test2.txt"));
}
public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAnArray()
{
if (!(driver is IJavaScriptExecutor))
{
return;
}
driver.Url = javascriptPage;
List<object> expectedResult = new List<object>();
expectedResult.Add("zero");
List<object> subList = new List<object>();
subList.Add(true);
subList.Add(false);
expectedResult.Add(subList.AsReadOnly());
object result = ExecuteScript("return ['zero', [true, false]];");
Assert.IsTrue(result is ReadOnlyCollection<object>, "result was: " + result + " (" + result.GetType().Name + ")");
ReadOnlyCollection<object> list = (ReadOnlyCollection<object>)result;
Assert.IsTrue(CompareLists(expectedResult.AsReadOnly(), list));
}
public void ShouldBeAbleToExecuteSimpleJavascriptAndReturnAnObjectLiteral()
{
if (!(driver is IJavaScriptExecutor))
{
return;
}
driver.Url = javascriptPage;
Dictionary<string, object> expectedPerson = new Dictionary<string, object>();
expectedPerson.Add("first", "John");
expectedPerson.Add("last", "Doe");
Dictionary<string, object> expectedResult = new Dictionary<string, object>();
expectedResult.Add("foo", "bar");
List<object> subList = new List<object>() { "a", "b", "c" };
expectedResult.Add("baz", subList.AsReadOnly());
expectedResult.Add("person", expectedPerson);
object result = ExecuteScript(
"return {foo:'bar', baz: ['a', 'b', 'c'], " +
"person: {first: 'John',last: 'Doe'}};");
Assert.IsTrue(result is Dictionary<string, object>, "result was: " + result.GetType().ToString());
Dictionary<string, object> map = (Dictionary<string, object>)result;
Assert.AreEqual(3, map.Count, "Expected:<" + expectedResult.Count + ">, but was:<" + map.Count + ">");
foreach (string expectedKey in expectedResult.Keys)
{
Assert.IsTrue(map.ContainsKey(expectedKey));
}
Assert.AreEqual("bar", map["foo"]);
Assert.IsTrue(CompareLists((ReadOnlyCollection<object>)expectedResult["baz"], (ReadOnlyCollection<object>)map["baz"]));
Dictionary<string, object> person = (Dictionary<string, object>) map["person"];
Assert.AreEqual(2, person.Count);
Assert.AreEqual("John", person["first"]);
Assert.AreEqual("Doe", person["last"]);
}
static AgentTest()
{
buffer = new byte[4096];
stream = new MemoryStream(buffer);
parser = new BlobParser(stream);
rsa1Key = KeyGenerator.CreateKey(SshVersion.SSH1,
PublicKeyAlgorithm.SSH_RSA, "SSH1 RSA test key");
rsaKey = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.SSH_RSA, "SSH2 RSA test key");
dsaKey = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.SSH_DSS, "SSH2 DSA test key");
ecdsa256Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ECDSA_SHA2_NISTP256, "SSH2 ECDSA 256 test key");
ecdsa384Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ECDSA_SHA2_NISTP384, "SSH2 ECDSA 384 test key");
ecdsa521Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ECDSA_SHA2_NISTP521, "SSH2 ECDSA 521 test key");
ed25519Key = KeyGenerator.CreateKey(SshVersion.SSH2,
PublicKeyAlgorithm.ED25519, "SSH2 ED25519 test key");
List<ISshKey> allKeysList = new List<ISshKey>();
allKeysList.Add(rsa1Key);
allKeysList.Add(rsaKey);
allKeysList.Add(dsaKey);
allKeysList.Add(ecdsa256Key);
allKeysList.Add(ecdsa384Key);
allKeysList.Add(ecdsa521Key);
allKeysList.Add(ed25519Key);
allKeys = allKeysList.AsReadOnly();
}
public void ArrangeStaticFieldsTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
TypeElement classElement = new TypeElement();
classElement.Type = TypeElementType.Class;
classElement.Access = CodeAccess.Public;
classElement.Name = "TestClass";
FieldElement fieldElement1 = new FieldElement();
fieldElement1.MemberModifiers = MemberModifiers.Static;
fieldElement1.Access = CodeAccess.Protected;
fieldElement1.Type = "object";
fieldElement1.Name = "_obj";
fieldElement1.InitialValue = "typeof(int).ToString();";
classElement.AddChild(fieldElement1);
// This field has a static dependency. Normally it would be sorted first
// due to its access, but we want to make sure it gets added after the
// field for which it is dependent.
FieldElement fieldElement2 = new FieldElement();
fieldElement2.MemberModifiers = MemberModifiers.Static;
fieldElement2.Access = CodeAccess.Public;
fieldElement2.Type = "bool";
fieldElement2.Name = "Initialized";
fieldElement2.InitialValue = "_initializationString != null";
classElement.AddChild(fieldElement2);
FieldElement fieldElement3 = new FieldElement();
fieldElement3.MemberModifiers = MemberModifiers.Static;
fieldElement3.Access = CodeAccess.Private;
fieldElement3.Type = "string";
fieldElement3.Name = "_initializationString";
fieldElement3.InitialValue = "_obj";
classElement.AddChild(fieldElement3);
codeElements.Add(classElement);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
TypeElement typeElement = arranged[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
List<FieldElement> staticFields = new List<FieldElement>();
Action<ICodeElement> findStaticFields = delegate(ICodeElement codeElement)
{
FieldElement fieldElement = codeElement as FieldElement;
if (fieldElement != null && fieldElement.MemberModifiers == MemberModifiers.Static)
{
staticFields.Add(fieldElement);
}
};
ElementUtilities.ProcessElementTree(typeElement, findStaticFields);
Assert.AreEqual(3, staticFields.Count, "Unexpected number of static fields after arranging.");
Assert.AreEqual("_obj", staticFields[0].Name);
Assert.AreEqual("_initializationString", staticFields[1].Name);
Assert.AreEqual("Initialized", staticFields[2].Name);
//
// Remove the dependency
//
fieldElement2.InitialValue = "true";
fieldElement3.InitialValue = "\"test\"";
arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
typeElement = arranged[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
staticFields.Clear();
ElementUtilities.ProcessElementTree(typeElement, findStaticFields);
Assert.AreEqual(3, staticFields.Count, "Unexpected number of static fields after arranging.");
Assert.AreEqual("Initialized", staticFields[0].Name);
Assert.AreEqual("_obj", staticFields[1].Name);
Assert.AreEqual("_initializationString", staticFields[2].Name);
}
public void MoveUsingsToNamespaceTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
UsingElement using1 = new UsingElement();
using1.Name = "System";
using1.IsMovable = true;
codeElements.Add(using1);
// Nested region and groups
RegionElement region = new RegionElement();
region.Name = "Region";
codeElements.Add(region);
GroupElement group = new GroupElement();
group.Name = "Group";
region.AddChild(group);
UsingElement using2 = new UsingElement();
using2.Name = "System.IO";
using2.IsMovable = true;
group.AddChild(using2);
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
codeElements.Add(namespaceElement);
UsingElement using3 = new UsingElement();
using3.Name = "System.Collections";
using3.IsMovable = true;
namespaceElement.AddChild(using3);
TypeElement class1 = new TypeElement();
class1.Name = "Class1";
namespaceElement.AddChild(class1);
TypeElement class2 = new TypeElement();
class2.Name = "Class2";
namespaceElement.AddChild(class2);
CodeConfiguration configuration = CodeConfiguration.Default.Clone() as CodeConfiguration;
CodeArranger arranger;
//
// Move to namespace.
//
configuration.Formatting.Usings.MoveTo = CodeLevel.Namespace;
arranger = new CodeArranger(configuration);
ReadOnlyCollection<ICodeElement> arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(2, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
GroupElement namespaceGroup = namespaceElementTest.Children[0] as GroupElement;
Assert.IsNotNull(namespaceGroup);
GroupElement innerGroup = namespaceGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
RegionElement typeRegion = namespaceElementTest.Children[1] as RegionElement;
Assert.IsNotNull(typeRegion);
Assert.AreEqual("Class1", typeRegion.Children[0].Name);
Assert.AreEqual("Class2", typeRegion.Children[1].Name);
}
public void MoveUsingsBasicTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
UsingElement using1 = new UsingElement();
using1.Name = "System";
using1.IsMovable = true;
UsingElement using2 = new UsingElement();
using2.Name = "System.IO";
using2.IsMovable = true;
UsingElement using3 = new UsingElement();
using3.Name = "System.Collections";
using3.IsMovable = true;
codeElements.Add(using1);
codeElements.Add(using2);
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(using3);
codeElements.Add(namespaceElement);
CodeConfiguration configuration = CodeConfiguration.Default.Clone() as CodeConfiguration;
CodeArranger arranger;
//
// Do not move.
//
configuration.Formatting.Usings.MoveTo = CodeLevel.None;
arranger = new CodeArranger(configuration);
ReadOnlyCollection<ICodeElement> arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
GroupElement fileGroup = arranged[0] as GroupElement;
Assert.IsNotNull(fileGroup);
GroupElement innerGroup = fileGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.IO", innerGroup.Children[1].Name);
NamespaceElement namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
GroupElement namespaceGroup = namespaceElementTest.Children[0] as GroupElement;
Assert.IsNotNull(namespaceGroup);
innerGroup = namespaceGroup.Children[0] as GroupElement;
Assert.AreEqual("System.Collections", innerGroup.Children[0].Name);
//
// Move to file level;
//
configuration.Formatting.Usings.MoveTo = CodeLevel.File;
arranger = new CodeArranger(configuration);
arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
fileGroup = arranged[0] as GroupElement;
Assert.IsNotNull(fileGroup);
innerGroup = fileGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
//
// Move to namespace.
//
configuration.Formatting.Usings.MoveTo = CodeLevel.Namespace;
arranger = new CodeArranger(configuration);
arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
namespaceGroup = namespaceElementTest.Children[0] as GroupElement;
Assert.IsNotNull(namespaceGroup);
innerGroup = namespaceGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
//
// Move back to file level;
//
configuration.Formatting.Usings.MoveTo = CodeLevel.File;
arranger = new CodeArranger(configuration);
arranged = arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(2, arranged.Count, "After arranging, an unexpected number of elements were returned.");
fileGroup = arranged[0] as GroupElement;
Assert.IsNotNull(fileGroup);
innerGroup = fileGroup.Children[0] as GroupElement;
Assert.AreEqual("System", innerGroup.Children[0].Name);
Assert.AreEqual("System.Collections", innerGroup.Children[1].Name);
Assert.AreEqual("System.IO", innerGroup.Children[2].Name);
namespaceElementTest = arranged[1] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
}
public void PersonMerge()
{
var singlePersonMergeData = new MergeTestData
{
FullName = "Johnny Rockets, King of the Dinosaurs",
Things =
new List<MergeTestData.Thing>(
new[]
{
new MergeTestData.Thing { TheValue = "Something" }, new MergeTestData.Thing { TheValue = "Another thing" },
new MergeTestData.Thing { TheValue = "One more thing" }, new MergeTestData.Thing { TheValue = "Last thing" },
new MergeTestData.Thing { TheValue = "Okay THIS is the last thing" }, new MergeTestData.Thing { TheValue = "Something again" },
new MergeTestData.Thing { TheValue = "Another thing again" }, new MergeTestData.Thing { TheValue = "One more thing again" },
new MergeTestData.Thing { TheValue = "Last thing again" }, new MergeTestData.Thing { TheValue = "Okay THIS is the last thing again" },
new MergeTestData.Thing { TheValue = "Something one more time" }, new MergeTestData.Thing { TheValue = "Another thing one more time" },
new MergeTestData.Thing { TheValue = "One more thing one more time" }, new MergeTestData.Thing { TheValue = "Last thing one more time" },
new MergeTestData.Thing { TheValue = "Okay THIS is the last thing one more time" },
new MergeTestData.Thing { TheValue = "Something that is getting old" }, new MergeTestData.Thing { TheValue = "Another thing that is getting old" },
new MergeTestData.Thing { TheValue = "One more thing that is getting old" }, new MergeTestData.Thing { TheValue = "Last thing that is getting old" },
new MergeTestData.Thing { TheValue = "Okay THIS is the last thing that is getting old" },
new MergeTestData.Thing { TheValue = "Something about the end of all things" },
new MergeTestData.Thing { TheValue = "Another thing about the end of all things" },
new MergeTestData.Thing { TheValue = "One more thing about the end of all things" },
new MergeTestData.Thing { TheValue = "Last thing about the end of all things" },
new MergeTestData.Thing { TheValue = "Okay THIS is the last thing about the end of all things" },
} )
};
var mergingInfoFields = new List<MergeField<MergeTestData>>( new[] { MergeFieldOps.CreateBasicField( new FullName() ) } );
var internalTableDataFields = new List<MergeField<MergeTestData.Thing>>( new[] { MergeFieldOps.CreateBasicField( new TheValue() ) } );
var mergeTree = MergeDataTreeOps.CreateRowTree(
mergingInfoFields.AsReadOnly(),
singlePersonMergeData.ToSingleElementArray(),
new List<MergeDataTreeChild<MergeTestData>>
{
new MergeDataTreeChild<MergeTestData, MergeTestData.Thing>( "Things", internalTableDataFields.AsReadOnly(), info => info.Things )
}.AsReadOnly() );
using( var templateStream = File.OpenRead( testingWordTemplatePath ) ) {
using( var destinationStream = File.Create( getFilePath( "basic_merge_test" ) ) ) {
MergeOps.CreateMsWordDoc( mergeTree, true, templateStream, destinationStream );
doneCreating = DateTime.Now;
}
}
}
public DicomAttributeEmptyNullTestSuite() {
uint tag = 0x2101FF00;
List<DicomTag> tags = new List<DicomTag>();
foreach (DicomVr vr in DicomVr.GetDicomVrList()) {
tags.Add(new DicomTag(tag++, "dummy-tag-" + vr.Name, "dummy_tag_" + vr.Name, vr, false, 1, 1, false));
tags.Add(new DicomTag(tag++, "dummy-mvtag-" + vr.Name, "dummy_mvtag_" + vr.Name, vr, false, 0, 10, false));
}
_tags = tags.AsReadOnly();
}
public void DefaultArrangeEnumerationTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
UsingElement usingElement = new UsingElement();
usingElement.Name = "System";
TypeElement enumElement = new TypeElement();
enumElement.Type = TypeElementType.Enum;
enumElement.Access = CodeAccess.Public;
enumElement.Name = "TestEnum";
enumElement.BodyText = "Value1 = 1,\r\nValue2 = 2";
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(usingElement);
namespaceElement.AddChild(enumElement);
codeElements.Add(namespaceElement);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged =
arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(2, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
Assert.AreEqual(ElementType.Using, namespaceElement.Children[0].ElementType);
RegionElement regionElement = namespaceElementTest.Children[1] as RegionElement;
Assert.IsNotNull(regionElement, "Expected a region element.");
Assert.AreEqual("Enumerations", regionElement.Name, "Unexpected region name.");
Assert.AreEqual(1, regionElement.Children.Count,
"After arranging, an unexpected number of region elements were returned.");
TypeElement typeElement = regionElement.Children[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
Assert.AreEqual(TypeElementType.Enum, typeElement.Type, "Unexpected type element type.");
Assert.AreEqual(enumElement.Name, typeElement.Name, "Unexpected type element name.");
}
public void OpenRecentAccount()
{
var values = new List<RecentAccountInformation>
{
CreateRecentAccountInformation(@"C:\test\test.txt", new DateTime(2014, 4, 1)),
};
ApplicationContext.RecentAccounts.Returns(values.AsReadOnly());
var viewModel = new AccountManagementPageViewModel(Application);
viewModel.Accounts.First().OpenCommand.Execute(null);
Repository.Received(1).Open(@"C:\test\test.txt");
Repository.Received(1).UpdateStandingOrdersToCurrentMonth();
ApplicationContext.DidNotReceiveWithAnyArgs().UpdateRecentAccountInformation(@"C:\test\test.txt");
Assert.That(Application.ActivePage, Is.InstanceOf<RequestManagementPageViewModel>());
}
public void DefaultArrangeConditionDirectiveTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
ConditionDirectiveElement ifCondition = new ConditionDirectiveElement();
ifCondition.ConditionExpression = "DEBUG";
FieldElement field1 = new FieldElement();
field1.Name = "zField";
field1.Type = "int";
FieldElement field2 = new FieldElement();
field2.Name = "aField";
field2.Type = "int";
ifCondition.AddChild(field1);
ifCondition.AddChild(field2);
ifCondition.ElseCondition = new ConditionDirectiveElement();
FieldElement field3 = new FieldElement();
field3.Name = "testField";
field3.Type = "int";
FieldElement field1Clone = field1.Clone() as FieldElement;
FieldElement field2Clone = field2.Clone() as FieldElement;
TypeElement classElement = new TypeElement();
classElement.Name = "TestClass";
classElement.AddChild(field1Clone);
classElement.AddChild(field2Clone);
ifCondition.ElseCondition.AddChild(field3);
ifCondition.ElseCondition.AddChild(classElement);
codeElements.Add(ifCondition);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged =
arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
ConditionDirectiveElement ifConditionTest = arranged[0] as ConditionDirectiveElement;
Assert.IsNotNull(ifConditionTest, "Expected a condition directive element.");
Assert.AreEqual(2, ifConditionTest.Children.Count,
"After arranging, an unexpected number of nested elements were returned.");
Assert.AreEqual(field2.Name, ifConditionTest.Children[0].Name);
Assert.AreEqual(field1.Name, ifConditionTest.Children[1].Name);
ConditionDirectiveElement elseConditionTest = ifConditionTest.ElseCondition;
Assert.IsNotNull(elseConditionTest, "Expected a condition directive element.");
Assert.AreEqual(2, ifConditionTest.Children.Count,
"After arranging, an unexpected number of nested elements were returned.");
Assert.AreEqual(field3.Name, elseConditionTest.Children[0].Name);
Assert.AreEqual(classElement.Name, elseConditionTest.Children[1].Name);
TypeElement classElementTest = elseConditionTest.Children[1] as TypeElement;
Assert.IsNotNull(classElementTest, "Expected a type element.");
Assert.AreEqual(1, classElementTest.Children.Count);
Assert.AreEqual("Fields", classElementTest.Children[0].Name);
}
public override IReadOnlyCollection<ParameterMapping> ProvideParameterMapping(System.Reflection.MethodInfo methodInfo)
{
List<ParameterMapping> mapping = new List<ParameterMapping>();
var email = methodInfo.GetParameters()[0];
var from = new ParameterMapping("from");
mapping.Add(from);
from.AddSource(email, (EmailChange e) => e.From);
var to = new ParameterMapping("to");
to.AddSource(email, (EmailChange e) => e.To);
mapping.Add(to);
var when = new ParameterMapping("when");
when.AddSource(email, (EmailChange e) => e.When);
mapping.Add(when);
var domain = new ParameterMapping("domain");
domain.AddSource(email, (EmailChange e) => e.GetDomain());
mapping.Add(domain);
return mapping.AsReadOnly();
}
public override IReadOnlyCollection<ParameterMapping> ProvideParameterMapping(System.Reflection.MethodInfo methodInfo)
{
List<ParameterMapping> mapping = new List<ParameterMapping>();
var email = methodInfo.GetParameters()[0];
var from = new ParameterMapping("from");
mapping.Add(from);
from.AddSource(email, (OtherClass o) => o.AMethodNotShared());
return mapping.AsReadOnly();
}
public override IReadOnlyCollection<ParameterMapping> ProvideParameterMapping(System.Reflection.MethodInfo methodInfo)
{
var mappings = new List<ParameterMapping>();
var mapping = new ParameterMapping("data");
mappings.Add(mapping);
// return a mapping with an empty source
return mappings.AsReadOnly();
}
public override IReadOnlyCollection<ParameterMapping> ProvideParameterMapping(System.Reflection.MethodInfo methodInfo)
{
var mappings = new List<ParameterMapping>();
var mapping = new ParameterMapping("data");
mappings.Add(mapping);
foreach (var p in methodInfo.GetParameters().Reverse())
mapping.AddSource(p);
return mappings.AsReadOnly();
}
public void OpenRecentAccountWithException(bool answerYes)
{
const string accountPath = @"C:\test\test.txt";
var values = new List<RecentAccountInformation>
{
CreateRecentAccountInformation(accountPath, new DateTime(2014, 4, 1)),
};
ApplicationContext.RecentAccounts.Returns(values.AsReadOnly());
Repository.When(r => r.Open(Arg.Any<string>())).Do(c => { throw new FileNotFoundException("Text"); });
if (answerYes)
{
WindowManager.When(w => w.ShowQuestion(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<Action>(), Arg.Any<Action>()))
.Do(c => ((Action)c[2]).Invoke());
}
var viewModel = new AccountManagementPageViewModel(Application);
viewModel.Accounts.First().OpenCommand.Execute(null);
Repository.Received(1).Open(accountPath);
ApplicationContext.DidNotReceiveWithAnyArgs().UpdateRecentAccountInformation(Arg.Any<string>());
WindowManager.Received(1).ShowQuestion(Properties.Resources.ErrorOpenRecentAccount,
string.Format(Properties.Resources.RecentAccountNotFoundFormat, accountPath),
Arg.Any<Action>(), Arg.Any<Action>());
if (answerYes)
{
ApplicationContext.Received(1).DeleteRecentAccountInformation(accountPath);
Assert.That(viewModel.Accounts.Count, Is.EqualTo(0));
}
else
{
ApplicationContext.DidNotReceiveWithAnyArgs().DeleteRecentAccountInformation(Arg.Any<string>());
Assert.That(viewModel.Accounts.Count, Is.EqualTo(1));
}
Assert.That(Application.ActivePage, Is.Not.InstanceOf<AccountManagementPageViewModel>());
}
public void DefaultArrangeSimpleClassTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
TypeElement classElement = new TypeElement();
classElement.Type = TypeElementType.Class;
classElement.Access = CodeAccess.Public;
classElement.Name = "TestClass";
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(classElement);
MethodElement methodElement = new MethodElement();
methodElement.Type = "void";
methodElement.Access = CodeAccess.Public;
methodElement.Name = "DoSomething";
classElement.AddChild(methodElement);
FieldElement fieldElement = new FieldElement();
fieldElement.Type = "bool";
fieldElement.Access = CodeAccess.Private;
fieldElement.Name = "_val";
classElement.AddChild(fieldElement);
PropertyElement propertyElement = new PropertyElement();
propertyElement.Type = "bool";
propertyElement.Access = CodeAccess.Public;
propertyElement.Name = "Value";
propertyElement.BodyText = "return _val";
classElement.AddChild(propertyElement);
codeElements.Add(namespaceElement);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged =
arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
RegionElement typeRegionElement = namespaceElementTest.Children[0] as RegionElement;
Assert.IsNotNull(typeRegionElement, "Expected a region element.");
Assert.AreEqual("Types", typeRegionElement.Name);
Assert.AreEqual(1, typeRegionElement.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
TypeElement typeElement = typeRegionElement.Children[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
Assert.AreEqual(TypeElementType.Class, typeElement.Type, "Unexpected type element type.");
Assert.AreEqual(classElement.Name, typeElement.Name, "Unexpected type element name.");
Assert.AreEqual(3, typeElement.Children.Count, "An unexpected number of class child elements were returned.");
List<RegionElement> regionElements = new List<RegionElement>();
foreach (ICodeElement classChildElement in typeElement.Children)
{
RegionElement regionElement = classChildElement as RegionElement;
Assert.IsNotNull(
regionElement, "Expected a region element but was {0}.", classChildElement.ElementType);
regionElements.Add(regionElement);
}
Assert.AreEqual("Fields", regionElements[0].Name, "Unexpected region element name.");
Assert.AreEqual("Properties", regionElements[1].Name, "Unexpected region element name.");
Assert.AreEqual("Methods", regionElements[2].Name, "Unexpected region element name.");
GroupElement fieldGroupElement = regionElements[0].Children[0].Children[0] as GroupElement;
Assert.IsNotNull(fieldGroupElement, "Expected a group element for fields.");
foreach (ICodeElement codeElement in fieldGroupElement.Children)
{
FieldElement fieldElementTest = codeElement as FieldElement;
Assert.IsNotNull(
fieldElementTest,
"Expected a field element but was type {0}: {1}",
codeElement.ElementType,
codeElement);
}
Assert.AreEqual(1, regionElements[1].Children.Count);
foreach (ICodeElement codeElement in regionElements[1].Children[0].Children)
{
PropertyElement propertyElementTest = codeElement as PropertyElement;
Assert.IsNotNull(
propertyElementTest,
"Expected a property element but was type {0}: {1}",
codeElement.ElementType,
codeElement);
}
Assert.AreEqual(1, regionElements[2].Children.Count);
foreach (ICodeElement codeElement in regionElements[2].Children[0].Children)
{
MethodElement methodElementTest = codeElement as MethodElement;
Assert.IsNotNull(
methodElementTest,
"Expected a method element but was type {0}: {1}",
codeElement.ElementType,
codeElement);
}
}
private IParsable CreateMockParser(UInt32 expectedReportItemCount)
{
var control = new DynamicMock(typeof(IParsable));
control.ExpectAndReturn("GetBytes", code, null);
var reportItemList = new List<ReportItem>();
for (UInt32 i = 0; i < expectedReportItemCount; i++)
{
reportItemList.Add(new ReportItem(i, false));
}
control.ExpectAndReturn("get_ExpectedReportItems", reportItemList.AsReadOnly(), null);
control.ExpectAndReturn("get_ExpectedReportItems", reportItemList.AsReadOnly(), null);
return control.MockInstance as IParsable;
}
public void DefaultArrangeStructLayoutTest()
{
List<ICodeElement> codeElements = new List<ICodeElement>();
TypeElement structElement = new TypeElement();
structElement.Type = TypeElementType.Structure;
structElement.Access = CodeAccess.Public;
structElement.Name = "TestStructure";
structElement.AddAttribute(new AttributeElement("System.Runtime.InteropServices.StructLayout"));
NamespaceElement namespaceElement = new NamespaceElement();
namespaceElement.Name = "TestNamespace";
namespaceElement.AddChild(structElement);
FieldElement fieldElement1 = new FieldElement();
fieldElement1.Type = "int";
fieldElement1.Access = CodeAccess.Public;
fieldElement1.Name = "z";
structElement.AddChild(fieldElement1);
FieldElement fieldElement2 = new FieldElement();
fieldElement2.Type = "int";
fieldElement2.Access = CodeAccess.Public;
fieldElement2.Name = "x";
structElement.AddChild(fieldElement2);
FieldElement fieldElement3 = new FieldElement();
fieldElement3.Type = "int";
fieldElement3.Access = CodeAccess.Public;
fieldElement3.Name = "y";
structElement.AddChild(fieldElement3);
codeElements.Add(namespaceElement);
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
ReadOnlyCollection<ICodeElement> arranged =
arranger.Arrange(codeElements.AsReadOnly());
Assert.AreEqual(1, arranged.Count, "After arranging, an unexpected number of elements were returned.");
NamespaceElement namespaceElementTest = arranged[0] as NamespaceElement;
Assert.IsNotNull(namespaceElementTest, "Expected a namespace element.");
Assert.AreEqual(1, namespaceElementTest.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
RegionElement typeRegionElement = namespaceElementTest.Children[0] as RegionElement;
Assert.IsNotNull(typeRegionElement, "Expected a region element.");
Assert.AreEqual("Types", typeRegionElement.Name);
Assert.AreEqual(1, typeRegionElement.Children.Count,
"After arranging, an unexpected number of namespace elements were returned.");
TypeElement typeElement = typeRegionElement.Children[0] as TypeElement;
Assert.IsNotNull(typeElement, "Expected a type element.");
Assert.AreEqual(TypeElementType.Structure, typeElement.Type, "Unexpected type element type.");
Assert.AreEqual(structElement.Name, typeElement.Name, "Unexpected type element name.");
Assert.AreEqual(1, typeElement.Children.Count, "An unexpected number of class child elements were returned.");
RegionElement regionElement = typeElement.Children[0] as RegionElement;
Assert.IsNotNull(regionElement, "Expected a region element but was {0}.", regionElement.ElementType);
Assert.AreEqual("Fixed Fields", regionElement.Name, "Unexpected region name.");
Assert.AreEqual(3, regionElement.Children.Count, "Unexpected number of region child elements.");
// The fields should not have been sorted
Assert.AreEqual(fieldElement1.Name, regionElement.Children[0].Name);
Assert.AreEqual(fieldElement2.Name, regionElement.Children[1].Name);
Assert.AreEqual(fieldElement3.Name, regionElement.Children[2].Name);
}
public void DefaultArrangeUsingsInRegionTest()
{
CodeArranger arranger = new CodeArranger(CodeConfiguration.Default);
List<ICodeElement> codeElements = new List<ICodeElement>();
RegionElement regionElement = new RegionElement();
regionElement.Name = "Using Directives";
UsingElement usingElement1 = new UsingElement();
usingElement1.Name = "System";
regionElement.AddChild(usingElement1);
UsingElement usingElement2 = new UsingElement();
usingElement2.Name = "System.Text";
regionElement.AddChild(usingElement2);
codeElements.Add(regionElement);
ReadOnlyCollection<ICodeElement> arranged = arranger.Arrange(codeElements.AsReadOnly());
//
// Verify using statements were stripped from the region
//
Assert.AreEqual(1, arranged.Count, "An unexpected number of root elements were returned from Arrange.");
GroupElement groupElement = arranged[0] as GroupElement;
Assert.IsNotNull(groupElement, "Expected a group element.");
Assert.AreEqual("Namespace", groupElement.Name);
groupElement = groupElement.Children[0] as GroupElement;
Assert.IsNotNull(groupElement, "Expected a group element.");
Assert.AreEqual("System", groupElement.Name);
foreach (ICodeElement arrangedElement in groupElement.Children)
{
Assert.IsTrue(arrangedElement is UsingElement, "Expected a using element.");
}
}
public void PracticesMerge()
{
var practiceData = new PracticeMockData(
"Entymology Associates of Rock Chester",
new[] { "*****@*****.**", "*****@*****.**", "*****@*****.**", "*****@*****.**" }.Select( s => new PracticeManagerMockData( s ) ),
new[]
{
new PhysicianMockData( "*****@*****.**", "Joan", "Ann" ), new PhysicianMockData( "*****@*****.**", "Johnny", "Ann" ),
new PhysicianMockData( "*****@*****.**", "Billy", "Pullman" ), new PhysicianMockData( "*****@*****.**", "William", "Smithers" )
} );
var practiceFields = new List<MergeField<PracticeMockData>>( MergeFieldOps.CreateBasicField( new PracticeName() ).ToSingleElementArray() );
var managerFields = new List<MergeField<PracticeManagerMockData>>( MergeFieldOps.CreateBasicField( new MergeFields.PracticeManagerMergeFields.Email() ).ToSingleElementArray() );
var physicianFields =
new List<MergeField<PhysicianMockData>>(
new[]
{
MergeFieldOps.CreateBasicField( new MergeFields.PhysicianMergeFields.Email() ), MergeFieldOps.CreateBasicField( new FirstName() ),
MergeFieldOps.CreateBasicField( new LastName() )
} );
var managersChild = new MergeDataTreeChild<PracticeMockData, PracticeManagerMockData>(
"PracticeManagers",
managerFields.AsReadOnly(),
data => data.Managers );
var physiciansChild = new MergeDataTreeChild<PracticeMockData, PhysicianMockData>( "Physicians", physicianFields.AsReadOnly(), data => data.Physicians );
var mergeTree = MergeDataTreeOps.CreateRowTree(
practiceFields.AsReadOnly(),
practiceData.ToSingleElementArray(),
new List<MergeDataTreeChild<PracticeMockData>> { managersChild, physiciansChild }.AsReadOnly() );
using( var templateStream = File.OpenRead( testingPracticesWordTemplatePath ) ) {
using( var destinationStream = File.Create( getFilePath( "practices_merge_test" ) ) ) {
MergeOps.CreateMsWordDoc( mergeTree, true, templateStream, destinationStream );
doneCreating = DateTime.Now;
}
}
}
