public void Initialize(TestLoggerEvents events, Dictionary<string, string> parameters)
{
var loggersParameter = parameters.Keys.SingleOrDefault(k => string.Equals("loggers", k, StringComparison.InvariantCultureIgnoreCase));
var loggers = loggersParameter == null ?
parameters.Where(p => !p.Key.Contains(".") && p.Key != Testrundirectory) :
parameters[loggersParameter].Split(',').Select(l => new KeyValuePair<string, string>(l, l));
foreach (var keyValuePair in loggers)
{
var loggerType = _loggers.FirstOrDefault(l => FriendlyNameMatches(l, keyValuePair.Value) || LoggerUrlMatches(l, keyValuePair.Value));
if (loggerType == null)
{
throw new Exception(string.Format("Unable to find logger {0}", keyValuePair.Value));
}
var loggerInstance = (ITestLogger)Activator.CreateInstance(loggerType.TypeInAssembly, true);
var loggerWithParameters = loggerInstance as ITestLoggerWithParameters;
if (loggerWithParameters != null)
{
var parametersFor = GetParametersFor(keyValuePair.Key, parameters);
loggerWithParameters.Initialize(events, parametersFor);
}
else
{
loggerInstance.Initialize(events, parameters[Testrundirectory]);
}
}
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
Initialize(events, new Dictionary<string, string>
{
{"TestResultsFile", "TestResults.xml"},
{"IncludeSourceFileInfo", "false"}
});
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events which can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
// Register for the events.
events.TestRunMessage += TestMessageHandler;
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
CreateReportFolder();
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
// Register for the events.
events.TestRunMessage += TestMessageHandler;
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
Console.WriteLine("##teamcity[testSuiteStarted name='VSTest']");
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
// Register for the events.
events.TestRunMessage += TestMessageHandler;
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
_teamCityWriter = new TeamCityServiceMessages().CreateWriter(w => Trace.WriteLine(w));
_vsTestSuite = _teamCityWriter.OpenTestSuite("VSTest");
}
public void Initialize(TestLoggerEvents events, Dictionary<string, string> parameters)
{
startupParameters = parameters;
Trace.WriteLine("[JUnitLogger] Current dir: " + Environment.CurrentDirectory);
foreach (var kv in parameters)
{
Trace.WriteLine(string.Format("[JUnitLogger] Init parameter: " + kv.Key + " " + kv.Value));
}
SubscribeToEvents(events);
}
public void Initialize(TestLoggerEvents events, Dictionary<string, string> parameters)
{
testManager = new PnPTestManager(parameters);
foreach (var param in parameters)
{
Console.WriteLine("Property: {0} Value:{1}", param.Key, param.Value);
}
events.TestResult += events_TestResult;
events.TestRunMessage += events_TestRunMessage;
events.TestRunComplete += events_TestRunComplete;
}
private void InitializeImpl(TestLoggerEvents events, string outputPath)
{
events.TestRunMessage += this.TestMessageHandler;
events.TestResult += this.TestResultHandler;
events.TestRunComplete += this.TestRunCompleteHandler;
this.outputFilePath = Path.GetFullPath(outputPath);
lock (this.resultsGuard)
{
this.results = new List <TestResultInfo>();
}
this.localStartTime = DateTime.UtcNow;
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
if (!Directory.Exists(testRunDirectory))
{
Directory.CreateDirectory(testRunDirectory);
}
TestRunDirectory = testRunDirectory;
events.DiscoveryStart += Events_DiscoveryStart;
events.DiscoveredTests += Events_DiscoveredTests;
events.DiscoveryComplete += Events_DiscoveryComplete;
}
/// <inheritdoc/>
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Count == 0)
{
throw new ArgumentException("No default parameters added", nameof(parameters));
}
this.parametersDictionary = parameters;
this.Initialize(events, this.parametersDictionary[DefaultLoggerParameterNames.TestRunDirectory]);
}
/// <inheritdoc/>
public void Initialize(TestLoggerEvents events, string testResultsDirPath)
{
Console.WriteLine("CoverageLogger.Initialize: Initializing Spekt code coverage logger...");
this.codeCoverageUtility = new CodeCoverageUtility();
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
// Register for the events.
events.TestRunComplete += this.TestRunCompleteHandler;
Console.WriteLine("CoverageLogger.Initialize: Completed Spekt code coverage logger initialization...");
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="parameters">Configuration parameters for logger.</param>
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
try
{
_configBuilder.Add(new LoggerConfigurationProvider(parameters));
Initialize(events, parameters.Single(p => p.Key == "TestRunDirectory").Value);
}
catch (Exception exp)
{
var error = $"Unexpected exception in {nameof(Initialize)}: {exp}";
TraceLogger.Error(error);
Console.WriteLine(error);
throw;
}
}
public void Initialize(TestLoggerEvents events, string testResultsDirPath)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
if (testResultsDirPath == null)
{
throw new ArgumentNullException(nameof(testResultsDirPath));
}
var outputPath = Path.Combine(testResultsDirPath, "TestResults.xml");
InitializeImpl(events, outputPath);
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
if (events == null)
{
throw new ArgumentNullException("events");
}
if (ConsoleLogger.Output == null)
{
ConsoleLogger.Output = ConsoleOutput.Instance;
}
// Register for the events.
events.TestRunMessage += this.TestMessageHandler;
events.TestResult += this.TestResultHandler;
events.TestRunComplete += this.TestRunCompleteHandler;
}
public ITestRunBuilder Subscribe(TestLoggerEvents loggerEvents)
{
if (loggerEvents == null)
{
throw new ArgumentNullException(nameof(loggerEvents));
}
loggerEvents.TestRunStart += (_, eventArgs) =>
{
this.testRun.RunConfiguration = this.testRun.Start(eventArgs);
};
loggerEvents.TestRunMessage += (_, eventArgs) => this.testRun.Message(eventArgs);
loggerEvents.TestResult += (_, eventArgs) => this.testRun.Result(eventArgs);
loggerEvents.TestRunComplete += (_, eventArgs) => this.testRun.Complete(eventArgs);
return(this);
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
Console.WriteLine("Initializing MsTestTrxLogger.");
Console.WriteLine("Test Run Directory: {0}", testRunDirectory);
var testRunStarted = DateTime.Now;
List <TestResult> testResults = new List <TestResult>();
events.TestResult += (sender, eventArgs) =>
{
try
{
if (!IsTestIgnored(eventArgs.Result))
{
testResults.Add(eventArgs.Result);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
};
events.TestRunMessage += (sender, args) =>
{
if (args != null)
{
Console.WriteLine(args.Message);
}
};
events.TestRunComplete += (sender, args) =>
{
try
{
var trxOutputWriter = new MsTestTrxXmlWriter(testResults, args, testRunStarted);
trxOutputWriter.WriteTrxOutput(_trxFilePath);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
};
}
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Count == 0)
{
throw new ArgumentException("No default parameters added", nameof(parameters));
}
parameters.TryGetValue(LogFileNameKey, out string logFileNameValue);
string testResultsDirPath = parameters[DefaultLoggerParameterNames.TestRunDirectory];
DeriveTrxFilePath(logFileNameValue, testResultsDirPath);
Initialize(events, testResultsDirPath);
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
if (string.IsNullOrEmpty(testRunDirectory))
{
throw new ArgumentNullException(nameof(testRunDirectory));
}
_testRunDirectory = testRunDirectory;
_testResults = new List <ExercismTestResult>();
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
}
public void Initialize(TestLoggerEvents events, string testResultsDirPath)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
events.TestRunMessage += this.OnTestRunMessage;
events.TestResult += this.OnTestResult;
events.TestRunComplete += this.OnTestRunComplete;
_results = new List <TestResultModel>();
if (!Directory.Exists(testResultsDirPath))
{
Directory.CreateDirectory(testResultsDirPath);
}
_logfile = Path.Combine(testResultsDirPath, "TestResults.txt");
}
private static void InnerInitialize(TestLoggerEvents events, string file)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
Console.WriteLine($"using {file} for skipped test case log");
events.TestResult += (sender, args) =>
{
using (var w = File.AppendText(file))
{
if (args.Result.Outcome == TestOutcome.Skipped)
{
w.WriteLine(args.Result.DisplayName);
}
}
};
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
events.TestResult += (s, e) =>
{
if (e.Result.Outcome != TestOutcome.Failed)
{
return;
}
_failedTests.Enqueue(e.Result);
};
//events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
events.TestRunStart += (sender, args) =>
{
var settingsXml = args.TestRunCriteria.TestRunSettings;
if (string.IsNullOrWhiteSpace(settingsXml))
{
return;
}
var settings = XDocument.Parse(settingsXml);
var parameters = settings.Root?.XPathSelectElements("//TestRunParameters/Parameter");
if (parameters == null)
{
return;
}
foreach (var para in parameters)
{
var name = para.Attribute("name")?.Value;
var value = para.Attribute("value")?.Value;
if (name == "DisableFullSkipMessages" && !string.IsNullOrWhiteSpace(value))
{
_disableSkipNamespaces.AddRange(value
.Split(';')
.Select(s => s.Trim())
.Where(s => !string.IsNullOrWhiteSpace(s))
);
}
}
};
}
/// <inheritdoc/>
/// <remarks>Overrides <see cref="ITestLogger.Initialize"/> method. Supports older runners.</remarks>
public void Initialize(TestLoggerEvents events, string testResultsDirPath)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
if (testResultsDirPath == null)
{
throw new ArgumentNullException(nameof(testResultsDirPath));
}
var config = new Dictionary <string, string>
{
{ DefaultLoggerParameterNames.TestRunDirectory, testResultsDirPath },
{ LoggerConfiguration.LogFilePathKey, Path.Combine(testResultsDirPath, this.DefaultTestResultFile) }
};
this.CreateTestRun(events, new LoggerConfiguration(config));
}
/// <inheritdoc/>
public void Initialize(TestLoggerEvents events, string testResultsDirPath)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
if (string.IsNullOrEmpty(testResultsDirPath))
{
throw new ArgumentNullException(nameof(testResultsDirPath));
}
// Register for the events.
events.TestRunMessage += this.TestMessageHandler;
events.TestResult += this.TestResultHandler;
events.TestRunComplete += this.TestRunCompleteHandler;
this.testResultsDirPath = testResultsDirPath;
this.InitializeInternal();
}
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Count == 0)
{
throw new ArgumentException("No default parameters added", nameof(parameters));
}
var verbosityExists = parameters.TryGetValue(ConsoleLogger.VerbosityParam, out string verbosity);
if (verbosityExists && Enum.TryParse(verbosity, true, out Verbosity verbosityLevel))
{
this.verbosityLevel = verbosityLevel;
}
this.Initialize(events, String.Empty);
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
this.testRunDirectory = testRunDirectory;
var fs = File.Create("test.test");
fs.Close();
// Register for the events.
events.TestRunMessage += TestMessageHandler;
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
string ipStr = "127.0.0.1";
IPAddress ipServer = IPAddress.Parse(ipStr);
int port = 6543;
clientSocketWriter = new System.Net.Sockets.TcpClient();
clientSocketWriter.Connect(ipServer, port);
networkStream = clientSocketWriter.GetStream();
Thread.Sleep(1000);
}
/// <inheritdoc/>
public void Initialize(TestLoggerEvents events, string testResultsDirPath)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
if (string.IsNullOrEmpty(testResultsDirPath))
{
throw new ArgumentNullException(nameof(testResultsDirPath));
}
// Register for the events.
events.TestRunMessage += TestMessageHandler;
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
TestResultsDirPath = testResultsDirPath;
TestRunDetails = new TestRunDetails();
Results = new ConcurrentDictionary <Guid, ObjectModel.TestResult>();
ResultCollectionDictionary = new ConcurrentDictionary <string, TestResultCollection>();
}
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Count == 0)
{
throw new ArgumentException("No default parameters added", nameof(parameters));
}
var verbosityExists = parameters.TryGetValue(ConsoleLogger.VerbosityParam, out string verbosity);
if (verbosityExists && Enum.TryParse(verbosity, true, out Verbosity verbosityLevel))
{
this.verbosityLevel = verbosityLevel;
}
var prefixExists = parameters.TryGetValue(ConsoleLogger.PrefixParam, out string prefix);
if (prefixExists)
{
bool.TryParse(prefix, out AppendPrefix);
}
var progressArgExists = parameters.TryGetValue(ConsoleLogger.ProgressIndicatorParam, out string enableProgress);
if (progressArgExists)
{
bool.TryParse(enableProgress, out EnableProgress);
}
parameters.TryGetValue(DefaultLoggerParameterNames.TargetFramework, out this.targetFramework);
this.targetFramework = !string.IsNullOrEmpty(this.targetFramework) ? NuGetFramework.Parse(this.targetFramework).GetShortFolderName() : this.targetFramework;
Initialize(events, String.Empty);
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="parameters">Configuration parameters for logger.</param>
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
foreach (var parameter in parameters)
{
if (parameter.Key == "TestRunDirectory")
{
Initialize(events, parameter.Value);
}
else if (parameter.Key.ToLowerInvariant() == "launch.name")
{
Config.Launch.Name = parameter.Value;
}
else if (parameter.Key.ToLowerInvariant() == "launch.description")
{
Config.Launch.Description = parameter.Value;
}
else if (parameter.Key.ToLowerInvariant() == "launch.tags")
{
Config.Launch.Tags = parameter.Value.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Select(t => t.Trim()).ToList();
}
else if (parameter.Key.ToLowerInvariant() == "launch.isdebugmode")
{
Config.Launch.IsDebugMode = bool.Parse(parameter.Value);
}
else if (parameter.Key.ToLowerInvariant() == "server.project")
{
Config.Server.Project = parameter.Value;
}
else if (parameter.Key.ToLowerInvariant() == "server.authentication.uuid")
{
Config.Server.Authentication.Uuid = parameter.Value;
}
else
{
throw new ArgumentException($"Unknown '{parameter.Key}' parameter.");
}
}
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
NotNull(events, nameof(events));
string appveyorApiUrl = Environment.GetEnvironmentVariable("APPVEYOR_API_URL");
if (appveyorApiUrl == null)
{
Console.WriteLine("Appveyor.TestLogger: Not an AppVeyor run. Environment variable 'APPVEYOR_API_URL' not set.");
return;
}
#if DEBUG
Console.WriteLine("Appveyor.TestLogger: Logging to {0}", appveyorApiUrl);
#endif
queue = new AppveyorLoggerQueue(appveyorApiUrl);
// Register for the events.
events.TestRunMessage += this.TestMessageHandler;
events.TestResult += this.TestResultHandler;
events.TestRunComplete += this.TestRunCompleteHandler;
}
/// <summary>
/// Initializes the Test Logger.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="testRunDirectory">Test Run Directory</param>
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
if (events == null)
{
throw new ArgumentNullException("events");
}
if (ConsoleLogger.Output == null)
{
ConsoleLogger.Output = ConsoleOutput.Instance;
}
// Register for the events.
events.TestRunMessage += this.TestMessageHandler;
events.TestResult += this.TestResultHandler;
events.TestRunComplete += this.TestRunCompleteHandler;
// Register for the discovery events.
events.DiscoveryMessage += this.TestMessageHandler;
// TODO Get changes from https://github.com/Microsoft/vstest/pull/1111/
// events.DiscoveredTests += DiscoveredTestsHandler;
}
/// <inheritdoc/>
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.Count == 0)
{
throw new ArgumentException("No default parameters added", nameof(parameters));
}
parametersDictionary = parameters;
if (parameters.TryGetValue(HtmlLoggerConstants.LogFilePrefixKey, out string logFilePrefixValue) && parameters.TryGetValue(HtmlLoggerConstants.LogFileNameKey, out string logFileNameValue))
{
var htmlParameterErrorMsg = string.Format(CultureInfo.CurrentCulture, HtmlResource.PrefixAndNameProvidedError);
EqtTrace.Error(htmlParameterErrorMsg);
throw new ArgumentException(htmlParameterErrorMsg);
}
this.Initialize(events, parameters[DefaultLoggerParameterNames.TestRunDirectory]);
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
if (!GetRequiredVariable("SYSTEM_ACCESSTOKEN", out string accessToken) ||
!GetRequiredVariable("SYSTEM_TEAMFOUNDATIONCOLLECTIONURI", out string collectionUri) ||
!GetRequiredVariable("SYSTEM_TEAMPROJECT", out string teamProject) ||
!GetRequiredVariable("BUILD_BUILDID", out string buildId) ||
!GetRequiredVariable("AGENT_NAME", out string agentName) ||
!GetRequiredVariable("AGENT_JOBNAME", out string jobName))
{
return;
}
if (_apiClient == null)
{
_apiClient = new ApiClient(accessToken, collectionUri, teamProject);
}
_queue = new LoggerQueue(_apiClient, buildId, agentName, jobName);
// Register for the events
events.TestRunMessage += TestMessageHandler;
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
}
/// <summary>
/// Initialises the Test Logger with given parameters.
/// </summary>
/// <param name="events">Events that can be registered for.</param>
/// <param name="parameters">Collection of parameters.</param>
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
if (events is null)
{
throw new ArgumentNullException(nameof(events));
}
if (parameters?.Any() != true)
{
throw new ArgumentNullException(nameof(parameters));
}
if (parameters.ContainsKey(Constants.LogFilePrefixKey) && parameters.ContainsKey(Constants.LogFileNameKey))
{
throw new ArgumentException($"The parameters {Constants.LogFileNameKey} and {Constants.LogFilePrefixKey} cannot be used together.");
}
var testRunDirectory = parameters[DefaultLoggerParameterNames.TestRunDirectory];
TestParameters = parameters;
Initialize(events, testRunDirectory);
OnInitialize(TestParameters);
}
/// <inheritdoc/>
/// <remarks>
/// Overrides <c>ITestLoggerWithParameters.Initialize(TestLoggerEvents, Dictionary)</c> method.
/// </remarks>
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
if (events == null)
{
throw new ArgumentNullException(nameof(events));
}
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
var config = new Dictionary <string, string>(parameters);
// Set the default log file name if not provided by user
if (!config.ContainsKey(LoggerConfiguration.LogFilePathKey) &&
!config.ContainsKey(LoggerConfiguration.LogFileNameKey))
{
config[LoggerConfiguration.LogFileNameKey] = this.DefaultTestResultFile;
}
this.CreateTestRun(events, new LoggerConfiguration(config));
}
public void Initialize(TestLoggerEvents events, Dictionary <string, string> parameters)
{
Initialize(events, parameters["TestRunDirectory"]);
foreach (KeyValuePair <string, string> parameter in parameters)
{
Console.WriteLine(parameter.Key + ":" + RESULTS_PATH_PARAMETER_NAME);
if (String.Compare(parameter.Key, RESULTS_PATH_PARAMETER_NAME, true) == 0)
{
string resultPath = parameter.Value;
if (!resultPath.EndsWith(Path.DirectorySeparatorChar.ToString()))
{
resultPath += Path.DirectorySeparatorChar;
}
if (!Directory.Exists(resultPath))
{
Directory.CreateDirectory(resultPath);
}
AllureConfig.ResultsPath = resultPath;
}
}
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
events.TestRunMessage += TestMessageHandler;
events.TestRunComplete += Events_TestRunComplete;
events.TestResult += Events_TestResult;
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
throw new NotImplementedException();
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
}
public void Initialize(TestLoggerEvents events, Dictionary<string, string> parameters)
{
Parameters = parameters;
}
private void SubscribeToEvents(TestLoggerEvents events)
{
events.TestRunMessage += TestMessageHandler;
events.TestResult += TestResultHandler;
events.TestRunComplete += TestRunCompleteHandler;
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
throw new InvalidOperationException("This should never happen, but then again, vstest loggers are pretty much undocumented, so let me know if this happens!");
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
_teamCityLogger.Initialize(events, testRunDirectory);
_trxLogger.Initialize(events, testRunDirectory);
}
public void Initialize(TestLoggerEvents events, string testRunDirectory)
{
Console.WriteLine("In Initialize");
}
