Beispiel #1
0
  public void testLimeDHTManager() throws Exception {
    DHTSettings.PERSIST_ACTIVE_DHT_ROUTETABLE.setValue(true);
    DHTSettings.PERSIST_DHT_DATABASE.setValue(true);

    TestExecutor executor = new TestExecutor();
    DHTManagerImpl manager = new DHTManagerImpl(executor, dhtControllerFactory);

    try {
      assertFalse(manager.isRunning());
      assertFalse(manager.isBootstrapped());
      assertFalse(manager.isWaitingForNodes());
      assertEquals(0, manager.getActiveDHTNodes(10).size());

      manager.start(DHTMode.ACTIVE);
      assertEquals(1, executor.getRunners().size());
      Thread.sleep(200);
      assertTrue(manager.isRunning());
      assertEquals(DHTMode.ACTIVE, manager.getDHTMode());
      KUID activeLocalNodeID = manager.getMojitoDHT().getLocalNodeID();

      // Rry starting again
      manager.start(DHTMode.ACTIVE);
      Thread.sleep(200);
      assertEquals(activeLocalNodeID, manager.getMojitoDHT().getLocalNodeID());

      // Try switching mode
      manager.start(DHTMode.PASSIVE);
      Thread.sleep(200);
      assertEquals(DHTMode.PASSIVE, manager.getDHTMode());
      assertTrue(manager.isRunning());
      KUID passiveLocalNodeID = manager.getMojitoDHT().getLocalNodeID();
      assertNotEquals(activeLocalNodeID, passiveLocalNodeID);
      manager.start(DHTMode.PASSIVE);
      Thread.sleep(200);
      assertEquals(passiveLocalNodeID, manager.getMojitoDHT().getLocalNodeID());
      manager.addressChanged();
      Thread.sleep(200);
      assertEquals(passiveLocalNodeID, manager.getMojitoDHT().getLocalNodeID());

      // Try switching multiple times (does some Disk I/O)
      manager.start(DHTMode.ACTIVE);
      manager.start(DHTMode.PASSIVE);
      manager.start(DHTMode.ACTIVE);

      // Give it enough time --> previous starts were offloaded to threadpool
      Thread.sleep(10000);

      // We should be in active mode
      assertEquals(DHTMode.ACTIVE, manager.getDHTMode());

      // The Node ID should be something else than passiveLocalNodeID
      assertNotEquals(passiveLocalNodeID, manager.getMojitoDHT().getLocalNodeID());

      // The Node ID should be (but it's not guaranteed) equals to activeLocalNodeID
      assertEquals(activeLocalNodeID, manager.getMojitoDHT().getLocalNodeID());
    } finally {
      manager.stop();
    }
  }
