public void Permutate32BitText_ExpectNotEqualTexts()
{
var input = _block.ConvertStringToBinaryString("ABcd");
var permutedText = _block.Permutate32BitText(input);
Assert.AreNotEqual(input, permutedText);
}
public async Task SiloUngracefulShutdown_OutstandingRequestsBreak()
{
var grain = HostedCluster.GrainFactory.GetGrain <ILongRunningTaskGrain <bool> >(Guid.NewGuid());
var instanceId = await grain.GetRuntimeInstanceId();
var target = HostedCluster.GrainFactory.GetGrain <ILongRunningTaskGrain <bool> >(Guid.NewGuid());
var targetInstanceId = await target.GetRuntimeInstanceId();
Assert.AreNotEqual(instanceId, targetInstanceId, "Activations must be placed on different silos");
var promise = instanceId.Contains(HostedCluster.Primary.Endpoint.ToString()) ?
grain.CallOtherLongRunningTask(target, true, TimeSpan.FromSeconds(7))
: target.CallOtherLongRunningTask(grain, true, TimeSpan.FromSeconds(7));
await Task.Delay(500);
HostedCluster.KillSilo(HostedCluster.SecondarySilos[0]);
try
{
await promise;
Assert.Fail("The broken promise exception was not thrown");
}
catch (Exception ex)
{
Assert.AreEqual(typeof(SiloUnavailableException), ex.GetBaseException().GetType());
}
}
public void ServiceId_SiloRestart()
{
Guid configServiceId = this.HostedCluster.Globals.ServiceId;
var initialDeploymentId = this.HostedCluster.DeploymentId;
output.WriteLine("DeploymentId={0} ServiceId={1}", this.HostedCluster.DeploymentId, ServiceId);
Assert.AreEqual(ServiceId, configServiceId, "ServiceId in test config");
output.WriteLine("About to reset Silos .....");
output.WriteLine("Stopping Silos ...");
this.HostedCluster.StopDefaultSilos();
output.WriteLine("Starting Silos ...");
this.HostedCluster.RedeployTestingSiloHost(SiloOptions);
output.WriteLine("..... Silos restarted");
output.WriteLine("DeploymentId={0} ServiceId={1}", this.HostedCluster.DeploymentId, this.HostedCluster.Globals.ServiceId);
Assert.AreEqual(ServiceId, this.HostedCluster.Globals.ServiceId, "ServiceId same after restart.");
Assert.AreNotEqual(initialDeploymentId, this.HostedCluster.DeploymentId, "DeploymentId different after restart.");
SiloHandle siloHandle = this.HostedCluster.GetActiveSilos().First();
Guid serviceId = siloHandle.Silo.GlobalConfig.ServiceId;
Assert.AreEqual(ServiceId, serviceId, "ServiceId in Silo config");
serviceId = siloHandle.Silo.TestHook.ServiceId;
Assert.AreEqual(ServiceId, serviceId, "ServiceId active in silo");
// ServiceId is not currently available in client config
//serviceId = ClientProviderRuntime.Instance.GetServiceId();
//Assert.AreEqual(initialServiceId, serviceId, "ServiceId active in client");
}
public async Task SMS_Limits_FindMax_Consumers()
{
// 1 Stream, 1 Producer, X Consumers
Guid streamId = Guid.NewGuid();
string streamProviderName = StreamTestsConstants.SMS_STREAM_PROVIDER_NAME;
output.WriteLine("Starting search for MaxConsumersPerStream value using stream {0}", streamId);
IStreamLifecycleProducerGrain producer = GrainClient.GrainFactory.GetGrain <IStreamLifecycleProducerGrain>(Guid.NewGuid());
await producer.BecomeProducer(streamId, this.StreamNamespace, streamProviderName);
int loopCount = 0;
try
{
// Loop until something breaks!
for (loopCount = 1; loopCount <= MaxExpectedPerStream; loopCount++)
{
IStreamLifecycleConsumerGrain consumer = GrainClient.GrainFactory.GetGrain <IStreamLifecycleConsumerGrain>(Guid.NewGuid());
await consumer.BecomeConsumer(streamId, this.StreamNamespace, streamProviderName);
}
}
catch (Exception exc)
{
output.WriteLine("Stopping loop at loopCount={0} due to exception {1}", loopCount, exc);
}
MaxConsumersPerStream = loopCount - 1;
output.WriteLine("Finished search for MaxConsumersPerStream with value {0}", MaxConsumersPerStream);
Assert.AreNotEqual(0, MaxConsumersPerStream, "MaxConsumersPerStream should be greater than zero.");
output.WriteLine("MaxConsumersPerStream={0}", MaxConsumersPerStream);
}
public void CodeGen_EncounteredFullySpecifiedInterfacesAreEncodedDistinctly()
{
var id1 = GrainInterfaceUtils.ComputeInterfaceId(typeof(IFullySpecified <int>));
var id2 = GrainInterfaceUtils.ComputeInterfaceId(typeof(IFullySpecified <long>));
Assert.AreNotEqual(id1, id2);
}
public async Task PrimaryKeyExtensionsShouldDifferentiateGrainsUsingTheSameBasePrimaryKey()
{
var baseKey = Guid.NewGuid();
const string kx1 = "1";
const string kx2 = "2";
var grain1 = GrainClient.GrainFactory.GetGrain <IKeyExtensionTestGrain>(baseKey, kx1, null);
var grainId1 = await grain1.GetGrainReference();
var activationId1 = await grain1.GetActivationId();
var grain2 = GrainClient.GrainFactory.GetGrain <IKeyExtensionTestGrain>(baseKey, kx2, null);
var grainId2 = await grain2.GetGrainReference();
var activationId2 = await grain2.GetActivationId();
Assert.AreNotEqual(
grainId1,
grainId2,
"Mismatched key extensions should differentiate an identical base primary key.");
Assert.AreNotEqual(
activationId1,
activationId2,
"Mismatched key extensions should differentiate an identical base primary key.");
}
public void GrainID_AsGuid()
{
string guidString = "0699605f-884d-4343-9977-f40a39ab7b2b";
Guid grainIdGuid = Guid.Parse(guidString);
GrainId grainId = GrainId.GetGrainIdForTesting(grainIdGuid);
//string grainIdToKeyString = grainId.ToKeyString();
string grainIdToFullString = grainId.ToFullString();
string grainIdToGuidString = GrainIdToGuidString(grainId);
string grainIdKeyString = grainId.Key.ToString();
output.WriteLine("Guid={0}", grainIdGuid);
output.WriteLine("GrainId={0}", grainId);
//output.WriteLine("GrainId.ToKeyString={0}", grainIdToKeyString);
output.WriteLine("GrainId.Key.ToString={0}", grainIdKeyString);
output.WriteLine("GrainIdToGuidString={0}", grainIdToGuidString);
output.WriteLine("GrainId.ToFullString={0}", grainIdToFullString);
// Equal: Public APIs
//Assert.AreEqual(guidString, grainIdToKeyString, "GrainId.ToKeyString");
Assert.AreEqual(guidString, grainIdToGuidString, "GrainIdToGuidString");
// Equal: Internal APIs
Assert.AreEqual(grainIdGuid, grainId.GetPrimaryKey(), "GetPrimaryKey Guid");
// NOT-Equal: Internal APIs
Assert.AreNotEqual(guidString, grainIdKeyString, "GrainId.Key.ToString");
}
public async Task PrimaryKeyExtensionsShouldDifferentiateGrainsUsingDifferentBaseKeys()
{
var baseKey1 = Guid.NewGuid();
var baseKey2 = Guid.NewGuid();
const string kx = "1";
var grain1 = GrainClient.GrainFactory.GetGrain <IKeyExtensionTestGrain>(baseKey1, kx, null);
var grainId1 = await grain1.GetGrainReference();
var activationId1 = await grain1.GetActivationId();
var grain2 = GrainClient.GrainFactory.GetGrain <IKeyExtensionTestGrain>(baseKey2, kx, null);
var grainId2 = await grain2.GetGrainReference();
var activationId2 = await grain2.GetActivationId();
Assert.AreNotEqual(
grainId1,
grainId2,
"Mismatched base keys should differentiate between identical extended keys.");
Assert.AreNotEqual(
activationId1,
activationId2,
"Mismatched base keys should differentiate between identical extended keys.");
}
public async Task PreferLocalPlacementGrain_ShouldMigrateWhenHostSiloKilled(string value)
{
await HostedCluster.WaitForLivenessToStabilizeAsync();
output.WriteLine("******************** Starting test ({0}) ********************", value);
TestSilosStarted(2);
foreach (SiloHandle silo in HostedCluster.GetActiveSilos())
{
NodeConfiguration cfg = silo.Silo.LocalConfig;
Assert.IsNotNull(cfg, "NodeConfiguration should be present for silo " + silo);
output.WriteLine(
"Silo {0} : Address = {1} Proxy gateway: {2}",
cfg.SiloName, cfg.Endpoint, cfg.ProxyGatewayEndpoint);
}
IPEndPoint targetSilo;
if (value == "Primary")
{
targetSilo = HostedCluster.Primary.Endpoint;
}
else
{
targetSilo = HostedCluster.Secondary.Endpoint;
}
Guid proxyKey;
IRandomPlacementTestGrain proxy;
IPEndPoint expected;
do
{
proxyKey = Guid.NewGuid();
proxy = GrainFactory.GetGrain <IRandomPlacementTestGrain>(proxyKey);
expected = await proxy.GetEndpoint();
} while (!targetSilo.Equals(expected));
output.WriteLine("Proxy grain was originally located on silo {0}", expected);
Guid grainKey = proxyKey;
await proxy.StartPreferLocalGrain(grainKey);
IPreferLocalPlacementTestGrain grain = GrainFactory.GetGrain <IPreferLocalPlacementTestGrain>(grainKey);
IPEndPoint actual = await grain.GetEndpoint();
output.WriteLine("PreferLocalPlacement grain was originally located on silo {0}", actual);
Assert.AreEqual(expected, actual,
"PreferLocalPlacement strategy should create activations on the local silo.");
SiloHandle siloToKill = HostedCluster.GetActiveSilos().First(s => s.Endpoint.Equals(expected));
output.WriteLine("Killing silo {0} hosting locally placed grain", siloToKill);
HostedCluster.StopSilo(siloToKill);
IPEndPoint newActual = await grain.GetEndpoint();
output.WriteLine("PreferLocalPlacement grain was recreated on silo {0}", newActual);
Assert.AreNotEqual(expected, newActual,
"PreferLocalPlacement strategy should recreate activations on other silo if local fails.");
}
public void ToMD5_PassIncorrectSentence_ReturnInCorrectEncryption()
{
string input = "The quickXXX brown fox jumps over the lazy dog";
string expected = "9e107d9d372bb6826bd81d3542a419d6";
string actual = input.ToMD5();
Assert.AreNotEqual(expected, actual);
}
public void Encrypt_PassString_IncorrectPassPhrase_NotEncrypted()
{
var str = "this string will be encrypted";
var encryptedString = str.Encrypt("pp for encryption");
var decryptedString = encryptedString.Decrypt("wrong pp for encryption");
Assert.AreNotEqual(str, decryptedString);
}
public void Interning_SiloAddress2()
{
SiloAddress a1 = SiloAddress.New(new IPEndPoint(IPAddress.Loopback, 1111), 12345);
SiloAddress a2 = SiloAddress.New(new IPEndPoint(IPAddress.Loopback, 2222), 12345);
Assert.AreNotEqual(a1, a2, "Should not be equal SiloAddress's");
Assert.AreNotSame(a1, a2, "Should not be same / intern'ed SiloAddress object");
}
public void InsertPlainttextIntoEncrpytion_expectSomeCipherText_withGenericKey()
{
var plainText = "abc123av";
var key = "12345678";
var cipherText = _logic.Encrypt(plainText, key);
Assert.AreNotEqual(plainText, cipherText);
}
private Task Test_Stream_Churn_NumStreams(
string streamProviderName,
int pipelineSize,
int numStreams,
int numConsumers = 9,
int numProducers = 1,
bool warmUpPubSub = true,
bool normalSubscribeCalls = true)
{
output.WriteLine("Testing churn with {0} Streams with {1} Consumers and {2} Producers per Stream NormalSubscribe={3}",
numStreams, numConsumers, numProducers, normalSubscribeCalls);
AsyncPipeline pipeline = new AsyncPipeline(pipelineSize);
var promises = new List <Task>();
// Create streamId Guids
Guid[] streamIds = new Guid[numStreams];
for (int i = 0; i < numStreams; i++)
{
streamIds[i] = Guid.NewGuid();
}
if (warmUpPubSub)
{
WarmUpPubSub(streamProviderName, streamIds, pipeline);
pipeline.Wait();
int activePubSubGrains = ActiveGrainCount(typeof(PubSubRendezvousGrain).FullName);
Assert.AreEqual(streamIds.Length, activePubSubGrains, "Initial PubSub count -- should all be warmed up");
}
int activeConsumerGrains = ActiveGrainCount(typeof(StreamLifecycleConsumerGrain).FullName);
Assert.AreEqual(0, activeConsumerGrains, "Initial Consumer count should be zero");
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < numStreams; i++)
{
Task promise = SetupOneStream(streamIds[i], streamProviderName, pipeline, numConsumers, numProducers, normalSubscribeCalls);
promises.Add(promise);
}
Task.WhenAll(promises).Wait();
sw.Stop();
int consumerCount = ActiveGrainCount(typeof(StreamLifecycleConsumerGrain).FullName);
Assert.AreEqual(activeConsumerGrains + (numStreams * numConsumers), consumerCount, "The correct number of new Consumer grains are active");
TimeSpan elapsed = sw.Elapsed;
int totalSubscriptions = numStreams * numConsumers;
double rps = totalSubscriptions / elapsed.TotalSeconds;
output.WriteLine("Subscriptions-per-second = {0} during period {1}", rps, elapsed);
Assert.AreNotEqual(0.0, rps, "RPS greater than zero");
return(TaskDone.Done);
}
public void TestIncome()
{
game.Person.Mood = 95;
factory.CreatePersonService().NewJob(game, 1);
Assert.AreEqual(15, game.Person.Income);
game.Person.Mood = 8;
factory.CreatePersonService().IncomeCalculate(game);
Assert.AreNotEqual(10, game.Person.Income);
}
public void GivenSameWordWithNoSaltWhenHashedTheHashIsDifferent()
{
var inputWord = Root.Any.String();
var firstHashResult = _sut.CreateHash(inputWord);
var secondHashResult = _sut.CreateHash(inputWord);
Assert.AreNotEqual(firstHashResult.Hash, secondHashResult.Hash);
Assert.AreNotEqual(firstHashResult.Salt, secondHashResult.Salt);
}
public void TestPermutate()
{
var block = new Block();
var blocks = block.SplitBlockIntoStrings("ABCD1234");
var permutatedBlocks = _logic.PermutateTwoBlocks(blocks);
Assert.AreNotEqual(blocks, permutatedBlocks);
Assert.AreEqual(blocks[1], permutatedBlocks[0]);
Assert.AreEqual(blocks[0], permutatedBlocks[1]);
}
public void GivenDifferentWordsAndSameSaltWhenHashedTheHashIsDifferent()
{
var firstInputWord = Root.Any.String();
var secondInputWord = Root.Any.String();
var firstHashResult = _sut.CreateHash(firstInputWord);
var secondHashResult = _sut.CreateHash(secondInputWord, firstHashResult.Salt);
Assert.AreNotEqual(firstHashResult.Hash, secondHashResult.Hash);
Assert.AreEqual(firstHashResult.Salt, secondHashResult.Salt);
}
public void OnNoRelationshipNoError_WhenAddedOnList()
{
var master = new Employee();
var child = new Child()
{
Name = "ChildName", EmployeeId = 1
};
master.Id = 2;
master.Children.Add(child);
Assert.AreNotEqual(master.Id, child.EmployeeId);
}
private static void CheckNotEquals(object obj, object other)
{
Assert.IsNotNull(obj);
Assert.IsNotNull(other);
Assert.AreNotEqual(obj, other);
Assert.AreNotEqual(other, obj);
Assert.AreNotEqual(obj.GetHashCode(), other.GetHashCode());
Assert.IsFalse(obj.Equals(other));
Assert.IsFalse(other.Equals(obj));
Assert.IsFalse(obj == other);
Assert.IsFalse(other == obj);
Assert.IsTrue(obj != other);
Assert.IsTrue(other != obj);
}
public void SwapTest()
{
string a = "Test", b = "Unit";
Assert.AreEqual("Unit", b);
Assert.AreNotEqual("Unit", a);
Assert.AreEqual("Test", a);
Assert.AreNotEqual("Test", b);
ValueUtils.Swap(ref a, ref b);
Assert.AreEqual("Unit", a);
Assert.AreNotEqual("Unit", b);
Assert.AreEqual("Test", b);
Assert.AreNotEqual("Test", a);
}
private async Task StateClassTests_Test(string grainClass)
{
var grain = GrainFactory.GetGrain <ISimplePersistentGrain>(GetRandomGrainId(), grainClass);
var originalVersion = await grain.GetVersion();
await grain.SetA(98, true); // deactivate grain after setting A
var newVersion = await grain.GetVersion(); // get a new version from the new activation
Assert.AreNotEqual(originalVersion, newVersion);
var a = await grain.GetA();
Assert.AreEqual(98, a); // value of A survive deactivation and reactivation of the grain
}
public void GetFlights_ShouldReturnFlightss()
{
{
//add Flights plan to the db
DataBase.flightPlanDB.Add("00", new FlightPlan
{
Passengers = 400,
Company_Name = "Our_company",
Initial_location = new InitialLocation
{
Longitude = 90,
Latitude = 21,
Date_time = "2020-06-05T09:23:00Z"
},
Segments = new List <Segment>()
{
new Segment
{
Longitude = 20,
Latitude = 20,
Timespan_seconds = 100
}
}
});
//the function from the FlightsController
Mock <FlightsController> controller = new Mock <FlightsController>();
controller.Setup(x => x.flightsCheck(It.IsAny <string>()))
.Returns(ReturnFlightss());
//ACT
var listFlightss =
controller.Object.GetFlightsByDateTimeForTest("2020-06-05T09:23:00Z").Result;
//Assert
//check it is equal
Assert.AreEqual(listFlightss.Count, 1);
Assert.AreEqual(listFlightss[0].Passengers, 400);
Assert.AreEqual(listFlightss[0].Is_external, false);
Assert.AreEqual(listFlightss[0].Company_name, "Our_company");
Assert.AreEqual(listFlightss[0].Date_time, "2020-06-05T09:23:00Z");
//check it is not equal
Assert.AreNotEqual(listFlightss.Count, 2);
Assert.AreNotEqual(listFlightss.Count, 3);
Assert.AreNotEqual(listFlightss[0].Passengers, 102);
Assert.AreNotEqual(listFlightss[0].Is_external, true);
Assert.AreNotEqual(listFlightss[0].Company_name, "Failier");
}
}
public async Task RequestContext_ActivityId_DynamicChange_Server()
{
Guid activityId = Guid.NewGuid();
Guid activityId2 = Guid.NewGuid();
const string PropagateActivityIdConfigKey = @"/OrleansConfiguration/Defaults/Tracing/@PropagateActivityId";
var changeConfig = new Dictionary <string, string>();
IManagementGrain mgmtGrain = GrainClient.GrainFactory.GetGrain <IManagementGrain>(RuntimeInterfaceConstants.SYSTEM_MANAGEMENT_ID);
IRequestContextTestGrain grain = GrainClient.GrainFactory.GetGrain <IRequestContextTestGrain>(GetRandomGrainId());
Trace.CorrelationManager.ActivityId = activityId;
Guid result = await grain.E2EActivityId();
Assert.AreEqual(activityId, result, "E2E ActivityId #1 not propagated correctly");
RequestContext.Clear();
changeConfig[PropagateActivityIdConfigKey] = Boolean.FalseString;
output.WriteLine("Set {0}={1}", PropagateActivityIdConfigKey, changeConfig[PropagateActivityIdConfigKey]);
await mgmtGrain.UpdateConfiguration(null, changeConfig, null);
Trace.CorrelationManager.ActivityId = activityId2;
result = await grain.E2EActivityId();
Assert.AreNotEqual(activityId2, result, "E2E ActivityId #2 should not have been propagated");
Assert.AreEqual(Guid.Empty, result, "E2E ActivityId #2 should not have been propagated");
RequestContext.Clear();
changeConfig[PropagateActivityIdConfigKey] = Boolean.TrueString;
output.WriteLine("Set {0}={1}", PropagateActivityIdConfigKey, changeConfig[PropagateActivityIdConfigKey]);
await mgmtGrain.UpdateConfiguration(null, changeConfig, null);
Trace.CorrelationManager.ActivityId = activityId2;
result = await grain.E2EActivityId();
Assert.AreEqual(activityId2, result, "E2E ActivityId #2 should have been propagated");
RequestContext.Clear();
Trace.CorrelationManager.ActivityId = activityId;
result = await grain.E2EActivityId();
Assert.AreEqual(activityId, result, "E2E ActivityId #1 not propagated correctly after #2");
RequestContext.Clear();
}
public void Feature_DependencyInjection_ViewModelScopedService()
{
RunInAllBrowsers(browser => {
browser.NavigateToUrl(SamplesRouteUrls.FeatureSamples_DependencyInjection_ViewModelScopedService);
for (int i = 0; i < 5; i++)
{
var value = browser.First(".result").GetInnerText();
AssertUI.InnerTextEquals(browser.First(".result2"), value);
browser.First("input[type=button]").Click().Wait();
var value2 = browser.First(".result").GetInnerText();
AssertUI.InnerTextEquals(browser.First(".result2"), value2);
Assert.AreNotEqual(value, value2);
}
});
}
public void NullToNoneTest()
{
Assert.AreEqual("None", TextUtils.NullToNone(null));
Assert.AreEqual(TextUtils.None, TextUtils.NullToNone(null));
Assert.AreEqual(TextUtils.None, TextUtils.NullToNone(" n o n e "));
Assert.AreNotEqual(TextUtils.None, TextUtils.NullToNone("Nessuno"));
Assert.AreEqual("Nessuno", TextUtils.NullToNone("Nessuno"));
Assert.AreEqual("Intersect", TextUtils.NullToNone("Intersect"));
TextUtils.None = "Nessuno";
Assert.AreEqual("Nessuno", TextUtils.NullToNone(null));
Assert.AreEqual(TextUtils.None, TextUtils.NullToNone(null));
Assert.AreEqual(TextUtils.None, TextUtils.NullToNone(" n o n e "));
Assert.AreEqual(TextUtils.None, TextUtils.NullToNone("Nessuno"));
Assert.AreEqual("Nessuno", TextUtils.NullToNone("Nessuno"));
Assert.AreEqual("Intersect", TextUtils.NullToNone("Intersect"));
}
/// <summary>
/// Loads the simple project and makes sure we get the correct module.
/// </summary>
public void EnumModules(VisualStudioApp app, DotNotWaitOnNormalExit optionSetter)
{
StartHelloWorldAndBreak(app);
var modules = ((Process3)app.Dte.Debugger.CurrentProcess).Modules;
Assert.IsTrue(modules.Count >= 1);
var module = modules.Item("__main__");
Assert.IsNotNull(module);
Assert.IsTrue(module.Path.EndsWith("Program.py"));
Assert.AreEqual("__main__", module.Name);
Assert.AreNotEqual((uint)0, module.Order);
app.Dte.Debugger.TerminateAll();
WaitForMode(app, dbgDebugMode.dbgDesignMode);
}
public async Task Sched_AC_Turn_Execution_Order()
{
// Can we add a unit test that basicaly checks that any turn is indeed run till completion before any other turn?
// For example, you have a long running main turn and in the middle it spawns a lot of short CWs (on Done promise) and StartNew.
// You test that no CW/StartNew runs until the main turn is fully done. And run in stress.
UnitTestSchedulingContext context = new UnitTestSchedulingContext();
orleansTaskScheduler = TestInternalHelper.InitializeSchedulerForTesting(context);
var result1 = new TaskCompletionSource <bool>();
var result2 = new TaskCompletionSource <bool>();
orleansTaskScheduler.QueueWorkItem(new ClosureWorkItem(() =>
{
mainDone = false;
stageNum1 = stageNum2 = 0;
Task task1 = Task.Factory.StartNew(() => SubProcess1(11));
Task task2 = task1.ContinueWith((_) => SubProcess1(12));
Task task3 = task2.ContinueWith((_) => SubProcess1(13));
Task task4 = task3.ContinueWith((_) => { SubProcess1(14); result1.SetResult(true); });
task4.Ignore();
Task task21 = TaskDone.Done.ContinueWith((_) => SubProcess2(21));
Task task22 = task21.ContinueWith((_) => { SubProcess2(22); result2.SetResult(true); });
task22.Ignore();
Thread.Sleep(TimeSpan.FromSeconds(1));
mainDone = true;
}), context);
try { await result1.Task.WithTimeout(TimeSpan.FromSeconds(3)); }
catch (TimeoutException) { Assert.Fail("Timeout-1"); }
try { await result2.Task.WithTimeout(TimeSpan.FromSeconds(3)); }
catch (TimeoutException) { Assert.Fail("Timeout-2"); }
Assert.AreNotEqual(0, stageNum1, "Work items did not get executed-1");
Assert.AreNotEqual(0, stageNum2, "Work items did not get executed-2");
Assert.AreEqual(14, stageNum1, "Work items executed out of order-1");
Assert.AreEqual(22, stageNum2, "Work items executed out of order-2");
}
public async Task Generic_Non_Primitive_Type_Argument()
{
IEchoHubGrain <Guid, string> g1 = GrainFactory.GetGrain <IEchoHubGrain <Guid, string> >(1);
IEchoHubGrain <Guid, int> g2 = GrainFactory.GetGrain <IEchoHubGrain <Guid, int> >(1);
IEchoHubGrain <Guid, byte[]> g3 = GrainFactory.GetGrain <IEchoHubGrain <Guid, byte[]> >(1);
Assert.AreNotEqual((GrainReference)g1, (GrainReference)g2);
Assert.AreNotEqual((GrainReference)g1, (GrainReference)g3);
Assert.AreNotEqual((GrainReference)g2, (GrainReference)g3);
await g1.Foo(Guid.Empty, "", 1);
await g2.Foo(Guid.Empty, 0, 2);
await g3.Foo(Guid.Empty, new byte[] { }, 3);
Assert.AreEqual(1, await g1.GetX());
Assert.AreEqual(2, await g2.GetX());
Assert.AreEqual(3m, await g3.GetX());
}
public void Baseline_StreamRel_RestartSilos()
{
// This test case is just a sanity-check that the silo test config is OK.
const string testName = "Baseline_StreamRel_RestartSilos";
StreamTestUtils.LogStartTest(testName, _streamId, _streamProviderName, logger);
CheckSilosRunning("Before Restart", numExpectedSilos);
SiloHandle prim1 = this.HostedCluster.Primary;
SiloHandle sec1 = this.HostedCluster.Secondary;
RestartAllSilos();
CheckSilosRunning("After Restart", numExpectedSilos);
Assert.AreNotEqual(prim1, this.HostedCluster.Primary, "Should be different Primary silos after restart");
Assert.AreNotEqual(sec1, this.HostedCluster.Secondary, "Should be different Secondary silos after restart");
StreamTestUtils.LogEndTest(testName, logger);
}
