hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From st...@apache.org
Subject hbase git commit: HBASE-13575 TestChoreService has to make sure that the opened ChoreService is closed for each unit test (Stephen Yuan Jiang)
Date Mon, 27 Apr 2015 21:24:14 GMT
Repository: hbase
Updated Branches:
  refs/heads/master b96952bee -> 2759fd0cd


HBASE-13575 TestChoreService has to make sure that the opened ChoreService is closed for each
unit test (Stephen Yuan Jiang)


Project: http://git-wip-us.apache.org/repos/asf/hbase/repo
Commit: http://git-wip-us.apache.org/repos/asf/hbase/commit/2759fd0c
Tree: http://git-wip-us.apache.org/repos/asf/hbase/tree/2759fd0c
Diff: http://git-wip-us.apache.org/repos/asf/hbase/diff/2759fd0c

Branch: refs/heads/master
Commit: 2759fd0cdbb8aee928819c9d7306bb61c94126d8
Parents: b96952b
Author: stack <stack@apache.org>
Authored: Mon Apr 27 14:23:57 2015 -0700
Committer: stack <stack@apache.org>
Committed: Mon Apr 27 14:23:57 2015 -0700

----------------------------------------------------------------------
 .../apache/hadoop/hbase/TestChoreService.java   | 762 ++++++++++---------
 1 file changed, 400 insertions(+), 362 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/hbase/blob/2759fd0c/hbase-common/src/test/java/org/apache/hadoop/hbase/TestChoreService.java
----------------------------------------------------------------------
diff --git a/hbase-common/src/test/java/org/apache/hadoop/hbase/TestChoreService.java b/hbase-common/src/test/java/org/apache/hadoop/hbase/TestChoreService.java
index 3529e94..1496dc7 100644
--- a/hbase-common/src/test/java/org/apache/hadoop/hbase/TestChoreService.java
+++ b/hbase-common/src/test/java/org/apache/hadoop/hbase/TestChoreService.java
@@ -241,23 +241,27 @@ public class TestChoreService {
 
     final int period = 100;
     final int failureThreshold = 5;
-    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;
-      }
+
+    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);
-    shutdownService(service);
+    } finally {
+      shutdownService(service);
+    }
   }
 
   @Test (timeout=20000)
@@ -265,14 +269,16 @@ public class TestChoreService {
     final int period = 100;
     ScheduledChore chore1 = new DoNothingChore("chore1", period);
     ChoreService service = ChoreService.getInstance("testCancelChore");
-
-    service.scheduleChore(chore1);
-    assertTrue(chore1.isScheduled());
-
-    chore1.cancel(true);
-    assertFalse(chore1.isScheduled());
-    assertTrue(service.getNumberOfScheduledChores() == 0);
-    shutdownService(service);
+    try {
+      service.scheduleChore(chore1);
+      assertTrue(chore1.isScheduled());
+
+      chore1.cancel(true);
+      assertFalse(chore1.isScheduled());
+      assertTrue(service.getNumberOfScheduledChores() == 0);
+    } finally {
+      shutdownService(service);
+    }
   }
 
   @Test (timeout=20000)
@@ -314,18 +320,25 @@ public class TestChoreService {
     final int defaultCorePoolSize = ChoreService.MIN_CORE_POOL_SIZE;
 
     ChoreService customInit = new ChoreService("testChoreServiceConstruction_custom", corePoolSize);
-    assertEquals(corePoolSize, customInit.getCorePoolSize());
+    try {
+      assertEquals(corePoolSize, customInit.getCorePoolSize());
+    } finally {
+      shutdownService(customInit);
+    }
 
     ChoreService defaultInit = new ChoreService("testChoreServiceConstruction_default");
-    assertEquals(defaultCorePoolSize, defaultInit.getCorePoolSize());
+    try {
+      assertEquals(defaultCorePoolSize, defaultInit.getCorePoolSize());
+    } finally {
+      shutdownService(defaultInit);
+    }
 
     ChoreService invalidInit = new ChoreService("testChoreServiceConstruction_invalid", -10);
-    assertEquals(defaultCorePoolSize, invalidInit.getCorePoolSize());
-
-    shutdownService(customInit);
-    shutdownService(defaultInit);
+    try {
+      assertEquals(defaultCorePoolSize, invalidInit.getCorePoolSize());
+    } finally {
     shutdownService(invalidInit);
-
+    }
   }
 
   @Test (timeout=20000)
