Java Code Examples for org.junit.Before

@Before
public void setUp() throws Exception {
    this.action = new PrincipalFromRequestRemoteUserNonInteractiveCredentialsAction();

    final Map<String, UniqueTicketIdGenerator> idGenerators = new HashMap<>();
    idGenerators.put(SimpleWebApplicationServiceImpl.class.getName(), new DefaultUniqueTicketIdGenerator());


    final AuthenticationManager authenticationManager = new PolicyBasedAuthenticationManager(
            Collections.<AuthenticationHandler, PrincipalResolver>singletonMap(
                    new PrincipalBearingCredentialsAuthenticationHandler(),
                    new PrincipalBearingPrincipalResolver()));
    final CentralAuthenticationServiceImpl centralAuthenticationService = new CentralAuthenticationServiceImpl(
            new DefaultTicketRegistry(), null, authenticationManager, new DefaultUniqueTicketIdGenerator(),
            idGenerators, new NeverExpiresExpirationPolicy(), new NeverExpiresExpirationPolicy(),
            mock(ServicesManager.class), mock(LogoutManager.class));
    this.action.setCentralAuthenticationService(centralAuthenticationService);
}
 

@Before
public void setUp() throws InterruptedException {
	super.setUp();
	HashMap testMap = new <String, Object> HashMap();
	testMap.put("testComponet", "AG_Border");
	testMap.put("testChildCaseInit", "AG_Border_Text_Border_Left_Color");
	testMap.put("step1",new HashMap(){
		{
			put("click", "#FF0000");
			put("screenshot", "AG_Border_Text_Border_Left_Color_01_#FF0000");
		}
	});
	testMap.put("step2",new HashMap(){
		{
			put("click", "#00FFFF");
			put("screenshot", "AG_Border_Text_Border_Left_Color_02_#00FFFF");
		}
	});
	super.setTestMap(testMap);
}
 

@Before
public void init() throws Exception {
    MobileEngageExperimental.enableFeature(MobileEngageFeature.IN_APP_MESSAGING);

    application = (Application) InstrumentationRegistry.getTargetContext().getApplicationContext();
    coreCompletionHandler = mock(MobileEngageCoreCompletionHandler.class);
    mobileEngageInternal = mock(MobileEngageInternal.class);
    inboxInternal = mock(InboxInternal.class);
    baseConfig = new MobileEngageConfig.Builder()
            .application(application)
            .credentials(appID, appSecret)
            .disableDefaultChannel()
            .build();
    MobileEngage.inboxInstance = inboxInternal;
    MobileEngage.instance = mobileEngageInternal;
    MobileEngage.completionHandler = coreCompletionHandler;

    ConnectivityWatchdogTestUtils.resetCurrentActivityWatchdog();
}
 

@Before
public void setup() {
    // set up mock objects
    request = mock(Request.class);
    session = mock(Session.class);
    when(request.session()).thenReturn(session);
    engine = mock(TemplateEngine.class);

    // set up friendly objects
    playerLobby = new PlayerLobby();
    playerLobby.addPlayer(new Player("inuse"));
    gameLobby = new GameLobby();
    gameCenter = new GameCenter(playerLobby, gameLobby);

    CuT = new PostSigninRoute(engine, gameCenter);
}
 

@Before
public void setup() throws Exception {
  TEST_UTIL.startMiniZKCluster();
  Configuration conf = TEST_UTIL.getConfiguration();
  zkw = new ZooKeeperWatcher(TEST_UTIL.getConfiguration(),
      "split-log-worker-tests", null);
  ds = new DummyServer(zkw, conf);
  ZKUtil.deleteChildrenRecursively(zkw, zkw.baseZNode);
  ZKUtil.createAndFailSilent(zkw, zkw.baseZNode);
  assertThat(ZKUtil.checkExists(zkw, zkw.baseZNode), not (is(-1)));
  LOG.debug(zkw.baseZNode + " created");
  ZKUtil.createAndFailSilent(zkw, zkw.splitLogZNode);
  assertThat(ZKUtil.checkExists(zkw, zkw.splitLogZNode), not (is(-1)));

  LOG.debug(zkw.splitLogZNode + " created");
  ZKUtil.createAndFailSilent(zkw, zkw.rsZNode);
  assertThat(ZKUtil.checkExists(zkw, zkw.rsZNode), not (is(-1)));

  SplitLogCounters.resetCounters();
  executorService = new ExecutorService("TestSplitLogWorker");
  executorService.startExecutorService(ExecutorType.RS_LOG_REPLAY_OPS, 10);
  this.mode = (conf.getBoolean(HConstants.DISTRIBUTED_LOG_REPLAY_KEY, false) ?
      RecoveryMode.LOG_REPLAY : RecoveryMode.LOG_SPLITTING);
}
 