Beispiel #2
0
 public void test(TestExecutor testExecutor, Context context) {
   for (Test test : childTest) {
     testExecutor.executeOnSuite(getName(), test, context.duplicar());
   }
   if (!childTestAreSuccesses(testExecutor.getResults().get(this.getName()))) {
     throw new AssertionError();
   }
 }
 @Test
 public void testReadAggregate_WrongIdentifier() {
   fixture.registerAggregateFactory(mockAggregateFactory);
   fixture.registerAnnotatedCommandHandler(
       new MyCommandHandler(fixture.getRepository(), fixture.getEventBus()));
   TestExecutor exec = fixture.given(new MyEvent("AggregateId", 1));
   try {
     exec.when(new TestCommand("OtherIdentifier"));
     fail("Expected an AssertionError");
   } catch (AssertionError e) {
     assertTrue(
         "Wrong message. Was: " + e.getMessage(), e.getMessage().contains("OtherIdentifier"));
     assertTrue("Wrong message. Was: " + e.getMessage(), e.getMessage().contains("AggregateId"));
   }
 }
 @Test
 public void testFixtureDetectsStateChangeOutsideOfHandler_AggregateDeleted() {
   TestExecutor exec =
       fixture
           .registerAnnotatedCommandHandler(
               new MyCommandHandler(fixture.getRepository(), fixture.getEventBus()))
           .given(new MyEvent("aggregateId", 5));
   try {
     exec.when(new DeleteCommand("aggregateId", true));
     fail("Fixture should have failed");
   } catch (AssertionError error) {
     assertTrue(
         "Wrong message: " + error.getMessage(),
         error.getMessage().contains("considered deleted"));
   }
 }
 @SmallTest
 @Feature({"Cronet"})
 public void testRealTimeNetworkQualityObservations() throws Exception {
   mActivity = launchCronetTestApp();
   TestExecutor testExecutor = new TestExecutor();
   TestNetworkQualityListener networkQualityListener = new TestNetworkQualityListener();
   mActivity.mCronetEngine.enableNetworkQualityEstimatorForTesting(true, true, testExecutor);
   mActivity.mCronetEngine.addRttListener(networkQualityListener);
   mActivity.mCronetEngine.addThroughputListener(networkQualityListener);
   TestUrlRequestListener listener = new TestUrlRequestListener();
   UrlRequest urlRequest =
       mActivity.mCronetEngine.createRequest(TEST_URL, listener, listener.getExecutor());
   urlRequest.start();
   listener.blockForDone();
   testExecutor.runAllTasks();
   assertTrue(networkQualityListener.rttObservationCount() > 0);
   assertTrue(networkQualityListener.throughputObservationCount() > 0);
   mActivity.mCronetEngine.shutdown();
 }
  /** @return reschedule time duration in milliseconds */
  public long executeReturnRescheduleDurationMilliseconds() {

    // TODO - is the following assertion something that should be re-activated?
    // SKLogger.sAssert(getClass(), (accumulatedTestBytes == 0L));

    TestExecutor scheduledTestExecutor = new TestExecutor(tc);
    long time = System.currentTimeMillis();

    // The events in the queue are run through, until all are processed.
    // So, we must start by clearing-out all tests that pre-date the current time.
    while (true) {
      QueueEntry entry = entries.peek();
      if (entry != null && !canExecute(entry, time) && entry.getSystemTimeMilliseconds() < time) {
        entries.remove();
        SKLogger.d(this, "removing test scheduled at: " + entry.getSystemTimeAsDebugString());
      } else {
        break;
      }
    }

    boolean result = true;
    boolean fail = false;
    if (canExecute(time)) {
      scheduledTestExecutor.start();

      while (canExecute(time)) {
        QueueEntry entry = entries.remove();
        long maximumTestUsage = tc.config == null ? 0 : tc.config.maximumTestUsage;
        // if data cap is going to be breached do not run test
        // the datacap condition is successful if the datacap is not reached

        boolean dataCapLikelyToBeReachedFlag =
            SK2AppSettings.getSK2AppSettingsInstance().isDataCapLikelyToBeReached(maximumTestUsage);
        // If we're not going to reach the limit, then success is true.
        // If we're going to reach the limit, then success is false.
        boolean dataCapSuccessFlag = !dataCapLikelyToBeReachedFlag;
        DatacapCondition dc = new DatacapCondition(dataCapSuccessFlag);

        if (dc.isSuccess()) {
          ConditionGroupResult tr = scheduledTestExecutor.executeBackgroundTestGroup(entry.groupId);
          accumulatedTestBytes += scheduledTestExecutor.getAccumulatedTestBytes();
          result = tr.isSuccess;
        } else {
          SKLogger.d(this, "Active metrics won't be collected due to potential datacap breach");
          scheduledTestExecutor
              .getResultsContainer()
              .addFailedCondition(DatacapCondition.JSON_DATACAP);
        }
        scheduledTestExecutor.getResultsContainer().addCondition(dc.getCondition());
      }

      scheduledTestExecutor.stop();
      scheduledTestExecutor.save("scheduled_tests", -1);
    }

    extendSize();

    if (fail) {
      RetryFailAction failAction = tc.config.retryFailAction;
      if (failAction != null) {
        return tc.config.retryFailAction.delay; // reschedule
      } else {
        SKLogger.e(this, "can't find on test fail action, just skipping the test.");
        entries.remove();
      }
    }

    return getSleepTimeDurationMilliseconds();
  }