import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
static void repeatedlyInterruptTestThread(
    long interruptPeriodMillis, TearDownAccepter tearDownAccepter) {
  final Interruptenator interruptingTask =
      new Interruptenator(Thread.currentThread(), interruptPeriodMillis);
  final Thread interruptingThread = new Thread(interruptingTask);
  interruptingThread.start();
  tearDownAccepter.addTearDown(new TearDown() {
    @Override public void tearDown() throws Exception {
      interruptingTask.stopInterrupting();
      interruptingThread.interrupt();
      joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
      Thread.interrupted();
      if (interruptingThread.isAlive()) {
        // This will be hidden by test-output redirection:
        logger.severe(
            "InterruptenatorTask did not exit; future tests may be affected");
        /*
         * This won't do any good under JUnit 3, but I'll leave it around in
         * case we ever switch to JUnit 4:
         */
        fail();
      }
    }
  });
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
/**
 * Same as {@link #setUp(TearDownAccepter, Class)}, but with the given 
 * {@code guiceBerryEnvSelector}.
 *
 * @see #setUp(TestCase, Class)
 */
public static <T extends TestCase & TearDownAccepter> void setUp(
    /* TeaDownTestCase */ T testCase,
    GuiceBerryEnvSelector guiceBerryEnvSelector) {
  final GuiceBerryWrapper toTearDown = 
    GuiceBerry.INSTANCE.buildWrapper(
        ManualTearDownGuiceBerry.buildTestDescription(testCase, testCase.getName()),
        guiceBerryEnvSelector);
  testCase.addTearDown(new TearDown() {
    
    public void tearDown() throws Exception {
      toTearDown.runAfterTest();
    }
  })  ;
  toTearDown.runBeforeTest();
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
private static TestWrapper buildTestWrapperInstance(Injector injector) {
  TestWrapper result = NoOpTestScopeListener.NO_OP_INSTANCE;
  try {
    boolean hasTestScopeListenerBinding = hasTestScopeListenerBinding(injector);
    boolean hasDeprecatedTestScopeListenerBinding = hasDeprecatedTestScopeListenerBinding(injector);
    if (hasTestScopeListenerBinding && hasDeprecatedTestScopeListenerBinding) {
      throw new RuntimeException(
        "Your GuiceBerry Env has bindings for both the new TestScopeListener and the deprecated one. Please fix.");
    } else if (hasTestScopeListenerBinding) {
      result = injector.getInstance(TestWrapper.class);
    } else if (hasDeprecatedTestScopeListenerBinding) {
      result = adapt(
          injector.getInstance(com.google.inject.testing.guiceberry.TestScopeListener.class),
          injector.getInstance(TearDownAccepter.class));
    }
  } catch (ConfigurationException e) {
    String msg = String.format("Error while creating a TestWrapper: '%s'.",
      e.getMessage());
    throw new RuntimeException(msg, e); 
  }
  return result;
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@Provides
@Singleton
TestWrapper getTestWrapper(final TestId testId,
    final TearDownAccepter tearDownAccepter) {
  
  return new TestWrapper() {
    
    public void toRunBeforeTest() {
      tearDownAccepter.addTearDown(new TearDown() {
        
        public void tearDown() throws Exception {
          System.out.println("Ending: " + testId);
        }
      });
      System.out.println("Beginning: " + testId);
    }
  };
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@Provides
TestWrapper getTestWrapper(final TestId testId,
    final TearDownAccepter tearDownAccepter) {
  
  return new TestWrapper() {
    
    public void toRunBeforeTest() {
      tearDownAccepter.addTearDown(new TearDown() {
        
        public void tearDown() throws Exception {
          System.out.println("Ending: " + testId);
        }
      });
      System.out.println("Beginning: " + testId);
    }
  };
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
static void repeatedlyInterruptTestThread(
    long interruptPeriodMillis, TearDownAccepter tearDownAccepter) {
  final Interruptenator interruptingTask =
      new Interruptenator(Thread.currentThread(), interruptPeriodMillis);
  final Thread interruptingThread = new Thread(interruptingTask);
  interruptingThread.start();
  tearDownAccepter.addTearDown(
      new TearDown() {
        @Override
        public void tearDown() throws Exception {
          interruptingTask.stopInterrupting();
          interruptingThread.interrupt();
          joinUninterruptibly(interruptingThread, 2500, MILLISECONDS);
          Thread.interrupted();
          if (interruptingThread.isAlive()) {
            // This will be hidden by test-output redirection:
            logger.severe("InterruptenatorTask did not exit; future tests may be affected");
            /*
             * This won't do any good under JUnit 3, but I'll leave it around in
             * case we ever switch to JUnit 4:
             */
            fail();
          }
        }
      });
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
protected void configure() {
  for (Map.Entry<Key<?>, IcStrategy> e : rewriter.entrySet()) {
    bind(IcStrategy.wrap(IcClient.class, e.getKey()))
       .toProvider(new MyClientProvider(
           e.getKey(), 
           getProvider(TestId.class), 
           getProvider(e.getValue().clientSupportClass()),
           getProvider(TearDownAccepter.class)));
  }
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
public MyClientProvider(Key<T> key,  
    Provider<TestId> testIdProvider, 
    Provider<IcStrategy.ClientSupport> clientControllerSupportProvider,
    Provider<TearDownAccepter> tearDownAccepterProvider) {
  this.key = key;
  this.testIdProvider = testIdProvider;
  this.clientControllerSupportProvider = clientControllerSupportProvider;
  this.tearDownAccepterProvider = tearDownAccepterProvider;
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
@Override
protected void configure() {
  for (Map.Entry<Key<?>, IcStrategy> e : rewriter.entrySet()) {
    bind(IcStrategy.wrap(InjectionController.class, e.getKey()))
       .toProvider(new MyClientProvider(
           e.getKey(), 
           getProvider(TestId.class), 
           getProvider(e.getValue().clientSupportClass()),
           getProvider(TearDownAccepter.class)));
  }
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
public synchronized void runBeforeTest() {
  
  // If anything should go wrong, we "tag" this scaffolding as having failed
  // to acquire an injector, so that the tear down knows to skip the
  // appropriate steps.
  injector = BOGUS_INJECTOR;

  checkPreviousTestCalledTearDown(testDescription);
  
  final Class<? extends Module> gbeClass =
    guiceBerryEnvSelector.guiceBerryEnvToUse(testDescription);
  
  universe.currentTestDescriptionThreadLocal.set(testDescription);
  injector = getAndSetInjector(gbeClass);

  stack.addTearDown(new TearDown() {
    public void tearDown() throws Exception {
      doTearDown();
    }
  });
  
  stack.addTearDown(new TearDown() {
    public void tearDown() throws Exception {
      ToTearDown toTearDown = injector.getInstance(ToTearDown.class);
      toTearDown.runTearDown();
    }
  });
  
  TearDownAccepter accepter = wrappedGetInstance(injector, TearDownAccepter.class, gbeClass);
  buildTestWrapperInstance(injector).toRunBeforeTest();
  
  injectMembersIntoTest(gbeClass, injector); 
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
private static TestWrapper adapt(
    final com.google.inject.testing.guiceberry.TestScopeListener instance,
    final TearDownAccepter tearDownAccepter) {
  return new TestWrapper() {

    public void toRunBeforeTest() {
      tearDownAccepter.addTearDown(new TearDown() {
        public void tearDown() throws Exception {
          instance.exitingScope();
        }
      });
      instance.enteringScope();
    }
  };
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@Override
protected void configure() {
  TestScope testScope = new TestScope(universe);
  bind(TestScope.class).toInstance(testScope);
  bindScope(TestScoped.class, testScope);
  bind(TearDownAccepter.class).to(ToTearDown.class);
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@Deprecated
public static void maybeAddGuiceBerryTearDown(
    ThreadLocal<TearDown> scaffoldingThreadLocal, final TestDescription testDescription,
    final TearDown toTearDown) {
  Object testToTearDown = testDescription.getTestCase();
  if (testToTearDown instanceof TearDownAccepter) {
    TearDownAccepter tdtc = (TearDownAccepter) testToTearDown;
    tdtc.addTearDown(toTearDown);
  } else {
    scaffoldingThreadLocal.set(toTearDown);
  }
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
private AbstractModule buildTestModule(final IcMaster icMaster) {
  return new AbstractModule() {
    @Override
    protected void configure() {
      install(icMaster.buildClientModule());
      bind(TestId.class).toInstance(TEST_ID);
      bind(TearDownAccepter.class).toInstance(new TearDownStack());
    }
  };
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@SuppressWarnings("unused")
@Provides
TestWrapper getWrapper(final TearDownAccepter tearDownAccepter) {
  
  return new TestWrapper() {
    public void toRunBeforeTest() {
      tearDownAccepter.addTearDown(new TearDown() {
        public void tearDown() throws Exception {
          beforeTestTearDownHasRun = true;
        }
      });
      throw new RuntimeException("kaboom");
    }
  };
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
@Inject
public BrowserProvider(BrowserFactory browserFactory, TearDownAccepter tearDownAccepter) {
    this.browserFactory = browserFactory;
    this.tearDownAccepter = tearDownAccepter;
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
/**   
 * You should only call this method if your test does <em>not</em> implement 
 * {@link TearDownAccepter}.
 *
 * <p>Stops storing the information that {@link TestCase} (given as the argument) 
 * is being run.
 * 
 * <p>Notifies {@link  TestScopeListener} corresponding to this module (
 * The {@link GuiceBerryEnv} annotation of the test case provides the name  
 * of the module)that {@link TestCase} has just become out of scope.
 * It also causes that {@link TestCase} is removed from the {@code TestScope} 
 * assigned to this  module. 
 * 
 * <p>Do not change the value (if any) of the
 * {@link GuiceBerryEnvRemapper#GUICE_BERRY_ENV_REMAPPER_PROPERTY_NAME} 
 * property, as it will likely cause the wrong {@link GuiceBerryEnv} to be
 * used on your tearDown.
 * 
 * <p>If your code, for whatever reason, happens to synchronize on the test
 * class while calling the {@link #setUp(TestCase)} method, <em>and</em> you 
 * run your tests in parallel, you should likewise synchronize the 
 * {@link #tearDown(TestCase)}.
 *
 * @throws IllegalArgumentException If the {@link TestCase} provided  as an 
 *     argument  has no {@link GuiceBerryEnv} annotation or the module 
 *     provided by this annotation does not exist or {@link TestCase} is not 
 *     a type of {@code Class <? extends Module>}.   
 * @throws RuntimeException If the method {@link GuiceBerryJunit3#setUp(TestCase)} 
 *     wasn't called before calling this method.                                 
 * 
 * @see TestScopeListener
 * @see com.google.guiceberry.TestScoped
 */
public synchronized static void tearDown(TestCase testCase) {
  if (testCase instanceof TearDownAccepter) {
    throw new UnsupportedOperationException("You must not call " +
    		"GuiceBerryJunit3.tearDown (it's only needed for tests that do " +
    		"not implement TearDownAccepter).");
  }
  try {
    scaffoldingThreadLocal.get().tearDown();
  } catch (Exception e) {
    throw new RuntimeException(e);
  } finally {
    scaffoldingThreadLocal.remove();
  }
}
 

import com.google.common.testing.TearDownAccepter; //导入依赖的package包/类
/**
 * Sets up the {@code testCase} by leveraging the 
 * {@link AnnotationBasedGuiceBerryEnvSelector} and automatically registers a 
 * {@link TearDown} (thus the "auto" moniker).
 */
public static <T extends TestCase & TearDownAccepter> void setUp(
    /*TearDownTestCase*/ T testCase) {
  AutoTearDownGuiceBerry.setUp(testCase, AnnotationBasedGuiceBerryEnvSelector.INSTANCE);
}