@Test(invocationCount = 5, successPercentage = 19) public void topicConduit() throws Exception { String topicName = "JmsByteArrayTransportTest-topicConduit-" + System.getProperty("user.name") + "-" + System.currentTimeMillis(); ConnectionFactory cf = ActiveMQTestUtils.createTestConnectionFactory(); JmsTemplate jmsTemplate = new JmsTemplate(); jmsTemplate.setConnectionFactory(cf); jmsTemplate.setPubSubDomain(true); JmsByteArrayMessageSender messageSender = new JmsByteArrayMessageSender(topicName, jmsTemplate); CollectingByteArrayMessageReceiver collectingReceiver = new CollectingByteArrayMessageReceiver(); JmsByteArrayMessageDispatcher messageDispatcher = new JmsByteArrayMessageDispatcher(collectingReceiver); DefaultMessageListenerContainer container = new DefaultMessageListenerContainer(); container.setConnectionFactory(cf); container.setMessageListener(messageDispatcher); container.setDestinationName(topicName); container.setPubSubDomain(true); container.afterPropertiesSet(); container.start(); Random random = new Random(); byte[] randomBytes = new byte[1024]; random.nextBytes(randomBytes); while (!container.isRunning()) { Thread.sleep(10l); } // TODO: this is a hack. The context doesn't seem to have always set up the consumer completely // yet Thread.sleep(500l); messageSender.send(randomBytes); long startTime = System.currentTimeMillis(); while (collectingReceiver.getMessages().isEmpty()) { Thread.sleep(10l); if ((System.currentTimeMillis() - startTime) > TIMEOUT) { fail("Did not receive a message in " + (TIMEOUT / 1000) + " seconds."); } } s_logger.debug( "topicConduit message received {}ms before timeout limit", TIMEOUT - (System.currentTimeMillis() - startTime)); assertEquals(1, collectingReceiver.getMessages().size()); byte[] receivedBytes = collectingReceiver.getMessages().get(0); assertEquals(randomBytes.length, receivedBytes.length); for (int i = 0; i < randomBytes.length; i++) { assertEquals(randomBytes[i], receivedBytes[i]); } container.stop(); container.destroy(); }
@Test public void testDBName() throws Exception { Mongo m = new Mongo(); try { new DBImpl(null, null, null); fail(); } catch (Exception e) { // ok } try { new DBImpl(m, null, ""); fail(); } catch (Exception e) { // ok } try { new DBImpl(m, null, "a.b"); fail(); } catch (Exception e) { // ok } DBImpl db = new DBImpl(m, m.getConnection(), "test_me"); assert (db.getName().equals("test_me")); db.close(); }
public void testDeleteWithExpectedResultSizeOnCobarSqlMapClientTemplate() { Follower f = new Follower("fname"); getSqlMapClientTemplate().insert("com.alibaba.cobar.client.entities.Follower.create", f); String confirmSQL = "select name from followers where name='fname'"; verifyEntityNonExistenceOnSpecificDataSource(confirmSQL, jt1m); verifyEntityNonExistenceOnSpecificDataSource(confirmSQL, jt1s); verifyEntityExistenceOnSpecificDataSource(confirmSQL, jt2m); verifyEntityNonExistenceOnSpecificDataSource(confirmSQL, jt2s); try { getSqlMapClientTemplate() .delete("com.alibaba.cobar.client.entities.Follower.deleteByName", f, 2); fail("only one row will be affected in fact."); } catch (DataAccessException e) { assertTrue(e instanceof JdbcUpdateAffectedIncorrectNumberOfRowsException); JdbcUpdateAffectedIncorrectNumberOfRowsException ex = (JdbcUpdateAffectedIncorrectNumberOfRowsException) e; assertEquals(1, ex.getActualRowsAffected()); } // although JdbcUpdateAffectedIncorrectNumberOfRowsException is raised, but the delete does // performed successfully. verifyEntityNonExistenceOnSpecificDataSource(confirmSQL, jt1m); verifyEntityNonExistenceOnSpecificDataSource(confirmSQL, jt1s); verifyEntityNonExistenceOnSpecificDataSource(confirmSQL, jt2m); verifyEntityNonExistenceOnSpecificDataSource(confirmSQL, jt2s); try { getSqlMapClientTemplate() .delete("com.alibaba.cobar.client.entities.Follower.deleteByName", f, 0); } catch (DataAccessException e) { fail(); } }
private void testOn(Directory dir, int writeSize, int readSize, Cache cache) throws IOException { if (cache != null) cache .clear(); // needed to make sure no chunks are left over in case of Infinispan // implementation final String filename = "chunkTest"; IndexOutput indexOutput = dir.createOutput(filename); byte[] toWrite = fillBytes(writeSize); indexOutput.writeBytes(toWrite, writeSize); indexOutput.close(); if (cache != null) { AssertJUnit.assertEquals( writeSize, DirectoryIntegrityCheck.deepCountFileSize(new FileCacheKey(INDEXNAME, filename), cache)); } AssertJUnit.assertEquals(writeSize, indexOutput.length()); byte[] results = new byte[readSize]; IndexInput openInput = dir.openInput(filename); try { openInput.readBytes(results, 0, readSize); for (int i = 0; i < writeSize && i < readSize; i++) { AssertJUnit.assertEquals(results[i], toWrite[i]); } if (readSize > writeSize) AssertJUnit.fail("should have thrown an IOException for reading past EOF"); } catch (IOException ioe) { if (readSize <= writeSize) AssertJUnit.fail("should not have thrown an IOException" + ioe.getMessage()); } }
public void verifyCommentRowContent( String commentRowIdSuffix, String commentText, String giverName) { WebDriverWait wait = new WebDriverWait(browser.driver, 30); WebElement commentRow; try { commentRow = wait.until( ExpectedConditions.presenceOfElementLocated( By.id("responseCommentRow" + commentRowIdSuffix))); } catch (TimeoutException e) { fail("Timeout!"); commentRow = null; } try { wait.until( ExpectedConditions.textToBePresentInElement( commentRow.findElement(By.id("plainCommentText" + commentRowIdSuffix)), commentText)); } catch (TimeoutException e) { fail("Not expected message"); } try { assertTrue(commentRow.findElement(By.className("text-muted")).getText().contains(giverName)); } catch (AssertionError e) { assertTrue(commentRow.findElement(By.className("text-muted")).getText().contains("you")); } }
/** * Asserts that within a set of records, there is no record such that record[fieldName] == val. * Note that if multiple such asserts are to be made, it may be necessary to synchronize on the * list to ensure it is consistent throughout multiple asserts. */ protected void assertNoSuchRecord( List<GenericData.Record> records, String fieldName, Object val) { for (GenericData.Record record : records) { if (null == val) { if (record.get(fieldName) == null) { fail("Assertion failed: Found record with null in field " + fieldName); } } else if (val.equals(record.get(fieldName))) { fail("Assertion failed: Found record with field " + fieldName + " equals " + val); } } }
private void checkField(GenericData.Record record, String testField, Object testValue) { if (null == testValue) { if (record.get(testField) != null) { fail("Assertion failed: candidate record had non-null value for " + testField); } } else if (!testValue.equals(record.get(testField))) { fail( "Assertion failed: test field had value " + record.get(testField) + ", but expected " + testValue); } }
@TestFor(issues = "TW-18853") public void should_throw_special_exception_when_stderr_mentions_broken_index() throws VcsException { AskPassGenerator fakeGen = new AskPassGenerator() { @NotNull public File generate(@NotNull AuthSettings authSettings) throws IOException { return new File("."); } }; File tmpDir = new File(FileUtil.getTempDirectory()); GitCommandLine failedCmd = new GitCommandLine(null, fakeGen, tmpDir, false, GitProgressLogger.NO_OP) { @Override public ExecResult run(@NotNull GitCommandSettings settings) throws VcsException { throw new VcsException("fatal: index file smaller than expected"); } }; FetchCommand fetch = new FetchCommandImpl(failedCmd) .setRefspec("+refs/heads/*:refs/remotes/origin/*") .setTimeout(3600) .setAuthSettings(new AuthSettings(new HashMap<String, String>())); try { fetch.call(); } catch (GitIndexCorruptedException e) { // expected } catch (VcsException e) { fail("GitIndexCorruptedException should be thrown"); } }
/** Asserts that there exists a record in records such that testField = testValue. */ protected void assertRecordExists( List<GenericData.Record> records, String testField, Object testValue) { for (GenericData.Record record : records) { Object result = record.get(testField); if (result != null && testValue != null) { LOG.debug( "Checking result: " + result + " (class=" + result.getClass().getName() + ")" + " against testValue: " + testValue + " (class=" + testValue.getClass().getName() + ") for field " + testField); } if (null == testValue && null == result) { return; } else if (null != testValue && testValue.equals(result)) { return; } } fail("Could not find record such that " + testField + " equals " + testValue); }
public void testClear() throws Exception { _tool.createTestSchema(); createTestTable(); _tool.executeSql( _tool.getTestCatalog(), _tool.getTestSchema(), "INSERT INTO " + TEST_TABLE + " (test_column) VALUES ('test')"); _tool.clearTestTables(); Connection connection = getConnection(); Statement statement = connection.createStatement(); ResultSet rs = statement.executeQuery("SELECT COUNT(*) FROM " + TEST_TABLE); if (rs.next()) { int count = rs.getInt(1); assertEquals(0, count); } else { fail(); } rs.close(); statement.close(); connection.close(); _tool.dropTestSchema(); }
@Test public void testStrictCollectionCreation() throws Exception { Mongo m = new Mongo(); DB db = new DBImpl(m, m.getConnection(), "org_mongo_driver_DBTest"); db.setDBOptions(new DBOptions().setStrictCollectionMode(true)); for (String n : db.getCollectionNames()) { db.dropCollection(n); } assert (db.getCollectionNames().size() == 0); try { db.getCollection("woogie"); fail(); } catch (Exception e) { // expect an exception as we're in strict mode } assert (db.getCollectionNames().size() == 0); db.setDBOptions(null); assert (db.getCollection("woogie") != null); assert (db.getCollectionNames().size() == 1); }
@Test public static void depositeDetailTest() throws Exception { CloseableHttpClient httpclient = HttpClients.createDefault(); try { HttpPost post = new HttpPost("http://192.168.2.111:8578/service?channel=QueryNoticePage"); List<NameValuePair> list = new ArrayList<NameValuePair>(); list.add(new BasicNameValuePair("platformId", "82044")); list.add(new BasicNameValuePair("appKey", "1")); post.setEntity(new UrlEncodedFormEntity(list)); CloseableHttpResponse response = httpclient.execute(post); try { System.out.println(response.getStatusLine()); HttpEntity entity2 = response.getEntity(); String entity = EntityUtils.toString(entity2); if (entity.contains("code\":\"0")) { System.out.println("Success!"); System.out.println("response content:" + entity); } else { System.out.println("Failure!"); System.out.println("response content:" + entity); AssertJUnit.fail(entity); } } finally { response.close(); } } finally { httpclient.close(); } }
@Test public void test100GetAccountMurray() throws Exception { TestUtil.displayTestTile(this, "test100GetAccountMurray"); // GIVEN Task task = taskManager.createTaskInstance( TestModelServiceContract.class.getName() + ".test100GetAccountMurray"); OperationResult result = task.getResult(); try { // WHEN PrismObject<ShadowType> account = modelService.getObject( ShadowType.class, ACCOUNT_SHADOW_MURRAY_CSVFILE_OID, null, task, result); AssertJUnit.fail("Expected SystemException but the operation was successful"); } catch (SystemException e) { // This is expected display("Expected exception", e); result.computeStatus(); display("getObject result", result); TestUtil.assertFailure("getObject result", result); } }
public void testBasicTargetRemoteDistributedCallable() throws Exception { long taskTimeout = TimeUnit.SECONDS.toMillis(15); EmbeddedCacheManager cacheManager1 = manager(0); final EmbeddedCacheManager cacheManager2 = manager(1); Cache<Object, Object> cache1 = cacheManager1.getCache(); Cache<Object, Object> cache2 = cacheManager2.getCache(); DistributedExecutorService des = null; try { des = new DefaultExecutorService(cache1); Address target = cache2.getAdvancedCache().getRpcManager().getAddress(); DistributedTaskBuilder<Integer> builder = des.createDistributedTaskBuilder(new SimpleCallable()) .failoverPolicy(DefaultExecutorService.RANDOM_NODE_FAILOVER) .timeout(taskTimeout, TimeUnit.MILLISECONDS); Future<Integer> future = des.submit(target, builder.build()); AssertJUnit.assertEquals((Integer) 1, future.get()); } catch (Exception ex) { AssertJUnit.fail("Task did not failover properly " + ex); } finally { des.shutdown(); } }
/** * Tries to create payment against review invoice. Here, instead of using the billing process to * generate a review invoice we are creating a review invoice with the help of saveLegacyInvoice * call. */ @Test public void testPayReviewInvoice() { // creating new user UserWS user = buildUser(PRANCING_PONY_ACCOUNT_TYPE); user.setId(api.createUser(user)); ItemTypeWS itemType = buildItemType(); itemType.setId(api.createItemCategory(itemType)); ItemDTOEx item = buildItem(itemType.getId(), api.getCallerCompanyId()); item.setId(api.createItem(item)); InvoiceWS invoice = buildInvoice(user.getId(), item.getId()); invoice.setIsReview(Integer.valueOf(1)); invoice.setId(api.saveLegacyInvoice(invoice)); // check if invoice is a review invoice System.out.println("Invoice is review : " + invoice.getIsReview()); assertEquals("Invoice is a review invoice", Integer.valueOf(1), invoice.getIsReview()); try { // pay for a review invoice api.payInvoice(invoice.getId()); fail("We should not be able to issue a payment against review invoice"); } catch (SessionInternalError e) { System.out.println(e.getMessage()); } // clean up api.deleteInvoice(invoice.getId()); api.deleteItem(item.getId()); api.deleteItemCategory(itemType.getId()); api.deleteUser(user.getId()); }
@Test public void test120SearchAccountByUsernameJack() throws Exception { TestUtil.displayTestTile(this, "test120SearchAccountByUsernameJack"); // GIVEN Task task = taskManager.createTaskInstance( TestModelServiceContract.class.getName() + ".test120SearchAccountByUsernameJack"); OperationResult result = task.getResult(); PrismObject<ResourceType> resource = modelService.getObject(ResourceType.class, RESOURCE_CSVFILE_BROKEN_OID, null, task, result); try { // WHEN PrismObject<ShadowType> account = findAccountByUsername("jack", resource, task, result); AssertJUnit.fail("Expected SystemException but the operation was successful"); } catch (SystemException e) { // This is expected result.computeStatus(); display("findAccountByUsername result", result); TestUtil.assertFailure("findAccountByUsername result", result); } }
@Test(groups = "unstable") public void testInvalidationDuringStateTransfer() throws Exception { cache(0).put("key1", "value1"); CheckPoint checkPoint = new CheckPoint(); blockJoinResponse(manager(0), checkPoint); addClusterEnabledCacheManager(dccc); Future<Object> joinFuture = fork( new Callable<Object>() { @Override public Object call() throws Exception { // The cache only joins here return cache(2); } }); checkPoint.awaitStrict("sending_join_response", 10, SECONDS); // This will invoke an invalidation on the joiner NotifyingFuture<Object> putFuture = cache(0).putAsync("key2", "value2"); try { putFuture.get(1, SECONDS); fail("Put operation should have been blocked, but it finished successfully"); } catch (java.util.concurrent.TimeoutException e) { // expected } checkPoint.trigger("resume_join_response"); putFuture.get(10, SECONDS); }
private void testLockMigration(int nodeThatPuts) throws Exception { Map<Object, DummyTransaction> key2Tx = new HashMap<Object, DummyTransaction>(); for (int i = 0; i < NUM_KEYS; i++) { Object key = getKeyForCache(0); if (key2Tx.containsKey(key)) continue; dummyTm(nodeThatPuts).begin(); cache(nodeThatPuts).put(key, key); DummyTransaction tx = dummyTm(nodeThatPuts).getTransaction(); tx.runPrepare(); dummyTm(nodeThatPuts).suspend(); key2Tx.put(key, tx); assertLocked(0, key); } log.trace("Lock transfer happens here"); addClusterEnabledCacheManager(dccc); waitForClusterToForm(); Object migratedKey = null; ConsistentHash ch = advancedCache(2).getDistributionManager().getConsistentHash(); for (Object key : key2Tx.keySet()) { if (ch.locatePrimaryOwner(key).equals(address(2))) { migratedKey = key; break; } } if (migratedKey == null) { log.trace("No key migrated to new owner."); } else { log.trace("migratedKey = " + migratedKey); dummyTm(2).begin(); cache(2).put(migratedKey, "someValue"); try { dummyTm(2).commit(); fail("RollbackException should have been thrown here."); } catch (RollbackException e) { // expected } } log.trace("About to commit existing transactions."); log.trace("Committing the tx to the new node."); for (Transaction tx : key2Tx.values()) { tm(nodeThatPuts).resume(tx); dummyTm(nodeThatPuts).getTransaction().runCommitTx(); } for (Object key : key2Tx.keySet()) { Object value = getValue( key); // make sure that data from the container, just to make sure all replicas are // correctly set assertEquals(key, value); } }
@Test(dependsOnMethods = {"testMetadataLevel"}) public void testCreationDateIsReasonable() { List<IObjectContainer> containers = store.getIObjectContainers(Image.class); for (IObjectContainer container : containers) { Image image = (Image) container.sourceObject; assertNotNull(image.getAcquisitionDate()); Date acquisitionDate = new Date(image.getAcquisitionDate().getValue()); Date now = new Date(System.currentTimeMillis()); Date january1st1995 = new GregorianCalendar(1995, 1, 1).getTime(); if (acquisitionDate.after(now)) { fail(String.format("%s after %s", acquisitionDate, now)); } if (acquisitionDate.before(january1st1995)) { fail(String.format("%s before %s", acquisitionDate, january1st1995)); } } }
@AfterMethod public void tearDown() throws Exception { driver.quit(); String verificationErrorString = verificationErrors.toString(); if (!"".equals(verificationErrorString)) { AssertJUnit.fail(verificationErrorString); } }
public void verifyRowMissing(String rowIdSuffix) { try { waitForElementToDisappear(By.cssSelector("img[src='/images/ajax-loader.gif']")); browser.driver.findElement(By.id("responseCommentRow" + rowIdSuffix)); fail("Row expected to be missing found."); } catch (NoSuchElementException expected) { // row expected to be missing } }
@SuppressWarnings("unchecked") protected void setupFolderSyncZone() throws Exception { int custId = getJspTestUtils().getCustId(); IFolderSyncManager folderMgr = ManagementContainer.getInstance().getFolderSyncManager(); IUserManager userService = ManagementContainer.getInstance().getUserManager(); UserAccount account = userService.getUser(getJspTestUtils().getUserAddress()); m_userId = account.getUserID(); // first create the topology and zone itself CustomerTopology ct = createTopology(); Iterator serverIterator = ct.getAllServers(); if (!serverIterator.hasNext()) { fail("No server in topology."); } CustomerServer server = (CustomerServer) serverIterator.next(); Iterator storesIterator = ct.getAllStores(); if (!storesIterator.hasNext()) { fail("No stores in server."); } CustomerStore store = (CustomerStore) storesIterator.next(); FolderSyncZone zone = new FolderSyncZone(); zone.setCustomerId(getJspTestUtils().getCustId()); zone.setDisplayName("foobar"); zone.setRegistrationKey("12345"); zone.getServers().add(server); folderMgr.saveFolderSyncZone(zone); // now enable the user for folder sync account.setMessageStoreID(store.getStoreID()); userService.updateUsers(Arrays.asList(account)); SavedUserSet userSet = new SavedUserSet(custId); List<Integer> userIDs = Arrays.asList(account.getUserID()); List<SearchConstraint> oldScList = new ArrayList<SearchConstraint>(); oldScList.add( new SearchConstraint( UserManagerConstants.PROP_USERID, SearchConstraintOperator.CONSTRAINT_IN_LIST, userIDs)); userSet.addUsers(oldScList); folderMgr.saveUserSetEnabledForSync(custId, userSet); }
protected ExperimentPE pickAnExperiment() { List<ExperimentPE> experiments = daoFactory.getExperimentDAO().listExperiments(); for (ExperimentPE experimentPE : experiments) { if (experimentPE.getInvalidation() == null) { return experimentPE; } } fail("No valid experiment found."); return null; // to make the compiler happy }
public void testImmutabilityOfData() { Node<Object, Object> rootNode = cache.getRoot(); rootNode.put("key", "value"); Map<Object, Object> m = rootNode.getData(); try { m.put("x", "y"); fail("Map should be immutable!!"); } catch (Exception e) { // expected } try { rootNode.getKeys().add(new Object()); fail("Key set should be immutable"); } catch (Exception e) { // expected } }
@Test(dependsOnMethods = {"testMetadataLevel"}) public void testAuthoritativeLSIDsAreUnique() { Set<String> authoritativeLSIDs = new HashSet<String>(); Set<IObjectContainer> containers = new HashSet<IObjectContainer>(containerCache.values()); for (IObjectContainer container : containers) { if (!authoritativeLSIDs.add(container.LSID)) { String e = String.format("LSID from %s,%s not unique.", container.sourceObject, container.LSID); fail(e); } } }
@Test public void testReadWithConnection() throws Exception { PreparedStatement preparedStatement = EasyMock.createStrictMock(PreparedStatement.class); ResultSet resultSet = EasyMock.createStrictMock(ResultSet.class); Connection connection = EasyMock.createStrictMock(Connection.class); SavedReviewerSearch search = new SavedReviewerSearch(); int id = 34; String name = "myName"; SavedReviewerSearchDAO dao = EasyMock.createMockBuilder(SavedReviewerSearchDAO.class) .withConstructor() .addMockedMethod("resultFromResultSet") .createStrictMock(); EasyMock.expect(connection.prepareStatement(SavedReviewerSearchDAO.READ_SQL)) .andReturn(preparedStatement); preparedStatement.setInt(1, id); EasyMock.expectLastCall(); preparedStatement.setString(2, name); EasyMock.expectLastCall(); EasyMock.expect(preparedStatement.executeQuery()).andReturn(resultSet); EasyMock.expect(resultSet.next()).andReturn(true); EasyMock.expect(dao.resultFromResultSet(resultSet)).andReturn(search); resultSet.close(); EasyMock.expectLastCall(); preparedStatement.close(); EasyMock.replay(preparedStatement, resultSet, connection, dao); SavedReviewerSearch result = dao.read(connection, id, name); assertEquals("Wrong search returned", search, result); EasyMock.verify(preparedStatement, resultSet, connection, dao); // failure case EasyMock.reset(preparedStatement, resultSet, connection, dao); EasyMock.expect(connection.prepareStatement(SavedReviewerSearchDAO.READ_SQL)) .andReturn(preparedStatement); preparedStatement.setInt(1, id); EasyMock.expectLastCall(); preparedStatement.setString(2, name); EasyMock.expectLastCall(); EasyMock.expect(preparedStatement.executeQuery()).andReturn(resultSet); EasyMock.expect(resultSet.next()).andReturn(false); resultSet.close(); EasyMock.expectLastCall(); preparedStatement.close(); EasyMock.replay(preparedStatement, resultSet, connection, dao); try { dao.read(connection, id, name); fail("Should have thrown a sql exception."); } catch (SQLException ex) { // expected } EasyMock.verify(preparedStatement, resultSet, connection, dao); }
public void testGetEarliestValue() { ObjectTimeSeries<E, T> empty = createEmptyTimeSeries(); ObjectTimeSeries<E, T> dts = createStandardTimeSeries(); T[] values = testValues(); assertEquals(values[0], dts.getEarliestValue()); try { empty.getEarliestValue(); } catch (NoSuchElementException nsee) { return; } fail(); }
public void testGetLatestInstant() { ObjectTimeSeries<E, T> empty = createEmptyTimeSeries(); ObjectTimeSeries<E, T> dts = createStandardTimeSeries(); E[] testDates = testTimes(); assertEquals(testDates[5], dts.getLatestTime()); try { empty.getLatestTime(); } catch (NoSuchElementException nsee) { return; } fail(); }
@Test public void simpleTest() { try { doTest("10:00", 10, 0); doTest("10:10", 10, 10); doTest("23:58", 23, 58); doTest("1:01", 1, 1); doTest("24:61", 1, 1); } catch (ParseException e) { fail(String.format("unexpected exception %s", e)); } }
protected void testRemovePerformance(int count, Map<Integer, Integer> bchm, String evictionName) { long startIncludePut = System.currentTimeMillis(); int j = 0; long firstHalfNano = System.nanoTime(); // fill the cache for (; j < count / 2; j++) bchm.put(j, j); firstHalfNano = System.nanoTime() - firstHalfNano; long secondHalfNano = System.nanoTime(); for (; j < count; j++) bchm.put(j, j); secondHalfNano = System.nanoTime() - secondHalfNano; // force a single cache hit (so that accessQueue has a head item) bchm.get(0); // remove items long start = System.currentTimeMillis(); long getNano = 0; long removeNano = 0; for (int i = 1; i < count; i++) { long getBegin = System.nanoTime(); assertNotNull(bchm.get(i)); getNano += System.nanoTime() - getBegin; long removeBegin = System.nanoTime(); bchm.remove(i); removeNano += System.nanoTime() - removeBegin; // Only check every 100 if (i % 100 == 0) { if (System.currentTimeMillis() - start > TimeUnit.SECONDS.toMillis(50)) fail(evictionName + ": removing " + count + " entries takes more than 50 seconds!"); } } System.out.println( "BCHM Stress Test " + evictionName + " took " + (System.currentTimeMillis() - start) + " milliseconds"); System.out.println( "BCHM Entire Stress Test " + evictionName + " took " + (System.currentTimeMillis() - startIncludePut) + " milliseconds"); System.out.println("First half of puts took " + firstHalfNano + " nanoseconds"); System.out.println("Second half of puts took " + secondHalfNano + " nanoseconds"); System.out.println("Gets took: " + getNano + " nanoseconds"); System.out.println("Removes took: " + removeNano + " nanoseconds"); }