@Before
public void setUp() throws InterruptedException {
	super.setUp();
	HashMap testMap = new <String, Object> HashMap();
	testMap.put("testComponet", "AG_Border");
	testMap.put("testChildCaseInit", "AG_Border_Image_Border_Right_Color");
	testMap.put("step1",new HashMap(){
		{
			put("click", "#FF0000");
			put("screenshot", "AG_Border_Image_Border_Right_Color_01_#FF0000");
		}
	});
	testMap.put("step2",new HashMap(){
		{
			put("click", "#00FFFF");
			put("screenshot", "AG_Border_Image_Border_Right_Color_02_#00FFFF");
		}
	});
	super.setTestMap(testMap);
}
 

@Before
public void setupCoordinator() {
    this.mockTime = new MockTime();
    this.mockClient = new MockClient(mockTime);

    Metadata metadata = new Metadata(100L, 60 * 60 * 1000L, true);
    this.consumerClient = new ConsumerNetworkClient(mockClient, metadata, mockTime,
            RETRY_BACKOFF_MS, REQUEST_TIMEOUT_MS);
    Metrics metrics = new Metrics();

    Cluster cluster = TestUtils.singletonCluster("topic", 1);
    metadata.update(cluster, Collections.<String>emptySet(), mockTime.milliseconds());
    this.node = cluster.nodes().get(0);
    mockClient.setNode(node);

    this.coordinatorNode = new Node(Integer.MAX_VALUE - node.id(), node.host(), node.port());
    this.coordinator = new DummyCoordinator(consumerClient, metrics, mockTime);
}
 

@Before
public void setUp() throws Exception {
	points = new Point[6][2];
	graph = new DijkstraGraph();
	for(int y = 0; y < 2; y++) {
		for(int x = 0; x < 6; x++) {
			points[x][y] = new Point(1.0);
			graph.addPoint(points[x][y]);
			if(y != 0) {
				graph.addConnection(points[x][y], points[x][y - 1]);
			}
			if(x != 0) {
				graph.addConnection(points[x][y], points[x - 1][y]);
			}
		}
	}
	points[0][1].entryCost = 2.0;
	points[2][0].entryCost = 4.0;
	points[4][1].entryCost = 4.0;
}
 

@Before
public void before() {
    stubProviderOne = new StateStoreProviderStub(false);
    stubProviderTwo = new StateStoreProviderStub(false);
    underlyingWindowStore = new ReadOnlyWindowStoreStub<>(WINDOW_SIZE);
    stubProviderOne.addStore(storeName, underlyingWindowStore);

    otherUnderlyingStore = new ReadOnlyWindowStoreStub<>(WINDOW_SIZE);
    stubProviderOne.addStore("other-window-store", otherUnderlyingStore);


    windowStore = new CompositeReadOnlyWindowStore<>(
        new WrappingStoreProvider(Arrays.<StateStoreProvider>asList(stubProviderOne, stubProviderTwo)),
            QueryableStoreTypes.<String, String>windowStore(),
            storeName);
}
 

@Before
public void setUp() throws InterruptedException {
	super.setUp();
	HashMap testMap = new <String, Object> HashMap();
	testMap.put("testComponet", "AG_Input");
	testMap.put("testChildCaseInit", "AG_Input_Input_Font_Style");
	testMap.put("step1",new HashMap(){
		{
			put("click", "normal");
			put("screenshot", "AG_Input_Input_Font_Style_01_normal");
		}
	});
	testMap.put("step2",new HashMap(){
		{
			put("click", "italic");
			put("screenshot", "AG_Input_Input_Font_Style_02_italic");
		}
	});
	super.setTestMap(testMap);
}
 

