bool DoExecute(MessageResult ctx, IObserverHandler<IMessage> handler, AtomicInteger barrier)
{
var e = new MessageReceivingEventArgs (ctx, handler.Target);
try
{
ListnerManager.OnReceiving(e);
if (!e.Ignored)
ctx.results.Add(DelegateInvoker.Invoke<IMessage>(handler, ctx.Request.Sender, ctx.Request.ToMessage()));
return true;
}
catch (Exception ex)
{
var re = new MessageExceptionEventArgs (ctx,ex);
ListnerManager.OnReceivingException(re);
ctx.InnerExceptions.Add(ex);
return !re.Canceled;
}
finally
{
barrier--;
if (barrier == 0)
{
ListnerManager.OnReceived(new MessageEventArgs(ctx));
ListnerManager.OnSent(e);
OnCompleted(ctx);
}
else
ListnerManager.OnReceived(new MessageEventArgs(ctx));
e = null;
}
}
public void AtomicInteger_Post_Decrement_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue);
atomicInteger--;
Assert.Equal(int.MaxValue-1, atomicInteger.Value);
}
public void Listener_must_listen_in()
{
//arrange
var fooLatch = new TestLatch(sys, 2);
var barLatch = new TestLatch(sys, 2);
var barCount = new AtomicInteger(0);
var broadcast = sys.ActorOf<BroadcastActor>();
var newListenerProps = Props.Create(() => new ListenerActor(fooLatch, barLatch, barCount));
var a1 = sys.ActorOf(newListenerProps);
var a2 = sys.ActorOf(newListenerProps);
var a3 = sys.ActorOf(newListenerProps);
//act
broadcast.Tell(new Listen(a1));
broadcast.Tell(new Listen(a2));
broadcast.Tell(new Listen(a3));
broadcast.Tell(new Deafen(a3));
broadcast.Tell(new WithListeners(a => a.Tell("foo")));
broadcast.Tell("foo");
//assert
barLatch.Ready(TestLatch.DefaultTimeout);
Assert.Equal(2, barCount.Value);
fooLatch.Ready(TestLatch.DefaultTimeout);
foreach (var actor in new[] {a1, a2, a3, broadcast})
{
actor.Stop();
}
}
public ListenerActor(TestLatch fooLatch, TestLatch barLatch, AtomicInteger barCount)
{
_fooLatch = fooLatch;
_barLatch = barLatch;
_barCount = barCount;
Listeners = new ListenerSupport();
}
public void AtomicInteger_Pre_Increment_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue-1);
++atomicInteger;
Assert.Equal(int.MaxValue, atomicInteger.Value);
}
public void ShouldAddToValueUsingFunction()
{
var atomicInt = new AtomicInteger();
const int expected = 100;
atomicInt.Add(x => expected);
Assert.AreEqual(expected, atomicInt.Value);
}
public void AtomicInteger_IEquatable_Of_Int_Should_Compare()
{
IEquatable<int> firstAtomic = new AtomicInteger(int.MaxValue);
IEquatable<int> secondAtomic = new AtomicInteger(int.MinValue);
Assert.False(firstAtomic.Equals(int.MinValue));
Assert.False(secondAtomic.Equals(int.MaxValue));
}
public void AtomicInteger_Division_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(256);
var result = atomicInteger / 2;
Assert.Equal(256 / 2, result);
}
public void AtomicInteger_Multiplication_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(123);
var result = atomicInteger * 2;
Assert.Equal(123*2, result);
}
public void AtomicInteger_Subtraction_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue);
var result = atomicInteger - 1;
Assert.Equal(int.MaxValue-1, result);
}
public void AtomicInteger_Load_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue);
Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.Relaxed));
Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.Acquire));
Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.AcqRel));
Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.SeqCst));
}
public void AtomicInteger_Addition_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue - 1);
var result = atomicInteger+1;
Assert.Equal(int.MaxValue, result);
}
public void AtomicInteger_Implicit_Reassignment_Should_Change_Reference()
{
var firstAtomic = new AtomicInteger(int.MaxValue);
var secondAtomic = firstAtomic;
firstAtomic = int.MinValue;
Assert.NotEqual(secondAtomic, firstAtomic);
Assert.False(object.ReferenceEquals(secondAtomic, firstAtomic));
}
public void AtomicInteger_Should_Implement_Reference_Equality()
{
var firstAtomic = new AtomicInteger(int.MaxValue);
var secondAtomic = new AtomicInteger(int.MinValue);
Assert.False(firstAtomic.Equals(secondAtomic));
Assert.False(secondAtomic.Equals(firstAtomic));
// self equality
Assert.True(firstAtomic.Equals(firstAtomic));
Assert.True(secondAtomic.Equals(secondAtomic));
}
public void BroadcastGroup_router_must_broadcast_message_using_Ask()
{
var doneLatch = new TestLatch(sys, 2);
var counter1 = new AtomicInteger(0);
var counter2 = new AtomicInteger(0);
var actor1 = sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter1)));
var actor2 = sys.ActorOf(Props.Create(() => new BroadcastTarget(doneLatch, counter2)));
var routedActor = sys.ActorOf(Props.Create<TestActor>().WithRouter(new BroadcastGroup(actor1.Path.ToString(), actor2.Path.ToString())));
routedActor.Ask(new Broadcast(1));
routedActor.Tell(new Broadcast("end"));
doneLatch.Ready(TimeSpan.FromSeconds(1));
counter1.Value.ShouldBe(1);
counter2.Value.ShouldBe(1);
}
//-------------------------------------------------------------------------
public virtual void test_of_intintlambda()
{
assertMatrix(DoubleMatrix.of(0, 0, (i, j) =>
{
throw new AssertionError();
}));
assertMatrix(DoubleMatrix.of(0, 2, (i, j) =>
{
throw new AssertionError();
}));
assertMatrix(DoubleMatrix.of(2, 0, (i, j) =>
{
throw new AssertionError();
}));
AtomicInteger counter = new AtomicInteger(2);
assertMatrix(DoubleMatrix.of(1, 2, (i, j) => counter.AndIncrement), 2d, 3d);
assertMatrix(DoubleMatrix.of(2, 2, (i, j) => (i + 1) * (j + 1)), 1d, 2d, 2d, 4d);
}
public void AtomicityInt()
{
AtomicTypeBase <int> atomic = new AtomicInteger();
void SumTask()
{
for (var x = 0; x < 300; x++)
{
atomic++;
}
}
Task.WaitAll(
Task.Factory.StartNew(SumTask),
Task.Factory.StartNew(SumTask),
Task.Factory.StartNew(SumTask));
Assert.That(atomic.Value, Is.EqualTo(900));
}
public void TestTlsCertsFromDynamicStreamExpiredAndRenewCert()
{
AtomicInteger certIndex = new AtomicInteger(1);
AtomicInteger keyIndex = new AtomicInteger(0);
MemoryStream certStream = CreateByteInputStream(TlsClientCertFilePath);
MemoryStream keyStream = CreateByteInputStream(TlsClientKeyFilePath);
Func <MemoryStream> certProvider = () => GetStream(certIndex, certStream, keyStream);
Func <MemoryStream> keyProvider = () => GetStream(keyIndex, keyStream);
AuthenticationTls auth = new AuthenticationTls(certProvider, keyProvider);
_common.GetPulsarSystem(auth, 1000, enableTls: true, brokerService: "pulsar.BrokerServiceUrlTls");
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsCertsFromDynamicStreamExpiredAndRenewCert", "my-subscriber-name"));
certIndex.SetValue(0);
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsCertsFromDynamicStreamExpiredAndRenewCert", "my-subscriber-name"));
}
void Dispatch(MessageResult ctx)
{
var handlers = Subject.Subscriber.Observers;
var syncHandlers = handlers.Where(i => i.Value == SubscribeMode.Sync).Select(i => i.Key).ToArray();
var asyncHandlers = handlers.Where(i => i.Value == SubscribeMode.Async).Select(i => i.Key).ToArray();
var handlerCount = syncHandlers.Length + asyncHandlers.Length;
var barrier = new AtomicInteger(handlerCount);
foreach (var item in syncHandlers)
{
if (!DoExecute(ctx, item, barrier))
break;
}
Paraller.ForEach(asyncHandlers, handler => DoExecute(ctx, handler, barrier));
}
public virtual void TestMaxMergeCount()
{
Directory dir = NewDirectory();
IndexWriterConfig iwc = new IndexWriterConfig(TEST_VERSION_CURRENT, new MockAnalyzer(Random()));
int maxMergeCount = TestUtil.NextInt(Random(), 1, 5);
int maxMergeThreads = TestUtil.NextInt(Random(), 1, maxMergeCount);
CountdownEvent enoughMergesWaiting = new CountdownEvent(maxMergeCount);
AtomicInteger runningMergeCount = new AtomicInteger(0);
AtomicBoolean failed = new AtomicBoolean();
if (VERBOSE)
{
Console.WriteLine("TEST: maxMergeCount=" + maxMergeCount + " maxMergeThreads=" + maxMergeThreads);
}
ConcurrentMergeScheduler cms = new ConcurrentMergeSchedulerAnonymousInnerClassHelper(this, maxMergeCount, enoughMergesWaiting, runningMergeCount, failed);
cms.SetMaxMergesAndThreads(maxMergeCount, maxMergeThreads);
iwc.SetMergeScheduler(cms);
iwc.SetMaxBufferedDocs(2);
TieredMergePolicy tmp = new TieredMergePolicy();
iwc.SetMergePolicy(tmp);
tmp.MaxMergeAtOnce = 2;
tmp.SegmentsPerTier = 2;
IndexWriter w = new IndexWriter(dir, iwc);
Document doc = new Document();
doc.Add(NewField("field", "field", TextField.TYPE_NOT_STORED));
while (enoughMergesWaiting.CurrentCount != 0 && !failed.Get())
{
for (int i = 0; i < 10; i++)
{
w.AddDocument(doc);
}
}
w.Dispose(false);
dir.Dispose();
}
[Test] public virtual void FairQueueUnblocksTakingThreadsInFifoOrder()
{
Options.SkipWhenNot(CollectionContractOptions.Fair);
const int size = 3;
var q = NewBlockingQueue();
var exitValue = new AtomicInteger();
var order = new AtomicInteger(1);
for (int i = 1; i <= size; i++)
{
var index = i;
ThreadManager.StartAndAssertRegistered(
"T" + index,
() =>
{
while (order.Value < index)
{
Thread.Sleep(1);
}
Thread.Sleep(Delays.Short);
order.IncrementValueAndReturn();
T result;
Assert.IsTrue(q.Poll(Delays.Long, out result));
exitValue.Value = index;
});
}
while (order.Value <= size)
{
Thread.Sleep(1);
}
Thread.Sleep(Delays.Short);
for (int i = 1; i <= size; i++)
{
Assert.IsTrue(q.Offer(TestData <T> .MakeData(i), Delays.Short));
for (int j = 0; j < 100 && exitValue.Value != i; j++)
{
Thread.Sleep(1);
}
Assert.That(exitValue.Value, Is.EqualTo(i));
}
ThreadManager.JoinAndVerify();
}
public void TestDebatchByContainer()
{
var provider = new ServiceCollection().BuildServiceProvider();
var config = new ConfigurationBuilder().Build();
var received = new List <IMessage>();
var latch = new CountdownEvent(2);
var container = new DirectMessageListenerContainer(new GenericApplicationContext(provider, config), connectionFactory);
container.SetQueueNames(ROUTE);
var lastInBatch = new List <bool>();
var batchSize = new AtomicInteger();
container.MessageListener = new TestDebatchListener(received, lastInBatch, batchSize, latch);
container.Initialize();
container.Start();
try
{
var batchingStrategy = new SimpleBatchingStrategy(2, int.MaxValue, 30000);
var template = new BatchingRabbitTemplate(batchingStrategy)
{
ConnectionFactory = connectionFactory
};
var message = Message.Create(Encoding.UTF8.GetBytes("foo"));
template.Send(string.Empty, ROUTE, message);
message = Message.Create(Encoding.UTF8.GetBytes("bar"));
template.Send(string.Empty, ROUTE, message);
Assert.True(latch.Wait(TimeSpan.FromSeconds(10)));
Assert.Equal(2, received.Count);
Assert.Equal("foo", Encoding.UTF8.GetString((byte[])received[0].Payload));
Assert.Equal(3, received[0].Headers.ContentLength());
Assert.False(lastInBatch[0]);
Assert.Equal("bar", Encoding.UTF8.GetString((byte[])received[1].Payload));
Assert.Equal(3, received[1].Headers.ContentLength());
Assert.True(lastInBatch[1]);
Assert.Equal(2, batchSize.Value);
}
finally
{
container.Stop();
}
}
public void TestWithChannelListener()
{
var mockConnectionFactory = new Mock <ConnectionFactory>();
var mockConnection = new Mock <IConnection>();
var mockChannel = new Mock <IModel>();
mockConnectionFactory.Setup(c => c.CreateConnection()).Returns(mockConnection.Object);
mockConnection.Setup(m => m.IsOpen).Returns(true);
mockChannel.Setup(m => m.IsOpen).Returns(true);
mockConnection.Setup(m => m.CreateModel()).Returns(mockChannel.Object);
var called = new AtomicInteger(0);
var connectionFactory = this.CreateConnectionFactory(mockConnectionFactory.Object);
var mockConnectionListener = new Mock <IConnectionListener>();
mockConnectionListener.Setup(m => m.OnCreate(It.IsAny <Rabbit.Connection.IConnection>())).Callback((Rabbit.Connection.IConnection conn) => called.IncrementValueAndReturn());
mockConnectionListener.Setup(m => m.OnClose(It.IsAny <Rabbit.Connection.IConnection>())).Callback((Rabbit.Connection.IConnection conn) => called.DecrementValueAndReturn());
connectionFactory.ConnectionListeners = new List <IConnectionListener> {
mockConnectionListener.Object
};
((CachingConnectionFactory)connectionFactory).ChannelCacheSize = 1;
var con = connectionFactory.CreateConnection();
var channel = con.CreateChannel(false);
Assert.AreEqual(1, called.Value);
channel.Close();
con.Close();
mockConnection.Verify(c => c.Close(), Times.Never());
connectionFactory.CreateConnection();
con.CreateChannel(false);
Assert.AreEqual(1, called.Value);
connectionFactory.Dispose();
mockConnection.Verify(c => c.Close(), Times.AtLeastOnce());
mockConnectionFactory.Verify(c => c.CreateConnection(), Times.Exactly(1));
}
public void AtomicInteger_Aligned_Value_Change_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue, align: true);
Assert.Equal(int.MaxValue, atomicInteger.Value);
atomicInteger.Value = int.MinValue;
Assert.Equal(int.MinValue, atomicInteger.Value);
atomicInteger.Value = 0;
Assert.Equal(0, atomicInteger.Value);
// same value assignment
atomicInteger.Value = 0;
Assert.Equal(0, atomicInteger.Value);
atomicInteger.Value = 123;
Assert.Equal(123, atomicInteger.Value);
atomicInteger.Value = 123;
Assert.Equal(123, atomicInteger.Value);
}
/// <exception cref="System.Exception"/>
public virtual void TestShutdown()
{
AtomicInteger bytesRead = new AtomicInteger(0);
AtomicBoolean failed = new AtomicBoolean(false);
DomainSocket[] socks = DomainSocket.Socketpair();
Runnable reader = new _Runnable_737(socks, bytesRead, failed);
Thread readerThread = new Thread(reader);
readerThread.Start();
socks[0].GetOutputStream().Write(1);
socks[0].GetOutputStream().Write(2);
socks[0].GetOutputStream().Write(3);
Assert.True(readerThread.IsAlive());
socks[0].Shutdown();
readerThread.Join();
NUnit.Framework.Assert.IsFalse(failed.Get());
Assert.Equal(3, bytesRead.Get());
IOUtils.Cleanup(null, socks);
}
public void TestChangeListenerNotificationBatching()
{
const int numDocs = 50;
var atomicInteger = new AtomicInteger(0);
var doneSignal = new CountDownLatch(1);
database.Changed += (sender, e) => atomicInteger.IncrementAndGet();
database.RunInTransaction(() =>
{
CreateDocuments(database, numDocs);
doneSignal.CountDown();
return(true);
});
var success = doneSignal.Await(TimeSpan.FromSeconds(30));
Assert.IsTrue(success);
Assert.AreEqual(1, atomicInteger.Get());
}
public static void execute(List <Action> callables, AtomicInteger noEstimateCounter, RunningAverageAndStdDev timing)
{
List <Action> list = wrapWithStatsCallables(callables, noEstimateCounter, timing);
int processorCount = Environment.ProcessorCount;
Task[] tasks = new Task[list.Count];
log.info("Starting timing of {} tasks in {} threads", new object[] { list.Count, processorCount });
try
{
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = Task.Factory.StartNew(list[i]);
}
Task.WaitAll(tasks, 0x2710);
}
catch (Exception exception)
{
throw new TasteException(exception.Message, exception);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void createdExecutorShouldExecuteSubmittedTasks() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void CreatedExecutorShouldExecuteSubmittedTasks()
{
AtomicBoolean exitCondition = new AtomicBoolean(false);
AtomicInteger threadCounter = new AtomicInteger(0);
_executorService = _factory.create(0, 1, Duration.ZERO, 0, false, NewThreadFactoryWithCounter(threadCounter));
assertNotNull(_executorService);
assertEquals(0, threadCounter.get());
Future task1 = _executorService.submit(NewInfiniteWaitingRunnable(exitCondition));
assertEquals(1, threadCounter.get());
exitCondition.set(true);
assertNull(task1.get(1, MINUTES));
assertTrue(task1.Done);
assertFalse(task1.Cancelled);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCloseableScheduleWithFixedDelayAndAdditionalTasks() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void testCloseableScheduleWithFixedDelayAndAdditionalTasks()
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger outerCounter = new java.util.concurrent.atomic.AtomicInteger(0);
AtomicInteger outerCounter = new AtomicInteger(0);
Runnable command = () =>
{
outerCounter.incrementAndGet();
};
executorService.scheduleWithFixedDelay(command, DELAY_MS, DELAY_MS, TimeUnit.MILLISECONDS);
CloseableScheduledExecutorService service = new CloseableScheduledExecutorService(executorService);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger innerCounter = new java.util.concurrent.atomic.AtomicInteger(0);
AtomicInteger innerCounter = new AtomicInteger(0);
service.scheduleWithFixedDelay(() =>
{
innerCounter.incrementAndGet();
}, DELAY_MS, DELAY_MS, TimeUnit.MILLISECONDS);
Thread.Sleep(DELAY_MS * 4);
service.close();
Thread.Sleep(DELAY_MS * 2);
int innerValue = innerCounter.get();
Assert.assertTrue(innerValue > 0);
int value = outerCounter.get();
Thread.Sleep(DELAY_MS * 2);
int newValue = outerCounter.get();
Assert.assertTrue(newValue > value);
Assert.assertEquals(innerValue, innerCounter.get());
value = newValue;
Thread.Sleep(DELAY_MS * 2);
newValue = outerCounter.get();
Assert.assertTrue(newValue > value);
Assert.assertEquals(innerValue, innerCounter.get());
}
public void TestWriteThreadSafety()
{
MockedTime time = new MockedTime();
HystrixRollingPercentile p = new HystrixRollingPercentile(time, 100, 25, 1000, true);
int num_threads = 10;
int num_iterations = 1000;
CountdownEvent latch = new CountdownEvent(num_threads);
Random r = new Random();
AtomicInteger added = new AtomicInteger(0);
for (int i = 0; i < num_threads; i++)
{
Task t = new Task(
() =>
{
for (int j = 1; j < (num_iterations / num_threads) + 1; j++)
{
int nextInt = r.Next(100);
p.AddValue(nextInt);
added.GetAndIncrement();
}
latch.SignalEx();
}, CancellationToken.None,
TaskCreationOptions.LongRunning);
t.Start();
}
try
{
latch.Wait(TimeSpan.FromSeconds(100));
Assert.Equal(added.Value, p._buckets.PeekLast._data.Length);
}
catch (Exception)
{
Assert.True(false, "Timeout on all threads writing percentiles");
}
}
public void TestRecovery()
{
var mockConnectionFactory = new Mock <RC.IConnectionFactory>();
var count = new AtomicInteger();
mockConnectionFactory.Setup((f) => f.CreateConnection(It.IsAny <string>()))
.Callback(() => count.IncrementAndGet())
.Throws(new AuthenticationFailureException("foo"));
var connectionFactory = new SingleConnectionFactory(mockConnectionFactory.Object);
var template = new RabbitTemplate(connectionFactory)
{
RetryTemplate = new PollyRetryTemplate(new Dictionary <Type, bool>(), 3, true, 1, 1, 1)
};
var recoverInvoked = new AtomicBoolean();
template.RecoveryCallback = new TestRecoveryRecoveryCallback(recoverInvoked);
template.ConvertAndSend("foo", "bar", "baz");
Assert.Equal(3, count.Value);
Assert.True(recoverInvoked.Value);
}
void Dispatch(MessageResult ctx)
{
var handlers = Subject.Subscriber.Observers;
var syncHandlers = handlers.Where(i => i.Value == SubscribeMode.Sync).Select(i => i.Key).ToArray();
var asyncHandlers = handlers.Where(i => i.Value == SubscribeMode.Async).Select(i => i.Key).ToArray();
var handlerCount = syncHandlers.Length + asyncHandlers.Length;
var barrier = new AtomicInteger(handlerCount);
foreach (var item in syncHandlers)
{
if (!DoExecute(ctx, item, barrier))
{
break;
}
}
Paraller.ForEach(asyncHandlers, handler => DoExecute(ctx, handler, barrier));
}
/// <summary>
/// Initializes a new instance of the <see cref="ClientBase" /> class.
/// </summary>
/// <param name="serverSession">The network session to bind the instance to.</param>
/// <param name="packetFactory">The <see cref="IPacketFactory" /> to use for this client.</param>
/// <param name="logger">The logger to use for this client.</param>
/// <exception cref="ArgumentNullException">Thrown if any of the parameters is <see langword="null" />.</exception>
protected ClientBase(IServerSession serverSession, IPacketFactory packetFactory, ILogger logger)
{
if (serverSession == null)
{
throw new ArgumentNullException(nameof(serverSession));
}
if (packetFactory == null)
{
throw new ArgumentNullException(nameof(packetFactory));
}
_isDisposed = false;
_sentPings = new AtomicInteger(0);
ServerSession = InitializeSession(serverSession);
PacketFactory = packetFactory;
Logger = logger;
_keepAliveTimer = InitializeTimer();
_keepAliveTimer.Start();
}
public virtual void TestMultipleFailedTasks()
{
JobHistoryParser parser = new JobHistoryParser(Org.Mockito.Mockito.Mock <FSDataInputStream
>());
EventReader reader = Org.Mockito.Mockito.Mock <EventReader>();
AtomicInteger numEventsRead = new AtomicInteger(0);
// Hack!
TaskType taskType = TaskType.Map;
TaskID[] tids = new TaskID[2];
JobID jid = new JobID("1", 1);
tids[0] = new TaskID(jid, taskType, 0);
tids[1] = new TaskID(jid, taskType, 1);
Org.Mockito.Mockito.When(reader.GetNextEvent()).ThenAnswer(new _Answer_842(numEventsRead
, tids, taskType, jid));
// send two task start and two task fail events for tasks 0 and 1
JobHistoryParser.JobInfo info = parser.Parse(reader);
NUnit.Framework.Assert.IsTrue("Task 0 not implicated", info.GetErrorInfo().Contains
(tids[0].ToString()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldWaitForAllContestantsToComplete() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
internal virtual void ShouldWaitForAllContestantsToComplete()
{
// GIVEN
Race race = new Race();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.util.concurrent.atomic.AtomicInteger completed = new java.util.concurrent.atomic.AtomicInteger();
AtomicInteger completed = new AtomicInteger();
int count = 5;
race.AddContestants(count, throwing(() =>
{
sleep(current().Next(100));
completed.incrementAndGet();
}));
// WHEN
race.Go();
// THEN
assertEquals(count, completed.get());
}
public void Start()
{
if (_shutdown.CompareAndSet(true, false))
{
_eventId = new AtomicInteger(0);
_eventQueue = new BlockingCollection <ZooKeeperEvent>();
Task.Factory.StartNew(() =>
{
var events = _eventQueue.GetConsumingEnumerable();
foreach (var @event in events)
{
var eventId = _eventId.Increment();
@event.Description = string.Format("Delivering event #{0} {1}", eventId, @event.Description);
@event.Run();
}
_shutdownCompleted.Set();
});
}
}
public void AtomicInteger_Value_Change_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue);
Assert.Equal(int.MaxValue, atomicInteger.Value);
atomicInteger.Value = int.MinValue;
Assert.Equal(int.MinValue, atomicInteger.Value);
atomicInteger.Value = 0;
Assert.Equal(0, atomicInteger.Value);
// same value assignment
atomicInteger.Value = 0;
Assert.Equal(0, atomicInteger.Value);
atomicInteger.Value = 123;
Assert.Equal(123, atomicInteger.Value);
atomicInteger.Value = 123;
Assert.Equal(123, atomicInteger.Value);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void distinctRateLimitersOperateIndependently() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void DistinctRateLimitersOperateIndependently()
{
// given
Limiters limiters = new Limiters(Clocks.fakeClock());
AtomicInteger cnt = new AtomicInteger();
System.Action <ThreadStart> rateLimiterA = Org.Neo4j.causalclustering.helper.Limiters.rateLimiter("A", _eternity);
System.Action <ThreadStart> rateLimiterB = Org.Neo4j.causalclustering.helper.Limiters.rateLimiter("B", _eternity);
// when
rateLimiterA(cnt.incrementAndGet);
rateLimiterA(cnt.incrementAndGet);
rateLimiterA(cnt.incrementAndGet);
rateLimiterB(cnt.incrementAndGet);
rateLimiterB(cnt.incrementAndGet);
rateLimiterB(cnt.incrementAndGet);
// then
assertEquals(2, cnt.get());
}
public MockClusterApplication()
{
AllLiveNodes = new AtomicInteger(0);
HandleApplicationMessageCheck = new AtomicInteger(0);
InformLeaderElectedCheck = new AtomicInteger(0);
InformLeaderLostCheck = new AtomicInteger(0);
InformLocalNodeShutDownCheck = new AtomicInteger(0);
InformLocalNodeStartedCheck = new AtomicInteger(0);
InformNodeIsHealthyCheck = new AtomicInteger(0);
InformNodeJoinedClusterCheck = new AtomicInteger(0);
InformNodeLeftClusterCheck = new AtomicInteger(0);
InformQuorumAchievedCheck = new AtomicInteger(0);
InformQuorumLostCheck = new AtomicInteger(0);
InformAttributesClientCheck = new AtomicInteger(0);
InformAttributeSetCreatedCheck = new AtomicInteger(0);
InformAttributeAddedCheck = new AtomicInteger(0);
InformAttributeRemovedCheck = new AtomicInteger(0);
InformAttributeReplacedCheck = new AtomicInteger(0);
InformAttributeSetRemovedCheck = new AtomicInteger(0);
StopCheck = new AtomicInteger(0);
}
public virtual void TestRepeatingThread()
{
AtomicInteger counter = new AtomicInteger();
MultithreadedTestUtil.TestContext ctx = new MultithreadedTestUtil.TestContext();
ctx.AddThread(new _RepeatingTestThread_118(counter, ctx));
ctx.StartThreads();
long st = Time.Now();
ctx.WaitFor(3000);
ctx.Stop();
long et = Time.Now();
long elapsed = et - st;
// Test should have waited just about 3 seconds
Assert.True("Test took " + (et - st) + "ms", Math.Abs(elapsed -
3000) < 500);
// Counter should have been incremented lots of times in 3 full seconds
Assert.True("Counter value = " + counter.Get(), counter.Get() >
1000);
}
internal Mover(NameNodeConnector nnc, Configuration conf, AtomicInteger retryCount
)
{
long movedWinWidth = conf.GetLong(DFSConfigKeys.DfsMoverMovedwinwidthKey, DFSConfigKeys
.DfsMoverMovedwinwidthDefault);
int moverThreads = conf.GetInt(DFSConfigKeys.DfsMoverMoverthreadsKey, DFSConfigKeys
.DfsMoverMoverthreadsDefault);
int maxConcurrentMovesPerNode = conf.GetInt(DFSConfigKeys.DfsDatanodeBalanceMaxNumConcurrentMovesKey
, DFSConfigKeys.DfsDatanodeBalanceMaxNumConcurrentMovesDefault);
this.retryMaxAttempts = conf.GetInt(DFSConfigKeys.DfsMoverRetryMaxAttemptsKey, DFSConfigKeys
.DfsMoverRetryMaxAttemptsDefault);
this.retryCount = retryCount;
this.dispatcher = new Dispatcher(nnc, Sharpen.Collections.EmptySet <string>(), Sharpen.Collections
.EmptySet <string>(), movedWinWidth, moverThreads, 0, maxConcurrentMovesPerNode,
conf);
this.storages = new Mover.StorageMap();
this.targetPaths = nnc.GetTargetPaths();
this.blockStoragePolicies = new BlockStoragePolicy[1 << BlockStoragePolicySuite.IdBitLength
];
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void startAndAssertJoined(System.Nullable<int> expectedAssignedPort, java.util.Map<String, String> config) throws Exception
private void StartAndAssertJoined(int?expectedAssignedPort, IDictionary <string, string> config)
{
File configDir = WriteConfig(config);
System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
AtomicInteger port = new AtomicInteger();
_clients[0].addClusterListener(JoinAwaitingListener(latch, port));
bool arbiterStarted = StartArbiter(configDir, latch);
if (expectedAssignedPort == null)
{
assertFalse(format("Should not be able to start arbiter given config file:%s", config), arbiterStarted);
}
else
{
assertTrue(format("Should be able to start arbiter given config file:%s", config), arbiterStarted);
assertEquals(expectedAssignedPort.Value, port.get());
}
}
//-------------------------------------------------------------------------
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(enabled = false) public void test_javaBroken() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
public virtual void test_javaBroken()
{
// uncomment system out to see how broken it is
// very specific format instance needed
DecimalFormat format = new DecimalFormat("#,##0.###", new DecimalFormatSymbols(Locale.ENGLISH));
Random random = new Random(1);
System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1);
AtomicInteger broken = new AtomicInteger();
int threadCount = 15;
for (int i = 0; i < threadCount; i++)
{
ThreadStart runner = () =>
{
try
{
latch.await();
int val = random.Next(999);
string a = format.format((double)val);
string b = Convert.ToInt32(val).ToString();
Console.WriteLine(a + " " + b);
if (!a.Equals(b))
{
broken.incrementAndGet();
}
}
catch (Exception ex)
{
Console.WriteLine("Exception: " + ex.Message);
}
};
(new Thread(runner, "TestThread" + i)).Start();
}
// start all threads together
latch.Signal();
Thread.Sleep(1000);
Console.WriteLine("Broken: " + broken.get());
assertTrue(broken.get() > 0);
}
bool DoExecute(MessageResult ctx, IObserverHandler <IMessage> handler, AtomicInteger barrier)
{
var e = new MessageReceivingEventArgs(ctx, handler.Target);
try
{
ListnerManager.OnReceiving(e);
if (!e.Ignored)
{
ctx.results.Add(DelegateInvoker.Invoke <IMessage>(handler, ctx.Request.Sender, ctx.Request.ToMessage()));
}
return(true);
}
catch (Exception ex)
{
var re = new MessageExceptionEventArgs(ctx, ex);
ListnerManager.OnReceivingException(re);
ctx.InnerExceptions.Add(ex);
return(!re.Canceled);
}
finally
{
barrier--;
if (barrier == 0)
{
ListnerManager.OnReceived(new MessageEventArgs(ctx));
ListnerManager.OnSent(e);
OnCompleted(ctx);
}
else
{
ListnerManager.OnReceived(new MessageEventArgs(ctx));
}
e = null;
}
}
public void TestTlsCertsFromDynamicStream()
{
string topicName = "persistent://my-property/use/my-ns/my-topic1";
AtomicInteger index = new AtomicInteger(0);
MemoryStream certStream = CreateByteInputStream(TlsClientCertFilePath);
MemoryStream keyStream = CreateByteInputStream(TlsClientKeyFilePath);
Func <MemoryStream> certProvider = () => GetStream(index, certStream);
Func <MemoryStream> keyProvider = () => GetStream(index, keyStream);
AuthenticationTls auth = new AuthenticationTls(certProvider, keyProvider);
_common.GetPulsarSystem(auth, 1000, enableTls: true, brokerService: "pulsar.BrokerServiceUrlTls");
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), topicName, "TestTlsCertsFromDynamicStream", "my-subscriber-name"));
// unload the topic so, new connection will be made and read the cert streams again
var producer = _common.PulsarSystem.PulsarProducer(_common.CreateProducer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", ""));
for (int i = 0; i < 10; i++)
{
var send = new Send(("test" + i).GetBytes(), ImmutableDictionary <string, object> .Empty);
_common.PulsarSystem.Send(send, producer.Producer);
}
ConsumedMessage msg = null;
for (var i = 0; i < 10; i++)
{
msg = _common.PulsarSystem.Receive("TestTlsCertsFromDynamicStream", 5000);
var exepctedMsg = "test" + i;
var data = (byte[])(object)msg.Message.Data;
Assert.Equal(exepctedMsg.GetBytes(), data);
}
// Acknowledge the consumption of all messages at once
_common.PulsarSystem.AcknowledgeCumulative(msg);
}
private WindowCache(WindowCacheConfig cfg)
: base(TableSize(cfg), LockCount(cfg))
{
_maxFiles = cfg.PackedGitOpenFiles;
_maxBytes = cfg.PackedGitLimit;
_memoryMap = cfg.PackedGitMMAP;
_windowSizeShift = Bits(cfg.PackedGitWindowSize);
_windowSize = 1 << _windowSizeShift;
_openFiles = new AtomicInteger();
_openBytes = new AtomicLong();
if (_maxFiles < 1)
{
throw new ArgumentException("Open files must be >= 1");
}
if (_maxBytes < _windowSize)
{
throw new ArgumentException("Window size must be < limit");
}
}
public virtual void TestNoErrors()
{
AtomicInteger threadsRun = new AtomicInteger();
MultithreadedTestUtil.TestContext ctx = new MultithreadedTestUtil.TestContext();
for (int i = 0; i < 3; i++)
{
ctx.AddThread(new _TestingThread_42(threadsRun, ctx));
}
Assert.Equal(0, threadsRun.Get());
ctx.StartThreads();
long st = Time.Now();
ctx.WaitFor(30000);
long et = Time.Now();
// All threads should have run
Assert.Equal(3, threadsRun.Get());
// Test shouldn't have waited the full 30 seconds, since
// the threads exited faster than that.
Assert.True("Test took " + (et - st) + "ms", et - st < 5000);
}
public int computeItemSimilarities(int degreeOfParallelism, int maxDurationInHours, SimilarItemsWriter writer)
{
ExecutorService executorService = Executors.newFixedThreadPool(degreeOfParallelism + 1);
Output output = null;
try {
writer.open();
DataModel dataModel = getRecommender().getDataModel();
BlockingQueue<long[]> itemsIDsInBatches = queueItemIDsInBatches(dataModel, batchSize);
BlockingQueue<List<SimilarItems>> results = new LinkedBlockingQueue<List<SimilarItems>>();
AtomicInteger numActiveWorkers = new AtomicInteger(degreeOfParallelism);
for (int n = 0; n < degreeOfParallelism; n++) {
executorService.execute(new SimilarItemsWorker(n, itemsIDsInBatches, results, numActiveWorkers));
}
output = new Output(results, writer, numActiveWorkers);
executorService.execute(output);
} catch (Exception e) {
throw new IOException(e);
} finally {
executorService.shutdown();
try {
bool succeeded = executorService.awaitTermination(maxDurationInHours, TimeUnit.HOURS);
if (!succeeded) {
throw new RuntimeException("Unable to complete the computation in " + maxDurationInHours + " hours!");
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
Closeables.close(writer, false);
}
return output.getNumSimilaritiesProcessed();
}
public void Test()
{
AtomicInteger m = new AtomicInteger(0);
Assert.IsTrue(m == 0);
Assert.IsFalse(m.CompareAndSet(3, 2));
Assert.IsTrue(m == 0);
Assert.IsTrue(m.CompareAndSet(0, 2));
Assert.IsTrue(m == 2);
var rs = m + 3;// 2+3
Assert.AreEqual(5, rs);
Assert.AreEqual(4, m--);
Assert.AreEqual(2, m - 2);
Assert.AreEqual(6, m + 4);
Assert.AreEqual(6, m.GetAndAdd(4));
Assert.AreEqual(10, m);
}
public void AtomicInteger_Division_SeqCst_Should_Fail()
{
var atomicInteger = new AtomicInteger(256, MemoryOrder.SeqCst);
Assert.Throws<DivideByZeroException>(() => atomicInteger / 0);
}
public void AtomicInteger_Division_SeqCst_Should_Success()
{
const int initialValue = 256;
var atomicInteger = new AtomicInteger(initialValue);
var result = atomicInteger / 2;
Assert.Equal(initialValue / 2, result);
Assert.Equal(initialValue, atomicInteger.Value);
}
public void AtomicInteger_Addition_SeqCst_Should_Success()
{
const int initialValue = int.MaxValue - 1;
var atomicInteger = new AtomicInteger(initialValue);
var result = atomicInteger + 1;
Assert.Equal(int.MaxValue, result);
Assert.Equal(initialValue, atomicInteger.Value);
}
public void AtomicInteger_Implicit_Int_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue);
var func = new Func<int, int>(i => i);
Assert.Equal(int.MaxValue, func(atomicInteger));
}
public void AtomicInteger_Post_Decrement_SeqCst_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue, MemoryOrder.SeqCst);
atomicInteger--;
Assert.Equal(int.MaxValue - 1, atomicInteger.Value);
}
public void AtomicInteger_Implicit_Int_SeqCst_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue, MemoryOrder.SeqCst);
var func = new Func<int, int>(i => i);
Assert.Equal(int.MaxValue, func(atomicInteger));
}
public void AtomicInteger_Division_AcqRel_Should_Fail()
{
var atomicInteger = new AtomicInteger(256);
Assert.Throws<DivideByZeroException>(() => atomicInteger/0);
}
public void AtomicInteger_Pre_Increment_SeqCst_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MaxValue - 1, MemoryOrder.SeqCst);
++atomicInteger;
Assert.Equal(int.MaxValue, atomicInteger.Value);
}
public void AtomicInteger_Inequality_AcqRel_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MinValue);
Assert.True(atomicInteger != int.MaxValue);
}
public void AtomicInteger_Multiplication_SeqCst_Should_Success()
{
const int initialValue = 123;
var atomicInteger = new AtomicInteger(initialValue);
var result = atomicInteger * 2;
Assert.Equal(initialValue * 2, result);
Assert.Equal(initialValue, atomicInteger.Value);
}
public void AtomicInteger_Inequality_SeqCst_Should_Success()
{
var atomicInteger = new AtomicInteger(int.MinValue, MemoryOrder.SeqCst);
Assert.True(atomicInteger != int.MaxValue);
}
