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