@@ -335,15 +348,17 @@ public class TestChoreService {
     final int delta = 5;
     ChoreService service = ChoreService.getInstance("testFrequencyOfChores");
     CountingChore chore = new CountingChore("countingChore", period);
-    service.scheduleChore(chore);
-
-    Thread.sleep(10 * period + delta);
-    assertTrue(chore.getCountOfChoreCalls() == 11);
+    try {
+      service.scheduleChore(chore);
 
-    Thread.sleep(10 * period);
-    assertTrue(chore.getCountOfChoreCalls() == 21);
+      Thread.sleep(10 * period + delta);
+      assertTrue(chore.getCountOfChoreCalls() == 11);
 
-    shutdownService(service);
+      Thread.sleep(10 * period);
+      assertTrue(chore.getCountOfChoreCalls() == 21);
+    } finally {
+      shutdownService(service);
+    }
   }
 
   public void shutdownService(ChoreService service) throws InterruptedException {
@@ -359,68 +374,73 @@ public class TestChoreService {
     final int delta = 5;
     ChoreService service = ChoreService.getInstance("testForceTrigger");
     CountingChore chore = new CountingChore("countingChore", period);
-    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);
-
-    shutdownService(service);
+    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);
-    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);
+    try {
+      assertEquals("Should have a core pool of size: " + initialCorePoolSize, initialCorePoolSize,
+        service.getCorePoolSize());
 
-    service.scheduleChore(slowChore1);
-    service.scheduleChore(slowChore2);
-    service.scheduleChore(slowChore3);
+      final int slowChorePeriod = 100;
+      SlowChore slowChore1 = new SlowChore("slowChore1", slowChorePeriod);
+      SlowChore slowChore2 = new SlowChore("slowChore2", slowChorePeriod);
+      SlowChore slowChore3 = new SlowChore("slowChore3", slowChorePeriod);
 
-    Thread.sleep(slowChorePeriod * 10);
-    assertEquals("Should not create more pools than scheduled chores", 3,
-      service.getCorePoolSize());
+      service.scheduleChore(slowChore1);
+      service.scheduleChore(slowChore2);
+      service.scheduleChore(slowChore3);
 
-    SlowChore slowChore4 = new SlowChore("slowChore4", slowChorePeriod);
-    service.scheduleChore(slowChore4);
+      Thread.sleep(slowChorePeriod * 10);
+      assertEquals("Should not create more pools than scheduled chores", 3,
+        service.getCorePoolSize());
 
-    Thread.sleep(slowChorePeriod * 10);
-    assertEquals("Chores are missing their start time. Should expand core pool size", 4,
-      service.getCorePoolSize());
+      SlowChore slowChore4 = new SlowChore("slowChore4", slowChorePeriod);
+      service.scheduleChore(slowChore4);
 
-    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", 4,
+        service.getCorePoolSize());
 
-    Thread.sleep(slowChorePeriod * 10);
-    assertEquals("Chores are missing their start time. Should expand core pool size", 5,
-      service.getCorePoolSize());
+      SlowChore slowChore5 = new SlowChore("slowChore5", slowChorePeriod);
+      service.scheduleChore(slowChore5);
 
-    shutdownService(service);
+      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)
@@ -428,67 +448,68 @@ public class TestChoreService {
     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);
 
-    // 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);
-
-    shutdownService(service);
+      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)
@@ -498,36 +519,38 @@ public class TestChoreService {
     final int period = 100;
     final int sleepTime = 5;
 
-    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());
-
-    shutdownService(service);
+    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)
@@ -537,38 +560,40 @@ public class TestChoreService {
     final int period = 100;
     final int sleepTime = 5 * period;
 
-    // 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());
-
-    shutdownService(service);
+    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);
+    }
   }
 
   /**
@@ -583,42 +608,44 @@ public class TestChoreService {
     final int period = 100;
     final int sleepTime = 5 * period;
 
-    // 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());
-
-    shutdownService(service);
+    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)
@@ -629,33 +656,35 @@ public class TestChoreService {
     ChoreService service2 = new ChoreService("testChangingChoreServices_2");
     ScheduledChore chore = new DoNothingChore("sample", period);
 
-    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);
-
-    shutdownService(service1);
-    shutdownService(service2);
+    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)
@@ -666,23 +695,25 @@ public class TestChoreService {
     ChoreService service = new ChoreService("testTriggerNowFailsWhenNotScheduled");
     CountingChore chore = new CountingChore("dn", period);
 
-    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());
-
-    shutdownService(service);
+    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)
@@ -693,49 +724,51 @@ public class TestChoreService {
     final int period = 100;
     final int delta = 10;
 
-    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());
-
-    shutdownService(service);
+    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)
@@ -746,14 +779,16 @@ public class TestChoreService {
     ScheduledChore successChore2 = new DoNothingChore("sc2", period);
     ScheduledChore successChore3 = new DoNothingChore("sc3", period);
 
-    assertTrue(service.scheduleChore(successChore1));
-    assertTrue(successChore1.isScheduled());
-    assertTrue(service.scheduleChore(successChore2));
-    assertTrue(successChore2.isScheduled());
-    assertTrue(service.scheduleChore(successChore3));
-    assertTrue(successChore3.isScheduled());
-
-    shutdownService(service);
+    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());
@@ -768,23 +803,24 @@ public class TestChoreService {
     ScheduledChore slowChore1 = new SleepingChore("sc1", period, sleep);
     ScheduledChore slowChore2 = new SleepingChore("sc2", period, sleep);
     ScheduledChore slowChore3 = new SleepingChore("sc3", period, sleep);
-
-    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());
-
-    shutdownService(service);
+    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)
@@ -798,14 +834,16 @@ public class TestChoreService {
     ScheduledChore failChore2 = new DoNothingChore("fc2", period);
     ScheduledChore failChore3 = new DoNothingChore("fc3", period);
 
-    assertTrue(service.scheduleChore(successChore1));
-    assertTrue(successChore1.isScheduled());
-    assertTrue(service.scheduleChore(successChore2));
-    assertTrue(successChore2.isScheduled());
-    assertTrue(service.scheduleChore(successChore3));
-    assertTrue(successChore3.isScheduled());
-
-    shutdownService(service);
+    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());


Mime
View raw message