public bool Equals(Asp330SequenceTest that)
{
if (that is null)
{
return(false);
}
if (ReferenceEquals(this, that))
{
return(true);
}
if (!SequenceId.Equals(that.SequenceId))
{
return(false);
}
if (!TestId.Equals(that.TestId))
{
return(false);
}
if (!SequenceName.Equals(that.SequenceName))
{
return(false);
}
if (!TestName.Equals(that.TestName))
{
return(false);
}
if (!TestTableName.Equals(that.TestTableName))
{
return(false);
}
return(true);
}
//implemented methods
public override void InputFormFields()
{
if (Data.TestId != null)
{
//TestId.MouseOverAndClick(TestId);
TestId.Clear();
TestId.SendKeys(Data.TestId);
}
if (Data.Subject != null)
{
SubjectSelect.Wait().SelectByText(Data.Subject);
}
if (Data.RecentlyViewedTests != null)
{
RecentlyViewedTests.SelectByText(Data.RecentlyViewedTests);
}
if (Data.GradeLevelFrom != null)
{
GradeFromSelect.Wait().SelectByText(Data.GradeLevelFrom);
}
if (Data.GradeLevelTo != null)
{
GradeToSelect.Wait().SelectByText(Data.GradeLevelTo);
}
}
public void JsonUtility_ToJson_should_generate_String()
{
Assert.Equal(
"\"1234\"",
JsonUtility.ToJson(TestId.Parse("1234"))
);
}
public Test(TFunc inFunc, TFunc outFunc, TestId id, string name)
{
InFunc = inFunc;
OutFunc = outFunc;
Id = id;
Name = name;
}
//-------------------------------------------------------------------------
public virtual void test_requirements()
{
CalculationFunctions functions = CalculationFunctions.of(ImmutableMap.of(typeof(TestTarget), new TestFunction()));
CalculationRules calculationRules = CalculationRules.of(functions, USD);
IList <TestTarget> targets = ImmutableList.of(TARGET1);
IList <Column> columns = ImmutableList.of(Column.of(TestingMeasures.PRESENT_VALUE));
CalculationTasks test = CalculationTasks.of(calculationRules, targets, columns);
MarketDataRequirements requirements = test.requirements(REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<? extends com.opengamma.strata.data.MarketDataId<?>> nonObservables = requirements.getNonObservables();
ISet <MarketDataId <object> > nonObservables = requirements.NonObservables;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.google.common.collect.ImmutableSet<? extends com.opengamma.strata.data.ObservableId> observables = requirements.getObservables();
ImmutableSet <ObservableId> observables = requirements.Observables;
ImmutableSet <ObservableId> timeSeries = requirements.TimeSeries;
assertThat(nonObservables).hasSize(1);
assertThat(nonObservables.GetEnumerator().next()).isEqualTo(TestId.of("1"));
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> observableId = com.opengamma.strata.calc.marketdata.TestObservableId.of("2", CalculationTaskTest.OBS_SOURCE);
MarketDataId <object> observableId = TestObservableId.of("2", CalculationTaskTest.OBS_SOURCE);
assertThat(observables).hasSize(1);
assertThat(observables.GetEnumerator().next()).isEqualTo(observableId);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> timeSeriesId = com.opengamma.strata.calc.marketdata.TestObservableId.of("3", CalculationTaskTest.OBS_SOURCE);
MarketDataId <object> timeSeriesId = TestObservableId.of("3", CalculationTaskTest.OBS_SOURCE);
assertThat(timeSeries).hasSize(1);
assertThat(timeSeries.GetEnumerator().next()).isEqualTo(timeSeriesId);
}
public virtual void requirements()
{
CalculationTaskCell cell = CalculationTaskCell.of(0, 0, TestingMeasures.PRESENT_VALUE, NATURAL);
CalculationTask task = CalculationTask.of(TARGET, new TestFunction(), cell);
MarketDataRequirements requirements = task.requirements(REF_DATA);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: java.util.Set<? extends com.opengamma.strata.data.MarketDataId<?>> nonObservables = requirements.getNonObservables();
ISet <MarketDataId <object> > nonObservables = requirements.NonObservables;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.google.common.collect.ImmutableSet<? extends com.opengamma.strata.data.ObservableId> observables = requirements.getObservables();
ImmutableSet <ObservableId> observables = requirements.Observables;
ImmutableSet <ObservableId> timeSeries = requirements.TimeSeries;
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> timeSeriesId = com.opengamma.strata.calc.marketdata.TestObservableId.of("3", OBS_SOURCE);
MarketDataId <object> timeSeriesId = TestObservableId.of("3", OBS_SOURCE);
assertThat(timeSeries).hasSize(1);
assertThat(timeSeries.GetEnumerator().next()).isEqualTo(timeSeriesId);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> nonObservableId = new com.opengamma.strata.calc.marketdata.TestId("1");
MarketDataId <object> nonObservableId = new TestId("1");
assertThat(nonObservables).hasSize(1);
assertThat(nonObservables.GetEnumerator().next()).isEqualTo(nonObservableId);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> observableId = com.opengamma.strata.calc.marketdata.TestObservableId.of("2", OBS_SOURCE);
MarketDataId <object> observableId = TestObservableId.of("2", OBS_SOURCE);
assertThat(observables).hasSize(1);
assertThat(observables.GetEnumerator().next()).isEqualTo(observableId);
}
public void CanSerializePrimitiveValueObjectToJson()
{
var value = new TestId(123);
var json = WriteJson(value);
Validate(json, "123");
}
public void Equals_WhenSameTypeButDifferentUnderlyingValue_ReturnsFalse()
{
var id1 = TestId.NewId();
var id2 = TestId.NewId();
id1.Should().NotBeSameAs(id2);
}
public void Operator_Equals_will_test_value_equality()
{
var left = TestId.Parse("9121e62543b5881d5ff2e04a9dd6ae231c55da3122a98dc4379177617955af10");
var right = TestId.Parse("9121e62543b5881d5ff2e04a9dd6ae231c55da3122a98dc4379177617955af10");
Assert.True(left == right);
}
public void JsonUtility_LoadJson_should_parse_String()
{
Assert.Equal(
TestId.Parse("1234"),
JsonUtility.LoadJson <TestId>("\"1234\"")
);
}
protected async Task PublishPingCommandAsync(TestId testId, int count = 1)
{
for (var i = 0; i < count; i++)
{
await CommandBus.PublishAsync(new PingCommand(testId, PingId.New), CancellationToken.None).ConfigureAwait(false);
}
}
public ArkadeTestMock(TestId testId, string name, TestType testType, string description = null)
{
_testId = testId;
_name = name;
_testType = testType;
_description = description;
}
public async Task <JsonResult> Post([FromBody] TestId testId)
{
string error = "";
JsonResult response = null;
try
{
if (testId == null || !testId.IsValid(ref error))
{
response = new JsonResult(error);
response.StatusCode = 400;
}
else
{
TestRunnerResponse testRunnerResponse = await _serviceFabricTestRunner.RunTestCase(testId);
response = new JsonResult(testRunnerResponse);
if (testRunnerResponse == null)
{
response.StatusCode = 404;
}
else if (testRunnerResponse.HasError)
{
response.StatusCode = 500;
}
}
}
catch (Exception ex)
{
response = new JsonResult(ex);
response.StatusCode = 500;
}
return(response);
}
public async Task <IHttpActionResult> Ping(string id)
{
var testId = TestId.With(id);
var pingCommand = new PingCommand(testId, PingId.New);
await _commandBus.PublishAsync(pingCommand, CancellationToken.None).ConfigureAwait(false);
return(Ok());
}
public void NewIsValid()
{
// Arrange
var testId = TestId.New;
// Assert
TestId.IsValid(testId.Value).Should().BeTrue();
}
public void NewDeterministic_IsValid()
{
// Arrange
var testId = TestId.NewDeterministic(Guid.NewGuid(), Guid.NewGuid().ToString());
// Assert
TestId.IsValid(testId.Value).Should().BeTrue(testId.Value);
}
public AggregateProjectionTests()
{
var id = new TestId();
var aggregate = new TestAggregate(id);
aggregate.AddEvent1();
aggregate.AddEvent2();
_aggregate = aggregate;
}
public void Equals_WhenSameTypeAndUnderlyingValue_ReturnsTrue()
{
var backingValue = Guid.NewGuid();
var id1 = new TestId(backingValue);
var id2 = new TestId(backingValue);
id1.Should().Be(id2);
}
public void NotEqualWhenIdsAreDifferent()
{
var left = new TestId(1);
var right = new TestId(2);
left.Equals(right as object).Should().BeFalse();
left.Equals(right).Should().BeFalse();
(left == right).Should().BeFalse();
(left != right).Should().BeTrue();
}
public void Constructor_NoIdProvided_IsCreatedWithGeneratedId()
{
// Arrange
// Act
var id = new TestId();
// Assert
Assert.That(id.Id, Is.Not.EqualTo(Guid.Empty));
}
public void DifferentAreNotEqual()
{
// Arrange
var id1 = TestId.With("test-7ddc487f-02ad-4be3-a6ef-71203d333c61");
var id2 = TestId.With("test-d15b1562-11f2-4645-8b1a-f8b946b566d3");
// Assert
id1.Equals(id2).Should().BeFalse();
(id1 == id2).Should().BeFalse();
}
public void SameIdsAreEqual()
{
// Arrange
const string value = "test-d15b1562-11f2-4645-8b1a-f8b946b566d3";
var id1 = TestId.With(value);
var id2 = TestId.With(value);
// Assert
id1.Equals(id2).Should().BeTrue();
(id1 == id2).Should().BeTrue();
}
public void ManuallyCreatedIsOk()
{
// Arrange
const string value = "test-d15b1562-11f2-4645-8b1a-f8b946b566d3";
// Act
var testId = TestId.With(value);
// Test
testId.Value.Should().Be(value);
}
public void Constructor_StringProvided_IsCreatedWithGuidOfProvidedStringAsId()
{
// Arrange
const string guidString = "7a8336a2-dc2e-478c-a45e-b79212b93d8d";
// Act
var id = new TestId(guidString);
// Assert
Assert.That(id.Id, Is.EqualTo(new Guid(guidString)));
}
public void Constructor_GuidProvided_IsCreatedWithProvidedGuidAsId()
{
// Arrange
var guid = new Guid("afa60c9b-3d66-4e0a-ac16-50921a90f724");
// Act
var id = new TestId(guid);
// Assert
Assert.That(id.Id, Is.EqualTo(guid));
}
public void ToString_ReturnsTheStringValueOfTheId()
{
// Arrange
var id = new TestId("10c8f55a-ddda-484d-bf98-53cbf41f66c1");
// Act
var result = id.ToString();
// Assert
Assert.That(result, Is.EqualTo("10c8f55a-ddda-484d-bf98-53cbf41f66c1"));
}
private static void InjectExitUtCallInsideMethodWiseFinally(
ModuleDefinition mod,
MethodDefinition meth, TestId testId, MethodReference exitMarkerMethodRef)
{
ILProcessor ilProcessor = meth.Body.GetILProcessor();
var firstInstruction = FindFirstInstructionSkipCtor(meth);
Instruction returnInstruction = FixReturns(meth, mod);
var beforeReturn = Instruction.Create(OpCodes.Endfinally);
ilProcessor.InsertBefore(returnInstruction, beforeReturn);
/////////////// Start of try block
Instruction nopInstruction1 = Instruction.Create(OpCodes.Nop);
ilProcessor.InsertBefore(firstInstruction, nopInstruction1);
//////// Start Finally block
Instruction nopInstruction2 = Instruction.Create(OpCodes.Nop);
ilProcessor.InsertBefore(beforeReturn, nopInstruction2);
Instruction instrMarker = nopInstruction2;
Instruction instr = null;
// IL_000d: call void R4nd0mApps.TddStud10.TestHost.Marker::EnterUnitTest(ldstr)
instr = ilProcessor.Create(OpCodes.Call, exitMarkerMethodRef);
ilProcessor.InsertBefore(instrMarker, instr);
instrMarker = instr;
// IL_0006: ldstr <string>
instr = ilProcessor.Create(OpCodes.Ldstr, testId.location.line.Item.ToString(CultureInfo.InvariantCulture));
ilProcessor.InsertBefore(instrMarker, instr);
instrMarker = instr;
// IL_0006: ldstr <string>
instr = ilProcessor.Create(OpCodes.Ldstr, testId.location.document.Item);
ilProcessor.InsertBefore(instrMarker, instr);
instrMarker = instr;
// IL_0006: ldstr <string>
instr = ilProcessor.Create(OpCodes.Ldstr, testId.source.Item);
ilProcessor.InsertBefore(instrMarker, instr);
instrMarker = instr;
///////// End finally block
var handler = new ExceptionHandler(ExceptionHandlerType.Finally)
{
TryStart = nopInstruction1,
TryEnd = instrMarker,
HandlerStart = instrMarker,
HandlerEnd = returnInstruction,
};
meth.Body.ExceptionHandlers.Add(handler);
}
public void GetHashCodeTest()
{
var testId1 = new TestId(10);
var testId2 = new TestId(10);
Assert.Equal(testId1.GetHashCode(), testId2.GetHashCode());
var testId3 = new TestId(11);
Assert.NotEqual(testId1.GetHashCode(), testId3.GetHashCode());
}
public void EqualWhenIdsAreEqual()
{
var left = new TestId(1);
var right = new TestId(1);
left.Equals(right as object).Should().BeTrue();
left.Equals(right).Should().BeTrue();
(left == right).Should().BeTrue();
(left != right).Should().BeFalse();
left.GetHashCode().Should().Be(right.GetHashCode());
}
private void GetExtendedResultsExcelInfo()
{
connection.SendCommand(
new RequestInfo(
"GetExtendedResultSheet",
SequrityUtils.Encrypt(
TestId.ToString(),
connection.User.SecretKey),
connection.User.UserToken),
onExtendedResultsExcelInfoRecive);
}
protected long GetTestId(TestId key)
{
return long.Parse(ConfigurationManager.AppSettings["Test_" + key.ToString()]);
}
