//导出单条数据
private void ExportSingleDataToPath(string folderPath, string dataBaseName, WimsGridView wimsGridView)
{
Cursor.Current = Cursors.WaitCursor;
if (Directory.Exists(folderPath))
{
Directory.Delete(folderPath, true);
}
Directory.CreateDirectory(folderPath);
switch (dataBaseName)
{
case "Command":
Command Entity = wimsGridView.FindFirstSelect <Command>();
List <Command> commandList = new List <Command>();
commandList.Add(Entity);
BackupDataBll <Command> .ExportSingleData(folderPath, commandList);
break;
case "Dut":
Dut dutEntity = wimsGridView.FindFirstSelect <Dut>();
List <Dut> dutList = new List <Dut>();
dutList.Add(dutEntity);
BackupDataBll <Dut> .ExportSingleData(folderPath, dutList);
break;
case "Project":
Project projectEntity = wimsGridView.FindFirstSelect <Project>();
List <Project> projectList = new List <Project>();
projectList.Add(projectEntity);
BackupDataBll <Project> .ExportSingleData(folderPath, projectList);
break;
case "TestCase":
TestCase testCaseEntity = wimsGridView.FindFirstSelect <TestCase>();
List <TestCase> testCaseList = new List <TestCase>();
testCaseList.Add(testCaseEntity);
BackupDataBll <TestCase> .ExportSingleData(folderPath, testCaseList);
break;
case "TestDevice":
TestDevice testDeviceEntity = wimsGridView.FindFirstSelect <TestDevice>();
List <TestDevice> testDeviceList = new List <TestDevice>();
testDeviceList.Add(testDeviceEntity);
BackupDataBll <TestDevice> .ExportSingleData(folderPath, testDeviceList);
break;
case "TestParams":
TestParams testParamsEntity = wimsGridView.FindFirstSelect <TestParams>();
List <TestParams> testParamsList = new List <TestParams>();
testParamsList.Add(testParamsEntity);
BackupDataBll <TestParams> .ExportSingleData(folderPath, testParamsList);
break;
}
Cursor.Current = Cursors.Default;
}
private static async Task TestMassiveFileQuantity(CancellationToken cancellationToken)
{
var options = new TestParams()
{
CacheOptions = new HybridCacheOptions(null)
{
AsyncCacheOptions = new AsyncCacheOptions()
{
MaxQueuedBytes = 0,
FailRequestsOnEnqueueLockTimeout = true,
WriteSynchronouslyWhenQueueFull = true,
},
CleanupManagerOptions = new CleanupManagerOptions()
{
MaxCacheBytes = (long)4096 * 2 * 1000 * 1000, // 1/2th the size of the files we are trying to write
MinAgeToDelete = TimeSpan.Zero,
MinCleanupBytes = 0, //1 * 1000 * 1000,
}
},
FileSize = 64,
FileCount = 60000,
RequestCountPerWave = 2000,
RequestWaves = 5,
RequestWavesIntermission = TimeSpan.Zero,
CreationTaskDelay = TimeSpan.FromMilliseconds(0),
CreationThreadSleep = TimeSpan.FromMilliseconds(0),
DisplayLog = true
};
Console.WriteLine("Starting HybridCache test async disabled and 60,000 files in waves of 2000 requests");
await TestRandom(options, cancellationToken);
}
private static async Task TestRandomAsyncVeryLimitedCache(CancellationToken cancellationToken)
{
var options = new TestParams()
{
CacheOptions = new HybridCacheOptions(null)
{
AsyncCacheOptions = new AsyncCacheOptions()
{
MaxQueuedBytes = 100 * 1000 * 1000,
FailRequestsOnEnqueueLockTimeout = true,
WriteSynchronouslyWhenQueueFull = true,
},
CleanupManagerOptions = new CleanupManagerOptions()
{
MaxCacheBytes = 8192000, // 1/5th the size of the files we are trying to write
MinAgeToDelete = TimeSpan.Zero,
MinCleanupBytes = 0,
},
Subfolders = 1
},
FileSize = 81920,
FileCount = 500,
RequestCountPerWave = 2000,
RequestWaves = 5,
RequestWavesIntermission = TimeSpan.FromSeconds(1),
CreationTaskDelay = TimeSpan.FromMilliseconds(1000),
CreationThreadSleep = TimeSpan.FromMilliseconds(0),
DisplayLog = false
};
Console.WriteLine("Starting HybridCache test with the async queue enabled and the cache limited to 1/5th the needed size");
await TestRandom(options, cancellationToken);
}
async Task FillTestParams(TradingMacro tmOriginal, Action <IList <KeyValuePair <string, object>[]> > paramsTransformation)
{
var c = _testParamValuesSeparators;
if (!_testParamsRaw.Any())
{
if (!ReplayArguments.IsWww && tmOriginal.UseTestFile)
{
var od = new Microsoft.Win32.OpenFileDialog()
{
FileName = "TestParams", DefaultExt = ".txt", Filter = "Text documents(.txt)|*.txt"
};
var odRes = od.ShowDialog();
if (!odRes.GetValueOrDefault())
{
throw new ArgumentException("Must provide test params file name.");
}
tmOriginal.TestFileName = System.IO.Path.GetFileName(od.FileName);
if (tmOriginal.TestFileName.Contains("skipme"))
{
tmOriginal.TestFileName = "";
}
else
{
var paramsDict = Lib.ReadTestParameters(od.FileName);
_testParamsRaw.AddRange(paramsDict.Select(kv => kv.Value.Split(c).Select(v => new KeyValuePair <string, object>(kv.Key, v)).ToArray()));
}
}
else if (ReplayArguments.IsWww)
{
ReplayArguments.LastWwwError = "";
var strats = TaskMonad.RunSync(() => ReadStrategies(tmOriginal, (name, desc, content, uri, diff) => new { name, content, diff }));
Func <string, bool> isTest = s => s.ToLower().Trim().EndsWith("{t}");
await strats.Select(s => s.First())
.Take(2)
.OrderByDescending(s => isTest(s.name))
.Where(s => isTest(s.name) || s.diff.IsEmpty())
.OnEmpty(() => { LogWww(new Exception(ReplayArguments.LastWwwError = "Current settings don't match any strategy")); })
.Select(strategy => {
tmOriginal.TestFileName = strategy.name;
var paramsDict = Lib.ReadParametersFromString(strategy.content);
_testParamsRaw.AddRange(
paramsDict
.Select(kv => kv.Value.Split(c).Select(v => new KeyValuePair <string, object>(kv.Key, v))
.ToArray()));
return(tmOriginal.LoadActiveSettings(strategy.name, TradingMacro.ActiveSettingsStore.Gist));
}).WhenAll();
}
else
{
var testParams = tmOriginal.GetPropertiesByAttibute <CategoryAttribute>(a => a.Category == TradingMacro.categoryTest);
var paramsDict = testParams.ToDictionary(p => p.Item2.Name.Substring(4), p => p.Item2.GetValue(tmOriginal, null).ToString().ParseParamRange());
_testParamsRaw.AddRange(paramsDict.Where(kv => !string.IsNullOrWhiteSpace(kv.Value))
.Select(kv => kv.Value.Split(c).Select(v => new KeyValuePair <string, object>(kv.Key, v)).ToArray()));
}
}
TestParams.Clear();
paramsTransformation(_testParamsRaw);
_testParamsRaw.CartesianProduct().ForEach(tp => TestParams.Enqueue(tp.ToArray()));
}
public static void Init(string parametersFile)
{
TextReader reader = new StreamReader(parametersFile);
XmlSerializer serializer = new XmlSerializer(typeof(TestParams));
TestParams = (TestParams)serializer.Deserialize(reader);
}
async Task StartReplay(TradingMacro tm)
{
TradingMacro tmOriginal = (TradingMacro)tm;
if (!IsLoggedIn)
{
LogWww(new Exception("Must login first."));
return;
}
try {
while (_replayTasks.ToArray().Any(t => t.Status == TaskStatus.Running))
{
if (ReplayArguments.IsWww)
{
ReplayArguments.LastWwwError = "Replay is running";
return;
}
Log = new Exception("Replay is running.");
Thread.Sleep(1000);
continue;
}
ReplayArguments.Initiator = tmOriginal;
ReplayArguments.StartingBalance = tmOriginal.TestBalance;
ReplayArguments.PrevSessionUid = tmOriginal.TestPrevSession;
ReplayArguments.SuperSessionId = tmOriginal.TestSuperSessionUid.ValueOrDefault(Guid.NewGuid());
_testParamsRaw.Clear();
tmOriginal.TestFileName = "";
if (ReplayArguments.UseSuperSession)
{
#region getDateFromSuperSession
Func <Task <DateTime> > getDateFromSuperSession = async() => {
try {
var sessions = GetBestSessions(ReplayArguments.SuperSessionId).ToArray();
if (sessions.Any())
{
await FillTestParams(tmOriginal, tpr => { });
}
else
{
throw new Exception("Either ReplayArguments.DateStart or valid Supersession Uid must be provided.");
}
return(sessions.Min(s => s.DateStart.Value).AddDays(5));
} catch (Exception exc) {
Log = exc;
throw;
}
};
#endregion
ReplayArguments.DateStart = ReplayArguments.DateStart ?? await getDateFromSuperSession();
}
await FillTestParams(tmOriginal, pt => { });
Log = new Exception("Starting testing with {0} sets.".Formater(TestParams.Count));
StartReplayInternal(tmOriginal, TestParams.Any() ? TestParams.Dequeue() : null, task => { ContinueReplayWith(tmOriginal, TestParams); });
} catch (Exception exc) { Log = exc; }
}
public async Task <ActionResult <IEnumerable <MemberDto> > > GetTestFilter([FromQuery] TestParams filtrationParams)
{
var membersList = await _memberRepository.GetMembersTestFilterAsync(filtrationParams);
Response.AddFiltrationHeader(membersList);
return(membersList.Result);
}
public static void Init(string parametersFile)
{
TextReader reader = new StreamReader(parametersFile);
XmlSerializer serializer = new XmlSerializer(typeof(TestParams));
TestParams = (TestParams)serializer.Deserialize(reader);
}
internal static TestParams Create()
{
TestParams @params = new TestParams();
//Properties props = System.GetProperties();
IDictionary <string, string> props = new System.Collections.Generic.Dictionary <string, string>();
@params.ParseProperties(props);
return(@params);
}
public UsageContextGeneralTest(bool expectedCanUse, bool canUseItem, bool canUseItemWeapon)
{
Params = new TestParams()
{
CanUseItem = canUseItem,
ExpectedCanUse = expectedCanUse,
CanUseItemWeapon = canUseItemWeapon
};
}
public void SetupPDF()
{
pdf = new Pdfium();
TestParams filePath = LoadJson();
string file = filePath.pathToFile;
Console.WriteLine("\nOpen PDF file: " + file);
pdf.LoadFile(file);
}
public static TestParams LoadJson()
{
string jsonPath = Environment.GetEnvironmentVariable("JsonFilePath") as string;
using (StreamReader r = new StreamReader(jsonPath))
{
string json = r.ReadToEnd();
TestParams param = JsonConvert.DeserializeObject <TestParams>(json);
return(param);
}
}
public ClientTest(TestParams paramin)
{
param = paramin;
transport = param.CreateTransport();
TProtocol protocol = param.CreateProtocol(transport);
if (param.multiplexed)
{
second = new SecondService.Client(new TMultiplexedProtocol(protocol, "SecondService"));
}
client = new ThriftTest.Client(protocol);
numIterations = param.numIterations;
}
private GameValue Solve(TestParams testParams, bool visualize, ConfigureSolver configureSolver)
{
if (visualize)
{
VisActionTree.Show(testParams.ActionTree,
Path.Combine(_outDir, String.Format("{0}-at.gv", testParams.Name)));
VisChanceTree.Show(testParams.ChanceTree,
Path.Combine(_outDir, String.Format("{0}-ct.gv", testParams.Name)));
for (int p = 0; p < testParams.StrategyTrees.Length; ++p)
{
VisStrategyTree.Show(testParams.StrategyTrees[p],
Path.Combine(_outDir, string.Format("{0}-st-{1}.gv", testParams.Name, p)));
}
}
// Make sure input is correct.
for (int p = 0; p < testParams.ChanceTree.Nodes[0].Position; ++p)
{
string errorText;
Assert.IsTrue(VerifyAbsStrategy.Verify(testParams.StrategyTrees[p], p, 0.000001, out errorText), errorText);
}
GameValue gv = new GameValue {
ChanceTree = testParams.ChanceTree, ActionTree = testParams.ActionTree, Strategies = testParams.StrategyTrees
};
gv.PrepareVis = visualize;
if (configureSolver != null)
{
configureSolver(gv);
}
gv.Solve();
if (visualize)
{
for (int p = 0; p < testParams.ChanceTree.PlayersCount; ++p)
{
GameValue.Vis.Show(gv, p, Path.Combine(_outDir, String.Format("{0}-{1}-val.gv", testParams.Name, p)));
}
}
Assert.AreEqual(2, gv.Values.Length);
for (int p = 0; p < testParams.ChanceTree.PlayersCount; ++p)
{
Console.WriteLine("Game value pos {0}: {1}", p, gv.Values[p]);
Assert.AreEqual(testParams.ExpectedResult[p], gv.Values[p], testParams.Epsilon);
}
return(gv);
}
private static void PrintDiskUtilization(TestParams options)
{
if (options.CacheOptions.PhysicalCacheDir == options.MetaStoreOptions.DatabaseDir)
{
PrintDiskUtilization("Cache", options.MetaStoreOptions.DatabaseDir,
options.CacheOptions.CleanupManagerOptions.MaxCacheBytes);
}
else
{
PrintDiskUtilization("Files", options.CacheOptions.PhysicalCacheDir,
options.CacheOptions.CleanupManagerOptions.MaxCacheBytes);
PrintDiskUtilization("Database", options.MetaStoreOptions.DatabaseDir,
options.CacheOptions.CleanupManagerOptions.MaxCacheBytes);
}
}
public void GetAllDoesNotRemoveDeletedItems(TestParams testParams)
{
var wrapper = MakeWrapper(testParams);
var itemA = new TestItem("itemA");
_core.ForceSet(TestDataKind, "keyA", 1, itemA);
_core.ForceSet(TestDataKind, "keyB", 2, null); // deleted item
var items = wrapper.GetAll(TestDataKind).Items.ToDictionary(kv => kv.Key, kv => kv.Value);
var expected = ImmutableDictionary.Create <string, ItemDescriptor>()
.Add("keyA", itemA.WithVersion(1))
.Add("keyB", ItemDescriptor.Deleted(2));
Assert.Equal(expected, items);
}
public void Test_Kuhn()
{
TestParams testParams = new TestParams(this, "kuhn.gamedef.xml", null, /* new KuhnChanceAbstraction(),*/ 0.001);
SolveAndVerifyVerifySolution(testParams, true, false,
new int[] { -1 },
s =>
{
s.IsVerbose = true;
s.EpsilonLogThreshold = 0;
s.IterationVerbosity = 1000;
s.MaxIterationCount = 0;
s.ThreadsCount = 0; // Test single-threaded variant.
});
}
public void GetDeletedItem(TestParams testParams)
{
var wrapper = MakeWrapper(testParams);
var key = "flag";
var itemv2 = new TestItem("itemv2");
_core.ForceSet(TestDataKind, key, 1, null);
Assert.Equal(new ItemDescriptor(1, null), wrapper.Get(TestDataKind, key));
_core.ForceSet(TestDataKind, key, 2, itemv2);
var result = wrapper.Get(TestDataKind, key);
// if cached, we will not see the new underlying value yet
Assert.Equal(testParams.CacheMode.IsUncached ? itemv2.WithVersion(2) : ItemDescriptor.Deleted(1), result);
}
private void Solve(TestParams testParams, bool visualize, ConfigureSolver configureSolver)
{
if (visualize)
{
VisActionTree.Show(testParams.ActionTree,
Path.Combine(_outDir, String.Format("{0}-at.gv", testParams.Name)));
VisChanceTree.Show(testParams.ChanceTree,
Path.Combine(_outDir, String.Format("{0}-ct.gv", testParams.Name)));
}
StrategyTree [] eqStrategies = new StrategyTree[testParams.ChanceTree.PlayersCount];
string error;
for (int heroPos = 0; heroPos < testParams.ChanceTree.PlayersCount; ++heroPos)
{
// Create and configure EqLp solver
EqLp solver = new EqLp
{
HeroPosition = heroPos,
ChanceTree = testParams.ChanceTree,
ActionTree = testParams.ActionTree,
};
if (configureSolver != null)
{
configureSolver(solver);
}
// Solve EqLp
solver.Solve();
eqStrategies[heroPos] = solver.Strategy;
if (visualize)
{
VisStrategyTree.Show(solver.Strategy,
Path.Combine(_outDir, string.Format("{0}-eq-{1}.gv", testParams.Name, heroPos)));
}
// Verify the eq value and strategy
Assert.AreEqual(testParams.ExpectedResult[heroPos], solver.Value, testParams.Epsilon, "Wrong eq value");
Assert.IsTrue(VerifyAbsStrategy.Verify(solver.Strategy, solver.HeroPosition, 1e-7, out error), error);
}
// Verify eq, use another (better) epsilon because EqLp and VerifyEq have better precision
// than most of the reference game solvers like OCFR.
Assert.IsTrue(VerifyEq.Verify(testParams.ActionTree, testParams.ChanceTree, eqStrategies, 1e-7, out error), error);
}
/// <summary>
/// Solves the game by fictitious play and verifies the solution.
/// </summary>
/// <param name="snapshotAfter">Number of iterations to make an intermediate snapshot after. -1 for no intermediate snapshot.</param>
/// <param name="configureSolver"></param>
private void SolveAndVerifyVerifySolution(TestParams testParams, bool visualize, bool trace, int[] iterCounts, ConfigureSolver configureSolver)
{
int playersCount = testParams.ChanceTree.PlayersCount;
StrategyTree eqStrategy = RunSolver(testParams, visualize, trace, iterCounts, configureSolver);
string error;
// Verify consistency of strategies
for (int p = 0; p < 2; ++p)
{
Assert.IsTrue(VerifyAbsStrategy.Verify(eqStrategy, p, 1e-7, out error), string.Format("Pos {0}: {1}", p, error));
}
// Run VerifyEq on the computed strategies.
StrategyTree[] strategies = new StrategyTree[] { eqStrategy, eqStrategy };
Assert.IsTrue(VerifyEq.Verify(testParams.ActionTree, testParams.ChanceTree,
strategies, 3 * testParams.Epsilon, out error), error);
//
// Do a redundant test with EqLp
//
// Find game values for our solution
GameValue gv = new GameValue
{
ActionTree = testParams.ActionTree,
ChanceTree = testParams.ChanceTree,
Strategies = new StrategyTree[] { eqStrategy, eqStrategy }
};
gv.Solve();
// Solve eq with EqLp
double[] expEqValues;
StrategyTree[] expStrategies = EqLp.Solve(testParams.ActionTree, testParams.ChanceTree, out expEqValues);
// Verify the eq value and strategy
for (int p = 0; p < 2; ++p)
{
if (visualize)
{
Console.WriteLine("Expected eq value pos {0}: {1}", p, expEqValues[p]);
}
Assert.AreEqual(expEqValues[p], gv.Values[p], testParams.Epsilon, "Eq value differs from EqLp solution");
}
}
public static int Execute(List <string> args)
{
try
{
var param = new TestParams();
try
{
param.Parse(args);
}
catch (Exception ex)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Error while parsing arguments");
Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
return(ErrorUnknown);
}
var tests = Enumerable.Range(0, param.numThreads).Select(_ => new ClientTest(param)).ToArray();
//issue tests on separate threads simultaneously
var threads = tests.Select(test => new Thread(test.Execute)).ToArray();
var start = DateTime.Now;
foreach (var t in threads)
{
t.Start();
}
foreach (var t in threads)
{
t.Join();
}
Console.WriteLine("Total time: " + (DateTime.Now - start));
Console.WriteLine();
return(tests.Select(t => t.ReturnCode).Aggregate((r1, r2) => r1 | r2));
}
catch (Exception outerEx)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Unexpected error");
Console.WriteLine(outerEx.Message + " ST: " + outerEx.StackTrace);
return(ErrorUnknown);
}
}
public static TestParams LoadJson()
{
//dotnet test の場合
string jsonPath = Environment.GetEnvironmentVariable("JsonFilePath");
//dotnet vstest の場合
if (jsonPath == null)
{
jsonPath = "C:/Users/KINU04/Desktop/AllAckahProjs_2019/FreshStartMorisawa/testparams.json";
}
using (StreamReader r = new StreamReader(jsonPath))
{
string json = r.ReadToEnd();
TestParams param = JsonConvert.DeserializeObject <TestParams>(json);
return(param);
}
}
private static async Task TestAsyncMediumLimitedCacheWavesMetaStore(CancellationToken cancellationToken)
{
var options = new TestParams()
{
CacheOptions = new HybridCacheOptions(null)
{
Subfolders = 2048,
AsyncCacheOptions = new AsyncCacheOptions()
{
MaxQueuedBytes = 100 * 100 * 1000,
FailRequestsOnEnqueueLockTimeout = true,
WriteSynchronouslyWhenQueueFull = true,
MoveFileOverwriteFunc = (from, to) => File.Move(from, to, true),
MoveFilesIntoPlace = false
},
CleanupManagerOptions = new CleanupManagerOptions()
{
MaxCacheBytes = 409600000, // 1/2th the size of the files we are trying to write
MinAgeToDelete = TimeSpan.Zero,
MinCleanupBytes = 0,
},
},
MetaStoreOptions = new MetaStoreOptions(null)
{
Shards = 32
},
UseMetaStore = true,
FileSize = 81920,
FileCount = 10000,
RequestCountPerWave = 1000,
RequestWaves = 10,
RebootCount = 12,
RequestWavesIntermission = TimeSpan.FromMilliseconds(15),
CreationTaskDelay = TimeSpan.FromMilliseconds(0),
CreationThreadSleep = TimeSpan.FromMilliseconds(0),
DisplayLog = false,
Synchronous = false,
MaxLogEntries = 75,
WaitForKeypress = true,
};
Console.WriteLine("Starting HybridCache test with the async queue disabled and the cache limited to 1/5th the needed size");
await TestRandom(options, cancellationToken);
}
private void Submit_Click(object sender, EventArgs e)
{
if (this.Entity == null)
{
this.Entity = new TestParams();
this.Entity.Id = Guid.NewGuid().ToString();
}
this.Entity.Name = this.textBox1.Text.Trim();
this.Entity.Desc = this.textBox2.Text.Trim();
this.Entity.ParamList = (List <TestParam>) this.myGridView1.DataSource;
if (isModify)
{
bll.SelectAll().RemoveAll(p => p.Id == this.Entity.Id);
}
bll.Dao.Save(this.Entity);
this.DialogResult = System.Windows.Forms.DialogResult.OK;
this.Close();
}
protected TestParams GetParams()
{
var result = new TestParams();
var row = TestContext.DataRow;
if (row != null)
{
foreach (DataColumn column in row.Table.Columns)
{
var key = column.ColumnName.Split(new[] { "__" }, StringSplitOptions.RemoveEmptyEntries);
var objValue = row[column.ColumnName];
var value = objValue is DBNull ? null : (string)objValue;
if (key.Length == 1)
{
if (key[0] == "Pattern")
{
result.Pattern = value;
}
else if (key[0] == "Url")
{
result.Url = value;
}
else if (key[0] == "Result")
{
result.Result = bool.Parse(value);
}
else
{
result.RouteValues[key[0]] = value;
}
}
else if (key[0] == "default")
{
result.Defaults[key[1]] = value;
}
else if (key[0] == "constraint")
{
result.Constraints[key[1]] = value;
}
}
}
return(result);
}
public void BuildRequestParamsHandlesBasicObject()
{
var subject = new RestSharpRequestHandler("xxx");
var testParams = new TestParams
{
MyString = "foo",
MyBool = true,
MyBytes = new byte[10],
MyEnum = TestEnumParams.TestItem2,
MyInt = 90
};
var result = subject.BuildRequestParams(testParams);
Assert.Equal(4, result.Keys.Count);
Assert.Equal("foo", result["my_string"]);
Assert.Equal("true", result["my_bool"]);
Assert.Equal("test_item2", result["my_enum"]);
Assert.Equal("90", result["my_int"]);
}
public void TestBatch()
{
var param1 = new TestParams
{
Param2 = "abc",
Param1 = 114514
};
var param2 = new TestParams
{
Param2 = "def",
Param1 = 1919810
};
var batch = new RpcBatchParams <bool>(param1, param2)
{
Token = "token"
};
TestSerialization(batch,
"[\"token\",[{\"methodName\":\"test.testMethod\",\"params\":[\"abc\",114514]},{\"methodName\":\"test.testMethod\",\"params\":[\"def\",1919810]}]]");
}
private Modifier GetTestModifier(TestParams testParams)
{
switch (testParams.Grade)
{
case EGrades.One:
return(new LevelOne().Modifier);
case EGrades.Two:
return(new LevelTwo().Modifier);
case EGrades.Three:
return(new LevelThree().Modifier);
case EGrades.Four:
return(new LevelFour().Modifier);
default:
return(new LevelOne().Modifier);
}
}
public void GetMissingItem(TestParams testParams)
{
var wrapper = MakeWrapper(testParams);
var key = "flag";
var item = new TestItem("item");
Assert.Null(wrapper.Get(TestDataKind, key));
_core.ForceSet(TestDataKind, key, 1, item);
var result = wrapper.Get(TestDataKind, key);
if (testParams.CacheMode.IsCached)
{
Assert.Null(result); // the cache can retain a null result
}
else
{
Assert.Equal(item.WithVersion(1), result);
}
}
public void BuildRequestParamsHandlesBasicObject()
{
var subject = new RestSharpRequestHandler("xxx");
var testParams = new TestParams
{
MyString = "foo",
MyBool = true,
MyBytes = new byte[10],
MyEnum = TestEnumParams.TestItem2,
MyInt = 90
};
var result = subject.BuildRequestParams(testParams);
Assert.Equal(4, result.Keys.Count);
Assert.Equal("foo", result["my_string"]);
Assert.Equal("true", result["my_bool"]);
Assert.Equal("test_item2", result["my_enum"]);
Assert.Equal("90", result["my_int"]);
}
public static int Execute(string[] args)
{
try
{
TestParams param = new TestParams();
int numThreads = 1;
try
{
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "-u")
{
param.url = args[++i];
}
else if (args[i] == "-n")
{
param.numIterations = Convert.ToInt32(args[++i]);
}
else if (args[i] == "-pipe") // -pipe <name>
{
param.pipe = args[++i];
Console.WriteLine("Using named pipes transport");
}
else if (args[i].Contains("--host="))
{
param.host = args[i].Substring(args[i].IndexOf("=") + 1);
}
else if (args[i].Contains("--port="))
{
param.port = int.Parse(args[i].Substring(args[i].IndexOf("=") + 1));
}
else if (args[i] == "-b" || args[i] == "--buffered" || args[i] == "--transport=buffered")
{
param.buffered = true;
Console.WriteLine("Using buffered sockets");
}
else if (args[i] == "-f" || args[i] == "--framed" || args[i] == "--transport=framed")
{
param.framed = true;
Console.WriteLine("Using framed transport");
}
else if (args[i] == "-t")
{
numThreads = Convert.ToInt32(args[++i]);
}
else if (args[i] == "--compact" || args[i] == "--protocol=compact")
{
param.protocol = "compact";
Console.WriteLine("Using compact protocol");
}
else if (args[i] == "--json" || args[i] == "--protocol=json")
{
param.protocol = "json";
Console.WriteLine("Using JSON protocol");
}
else if (args[i] == "--ssl")
{
param.encrypted = true;
Console.WriteLine("Using encrypted transport");
}
}
}
catch (Exception ex)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Error while parsing arguments");
Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
return(ErrorUnknown);
}
var tests = Enumerable.Range(0, numThreads).Select(_ => new ClientTest(param)).ToArray();
//issue tests on separate threads simultaneously
var threads = tests.Select(test => new Thread(test.Execute)).ToArray();
DateTime start = DateTime.Now;
foreach (var t in threads)
{
t.Start();
}
foreach (var t in threads)
{
t.Join();
}
Console.WriteLine("Total time: " + (DateTime.Now - start));
Console.WriteLine();
return(tests.Select(t => t.ReturnCode).Aggregate((r1, r2) => r1 | r2));
}
catch (Exception outerEx)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Unexpected error");
Console.WriteLine(outerEx.Message + " ST: " + outerEx.StackTrace);
return(ErrorUnknown);
}
}
public ClientTest(TestParams param)
{
transport = param.CreateTransport();
client = new ThriftTest.Client(param.CreateProtocol(transport));
numIterations = param.numIterations;
}
public void BuildRequestParamsHandlesComplexObject()
{
var complexObject = new TestParams
{
MyString = "inner-foo"
};
var mockParser = new Mock<IResponseParser>();
mockParser.Setup(p => p.SerializeMessage(complexObject))
.Returns("{\"json\": \"result\"}")
.Verifiable();
var subject = new RestSharpRequestHandler("xxx");
subject.ResponseParser = mockParser.Object;
var testParams = new TestParams
{
MyInt = 90,
MyComplexObject = complexObject
};
var result = subject.BuildRequestParams(testParams);
Assert.Equal(2, result.Keys.Count);
Assert.Equal("{\"json\": \"result\"}", result["my_complex_object"]);
Assert.Equal("90", result["my_int"]);
mockParser.Verify();
}
public static int Execute(List<string> args)
{
try
{
var param = new TestParams();
try
{
param.Parse(args);
}
catch (Exception ex)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Error while parsing arguments");
Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
return ErrorUnknown;
}
var tests = Enumerable.Range(0, param.numThreads).Select(_ => new ClientTest(param)).ToArray();
//issue tests on separate threads simultaneously
var threads = tests.Select(test => new Thread(test.Execute)).ToArray();
var start = DateTime.Now;
foreach (var t in threads)
{
t.Start();
}
foreach (var t in threads)
{
t.Join();
}
Console.WriteLine("Total time: " + (DateTime.Now - start));
Console.WriteLine();
return tests.Select(t => t.ReturnCode).Aggregate((r1, r2) => r1 | r2);
}
catch (Exception outerEx)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Unexpected error");
Console.WriteLine(outerEx.Message + " ST: " + outerEx.StackTrace);
return ErrorUnknown;
}
}
public static int Execute(string[] args)
{
try
{
TestParams param = new TestParams();
int numThreads = 1;
try
{
for (int i = 0; i < args.Length; i++)
{
if (args[i] == "-u")
{
param.url = args[++i];
}
else if (args[i] == "-n")
{
param.numIterations = Convert.ToInt32(args[++i]);
}
else if (args[i] == "-pipe") // -pipe <name>
{
param.pipe = args[++i];
Console.WriteLine("Using named pipes transport");
}
else if (args[i].Contains("--host="))
{
param.host = args[i].Substring(args[i].IndexOf("=") + 1);
}
else if (args[i].Contains("--port="))
{
param.port = int.Parse(args[i].Substring(args[i].IndexOf("=")+1));
}
else if (args[i] == "-b" || args[i] == "--buffered" || args[i] == "--transport=buffered")
{
param.buffered = true;
Console.WriteLine("Using buffered sockets");
}
else if (args[i] == "-f" || args[i] == "--framed" || args[i] == "--transport=framed")
{
param.framed = true;
Console.WriteLine("Using framed transport");
}
else if (args[i] == "-t")
{
numThreads = Convert.ToInt32(args[++i]);
}
else if (args[i] == "--compact" || args[i] == "--protocol=compact")
{
param.protocol = "compact";
Console.WriteLine("Using compact protocol");
}
else if (args[i] == "--json" || args[i] == "--protocol=json")
{
param.protocol = "json";
Console.WriteLine("Using JSON protocol");
}
else if (args[i] == "--ssl")
{
param.encrypted = true;
Console.WriteLine("Using encrypted transport");
}
}
}
catch (Exception ex)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Error while parsing arguments");
Console.WriteLine(ex.Message + " ST: " + ex.StackTrace);
return ErrorUnknown;
}
var tests = Enumerable.Range(0, numThreads).Select(_ => new ClientTest(param)).ToArray();
//issue tests on separate threads simultaneously
var threads = tests.Select(test => new Thread(test.Execute)).ToArray();
DateTime start = DateTime.Now;
foreach (var t in threads)
t.Start();
foreach (var t in threads)
t.Join();
Console.WriteLine("Total time: " + (DateTime.Now - start));
Console.WriteLine();
return tests.Select(t => t.ReturnCode).Aggregate((r1, r2) => r1 | r2);
}
catch (Exception outerEx)
{
Console.WriteLine("*** FAILED ***");
Console.WriteLine("Unexpected error");
Console.WriteLine(outerEx.Message + " ST: " + outerEx.StackTrace);
return ErrorUnknown;
}
}
public ClientTest(TestParams param)
{
transport = param.CreateTransport();
client = new ThriftTest.Client(param.CreateProtocol(transport));
numIterations = param.numIterations;
}