@Before public void setUp() {
  Retrofit retrofit = new Retrofit.Builder()
      .baseUrl(server.url("/"))
      .addConverterFactory(new StringConverterFactory())
      .addCallAdapterFactory(ScalaCallAdapterFactory.create())
      .build();
  service = retrofit.create(Service.class);
}
 

@Before
public void setUp() {
    groupAnswersControllerModel = new GroupAnswersControllerModel(identifiableAnswersByTypeFinder, model);
    groupController1 = mock(GroupAnswersController.class);
    groupController2 = mock(GroupAnswersController.class);

    groupControllers = Lists.newArrayList(groupController1, groupController2);

    groupAnswersControllerModel.setGroupChoicesControllers(groupControllers);
}
 

@Before
public void setUp() throws Exception {
    idpEntityId = "idpEntityId";
    rpEntityId = "rpEntityId";
    translatedAuthnRequest = SamlResponseWithAuthnRequestInformationDtoBuilder.aSamlResponseWithAuthnRequestInformationDto().withIssuer(rpEntityId).build();
    rpSamlRequest = SamlAuthnRequestContainerDtoBuilder.aSamlAuthnRequestContainerDto().build();
    idpSsoUri = UriBuilder.fromPath("idpSsoUri").build();

    configStub.reset();
    configStub.setupStubForEnabledIdps(asList(idpEntityId));
    configStub.setUpStubForLevelsOfAssurance(rpEntityId);
    configStub.setUpStubForMatchingServiceEntityId(rpEntityId, msEntityId);
    configStub.setupStubForEidasEnabledForTransaction(rpEntityId, false);
    eventSinkStub.setupStubForLogging();
}
 

@Before
public void setup() throws Exception {
    emptyLogsFolder();

    configServiceMock = setupConfigurationMockForLogging();
    listener = new LoggerInitListener() {
        @Override
        ConfigurationService getConfigurationService() {
            return configServiceMock;
        }
    };

    logger = LoggerFactory.getLogger(this.getClass());
}
 

@Before
public void setUp() {
	operations.dropCollection(Image.class);

	operations.insert(new Image("1",
		"learning-spring-boot-cover.jpg"));
	operations.insert(new Image("2",
		"learning-spring-boot-2nd-edition-cover.jpg"));
	operations.insert(new Image("3",
		"bazinga.png"));
}
 

@Before
public void setUp() throws Exception {
  resourceMgrDelegate = mock(ResourceMgrDelegate.class);
  conf = new YarnConfiguration();
  conf.set(YarnConfiguration.RM_PRINCIPAL, "mapred/[email protected]");
  clientCache = new ClientCache(conf, resourceMgrDelegate);
  clientCache = spy(clientCache);
  yarnRunner = new YARNRunner(conf, resourceMgrDelegate, clientCache);
  yarnRunner = spy(yarnRunner);
  submissionContext = mock(ApplicationSubmissionContext.class);
  doAnswer(
      new Answer<ApplicationSubmissionContext>() {
        @Override
        public ApplicationSubmissionContext answer(InvocationOnMock invocation)
            throws Throwable {
          return submissionContext;
        }
      }
      ).when(yarnRunner).createApplicationSubmissionContext(any(Configuration.class),
          any(String.class), any(Credentials.class));

  appId = ApplicationId.newInstance(System.currentTimeMillis(), 1);
  jobId = TypeConverter.fromYarn(appId);
  if (testWorkDir.exists()) {
    FileContext.getLocalFSFileContext().delete(new Path(testWorkDir.toString()), true);
  }
  testWorkDir.mkdirs();
}
 

@Before
public void setup() throws Exception {
    debugSession = DebugSessionFactory.getDebugSession(PROJECT_NAME, "VariableTest");
    if (staticBreakpointEvent == null) {
        staticBreakpointEvent = waitForBreakPointEvent("VariableTest", 60);
    }
}
 

