public void Pass_Correct_Values_To_Server_Client()
{
// arrange
var args = new[] { "-n", "test" };
var initMethod = new InitMethod();
var clientBuilder = new ServerClientBuilder();
var dbg = new DebugEngineProxyBuilder();
var builder = new TimeTravelFacadeBuilder(dbg);
builder.WithGetStartingPosition(new Position(0, 0)).WithGetEndingPosition(new Position(1, 0));
initMethod.TimeTravelFacade = builder.Build();
initMethod.ServerClient = clientBuilder.Build();
initMethod.Settings = new Settings
{
ServerUrl = "http://localhost:5000"
};
// act
initMethod.Process(args);
// assert
clientBuilder.Mock.Verify(
client => client.InitializeProject("test", new Position(0, 0), new Position(1, 0)), Times.Once);
}
public AssistTypeBuilderContainer(ModuleBuilder moduleBuilder, TypeBuilder typeBuilder)
{
ModuleBuilder = moduleBuilder;
TypeBuilder = typeBuilder;
Fields = new Dictionary <string, FieldBuilder>();
InitMethod = TypeBuilder.DefineMethod("Init", MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard, typeof(void), new Type[] { typeof(IInterceptorCreator) });
InitMethodIL = InitMethod.GetILGenerator();
}
private async Task ExecuteTestInit(object testClassInstance)
{
var result = InitMethod?.Invoke(testClassInstance, null);
if (result is Task t)
{
await t;
}
}
public void Correctly_Extract_Options_From_String_Array()
{
var initMethod = new InitMethod();
Action a = () => initMethod.ExtractOptions(null);
a.Should().Throw <ArgumentNullException>();
a = () => initMethod.ExtractOptions(new[] { "" });
a.Should().Throw <ArgumentOutOfRangeException>();
var one = initMethod.ExtractOptions(new[] { "--name", "test" });
one.ProjectName.Should().Be("test");
var two = initMethod.ExtractOptions(new[] { "-n", "test" });
two.ProjectName.Should().Be("test");
}
/// <summary>
/// Invokes the current method on the given instance.
/// </summary>
/// <param name="instance">The object instance</param>
/// <param name="scope">The current service scope</param>
/// <param name="managerInit">If manager init should be invoked</param>
public async Task InvokeAsync(object instance, IServiceScope scope, bool managerInit)
{
if (!managerInit)
{
if (InitMethod != null)
{
await InitMethod.InvokeAsync(instance, scope).ConfigureAwait(false);
}
}
else
{
if (InitManagerMethod != null)
{
await InitManagerMethod.InvokeAsync(instance, scope).ConfigureAwait(false);
}
}
}
private void AddToSelectable(Component parentSelectableComponent)
{
_selectable.transform.SetParent(parentSelectableComponent.transform, true);
object thisSelectable = _selectable.GetComponent(SelectableType);
object parentSelectable = parentSelectableComponent.GetComponent(SelectableType);
ParentField.SetValue(thisSelectable, parentSelectable);
Array parentChildren = (Array)ChildrenField.GetValue(parentSelectable);
Array newParentChildren = Array.CreateInstance(SelectableType, parentChildren.Length + 1);
Array.Copy(parentChildren, newParentChildren, holdableChildIndex);
newParentChildren.SetValue(thisSelectable, holdableChildIndex);
Array.Copy(parentChildren, holdableChildIndex, newParentChildren, holdableChildIndex + 1, parentChildren.Length - holdableChildIndex);
ChildrenField.SetValue(parentSelectable, newParentChildren);
ChildRowLengthField.SetValue(parentSelectable, ((int)ChildRowLengthField.GetValue(parentSelectable)) + 1);
InitMethod.Invoke(parentSelectable, null);
InputHelper.InvokeConfigureSelectableAreas(parentSelectableComponent);
}
public DefaultValueAttribute(InitMethod initMethod)
{
InitMethod = initMethod;
}
private static ServiceDescriptor CreateDescriptor(this Type Service, Type?Implementation, ServiceLifetime Mode)
{
var service_type = Implementation ?? Service;
var ctor = service_type.GetConstructors(BindingFlags.Instance | BindingFlags.Public)
.Concat(service_type.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic))
.OrderByDescending(c => c.GetParameters().Length)
.First();
var sp = Expression.Parameter(typeof(IServiceProvider), "sp");
var get_service = sp.Type.GetMethod("GetService") ?? throw new InvalidOperationException();
var ctor_parameters = ctor.GetParameters()
.Select(p => Expression.Convert(Expression.Call(sp, get_service, Expression.Constant(p.ParameterType)), p.ParameterType));
var properties = service_type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty)
.Concat(service_type.GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.SetProperty))
.Where(p => p.GetCustomAttribute <InjectAttribute>() != null)
.Select(p =>
{
var type = Expression.Constant(p.PropertyType);
var obj = Expression.Call(sp, get_service, type);
var value = Expression.Convert(obj, p.PropertyType);
return((MemberBinding)Expression.Bind(p, value));
})
.ToArray();
var ctor_expr = Expression.New(ctor, ctor_parameters);
Expression instance = properties.Length > 0
? Expression.MemberInit(ctor_expr, properties)
: ctor_expr;
var result = Expression.Variable(Service, "result");
var methods = service_type.GetMethods(BindingFlags.Instance | BindingFlags.Public)
.Concat(service_type.GetMethods(BindingFlags.Instance | BindingFlags.NonPublic))
.Where(InitMethod => InitMethod.GetCustomAttribute <InjectAttribute>() != null)
.Select(InitMethod =>
{
var parameters = InitMethod
.GetParameters()
.Select(p =>
{
var type = Expression.Constant(p.ParameterType);
var obj = Expression.Call(sp, get_service, type);
return(Expression.Convert(obj, p.ParameterType));
});
return((Expression)Expression.Call(result, InitMethod, parameters));
})
.ToArray();
var body = methods.Length > 0
? Expression.Block(
new[] { result },
Expression.Assign(result, instance),
methods.Length == 1 ? methods[0] : Expression.Block(methods),
result)
: instance;
var factory_expr = Expression.Lambda <Func <IServiceProvider, object> >(body, sp);
var factory = factory_expr.Compile();
return(new ServiceDescriptor(Service, factory, Mode));
}
