Java tutorial
/** * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.hadoop.hbase; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import java.util.concurrent.TimeUnit; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.hbase.TestChoreService.ScheduledChoreSamples.CountingChore; import org.apache.hadoop.hbase.TestChoreService.ScheduledChoreSamples.DoNothingChore; import org.apache.hadoop.hbase.TestChoreService.ScheduledChoreSamples.FailInitialChore; import org.apache.hadoop.hbase.TestChoreService.ScheduledChoreSamples.SampleStopper; import org.apache.hadoop.hbase.TestChoreService.ScheduledChoreSamples.SleepingChore; import org.apache.hadoop.hbase.TestChoreService.ScheduledChoreSamples.SlowChore; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.junit.Test; import org.junit.experimental.categories.Category; @Category(SmallTests.class) public class TestChoreService { private static final Log LOG = LogFactory.getLog(TestChoreService.class); /** * A few ScheduledChore samples that are useful for testing with ChoreService */ public static class ScheduledChoreSamples { /** * Straight forward stopper implementation that is used by default when one is not provided */ public static class SampleStopper implements Stoppable { private boolean stopped = false; @Override public void stop(String why) { stopped = true; } @Override public boolean isStopped() { return stopped; } } /** * Sleeps for longer than the scheduled period. This chore always misses its scheduled periodic * executions */ public static class SlowChore extends ScheduledChore { public SlowChore(String name, int period) { this(name, new SampleStopper(), period); } public SlowChore(String name, Stoppable stopper, int period) { super(name, stopper, period); } @Override protected boolean initialChore() { try { Thread.sleep(getPeriod() * 2); } catch (InterruptedException e) { e.printStackTrace(); } return true; } @Override protected void chore() { try { Thread.sleep(getPeriod() * 2); } catch (InterruptedException e) { //e.printStackTrace(); } } } /** * Lightweight ScheduledChore used primarily to fill the scheduling queue in tests */ public static class DoNothingChore extends ScheduledChore { public DoNothingChore(String name, int period) { super(name, new SampleStopper(), period); } public DoNothingChore(String name, Stoppable stopper, int period) { super(name, stopper, period); } @Override protected void chore() { // DO NOTHING } } public static class SleepingChore extends ScheduledChore { private int sleepTime; public SleepingChore(String name, int chorePeriod, int sleepTime) { this(name, new SampleStopper(), chorePeriod, sleepTime); } public SleepingChore(String name, Stoppable stopper, int period, int sleepTime) { super(name, stopper, period); this.sleepTime = sleepTime; } @Override protected boolean initialChore() { try { Thread.sleep(sleepTime); } catch (InterruptedException e) { e.printStackTrace(); } return true; } @Override protected void chore() { try { Thread.sleep(sleepTime); } catch (Exception e) { System.err.println(e.getStackTrace()); } } } public static class CountingChore extends ScheduledChore { private int countOfChoreCalls; private boolean outputOnTicks = false; public CountingChore(String name, int period) { this(name, new SampleStopper(), period); } public CountingChore(String name, Stoppable stopper, int period) { this(name, stopper, period, false); } public CountingChore(String name, Stoppable stopper, int period, final boolean outputOnTicks) { super(name, stopper, period); this.countOfChoreCalls = 0; this.outputOnTicks = outputOnTicks; } @Override protected boolean initialChore() { countOfChoreCalls++; if (outputOnTicks) outputTickCount(); return true; } @Override protected void chore() { countOfChoreCalls++; if (outputOnTicks) outputTickCount(); } private void outputTickCount() { System.out.println("Chore: " + getName() + ". Count of chore calls: " + countOfChoreCalls); } public int getCountOfChoreCalls() { return countOfChoreCalls; } public boolean isOutputtingOnTicks() { return outputOnTicks; } public void setOutputOnTicks(boolean o) { outputOnTicks = o; } } /** * A Chore that will try to execute the initial chore a few times before succeeding. Once the * initial chore is complete the chore cancels itself */ public static class FailInitialChore extends ScheduledChore { private int numberOfFailures; private int failureThreshold; /** * @param failThreshold Number of times the Chore fails when trying to execute initialChore * before succeeding. */ public FailInitialChore(String name, int period, int failThreshold) { this(name, new SampleStopper(), period, failThreshold); } public FailInitialChore(String name, Stoppable stopper, int period, int failThreshold) { super(name, stopper, period); numberOfFailures = 0; failureThreshold = failThreshold; } @Override protected boolean initialChore() { if (numberOfFailures < failureThreshold) { numberOfFailures++; return false; } else { return true; } } @Override protected void chore() { assertTrue(numberOfFailures == failureThreshold); cancel(false); } } } @Test(timeout = 20000) public void testInitialChorePrecedence() throws InterruptedException { ChoreService service = ChoreService.getInstance("testInitialChorePrecedence"); final int period = 100; final int failureThreshold = 5; try { ScheduledChore chore = new FailInitialChore("chore", period, failureThreshold); service.scheduleChore(chore); int loopCount = 0; boolean brokeOutOfLoop = false; while (!chore.isInitialChoreComplete() && chore.isScheduled()) { Thread.sleep(failureThreshold * period); loopCount++; if (loopCount > 3) { brokeOutOfLoop = true; break; } } assertFalse(brokeOutOfLoop); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testCancelChore() throws InterruptedException { final int period = 100; ScheduledChore chore1 = new DoNothingChore("chore1", period); ChoreService service = ChoreService.getInstance("testCancelChore"); try { service.scheduleChore(chore1); assertTrue(chore1.isScheduled()); chore1.cancel(true); assertFalse(chore1.isScheduled()); assertTrue(service.getNumberOfScheduledChores() == 0); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testScheduledChoreConstruction() { final String NAME = "chore"; final int PERIOD = 100; final long VALID_DELAY = 0; final long INVALID_DELAY = -100; final TimeUnit UNIT = TimeUnit.NANOSECONDS; ScheduledChore chore1 = new ScheduledChore(NAME, new SampleStopper(), PERIOD, VALID_DELAY, UNIT) { @Override protected void chore() { // DO NOTHING } }; assertEquals("Name construction failed", chore1.getName(), NAME); assertEquals("Period construction failed", chore1.getPeriod(), PERIOD); assertEquals("Initial Delay construction failed", chore1.getInitialDelay(), VALID_DELAY); assertEquals("TimeUnit construction failed", chore1.getTimeUnit(), UNIT); ScheduledChore invalidDelayChore = new ScheduledChore(NAME, new SampleStopper(), PERIOD, INVALID_DELAY, UNIT) { @Override protected void chore() { // DO NOTHING } }; assertEquals("Initial Delay should be set to 0 when invalid", 0, invalidDelayChore.getInitialDelay()); } @Test(timeout = 20000) public void testChoreServiceConstruction() throws InterruptedException { final int corePoolSize = 10; final int defaultCorePoolSize = ChoreService.MIN_CORE_POOL_SIZE; ChoreService customInit = new ChoreService("testChoreServiceConstruction_custom", corePoolSize); try { assertEquals(corePoolSize, customInit.getCorePoolSize()); } finally { shutdownService(customInit); } ChoreService defaultInit = new ChoreService("testChoreServiceConstruction_default"); try { assertEquals(defaultCorePoolSize, defaultInit.getCorePoolSize()); } finally { shutdownService(defaultInit); } ChoreService invalidInit = new ChoreService("testChoreServiceConstruction_invalid", -10); try { assertEquals(defaultCorePoolSize, invalidInit.getCorePoolSize()); } finally { shutdownService(invalidInit); } } @Test(timeout = 20000) public void testFrequencyOfChores() throws InterruptedException { final int period = 100; // Small delta that acts as time buffer (allowing chores to complete if running slowly) final int delta = 5; ChoreService service = ChoreService.getInstance("testFrequencyOfChores"); CountingChore chore = new CountingChore("countingChore", period); try { service.scheduleChore(chore); Thread.sleep(10 * period + delta); assertTrue(chore.getCountOfChoreCalls() == 11); Thread.sleep(10 * period); assertTrue(chore.getCountOfChoreCalls() == 21); } finally { shutdownService(service); } } public void shutdownService(ChoreService service) throws InterruptedException { service.shutdown(); while (!service.isTerminated()) { Thread.sleep(100); } } @Test(timeout = 20000) public void testForceTrigger() throws InterruptedException { final int period = 100; final int delta = 5; ChoreService service = ChoreService.getInstance("testForceTrigger"); CountingChore chore = new CountingChore("countingChore", period); try { service.scheduleChore(chore); Thread.sleep(10 * period + delta); assertTrue(chore.getCountOfChoreCalls() == 11); // Force five runs of the chore to occur, sleeping between triggers to ensure the // chore has time to run chore.triggerNow(); Thread.sleep(delta); chore.triggerNow(); Thread.sleep(delta); chore.triggerNow(); Thread.sleep(delta); chore.triggerNow(); Thread.sleep(delta); chore.triggerNow(); Thread.sleep(delta); assertTrue(chore.getCountOfChoreCalls() == 16); Thread.sleep(10 * period + delta); assertTrue(chore.getCountOfChoreCalls() == 26); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testCorePoolIncrease() throws InterruptedException { final int initialCorePoolSize = 3; ChoreService service = new ChoreService("testCorePoolIncrease", initialCorePoolSize); try { assertEquals("Should have a core pool of size: " + initialCorePoolSize, initialCorePoolSize, service.getCorePoolSize()); final int slowChorePeriod = 100; SlowChore slowChore1 = new SlowChore("slowChore1", slowChorePeriod); SlowChore slowChore2 = new SlowChore("slowChore2", slowChorePeriod); SlowChore slowChore3 = new SlowChore("slowChore3", slowChorePeriod); service.scheduleChore(slowChore1); service.scheduleChore(slowChore2); service.scheduleChore(slowChore3); Thread.sleep(slowChorePeriod * 10); assertEquals("Should not create more pools than scheduled chores", 3, service.getCorePoolSize()); SlowChore slowChore4 = new SlowChore("slowChore4", slowChorePeriod); service.scheduleChore(slowChore4); Thread.sleep(slowChorePeriod * 10); assertEquals("Chores are missing their start time. Should expand core pool size", 4, service.getCorePoolSize()); SlowChore slowChore5 = new SlowChore("slowChore5", slowChorePeriod); service.scheduleChore(slowChore5); Thread.sleep(slowChorePeriod * 10); assertEquals("Chores are missing their start time. Should expand core pool size", 5, service.getCorePoolSize()); } finally { shutdownService(service); } } @Test(timeout = 30000) public void testCorePoolDecrease() throws InterruptedException { final int initialCorePoolSize = 3; ChoreService service = new ChoreService("testCorePoolDecrease", initialCorePoolSize); final int chorePeriod = 100; try { // Slow chores always miss their start time and thus the core pool size should be at least as // large as the number of running slow chores SlowChore slowChore1 = new SlowChore("slowChore1", chorePeriod); SlowChore slowChore2 = new SlowChore("slowChore2", chorePeriod); SlowChore slowChore3 = new SlowChore("slowChore3", chorePeriod); service.scheduleChore(slowChore1); service.scheduleChore(slowChore2); service.scheduleChore(slowChore3); Thread.sleep(chorePeriod * 10); assertEquals("Should not create more pools than scheduled chores", service.getNumberOfScheduledChores(), service.getCorePoolSize()); SlowChore slowChore4 = new SlowChore("slowChore4", chorePeriod); service.scheduleChore(slowChore4); Thread.sleep(chorePeriod * 10); assertEquals("Chores are missing their start time. Should expand core pool size", service.getNumberOfScheduledChores(), service.getCorePoolSize()); SlowChore slowChore5 = new SlowChore("slowChore5", chorePeriod); service.scheduleChore(slowChore5); Thread.sleep(chorePeriod * 10); assertEquals("Chores are missing their start time. Should expand core pool size", service.getNumberOfScheduledChores(), service.getCorePoolSize()); assertEquals(service.getNumberOfChoresMissingStartTime(), 5); // Now we begin to cancel the chores that caused an increase in the core thread pool of the // ChoreService. These cancellations should cause a decrease in the core thread pool. slowChore5.cancel(); Thread.sleep(chorePeriod * 10); assertEquals(Math.max(ChoreService.MIN_CORE_POOL_SIZE, service.getNumberOfScheduledChores()), service.getCorePoolSize()); assertEquals(service.getNumberOfChoresMissingStartTime(), 4); slowChore4.cancel(); Thread.sleep(chorePeriod * 10); assertEquals(Math.max(ChoreService.MIN_CORE_POOL_SIZE, service.getNumberOfScheduledChores()), service.getCorePoolSize()); assertEquals(service.getNumberOfChoresMissingStartTime(), 3); slowChore3.cancel(); Thread.sleep(chorePeriod * 10); assertEquals(Math.max(ChoreService.MIN_CORE_POOL_SIZE, service.getNumberOfScheduledChores()), service.getCorePoolSize()); assertEquals(service.getNumberOfChoresMissingStartTime(), 2); slowChore2.cancel(); Thread.sleep(chorePeriod * 10); assertEquals(Math.max(ChoreService.MIN_CORE_POOL_SIZE, service.getNumberOfScheduledChores()), service.getCorePoolSize()); assertEquals(service.getNumberOfChoresMissingStartTime(), 1); slowChore1.cancel(); Thread.sleep(chorePeriod * 10); assertEquals(Math.max(ChoreService.MIN_CORE_POOL_SIZE, service.getNumberOfScheduledChores()), service.getCorePoolSize()); assertEquals(service.getNumberOfChoresMissingStartTime(), 0); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testNumberOfRunningChores() throws InterruptedException { ChoreService service = new ChoreService("testNumberOfRunningChores"); final int period = 100; final int sleepTime = 5; try { DoNothingChore dn1 = new DoNothingChore("dn1", period); DoNothingChore dn2 = new DoNothingChore("dn2", period); DoNothingChore dn3 = new DoNothingChore("dn3", period); DoNothingChore dn4 = new DoNothingChore("dn4", period); DoNothingChore dn5 = new DoNothingChore("dn5", period); service.scheduleChore(dn1); service.scheduleChore(dn2); service.scheduleChore(dn3); service.scheduleChore(dn4); service.scheduleChore(dn5); Thread.sleep(sleepTime); assertEquals("Scheduled chore mismatch", 5, service.getNumberOfScheduledChores()); dn1.cancel(); Thread.sleep(sleepTime); assertEquals("Scheduled chore mismatch", 4, service.getNumberOfScheduledChores()); dn2.cancel(); dn3.cancel(); dn4.cancel(); Thread.sleep(sleepTime); assertEquals("Scheduled chore mismatch", 1, service.getNumberOfScheduledChores()); dn5.cancel(); Thread.sleep(sleepTime); assertEquals("Scheduled chore mismatch", 0, service.getNumberOfScheduledChores()); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testNumberOfChoresMissingStartTime() throws InterruptedException { ChoreService service = new ChoreService("testNumberOfChoresMissingStartTime"); final int period = 100; final int sleepTime = 5 * period; try { // Slow chores sleep for a length of time LONGER than their period. Thus, SlowChores // ALWAYS miss their start time since their execution takes longer than their period SlowChore sc1 = new SlowChore("sc1", period); SlowChore sc2 = new SlowChore("sc2", period); SlowChore sc3 = new SlowChore("sc3", period); SlowChore sc4 = new SlowChore("sc4", period); SlowChore sc5 = new SlowChore("sc5", period); service.scheduleChore(sc1); service.scheduleChore(sc2); service.scheduleChore(sc3); service.scheduleChore(sc4); service.scheduleChore(sc5); Thread.sleep(sleepTime); assertEquals(5, service.getNumberOfChoresMissingStartTime()); sc1.cancel(); Thread.sleep(sleepTime); assertEquals(4, service.getNumberOfChoresMissingStartTime()); sc2.cancel(); sc3.cancel(); sc4.cancel(); Thread.sleep(sleepTime); assertEquals(1, service.getNumberOfChoresMissingStartTime()); sc5.cancel(); Thread.sleep(sleepTime); assertEquals(0, service.getNumberOfChoresMissingStartTime()); } finally { shutdownService(service); } } /** * ChoreServices should never have a core pool size that exceeds the number of chores that have * been scheduled with the service. For example, if 4 ScheduledChores are scheduled with a * ChoreService, the number of threads in the ChoreService's core pool should never exceed 4 */ @Test(timeout = 20000) public void testMaximumChoreServiceThreads() throws InterruptedException { ChoreService service = new ChoreService("testMaximumChoreServiceThreads"); final int period = 100; final int sleepTime = 5 * period; try { // Slow chores sleep for a length of time LONGER than their period. Thus, SlowChores // ALWAYS miss their start time since their execution takes longer than their period. // Chores that miss their start time will trigger the onChoreMissedStartTime callback // in the ChoreService. This callback will try to increase the number of core pool // threads. SlowChore sc1 = new SlowChore("sc1", period); SlowChore sc2 = new SlowChore("sc2", period); SlowChore sc3 = new SlowChore("sc3", period); SlowChore sc4 = new SlowChore("sc4", period); SlowChore sc5 = new SlowChore("sc5", period); service.scheduleChore(sc1); service.scheduleChore(sc2); service.scheduleChore(sc3); service.scheduleChore(sc4); service.scheduleChore(sc5); Thread.sleep(sleepTime); assertTrue(service.getCorePoolSize() <= service.getNumberOfScheduledChores()); SlowChore sc6 = new SlowChore("sc6", period); SlowChore sc7 = new SlowChore("sc7", period); SlowChore sc8 = new SlowChore("sc8", period); SlowChore sc9 = new SlowChore("sc9", period); SlowChore sc10 = new SlowChore("sc10", period); service.scheduleChore(sc6); service.scheduleChore(sc7); service.scheduleChore(sc8); service.scheduleChore(sc9); service.scheduleChore(sc10); Thread.sleep(sleepTime); assertTrue(service.getCorePoolSize() <= service.getNumberOfScheduledChores()); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testChangingChoreServices() throws InterruptedException { final int period = 100; final int sleepTime = 10; ChoreService service1 = new ChoreService("testChangingChoreServices_1"); ChoreService service2 = new ChoreService("testChangingChoreServices_2"); ScheduledChore chore = new DoNothingChore("sample", period); try { assertFalse(chore.isScheduled()); assertFalse(service1.isChoreScheduled(chore)); assertFalse(service2.isChoreScheduled(chore)); assertTrue(chore.getChoreServicer() == null); service1.scheduleChore(chore); Thread.sleep(sleepTime); assertTrue(chore.isScheduled()); assertTrue(service1.isChoreScheduled(chore)); assertFalse(service2.isChoreScheduled(chore)); assertFalse(chore.getChoreServicer() == null); service2.scheduleChore(chore); Thread.sleep(sleepTime); assertTrue(chore.isScheduled()); assertFalse(service1.isChoreScheduled(chore)); assertTrue(service2.isChoreScheduled(chore)); assertFalse(chore.getChoreServicer() == null); chore.cancel(); assertFalse(chore.isScheduled()); assertFalse(service1.isChoreScheduled(chore)); assertFalse(service2.isChoreScheduled(chore)); assertTrue(chore.getChoreServicer() == null); } finally { shutdownService(service1); shutdownService(service2); } } @Test(timeout = 20000) public void testTriggerNowFailsWhenNotScheduled() throws InterruptedException { final int period = 100; // Small sleep time buffer to allow CountingChore to complete final int sleep = 5; ChoreService service = new ChoreService("testTriggerNowFailsWhenNotScheduled"); CountingChore chore = new CountingChore("dn", period); try { assertFalse(chore.triggerNow()); assertTrue(chore.getCountOfChoreCalls() == 0); service.scheduleChore(chore); Thread.sleep(sleep); assertEquals(1, chore.getCountOfChoreCalls()); Thread.sleep(period); assertEquals(2, chore.getCountOfChoreCalls()); assertTrue(chore.triggerNow()); Thread.sleep(sleep); assertTrue(chore.triggerNow()); Thread.sleep(sleep); assertTrue(chore.triggerNow()); Thread.sleep(sleep); assertEquals(5, chore.getCountOfChoreCalls()); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testStopperForScheduledChores() throws InterruptedException { ChoreService service = ChoreService.getInstance("testStopperForScheduledChores"); Stoppable stopperForGroup1 = new SampleStopper(); Stoppable stopperForGroup2 = new SampleStopper(); final int period = 100; final int delta = 10; try { ScheduledChore chore1_group1 = new DoNothingChore("c1g1", stopperForGroup1, period); ScheduledChore chore2_group1 = new DoNothingChore("c2g1", stopperForGroup1, period); ScheduledChore chore3_group1 = new DoNothingChore("c3g1", stopperForGroup1, period); ScheduledChore chore1_group2 = new DoNothingChore("c1g2", stopperForGroup2, period); ScheduledChore chore2_group2 = new DoNothingChore("c2g2", stopperForGroup2, period); ScheduledChore chore3_group2 = new DoNothingChore("c3g2", stopperForGroup2, period); service.scheduleChore(chore1_group1); service.scheduleChore(chore2_group1); service.scheduleChore(chore3_group1); service.scheduleChore(chore1_group2); service.scheduleChore(chore2_group2); service.scheduleChore(chore3_group2); Thread.sleep(delta); Thread.sleep(10 * period); assertTrue(chore1_group1.isScheduled()); assertTrue(chore2_group1.isScheduled()); assertTrue(chore3_group1.isScheduled()); assertTrue(chore1_group2.isScheduled()); assertTrue(chore2_group2.isScheduled()); assertTrue(chore3_group2.isScheduled()); stopperForGroup1.stop("test stopping group 1"); Thread.sleep(period); assertFalse(chore1_group1.isScheduled()); assertFalse(chore2_group1.isScheduled()); assertFalse(chore3_group1.isScheduled()); assertTrue(chore1_group2.isScheduled()); assertTrue(chore2_group2.isScheduled()); assertTrue(chore3_group2.isScheduled()); stopperForGroup2.stop("test stopping group 2"); Thread.sleep(period); assertFalse(chore1_group1.isScheduled()); assertFalse(chore2_group1.isScheduled()); assertFalse(chore3_group1.isScheduled()); assertFalse(chore1_group2.isScheduled()); assertFalse(chore2_group2.isScheduled()); assertFalse(chore3_group2.isScheduled()); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testShutdownCancelsScheduledChores() throws InterruptedException { final int period = 100; ChoreService service = new ChoreService("testShutdownCancelsScheduledChores"); ScheduledChore successChore1 = new DoNothingChore("sc1", period); ScheduledChore successChore2 = new DoNothingChore("sc2", period); ScheduledChore successChore3 = new DoNothingChore("sc3", period); try { assertTrue(service.scheduleChore(successChore1)); assertTrue(successChore1.isScheduled()); assertTrue(service.scheduleChore(successChore2)); assertTrue(successChore2.isScheduled()); assertTrue(service.scheduleChore(successChore3)); assertTrue(successChore3.isScheduled()); } finally { shutdownService(service); } assertFalse(successChore1.isScheduled()); assertFalse(successChore2.isScheduled()); assertFalse(successChore3.isScheduled()); } @Test(timeout = 20000) public void testShutdownWorksWhileChoresAreExecuting() throws InterruptedException { final int period = 100; final int sleep = 5 * period; ChoreService service = new ChoreService("testShutdownWorksWhileChoresAreExecuting"); ScheduledChore slowChore1 = new SleepingChore("sc1", period, sleep); ScheduledChore slowChore2 = new SleepingChore("sc2", period, sleep); ScheduledChore slowChore3 = new SleepingChore("sc3", period, sleep); try { assertTrue(service.scheduleChore(slowChore1)); assertTrue(service.scheduleChore(slowChore2)); assertTrue(service.scheduleChore(slowChore3)); Thread.sleep(sleep / 2); shutdownService(service); assertFalse(slowChore1.isScheduled()); assertFalse(slowChore2.isScheduled()); assertFalse(slowChore3.isScheduled()); assertTrue(service.isShutdown()); Thread.sleep(5); assertTrue(service.isTerminated()); } finally { shutdownService(service); } } @Test(timeout = 20000) public void testShutdownRejectsNewSchedules() throws InterruptedException { final int period = 100; ChoreService service = new ChoreService("testShutdownRejectsNewSchedules"); ScheduledChore successChore1 = new DoNothingChore("sc1", period); ScheduledChore successChore2 = new DoNothingChore("sc2", period); ScheduledChore successChore3 = new DoNothingChore("sc3", period); ScheduledChore failChore1 = new DoNothingChore("fc1", period); ScheduledChore failChore2 = new DoNothingChore("fc2", period); ScheduledChore failChore3 = new DoNothingChore("fc3", period); try { assertTrue(service.scheduleChore(successChore1)); assertTrue(successChore1.isScheduled()); assertTrue(service.scheduleChore(successChore2)); assertTrue(successChore2.isScheduled()); assertTrue(service.scheduleChore(successChore3)); assertTrue(successChore3.isScheduled()); } finally { shutdownService(service); } assertFalse(service.scheduleChore(failChore1)); assertFalse(failChore1.isScheduled()); assertFalse(service.scheduleChore(failChore2)); assertFalse(failChore2.isScheduled()); assertFalse(service.scheduleChore(failChore3)); assertFalse(failChore3.isScheduled()); } }