/// <summary> Main entry point for Console CM Test Utility. </summary>
/// <param name="args"> Command line arguments. </param>
public static void Main(string[] args)
{
try
{
Console.WriteLine();
Consolery.Run(
"Provides commands for Test Automation.",
Assembly.GetExecutingAssembly(),
args);
}
catch (CommandLineArgumentException ex)
{
Console.WriteLine(
string.Format("Argument '{0}' has invalid value specified: {1}", ex.ParamName, ex.Message));
}
catch (Exception ex)
{
Console.WriteLine("The command failed with the following exception: {0}", ex);
object originalStackTrace = ex.Data["OriginalStackTrace"];
if (originalStackTrace != null)
{
Console.WriteLine();
Console.WriteLine("Original stack trace:");
Console.WriteLine(originalStackTrace);
}
}
}
public void ShouldWorkWithNet40OptionalArguments()
{
Consolery.Run(typeof(Net40OptionalArgumentsProgram), new[] { "1" });
Assert.That(_verifier.required, Is.EqualTo(1));
Assert.That(_verifier.optional, Is.EqualTo(true));
}
static void Main(string[] args)
{
Console.Clear();
Console.WriteLine("{0} 0.4 (www.megapanzer.com)", Application.ProductName);
Console.WriteLine("------------------------------------------------\n\n");
Consolery.Run(typeof(Program), args);
}
static void Main(string[] args)
{
while (true)
{
var cmds = System.Console.ReadLine();
Consolery.Run(typeof(Program), cmds.Split(' '));
}
}
public static void Main(string[] args)
{
Console.WriteLine("Gibbed's Sassy Tool");
Console.WriteLine("For use with signed assemblies in The Sims 3.");
Console.WriteLine("");
Consolery.Run(typeof(Program), args);
}
public void should_work_with_instance_actions()
{
var instance = new InstanceActionsProgram();
Consolery.Run(instance, new[] { "test" });
Assert.That(_verifier.arg, Is.EqualTo("test"));
}
public void UnknownBooleanParameter()
{
Consolery.Run(typeof(OneParameterProgram),
new[] { "required", "/unknown" }, _messenger);
Assert.That(ConsoleOutput(),
Is.EqualTo("Unknown parameter name /unknown"));
}
public void VeryBigDefaultValueForOptionalIntegerParameter()
{
Consolery.Run(typeof(VeryBigDefaultValueForOptionalIntegerParameterProgram),
new string[] { }, _messenger);
Assert.That(ConsoleOutput(),
Is.EqualTo(
"Default value for an optional parameter \"optionalParameter\" in method \"RunProgram\" can not be assigned to the parameter"));
}
public void DuplicatedParameterAttributes()
{
Consolery.Run(typeof(DuplicatedParameterAttributesProgram),
new[] { "parameter" }, _messenger);
Assert.That(ConsoleOutput(),
Is.EqualTo(
"More than one attribute is applied to the parameter \"parameter\" in the method \"RunProgram\""));
}
public void DuplicatedParameterNames()
{
Consolery.Run(typeof(DuplicatedParameterNamesProgram),
new string[] { }, _messenger);
Assert.That(ConsoleOutput(),
Is.EqualTo(
"Found duplicated parameter name \"a\" in method \"RunProgram\". Please check alt names for optional parameters"));
}
public void WrongParameterOrder()
{
Consolery.Run(typeof(WrongParameterOrderProgram),
new[] { "string" }, _messenger);
Assert.That(ConsoleOutput(),
Is.EqualTo(
"It is not allowed to write a parameter with a Required attribute after a parameter with an Optional one. See method \"RunProgram\" parameter \"requiredParameter\""));
}
private static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
Log.WriteLine($"Altairis AutoACME Manager version {Assembly.GetExecutingAssembly().GetName().Version}");
Log.WriteLine("Copyright © Michal A. Valášek - Altairis and contributors, 2017-2019");
Log.WriteLine("www.autoacme.net | www.rider.cz | www.altairis.cz");
Log.WriteLine();
Consolery.Run();
}
static void Main(string[] args)
{
Console.WriteLine("Gherkin parser import tool:");
Console.WriteLine(" + adds signing for the assembly");
Console.WriteLine(" + generates Language.xml from the parser");
Console.WriteLine();
Consolery.Run(typeof(Program), args);
return;
}
private static void Main(string[] args)
{
var version = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
Console.WriteLine($"TMDC: Tutorial Markdown Compiler version {version:4}");
Console.WriteLine("Copyright (c) Michal Altair Valasek - Altairis, 2019-2020");
Console.WriteLine("www.altairis.cz | www.rider.cz | github.com/ridercz/TMD");
Console.WriteLine();
Consolery.Run();
}
static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
Trace.IndentSize = 2;
Trace.WriteLine($"Altairis AutoACME Manager version {System.Reflection.Assembly.GetExecutingAssembly().GetName().Version}");
Trace.WriteLine("Copyright (c) Michal A. Valasek - Altairis, 2017");
Trace.WriteLine("www.autoacme.net | www.rider.cz | www.altairis.cz");
Trace.WriteLine(string.Empty);
Consolery.Run();
}
static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
Log.WriteLine($"Altairis AutoACME IIS Synchronization Tool version {System.Reflection.Assembly.GetExecutingAssembly().GetName().Version}");
Log.WriteLine("Copyright (c) Michal A. Valasek - Altairis, 2017");
Log.WriteLine("www.autoacme.net | www.rider.cz | www.altairis.cz");
Log.WriteLine();
Consolery.Run();
}
public void RunConsoleProgramWithoutOptionalParameters()
{
Consolery.Run(typeof(ManyParametersProgram),
new[] { "string", "1", "true" });
Assert.That(_verifier.sParameter, Is.EqualTo("string"));
Assert.That(_verifier.iParameter, Is.EqualTo(1));
Assert.That(_verifier.bParameter, Is.EqualTo(true));
Assert.That(_verifier.osParameter, Is.EqualTo("0"));
Assert.That(_verifier.oiParameter, Is.EqualTo(0));
Assert.That(_verifier.obParameter, Is.EqualTo(false));
}
static void Main(string[] args)
{
Console.WriteLine("Altairis DB>doc version {0:4}", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
Console.WriteLine("Copyright (c) Altairis, 2011 | www.altairis.cz | SqlDbDoc.codeplex.com");
Console.WriteLine();
// Add console trace listener
Trace.Listeners.Add(new ConsoleTraceListener());
// Run actions
Consolery.Run();
}
public void NegativeBooleanParameter()
{
Consolery.Run(typeof(ManyParametersProgram),
new[] { "string", "1", "true", "/-ob" });
Assert.That(_verifier.sParameter, Is.EqualTo("string"));
Assert.That(_verifier.iParameter, Is.EqualTo(1));
Assert.That(_verifier.bParameter, Is.EqualTo(true));
Assert.That(_verifier.osParameter, Is.EqualTo("0"));
Assert.That(_verifier.oiParameter, Is.EqualTo(0));
Assert.That(_verifier.obParameter, Is.EqualTo(false));
}
public void ManyParameters()
{
Consolery.Run(typeof(ManyParametersProgram),
new[] { "string", "1", "true", "/os:string", "/oi:1", "/ob" });
Assert.That(_verifier.sParameter, Is.EqualTo("string"));
Assert.That(_verifier.iParameter, Is.EqualTo(1));
Assert.That(_verifier.bParameter, Is.EqualTo(true));
Assert.That(_verifier.osParameter, Is.EqualTo("string"));
Assert.That(_verifier.oiParameter, Is.EqualTo(1));
Assert.That(_verifier.obParameter, Is.EqualTo(true));
}
public void ShouldShowDefaultValueForOptionalParameter()
{
Consolery.Run(typeof(OneActionProgramWithOptionalParameters), new[] { "help", "Test" }, _messenger);
var console = ConsoleOutput();
Assert.That(
console.Contains(
@"usage: oneactionprogramwithoptionalparameters [/parameter1:value] [/param2:number]
[/parameter1:value] param1 desc
default value: 'value1'
[/param2:number] desc2
default value: 42"));
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo.Console()
.WriteTo.File("log-.txt", rollingInterval: RollingInterval.Day)
.CreateLogger();
_sorter = new MusicSorter();
Log.Information("Music Sorter v0.1a");
Log.Information("--------------------------------------");
Consolery.Run(typeof(Program), args);
}
public void NotAllRequiredParametersAreSet()
{
Consolery.Run(typeof(ManyParametersProgram),
new[] { "test" }, _messenger);
var console = ConsoleOutput();
Assert.That(console.Contains(
@"usage: manyparametersprogram sParameter iParameter bParameter [/os:value] [/oi:number] [/ob]
[/os:value]
default value: '0'
[/oi:number]
default value: 0
[/ob]
default value: False
Error: Not all required parameters are set"));
}
public void WhenTargetMethodThrowsAnException()
{
Exception exception = null;
try
{
Consolery.Run(typeof(ExceptionalProgram), new[] { "/-parameter" });
}
catch (Exception e)
{
exception = e;
}
Assert.That(exception, Is.Not.Null);
Assert.That(exception.GetType(), Is.EqualTo(typeof(SpecificException)));
}
static void Main(string[] args)
{
Console.WriteLine("Altairis DB>doc version {0:4}", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version);
Console.WriteLine("Copyright (c) Altairis, 2011 | www.altairis.cz | SqlDbDoc.codeplex.com");
Console.WriteLine("Modifications by HAVIT, 2015 | www.havit.eu | https://github.com/hakenr/SqlDbDoc");
Console.WriteLine("Modifications by MissAmberInSeattle, 2018");
Console.WriteLine();
// Add console trace listener
Trace.Listeners.Add(new ConsoleTraceListener());
try
{
// Run actions
Consolery.Run();
Console.WriteLine("Complete. Press enter to finish.");
Console.ReadLine();
}
catch (Exception ex)
{
Console.Error.WriteLine(ex);
}
}
static void Main(string[] args)
{
Consolery.Run();
}
public static void Main(string[] args)
{
Consolery.Run(typeof(Program), args);
}
private static void Main(string[] args)
{
Consolery.Run(typeof(Program), args);
return;
}
public void ShouldCorrectlyConvertToDateTimeFromOptionalAttributeDefaultValue()
{
Consolery.Run(typeof(OptionalDateTimeProgram), new[] { "01-01-2009", "/dtDate:31-12-2008" });
Assert.That(_verifier.date, Is.EqualTo(new DateTime(2008, 12, 31)));
}
public void WhenMetadataValidationFailsShouldSetErrorCode()
{
Consolery.Run(typeof(ExceptionalProgram), new[] { "wrong" });
Assert.That(Environment.ExitCode, Is.EqualTo(1));
}
