public void AppendParameterizedSwitchesTests1()
{
CommandLineSwitches switchesLeft = new CommandLineSwitches();
switchesLeft.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Project, "tempproject.proj", "tempproject.proj", false, true);
Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
Assert.False(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
CommandLineSwitches switchesRight = new CommandLineSwitches();
switchesRight.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Target, "/t:build", "build", true, true);
Assert.False(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
Assert.True(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
switchesLeft.Append(switchesRight);
Assert.Equal("tempproject.proj", switchesLeft.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Project));
Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
string[] parameters = switchesLeft[CommandLineSwitches.ParameterizedSwitch.Project];
Assert.NotNull(parameters);
Assert.Equal(1, parameters.Length);
Assert.Equal("tempproject.proj", parameters[0]);
Assert.Equal("/t:build", switchesLeft.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Target));
Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
parameters = switchesLeft[CommandLineSwitches.ParameterizedSwitch.Target];
Assert.NotNull(parameters);
Assert.Equal(1, parameters.Length);
Assert.Equal("build", parameters[0]);
}
/// <summary>
/// Appends the given collection of command-line switches to this one.
/// </summary>
/// <remarks>
/// Command-line switches have left-to-right precedence i.e. switches on the right override switches on the left. As a
/// result, this "append" operation is also performed in a left-to-right manner -- the switches being appended to are
/// considered to be on the "left", and the switches being appended are on the "right".
/// </remarks>
/// <param name="switchesToAppend"></param>
internal void Append(CommandLineSwitches switchesToAppend)
{
// if this collection doesn't already have an error registered, but the collection being appended does
if (!HaveErrors() && switchesToAppend.HaveErrors())
{
// register the error from the given collection
// NOTE: we always store the first error found (parsing left-to-right), and since this collection is considered to
// be on the "left" of the collection being appended, the error flagged in this collection takes priority over the
// error in the collection being appended
_errorMessage = switchesToAppend._errorMessage;
_badCommandLineArg = switchesToAppend._badCommandLineArg;
_innerException = switchesToAppend._innerException;
_isParameterError = switchesToAppend._isParameterError;
}
// NOTE: we might run into some duplicate switch errors below, but if we've already registered the error from the
// collection being appended, all the duplicate switch errors will be ignored; this is fine because we really have no
// way of telling which error would occur first in the left-to-right order without keeping track of a lot more error
// information -- so we play it safe, and register the guaranteed error
// append the parameterless switches with left-to-right precedence, flagging duplicate switches as necessary
for (int i = 0; i < (int)ParameterlessSwitch.NumberOfParameterlessSwitches; i++)
{
if (switchesToAppend.IsParameterlessSwitchSet((ParameterlessSwitch)i))
{
if (!IsParameterlessSwitchSet((ParameterlessSwitch)i) ||
(s_parameterlessSwitchesMap[i].duplicateSwitchErrorMessage == null))
{
_parameterlessSwitches[i].commandLineArg = switchesToAppend._parameterlessSwitches[i].commandLineArg;
}
else
{
SetSwitchError(s_parameterlessSwitchesMap[i].duplicateSwitchErrorMessage,
switchesToAppend.GetParameterlessSwitchCommandLineArg((ParameterlessSwitch)i));
}
}
}
// append the parameterized switches with left-to-right precedence, flagging duplicate switches as necessary
for (int j = 0; j < (int)ParameterizedSwitch.NumberOfParameterizedSwitches; j++)
{
if (switchesToAppend.IsParameterizedSwitchSet((ParameterizedSwitch)j))
{
if (!IsParameterizedSwitchSet((ParameterizedSwitch)j) ||
(s_parameterizedSwitchesMap[j].duplicateSwitchErrorMessage == null))
{
if (_parameterizedSwitches[j].commandLineArg == null)
{
_parameterizedSwitches[j].parameters = new ArrayList();
}
_parameterizedSwitches[j].commandLineArg = switchesToAppend._parameterizedSwitches[j].commandLineArg;
_parameterizedSwitches[j].parameters.AddRange(switchesToAppend._parameterizedSwitches[j].parameters);
}
else
{
SetSwitchError(s_parameterizedSwitchesMap[j].duplicateSwitchErrorMessage,
switchesToAppend.GetParameterizedSwitchCommandLineArg((ParameterizedSwitch)j));
}
}
}
}
public void SetParameterizedSwitchTests2()
{
CommandLineSwitches switches = new CommandLineSwitches();
// we haven't set this switch yet
Assert.Null(switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Target));
Assert.False(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
string[] parameters = switches[CommandLineSwitches.ParameterizedSwitch.Target];
Assert.NotNull(parameters);
Assert.Equal(0, parameters.Length);
// fake/missing parameters -- this is bogus because the /target switch allows multiple parameters but we're turning
// that off here just for testing purposes
Assert.False(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Target, "/t:\"", "\"", false, true));
// switch has been set
Assert.Equal("/t:\"", switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Target));
Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
parameters = switches[CommandLineSwitches.ParameterizedSwitch.Target];
// but no parameters
Assert.NotNull(parameters);
Assert.Equal(0, parameters.Length);
// more fake/missing parameters
Assert.False(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Target, "/t:A,\"\";B", "A,\"\";B", true, true));
Assert.Equal("/t:\" /t:A,\"\";B", switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Target));
Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
parameters = switches[CommandLineSwitches.ParameterizedSwitch.Target];
// now we have some parameters
Assert.NotNull(parameters);
Assert.Equal(2, parameters.Length);
Assert.Equal("A", parameters[0]);
Assert.Equal("B", parameters[1]);
}
public void SetParameterizedSwitchTests3()
{
CommandLineSwitches switches = new CommandLineSwitches();
// we haven't set this switch yet
Assert.Null(switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Logger));
Assert.False(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Logger));
string[] parameters = switches[CommandLineSwitches.ParameterizedSwitch.Logger];
Assert.NotNull(parameters);
Assert.Equal(0, parameters.Length);
// don't unquote fake/missing parameters
Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Logger, "/l:\"", "\"", false, false));
Assert.Equal("/l:\"", switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Logger));
Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Logger));
parameters = switches[CommandLineSwitches.ParameterizedSwitch.Logger];
Assert.NotNull(parameters);
Assert.Equal(1, parameters.Length);
Assert.Equal("\"", parameters[0]);
// don't unquote multiple fake/missing parameters -- this is bogus because the /logger switch does not take multiple
// parameters, but for testing purposes this is fine
Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Logger, "/LOGGER:\"\",asm;\"p,a;r\"", "\"\",asm;\"p,a;r\"", true, false));
Assert.Equal("/l:\" /LOGGER:\"\",asm;\"p,a;r\"", switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Logger));
Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Logger));
parameters = switches[CommandLineSwitches.ParameterizedSwitch.Logger];
Assert.NotNull(parameters);
Assert.Equal(4, parameters.Length);
Assert.Equal("\"", parameters[0]);
Assert.Equal("\"\"", parameters[1]);
Assert.Equal("asm", parameters[2]);
Assert.Equal("\"p,a;r\"", parameters[3]);
}
public void SetParameterizedSwitchTests1()
{
CommandLineSwitches switches = new CommandLineSwitches();
Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Verbosity, "/v:q", "q", false, true));
Assert.Equal("/v:q", switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Verbosity));
Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Verbosity));
string[] parameters = switches[CommandLineSwitches.ParameterizedSwitch.Verbosity];
Assert.NotNull(parameters);
Assert.Equal(1, parameters.Length);
Assert.Equal("q", parameters[0]);
// set it again -- this is bogus, because the /verbosity switch doesn't allow multiple parameters, but for the
// purposes of testing the SetParameterizedSwitch() method, it doesn't matter
Assert.True(switches.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Verbosity, "/verbosity:\"diag\";minimal", "\"diag\";minimal", true, true));
Assert.Equal("/v:q /verbosity:\"diag\";minimal", switches.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Verbosity));
Assert.True(switches.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Verbosity));
parameters = switches[CommandLineSwitches.ParameterizedSwitch.Verbosity];
Assert.NotNull(parameters);
Assert.Equal(3, parameters.Length);
Assert.Equal("q", parameters[0]);
Assert.Equal("diag", parameters[1]);
Assert.Equal("minimal", parameters[2]);
}
public void AppendParameterizedSwitchesTests3()
{
CommandLineSwitches switchesLeft = new CommandLineSwitches();
switchesLeft.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Project, "tempproject.proj", "tempproject.proj", false, true);
Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
CommandLineSwitches switchesRight = new CommandLineSwitches();
switchesRight.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Project, "Rhubarb.proj", "Rhubarb.proj", false, true);
Assert.True(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
switchesLeft.Append(switchesRight);
Assert.Equal("tempproject.proj", switchesLeft.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Project));
Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Project));
string[] parameters = switchesLeft[CommandLineSwitches.ParameterizedSwitch.Project];
Assert.NotNull(parameters);
Assert.Equal(1, parameters.Length);
Assert.Equal("tempproject.proj", parameters[0]);
Assert.True(switchesLeft.HaveErrors());
VerifySwitchError(switchesLeft, "Rhubarb.proj");
}
public void AppendParameterizedSwitchesTests2()
{
CommandLineSwitches switchesLeft = new CommandLineSwitches();
switchesLeft.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Target, "/target:Clean", "Clean", true, true);
Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
CommandLineSwitches switchesRight = new CommandLineSwitches();
switchesRight.SetParameterizedSwitch(CommandLineSwitches.ParameterizedSwitch.Target, "/t:\"RESOURCES\";build", "\"RESOURCES\";build", true, true);
Assert.True(switchesRight.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
switchesLeft.Append(switchesRight);
Assert.Equal("/t:\"RESOURCES\";build", switchesLeft.GetParameterizedSwitchCommandLineArg(CommandLineSwitches.ParameterizedSwitch.Target));
Assert.True(switchesLeft.IsParameterizedSwitchSet(CommandLineSwitches.ParameterizedSwitch.Target));
string[] parameters = switchesLeft[CommandLineSwitches.ParameterizedSwitch.Target];
Assert.NotNull(parameters);
Assert.Equal(3, parameters.Length);
Assert.Equal("Clean", parameters[0]);
Assert.Equal("RESOURCES", parameters[1]);
Assert.Equal("build", parameters[2]);
}
internal void Append(CommandLineSwitches switchesToAppend)
{
if (!this.HaveErrors() && switchesToAppend.HaveErrors())
{
this.errorMessage = switchesToAppend.errorMessage;
this.badCommandLineArg = switchesToAppend.badCommandLineArg;
this.innerException = switchesToAppend.innerException;
this.isParameterError = switchesToAppend.isParameterError;
}
for (int i = 0; i < 0x13; i++)
{
if (switchesToAppend.IsParameterlessSwitchSet((ParameterlessSwitch)i))
{
if (!this.IsParameterlessSwitchSet((ParameterlessSwitch)i) || (parameterlessSwitchesMap[i].duplicateSwitchErrorMessage == null))
{
this.parameterlessSwitches[i].commandLineArg = switchesToAppend.parameterlessSwitches[i].commandLineArg;
}
else
{
this.SetSwitchError(parameterlessSwitchesMap[i].duplicateSwitchErrorMessage, switchesToAppend.GetParameterlessSwitchCommandLineArg((ParameterlessSwitch)i));
}
}
}
for (int j = 0; j < 0x18; j++)
{
if (switchesToAppend.IsParameterizedSwitchSet((ParameterizedSwitch)j))
{
if (!this.IsParameterizedSwitchSet((ParameterizedSwitch)j) || (parameterizedSwitchesMap[j].duplicateSwitchErrorMessage == null))
{
if (this.parameterizedSwitches[j].commandLineArg == null)
{
this.parameterizedSwitches[j].parameters = new ArrayList();
}
this.parameterizedSwitches[j].commandLineArg = switchesToAppend.parameterizedSwitches[j].commandLineArg;
this.parameterizedSwitches[j].parameters.AddRange(switchesToAppend.parameterizedSwitches[j].parameters);
}
else
{
this.SetSwitchError(parameterizedSwitchesMap[j].duplicateSwitchErrorMessage, switchesToAppend.GetParameterizedSwitchCommandLineArg((ParameterizedSwitch)j));
}
}
}
}
/// <summary>
/// Appends the given collection of command-line switches to this one.
/// </summary>
/// <remarks>
/// Command-line switches have left-to-right precedence i.e. switches on the right override switches on the left. As a
/// result, this "append" operation is also performed in a left-to-right manner -- the switches being appended to are
/// considered to be on the "left", and the switches being appended are on the "right".
/// </remarks>
/// <param name="switchesToAppend"></param>
internal void Append(CommandLineSwitches switchesToAppend)
{
// if this collection doesn't already have an error registered, but the collection being appended does
if (!HaveErrors() && switchesToAppend.HaveErrors())
{
// register the error from the given collection
// NOTE: we always store the first error found (parsing left-to-right), and since this collection is considered to
// be on the "left" of the collection being appended, the error flagged in this collection takes priority over the
// error in the collection being appended
_errorMessage = switchesToAppend._errorMessage;
_badCommandLineArg = switchesToAppend._badCommandLineArg;
_innerException = switchesToAppend._innerException;
_isParameterError = switchesToAppend._isParameterError;
}
// NOTE: we might run into some duplicate switch errors below, but if we've already registered the error from the
// collection being appended, all the duplicate switch errors will be ignored; this is fine because we really have no
// way of telling which error would occur first in the left-to-right order without keeping track of a lot more error
// information -- so we play it safe, and register the guaranteed error
// append the parameterless switches with left-to-right precedence, flagging duplicate switches as necessary
for (int i = 0; i < (int)ParameterlessSwitch.NumberOfParameterlessSwitches; i++)
{
if (switchesToAppend.IsParameterlessSwitchSet((ParameterlessSwitch)i))
{
if (!IsParameterlessSwitchSet((ParameterlessSwitch)i) ||
(s_parameterlessSwitchesMap[i].duplicateSwitchErrorMessage == null))
{
_parameterlessSwitches[i].commandLineArg = switchesToAppend._parameterlessSwitches[i].commandLineArg;
}
else
{
SetSwitchError(s_parameterlessSwitchesMap[i].duplicateSwitchErrorMessage,
switchesToAppend.GetParameterlessSwitchCommandLineArg((ParameterlessSwitch)i));
}
}
}
// append the parameterized switches with left-to-right precedence, flagging duplicate switches as necessary
for (int j = 0; j < (int)ParameterizedSwitch.NumberOfParameterizedSwitches; j++)
{
if (switchesToAppend.IsParameterizedSwitchSet((ParameterizedSwitch)j))
{
if (!IsParameterizedSwitchSet((ParameterizedSwitch)j) ||
(s_parameterizedSwitchesMap[j].duplicateSwitchErrorMessage == null))
{
if (_parameterizedSwitches[j].commandLineArg == null)
{
_parameterizedSwitches[j].parameters = new ArrayList();
}
_parameterizedSwitches[j].commandLineArg = switchesToAppend._parameterizedSwitches[j].commandLineArg;
_parameterizedSwitches[j].parameters.AddRange(switchesToAppend._parameterizedSwitches[j].parameters);
}
else
{
SetSwitchError(s_parameterizedSwitchesMap[j].duplicateSwitchErrorMessage,
switchesToAppend.GetParameterizedSwitchCommandLineArg((ParameterizedSwitch)j));
}
}
}
}