protected void assertIndex(int expected, String s) {
// System.out.println("Adding " + s + ", expecting " + expected);
int index = indexer.getOrCreateIndex(s);
// System.out.println(csi);
assertEquals(expected, index);
mappings.put(expected, s);
}
private void assertConcurrentUpdates(Function<Integer, String> keyGenerator) throws Exception {
final AtomicInteger safeIndex = new AtomicInteger(-1);
List<String> keys = Lists.newArrayListWithCapacity(ATTEMPTS);
ThreadPoolExecutor executor =
new ThreadPoolExecutor(
3, 3, 5, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(ATTEMPTS));
synchronized (indexer) {
for (int i = 0; i < ATTEMPTS; i++) {
final String key = keyGenerator.apply(i);
keys.add(key);
executor.execute(
new Runnable() {
@Override
public void run() {
int index = indexer.getOrCreateIndex(key);
if (safeIndex.get() < index) {
safeIndex.set(index);
}
indexer.addString(key);
}
});
}
}
try {
while (!executor.getQueue().isEmpty()) {
// Validate that we can execute concurrent queries too.
if (safeIndex.get() >= 0) {
int index = safeIndex.get();
// Retrieve string using random existing index and validate reverse mapping.
String key = indexer.getStringForIndex(index);
assertNotNull(key);
assertEquals(index, indexer.getIndex(key));
}
}
} finally {
executor.shutdown();
executor.awaitTermination(TestUtils.WAIT_TIMEOUT_SECONDS, TimeUnit.SECONDS);
}
for (String key : keys) {
// Validate mapping between keys and indices.
assertEquals(key, indexer.getStringForIndex(indexer.getIndex(key)));
}
}
protected void assertContent() {
for (int i = 0; i < indexer.size(); i++) {
assertNotNull(mappings.get(i));
assertThat(mappings).containsEntry(i, indexer.getStringForIndex(i));
}
}
protected void assertNoIndex(String s) {
int size = indexer.size();
assertEquals(-1, indexer.getIndex(s));
assertEquals(size, indexer.size());
}
protected void assertSize(int expected) {
assertEquals(expected, indexer.size());
}
