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; } } }