while (!at.compareAndSet(2.0, 3.0)) {
                  Thread.yield();
                }
              }
            });

    assertTrue(at.compareAndSet(1.0, 2.0));
    awaitTermination(t);
    assertBitEquals(3.0, at.get());
  }

  /** repeated weakCompareAndSet succeeds in changing value when equal to expected */
  public void testWeakCompareAndSet() {
    double prev = Math.E;

      lastDelay = delay;
      lastUnit = unit;
      return null;
    }

    // No need to test these methods as they are handled by WrappingExecutorServiceTest
    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) {
      throw new UnsupportedOperationException();
    }

    @Override
    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)

        if ( this.executor != null ) {
            this.executor.shutdown();
            if ( this.future != null ) {
                this.future.cancel(true);
            }
            this.executor.awaitTermination(1, TimeUnit.SECONDS);
        }
        if ( this.base != null ) {
            this.base.delete();
        }
        super.tearDown();
    }

   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
   * fails.
   */
  void awaitTermination(Thread t) {
    awaitTermination(t, LONG_DELAY_MS);
  }

  // Some convenient Runnable classes

  public abstract class CheckedRunnable implements Runnable {
    protected abstract void realRun() throws Throwable;

   * Thread#join(long)}), else interrupts the thread (in the hope that it may terminate later) and
   * fails.
   */
  void awaitTermination(Thread t) {
    awaitTermination(t, LONG_DELAY_MS);
  }

  // Some convenient Runnable classes

  public abstract class CheckedRunnable implements Runnable {
    protected abstract void realRun() throws Throwable;

                    if (crawlerList.get(i).getCrawlerContext().getStatus() == CrawlerStatus.DONE
                            && Constants.RUNNING.equals(crawlerStatusList.get(i))) {
                        crawlerList.get(i).awaitTermination();
                        crawlerStatusList.set(i, Constants.DONE);
                        final String sid = crawlerList.get(i).getCrawlerContext().getSessionId();

                    }
                  }
                  return threadSum;
                }
              }));
    }
    threadPool.shutdown();
    assertTrue(threadPool.awaitTermination(300, SECONDS));
    long sum = 0;
    for (Future<Long> f : futures) {
      sum += f.get();
    }
    assertEquals(sum, map.get(key));
  }

                assertEquals(result, crawlingInfoHelper.generateId(dataMap));
                counter.incrementAndGet();
            });
        }
        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.SECONDS);
        assertEquals(1000, counter.get());
    }

    public boolean isShutdown() {
      return shutdown;
    }

    @Override
    public boolean isTerminated() {
      return shutdown;
    }

    @Override
    public boolean awaitTermination(long timeout, TimeUnit unit) {
      return true;
    }

    @Override
    public void execute(Runnable runnable) {}

    @Override
    public <V> ListenableScheduledFuture<V> schedule(

    threadPool = newCachedThreadPool();
  }

  @Override
  public void tearDown() throws InterruptedException {
    threadPool.shutdown();
    assertTrue("Some worker didn't finish in time", threadPool.awaitTermination(10, SECONDS));
  }

  private static <T> int drain(
      BlockingQueue<T> q,
      Collection<? super T> buffer,
      int maxElements,
      long timeout,
      TimeUnit unit,