public static void SingleValidMethodArgument()
{
const string name = "Namespace.Class.Method1";
var arguments = new[] { "assemblyName.dll", "-method", name };
var commandLine = TestableCommandLine.Parse(arguments);
Assert.Equal(1, commandLine.Project.Filters.IncludedMethods.Count);
Assert.True(commandLine.Project.Filters.IncludedMethods.Contains(name));
}
public static void MultipleValidTraitArguments_SameName()
{
var arguments = new[] { "assemblyName.dll", "-notrait", "foo=bar", "-notrait", "foo=baz" };
var commandLine = TestableCommandLine.Parse(arguments);
Assert.Equal(1, commandLine.Project.Filters.ExcludedTraits.Count);
Assert.Equal(2, commandLine.Project.Filters.ExcludedTraits["foo"].Count());
Assert.Contains("bar", commandLine.Project.Filters.ExcludedTraits["foo"]);
Assert.Contains("baz", commandLine.Project.Filters.ExcludedTraits["foo"]);
}
public static void ParallelizationOptionsAreNullByDefault()
{
var commandLine = new TestableCommandLine("assemblyName.dll", "no-config.json");
var project = commandLine.Parse();
foreach (var assembly in project.Assemblies)
{
Assert.Null(assembly.Configuration.ParallelizeAssembly);
Assert.Null(assembly.Configuration.ParallelizeTestCollections);
}
}
public static void FailsWithoutOptionOrWithIncorrectOptions()
{
var commandLine1 = TestableCommandLine.Parse("no-config.json", "-parallel");
Assert.IsType <ArgumentException>(commandLine1.ParseFault);
Assert.Equal("missing argument for -parallel", commandLine1.ParseFault.Message);
var commandLine2 = TestableCommandLine.Parse("no-config.json", "-parallel", "nonsense");
Assert.IsType <ArgumentException>(commandLine2.ParseFault);
Assert.Equal("incorrect argument value for -parallel", commandLine2.ParseFault.Message);
}
public static void MultiplierValue(string value)
{
var expected = Environment.ProcessorCount * 2;
var commandLine = new TestableCommandLine("assemblyName.dll", "no-config.json", "-maxthreads", value);
var project = commandLine.Parse();
foreach (var assembly in project.Assemblies)
{
Assert.Equal(expected, assembly.Configuration.MaxParallelThreads);
}
}
public static void TwoConfigFiles_Throws(
string configFile1,
string configFile2)
{
var arguments = new[] { "assemblyName.dll", configFile1, configFile2 };
var commandLine = new TestableCommandLine(arguments);
var exception = Record.Exception(() => commandLine.Parse());
Assert.IsType <ArgumentException>(exception);
Assert.Equal("expecting assembly, got config file: " + configFile2, exception.Message);
}
public void OutputOnNonProjectFile()
{
string[] arguments = new[] { "assemblyName.dll", "/xml", "foo.xml" };
TestableCommandLine commandLine = TestableCommandLine.Parse(arguments);
XunitProjectAssembly assembly = Assert.Single(commandLine.Project.Assemblies);
KeyValuePair <string, string> output = Assert.Single(assembly.Output);
Assert.Equal("xml", output.Key);
Assert.Equal("foo.xml", output.Value);
}
public void MultipleValidTraitArguments_DifferentName()
{
string[] arguments = new[] { "assemblyName.dll", "/-trait", "foo=bar", "/-trait", "baz=biff" };
TestableCommandLine commandLine = TestableCommandLine.Parse(arguments);
Assert.Equal(2, commandLine.Project.Filters.ExcludedTraits.Count);
Assert.Equal(1, commandLine.Project.Filters.ExcludedTraits["foo"].Count());
Assert.Contains("bar", commandLine.Project.Filters.ExcludedTraits["foo"]);
Assert.Equal(1, commandLine.Project.Filters.ExcludedTraits["baz"].Count());
Assert.Contains("biff", commandLine.Project.Filters.ExcludedTraits["baz"]);
}
public static void MultipleValidClassArguments()
{
const string name1 = "Namespace.Class1";
const string name2 = "Namespace.Class2";
var arguments = new[] { "assemblyName.dll", "-class", name1, "-class", name2 };
var commandLine = TestableCommandLine.Parse(arguments);
Assert.Equal(2, commandLine.Project.Filters.IncludedClasses.Count);
Assert.True(commandLine.Project.Filters.IncludedClasses.Contains(name1));
Assert.True(commandLine.Project.Filters.IncludedClasses.Contains(name2));
}
public static void OutputWithFolder()
{
var arguments = new[] { "assemblyName.dll", "-xml", "bar/foo.xml" };
var commandLine = TestableCommandLine.Parse(arguments);
var output = Assert.Single(commandLine.Project.Output);
Assert.Equal("xml", output.Key);
Assert.Equal("bar/foo.xml", output.Value);
Assert.True(Directory.Exists("bar"));
Directory.Delete("bar");
}
public static void ParallelCanBeTurnedOn(
string parallelOption,
bool expectedCollectionsParallelization)
{
var commandLine = new TestableCommandLine("no-config.json", "-parallel", parallelOption);
var project = commandLine.Parse();
foreach (var assembly in project.Assemblies)
{
Assert.Equal(expectedCollectionsParallelization, assembly.Configuration.ParallelizeTestCollections);
}
}
public static void ValidValues(
string value,
int?expected)
{
var commandLine = new TestableCommandLine("no-config.json", "-maxthreads", value);
var project = commandLine.Parse();
foreach (var assembly in project.Assemblies)
{
Assert.Equal(expected, assembly.Configuration.MaxParallelThreads);
}
}
public static void ValidValues(
string value,
AppDomainSupport expected)
{
var commandLine = new TestableCommandLine("assemblyName.dll", "no-config.json", "-appdomains", value);
var project = commandLine.Parse();
foreach (var assembly in project.Assemblies)
{
Assert.Equal(expected, assembly.Configuration.AppDomain);
}
}
public static void FailsWithoutOptionOrWithIncorrectOptions()
{
var commandLine1 = new TestableCommandLine("no-config.json", "-parallel");
var exception1 = Record.Exception(() => commandLine1.Parse());
Assert.IsType <ArgumentException>(exception1);
Assert.Equal("missing argument for -parallel", exception1.Message);
var commandLine2 = new TestableCommandLine("no-config.json", "-parallel", "nonsense");
var exception2 = Record.Exception(() => commandLine2.Parse());
Assert.IsType <ArgumentException>(exception2);
Assert.Equal("incorrect argument value for -parallel", exception2.Message);
}
public void Will_add_environment()
{
var arguments = new[] { "/SettingsFileEnvironment", "somePath\\chutzpah.json;a=1;b=ok" };
var commandLine = TestableCommandLine.Create(arguments);
Assert.Equal(1, commandLine.SettingsFileEnvironments.Count);
var env = commandLine.SettingsFileEnvironments.GetSettingsFileEnvironment("somePath\\chutzpah.json");
Assert.Equal(2, env.Properties.Count);
Assert.Equal("a", env.Properties[0].Name);
Assert.Equal("1", env.Properties[0].Value);
Assert.Equal("b", env.Properties[1].Name);
Assert.Equal("ok", env.Properties[1].Value);
}
public static void DefaultFilters()
{
var commandLine = TestableCommandLine.Parse("no-config.json");
var filters = commandLine.Project.Assemblies.Single().Configuration.Filters;
Assert.Equal(0, filters.IncludedTraits.Count);
Assert.Equal(0, filters.ExcludedTraits.Count);
Assert.Equal(0, filters.IncludedNamespaces.Count);
Assert.Equal(0, filters.ExcludedNamespaces.Count);
Assert.Equal(0, filters.IncludedClasses.Count);
Assert.Equal(0, filters.ExcludedClasses.Count);
Assert.Equal(0, filters.IncludedMethods.Count);
Assert.Equal(0, filters.ExcludedMethods.Count);
}
public static void MultipleAssemblies_NoConfigFiles()
{
var arguments = new[] { "assemblyName.dll", "assemblyName2.dll" };
var result = TestableCommandLine.Parse(arguments);
Assert.Collection(
result.Project,
a =>
{
Assert.Equal("/full/path/assemblyName.dll", a.AssemblyFilename);
Assert.Null(a.ConfigFilename);
},
a =>
{
Assert.Equal("/full/path/assemblyName2.dll", a.AssemblyFilename);
Assert.Null(a.ConfigFilename);
}
);
}
public static void TestUniqueNames()
{
var arguments = new[]
{
"assemblyName.dll",
"-test",
"foo",
"--test",
"bar",
"--test",
"baz",
};
var commandLine = TestableCommandLine.Parse(arguments);
Assert.Equal(3, commandLine.DesignTimeTestUniqueNames.Count);
Assert.Contains("foo", commandLine.DesignTimeTestUniqueNames);
Assert.Contains("bar", commandLine.DesignTimeTestUniqueNames);
Assert.Contains("baz", commandLine.DesignTimeTestUniqueNames);
}
public static void MultipleAssembliesOneWithConfig(string configFile)
{
var arguments = new[] { "assemblyName.dll", "assemblyName2.dll", configFile };
var result = TestableCommandLine.Parse(arguments);
Assert.Collection(
result.Project,
item =>
{
Assert.Equal("/full/path/assemblyName.dll", item.AssemblyFilename);
Assert.Null(item.ConfigFilename);
},
item =>
{
Assert.Equal("/full/path/assemblyName2.dll", item.AssemblyFilename);
Assert.Equal($"/full/path/{configFile}", item.ConfigFilename);
}
);
}
public static void MultipleAssembliesOneWithConfig(string configFile)
{
var arguments = new[] { "assemblyName.dll", "assemblyName2.dll", configFile };
var result = TestableCommandLine.Parse(arguments);
Assert.Collection(result.Project,
a =>
{
Assert.Equal(Path.GetFullPath("assemblyName.dll"), a.AssemblyFilename);
Assert.Null(a.ConfigFilename);
Assert.True(a.ShadowCopy);
},
a =>
{
Assert.Equal(Path.GetFullPath("assemblyName2.dll"), a.AssemblyFilename);
Assert.Equal(Path.GetFullPath(configFile), a.ConfigFilename);
Assert.True(a.ShadowCopy);
}
);
}
public void SetsMaxParallelThreads()
{
var commandLine = TestableCommandLine.Parse("assemblyName.dll", "-maxthreads", "16");
Assert.Equal(16, commandLine.MaxParallelThreads);
}
public void MissingValue()
{
var ex = Assert.Throws <ArgumentException>(() => TestableCommandLine.Parse("assemblyName.dll", "-maxthreads"));
Assert.Equal("missing argument for -maxthreads", ex.Message);
}
public void InvalidValue()
{
var ex = Assert.Throws <ArgumentException>(() => TestableCommandLine.Parse("assemblyName.dll", "-maxthreads", "abc"));
Assert.Equal("incorrect argument value for -maxthreads", ex.Message);
}
public static void ValidValues(string value, int expected)
{
var commandLine = TestableCommandLine.Parse("assemblyName.dll", "-maxthreads", value);
Assert.Equal(expected, commandLine.MaxParallelThreads);
}
public void DefaultValueIsZero()
{
var commandLine = TestableCommandLine.Parse("assemblyName.dll");
Assert.Equal(0, commandLine.MaxParallelThreads);
}
public static void DefaultValueIsNull()
{
var commandLine = TestableCommandLine.Parse("assemblyName.dll");
Assert.Null(commandLine.MaxParallelThreads);
}
public static void DefaultValueIsFalse()
{
var commandLine = TestableCommandLine.Parse("assemblyName.dll");
Assert.False(commandLine.WaitCommand);
}
public void WaitCommandWithPortThrowsArgumentException()
{
var ex = Assert.Throws <ArgumentException>(() => TestableCommandLine.Parse("assemblyName.dll", "-wait-command"));
Assert.Equal("when specifing --wait-command you must also pass a port using --port", ex.Message);
}
public static void ValidValues(string value, int expected)
{
var commandLine = TestableCommandLine.Parse("assemblyName.dll", "-port", value);
Assert.Equal(expected, commandLine.Port);
}
public void NoReporters_UsesDefaultReporter()
{
var commandLine = TestableCommandLine.Parse("assemblyName.dll");
Assert.IsType <DefaultRunnerReporter>(commandLine.Reporter);
}
