public void GetClone_Class_Cloned() { var source = new SimpleClass() { Property = 10, _field = 3 }; var target = CloneFactory.GetClone(source); Assert.AreEqual(source.Property, target.Property); Assert.AreEqual(source._field, target._field); }
public void TestSimpleObject() { var nodeContainer = new NodeContainer(); var instance = new SimpleClass { Member1 = 3, Member2 = new SimpleClass() }; var rootNode = nodeContainer.GetOrCreateNode(instance); var visitor = new TestVisitor(); visitor.Visit(rootNode); var expectedNodes = new[] { rootNode, rootNode.TryGetChild(nameof(SimpleClass.Member1)), rootNode.TryGetChild(nameof(SimpleClass.Member2)), rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target, rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member1)), rootNode.TryGetChild(nameof(SimpleClass.Member2)).Target.TryGetChild(nameof(SimpleClass.Member2)), }; var expectedPaths = new[] { new GraphNodePath(rootNode), new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member1)), new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)), new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget(), new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member1)), new GraphNodePath(rootNode).PushMember(nameof(SimpleClass.Member2)).PushTarget().PushMember(nameof(SimpleClass.Member2)), }; VerifyNodesAndPath(expectedNodes, expectedPaths, visitor); }
public void CopyTo() { ViewFactory<SimpleClass> factory = ViewFactory<SimpleClass>.IList(); IList<SimpleClass> list = factory.List; list.Add(new SimpleClass(100, "aaa", new DateTime(1970, 1, 1))); list.Add(new SimpleClass(80, "bbb", new DateTime(1980, 12, 12))); list.Add(new SimpleClass(60, "ccc", new DateTime(1975, 6, 6))); SimpleClass[] array = new SimpleClass[3]; ((ICollection)factory.View).CopyTo(array, 0); SimpleClass item = array[0]; Assert.IsNotNull(item); Assert.AreEqual(100, item.IntegerValue); Assert.AreEqual("aaa", item.StringValue); Assert.AreEqual(new DateTime(1970, 1, 1), item.DateTimeValue); item = array[1]; Assert.AreEqual(80, item.IntegerValue); Assert.AreEqual("bbb", item.StringValue); Assert.AreEqual(new DateTime(1980, 12, 12), item.DateTimeValue); item = array[2]; Assert.AreEqual(60, item.IntegerValue); Assert.AreEqual("ccc", item.StringValue); Assert.AreEqual(new DateTime(1975, 6, 6), item.DateTimeValue); }
public static void Main() { SimpleStruct ss = new SimpleStruct(); ss.X = 5; ss.DisplayX(); SS si = (SS) ss; si.X = 90; si.DisplayX(); ss = (SimpleStruct) si ; ss.X = 5; ss.DisplayX(); SimpleClass ss1 = new SimpleClass(); ss1.X = 5; ss1.DisplayX(); try { ss1 = (SimpleClass) si ; ss1.X = 5; ss1.DisplayX(); } catch(Exception) { Console.WriteLine("Failed to cast"); } }
public void CrossoverTest() { var obj = new SimpleClass(); var generator = new Generator<SimpleClass>(); CodeExpression<SimpleClass> leftTree = generator.BuildRandomExpressionTree(); CodeExpression<SimpleClass> rightTree = generator.BuildRandomExpressionTree(); Trace.WriteLine("Vor dem Crossover"); Trace.WriteLine("-----------------"); Trace.WriteLine(""); Trace.WriteLine("Tree links:"); Trace.WriteLine(leftTree); Trace.WriteLine(""); Trace.WriteLine("Tree rechts:"); Trace.WriteLine(rightTree); generator.Crossover(ref leftTree, ref rightTree); Trace.WriteLine(""); Trace.WriteLine("Nach dem Crossover"); Trace.WriteLine("------------------"); Trace.WriteLine(""); Trace.WriteLine("Tree links:"); Trace.WriteLine(leftTree); Trace.WriteLine(""); Trace.WriteLine("Tree rechts:"); Trace.WriteLine(rightTree); }
public static SimpleClass delegate_test_class(SimpleClass ss) { if (ss == null) return null; if (! (!ss.a && ss.b && !ss.c && ss.d == "TEST")) return null; SimpleClass res = ss; return res; }
static void Main (string[] args) { var v = ObjCRuntime.Dlfcn.dlopen (GetCurrentExecutingDirectory () + "/SimpleClass.dylib", 0); NSApplication.Init (); SimpleClass c = new SimpleClass (); Console.WriteLine (c.DoIt()); }
public void TestExecuteMethod() { SimpleClass simpleClass = new SimpleClass(); Assert.IsFalse(simpleClass.MethodCalled); ReflectionUtilities.ExecuteMethod(simpleClass, "MyMethod"); Assert.IsTrue(simpleClass.MethodCalled); }
public void ToViewModel_Simple_Class() { var model = new SimpleClass { A = 5, B = "test" }; var json = Knockout.ToViewModel(model); Assert.AreEqual("{\"A\":ko.observable(5),\"B\":ko.observable(\"test\")}", json.ToJson()); }
public void BuildNullObject6() { UnityContainer uc = new UnityContainer(); SimpleClass myObject = new SimpleClass(); uc.BuildUp(myObject, String.Empty); Assert.AreNotEqual(uc.Resolve<SimpleClass>(), myObject); }
public void GetBindingInstance_should_return_instance_specified_through_SetBindingInstance() { var scenarioContext = CreateScenarioContext(); var expectedInstance = new SimpleClass(); scenarioContext.SetBindingInstance(typeof(SimpleClass), expectedInstance); var result = scenarioContext.GetBindingInstance(typeof(SimpleClass)); result.Should().Be(expectedInstance); }
public void TestExecuteMethod_WithReturnValue() { SimpleClass simpleClass = new SimpleClass(); Assert.IsFalse(simpleClass.MethodCalled); var returnValue = ReflectionUtilities.ExecuteMethod(simpleClass, "MyMethodWithReturn"); Assert.IsTrue(simpleClass.MethodCalled); Assert.IsTrue(Convert.ToBoolean(returnValue)); }
public void PacksDefinedClassCorrectly() { var toPack = new SimpleClass {A = true}; var expected = new List<byte> {0xA1, 0x81, 0x41, (byte) Markers.True}; //1 fields var actual = Packers.Map.Pack(toPack); actual.Should().Equal(expected); }
public void TestReadonly() { SimpleClass instance = new SimpleClass(); int value = 100; instance.m_array[0] = value; Assert.AreEqual(value, instance.m_array[0]); }
public void GenerateExpressionTree() { var obj = new SimpleClass(); var generator = new Generator<SimpleClass>(); var func = generator.BuildRandomExpressionTree(); Trace.WriteLine(func); func.Execute(obj); }
public void I_want_some_nifty_helpers_to_make_generics_useful() { SimpleClass testClass = new SimpleClass(); SingleGenericClass<Guid> single = new SingleGenericClass<Guid>(Guid.NewGuid()); DoubleGenericClass<SingleGenericClass<Guid>, Guid> argument = new DoubleGenericClass<SingleGenericClass<Guid>, Guid>(single, single.Key); Generic.Call(testClass, x => x.DoubleGenericMethod<object, object>(null), argument); }
public static int delegate_test_class_out(out SimpleClass ss) { ss = new SimpleClass (); ss.a = true; ss.b = false; ss.c = true; ss.d = "RES"; return 0; }
public void Takes_Properties() { var properties = new [] { "Property1", "Property2" }; var target = new SimpleClass { Property1 = "Property1", Property2 = 32 }; var line = Sugar.ComposeLine<SimpleClass>(SerializeMethod.CSV, properties, target); Assert.Equal("Property1,32", line); }
public void BuildNullObject7() { UnityContainer uc = new UnityContainer(); SimpleClass myObject1 = new SimpleClass(); SimpleClass myObject2 = new SimpleClass(); uc.BuildUp(myObject1, String.Empty); uc.BuildUp(myObject2, (string)null); Assert.AreNotEqual(uc.Resolve<SimpleClass>(), myObject2); }
public void LoggingToolkit_Methods_LogsMethodEnter() { SimpleClass s = new SimpleClass(); s.MethodWith1Argument("asd"); Thread.Sleep( 100 ); //Make sure method is executed string output = OutputString.ToString(); StringAssert.Contains("Entering: PostSharp.Toolkit.Integration.Tests.SimpleClass.MethodWith1Argument(string stringArg = \"asd\")", output); }
public void Ignores_Case() { var properties = new [] { "PROPERTY1" }; var target = new SimpleClass { Property1 = "Property1", Property2 = 32 }; var line = Sugar.ComposeLine<SimpleClass>(SerializeMethod.FixedWidth, properties, target); Assert.Equal("Property1", line); }
public void IndexOfItemNotInList() { ViewFactory<SimpleClass> factory = ViewFactory<SimpleClass>.IList(); IList<SimpleClass> list = factory.List; list.Add(new SimpleClass(100, "aaa", new DateTime(1970, 1, 1))); SimpleClass bbb = new SimpleClass(80, "bbb", new DateTime(1980, 12, 12)); list.Add(new SimpleClass(60, "ccc", new DateTime(1975, 6, 6))); Assert.AreEqual(-1, factory.View.IndexOf(bbb)); }
public void Inner_Properties() { var properties = new [] { "Property3.Property1" }; var target = new SimpleClass { Property1 = "Property1", Property2 = 32, Property3 = new InnerClass { Property1 = "Property3" } }; var line = Sugar.ComposeLine<SimpleClass>(SerializeMethod.CSV, properties, target); Assert.Equal("Property3", line); }
public void InjectDependencies_ShouldPopulateInterfacePropertyOnObject_GivenTheInterfaceIsRegisteredWithTheContainer() { var container = new WindsorContainer(); container.Register(Component.For<IService>().ImplementedBy<ServiceImpl>()); var objectWithDependencies = new SimpleClass(); container.Kernel.InjectDependencies(objectWithDependencies); container.Kernel.ReleaseDependencies(objectWithDependencies); Assert.That(objectWithDependencies.Dependency, Is.InstanceOf<ServiceImpl>()); }
public void FirstIntegrationTest() { //arrange string expected = "F#"; SimpleClass sc = new SimpleClass(); //act var result = sc.X; OutputWriter.WriteLine("result: {0}", result); //assert result.Should().Be(expected); }
private static void Main() { SimpleClass myTest = new SimpleClass(); Type myType = typeof(SimpleClass); object[] myAttributes = myType.GetCustomAttributes(false); foreach (VersionAttribute item in myAttributes) { Console.WriteLine("{0} {1}", item, item.Version); } }
public void Trace_OnException_PrintsException() { SimpleClass s = new SimpleClass(); try { s.MethodThrowsException(); } catch { } string output = OutputString.ToString(); StringAssert.Contains("System.Exception: This is an exception", output); }
public void Multiple() { var source = new SimpleClass(); var patched = new SimpleClass() { Integer2 = 7, String2 = "Something" }; var diff = DiffBuilder.Build(source, patched); Assert.True(JObject.DeepEquals( JObject.Parse("{Integer2: 7, String2:'Something'}"), diff)); }
public static int delegate_test_byval_class_inout(SimpleClass ss) { if ((ss.a != false) || (ss.b != true) || (ss.c != false) || (ss.d != "FOO")) { return(1); } ss.a = true; ss.b = false; ss.c = true; ss.d = "RES"; return(0); }
public void NullToValue() { var source = new SimpleClass(); var patched = new SimpleClass() { String1 = "value" }; var diff = DiffBuilder.Build(source, patched); Assert.True(JObject.DeepEquals( JObject.Parse("{String1:'value'}"), diff)); }
public void ValueToNull() { var source = new SimpleClass(); var patched = new SimpleClass() { String2 = null }; var diff = DiffBuilder.Build(source, patched); Assert.True(JObject.DeepEquals( JObject.Parse("{String2:null}"), diff)); }
public void PacksDefinedClassCorrectly() { var toPack = new SimpleClass { A = true }; var expected = new List <byte> { 0xA1, 0x81, 0x41, Markers.True }; //1 fields var actual = Packers.Map.Pack(toPack); actual.Should().Equal(expected); }
public void UnpacksDefinedClass_WithProperty() { var expected = new SimpleClass { A = true }; var toUnpack = new List <byte> { 0xA1, 0x81, 0x41, Markers.True }; //1 fields var actual = Packers.Map.Unpack <SimpleClass>(toUnpack.ToArray()); actual.ShouldBeEquivalentTo(expected); }
public void IndexOf() { var factory = ViewFactory <SimpleClass> .IList(); var list = factory.List; list.Add(new SimpleClass(100, "aaa", new DateTime(1970, 1, 1))); var bbb = new SimpleClass(80, "bbb", new DateTime(1980, 12, 12)); list.Add(bbb); list.Add(new SimpleClass(60, "ccc", new DateTime(1975, 6, 6))); Assert.AreEqual(1, ((IList)factory.View).IndexOf(bbb)); }
private void returns_intercepted_parameters_as_string_when_GenericWithRepeatedGenericParameterReturnInterceptedOutParameters_is_called() { Execute(() => { var instance = new InterceptGenericMethodsClass <int, string>(); var interceptedP1 = 2; var interceptedP2 = new SimpleStruct(2); var interceptedP3 = new SimpleClass(2); var interceptedP4 = new[] { 1, 2 }; var interceptedP5 = new[] { new SimpleStruct(1), new SimpleStruct(2) }; var interceptedP6 = new[] { new SimpleClass(1), new SimpleClass(2) }; var interceptedP7 = new List <int> { 1, 2 }; var interceptedP8 = new List <SimpleStruct> { new SimpleStruct(1), new SimpleStruct(2) }; var interceptedP9 = new List <SimpleClass> { new SimpleClass(1), new SimpleClass(2) }; int out1; SimpleStruct out2; SimpleClass out3; int[] out4; SimpleStruct[] out5; SimpleClass[] out6; List <int> out7; List <SimpleStruct> out8; List <SimpleClass> out9; instance.GenericWithRepeatedGenericParameterReturnInterceptedOutParameters <SimpleClass, SimpleStruct>(out out1, out out2, out out3, out out4, out out5, out out6, out out7, out out8, out out9); Assert.Equal(interceptedP1, out1); Assert.Equal(interceptedP2.Value, out2.Value); Assert.Equal(interceptedP3.Value, out3.Value); Assert.Equal(interceptedP4[0], out4[0]); Assert.Equal(interceptedP4[1], out4[1]); Assert.Equal(interceptedP5[0].Value, out5[0].Value); Assert.Equal(interceptedP5[1].Value, out5[1].Value); Assert.Equal(interceptedP6[0].Value, out6[0].Value); Assert.Equal(interceptedP6[1].Value, out6[1].Value); Assert.Equal(interceptedP7[0], out7[0]); Assert.Equal(interceptedP7[1], out7[1]); Assert.Equal(interceptedP8[0].Value, out8[0].Value); Assert.Equal(interceptedP8[1].Value, out8[1].Value); Assert.Equal(interceptedP9[0].Value, out9[0].Value); Assert.Equal(interceptedP9[1].Value, out9[1].Value); }); }
public void Inner_Properties() { var properties = new [] { "Property3.Property1" }; var target = new SimpleClass { Property1 = "Property1", Property2 = 32, Property3 = new InnerClass { Property1 = "Property3" } }; var line = Sugar.ComposeLine <SimpleClass>(SerializeMethod.CSV, properties, target); Assert.Equal("Property3", line); }
public void GetBindingInstance_should_return_instance_through_BindingInstanceResolver() { var expectedInstance = new SimpleClass(); var scenarioContext = CreateScenarioContext(registerGlobalMocks: (globalContainer => { var bindingInstanceResolverMock = new Mock<IBindingInstanceResolver>(); bindingInstanceResolverMock.Setup(m => m.ResolveBindingInstance(typeof(SimpleClass), It.IsAny<IObjectContainer>())) .Returns(expectedInstance); globalContainer.RegisterInstanceAs(bindingInstanceResolverMock.Object); })); var result = scenarioContext.GetBindingInstance(typeof(SimpleClass)); result.Should().Be(expectedInstance); }
public void ComplexCopyTest() { var simple = new SimpleClass() { Primitive = 1, Str = "apollo ssc" }; var obj = new ComplexClass { Reference = simple }; var copy = obj.Copy(); Check.That(obj).IsNotEqualTo(copy); Check.That(obj.Reference).IsNotEqualTo(copy.Reference); Check.That(obj.Reference.Str).IsEqualTo("apollo ssc"); }
public void ContainsItemInList() { var factory = ViewFactory <SimpleClass> .IList(); var list = factory.List; var view = factory.View; list.Add(new SimpleClass(100, "aaa", new DateTime(1970, 1, 1))); var bbb = new SimpleClass(80, "bbb", new DateTime(1980, 12, 12)); list.Add(bbb); list.Add(new SimpleClass(60, "ccc", new DateTime(1975, 6, 6))); Assert.IsTrue(view.Contains(bbb)); }
static void Main(string[] args) { SimpleClass simpleClass = new SimpleClass(); MyDelegate handler1 = simpleClass.Method1; MyDelegate handler2 = simpleClass.Method2; // Статический метод. MyDelegate handler3 = SimpleClass.Method3; MyDelegate handler4 = handler1 + handler2 + handler3; handler4(); Console.ReadLine(); }
public void ContainsItemInList() { ViewFactory <SimpleClass> factory = ViewFactory <SimpleClass> .IList(); IList <SimpleClass> list = factory.List; ObjectListView <SimpleClass> view = factory.View; list.Add(new SimpleClass(100, "aaa", new DateTime(1970, 1, 1))); SimpleClass bbb = new SimpleClass(80, "bbb", new DateTime(1980, 12, 12)); list.Add(bbb); list.Add(new SimpleClass(60, "ccc", new DateTime(1975, 6, 6))); Assert.IsTrue(((IList)view).Contains(bbb)); }
public void ShouldRecordMasterListKeys() { SimpleClass[] masterList = new SimpleClass[19]; objectBuilder.Construct(Arg.Any <int>()).Returns(new SimpleClass()); declaration = new RangeDeclaration <SimpleClass>(listBuilderImpl, objectBuilder, 9, 10); declaration.Construct(); declaration.AddToMaster(masterList); Assert.That(declaration.MasterListAffectedIndexes.Count, Is.EqualTo(2)); Assert.That(declaration.MasterListAffectedIndexes[0], Is.EqualTo(9)); Assert.That(declaration.MasterListAffectedIndexes[1], Is.EqualTo(10)); }
public void Create() { this.Initialize(); var simple = new SimpleClass().CreateProxy(this.DebugContext, this); simple.Hook(); simple.DoNotHook(); simple.Hook(); var hooks = this.Counts["Hook"]; Assert.Equal(2, hooks.BeforeCount); Assert.Equal(2, hooks.AfterCount); Assert.Equal(0, hooks.AfterExceptionCount); }
public async Task ValidClassIsValidWithCustomRulesForAsync() { var simple = new SimpleClass { Number = 2, Text = "A value" }; var complex = new ComplexClass { Id = Guid.NewGuid(), Child = simple }; var validator = new ComplexClassValidator(new SimpleClassValidator()) as Core.Validators.IValidator <ComplexClass>; var result = await validator?.ValidateAsync(complex, ComplexClassValidator.RuleSetName); validator.Should().NotBeNull("because the base validator should impleent the base IValidator<T> contract"); result.Should().NotBeNull("because a set should be returned even for valid objects"); result.Should().HaveCount(0, "because a valid object should have no errors"); }
private void returns_original_parameters_as_string_when_GenericWithRepeatedGenericParameterReturnOriginalParametersAsString_is_called() { Execute(() => { var instance = new InterceptGenericMethodsClass <int, string>(); var p1 = 1; var p2 = new SimpleStruct(1); var p3 = new SimpleClass(1); var expected = Helper.AsString(p1, p2, p3); var result = instance.GenericWithRepeatedGenericParameterReturnOriginalParametersAsString <SimpleClass, SimpleStruct>(p1, p2, p3); Assert.Equal(expected, result); }); }
public void AfterConstructionOf_PropertySetter_NullValue() { var builder = new Builder(1) .For <SimpleClass>() .Set(c => c.StringProperty, (string)null) .Set(c => c.StringField, (string)null) ; SimpleClass newClass = null; Assert.DoesNotThrow(() => newClass = builder.Build <SimpleClass>()); Assert.IsNotNull(newClass); Assert.IsNull(newClass.StringProperty); Assert.IsNull(newClass.StringField); }
public void Run() { Type t = typeof(SimpleClass); BindingFlags flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy; MemberInfo[] members = t.GetMembers(flags); Console.WriteLine($"Type {t.Name} has {members.Length} members: "); foreach (var member in members) { string access = ""; string stat = ""; var method = member as MethodBase; if (method != null) { if (method.IsPublic) { access = " Public"; } else if (method.IsPrivate) { access = " Private"; } else if (method.IsFamily) { access = " Protected"; } else if (method.IsAssembly) { access = " Internal"; } else if (method.IsFamilyOrAssembly) { access = " Protected Internal "; } if (method.IsStatic) { stat = " Static"; } } var output = $"{member.Name} ({member.MemberType}): {access}{stat}, Declared by {member.DeclaringType}"; Console.WriteLine(output); } SimpleClass sc = new SimpleClass(); Console.WriteLine(sc.ToString()); }
public void Store_two_objects_one_commited_one_reverted() { var a = new SimpleClass(); a.Name = "abc"; a.Value = 3; var b = new SimpleClass(); b.Name = "def"; b.Value = 6; using (var odb = OdbFactory.Open(DbName)) { odb.Store(a); odb.Commit(); odb.Store(b); odb.Rollback(); } using (var odb = OdbFactory.Open(DbName)) { var items = odb.QueryAndExecute <SimpleClass>(); Assert.That(items.Count, Is.EqualTo(1)); var item = items.GetFirst(); Assert.That(item.Name, Is.EqualTo("abc")); Assert.That(item.Value, Is.EqualTo(3)); } using (var odb = OdbFactory.Open(DbName)) { var item = odb.QueryAndExecute <SimpleClass>().GetFirst(); item.Name = "ghi"; odb.Store(item); odb.Commit(); item.Value = 9; odb.Store(item); odb.Rollback(); } using (var odb = OdbFactory.Open(DbName)) { var item = odb.QueryAndExecute <SimpleClass>().GetFirst(); Assert.That(item.Name, Is.EqualTo("ghi")); Assert.That(item.Value, Is.EqualTo(3)); } }
public void ShouldPreserveIdentity() { var str = "This is a string"; var simple1 = new SimpleClass { Str = str }; var simple2 = new SimpleClass { Str = str }; var container = new SimpleContainer { First = simple1, Second = simple2 }; var copy = SerializerClone(container); Assert.AreSame(copy.First.Str, copy.Second.Str); }
public void ShouldRecordMasterListKeys() { SimpleClass[] masterList = new SimpleClass[19]; using (mocks.Record()) objectBuilder.Expect(x => x.Construct(Arg <int> .Is.Anything)).Return(new SimpleClass()).Repeat.Times(2); declaration = new RangeDeclaration <SimpleClass>(listBuilderImpl, objectBuilder, 9, 10); declaration.Construct(); declaration.AddToMaster(masterList); Assert.That(declaration.MasterListAffectedIndexes.Count, Is.EqualTo(2)); Assert.That(declaration.MasterListAffectedIndexes[0], Is.EqualTo(9)); Assert.That(declaration.MasterListAffectedIndexes[1], Is.EqualTo(10)); }
public static SimpleClass delegate_test_class(SimpleClass ss) { if (ss == null) { return(null); } if (!(!ss.a && ss.b && !ss.c && ss.d == "TEST")) { return(null); } SimpleClass res = ss; return(res); }
public void Log4Net_OnException_PrintsException() { SimpleClass s = new SimpleClass(); try { s.MethodThrowsException(); } catch { } string output = OutputString.ToString(); StringAssert.Contains("An exception occurred:\nSystem.Exception", output); }
public void ShouldRecordMasterListKeys() { SimpleClass[] masterList = new SimpleClass[19]; objectBuilder.BuilderSettings.Returns(builderSettings); objectBuilder.Construct(Arg.Any <int>()).Returns(new SimpleClass()); declaration = new GlobalDeclaration <SimpleClass>(listBuilderImpl, objectBuilder); declaration.Construct(); declaration.AddToMaster(masterList); declaration.MasterListAffectedIndexes.Count.ShouldBe(2); declaration.MasterListAffectedIndexes[0].ShouldBe(0); declaration.MasterListAffectedIndexes[1].ShouldBe(1); }
private void returns_intercepted_parameters_as_string_when_ReturnInterceptedParametersAsString_is_called() { Execute(() => { var instance = new InterceptGenericMethodsWithConstraintsClass <InheritsFromSimpleClass, SimpleClass>(); var interceptedP1 = new InheritsFromSimpleClass(2); var interceptedP2 = new SimpleClass(2); var expected = Helper.AsString(interceptedP1, interceptedP2); var originalP1 = new InheritsFromSimpleClass(1); var originalP2 = new SimpleClass(1); var result = instance.ReturnInterceptedParametersAsString(originalP1, originalP2); Assert.Equal(expected, result); }); }
public static int delegate_test_class_byref (ref SimpleClass ss) { if (ss == null) return -1; if (!ss.a && ss.b && !ss.c && ss.d == "TEST") { ss.a = true; ss.b = false; ss.c = true; ss.d = "RES"; return 0; } return 1; }
private void returns_original_parameters_as_string_when_GenericReturnOriginalParametersAsString_is_called() { Execute(() => { var instance = new InterceptGenericMethodsWithConstraintsClass <InheritsFromSimpleClass, SimpleClass>(); var p1 = new InheritsFromSimpleClass(1); var p2 = new SimpleClass(1); var p3 = new SimpleStruct(1); var p4 = new SimpleClass(1); var expected = Helper.AsString(p1, p2, p3, p4); var result = instance.GenericReturnOriginalParametersAsString <SimpleStruct, SimpleClass>(p1, p2, p3, p4); Assert.Equal(expected, result); }); }
public void ItemGet() { ViewFactory <SimpleClass> factory = ViewFactory <SimpleClass> .IList(); IList <SimpleClass> list = factory.List; list.Add(new SimpleClass(100, "aaa", new DateTime(1970, 1, 1))); SimpleClass bbb = new SimpleClass(80, "bbb", new DateTime(1980, 12, 12)); list.Add(bbb); list.Add(new SimpleClass(60, "ccc", new DateTime(1975, 6, 6))); SimpleClass item = factory.View[1]; Assert.AreEqual(bbb, item); }
public void TestExecuteMethodDoesntExist() { //---------------Set up test pack------------------- SimpleClass simpleClass = new SimpleClass(); //---------------Execute Test ---------------------- try { ReflectionUtilities.ExecuteMethod(simpleClass, "InvalidMethod"); Assert.Fail("Expected to throw an Exception"); } //---------------Test Result ----------------------- catch (Exception ex) { StringAssert.Contains("Virtual method call for 'InvalidMethod' does not exist for object of type 'SimpleClass'", ex.Message); } }
public void Test_SetPropertyValue_ThatThrowsError_ShouldRethrowError() { //---------------Set up test pack------------------- SimpleClass simpleClass = new SimpleClass(); //---------------Execute Test ---------------------- try { ReflectionUtilities.SetPropertyValue(simpleClass, "MyPropWithException", true); Assert.Fail("Expected to throw an HabaneroApplicationException"); } //---------------Test Result ----------------------- catch (HabaneroApplicationException ex) { StringAssert.Contains("Error setting public property 'MyPropWithException' for object of type 'SimpleClass'", ex.Message); Assert.IsInstanceOf<ArgumentNullException>(ex.InnerException); StringAssert.Contains("Value cannot be null", ex.InnerException.Message); } }
public void MutationTest() { var obj = new SimpleClass(); var generator = new Generator<SimpleClass>(); CodeExpression<SimpleClass> tree = generator.BuildRandomExpressionTree(); Trace.WriteLine("Vor der Mutation"); Trace.WriteLine("----------------"); Trace.WriteLine(""); Trace.WriteLine(tree); generator.Mutate(ref tree); Trace.WriteLine(""); Trace.WriteLine("Nach der Mutation"); Trace.WriteLine("-----------------"); Trace.WriteLine(""); Trace.WriteLine(tree); }