internal static void IntroduceBunnies(List<Bunny> bunnies, ConsoleWriter consoleWriter)
{
foreach (var bunny in bunnies)
{
bunny.Introduce(consoleWriter);
}
}
public static void WriteLine(object value, ConsoleType type, ConsoleWriter writer)
{
switch (type)
{
case ConsoleType.Info:
WriteLine(" [INFO] " + value, ConsoleColor.Yellow, writer); break;
case ConsoleType.Error:
WriteLine(" [ERROR] " + value, ConsoleColor.Red, writer); break;
case ConsoleType.Connect:
if (!GlobalConfig.Debug) return;
WriteLine(" [CONNECTION] " + value, ConsoleColor.Cyan, writer); break;
case ConsoleType.Disconnect:
if (!GlobalConfig.Debug) return;
WriteLine(" [DISCONNNECTION] " + value, ConsoleColor.DarkCyan, writer); break;
case ConsoleType.Receive:
if (!GlobalConfig.Debug) return;
WriteLine(" [RECV] " + value, ConsoleColor.Green, writer); break;
case ConsoleType.Send:
if (!GlobalConfig.Debug) return;
WriteLine(" [SEND] " + value, ConsoleColor.DarkGreen, writer); break;
default:
WriteLine(value, ConsoleColor.White, writer); break;
}
}
public static int Main(string[] args)
{
var consoleWriter = new ConsoleWriter();
try
{
var settings = new SaucySettings();
ILogger logger = new VerboseLogger();
var restoreVerb = new SaucyCommandLine(
new PackagesRestorer(
new JsonLoader(),
new ProviderMatcher(new GitHubProvider(new FolderSync(logger))),
consoleWriter,
settings),
settings);
var runner = new Runner();
runner.Register(restoreVerb);
var exitCode = runner.Run(args);
return exitCode;
}
catch (Exception e)
{
consoleWriter.Write(e.Message);
consoleWriter.Write(e.StackTrace);
return -1;
}
}
public void TestBatchRequest()
{
using (var socket = CreateClient())
{
var socketStream = new NetworkStream(socket);
using (var reader = new StreamReader(socketStream, Encoding.ASCII, true))
using (var writer = new ConsoleWriter(socketStream, Encoding.ASCII, 1024 * 8))
{
reader.ReadLine();
int size = 100;
var lines = new string[size];
for (var i = 0; i < size; i++)
{
var line = Guid.NewGuid().ToString();
lines[i] = line;
var request = CreateRequest(line);
writer.Write(request);
}
writer.Flush();
for (var i = 0; i < size; i++)
{
var receivedLine = reader.ReadLine();
Assert.AreEqual(lines[i], receivedLine);
}
}
}
}
public DebugWindow()
{
InitializeComponent();
_cw = new ConsoleWriter(this);
Console.SetOut(_cw);
}
public LogWPF()
{
InitializeComponent();
var console = new ConsoleWriter();
console.OnText += console_OnText;
Console.SetOut(console);
}
public static void Clear()
{
if (cw == null)
{
cw = new ConsoleWriter ();//will do a clear
}
cw.Clear ();
}
static void Main()
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
var engine = new Engine(reader, writer);
engine.Run();
}
public static void Main()
{
IWritter consoleWriter = new ConsoleWriter();
IReader consoleReader = new ConsoleReader();
IPowerPlant powerPlant = new PowerPlant(consoleWriter, consoleReader);
powerPlant.Run();
}
public static void Main(string[] args)
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
IEventHolder events = new EventHolder();
IEventLogger logger = new EventLogger();
IEventEngine eventEngine = new EventEngine(reader, writer, events, logger);
eventEngine.Run();
}
static public void WriteLine(string format, params Object[] arg)
{
if (cw == null)
cw = new ConsoleWriter();
lock (cw)
{
cw.WriteLine(string.Format(format, arg));
}
}
static void Main(string[] args)
{
var writer = new ConsoleWriter();
writer.X = 2;
var test = writer.X;
writer.X2 = 6;
var test2 = writer.X2;
}
public static void Main()
{
IReader consoleReader = new ConsoleReader();
IWriter consoleWriter = new ConsoleWriter();
IPerformanceDatabase database = new PerformanceDatabase();
IEngine engine = new Engine(consoleReader, consoleWriter, database);
engine.Run();
}
static void Main(string[] args)
{
var blobFactory = new BlobFactory();
var reader = new ConsoleReader();
var writer = new ConsoleWriter();
var data = new BlobData();
var engine = new Engine(blobFactory, data, reader, writer);
engine.Run();
}
public static void Main()
{
var blopFactory = new BlobFactory();
var reader = new ConsoleReader();
var writer = new ConsoleWriter();
var data = new Data();
var engine = new Engine(blopFactory, data, reader, writer);
engine.Run();
}
public static void Main()
{
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter();
IGameData data = new GameData();
IBlobFactory blobFactory = new BlobFactory();
IRunnable engine = new GameEngine(reader, writer, data, blobFactory);
engine.Run();
}
public static void Main(string[] args)
{
IBlobFactory blobFactory = new BlobFactory();
IAttackFactory attackFactory = new AttackFactory();
IBehaviorFactory behaviorFactory = new BehaviorFactory();
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter();
IEngine engine = new Engine(blobFactory, attackFactory, behaviorFactory, reader, writer);
engine.Run();
}
public static void Main()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
IHotelBookingSystemData database = new HotelBookingSystemData();
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter();
var engine = new Engine(database, reader, writer);
engine.StartOperation();
}
static void Main()
{
var buildingFactory = new BuildingFactory();
var unitFactory = new UnitFactory();
var resourceFactory = new ResourceFactory();
var reader = new ConsoleReader();
var writer = new ConsoleWriter();
var data = new EmpiresData();
var engine = new Engine(buildingFactory,resourceFactory,unitFactory,data,reader,writer);
engine.Run();
}
public static void Main(string[] args)
{
IBuildingFactory buildingFactory = new BuildingFactory();
IUnitFactory unitFactory = new UnitFactory();
IResourceFactory resourceFactory = new ResourceFactory();
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter();
IEmpiresData database = new Database();
IEngine engine = new Engine(unitFactory, resourceFactory, buildingFactory, reader, writer, database);
engine.Run();
}
public static void Main()
{
IGameDatabase gameDatabase = new GameDatabase();
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter();
var engine = new GameEngine(
gameDatabase,
reader,
writer);
engine.Start();
}
/// <summary>
/// Initializes console properties and sets up environment.
/// </summary>
internal virtual void Start()
{
Initialize();
In = string.Empty;
Out = new ConsoleWriter();
consoleBuffer = Header;
if (consoleBuffer != "")
Out.WriteLine(consoleBuffer);
scrollPosition = Vector2.zero;
ID = IDCount++;
this.consoleID = "window" + ID;
history = new List<string>();
}
public static void Main()
{
ICity city = new City();
IRenderer renderer = new ConsoleRenderer();
IWriter writer = new ConsoleWriter();
ICityBuilder cityBuilder = new CityBuilder(
city,
renderer,
writer);
cityBuilder.Run();
}
public static void Main()
{
IBangaloreUniversityData data = new BangaloreUniversityData();
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter
{
AutoFlush = true
};
IEngine engine = new BangaloreUniversityEngine(reader, writer, data);
engine.Run();
}
/// <summary>
/// Initializes a new instance of the <see cref="BartForm"/> class.
/// </summary>
public BartForm( )
{
InitializeComponent ( );
cwOut = new ConsoleWriter ( ref this.console );
cwError = new ConsoleWriter ( ref this.console );
this.console.ReadOnly = true;
BartExecutor.Instance.ConsoleOutput = cwOut;
BartExecutor.Instance.ConsoleError = cwError;
BartExecutor.Instance.Complete += delegate ( object sender, EventArgs e ) {
backups.DataSource = BartExecutor.Instance.List ( );
};
backups.DataSource = BartExecutor.Instance.List ( );
}
public override void Run()
{
ConsoleWriter writer = new ConsoleWriter();
ResultPrinter resultPrinter = new ResultPrinter(new StreamWriter(results), writer);
SnapshotLoader loader = new SnapshotLoader(snapshotPath);
IList<HistorySnapshot> shapshots = loader.LoadSnapshots();
for (int snapshotLength = 100; snapshotLength >= 80; snapshotLength = snapshotLength - 10)
{
ExperimentWatcher experiment = new ExperimentWatcher(writer, snapshotLength, name, shapshots);
experiment.Start();
resultPrinter.Prefix = snapshotLength + ", ";
resultPrinter.PrintResult(experiment.Results);
}
resultPrinter.Close();
}
public static void Main()
{
ITicketCatalog catalog = new TicketCatalog();
ICommandManager commandManager = new CommandManager(catalog);
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter
{
AutoFlush = true
};
IEngine engine = new Engine(commandManager, reader, writer);
engine.Run();
}
public static void Main()
{
IDataBase db = new DataBase();
ICommandManager commandManager = new CommandManager();
IInputReader reader = new ConsoleReader();
IOutputWriter writer = new ConsoleWriter
{
AutoFlush = true
};
IEngine engine = new EmpiresEngine(db, commandManager, reader, writer);
engine.Run();
}
public void Can_deploy_to_directory()
{
// setup
var deployDirectory = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "DeploymentDirectory");
if (Directory.Exists(deployDirectory))
Directory.Delete(deployDirectory, true);
Directory.CreateDirectory(deployDirectory);
var writer = new ConsoleWriter();
var runContext = new RunContext();
var runner = new CommandLineRunner(writer,
new PackageProcessor(new ActionExecutor(writer, runContext), writer, new NuGetProcess(writer), runContext),
new NullActionExecutor(),
runContext);
SetDefinitions(new Packages
{
Items = new object[]
{
new Package
{
BasePath = _baseDirectory,
name = "package 1",
NuSpecPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestData/TestNuSpec.nuspec"),
OutputDirectory = _outputDirectory,
Version = "",
Deployments = new PackageDeployments
{
Deployment = new[]
{
new Deployment
{
name = "test deployment",
path = deployDirectory
}
}
}
}
}
});
// act
runner.Run(_rootDirectory, _nugetLocation, _defintionsFileLocation, "", new Dictionary<string, string>());
// assert
Assert.IsTrue(File.Exists(Path.Combine(deployDirectory, "package1.1.2.3.nupkg")));
}
public override void Run()
{
ConsoleWriter writer = new ConsoleWriter();
ResultPrinter resultPrinter = new ResultPrinter(new StreamWriter(results), writer);
SnapshotLoader loader = new SnapshotLoader(source);
IList<HistorySnapshot> snapshots = loader.LoadSnapshots();
ISet<string> names = ProcessNamesExtractor.GetProcessNames(snapshots);
foreach (string name in names)
{
//Console.WriteLine(name);
ExperimentWatcher experiment = new ExperimentWatcher(writer, 20, name, snapshots);
experiment.Start();
resultPrinter.Prefix = name + ": ";
resultPrinter.PrintResult(experiment.Results);
}
resultPrinter.Close();
}
public void Execute(params object[] list)
{
this.game.RestoreState();
ConsoleWriter.PrintMatrix(this.game.Board);
}
private void generateAnalysisReport(TestRunResults runDesc)
{
string lrrLocation = Path.Combine(runDesc.ReportLocation, LRR_FOLDER, LRR_FOLDER + ".lrr");
string lraLocation = Path.Combine(runDesc.ReportLocation, LRA_FOLDER, LRA_FOLDER + ".lra");
string htmlLocation = Path.Combine(runDesc.ReportLocation, HTML_FOLDER, HTML_FOLDER + ".html");
ProcessStartInfo analysisRunner = new ProcessStartInfo();
analysisRunner.FileName = ANALYSIS_LAUNCHER;
analysisRunner.Arguments = "\"" + lrrLocation + "\" \"" + lraLocation + "\" \"" + htmlLocation + "\" \"" + _analysisTemplate + "\"";
analysisRunner.UseShellExecute = false;
analysisRunner.RedirectStandardOutput = true;
ConsoleWriter.WriteLine("executing Analysis launcher with arguments : " + analysisRunner.Arguments);
ConsoleWriter.WriteLine("time for analysis: " + _perScenarioTimeOutMinutes.ToString(@"dd\:\:hh\:mm\:ss"));
analysisRunner.RedirectStandardOutput = true;
analysisRunner.RedirectStandardError = true;
Process runner = Process.Start(analysisRunner);
if (runner != null)
{
runner.OutputDataReceived += runner_OutputDataReceived;
runner.ErrorDataReceived += runner_ErrorDataReceived;
runner.BeginOutputReadLine();
runner.BeginErrorReadLine();
Stopwatch analysisStopWatch = Stopwatch.StartNew();
while (!runner.WaitForExit(_pollingInterval * 1000) && analysisStopWatch.Elapsed < _perScenarioTimeOutMinutes)
{
;
}
analysisStopWatch.Stop();
runner.CancelOutputRead();
runner.CancelErrorRead();
ConsoleWriter.WriteLine("time passed: " + analysisStopWatch.Elapsed.ToString(@"dd\:\:hh\:mm\:ss"));
if (analysisStopWatch.Elapsed > _perScenarioTimeOutMinutes)
{
runDesc.ErrorDesc = Resources.LrAnalysisTimeOut;
ConsoleWriter.WriteErrLine(runDesc.ErrorDesc);
runDesc.TestState = TestState.Error;
if (!runner.HasExited)
{
runner.Kill();
}
}
//ConsoleWriter.WriteLine("checking error code");
if (runner.ExitCode != (int)Launcher.ExitCodeEnum.Passed)
{
runDesc.ErrorDesc = Resources.LrAnalysisRunTimeError;
ConsoleWriter.WriteErrLine(runDesc.ErrorDesc);
runDesc.TestState = TestState.Error;
}
//using (StreamReader reader = runner.StandardOutput)
//{
// string result = reader.ReadToEnd();
// ConsoleWriter.WriteLine(Resources.LrAnlysisResults);
// ConsoleWriter.WriteLine("");
// ConsoleWriter.WriteLine(result);
//}
}
else
{
runDesc.ErrorDesc = Resources.LrAnlysisInitFail;
ConsoleWriter.WriteErrLine(runDesc.ErrorDesc);
runDesc.TestState = TestState.Error;
}
}
private bool waitForScenario(ref string errorReason)
{
ConsoleWriter.WriteLine("Scenario run has started");
ThreadPool.QueueUserWorkItem(DoTask, autoEvent);
//wait for the scenario to end gracefully:
int time = _pollingInterval * 1000;
if (_summaryDataLogger.IsAnyDataLogged())
{
LogDataDuringScenarioExecution();
}
while (_stopWatch.Elapsed <= _perScenarioTimeOutMinutes)
{
if (_runCancelled())
{
errorReason = Resources.GeneralTimedOut;
return(false);
}
if (autoEvent.WaitOne(time))
{
break;
}
}
if (_stopWatch.Elapsed > _perScenarioTimeOutMinutes)
{
_stopWatch.Stop();
errorReason = string.Format(Resources.LrScenarioTimeOut, _stopWatch.Elapsed.ToString("dd\\:hh\\:mm\\:ss"));
ConsoleWriter.WriteErrLine(errorReason);
}
if (_scenarioEndedEvent)
{
try
{
//ConsoleWriter.WriteLine("unregistering event");
_engine.Events.ScenarioEvents.OnScenarioEnded -= ScenarioEvents_OnScenarioEnded;
_scenarioEndedEvent = false;
}
catch { }
}
//if scenario not ended until now, force stop it.
if (!_scenarioEnded)
{
int ret = _engine.Scenario.StopNow();
if (ret != 0)
{
errorReason = string.Format(Resources.LrStopScenarioEnded);
return(false);
}
int tries = 2;
while (_engine.Scenario.IsActive() && tries > 0)
{
//ConsoleWriter.WriteLine("\t\tScenario is still running. Waiting for the scenario to stop...");
Stopper wlrunStopper = new Stopper(_pollingInterval * 1000);
wlrunStopper.Start();
tries--;
}
if (_engine.Scenario.IsActive())
{
errorReason = Resources.LrControllerFailedToStop;
return(false);
}
}
return(true);
}
private void checkForErrors()
{
//init variables
string message = null;
XmlDocument errorsXML = new XmlDocument();
errorsXML.Load(Path.Combine(_resultsFolder, "errors.xml"));
_errors = new Dictionary <string, ControllerError>();
//new unseen error(s)
foreach (XmlNode errorNode in errorsXML.DocumentElement.ChildNodes)
{
message = errorNode.InnerText;
//ControllerError cerror;
//if error exist, just update the count:
bool added = false;
//check if the error is ignorable
foreach (string ignoreError in _ignoreErrorStrings)
{
if (message.ToLowerInvariant().Contains(ignoreError.ToLowerInvariant()))
{
ConsoleWriter.WriteLine(string.Format(Resources.LrErrorIgnored, message, ignoreError));
if (_errors.ContainsKey(message))
{
_errors[message].occurences++;
}
else
{
_errors.Add(message, new ControllerError {
state = ERRORState.Ignore, occurences = 1
});
}
added = true;
_errorsCount++;
}
}
//error was not ignored, and was not added yet. add it now.
if (!added)
{
// non ignorable error message,
ConsoleWriter.WriteErrLine(message);//+ ", time " + time + ", host: " + host + ", VuserID: " + vuserId + ", script: " + script + ", line: " + line);
if (_errors.ContainsKey(message))
{
_errors[message].occurences++;
}
else
{
_errors.Add(message, new ControllerError {
state = ERRORState.Error, occurences = 1
});
}
_errorsCount++;
//if the scenario ended event was not registered, we need to provide the opportunity to check the vuser status.
//if (!_scenarioEndedEvent)
//{
break;
//}
}
}
ConsoleWriter.WriteErrLine("total number of errors: " + _errorsCount);
}
public TestRunResults RunTest(TestInfo scenarioInf, ref string errorReason, RunCancelledDelegate runCancelled)
{
string scenarioPath = scenarioInf.TestPath;
//prepare the instance that will contain test results for JUnit
TestRunResults runDesc = new TestRunResults();
ConsoleWriter.ActiveTestRun = runDesc;
ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Running: " + scenarioPath);
runDesc.TestType = TestType.LoadRunner.ToString();
_resultsFolder = Helper.GetTempDir();
if (!string.IsNullOrWhiteSpace(scenarioInf.ReportPath))
{
_resultsFolder = scenarioInf.ReportPath;
ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Result folder is set explicitly: " + _resultsFolder);
}
else if (!string.IsNullOrWhiteSpace(scenarioInf.ReportBaseDirectory))
{
_resultsFolder = Path.Combine(scenarioInf.ReportBaseDirectory,
scenarioInf.TestName.Substring(scenarioInf.TestName.LastIndexOf('\\') + 1));
ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Result folder is generated under base directory: " + _resultsFolder);
}
else
{
ConsoleWriter.WriteLine(DateTime.Now.ToString(Launcher.DateFormat) + " Result folder is automatically generated: " + _resultsFolder);
}
//a directory with this name may already exist. try to delete it.
if (Directory.Exists(_resultsFolder))
{
try
{
// Directory.Delete(_resultsFolder, true);
DirectoryInfo dir = new DirectoryInfo(_resultsFolder);
dir.GetFiles().ToList().ForEach(file => file.Delete());
dir.GetDirectories().ToList().ForEach(subdir => subdir.Delete());
}
catch (Exception)
{
Console.WriteLine(string.Format(Resources.CannotDeleteReportFolder, _resultsFolder));
}
}
else
{
try
{
Directory.CreateDirectory(_resultsFolder);
}
catch (Exception)
{
errorReason = string.Format(Resources.FailedToCreateTempDirError, _resultsFolder);
runDesc.TestState = TestState.Error;
runDesc.ErrorDesc = errorReason;
Environment.ExitCode = (int)Launcher.ExitCodeEnum.Failed;
return(runDesc);
}
}
//create LRR folder:
_controller_result_dir = Path.Combine(_resultsFolder, LRR_FOLDER);
Directory.CreateDirectory(_controller_result_dir);
//init result params
runDesc.ErrorDesc = errorReason;
runDesc.TestPath = scenarioPath;
ConsoleWriter.WriteLine(runDesc.TestPath);
runDesc.TestState = TestState.Unknown;
if (!Helper.isLoadRunnerInstalled())
{
runDesc.TestState = TestState.Error;
runDesc.ErrorDesc = string.Format(Resources.LoadRunnerNotInstalled, System.Environment.MachineName);
ConsoleWriter.WriteErrLine(runDesc.ErrorDesc);
Environment.ExitCode = (int)Launcher.ExitCodeEnum.Failed;
return(runDesc);
}
//from here on, we may delegate runCancelled().
_runCancelled = runCancelled;
//start scenario stop watch
Stopwatch scenarioStopWatch = Stopwatch.StartNew();
//set state to running
runDesc.TestState = TestState.Running;
//and run the scenario
bool res = runScenario(scenarioPath, ref errorReason, runCancelled);
if (!res)
{
//runScenario failed. print the error and set test as failed
ConsoleWriter.WriteErrLine(errorReason);
runDesc.TestState = TestState.Error;
runDesc.ErrorDesc = errorReason;
runDesc.Runtime = scenarioStopWatch.Elapsed;
//and try to close the controller
closeController();
return(runDesc);
}
else
{
try
{
ConsoleWriter.WriteLine(Resources.GeneralDoubleSeperator);
runDesc.ReportLocation = _resultsFolder;
ConsoleWriter.WriteLine(Resources.LrAnalysingResults);
//close the controller, so Analysis can be opened
ConsoleWriter.WriteLine("closing Controller");
closeController();
ConsoleWriter.WriteLine("Controller closed");
//generate report using Analysis:
ConsoleWriter.WriteLine("calling analysis report generator");
generateAnalysisReport(runDesc);
ConsoleWriter.WriteLine("analysis report generator finished");
//check for errors:
if (File.Exists(Path.Combine(_resultsFolder, "errors.xml")))
{
checkForErrors();
}
ConsoleWriter.WriteLine(Resources.LRErrorsSummary);
//count how many ignorable errors and how many fatal errors occured.
int ignore = getErrorsCount(ERRORState.Ignore);
int fatal = getErrorsCount(ERRORState.Error);
runDesc.FatalErrors = fatal;
ConsoleWriter.WriteLine(String.Format(Resources.LrErrorSummeryNum, ignore, fatal));
ConsoleWriter.WriteLine("");
if (_errors != null && _errors.Count > 0)
{
foreach (ERRORState state in Enum.GetValues(typeof(ERRORState)))
{
ConsoleWriter.WriteLine(printErrorSummary(state));
}
}
//if scenario ended with fatal errors, change test state
if (fatal > 0)
{
ConsoleWriter.WriteErrLine(string.Format(Resources.LRTestFailDueToFatalErrors, fatal));
errorReason = buildErrorReasonForErrors();
runDesc.TestState = TestState.Failed;
}
else if (ignore > 0)
{
ConsoleWriter.WriteLine(string.Format(Resources.LRTestWarningDueToIgnoredErrors, ignore));
runDesc.HasWarnings = true;
runDesc.TestState = TestState.Warning;
}
else
{
Console.WriteLine(Resources.LRTestPassed);
runDesc.TestState = TestState.Passed;
}
}
catch (Exception e)
{
ConsoleWriter.WriteException(Resources.LRExceptionInAnalysisRunner, e);
runDesc.TestState = TestState.Error;
runDesc.ErrorDesc = Resources.LRExceptionInAnalysisRunner;
runDesc.Runtime = scenarioStopWatch.Elapsed;
}
//runDesc.ReportLocation = _resultsFolder;
}
runDesc.Runtime = scenarioStopWatch.Elapsed;
if (!string.IsNullOrEmpty(errorReason))
{
runDesc.ErrorDesc = errorReason;
}
KillController();
return(runDesc);
}
private bool runScenario(string scenario, ref string errorReason, RunCancelledDelegate runCancelled)
{
cleanENV();
ConsoleWriter.WriteLine(string.Format(Resources.LrInitScenario, scenario));
//start controller
_engine = new LrEngine();
if (_engine == null)
{
errorReason = string.Format(Resources.LrFailToOpenController, scenario);
return(false);
}
//try to register the end scenario event:
_scenarioEndedEvent = false;
try
{
_engine.Events.ScenarioEvents.OnScenarioEnded += ScenarioEvents_OnScenarioEnded;
_scenarioEndedEvent = true;
}
catch (Exception e)
{
ConsoleWriter.WriteException(Resources.LrFailToRegisterEndScenarioEvent, e);
_scenarioEndedEvent = false;
}
if (_displayController == true)
{
_engine.ShowMainWindow(1);
}
else
{
_engine.ShowMainWindow(0);
}
//pointer to the scenario object:
LrScenario currentScenario = _engine.Scenario;
//try to open the scenario and validate the scenario and connect to load generators
if (openScenario(scenario, ref errorReason) && validateScenario(currentScenario, ref errorReason))
{
//apply rts to scripts
foreach (ScriptRTSModel scriptRTS in _scriptRTSSet)
{
try
{
LrScripts currentScripts = currentScenario.Scripts;
LrScript currentScript = currentScripts.Item[scriptRTS.GetScriptName()];
string runtimeSettings = "",
actionLogic = "";
currentScript.GetScriptRunTimeSettings(ref runtimeSettings, ref actionLogic);
RTSHelper rtsHelper = new RTSHelper(runtimeSettings, RTSHelper.COMMAND_ARGUMENTS, scriptRTS.GetKeyValuePairs());
string updatedRuntimeSettings = rtsHelper.GetUpdatedIniFileText();
currentScript.SetScriptRunTimeSettings(updatedRuntimeSettings, actionLogic);
}
catch (Exception e)
{
errorReason = string.Format(Resources.LrRTSError, scriptRTS.GetScriptName(), e.Message);
return(false);
}
}
//set the result dir:
ConsoleWriter.WriteLine("setting scenario result folder to " + Path.Combine(_resultsFolder, LRR_FOLDER));
currentScenario.ResultDir = Path.Combine(_resultsFolder, LRR_FOLDER);
ConsoleWriter.WriteLine("scenario result folder: " + currentScenario.ResultDir);
//check if canceled or timedOut:
if (_runCancelled())
{
errorReason = Resources.GeneralTimedOut;
return(false);
}
_scenarioEnded = false;
ConsoleWriter.WriteLine(Resources.LrStartScenario);
int ret = currentScenario.Start();
if (!currentScenario.ResultDir.Equals(Path.Combine(_resultsFolder, LRR_FOLDER)))
{
ConsoleWriter.WriteLine("controller failed to write to " + Path.Combine(_resultsFolder, LRR_FOLDER) + " setting result folder to " + currentScenario.ResultDir);
_controller_result_dir = new DirectoryInfo(currentScenario.ResultDir).Name;
ConsoleWriter.WriteLine("controller reult dir: " + _controller_result_dir);
}
if (ret != 0)
{
errorReason = string.Format(Resources.LrStartScenarioFail, scenario, ret);
return(false);
}
//per scenario timeout stopwatch
_stopWatch = Stopwatch.StartNew();
//wait for scenario to end:
if (!waitForScenario(ref errorReason))
{
//something went wrong during scenario execution, error reason set in errorReason string
return(false);
}
else
{//scenario has ended
Console.WriteLine(string.Format(Resources.LrScenarioEnded, scenario, _stopWatch.Elapsed.Hours, _stopWatch.Elapsed.Minutes, _stopWatch.Elapsed.Seconds));
//collate results
collateResults();
}
}
else
{
return(false);
}
return(true);
}
