public void ExtractsHideSkipped_DefaultsToAll()
{
// arrange
var parser = new CommandLineParser(new[] { "-hideskipped", RequiredArgs });
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(5, parser.HideSkipped.Distinct().Count());
}
public void HandlesReturnTargetCodeArgument()
{
// arrange
var parser = new CommandLineParser(new[] { "-returntargetcode", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.ReturnTargetCode);
}
public void HandlesNoDefaultFiltersArgument()
{
// arrange
var parser = new CommandLineParser(new[]{"-nodefaultfilters" , RequiredArgs});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.NoDefaultFilters);
}
public void HandlesMergeByHashArgument()
{
// arrange
var parser = new CommandLineParser(new[] { "-mergebyhash", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.MergeByHash);
}
public void HandlesFilterArgument()
{
// arrange
var parser = new CommandLineParser(new[]{"-filter:XYZ ABC", RequiredArgs});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(2, parser.Filters.Count);
}
public void DetectsServiceArgument()
{
// arrange
var parser = new CommandLineParser(new[] { "-service", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.Service);
}
public void Detects_EnablePerformanceCounters_Argument()
{
// arrange
var parser = new CommandLineParser(new[] { "-enableperformancecounters", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.EnablePerformanceCounters);
}
public void DetectsOldStyleArgument()
{
// arrange
var parser = new CommandLineParser(new[] { "-oldstyle", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.OldStyleInstrumentation);
}
public void HandlesTheRegisterArgumentWithUserValue()
{
// arrange
var parser = new CommandLineParser(new[]{"-register:User" , RequiredArgs});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.Register);
Assert.AreEqual(Registration.User, parser.Registration);
}
public void HandlesExcludeByAttributeArgument_WithMultipleValues()
{
// arrange
var parser = new CommandLineParser(new[] { "-excludebyattribute:wibble;wobble;woop", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(3, parser.AttributeExclusionFilters.Count);
Assert.AreEqual("wibble", parser.AttributeExclusionFilters[0]);
Assert.AreEqual("wobble", parser.AttributeExclusionFilters[1]);
Assert.AreEqual("woop", parser.AttributeExclusionFilters[2]);
}
public void HandlesCoverByTestArgument_WithMultipleValues()
{
// arrange
var parser = new CommandLineParser(new[] { "-coverbytest:wibble;wobble;woop", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(3, parser.TestFilters.Count);
Assert.AreEqual("wibble", parser.TestFilters[0]);
Assert.AreEqual("wobble", parser.TestFilters[1]);
Assert.AreEqual("woop", parser.TestFilters[2]);
}
public void ExtractsHideSkipped_Handles_Multiple_Arg()
{
// arrange
var parser = new CommandLineParser(new[] { "-hideskipped:File;Filter;MissingPdb;Attribute", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(4, parser.HideSkipped.Distinct().Count());
Assert.AreEqual(SkippedMethod.File, parser.HideSkipped[0]);
Assert.AreEqual(SkippedMethod.Filter, parser.HideSkipped[1]);
Assert.AreEqual(SkippedMethod.MissingPdb, parser.HideSkipped[2]);
Assert.AreEqual(SkippedMethod.Attribute, parser.HideSkipped[3]);
}
public void HandlesTheOutputArgumentWithSuppliedValueWithMultipleTimes()
{
// arrange
var parser = new CommandLineParser(new[] { "-output:ZYX", "-output:XYZ", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual("ZYX XYZ", parser.OutputFile);
}
public void HandlesShowUnvisitedArgument()
{
// arrange
var parser = new CommandLineParser(new[] { "-showunvisited", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.ShowUnvisited);
}
public void HandlesReturnTargetCodeArgument_WithValue()
{
// arrange
var parser = new CommandLineParser(new[] { "-returntargetcode:100", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.ReturnTargetCode);
Assert.AreEqual(100, parser.ReturnCodeOffset);
}
public void HandlesTheRegisterArgument()
{
// arrange
var parser = new CommandLineParser(new[]{"-register" , RequiredArgs});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.Register);
Assert.IsFalse(parser.UserRegistration);
}
public void HandlesTheUsageArgument()
{
// arrange
var parser = new CommandLineParser(new[]{"-?"});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(true, parser.PrintUsage);
Assert.IsFalse(string.IsNullOrWhiteSpace(parser.Usage()));
}
public void HandlesFilterArgumentWithMultipleTimes()
{
// arrange
var parser = new CommandLineParser(new[] { "-filter:+[XYZ]ABC", "-filter:-[XYZ]ABC*", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(2, parser.Filters.Count);
Assert.AreEqual("+[XYZ]ABC", parser.Filters[0]);
Assert.AreEqual("-[XYZ]ABC*", parser.Filters[1]);
}
public void HandlesVersionArgument()
{
// arrange
var parser = new CommandLineParser(new[] {"-version"});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.PrintVersion);
}
public void Extracts_SkipAutoImplementedProperties()
{
// arrange
var parser = new CommandLineParser(new[] { "-skipautoprops", RequiredArgs });
parser.ExtractAndValidateArguments();
// assert
Assert.IsTrue(parser.SkipAutoImplementedProperties);
}
public void ExtractsHideSkipped_Merges_FileFile()
{
// arrange
var parser = new CommandLineParser(new[] { "-hideskipped:File;File", RequiredArgs });
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(1, parser.HideSkipped.Distinct().Count());
}
public void ExtractsHideSkipped_Handles_Single_Arg()
{
// arrange
var parser = new CommandLineParser(new[] { "-hideskipped:File", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(1, parser.HideSkipped.Count);
Assert.AreEqual(SkippedMethod.File, parser.HideSkipped[0]);
}
public void HandlesTheTargetArgsArgumentWithSuppliedValueWithMultipleTimes()
{
// arrange
var parser = new CommandLineParser(new[] { "-targetargs:XXX", "-targetargs:YYY", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual("XXX YYY", parser.TargetArgs);
}
public void HandlesFilterFileArgumentsWithEmptyArgument()
{
// arrange
var parser = new CommandLineParser(new[] { "-filterfile:XYZABC.LOG", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual("XYZABC.LOG", parser.FilterFile);
}
public void HandlesTheTargetDirArgumentWithSuppliedValue()
{
// arrange
var parser = new CommandLineParser(new[]{"-targetdir:XXX" , RequiredArgs});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual("XXX", parser.TargetDir);
}
public void HandlesLogArgument_ValidValue()
{
// arrange
var parser = new CommandLineParser(new[] {"-log:info", RequiredArgs});
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(parser.LogLevel, Level.Info);
}
public void HandlesThresholdArgument_WithValue()
{
// arrange
var parser = new CommandLineParser(new[] { "-threshold:127", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(127, parser.Threshold);
}
private static bool ParseCommandLine(string[] args, out CommandLineParser parser)
{
try
{
parser = new CommandLineParser(args);
}
catch (Exception)
{
throw new InvalidOperationException(
"An error occurred whilst parsing the command line; try -? for command line arguments.");
}
try
{
parser.ExtractAndValidateArguments();
if (parser.PrintUsage)
{
System.Console.WriteLine(parser.Usage());
return false;
}
if (!string.IsNullOrWhiteSpace(parser.TargetDir) && !Directory.Exists(parser.TargetDir))
{
System.Console.WriteLine("TargetDir '{0}' cannot be found - have you specified your arguments correctly?", parser.TargetDir);
return false;
}
if (parser.Service)
{
try
{
var service = new ServiceController(parser.Target);
var name = service.DisplayName;
}
catch (Exception)
{
System.Console.WriteLine("Service '{0}' cannot be found - have you specified your arguments correctly?", parser.Target);
return false;
}
}
else if (!File.Exists(Environment.ExpandEnvironmentVariables(parser.Target)))
{
System.Console.WriteLine("Target '{0}' cannot be found - have you specified your arguments correctly?", parser.Target);
return false;
}
}
catch (Exception ex)
{
System.Console.WriteLine("Incorrect Arguments: {0}", ex.Message);
System.Console.WriteLine(parser.Usage());
return false;
}
return true;
}
private static bool ParseCommandLine(string[] args, out CommandLineParser parser)
{
try
{
parser = new CommandLineParser(args);
}
catch (Exception)
{
throw new InvalidOperationException(
"An error occurred whilst parsing the command line; try /? for command line arguments.");
}
try
{
parser.ExtractAndValidateArguments();
if (parser.PrintUsage)
{
System.Console.WriteLine(parser.Usage());
return true;
}
if (!File.Exists(Environment.ExpandEnvironmentVariables(parser.Target)))
{
System.Console.WriteLine("Target {0} cannot be found - have you specified your arguments correctly?");
return true;
}
}
catch (Exception ex)
{
System.Console.WriteLine("Incorrect Arguments: {0}", ex.Message);
System.Console.WriteLine(parser.Usage());
return true;
}
return false;
}
public void HandlesExcludeByFileArgument_WithValue()
{
// arrange
var parser = new CommandLineParser(new[] { "-excludebyfile:wibble", RequiredArgs });
// act
parser.ExtractAndValidateArguments();
// assert
Assert.AreEqual(1, parser.FileExclusionFilters.Count);
Assert.AreEqual("wibble", parser.FileExclusionFilters[0]);
}