public static void Main(string[] args)
{
var config = new LoaderConfiguration();
var loader = new Loader(config);
try
{
if (args.Length == 0)
{
loader.Start(ExecutableFactory.Detect());
return;
}
/**
* The parameters are expected to be the HCE ones, e.g. `-window`, `-safemode`, etc.
* This effectively makes the SPV3 Loader a wrapper around the HCE executable.
*/
var parameters = new ParametersParser().Parse(string.Join(" ", args));
/**
* This allows explicit declaration of the path which the HCE executable resides in.
* If the path isn't declared, then we implicitly attempt to detect the executable.
*/
var executable = args[0].Contains(Executable.Name)
? new Executable(args[0])
: ExecutableFactory.Detect();
loader.Start(executable, parameters);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public WorkplanExecutable GetMainWorkplan()
{
if (rootWorkplan == null)
{
rootWorkplan = (WorkplanExecutable)ExecutableFactory.fromId(finder, finder.GetMainWorkplan());
}
return(rootWorkplan);
}
public void Exists_WhenNotExists_ReturnsFalse()
{
var factory = new ExecutableFactory(
new[] { new BasicParameterValueFactory() },
new[] { typeof(CreateFoo) });
var result = factory.Exists("CreateBar");
result.Should().BeFalse();
}
public void Create_WhenExecutableTypeNameIsNotInRegisteredAssemblies_Throws()
{
var factory = new ExecutableFactory(
new[] { new BasicParameterValueFactory() },
new[] { typeof(CreateFoo) });
var exception = Assert.Throws <TypeNotFoundException>(() => factory.Create(new ExecutableInfo(
"CreateFooBar", Enumerable.Empty <ExecutableParameterInfo>())));
exception.TypeShortName.Should().Be("CreateFooBar");
}
public void Create_WhenNoParameterFactoryQualifiesForCommandConstructorParameterType_Throws()
{
var factory = new ExecutableFactory(
Enumerable.Empty <IParameterValueFactory>(),
new[] { typeof(CreateFoo) });
var exception = Assert.Throws <NoQualifyingParameterValueFactoryException>(() => factory.Create(new ExecutableInfo("CreateFoo",
new [] { new ExecutableParameterInfo("id", "1") })));
exception.TypeShortName.Should().Be("Int32");
}
public void Create_WhenMissingParameterThatHasDefaultValue_CreatesCommandWithDefaultValue()
{
var factory = new ExecutableFactory(
new[] { new BasicParameterValueFactory() },
new[] { typeof(CreateFoo) });
var result = factory.Create(typeof(CreateFoo));
result.Should().NotBeNull();
result.Should().BeOfType <CreateFoo>();
result.As <CreateFoo>().Bar.Should().Be("bar");
}
private static void HandleDetectCommand()
{
try
{
Console.WriteLine(ExecutableFactory.Get(ExecutableFactory.Type.Detect).Path);
Environment.Exit(0);
}
catch (FileNotFoundException e)
{
ErrorExit(e.Message, 4);
Console.Error.WriteLine(e.Message);
}
}
private void Detect()
{
Info("Invoked the Loader.Detect command.");
Info("Attempting to detect executable path.");
try
{
Console.WriteLine(ExecutableFactory.Get(ExecutableFactory.Type.Detect, Output).Path);
}
catch (FileNotFoundException e)
{
Fail(e.Message, ExitType.Exception);
}
}
public void Create_WhenExecutableTypeConstructorDoesNotMatchPassedParameters_Throws()
{
var factory = new ExecutableFactory(
new[] { new BasicParameterValueFactory() },
new[] { typeof(CreateFoo) });
var parameters = new List <ExecutableParameterInfo>
{
new ExecutableParameterInfo("id", "1"),
new ExecutableParameterInfo("dateCreated", DateTime.Now.ToString(CultureInfo.InvariantCulture)),
new ExecutableParameterInfo("foo", "bar")
};
var exception = Assert.Throws <ConstructorNotFoundException>(() =>
factory.Create(new ExecutableInfo("CreateFoo", parameters)));
exception.Type.Should().Be(typeof(CreateFoo));
exception.Parameters.Should().BeEquivalentTo(parameters.Select(p => p.Name).ToList());
}
public void Create_WhenCommandAssemblyIsRegistered_CreatesCommand()
{
var factory = new ExecutableFactory(
new IParameterValueFactory[] { new BasicParameterValueFactory(), new DateTimeParameterValueFactory(CultureInfo.InvariantCulture) },
new [] { typeof(CreateFoo) });
var created = new DateTime(2017, 1, 1, 14, 0, 0);
var result = factory.Create(
typeof(CreateFoo),
new ExecutableParameterInfo("bar", "something"),
new ExecutableParameterInfo("id", "12345"),
new ExecutableParameterInfo("datecreated", created.ToString(CultureInfo.InvariantCulture)));
result.Should().NotBeNull();
result.Should().BeOfType <CreateFoo>();
result.As <CreateFoo>().Id.Should().Be(12345);
result.As <CreateFoo>().Bar.Should().Be("something");
result.As <CreateFoo>().DateCreated.Should().Be(created);
}
public static void Main(string[] args)
{
var config = new LoaderConfiguration();
var loader = new Loader(config, new StatusOutput());
try
{
Task.Run(() =>
{
/**
* Implicitly detect the HCE executable and start it without any parameters.
*/
if (args.Length == 0)
{
loader.Start(ExecutableFactory.Detect());
return;
}
/**
* The parameters are expected to be the HCE ones, e.g. `-window`, `-safemode`, etc.
* This effectively makes the SPV3 Loader a wrapper around the HCE executable.
*/
var parameters = new ParametersParser().Parse(string.Join(" ", args));
/**
* This allows explicit declaration of the path which the HCE executable resides in.
* If the path isn't declared, then we implicitly attempt to detect the executable.
*/
var executable = args[0].Contains(Executable.Name)
? new Executable(args[0])
: ExecutableFactory.Detect();
loader.Start(executable, parameters);
}).GetAwaiter().GetResult();
}
catch (SecurityException e)
{
Console.WriteLine(e.ToString());
Environment.Exit(1);
}
}
private static void HandleLoadCommand(string[] args)
{
var executable = new Atarashii.Executable(Atarashii.Executable.Name);
if (args.Length > 1)
{
executable = new Atarashii.Executable(args[1]);
}
else
{
try
{
executable = ExecutableFactory.Get(ExecutableFactory.Type.Detect);
}
catch (FileNotFoundException e)
{
ErrorExit(e.Message, 1);
}
}
try
{
executable.Load();
}
catch (LoaderException e)
{
ErrorExit(e.Message, 2);
}
catch (Exception e)
{
ErrorExit(e.Message, 3);
}
Console.WriteLine($"The specified executable '{executable.Path}' has been loaded.");
Environment.Exit(0);
}
/// <summary>
/// Attempts to detect the path of the HCE executable on the file system.
/// </summary>
/// <returns>
/// Path to the HCE executable, assuming its installation is legal.
/// </returns>
public static string Detect()
{
return(ExecutableFactory.Get(ExecutableFactory.Type.Detect).Path);
}
public ExecutableFactoryTest()
{
this.testee = new ExecutableFactory<IExtension>();
}
public void Setup()
{
_factory = new ExecutableFactory();
}
public Executable GetSpecificWorkplan(long wpid)
{
return(ExecutableFactory.fromId(finder, wpid));
}
