@Test public void testCompute() { ConstantPostAggregator constantPostAggregator; constantPostAggregator = new ConstantPostAggregator("shichi", 7); Assert.assertEquals(7, constantPostAggregator.compute(null)); constantPostAggregator = new ConstantPostAggregator("rei", 0.0); Assert.assertEquals(0.0, constantPostAggregator.compute(null)); constantPostAggregator = new ConstantPostAggregator("ichi", 1.0); Assert.assertNotSame(1, constantPostAggregator.compute(null)); }
new ConstantPostAggregator("", 0) ); @SuppressWarnings("ObjectEqualsNull") new ConstantPostAggregator("", 0) ); Assert.assertTrue(postAgg1.equals(postAgg2)); new ConstantPostAggregator("", 1) ); Assert.assertFalse(postAgg1.equals(postAgg3)); new ConstantPostAggregator("", 0) ); Assert.assertFalse(postAgg1.equals(postAgg4)); new ConstantPostAggregator("", 0) ); Assert.assertFalse(postAgg1.equals(postAgg5));
new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("2", 2L) new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("4", 4L)
new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("2", 2L) new ConstantPostAggregator("1", 1L), new ConstantPostAggregator("4", 4L)
@Test public void testComparator() { ConstantPostAggregator constantPostAggregator = new ConstantPostAggregator("thistestbasicallydoesnothing unhappyface", 1); Comparator comp = constantPostAggregator.getComparator(); Assert.assertEquals(0, comp.compare(0, constantPostAggregator.compute(null))); Assert.assertEquals(0, comp.compare(0, 1)); Assert.assertEquals(0, comp.compare(1, 0)); }
@Test public void testComputedInArithmeticPostAggregator() { String aggName = "billy"; AggregatorFactory aggFactory = EasyMock.createMock(AggregatorFactory.class); EasyMock.expect(aggFactory.getComparator()).andReturn(Comparators.naturalNullsFirst()).once(); EasyMock.expect(aggFactory.finalizeComputation("test")).andReturn(3L).once(); EasyMock.replay(aggFactory); FinalizingFieldAccessPostAggregator postAgg = buildDecorated( "final_billy", aggName, ImmutableMap.of(aggName, aggFactory) ); Map<String, Object> metricValues = new HashMap<>(); metricValues.put(aggName, "test"); List<PostAggregator> postAggsList = Lists.newArrayList( new ConstantPostAggregator("roku", 6), postAgg); ArithmeticPostAggregator arithmeticPostAggregator = new ArithmeticPostAggregator("add", "+", postAggsList); Assert.assertEquals(new Double(9.0f), arithmeticPostAggregator.compute(metricValues)); EasyMock.verify(); }
@Test public void testNumericFirstOrdering() { ArithmeticPostAggregator agg = new ArithmeticPostAggregator( null, "quotient", ImmutableList.of( new ConstantPostAggregator("zero", 0), new ConstantPostAggregator("zero", 0) ), "numericFirst" ); final Comparator numericFirst = agg.getComparator(); Assert.assertTrue(numericFirst.compare(Double.NaN, 0.0) < 0); Assert.assertTrue(numericFirst.compare(Double.POSITIVE_INFINITY, 0.0) < 0); Assert.assertTrue(numericFirst.compare(Double.NEGATIVE_INFINITY, 0.0) < 0); Assert.assertTrue(numericFirst.compare(0.0, Double.NaN) > 0); Assert.assertTrue(numericFirst.compare(0.0, Double.POSITIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(0.0, Double.NEGATIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY) < 0); Assert.assertTrue(numericFirst.compare(Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.NaN, Double.POSITIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.NaN, Double.NEGATIVE_INFINITY) > 0); Assert.assertTrue(numericFirst.compare(Double.POSITIVE_INFINITY, Double.NaN) < 0); Assert.assertTrue(numericFirst.compare(Double.NEGATIVE_INFINITY, Double.NaN) < 0); } }
@Test public void testDiv() { ArithmeticPostAggregator agg = new ArithmeticPostAggregator( null, "/", ImmutableList.of( new FieldAccessPostAggregator("numerator", "value"), new ConstantPostAggregator("denomiator", 0) ) ); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", 0))); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", Double.NaN))); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", 1))); Assert.assertEquals(0.0, agg.compute(ImmutableMap.of("value", -1))); }
@Test public void testQuotient() { ArithmeticPostAggregator agg = new ArithmeticPostAggregator( null, "quotient", ImmutableList.of( new FieldAccessPostAggregator("numerator", "value"), new ConstantPostAggregator("zero", 0) ), "numericFirst" ); Assert.assertEquals(Double.NaN, agg.compute(ImmutableMap.of("value", 0))); Assert.assertEquals(Double.NaN, agg.compute(ImmutableMap.of("value", Double.NaN))); Assert.assertEquals(Double.POSITIVE_INFINITY, agg.compute(ImmutableMap.of("value", 1))); Assert.assertEquals(Double.NEGATIVE_INFINITY, agg.compute(ImmutableMap.of("value", -1))); }
@Test public void testSerde() throws Exception { DefaultObjectMapper mapper = new DefaultObjectMapper(); ConstantPostAggregator aggregator = new ConstantPostAggregator("aggregator", 2); ConstantPostAggregator aggregator1 = mapper.readValue( mapper.writeValueAsString(aggregator), ConstantPostAggregator.class ); Assert.assertEquals(aggregator, aggregator1); } }
@Test public void testCompute() { final String aggName = "rows"; LongLeastPostAggregator leastPostAggregator; CountAggregator agg = new CountAggregator(); agg.aggregate(); agg.aggregate(); agg.aggregate(); Map<String, Object> metricValues = new HashMap<String, Object>(); metricValues.put(aggName, agg.get()); List<PostAggregator> postAggregatorList = Lists.newArrayList( new ConstantPostAggregator( "roku", 6D ), new FieldAccessPostAggregator( "rows", aggName ) ); leastPostAggregator = new LongLeastPostAggregator("leastPostAggregator", postAggregatorList); Assert.assertEquals(Long.valueOf(3), leastPostAggregator.compute(metricValues)); }
@Test public void testCompute() { final String aggName = "rows"; LongGreatestPostAggregator greatestPostAggregator; CountAggregator agg = new CountAggregator(); agg.aggregate(); agg.aggregate(); agg.aggregate(); Map<String, Object> metricValues = new HashMap<String, Object>(); metricValues.put(aggName, agg.get()); List<PostAggregator> postAggregatorList = Lists.newArrayList( new ConstantPostAggregator( "roku", 6D ), new FieldAccessPostAggregator( "rows", aggName ) ); greatestPostAggregator = new LongGreatestPostAggregator("greatest", postAggregatorList); Assert.assertEquals(Long.valueOf(6), greatestPostAggregator.compute(metricValues)); }
@Test public void testCompute() { final String aggName = "rows"; DoubleLeastPostAggregator leastPostAggregator; CountAggregator agg = new CountAggregator(); agg.aggregate(); agg.aggregate(); agg.aggregate(); Map<String, Object> metricValues = new HashMap<String, Object>(); metricValues.put(aggName, agg.get()); List<PostAggregator> postAggregatorList = Lists.newArrayList( new ConstantPostAggregator( "roku", 6D ), new FieldAccessPostAggregator( "rows", aggName ) ); leastPostAggregator = new DoubleLeastPostAggregator("least", postAggregatorList); Assert.assertEquals(3.0, leastPostAggregator.compute(metricValues)); }
@Test public void testComparator() { final String aggName = "rows"; ArithmeticPostAggregator arithmeticPostAggregator; CountAggregator agg = new CountAggregator(); Map<String, Object> metricValues = new HashMap<String, Object>(); metricValues.put(aggName, agg.get()); List<PostAggregator> postAggregatorList = Lists.newArrayList( new ConstantPostAggregator( "roku", 6D ), new FieldAccessPostAggregator( "rows", "rows" ) ); arithmeticPostAggregator = new ArithmeticPostAggregator("add", "+", postAggregatorList); Comparator comp = arithmeticPostAggregator.getComparator(); Object before = arithmeticPostAggregator.compute(metricValues); agg.aggregate(); agg.aggregate(); agg.aggregate(); metricValues.put(aggName, agg.get()); Object after = arithmeticPostAggregator.compute(metricValues); Assert.assertEquals(-1, comp.compare(before, after)); Assert.assertEquals(0, comp.compare(before, before)); Assert.assertEquals(0, comp.compare(after, after)); Assert.assertEquals(1, comp.compare(after, before)); }
new ConstantPostAggregator( "roku", 2D ),
new ConstantPostAggregator( "roku", 2D ),
new ConstantPostAggregator( "roku", 2D ),
new ConstantPostAggregator( "roku", 2D ),
@Test public void testCompute() { final String aggName = "rows"; DoubleGreatestPostAggregator greatestPostAggregator; CountAggregator agg = new CountAggregator(); agg.aggregate(); agg.aggregate(); agg.aggregate(); Map<String, Object> metricValues = new HashMap<String, Object>(); metricValues.put(aggName, agg.get()); List<PostAggregator> postAggregatorList = Lists.newArrayList( new ConstantPostAggregator( "roku", 6D ), new FieldAccessPostAggregator( "rows", aggName ) ); greatestPostAggregator = new DoubleGreatestPostAggregator("greatest", postAggregatorList); Assert.assertEquals(6.0, greatestPostAggregator.compute(metricValues)); }
Collections.singletonList(new ConstantPostAggregator("constant", 1))