method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
Datastore { public AddActions add() { return datastoreAddActions; } Datastore(final DatastoreSaveActions datastoreSaveActions, final DatastoreAddActions datastoreAddActions,
final DatastoreGetActions datastoreGetActions, final DatastoreUpdateActions datastoreUpdateActions); SaveActions save(); AddActions add(); GetActions get(); UpdateActions update(); }### Answer:
@Test public void addTest() { assertThat(datastore.add()).isEqualTo(datastoreAddActionsMock); }
|
### Question:
Datastore { public GetActions get() { return datastoreGetActions; } Datastore(final DatastoreSaveActions datastoreSaveActions, final DatastoreAddActions datastoreAddActions,
final DatastoreGetActions datastoreGetActions, final DatastoreUpdateActions datastoreUpdateActions); SaveActions save(); AddActions add(); GetActions get(); UpdateActions update(); }### Answer:
@Test public void getTest() { assertThat(datastore.get()).isEqualTo(datastoreGetActionsMock); }
|
### Question:
CountByKey extends StateAwareWindowWiseSingleInputOperator<
IN, IN, IN, KEY, Pair<KEY, Long>, W, CountByKey<IN, KEY, W>> { public static <IN> KeyByBuilder<IN> of(Dataset<IN> input) { return new KeyByBuilder<>("CountByKey", input); } CountByKey(String name,
Flow flow,
Dataset<IN> input,
UnaryFunction<IN, KEY> extractor,
@Nullable Windowing<IN, W> windowing,
Set<OutputHint> outputHints); static KeyByBuilder<IN> of(Dataset<IN> input); static OfBuilder named(String name); @Override DAG<Operator<?, ?>> getBasicOps(); }### Answer:
@Test public void testBuild_ImplicitName() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 3); CountByKey.of(dataset) .keyBy(s -> s) .output(); CountByKey count = (CountByKey) flow.operators().iterator().next(); assertEquals("CountByKey", count.getName()); }
|
### Question:
FlatMap extends ElementWiseOperator<IN, OUT> { public static <IN> UsingBuilder<IN> of(Dataset<IN> input) { return new UsingBuilder<>("FlatMap", input); } FlatMap(String name, Flow flow, Dataset<IN> input,
UnaryFunctor<IN, OUT> functor,
@Nullable ExtractEventTime<IN> evtTimeFn,
Set<OutputHint> outputHints); FlatMap(String name, Flow flow, Dataset<IN> input,
UnaryFunctor<IN, OUT> functor,
@Nullable ExtractEventTime<IN> evtTimeFn); static UsingBuilder<IN> of(Dataset<IN> input); static OfBuilder named(String name); UnaryFunctor<IN, OUT> getFunctor(); @Nullable ExtractEventTime<IN> getEventTimeExtractor(); }### Answer:
@Test public void testBuild_ImplicitName() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 1); Dataset<String> mapped = FlatMap.of(dataset) .using((String s, Collector<String> c) -> c.collect(s)) .output(); FlatMap map = (FlatMap) flow.operators().iterator().next(); assertEquals("FlatMap", map.getName()); }
|
### Question:
Filter extends ElementWiseOperator<IN, IN> { public static <IN> ByBuilder<IN> of(Dataset<IN> input) { return new ByBuilder<>("Filter", input); } Filter(String name,
Flow flow, Dataset<IN> input,
UnaryPredicate<IN> predicate,
Set<OutputHint> outputHints); static ByBuilder<IN> of(Dataset<IN> input); static OfBuilder named(String name); UnaryPredicate<IN> getPredicate(); @Override DAG<Operator<?, ?>> getBasicOps(); }### Answer:
@Test public void testBuild_ImplicitName() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 1); Dataset<String> filtered = Filter.of(dataset) .by(s -> !s.equals("")) .output(); Filter filter = (Filter) flow.operators().iterator().next(); assertEquals("Filter", filter.getName()); }
|
### Question:
MapElements extends ElementWiseOperator<IN, OUT> { public static <IN> UsingBuilder<IN> of(Dataset<IN> input) { return new UsingBuilder<>("MapElements", input); } MapElements(String name,
Flow flow,
Dataset<IN> input,
UnaryFunction<IN, OUT> mapper); MapElements(String name,
Flow flow,
Dataset<IN> input,
UnaryFunction<IN, OUT> mapper,
Set<OutputHint> outputHints); MapElements(String name,
Flow flow,
Dataset<IN> input,
UnaryFunctionEnv<IN, OUT> mapper, Set<OutputHint> outputHints); static UsingBuilder<IN> of(Dataset<IN> input); static OfBuilder named(String name); @Override DAG<Operator<?, ?>> getBasicOps(); UnaryFunctionEnv<IN, OUT> getMapper(); }### Answer:
@Test public void testBuild_ImplicitName() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 1); Dataset<String> mapped = MapElements.of(dataset) .using(s -> s) .output(); MapElements map = (MapElements) flow.operators().iterator().next(); assertEquals("MapElements", map.getName()); }
@Test public void testBuild_Hints() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 1); Dataset<String> dataSetWithHint = MapElements.of(dataset).using(i -> i).output(SizeHint.FITS_IN_MEMORY); assertTrue(dataSetWithHint.getProducer().getHints().contains(SizeHint.FITS_IN_MEMORY)); assertEquals(1, dataSetWithHint.getProducer().getHints().size()); Dataset<String> dataSetWithoutHint = MapElements.of(dataset).using(i -> i).output(); assertEquals(0, dataSetWithoutHint.getProducer().getHints().size()); }
|
### Question:
Distinct extends StateAwareWindowWiseSingleInputOperator<
IN, IN, IN, ELEM, ELEM, W, Distinct<IN, ELEM, W>> { public static <IN> MappedBuilder<IN, IN> of(Dataset<IN> input) { return new MappedBuilder<>("Distinct", input); } Distinct(String name,
Flow flow,
Dataset<IN> input,
UnaryFunction<IN, ELEM> mapper,
@Nullable Windowing<IN, W> windowing,
Set<OutputHint> outputHints); static MappedBuilder<IN, IN> of(Dataset<IN> input); static OfBuilder named(String name); @Override DAG<Operator<?, ?>> getBasicOps(); }### Answer:
@Test public void testBuild_ImplicitName() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 3); Dataset<String> uniq = Distinct.of(dataset).output(); Distinct distinct = (Distinct) flow.operators().iterator().next(); assertEquals("Distinct", distinct.getName()); }
@Test public void testBuild_Windowing() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 3); Dataset<String> uniq = Distinct.of(dataset) .windowBy(Time.of(Duration.ofHours(1))) .output(); Distinct distinct = (Distinct) flow.operators().iterator().next(); assertTrue(distinct.getWindowing() instanceof Time); }
@Test public void testWindow_applyIf() { Flow flow = Flow.create("TEST"); Dataset<String> dataset = Util.createMockDataset(flow, 3); Distinct.of(dataset) .applyIf(true, b -> b.windowBy(Time.of(Duration.ofHours(1)))) .output(); Distinct distinct = (Distinct) flow.operators().iterator().next(); assertTrue(distinct.getWindowing() instanceof Time); }
|
### Question:
Split { public static <IN> UsingBuilder<IN> of(Dataset<IN> input) { return new UsingBuilder<IN>(DEFAULT_NAME, input); } static OfBuilder named(String name); static UsingBuilder<IN> of(Dataset<IN> input); }### Answer:
@Test public void testBuild_ImplicitName() { Flow flow = Flow.create("split-test"); Dataset<String> dataset = Util.createMockDataset(flow, 1); Split.of(dataset) .using((UnaryPredicate<String>) what -> true) .output(); assertNotNull( getOperator(flow, Split.DEFAULT_NAME + Split.POSITIVE_FILTER_SUFFIX)); assertNotNull( getOperator(flow, Split.DEFAULT_NAME + Split.NEGATIVE_FILTER_SUFFIX)); }
@SuppressWarnings("unchecked") @Test public void testBuild_NegatedPredicate() { Flow flow = Flow.create("split-test"); Dataset<Integer> dataset = Util.createMockDataset(flow, 1); Split.of(dataset) .using((UnaryPredicate<Integer>) what -> what % 2 == 0) .output(); Filter<Integer> oddNumbers = (Filter<Integer>) getOperator( flow, Split.DEFAULT_NAME + Split.NEGATIVE_FILTER_SUFFIX); assertFalse(oddNumbers.getPredicate().apply(0)); assertFalse(oddNumbers.getPredicate().apply(2)); assertFalse(oddNumbers.getPredicate().apply(4)); assertTrue(oddNumbers.getPredicate().apply(1)); assertTrue(oddNumbers.getPredicate().apply(3)); assertTrue(oddNumbers.getPredicate().apply(5)); }
|
### Question:
TimeProviders { public static FixedTimeProvider getFixedTimeInstance(Date d) { return new FixedTimeProvider(d); } private TimeProviders(); static TimeProvider getInstance(); static TimeProvider getInstance(TimeZone tz); static FixedTimeProvider getFixedTimeInstance(Date d); }### Answer:
@Test public void testFixedTimeProvider() { Date fixed = new Date(); TimeProvider provider = TimeProviders.getFixedTimeInstance(fixed); assertTrue("FixedTimeProvider should return fixed date", provider.now().equals(fixed)); }
|
### Question:
EuphoriaIO { public static <T> Read<T> read(DataSource<T> dataSource, Coder<T> outputCoder) { return new Read<>(dataSource, outputCoder); } static Read<T> read(DataSource<T> dataSource, Coder<T> outputCoder); }### Answer:
@Test public void boundedReadTest() { List<String> inputList = asList( "one", "two", "three", "four", "five", "one two three four four two two", "one one one two two three"); ListDataSource<String> input = ListDataSource.bounded(inputList); PCollection<String> output = testPipeline.apply(EuphoriaIO.read(input, StringUtf8Coder.of())); PAssert.that(output).containsInAnyOrder(inputList); testPipeline.run().waitUntilFinish(); }
|
### Question:
SingletonSerializer extends Serializer<T> { public static <T> SingletonSerializer<T> of(String methodName) { return new SingletonSerializer<>(methodName); } private SingletonSerializer(String methodName); static SingletonSerializer<T> of(String methodName); @Override void write(Kryo kryo, Output output, T object); @Override @SuppressWarnings("unchecked") T read(Kryo kryo, Input input, Class<T> type); }### Answer:
@Test public void test() { final Kryo kryo = new Kryo(); kryo.register(TestSingleton.class, SingletonSerializer.of("getInstance")); final Output output = new Output(1024); kryo.writeClassAndObject(output, TestSingleton.getInstance()); final Input input = new Input(output.getBuffer()); final TestSingleton deserialized = (TestSingleton) kryo.readClassAndObject(input); assertEquals(TestSingleton.getInstance(), deserialized); }
|
### Question:
BatchJoinIterator implements Iterator<Tuple2<K, Tuple2<Optional<L>, Optional<R>>>> { private void emitCartesianProduct(Tuple2<BatchJoinKey<K>, Either<L, R>> right) { leftQueue.forEach( left -> outQueue.add( new Tuple2<>( left._1.getKey(), new Tuple2<>(Optional.of(left._2.left()), Optional.of(right._2.right()))))); } BatchJoinIterator(Iterator<Tuple2<BatchJoinKey<K>, Either<L, R>>> inner); @Override boolean hasNext(); @Override Tuple2<K, Tuple2<Optional<L>, Optional<R>>> next(); }### Answer:
@Test public void emitCartesianProduct() { final Iterator<Tuple2<BatchJoinKey<String>, Either<String, String>>> inner = asList( entry("key1", LEFT, Either.left("v1")), entry("key1", LEFT, Either.left("v2")), entry("key1", RIGHT, Either.right("w1")), entry("key1", RIGHT, Either.right("w2")), entry("key1", RIGHT, Either.right("w3"))) .iterator(); final List<Tuple2<String, Tuple2<Optional<String>, Optional<String>>>> results = Lists.newArrayList(new BatchJoinIterator<>(inner)); assertEquals( asList( entry("key1", "v1", "w1"), entry("key1", "v2", "w1"), entry("key1", "v1", "w2"), entry("key1", "v2", "w2"), entry("key1", "v1", "w3"), entry("key1", "v2", "w3")), results); }
|
### Question:
HFileSink implements DataSink<Cell> { @VisibleForTesting static int toRegionId(ByteBuffer[] endKeys, ImmutableBytesWritable row) { return toRegionId(endKeys, ByteBuffer.wrap( row.get(), row.getOffset(), row.getLength())); } @VisibleForTesting HFileSink(HFileSink clone); HFileSink(
String tableName,
boolean doBulkLoad,
@Nullable Windowing<Cell, ?> windowing,
UnaryFunction<Window<?>, String> folderNaming,
Configuration conf,
List<Update<Job>> updaters); static Builder newBuilder(); @Override boolean prepareDataset(Dataset<Cell> output); @Override Writer<Cell> openWriter(int partitionId); @Override void commit(); @Override void rollback(); void persist(Dataset<T> input, UnaryFunction<T, Cell> mapper); static final String HDFS_USER; static final String HBASE_USER; }### Answer:
@Test public void testRegionAssignment() { ByteBuffer[] endKeys = Stream.of("b", "dd", "fff") .map(c -> ByteBuffer.wrap(b(c))) .toArray(l -> new ByteBuffer[l]); assertEquals(0, HFileSink.toRegionId(endKeys, ibw("a"))); assertEquals(1, HFileSink.toRegionId(endKeys, ibw("b"))); assertEquals(1, HFileSink.toRegionId(endKeys, ibw("c"))); assertEquals(2, HFileSink.toRegionId(endKeys, ibw("dd"))); assertEquals(2, HFileSink.toRegionId(endKeys, ibw("ddd"))); assertEquals(2, HFileSink.toRegionId(endKeys, ibw("e"))); assertEquals(3, HFileSink.toRegionId(endKeys, ibw("fff"))); assertEquals(3, HFileSink.toRegionId(endKeys, ibw("ffff"))); assertEquals(3, HFileSink.toRegionId(endKeys, ibw("gg"))); }
|
### Question:
Fluent { public static Flow flow(String name) { return Flow.create(name); } static Flow flow(String name); static Flow flow(String name, Settings settings); static Dataset<T> lift(cz.seznam.euphoria.core.client.dataset.Dataset<T> xs); }### Answer:
@Test public void testBasics() throws Exception { final Duration READ_DELAY = Duration.ofMillis(100L); ListDataSink<Set<String>> out = ListDataSink.get(); Fluent.flow("Test") .read(ListDataSource.unbounded( asList("0-one 1-two 0-three 1-four 0-five 1-six 0-seven".split(" "))) .withReadDelay(READ_DELAY)) .apply(input -> ReduceByKey.of(input) .keyBy(e -> "") .valueBy(e -> e) .reduceBy(s -> s.collect(Collectors.toSet())) .windowBy(Count.of(3))) .flatMap((Pair<String, Set<String>> e, Collector<String> c) -> e.getSecond().stream().forEachOrdered(c::collect)) .apply(input -> ReduceByKey.of(input) .keyBy(e -> "") .valueBy(e -> e) .reduceBy(s -> s.collect(Collectors.toSet()))) .mapElements(Pair::getSecond) .persist(out) .execute(new LocalExecutor()); }
|
### Question:
FsSpillingListStorage implements ListStorage<T>, ExternalIterable<T> { void closeOutput() { flush(); if (serializerStream != null) { serializerStream.close(); serializerStream = null; } } FsSpillingListStorage(
SerializerFactory serializerFactory,
SpillFileFactory spillFileFactory,
int maxElemsInMemory); @Override void add(T element); @Override Iterable<T> get(); @Override void clear(); @Override Iterator<T> iterator(); @Override void close(); }### Answer:
@Test public void testCloseOutput() { List<String> input = Arrays.asList( "one", "two", "three", "four", "five", "six", "seven", "eight"); FsSpillingListStorage<String> storage = new FsSpillingListStorage<>(new JavaSerializationFactory(), spillFiles, 5); storage.addAll(input); storage.closeOutput(); assertEquals(input, StreamSupport .stream(storage.get().spliterator(), false) .collect(Collectors.toList())); }
|
### Question:
GenericSpillTools implements SpillTools { @Override public <T> Collection<ExternalIterable<T>> spillAndSortParts( Iterable<T> what, Comparator<T> comparator) throws InterruptedException { List<ExternalIterable<T>> ret = new ArrayList<>(); List<T> sortList = new ArrayList<>(numSpillRecords); for (T e : what) { if (sortList.size() == numSpillRecords) { ret.add(externalize(sortList.stream().sorted(comparator))); LOG.debug("Successfully externalized {} records", sortList.size()); sortList.clear(); } sortList.add(e); if (Thread.currentThread().isInterrupted()) { throw new InterruptedException(); } } if (!sortList.isEmpty()) { ret.add(externalize(sortList.stream().sorted(comparator))); } return ret; } GenericSpillTools(
SerializerFactory serializer,
SpillFileFactory spillFactory,
Settings settings); GenericSpillTools(
SerializerFactory serializer,
Settings settings); @VisibleForTesting GenericSpillTools(
SerializerFactory serializer,
SpillFileFactory spillFactory,
int spillRecords); @Override ExternalIterable<T> externalize(Iterable<T> what); @Override Collection<ExternalIterable<T>> spillAndSortParts(
Iterable<T> what, Comparator<T> comparator); }### Answer:
@Test public void testSpilling() throws InterruptedException { Collection<ExternalIterable<Integer>> parts = tools.spillAndSortParts( IntStream.range(0, 1003) .boxed() .sorted(Comparator.reverseOrder()) .collect(Collectors.toList()), Integer::compare); assertEquals(11, parts.size()); assertEquals(11, spillFiles.getCreatedFiles().size()); }
|
### Question:
DAG { @SafeVarargs public final DAG<T> add(T elem, T... parents) { add(elem, Arrays.asList(parents)); return this; } private DAG(); static DAG<T> empty(); @SuppressWarnings("unchecked") static DAG<T> of(T ...rootElements); static DAG<T> of(Iterable<T> rootElements); @SafeVarargs final DAG<T> add(T elem, T... parents); DAG<T> add(T elem, List<T> parents); Node<T> getNode(T elem); Collection<Node<T>> getRoots(); Collection<Node<T>> getLeafs(); DAG<T> parentSubGraph(T elem); int size(); Stream<T> nodes(); Stream<Node<T>> traverse(); @Override String toString(); }### Answer:
@Test public void testAdd() { DAG<Integer> dag = DAG.of(1); assertEquals(dag.size(), 1); }
|
### Question:
DAG { public Collection<Node<T>> getRoots() { return roots; } private DAG(); static DAG<T> empty(); @SuppressWarnings("unchecked") static DAG<T> of(T ...rootElements); static DAG<T> of(Iterable<T> rootElements); @SafeVarargs final DAG<T> add(T elem, T... parents); DAG<T> add(T elem, List<T> parents); Node<T> getNode(T elem); Collection<Node<T>> getRoots(); Collection<Node<T>> getLeafs(); DAG<T> parentSubGraph(T elem); int size(); Stream<T> nodes(); Stream<Node<T>> traverse(); @Override String toString(); }### Answer:
@Test public void testGetRoots() { DAG<Integer> dag = DAG.of(1, 2, 3); Collection<Node<Integer>> roots = dag.getRoots(); assertEquals(3, roots.size()); assertTrue(roots.contains(new Node<>(1))); assertTrue(roots.contains(new Node<>(2))); assertTrue(roots.contains(new Node<>(3))); }
|
### Question:
DAG { public Collection<Node<T>> getLeafs() { return nodeMap.values().stream().filter(n -> n.children.isEmpty()) .collect(Collectors.toList()); } private DAG(); static DAG<T> empty(); @SuppressWarnings("unchecked") static DAG<T> of(T ...rootElements); static DAG<T> of(Iterable<T> rootElements); @SafeVarargs final DAG<T> add(T elem, T... parents); DAG<T> add(T elem, List<T> parents); Node<T> getNode(T elem); Collection<Node<T>> getRoots(); Collection<Node<T>> getLeafs(); DAG<T> parentSubGraph(T elem); int size(); Stream<T> nodes(); Stream<Node<T>> traverse(); @Override String toString(); }### Answer:
@Test public void testGetLeafs() { DAG<Integer> dag = DAG.of(1, 2, 3); dag.add(4, 2, 3); dag.add(5, 4, 2); dag.add(6, 5, 3); Collection<Node<Integer>> leafs = dag.getLeafs(); assertEquals(2, leafs.size()); assertTrue(leafs.contains(new Node<>(1))); assertTrue(leafs.contains(new Node<>(6))); }
|
### Question:
InstrumentedAppender extends AbstractAppender { @Override public void append(LogEvent event) { Level level = event.getLevel(); if (TRACE.equals(level)) TRACE_LABEL.inc(); else if (DEBUG.equals(level)) DEBUG_LABEL.inc(); else if (INFO.equals(level)) INFO_LABEL.inc(); else if (WARN.equals(level)) WARN_LABEL.inc(); else if (ERROR.equals(level)) ERROR_LABEL.inc(); else if (FATAL.equals(level)) FATAL_LABEL.inc(); } protected InstrumentedAppender(String name); @Override void append(LogEvent event); @PluginFactory static InstrumentedAppender createAppender(
@PluginAttribute("name") String name); static final String COUNTER_NAME; }### Answer:
@Test public void metersTraceEvents() throws Exception { when(event.getLevel()).thenReturn(TRACE); appender.append(event); assertEquals(1, getLogLevelCount("trace")); }
@Test public void metersDebugEvents() throws Exception { when(event.getLevel()).thenReturn(DEBUG); appender.append(event); assertEquals(1, getLogLevelCount("debug")); }
@Test public void metersInfoEvents() throws Exception { when(event.getLevel()).thenReturn(INFO); appender.append(event); assertEquals(1, getLogLevelCount("trace")); }
@Test public void metersWarnEvents() throws Exception { when(event.getLevel()).thenReturn(WARN); appender.append(event); assertEquals(1, getLogLevelCount("warn")); }
@Test public void metersErrorEvents() throws Exception { when(event.getLevel()).thenReturn(ERROR); appender.append(event); assertEquals(1, getLogLevelCount("error")); }
@Test public void metersFatalEvents() throws Exception { when(event.getLevel()).thenReturn(FATAL); appender.append(event); assertEquals(1, getLogLevelCount("fatal")); }
|
### Question:
HTTPServer { public void stop() { server.stop(0); executorService.shutdown(); } HTTPServer(HttpServer httpServer, CollectorRegistry registry, boolean daemon); HTTPServer(InetSocketAddress addr, CollectorRegistry registry, boolean daemon); HTTPServer(InetSocketAddress addr, CollectorRegistry registry); HTTPServer(int port, boolean daemon); HTTPServer(int port); HTTPServer(String host, int port, boolean daemon); HTTPServer(String host, int port); void stop(); int getPort(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testRefuseUsingUnbound() throws IOException { CollectorRegistry registry = new CollectorRegistry(); HTTPServer s = new HTTPServer(HttpServer.create(), registry, true); s.stop(); }
|
### Question:
GarbageCollectorExports extends Collector { public GarbageCollectorExports() { this(ManagementFactory.getGarbageCollectorMXBeans()); } GarbageCollectorExports(); GarbageCollectorExports(List<GarbageCollectorMXBean> garbageCollectors); List<MetricFamilySamples> collect(); }### Answer:
@Test public void testGarbageCollectorExports() { assertEquals( 100L, registry.getSampleValue( "jvm_gc_collection_seconds_count", new String[]{"gc"}, new String[]{"MyGC1"}), .0000001); assertEquals( 10d, registry.getSampleValue( "jvm_gc_collection_seconds_sum", new String[]{"gc"}, new String[]{"MyGC1"}), .0000001); assertEquals( 200L, registry.getSampleValue( "jvm_gc_collection_seconds_count", new String[]{"gc"}, new String[]{"MyGC2"}), .0000001); assertEquals( 20d, registry.getSampleValue( "jvm_gc_collection_seconds_sum", new String[]{"gc"}, new String[]{"MyGC2"}), .0000001); }
|
### Question:
StandardExports extends Collector { public StandardExports() { this(new StatusReader(), ManagementFactory.getOperatingSystemMXBean(), ManagementFactory.getRuntimeMXBean()); } StandardExports(); StandardExports(StatusReader statusReader, OperatingSystemMXBean osBean, RuntimeMXBean runtimeBean); @Override List<MetricFamilySamples> collect(); }### Answer:
@Test public void testStandardExports() { CollectorRegistry registry = new CollectorRegistry(); new StandardExports(new StatusReaderTest(), osBean, runtimeBean).register(registry); assertEquals(123 / 1.0E9, registry.getSampleValue("process_cpu_seconds_total", new String[]{}, new String[]{}), .0000001); assertEquals(10, registry.getSampleValue("process_open_fds", new String[]{}, new String[]{}), .001); assertEquals(20, registry.getSampleValue("process_max_fds", new String[]{}, new String[]{}), .001); assertEquals(456 / 1.0E3, registry.getSampleValue("process_start_time_seconds", new String[]{}, new String[]{}), .0000001); assertEquals(5900 * 1024, registry.getSampleValue("process_virtual_memory_bytes", new String[]{}, new String[]{}), .001); assertEquals(360 * 1024, registry.getSampleValue("process_resident_memory_bytes", new String[]{}, new String[]{}), .001); }
|
### Question:
SpringBootMetricsCollector extends Collector implements Collector.Describable { @Override public List<MetricFamilySamples> collect() { ArrayList<MetricFamilySamples> samples = new ArrayList<MetricFamilySamples>(); for (PublicMetrics publicMetrics : this.publicMetrics) { for (Metric<?> metric : publicMetrics.metrics()) { String name = Collector.sanitizeMetricName(metric.getName()); double value = metric.getValue().doubleValue(); MetricFamilySamples metricFamilySamples = new MetricFamilySamples( name, Type.GAUGE, name, Collections.singletonList( new MetricFamilySamples.Sample(name, Collections.<String>emptyList(), Collections.<String>emptyList(), value))); samples.add(metricFamilySamples); } } return samples; } @Autowired SpringBootMetricsCollector(Collection<PublicMetrics> publicMetrics); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void collect() throws Exception { counterService.increment("foo"); gaugeService.submit("bar", 3.14); CollectorRegistry defaultRegistry = CollectorRegistry.defaultRegistry; assertThat(defaultRegistry.getSampleValue("counter_foo"), is(1.0)); assertThat(defaultRegistry.getSampleValue("gauge_bar"), is(3.14)); }
|
### Question:
PushGateway { public void delete(String job) throws IOException { doRequest(null, job, null, "DELETE"); } PushGateway(String address); PushGateway(URL serverBaseURL); void setConnectionFactory(HttpConnectionFactory connectionFactory); void push(CollectorRegistry registry, String job); void push(Collector collector, String job); void push(CollectorRegistry registry, String job, Map<String, String> groupingKey); void push(Collector collector, String job, Map<String, String> groupingKey); void pushAdd(CollectorRegistry registry, String job); void pushAdd(Collector collector, String job); void pushAdd(CollectorRegistry registry, String job, Map<String, String> groupingKey); void pushAdd(Collector collector, String job, Map<String, String> groupingKey); void delete(String job); void delete(String job, Map<String, String> groupingKey); @Deprecated void push(CollectorRegistry registry, String job, String instance); @Deprecated void push(Collector collector, String job, String instance); @Deprecated void pushAdd(CollectorRegistry registry, String job, String instance); @Deprecated void pushAdd(Collector collector, String job, String instance); @Deprecated void delete(String job, String instance); static Map<String, String> instanceIPGroupingKey(); }### Answer:
@Test public void testDelete() throws IOException { mockServerClient.when( request() .withMethod("DELETE") .withPath("/metrics/job/j") ).respond(response().withStatusCode(202)); pg.delete("j"); }
@Test public void testDeleteWithGroupingKey() throws IOException { mockServerClient.when( request() .withMethod("DELETE") .withPath("/metrics/job/j/l/v") ).respond(response().withStatusCode(202)); pg.delete("j", groupingKey); }
@Test public void testOldDelete() throws IOException { mockServerClient.when( request() .withMethod("DELETE") .withPath("/metrics/job/j/instance/i") ).respond(response().withStatusCode(202)); pg.delete("j", "i"); }
|
### Question:
PushGateway { public static Map<String, String> instanceIPGroupingKey() throws UnknownHostException { Map<String, String> groupingKey = new HashMap<String, String>(); groupingKey.put("instance", InetAddress.getLocalHost().getHostAddress()); return groupingKey; } PushGateway(String address); PushGateway(URL serverBaseURL); void setConnectionFactory(HttpConnectionFactory connectionFactory); void push(CollectorRegistry registry, String job); void push(Collector collector, String job); void push(CollectorRegistry registry, String job, Map<String, String> groupingKey); void push(Collector collector, String job, Map<String, String> groupingKey); void pushAdd(CollectorRegistry registry, String job); void pushAdd(Collector collector, String job); void pushAdd(CollectorRegistry registry, String job, Map<String, String> groupingKey); void pushAdd(Collector collector, String job, Map<String, String> groupingKey); void delete(String job); void delete(String job, Map<String, String> groupingKey); @Deprecated void push(CollectorRegistry registry, String job, String instance); @Deprecated void push(Collector collector, String job, String instance); @Deprecated void pushAdd(CollectorRegistry registry, String job, String instance); @Deprecated void pushAdd(Collector collector, String job, String instance); @Deprecated void delete(String job, String instance); static Map<String, String> instanceIPGroupingKey(); }### Answer:
@Test public void testInstanceIPGroupingKey() throws IOException { groupingKey = PushGateway.instanceIPGroupingKey(); Assert.assertTrue(!groupingKey.get("instance").equals("")); }
|
### Question:
MetricsFilter implements Filter { @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { if (!(servletRequest instanceof HttpServletRequest)) { filterChain.doFilter(servletRequest, servletResponse); return; } HttpServletRequest request = (HttpServletRequest) servletRequest; String path = request.getRequestURI(); String components = getComponents(path); String method = request.getMethod(); Histogram.Timer timer = histogram .labels(components, method) .startTimer(); try { filterChain.doFilter(servletRequest, servletResponse); } finally { timer.observeDuration(); statusCounter.labels(components, method, getStatusCode(servletResponse)).inc(); } } MetricsFilter(); MetricsFilter(
String metricName,
String help,
Integer pathComponents,
double[] buckets); @Override void init(FilterConfig filterConfig); @Override void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain); @Override void destroy(); }### Answer:
@Test public void doFilter() throws Exception { HttpServletRequest req = mock(HttpServletRequest.class); final String path = "/foo/bar/baz/bang/zilch/zip/nada"; when(req.getRequestURI()).thenReturn(path); when(req.getMethod()).thenReturn(HttpMethods.GET); HttpServletResponse res = mock(HttpServletResponse.class); FilterChain c = mock(FilterChain.class); String name = "foo"; FilterConfig cfg = mock(FilterConfig.class); when(cfg.getInitParameter(MetricsFilter.METRIC_NAME_PARAM)).thenReturn(name); when(cfg.getInitParameter(MetricsFilter.PATH_COMPONENT_PARAM)).thenReturn("0"); f.init(cfg); f.doFilter(req, res, c); verify(c).doFilter(req, res); final Double sampleValue = CollectorRegistry.defaultRegistry.getSampleValue(name + "_count", new String[]{"path", "method"}, new String[]{path, HttpMethods.GET}); assertNotNull(sampleValue); assertEquals(1, sampleValue, 0.0001); }
|
### Question:
Counter extends SimpleCollector<Counter.Child> implements Collector.Describable { public void inc() { inc(1); } Counter(Builder b); static Builder build(String name, String help); static Builder build(); void inc(); void inc(double amt); double get(); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testNegativeIncrementFails() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Amount to increment must be non-negative."); noLabels.inc(-1); }
@Test public void testLabels() { assertEquals(null, getLabelsValue("a")); assertEquals(null, getLabelsValue("b")); labels.labels("a").inc(); assertEquals(1.0, getLabelsValue("a").doubleValue(), .001); assertEquals(null, getLabelsValue("b")); labels.labels("b").inc(3); assertEquals(1.0, getLabelsValue("a").doubleValue(), .001); assertEquals(3.0, getLabelsValue("b").doubleValue(), .001); }
|
### Question:
Counter extends SimpleCollector<Counter.Child> implements Collector.Describable { @Override public List<MetricFamilySamples> collect() { List<MetricFamilySamples.Sample> samples = new ArrayList<MetricFamilySamples.Sample>(children.size()); for(Map.Entry<List<String>, Child> c: children.entrySet()) { samples.add(new MetricFamilySamples.Sample(fullname, labelNames, c.getKey(), c.getValue().get())); } return familySamplesList(Type.COUNTER, samples); } Counter(Builder b); static Builder build(String name, String help); static Builder build(); void inc(); void inc(double amt); double get(); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testCollect() { labels.labels("a").inc(); List<Collector.MetricFamilySamples> mfs = labels.collect(); ArrayList<Collector.MetricFamilySamples.Sample> samples = new ArrayList<Collector.MetricFamilySamples.Sample>(); ArrayList<String> labelNames = new ArrayList<String>(); labelNames.add("l"); ArrayList<String> labelValues = new ArrayList<String>(); labelValues.add("a"); samples.add(new Collector.MetricFamilySamples.Sample("labels", labelNames, labelValues, 1.0)); Collector.MetricFamilySamples mfsFixture = new Collector.MetricFamilySamples("labels", Collector.Type.COUNTER, "help", samples); assertEquals(1, mfs.size()); assertEquals(mfsFixture, mfs.get(0)); }
|
### Question:
Collector { public static String sanitizeMetricName(String metricName) { return SANITIZE_BODY_PATTERN.matcher( SANITIZE_PREFIX_PATTERN.matcher(metricName).replaceFirst("_") ).replaceAll("_"); } abstract List<MetricFamilySamples> collect(); T register(); T register(CollectorRegistry registry); static String sanitizeMetricName(String metricName); static String doubleToGoString(double d); static final double NANOSECONDS_PER_SECOND; static final double MILLISECONDS_PER_SECOND; }### Answer:
@Test public void sanitizeMetricName() throws Exception { assertEquals("_hoge", Collector.sanitizeMetricName("0hoge")); assertEquals("foo_bar0", Collector.sanitizeMetricName("foo.bar0")); assertEquals(":baz::", Collector.sanitizeMetricName(":baz::")); }
|
### Question:
Histogram extends SimpleCollector<Histogram.Child> implements Collector.Describable { public static Builder build(String name, String help) { return new Builder().name(name).help(help); } Histogram(Builder b); static Builder build(String name, String help); static Builder build(); void observe(double amt); Timer startTimer(); double time(Runnable timeable); E time(Callable<E> timeable); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testLeLabelThrows() { thrown.expect(IllegalStateException.class); thrown.expectMessage("Histogram cannot have a label named 'le'."); Histogram.build().name("labels").help("help").labelNames("le").create(); }
|
### Question:
SimpleCollector extends Collector { public Child labels(String... labelValues) { if (labelValues.length != labelNames.size()) { throw new IllegalArgumentException("Incorrect number of labels."); } for (String label: labelValues) { if (label == null) { throw new IllegalArgumentException("Label cannot be null."); } } List<String> key = Arrays.asList(labelValues); Child c = children.get(key); if (c != null) { return c; } Child c2 = newChild(); Child tmp = children.putIfAbsent(key, c2); return tmp == null ? c2 : tmp; } protected SimpleCollector(Builder b); Child labels(String... labelValues); void remove(String... labelValues); void clear(); T setChild(Child child, String... labelValues); }### Answer:
@Test public void testTooFewLabelsThrows() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Incorrect number of labels."); metric.labels(); }
@Test public void testNullLabelThrows() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Label cannot be null."); metric.labels(new String[]{null}); }
@Test public void testTooManyLabelsThrows() { thrown.expect(IllegalArgumentException.class); thrown.expectMessage("Incorrect number of labels."); metric.labels("a", "b"); }
|
### Question:
SimpleCollector extends Collector { public void remove(String... labelValues) { children.remove(Arrays.asList(labelValues)); initializeNoLabelsChild(); } protected SimpleCollector(Builder b); Child labels(String... labelValues); void remove(String... labelValues); void clear(); T setChild(Child child, String... labelValues); }### Answer:
@Test public void testRemove() { metric.labels("a"); assertNotNull(getValue("a")); assertNull(getValue("b")); metric.labels("b").set(7); assertNotNull(getValue("a")); assertNotNull(getValue("b")); metric.remove("b"); assertNotNull(getValue("a")); assertNull(getValue("b")); metric.labels("b").inc(); assertEquals(1.0, getValue("b").doubleValue(), .001); }
@Test public void testNoLabelsWorkAfterRemove() { noLabels.inc(1); assertEquals(getValueNoLabels(), 1.0, .001); noLabels.remove(); noLabels.inc(2); assertEquals(getValueNoLabels(), 2.0, .001); }
|
### Question:
SimpleCollector extends Collector { public void clear() { children.clear(); initializeNoLabelsChild(); } protected SimpleCollector(Builder b); Child labels(String... labelValues); void remove(String... labelValues); void clear(); T setChild(Child child, String... labelValues); }### Answer:
@Test public void testClear() { assertNull(getValue("a")); metric.labels("a").set(7); assertNotNull(getValue("a")); metric.clear(); assertNull(getValue("a")); metric.labels("a").inc(); assertEquals(1.0, getValue("a").doubleValue(), .001); }
@Test public void testNoLabelsWorkAfterClear() { noLabels.inc(1); assertEquals(getValueNoLabels(), 1.0, .001); noLabels.clear(); noLabels.inc(2); assertEquals(getValueNoLabels(), 2.0, .001); }
|
### Question:
SimpleCollector extends Collector { public <T extends Collector> T setChild(Child child, String... labelValues) { if (labelValues.length != labelNames.size()) { throw new IllegalArgumentException("Incorrect number of labels."); } children.put(Arrays.asList(labelValues), child); return (T)this; } protected SimpleCollector(Builder b); Child labels(String... labelValues); void remove(String... labelValues); void clear(); T setChild(Child child, String... labelValues); }### Answer:
@Test public void testSetChild() { metric.setChild(new Gauge.Child(){ public double get() { return 42; } }, "a"); assertEquals(42.0, getValue("a").doubleValue(), .001); }
@Test public void testSetChildReturnsGauge() { Gauge g = metric.setChild(new Gauge.Child(){ public double get() { return 42; } }, "a"); }
|
### Question:
CollectorRegistry { public void unregister(Collector m) { synchronized (namesCollectorsLock) { List<String> names = collectorsToNames.remove(m); for (String name : names) { namesToCollectors.remove(name); } } } CollectorRegistry(); CollectorRegistry(boolean autoDescribe); void register(Collector m); void unregister(Collector m); void clear(); Enumeration<Collector.MetricFamilySamples> metricFamilySamples(); Enumeration<Collector.MetricFamilySamples> filteredMetricFamilySamples(Set<String> includedNames); Double getSampleValue(String name); Double getSampleValue(String name, String[] labelNames, String[] labelValues); static final CollectorRegistry defaultRegistry; }### Answer:
@Test public void testUnregister() { Collector g = Gauge.build().name("g").help("h").register(registry); Collector c = Counter.build().name("c").help("h").register(registry); List<Collector.MetricFamilySamples> mfs = Collections.list(registry.metricFamilySamples()); assertEquals(2, mfs.size()); registry.unregister(g); mfs = Collections.list(registry.metricFamilySamples()); assertEquals(1, mfs.size()); assertEquals("c", mfs.get(0).name); }
|
### Question:
CollectorRegistry { public void clear() { synchronized (namesCollectorsLock) { collectorsToNames.clear(); namesToCollectors.clear(); } } CollectorRegistry(); CollectorRegistry(boolean autoDescribe); void register(Collector m); void unregister(Collector m); void clear(); Enumeration<Collector.MetricFamilySamples> metricFamilySamples(); Enumeration<Collector.MetricFamilySamples> filteredMetricFamilySamples(Set<String> includedNames); Double getSampleValue(String name); Double getSampleValue(String name, String[] labelNames, String[] labelValues); static final CollectorRegistry defaultRegistry; }### Answer:
@Test public void testClear() { Collector g = Gauge.build().name("g").help("h").register(registry); Collector c = Counter.build().name("c").help("h").register(registry); List<Collector.MetricFamilySamples> mfs = Collections.list(registry.metricFamilySamples()); assertEquals(2, mfs.size()); registry.clear(); mfs = Collections.list(registry.metricFamilySamples()); assertEquals(0, mfs.size()); }
|
### Question:
CollectorRegistry { public Enumeration<Collector.MetricFamilySamples> metricFamilySamples() { return new MetricFamilySamplesEnumeration(); } CollectorRegistry(); CollectorRegistry(boolean autoDescribe); void register(Collector m); void unregister(Collector m); void clear(); Enumeration<Collector.MetricFamilySamples> metricFamilySamples(); Enumeration<Collector.MetricFamilySamples> filteredMetricFamilySamples(Set<String> includedNames); Double getSampleValue(String name); Double getSampleValue(String name, String[] labelNames, String[] labelValues); static final CollectorRegistry defaultRegistry; }### Answer:
@Test public void testMetricFamilySamples() { Collector g = Gauge.build().name("g").help("h").register(registry); Collector c = Counter.build().name("c").help("h").register(registry); Collector s = Summary.build().name("s").help("h").register(registry); Collector ec = new EmptyCollector().register(registry); HashSet<String> names = new HashSet<String>(); for (Collector.MetricFamilySamples metricFamilySamples : Collections.list(registry.metricFamilySamples())) { names.add(metricFamilySamples.name); } assertEquals(new HashSet<String>(Arrays.asList("g", "c", "s")), names); }
@Test public void testEmptyRegistryHasNoMoreElements() { assertFalse(registry.metricFamilySamples().hasMoreElements()); }
|
### Question:
SimpleTimer { public double elapsedSeconds() { return elapsedSecondsFromNanos(start, timeProvider.nanoTime()); } SimpleTimer(TimeProvider timeProvider); SimpleTimer(); double elapsedSeconds(); static double elapsedSecondsFromNanos(long startNanos, long endNanos); }### Answer:
@Test public void elapsedSeconds() throws Exception { SimpleTimer.TimeProvider provider = new SimpleTimer.TimeProvider() { long value = (long)(30 * 1e9); long nanoTime() { value += (long)(10 * 1e9); return value; } }; SimpleTimer timer = new SimpleTimer(provider); assertEquals(10, timer.elapsedSeconds(), .001); }
|
### Question:
QueuedThreadPoolStatisticsCollector extends Collector { @Override public <T extends Collector> T register(CollectorRegistry registry) { if (queuedThreadPoolMap.isEmpty()) { throw new IllegalStateException("You must register at least one QueuedThreadPool."); } return super.register(registry); } QueuedThreadPoolStatisticsCollector(); QueuedThreadPoolStatisticsCollector(QueuedThreadPool queuedThreadPool, String name); QueuedThreadPoolStatisticsCollector add(QueuedThreadPool queuedThreadPool, String name); @Override List<MetricFamilySamples> collect(); @Override T register(CollectorRegistry registry); }### Answer:
@Test public void metricsGathered() throws Exception { String unit = "queue1"; String[] labelValues = {unit}; new QueuedThreadPoolStatisticsCollector(queuedThreadPool, unit).register(); server.start(); assertTrue( CollectorRegistry.defaultRegistry.getSampleValue("jetty_queued_thread_pool_threads", LABEL_NAMES, labelValues) > 0); assertTrue( CollectorRegistry.defaultRegistry.getSampleValue("jetty_queued_thread_pool_threads_idle", LABEL_NAMES, labelValues) > 0); assertTrue( CollectorRegistry.defaultRegistry.getSampleValue("jetty_queued_thread_pool_threads_max", LABEL_NAMES, labelValues) == 200); assertNotNull(CollectorRegistry.defaultRegistry.getSampleValue("jetty_queued_thread_pool_jobs", LABEL_NAMES, labelValues)); }
@Test public void shouldFailIfNoQueueThreadPoolsAreRegistered() { expectedException.expect(IllegalStateException.class); expectedException.expectMessage("QueuedThreadPool"); new QueuedThreadPoolStatisticsCollector().register(); }
|
### Question:
Gauge extends SimpleCollector<Gauge.Child> implements Collector.Describable { public void dec() { dec(1); } Gauge(Builder b); static Builder build(String name, String help); static Builder build(); void inc(); void inc(double amt); void dec(); void dec(double amt); void set(double val); void setToCurrentTime(); Timer startTimer(); double setToTime(Runnable timeable); E setToTime(Callable<E> timeable); double get(); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testDecrement() { noLabels.dec(); assertEquals(-1.0, getValue(), .001); noLabels.dec(2); assertEquals(-3.0, getValue(), .001); noLabels.labels().dec(4); assertEquals(-7.0, getValue(), .001); noLabels.labels().dec(); assertEquals(-8.0, getValue(), .001); }
|
### Question:
Gauge extends SimpleCollector<Gauge.Child> implements Collector.Describable { public void set(double val) { noLabelsChild.set(val); } Gauge(Builder b); static Builder build(String name, String help); static Builder build(); void inc(); void inc(double amt); void dec(); void dec(double amt); void set(double val); void setToCurrentTime(); Timer startTimer(); double setToTime(Runnable timeable); E setToTime(Callable<E> timeable); double get(); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testSet() { noLabels.set(42); assertEquals(42, getValue(), .001); noLabels.labels().set(7); assertEquals(7.0, getValue(), .001); }
|
### Question:
Gauge extends SimpleCollector<Gauge.Child> implements Collector.Describable { public void setToCurrentTime() { noLabelsChild.setToCurrentTime(); } Gauge(Builder b); static Builder build(String name, String help); static Builder build(); void inc(); void inc(double amt); void dec(); void dec(double amt); void set(double val); void setToCurrentTime(); Timer startTimer(); double setToTime(Runnable timeable); E setToTime(Callable<E> timeable); double get(); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testSetToCurrentTime() { Gauge.Child.timeProvider = new Gauge.TimeProvider() { long currentTimeMillis() { return 42000; } }; noLabels.setToCurrentTime(); assertEquals(42, getValue(), .001); }
|
### Question:
Gauge extends SimpleCollector<Gauge.Child> implements Collector.Describable { public void inc() { inc(1); } Gauge(Builder b); static Builder build(String name, String help); static Builder build(); void inc(); void inc(double amt); void dec(); void dec(double amt); void set(double val); void setToCurrentTime(); Timer startTimer(); double setToTime(Runnable timeable); E setToTime(Callable<E> timeable); double get(); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testLabels() { assertEquals(null, getLabelsValue("a")); assertEquals(null, getLabelsValue("b")); labels.labels("a").inc(); assertEquals(1.0, getLabelsValue("a").doubleValue(), .001); assertEquals(null, getLabelsValue("b")); labels.labels("b").inc(3); assertEquals(1.0, getLabelsValue("a").doubleValue(), .001); assertEquals(3.0, getLabelsValue("b").doubleValue(), .001); }
|
### Question:
Gauge extends SimpleCollector<Gauge.Child> implements Collector.Describable { @Override public List<MetricFamilySamples> collect() { List<MetricFamilySamples.Sample> samples = new ArrayList<MetricFamilySamples.Sample>(children.size()); for(Map.Entry<List<String>, Child> c: children.entrySet()) { samples.add(new MetricFamilySamples.Sample(fullname, labelNames, c.getKey(), c.getValue().get())); } return familySamplesList(Type.GAUGE, samples); } Gauge(Builder b); static Builder build(String name, String help); static Builder build(); void inc(); void inc(double amt); void dec(); void dec(double amt); void set(double val); void setToCurrentTime(); Timer startTimer(); double setToTime(Runnable timeable); E setToTime(Callable<E> timeable); double get(); @Override List<MetricFamilySamples> collect(); @Override List<MetricFamilySamples> describe(); }### Answer:
@Test public void testCollect() { labels.labels("a").inc(); List<Collector.MetricFamilySamples> mfs = labels.collect(); ArrayList<Collector.MetricFamilySamples.Sample> samples = new ArrayList<Collector.MetricFamilySamples.Sample>(); ArrayList<String> labelNames = new ArrayList<String>(); labelNames.add("l"); ArrayList<String> labelValues = new ArrayList<String>(); labelValues.add("a"); samples.add(new Collector.MetricFamilySamples.Sample("labels", labelNames, labelValues, 1.0)); Collector.MetricFamilySamples mfsFixture = new Collector.MetricFamilySamples("labels", Collector.Type.GAUGE, "help", samples); assertEquals(1, mfs.size()); assertEquals(mfsFixture, mfs.get(0)); }
|
### Question:
GraphiteNamePattern { String getPatternString() { return this.patternStr; } GraphiteNamePattern(final String pattern); }### Answer:
@Test public void createNew_WHEN_ValidPattern_THEN_ShouldInitInternalPatternSuccessfully() { final Map<String, String> validPatterns = new HashMap<String, String>(); validPatterns.put("org.test.controller.gather.status.400", "^\\Qorg.test.controller.gather.status.400\\E$"); validPatterns.put("org.test.controller.*.status.400", "^\\Qorg.test.controller.\\E([^.]*)\\Q.status.400\\E$"); validPatterns.put("org.test.controller.*.status.*", "^\\Qorg.test.controller.\\E([^.]*)\\Q.status.\\E([^.]*)\\Q\\E$"); validPatterns.put("*.test.controller.*.status.*", "^\\Q\\E([^.]*)\\Q.test.controller.\\E([^.]*)\\Q.status.\\E([^.]*)\\Q\\E$"); for (Map.Entry<String, String> expected : validPatterns.entrySet()) { final GraphiteNamePattern pattern = new GraphiteNamePattern(expected.getKey()); Assertions.assertThat(pattern.getPatternString()).isEqualTo(expected.getValue()); } }
|
### Question:
MapperConfig { public void setMatch(final String match) { validateMatch(match); this.match = match; } MapperConfig(); MapperConfig(final String match); MapperConfig(final String match, final String name, final Map<String, String> labels); @Override String toString(); String getMatch(); void setMatch(final String match); String getName(); void setName(final String name); Map<String, String> getLabels(); void setLabels(final Map<String, String> labels); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void setMatch_WHEN_ExpressionDoesnNotMatchPattern_ThrowException() { final MapperConfig mapperConfig = new MapperConfig(); mapperConfig.setMatch("com.company.meter.**.yay"); }
|
### Question:
MapperConfig { public void setLabels(final Map<String, String> labels) { validateLabels(labels); this.labels = labels; } MapperConfig(); MapperConfig(final String match); MapperConfig(final String match, final String name, final Map<String, String> labels); @Override String toString(); String getMatch(); void setMatch(final String match); String getName(); void setName(final String name); Map<String, String> getLabels(); void setLabels(final Map<String, String> labels); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void setLabels_WHEN_ExpressionDoesnNotMatchPattern_ThrowException() { final MapperConfig mapperConfig = new MapperConfig(); final Map<String, String> labels = new HashMap<String, String>(); labels.put("valid", "${0}"); labels.put("not valid", "${0}"); mapperConfig.setLabels(labels); }
|
### Question:
MapperConfig { @Override public String toString() { return String.format("MapperConfig{match=%s, name=%s, labels=%s}", match, name, labels); } MapperConfig(); MapperConfig(final String match); MapperConfig(final String match, final String name, final Map<String, String> labels); @Override String toString(); String getMatch(); void setMatch(final String match); String getName(); void setName(final String name); Map<String, String> getLabels(); void setLabels(final Map<String, String> labels); @Override boolean equals(final Object o); @Override int hashCode(); }### Answer:
@Test public void toString_WHEN_EmptyConfig_AllGood() { final MapperConfig mapperConfig = new MapperConfig(); assertEquals("MapperConfig{match=null, name=null, labels={}}", mapperConfig.toString()); }
|
### Question:
DefaultSampleBuilder implements SampleBuilder { @Override public Collector.MetricFamilySamples.Sample createSample(final String dropwizardName, final String nameSuffix, final List<String> additionalLabelNames, final List<String> additionalLabelValues, final double value) { final String suffix = nameSuffix == null ? "" : nameSuffix; final List<String> labelNames = additionalLabelNames == null ? Collections.<String>emptyList() : additionalLabelNames; final List<String> labelValues = additionalLabelValues == null ? Collections.<String>emptyList() : additionalLabelValues; return new Collector.MetricFamilySamples.Sample( Collector.sanitizeMetricName(dropwizardName + suffix), new ArrayList<String>(labelNames), new ArrayList<String>(labelValues), value ); } @Override Collector.MetricFamilySamples.Sample createSample(final String dropwizardName, final String nameSuffix, final List<String> additionalLabelNames, final List<String> additionalLabelValues, final double value); }### Answer:
@Test public void test_WHEN_NoSuffixAndExtraLabels_THEN_ShouldReturnCorrectSample() { final DefaultSampleBuilder builder = new DefaultSampleBuilder(); final Collector.MetricFamilySamples.Sample result = builder.createSample("org.github.name", null, null, null, 1d); Assert.assertEquals( new Collector.MetricFamilySamples.Sample("org_github_name", Collections.<String>emptyList(), Collections.<String>emptyList(), 1d) , result); }
@Test public void test_WHEN_SuffixAndExtraLabels_THEN_ShouldReturnCorrectSample() { final DefaultSampleBuilder builder = new DefaultSampleBuilder(); final Collector.MetricFamilySamples.Sample result = builder.createSample("org.github.name", "suffix.test", Collections.singletonList("another"), Arrays.asList("label"), 1d); Assert.assertEquals( new Collector.MetricFamilySamples.Sample("org_github_namesuffix_test", Collections.singletonList("another"), Arrays.asList("label"), 1d), result); }
|
### Question:
MethodTimer { @Around("timeable()") public Object timeMethod(ProceedingJoinPoint pjp) throws Throwable { String key = pjp.getSignature().toLongString(); Summary summary; final Lock r = summaryLock.readLock(); r.lock(); try { summary = summaries.get(key); } finally { r.unlock(); } if (summary == null) { summary = ensureSummary(pjp, key); } final Summary.Timer t = summary.startTimer(); try { return pjp.proceed(); } finally { t.observeDuration(); } } @Pointcut("@annotation(io.prometheus.client.spring.web.PrometheusTimeMethod)") void annotatedMethod(); @Pointcut("annotatedMethod()") void timeable(); @Around("timeable()") Object timeMethod(ProceedingJoinPoint pjp); }### Answer:
@Test public void timeMethod() throws Exception { Timeable cprime = new TestClass(); AspectJProxyFactory factory = new AspectJProxyFactory(cprime); factory.addAspect(MethodTimer.class); Timeable proxy = factory.getProxy(); proxy.timeMe(); final Double tot = CollectorRegistry.defaultRegistry.getSampleValue("test_class_sum"); Assert.assertNotNull(tot); assertEquals(0.02, tot, 0.01); }
|
### Question:
PlaceScoper extends GlobalListener { public void close() { okuki.removeGlobalListener(this); Toothpick.closeScope(okuki); } PlaceScoper(Okuki okuki, Module... rootModules); void close(); void inject(Object obj); T getInstance(Class<T> clazz); @Override void onPlace(Place place); }### Answer:
@Test public void testSetupAndDestroy() { verifyStatic(); Toothpick.openScope(okuki); verify(rootScope).installModules(isA(RootModule.class)); verify(okuki).addGlobalListener(placeScoper); placeScoper.close(); verifyStatic(); Toothpick.closeScope(okuki); verify(okuki).removeGlobalListener(placeScoper); }
|
### Question:
Okuki { public boolean goBack() { boolean success = false; if (history.size() > 1) { history.pop(); callPlace(history.peek()); success = true; } return success; } Okuki(); static Okuki getDefault(); void gotoPlace(Place place); void gotoPlace(Place place, HistoryAction historyAction); boolean goBack(); Place getCurrentPlace(); void addGlobalListener(GlobalListener listener); void removeGlobalListener(GlobalListener listener); void addPlaceListener(PlaceListener listener); void removePlaceListener(PlaceListener listener); void addBranchListener(final BranchListener listener); void removeBranchListener(BranchListener listener); Deque<Place> getHistory(); }### Answer:
@Test public void testGoBack() throws Exception { okuki.addGlobalListener(globalListener); gotoAllPlaces(); assertThat(okuki.goBack()).isTrue(); assertThat(okuki.goBack()).isTrue(); assertThat(okuki.goBack()).isFalse(); verify(globalListener, times(2)).onPlace(place1); verify(globalListener, times(2)).onPlace(place2); verify(globalListener).onPlace(place3); verifyNoMoreInteractions(globalListener); }
|
### Question:
RxOkuki { public static Observable<Place> onAnyPlace(Okuki okuki) { return Observable.create(new OnGlobalPlaceOnSubscribe(okuki)); } private RxOkuki(); static Observable<Place> onAnyPlace(Okuki okuki); static Observable<P> onPlace(Okuki okuki, Class<P> clazz); static Observable<Place> onBranch(Okuki okuki, Class<B> clazz); }### Answer:
@Test public void testGlobalSubscription() throws Exception { TestSubscriber<Place> testObserver = TestSubscriber.create(); RxOkuki.onAnyPlace(okuki).subscribe(testObserver); verify(okuki).addGlobalListener(isA(GlobalListener.class)); testObserver.unsubscribe(); verify(okuki).removeGlobalListener(isA(GlobalListener.class)); }
|
### Question:
RxOkuki { public static <P extends Place> Observable<P> onPlace(Okuki okuki, Class<P> clazz) { return Observable.create(new OnPlaceOnSubscribe<>(okuki, clazz)); } private RxOkuki(); static Observable<Place> onAnyPlace(Okuki okuki); static Observable<P> onPlace(Okuki okuki, Class<P> clazz); static Observable<Place> onBranch(Okuki okuki, Class<B> clazz); }### Answer:
@Test public void testPlaceSubscription() throws Exception { TestSubscriber<Place> testObserver = TestSubscriber.create(); RxOkuki.onPlace(okuki, TestPlace.class).subscribe(testObserver); verify(okuki).addPlaceListener(isA(PlaceListener.class)); testObserver.unsubscribe(); verify(okuki).removePlaceListener(isA(PlaceListener.class)); }
|
### Question:
RxOkuki { public static <B extends Place> Observable<Place> onBranch(Okuki okuki, Class<B> clazz) { return Observable.create(new OnBranchOnSubscribe<>(okuki, clazz)); } private RxOkuki(); static Observable<Place> onAnyPlace(Okuki okuki); static Observable<P> onPlace(Okuki okuki, Class<P> clazz); static Observable<Place> onBranch(Okuki okuki, Class<B> clazz); }### Answer:
@Test public void testBranchSubscription() throws Exception { TestSubscriber<Place> testObserver = TestSubscriber.create(); RxOkuki.onBranch(okuki, TestPlace.class).subscribe(testObserver); verify(okuki).addBranchListener(isA(BranchListener.class)); testObserver.unsubscribe(); verify(okuki).removeBranchListener(isA(BranchListener.class)); }
|
### Question:
RaygunSettings { public static RaygunSettings getSettings() { if (RaygunSettings.raygunSettings == null) { RaygunSettings.raygunSettings = new RaygunSettings(); } return RaygunSettings.raygunSettings; } private RaygunSettings(); static RaygunSettings getSettings(); String getApiEndPoint(); Proxy getHttpProxy(); void setHttpProxy(String host, int port); void setConnectTimeout(Integer ms); Integer getConnectTimeout(); }### Answer:
@Test public void getSettings_OnlySingletonReturned_FirstAndSecondReturnObjectsAreSame() { RaygunSettings raygunSettings1 = RaygunSettings.getSettings(); RaygunSettings raygunSettings2 = RaygunSettings.getSettings(); assertEquals(raygunSettings1, raygunSettings2); }
|
### Question:
RaygunStripWrappedExceptionFilter implements IRaygunOnBeforeSend, IRaygunSendEventFactory<IRaygunOnBeforeSend> { public IRaygunOnBeforeSend create() { return this; } RaygunStripWrappedExceptionFilter(Class<?>... stripClasses); RaygunMessage onBeforeSend(RaygunClient client, RaygunMessage message); IRaygunOnBeforeSend create(); }### Answer:
@Test public void shouldReturnSameInstanceFromCreateFactoryFunction() { RaygunStripWrappedExceptionFilter factory = new RaygunStripWrappedExceptionFilter(ClassNotFoundException.class); assertThat(factory.create(), is(factory.create())); }
|
### Question:
RaygunSendStoredExceptions implements Runnable { public void run() { if (storage == null || !storage.isDirectory()) { return; } synchronized (globalSendLock) { processFiles(); processFiles(); } } RaygunSendStoredExceptions(RaygunClient client, File storage); void run(); }### Answer:
@Test public void shouldNotThrowExceptionWhenStorageNotInitialized() { new RaygunSendStoredExceptions(client, null).run(); }
|
### Question:
RaygunSendStoredExceptions implements Runnable { void processFiles() { File[] files = storage.listFiles(new FilenameFilter() { public boolean accept(File dir, String name) { return name.endsWith(RaygunOnFailedSendOfflineStorageHandler.fileExtension); } }); if (files == null) { return; } for (File file : files) { InputStream inputStream = null; ByteArrayOutputStream outputStream = null; try { inputStream = getInputStream(file); outputStream = new ByteArrayOutputStream(); byte[] buffer = new byte[(int) file.length()]; int length; while ((length = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, length); } inputStream.close(); int reponseCode = client.send(outputStream.toString("UTF-8")); if (deleteOnStatusCodes.contains(reponseCode)) { file.delete(); } } catch (IOException e) { Logger.getLogger("Raygun4Java").warning("exception processing offline payload: " + e.getMessage()); return; } finally { if (outputStream != null) { try { outputStream.close(); } catch (IOException e) { Logger.getLogger("Raygun4Java").warning("exception closing outputStream: " + e.getMessage()); } } if (inputStream != null) { try { inputStream.close(); } catch (IOException e) { Logger.getLogger("Raygun4Java").warning("exception closing inputStream: " + e.getMessage()); } } } } } RaygunSendStoredExceptions(RaygunClient client, File storage); void run(); }### Answer:
@Test public void processFilesShouldProcessRaygunFilesOnly() throws IOException { sendStoredExceptions.processFiles(); verify(client).send("hello world"); verify(inputStream, times(2)).close(); verify(file).delete(); }
@Test public void shouldNotDeleteFileAfterA500() throws IOException { when(client.send(anyString())).thenReturn(500); sendStoredExceptions.processFiles(); verify(client).send("hello world"); verify(file, never()).delete(); }
|
### Question:
RaygunOnFailedSendOfflineStorageHandler implements IRaygunOnFailedSend, IRaygunOnBeforeSend, IRaygunSendEventFactory { public RaygunMessage onBeforeSend(RaygunClient client, RaygunMessage message) { if (enabled && hasStoredExceptions && sendingStoredExceptions == null) { synchronized (this) { if (sendingStoredExceptions == null) { sendingStoredExceptions = new RaygunSendStoredExceptions(client, this.getStorage(this.storageDir)); new Thread(new Runnable() { public void run() { sendingStoredExceptions.run(); sendingStoredExceptions = null; hasStoredExceptions = false; } }).start(); } } } return message; } RaygunOnFailedSendOfflineStorageHandler(String storageDir, String apiKey); void setEnabled(boolean enabled); RaygunMessage onBeforeSend(RaygunClient client, RaygunMessage message); String onFailedSend(RaygunClient client, String jsonPayload); IRaygunOnBeforeSend create(); }### Answer:
@Test public void shouldDefaultToHasStoredExceptionsSoThatSendsOnFirstError() throws InterruptedException { assertTrue(handler.hasStoredExceptions); handler.onBeforeSend(client, null); }
@Test public void shouldSendStoredExceptionsOnce() throws InterruptedException { handler.enabled = true; handler.hasStoredExceptions = true; RaygunMessage message = mock(RaygunMessage.class); when(storage.listFiles((FilenameFilter) anyObject())).thenReturn(new File[0]); handler.storage = storage; assertThat(handler.onBeforeSend(client, message), is(message)); Thread.sleep(200); verify(storage, times(2)).listFiles((FilenameFilter) anyObject()); assertThat(handler.onBeforeSend(client, message), is(message)); Thread.sleep(200); verify(storage, times(2)).listFiles((FilenameFilter) anyObject()); }
|
### Question:
RaygunConnection { public HttpURLConnection getConnection(String apiKey) throws IOException { HttpURLConnection connection = null; URL url = new URL(raygunSettings.getApiEndPoint()); Proxy proxy = raygunSettings.getHttpProxy(); if (proxy != null) { connection = (HttpURLConnection) url.openConnection(proxy); } else { connection = (HttpURLConnection) url.openConnection(); } if (raygunSettings.getConnectTimeout() != null) { connection.setConnectTimeout(raygunSettings.getConnectTimeout()); } connection.setDoOutput(true); connection.setRequestMethod("POST"); connection.setRequestProperty("Content-Type", "application/json"); connection.setRequestProperty("charset", "utf-8"); connection.setRequestProperty("X-ApiKey", apiKey); return connection; } RaygunConnection(RaygunSettings raygunSettings); HttpURLConnection getConnection(String apiKey); }### Answer:
@Test public void getConnection_ApiKeyIsPopulated_RequestPropertyIsSet() throws MalformedURLException, IOException { HttpURLConnection connection = this.raygunConnection.getConnection("TestKey"); assertEquals("TestKey", connection.getRequestProperty("X-ApiKey")); }
@Test public void getConnection_ProxyIsUsedWhenAvailable_ProxyTypeIsCalled() throws MalformedURLException, IOException { Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.example.org", 1234)); when(this.raygunSettings.getHttpProxy()).thenReturn(proxy); HttpURLConnection connection = this.raygunConnection.getConnection("TestKey"); assertNotNull(connection); verify(this.raygunSettings, times(2)).getHttpProxy(); }
|
### Question:
RaygunOnFailedSendOfflineStorageHandler implements IRaygunOnFailedSend, IRaygunOnBeforeSend, IRaygunSendEventFactory { File getStorage(String storageDir) { return new File(new File(storageDir).getAbsolutePath(), ".raygun_offline_storage_" + apiKeyHash).getAbsoluteFile(); } RaygunOnFailedSendOfflineStorageHandler(String storageDir, String apiKey); void setEnabled(boolean enabled); RaygunMessage onBeforeSend(RaygunClient client, RaygunMessage message); String onFailedSend(RaygunClient client, String jsonPayload); IRaygunOnBeforeSend create(); }### Answer:
@Test public void shouldCreateDifferentStorageForDifferentApiKeys() { String s1 = new RaygunOnFailedSendOfflineStorageHandler(storageDir, "myApiKey").getStorage("").getName(); String s2 = new RaygunOnFailedSendOfflineStorageHandler(storageDir, "myApiKey").getStorage("").getName(); assertEquals(s1, ".raygun_offline_storage_lxertb"); assertEquals(s2, s2); String s3 = new RaygunOnFailedSendOfflineStorageHandler(storageDir, "notMyApiKey").getStorage("").getName(); assertNotEquals(s1, s3); }
|
### Question:
RaygunClientFactory implements IRaygunClientFactory { public RaygunClientFactory withVersionFrom(Class versionFromClass) { version = raygunMessageBuilderFactory.newMessageBuilder().setVersionFrom(versionFromClass).build().getDetails().getVersion(); return this; } RaygunClientFactory(String apiKey); RaygunClientFactory withBeforeSend(IRaygunSendEventFactory<IRaygunOnBeforeSend> onBeforeSend); RaygunClientFactory withAfterSend(IRaygunSendEventFactory<IRaygunOnAfterSend> onAfterSend); RaygunClientFactory withFailedSend(IRaygunSendEventFactory<IRaygunOnFailedSend> onFailedSend); RaygunClientFactory withApiKey(String apiKey); RaygunClientFactory withVersion(String version); RaygunClientFactory withVersionFrom(Class versionFromClass); RaygunClientFactory withMessageBuilder(IRaygunMessageBuilderFactory messageBuilderFactory); RaygunClientFactory withOfflineStorage(); RaygunClientFactory withOfflineStorage(String storageDir); RaygunClientFactory withBreadcrumbLocations(); RaygunClientFactory withTag(String tag); Set<String> getTags(); void setTags(Set<String> tags); Map<?, ?> getData(); void setData(Map<?, ?> data); RaygunClientFactory withData(Object key, Object value); RaygunClientFactory withWrappedExceptionStripping(Class... stripWrappers); RaygunClientFactory withExcludedExceptions(Class... excludedWrappers); RaygunClient newClient(); T buildClient(T client); AbstractRaygunSendEventChainFactory<IRaygunOnBeforeSend> getRaygunOnBeforeSendChainFactory(); AbstractRaygunSendEventChainFactory getRaygunOnAfterSendChainFactory(); AbstractRaygunSendEventChainFactory getRaygunOnFailedSendChainFactory(); }### Answer:
@Test public void shouldConstructFactoryWithVersionDetectionFromClass() { IRaygunClientFactory factory = getFactory("apiKey").withVersionFrom(org.apache.commons.io.IOUtils.class); RaygunClient client = getClient(factory); assertEquals("2.5", client.string); assertEquals("apiKey", client.apiKey); }
|
### Question:
RaygunClientFactory implements IRaygunClientFactory { public RaygunClientFactory withVersion(String version) { this.version = version; return this; } RaygunClientFactory(String apiKey); RaygunClientFactory withBeforeSend(IRaygunSendEventFactory<IRaygunOnBeforeSend> onBeforeSend); RaygunClientFactory withAfterSend(IRaygunSendEventFactory<IRaygunOnAfterSend> onAfterSend); RaygunClientFactory withFailedSend(IRaygunSendEventFactory<IRaygunOnFailedSend> onFailedSend); RaygunClientFactory withApiKey(String apiKey); RaygunClientFactory withVersion(String version); RaygunClientFactory withVersionFrom(Class versionFromClass); RaygunClientFactory withMessageBuilder(IRaygunMessageBuilderFactory messageBuilderFactory); RaygunClientFactory withOfflineStorage(); RaygunClientFactory withOfflineStorage(String storageDir); RaygunClientFactory withBreadcrumbLocations(); RaygunClientFactory withTag(String tag); Set<String> getTags(); void setTags(Set<String> tags); Map<?, ?> getData(); void setData(Map<?, ?> data); RaygunClientFactory withData(Object key, Object value); RaygunClientFactory withWrappedExceptionStripping(Class... stripWrappers); RaygunClientFactory withExcludedExceptions(Class... excludedWrappers); RaygunClient newClient(); T buildClient(T client); AbstractRaygunSendEventChainFactory<IRaygunOnBeforeSend> getRaygunOnBeforeSendChainFactory(); AbstractRaygunSendEventChainFactory getRaygunOnAfterSendChainFactory(); AbstractRaygunSendEventChainFactory getRaygunOnFailedSendChainFactory(); }### Answer:
@Test public void shouldConstructFactoryWithSuppliedVersion() { IRaygunClientFactory factory = getFactory("apiKey").withVersion("1.2.3"); RaygunClient client = getClient(factory); assertEquals("1.2.3", client.string); assertEquals("apiKey", client.apiKey); }
|
### Question:
RaygunClientFactory implements IRaygunClientFactory { public RaygunClientFactory withBreadcrumbLocations() { this.shouldProcessBreadcrumbLocations = true; return this; } RaygunClientFactory(String apiKey); RaygunClientFactory withBeforeSend(IRaygunSendEventFactory<IRaygunOnBeforeSend> onBeforeSend); RaygunClientFactory withAfterSend(IRaygunSendEventFactory<IRaygunOnAfterSend> onAfterSend); RaygunClientFactory withFailedSend(IRaygunSendEventFactory<IRaygunOnFailedSend> onFailedSend); RaygunClientFactory withApiKey(String apiKey); RaygunClientFactory withVersion(String version); RaygunClientFactory withVersionFrom(Class versionFromClass); RaygunClientFactory withMessageBuilder(IRaygunMessageBuilderFactory messageBuilderFactory); RaygunClientFactory withOfflineStorage(); RaygunClientFactory withOfflineStorage(String storageDir); RaygunClientFactory withBreadcrumbLocations(); RaygunClientFactory withTag(String tag); Set<String> getTags(); void setTags(Set<String> tags); Map<?, ?> getData(); void setData(Map<?, ?> data); RaygunClientFactory withData(Object key, Object value); RaygunClientFactory withWrappedExceptionStripping(Class... stripWrappers); RaygunClientFactory withExcludedExceptions(Class... excludedWrappers); RaygunClient newClient(); T buildClient(T client); AbstractRaygunSendEventChainFactory<IRaygunOnBeforeSend> getRaygunOnBeforeSendChainFactory(); AbstractRaygunSendEventChainFactory getRaygunOnAfterSendChainFactory(); AbstractRaygunSendEventChainFactory getRaygunOnFailedSendChainFactory(); }### Answer:
@Test public void shouldSetBreadcrumbLocations() { RaygunClientFactory factory = getFactory("apiKey"); assertFalse(getClient(factory).shouldProcessBreadcrumbLocation()); factory.withBreadcrumbLocations(); assertTrue(getClient(factory).shouldProcessBreadcrumbLocation()); }
|
### Question:
RaygunServletClient extends RaygunClient { public void sendAsync(Throwable throwable) { sendAsync(buildMessage(throwable, null, null)); } RaygunServletClient(String apiKey, HttpServletRequest request); void sendAsync(Throwable throwable); void sendAsync(Throwable throwable, Set<String> tags); void sendAsync(Throwable throwable, Set<String> tags, Map data); void sendAsync(Throwable throwable, Map data); void sendAsyncUnhandled(Throwable throwable); void sendAsyncUnhandled(Throwable throwable, Set<String> tags); void sendAsyncUnhandled(Throwable throwable, Map data); void sendAsyncUnhandled(Throwable throwable, Set<String> tags, Map data); RaygunMessage buildMessage(Throwable throwable, Set<String> errorTags, Map errorData); IRaygunOnBeforeSend getOnBeforeSend(); void setResponse(HttpServletResponse response); }### Answer:
@Test public void post_AsyncWithInvalidKey_MinusOneReturned() { raygunClient = new RaygunServletClient("", request); try { throw new Exception("Test"); } catch (Exception e) { ((RaygunServletClient)raygunClient).sendAsync(e); } }
|
### Question:
RaygunServletFilter implements Filter { public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { try { if (servletRequest instanceof HttpServletRequest) { raygunServletFilterFacade.initializeRequest((HttpServletRequest)servletRequest); } filterChain.doFilter(servletRequest, servletResponse); } catch (Throwable ex) { if (servletResponse instanceof HttpServletResponse) { raygunServletFilterFacade.setCommittedResponse((HttpServletResponse) servletResponse); } raygunServletFilterFacade.sendUnhandled(ex); if (ex instanceof ServletException) throw (ServletException)ex; if (ex instanceof IOException) throw (IOException)ex; if (ex instanceof RuntimeException) throw (RuntimeException)ex; throw new ServletException(ex); } finally { raygunServletFilterFacade.done(); } } RaygunServletFilter(IRaygunServletFilterFacade raygunServletFilterFacade); void init(FilterConfig filterConfig); void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain); void destroy(); }### Answer:
@Test public void shouldExecuteHappyPath() throws IOException, ServletException { filter.doFilter(request, response, chain); verify(facade).initializeRequest(request); verify(chain).doFilter(request, response); verify(facade, never()).send((Throwable) anyObject()); verify(facade).done(); }
@Test(expected = ServletException.class) public void shouldHandleExceptions() throws IOException, ServletException { ServletException exception = new ServletException(); doThrow(exception).when(chain).doFilter(request, response); filter.doFilter(request, response, chain); verify(facade).initializeRequest(request); verify(chain).doFilter(request, response); verify(facade).send(exception); verify(facade).done(); }
|
### Question:
RaygunExcludeExceptionFilter implements IRaygunOnBeforeSend, IRaygunSendEventFactory<IRaygunOnBeforeSend> { public RaygunMessage onBeforeSend(RaygunClient client, RaygunMessage message) { if(message.getDetails() != null && message.getDetails().getError() != null) { RaygunErrorMessage error = message.getDetails().getError(); while(error != null && error.getThrowable() != null) { for (Class<?> excludeClass : excludeClasses) { if (excludeClass.isAssignableFrom(error.getThrowable().getClass())) { return null; } } error = error.getInnerError(); } } return message; } RaygunExcludeExceptionFilter(Class<?>... excludeClasses); RaygunMessage onBeforeSend(RaygunClient client, RaygunMessage message); IRaygunOnBeforeSend create(); }### Answer:
@Test public void shouldExcludeNestedException() { RaygunExcludeExceptionFilter f = new RaygunExcludeExceptionFilter(IllegalStateException.class); RaygunMessage message = new RaygunMessage(); message.getDetails().setError(new RaygunErrorMessage(new ClassNotFoundException("wrapper1", new IllegalStateException("wrapper2", new ClassNotFoundException("wrapper3"))))); assertNull(f.onBeforeSend(null, message)); }
@Test public void shouldNotExcludeNestedException() { RaygunExcludeExceptionFilter f = new RaygunExcludeExceptionFilter(IllegalStateException.class); RaygunMessage message = new RaygunMessage(); message.getDetails().setError(new RaygunErrorMessage(new ClassNotFoundException("wrapper1", new ClassNotFoundException("wrapper2", new ClassNotFoundException("wrapper3"))))); assertNotNull(f.onBeforeSend(null, message)); }
|
### Question:
TimeData { static byte[] exactTime256WithUpdateReason(Calendar time, byte updateReason) { int month = time.get(Calendar.MONTH) + 1; int dayOfWeek = time.get(Calendar.DAY_OF_WEEK); if (dayOfWeek == Calendar.SUNDAY) { dayOfWeek = 7; } else { dayOfWeek = dayOfWeek - 1; } int fractionsOfSecond = (int)((time).get(Calendar.MILLISECOND) * 0.255F); return ByteBuffer.allocate(10) .order(ByteOrder.LITTLE_ENDIAN) .putShort((short) time.get(Calendar.YEAR)) .put((byte) month) .put((byte) time.get(Calendar.DAY_OF_MONTH)) .put((byte) time.get(Calendar.HOUR_OF_DAY)) .put((byte) time.get(Calendar.MINUTE)) .put((byte) time.get(Calendar.SECOND)) .put((byte) dayOfWeek) .put((byte) fractionsOfSecond) .put(updateReason) .array(); } private TimeData(); }### Answer:
@Test public void exactTime256WithUpdateReason_millennium() { assertArrayEquals( new byte[]{-48, 7, 1, 1, 0, 0, 0, 6, 0, 0}, TimeData.exactTime256WithUpdateReason(utc("00:00:00 01 Jan 2000"), TimeData.UPDATE_REASON_UNKNOWN) ); }
@Test public void exactTime256WithUpdateReason_stGeorgesDay2017_manualUpdate() { assertArrayEquals( new byte[]{-31, 7, 4, 23, 13, 36, 59, 7, 0, 1}, TimeData.exactTime256WithUpdateReason(utc("13:36:59 23 Apr 2017"), TimeData.UPDATE_REASON_MANUAL) ); }
|
### Question:
TimeData { static byte[] timezoneWithDstOffset(Calendar time) { int timezone = time.get(Calendar.ZONE_OFFSET) / 1000 / 60 / 15; int dstOffset = time.get(Calendar.DST_OFFSET) / 1000 / 60 / 15; return ByteBuffer.allocate(2) .order(ByteOrder.LITTLE_ENDIAN) .put((byte) timezone) .put((byte) dstOffset) .array(); } private TimeData(); }### Answer:
@Test public void timeZoneWithDstOffset_UTC() { assertArrayEquals( new byte[] {0, 0}, TimeData.timezoneWithDstOffset(Calendar.getInstance(TimeZone.getTimeZone("UTC"))) ); }
@Test public void timeZoneWithDstOffset_SriLanka() { assertArrayEquals( new byte[] {22, 0}, TimeData.timezoneWithDstOffset(Calendar.getInstance(TimeZone.getTimeZone("Asia/Colombo"))) ); }
@Test public void timeZoneWithDstOffset_BST() { Calendar bst = Calendar.getInstance(TimeZone.getTimeZone("UTC")); bst.set(Calendar.MONTH, Calendar.JUNE); bst.set(Calendar.DST_OFFSET, ONE_HOUR); assertArrayEquals( new byte[] {0, 4}, TimeData.timezoneWithDstOffset(bst) ); }
|
### Question:
ConBeeDeviceStateChanged extends ConBeeFrameResponse { @Override public ConBeeDeviceState getDeviceState() { return state; } ConBeeDeviceStateChanged(final int[] response); @Override ConBeeDeviceState getDeviceState(); @Override String toString(); }### Answer:
@Test public void doRequest() { ConBeeDeviceStateChanged response = new ConBeeDeviceStateChanged( new int[] { 0x0E, 0x11, 0x00, 0x07, 0x00, 0xA6, 0x00, 0x34, 0xFF }); System.out.print(response); assertEquals(17, response.getSequence()); assertEquals(ConBeeStatus.SUCCESS, response.getStatus()); assertEquals(ConBeeNetworkState.NET_CONNECTED, response.getDeviceState().getNetworkState()); assertTrue(response.getDeviceState().isDataConfirm()); assertFalse(response.getDeviceState().isDataIndication()); assertTrue(response.getDeviceState().isDataRequest()); assertFalse(response.getDeviceState().isConfigChanged()); }
|
### Question:
ExtendedPanId { public boolean isValid() { if (panId == null || panId.length != 8) { return false; } int cnt0 = 0; int cntF = 0; for (int val : panId) { if (val == 0x00) { cnt0++; } if (val == 0xFF) { cntF++; } } return !(cnt0 == 8 || cntF == 8); } ExtendedPanId(); ExtendedPanId(BigInteger panId); ExtendedPanId(String panId); ExtendedPanId(int[] panId); int[] getValue(); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ExtendedPanId createRandom(); }### Answer:
@Test public void testValid() { ExtendedPanId address = new ExtendedPanId("17880100dc880b"); assertTrue(address.isValid()); address = new ExtendedPanId(); assertFalse(address.isValid()); address = new ExtendedPanId("0000000000000000"); assertFalse(address.isValid()); address = new ExtendedPanId("FFFFFFFFFFFFFFFF"); assertFalse(address.isValid()); }
|
### Question:
ExtendedPanId { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(panId); return result; } ExtendedPanId(); ExtendedPanId(BigInteger panId); ExtendedPanId(String panId); ExtendedPanId(int[] panId); int[] getValue(); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ExtendedPanId createRandom(); }### Answer:
@Test public void testHash() { ExtendedPanId address1 = new ExtendedPanId("17880100dc880b"); ExtendedPanId address2 = new ExtendedPanId("17880100dc880b"); assertEquals(address1.hashCode(), address2.hashCode()); }
|
### Question:
ExtendedPanId { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } ExtendedPanId other = (ExtendedPanId) obj; return Arrays.equals(panId, other.panId); } ExtendedPanId(); ExtendedPanId(BigInteger panId); ExtendedPanId(String panId); ExtendedPanId(int[] panId); int[] getValue(); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ExtendedPanId createRandom(); }### Answer:
@Test public void testEquals() { ExtendedPanId address1 = new ExtendedPanId("17880100dc880b"); ExtendedPanId address2 = new ExtendedPanId("17880100dc880b"); assertTrue(address1.equals(address2)); }
|
### Question:
ExtendedPanId { @Override public String toString() { StringBuilder builder = new StringBuilder(); for (int cnt = 7; cnt >= 0; cnt--) { builder.append(String.format("%02X", panId[cnt])); } return builder.toString(); } ExtendedPanId(); ExtendedPanId(BigInteger panId); ExtendedPanId(String panId); ExtendedPanId(int[] panId); int[] getValue(); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ExtendedPanId createRandom(); }### Answer:
@Test public void testToString() { ExtendedPanId address = new ExtendedPanId("17880100dc880b"); assertEquals("0017880100DC880B", address.toString()); }
@Test public void testConstructorBigInteger() { ExtendedPanId address = new ExtendedPanId(new BigInteger("0017880100DC880B", 16)); assertEquals("0017880100DC880B", address.toString()); }
@Test public void testConstructorArray() { ExtendedPanId address = new ExtendedPanId(new int[] { 0x0b, 0x88, 0xdc, 0x00, 0x01, 0x88, 0x17, 0x00 }); assertEquals("0017880100DC880B", address.toString()); }
@Test public void testConstructorString() { ExtendedPanId address = new ExtendedPanId("17880100dc880b"); assertEquals("0017880100DC880B", address.toString()); address = new ExtendedPanId("8418260000D9959B"); assertEquals("8418260000D9959B", address.toString()); }
|
### Question:
ExtendedPanId { public static ExtendedPanId createRandom() { int key[] = new int[8]; for (int cnt = 0; cnt < 8; cnt++) { key[cnt] = (int) Math.floor((Math.random() * 255)); } return new ExtendedPanId(key); } ExtendedPanId(); ExtendedPanId(BigInteger panId); ExtendedPanId(String panId); ExtendedPanId(int[] panId); int[] getValue(); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ExtendedPanId createRandom(); }### Answer:
@Test public void createRandom() { ExtendedPanId pan1 = ExtendedPanId.createRandom(); ExtendedPanId pan2 = ExtendedPanId.createRandom(); assertNotEquals(pan1, pan2); }
|
### Question:
ZigBeeNodeDao { public void setNetworkAddress(Integer networkAddress) { this.networkAddress = networkAddress; } IeeeAddress getIeeeAddress(); void setIeeeAddress(IeeeAddress ieeeAddress); Integer getNetworkAddress(); void setNetworkAddress(Integer networkAddress); NodeDescriptor getNodeDescriptor(); void setNodeDescriptor(NodeDescriptor nodeDescriptor); PowerDescriptor getPowerDescriptor(); void setPowerDescriptor(PowerDescriptor powerDescriptor); void setEndpoints(List<ZigBeeEndpointDao> endpointDaoList); List<ZigBeeEndpointDao> getEndpoints(); void setBindingTable(Set<BindingTable> bindingTable); Set<BindingTable> getBindingTable(); }### Answer:
@Test public void testSerialize() { ZigBeeTransportTransmit mockedTransport = Mockito.mock(ZigBeeTransportTransmit.class); ZigBeeNetworkManager networkManager = new ZigBeeNetworkManager(mockedTransport); ZigBeeNode node = new ZigBeeNode(networkManager, new IeeeAddress("1234567890ABCDEF")); node.setNetworkAddress(12345); ZigBeeEndpoint endpoint; endpoint = new ZigBeeEndpoint(node, 1); endpoint.setProfileId(123); node.addEndpoint(endpoint); endpoint = new ZigBeeEndpoint(node, 2); endpoint.setProfileId(321); node.addEndpoint(endpoint); }
|
### Question:
ZigBeeCbkeCertificate { protected int[] hexStringToIntArray(String hexString) { if (hexString.length() % 2 != 0) { throw new IllegalArgumentException( "Certificate string '" + hexString + "' must be even number of bytes long."); } int[] output = new int[hexString.length() / 2]; char enc[] = hexString.toCharArray(); for (int i = 0; i < enc.length - 1; i += 2) { StringBuilder curr = new StringBuilder(2); curr.append(enc[i]).append(enc[i + 1]); output[i / 2] = Integer.parseInt(curr.toString(), 16); } return output; } ZigBeeCryptoSuites getCryptoSuite(); int[] getCertificate(); int[] getPrivateKey(); int[] getCaPublicKey(); }### Answer:
@Test public void hexStringToIntArray() { ZigBeeCbkeCertificate certificate = Mockito.mock(ZigBeeCbkeCertificate.class, Mockito.CALLS_REAL_METHODS); assertTrue(Arrays.equals(new int[] { 0x12, 0x34, 0x56, 0x78 }, certificate.hexStringToIntArray("12345678"))); }
|
### Question:
ZigBeeKey { public boolean isValid() { if (key == null || key.length != 16) { return false; } int cnt0 = 0; for (int val : key) { if (val == 0x00) { cnt0++; } } return (cnt0 != 16); } ZigBeeKey(); ZigBeeKey(String key); ZigBeeKey(int[] key); int[] getValue(); boolean hasIncomingFrameCounter(); boolean hasOutgoingFrameCounter(); boolean hasSequenceNumber(); boolean hasAddress(); IeeeAddress getAddress(); void setAddress(IeeeAddress address); Integer getIncomingFrameCounter(); void setIncomingFrameCounter(Integer counter); Integer getOutgoingFrameCounter(); void setOutgoingFrameCounter(Integer counter); Integer getSequenceNumber(); void setSequenceNumber(Integer counter); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ZigBeeKey createRandom(); }### Answer:
@Test public void testValid() { ZigBeeKey key = new ZigBeeKey("11223344556677889900AABBCCDDEEFF"); assertTrue(key.isValid()); key = new ZigBeeKey("00000000000000000000000000000000"); assertFalse(key.isValid()); }
|
### Question:
ZigBeeKey { @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + Arrays.hashCode(key); return result; } ZigBeeKey(); ZigBeeKey(String key); ZigBeeKey(int[] key); int[] getValue(); boolean hasIncomingFrameCounter(); boolean hasOutgoingFrameCounter(); boolean hasSequenceNumber(); boolean hasAddress(); IeeeAddress getAddress(); void setAddress(IeeeAddress address); Integer getIncomingFrameCounter(); void setIncomingFrameCounter(Integer counter); Integer getOutgoingFrameCounter(); void setOutgoingFrameCounter(Integer counter); Integer getSequenceNumber(); void setSequenceNumber(Integer counter); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ZigBeeKey createRandom(); }### Answer:
@Test public void testHash() { ZigBeeKey key1 = new ZigBeeKey("11223344556677889900AABBCCDDEEFF"); ZigBeeKey key2 = new ZigBeeKey("11223344556677889900AABBCCDDEEFF"); assertEquals(key1.hashCode(), key2.hashCode()); }
|
### Question:
ZigBeeKey { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } ZigBeeKey other = (ZigBeeKey) obj; return Arrays.equals(key, other.key); } ZigBeeKey(); ZigBeeKey(String key); ZigBeeKey(int[] key); int[] getValue(); boolean hasIncomingFrameCounter(); boolean hasOutgoingFrameCounter(); boolean hasSequenceNumber(); boolean hasAddress(); IeeeAddress getAddress(); void setAddress(IeeeAddress address); Integer getIncomingFrameCounter(); void setIncomingFrameCounter(Integer counter); Integer getOutgoingFrameCounter(); void setOutgoingFrameCounter(Integer counter); Integer getSequenceNumber(); void setSequenceNumber(Integer counter); boolean isValid(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); static ZigBeeKey createRandom(); }### Answer:
@Test public void testEquals() { ZigBeeKey key1 = new ZigBeeKey("11223344556677889900AABBCCDDEEFF"); ZigBeeKey key2 = new ZigBeeKey("11223344556677889900AABBCCDDEEFF"); assertTrue(key1.equals(key2)); }
|
### Question:
IeeeAddress implements Comparable<IeeeAddress> { @Override public String toString() { StringBuilder builder = new StringBuilder(); for (int cnt = 7; cnt >= 0; cnt--) { builder.append(String.format("%02X", address[cnt])); } return builder.toString(); } IeeeAddress(); IeeeAddress(BigInteger address); IeeeAddress(String address); IeeeAddress(int[] address); int[] getValue(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(IeeeAddress other); }### Answer:
@Test public void testConstructorArray() { IeeeAddress address = new IeeeAddress(new int[] { 0x0b, 0x88, 0xdc, 0x00, 0x01, 0x88, 0x17, 0x00 }); assertEquals("0017880100DC880B", address.toString()); }
@Test public void testConstructorString() { IeeeAddress address = new IeeeAddress("17880100dc880b"); assertEquals("0017880100DC880B", address.toString()); address = new IeeeAddress("8418260000D9959B"); assertEquals("8418260000D9959B", address.toString()); }
@Test public void testToString() { IeeeAddress address = new IeeeAddress("17880100dc880b"); assertEquals("0017880100DC880B", address.toString()); }
|
### Question:
IeeeAddress implements Comparable<IeeeAddress> { @Override public int hashCode() { return Objects.hash(address[0], address[1], address[2], address[3], address[4], address[5], address[6], address[7]); } IeeeAddress(); IeeeAddress(BigInteger address); IeeeAddress(String address); IeeeAddress(int[] address); int[] getValue(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(IeeeAddress other); }### Answer:
@Test public void testHash() { IeeeAddress address1 = new IeeeAddress("17880100dc880b"); IeeeAddress address2 = new IeeeAddress("17880100dc880b"); assertEquals(address1.hashCode(), address2.hashCode()); }
|
### Question:
IeeeAddress implements Comparable<IeeeAddress> { @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (!IeeeAddress.class.isAssignableFrom(obj.getClass())) { return false; } final IeeeAddress other = (IeeeAddress) obj; for (int cnt = 0; cnt < 8; cnt++) { if (other.getValue()[cnt] != address[cnt]) { return false; } } return true; } IeeeAddress(); IeeeAddress(BigInteger address); IeeeAddress(String address); IeeeAddress(int[] address); int[] getValue(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(IeeeAddress other); }### Answer:
@Test public void testEquals() { IeeeAddress address1 = new IeeeAddress("17880100dc880b"); IeeeAddress address2 = new IeeeAddress("17880100dc880b"); assertTrue(address1.equals(address2)); }
|
### Question:
IeeeAddress implements Comparable<IeeeAddress> { @Override public int compareTo(IeeeAddress other) { if (other == null) { return -1; } if (!IeeeAddress.class.isAssignableFrom(other.getClass())) { return -1; } for (int cnt = 0; cnt < 8; cnt++) { if (other.getValue()[cnt] == address[cnt]) { continue; } return other.getValue()[cnt] < address[cnt] ? 1 : -1; } return 0; } IeeeAddress(); IeeeAddress(BigInteger address); IeeeAddress(String address); IeeeAddress(int[] address); int[] getValue(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override int compareTo(IeeeAddress other); }### Answer:
@Test public void testCompareTo() { IeeeAddress address1 = new IeeeAddress("17880100dc880b"); IeeeAddress address2 = new IeeeAddress("17880100dc880b"); assertEquals(0, address1.compareTo(address2)); address2 = new IeeeAddress("17880100dc880c"); assertEquals(-1, address1.compareTo(address2)); address2 = new IeeeAddress("17880100dc880a"); assertEquals(1, address1.compareTo(address2)); address2 = new IeeeAddress("27880100dc880c"); assertEquals(-1, address1.compareTo(address2)); address2 = new IeeeAddress("17880120dc880c"); assertEquals(-1, address1.compareTo(address2)); address2 = new IeeeAddress("16880100dc880b"); assertEquals(1, address1.compareTo(address2)); }
|
### Question:
NodeDescriptor { public int getStackCompliance() { return stackCompliance; } NodeDescriptor(); NodeDescriptor(int apsFlags, int bufferSize, int macCapabilities, boolean complexDescriptorAvailable,
int manufacturerCode, int logicalType, int serverMask, int transferSize, boolean userDescriptorAvailable,
int frequencyBands); int getApsFlags(); int getBufferSize(); Set<MacCapabilitiesType> getMacCapabilities(); int getManufacturerCode(); boolean isComplexDescriptorAvailable(); boolean isExtendedEndpointListAvailable(); boolean isExtendedSimpleDescriptorListAvailable(); LogicalType getLogicalType(); Set<ServerCapabilitiesType> getServerCapabilities(); int getOutGoingTransferSize(); int getIncomingTransferSize(); boolean isUserDescriptorAvailable(); Set<FrequencyBandType> getFrequencyBands(); int[] serialize(ZclFieldSerializer serializer); void deserialize(ZigBeeDeserializer deserializer); @Override int hashCode(); @Override boolean equals(Object obj); int getStackCompliance(); @Override String toString(); }### Answer:
@Test public void testNodeDescriptorR21() { NodeDescriptor descriptor = new NodeDescriptor(0, 0, 0, true, 0, 0, 0x2A00, 0, true, 0); assertEquals(21, descriptor.getStackCompliance()); }
|
### Question:
ManagementPermitJoiningRequest extends ZdoRequest implements ZigBeeTransactionMatcher { @Override public void serialize(final ZclFieldSerializer serializer) { super.serialize(serializer); serializer.serialize(permitDuration, ZclDataType.UNSIGNED_8_BIT_INTEGER); serializer.serialize(tcSignificance, ZclDataType.BOOLEAN); } @Deprecated ManagementPermitJoiningRequest(); ManagementPermitJoiningRequest(
Integer permitDuration,
Boolean tcSignificance); Integer getPermitDuration(); @Deprecated void setPermitDuration(final Integer permitDuration); Boolean getTcSignificance(); @Deprecated void setTcSignificance(final Boolean tcSignificance); @Override void serialize(final ZclFieldSerializer serializer); @Override void deserialize(final ZclFieldDeserializer deserializer); @Override boolean isTransactionMatch(ZigBeeCommand request, ZigBeeCommand response); @Override String toString(); static int CLUSTER_ID; }### Answer:
@Test public void testReceive() { int[] packet = getPacketData("00 FF 01"); ManagementPermitJoiningRequest request = new ManagementPermitJoiningRequest(255, true); request.setDestinationAddress(new ZigBeeEndpointAddress(0)); DefaultSerializer serializer = new DefaultSerializer(); ZclFieldSerializer fieldSerializer = new ZclFieldSerializer(serializer); request.serialize(fieldSerializer); assertTrue(Arrays.equals(packet, serializer.getPayload())); }
|
### Question:
ZigBeeNetworkDiscoverer implements ZigBeeCommandListener, ZigBeeAnnounceListener { @Override public void deviceStatusUpdate(final ZigBeeNodeStatus deviceStatus, final Integer networkAddress, final IeeeAddress ieeeAddress) { switch (deviceStatus) { case UNSECURED_JOIN: case SECURED_REJOIN: case UNSECURED_REJOIN: logger.debug("{}: Device status updated. NWK={}", ieeeAddress, String.format("%04X", networkAddress)); addNode(ieeeAddress, networkAddress); break; default: break; } } protected ZigBeeNetworkDiscoverer(final ZigBeeNetworkManager networkManager); @Override void deviceStatusUpdate(final ZigBeeNodeStatus deviceStatus, final Integer networkAddress,
final IeeeAddress ieeeAddress); @Override void announceUnknownDevice(final Integer networkAddress); @Override void commandReceived(final ZigBeeCommand command); }### Answer:
@Test public void deviceStatusUpdate() { ZigBeeNetworkDiscoverer discoverer = new ZigBeeNetworkDiscoverer(networkManager); discoverer.setRetryPeriod(0); discoverer.setRequeryPeriod(0); discoverer.setRetryCount(0); discoverer.deviceStatusUpdate(ZigBeeNodeStatus.UNSECURED_JOIN, 2222, new IeeeAddress("1111111111111111")); Mockito.verify(networkManager, Mockito.times(1)).updateNode(ArgumentMatchers.any()); }
|
### Question:
SmartEnergyClient implements ZigBeeNetworkExtension, ZigBeeCommandListener, ZigBeeNetworkNodeListener,
ZigBeeNetworkStateListener { @Override public void networkStateUpdated(ZigBeeNetworkState state) { switch (state) { case ONLINE: discoveryStart(); break; case OFFLINE: discoveryStop(); break; default: break; } } SmartEnergyClient(ZigBeeCbkeProvider cbkeProvider); @Override ZigBeeStatus extensionInitialize(ZigBeeNetworkManager networkManager); @Override ZigBeeStatus extensionStartup(); @Override void extensionShutdown(); ZigBeeCbkeProvider getCbkeProvider(); boolean setCryptoSuite(ZigBeeCryptoSuites requestedCryptoSuite); void addListener(final SmartEnergyStatusCallback listener); void removeListener(final SmartEnergyStatusCallback listener); void setKeepAlivePeriod(int timeout); Calendar getLastKeepAlive(); ZigBeeStatus startKeyExchange(ZigBeeEndpointAddress endpoint); @Override void commandReceived(ZigBeeCommand command); @Override void networkStateUpdated(ZigBeeNetworkState state); SmartEnergyClientState getDiscoveryState(); @Override void nodeAdded(ZigBeeNode node); @Override void nodeUpdated(ZigBeeNode node); }### Answer:
@Test public void networkStateUpdated() { System.out.println("--- " + Thread.currentThread().getStackTrace()[1].getMethodName()); SmartEnergyClient extension = new SmartEnergyClient(Mockito.mock(ZigBeeCbkeProvider.class)); ZigBeeNetworkManager networkManager = Mockito.mock(ZigBeeNetworkManager.class); Mockito.when(networkManager.getNotificationService()).thenReturn(new NotificationService()); assertEquals(ZigBeeStatus.SUCCESS, extension.extensionInitialize(networkManager)); SmartEnergyStatusCallback listener = Mockito.mock(SmartEnergyStatusCallback.class); extension.addListener(listener); extension.networkStateUpdated(ZigBeeNetworkState.ONLINE); extension.networkStateUpdated(ZigBeeNetworkState.OFFLINE); }
|
### Question:
CommandResult { public boolean isSuccess() { return !(isTimeout() || isError()); } @Deprecated CommandResult(final ZigBeeCommand response); CommandResult(final ZigBeeStatus commandSentSuccessfully, final ZigBeeCommand response); @Deprecated CommandResult(); boolean isSuccess(); boolean isTimeout(); boolean isError(); Integer getStatusCode(); ZigBeeCommand getResponse(); @Override String toString(); }### Answer:
@Test public void testIsSuccessIfResponseReceived() { CommandResult commandResult = new CommandResult(ZigBeeStatus.SUCCESS, new ZoneEnrollResponse(1, 2)); assertTrue(commandResult.isSuccess()); commandResult = new CommandResult(ZigBeeStatus.SUCCESS, new DefaultResponse(1, ZclStatus.SUCCESS)); assertTrue(commandResult.isSuccess()); commandResult = new CommandResult(ZigBeeStatus.SUCCESS, new DefaultResponse(1, ZclStatus.FAILURE)); assertFalse(commandResult.isSuccess()); }
@Test public void testIsSuccessIfNoResponseReceived() { CommandResult commandResult = new CommandResult(ZigBeeStatus.SUCCESS, null); assertTrue(commandResult.isSuccess()); commandResult = new CommandResult(ZigBeeStatus.FAILURE, null); assertFalse(commandResult.isSuccess()); }
|
### Question:
CommandResult { public boolean isError() { if (commandSentSuccessfully == ZigBeeStatus.SUCCESS) { if (hasStatusCode()) { return getStatusCode() != 0; } else { return false; } } else { return true; } } @Deprecated CommandResult(final ZigBeeCommand response); CommandResult(final ZigBeeStatus commandSentSuccessfully, final ZigBeeCommand response); @Deprecated CommandResult(); boolean isSuccess(); boolean isTimeout(); boolean isError(); Integer getStatusCode(); ZigBeeCommand getResponse(); @Override String toString(); }### Answer:
@Test public void testIsErrorIfResponseReceived() { CommandResult commandResult = new CommandResult(ZigBeeStatus.SUCCESS, new ZoneEnrollResponse(1, 2)); assertFalse(commandResult.isError()); commandResult = new CommandResult(ZigBeeStatus.SUCCESS, new DefaultResponse(1, ZclStatus.SUCCESS)); assertFalse(commandResult.isError()); commandResult = new CommandResult(ZigBeeStatus.SUCCESS, new DefaultResponse(1, ZclStatus.FAILURE)); assertTrue(commandResult.isError()); }
@Test public void testIsErrorIfNoResponseReceived() { CommandResult commandResult = new CommandResult(ZigBeeStatus.SUCCESS, null); assertFalse(commandResult.isError()); commandResult = new CommandResult(ZigBeeStatus.FAILURE, null); assertTrue(commandResult.isError()); }
|
### Question:
CommandResult { public boolean isTimeout() { return commandSentSuccessfully != ZigBeeStatus.SUCCESS; } @Deprecated CommandResult(final ZigBeeCommand response); CommandResult(final ZigBeeStatus commandSentSuccessfully, final ZigBeeCommand response); @Deprecated CommandResult(); boolean isSuccess(); boolean isTimeout(); boolean isError(); Integer getStatusCode(); ZigBeeCommand getResponse(); @Override String toString(); }### Answer:
@Test public void testIsTimeoutIfResponseReceived() { CommandResult commandResult = new CommandResult(ZigBeeStatus.SUCCESS, new ZoneEnrollResponse(1, 2)); assertFalse(commandResult.isTimeout()); }
@Test public void testIsTimeoutIfNoResponseReceived() { CommandResult commandResult = new CommandResult(ZigBeeStatus.FAILURE, null); assertTrue(commandResult.isTimeout()); }
|
### Question:
ZigBeeTransaction { public void setTransactionId(int transactionId) { command.setTransactionId(transactionId); } ZigBeeTransaction(ZigBeeTransactionManager transactionManager, final ZigBeeCommand command,
final ZigBeeTransactionMatcher responseMatcher); void setTransactionId(int transactionId); Integer getTransactionId(); int getTimerPeriod1(); void setTimerPeriod1(int timeout); int getTimerPeriod2(); void setTimerPeriod2(int timeout); IeeeAddress getIeeeAddress(); void setIeeeAddress(IeeeAddress ieeeAddress); void commandReceived(ZigBeeCommand receivedCommand); void transactionStatusReceived(ZigBeeTransportProgressState progress, int transactionId); @Override String toString(); }### Answer:
@Test public void setTransactionId() { ZigBeeTransaction transaction = new ZigBeeTransaction(null, new OffCommand(), null); assertNull(transaction.getTransactionId()); transaction.setTransactionId(1); assertEquals(Integer.valueOf(1), transaction.getTransactionId()); }
|
### Question:
ZigBeeTransaction { public void setIeeeAddress(IeeeAddress ieeeAddress) { this.ieeeAddress = ieeeAddress; } ZigBeeTransaction(ZigBeeTransactionManager transactionManager, final ZigBeeCommand command,
final ZigBeeTransactionMatcher responseMatcher); void setTransactionId(int transactionId); Integer getTransactionId(); int getTimerPeriod1(); void setTimerPeriod1(int timeout); int getTimerPeriod2(); void setTimerPeriod2(int timeout); IeeeAddress getIeeeAddress(); void setIeeeAddress(IeeeAddress ieeeAddress); void commandReceived(ZigBeeCommand receivedCommand); void transactionStatusReceived(ZigBeeTransportProgressState progress, int transactionId); @Override String toString(); }### Answer:
@Test public void setIeeeAddress() { ZigBeeTransaction transaction = new ZigBeeTransaction(null, new OffCommand(), null); assertNull(transaction.getIeeeAddress()); IeeeAddress address = new IeeeAddress(); transaction.setIeeeAddress(address); assertEquals(address, transaction.getIeeeAddress()); }
|
### Question:
ZigBeeTransactionFuture implements Future<CommandResult> { @Override public synchronized boolean isDone() { return cancelled | result != null; } ZigBeeTransactionFuture(ZigBeeTransaction transaction); synchronized void set(final CommandResult result); @Override synchronized boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override synchronized boolean isDone(); @Override CommandResult get(); @Override CommandResult get(long timeout, TimeUnit unit); @Override String toString(); }### Answer:
@Test public void testIsDone() throws InterruptedException, ExecutionException, TimeoutException { ZigBeeTransactionFuture future = new ZigBeeTransactionFuture(Mockito.mock(ZigBeeTransaction.class)); assertFalse(future.isDone()); CommandResult result = new CommandResult(ZigBeeStatus.FAILURE, null); future.set(result); assertTrue(future.isDone()); assertEquals(result, future.get()); assertEquals(result, future.get(0, TimeUnit.MICROSECONDS)); }
|
### Question:
ZigBeeTransactionFuture implements Future<CommandResult> { @Override public synchronized boolean cancel(boolean mayInterruptIfRunning) { if (result != null || cancelled) { return false; } cancelled = true; transaction.cancel(); notifyAll(); return true; } ZigBeeTransactionFuture(ZigBeeTransaction transaction); synchronized void set(final CommandResult result); @Override synchronized boolean cancel(boolean mayInterruptIfRunning); @Override boolean isCancelled(); @Override synchronized boolean isDone(); @Override CommandResult get(); @Override CommandResult get(long timeout, TimeUnit unit); @Override String toString(); }### Answer:
@Test public void testCancel() { ZigBeeTransaction transaction = Mockito.mock(ZigBeeTransaction.class); ZigBeeTransactionFuture future = new ZigBeeTransactionFuture(transaction); assertFalse(future.isCancelled()); assertTrue(future.cancel(true)); Mockito.verify(transaction, Mockito.timeout(TIMEOUT).times(1)).cancel(); assertFalse(future.cancel(true)); Mockito.verify(transaction, Mockito.timeout(TIMEOUT).times(1)).cancel(); assertTrue(future.isCancelled()); }
|
### Question:
ZigBeeEndpointAddress extends ZigBeeAddress { @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (!ZigBeeEndpointAddress.class.isAssignableFrom(obj.getClass())) { return false; } final ZigBeeEndpointAddress other = (ZigBeeEndpointAddress) obj; return (other.getAddress() == getAddress() && other.getEndpoint() == getEndpoint()); } ZigBeeEndpointAddress(int address); ZigBeeEndpointAddress(int address, int endpoint); ZigBeeEndpointAddress(String address); @Override int getAddress(); @Override void setAddress(final int address); @Override boolean isGroup(); int getEndpoint(); void setEndpoint(final int endpoint); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(ZigBeeAddress that); @Override String toString(); }### Answer:
@Test public void testEquals() { ZigBeeEndpointAddress address1 = new ZigBeeEndpointAddress("25000/33"); ZigBeeEndpointAddress address2 = new ZigBeeEndpointAddress("25000/33"); assertTrue(address1.equals(address2)); ZigBeeEndpointAddress address3 = new ZigBeeEndpointAddress("25001/33"); assertFalse(address1.equals(address3)); ZigBeeEndpointAddress address4 = new ZigBeeEndpointAddress(25000, 33); assertTrue(address1.equals(address4)); }
|
### Question:
ZigBeeEndpointAddress extends ZigBeeAddress { @Override public boolean isGroup() { return false; } ZigBeeEndpointAddress(int address); ZigBeeEndpointAddress(int address, int endpoint); ZigBeeEndpointAddress(String address); @Override int getAddress(); @Override void setAddress(final int address); @Override boolean isGroup(); int getEndpoint(); void setEndpoint(final int endpoint); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(ZigBeeAddress that); @Override String toString(); }### Answer:
@Test public void testIsGroup() { ZigBeeEndpointAddress address = new ZigBeeEndpointAddress("25000/33"); assertFalse(address.isGroup()); }
|
### Question:
ZigBeeEndpointAddress extends ZigBeeAddress { @Override public String toString() { return String.format("%04X/%d", address, endpoint); } ZigBeeEndpointAddress(int address); ZigBeeEndpointAddress(int address, int endpoint); ZigBeeEndpointAddress(String address); @Override int getAddress(); @Override void setAddress(final int address); @Override boolean isGroup(); int getEndpoint(); void setEndpoint(final int endpoint); @Override int hashCode(); @Override boolean equals(Object obj); @Override int compareTo(ZigBeeAddress that); @Override String toString(); }### Answer:
@Test public void testToString() { String stringAddress = "25000/44"; ZigBeeEndpointAddress address = new ZigBeeEndpointAddress(stringAddress); assertEquals("61A8/44", address.toString()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.