private static ConstructorTarget CreateConstructorTarget(XPathNavigator api) { ConstructorTarget target = new ConstructorTarget(); target.parameters = CreateParameterList(api); return(target); }
private void WriteConstructor(ConstructorTarget constructor, ReferenceLinkDisplayOptions options, XmlWriter writer) { WriteType(constructor.Type, options & ~ReferenceLinkDisplayOptions.ShowContainer, writer); if ((options & ReferenceLinkDisplayOptions.ShowParameters) > 0) { IList <Parameter> parameters = constructor.Parameters; WriteMethodParameters(parameters, writer); } }
public void ShouldSetMemberBindingBehaviour() { //test both Ctors here var ctor = typeof(NoCtor).GetConstructor(Type.EmptyTypes); var target1 = new ConstructorTarget(typeof(NoCtor), memberBinding: MemberBindingBehaviour.BindAll); var target2 = new ConstructorTarget(ctor, memberBinding: MemberBindingBehaviour.BindAll); Assert.Same(target1.MemberBindingBehaviour, MemberBindingBehaviour.BindAll); Assert.Same(target2.MemberBindingBehaviour, MemberBindingBehaviour.BindAll); }
public void ShouldSetParameterBindings() { var ctor = typeof(OneCtor).GetConstructor(new[] { typeof(int) }); var bindings = new[] { new ParameterBinding(ctor.GetParameters()[0], new TestTarget(typeof(int))) }; var target = new ConstructorTarget(ctor, parameterBindings: bindings); Assert.Equal(1, target.ParameterBindings.Count); //bindings should not be cloned Assert.Same(bindings[0], target.ParameterBindings[0]); }
public void ShouldCreateTargetForType() { var target = new ConstructorTarget(typeof(NoCtor)); Assert.Equal(typeof(NoCtor), target.DeclaredType); //constructor should not be bound up front Assert.Null(target.Ctor); Assert.Null(target.MemberBindingBehaviour); Assert.Equal(0, target.NamedArgs.Count); Assert.Equal(0, target.ParameterBindings.Count); }
public void compile_and_exercise_build_up() { var args = new StubArguments(); args.Set("Color", "blue"); var target = new ConstructorTarget(null, 5, DateTime.Today); Action<IArguments, object> action = BuilderCompiler.CompileBuildUp(new Plugin(typeof (ConstructorTarget))); action(args, target); target.Color.ShouldEqual("blue"); }
public void ShouldCreateTargetForCtor() { var ctor = typeof(NoCtor).GetConstructor(Type.EmptyTypes); var target = new ConstructorTarget(ctor); //declared type should be lifted from the ctor Assert.Equal(typeof(NoCtor), target.DeclaredType); Assert.Same(ctor, target.Ctor); Assert.Null(target.MemberBindingBehaviour); Assert.Equal(0, target.NamedArgs.Count); Assert.Equal(0, target.ParameterBindings.Count); }
public void ShouldSetNamedArgs() { //named arguments are used when create a JIT-bound target for a type //NOTE: it doesn't matter that the argument doesn't have a matching parameter Dictionary <string, ITarget> namedArgs = new Dictionary <string, ITarget>() { ["arg"] = new TestTarget() }; var target = new ConstructorTarget(typeof(NoCtor), namedArgs: namedArgs); Assert.Equal(1, target.NamedArgs.Count); Assert.Same(target.NamedArgs["arg"], namedArgs["arg"]); }
public void compile_and_exercise_build_up() { var args = new StubArguments(); args.Set("Color", "blue"); var target = new ConstructorTarget(null, 5, DateTime.Today); Action <IArguments, object> action = BuilderCompiler.CompileBuildUp(new Plugin(typeof(ConstructorTarget))); action(args, target); target.Color.ShouldEqual("blue"); }
public void build_an_object() { var args = new StubArguments(); args.Set("name", "Jeremy"); args.Set("age", 35); // That's actually correct, you know, just in case you want to buy me // a birthday present args.Set("birthDay", new DateTime(1974, 1, 1)); ConstructorTarget target = func(args); target.Name.ShouldEqual("Jeremy"); target.Age.ShouldEqual(35); target.BirthDay.ShouldEqual(new DateTime(1974, 1, 1)); }
public void Run(ConstructorTargetTests host) { host.Output.WriteLine("Running Upfront Binding Test \"{0}\"", Description ?? "Unknown binding test"); host.Output.WriteLine(ToString()); //we check that each parameter is bound; and that the bindings are the same as the ones //we were given or added dynamically if not supplied var parameterBindings = SuppliedBindingsFactory(Constructor) ?? new ParameterBinding[0]; ConstructorTarget target = new ConstructorTarget(Constructor, parameterBindings: parameterBindings); var compileContext = host.GetCompileContext(target); var binding = target.Bind(compileContext); ParameterBinding[] expectedBoundParameters = null; var allDefaultBoundParameters = Constructor.GetParameters() .Select(p => new ParameterBinding(p, new TestTarget(p.ParameterType, useFallBack: true))).ToArray(); if (parameterBindings.Length != Constructor.GetParameters().Length) { //join those bindings which match; generate 'fake' ones for those which don't expectedBoundParameters = allDefaultBoundParameters.Select(b => parameterBindings.SingleOrDefault(pb => pb.Parameter == b.Parameter) ?? b).ToArray(); } else { expectedBoundParameters = allDefaultBoundParameters; } Assert.NotNull(binding); Assert.Collection(binding.BoundArguments, expectedBoundParameters.Select(bb => new Action <ParameterBinding>(b => { Assert.Same(bb.Parameter, b.Parameter); //non fallback TestTarget means 'should be bound to this one' //expected fallback TestTarget means 'must be non-null' if (!(bb.Target is TestTarget) || !bb.Target.UseFallback) { Assert.Same(b.Target, bb.Target); } else { Assert.NotNull(bb.Target); } })).ToArray()); }
public static MemberTarget ReadMemberTarget(XmlReader reader) { if (reader == null || reader.NodeType != XmlNodeType.Element) { return(null); } switch (reader.Name) { case "MemberTarget": MemberTarget memberTarget = new MemberTarget(); memberTarget.ReadXml(reader); return(memberTarget); case "ConstructorTarget": ConstructorTarget constructorTarget = new ConstructorTarget(); constructorTarget.ReadXml(reader); return(constructorTarget); case "ProcedureTarget": ProcedureTarget procedTarget = new ProcedureTarget(); procedTarget.ReadXml(reader); return(procedTarget); case "EventTarget": EventTarget eventTarget = new EventTarget(); eventTarget.ReadXml(reader); return(eventTarget); case "PropertyTarget": PropertyTarget propertyTarget = new PropertyTarget(); propertyTarget.ReadXml(reader); return(propertyTarget); case "MethodTarget": MethodTarget methodTarget = new MethodTarget(); methodTarget.ReadXml(reader); return(methodTarget); } return(null); }
private void AreEqual(ConstructorTarget expected, params object[] args) { var reflector = CreateReflector(); var obj = reflector.CreateInstance(args); var result = obj.Equals(expected); Console.WriteLine("Equals[1]: {0}", result); if (!result) { Console.WriteLine("//-----------------------------------------------------------------"); Console.WriteLine("//Equalseメソッドがfalseだったので型の内容を表す文字列を表示します"); Console.WriteLine("//-----------------------------------------------------------------"); Console.WriteLine("//Left"); Console.WriteLine("//-----------------------------------------------------------------"); Console.WriteLine(expected.ToString()); Console.WriteLine("//-----------------------------------------------------------------"); Console.WriteLine("//Right"); Console.WriteLine("//-----------------------------------------------------------------"); Console.WriteLine(obj.ToString()); } Assert.IsTrue(result); }
public void RunBindingTest(ConstructorTargetTests host) { host.Output.WriteLine("Running JIT Binding Test \"{0}\".", Description ?? "Unknown Bindings Test"); host.Output.WriteLine(ToString()); var namedArgs = NamedArgsFactory(); var target = new ConstructorTarget(Type, namedArgs: namedArgs); var compileContext = host.GetCompileContext(target, ContainerFactory()); var binding = target.Bind(compileContext); Xunit.Assert.NotNull(binding); Xunit.Assert.Same(ExpectedConstructor, binding.Constructor); if (namedArgs != null && namedArgs.Count != 0) { Assert.All(namedArgs, kvp => { var boundArg = binding.BoundArguments.SingleOrDefault(p => p.Parameter.Name == kvp.Key); Assert.NotNull(boundArg); Assert.Same(kvp.Value, boundArg.Target); }); } // host.Output.WriteLine("Test Complete"); }
public static Target ReadTarget(XmlReader reader) { if (reader == null || reader.NodeType != XmlNodeType.Element) { return(null); } switch (reader.Name) { case "Target": Target target = new Target(); target.ReadXml(reader); return(target); case "NamespaceTarget": NamespaceTarget namespaceTarget = new NamespaceTarget(); namespaceTarget.ReadXml(reader); return(namespaceTarget); case "TypeTarget": TypeTarget typeTarget = new TypeTarget(); typeTarget.ReadXml(reader); return(typeTarget); case "EnumerationTarget": EnumerationTarget enumTarget = new EnumerationTarget(); enumTarget.ReadXml(reader); return(enumTarget); case "MemberTarget": MemberTarget memberTarget = new MemberTarget(); memberTarget.ReadXml(reader); return(memberTarget); case "ConstructorTarget": ConstructorTarget constructorTarget = new ConstructorTarget(); constructorTarget.ReadXml(reader); return(constructorTarget); case "ProcedureTarget": ProcedureTarget procedTarget = new ProcedureTarget(); procedTarget.ReadXml(reader); return(procedTarget); case "EventTarget": EventTarget eventTarget = new EventTarget(); eventTarget.ReadXml(reader); return(eventTarget); case "PropertyTarget": PropertyTarget propertyTarget = new PropertyTarget(); propertyTarget.ReadXml(reader); return(propertyTarget); case "MethodTarget": MethodTarget methodTarget = new MethodTarget(); methodTarget.ReadXml(reader); return(methodTarget); } return(null); }