private void uploadResourcesToConfigRegistry() throws Exception {

    ResourceAdminServiceClient resourceAdminServiceStub =
        new ResourceAdminServiceClient(
            context.getContextUrls().getBackEndUrl(), getSessionCookie());

    resourceAdminServiceStub.deleteResource("/_system/config/sequence");
    resourceAdminServiceStub.addCollection(
        "/_system/config/", "sequence", "", "Contains test sequence files");

    resourceAdminServiceStub.addResource(
        "/_system/config/sequence/out_sequence.xml",
        "application/vnd.wso2.sequence",
        "application/vnd.wso2.sequence files",
        new DataHandler(
            new URL(
                "file:///"
                    + getESBResourceLocation()
                    + "/proxyconfig/proxy/utils/out_sequence.xml")));

    Thread.sleep(2000);

    resourceAdminServiceStub.addResource(
        "/_system/config/sequence/fault_sequence.xml",
        "application/vnd.wso2.sequence",
        "application/vnd.wso2.sequence files",
        new DataHandler(
            new URL(
                "file:///"
                    + getESBResourceLocation()
                    + "/proxyconfig/proxy/utils/fault_sequence.xml")));

    Thread.sleep(1000);
  }
    @Override
    public void run() {
      try {
        final MessageSender sender = msm.acquireSender();
        Thread.sleep(rnd.nextInt(THREAD_SLEEP_MILLIS));
        msm.releaseSender(sender);
        counter.decrementAndGet();

      } catch (final Throwable t) {
        threads.put(Thread.currentThread(), t);
      }
    }
  /**
   * Tests update of session expiration in memcached (like {@link
   * #testExpirationOfSessionsInMemcachedIfBackupWasSkippedSimple()}) but for the scenario where
   * many readonly requests occur: in this case, we cannot just use <em>maxInactiveInterval -
   * secondsSinceLastBackup</em> (in {@link MemcachedSessionService#updateExpirationInMemcached}) to
   * determine if an expiration update is required, but we must use the last expiration time sent to
   * memcached.
   *
   * @throws Exception if something goes wrong with the http communication with tomcat
   */
  @Test(enabled = true, dataProviderClass = TestUtils.class, dataProvider = STICKYNESS_PROVIDER)
  public void testExpirationOfSessionsInMemcachedIfBackupWasSkippedManyReadonlyRequests(
      final SessionAffinityMode stickyness) throws Exception {

    final SessionManager manager = _tomcat1.getManager();
    setStickyness(stickyness);

    // set to 1 sec above (in setup), default is 10 seconds
    final int delay = manager.getContainer().getBackgroundProcessorDelay();
    manager.setMaxInactiveInterval(delay * 4);

    final String sessionId1 = makeRequest(_httpClient, _portTomcat1, null);
    assertNotNull(sessionId1, "No session created.");
    assertWaitingWithProxy(Predicates.<MemcachedClientIF>notNull(), 200l, _memcached)
        .get(sessionId1);

    /* after 3 seconds make another request without changing the session, so that
     * it's not sent to memcached
     */
    Thread.sleep(TimeUnit.SECONDS.toMillis(delay * 3));
    assertEquals(
        makeRequest(_httpClient, _portTomcat1, sessionId1),
        sessionId1,
        "SessionId should be the same");
    assertNotNull(_memcached.get(sessionId1), "Session should still exist in memcached.");

    /* after another 3 seconds make another request without changing the session
     */
    Thread.sleep(TimeUnit.SECONDS.toMillis(delay * 3));
    assertEquals(
        makeRequest(_httpClient, _portTomcat1, sessionId1),
        sessionId1,
        "SessionId should be the same");
    assertNotNull(_memcached.get(sessionId1), "Session should still exist in memcached.");

    /* after another nearly 4 seconds (maxInactiveInterval) check that the session is still alive in memcached,
     * this would have been expired without an updated expiration
     */
    Thread.sleep(TimeUnit.SECONDS.toMillis(manager.getMaxInactiveInterval()) - 500);
    assertNotNull(_memcached.get(sessionId1), "Session should still exist in memcached.");

    /* after another second in sticky mode (more than 4 seconds since the last request), or an two times the
     * maxInactiveInterval in non-sticky mode (we must keep sessions in memcached with double expirationtime)
     * the session must be expired in memcached
     */
    Thread.sleep(TimeUnit.SECONDS.toMillis(delay) + 500);
    assertNotSame(
        makeRequest(_httpClient, _portTomcat1, sessionId1),
        sessionId1,
        "The sessionId should have changed due to expired sessin");
  }
  /**
   * Test for issue #60 (Add possibility to disable msm at runtime): start msm disabled and
   * afterwards enable
   */
  @Test(enabled = true)
  public void testStartMsmDisabled() throws Exception {

    // shutdown our server and our client
    _memcached.shutdown();
    _daemon.stop();

    // start a new tomcat with msm initially disabled
    _tomcat1.stop();
    Thread.sleep(500);
    final String memcachedNodes = _memcachedNodeId + ":localhost:" + _memcachedPort;
    _tomcat1 =
        getTestUtils()
            .tomcatBuilder()
            .port(_portTomcat1)
            .memcachedNodes(memcachedNodes)
            .sticky(true)
            .enabled(false)
            .jvmRoute("app1")
            .buildAndStart();

    LOG.info("Waiting, check logs to see if the client causes any 'Connection refused' logging...");
    Thread.sleep(1000);

    // some basic tests for session functionality
    checkSessionFunctionalityWithMsmDisabled();

    // start memcached, client and reenable msm
    _daemon.start();
    _memcached =
        createMemcachedClient(memcachedNodes, new InetSocketAddress("localhost", _memcachedPort));
    _tomcat1.getManager().setEnabled(true);
    // Wait a little bit, so that msm's memcached client can connect and is ready when test starts
    Thread.sleep(100);

    // memcached based stuff should work again
    final String sessionId1 = makeRequest(_httpClient, _portTomcat1, null);
    assertNotNull(sessionId1, "No session created.");
    assertNotNull(
        new SessionIdFormat().extractMemcachedId(sessionId1),
        "memcached node id missing with msm switched to enabled");
    Thread.sleep(50);
    assertNotNull(_memcached.get(sessionId1), "Session not available in memcached.");

    waitForSessionExpiration(true);

    assertNull(_memcached.get(sessionId1), "Expired session still existing in memcached");
  }
  /**
   * Test for issue #49: Sessions not associated with a memcached node don't get associated as soon
   * as a memcached is available
   *
   * @throws InterruptedException
   * @throws IOException
   * @throws TimeoutException
   * @throws ExecutionException
   */
  @Test(enabled = true)
  public void testNotAssociatedSessionGetsAssociatedIssue49()
      throws InterruptedException, IOException, ExecutionException, TimeoutException {
    _daemon.stop();

    final SessionManager manager = _tomcat1.getManager();
    manager.setMaxInactiveInterval(5);
    manager.setSticky(true);
    final SessionIdFormat sessionIdFormat = new SessionIdFormat();

    final Session session = manager.createSession(null);
    assertNull(sessionIdFormat.extractMemcachedId(session.getId()));

    _daemon.start();

    // Wait so that the daemon will be available and the client can reconnect (async get didn't do
    // the trick)
    Thread.sleep(4000);

    final String newSessionId =
        manager.getMemcachedSessionService().changeSessionIdOnMemcachedFailover(session.getId());
    assertNotNull(newSessionId);
    assertEquals(newSessionId, session.getId());
    assertEquals(sessionIdFormat.extractMemcachedId(newSessionId), _memcachedNodeId);
  }
