public async Task <IActionResult> PutTestGroup(int id, TestGroup testGroup)
{
if (id != testGroup.Id)
{
return(BadRequest());
}
_context.Entry(testGroup).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TestGroupExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async void EndGroup(TestGroup group)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
_currentGroup = null;
});
}
public void ToolStrip_RunFailedCommand_RunsAllTests()
{
var testGroup = new TestGroup("RunTests");
_view.RunFailedCommand.Execute += Raise.Event <CommandHandler>();
_model.Received().RunTests(testGroup);
}
public async Task <ActionResult <TestGroup> > PostTestGroup(TestGroup testGroup)
{
_context.TestGroups.Add(testGroup);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTestGroup", new { id = testGroup.Id }, testGroup));
}
public async void EndGroup(TestGroup group)
{
await Dispatcher.InvokeAsync(() =>
{
_currentGroup = null;
});
}
private static void DoSpeedTest <T>(
string testGroupName, List <T> objects, Func <List <T>, List <byte[]> > serializeFunc, Func <List <byte[]>, List <T> > deserializeFunc)
{
var byteArrays = new List <byte[]>();
var testGroup = new TestGroup(testGroupName);
var serializationTestSummary =
testGroup
.Plan("Serialization", () => byteArrays = serializeFunc(objects), TestRuns)
.GetResult()
.GetSummary(OutcomeFilter);
Console.WriteLine(serializationTestSummary);
Console.WriteLine("Test Group [{0}] average serialized byte array size is [{1}]", testGroupName, byteArrays.Average(arr => arr.Length));
var clones = new List <T>();
if (deserializeFunc != null)
{
var deserializationTestSummary =
testGroup
.Plan("Deserialization", () => clones = deserializeFunc(byteArrays), TestRuns)
.GetResult()
.GetSummary(OutcomeFilter);
Console.WriteLine(deserializationTestSummary);
}
Console.WriteLine("--------------------------------------------------------");
}
private static void DoSpeedTest <T>(
string testGroupName,
Func <List <SimpleObject>, List <T> > serializeFunc,
Func <List <T>, List <SimpleObject> > deserializeFunc,
Func <List <T>, double> getAvgPayload)
{
var data = new List <T>();
var testGroup = new TestGroup(testGroupName);
var serializationTestSummary =
testGroup
.Plan("Serialization", () => data = serializeFunc(SimpleObjects), TestRuns)
.GetResult()
.GetSummary(OutcomeFilter);
Console.WriteLine(serializationTestSummary);
Console.WriteLine("Test Group [{0}] average serialized byte array size is [{1}]", testGroupName, getAvgPayload(data));
var objects = new List <SimpleObject>();
var deserializationTestSummary =
testGroup
.Plan("Deserialization", () => objects = deserializeFunc(data), TestRuns)
.GetResult()
.GetSummary(OutcomeFilter);
Console.WriteLine(deserializationTestSummary);
Console.WriteLine("---------------------------------------------------------\n\n");
}
public void Update_Should_Update_A_TestGroup()
{
_repository
.Setup(it => it.Update(It.IsAny <Int32>(), It.IsAny <String>(), It.IsAny <Boolean>(), It.IsAny <Int32>()))
.Callback <Int32, String, Boolean, Int32>((projectId, name, isActive, id) =>
{
var tTestGroup = _repositoryList.Find(x => x.Id == id);
tTestGroup.ProjectId = projectId;
tTestGroup.Name = name;
tTestGroup.IsActive = isActive;
});
var tempTestGroup = _repositoryList.Find(x => x.Id == id);
var testTestGroup = new TestGroup {
Id = tempTestGroup.Id,
ProjectId = tempTestGroup.ProjectId,
Name = tempTestGroup.Name,
IsActive = tempTestGroup.IsActive
};
//TODO change something on testTestGroup
//testTestGroup.oldValue = newValue;
_target.Update(testTestGroup);
//Assert.AreEqual(newValue, _repositoryList.Find(x => x.Id==1).oldValue);
//TODO fail until we update the test above
Assert.Fail();
}
public ActionResult DeleteAttachedTestCase(string id, string testCaseId)
{
TestGroupRepository testGroupRepo = new TestGroupRepository();
TestCaseRepository testCaseRepo = new TestCaseRepository();
TestGroup testGroup = testGroupRepo.GetById(Guid.Parse(id));
if (testGroup.TestCases != null && testGroup.TestCases.Count > 0)
{
foreach (var tempTestCase in testGroup.TestCases)
{
if (tempTestCase.Id == Guid.Parse(testCaseId))
{
testGroup.TestCases.Remove(tempTestCase);
break;
}
}
testGroup.SkillDificulty = testGroup.CountSkillDificulty();
testGroup.TimeDificulty = testGroup.CountTimeDificulty();
testGroupRepo.Update(testGroup);
TestCase testCase = testCaseRepo.GetById(Guid.Parse(testCaseId));
testCase.IsInGroup = false;
testCaseRepo.Update(testCase);
}
return(RedirectToAction("EditTestGroup", "TestGroups", new { id = testGroup.Id.ToString() }));
}
public void StartGroup(TestGroup testGroup)
{
BeginInvokeOnMainThread(() => {
this.testsSection = new Section(testGroup.Name);
Root.Add(this.testsSection);
});
}
public TastyScope()
{
Executor = () => Task.FromResult(true);
CurrentGroup = this;
RegisterCommand(ExecuteTestsCommand.Register);
RegisterCommand(ExitCommand.Register);
}
public TestResultGrp EnumerationDouble()
{
clearData = false;
const int numberTestRuns = 5;
TestRunner tr = new TestRunner(0, numberTestRuns);
//itialise test data
const int collIncrease = 5;
StronglyTypedDouble(numberIterations * collIncrease);
ArrayList(numberIterations * collIncrease);
TestGroup tgStrong = new TestGroup(new TestRunner.TestCase(this.StronglyTypedEnum),
new TestRunner.TestCleanup(TestRunner.GCCollect), new TestRunner.TestCleanup(TestRunner.GCCollect),
new TestRunner.TestValidity(TestRunner.TestOK));
tr.AddTestGroup(tgStrong);
TestGroup tgAL = new TestGroup(new TestRunner.TestCase(this.ArrayListEnum),
new TestRunner.TestCleanup(TestRunner.GCCollect), new TestRunner.TestCleanup(TestRunner.GCCollect),
new TestRunner.TestValidity(TestRunner.TestOK));
tr.AddTestGroup(tgAL);
return(tr.RunTests(null));
}
public void EndGroup(TestGroup group)
{
Dispatcher.BeginInvoke(() =>
{
_currentGroup = null;
});
}
public static void Populate(TestHarness harness)
{
Assembly assembly = typeof(TestDiscovery).GetTypeInfo().Assembly;
Dictionary <TypeInfo, TestGroup> groups = new Dictionary <TypeInfo, TestGroup>();
Dictionary <TestGroup, object> instances = new Dictionary <TestGroup, object>();
foreach (TypeInfo type in assembly.DefinedTypes)
{
foreach (MethodInfo method in type.DeclaredMethods)
{
if (method.GetCustomAttribute <TestMethodAttribute>(true) != null ||
method.GetCustomAttribute <AsyncTestMethodAttribute>(true) != null)
{
TestGroup group = null;
object instance = null;
if (!groups.TryGetValue(type, out group))
{
group = CreateGroup(type);
harness.Groups.Add(group);
groups[type] = group;
instance = Activator.CreateInstance(type.AsType());
instances[group] = instance;
}
else
{
instances.TryGetValue(group, out instance);
}
TestMethod test = CreateMethod(type, instance, method);
group.Methods.Add(test);
}
}
}
}
IEnumerator Get()
{
WebClient request = new WebClient();
request.Credentials = credential;
while (true)
{
yield return(new WaitForSeconds(dataRate));
try
{
byte[] newFileData = request.DownloadData(url);
string fileString = System.Text.Encoding.UTF8.GetString(newFileData);
data = JsonUtility.FromJson(fileString, typeof(TestGroup)) as TestGroup;
if (data.canStart)
{
foreach (UserInfo page in data.users)
{
Debug.Log($"OculusID: {page.questID} | UserID: {page.userID} | GroupID: {page.groupID}");
}
string userID = data.users[ChicagoSceneTransition.Instance.HeadsetID - 1].userID;
string groupID = data.users[ChicagoSceneTransition.Instance.HeadsetID - 1].groupID;
ChicagoSceneTransition.Instance.InitializeUser(userID, groupID);
data.users[ChicagoSceneTransition.Instance.HeadsetID - 1].questReady = true;
Post();
yield break;
}
}
catch (WebException e)
{
Debug.LogError(e.Message);
}
}
}
public void SetTestGroups(int testId, int[] addGroups, int[] remGroups)
{
Debug.Assert(testId > 0);
Provider.TestRoles(TestorUserRole.Administrator, TestorUserRole.Teacher, TestorUserRole.Laboratorian);
using (DataClassesTestorCoreDataContext dataContext = new DataClassesTestorCoreDataContext(TestorSecurityProvider.ConnectionString))
{
Provider.TestCoreTestsAccess(testId);
var test = dataContext.CoreTests.Where(c => c.TestId == testId).FirstOrDefault();
if (test == null)
{
return;
}
var ids = (from c in dataContext.GetUserGroupTree(Provider.CurrentUser.UserRole == TestorUserRole.Administrator ||
Provider.CurrentUser.UserRole == TestorUserRole.Anonymous ? 0 : Provider.CurrentUser.UserId,
null, true, null)
select c.GroupId).ToArray();
var aGroups = addGroups.Where(c => ids.Contains(c));
var rGroups = remGroups.Where(c => ids.Contains(c));
dataContext.TestGroups.DeleteAllOnSubmit(test.TestGroups.Where(
c => rGroups.Contains(c.GroupId) || aGroups.Contains(c.GroupId)));
foreach (int groupId in aGroups)
{
TestGroup group = new TestGroup();
group.CoreTest = test;
group.GroupId = groupId;
dataContext.TestGroups.InsertOnSubmit(group);
}
dataContext.SubmitChanges();
}
}
public void Update_Should_Update_A_TestGroup()
{
_repository
.Setup(it => it.Update(It.IsAny<Int32>(), It.IsAny<String>(), It.IsAny<Boolean>(), It.IsAny<Int32>()))
.Callback<Int32, String, Boolean, Int32>((projectId, name, isActive, id) =>
{
var tTestGroup = _repositoryList.Find(x => x.Id==id);
tTestGroup.ProjectId = projectId;
tTestGroup.Name = name;
tTestGroup.IsActive = isActive;
});
var tempTestGroup = _repositoryList.Find(x => x.Id==id);
var testTestGroup = new TestGroup {
Id = tempTestGroup.Id,
ProjectId = tempTestGroup.ProjectId,
Name = tempTestGroup.Name,
IsActive = tempTestGroup.IsActive};
//TODO change something on testTestGroup
//testTestGroup.oldValue = newValue;
_target.Update(testTestGroup);
//Assert.AreEqual(newValue, _repositoryList.Find(x => x.Id==1).oldValue);
//TODO fail until we update the test above
Assert.Fail();
}
private TestPlanPageViewModel(Type type, string title, string description, TestGroup testGroup)
{
Type = type;
Title = title;
Description = description;
TestGroup = testGroup;
}
private static IEnumerable <MethodTester> GetMethodTesters(TestGroup group)
{
foreach (var item in group.Items)
{
var groupItem = item as TestGroup;
if (groupItem != null)
{
foreach (var subItem in GetMethodTesters(groupItem))
{
yield return(subItem);
}
continue;
}
var typeItem = item as TypeTester;
if (typeItem != null)
{
foreach (var subItem in typeItem.Items)
{
yield return(subItem);
}
continue;
}
throw new InvalidOperationException();
}
}
public ActionResult DeleteConfirmed(int id)
{
TestGroup testGroup = db.TestGroups.Find(id);
db.TestGroups.Remove(testGroup);
db.SaveChanges();
return(RedirectToAction("GetTestGroupList", "TestGroups"));
}
private void OnAddGroup(object parameter)
{
var group = new TestGroup {
Name = "new group"
};
TestDoc.Current.Groups.Add(group);
}
static List <Result> DoSpeedTest <T, V>(string serializerName, string niceTypeName, Func <T, V> serializeFunc, Func <V, T, dynamic> deserializeFunc, T obj)
where T : class
where V : class
{
const int TestRuns = 100;
V data = null;
var testGroup = new TestGroup(niceTypeName + " - " + serializerName);
Console.WriteLine(serializerName);
var serializeResult =
testGroup
.Plan("Serialization", () => data = serializeFunc(obj), TestRuns)
.GetResult();
if (serializeResult.Outcomes.Any(o => o.Exception != null))
{
throw new Exception("Serialization failed w/ " + serializerName);
}
Console.WriteLine("\t" + serializeResult.Outcomes.Select(s => s.Elapsed.TotalMilliseconds).Average() + "ms");
var deserializeResult =
testGroup
.Plan("Deserialization", () => deserializeFunc(data, obj), TestRuns)
.GetResult();
if (deserializeResult.Outcomes.Any(o => o.Exception != null))
{
throw new Exception("Deserialization failed w/ " + serializerName);
}
Console.WriteLine("\t" + deserializeResult.Outcomes.Select(s => s.Elapsed.TotalMilliseconds).Average() + "ms");
return
(serializeResult.Outcomes.Select(
o =>
new Result
{
Serializer = serializerName + " (Serialize)",
TypeName = niceTypeName,
Elapsed = o.Elapsed
}
).Concat(
deserializeResult.Outcomes.Select(
o =>
new Result
{
Serializer = serializerName + " (Deserialize)",
TypeName = niceTypeName,
Elapsed = o.Elapsed
}
)
).ToList());
}
public List <KeyValuePair <TestUser, BrowserType> > GetTestSource(TestGroup group)
{
List <TestUser> usersTemplates = new XMLParseTestUsers().GetUsersTamplate();
List <TestUser> targetTestUsers = GetTargetTestGroupUsers(usersTemplates, group);
List <KeyValuePair <TestUser, BrowserType> > testSource = CreateIncrementedTestSource(targetTestUsers, TestGroup.NewUserTests);
UpdateUsersTamplateXML();
return(testSource);
}
public static TestGroup IncludeTests(this TestGroup testGroup, ITestRepository testRepository)
{
if (testGroup.Tests != null)
{
return(testGroup);
}
testGroup.Tests = (TestList)testRepository.GetDataByGroupId(testGroup.Id);
return(testGroup);
}
public static TestGroup IncludeProject(this TestGroup testGroup, IProjectRepository projectRepository)
{
if (testGroup.Project != null)
{
return(testGroup);
}
testGroup.Project = projectRepository.GetDataByProjectId(testGroup.ProjectId).ToList().First();
return(testGroup);
}
public async Task <IActionResult> Create([Bind("Name,Description,Id")] TestGroup testGroup)
{
if (ModelState.IsValid)
{
_context.Add(testGroup);
await _context.SaveChangesAsync();
}
return(RedirectToAction("Index", "Home"));
}
unsafe List <MyTestResult> BenchAll <T>(string name, T item, IntPtr ptr, int length, Random random, int testRuns)
{
var methods = new Benchy <T>[] {
Newtonsoft,
Jil,
ProtoBuf,
#if FPBENCH
Brianary,
#endif
CameronismPointer,
CameronismStream,
CameronismFakeStream,
};
var testGroup = new TestGroup(name);
return(methods
.OrderBy(_ => random.Next())
.Select(method =>
{
var positions = new List <long?>();
var result = new MyTestResult
{
Case = testGroup.Name,
Serializer = method.Method.Name,
Lengths = positions,
};
Action plan = () =>
{
using (var ms = new UnmanagedMemoryStream((byte *)ptr, 0, length, FileAccess.Write))
{
method.Invoke(item, ms);
positions.Add(ms.Position);
}
};
var serializeResult =
testGroup
.Plan(method.Method.Name, plan, testRuns)
.GetResult();
var filter = new SimpleSpeedTester.Core.OutcomeFilters.ExcludeMinAndMaxTestOutcomeFilter();
var summary = serializeResult.GetSummary(filter);
result.Summary = summary;
positions.Sort();
if (positions.Count > 1 && positions.First() != positions.Last())
{
throw new Exception("Inconsistent results from " + method.Method.Name);
}
return result;
})
.ToList());
}
public ActionResult Edit([Bind(Include = "TestGroupId,GroupName")] TestGroup testGroup)
{
if (ModelState.IsValid)
{
db.Entry(testGroup).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("GetTestGroupList", "TestGroups"));
}
return(View(testGroup));
}
public void StartGroup(TestGroup group)
{
Dispatcher.BeginInvoke(() =>
{
_currentGroup = new GroupDescription {
Name = group.Name
};
_groups.Add(_currentGroup);
});
}
private void AddTestNode(TreeNode node, TestGroup group)
{
foreach (var t in group.tests)
{
var n = new TreeNode(t.testid);
n.Checked = !t.skip;
n.Tag = t;
node.Nodes.Add(n);
}
}
public ValidationTestGroup(Connection connection, TestGroup testGroup)
{
TestGroupId = testGroup.Id;
Name = testGroup.Name;
ValidationTests = new Collection<ValidationTest>();
foreach (var test in testGroup.Tests)
{
ValidationTests.Add(new ValidationTest(connection, test));
}
}
public async void StartGroup(TestGroup group)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
_currentGroup = new GroupDescription {
Name = group.Name
};
_groups.Add(_currentGroup);
});
}
public ActionResult Create(TestGroup testGroup)
{
try
{
_dbTestGroupRepository.Insert(testGroup);
return RedirectToAction("Index");
}
catch
{
return View(testGroup);
}
}
public ActionResult Edit(int id, TestGroup testGroup)
{
try
{
_dbTestGroupRepository.Update(testGroup);
return RedirectToAction("Index");
}
catch
{
return View(testGroup);
}
}
private static void Execute(Func<string> sample, string name)
{
Console.WriteLine("Executing " + name);
var testGroup = new TestGroup(name).Plan("Execute", () => sample(), Test_Runs).GetResult();
Console.WriteLine("Total: {0}ms (" + Test_Runs + " runs)", testGroup.Outcomes.Select(x => x.Elapsed.TotalMilliseconds).Sum());
Console.WriteLine("Avg : {0}ms", testGroup.Outcomes.Select(x => x.Elapsed.TotalMilliseconds).Average());
Console.WriteLine("Min : {0}ms", testGroup.Outcomes.Select(x => x.Elapsed.TotalMilliseconds).Min());
Console.WriteLine("Max : {0}ms", testGroup.Outcomes.Select(x => x.Elapsed.TotalMilliseconds).Max());
if (testGroup.Outcomes.Any(x => x.Exception != null))
{
Console.WriteLine("!!! -- Exception thrown by one or more test samples -- !!!");
}
Console.WriteLine("------------------------------------------");
}
protected bool ShouldRun(TestGroup testGroup)
{
#if SkipMigrationsTests
if (testGroup == TestGroup.MigrationsTests)
{
return false;
}
#endif
#if SkipSlowTests
if (testGroup != TestGroup.Default)
{
return false;
}
#endif
return true;
}
/// <summary>
/// Performs test to measure the difference in execution time when:
/// - stack trace is shallow
/// - stack trace is deeper (50 levels of recursion)
/// - stack trace os deeeper (100 levels of recursion)
/// </summary>
private static void PerformStackTraceDepthTest(int iterationCount, int testRuns)
{
var testGroup = new TestGroup("StackTraceDepthTest");
var shallowTestResult = testGroup.PlanAndExecute(
"Shallow (1)", () => TestRecurseThenException(iterationCount, 1), testRuns);
var deeperTestResult = testGroup.PlanAndExecute(
"Deeper (50)", () => TestRecurseThenException(iterationCount, 50), testRuns);
var deepestTestResult = testGroup.PlanAndExecute(
"Deepest (100)", () => TestRecurseThenException(iterationCount, 100), testRuns);
Console.WriteLine(shallowTestResult);
Console.WriteLine(deeperTestResult);
Console.WriteLine(deepestTestResult);
Console.WriteLine("All done...");
Console.ReadKey();
}
public void Update(int projectId, string name, bool isActive, int id)
{
using (var client = new HttpClient(_messageHandler, false))
{
client.BaseAddress = new Uri(_baseAddress);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var testGroup = new TestGroup
{
ProjectId = projectId,
Name = name,
IsActive = isActive,
Id = id
};
var response = client.PutAsync(UrlBase, testGroup, new JsonMediaTypeFormatter()).Result;
response.EnsureSuccessStatusCode();
}
}
private static void Example2()
{
// initialize a new test group
var testGroup = new TestGroup("Example2");
// PlanAndExecute actually executes the Action delegate 5 times and returns
// the result summary
var testResultSummary = testGroup.PlanAndExecute("Test1", () => { }, 5);
Console.WriteLine(testResultSummary);
/* prints out something along the line of
*
* Test Group [Example2], Test [Test1] results summary:
* Successes [5]
* Failures [0]
* Average Exec Time [...] milliseconds
*
*/
}
public static int Main(String[] args)
{
Exception[] cryptoEx = new Exception[] { new CryptographicException() };
TestGroup apiTests = new TestGroup("API tests", new TestCase[]
{
new TestCase("GetBytes with small values", new TestCaseImpl(GetBytesSmall)),
new TestCase("Reset and ensure same", new TestCaseImpl(Reset)),
new TestCase("Set and Check Hash", new TestCaseImpl(SetCheckHash)),
new TestCase("Set and Check Salt", new TestCaseImpl(SetCheckSalt)),
new TestCase("Set and Check IC", new TestCaseImpl(SetCheckIC)),
new TestCase("Create with password bytes", new TestCaseImpl(CreateWithPasswordBytes)),
new TestCase("Create with password bytes and CSP", new TestCaseImpl(CreateWithPasswordBytesCSP))
});
TestGroup exceptionTests = new TestGroup("Exception tests", new TestCase[]
{
new ExceptionTestCase("Derive key, negative key size", new ExceptionTestCaseImpl(DeriveNegKey), cryptoEx),
new ExceptionTestCase("Derive key, bad algorithm", new ExceptionTestCaseImpl(DeriveKeyBadAlg), cryptoEx),
new ExceptionTestCase("Derive key, null IV", new ExceptionTestCaseImpl(DeriveKeyNullIv), cryptoEx),
new ExceptionTestCase("Null HashName", new ExceptionTestCaseImpl(NullHashName), ExceptionTestCase.ArgumentExceptions),
new ExceptionTestCase("Set HashName after Calculating", new ExceptionTestCaseImpl(HashNameAfterCalc), cryptoEx),
new ExceptionTestCase("Set Salt after Calculating", new ExceptionTestCaseImpl(SaltAfterCalc), cryptoEx),
new ExceptionTestCase("Zero iteration count", new ExceptionTestCaseImpl(ZeroIC), ExceptionTestCase.ArgumentExceptions),
new ExceptionTestCase("Negative iteration count", new ExceptionTestCaseImpl(NegativeIC), ExceptionTestCase.ArgumentExceptions),
new ExceptionTestCase("Set iteration count after calcuating", new ExceptionTestCaseImpl(ICAfterCalc), cryptoEx)
});
TestGroup customTests = new TestGroup("Custom Impl tests", new TestCase[]
{
new TestCase("Compare with custom impl", new TestCaseImpl(CompareWithCustom))
});
TestGroup otherTests = new TestGroup("Other tests", new TestCase[]
{
new TestCase("Change hash", new TestCaseImpl(ChangeHash)),
new TestCase("Change salt", new TestCaseImpl(ChangeSalt))
});
TestRunner runner = new TestRunner(new TestGroup[] { apiTests, exceptionTests, customTests, otherTests }, new ILogger[] { new ConsoleLogger(), new XmlFailureLogger() });
return runner.Run() ? PASS_CODE : FAIL_CODE;
}
private static void Example3()
{
// initialize a new test group
var testGroup = new TestGroup("Example3");
var randomGenerator = new Random(DateTime.UtcNow.Millisecond);
// you can also plan a test that runs against some piece of data, it provides
// you with a way to track some arbitrary metric as you run your tests
var numbers = new List<int>();
var testAction = testGroup.Plan(
"Test1", lst => lst.Add(randomGenerator.Next(100)), numbers, 5);
// when executed, this test will add 5 random numbers between 0 and 99 to the
// 'numbers' list
testAction.GetResult();
// this will print the 5 random number, e.g. 15, 7, 4, 9, 38
Console.WriteLine(string.Join(",", numbers.Select(n => n.ToString())));
}
/// <summary>
/// Performs simple test to measure the difference in execution time when:
/// - executing code in try-catch
/// - throwing exception in try-catch
/// compared to just running the code
/// </summary>
private static void PerformSimpleTest(int iterationCount, int testRuns)
{
Action doNothing = () => { };
Action throwEx = () => { throw new Exception(); };
var testGroup = new TestGroup("SimpleTest");
var noTryCatchResult = testGroup.PlanAndExecute(
"NoTryCatch", () => NoTryCatch(doNothing, iterationCount), testRuns);
var tryCatchNoExceptionResult = testGroup.PlanAndExecute(
"TryCatchNoException", () => WithTryCatch(doNothing, iterationCount), testRuns);
var tryCatchWithExceptionResult = testGroup.PlanAndExecute(
"TryCatchWithException", () => WithTryCatch(throwEx, iterationCount), testRuns);
Console.WriteLine(noTryCatchResult);
Console.WriteLine(tryCatchNoExceptionResult);
Console.WriteLine(tryCatchWithExceptionResult);
Console.WriteLine("All done...");
Console.ReadKey();
}
private static IEnumerable<MethodTester> GetMethodTesters(TestGroup group)
{
foreach (var item in group.Items)
{
var groupItem = item as TestGroup;
if (groupItem != null)
{
foreach (var subItem in GetMethodTesters(groupItem))
yield return subItem;
continue;
}
var methodTester = item as MethodTester;
if (methodTester != null)
{
yield return methodTester;
continue;
}
throw new InvalidOperationException();
}
}
OBX|9|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|10|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|11|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|12|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|13|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^JVBERi0xLjcNJeLjz9MNCjI0IDAgb2JqDTw8L0xpbmVhcml6ZWQgMS9MIDExMjQxNi9PIDI2L0UgNTQ2MTkvTiAyL1QgMTExODE2L0ggWyA5NzYgMjk3XT4+DWVuZG9iag0gICAgICAgICAgICAgICAgDQp4cmVmDQoyNCAzNA0KMDAwMDAwMDAxNiAwMDAwMCBuDQowMDAwMDAxMjczIDAwMDAwIG4NCjAwMDAwMDE0NDUgMDAwMDAgbg0KMDAwMDAwMTg5OSAwMDAwMCBuDQowMDAwMDAyNDgwIDAwMDAwIG4NCjAwMDAwMDI1MTUgMDAwMDAgbg0KMDAwMDAwMjYyOCAwMDAwMCBuDQowMDAwMDAyODgzIDAwMDAwIG4NCjAwMDAwMDM0NTEgMDAwMDAgbg0KMDAwMDAwNDI0OSAwMDAwMCBuDQowMDAwMDA0MzgzIDAwMDAwIG4NCjAwMDAwMDQ5MjYgMDAwMDAgbg0KMDAwMDAwNTAzNyAwMDAwMCBuDQowMDAwMDA1MDYyIDAwMDAwIG4NCjAwMDAwMDU1NjcgMDAwMDAgbg0KMDAwMDAwNTgyMyAwMDAwMCBuDQowMDAwMDA2MzA4IDAwMDAwIG4NCjAwMDAwMDcwMTYgMDAwMDAgbg0KMDAwMDAwNzYyNCAwMDAwMCBuDQowMDAwMDA4MjE0IDAwMDAwIG4NCjAwMDAwMDg4NzAgMDAwMDAgbg0KMDAwMDAwOTM0NyAwMDAwMCBuDQowMDAwMDA5Nzg3IDAwMDAwIG4NCjAwMDAwMTA0NDMgMDAwMDAgbg0KMDAwMDAxMzA5MiAwMDAwMCBuDQowMDAwMDEzMTYxIDAwMDAwIG4NCjAwMDAwMTMyNjAgMDAwMDAgbg0KMDAwMDAxOTU3NSAwMDAwMCBuDQowMDAwMDE5ODQzIDAwMDAwIG4NCjAwMDAwMjAyNDIgMDAwMDAgbg0KMDAwMDAyODAyNCAwMDAwMCBuDQowMDAwMDM0MzUyIDAwMDAwIG4NCjAwMDAwNTE0OTQgMDAwMDAgbg0KMDAwMDAwMDk3NiAwMDAwMCBuDQp0cmFpbGVyDQo8PC9TaXplIDU4L1Jvb3QgMjUgMCBSL0luZm8gMjMgMCBSL0lEWzxDNzc3RERCRUE2QTE1RDQwODZEMDg2MTlBODBGOEVBOD48RjlDREEyMTExMzgzMTU0MzhGRjlGNzgwQkMzRDZEQzc+XS9QcmV2IDExMTgwNT4+DQpzdGFydHhyZWYNCjANCiUlRU9GDQogICAgICAgICAgICANCjU3IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9JIDI1Mi9MZW5ndGggMjA0L08gMjM2L1MgOTgvVCAxOTE+PnN0cmVhbQ0KaN5iYGDgY2BgqWFgZWA4tZSBmwEBuIFibAwsDBwdDIsUGJY6MKACDiMvnUJWNmFexdDpidNmFzAwMAoKCnYAAVhaUALIagBqBAJ+BsZ514G0PBArgWUlGfiZozg2MASwNsgcaD/Y1JDLwsMYwcAgxyDzoJgxtMmdJYvzDp+C5Ae/RxMYxBi8DFWYz3BvfHJZ+MN2Nz4GceZLDD4wdwgzMC5MANJMIA6TLgMXkGJkwAQqDUBCCKjYFKpAG4jFGRg33YfytwIEGAADmimBDQplbmRzdHJlYW0NZW5kb2JqDTI1IDAgb2JqDTw8L0V4dGVuc2lvbnM8PC9BREJFPDwvQmFzZVZlcnNpb24vMS43L0V4dGVuc2lvbkxldmVsIDM+Pj4+L01ldGFkYXRhIDIyIDAgUi9PdXRsaW5lcyAxOCAwIFIvUGFnZXMgMjEgMCBSL1R5cGUvQ2F0YWxvZy9WaWV3ZXJQcmVmZXJlbmNlczw8L0RpcmVjdGlvbi9MMlI+Pj4+DWVuZG9iag0yNiAwIG9iag08PC9BcnRCb3hbMC4wIDAuMCA2MTIuMCA3OTIuMF0vQmxlZWRCb3hbMC4wIDAuMCA2MTIuMCA3OTIuMF0vQ29udGVudHNbMzIgMCBSIDQwIDAgUiA0MSAwIFIgNDIgMCBSIDQzIDAgUiA0NCAwIFIgNDUgMCBSIDQ2IDAgUl0vQ3JvcEJveFswLjAgMC4wIDYxMi4wIDc5Mi4wXS9NZWRpYUJveFswLjAgMC4wIDYxMi4wIDc5Mi4wXS9QYXJlbnQgMjEgMCBSL1Jlc291cmNlczw8L0NvbG9yU3BhY2U8PC9DUzAgMjggMCBSPj4vRXh0R1N0YXRlPDwvR1MwIDI5IDAgUi9HUzEgMzUgMCBSPj4vRm9udDw8L0MyXzAgMzMgMCBSL1RUMCAyNyAwIFIvVFQxIDM0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQ10vWE9iamVjdDw8L0ltMCA1NiAwIFI+Pj4+L1JvdGF0ZSAwL1RhYnMvVy9UaHVtYiAxOSAwIFIvVHJpbUJveFswLjAgMC4wIDYxMi4wIDc5Mi4wXS9UeXBlL1BhZ2U+Pg1lbmRvYmoNMjcgMCBvYmoNPDwvQmFzZUZvbnQvSlhGUU1MK1doaXRuZXktQm9vay9FbmNvZGluZy9XaW5BbnNpRW5jb2RpbmcvRmlyc3RDaGFyIDMyL0ZvbnREZXNjcmlwdG9yIDMwIDAgUi9MYXN0Q2hhciAxNzQvU3VidHlwZS9UcnVlVHlwZS9Ub1VuaWNvZGUgMzEgMCBSL1R5cGUvRm9udC9XaWR0aHNbMjI2IDAgMCAwIDAgMCAwIDAgMzk4IDM5OCAwIDAgMjE5IDM2NCAyMTkgNTE3IDAgMCA1MzUgNTIzIDAgMCAwIDUzMiAwIDAgMjI3IDAgMCAwIDAgMCAwIDY5MSAwIDY0OCA3MDEgNTA0IDQ3NyAwIDcwNSAyNjggMzY0IDAgNDY2IDkwNyA3MDUgNzQ1IDUzMyAwIDU2NyA1MTIgNTgxIDY4MSA2ODAgMCA2MzUgMCAwIDAgMCAwIDAgMCAwIDQ4OSA1MjggNDY2IDUzMSA0OTEgMjk4IDUwMiA1MjMgMjMzIDAgNDY2IDIzNCA4MTkgNTIzIDUyMyA1MzEgNTI4IDM0NCA0MzggMzMwIDUyMyA0NzAgNzMwIDQ3MCA0ODAgNDQ5IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAyMTkgMzg4IDM4OCAwIDQ1NiAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgNTY2XT4+DWVuZG9iag0yOCAwIG9iag1bL0lDQ0Jhc2VkIDQ3IDAgUl0NZW5kb2JqDTI5IDAgb2JqDTw8L0FJUyBmYWxzZS9CTS9Ob3JtYWwvQ0EgMS4wL09QIGZhbHNlL09QTSAxL1NBIHRydWUvU01hc2svTm9uZS9UeXBlL0V4dEdTdGF0ZS9jYSAxLjAvb3AgZmFsc2U+Pg1lbmRvYmoNMzAgMCBvYmoNPDwvQXNjZW50IDkzOS9DYXBIZWlnaHQgNjkwL0Rlc2NlbnQgLTIwMC9GbGFncyAzMi9Gb250QkJveFstNzYgLTIwMCA5ODAgOTM5XS9Gb250RmFtaWx5KFdoaXRuZXktQm9vaykvRm9udEZpbGUyIDUzIDAgUi9Gb250TmFtZS9KWEZRTUwrV2hpdG5leS1Cb29rL0ZvbnRTdHJldGNoL05vcm1hbC9Gb250V2VpZ2h0IDUwMC9JdGFsaWNBbmdsZSAwL1N0ZW1WIDY4L1R5cGUvRm9udERlc2NyaXB0b3IvWEhlaWdodCA0ODE+Pg1lbmRvYmoNMzEgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0OTg+PnN0cmVhbQ0KSIlck81uozAUhfc8hZftooIk9r1FQpHSpJWymB9NZh6AgJMiNYAcssjbzz2cqiNNpMQfwT58B3C+3e/2fTe5/GcamkOc3Knr2xSvwy010R3jueuzxdK1XTN9Hs2/zaUes9wWH+7XKV72/WnIqsrlv+zkdUp397Bph2N8zPIfqY2p68/u4c/28Ojyw20cP+Il9pMr3Hrt2niyoG/1+L2+RJfPy572rZ3vpvuTrfk34/d9jG45Hy8o0wxtvI51E1Pdn2NWFfZZu+rNPuss9u1/56XgsuOpea9TVi0xuShsMH4mP4NLcgnekrfgHXkHfiW/gt/IdtFqtZzZBuMVeQVWsoI35I2xX8xsgzHne8z3nuzBgRzAQhYwnT2cPZ09nD3z/ZxPfw9/T38Pf09/D39Pfw//wHsScE8CuwR0CXQLcAt0C3ALdAtwC3QLcAt0C3ATdhR0FGYKMoWZgkxhpiBTmCnIFGYKMoX3UHAPhfky57O7oLu8kF/A7C7oLuwu6C7sLugu7C7oruyu6K50VjgrnRXOSmeFs9JZ4ax0VjgrnRXOSmeFs9JZ4ax0Vjgrn5fieZW41rJY4P9yRYZ/6cnwL4UMhw272IAX/vPNxqtvO9R97avmlpJtqXkbz3sJu6jr49dOH4fR2Sp8s78CDAC1afppDQplbmRzdHJlYW0NZW5kb2JqDTMyIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNzI4Pj5zdHJlYW0NCkiJdFPLctQwELzvV8xRooLj9+MISYWE4hRcXAgH2dauBbLssrRJ9u+ZkbUJoeAQxTuSpnu6W5dXX2PoLcRRVie05g2tWQ1ge7O7/ITbB7uLoUqqqIYySfEvalJY5W6P5diXcC+tQylKU2qUNDmtdbE1SrIytMirEso8CsepHvvamx5NnAGtFa3J1gI5ZP4MIRZ5VAUSH1u6kHlQupUUaSDftjEk0CJKCkSVmGYFlGUdlTm00+47u7m9u39IixIe0rSEG459Eyasg1sptBvhzjhOJbnypGbzsv0XnZZwT1/Szkdf6nmDP+CBjbriTcwi/D2vvGIH/r7I2SXPSrYf1frANyhlQYCRvMHmzw4OPImZNKG9U7MB/qP9vGPA2584+vskSgtor5GydcIMwh8cLOzpgzhPklo88SRH3F/Q+wNSIH0mB+iQzgluvxA3PB0BDQ5Eep46ZZC5GyV0Eiffe054cxsMt+Y93UTaKc8K3LN/cmvfIadvvPYaNcwS9fQCXip0nmoZIG24uiYhPvC8YV72ZdN1OPYOtOfxNCoUV9M0UcoeaZ6gykGZg6ept6mQK41LZDt4q4rn55kRqFgWfaLLApw6jOcR5/6IsxlQ06LlJI0TndLK4V7KTjwnD6mNF78K4nvZ7KyPZBFaGNRH6Y5Kuxc35gmxrHQk3YTTabGS2H5nmQ1iWeiF1ugMyprdhy4hTPi5xQn38ghaGmqUVsIrn3MY1n+FsBcGpLBKn9BRENYn2MqpIzwVEj3DOSukjKV8kH0h7hMFQjga9TFoDAhRRQgg9Fn3edUD9OibwmH+Fn2YsG7dOZ9ObV6eLUcyCIIQ4jXDvQ8+akYuL6vaJJNUCS8FG3ojtU/AakJbL14E//EL35o9KudfbbB+hSPqqQyiP6lBAjbJiMGqpPMnTgTq34fxUPj1jKb5t2vnXuG8kxyUoABNc0eZXUZ01l4gC/gtwACq7XPzDQplbmRzdHJlYW0NZW5kb2JqDTMzIDAgb2JqDTw8L0Jhc2VGb250L1FLUkdHWCtXaGl0bmV5LUJvb2svRGVzY2VuZGFudEZvbnRzIDM2IDAgUi9FbmNvZGluZy9JZGVudGl0eS1IL1N1YnR5cGUvVHlwZTAvVG9Vbmljb2RlIDM3IDAgUi9UeXBlL0ZvbnQ+Pg1lbmRvYmoNMzQgMCBvYmoNPDwvQmFzZUZvbnQvQkxFVUVCK1doaXRuZXktQm9sZC9FbmNvZGluZy9XaW5BbnNpRW5jb2RpbmcvRmlyc3RDaGFyIDMyL0ZvbnREZXNjcmlwdG9yIDM4IDAgUi9MYXN0Q2hhciAxNzQvU3VidHlwZS9UcnVlVHlwZS9Ub1VuaWNvZGUgMzkgMCBSL1R5cGUvRm9udC9XaWR0aHNbMjA5IDAgMCA2NzMgMCAwIDAgMCAwIDAgMCAwIDAgMzU0IDI1OCA1MzAgMCAwIDAgMCAwIDAgMCA1NDEgMCAwIDI2NyAwIDAgMCAwIDAgMCAwIDAgNjA1IDAgNTM1IDUwMyAwIDcwNyAzMDUgMCAwIDQ4NSAwIDAgMCA1NzQgMCA2MTUgNTUzIDYwOSAwIDAgOTkwIDAgMCAwIDAgMCAwIDAgMCAwIDUwNyA1NDEgNDUxIDU0NCA1MDUgMzQxIDUzNCA1MzcgMjYyIDAgMCAyNjIgODExIDUzNyA1MjcgNTQ0IDAgMzc3IDQ2NCAzNjMgNTM3IDUwNyA3MjUgNDk2IDUxMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDU2M10+Pg1lbmRvYmoNMzUgMCBvYmoNPDwvQUlTIGZhbHNlL0JNL05vcm1hbC9DQSAxLjAvT1AgdHJ1ZS9PUE0gMC9TQSB0cnVlL1NNYXNrL05vbmUvVHlwZS9FeHRHU3RhdGUvY2EgMS4wL29wIHRydWU+Pg1lbmRvYmoNMzYgMCBvYmoNWzUyIDAgUl0NZW5kb2JqDTM3IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDM1Pj5zdHJlYW0NCkiJXJPNauMwFEb3fgot20WxLesnhWBokgay6MwwaR/AsZXU0MhGcRZ5+yo6pgNjsM1B97PvEbr5erfZ+X4S+Z8wtHs3iWPvu+AuwzW0ThzcqfdZKUXXt9NM6dmemzHLY3h/u0zuvPPHIVsuRf43Ll6mcBMPL91wcI9Z/jt0LvT+JB4+1vtHke+v4/jlzs5PohB1LTp3jB96a8ZfzdmJPMWedl1c76fbU8z8q3i/jU7IxCXNtEPnLmPTutD4k8uWRbxqsdzGq86c7/5bV5bY4dh+NiGVV7E8vp7rRNtEcp2oLKFXiMqqgBRUQhqS0ALS0AtkE0kqFZXSQgp6hgxETs25FbSA1hBdS7pWdF0V0AbCQeEQG0y0hTDSGFV0pumsMlAF0aemT4W7wV2RM+QUOUNOkTNzjn0x7IvC1mCrsDXYKmwNtgpbg21USbSCcDe4a9wN7hp3g7vG3eCucbe4axwsDhoHi4PGweKgcbA4aBwsDhoHi4PGweKgcbA4LO7flIXkf6vNvBM4xmM7n8/7AY5zJn6mo72GEAcjDWOaiPss9N79zOs4jCKm7nf2LcAA6V3tzg0KZW5kc3RyZWFtDWVuZG9iag0zOCAwIG9iag08PC9Bc2NlbnQgOTU0L0NhcEhlaWdodCA2OTAvRGVzY2VudCAtMjAwL0ZsYWdzIDMyL0ZvbnRCQm94Wy03OSAtMjAwIDk5OCA5NTRdL0ZvbnRGYW1pbHkoV2hpdG5leS1Cb2xkKS9Gb250RmlsZTIgNTQgMCBSL0ZvbnROYW1lL0JMRVVFQitXaGl0bmV5LUJvbGQvRm9udFN0cmV0Y2gvTm9ybWFsL0ZvbnRXZWlnaHQgNzAwL0l0YWxpY0FuZ2xlIDAvU3RlbVYgMTUyL1R5cGUvRm9udERlc2NyaXB0b3IvWEhlaWdodCA0OTc+Pg1lbmRvYmoNMzkgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0MTU+PnN0cmVhbQ0KSIlck92Ko0AQhe99ir6cuRhMjFbNgARCMgO52B82uw9gtJIVNq10zEXefut4wiysoP1Je4rPssy3+90+9lPIv6ehPdgUTn3skl2HW2otHO3cx2xZhK5vp8fdfG0vzZjlHj7cr5Nd9vE0ZHUd8h++eZ3SPTxtuuFoz1n+LXWW+ngOT7+2h+eQH27j+McuFqewCOt16Ozkhb4049fmYiGfYy/7zvf76f7imX9P/LyPFor5fkmZdujsOjatpSaeLasXfqxD/eHHOrPY/bdfPmLHU/u7SVld4OHFwhfnFXkF3pF34HfyO/iD7MXrlc7si/OGvHEuWadEnbIiV2AhC/iV/Ap+I7+Bt+Stc0W3Cm5VQS7ArF+hflWSSzB9KvjIcmZfnJkVZIVZQVaYFWSFngJPoafAU1hT5pp0FjgLnQXOQmeBs7Bvgr4J+ybom7Bvgr4p30vxXko3hZvSTeGmdFO4Kd0Ubko3hZvSTeGmdFO4Kd0Ubhs6+IJheHx1jIVPb/icufaWko/bPOLznGHC+miff8E4jMFTOLO/AgwAEuPNhg0KZW5kc3RyZWFtDWVuZG9iag00MCAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDYzOD4+c3RyZWFtDQpIiaRUXU/bMBR9z6+4j85EXTtfTaeqEgM6hsQLRNpDQZObmMYjHyh2+Pj3XDspdGUPm1Cl1K3tc88599xkFx6DCadBDNmptyZ51fYF5P6ctHXdNyoXRrWNPoKz8yufhzQgk43QsoBCGAG6FJ1qtkegZffo84hyIrsPt8G/zS48An7228u+YBHVQCU6f0a2PmdEgmq0Uaa3Z0UFpRSVKXM8wFOsJ+HBrkiL+ORRFbJDeCQkmgLqPi+hbt1JLE1dIQb2AzpvvOn3aw5b7U2zjAOH7M7jAY3dvlvwMIYoTWgSQVYjsZ8lknqB1fmPK1AaNtIYP0JJDhdB2AjCdiBsBzILKR9B3O327g5pDlyhFg1+v4Cq96XYh6xlYzTs/dGBxLPPCh1ptqANynROkEJ/HeTReciBUR7aRxy8KWVO6Unwa8cy2bG0Cx4hyzgepS4YS2dL7MffzRoRptcPolkspse56UWVyWezWJ2tVoyx+XK5hG+nJ3DoRcxpmrIIS83GUkPfzy7xLKNRmuLRrECbjlHc4AbqtGa1eY9OjGl57xhB1yrnkwuTBXtnuCZwEwQJ3uchEdq4VEihnd22dy28XYcbUveVUfgTCmmTNzhetQ/Yp5TaTu0l9V/E4+DwKHTzkyZW1p7YYWsUWwpkNJSDUhSgHSsM/pCvgb6dG6nhyc4Z2tHd2wTgrOCc4cqytigv1rMb/9NZCJL/ygKjQRJA9gSfCUWQfgwFudw1ZWzt2Hdmi+EbZT7bmfhnEKBSm3Hw8SUk9cGMrsnR29wdJGpNJI75M24Ji/jxJozdwp6oSmyQ2hCle5Xf+8GMTHAsO38yJ+YwSJadfwuvAgwATfNmqQ0KZW5kc3RyZWFtDWVuZG9iag00MSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDUzOD4+c3RyZWFtDQpIibxS227bMAx991fw0QJmh/JFsYHAQJvLtmJ7qrGXbhgUW2k8OFYWy1v796VkZx1QFC1QbDBkUaRI8ZzD8srDMI85YMhj+0sjgL7qvNn7a4Tb3psto+8IHMqdx0WYAtLnDJ6kkHAe8gTKg7dAzOZF+cNDd+NcgtsSHM951uApD7MME0qOp+Qbysa4CCLBQ0F2LBDTGDHJaJGdLBEvV5OdUGw++tKIFi++lVfe7Poou8VidlGZQbalujOLzXqzQYywKAq4XC3BG1+hHtefx5OrIaxnVpZ8BHnjw+7EMl8p2LHU1ycYegXMvVGWeL70uzF76DScGKe7vTk1lWl017uLb2A0ztNQvMjoYyfP4sb8D+5n+I/z+fSUD+zMyiMRGCZZRkllTXA/doYlvrLE6CNtfB7mvtw2bWNYHnL/HvRgKBhoIo3OgdmrYKtZFPl3T7iDr1EkYCuJ14k+PTijYjkdoJIdbJXlvQbZQ9O/g+1gnFu2vbYxV3Ns+zUMBHZMY6AtyoRF9BfiMTThlLU8OqQ1qZ9b9VtdyXbq8+fQjMZBdebtUgvx36QW2aulXluEvxgX|||A|||F|||201411201536
OBX|14|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|15|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|16|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|17|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^JVBERi0xLjcNJeLjz9MNCjI0IDAgb2JqDTw8L0xpbmVhcml6ZWQgMS9MIDExMjQxNi9PIDI2L0UgNTQ2MTkvTiAyL1QgMTExODE2L0ggWyA5NzYgMjk3XT4+DWVuZG9iag0gICAgICAgICAgICAgICAgDQp4cmVmDQoyNCAzNA0KMDAwMDAwMDAxNiAwMDAwMCBuDQowMDAwMDAxMjczIDAwMDAwIG4NCjAwMDAwMDE0NDUgMDAwMDAgbg0KMDAwMDAwMTg5OSAwMDAwMCBuDQowMDAwMDAyNDgwIDAwMDAwIG4NCjAwMDAwMDI1MTUgMDAwMDAgbg0KMDAwMDAwMjYyOCAwMDAwMCBuDQowMDAwMDAyODgzIDAwMDAwIG4NCjAwMDAwMDM0NTEgMDAwMDAgbg0KMDAwMDAwNDI0OSAwMDAwMCBuDQowMDAwMDA0MzgzIDAwMDAwIG4NCjAwMDAwMDQ5MjYgMDAwMDAgbg0KMDAwMDAwNTAzNyAwMDAwMCBuDQowMDAwMDA1MDYyIDAwMDAwIG4NCjAwMDAwMDU1NjcgMDAwMDAgbg0KMDAwMDAwNTgyMyAwMDAwMCBuDQowMDAwMDA2MzA4IDAwMDAwIG4NCjAwMDAwMDcwMTYgMDAwMDAgbg0KMDAwMDAwNzYyNCAwMDAwMCBuDQowMDAwMDA4MjE0IDAwMDAwIG4NCjAwMDAwMDg4NzAgMDAwMDAgbg0KMDAwMDAwOTM0NyAwMDAwMCBuDQowMDAwMDA5Nzg3IDAwMDAwIG4NCjAwMDAwMTA0NDMgMDAwMDAgbg0KMDAwMDAxMzA5MiAwMDAwMCBuDQowMDAwMDEzMTYxIDAwMDAwIG4NCjAwMDAwMTMyNjAgMDAwMDAgbg0KMDAwMDAxOTU3NSAwMDAwMCBuDQowMDAwMDE5ODQzIDAwMDAwIG4NCjAwMDAwMjAyNDIgMDAwMDAgbg0KMDAwMDAyODAyNCAwMDAwMCBuDQowMDAwMDM0MzUyIDAwMDAwIG4NCjAwMDAwNTE0OTQgMDAwMDAgbg0KMDAwMDAwMDk3NiAwMDAwMCBuDQp0cmFpbGVyDQo8PC9TaXplIDU4L1Jvb3QgMjUgMCBSL0luZm8gMjMgMCBSL0lEWzxDNzc3RERCRUE2QTE1RDQwODZEMDg2MTlBODBGOEVBOD48RjlDREEyMTExMzgzMTU0MzhGRjlGNzgwQkMzRDZEQzc+XS9QcmV2IDExMTgwNT4+DQpzdGFydHhyZWYNCjANCiUlRU9GDQogICAgICAgICAgICANCjU3IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9JIDI1Mi9MZW5ndGggMjA0L08gMjM2L1MgOTgvVCAxOTE+PnN0cmVhbQ0KaN5iYGDgY2BgqWFgZWA4tZSBmwEBuIFibAwsDBwdDIsUGJY6MKACDiMvnUJWNmFexdDpidNmFzAwMAoKCnYAAVhaUALIagBqBAJ+BsZ514G0PBArgWUlGfiZozg2MASwNsgcaD/Y1JDLwsMYwcAgxyDzoJgxtMmdJYvzDp+C5Ae/RxMYxBi8DFWYz3BvfHJZ+MN2Nz4GceZLDD4wdwgzMC5MANJMIA6TLgMXkGJkwAQqDUBCCKjYFKpAG4jFGRg33YfytwIEGAADmimBDQplbmRzdHJlYW0NZW5kb2JqDTI1IDAgb2JqDTw8L0V4dGVuc2lvbnM8PC9BREJFPDwvQmFzZVZlcnNpb24vMS43L0V4dGVuc2lvbkxldmVsIDM+Pj4+L01ldGFkYXRhIDIyIDAgUi9PdXRsaW5lcyAxOCAwIFIvUGFnZXMgMjEgMCBSL1R5cGUvQ2F0YWxvZy9WaWV3ZXJQcmVmZXJlbmNlczw8L0RpcmVjdGlvbi9MMlI+Pj4+DWVuZG9iag0yNiAwIG9iag08PC9BcnRCb3hbMC4wIDAuMCA2MTIuMCA3OTIuMF0vQmxlZWRCb3hbMC4wIDAuMCA2MTIuMCA3OTIuMF0vQ29udGVudHNbMzIgMCBSIDQwIDAgUiA0MSAwIFIgNDIgMCBSIDQzIDAgUiA0NCAwIFIgNDUgMCBSIDQ2IDAgUl0vQ3JvcEJveFswLjAgMC4wIDYxMi4wIDc5Mi4wXS9NZWRpYUJveFswLjAgMC4wIDYxMi4wIDc5Mi4wXS9QYXJlbnQgMjEgMCBSL1Jlc291cmNlczw8L0NvbG9yU3BhY2U8PC9DUzAgMjggMCBSPj4vRXh0R1N0YXRlPDwvR1MwIDI5IDAgUi9HUzEgMzUgMCBSPj4vRm9udDw8L0MyXzAgMzMgMCBSL1RUMCAyNyAwIFIvVFQxIDM0IDAgUj4+L1Byb2NTZXRbL1BERi9UZXh0L0ltYWdlQ10vWE9iamVjdDw8L0ltMCA1NiAwIFI+Pj4+L1JvdGF0ZSAwL1RhYnMvVy9UaHVtYiAxOSAwIFIvVHJpbUJveFswLjAgMC4wIDYxMi4wIDc5Mi4wXS9UeXBlL1BhZ2U+Pg1lbmRvYmoNMjcgMCBvYmoNPDwvQmFzZUZvbnQvSlhGUU1MK1doaXRuZXktQm9vay9FbmNvZGluZy9XaW5BbnNpRW5jb2RpbmcvRmlyc3RDaGFyIDMyL0ZvbnREZXNjcmlwdG9yIDMwIDAgUi9MYXN0Q2hhciAxNzQvU3VidHlwZS9UcnVlVHlwZS9Ub1VuaWNvZGUgMzEgMCBSL1R5cGUvRm9udC9XaWR0aHNbMjI2IDAgMCAwIDAgMCAwIDAgMzk4IDM5OCAwIDAgMjE5IDM2NCAyMTkgNTE3IDAgMCA1MzUgNTIzIDAgMCAwIDUzMiAwIDAgMjI3IDAgMCAwIDAgMCAwIDY5MSAwIDY0OCA3MDEgNTA0IDQ3NyAwIDcwNSAyNjggMzY0IDAgNDY2IDkwNyA3MDUgNzQ1IDUzMyAwIDU2NyA1MTIgNTgxIDY4MSA2ODAgMCA2MzUgMCAwIDAgMCAwIDAgMCAwIDQ4OSA1MjggNDY2IDUzMSA0OTEgMjk4IDUwMiA1MjMgMjMzIDAgNDY2IDIzNCA4MTkgNTIzIDUyMyA1MzEgNTI4IDM0NCA0MzggMzMwIDUyMyA0NzAgNzMwIDQ3MCA0ODAgNDQ5IDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAyMTkgMzg4IDM4OCAwIDQ1NiAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgNTY2XT4+DWVuZG9iag0yOCAwIG9iag1bL0lDQ0Jhc2VkIDQ3IDAgUl0NZW5kb2JqDTI5IDAgb2JqDTw8L0FJUyBmYWxzZS9CTS9Ob3JtYWwvQ0EgMS4wL09QIGZhbHNlL09QTSAxL1NBIHRydWUvU01hc2svTm9uZS9UeXBlL0V4dEdTdGF0ZS9jYSAxLjAvb3AgZmFsc2U+Pg1lbmRvYmoNMzAgMCBvYmoNPDwvQXNjZW50IDkzOS9DYXBIZWlnaHQgNjkwL0Rlc2NlbnQgLTIwMC9GbGFncyAzMi9Gb250QkJveFstNzYgLTIwMCA5ODAgOTM5XS9Gb250RmFtaWx5KFdoaXRuZXktQm9vaykvRm9udEZpbGUyIDUzIDAgUi9Gb250TmFtZS9KWEZRTUwrV2hpdG5leS1Cb29rL0ZvbnRTdHJldGNoL05vcm1hbC9Gb250V2VpZ2h0IDUwMC9JdGFsaWNBbmdsZSAwL1N0ZW1WIDY4L1R5cGUvRm9udERlc2NyaXB0b3IvWEhlaWdodCA0ODE+Pg1lbmRvYmoNMzEgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0OTg+PnN0cmVhbQ0KSIlck81uozAUhfc8hZftooIk9r1FQpHSpJWymB9NZh6AgJMiNYAcssjbzz2cqiNNpMQfwT58B3C+3e/2fTe5/GcamkOc3Knr2xSvwy010R3jueuzxdK1XTN9Hs2/zaUes9wWH+7XKV72/WnIqsrlv+zkdUp397Bph2N8zPIfqY2p68/u4c/28Ojyw20cP+Il9pMr3Hrt2niyoG/1+L2+RJfPy572rZ3vpvuTrfk34/d9jG45Hy8o0wxtvI51E1Pdn2NWFfZZu+rNPuss9u1/56XgsuOpea9TVi0xuShsMH4mP4NLcgnekrfgHXkHfiW/gt/IdtFqtZzZBuMVeQVWsoI35I2xX8xsgzHne8z3nuzBgRzAQhYwnT2cPZ09nD3z/ZxPfw9/T38Pf09/D39Pfw//wHsScE8CuwR0CXQLcAt0C3ALdAtwC3QLcAt0C3ATdhR0FGYKMoWZgkxhpiBTmCnIFGYKMoX3UHAPhfky57O7oLu8kF/A7C7oLuwu6C7sLugu7C7oruyu6K50VjgrnRXOSmeFs9JZ4ax0VjgrnRXOSmeFs9JZ4ax0Vjgrn5fieZW41rJY4P9yRYZ/6cnwL4UMhw272IAX/vPNxqtvO9R97avmlpJtqXkbz3sJu6jr49dOH4fR2Sp8s78CDAC1afppDQplbmRzdHJlYW0NZW5kb2JqDTMyIDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNzI4Pj5zdHJlYW0NCkiJdFPLctQwELzvV8xRooLj9+MISYWE4hRcXAgH2dauBbLssrRJ9u+ZkbUJoeAQxTuSpnu6W5dXX2PoLcRRVie05g2tWQ1ge7O7/ITbB7uLoUqqqIYySfEvalJY5W6P5diXcC+tQylKU2qUNDmtdbE1SrIytMirEso8CsepHvvamx5NnAGtFa3J1gI5ZP4MIRZ5VAUSH1u6kHlQupUUaSDftjEk0CJKCkSVmGYFlGUdlTm00+47u7m9u39IixIe0rSEG459Eyasg1sptBvhzjhOJbnypGbzsv0XnZZwT1/Szkdf6nmDP+CBjbriTcwi/D2vvGIH/r7I2SXPSrYf1frANyhlQYCRvMHmzw4OPImZNKG9U7MB/qP9vGPA2584+vskSgtor5GydcIMwh8cLOzpgzhPklo88SRH3F/Q+wNSIH0mB+iQzgluvxA3PB0BDQ5Eep46ZZC5GyV0Eiffe054cxsMt+Y93UTaKc8K3LN/cmvfIadvvPYaNcwS9fQCXip0nmoZIG24uiYhPvC8YV72ZdN1OPYOtOfxNCoUV9M0UcoeaZ6gykGZg6ept6mQK41LZDt4q4rn55kRqFgWfaLLApw6jOcR5/6IsxlQ06LlJI0TndLK4V7KTjwnD6mNF78K4nvZ7KyPZBFaGNRH6Y5Kuxc35gmxrHQk3YTTabGS2H5nmQ1iWeiF1ugMyprdhy4hTPi5xQn38ghaGmqUVsIrn3MY1n+FsBcGpLBKn9BRENYn2MqpIzwVEj3DOSukjKV8kH0h7hMFQjga9TFoDAhRRQgg9Fn3edUD9OibwmH+Fn2YsG7dOZ9ObV6eLUcyCIIQ4jXDvQ8+akYuL6vaJJNUCS8FG3ojtU/AakJbL14E//EL35o9KudfbbB+hSPqqQyiP6lBAjbJiMGqpPMnTgTq34fxUPj1jKb5t2vnXuG8kxyUoABNc0eZXUZ01l4gC/gtwACq7XPzDQplbmRzdHJlYW0NZW5kb2JqDTMzIDAgb2JqDTw8L0Jhc2VGb250L1FLUkdHWCtXaGl0bmV5LUJvb2svRGVzY2VuZGFudEZvbnRzIDM2IDAgUi9FbmNvZGluZy9JZGVudGl0eS1IL1N1YnR5cGUvVHlwZTAvVG9Vbmljb2RlIDM3IDAgUi9UeXBlL0ZvbnQ+Pg1lbmRvYmoNMzQgMCBvYmoNPDwvQmFzZUZvbnQvQkxFVUVCK1doaXRuZXktQm9sZC9FbmNvZGluZy9XaW5BbnNpRW5jb2RpbmcvRmlyc3RDaGFyIDMyL0ZvbnREZXNjcmlwdG9yIDM4IDAgUi9MYXN0Q2hhciAxNzQvU3VidHlwZS9UcnVlVHlwZS9Ub1VuaWNvZGUgMzkgMCBSL1R5cGUvRm9udC9XaWR0aHNbMjA5IDAgMCA2NzMgMCAwIDAgMCAwIDAgMCAwIDAgMzU0IDI1OCA1MzAgMCAwIDAgMCAwIDAgMCA1NDEgMCAwIDI2NyAwIDAgMCAwIDAgMCAwIDAgNjA1IDAgNTM1IDUwMyAwIDcwNyAzMDUgMCAwIDQ4NSAwIDAgMCA1NzQgMCA2MTUgNTUzIDYwOSAwIDAgOTkwIDAgMCAwIDAgMCAwIDAgMCAwIDUwNyA1NDEgNDUxIDU0NCA1MDUgMzQxIDUzNCA1MzcgMjYyIDAgMCAyNjIgODExIDUzNyA1MjcgNTQ0IDAgMzc3IDQ2NCAzNjMgNTM3IDUwNyA3MjUgNDk2IDUxMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDAgMCAwIDU2M10+Pg1lbmRvYmoNMzUgMCBvYmoNPDwvQUlTIGZhbHNlL0JNL05vcm1hbC9DQSAxLjAvT1AgdHJ1ZS9PUE0gMC9TQSB0cnVlL1NNYXNrL05vbmUvVHlwZS9FeHRHU3RhdGUvY2EgMS4wL29wIHRydWU+Pg1lbmRvYmoNMzYgMCBvYmoNWzUyIDAgUl0NZW5kb2JqDTM3IDAgb2JqDTw8L0ZpbHRlci9GbGF0ZURlY29kZS9MZW5ndGggNDM1Pj5zdHJlYW0NCkiJXJPNauMwFEb3fgot20WxLesnhWBokgay6MwwaR/AsZXU0MhGcRZ5+yo6pgNjsM1B97PvEbr5erfZ+X4S+Z8wtHs3iWPvu+AuwzW0ThzcqfdZKUXXt9NM6dmemzHLY3h/u0zuvPPHIVsuRf43Ll6mcBMPL91wcI9Z/jt0LvT+JB4+1vtHke+v4/jlzs5PohB1LTp3jB96a8ZfzdmJPMWedl1c76fbU8z8q3i/jU7IxCXNtEPnLmPTutD4k8uWRbxqsdzGq86c7/5bV5bY4dh+NiGVV7E8vp7rRNtEcp2oLKFXiMqqgBRUQhqS0ALS0AtkE0kqFZXSQgp6hgxETs25FbSA1hBdS7pWdF0V0AbCQeEQG0y0hTDSGFV0pumsMlAF0aemT4W7wV2RM+QUOUNOkTNzjn0x7IvC1mCrsDXYKmwNtgpbg21USbSCcDe4a9wN7hp3g7vG3eCucbe4axwsDhoHi4PGweKgcbA4aBwsDhoHi4PGweKgcbA4LO7flIXkf6vNvBM4xmM7n8/7AY5zJn6mo72GEAcjDWOaiPss9N79zOs4jCKm7nf2LcAA6V3tzg0KZW5kc3RyZWFtDWVuZG9iag0zOCAwIG9iag08PC9Bc2NlbnQgOTU0L0NhcEhlaWdodCA2OTAvRGVzY2VudCAtMjAwL0ZsYWdzIDMyL0ZvbnRCQm94Wy03OSAtMjAwIDk5OCA5NTRdL0ZvbnRGYW1pbHkoV2hpdG5leS1Cb2xkKS9Gb250RmlsZTIgNTQgMCBSL0ZvbnROYW1lL0JMRVVFQitXaGl0bmV5LUJvbGQvRm9udFN0cmV0Y2gvTm9ybWFsL0ZvbnRXZWlnaHQgNzAwL0l0YWxpY0FuZ2xlIDAvU3RlbVYgMTUyL1R5cGUvRm9udERlc2NyaXB0b3IvWEhlaWdodCA0OTc+Pg1lbmRvYmoNMzkgMCBvYmoNPDwvRmlsdGVyL0ZsYXRlRGVjb2RlL0xlbmd0aCA0MTU+PnN0cmVhbQ0KSIlck92Ko0AQhe99ir6cuRhMjFbNgARCMgO52B82uw9gtJIVNq10zEXefut4wiysoP1Je4rPssy3+90+9lPIv6ehPdgUTn3skl2HW2otHO3cx2xZhK5vp8fdfG0vzZjlHj7cr5Nd9vE0ZHUd8h++eZ3SPTxtuuFoz1n+LXWW+ngOT7+2h+eQH27j+McuFqewCOt16Ozkhb4049fmYiGfYy/7zvf76f7imX9P/LyPFor5fkmZdujsOjatpSaeLasXfqxD/eHHOrPY/bdfPmLHU/u7SVld4OHFwhfnFXkF3pF34HfyO/iD7MXrlc7si/OGvHEuWadEnbIiV2AhC/iV/Ap+I7+Bt+Stc0W3Cm5VQS7ArF+hflWSSzB9KvjIcmZfnJkVZIVZQVaYFWSFngJPoafAU1hT5pp0FjgLnQXOQmeBs7Bvgr4J+ybom7Bvgr4p30vxXko3hZvSTeGmdFO4Kd0Ubko3hZvSTeGmdFO4Kd0Ubhs6+IJheHx1jIVPb/icufaWko/bPOLznGHC+miff8E4jMFTOLO/AgwAEuPNhg0KZW5kc3RyZWFtDWVuZG9iag00MCAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDYzOD4+c3RyZWFtDQpIiaRUXU/bMBR9z6+4j85EXTtfTaeqEgM6hsQLRNpDQZObmMYjHyh2+Pj3XDspdGUPm1Cl1K3tc88599xkFx6DCadBDNmptyZ51fYF5P6ctHXdNyoXRrWNPoKz8yufhzQgk43QsoBCGAG6FJ1qtkegZffo84hyIrsPt8G/zS48An7228u+YBHVQCU6f0a2PmdEgmq0Uaa3Z0UFpRSVKXM8wFOsJ+HBrkiL+ORRFbJDeCQkmgLqPi+hbt1JLE1dIQb2AzpvvOn3aw5b7U2zjAOH7M7jAY3dvlvwMIYoTWgSQVYjsZ8lknqB1fmPK1AaNtIYP0JJDhdB2AjCdiBsBzILKR9B3O327g5pDlyhFg1+v4Cq96XYh6xlYzTs/dGBxLPPCh1ptqANynROkEJ/HeTReciBUR7aRxy8KWVO6Unwa8cy2bG0Cx4hyzgepS4YS2dL7MffzRoRptcPolkspse56UWVyWezWJ2tVoyx+XK5hG+nJ3DoRcxpmrIIS83GUkPfzy7xLKNRmuLRrECbjlHc4AbqtGa1eY9OjGl57xhB1yrnkwuTBXtnuCZwEwQJ3uchEdq4VEihnd22dy28XYcbUveVUfgTCmmTNzhetQ/Yp5TaTu0l9V/E4+DwKHTzkyZW1p7YYWsUWwpkNJSDUhSgHSsM/pCvgb6dG6nhyc4Z2tHd2wTgrOCc4cqytigv1rMb/9NZCJL/ygKjQRJA9gSfCUWQfgwFudw1ZWzt2Hdmi+EbZT7bmfhnEKBSm3Hw8SUk9cGMrsnR29wdJGpNJI75M24Ji/jxJozdwp6oSmyQ2hCle5Xf+8GMTHAsO38yJ+YwSJadfwuvAgwATfNmqQ0KZW5kc3RyZWFtDWVuZG9iag00MSAwIG9iag08PC9GaWx0ZXIvRmxhdGVEZWNvZGUvTGVuZ3RoIDUzOD4+c3RyZWFtDQpIibxS227bMAx991fw0QJmh/JFsYHAQJvLtmJ7qrGXbhgUW2k8OFYWy1v796VkZx1QFC1QbDBkUaRI8ZzD8srDMI85YMhj+0sjgL7qvNn7a4Tb3psto+8IHMqdx0WYAtLnDJ6kkHAe8gTKg7dAzOZF+cNDd+NcgtsSHM951uApD7MME0qOp+Qbysa4CCLBQ0F2LBDTGDHJaJGdLBEvV5OdUGw++tKIFi++lVfe7Poou8VidlGZQbalujOLzXqzQYywKAq4XC3BG1+hHtefx5OrIaxnVpZ8BHnjw+7EMl8p2LHU1ycYegXMvVGWeL70uzF76DScGKe7vTk1lWl017uLb2A0ztNQvMjoYyfP4sb8D+5n+I/z+fSUD+zMyiMRGCZZRkllTXA/doYlvrLE6CNtfB7mvtw2bWNYHnL/HvRgKBhoIo3OgdmrYKtZFPl3T7iDr1EkYCuJ14k+PTijYjkdoJIdbJXlvQbZQ9O/g+1gnFu2vbYxV3Ns+zUMBHZMY6AtyoRF9BfiMTThlLU8OqQ1qZ9b9VtdyXbq8+fQjMZBdebtUgvx36QW2aulXluEvxgX|||A|||F|||201411201536
OBX|18|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|19|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536
OBX|20|ED|PDF^Display format in PDF^AUSPDI||^TX^PDF^Base64^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|||A|||F|||201411201536";
[Test]
public void TestParseLargeEmbeddedFiles()
{
Console.WriteLine(ParseLargeEmbeddedFileMessageTimes(100));
}
private static ITestResultSummary ParseLargeEmbeddedFileMessageTimes(int count)
{
var parser = new PipeParser();
var oru = new ORU_R01();
private static void Example1()
{
// initialize a new test group
var testGroup = new TestGroup("Example1");
// create a test (in the form of an Action delegate) but don't run it yet
// when executed, the test will invoke the Action delegate 5 times and time
// how long it took each time
var test = testGroup.Plan("Test1", () => { }, 5);
// calling GetResult() executes the test
var testResult = test.GetResult();
// the outcome (how long did it take, was an unhandled exception thrown?)
// for each test run is tracked
var testOutcomes = testResult.Outcomes;
// let's take a look at the TestOutcome object
var firstTestOutcome = testOutcomes.First();
var elapsed = firstTestOutcome.Elapsed; // a TimeSpan object
var exception = firstTestOutcome.Exception; // null if no exception
// you can use the TestResult object to analyse your test, but it's often
// useful to get a summary
var testResultSummary = testResult.GetSummary();
Console.WriteLine(testResultSummary);
/* prints out something along the line of
*
* Test Group [Example1], Test [Test1] results summary:
* Successes [5]
* Failures [0]
* Average Exec Time [...] milliseconds
*
*/
}
protected bool ShouldRun(TestGroup testGroup)
{
#if SkipMigrationsTests
if (testGroup == TestGroup.MigrationsTests)
{
return false;
}
#endif
#if SkipSlowTests
if (testGroup != TestGroup.Default)
{
return false;
}
#endif
if (SkipForSqlAzure)
{
var connectionString = ConfigurationManager.AppSettings["BaseConnectionString"];
if (DatabaseTestHelpers.IsSqlAzure(connectionString))
{
return false;
}
}
if (SkipForLocalDb)
{
var connectionString = ConfigurationManager.AppSettings["BaseConnectionString"];
if (DatabaseTestHelpers.IsLocalDb(connectionString))
{
return false;
}
}
return true;
}
private static void Example4()
{
// initialize a new test group
var testGroup = new TestGroup("Example4");
var sleepIntervals = new[] { 2, 3, 4, 5, 11 };
var index = 0;
// plans a test which puts the thread to sleep for 2, 3, 4, 5 and then 11 seconds, zzz....
var test = testGroup.Plan("Test1", () => Thread.Sleep(TimeSpan.FromSeconds(sleepIntervals[index++])), 5);
// execute the test runs and get the result
var testResult = test.GetResult();
// summaries the result whilst considering all the test outcomes
var resultSummaryDefault = testResult.GetSummary();
// alternatively, provide a filter so that when the average execution time is calculated, the min
// and max times are not considered
var resultSummaryExcludeMinAndMax = testResult.GetSummary(new ExcludeMinAndMaxTestOutcomeFilter());
Console.WriteLine(resultSummaryDefault);
/* prints out something along the line of:
*
* Test Group [Example4], Test [Test1] results summary:
* Successes [5]
* Failures [0]
* Average Exec Time [5000.05438] milliseconds
*
*/
Console.WriteLine(resultSummaryExcludeMinAndMax);
/* prints out something along the line of:
*
* Test Group [Example4], Test [Test1] results summary:
* Successes [5]
* Failures [0]
* Average Exec Time [4000.1766] milliseconds
*
*/
}
public void Delete(TestGroup testGroup)
{
Delete(testGroup.Id);
}
public int Insert(int projectId, string name, bool isActive)
{
using (var client = new HttpClient(_messageHandler, false))
{
client.BaseAddress = new Uri(_baseAddress);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var testGroup = new TestGroup
{
ProjectId = projectId,
Name = name,
IsActive = isActive
};
var response = client.PostAsync(UrlBase, testGroup, new JsonMediaTypeFormatter()).Result;
response.EnsureSuccessStatusCode();
var responseString = response.Content.ReadAsStringAsync().Result;
var returnValue = Convert.ToInt32(responseString);
return returnValue;
}
}
public void Update(TestGroup testGroup)
{
_dbRepository.Update(testGroup.ProjectId, testGroup.Name, testGroup.IsActive, testGroup.Id);
}
public int Insert(TestGroup testGroup)
{
return _dbRepository.Insert(testGroup.ProjectId, testGroup.Name, testGroup.IsActive);
}
public int Insert(TestGroup testGroup)
{
return Insert(testGroup.ProjectId, testGroup.Name, testGroup.IsActive);
}
public void Update(TestGroup testGroup)
{
Update(testGroup.ProjectId, testGroup.Name, testGroup.IsActive, testGroup.Id);
}
protected virtual Test GetTest(Action action, int count, string testName = TestName, TestGroup testGroup = null)
{
return new Test(testName, action, count, testGroup ?? GetTestGroup());
}
public Options(TestContext context)
{
this.TestContext = context;
this.Group = TestGroup.Get(context.TestName);
RootDirectory = Path.GetFullPath(RelativeRoot);
this.instance = this.Group.Instance;
var dataRow = context.DataRow;
if (dataRow != null)
{
SourceFile = LoadString(dataRow, "Name");
FoxtrotOptions = LoadString(dataRow, "FoxtrotOptions");
UseContractReferenceAssemblies = LoadBool("ContractReferenceAssemblies", dataRow, true);
CompilerOptions = LoadString(dataRow, "CompilerOptions");
References = LoadList(dataRow, "References", "mscorlib.dll", "System.dll", "ClousotTestHarness.dll");
libPaths = LoadList(dataRow, "LibPaths", MakeAbsolute(TestHarnessDirectory));
compilerCode = LoadString("Compiler", dataRow, "CS");
UseBinDir = LoadBool("BinDir", dataRow, false);
UseExe = LoadBool("UseExe", dataRow, true);
MustSucceed = LoadBool("MustSucceed", dataRow, true);
}
}
public static TestGroup Get(string testGroupName)
{
TestGroup result;
if (!testGroups.TryGetValue(testGroupName, out result))
{
result = new TestGroup();
testGroups.Add(testGroupName, result);
}
else
{
result.Increment();
}
return result;
}
