public ITestProperty SetObject(ITestObject testObject) { AssertIsVisible(); AssertIsModifiable(); ResetLastMessage(); Assert.IsFalse(field.ReturnSpec.IsParseable, "Drop(..) not allowed on value target field; use SetValue(..) instead"); INakedObjectAdapter testNakedObjectAdapter = testObject.NakedObject; Assert.IsTrue(testNakedObjectAdapter.Spec.IsOfType(field.ReturnSpec), string.Format("Can't drop a {0} on to the {1} field (which accepts {2})", testObject.NakedObject.Spec.ShortName, Name, field.ReturnSpec)); INakedObjectAdapter nakedObjectAdapter = owningObject.NakedObject; IConsent valid; var associationSpec = field as IOneToOneAssociationSpec; if (associationSpec != null) { valid = associationSpec.IsAssociationValid(nakedObjectAdapter, testNakedObjectAdapter); } else if (field is IOneToManyAssociationSpec) { valid = new Veto("Always disabled"); } else { throw new UnknownTypeException(field); } LastMessage = valid.Reason; Assert.IsFalse(valid.IsVetoed, string.Format("Cannot SetObject {0} in the field {1} within {2}: {3}", testNakedObjectAdapter, field, nakedObjectAdapter, valid.Reason)); var spec = field as IOneToOneAssociationSpec; if (spec != null) { spec.SetAssociation(nakedObjectAdapter, testNakedObjectAdapter); } return this; }
public DerivedConstructorDependenciesObject( ITestObject spouse1, ITestObject spouse2, IndexedTestObject other, int age, string name) : base(spouse1, spouse2, other) { Age = age; Name = name; }
public void TearDown() { CleanupNakedObjectsFramework(); countPayments = 0; payment1 = null; customer1 = null; payee1 = null; key1 = null; }
public virtual void ObjectWithSimpleToString() { rep = GetTestService("Object2s"); obj = rep.GetAction("New Instance").InvokeReturnObject(); prop1 = obj.GetPropertyByName("Prop1"); prop1.SetValue("Bar"); obj.AssertTitleEquals("Bar"); obj.Save(); obj.AssertTitleEquals("Bar"); }
public virtual void ObjectWithTitleAttributeOnString() { rep = GetTestService("Object1s"); obj = rep.GetAction("New Instance").InvokeReturnObject(); obj.AssertTitleEquals("Untitled Object1"); prop1 = obj.GetPropertyByName("Prop1"); prop1.SetValue("Foo"); obj.AssertTitleEquals("Foo"); obj.Save(); obj.AssertTitleEquals("Foo"); }
public virtual void TitleMethod() { rep = GetTestService("Object4s"); obj = rep.GetAction("New Instance").InvokeReturnObject(); obj.AssertTitleEquals("Untitled Object4"); prop1 = obj.GetPropertyByName("Prop1"); prop1.SetValue("Foo"); obj.AssertTitleEquals("Foo"); obj.Save(); obj.AssertTitleEquals("Foo"); }
public void Setup() { InitializeNakedObjectsFramework(); payment1 = CreatePayment(); customer1 = CreateCustomer("0c1ced04-7016-11e0-9c44-78544824019b"); customer2 = CreateCustomer("3d9d6ca0-7016-11e0-b12a-9e544824019b"); supplier1 = CreateSupplier("89bc90ec-7017-11e0-a08c-57564824019b"); payee1 = payment1.GetPropertyByName("Payee"); key1 = payment1.GetPropertyByName("Payee Compound Key"); }
public virtual void CMaskOnDecimalProperty() { obj = NewTestObject<Object2>(); prop1 = obj.GetPropertyByName("Prop1"); prop1.SetValue("32.70"); var dom = (Object2) obj.GetDomainObject(); StringAssert.Equals("32.7", dom.Prop1.ToString()); StringAssert.Equals("32.70", prop1.Content.Title); StringAssert.Equals("£32.70", prop1.Title); prop1.AssertTitleIsEqual("£32.70"); prop1.AssertValueIsEqual("32.70"); }
public void Setup() { InitializeNakedObjectsFramework(); payment1 = CreatePayment(); customer1 = CreateCustomer(); customer2 = CreateCustomer(); supplier1 = CreateSupplier(); payee1 = payment1.GetPropertyByName("Payee"); key1 = payment1.GetPropertyByName("Payee Compound Key"); emp1 = CreateEmployee("foo"); emp2 = CreateEmployee("bar"); }
public virtual void TitleMethodTakesPrecedenceOverToString() { rep = GetTestService("Object5s"); obj = rep.GetAction("New Instance").InvokeReturnObject(); StringAssert.Equals("Bar", obj.GetDomainObject().ToString()); obj.AssertTitleEquals("Untitled Object5"); ITestProperty prop1 = obj.GetPropertyByName("Prop1"); prop1.SetValue("Foo"); obj.AssertTitleEquals("Foo"); obj.Save(); obj.AssertTitleEquals("Foo"); }
public void Initialize() { InitializeNakedObjectsFramework(); payment1 = CreatePayment(); customer1 = CreateCustomerOnes(); customer2a = CreateCustomerTwos(); customer2b = CreateCustomerTwos(); customer3 = CreateCustomerThrees(); supplier1 = CreateSupplier(); payee1 = payment1.GetPropertyByName("Payee"); key1 = payment1.GetPropertyByName("Payee Compound Key"); emp1 = CreateEmployee("foo"); }
public void ExecuteSpelAction() { string executeHandlerText = "on exception name ArithmeticException execute Oragon.Spring.Aspects.Exceptions.ExceptionHandlerAspectIntegrationTests.Executed(true)"; ITestObject to = CreateTestObjectProxy(executeHandlerText); try { to.Exceptional(new ArithmeticException()); } catch (ArithmeticException) { Assert.IsTrue(spelActionExecuted); } }
public void ReturnWithString() { string returnHandlerText = "on exception name ArithmeticException return 12"; ITestObject to = CreateTestObjectProxy(returnHandlerText); try { int retVal = to.ExceptionalWithReturnValue(new ArithmeticException("Bad Math")); Assert.AreEqual(12, retVal); } catch (Exception) { Assert.Fail("Should not have thrown exception"); } }
public static UIACondition GetCondition(ITestObject testObject) { if (testObject == null) { return(null); } UIACondition condition = testObject.GetContext <UIACondition>(); if (condition == null) { condition = new UIACondition(testObject); } return(condition); }
public void VirtualControlHelper_LoadVirtualControls() { string appModelPath = "UnitTestVirtualControl.json"; AppModel virtualModel = AppModelManager.Load(appModelPath); Assert.AreEqual(1, virtualModel.Items.Count); ITestObject testObject = virtualModel.Items[0]; Assert.AreEqual(3, testObject.Children.Count); VirtualTestObject[] controls = VirtualControlHelper.GetVirtualControls(testObject); VirtualControlHelper.DumpVirtualControls(controls); }
private void CallGetObject() { ProxyFactoryObject proxyFactory = (ProxyFactoryObject)this.factory.GetObject("&concurrentPrototype"); ITestObject prevTestObject = null; for (int i = 0; i < 20; i++) { ITestObject o = proxyFactory.GetObject() as ITestObject; Assert.IsNotNull(o); Assert.AreNotSame(prevTestObject, o); prevTestObject = o; Thread.Sleep(0); } }
public static ITestObject LoadData(string name, ITestObject parentTestObject) { ITestObject testObject = null; if (parentTestObject == null) { testObject = model.FindFirst(ControlKeys.Name, name); } else { parentTestObject.Find(ControlKeys.Name, name); } return(testObject); }
public void Initialize() { InitializeNakedObjectsFrameworkOnce(); StartTest(); payment1 = GetTestService("Payments").GetAction("All Instances").InvokeReturnCollection().ElementAt(0); payee1 = payment1.GetPropertyByName("Payee"); key1 = payment1.GetPropertyByName("Payee Compound Key"); var customers = GetTestService("Customers").GetAction("All Instances").InvokeReturnCollection(); customer1 = customers.ElementAt(0); customer2 = customers.ElementAt(1); supplier1 = GetTestService("Suppliers").GetAction("All Instances").InvokeReturnCollection().ElementAt(0); }
public virtual void TestEnumDefault() { ITestObject obj = NewTestObject <Object1>(); ITestAction a1 = obj.GetAction("Do Something Else"); ITestParameter p1 = a1.Parameters.First(); ITestParameter p2 = a1.Parameters.Last(); ITestNaked def1 = p1.GetDefault(); ITestNaked def2 = p2.GetDefault(); Assert.AreEqual(TestEnum.Value2, def1.NakedObject.Object); Assert.AreEqual(null, def2); }
public void CleanUp() { CleanupNakedObjectsFramework(); countPayments = 0; countCustomerTwos = 0; countSuppliers = 0; countEmployees = 0; payment1 = null; customer1 = null; customer2a = null; customer2b = null; customer3 = null; payee1 = null; key1 = null; emp1 = null; }
public void ProxyPerformanceTests() { int runs = 5000000; StopWatch watch = new StopWatch(); ITestObject testObject = new ChainableTestObject(null); using (watch.Start("Naked Duration: {0}")) { for (int i = 0; i < runs; i++) { object result = testObject.DoSomething(this); } } ITestObject hardcodedWrapper = new ChainableTestObject(testObject); using (watch.Start("Hardcoded Wrapper Duration: {0}")) { for (int i = 0; i < runs; i++) { object result = hardcodedWrapper.DoSomething(this); } } PeformanceTestAopContextInterceptor interceptor = new PeformanceTestAopContextInterceptor(); ITestObject proxy = CreateProxy(testObject, interceptor, false); using (watch.Start("Proxy Duration ('ExposeProxy'==false): {0}")) { for (int i = 0; i < runs; i++) { object result = proxy.DoSomething(this); } } Assert.AreEqual(runs, interceptor.Calls); interceptor = new PeformanceTestAopContextInterceptor(); proxy = CreateProxy(testObject, interceptor, true); using (watch.Start("Proxy Duration ('ExposeProxy'==true): {0}")) { for (int i = 0; i < runs; i++) { object result = proxy.DoSomething(this); } } Assert.AreEqual(runs, interceptor.Calls); }
public void ProxyObjectWithInterface() { DefaultListableObjectFactory of = new DefaultListableObjectFactory(); of.RegisterObjectDefinition("bar", new RootObjectDefinition(typeof(ObjectWithInterface))); TestAutoProxyCreator apc = new TestAutoProxyCreator(of); of.AddObjectPostProcessor(apc); ITestObject o = of.GetObject("bar") as ITestObject; Assert.IsTrue(AopUtils.IsAopProxy(o)); o.Foo(); Assert.AreEqual(1, apc.NopInterceptor.Count); }
public static double RunTest(ITestObject obj) { long startTime = 0; long stopTime = 0; QueryPerformanceCounter(out startTime); for (int i = 0; i < 10000000; i++) { obj.DoubleValue = 5; double v = obj.DoubleValue; } QueryPerformanceCounter(out stopTime); double duration = (double)(stopTime - startTime) / (double)freq; return(duration); }
//Constructor for collecting all data. public RecoveryScenarios(DataSet recoverDataset, DataSet recoverData, DataSet orData, ITestObject objTest) { _recoverData = recoverDataset; _datasetRecoverBrowser = recoverData; _datasetOr = orData; _objTestObject = objTest; try { if(recoverData.Tables.Count>0) _noOfTimes = new int[recoverData.Tables[0].Rows.Count]; } catch (IndexOutOfRangeException) { } }
public virtual void DMaskOnDateProperty() { obj = NewTestObject<Object1>(); prop1 = obj.GetPropertyByName("Prop1"); prop1.SetValue("23/09/2009 11:34:50"); prop2 = obj.GetPropertyByName("Prop2"); prop2.SetValue("23/09/2009 11:34:50"); var dom = (Object1) obj.GetDomainObject(); StringAssert.Equals("23/09/2009 11:34:50", dom.Prop1.ToString()); StringAssert.Equals("23/09/2009 11:34:50", prop1.Content.Title); StringAssert.Equals("23/09/2009 11:34:50", dom.Prop2.ToString()); StringAssert.Equals("23/09/2009", prop2.Content.Title); prop1.AssertTitleIsEqual("23/09/2009 11:34:50"); prop1.AssertValueIsEqual("23/09/2009 11:34:50"); prop2.AssertTitleIsEqual("23/09/2009"); prop2.AssertValueIsEqual("23/09/2009 11:34:50"); }
public void CreateInstanceWithAutofacCreatesRegisteredType() { ContainerBuilder builder = new ContainerBuilder(); builder.RegisterType <TestObject>().AsImplementedInterfaces(); builder.RegisterType <TestChild>().AsImplementedInterfaces(); IContainer container = builder.Build(); string serializeResult = this.Serialize(container, new TestObject()); ITestObject deserializeResult = this.Deserialize(container, serializeResult); Assert.IsNotNull(deserializeResult); Assert.IsNotNull(deserializeResult.TestChild); }
public virtual void EnumPropertyBasic() { ITestObject foo = NewTestObject <Foo>(); ITestProperty sex1 = foo.GetPropertyByName("Sex1"); ITestNaked[] values = sex1.GetChoices(); Assert.AreEqual(4, values.Count()); Assert.AreEqual("Female", values.ElementAt(0).NakedObject.TitleString()); Assert.AreEqual("Male", values.ElementAt(1).NakedObject.TitleString()); Assert.AreEqual("Not Specified", values.ElementAt(2).NakedObject.TitleString()); Assert.AreEqual("Unknown", values.ElementAt(3).NakedObject.TitleString()); sex1.AssertFieldEntryIsValid("Male"); sex1.AssertFieldEntryInvalid("Man"); }
public void InstantiateWithExplicitCtor() { SimpleInstantiationStrategy strategy = new SimpleInstantiationStrategy(); object obj = strategy.Instantiate( SingletonDefinition, null, Factory, SingletonDefinition.ObjectType.GetConstructor( new Type[] { typeof(string), typeof(int) }), new object[] { "Rick", 19 }); Assert.IsNotNull(obj); Assert.IsTrue(obj is ITestObject); ITestObject actual = (ITestObject)obj; Assert.AreEqual("Rick", actual.Name); Assert.AreEqual(19, actual.Age); }
public void TargetThrowsInvalidCastException() { Exception expectedException = new InvalidCastException(); ITestObject test1 = (ITestObject)factory.GetObject("test1"); try { test1.Exceptional(expectedException); Assert.Fail("Should have thrown exception raised by target"); } catch (Exception ex) { Assert.AreEqual(expectedException, ex, "exception matches"); Assert.AreEqual(1, test1.ExceptionMethodCallCount); } }
public void TestInitialize() { InitializeNakedObjectsFrameworkOnce(); StartTest(); ITestObject cust1To = NewTestObject <Customer>(); cust1 = (Customer)cust1To.GetDomainObject(); cust1.Id = 1; cust1To.Save(); ITestObject cust2To = NewTestObject <Customer>(); cust2 = (Customer)cust2To.GetDomainObject(); cust2.Id = 2; cust2To.Save(); }
public void Initialize() { StartTest(); payment1 = GetAllInstances(typeof(SimpleRepository <Payment>), 0); payee1 = payment1.GetPropertyByName("Payee"); key1 = payment1.GetPropertyByName("Payee Compound Key"); customer1 = GetAllInstances(typeof(SimpleRepository <CustomerOne>), 0); customer2a = GetAllInstances(typeof(SimpleRepository <CustomerTwo>), 0); customer2b = GetAllInstances(typeof(SimpleRepository <CustomerTwo>), 1); customer3 = GetAllInstances(typeof(SimpleRepository <CustomerThree>), 0); customer4 = GetAllInstances(typeof(SimpleRepository <CustomerFour>), 0); customer4a = GetAllInstances(typeof(SimpleRepository <CustomerFour>), 1); supplier1 = GetAllInstances(typeof(SimpleRepository <Supplier>), 0); emp1 = GetAllInstances(typeof(SimpleRepository <Employee>), 0); }
public static AutomationElement GetCalculatorButton1Element() { ObjectDescriptor windowDescriptor = ObjectDescriptor.FromJson(@" {ntype:""uia"",identifyProperties: {name: ""Calculator""}} "); ObjectDescriptor buttonDescriptor = ObjectDescriptor.FromJson(@" {ntype:""uia"",identifyProperties: {name: ""1""}} ", windowDescriptor); ITestObject windowObject = windowDescriptor.GetObject(); UIATestObject uiaObject = (UIATestObject)windowObject.Children[0]; AutomationElement element = uiaObject.AutomationElement; return(element); }
public bool? LeftRightLocator(UIACondition selfCondition, out AutomationElement element) { AutomationElement leftElement = null, rightElement = null; //check if the left or right condtion exist //get the left and right element if (selfCondition.Right != "") { ITestObject rightTO; if (selfCondition.Right.IndexOf(DescriptionString.LeftRightQtpString) >= 0) { //format Right==something rightTO = UIAHelper.ConvertStringToTestObject(selfCondition.Right); } else { //selfCondition.Right is the name, then use the name to extract descriptor rightTO = UIAJsonPersister.LoadData(selfCondition.Right, selfCondition.ParentCondition.TestObject); } UIACondition rightCondition = new UIACondition(rightTO); rightCondition.ParentCondition = selfCondition.ParentCondition; rightElement = Find(rightCondition); } if (selfCondition.Left != "") { ITestObject leftDescriptor = null; if (selfCondition.Left.IndexOf(DescriptionString.LeftRightQtpString) >= 0) { leftDescriptor = UIAHelper.ConvertStringToTestObject(selfCondition.Left); } else { leftDescriptor = UIAJsonPersister.LoadData(selfCondition.Left, selfCondition.ParentCondition.TestObject); } UIACondition leftCondition = new UIACondition(leftDescriptor); leftCondition.ParentCondition = selfCondition.ParentCondition; leftElement = Find(leftCondition); } int sameCount = 0; bool? found = LeftRightCheck(selfCondition, leftElement, rightElement, element); return found; }
public virtual void TestGetActionById() { ITestObject obj = NewTestObject <Object1>(); var a1 = obj.GetActionById("ActionNumber1"); var a2 = obj.GetActionById("ActionNumber2"); try { a1 = obj.GetActionById("Action Number1"); Assert.Fail("Shouldn't get to here!"); } catch (Exception e) { Assert.AreEqual("Assert.Fail failed. No Action named 'Action Number1' (as method name)", e.Message); } //Now with params var a3 = obj.GetActionById("ActionNumber3", typeof(string), typeof(int)); a3 = obj.GetActionById("ActionNumber3"); //Params not necessary //And with wrong param types try { a3 = obj.GetActionById("ActionNumber3", typeof(int), typeof(string)); //wrong way round! Assert.Fail("Shouldn't get to here!"); } catch (Exception e) { Assert.AreEqual("Assert.Fail failed. No Action named 'ActionNumber3' (as method name & with specified parameters)", e.Message); } //Now from sub-menu, with & without params obj.GetActionById("ActionNumber4", "Sub1"); obj.GetActionById("ActionNumber4", "Sub1", typeof(string), typeof(int)); obj.GetActionById("ActionNumber4"); //works without specifying sub-menu obj.GetActionById("ActionNumber4", typeof(string), typeof(int)); //With wrong sub-menu try { obj.GetActionById("ActionNumber4", "Sub2", typeof(string), typeof(int)); Assert.Fail("Shouldn't get to here!"); } catch (Exception e) { Assert.AreEqual("Assert.IsNotNull failed. No menu item with name: Sub2", e.Message); } //With right sub-menu & wrong params try { obj.GetActionById("ActionNumber4", "Sub1", typeof(int), typeof(string)); Assert.Fail("Shouldn't get to here!"); } catch (Exception e) { Assert.AreEqual("Assert.IsTrue failed. Parameter Types do not match for action with method name: ActionNumber4", e.Message); } }
public void MethodPointcuts() { ITestObject tb = (ITestObject)factory.GetObject("pointcuts"); PointcutForVoid.Reset(); Assert.IsTrue((PointcutForVoid.methodNames.Count == 0), "No methods intercepted"); object o = tb.Age; Assert.IsTrue((PointcutForVoid.methodNames.Count == 0), "Not void: shouldn't have intercepted"); tb.Age = 1; o = tb.Age; tb.Name = "Tristan"; tb.ToString(); Assert.AreEqual(2, PointcutForVoid.methodNames.Count, "Recorded wrong number of invocations"); Assert.AreEqual("set_Age", PointcutForVoid.methodNames[0]); Assert.AreEqual("set_Name", PointcutForVoid.methodNames[1]); }
private static void AssertTranslation(ITestObject to) { try { to.Exceptional(new ArithmeticException("Bad Math")); Assert.Fail("Should have thrown exception"); } catch (InvalidOperationException e) { Assert.That(e.InnerException, Is.InstanceOf(typeof(ArithmeticException)), "Inner exception."); Assert.AreEqual("My Message, Method Name Exceptional", e.Message); } catch (Exception e) { Assert.That(e, Is.InstanceOf(typeof(InvalidOperationException)), "wrong exception type thrown."); } }
public static void MergeVirtualControls(ITestObject testObject, VirtualTestObject[] virtualObjects) { //Remove existing virtual objects foreach (ITestObject childObject in testObject.Children) { if (childObject is VirtualTestObject) { testObject.RemoveChild(childObject); } } //Add new virtualObjects foreach (VirtualTestObject virtualObject in virtualObjects) { testObject.AddChild(virtualObject); } }
public void InterceptorInclusionMethods() { NopInterceptor di = new NopInterceptor(); NopInterceptor diUnused = new NopInterceptor(1); // // make instance unique (see SPRNET-847) ProxyFactory factory = new ProxyFactory(new TestObject()); factory.AddAdvice(0, di); ITestObject tb = (ITestObject)factory.GetProxy(); Assert.IsTrue(factory.AdviceIncluded(di)); Assert.IsTrue(!factory.AdviceIncluded(diUnused)); Assert.IsTrue(factory.CountAdviceOfType(typeof(NopInterceptor)) == 1); factory.AddAdvice(0, diUnused); Assert.IsTrue(factory.AdviceIncluded(diUnused)); Assert.IsTrue(factory.CountAdviceOfType(typeof(NopInterceptor)) == 2); }
public void AdvisorAdapterRegistrationManagerPresentInContext() { string configLocation = ReadOnlyXmlTestResource.GetFilePath("withBPPContext.xml", typeof(AdvisorAdapterRegistrationTests)); IApplicationContext ctx = new XmlApplicationContext(configLocation); ITestObject to = (ITestObject)ctx.GetObject("testObject"); // just invoke any method to see if advice fired try { to.ReturnsThis(); Assert.AreEqual(1, GetAdviceImpl(to).InvocationCounter); } catch (UnknownAdviceTypeException) { Assert.Fail("Should not throw UnknownAdviceTypeException"); } }
//Constructor for collecting all data. public RecoveryScenarios(DataSet recoverDataset, DataSet recoverData, DataSet orData, ITestObject objTest) { _recoverData = recoverDataset; _datasetRecoverBrowser = recoverData; _datasetOr = orData; _objTestObject = objTest; try { if (recoverData.Tables.Count > 0) { _noOfTimes = new int[recoverData.Tables[0].Rows.Count]; } } catch (IndexOutOfRangeException) { } }
public void CanSetTransparentProxy() { PropertyOrFieldNode pofNode = new PropertyOrFieldNode(); pofNode.Text = "ObjectProp"; BaseClass ouc = new BaseClass(); TestTransparentProxyFactory tpf = new TestTransparentProxyFactory(null, typeof(ITestObject), null); object tpo = tpf.GetTransparentProxy(); Assert.IsTrue(tpo is ITestObject); ITestObject itpo = tpo as ITestObject; Assert.IsNotNull(itpo); pofNode.SetValue(ouc, null, itpo); Assert.AreSame(tpo, ouc.ObjectProp); }
public CalculatorWindowNode(ITestObject parent, AppModelBase applicationModel) : base(parent, applicationModel) { OnButton = new OnButtonNode(this, applicationModel); OffButton = new OffButtonNode(this, applicationModel); OneButton = new OneButtonNode(this, applicationModel); SixButton = new SixButtonNode(this, applicationModel); AddButton = new AddButtonNode(this, applicationModel); ClearButton = new ClearButtonNode(this, applicationModel); OutputField = new OutputFieldNode(this, applicationModel); CalcButton = new CalcButtonNode(this, applicationModel); MultiplyButton = new MultiplyButtonNode(this, applicationModel); TwoButton = new TwoButtonNode(this, applicationModel); ThreeButton = new ThreeButtonNode(this, applicationModel); MinusButton = new MinusButtonNode(this, applicationModel); NineButton = new NineButtonNode(this, applicationModel); SettingsButton = new SettingsButtonNode(this, applicationModel); DisplayName = @"Calculator"; }
public void CreateProxyFactoryWithoutTargetThenSetTarget() { TestObject target = new TestObject(); target.Name = "Adam"; NopInterceptor nopInterceptor = new NopInterceptor(); CountingBeforeAdvice countingBeforeAdvice = new CountingBeforeAdvice(); ProxyFactory pf = new ProxyFactory(); pf.Target = target; pf.AddAdvice(nopInterceptor); pf.AddAdvisor(new DefaultPointcutAdvisor(countingBeforeAdvice)); object proxy = pf.GetProxy(); ITestObject to = (ITestObject)proxy; Assert.AreEqual("Adam", to.Name); Assert.AreEqual(1, countingBeforeAdvice.GetCalls()); }
private void DecoratorProxyAssertions(ITestObject testObject) { CountingBeforeAdvice cba = (CountingBeforeAdvice)ctx.GetObject("countingBeforeAdvice"); NopInterceptor nop = (NopInterceptor)ctx.GetObject("nopInterceptor"); Assert.AreEqual(0, cba.GetCalls()); Assert.AreEqual(0, nop.Count); Assert.IsTrue(AopUtils.IsDecoratorAopProxy(testObject), testObject + " is not an AOP Proxy"); //extra advice calls are due to test IsDecoratorAopProxy and call to .GetType in impl Assert.AreEqual(1, nop.Count); Assert.AreEqual(1, cba.GetCalls()); int age = 5; testObject.Age = age; Assert.AreEqual(age, testObject.Age); Assert.AreEqual(3, nop.Count); Assert.AreEqual(3, cba.GetCalls()); }
public ITestProperty RemoveFromCollection(ITestObject testObject) { AssertIsVisible(); AssertIsModifiable(); ResetLastMessage(); Assert.IsTrue(field is IOneToManyAssociationSpec, "Cannot remove from non collection"); INakedObjectAdapter testNakedObjectAdapter = testObject.NakedObject; Assert.IsTrue(testNakedObjectAdapter.Spec.IsOfType(field.ReturnSpec), string.Format("Can't clear a {0} from the {1} field (which accepts {2})", testObject.NakedObject.Spec.ShortName, Name, field.ReturnSpec)); INakedObjectAdapter nakedObjectAdapter = owningObject.NakedObject; if (!(field is IOneToManyAssociationSpec)) { throw new UnknownTypeException(field); } IConsent valid = new Veto("Always disabled"); Assert.IsFalse(valid.IsVetoed, string.Format("Can't remove {0} from the field {1} within {2}: {3}", testNakedObjectAdapter, field, nakedObjectAdapter, valid.Reason)); return this; }
public ChainableTestObject(ITestObject next) { this.next = next; }
public void Diddly (ITestObject three) { }
public virtual void TitleAttributeTakesPrecedenceOverTitleMethod() { rep = GetTestService("Object6s"); obj = rep.GetAction("New Instance").InvokeReturnObject(); var dom = (Object6) obj.GetDomainObject(); StringAssert.Equals("Bar", dom.ToString()); StringAssert.Equals("Hex", dom.Title()); obj.AssertTitleEquals("Untitled Object6"); prop1 = obj.GetPropertyByName("Prop1"); prop1.SetValue("Foo"); obj.AssertTitleEquals("Foo"); obj.Save(); obj.AssertTitleEquals("Foo"); }
public OptionalDependencyTestClass(ITestObject obj) { internalTestObject = obj; }
public TestObject(ITestObject spouse) { this.spouse = spouse; }
public DerivedConstructorDependenciesObject( ITestObject spouse1, ITestObject spouse2, IndexedTestObject other, int age, int otherAge) : base(spouse1, spouse2, other) { }
public ITestProperty TestField(ITestObject expected) { SetObject(expected); Assert.AreEqual(expected.NakedObject, Content.NakedObject); return this; }
public ITestProperty AssertSetObjectInvalid(ITestObject testObject) { try { AssertSetObjectIsValid(testObject); } catch (AssertFailedException) { // expected return this; } Assert.Fail("Object {0} was allowed in field {1} : expected it to be invalid", testObject, field); return this; }
public NamedOptionalConstParameterClass([OptionalDependency("test")] ITestObject test) { TestObject = test; }
public ConstructorDependenciesObject(ITestObject spouse1) { this.spouse1 = spouse1; }
private SimpleBeforeAdviceImpl GetAdviceImpl(ITestObject to) { IAdvised advised = (IAdvised) to; IAdvisor advisor = advised.Advisors[0]; return (SimpleBeforeAdviceImpl) advisor.Advice; }
public DerivedConstructorDependenciesObject( ITestObject spouse1, object spouse2, IndexedTestObject other) : base(spouse1, null, other) { }
public ConstructorDependenciesObject(ITestObject spouse1, ITestObject spouse2) { this.spouse1 = spouse1; this.spouse2 = spouse2; }
public void AfterPropertiesSet() { testObject = new TestObject(); initialized = true; }
public ConstructorDependenciesObject(ITestObject spouse1, ITestObject spouse2, IndexedTestObject other) { this.spouse1 = spouse1; this.spouse2 = spouse2; this.other = other; }