//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldSlowlyReduceTheNumberOfResourcesInThePoolWhenResourcesAreReleased() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldSlowlyReduceTheNumberOfResourcesInThePoolWhenResourcesAreReleased() { // given const int poolMinSize = 50; const int poolMaxSize = 200; StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final SomethingResourcePool pool = getResourcePool(stateMonitor, clock, poolMinSize); SomethingResourcePool pool = GetResourcePool(stateMonitor, clock, poolMinSize); AcquireResourcesAndExceedTimeout(pool, clock, poolMaxSize); // when // After the peak, stay below MIN_SIZE concurrent usage, using up all already present resources. ExceedTimeout(clock); for (int i = 0; i < poolMaxSize; i++) { AcquireFromPool(pool, 1)[0].release(); } // then // currentPeakSize must have reset from the latest check to minimum size. assertEquals(1, stateMonitor.CurrentPeakSize.get()); // because of timeout // targetSize must be set to MIN_SIZE since currentPeakSize was that 2 checks ago and didn't increase assertEquals(poolMinSize, stateMonitor.TargetSize.get()); // Only pooled resources must be used, disposing what is in excess // +1 that was used to trigger exceed timeout check assertEquals(poolMinSize, pool.UnusedSize()); assertEquals(poolMaxSize - poolMinSize + 1, stateMonitor.DisposedConflict.get()); }
//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 public void shouldKeepSmallPeakAndNeverDisposeIfAcquireAndReleaseContinuously() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldKeepSmallPeakAndNeverDisposeIfAcquireAndReleaseContinuously() { // given const int poolMinSize = 1; StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final ResourcePool<Something> pool = getResourcePool(stateMonitor, clock, poolMinSize); ResourcePool <Something> pool = GetResourcePool(stateMonitor, clock, poolMinSize); // when for (int i = 0; i < 200; i++) { IList <ResourceHolder> newOnes = AcquireFromPool(pool, 1); System.Threading.CountdownEvent release = new System.Threading.CountdownEvent(newOnes.Count); foreach (ResourceHolder newOne in newOnes) { newOne.Release(release); } release.await(); } // 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 TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldUpdateTargetSizeWhenSpikesOccur() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldUpdateTargetSizeWhenSpikesOccur() { // given const int poolMinSize = 5; const int poolMaxSize = 10; StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final ResourcePool<Something> pool = getResourcePool(stateMonitor, clock, poolMinSize); ResourcePool <Something> pool = GetResourcePool(stateMonitor, clock, poolMinSize); // when IList <ResourceHolder> holders = AcquireFromPool(pool, poolMaxSize); ExceedTimeout(clock); ((IList <ResourceHolder>)holders).AddRange(AcquireFromPool(pool, 1)); // Needed to trigger the alarm // then assertEquals(poolMaxSize + 1, stateMonitor.CurrentPeakSize.get()); // We have not released anything, so targetSize will not be reduced assertEquals(poolMaxSize + 1, stateMonitor.TargetSize.get()); // + 1 from the acquire foreach (ResourceHolder holder in holders) { holder.End(); } }
//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 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()); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldReclaimAndRecreateWhenUsageGoesDownBetweenSpikes() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldReclaimAndRecreateWhenUsageGoesDownBetweenSpikes() { // given const int poolMinSize = 50; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int bellowPoolMinSize = poolMinSize / 5; int bellowPoolMinSize = poolMinSize / 5; const int poolMaxSize = 200; StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final SomethingResourcePool pool = getResourcePool(stateMonitor, clock, poolMinSize); SomethingResourcePool pool = GetResourcePool(stateMonitor, clock, poolMinSize); AcquireResourcesAndExceedTimeout(pool, clock, poolMaxSize); // when // After the peak, stay well below concurrent usage, using up all already present resources in the process ExceedTimeout(clock); // Requires some rounds to happen, since there is constant racing between releasing and acquiring which does // not always result in reaping of resources, as there is reuse for (int i = 0; i < 30; i++) { // The latch is necessary to reduce races between batches System.Threading.CountdownEvent release = new System.Threading.CountdownEvent(bellowPoolMinSize); foreach (ResourceHolder holder in AcquireFromPool(pool, bellowPoolMinSize)) { holder.Release(release); } release.await(); ExceedTimeout(clock); } // then // currentPeakSize should not be higher than bellowPoolMinSize assertTrue(stateMonitor.CurrentPeakSize.get().ToString(), stateMonitor.CurrentPeakSize.get() <= bellowPoolMinSize); // target size should remain at pool min size assertEquals(poolMinSize, stateMonitor.TargetSize.get()); assertEquals(poolMinSize, pool.UnusedSize()); // only the excess from the pool max size down to min size must have been disposed // +1 that was used to trigger initial exceed timeout check assertEquals(poolMaxSize - poolMinSize + 1, stateMonitor.DisposedConflict.get()); stateMonitor.CreatedConflict.set(0); stateMonitor.DisposedConflict.set(0); // when // After the lull, recreate a peak AcquireResourcesAndExceedTimeout(pool, clock, poolMaxSize); // then assertEquals(poolMaxSize - poolMinSize + 1, 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 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 public void shouldBuildUpGracefullyUntilReachedMinPoolSize() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldBuildUpGracefullyUntilReachedMinPoolSize() { // GIVEN StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final ResourcePool<Something> pool = getResourcePool(stateMonitor, clock, 5); ResourcePool <Something> pool = GetResourcePool(stateMonitor, clock, 5); // WHEN AcquireFromPool(pool, 5); // THEN assertEquals(-1, stateMonitor.CurrentPeakSize.get()); assertEquals(-1, stateMonitor.TargetSize.get()); // that means the target size was not updated assertEquals(0, stateMonitor.DisposedConflict.get()); // no disposed happened, since the count to update is 10 }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldBuildUpGracefullyWhilePassingMinPoolSizeBeforeTimerRings() throws InterruptedException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldBuildUpGracefullyWhilePassingMinPoolSizeBeforeTimerRings() { // GIVEN StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final ResourcePool<Something> pool = getResourcePool(stateMonitor, clock, 5); ResourcePool <Something> pool = GetResourcePool(stateMonitor, clock, 5); // WHEN AcquireFromPool(pool, 15); // THEN assertEquals(-1, stateMonitor.CurrentPeakSize.get()); assertEquals(15, stateMonitor.CreatedConflict.get()); assertEquals(-1, stateMonitor.TargetSize.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 public void shouldMaintainPoolHigherThenMinSizeWhenPeekUsagePasses() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldMaintainPoolHigherThenMinSizeWhenPeekUsagePasses() { // given const int poolMinSize = 50; const int poolMaxSize = 200; const int afterPeekPoolSize = 90; StatefulMonitor stateMonitor = new StatefulMonitor(this); FakeClock clock = FakeClocks; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final SomethingResourcePool pool = getResourcePool(stateMonitor, clock, poolMinSize); SomethingResourcePool pool = GetResourcePool(stateMonitor, clock, poolMinSize); AcquireResourcesAndExceedTimeout(pool, clock, poolMaxSize); // when // After the peak, stay at afterPeekPoolSize concurrent usage, using up all already present resources in the process // but also keeping the high watermark above the minimum size ExceedTimeout(clock); // Requires some rounds to happen, since there is constant racing between releasing and acquiring which does // not always result in reaping of resources, as there is reuse for (int i = 0; i < 10; i++) { // The latch is necessary to reduce races between batches System.Threading.CountdownEvent release = new System.Threading.CountdownEvent(afterPeekPoolSize); foreach (ResourceHolder holder in AcquireFromPool(pool, afterPeekPoolSize)) { holder.Release(release); } release.await(); ExceedTimeout(clock); } // then // currentPeakSize should be at afterPeekPoolSize assertEquals(afterPeekPoolSize, stateMonitor.CurrentPeakSize.get()); // target size too assertEquals(afterPeekPoolSize, stateMonitor.TargetSize.get()); // only the excess from the maximum size down to after peek usage size must have been disposed // +1 that was used to trigger exceed timeout check assertEquals(afterPeekPoolSize, pool.UnusedSize()); assertThat(stateMonitor.DisposedConflict.get(), greaterThanOrEqualTo(poolMaxSize - afterPeekPoolSize + 1)); }
//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 SomethingResourcePool(int minSize, CheckStrategy checkStrategy, StatefulMonitor stateMonitor) : base(minSize, checkStrategy, stateMonitor) { }
private LinkedQueuePool <object> GetLinkedQueuePool(StatefulMonitor stateMonitor, FakeClock clock, int minSize) { //JAVA TO C# CONVERTER TODO TASK: Method reference constructor syntax is not converted by Java to C# Converter: return(new LinkedQueuePool <object>(minSize, object::new, new LinkedQueuePool.CheckStrategy_TimeoutCheckStrategy(100, clock), stateMonitor)); }
private SomethingResourcePool GetResourcePool(StatefulMonitor stateMonitor, FakeClock clock, int minSize) { ResourcePool.CheckStrategy_TimeoutCheckStrategy timeoutCheckStrategy = new ResourcePool.CheckStrategy_TimeoutCheckStrategy(TIMEOUT_MILLIS, clock); return(new SomethingResourcePool(minSize, timeoutCheckStrategy, stateMonitor)); }