Refine search
@Override protected Object handleInvocation(Object p, Method calledMethod, Object[] args) throws Throwable { assertEquals(method, calledMethod); assertEquals(method + " invoked more than once.", 0, called.get()); for (int i = 0; i < passedArgs.length; i++) { assertEquals( "Parameter #" + i + " of " + method + " not forwarded", passedArgs[i], args[i]); } called.getAndIncrement(); return returnValue; }
private AtomicInteger counter = new AtomicInteger(); public int getNextUniqueIndex() { return counter.getAndIncrement(); }
@Override public Metrics metrics(Pipeline initialPipeline, DbmsType dbmsType) { requireNonNull(initialPipeline); requireNonNull(dbmsType); final AtomicInteger filterCounter = new AtomicInteger(); traverse(initialPipeline, $ -> filterCounter.getAndIncrement()); return Metrics.of(filterCounter.get(), filterCounter.get(), 0, 0, 0); }
protected void saveDatasets(DataSetIterator iterator, String dir) { AtomicInteger counter = new AtomicInteger(0); new File(dir).mkdirs(); while (iterator.hasNext()) { String path = FilenameUtils.concat(dir, "dataset-" + (counter.getAndIncrement()) + ".bin"); iterator.next().save(new File(path)); if (counter.get() % 500 == 0) log.info("{} datasets saved so far...", counter.get()); } }
private int nextValue(String topic) { AtomicInteger counter = topicCounterMap.get(topic); if (null == counter) { counter = new AtomicInteger(ThreadLocalRandom.current().nextInt()); AtomicInteger currentCounter = topicCounterMap.putIfAbsent(topic, counter); if (currentCounter != null) { counter = currentCounter; } } return counter.getAndIncrement(); }
private boolean isSkip() { int skip = connectSkip.get(); // Growth of skipping times if (skip >= 10) { // If the number of skipping times increases by more than 10, take the random number if (connectRandom == 0) { connectRandom = ThreadLocalRandom.current().nextInt(10); } skip = 10 + connectRandom; } if (connectSkipped.getAndIncrement() < skip) { // Check the number of skipping times return true; } connectSkip.incrementAndGet(); connectSkipped.set(0); connectRandom = 0; return false; }
@Test public void noCancelPreviousRetry() { final AtomicInteger counter = new AtomicInteger(); final AtomicInteger times = new AtomicInteger(); Observable<Integer> source = Observable.defer(new Callable<ObservableSource<Integer>>() { @Override public ObservableSource<Integer> call() throws Exception { if (times.getAndIncrement() < 4) { return Observable.error(new TestException()); } return Observable.just(1); } }) .doOnDispose(new Action() { @Override public void run() throws Exception { counter.getAndIncrement(); } }); source.retry(5) .test() .assertResult(1); assertEquals(0, counter.get()); }
@Override public String getDataSource(final String name, final String masterDataSourceName, final List<String> slaveDataSourceNames) { AtomicInteger count = COUNT_MAP.containsKey(name) ? COUNT_MAP.get(name) : new AtomicInteger(0); COUNT_MAP.putIfAbsent(name, count); count.compareAndSet(slaveDataSourceNames.size(), 0); return slaveDataSourceNames.get(Math.abs(count.getAndIncrement()) % slaveDataSourceNames.size()); } }
private boolean isSkip() { int skip = connectSkip.get(); // Growth of skipping times if (skip >= 10) { // If the number of skipping times increases by more than 10, take the random number if (connectRandom == 0) { connectRandom = ThreadLocalRandom.current().nextInt(10); } skip = 10 + connectRandom; } if (connectSkipped.getAndIncrement() < skip) { // Check the number of skipping times return true; } connectSkip.incrementAndGet(); connectSkipped.set(0); connectRandom = 0; return false; }
@Test public void noCancelPreviousRetry() { final AtomicInteger counter = new AtomicInteger(); final AtomicInteger times = new AtomicInteger(); Flowable<Integer> source = Flowable.defer(new Callable<Flowable<Integer>>() { @Override public Flowable<Integer> call() throws Exception { if (times.getAndIncrement() < 4) { return Flowable.error(new TestException()); } return Flowable.just(1); } }) .doOnCancel(new Action() { @Override public void run() throws Exception { counter.getAndIncrement(); } }); source.retry(5) .test() .assertResult(1); assertEquals(0, counter.get()); }
public int nextStatementIndex(Class<?> clazz){ AtomicInteger atomic = statementIndexes.get(clazz); if (atomic == null) statementIndexes.put(clazz, atomic = new AtomicInteger()); return atomic.getAndIncrement(); }
private short getNextId() { if (nextId.get() > MAX_ID) { return UNKNOWN_ID; } return (short) nextId.getAndIncrement(); }
@Test public void noCancelPreviousRetryWhile() { final AtomicInteger counter = new AtomicInteger(); final AtomicInteger times = new AtomicInteger(); Observable<Integer> source = Observable.defer(new Callable<ObservableSource<Integer>>() { @Override public ObservableSource<Integer> call() throws Exception { if (times.getAndIncrement() < 4) { return Observable.error(new TestException()); } return Observable.just(1); } }) .doOnDispose(new Action() { @Override public void run() throws Exception { counter.getAndIncrement(); } }); source.retry(5, Functions.alwaysTrue()) .test() .assertResult(1); assertEquals(0, counter.get()); }
protected Field[] fieldsForColumns(Schema schema, List<Column> columns) { Field[] fields = new Field[columns.size()]; AtomicInteger i = new AtomicInteger(0); columns.forEach(column -> { Field field = schema.field(column.name()); // may be null if the field is unused ... fields[i.getAndIncrement()] = field; }); return fields; }
synchronized void forceSetAllowPermits(boolean allowPermits) { epoch.getAndIncrement(); this.enablePermits = allowPermits; LOG.info("EnablePermits = {}, Epoch = {}.", this.enablePermits, epoch.get()); }
@Test public void noCancelPreviousRetryWhile() { final AtomicInteger counter = new AtomicInteger(); final AtomicInteger times = new AtomicInteger(); Flowable<Integer> source = Flowable.defer(new Callable<Flowable<Integer>>() { @Override public Flowable<Integer> call() throws Exception { if (times.getAndIncrement() < 4) { return Flowable.error(new TestException()); } return Flowable.just(1); } }) .doOnCancel(new Action() { @Override public void run() throws Exception { counter.getAndIncrement(); } }); source.retry(5, Functions.alwaysTrue()) .test() .assertResult(1); assertEquals(0, counter.get()); }
private void createPageProducers(int numMergeSources) { AtomicInteger counter = new AtomicInteger(0); splitPages = pages.stream() .collect(Collectors.groupingBy(it -> counter.getAndIncrement() % numMergeSources)) .values().stream() .collect(toImmutableList()); }
private void updateStats(long checkoutTimeNs) { long wait = waitNs.getAndAdd(checkoutTimeNs); int count = checkouts.getAndIncrement(); // reset reporting interval if we have used up the current interval int interval = this.monitoringInterval.get(); if(count % interval == interval - 1) { // harmless race condition: waitNs.set(0); checkouts.set(0); avgWaitNs.set(wait / count); } }
@Test public void noCancelPreviousRetryWhile2() { final AtomicInteger counter = new AtomicInteger(); final AtomicInteger times = new AtomicInteger(); Observable<Integer> source = Observable.defer(new Callable<ObservableSource<Integer>>() { @Override public ObservableSource<Integer> call() throws Exception { if (times.getAndIncrement() < 4) { return Observable.error(new TestException()); } return Observable.just(1); } }) .doOnDispose(new Action() { @Override public void run() throws Exception { counter.getAndIncrement(); } }); source.retry(new BiPredicate<Integer, Throwable>() { @Override public boolean test(Integer a, Throwable b) throws Exception { return a < 5; } }) .test() .assertResult(1); assertEquals(0, counter.get()); }
@Override public long getBackoffTime(ServerName serverName, byte[] region, ServerStatistics stats) { AtomicInteger inc = count.get(serverName); if (inc == null) { inc = new AtomicInteger(0); count.put(serverName, inc); } return inc.getAndIncrement(); } }