public void TearDown()
{
DatabaseMigrator.CleanUp();
MigrationsAssembly = null;
Logger = null;
DatabaseMigrator = null;
}
public void ExecuteScalar_SyntaxError_LoggedAsError()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = "SELEC_error 1";
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
try
{
var result = (long)loggedCmd.ExecuteScalar();
}
catch (Exception ex)
{
Assert.Contains("syntax error", ex.Message);
}
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Debug]);
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Error]);
}
public void GET_Response_404()
{
var logSpy = new StringLogger();
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://test.com");
var handler = new LoggingHandler(logSpy, LogLevel.Debug)
{
InnerHandler = new TestHandler((r, c) =>
{
var response = new HttpResponseMessage(HttpStatusCode.NotFound);
return(Task.FromResult(response));
})
};
var client = new HttpClient(handler);
var result = client.SendAsync(httpRequestMessage).Result;
Assert.Equal(HttpStatusCode.NotFound, result.StatusCode);
var logs = logSpy.Logs[LogLevel.Debug];
Assert.Contains("http://test.com", logs);
Assert.Contains("404", logs);
}
public void ExecuteScalar_CommandWithParameter_ResultOk_LoggedAsDebug()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = "SELECT @myparameter";
var param = queryCommand.CreateParameter();
param.SqliteType = SqliteType.Text;
param.ParameterName = "@myparameter";
param.Value = "SomeText";
queryCommand.Parameters.Add(param);
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
var result = (string)loggedCmd.ExecuteScalar();
var debugLogs = logSpy.Logs[LogLevel.Debug];
Assert.Equal("SomeText", result);
Assert.Contains(queryCommand.CommandText, debugLogs);
Assert.Contains("myparameter", debugLogs);
Assert.Contains("SomeText", debugLogs);
}
public void Log_With_Info_Level()
{
var logSpy = new StringLogger();
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://test.com");
var handler = new LoggingHandler(logSpy, LogLevel.Information)
{
InnerHandler = new TestHandler((r, c) =>
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
return(Task.FromResult(response));
})
};
var client = new HttpClient(handler);
var result = client.SendAsync(httpRequestMessage).Result;
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
var logs = logSpy.Logs[LogLevel.Information];
Assert.Contains("http://test.com", logs);
Assert.Contains("GET", logs);
Assert.Contains("OK", logs);
Assert.Contains("200", logs);
}
public void GET_Ok_With_Body()
{
var logSpy = new StringLogger();
var httpRequestMessage = new HttpRequestMessage(HttpMethod.Get, "http://test.com");
var handler = new LoggingHandler(logSpy, LogLevel.Debug)
{
InnerHandler = new TestHandler((r, c) =>
{
var response = new HttpResponseMessage(HttpStatusCode.OK);
response.Content = new StringContent("Sample Content Body");
return(Task.FromResult(response));
})
};
var client = new HttpClient(handler);
var result = client.SendAsync(httpRequestMessage).Result;
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
Assert.Equal("Sample Content Body", result.Content.ReadAsStringAsync().Result);
var logs = logSpy.Logs[LogLevel.Debug];
Assert.Contains("http://test.com", logs);
Assert.Contains("GET", logs);
Assert.Contains("OK", logs);
Assert.Contains("200", logs);
Assert.Contains("Sample Content Body", logs);
}
public void TestRunPythonCommand()
{
var expectedSearchPath = string.Format("['{0}', '{1}']",
TestData.GetPath(@"TestData").Replace("\\", "\\\\"),
TestData.GetPath(@"TestData\HelloWorld").Replace("\\", "\\\\")
);
var proj = new Project(TestData.GetPath(@"TestData\Targets\Commands4.pyproj"));
foreach (var version in PythonPaths.Versions)
{
var verStr = version.Version.ToVersion().ToString();
proj.SetProperty("InterpreterId", version.Id.ToString("B"));
proj.SetProperty("InterpreterVersion", verStr);
proj.RemoveItems(proj.ItemsIgnoringCondition.Where(i => i.ItemType == "InterpreterReference").ToArray());
proj.AddItem("InterpreterReference", string.Format("{0:B}\\{1}", version.Id, verStr));
proj.Save();
proj.ReevaluateIfNecessary();
var log = new StringLogger(LoggerVerbosity.Minimal);
Assert.IsTrue(proj.Build("CheckCode", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed), log }));
Console.WriteLine();
Console.WriteLine("Output from {0:B} {1}", version.Id, version.Version.ToVersion());
foreach (var line in log.Lines)
{
Console.WriteLine("* {0}", line.TrimEnd('\r', '\n'));
}
var logLines = log.Lines.Last().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(2, logLines.Length);
Assert.AreEqual(version.Version.ToVersion().ToString(), logLines[0].Trim());
Assert.AreEqual(expectedSearchPath, logLines[1].Trim());
}
}
public void Build()
{
CheckProjectLoaded();
BuildManager manager = BuildManager.DefaultBuildManager;
var buildLogger = new StringLogger();
var projectInstance = new ProjectInstance(_projectPath);
var buildParams = new BuildParameters()
{
DetailedSummary = true,
Loggers = new List <ILogger> {
buildLogger
},
};
BuildResult result = manager.Build(buildParams,
new BuildRequestData(
projectInstance, new string[] { "Build" }));
_logger.Debug("Build output:\n" + buildLogger.GetLog());
if (result.OverallResult == BuildResultCode.Failure)
{
throw new ProjectBuildException(
$"Failed to build project {_projectPath}:\n\n{buildLogger.GetLog()}");
}
}
public ExecutionResult Uninstall(UninstallDto uninstallOptions)
{
var logger = new StringLogger();
try
{
var packageInfo = new PackageInfo();
packageInfo.Name = uninstallOptions.Application;
packageInfo.Version = uninstallOptions.Version;
var packageRemover = new PackageRemover();
packageRemover.Logger = logger;
packageRemover.Remove(packageInfo, new string[] { uninstallOptions.Directory }, uninstallOptions.AdditionalParameters, uninstallOptions.UninstallScript);
return(new ExecutionResult()
{
Success = logger.Logs.All(x => !x.Error),
Log = logger.Logs
});
}
catch (Exception e)
{
logger.Log(e.InnerException != null ? e.InnerException.Message : e.Message, true);
return(new ExecutionResult()
{
Success = false,
Exception = e.InnerException != null ? e.InnerException.Message : e.Message,
Log = logger.Logs
});
}
}
public ExecutionResult Update(InstallDto installOptions)
{
var logger = new StringLogger();
try
{
var files = Directory.GetFiles(installOptions.Directory, "*.nupkg");
if (files.Count() == 0)
{
logger.Log("No package to uninstall found, proceeding with a normal install.");
}
if (files.Count() >= 1)
{
var filename = PackageHelpers.ExtractPackageName(files.First()).Trim();
var packageInfo = new PackageInfo()
{
Name = filename.Substring(filename.LastIndexOf("\\") + 1),
Version = PackageHelpers.ExtractPackageVersion(files.First()).Trim(),
InstallationDirectory = installOptions.Directory,
Configuration = installOptions.Configuration
};
var packageRemover = new PackageRemover();
packageRemover.Logger = logger;
var additionalParams = installOptions.AdditionalParameters;
packageRemover.Remove(packageInfo, new string[] { installOptions.Directory }, additionalParams, installOptions.UninstallScript);
}
var packageInfo2 = new PackageInfo()
{
Configuration = installOptions.Configuration,
InstallationDirectory = installOptions.Directory,
Name = installOptions.Application,
Version = installOptions.Version
};
var PackageInstaller = new PackageInstaller();
PackageInstaller.Logger = logger;
PackageInstaller.Install(packageInfo2, new string[] { installOptions.Repository }, installOptions.AdditionalParameters, installOptions.InstallScript, installOptions.ConfigurationFile, installOptions.ConfigurationTransform);
return(new ExecutionResult()
{
Success = logger.Logs.All(x => !x.Error),
Log = logger.Logs
});
}
catch (Exception e)
{
logger.Log(e.InnerException != null ? e.InnerException.Message : e.Message, true);
return(new ExecutionResult()
{
Success = false,
Exception = e.InnerException != null ? e.InnerException.Message : e.Message,
Log = logger.Logs
});
}
}
public ExecutionResult Install(InstallDto installOptions)
{
var logger = new StringLogger();
try
{
var packageInfo = new PackageInfo();
packageInfo.Configuration = installOptions.Configuration;
packageInfo.InstallationDirectory = installOptions.Directory;
packageInfo.Name = installOptions.Application;
packageInfo.Version = installOptions.Version;
var PackageInstaller = new PackageInstaller();
PackageInstaller.Logger = logger;
PackageInstaller.Install(packageInfo, new string[] { installOptions.Repository }, installOptions.AdditionalParameters, installOptions.InstallScript, installOptions.ConfigurationFile, installOptions.ConfigurationTransform);
return(new ExecutionResult()
{
Success = logger.Logs.All(x => !x.Error),
Log = logger.Logs
});
}
catch (Exception e)
{
logger.Log(e.InnerException != null ? e.InnerException.Message : e.Message, true);
return(new ExecutionResult()
{
Success = false,
Exception = e.InnerException != null ? e.InnerException.Message : e.Message,
Log = logger.Logs
});
}
}
private void OnYakChildElementSelected(YakChildTreeViewItem childEntry)
{
SelectedNodeImage = TexDecoder.Decode(childEntry.YakFile.FileData, childEntry.Value.TextureOffset + childEntry.Value.VifOffset,
childEntry.Value.VifLength - childEntry.Value.TextureOffset);
var log = new StringLogger();
_modelViewModel.Texture = SelectedNodeImage;
_modelViewModel.AnimData = null;
Model model = new Model();
model.meshList = VifDecoder.Decode(
log,
childEntry.YakFile.FileData,
childEntry.Value.VifOffset,
childEntry.Value.TextureOffset,
SelectedNodeImage.PixelWidth,
SelectedNodeImage.PixelHeight);
_modelViewModel.VifModel = model;
LogText += log.ToString();
_window.tabControl.SelectedIndex = 1; // Model View
_window.ResetCamera();
_window.SetViewportText(1, childEntry.Text + " of " + ((YakTreeViewItem)childEntry.Parent).Text, "");
}
public void ExecuteReader_SimpleCommand_ResultOk_LoggedAsDebug()
{
var logSpy = new StringLogger();
using var connection = new SqliteConnection(connectionString);
connection.Open();
var queryCommand = connection.CreateCommand();
queryCommand.CommandText = @"
SELECT 1
UNION
SELECT 2";
// act
var loggedCmd = new LoggedDbCommand(queryCommand, logSpy);
using var reader = loggedCmd.ExecuteReader();
Assert.True(reader.Read());
Assert.Equal(1, reader.GetInt64(0));
Assert.True(reader.Read());
Assert.Equal(2, reader.GetInt64(0));
Assert.False(reader.Read());
Assert.Contains(queryCommand.CommandText, logSpy.Logs[LogLevel.Debug]);
}
private void MigrateToVersion(long version, Assembly assembly)
{
var log = new StringBuilder();
var logger = new StringLogger(log);
var db = new DatabaseMigrator(logger, false, "SqlServer", version, true);
db.Execute(Settings, assembly);
}
public void ShouldLogNoExceptionLessThanThreshold()
{
var sut = new StringLogger(LogLevel.Fatal, 10000);
var e = new Exception("Testing");
sut.LogException("Test", e, typeof(StartupModuleCompleteTest), LogLevel.Error);
Assert.IsTrue(string.IsNullOrEmpty(sut.ToString()));
}
/// <summary>
/// Start KMS Server
/// </summary>
/// <param name="logger">Any Logger method that implements ILogger.</param>
/// <param name="settings">KMS Server Settings Object</param>
public static void Start(ILogger logger, KMSServerSettings settings = null)
{
// Prevent Running Twice
if (_listener != null && _listener.Running)
{
//throw new Exception("Cannot run two instances of KMS Server.");
_listener.Stop();
}
// Initialize Logger if No Logger was Set
if (logger == null)
{
logger = new StringLogger();
}
// Initialize KMS Server Settings to use with RPC Message Handler
if (settings != null)
{
Settings = settings;
}
else
{
Settings = new KMSServerSettings();
}
RpcMessageHandler messageHandler = new RpcMessageHandler(Settings, new KMSRequestHandler(Settings, logger));
// Kill Any Processes using the desired TCP/IP Port
if (settings != null && settings.KillProcessOnPort)
{
foreach (TcpRow tcpRow in ManagedIpHelper.GetExtendedTcpTable(true))
{
if (tcpRow.LocalEndPoint.Port == Settings.Port)
{
Process.GetProcessById(tcpRow.ProcessId).Kill();
Thread.Sleep(5000);
break;
}
}
}
// Configure and Start KMS Server
_listener = new TCPServer(messageHandler, logger);
_listener.Start(Settings.Port);
// Log KMS Server TCP Server Startup
if (_listener.Running)
{
logger.LogMessage("KMS Port: " + Settings.Port);
logger.LogMessage("KMS HWID: " + Settings.DefaultKMSHWID);
logger.LogMessage("KMS Activation Interval: " + Settings.VLActivationInterval);
logger.LogMessage("KMS Renewal Interval: " + Settings.VLRenewalInterval);
logger.LogMessage("KMS Port Process Termination: " + Settings.KillProcessOnPort);
logger.LogMessage("");
logger.LogMessage("KMS Server Emulator started successfully.");
logger.LogMessage("");
}
}
private static void AssertBuildsProject(Microsoft.Build.Evaluation.Project proj, string target)
{
var logger = new StringLogger();
if (!proj.Build(target, new StringLogger[] { logger }))
{
Assert.Fail(logger.ToString());
}
}
public void Format_WithoutPackageRootSpecified_DoesNotThrow()
{
var logger = new StringLogger();
App.Execute(new[] { "format", BaseDir.Combine("file").WriteAllText("") }, logger);
logger.ErrorsAsString.ShouldBeEmpty();
logger.InfosAsString.ShouldBeEmpty();
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
var logger = new StringLogger();
var tests = new PlatformTests(logger);
int testsRun, testsPassed, testsFailed;
tests.RunTests(out testsRun, out testsPassed, out testsFailed);
this.logSummary.Text = String.Format("{0} Run, {1} Passed, {2} Failed", testsRun, testsPassed, testsFailed);
this.logResults.Text = logger.Log;
}
public void ShouldLogErrorIfExitCode()
{
var logger = new StringLogger();
var parameters = new Dictionary <string, string>();
PowershellHelpers.ExecuteScript(".", "throw \"test\"", logger, parameters);
logger.Logs.Count.Should().Be.EqualTo(1);
logger.Logs.ElementAt(0).Error.Should().Be.True();
}
private void Button_Click_1(object sender, RoutedEventArgs e)
{
var logger = new StringLogger();
var tests = new PlatformTests(logger);
int testsRun, testsPassed, testsFailed;
tests.RunTests(out testsRun, out testsPassed, out testsFailed);
this.logSummary.Text = String.Format("{0} Run, {1} Passed, {2} Failed", testsRun, testsPassed, testsFailed);
this.logResults.Text = logger.Log;
}
public void ShouldLogOutputofCommand()
{
var logger = new StringLogger();
var parameters = new Dictionary <string, string>();
PowershellHelpers.ExecuteScript(".", "&echo 'test'", logger, parameters);
logger.Logs.Count.Should().Be.EqualTo(1);
logger.Logs.ElementAt(0).Text.Should().Be.EqualTo("test");
logger.Logs.ElementAt(0).Error.Should().Be.False();
}
public void ShouldLogErrorIfWriteError()
{
var logger = new StringLogger();
var parameters = new Dictionary <string, string>();
PowershellHelpers.ExecuteScript(".", "Write-Error 'test'", logger, parameters);
logger.Logs.Count.Should().Be.EqualTo(1);
logger.Logs.ElementAt(0).Text.Should().Be.EqualTo("test");
logger.Logs.ElementAt(0).Error.Should().Be.True();
}
public void ShouldClearLog()
{
var sut = new StringLogger(LogLevel.Debug, 10);
var e = new Exception("Testing");
sut.LogException("Testing Clear", e, typeof(StartupModuleCompleteTest), LogLevel.Error);
Assert.IsFalse(string.IsNullOrEmpty(sut.ToString()));
sut.LogException("New log", e, typeof(StartupModuleCompleteTest), LogLevel.Error);
Assert.IsFalse(sut.ToString().Contains("Testing Clear"));
Assert.IsTrue(sut.ToString().Contains("New log"));
}
public void ShouldThrowExceptionIfBufferOffsetAndCountIsNotSpecified()
{
byte[] buffer = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var lines = new List <string>();
var logger = new StringLogger(lines)
{
Level = LogLevel.Trace
};
var ex = Record.Exception(() => logger.Trace("message ", buffer));
ex.Should().BeOfType <ArgumentOutOfRangeException>();
}
public void ShouldLogOutputIfWriteOutput()
{
var logger = new StringLogger();
var parameters = new Dictionary <string, string>();
parameters.Add("username", "paolo");
PowershellHelpers.ExecuteScript(".", "Write-Output $username", logger, parameters);
logger.Logs.Count.Should().Be.EqualTo(1);
logger.Logs.ElementAt(0).Text.Should().Be.EqualTo("paolo");
logger.Logs.ElementAt(0).Error.Should().Be.False();
}
public void Run_Platform_Tests()
{
var logger = new StringLogger();
var platformTests = new PlatformTestSuite.PlatformTests(logger);
int failed;
int run;
int passed;
platformTests.RunTests(out run, out passed, out failed);
Assert.AreEqual(0, failed, logger.Log);
}
public static string getDetailedResultsAndSummary(this Summary summary)
{
StringLogger?logger = new StringLogger();
if (summary.HasCriticalValidationErrors)
{
foreach (ValidationError validationError in summary.ValidationErrors)
{
logger.WriteLine(validationError.Message);
}
}
else
{
// extracted from https://github.com/dotnet/BenchmarkDotNet/blob/ceef311bfc73a08a3b07f177f6b9f9782191b794/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs PrintSummary()
CultureInfo?cultureInfo = summary.GetCultureInfo();
// logger.WriteLineHeader("// * Detailed results *");
// BenchmarkReportExporter.Default.ExportToLog(summary, logger);
logger.WriteLineHeader("// * Summary *");
MarkdownExporter.Console.ExportToLog(summary, logger);
ImmutableConfig config = DefaultConfig.Instance.CreateImmutableConfig();
ConclusionHelper.Print(logger, config.GetCompositeAnalyser().Analyse(summary).Distinct().ToList());
/*var columnWithLegends = summary.Table.Columns.Select(c => c.OriginalColumn).Where(c => !string.IsNullOrEmpty(c.Legend)).ToList();
* var effectiveTimeUnit = summary.Table.EffectiveSummaryStyle.TimeUnit;
* if (columnWithLegends.Any() || effectiveTimeUnit != null) {
* logger.WriteLine();
* logger.WriteLineHeader("// * Legends *");
* int maxNameWidth = 0;
* if (columnWithLegends.Any())
* maxNameWidth = Math.Max(maxNameWidth, columnWithLegends.Select(c => c.ColumnName.Length).Max());
* if (effectiveTimeUnit != null)
* maxNameWidth = Math.Max(maxNameWidth, effectiveTimeUnit.Name.ToString(cultureInfo).Length + 2);
*
* foreach (var column in columnWithLegends)
* logger.WriteLineHint($" {column.ColumnName.PadRight(maxNameWidth, ' ')} : {column.Legend}");
*
* if (effectiveTimeUnit != null)
* logger.WriteLineHint($" {("1 " + effectiveTimeUnit.Name).PadRight(maxNameWidth, ' ')} :" +
* $" 1 {effectiveTimeUnit.Description} ({TimeUnit.Convert(1, effectiveTimeUnit, TimeUnit.Second).ToString("0.#########", summary.GetCultureInfo())} sec)");
* }*/
if (config.GetDiagnosers().Any())
{
logger.WriteLine();
config.GetCompositeDiagnoser().DisplayResults(logger);
}
}
return(logger.toString());
}
public void ShouldDefaultToLogLevelInfo()
{
var lines = new List <string>();
var logger = new StringLogger(lines);
logger.Error("You should see this Error");
logger.Info("You should see this Info.");
logger.Debug("You should not see Debug");
logger.Trace("You should not see Trace");
lines.Count.Should().Be(2);
lines[0].Should().StartWith("[Error] => You should see this Error");
lines[1].Should().StartWith("[Info] => You should see this Info");
}
public void SetUp()
{
string folder = Path.GetDirectoryName(Assembly.GetAssembly(typeof(DatabaseMigratorTests)).CodeBase);
MigrationsAssembly = Assembly.LoadFrom(new Uri(Path.Combine(folder, "SampleDbMigrations.dll")).LocalPath);
Settings = new Dictionary <string, string>
{
{ "Server", "." },
{ "Database", "TestDb" }
};
Log = new StringBuilder();
Logger = new StringLogger(Log);
DatabaseMigrator = new DatabaseMigrator(Logger, true, "SqlServer", -1, true);
}
public void ShouldLogAllMessages()
{
byte[] buffer = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
var lines = new List <string>();
var logger = new StringLogger(lines)
{
Level = LogLevel.Trace
};
logger.Debug("message ", buffer, "string after buffer", 10);
lines.Count.Should().Be(1);
lines[0].Should().Be("[Debug] => message [01 02 03 04 05 06 07 08 09 0A, string after buffer, 10]");
}
public HomeControllerDIContainerTest(StringLogger LoggerToUse)
{
Logger = LoggerToUse;
}
public void TestRunPythonCommand() {
var expectedSearchPath = string.Format("['{0}', '{1}']",
TestData.GetPath(@"TestData").Replace("\\", "\\\\"),
TestData.GetPath(@"TestData\HelloWorld").Replace("\\", "\\\\")
);
var proj = new Project(TestData.GetPath(@"TestData\Targets\Commands4.pyproj"));
foreach (var version in PythonPaths.Versions) {
var verStr = version.Version.ToVersion().ToString();
proj.SetProperty("InterpreterId", version.Id.ToString("B"));
proj.SetProperty("InterpreterVersion", verStr);
proj.RemoveItems(proj.ItemsIgnoringCondition.Where(i => i.ItemType == "InterpreterReference").ToArray());
proj.AddItem("InterpreterReference", string.Format("{0:B}\\{1}", version.Id, verStr));
proj.Save();
proj.ReevaluateIfNecessary();
var log = new StringLogger(LoggerVerbosity.Minimal);
Assert.IsTrue(proj.Build("CheckCode", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed), log }));
Console.WriteLine();
Console.WriteLine("Output from {0:B} {1}", version.Id, version.Version.ToVersion());
foreach (var line in log.Lines) {
Console.WriteLine("* {0}", line.TrimEnd('\r', '\n'));
}
var logLines = log.Lines.Last().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
Assert.AreEqual(2, logLines.Length);
Assert.AreEqual(version.Version.ToVersion().ToString(), logLines[0].Trim());
Assert.AreEqual(expectedSearchPath, logLines[1].Trim());
}
}
private static IDictionary<string, TargetResult> BuildTarget(IPythonProject2 project, string target) {
var config = project.GetMSBuildProjectInstance();
if (config == null) {
throw new ArgumentException("Project does not support MSBuild", "project");
}
IDictionary<string, TargetResult> outputs;
var logger = new StringLogger();
#if DEBUG
var loggers = new ILogger[] { new TraceLogger(), logger };
#else
var loggers = new ILogger[] { logger };
#endif
if (!config.Build(new[] { target }, loggers, Enumerable.Empty<ForwardingLoggerRecord>(), out outputs)) {
var outputWindow = OutputWindowRedirector.Get(
project.Site,
VSConstants.OutputWindowPaneGuid.BuildOutputPane_guid,
"Build"
);
outputWindow.WriteErrorLine(Strings.ErrorBuildingCustomCommand.FormatUI(target));
foreach (var line in logger.Lines) {
outputWindow.WriteErrorLine(line.TrimEnd('\r', '\n'));
}
throw new InvalidOperationException(Strings.ErrorBuildingCustomCommand.FormatUI(target));
}
return outputs;
}
public void Run_Platform_Tests()
{
var logger = new StringLogger();
var platformTests = new PlatformTestSuite.PlatformTests(logger);
int failed;
int run;
int passed;
platformTests.RunTests(out run, out passed, out failed);
Assert.AreEqual(0, failed, logger.Log);
}
private static void AssertBuildsProject(Microsoft.Build.Evaluation.Project proj, string target)
{
var logger = new StringLogger();
if(!proj.Build(target, new StringLogger[] { logger }))
Assert.Fail(logger.ToString());
}
