public override void InitializeArguments(IArgsManager argsManager)
{
Arguments.AddRange(CommonArguments.Create("AwesomeLogger", "5501"));
Arguments.AddRange(new List <Argument>
{
new Argument
{
Name = Constants.File,
ShortName = "f",
Description = "The log file.",
Example = "{name}=c:\\logs\\log.txt",
DefaultValue = Assembly.GetExecutingAssembly().Location + ".log",
Action = (value) => { Console.WriteLine(value); }
},
new Argument
{
Name = Constants.AlsoLogOnConsole,
ShortName = "c",
Description = "This will log to both a file and the console window.",
Example = "{name}=true",
DefaultValue = "true",
AllowedValues = CommonAllowedValues.TrueFalse,
Action = (value) => { Console.WriteLine(value); }
},
new ConfigFileArgument(argsManager) // This is a special Argument type to allow for args in a file
});
Arguments.RemoveAt(3); // Remove common logger endpoint as this is logger
}
public DotnetNewCommand(ITestOutputHelper log, params string[] args) : base(log)
{
// Set dotnet-new3.dll as first Argument to be passed to "dotnet"
// And use full path since we want to execute in any working directory
Arguments.Add(Path.GetFullPath("dotnet-new3.dll"));
Arguments.AddRange(args);
}
/// <summary>
/// Creates a command line arguments definition and infers things like Arguments, Actions, etc. from the type's metadata.
/// </summary>
/// <param name="t">The argument scaffold type used to infer the definition</param>
public CommandLineArgumentsDefinition(Type t) : this()
{
ArgumentScaffoldType = t;
Arguments.AddRange(FindCommandLineArguments(t));
Actions.AddRange(FindCommandLineActions(t));
Metadata.AddRange(t.Attrs <IArgMetadata>().AssertAreAllInstanceOf <ICommandLineArgumentsDefinitionMetadata>());
}
public XilinxProcess(string tool, string workingDirectory, List <string> arguments)
: this(tool, workingDirectory)
{
if (arguments != null)
{
Arguments.AddRange(arguments);
}
}
/// <summary>
/// Creates a command line arguments definition and infers things like Arguments, Actions, etc. from the type's metadata.
/// </summary>
/// <param name="t">The argument scaffold type used to infer the definition</param>
public CommandLineArgumentsDefinition(Type t) : this()
{
ArgumentScaffoldType = t;
ExceptionBehavior = t.HasAttr <ArgExceptionBehavior>() ? t.Attr <ArgExceptionBehavior>() : new ArgExceptionBehavior();
Arguments.AddRange(FindCommandLineArguments(t));
Actions.AddRange(FindCommandLineActions(t));
Metadata.AddRange(t.Attrs <IArgMetadata>().AssertAreAllInstanceOf <ICommandLineArgumentsDefinitionMetadata>());
}
public CodeObjectCreateExpression(CodeTypeReference createType, IEnumerable <CodeExpression> arguments)
{
Ensure.That(nameof(createType)).IsNotNull(createType);
Ensure.That(nameof(arguments)).IsNotNull(arguments);
CreateType = createType;
Arguments.AddRange(arguments);
}
public FunctionCall(SourcePosition pos, string fn = null, IEnumerable <FunctionArgument> args = null) : base(pos)
{
Function = fn;
if (args != null)
{
Arguments.AddRange(args);
}
}
public CodeMethodInvokeExpression(CodeMethodReferenceExpression method, IEnumerable <CodeExpression> arguments)
{
Ensure.That(nameof(method)).IsNotNull(method);
Ensure.That(nameof(arguments)).IsNotNull(arguments);
Method = method;
Arguments.AddRange(arguments);
}
public CodeAttributeDeclaration(CodeTypeReference attributeType, params CodeAttributeArgument [] arguments)
{
attribute = attributeType;
if (attributeType != null)
{
name = attributeType.BaseType;
}
Arguments.AddRange(arguments);
}
/// <summary>
/// Override the arguments.
/// </summary>
/// <returns>this</returns>
public AstExpression SetArguments(params AstExpression[] arguments)
{
Arguments.Clear();
if (arguments != null)
{
Arguments.AddRange(arguments);
}
return(this);
}
private FFMpegArguments WithInput(IInputArgument inputArgument, Action <FFMpegArgumentOptions>?addArguments)
{
var arguments = new FFMpegArgumentOptions();
addArguments?.Invoke(arguments);
Arguments.AddRange(arguments.Arguments);
Arguments.Add(inputArgument);
return(this);
}
public Attribute(string name, params ValueTuple <string, object>[] arguments)
{
Name = name;
if (arguments != null)
{
Arguments.AddRange(arguments);
}
}
public RunSettings AddRange(IEnumerable <string> arguments)
{
if (arguments is null)
{
throw new ArgumentNullException(nameof(arguments));
}
Arguments.AddRange(arguments);
return(this);
}
/// <summary>
/// Override the arguments.
/// </summary>
/// <returns>this</returns>
public AstExpression SetArguments(IEnumerable <AstExpression> arguments)
{
Arguments.Clear();
if (arguments != null)
{
Arguments.AddRange(arguments);
}
return(this);
}
private FFMpegArgumentProcessor ToProcessor(IOutputArgument argument, Action <FFMpegArgumentOptions>?addArguments)
{
var args = new FFMpegArgumentOptions();
addArguments?.Invoke(args);
Arguments.AddRange(args.Arguments);
Arguments.Add(argument);
return(new FFMpegArgumentProcessor(this));
}
public RunExeCommand(ITestOutputHelper log, string commandPath, params string[] args) : base(log)
{
if (!File.Exists(commandPath))
{
throw new ArgumentException($"Cannot find command {commandPath}");
}
_commandPath = commandPath;
Arguments.AddRange(args);
}
private void ReorderConjunctionParts()
{
for (var i = 0; i < Arguments.Count; i++)
{
var argument = Arguments[i];
if (argument is Conjunction conj)
{
Arguments.RemoveAt(i--);
Arguments.AddRange(conj.Arguments);
}
}
}
public RunSettings AddRangeIf(bool condition, IEnumerable <string> arguments)
{
if (arguments is null)
{
throw new ArgumentNullException(nameof(arguments));
}
if (condition)
{
Arguments.AddRange(arguments);
}
return(this);
}
public CodeObjectCreateExpression(CodeTypeReference createType, IEnumerable <CodeExpression> arguments, IEnumerable <IEnumerable <CodeExpression> > collectionInitializerItems)
{
Ensure.That(nameof(createType)).IsNotNull(createType);
Ensure.That(nameof(arguments)).IsNotNull(arguments);
Ensure.That(nameof(collectionInitializerItems)).IsNotNull(collectionInitializerItems);
CreateType = createType;
Arguments.AddRange(arguments);
foreach (var collectionInitializerItem in collectionInitializerItems)
{
CollectionInitializerItems.Add(new List <CodeExpression>(collectionInitializerItem));
}
}
public override void InitializeArguments(IArgsManager argsManager)
{
Arguments.AddRange(CommonArguments.Create("HealthDistrict", "5552"));
Arguments.AddRange(new List <Argument>
{
new Argument
{
Name = Constants.PublisherEndpoints,
ShortName = "p",
Description = "A comma separated array of endpoints for the publishers.",
Example = "{name}=tcp://127.0.0.1:5553,tcp://127.0.0.1:5554",
DefaultValue = "tcp://127.0.0.1:5553,tcp://127.0.0.1:5554",
Action = (value) => { Console.WriteLine(value); }
}
});
}
public override void InitializeArguments(IArgsManager argsManager)
{
Arguments.AddRange(CommonArguments.Create("NameServer", "6001"));
Arguments.AddRange(new List <Argument>
{
// Add more args here
new Argument
{
Name = "UseLocalHost",
ShortName = "ulh",
Description = "Use localhost, 127.0.0.1 for all registrations.",
Example = "{name}=true",
DefaultValue = "false",
AllowedValues = CommonAllowedValues.TrueFalse
},
new ConfigFileArgument(argsManager) // This is a special Argument type to allow for args in a file
});
Arguments.RemoveAt(2); // Remove common NameServer endpoint from comon as this is Name Server, so Enpoint is used.
}
public virtual void AcceptArguments(params IExpression[] arguments)
{
if (Arguments.Count > 0 && ExpectedArgumentCount > 0)
{
throw new ArgumentException(
"AcceptArguments has already been called for this function. AcceptArguments can only be called once.");
}
if (arguments != null)
{
if (ExpectedArgumentCount != UnlimitedArguments && arguments.Length != ExpectedArgumentCount)
{
throw new ArgumentException(GetType().Name + " expects " + ExpectedArgumentCount +
" but was provided with " + arguments.Length + " arguments.");
}
Arguments.AddRange(arguments);
}
}
public override void InitializeArguments(IArgsManager argsManager)
{
Arguments.AddRange(CommonArguments.Create("OutbreakAnalyzer", "5555"));
Arguments.AddRange(new List <Argument>
{
new Argument
{
Name = Constants.PublisherName,
ShortName = "pn",
Description = "The name of the publisher server.",
Example = "{name}=Publisher1",
DefaultValue = "Publisher1",
Action = (value) => { Console.WriteLine(value); }
},
new Argument
{
Name = Constants.PublisherEndpoint,
ShortName = "p",
Description = "The endpoint for the server service.",
Example = "{name}=tcp://127.0.0.1:5556",
DefaultValue = "tcp://127.0.0.1:5556",
Action = (value) => { Console.WriteLine(value); }
},
new Argument
{
Name = Constants.Disease,
ShortName = "d",
Description = "The disease this service analyzes.",
DefaultValue = "Influenza",
Example = "{name}=Influenza"
},
new Argument
{
Name = Constants.Threshold,
ShortName = "t",
Description = "The number of diseases per day that indicate an outbreak.",
DefaultValue = "200",
Example = "{name}=200"
}
});
}
/// <summary>
/// Parse command-line arguments
/// </summary>
/// <param name="args">Command-line arguments</param>
public void Parse(string[] args)
{
for (int i = 0; i < args.Length; i++)
{
if (args[i].StartsWith("--"))
{
if (args[i].Length == 2)
{
Arguments.AddRange(args.Skip(i));
return;
}
i = ParseLongOption(args, i);
}
else if (args[i].StartsWith("-") && args[i].Length > 1)
{
i = ParseShortOption(args, i);
}
else
{
Arguments.Add(args[i]);
}
}
}
public MetadataAttribute(string name, params string[] arguments)
{
Name = name;
Arguments.AddRange(arguments);
}
public DotnetCommand(ITestOutputHelper log, string commandName, params string[] args) : base(log)
{
Arguments.Add(commandName);
Arguments.AddRange(args);
this.commandName = commandName;
}
public CodeAttributeDeclaration(string name, params CodeAttributeArgument [] arguments)
{
this.Name = name;
Arguments.AddRange(arguments);
}
public override void InitializeArguments(IArgsManager argsManager)
{
Arguments.AddRange(CommonArguments.Create("Simulator", "5552"));
Arguments.AddRange(new List <Argument>
{
new Argument
{
Name = Constants.TimeMultiplier,
ShortName = "t",
Description = "This is how long 1 second simulates. For example: 3600 simulates 1 hour every second.",
DefaultValue = "3600",
Example = "{name}=3600",
CustomValidation = (val) =>
{
return(Regex.IsMatch(val, CommonAllowedValues.Digits));
}
},
new Argument
{
Name = Constants.Duration,
ShortName = "u",
Description = "The length of time in days the simulation runs. Max time simulation is 9999 days.",
DefaultValue = "31",
Example = "{name}=31",
CustomValidation = (val) =>
{
return(Regex.IsMatch(val, "[1-9][0-9]{0,4}"));
}
},
new Argument
{
Name = Constants.Year,
ShortName = "y",
Description = "The year the simulation starts.",
DefaultValue = "2018",
Example = "{name}=2018",
CustomValidation = (val) =>
{
return(Regex.IsMatch(val, "[1-9][0-9]{3}"));
}
},
new Argument
{
Name = Constants.Month,
ShortName = "m",
Description = "The month the simulation starts.",
DefaultValue = "01",
Example = "{name}=01",
CustomValidation = (val) =>
{
return(Regex.IsMatch(val, "[0]?[1-9]|[1][0-2]"));
}
},
new Argument
{
Name = Constants.Day,
ShortName = "d",
Description = "The day the simulation starts.",
DefaultValue = "01",
Example = "{name}=01",
CustomValidation = (val) =>
{
return(Regex.IsMatch(val, "[0]?[1-9]|[1-2][0-9]|[3][0-1]"));
}
},
new ConfigFileArgument(argsManager)
});
}
public CodeBracedInitializerExpression(IEnumerable <CodeExpression> arguments)
{
Ensure.That(nameof(arguments)).IsNotNull(arguments);
Arguments.AddRange(arguments);
}
public BasicCommand(ITestOutputHelper log, string processName, params string[] args) : base(log)
{
_processName = processName;
Arguments.AddRange(args.Where(a => !string.IsNullOrWhiteSpace(a)));
}
