public void WhenNoOptionsAreSpecified_PackageContainsOnlyTwoSettings()
{
var options = ConsoleMocks.Options("test.dll");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.Keys, Is.EquivalentTo(new string[] { "WorkDirectory", "DisposeRunners" }));
}
private void Run()
{
int version = Options.TargetVersion ?? -1;
string mode = (Options.Mode ?? "manual").ToLower();
if (mode == "script")
{
RunScript(version);
return;
}
if (mode == "auto")
{
var runner = new Runner(SharpFactory.Default.CreateDataClient(), GetAssemblyWithMigrations());
runner.MigrationGroup = Options.MigrationGroup;
runner.Run(version);
return;
}
if (mode == "seed")
{
if (String.IsNullOrEmpty(Options.SeedName))
{
Exit("Please, set the seed name");
return;
}
var seedRunner = new SeedRunner(SharpFactory.Default.CreateDataClient(), GetAssemblyWithMigrations());
seedRunner.Run(Options.SeedName, Options.SeedArgs, Options.MigrationGroup);
return;
}
var crunner = new ConsoleRunner(SharpFactory.Default.ConnectionString, SharpFactory.Default.DataProviderName);
crunner.AssemblyWithMigrations = GetAssemblyWithMigrations();
crunner.MigrationGroup = Options.MigrationGroup;
crunner.Start();
}
public void WhenX86IsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--x86");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.IsTrue(package.GetSetting("RunAsX86", false));
}
public void WhenDisposeIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--dispose-runners");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.IsTrue(package.GetSetting("DisposeRunners", false));
}
public void WhenNoOptionsAreSpecified_PackageContainsNoSettings()
{
var options = new ConsoleOptions("test.dll");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.AreEqual(0, package.Settings.Count);
}
static void Main(string[] args)
{
// Create the console runner
ConsoleRunner runner = new ConsoleRunner();
// Setting up dependency injection
runner.BuildServiceProvider += (services) =>
{
services.AddSingleton("This is my DI string");
services.AddSingleton(new DISample.ExampleType()
{
Name = "Thomas", Age = 92
});
};
runner.BuildNamedArguments += (arguments) =>
{
arguments.Add("apiToken", "abc123xyz");
arguments.Add("callLimit", 10_000);
};
// Find all samples in this assembly.
runner.FindSamples(typeof(Program).Assembly);
// Run the console runner.
runner.Run();
}
public void Pausing()
{
using (_mock.Ordered())
{
_hostedProcess.Expect(op => op.Start());
_wrapper.Expect(w => w.WriteLine("Press (P) to Pause or (ESC) to Exit..."));
_wrapper.Expect(w => w.ReadKey()).Return(ConsoleKey.P);
_wrapper.Expect(w => w.WriteLine("Pausing, Press any key to Resume..."));
_hostedProcess.Expect(op => op.Pause());
_wrapper.Expect(w => w.ReadKey()).Return(ConsoleKey.Select);
_wrapper.Expect(w => w.WriteLine("Resuming, press (P) to Pause or (ESC) to Exit..."));
_hostedProcess.Expect(op => op.Resume());
_wrapper.Expect(w => w.ReadKey()).Return(ConsoleKey.P);
_wrapper.Expect(w => w.WriteLine("Pausing, Press any key to Resume..."));
_hostedProcess.Expect(op => op.Pause());
_wrapper.Expect(w => w.ReadKey()).Return(ConsoleKey.Select);
_wrapper.Expect(w => w.WriteLine("Resuming, press (P) to Pause or (ESC) to Exit..."));
_hostedProcess.Expect(op => op.Resume());
_wrapper.Expect(w => w.ReadKey()).Return(ConsoleKey.Escape);
_hostedProcess.Expect(op => op.Stop());
}
_mock.ReplayAll();
ConsoleRunner consoleRunner = new ConsoleRunner(_hostedProcess, _wrapper);
consoleRunner.Run();
}
public void Run_When_Action_Arg_And_Exception_Then_Exception_Is_Rethrown_In_Main_Thread()
{
ConsoleRunner.Run(() =>
{
throw new InvalidOperationException();
});
}
private static void Main(string[] args)
{
//AppDomain.CurrentDomain.AssemblyLoad+= CurrentDomainOnAssemblyLoad;
//AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainOnAssemblyResolve;
if (!Directory.Exists(InternalsFolder))
{
Directory.CreateDirectory(InternalsFolder);
}
FileResolvers = ResolverManager.LoadResolvers();
string[] runnerLibs = Directory.GetFiles(InternalsFolder, RUNNER_FILE_SEARCH_PATTERN, SearchOption.AllDirectories);
if (runnerLibs.Length == 0)
{
System.Console.WriteLine("Can not Locate a Valid Runner Library.");
System.Console.WriteLine("Path is Empty: " + InternalsFolder);
System.Console.ReadLine();
return;
}
MethodInfo mi = null;
for (int i = 0; i < runnerLibs.Length; i++)
{
try
{
Assembly asm = Assembly.LoadFrom(FileResolvers[Path.GetExtension(runnerLibs[i])].ResolveLibrary(runnerLibs[i]));
System.Console.WriteLine("Loading Runner: " + asm.GetName().Version);
Type t = asm.GetExportedTypes().First(x => x.Name == "ConsoleRunner");
mi = t.GetMethod("Run");
break;
}
catch (Exception e)
{
System.Console.WriteLine("Error Loading Runner: " + runnerLibs[i]);
}
}
try
{
Dictionary <string, object> fr = FileResolvers.ToDictionary(x => x.Key, x => (object)x.Value);
//mi.Invoke(null, new object[] { args, fr });
ConsoleRunner.Run(args, fr);
}
catch (Exception e)
{
Exception ex = e.InnerException ?? e;
System.Console.WriteLine("Runner Command Errored.");
System.Console.WriteLine("Exception " + ex.GetType().Name + ": " + ex.Message);
System.Console.WriteLine(ex.StackTrace);
System.Console.ReadLine();
}
#if DEBUG
//System.Console.ReadLine();
#endif
}
private static void testDownloadPages()
{
Console.WriteLine("Main: Current thread {0}", Thread.CurrentThread.ManagedThreadId);
var successfulTasks = ConsoleRunner.Run(DownloadWebPages);
//int successfulTasks = DownloadWebPages().Result;
Console.WriteLine("Number of successful downloads: {0} Total urls: {1}", successfulTasks, _urls.Count());
}
static void Main(string[] args)
{
var connectionString = ConfigurationManager.ConnectionStrings["System.Data.SqlClient"].ConnectionString;
var factory = new SharpFactory(SqlClientFactory.Instance, connectionString);
var consoleRunner = new ConsoleRunner(factory.CreateDataClient(), Assembly.GetExecutingAssembly(), "Chinnok");
consoleRunner.Start();
}
public void cannot_place_turtle_if_its_already_placed_on_table()
{
var consoleRunner = new ConsoleRunner();
consoleRunner.Execute("PLace 1,2,EAST", null);
Assert.Throws <InvalidOperationException>(() => consoleRunner.Execute("PLace 1,2,EAST", null));
}
static void Main(string[] args)
{
IConnectFourGame game = new ConnectFourGameWithLists(7, 6);
IConnectFourRenderer renderer = new HorizontalRenderer(game);
ConsoleRunner runner = new ConsoleRunner(game, renderer);
runner.Run();
}
private static void Main(string[] args)
{
XmlConfigurator.Configure();
var connString = ConfigurationManager.ConnectionStrings["Oracle.ManagedDataAccess.Client"].ConnectionString;
var runner = new ConsoleRunner(connString, DataProviderNames.OracleManaged);
runner.Start();
}
public void Run_When_Func_Arg_Then_Returns_Expected_Value()
{
Func <int> intFunc = () => DEFAULT_INT_RESULT;
var currentResult = ConsoleRunner.Run(intFunc);
Assert.AreEqual(DEFAULT_INT_RESULT, currentResult);
}
public void WhenDebugging_NumberOfTestWorkersMayBeOverridden()
{
var options = ConsoleMocks.Options("test.dll", "--debug", "--workers=3");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings["DebugTests"], Is.EqualTo(true));
Assert.That(package.Settings["NumberOfTestWorkers"], Is.EqualTo(3));
}
public void WhenOptionIsSpecified_PackageIncludesSetting(string option, string key, object val)
{
var options = new ConsoleOptions("test.dll", option);
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey(key), "Setting not included for {0}", option);
Assert.AreEqual(val, package.Settings[key], "NumberOfTestWorkers not set correctly for {0}", option);
}
public static void Main(string[] args)
{
Console.WriteLine("CSpec Test Runner: \n");
ConsoleRunner runner = new ConsoleRunner();
runner.Run(args);
}
public void WhenNoOptionsAreSpecified_PackageContainsWorkDirectorySettingOnly()
{
var options = new ConsoleOptions("test.dll");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.AreEqual(1, package.Settings.Count);
Assert.That(package.Settings.Keys, Contains.Item("WorkDirectory"));
}
public void SingleAssembly()
{
var options = new ConsoleOptions("test.dll");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.AreEqual(1, package.SubPackages.Count);
Assert.AreEqual(Path.GetFullPath("test.dll"), package.SubPackages[0].FullName);
}
public void WhenConfigIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--config=Release");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("ActiveConfig"));
Assert.AreEqual("Release", package.Settings["ActiveConfig"]);
}
public void WhenDomainUsageIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--domain=Multiple");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("DomainUsage"));
Assert.AreEqual("Multiple", package.Settings["DomainUsage"]);
}
public void WhenFrameworkIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--framework=net-4.0");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("RuntimeFramework"));
Assert.AreEqual("net-4.0", package.Settings["RuntimeFramework"]);
}
public void WhenTimeoutIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--timeout=50");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("DefaultTimeout"));
Assert.AreEqual(50, package.Settings["DefaultTimeout"]);
}
public void WhenProcessModelIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--process=Separate");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("ProcessModel"));
Assert.AreEqual("Separate", package.Settings["ProcessModel"]);
}
public void WhenWorkersIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--workers=3");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("NumberOfTestWorkers"));
Assert.AreEqual(3, package.Settings["NumberOfTestWorkers"]);
}
public void WhenSeedIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--seed=1234");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("RandomSeed"));
Assert.AreEqual(1234, package.Settings["RandomSeed"]);
}
public void WhenTraceIsSpecified_PackageIncludesIt()
{
var options = new ConsoleOptions("test.dll", "--trace=Error");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings.ContainsKey("InternalTraceLevel"));
Assert.AreEqual("Error", package.Settings["InternalTraceLevel"]);
}
public void WhenDebugging_NumberOfTestWorkersDefaultsToZero()
{
var options = ConsoleMocks.Options("test.dll", "--debug");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.Settings["DebugTests"], Is.EqualTo(true));
Assert.That(package.Settings["NumberOfTestWorkers"], Is.EqualTo(0));
}
public void SingleAssembly()
{
var options = ConsoleMocks.Options("test.dll");
var package = ConsoleRunner.MakeTestPackage(options);
Assert.That(package.SubPackages.Count, Is.EqualTo(1));
Assert.That(package.SubPackages[0].FullName, Is.EqualTo(Path.GetFullPath("test.dll")));
}
static void Main(string[] args)
{
IClipRepository repo = new LocalClipDirectory(@"C:\Users\Kyle\Desktop\Airplane");
ClipPlayer player = new ClipPlayer(repo);
AbstractCommand random = new PlayRandomCommand(player);
AbstractCommand list = new ListCommand(player);
AbstractCommand play = new PlayCommand(player);
ConsoleRunner app = new ConsoleRunner(player);
app.AddCommand(list);
app.AddCommand(play);
app.AddCommand(random);
app.Run();
}
/// <summary>
/// Run the report (validates settings against the generator given)
/// </summary>
/// <param name="report">The report object to perform the analysis</param>
/// <param name="generator">Generator type given</param>
/// <param name="outputXml">Output XML file name/path</param>
/// <param name="quiet">Indicates if any console output should be available</param>
/// <param name="violations">True to report each violation encountered</param>
private static void RunReport(ReportBuilder report, string generator, string outputXml, bool quiet, bool violations)
{
var generatorType = Generator.Default;
if (generator != null)
{
generatorType = (Generator)Enum.Parse(typeof(Generator), generator, true);
}
FileRunner runner;
switch (generatorType)
{
case Generator.Xml:
report = report.WithOutputEventHandler(
(x, y) =>
{
violationCount++;
if (!quiet)
{
OutputGenerated(x, y);
}
});
runner = new XmlRunner();
break;
default:
EventHandler<StyleCop.ViolationEventArgs> callback = HadViolation;
if (!quiet)
{
if (violations)
{
callback = ViolationEncountered;
}
else
{
report = report.WithOutputEventHandler(OutputGenerated);
}
}
report = report.WithViolationEventHandler(callback);
runner = new ConsoleRunner();
break;
}
runner.OutputFile = string.IsNullOrEmpty(outputXml) ? null : string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0}.xml", System.IO.Path.GetFileNameWithoutExtension(outputXml));
report.Create(runner);
}
/// <summary>
/// Executes the test.
/// </summary>
/// <returns>
/// The output from StyleCop event output
/// </returns>
/// <param name='builder'>
/// Input report for testing
/// </param>
/// <param name='outputFile'>
/// Output file.
/// </param>
private static IList<string> ExecuteTest(ReportBuilder builder, string outputFile)
{
var outputList = new List<string>();
builder.WithOutputEventHandler((x, y) => { outputList.Add(((StyleCop.OutputEventArgs)y).Output); });
var runner = new ConsoleRunner();
runner.OutputFile = outputFile;
builder.Create(runner);
return outputList.OrderBy(value => value).ToList();
}