@Before
public void setUp() throws Exception {
    stubSamlEngineTranslationLOAForCountry(LevelOfAssurance.LEVEL_2, NETHERLANDS);
    stubSamlEngineGenerationOfAQR();
    configStub.reset();
    configStub.setUpStubForMatchingServiceRequest(RP_ENTITY_ID, MS_ENTITY_ID, true);
    configStub.setupStubForEnabledIdps(asList(IDP_ENTITY_ID));
    configStub.setUpStubForLevelsOfAssurance(RP_ENTITY_ID);
    configStub.setupStubForEidasEnabledForTransaction(RP_ENTITY_ID, false);
    enableCountriesForRp(RP_ENTITY_ID, NETHERLANDS, SPAIN);
    configStub.setupStubForEidasCountries(EIDAS_COUNTRIES);
    eventSinkStub.reset();
    eventSinkStub.setupStubForLogging();
}
 

@Before
public void init() {
    AppExecutors appExecutors = useRealExecutors
            ? countingAppExecutors.getAppExecutors()
            : new InstantAppExecutors();
    networkBoundResource = new NetworkBoundResource<Foo, Foo>(appExecutors) {
        @Override
        protected void saveCallResult(@NonNull Foo item) {
            saveCallResult.apply(item);
        }

        @Override
        protected boolean shouldFetch(@Nullable Foo data) {
            // since test methods don't handle repetitive fetching, call it only once
            return shouldFetch.apply(data) && fetchedOnce.compareAndSet(false, true);
        }

        @NonNull
        @Override
        protected LiveData<Foo> loadFromDb() {
            return dbData;
        }

        @NonNull
        @Override
        protected LiveData<ApiResponse<Foo>> createCall() {
            return createCall.apply(null);
        }
    };
}
 

@Before
public void setUp() {
    localePersistor = mock(LocalePersistor.class);
    localeResolver = mock(LocaleResolver.class);
    defaultLocalePair = mock(DefaultResolvedLocalePair.class);
    doReturn(defaultLocalePair).when(localeResolver).resolveDefault();
    appLocaleChanger = mock(AppLocaleChanger.class);
    sut = new LocaleChangerDelegate(localePersistor, localeResolver, appLocaleChanger);
}
 

@Before
public void setUp() {

    //init the test values
    ActionClassOne.ACTION_VALUE = 0;
    ActionClassTwo.ACTION_VALUE = 0;
}
 

@Before
public void setUp() throws Exception {
    block1 = new PolyBlockImpl();
    block2 = new PolyBlockImpl();
    block3 = new PolyBlockImpl();
    block4 = new PolyBlockImpl();
    block5 = new PolyBlockImpl();
}
 

@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);

    HttpParams httpParams = new BasicHttpParams();
    when(mockHttpClientFactory.create()).thenReturn(mockHttpClient);
    when(mockHttpClient.getParams()).thenReturn(httpParams);
    when(mockHttpClient.getConnectionManager()).thenReturn(mockClientConnectionManager);
    when(mockClientConnectionManager.getSchemeRegistry()).thenReturn(mockSchemeRegistry);
}
 

@Before
public void setUp() throws Exception {
    LOG.info("Setup test");
    realAdapter = (RealAdapter) adapterLoader.getAdapter("helionSwiftReal.properties");
    prov = realAdapter.getProvider();
    session = new SessionImpl("sessionOne", sessionManager.getInterval());
    aggregationManager.createSession(session);
    stitcher.createSession(session);
    // this triggers the data collection
    adapterManager.userConnected(session, prov, creds);
}
 

@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    AuditEventService auditEventService =
        new AuditEventService(auditEventRepository, auditEventConverter);
    AuditResource auditResource = new AuditResource(auditEventService);
    this.restAuditMockMvc = MockMvcBuilders.standaloneSetup(auditResource)
        .setCustomArgumentResolvers(pageableArgumentResolver)
        .setConversionService(formattingConversionService)
        .setMessageConverters(jacksonMessageConverter).build();
}
 

