(firstRetryDelay * Math.pow(retryBackoff, retryCount) * 1000); this.retryCount = retryCount; this.queue = new SinkQueue<MetricsBuffer>(checkArg(queueCapacity, queueCapacity > 0, "queue capacity")); latency = registry.newRate("Sink_"+ name, "Sink end to end latency", false);
(firstRetryDelay * Math.pow(retryBackoff, retryCount) * 1000); this.retryCount = retryCount; this.queue = new SinkQueue<MetricsBuffer>(checkArg(queueCapacity, queueCapacity > 0, "queue capacity")); latency = registry.newRate("Sink_"+ name, "Sink end to end latency", false);
(firstRetryDelay * Math.pow(retryBackoff, retryCount) * 1000); this.retryCount = retryCount; this.queue = new SinkQueue<MetricsBuffer>(checkArg(queueCapacity, queueCapacity > 0, "queue capacity")); latency = registry.newRate("Sink_"+ name, "Sink end to end latency", false);
(firstRetryDelay * Math.pow(retryBackoff, retryCount) * 1000); this.retryCount = retryCount; this.queue = new SinkQueue<MetricsBuffer>(checkArg(queueCapacity, queueCapacity > 0, "queue capacity")); latency = registry.newRate("Sink_"+ name, "Sink end to end latency", false);
private SinkQueue<Integer> newSleepingConsumerQueue(int capacity, int... values) throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(capacity); for (int i : values) { q.enqueue(i);
private SinkQueue<Integer> newSleepingConsumerQueue(int capacity, int... values) throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(capacity); for (int i : values) { q.enqueue(i);
private void testEmptyBlocking(int awhile) throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(2); final Runnable trigger = mock(Runnable.class); // try consuming emtpy equeue and blocking Thread t = new Thread() { @Override public void run() { try { assertEquals("element", 1, (int) q.dequeue()); q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { assertEquals("element", 2, (int) e); trigger.run(); } }); } catch (InterruptedException e) { LOG.warn("Interrupted", e); } } }; t.start(); // Should work with or without sleep if (awhile > 0) { Thread.sleep(awhile); } q.enqueue(1); q.enqueue(2); t.join(); verify(trigger).run(); }
private void testEmptyBlocking(int awhile) throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(2); final Runnable trigger = mock(Runnable.class); // try consuming emtpy equeue and blocking Thread t = new Thread() { @Override public void run() { try { assertEquals("element", 1, (int) q.dequeue()); q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { assertEquals("element", 2, (int) e); trigger.run(); } }); } catch (InterruptedException e) { LOG.warn("Interrupted", e); } } }; t.start(); // Should work with or without sleep if (awhile > 0) { Thread.sleep(awhile); } q.enqueue(1); q.enqueue(2); t.join(); verify(trigger).run(); }
(firstRetryDelay * Math.pow(retryBackoff, retryCount) * 1000); this.retryCount = retryCount; this.queue = new SinkQueue<MetricsBuffer>(checkArg(queueCapacity, queueCapacity > 0, "queue capacity")); latency = registry.newRate("Sink_"+ name, "Sink end to end latency", false);
/** * Test the consumeAll method * @throws Exception */ @Test public void testConsumeAll() throws Exception { final int capacity = 64; // arbitrary final SinkQueue<Integer> q = new SinkQueue<Integer>(capacity); for (int i = 0; i < capacity; ++i) { assertTrue("should enqueue", q.enqueue(i)); } assertTrue("should not enqueue", !q.enqueue(capacity)); final Runnable trigger = mock(Runnable.class); q.consumeAll(new Consumer<Integer>() { private int expected = 0; @Override public void consume(Integer e) { assertEquals("element", expected++, (int) e); trigger.run(); } }); verify(trigger, times(capacity)).run(); }
/** * Test the consumeAll method * @throws Exception */ @Test public void testConsumeAll() throws Exception { final int capacity = 64; // arbitrary final SinkQueue<Integer> q = new SinkQueue<Integer>(capacity); for (int i = 0; i < capacity; ++i) { assertTrue("should enqueue", q.enqueue(i)); } assertTrue("should not enqueue", !q.enqueue(capacity)); final Runnable trigger = mock(Runnable.class); q.consumeAll(new Consumer<Integer>() { private int expected = 0; @Override public void consume(Integer e) { assertEquals("element", expected++, (int) e); trigger.run(); } }); verify(trigger, times(capacity)).run(); }
/** * Test the consumer throwing exceptions * @throws Exception */ @Test public void testConsumerException() throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(1); final RuntimeException ex = new RuntimeException("expected"); q.enqueue(1); try { q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { throw ex; } }); } catch (Exception expected) { assertSame("consumer exception", ex, expected); } // The queue should be in consistent state after exception assertEquals("queue size", 1, q.size()); assertEquals("element", 1, (int) q.dequeue()); }
/** * Test the consumer throwing exceptions * @throws Exception */ @Test public void testConsumerException() throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(1); final RuntimeException ex = new RuntimeException("expected"); q.enqueue(1); try { q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { throw ex; } }); } catch (Exception expected) { assertSame("consumer exception", ex, expected); } // The queue should be in consistent state after exception assertEquals("queue size", 1, q.size()); assertEquals("element", 1, (int) q.dequeue()); }
/** * Test the clear method */ @Test public void testClear() { final SinkQueue<Integer> q = new SinkQueue<Integer>(128); for (int i = 0; i < q.capacity() + 97; ++i) { q.enqueue(i); } assertEquals("queue size", q.capacity(), q.size()); q.clear(); assertEquals("queue size", 0, q.size()); }
/** * Test the clear method */ @Test public void testClear() { final SinkQueue<Integer> q = new SinkQueue<Integer>(128); for (int i = 0; i < q.capacity() + 97; ++i) { q.enqueue(i); } assertEquals("queue size", q.capacity(), q.size()); q.clear(); assertEquals("queue size", 0, q.size()); }
/** * Test nonblocking enqueue when queue is full * @throws Exception */ @Test public void testFull() throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(1); q.enqueue(1); assertTrue("should drop", !q.enqueue(2)); assertEquals("element", 1, (int) q.dequeue()); q.enqueue(3); q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { assertEquals("element", 3, (int) e); } }); assertEquals("queue size", 0, q.size()); }
/** * Test nonblocking enqueue when queue is full * @throws Exception */ @Test public void testFull() throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(1); q.enqueue(1); assertTrue("should drop", !q.enqueue(2)); assertEquals("element", 1, (int) q.dequeue()); q.enqueue(3); q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { assertEquals("element", 3, (int) e); } }); assertEquals("queue size", 0, q.size()); }
/** * Test common use case * @throws Exception */ @Test public void testCommon() throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(2); q.enqueue(1); assertEquals("queue front", 1, (int) q.front()); assertEquals("queue back", 1, (int) q.back()); assertEquals("element", 1, (int) q.dequeue()); assertTrue("should enqueue", q.enqueue(2)); q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { assertEquals("element", 2, (int) e); } }); assertTrue("should enqueue", q.enqueue(3)); assertEquals("element", 3, (int) q.dequeue()); assertEquals("queue size", 0, q.size()); assertEquals("queue front", null, q.front()); assertEquals("queue back", null, q.back()); }
/** * Test common use case * @throws Exception */ @Test public void testCommon() throws Exception { final SinkQueue<Integer> q = new SinkQueue<Integer>(2); q.enqueue(1); assertEquals("queue front", 1, (int) q.front()); assertEquals("queue back", 1, (int) q.back()); assertEquals("element", 1, (int) q.dequeue()); assertTrue("should enqueue", q.enqueue(2)); q.consume(new Consumer<Integer>() { @Override public void consume(Integer e) { assertEquals("element", 2, (int) e); } }); assertTrue("should enqueue", q.enqueue(3)); assertEquals("element", 3, (int) q.dequeue()); assertEquals("queue size", 0, q.size()); assertEquals("queue front", null, q.front()); assertEquals("queue back", null, q.back()); }