Example #6
0
  @Test
  public void testAsyncLateListener() throws Exception {
    ListenableFuture<String> getFuture;
    final CountDownLatch latch = new CountDownLatch(1);

    try (DelayedMap.AsyncClient client =
        createClient(DelayedMap.AsyncClient.class, syncServer).get()) {
      getFuture = client.getValueSlowly(250, TimeUnit.MILLISECONDS, "testKey");

      // Sleep first, to test the case where the callback is executed immediately
      Thread.sleep(500);

      Futures.addCallback(
          getFuture,
          new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
              latch.countDown();
            }

            @Override
            public void onFailure(Throwable t) {
              fail("Async call to getValueSlowly failed", t);
            }
          });

      // Because of the sleep above, the latch should already be open
      // (because the callback is added on this thread and the default callback
      // executor runs callbacks on the same thread, this shouldn't even be a race).
      assertTrue(latch.await(0, TimeUnit.MILLISECONDS));
    }
  }
  @Test(groups = "standalone")
  public void testObserveMultiple() {
    final TestSubscriber<Response> tester = new TestSubscriber<>();

    try (AsyncHttpClient client = asyncHttpClient()) {
      Observable<Response> o1 =
          AsyncHttpObservable.observe(() -> client.prepareGet("http://gatling.io"));
      Observable<Response> o2 =
          AsyncHttpObservable.observe(
              () -> client.prepareGet("http://www.wisc.edu").setFollowRedirect(true));
      Observable<Response> o3 =
          AsyncHttpObservable.observe(
              () -> client.prepareGet("http://www.umn.edu").setFollowRedirect(true));
      Observable<Response> all = Observable.merge(o1, o2, o3);
      all.subscribe(tester);
      tester.awaitTerminalEvent();
      tester.assertTerminalEvent();
      tester.assertCompleted();
      tester.assertNoErrors();
      List<Response> responses = tester.getOnNextEvents();
      assertNotNull(responses);
      assertEquals(responses.size(), 3);
      for (Response response : responses) {
        assertEquals(response.getStatusCode(), 200);
      }
    } catch (Exception e) {
      Thread.currentThread().interrupt();
    }
  }
  @Test
  public void testGetDurationWithUnit() throws Exception {
    testStopwatch.start();
    Thread.sleep(10);
    testStopwatch.stop();

    assertTrue(testStopwatch.getDuration() > 12);
  }
  /**
   * Click and browse genre link
   *
   * @throws InterruptedException
   */
  public void browseGenre() throws InterruptedException {
    epor.browseGenre.click();

    List<WebElement> genres = driver.findElements(By.className("ODSearch_genreBox"));
    System.out.print("Genres: ");
    for (WebElement genre : genres) {
      System.out.print(genre.getText() + "; ");
      genre.click();
      pf.captureScreenShot(driver, genre.getText());
      Thread.sleep(1500);
    }
    System.out.print("\n");

    assertEquals(7, genres.size());
    epor.browseGenreComedy.click();
    Thread.sleep(1500);
  }
  /**
   * Click and browse genre link
   *
   * @throws InterruptedException
   */
  public void browseChannel() throws InterruptedException {
    epor.browseChannel.click();

    List<WebElement> channels = driver.findElements(By.className("ODSearch_Channel"));
    System.out.print("Channel: ");
    for (WebElement channel : channels) {
      System.out.print(channel.getText() + "; ");
      channel.click();
      pf.captureScreenShot(driver, channel.getText());
      Thread.sleep(1500);
    }
    System.out.print("\n");

    assertEquals(2, channels.size());
    epor.browseChannelThree.click();
    Thread.sleep(1500);
  }
  /**
   * Test prepared query.
   *
   * @param qCom the q com
   * @throws Exception the exception
   */
  @Test(dataProvider = "queryCommands")
  public void preparedQuery(LensQueryCommands qCom) throws Exception {
    long submitTime = System.currentTimeMillis();
    String sql = "cube select id, name from test_dim";
    String result =
        qCom.getAllPreparedQueries("testPreparedName", "all", submitTime, Long.MAX_VALUE);

    assertEquals(result, "No prepared queries");
    final String qh = qCom.prepare(sql, "testPreparedName");
    result =
        qCom.getAllPreparedQueries(
            "testPreparedName", "all", submitTime, System.currentTimeMillis());
    assertEquals(qh, result);

    result = qCom.getPreparedStatus(qh);
    assertTrue(result.contains("User query:cube select id, name from test_dim"));
    assertTrue(result.contains(qh));

    result = qCom.executePreparedQuery(qh, false, "testPrepQuery1");

    log.warn("XXXXXX Prepared query sync result is  " + result);
    assertTrue(result.contains("1\tfirst"));

    String handle = qCom.executePreparedQuery(qh, true, "testPrepQuery2");
    log.debug("Perpared query handle is   " + handle);
    while (!qCom.getClient().getQueryStatus(handle).finished()) {
      Thread.sleep(5000);
    }
    String status = qCom.getStatus(handle);
    log.debug("Prepared Query Status is  " + status);
    assertTrue(status.contains("Status : SUCCESSFUL"));

    result = qCom.getQueryResults(handle, null, true);
    log.debug("Prepared Query Result is  " + result);
    assertTrue(result.contains("1\tfirst"));
    // Fetch again.
    result = qCom.getQueryResults(handle, null, true);
    log.debug("Prepared Query Result is  " + result);
    assertTrue(result.contains("1\tfirst"));

    result = qCom.destroyPreparedQuery(qh);

    log.debug("destroy result is " + result);
    assertEquals("Successfully destroyed " + qh, result);
    result = qCom.getAllPreparedQueries("testPreparedName", "all", submitTime, Long.MAX_VALUE);

    assertEquals(result, "No prepared queries");

    final String qh2 = qCom.explainAndPrepare(sql, "testPrepQuery3");
    assertTrue(qh2.contains(explainPlan));
    String handles = qCom.getAllPreparedQueries("testPrepQuery3", "all", -1, Long.MAX_VALUE);
    assertFalse(handles.contains("No prepared queries"), handles);

    String handles2 = qCom.getAllPreparedQueries("testPrepQuery3", "all", -1, submitTime - 1);
    assertFalse(handles2.contains(qh), handles2);
    result = qCom.destroyPreparedQuery(handles);
    assertEquals("Successfully destroyed " + handles, result);
  }
  @Test
  public void testReset() throws Exception {
    testStopwatch.start();
    Thread.sleep(10);
    testStopwatch.stop();
    assertTrue(testStopwatch.getDuration() > 0);

    testStopwatch.reset();
    assertTrue(testStopwatch.getDuration() == 0);
  }
 @Test(dependsOnMethods = "checkChangeCategoryName", groups = "Enterprise-only", timeOut = 400000)
 public void checkDeleteCategory() throws Exception {
   CategoryManagerPage categoryManagerPage = drone.getCurrentPage().render();
   int categoryCount = categoryManagerPage.getCategoriesCount();
   categoryManagerPage.deleteCategory(renameCategoryName);
   Thread.sleep(solrWaitTime); // wait solr
   drone.refresh();
   assertFalse(categoryManagerPage.isCategoryPresent(renameCategoryName));
   assertTrue(categoryCount - 2 == categoryManagerPage.getCategoriesCount());
 }
 @Test(dependsOnMethods = "checkOpenSubCategory", groups = "Enterprise-only", timeOut = 400000)
 public void checkChangeCategoryName() throws Exception {
   CategoryManagerPage categoryManagerPage = drone.getCurrentPage().render();
   categoryManagerPage.editCategory(categoryName, renameCategoryName);
   Thread.sleep(solrWaitTime); // wait solr
   drone.refresh();
   assertTrue(categoryManagerPage.isCategoryPresent(renameCategoryName));
   categoryManagerPage.openSubCategoryList(renameCategoryName);
   assertTrue(categoryManagerPage.isCategoryPresent(subCategoryName));
 }
 private void assertEventuallyEquals(List<?> actual, List<?> expected, long timeout)
     throws InterruptedException {
   long startTime = System.currentTimeMillis();
   while (System.currentTimeMillis() < startTime + timeout) {
     if (expected.equals(actual)) {
       return; // success
     }
     Thread.sleep(timeout / 100L);
   }
   assertEquals(actual, expected, "After waiting " + timeout + "ms");
 }
  @Test(enabled = true, dataProviderClass = TestUtils.class, dataProvider = STICKYNESS_PROVIDER)
  public void testSessionAvailableInMemcached(final SessionAffinityMode sessionAffinity)
      throws IOException, InterruptedException, HttpException {

    setStickyness(sessionAffinity);

    final String sessionId1 = makeRequest(_httpClient, _portTomcat1, null);
    assertNotNull(sessionId1, "No session created.");
    Thread.sleep(50);
    assertNotNull(_memcached.get(sessionId1), "Session not available in memcached.");
  }
  @Test
  public void testTrim() throws Exception {
    ReplicationServer replicationServer = null;
    JEReplicaDB replicaDB = null;
    try {
      TestCaseUtils.startServer();
      replicationServer = configureReplicationServer(100, 5000);
      replicaDB = newReplicaDB(replicationServer);

      CSN[] csns = generateCSNs(1, 0, 5);

      replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[0], "uid"));
      replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[1], "uid"));
      replicaDB.add(new DeleteMsg(TEST_ROOT_DN, csns[2], "uid"));
      DeleteMsg update4 = new DeleteMsg(TEST_ROOT_DN, csns[3], "uid");

      // --
      // Iterator tests with changes persisted
      assertFoundInOrder(replicaDB, csns[0], csns[1], csns[2]);
      assertNotFound(replicaDB, csns[4], AFTER_MATCHING_KEY);

      assertEquals(replicaDB.getOldestCSN(), csns[0]);
      assertEquals(replicaDB.getNewestCSN(), csns[2]);

      // --
      // Cursor tests with changes persisted
      replicaDB.add(update4);

      assertFoundInOrder(replicaDB, csns[0], csns[1], csns[2], csns[3]);
      // Test cursor from existing CSN
      assertFoundInOrder(replicaDB, csns[2], csns[3]);
      assertFoundInOrder(replicaDB, csns[3]);
      assertNotFound(replicaDB, csns[4], AFTER_MATCHING_KEY);

      replicaDB.purgeUpTo(new CSN(Long.MAX_VALUE, 0, 0));

      int count = 0;
      boolean purgeSucceeded = false;
      final CSN expectedNewestCSN = csns[3];
      do {
        Thread.sleep(10);

        final CSN oldestCSN = replicaDB.getOldestCSN();
        final CSN newestCSN = replicaDB.getNewestCSN();
        purgeSucceeded = oldestCSN.equals(expectedNewestCSN) && newestCSN.equals(expectedNewestCSN);
        count++;
      } while (!purgeSucceeded && count < 100);
      assertTrue(purgeSucceeded);
    } finally {
      shutdown(replicaDB);
      remove(replicationServer);
    }
  }
 private void waitForSessionExpiration(final boolean sticky) throws InterruptedException {
   final SessionManager manager = _tomcat1.getManager();
   assertEquals(manager.getMemcachedSessionService().isSticky(), sticky);
   final Container container = manager.getContainer();
   final long timeout =
       TimeUnit.SECONDS.toMillis(
               sticky
                   ? container.getBackgroundProcessorDelay() + manager.getMaxInactiveInterval()
                   : 2 * manager.getMaxInactiveInterval())
           + 1000;
   Thread.sleep(timeout);
 }
  private void clearUploadedResource()
      throws InterruptedException, ResourceAdminServiceExceptionException, RemoteException,
          XPathExpressionException {

    ResourceAdminServiceClient resourceAdminServiceStub =
        new ResourceAdminServiceClient(
            context.getContextUrls().getBackEndUrl(), getSessionCookie());

    resourceAdminServiceStub.deleteResource("/_system/config/sequence");

    Thread.sleep(1000);
  }
  /**
   * Tests, that for a session that was not sent to memcached (because it's attributes were not
   * modified), the expiration is updated so that they don't expire in memcached before they expire
   * in tomcat.
   *
   * @throws Exception if something goes wrong with the http communication with tomcat
   */
  @Test(enabled = true, dataProviderClass = TestUtils.class, dataProvider = STICKYNESS_PROVIDER)
  public void testExpirationOfSessionsInMemcachedIfBackupWasSkippedSimple(
      final SessionAffinityMode stickyness) throws Exception {

    final SessionManager manager = _tomcat1.getManager();
    setStickyness(stickyness);

    // set to 1 sec above (in setup), default is 10 seconds
    final int delay = manager.getContainer().getBackgroundProcessorDelay();
    manager.setMaxInactiveInterval(delay * 4);

    final String sessionId1 = makeRequest(_httpClient, _portTomcat1, null);
    assertNotNull(sessionId1, "No session created.");
    assertNotNull(_memcached.get(sessionId1), "Session not available in memcached.");

    /* after 2 seconds make another request without changing the session, so that
     * it's not sent to memcached
     */
    Thread.sleep(TimeUnit.SECONDS.toMillis(delay * 2));
    assertEquals(
        makeRequest(_httpClient, _portTomcat1, sessionId1),
        sessionId1,
        "SessionId should be the same");

    /* after another 3 seconds check that the session is still alive in memcached,
     * this would have been expired without an updated expiration
     */
    Thread.sleep(TimeUnit.SECONDS.toMillis(delay * 3));
    assertNotNull(_memcached.get(sessionId1), "Session should still exist in memcached.");

    /* after another >1 second (4 seconds since the last request)
     * the session must be expired in memcached
     */
    Thread.sleep(
        TimeUnit.SECONDS.toMillis(delay) + 500); // +1000 just to be sure that we're >4 secs
    assertNotSame(
        makeRequest(_httpClient, _portTomcat1, sessionId1),
        sessionId1,
        "The sessionId should have changed due to expired sessin");
  }
  /**
   * Verify Kid's contents
   *
   * @throws InterruptedException
   */
  public void browseGenreKid() throws InterruptedException {
    epor.browseGenreKids.click();
    List<WebElement> genreKid = driver.findElements(By.className("Kids"));

    System.out.print("Kid: ");
    for (WebElement kid : genreKid) {
      System.out.print(kid.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(10, genreKid.size());
    Thread.sleep(1500);
  }
  /**
   * Verify Genre's contents
   *
   * @throws InterruptedException
   */
  public void browseGenreSport() throws InterruptedException {
    epor.browseGenreSport.click();
    List<WebElement> genreSport = driver.findElements(By.className("Sport"));

    System.out.print("Sport: ");
    for (WebElement sport : genreSport) {
      System.out.print(sport.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(4, genreSport.size());
    Thread.sleep(1500);
  }
  /**
   * Verify Reality's contents
   *
   * @throws InterruptedException
   */
  public void browseGenreReality() throws InterruptedException {
    epor.browseGenreReality.click();
    List<WebElement> genreReality = driver.findElements(By.className("Reality"));

    System.out.print("Reality: ");
    for (WebElement reality : genreReality) {
      System.out.print(reality.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(19, genreReality.size());
    Thread.sleep(1500);
  }
  /**
   * Verify News' contents
   *
   * @throws InterruptedException
   */
  public void browseGenreNews() throws InterruptedException {
    epor.browseGenreNews.click();
    List<WebElement> genreNews = driver.findElements(By.className("NewsCurrentAffairs"));

    System.out.print("News: ");
    for (WebElement news : genreNews) {
      System.out.print(news.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(3, genreNews.size());
    Thread.sleep(1500);
  }
  /**
   * Verify W's contents
   *
   * @throws InterruptedException
   */
  public void browseTitleW() throws InterruptedException {
    epor.browseTitleW.click();
    List<WebElement> titleWContents = driver.findElements(By.className("StartW"));

    System.out.print("W's contents: ");
    for (WebElement wContent : titleWContents) {
      System.out.print(wContent.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(1, titleWContents.size());
    Thread.sleep(1000);
  }
  /**
   * Verify Three's contents
   *
   * @throws InterruptedException
   */
  public void browseChannelThree() throws InterruptedException {
    epor.browseChannelThree2.click();
    List<WebElement> channelThree = driver.findElements(By.className("tv3"));

    System.out.print("TV Three: ");
    for (WebElement three : channelThree) {
      System.out.print(three.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(42, channelThree.size());
    Thread.sleep(1500);
  }
  /**
   * Verify Four's contents
   *
   * @throws InterruptedException
   */
  public void browseChannelFour() throws InterruptedException {
    epor.browseChannelFour.click();
    List<WebElement> channelFour = driver.findElements(By.className("four"));

    System.out.print("Four: ");
    for (WebElement four : channelFour) {
      System.out.print(four.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(19, channelFour.size());
    Thread.sleep(1500);
  }
 public void handle(
     String s, Request r, HttpServletRequest request, HttpServletResponse response)
     throws IOException, ServletException {
   try {
     Thread.sleep(210L);
   } catch (InterruptedException e) {
   }
   response.setContentType("text/plain");
   response.setStatus(400);
   OutputStream out = response.getOutputStream();
   out.write(BAD_REQUEST_STR.getBytes(UTF_8));
   out.flush();
 }
  /**
   * Verify Drama's contents
   *
   * @throws InterruptedException
   */
  public void browseGenreDrama() throws InterruptedException {
    epor.browseGenreDrama.click();
    List<WebElement> genreDrama = driver.findElements(By.className("Drama"));

    System.out.print("Drama: ");
    for (WebElement drama : genreDrama) {
      System.out.print(drama.getText() + "; ");
    }
    System.out.print("\n");

    assertEquals(6, genreDrama.size());
    Thread.sleep(1500);
  }
  private void setStickyness(final SessionAffinityMode sessionAffinity) {
    if (!sessionAffinity.isSticky()) {
      _tomcat1.getEngine().setJvmRoute(null);
    }
    final SessionManager manager = _tomcat1.getManager();
    manager.setSticky(sessionAffinity.isSticky());

    try {
      waitForReconnect(manager.getMemcachedSessionService().getMemcached(), 1, 500);
    } catch (final InterruptedException e) {
      Thread.currentThread().interrupt();
      throw new RuntimeException(e);
    }
  }