diff --git a/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRate.java b/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRate.java index 0835e4af53fd..6604300cbed5 100644 --- a/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRate.java +++ b/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRate.java @@ -30,6 +30,8 @@ package org.hisp.dhis.common; import static org.hisp.dhis.common.DimensionalObjectUtils.COMPOSITE_DIM_OBJECT_PLAIN_SEP; +import static org.hisp.dhis.common.TotalAggregationType.AVERAGE; +import static org.hisp.dhis.common.TotalAggregationType.SUM; import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.databind.annotation.JsonSerialize; @@ -101,12 +103,38 @@ public DimensionItemType getDimensionItemType() { @Override public List getLegendSets() { - return dataSet.getLegendSets(); + if (dataSet != null) { + return dataSet.getLegendSets(); + } + + return List.of(); + } + + @Override + public LegendSet getLegendSet() { + if (dataSet != null) { + return dataSet.getLegendSet(); + } + + return null; + } + + @Override + public boolean hasLegendSet() { + if (dataSet != null) { + return dataSet.hasLegendSet(); + } + + return false; } @Override public TotalAggregationType getTotalAggregationType() { - return TotalAggregationType.AVERAGE; + if (metric.isSum()) { + return SUM; + } + + return AVERAGE; } // ------------------------------------------------------------------------- diff --git a/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRateMetric.java b/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRateMetric.java index 8b4f50240c0d..e7eb45af58f3 100644 --- a/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRateMetric.java +++ b/dhis-2/dhis-api/src/main/java/org/hisp/dhis/common/ReportingRateMetric.java @@ -45,6 +45,7 @@ public enum ReportingRateMetric { ReportingRateMetric(String key, String displayName) { this.displayName = displayName; + this.key = key; } public String key() { @@ -54,4 +55,8 @@ public String key() { public String displayName() { return displayName; } + + public boolean isSum() { + return this == ACTUAL_REPORTS || this == EXPECTED_REPORTS || this == ACTUAL_REPORTS_ON_TIME; + } } diff --git a/dhis-2/dhis-services/dhis-service-analytics/src/main/java/org/hisp/dhis/analytics/data/handler/DataHandler.java b/dhis-2/dhis-services/dhis-service-analytics/src/main/java/org/hisp/dhis/analytics/data/handler/DataHandler.java index 80e28d55bfb5..b55cd891cd51 100644 --- a/dhis-2/dhis-services/dhis-service-analytics/src/main/java/org/hisp/dhis/analytics/data/handler/DataHandler.java +++ b/dhis-2/dhis-services/dhis-service-analytics/src/main/java/org/hisp/dhis/analytics/data/handler/DataHandler.java @@ -99,6 +99,7 @@ import static org.hisp.dhis.common.ReportingRateMetric.ACTUAL_REPORTS; import static org.hisp.dhis.common.ReportingRateMetric.ACTUAL_REPORTS_ON_TIME; import static org.hisp.dhis.common.ReportingRateMetric.EXPECTED_REPORTS; +import static org.hisp.dhis.common.ReportingRateMetric.REPORTING_RATE; import static org.hisp.dhis.common.ReportingRateMetric.REPORTING_RATE_ON_TIME; import static org.hisp.dhis.commons.util.DebugUtils.getStackTrace; import static org.hisp.dhis.commons.util.SystemUtils.getCpuCores; @@ -729,11 +730,30 @@ private void addReportRateToGrid( .addValue(params.isSkipRounding() ? value : getRoundedValueObject(params, value)); if (params.isIncludeNumDen()) { - grid.addValue(actual).addValue(target).addValue(PERCENT).addNullValues(2); + int multiplier = isRateMetric(metric) ? PERCENT : 1; + int divisor = 1; + double factor = (double) multiplier / divisor; + + grid.addValue(actual) + .addValue(target) + .addValue(factor) + .addValue(multiplier) + .addValue(divisor); } } } + /** + * Indicates whether the given metric is a percentage rate, as opposed to a count of reports. + * + * @param metric the {@link ReportingRateMetric}. + * @return true if the metric is {@link ReportingRateMetric#REPORTING_RATE} or {@link + * ReportingRateMetric#REPORTING_RATE_ON_TIME}. + */ + private boolean isRateMetric(ReportingRateMetric metric) { + return metric == REPORTING_RATE || metric == REPORTING_RATE_ON_TIME; + } + private boolean satisfiesMeasureCriteria(DataQueryParams params, Double value) { if (params.hasMeasureCriteria() && value != null) { Number finalValue = diff --git a/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/data/AnalyticsServiceReportingRateTest.java b/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/data/AnalyticsServiceReportingRateTest.java index c442a146789d..0f30b267452b 100644 --- a/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/data/AnalyticsServiceReportingRateTest.java +++ b/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/data/AnalyticsServiceReportingRateTest.java @@ -36,6 +36,7 @@ import static org.hisp.dhis.test.TestBase.createDataSet; import static org.hisp.dhis.test.TestBase.injectSecurityContextNoSettings; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.eq; @@ -73,7 +74,7 @@ */ class AnalyticsServiceReportingRateTest extends AnalyticsServiceBaseTest { @BeforeEach - public void setUp() { + void setUp() { injectSecurityContextNoSettings(new SystemUser()); } @@ -326,8 +327,7 @@ void verifyReportingRatesForMonthsWithMoreThen30DaysAreComputedCorrectly() { targets.put(dataSetA.getUid() + "-" + "201901", 1D); // Response for COMPLETENESS - set the completeness value to the same - // number of - // days of the selected month + // number of days of the selected month Map actuals = new HashMap<>(); actuals.put(dataSetA.getUid() + "-" + "201901", 31D); @@ -343,6 +343,186 @@ void verifyReportingRatesForMonthsWithMoreThen30DaysAreComputedCorrectly() { assertReportingRatesGrid(grid, dataSetA, "201901"); } + @Test + void verifyNumDenForRateMetricsHasPercentMultiplierAndDivisor() { + DataSet dataSetA = createDataSet('A'); + OrganisationUnit ou = new OrganisationUnit("aaaa"); + + Grid grid = + getNumDenGrid( + dataSetA, + ou, + 10, + true, + 500D, + 100D, + ReportingRateMetric.REPORTING_RATE, + ReportingRateMetric.REPORTING_RATE_ON_TIME); + + for (ReportingRateMetric metric : + List.of(ReportingRateMetric.REPORTING_RATE, ReportingRateMetric.REPORTING_RATE_ON_TIME)) { + List row = getRowByDx(grid, makeKey(dataSetA, metric)); + + assertEquals(50L, getValue(grid, row, "value"), metric.name()); + assertEquals(500D, getValue(grid, row, "numerator"), metric.name()); + assertEquals(1000D, getValue(grid, row, "denominator"), metric.name()); + assertEquals(100D, getValue(grid, row, "factor"), metric.name()); + assertEquals(100, getValue(grid, row, "multiplier"), metric.name()); + assertEquals(1, getValue(grid, row, "divisor"), metric.name()); + } + } + + @Test + void verifyNumDenForCountMetricsHasUnitFactorMultiplierAndDivisor() { + DataSet dataSetA = createDataSet('A'); + OrganisationUnit ou = new OrganisationUnit("aaaa"); + + Grid grid = + getNumDenGrid( + dataSetA, + ou, + 10, + true, + 500D, + 100D, + ReportingRateMetric.ACTUAL_REPORTS, + ReportingRateMetric.ACTUAL_REPORTS_ON_TIME, + ReportingRateMetric.EXPECTED_REPORTS); + + for (ReportingRateMetric metric : + List.of( + ReportingRateMetric.ACTUAL_REPORTS, + ReportingRateMetric.ACTUAL_REPORTS_ON_TIME, + ReportingRateMetric.EXPECTED_REPORTS)) { + List row = getRowByDx(grid, makeKey(dataSetA, metric)); + + assertEquals(1D, getValue(grid, row, "factor"), metric.name()); + assertEquals(1, getValue(grid, row, "multiplier"), metric.name()); + assertEquals(1, getValue(grid, row, "divisor"), metric.name()); + } + + // Numerator and denominator are always the actual and the expected reports + List expected = + getRowByDx(grid, makeKey(dataSetA, ReportingRateMetric.EXPECTED_REPORTS)); + assertEquals(1000L, getValue(grid, expected, "value")); + assertEquals(0D, getValue(grid, expected, "numerator")); + assertEquals(1000D, getValue(grid, expected, "denominator")); + + List actual = getRowByDx(grid, makeKey(dataSetA, ReportingRateMetric.ACTUAL_REPORTS)); + assertEquals(500L, getValue(grid, actual, "value")); + assertEquals(500D, getValue(grid, actual, "numerator")); + assertEquals(1000D, getValue(grid, actual, "denominator")); + } + + @Test + void verifyNumDenWhenReportingRateIsCappedAt100() { + DataSet dataSetA = createDataSet('A'); + OrganisationUnit ou = new OrganisationUnit("aaaa"); + + // More actual reports than expected: the rate is capped, numerator and + // denominator are not + Grid grid = + getNumDenGrid(dataSetA, ou, 1, true, 150D, 100D, ReportingRateMetric.REPORTING_RATE); + + List row = getRowByDx(grid, makeKey(dataSetA, ReportingRateMetric.REPORTING_RATE)); + + assertEquals(100L, getValue(grid, row, "value")); + assertEquals(150D, getValue(grid, row, "numerator")); + assertEquals(100D, getValue(grid, row, "denominator")); + assertEquals(100D, getValue(grid, row, "factor")); + assertEquals(100, getValue(grid, row, "multiplier")); + assertEquals(1, getValue(grid, row, "divisor")); + } + + @Test + void verifyNoNumDenColumnsWhenIncludeNumDenIsFalse() { + DataSet dataSetA = createDataSet('A'); + OrganisationUnit ou = new OrganisationUnit("aaaa"); + + Grid grid = + getNumDenGrid(dataSetA, ou, 1, false, 50D, 100D, ReportingRateMetric.REPORTING_RATE); + + assertThat(grid.getHeaders(), hasSize(3)); + assertThat(grid.getRows(), hasSize(1)); + assertThat(grid.getRow(0), hasSize(3)); + assertEquals(-1, getDimensionIndex(grid.getHeaders(), "multiplier")); + assertEquals(-1, getDimensionIndex(grid.getHeaders(), "divisor")); + } + + /** + * Runs an aggregated query for the given reporting rate metrics of a single data set and org + * unit, using a period filter with the given number of monthly periods. + */ + private Grid getNumDenGrid( + DataSet dataSet, + OrganisationUnit ou, + int timeUnits, + boolean includeNumDen, + double actualReports, + double expectedReportsPerPeriod, + ReportingRateMetric... metrics) { + List reportingRates = new ArrayList<>(); + + for (ReportingRateMetric metric : metrics) { + ReportingRate reportingRate = new ReportingRate(dataSet); + reportingRate.setMetric(metric); + reportingRates.add(reportingRate); + } + + List periods = new ArrayList<>(); + + Stream.iterate(1, i -> i + 1) + .limit(timeUnits) + .forEach( + x -> + periods.add( + PeriodDimension.of( + new MonthlyPeriodType() + .createPeriod(new DateTime(2014, x, 1, 0, 0).toDate())))); + + DataQueryParams params = + DataQueryParams.newBuilder() + .withOrganisationUnit(ou) + .withDataElements(reportingRates) + .withIgnoreLimit(true) + .withIncludeNumDen(includeNumDen) + .withFilters(List.of(new BaseDimensionalObject("pe", DimensionType.PERIOD, periods))) + .build(); + + initMock(params); + + Map actuals = new HashMap<>(); + actuals.put(dataSet.getUid() + "-" + ou.getUid(), actualReports); + + when(analyticsManager.getAggregatedDataValues( + any(DataQueryParams.class), eq(AnalyticsTableType.COMPLETENESS), eq(0))) + .thenReturn(CompletableFuture.completedFuture(actuals)); + + Map targets = new HashMap<>(); + targets.put(dataSet.getUid() + "-" + ou.getUid(), expectedReportsPerPeriod); + + when(analyticsManager.getAggregatedDataValues( + any(DataQueryParams.class), eq(AnalyticsTableType.COMPLETENESS_TARGET), eq(0))) + .thenReturn(CompletableFuture.completedFuture(targets)); + + return target.getAggregatedDataValueGrid(params); + } + + private List getRowByDx(Grid grid, String dx) { + int dxIndex = getDimensionIndex(grid.getHeaders(), "dx"); + + return grid.getRows().stream() + .filter(row -> dx.equals(row.get(dxIndex))) + .findFirst() + .orElseThrow(() -> new AssertionError("No row found for dx: " + dx)); + } + + private Object getValue(Grid grid, List row, String header) { + int index = getDimensionIndex(grid.getHeaders(), header); + assertNotEquals(-1, index, "Missing header: " + header); + return row.get(index); + } + private void assertReportingRatesGrid(Grid grid, DataSet dataset, String period) { assertThat(grid.getRows(), hasSize(1)); assertThat(grid.getRow(0), hasSize(3)); diff --git a/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/util/AnalyticsUtilsTest.java b/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/util/AnalyticsUtilsTest.java index e0532e49afa1..e6ad937f0bf2 100644 --- a/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/util/AnalyticsUtilsTest.java +++ b/dhis-2/dhis-services/dhis-service-analytics/src/test/java/org/hisp/dhis/analytics/util/AnalyticsUtilsTest.java @@ -75,7 +75,11 @@ import org.hisp.dhis.common.Grid; import org.hisp.dhis.common.GridHeader; import org.hisp.dhis.common.MetadataItem; +import org.hisp.dhis.common.ObjectStyle; import org.hisp.dhis.common.QueryRuntimeException; +import org.hisp.dhis.common.ReportingRate; +import org.hisp.dhis.common.ReportingRateMetric; +import org.hisp.dhis.common.TotalAggregationType; import org.hisp.dhis.common.ValueType; import org.hisp.dhis.dataelement.DataElement; import org.hisp.dhis.dataelement.DataElementOperand; @@ -86,6 +90,7 @@ import org.hisp.dhis.external.conf.ConfigurationKey; import org.hisp.dhis.indicator.Indicator; import org.hisp.dhis.indicator.IndicatorType; +import org.hisp.dhis.legend.LegendSet; import org.hisp.dhis.option.Option; import org.hisp.dhis.option.OptionSet; import org.hisp.dhis.organisationunit.OrganisationUnit; @@ -110,6 +115,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.EnumSource; import org.junit.jupiter.params.provider.MethodSource; import org.springframework.jdbc.BadSqlGrammarException; import org.springframework.jdbc.UncategorizedSQLException; @@ -945,4 +951,202 @@ void testGetDimensionMetadataMap_with_ProgramTrackedAttribute_withOptions() { assertEquals(option.getUid(), result.get(key).getOptions().get(0).get("uid")); assertEquals(option.getCode(), result.get(key).getOptions().get(0).get("code")); } + + // ------------------------------------------------------------------------- + // getDimensionMetadataItemMap with ReportingRate items + // ------------------------------------------------------------------------- + + @Test + void testGetDimensionMetadataItemMapReportingRateKeysAndNames() { + DataSet dataSetA = createDataSet('A'); + List reportingRates = createReportingRates(dataSetA); + + DataQueryParams params = + DataQueryParams.newBuilder() + .addDimension( + new BaseDimensionalObject(DATA_X_DIM_ID, DimensionType.DATA_X, reportingRates)) + .withDisplayProperty(DisplayProperty.NAME) + .build(); + + Map result = AnalyticsUtils.getDimensionMetadataItemMap(params); + + // One entry per reporting rate item plus one for the dx dimension + assertEquals(ReportingRateMetric.values().length + 1, result.size()); + assertTrue(result.containsKey(DATA_X_DIM_ID)); + + for (ReportingRateMetric metric : ReportingRateMetric.values()) { + String key = dataSetA.getUid() + "." + metric.name(); + + assertTrue(result.containsKey(key), "Missing key: " + key); + assertEquals("DataSetA - " + metric.displayName(), result.get(key).getName()); + } + + // The plain data set uid is not used as a key + assertFalse(result.containsKey(dataSetA.getUid())); + } + + @Test + void testGetDimensionMetadataItemMapReportingRateWithShortName() { + DataSet dataSetA = createDataSet('A'); + List reportingRates = createReportingRates(dataSetA); + + DataQueryParams params = + DataQueryParams.newBuilder() + .addDimension( + new BaseDimensionalObject(DATA_X_DIM_ID, DimensionType.DATA_X, reportingRates)) + .withDisplayProperty(DisplayProperty.SHORTNAME) + .build(); + + Map result = AnalyticsUtils.getDimensionMetadataItemMap(params); + + for (ReportingRateMetric metric : ReportingRateMetric.values()) { + String key = dataSetA.getUid() + "." + metric.name(); + + assertEquals("DataSetShortA - " + metric.displayName(), result.get(key).getName()); + } + } + + @Test + void testGetDimensionMetadataItemMapReportingRateWithoutMetadataDetails() { + DataSet dataSetA = createDataSet('A'); + ReportingRate reportingRate = new ReportingRate(dataSetA, ReportingRateMetric.REPORTING_RATE); + + DataQueryParams params = + DataQueryParams.newBuilder() + .addDimension( + new BaseDimensionalObject( + DATA_X_DIM_ID, DimensionType.DATA_X, List.of(reportingRate))) + .withDisplayProperty(DisplayProperty.NAME) + .withIncludeMetadataDetails(false) + .build(); + + MetadataItem item = + AnalyticsUtils.getDimensionMetadataItemMap(params).get(reportingRate.getDimensionItem()); + + assertNotNull(item); + assertEquals("DataSetA - Reporting rate", item.getName()); + assertNull(item.getUid()); + assertNull(item.getCode()); + assertNull(item.getDimensionItemType()); + assertNull(item.getValueType()); + assertNull(item.getTotalAggregationType()); + assertNull(item.getStyle()); + } + + @ParameterizedTest + @EnumSource(ReportingRateMetric.class) + void testGetDimensionMetadataItemMapReportingRateWithMetadataDetails(ReportingRateMetric metric) { + DataSet dataSetA = createDataSet('A'); + ObjectStyle style = new ObjectStyle(); + style.setColor("#FF0000"); + style.setIcon("icon-name"); + dataSetA.setStyle(style); + + ReportingRate reportingRate = new ReportingRate(dataSetA, metric); + + DataQueryParams params = + DataQueryParams.newBuilder() + .addDimension( + new BaseDimensionalObject( + DATA_X_DIM_ID, DimensionType.DATA_X, List.of(reportingRate))) + .withDisplayProperty(DisplayProperty.NAME) + .withIncludeMetadataDetails(true) + .build(); + + MetadataItem item = + AnalyticsUtils.getDimensionMetadataItemMap(params) + .get(dataSetA.getUid() + "." + metric.name()); + + assertNotNull(item); + assertEquals("DataSetA - " + metric.displayName(), item.getName()); + assertEquals(dataSetA.getUid(), item.getUid()); + assertEquals(DimensionItemType.REPORTING_RATE, item.getDimensionItemType()); + assertEquals(ValueType.NUMBER, item.getValueType()); + assertEquals( + metric.isSum() ? TotalAggregationType.SUM : TotalAggregationType.AVERAGE, + item.getTotalAggregationType()); + assertNull(item.getAggregationType()); + assertNotNull(item.getStyle()); + assertEquals("#FF0000", item.getStyle().getColor()); + assertEquals("icon-name", item.getStyle().getIcon()); + } + + @Test + void testGetDimensionMetadataItemMapReportingRatesFromMultipleDataSetsInFilter() { + DataSet dataSetA = createDataSet('A'); + DataSet dataSetB = createDataSet('B'); + + ReportingRate rateA = new ReportingRate(dataSetA, ReportingRateMetric.REPORTING_RATE); + ReportingRate rateB = new ReportingRate(dataSetB, ReportingRateMetric.EXPECTED_REPORTS); + + DataQueryParams params = + DataQueryParams.newBuilder() + .addFilter( + new BaseDimensionalObject( + DATA_X_DIM_ID, DimensionType.DATA_X, List.of(rateA, rateB))) + .withDisplayProperty(DisplayProperty.NAME) + .build(); + + Map result = AnalyticsUtils.getDimensionMetadataItemMap(params); + + assertEquals(3, result.size()); + assertEquals( + "DataSetA - Reporting rate", result.get(dataSetA.getUid() + ".REPORTING_RATE").getName()); + assertEquals( + "DataSetB - Expected reports", + result.get(dataSetB.getUid() + ".EXPECTED_REPORTS").getName()); + } + + @Test + void testGetDimensionMetadataItemMapReportingRateHasNoCategoryOptionCombos() { + DataSet dataSetA = createDataSet('A'); + ReportingRate reportingRate = new ReportingRate(dataSetA, ReportingRateMetric.ACTUAL_REPORTS); + + DataQueryParams params = + DataQueryParams.newBuilder() + .addDimension( + new BaseDimensionalObject( + DATA_X_DIM_ID, DimensionType.DATA_X, List.of(reportingRate))) + .withIncludeMetadataDetails(true) + .build(); + + Map result = AnalyticsUtils.getDimensionMetadataItemMap(params); + + // Unlike data elements, reporting rates do not add category option combo entries + assertEquals(2, result.size()); + assertTrue(result.containsKey(reportingRate.getDimensionItem())); + assertTrue(result.containsKey(DATA_X_DIM_ID)); + } + + @Test + void testGetDimensionMetadataItemMapReportingRateUsesDataSetLegendSet() { + DataSet dataSetA = createDataSet('A'); + LegendSet legendSet = createLegendSet('A'); + dataSetA.setLegendSets(List.of(legendSet)); + + ReportingRate reportingRate = new ReportingRate(dataSetA, ReportingRateMetric.REPORTING_RATE); + + DataQueryParams params = + DataQueryParams.newBuilder() + .addDimension( + new BaseDimensionalObject( + DATA_X_DIM_ID, DimensionType.DATA_X, List.of(reportingRate))) + .withIncludeMetadataDetails(true) + .build(); + + MetadataItem item = + AnalyticsUtils.getDimensionMetadataItemMap(params).get(reportingRate.getDimensionItem()); + + assertEquals(legendSet.getUid(), item.getLegendSet()); + } + + private List createReportingRates(DataSet dataSet) { + List reportingRates = new ArrayList<>(); + + for (ReportingRateMetric metric : ReportingRateMetric.values()) { + reportingRates.add(new ReportingRate(dataSet, metric)); + } + + return reportingRates; + } } diff --git a/dhis-2/dhis-test-e2e/src/test/java/org/hisp/dhis/analytics/aggregate/AnalyticsQueryTest.java b/dhis-2/dhis-test-e2e/src/test/java/org/hisp/dhis/analytics/aggregate/AnalyticsQueryTest.java index 35d77805546d..7370a6f07e82 100644 --- a/dhis-2/dhis-test-e2e/src/test/java/org/hisp/dhis/analytics/aggregate/AnalyticsQueryTest.java +++ b/dhis-2/dhis-test-e2e/src/test/java/org/hisp/dhis/analytics/aggregate/AnalyticsQueryTest.java @@ -255,9 +255,9 @@ public void testQueryForReportingRatesWithMeasureCriteriaLT() { "24.82", "983.0", "3960.0", + "100.0", "100", - "", - "")); + "1")); validateRow( response, @@ -267,9 +267,9 @@ public void testQueryForReportingRatesWithMeasureCriteriaLT() { "24.71", "1542.0", "6240.0", + "100.0", "100", - "", - "")); + "1")); validateRow( response, @@ -279,9 +279,9 @@ public void testQueryForReportingRatesWithMeasureCriteriaLT() { "24.71", "1542.0", "6240.0", + "100.0", "100", - "", - "")); + "1")); } @Test @@ -406,9 +406,9 @@ public void testQueryForReportingRatesWithMeasureCriteriaEQ_WithRounding() { "25.11", "1401.0", "5580.0", + "100.0", "100", - "", - "")); + "1")); } @Test