//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldBuildUpGracefullyWhilePassingMinPoolSizeBeforeTimerRings()
internal virtual void ShouldBuildUpGracefullyWhilePassingMinPoolSizeBeforeTimerRings()
{
// GIVEN
StatefulMonitor stateMonitor = new StatefulMonitor();
FakeClock clock = new FakeClock();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LinkedQueuePool<Object> pool = getLinkedQueuePool(stateMonitor, clock, 5);
LinkedQueuePool <object> pool = GetLinkedQueuePool(stateMonitor, clock, 5);
// WHEN
IList <FlyweightHolder <object> > flyweightHolders = AcquireFromPool(pool, 15);
foreach (FlyweightHolder <object> flyweightHolder in flyweightHolders)
{
flyweightHolder.Release();
}
// THEN
// The clock hasn't ticked, so these two should be unset
assertEquals(-1, stateMonitor.CurrentPeakSize.get());
assertEquals(-1, stateMonitor.TargetSize.get());
// We obviously created 15 threads
assertEquals(15, stateMonitor.CreatedConflict.get());
// And of those 10 are not needed and therefore disposed on release (min size is 5)
assertEquals(10, stateMonitor.DisposedConflict.get());
}
internal CheckStrategy_TimeoutCheckStrategy(LinkedQueuePool <R> outerInstance, long interval, System.Func <long> clock)
{
this._outerInstance = outerInstance;
this.Interval = interval;
this.LastCheckTime = clock();
this.Clock = clock;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldSlowlyReduceTheNumberOfFlyweightsInThePoolWhenFlyweightsAreReleased()
internal virtual void ShouldSlowlyReduceTheNumberOfFlyweightsInThePoolWhenFlyweightsAreReleased()
{
// given
const int minSize = 50;
const int maxSize = 200;
StatefulMonitor stateMonitor = new StatefulMonitor();
FakeClock clock = new FakeClock();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LinkedQueuePool<Object> pool = getLinkedQueuePool(stateMonitor, clock, MIN_SIZE);
LinkedQueuePool <object> pool = GetLinkedQueuePool(stateMonitor, clock, minSize);
IList <FlyweightHolder <object> > holders = new LinkedList <FlyweightHolder <object> >();
BuildAPeakOfAcquiredFlyweightsAndTriggerAlarmWithSideEffects(maxSize, clock, pool, holders);
// when
// After the peak, stay below MIN_SIZE concurrent usage, using up all already present Flyweights.
clock.Forward(110, TimeUnit.MILLISECONDS);
for (int i = 0; i < maxSize; i++)
{
AcquireFromPool(pool, 1)[0].release();
}
// then
// currentPeakSize must have reset from the latest alarm to MIN_SIZE.
assertEquals(1, stateMonitor.CurrentPeakSize.get()); // Alarm
// targetSize must be set to MIN_SIZE since currentPeakSize was that 2 alarms ago and didn't increase
assertEquals(minSize, stateMonitor.TargetSize.get());
// Only pooled Flyweights must be used, disposing what is in excess
// +1 for the alarm from buildAPeakOfAcquiredFlyweightsAndTriggerAlarmWithSideEffects
assertEquals(maxSize - minSize + 1, stateMonitor.DisposedConflict.get());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldKeepSmallPeakAndNeverDisposeIfAcquireAndReleaseContinuously()
internal virtual void ShouldKeepSmallPeakAndNeverDisposeIfAcquireAndReleaseContinuously()
{
// given
const int minSize = 1;
StatefulMonitor stateMonitor = new StatefulMonitor();
FakeClock clock = new FakeClock();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LinkedQueuePool<Object> pool = getLinkedQueuePool(stateMonitor, clock, MIN_SIZE);
LinkedQueuePool <object> pool = GetLinkedQueuePool(stateMonitor, clock, minSize);
// when
for (int i = 0; i < 200; i++)
{
IList <FlyweightHolder <object> > newOnes = AcquireFromPool(pool, 1);
foreach (FlyweightHolder newOne in newOnes)
{
newOne.release();
}
}
// then
assertEquals(-1, stateMonitor.CurrentPeakSize.get()); // no alarm has rung, -1 is the default
assertEquals(1, stateMonitor.CreatedConflict.get());
assertEquals(0, stateMonitor.DisposedConflict.get()); // we should always be below min size, so 0 dispose calls
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are ignored unless the option to convert to C# 7.2 'in' parameters is selected:
//ORIGINAL LINE: private <R> java.util.List<FlyweightHolder<R>> acquireFromPool(final LinkedQueuePool<R> pool, int times)
private IList <FlyweightHolder <R> > AcquireFromPool <R>(LinkedQueuePool <R> pool, int times)
{
IList <FlyweightHolder <R> > acquirers = new LinkedList <FlyweightHolder <R> >();
for (int i = 0; i < times; i++)
{
FlyweightHolder <R> holder = new FlyweightHolder <R>(pool);
acquirers.Add(holder);
holder.Run();
}
return(acquirers);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldReclaimAndRecreateWhenLullBetweenSpikesOccurs()
internal virtual void ShouldReclaimAndRecreateWhenLullBetweenSpikesOccurs()
{
// given
const int minSize = 50;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final int BELOW_MIN_SIZE = MIN_SIZE / 5;
int belowMinSize = minSize / 5;
const int maxSize = 200;
StatefulMonitor stateMonitor = new StatefulMonitor();
FakeClock clock = new FakeClock();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LinkedQueuePool<Object> pool = getLinkedQueuePool(stateMonitor, clock, MIN_SIZE);
LinkedQueuePool <object> pool = GetLinkedQueuePool(stateMonitor, clock, minSize);
IList <FlyweightHolder <object> > holders = new LinkedList <FlyweightHolder <object> >();
BuildAPeakOfAcquiredFlyweightsAndTriggerAlarmWithSideEffects(maxSize, clock, pool, holders);
// when
// After the peak, stay well below concurrent usage, using up all already present Flyweights in the process
clock.Forward(110, TimeUnit.MILLISECONDS);
// Requires some rounds to happen, since there is constant racing between releasing and acquiring which does
// not always result in reaping of Flyweights, as there is reuse
for (int i = 0; i < 30; i++)
{
// The latch is necessary to reduce races between batches
foreach (FlyweightHolder holder in AcquireFromPool(pool, belowMinSize))
{
holder.release();
}
clock.Forward(110, TimeUnit.MILLISECONDS);
}
// then
// currentPeakSize should be at MIN_SIZE / 5
assertTrue(stateMonitor.CurrentPeakSize.get() <= belowMinSize, "Expected " + stateMonitor.CurrentPeakSize.get() + " <= " + belowMinSize);
// target size should remain at MIN_SIZE
assertEquals(minSize, stateMonitor.TargetSize.get());
// only the excess from the MAX_SIZE down to min size must have been disposed
// +1 for the alarm from buildAPeakOfAcquiredFlyweightsAndTriggerAlarmWithSideEffects
assertEquals(maxSize - minSize + 1, stateMonitor.DisposedConflict.get());
stateMonitor.CreatedConflict.set(0);
stateMonitor.DisposedConflict.set(0);
// when
// After the lull, recreate a peak
((IList <FlyweightHolder <object> >)holders).AddRange(AcquireFromPool(pool, maxSize));
// then
assertEquals(maxSize - minSize, stateMonitor.CreatedConflict.get());
assertEquals(0, stateMonitor.DisposedConflict.get());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldMaintainPoolAtHighWatermarkWhenConcurrentUsagePassesMinSize()
internal virtual void ShouldMaintainPoolAtHighWatermarkWhenConcurrentUsagePassesMinSize()
{
// given
const int minSize = 50;
const int maxSize = 200;
const int midSize = 90;
StatefulMonitor stateMonitor = new StatefulMonitor();
FakeClock clock = new FakeClock();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LinkedQueuePool<Object> pool = getLinkedQueuePool(stateMonitor, clock, MIN_SIZE);
LinkedQueuePool <object> pool = GetLinkedQueuePool(stateMonitor, clock, minSize);
IList <FlyweightHolder <object> > holders = new LinkedList <FlyweightHolder <object> >();
// when
BuildAPeakOfAcquiredFlyweightsAndTriggerAlarmWithSideEffects(maxSize, clock, pool, holders);
// then
assertEquals(maxSize + 1, stateMonitor.CurrentPeakSize.get()); // the peak method above does +1 on the peak
// when
/* After the peak, stay at MID_SIZE concurrent usage, using up all already present Flyweights in the process
* but also keeping the high watermark above the MIN_SIZE
* We must do this at least twice, since the counter for disposed is incremented once per release, if appropriate,
* and only after the clock has ticked. Essentially this is one loop for reducing the watermark down to
* mid size and one more loop to dispose of all excess resources. That does indeed mean that there is a lag
* of one clock tick before resources are disposed. If this is a bug or not remains to be seen.
*/
for (int i = 0; i < 2; i++)
{
clock.Forward(110, TimeUnit.MILLISECONDS);
foreach (FlyweightHolder holder in AcquireFromPool(pool, midSize))
{
holder.release();
}
clock.Forward(110, TimeUnit.MILLISECONDS);
foreach (FlyweightHolder holder in AcquireFromPool(pool, midSize))
{
holder.release();
}
}
// then
// currentPeakSize should be at MID_SIZE
assertEquals(midSize, stateMonitor.CurrentPeakSize.get());
// target size too
assertEquals(midSize, stateMonitor.TargetSize.get());
// only the excess from the MAX_SIZE down to mid size must have been disposed
// +1 for the alarm from buildAPeakOfAcquiredFlyweightsAndTriggerAlarmWithSideEffects
assertEquals(maxSize - midSize + 1, stateMonitor.DisposedConflict.get());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldUpdateTargetSizeWhenSpikesOccur()
internal virtual void ShouldUpdateTargetSizeWhenSpikesOccur()
{
// given
const int minSize = 5;
const int maxSize = 10;
StatefulMonitor stateMonitor = new StatefulMonitor();
FakeClock clock = new FakeClock();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LinkedQueuePool<Object> pool = getLinkedQueuePool(stateMonitor, clock, MIN_SIZE);
LinkedQueuePool <object> pool = GetLinkedQueuePool(stateMonitor, clock, minSize);
// when
IList <FlyweightHolder <object> > holders = AcquireFromPool(pool, maxSize);
clock.Forward(110, TimeUnit.MILLISECONDS);
((IList <FlyweightHolder <object> >)holders).AddRange(AcquireFromPool(pool, 1)); // Needed to trigger the alarm
// then
assertEquals(maxSize + 1, stateMonitor.CurrentPeakSize.get());
// We have not released anything, so targetSize will not be reduced
assertEquals(maxSize + 1, stateMonitor.TargetSize.get()); // + 1 from the acquire
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldBuildUpGracefullyUntilReachedMinPoolSize()
internal virtual void ShouldBuildUpGracefullyUntilReachedMinPoolSize()
{
// GIVEN
StatefulMonitor stateMonitor = new StatefulMonitor();
FakeClock clock = new FakeClock();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final LinkedQueuePool<Object> pool = getLinkedQueuePool(stateMonitor, clock, 5);
LinkedQueuePool <object> pool = GetLinkedQueuePool(stateMonitor, clock, 5);
// WHEN
IList <FlyweightHolder <object> > flyweightHolders = AcquireFromPool(pool, 5);
foreach (FlyweightHolder <object> flyweightHolder in flyweightHolders)
{
flyweightHolder.Release();
}
// THEN
// clock didn't tick, these two are not set
assertEquals(-1, stateMonitor.CurrentPeakSize.get());
assertEquals(-1, stateMonitor.TargetSize.get());
// no disposed happened, since the count to update is 5
assertEquals(0, stateMonitor.DisposedConflict.get());
}
internal CheckStrategy_TimeoutCheckStrategy(LinkedQueuePool <R> outerInstance, long interval) : this(outerInstance, interval, System.currentTimeMillis)
{
this._outerInstance = outerInstance;
}
public Monitor_Adapter(LinkedQueuePool <R> outerInstance)
{
this._outerInstance = outerInstance;
}
internal FlyweightHolder(LinkedQueuePool <R> pool)
{
this.Pool = pool;
}
private void BuildAPeakOfAcquiredFlyweightsAndTriggerAlarmWithSideEffects(int maxSize, FakeClock clock, LinkedQueuePool <object> pool, IList <FlyweightHolder <object> > holders)
{
((IList <FlyweightHolder <object> >)holders).AddRange(AcquireFromPool(pool, maxSize));
clock.Forward(110, TimeUnit.MILLISECONDS);
// "Ring the bell" only on acquisition, of course.
((IList <FlyweightHolder <object> >)holders).AddRange(AcquireFromPool(pool, 1));
foreach (FlyweightHolder holder in holders)
{
holder.release();
}
}