public void AtsignFilenameTests(string commandLine, string testFileNames, string testFileContents, string expectedArgs, string expectedErrors)
{
var ee = expectedErrors.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
var tfn = testFileNames.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
var tfc = testFileContents.Split(new[] { '|' });
var tfs = new TestFile[tfn.Length];
for (int ix = 0; ix < tfn.Length; ++ix)
tfs[ix] = new TestFile(Path.Combine(TestContext.CurrentContext.TestDirectory, tfn[ix]), tfc[ix], true);
var options = new NUnitLiteOptions();
string actualExpectedArgs;
try
{
actualExpectedArgs = String.Join(" ", options.PreParse(CommandLineOptions.GetArgs(commandLine)).ToArray());
}
finally
{
foreach (var tf in tfs)
tf.Dispose();
}
Assert.AreEqual(expectedArgs, actualExpectedArgs);
Assert.AreEqual(options.ErrorMessages, ee);
}
public void CanRecognizeBooleanOptions(string propertyName, string pattern)
{
Console.WriteLine("Testing " + propertyName);
string[] prototypes = pattern.Split('|');
PropertyInfo property = GetPropertyInfo(propertyName);
Assert.AreEqual(typeof(bool), property.PropertyType, "Property '{0}' is wrong type", propertyName);
NUnitLiteOptions options;
foreach (string option in prototypes)
{
if (option.Length == 1)
{
options = new NUnitLiteOptions("-" + option);
Assert.AreEqual(true, (bool)property.GetValue(options, null), "Didn't recognize -" + option);
}
else
{
options = new NUnitLiteOptions("--" + option);
Assert.AreEqual(true, (bool)property.GetValue(options, null), "Didn't recognize --" + option);
}
options = new NUnitLiteOptions("/" + option);
Assert.AreEqual(true, (bool)property.GetValue(options, null), "Didn't recognize /" + option);
}
}
public void CreateTextUI()
{
_reportBuilder = new StringBuilder();
var writer = new ExtendedTextWrapper(new StringWriter(_reportBuilder));
var options = new NUnitLiteOptions();
_textUI = new TextUI(writer, null, options);
}
public void WhenWorkDirectoryIsSpecified_RunSettingsIncludeIt()
{
var options = new NUnitLiteOptions("test.dll", "--work=results");
var settings = TextRunner.MakeRunSettings(options);
Assert.That(settings.ContainsKey("WorkDirectory"));
Assert.AreEqual(Path.GetFullPath("results"), settings["WorkDirectory"]);
}
public void WhenTimeoutIsSpecified_RunSettingsIncludeIt()
{
var options = new NUnitLiteOptions("test.dll", "--timeout=50");
var settings = TextRunner.MakeRunSettings(options);
Assert.That(settings.ContainsKey("DefaultTimeout"));
Assert.AreEqual(50, settings["DefaultTimeout"]);
}
public void WhenSeedIsSpecified_RunSettingsIncludeIt()
{
var options = new NUnitLiteOptions("test.dll", "--seed=1234");
var settings = TextRunner.MakeRunSettings(options);
Assert.That(settings.ContainsKey("RandomSeed"));
Assert.AreEqual(1234, settings["RandomSeed"]);
}
public void WhenWorkersIsSpecified_RunSettingsIncludeIt()
{
var options = new NUnitLiteOptions("test.dll", "--workers=8");
var settings = TextRunner.MakeRunSettings(options);
Assert.That(settings.ContainsKey("NumberOfTestWorkers"));
Assert.AreEqual(8, settings["NumberOfTestWorkers"]);
}
public void CreateTextUI()
{
_reportBuilder = new StringBuilder();
var writer = new ExtendedTextWrapper(new StringWriter(_reportBuilder));
#if !SILVERLIGHT
var options = new NUnitLiteOptions();
_textUI = new TextUI(writer, options);
#else
_textUI = new TextUI(writer);
#endif
}
public void NoResultSuppressesAllResultSpecifications()
{
var options = new NUnitLiteOptions("-result:results.xml", "-noresult", "-result:nunit2results.xml;format=nunit2");
Assert.AreEqual(0, options.ResultOutputSpecifications.Count);
}
public void ExploreOptionWithFilePathUsingEqualSign()
{
var options = new NUnitLiteOptions("tests.dll", "-explore=C:/nunit/tests/bin/Debug/console-test.xml");
Assert.True(options.Validate());
Assert.True(options.Explore);
Assert.AreEqual(1, options.InputFiles.Count, "assembly should be set");
Assert.AreEqual("tests.dll", options.InputFiles[0]);
Assert.AreEqual("C:/nunit/tests/bin/Debug/console-test.xml", options.ExploreOutputSpecifications[0].OutputPath);
}
public void NoResultSuppressesAllResultSpecifications()
{
var options = new NUnitLiteOptions("test.dll", "-result:results.xml", "-noresult", "-result:nunit2results.xml;format=nunit2");
Assert.AreEqual(0, options.ResultOutputSpecifications.Count);
}
public void NoInputFiles()
{
var options = new NUnitLiteOptions();
Assert.True(options.Validate());
Assert.AreEqual(0, options.InputFiles.Count);
}
public void DefaultResultSpecification()
{
var options = new NUnitLiteOptions("test.dll");
Assert.AreEqual(1, options.ResultOutputSpecifications.Count);
var spec = options.ResultOutputSpecifications[0];
Assert.AreEqual("TestResult.xml", spec.OutputPath);
Assert.AreEqual("nunit3", spec.Format);
Assert.Null(spec.Transform);
}
public void ResultOptionWithoutFileNameIsInvalid()
{
var options = new NUnitLiteOptions("tests.dll", "-result:");
Assert.False(options.Validate(), "Should not be valid");
Assert.AreEqual(1, options.ErrorMessages.Count, "An error was expected");
}
public void FileNameWithoutResultOptionLooksLikeParameter()
{
var options = new NUnitLiteOptions("tests.dll", "results.xml");
Assert.True(options.Validate());
Assert.AreEqual(0, options.ErrorMessages.Count);
Assert.AreEqual(2, options.InputFiles.Count);
}
public void TimeoutParsesIntValueCorrectly()
{
var options = new NUnitLiteOptions("tests.dll", "-timeout:5000");
Assert.True(options.Validate());
Assert.AreEqual(5000, options.DefaultTimeout);
}
public void NoResultSuppressesDefaultResultSpecification()
{
var options = new NUnitLiteOptions("-noresult");
Assert.AreEqual(0, options.ResultOutputSpecifications.Count);
}
public void TimeoutCausesErrorIfValueIsNotInteger()
{
var options = new NUnitLiteOptions("tests.dll", "-timeout:abc");
Assert.False(options.Validate());
Assert.AreEqual(-1, options.DefaultTimeout);
}
public void ParameterWithoutEqualSignIsInvalid()
{
var options = new NUnitLiteOptions("--params=X5");
Assert.That(options.ErrorMessages.Count, Is.EqualTo(1));
}
public void ResultOptionWithFilePathAndFormat()
{
var options = new NUnitLiteOptions("tests.dll", "-result:results.xml;format=nunit2");
Assert.True(options.Validate());
Assert.AreEqual(1, options.InputFiles.Count, "assembly should be set");
Assert.AreEqual("tests.dll", options.InputFiles[0]);
OutputSpecification spec = options.ResultOutputSpecifications[0];
Assert.AreEqual("results.xml", spec.OutputPath);
Assert.AreEqual("nunit2", spec.Format);
Assert.Null(spec.Transform);
}
public void CanRecognizeIntOptions(string propertyName, string pattern)
{
string[] prototypes = pattern.Split('|');
PropertyInfo property = GetPropertyInfo(propertyName);
Assert.AreEqual(typeof(int), property.PropertyType);
foreach (string option in prototypes)
{
var options = new NUnitLiteOptions("--" + option + ":42");
Assert.AreEqual(42, (int)property.GetValue(options, null), "Didn't recognize --" + option + ":text");
}
}
public void ResultOptionMayBeRepeated()
{
var options = new NUnitLiteOptions("tests.dll", "-result:results.xml", "-result:nunit2results.xml;format=nunit2", "-result:myresult.xml;transform=mytransform.xslt");
Assert.True(options.Validate(), "Should be valid");
var specs = options.ResultOutputSpecifications;
Assert.AreEqual(3, specs.Count);
var spec1 = specs[0];
Assert.AreEqual("results.xml", spec1.OutputPath);
Assert.AreEqual("nunit3", spec1.Format);
Assert.Null(spec1.Transform);
var spec2 = specs[1];
Assert.AreEqual("nunit2results.xml", spec2.OutputPath);
Assert.AreEqual("nunit2", spec2.Format);
Assert.Null(spec2.Transform);
var spec3 = specs[2];
Assert.AreEqual("myresult.xml", spec3.OutputPath);
Assert.AreEqual("user", spec3.Format);
Assert.AreEqual("mytransform.xslt", spec3.Transform);
}
public void MissingValuesAreReported(string option)
{
var options = new NUnitLiteOptions(option + "=");
Assert.False(options.Validate(), "Missing value should not be valid");
Assert.AreEqual("Missing required value for option '" + option + "'.", options.ErrorMessages[0]);
}
public void NoResultSuppressesDefaultResultSpecification()
{
var options = new NUnitLiteOptions("test.dll", "-noresult");
Assert.AreEqual(0, options.ResultOutputSpecifications.Count);
}
public void AssemblyName()
{
var options = new NUnitLiteOptions("nunit.tests.dll");
Assert.True(options.Validate());
Assert.AreEqual(1, options.InputFiles.Count);
Assert.AreEqual("nunit.tests.dll", options.InputFiles[0]);
}
public void ExploreOptionWithoutPath()
{
var options = new NUnitLiteOptions("tests.dll", "-explore");
Assert.True(options.Validate());
Assert.True(options.Explore);
}
public void AssemblyAloneIsValid()
{
var options = new NUnitLiteOptions("nunit.tests.dll");
Assert.True(options.Validate());
Assert.AreEqual(0, options.ErrorMessages.Count, "command line should be valid");
}
public void ExploreOptionWithFilePathAndTransform()
{
var options = new NUnitLiteOptions("tests.dll", "-explore:results.xml;transform=myreport.xslt");
Assert.True(options.Validate());
Assert.AreEqual(1, options.InputFiles.Count, "assembly should be set");
Assert.AreEqual("tests.dll", options.InputFiles[0]);
Assert.True(options.Explore);
OutputSpecification spec = options.ExploreOutputSpecifications[0];
Assert.AreEqual("results.xml", spec.OutputPath);
Assert.AreEqual("user", spec.Format);
Assert.AreEqual("myreport.xslt", spec.Transform);
}
public void InvalidOption()
{
var options = new NUnitLiteOptions("-asembly:nunit.tests.dll");
Assert.False(options.Validate());
Assert.AreEqual(1, options.ErrorMessages.Count);
Assert.AreEqual("Invalid argument: -asembly:nunit.tests.dll", options.ErrorMessages[0]);
}
public void ShouldSetTeamCityFlagAccordingToArgsAndDefauls(bool hasTeamcityInCmd, bool? defaultTeamcity, bool expectedTeamCity)
{
// Given
List<string> args = new List<string> { "tests.dll" };
if (hasTeamcityInCmd)
{
args.Add("--teamcity");
}
CommandLineOptions options;
if (defaultTeamcity.HasValue)
{
options = new NUnitLiteOptions(new DefaultOptionsProviderStub(defaultTeamcity.Value), args.ToArray());
}
else
{
options = new NUnitLiteOptions(args.ToArray());
}
// When
var actualTeamCity = options.TeamCity;
// Then
Assert.AreEqual(actualTeamCity, expectedTeamCity);
}
public void InvalidCommandLineParms()
{
var options = new NUnitLiteOptions("-garbage:TestFixture", "-assembly:Tests.dll");
Assert.False(options.Validate());
Assert.AreEqual(2, options.ErrorMessages.Count);
Assert.AreEqual("Invalid argument: -garbage:TestFixture", options.ErrorMessages[0]);
Assert.AreEqual("Invalid argument: -assembly:Tests.dll", options.ErrorMessages[1]);
}
public void CanRecognizeStringOptions(string propertyName, string pattern, string[] goodValues, string[] badValues)
{
string[] prototypes = pattern.Split('|');
PropertyInfo property = GetPropertyInfo(propertyName);
Assert.AreEqual(typeof(string), property.PropertyType);
foreach (string option in prototypes)
{
foreach (string value in goodValues)
{
string optionPlusValue = string.Format("--{0}:{1}", option, value);
var options = new NUnitLiteOptions(optionPlusValue);
Assert.True(options.Validate(), "Should be valid: " + optionPlusValue);
Assert.AreEqual(value, (string)property.GetValue(options, null), "Didn't recognize " + optionPlusValue);
}
foreach (string value in badValues)
{
string optionPlusValue = string.Format("--{0}:{1}", option, value);
var options = new NUnitLiteOptions(optionPlusValue);
Assert.False(options.Validate(), "Should not be valid: " + optionPlusValue);
}
}
}
public void TimeoutIsMinusOneIfNoOptionIsProvided()
{
var options = new NUnitLiteOptions("tests.dll");
Assert.True(options.Validate());
Assert.AreEqual(-1, options.DefaultTimeout);
}