@Before
public void setUp(){
    Properties properties = new Properties();
    try {
        properties.load(new FileInputStream("./cfg/sandbox.properties"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    this.goodApiService = new ApiService(StarlingBankEnvironment.SANDBOX, properties.getProperty("starling.access.token"));
}
 

@Before
public void setUp() throws Exception {
    MockitoAnnotations.initMocks(this);
    vServerProcessor = spy(new VServerProcessorBean());
    vServerProcessor.vserverComm = mock(VServerCommunication.class);
    vServerProcessor.vsysComm = mock(VSystemCommunication.class);
    vServerProcessor.fwComm = mock(FWCommunication.class);
    vServerProcessor.vdiskInfo = mock(VDiskCommunication.class);
    platformService = mock(APPlatformService.class);
    doReturn("RUNNING").when(vServerProcessor.fwComm).getFirewallStatus(
            any(PropertyHandler.class));
    doReturn(Boolean.TRUE).when(platformService).lockServiceInstance(
            anyString(), anyString(), any(PasswordAuthentication.class));
    doNothing().when(platformService).unlockServiceInstance(anyString(),
            anyString(), any(PasswordAuthentication.class));
    doNothing().when(platformService).sendMail(anyListOf(String.class),
            subject.capture(), text.capture());
    User user = new User();
    user.setLocale("de");
    doReturn(user).when(platformService).authenticate(anyString(),
            any(PasswordAuthentication.class));
    vServerProcessor.setPlatformService(platformService);

    parameters = new HashMap<>();
    configSettings = new HashMap<>();
    settings = new ProvisioningSettings(parameters, configSettings, "en");
    settings.setSubscriptionId("subId");
    paramHandler = new PropertyHandler(settings);
}
 

@Before
public void setup() throws Exception {
  RaftProperties properties = new RaftProperties();
  storageDir = getTestDir();
  RaftServerConfigKeys.setStorageDir(properties, storageDir);
  this.segmentMaxSize =
      RaftServerConfigKeys.Log.segmentSizeMax(properties).getSize();
  this.preallocatedSize =
      RaftServerConfigKeys.Log.preallocatedSize(properties).getSize();
  this.bufferSize =
      RaftServerConfigKeys.Log.writeBufferSize(properties).getSizeInt();
}
 

/**
 * Setup your test fixture with a fake task id. The {@link TaskDetailActivity} is started with
 * a particular task id, which is then loaded from the service API.
 *
 * <p>
 * Note that this test runs hermetically and is fully isolated using a fake implementation of
 * the service API. This is a great way to make your tests more reliable and faster at the same
 * time, since they are isolated from any outside dependencies.
 */
@Before
public void intentWithStubbedTaskId() {
    // Given some tasks
    TasksRepository.destroyInstance();
    TasksRepository repository = Injection.provideTasksRepository(InstrumentationRegistry.getContext());
    repository.saveTask(new Task("Title1", "", false));
    repository.saveTask(new Task("Title2", "", true));

    // Lazily start the Activity from the ActivityTestRule
    Intent startIntent = new Intent();
    mStatisticsActivityTestRule.launchActivity(startIntent);
}
 

@Before
public void setUp() throws Exception {
    initMocks(this);

    Mockito.when(mURL.openConnection()).thenReturn(mConnection);
    Mockito.when(mURL.openConnection(mProxy)).thenReturn(mConnection);
}
 

@Before
public void setup() {
    this.rest = WebTestClient
        .bindToServer()
        .responseTimeout(Duration.ofDays(1))
        .baseUrl("http://localhost:" + this.port)
        .build();
}
 

@Before
public void initialize() {
	MockitoAnnotations.initMocks(this);
	when(mockedLargeImg.getSize()).thenReturn(ImageSizePreset.FULL.getSize());
	when(mockedIconImg.getSize()).thenReturn(ImageSizePreset.ICON.getSize());
	when(mockedMainImg.getSize()).thenReturn(ImageSizePreset.MAIN_IMAGE.getSize());
	when(mockedPreviewImg.getSize()).thenReturn(ImageSizePreset.PREVIEW.getSize());
}
 

@Override
@Before
public void setUp() throws JsonIOException, IOException, IntegrationException {
    final List<BlackDuckFortifyMapperGroup> blackDuckFortifyMappers = mappingParser
            .createMapping(propertyConstants.getMappingJsonPath());
    HUB_PROJECT_NAME_1 = blackDuckFortifyMappers.get(0).getHubProjectVersion().get(0).getHubProject();
    HUB_PROJECT_VERSION_NAME_1 = blackDuckFortifyMappers.get(0).getHubProjectVersion().get(0).getHubProjectVersion();
    HUB_PROJECT_NAME_2 = blackDuckFortifyMappers.get(1).getHubProjectVersion().get(0).getHubProject();
    HUB_PROJECT_VERSION_NAME_2 = blackDuckFortifyMappers.get(1).getHubProjectVersion().get(0).getHubProjectVersion();
}
 

@Before
public void setUp() {
    RealmConfiguration config = configFactory.createConfiguration();
    sharedRealm = OsSharedRealm.getInstance(config);
    sharedRealm.beginTransaction();
    table = sharedRealm.createTable("test_table");
}
 

@Before
public void setup(){
    filenum = 4; // pick 1, 2, 3 or 4
    int numofmolecules = NIST_nmol[filenum-1];
    double boxlength = NIST_boxl[filenum -1];
    double kcut = Math.sqrt(26.999)*2*Math.PI/boxlength;
    double rCutRealES = 10;
    Space space = Space.getInstance(3);
    box = new Box(space);
    SpeciesWater3P species = new SpeciesWater3P(space,false);
    ChargeAgentSourceSPCE agentSource = new ChargeAgentSourceSPCE(species);
    AtomLeafAgentManager<EwaldSummation.MyCharge> atomAgentManager = new AtomLeafAgentManager<EwaldSummation.MyCharge>(agentSource, box);
    sim = new Simulation(space);

    sim.addSpecies(species);
    sim.addBox(box);
    box.setNMolecules(species,numofmolecules);
    box.getBoundary().setBoxSize(new Vector3D(boxlength,boxlength,boxlength));

    es = new EwaldSummation(box,atomAgentManager,space,kcut,rCutRealES);
    es.setAlpha(5.6/boxlength);

    Configuration config = new ConfigurationResourceFile(
            String.format("etomica/potential/spce"+String.valueOf(filenum)+".pos"),
            EwaldSummationTest.class
    );

    config.initializeCoordinates(box);



}
 

@Before
public void setUp() throws Exception {
    parameters = new HashMap<>();
    configSettings = new HashMap<>();
    settings = new ProvisioningSettings(parameters, configSettings, "en");
    propertyHandler = new PropertyHandler(settings);
}
 

@Before
public void setup() throws IOException {
  conf = new Configuration();
  conf.setLong(DFSConfigKeys.DFS_BLOCK_SIZE_KEY, BLOCKSIZE);
  cluster = new MiniDFSCluster.Builder(conf).numDataNodes(REPLICATION)
      .build();
  cluster.waitActive();
}
 

@Before
public void setUp() {
    context = InstrumentationRegistry.getInstrumentation().getContext();

    RealmConfiguration realmConfig = configFactory.createConfiguration();
    realm = Realm.getInstance(realmConfig);
}
 

@Before
public void initGraph() {
    _graph = new GraphBuilder().build();
    _graph.connect(new Callback<Boolean>() {
        @Override
        public void on(Boolean result) {
            Node root = _graph.newNode(0, 0);
            root.set("name", Type.STRING, "root");

            Node n1 = _graph.newNode(0, 0);
            n1.set("name", Type.STRING, "n1");

            Node n2 = _graph.newNode(0, 0);
            n2.set("name", Type.STRING, "n2");

            Node n3 = _graph.newNode(0, 0);
            n3.set("name", Type.STRING, "n3");

            root.addToRelation("child", n1);
            root.addToRelation("child", n2);
            root.addToRelation("child", n3);

            _graph.declareIndex(0, "rootIndex", rootIndex -> {
                rootIndex.update(root);
            }, "name");
        }
    });

}
 

@Before
public void before() throws Throwable {
  restoreSystemProperties.before();
  temporaryFolder.create();
  Invoke.invokeInEveryVM("Stop each VM", this::stopServerOrLocatorInThisVM);
  members = new ArrayList<>(4);
}
 

@Before
public void setUp() throws Exception
{
    transactionService = (TransactionService) ctx.getBean("TransactionService");
    
    attributeService = (AttributeService) ctx.getBean("AttributeService");
    propertyValueDAO = (PropertyValueDAO) ctx.getBean("propertyValueDAO");
    
    // Remove the caches to test all functionality
    clearCaches();
}
 

@Before
public void setUpTestDataWithinTransaction() {
  Assert.assertEquals(0, appRepository.count());
  Assert.assertEquals(7, appNamespaceRepository.count());
  Assert.assertEquals(0, namespaceRepository.count());
  Assert.assertEquals(0, clusterRepository.count());
}
 

@Before
public void setup() {
    assertEquals("^/opt(/[^/]*)(/.*)?", AdmRule.getMatchPattern().pattern());

    rule = new AdmRule();
    rule.setRewriteTo(rewriteTo + "$2");
    rule.setRevertPattern(Pattern.compile("^" + rewriteTo + "(/.*)?"));

    LoggerFactory.activateRollingFileAppender("./logs", null, "DEBUG");
}
 

@Before
public void setUp() {
    klass = Reflex.reflect(klassName);
    try {
        dictionaryClass = ReflectionUtils.findClass("Dictionary");
        dictionaryConstructor = ReflectionUtils.requireConstructor(dictionaryClass);
        translateMethod = ReflectionUtils.requireMethod(dictionaryClass, "translate", String.class);
        addMethod = ReflectionUtils.requireMethod(dictionaryClass, "add", String.class, String.class);
        textUserInterfaceClass = ReflectionUtils.findClass("TextUserInterface");
        textUserInterfaceConstructor = ReflectionUtils.requireConstructor(textUserInterfaceClass, Scanner.class, dictionaryClass);
        startMethod = ReflectionUtils.requireMethod(textUserInterfaceClass, "start");
    } catch (Throwable t) {
    }
}
 

@Before
public void setUp() {
    this.mAchievementsEventsContainer = new AchievementsEventsContainer();
    mAchievements = Arrays.asList(mock(Achievement.class), mock(Achievement.class));
    mEvents = Arrays.asList(mock(Event.class), mock(Event.class));
}
 

@Before
public void setUp() {
    file = createNewFile();
}
 

@Before
public void setUp() throws Exception {
    asbrSummaryLsa = new AsbrSummaryLsa(new LsaHeader());
}
 

@Override
@Before
public void setUp() throws Exception {
  super.setUp();
}
 

@Before
public void setUpNameNode() throws IOException {
  conf = new HdfsConfiguration();
  cluster = new MiniDFSCluster.Builder(conf).numDataNodes(0).build();
}
 

@Before
public void setUp() {
	requestBuilder = PasswordParametersRequest.builder();
}
 

@Before
public void setUp() {
    tickTimeProvider = new TickTimeProvider(tickTimeRepositoryMock, timeWatchMock);
}
 

@Before
public void setUp(){
    fileHandler = FileHandler.getInstance();
    filter = Filter.getInstance();
    unitManager = UnitManager.getInstance();
}
 

@Before
public void initStubData() {
  KernelManager.register(new KernelTest());
}
 

@Before
public void setup() {
	initMocks(this);
	this.mockMvc = MockMvcBuilders.standaloneSetup(statisticsController).build();
}
 

@Before
public void setup() {
    Utils.deleteExistingAccounts(preferences);
    controller = Robolectric.buildActivity( AccountSetupBasics.class ).create().resume();
}
 

@Before
public void setup() {
    mockChildren = TestHelper.setupMockChildren();
}
 

@Before
public void setUp() {
}
 

@Before
public void setUp() throws Exception {
    trafficEngineeringMetric = new TrafficEngineeringMetric(new TlvHeader());
}
 

@Before
public void setUp() throws Exception {
    db = new MySQLiteOpenHelper(RuntimeEnvironment.application, "test", null, 1).getWritableDatabase();
}
 

@Before
public void setUp() {
}