public static void AddKeys()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("added two keys", () =>
{
var condition = true;
string[] keys = null;
Act(() =>
{
result = builder.AddKeys(keys, condition);
});
And("a condition is true", () =>
{
condition = true;
And("keys are provided", () =>
{
keys = new[] { "key1", "key2" };
Should("provide the provided keys", () =>
{
Assert.That(result, Is.EqualTo("-key1 -key2"));
});
});
And("keys is null", () =>
{
keys = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
public async Task <RegistratedUser> GetById(int Id)
{
var args = new ArgsBuilder()
.Add(nameof(Id), Id.ToString())
.Build();
var result = await _webApi.Query <RegistratedUser>(Defines.UserServices.GetUserByIdUrl, args);
return(result.Responce);
}
public async Task <Bet> GetById(int id)
{
var args = new ArgsBuilder()
.Add(nameof(id), id.ToString())
.Build();
var result = await _webApi.Query <Bet>(Defines.BetService.GetBetById, args);
return(result.Responce);
}
public async Task <JustResult> Delete(int id)
{
var args = new ArgsBuilder()
.Add(nameof(id), id.ToString())
.Build();
var result = await _webApi.Query <JustResult>(Defines.EventServices.CreateEvent, args);
return(result.Responce);
}
public async Task <RegistratedUser> SignIn(string login, string password)
{
var args = new ArgsBuilder()
.Add(nameof(login), login)
.Add(nameof(password), password)
.Build();
var result = await _webApi.Query <RegistratedUser>(Defines.UserServices.SignInUserUrl, args);
return(result.Responce);
}
public async Task <EventInfo> Create(CreatingEventInfo ev)
{
var args = new ArgsBuilder()
.Add(nameof(ev.Name), ev.Name)
.Add(nameof(ev.DataTime), ev.DataTime.ToString())
.Add(nameof(ev.Teams), _serializer.Serialize(ev.Teams))
.Build();
var result = await _webApi.Query <EventInfo>(Defines.EventServices.CreateEvent, args);
return(result.Responce);
}
/// <summary>
/// Implements Class#allocate feature.
/// </summary>
public void BuildObjectAllocation(MetaObjectBuilder /*!*/ metaBuilder, CallArguments /*!*/ args, string /*!*/ methodName)
{
// check for empty arguments (handles splat correctly):
var argsBuilder = new ArgsBuilder(0, 0, 0, false);
argsBuilder.AddCallArguments(metaBuilder, args);
if (!metaBuilder.Error)
{
metaBuilder.Result = MakeAllocatorCall(args, () => Ast.Constant(Name));
}
}
public async Task <MakeBetResult> MakeBet(int userId, int betResultId, int summa)
{
var args = new ArgsBuilder()
.Add(nameof(userId), userId.ToString())
.Add(nameof(betResultId), betResultId.ToString())
.Add(nameof(summa), summa.ToString())
.Build();
var result = await _webApi.Query <MakeBetResult>(Defines.BetService.MakeBet, args);
return(result.Responce);
}
public static void AddPaths1()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("added paths", () =>
{
var condition = true;
var paths = new[] { "path1", "path2" };
Act(() =>
{
result = builder.AddPaths(paths, condition);
});
And("a condition is true", () =>
{
condition = true;
Should("provide the paths", () =>
{
Assert.That(result, Is.EqualTo("\"path1\" \"path2\""));
});
And("the paths is null", () =>
{
paths = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
public async Task <RegistratedUser> SignUp(RegisterInfoUser user)
{
var args = new ArgsBuilder()
.Add(nameof(user.Login), user.Login)
.Add(nameof(user.Password), user.Login)
.Add(nameof(user.Name), user.Login)
.Add(nameof(user.Age), user.Age.ToString())
.Add(nameof(user.Score), user.Age.ToString())
.Build();
var result = await _webApi.Query <RegistratedUser>(Defines.UserServices.SignUpUserUrl, args);
return(result.Responce);
}
private void UpdateComplete(bool update)
{
if (!update)
{
return;
}
ServicePointManager.ServerCertificateValidationCallback =
(sender, cert, chain, sslPolicyErrors) => true;//ignore ssl Certificate
//Current process file address
string cur_process = Process.GetCurrentProcess().MainModule.FileName;
//Get uri bind Download information Server address
Uri uri = new Uri(Server);
//Parameter for passing to DownloadForm
ArgsBuilder args = new ArgsBuilder();
//For start process application information
ProcessStartInfo pInfo = new ProcessStartInfo(DownLoadFormPath);
//Parameter[0] = DownLoadInfoPath
args.Add(DownLoadInfoPath);
//Parameter[1] = current process name
args.Add(Path.GetFileName(cur_process));
pInfo.Arguments = args.ToString();
if (!Directory.Exists(Path.GetDirectoryName(DownLoadInfoPath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(DownLoadInfoPath));
}
try
{
XmlDocument doc = new XmlDocument();
doc.Load(uri.AbsoluteUri);
doc.Save(DownLoadInfoPath);
using (Process p = new Process())
{
p.StartInfo = pInfo;
p.Start();
}
Application.Exit();
}
catch
{
MessageBox.Show("網路異常");
}
}
public static RuleGenerator /*!*/ GetException()
{
return(new RuleGenerator((metaBuilder, args, name) => {
Debug.Assert(args.Target is Exception);
// 1 optional parameter (exceptionArg):
var argsBuilder = new ArgsBuilder(0, 0, 1, false);
argsBuilder.AddCallArguments(metaBuilder, args);
if (!metaBuilder.Error)
{
if (argsBuilder.ExplicitArgumentCount == 0)
{
metaBuilder.Result = args.TargetExpression;
}
else
{
RubyClass cls = args.RubyContext.GetClassOf(args.Target);
var classExpression = AstUtils.Constant(cls);
args.SetTarget(classExpression, cls);
ParameterExpression messageVariable = null;
// RubyOps.MarkException(new <exception-type>(GetClrMessage(<class>, #message = <message>)))
if (cls.BuildAllocatorCall(metaBuilder, args, () =>
Ast.Call(null, new Func <RubyClass, object, string>(GetClrMessage).Method,
classExpression,
Ast.Assign(messageVariable = metaBuilder.GetTemporary(typeof(object), "#message"), AstUtils.Box(argsBuilder[0]))
)
))
{
// ReinitializeException(<result>, #message)
metaBuilder.Result = Ast.Call(null, new Func <RubyContext, Exception, object, Exception>(ReinitializeException).Method,
AstUtils.Convert(args.MetaContext.Expression, typeof(RubyContext)),
metaBuilder.Result,
messageVariable ?? AstUtils.Box(argsBuilder[0])
);
}
else
{
metaBuilder.SetError(Methods.MakeAllocatorUndefinedError.OpCall(Ast.Convert(args.TargetExpression, typeof(RubyClass))));
}
}
}
}));
}
public void TestPlanExecution()
{
const string path = @"%jmeter%\bin\jmeter.bat";
var argsBuilder = new ArgsBuilder()
.NonGui()
.LogTo(@"LoopTestPlan.jtl")
.WithTestPlan(@"LoopTestPlan.jmx")
.WithFailedAssersionReport();
var jmeterRunner = new JmeterRunner(path,argsBuilder);
jmeterRunner.Start();
var logPath = @"LoopTestPlan.jtl";
jmeterRunner.CreateSummaryReport(PluginTypeCsv.AggregateReport, @"LoopTestPlan.csv", logPath);
var errorsRate = jmeterRunner.GetErrorsRate(logPath);
Assert.AreEqual(errorsRate, 83.33d);
var totalDuration = jmeterRunner.GetTotalDuration(logPath);
Assert.AreNotEqual(totalDuration,0);
}
public static void By()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=", ";", "\"", " ");
});
When("added two paths and a key with a value", () =>
{
var condition = true;
Act(() =>
{
result = builder
.AddPaths("key1", new[] { "path1", "path2" }, false, condition)
.AddArgument("key2", "value2", condition)
.ToString();
});
And("a condition is true", () =>
{
condition = true;
Should("provide arguments with provided paths and the key with the value", () =>
{
Assert.That(result, Is.EqualTo("-key1=\"path1\";\"path2\" -key2=value2"));
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
public static void ToString1()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("the builder is empty", () =>
{
Act(() =>
{
builder.ToString();
builder.ToString();
result = builder.ToString();
});
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
And("a value is added", () =>
{
Act(() =>
{
builder.AddValue("value1");
builder.ToString();
builder.ToString();
result = builder.ToString();
});
Should("provide the added value", () =>
{
Assert.That(result, Is.EqualTo("value1"));
});
});
});
}
public static void OperatorString()
{
ArgsBuilder builder = null;
string result = null;
When("the builder is null", () =>
{
Act(() =>
{
builder = null;
result = builder;
});
Should("provide null", () =>
{
Assert.That(result, Is.Null);
});
And("the builder is not null and a value is added", () =>
{
Act(() =>
{
builder = ArgsBuilder.By("-", "=");
builder.AddValue("value1");
result = builder;
});
Should("provide the added value", () =>
{
Assert.That(result, Is.EqualTo("value1"));
});
});
});
}
public static void AddValue()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("added a value", () =>
{
var condition = true;
string value = null;
Act(() =>
{
result = builder.AddValue(value, condition);
});
And("a condition is true", () =>
{
condition = true;
And("the value is provided", () =>
{
value = "value1";
Should("provide the provided value", () =>
{
Assert.That(result, Is.EqualTo(value));
});
});
And("the value is an empty string", () =>
{
value = string.Empty;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
And("the value is null", () =>
{
value = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
static void Main(string[] args)
{
Options options = ArgsBuilder.Build <Options>(args);
Console.ReadLine();
}
public static void AddValues()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("added two values", () =>
{
var condition = true;
string[] values = null;
Act(() =>
{
result = builder.AddValues(values, condition);
});
And("a condition is true", () =>
{
condition = true;
And("the values has null value", () =>
{
values = new[] { "value1", null };
Should("provide only non-null values", () =>
{
Assert.That(result, Is.EqualTo("value1"));
});
});
And("values are provided", () =>
{
values = new[] { "value1", "value2" };
Should("provide arguments with the provided values", () =>
{
Assert.That(result, Is.EqualTo("value1 value2"));
});
});
And("values is null", () =>
{
values = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
public static void AddArguments()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("added arguments", () =>
{
var condition = true;
string key = null;
string[] values = null;
var multipleTimes = false;
Act(() =>
{
result = builder.AddArguments(key, values, multipleTimes, condition);
});
And("a condition is true", () =>
{
condition = true;
And("the key is provided", () =>
{
key = "key1";
And("the values has null value", () =>
{
values = new[] { "value1", null };
Should("provide only non-null values", () =>
{
Assert.That(result, Is.EqualTo("-key1=value1"));
});
});
And("the values are provided", () =>
{
values = new[] { "value1", "value2" };
Should("provide the argument with the provided key and values", () =>
{
Assert.That(result, Is.EqualTo("-key1=value1;value2"));
});
And("the key with values should be added multiple times", () =>
{
multipleTimes = true;
Should("provide the argument with the provided values with teir own keys", () =>
{
Assert.That(result, Is.EqualTo("-key1=value1 -key1=value2"));
});
});
});
And("the values is null", () =>
{
values = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
And("the key is an empty string", () =>
{
key = string.Empty;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
And("the key is null", () =>
{
key = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
public void ArgumentParsing()
{
var argsBuilder = new ArgsBuilder();
var build = argsBuilder.NonGui().LogTo(@"c:\tom\a a").SetPropertiesFile(@"c:\a.txt").WithTestPlan(@"a.txt").Build();
Assert.AreEqual(build, "-n -l \"c:\\tom\\a a\" -p \"c:\\a.txt\" -t \"a.txt\"");
}
public static void AddKey()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("added a key", () =>
{
var condition = true;
string key = null;
Act(() =>
{
result = builder.AddKey(key, condition);
});
And("a condition is true", () =>
{
condition = true;
And("the key is provided", () =>
{
key = "key1";
Should("provide the provided key", () =>
{
Assert.That(result, Is.EqualTo("-key1"));
});
});
And("the key is an empty string", () =>
{
key = string.Empty;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
And("the key is null", () =>
{
key = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
public static void AddPaths2()
{
ArgsBuilder builder = null;
string result = null;
Arrange(() =>
{
builder = ArgsBuilder.By("-", "=");
});
When("added paths", () =>
{
var condition = true;
string key = null;
string[] paths = null;
var multipleTimes = false;
Act(() =>
{
result = builder.AddPaths(key, paths, multipleTimes, condition);
});
And("a condition is true", () =>
{
condition = true;
And("the key is provided", () =>
{
key = "key1";
And("the paths are provided", () =>
{
paths = new[] { "path1", "path2" };
Should("provide the key with the provided paths", () =>
{
Assert.That(result, Is.EqualTo("-key1=\"path1\";\"path2\""));
});
});
And("the key with paths should be added multiple times", () =>
{
multipleTimes = true;
Should("provide the key with the provided paths with teir own keys", () =>
{
Assert.That(result, Is.EqualTo("-key1=\"path1\" -key1=\"path2\""));
});
});
And("the paths is null", () =>
{
paths = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
And("the key is an empty string", () =>
{
key = string.Empty;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
And("the key is null", () =>
{
key = null;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
});
And("a condition is false", () =>
{
condition = false;
Should("provide an empty string", () =>
{
Assert.That(result, Is.Empty);
});
});
});
}
