Java TearDownAccepter类代码示例

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");
    }
  };
}