/** Tests the standard aggregation behavior */
@Test
public void testAggregation() {
AggregateSummaryStatistics aggregate = new AggregateSummaryStatistics();
SummaryStatistics setOneStats = aggregate.createContributingStatistics();
SummaryStatistics setTwoStats = aggregate.createContributingStatistics();
Assert.assertNotNull("The set one contributing stats are null", setOneStats);
Assert.assertNotNull("The set two contributing stats are null", setTwoStats);
Assert.assertNotSame("Contributing stats objects are the same", setOneStats, setTwoStats);
setOneStats.addValue(2);
setOneStats.addValue(3);
setOneStats.addValue(5);
setOneStats.addValue(7);
setOneStats.addValue(11);
Assert.assertEquals("Wrong number of set one values", 5, setOneStats.getN());
Assert.assertTrue(
"Wrong sum of set one values", Precision.equals(28.0, setOneStats.getSum(), 1));
setTwoStats.addValue(2);
setTwoStats.addValue(4);
setTwoStats.addValue(8);
Assert.assertEquals("Wrong number of set two values", 3, setTwoStats.getN());
Assert.assertTrue(
"Wrong sum of set two values", Precision.equals(14.0, setTwoStats.getSum(), 1));
Assert.assertEquals("Wrong number of aggregate values", 8, aggregate.getN());
Assert.assertTrue("Wrong aggregate sum", Precision.equals(42.0, aggregate.getSum(), 1));
}
@Test
public void testAggregateSpecialValues() {
double[] totalSample = {Double.POSITIVE_INFINITY, 2, 3, Double.NaN, 5};
double[][] subSamples = {{Double.POSITIVE_INFINITY, 2}, {3}, {Double.NaN}, {5}};
// Compute combined stats directly
SummaryStatistics totalStats = new SummaryStatistics();
for (int i = 0; i < totalSample.length; i++) {
totalStats.addValue(totalSample[i]);
}
// Now compute subsample stats individually and aggregate
SummaryStatistics[] subSampleStats = new SummaryStatistics[5];
for (int i = 0; i < 4; i++) {
subSampleStats[i] = new SummaryStatistics();
}
Collection<SummaryStatistics> aggregate = new ArrayList<SummaryStatistics>();
for (int i = 0; i < 4; i++) {
for (int j = 0; j < subSamples[i].length; j++) {
subSampleStats[i].addValue(subSamples[i][j]);
}
aggregate.add(subSampleStats[i]);
}
// Compare values
StatisticalSummaryValues aggregatedStats = AggregateSummaryStatistics.aggregate(aggregate);
assertEquals(totalStats.getSummary(), aggregatedStats, 10E-12);
}
/** Similar to {@link #testAggregate()} but operating on {@link StatisticalSummary} instead. */
@Test
public void testAggregateStatisticalSummary() {
// Generate a random sample and random partition
double[] totalSample = generateSample();
double[][] subSamples = generatePartition(totalSample);
int nSamples = subSamples.length;
// Compute combined stats directly
SummaryStatistics totalStats = new SummaryStatistics();
for (int i = 0; i < totalSample.length; i++) {
totalStats.addValue(totalSample[i]);
}
// Now compute subsample stats individually and aggregate
SummaryStatistics[] subSampleStats = new SummaryStatistics[nSamples];
for (int i = 0; i < nSamples; i++) {
subSampleStats[i] = new SummaryStatistics();
}
Collection<StatisticalSummary> aggregate = new ArrayList<StatisticalSummary>();
for (int i = 0; i < nSamples; i++) {
for (int j = 0; j < subSamples[i].length; j++) {
subSampleStats[i].addValue(subSamples[i][j]);
}
aggregate.add(subSampleStats[i].getSummary());
}
// Compare values
StatisticalSummary aggregatedStats = AggregateSummaryStatistics.aggregate(aggregate);
assertEquals(totalStats.getSummary(), aggregatedStats, 10E-12);
}
/**
* Verify that aggregating over a partition gives the same results as direct computation.
*
* <p>1) Randomly generate a dataset of 10-100 values from [-100, 100] 2) Divide the dataset it
* into 2-5 partitions 3) Create an AggregateSummaryStatistic and ContributingStatistics for each
* partition 4) Compare results from the AggregateSummaryStatistic with values returned by a
* single SummaryStatistics instance that is provided the full dataset
*/
@Test
public void testAggregationConsistency() {
// Generate a random sample and random partition
double[] totalSample = generateSample();
double[][] subSamples = generatePartition(totalSample);
int nSamples = subSamples.length;
// Create aggregator and total stats for comparison
AggregateSummaryStatistics aggregate = new AggregateSummaryStatistics();
SummaryStatistics totalStats = new SummaryStatistics();
// Create array of component stats
SummaryStatistics componentStats[] = new SummaryStatistics[nSamples];
for (int i = 0; i < nSamples; i++) {
// Make componentStats[i] a contributing statistic to aggregate
componentStats[i] = aggregate.createContributingStatistics();
// Add values from subsample
for (int j = 0; j < subSamples[i].length; j++) {
componentStats[i].addValue(subSamples[i][j]);
}
}
// Compute totalStats directly
for (int i = 0; i < totalSample.length; i++) {
totalStats.addValue(totalSample[i]);
}
/*
* Compare statistics in totalStats with aggregate.
* Note that guaranteed success of this comparison depends on the
* fact that <aggregate> gets values in exactly the same order
* as <totalStats>.
*
*/
Assert.assertEquals(totalStats.getSummary(), aggregate.getSummary());
}
/**
* Get the Variance of all the stats that are watched, for all the stats added with add() since
* the creation of this <tt>HammerSummaryStats</tt>
*
* @return The Variance of all the stats JSON.
*/
public String getAggregateVarianceJSON() {
String str =
String.format(
FakeUserStats.jsonMediaStreamStatsTemplate,
-1, // ssrc not needed here
aggregateDownloadJitterMs.getVariance(),
aggregateDownloadPercentLoss.getVariance(),
aggregateDownloadRateKiloBitPerSec.getVariance(),
aggregateJitterBufferDelayMs.getVariance(),
aggregateJitterBufferDelayPackets.getVariance(),
aggregateNbDiscarded.getVariance(),
aggregateNbDiscardedFull.getVariance(),
aggregateNbDiscardedLate.getVariance(),
aggregateNbDiscardedReset.getVariance(),
aggregateNbDiscardedShrink.getVariance(),
aggregateNbFec.getVariance(),
aggregateNbPackets.getVariance(),
aggregateNbPacketsLost.getVariance(),
aggregateNbReceivedBytes.getVariance(),
aggregateNbSentBytes.getVariance(),
aggregatePacketQueueCountPackets.getVariance(),
aggregatePacketQueueSize.getVariance(),
aggregatePercentDiscarded.getVariance(),
aggregateRttMs.getVariance(),
aggregateUploadJitterMs.getVariance(),
aggregateUploadPercentLoss.getVariance(),
aggregateUploadRateKiloBitPerSec.getVariance());
return str;
}
/**
* Create new <tt>SummaryStatistics</tt> from the <tt>AggregateSummaryStatistics</tt> for all
* the stream's stats that are watched.
*/
public void clear() {
downloadJitterMs = aggregateDownloadJitterMs.createContributingStatistics();
downloadPercentLoss = aggregateDownloadPercentLoss.createContributingStatistics();
downloadRateKiloBitPerSec = aggregateDownloadRateKiloBitPerSec.createContributingStatistics();
jitterBufferDelayMs = aggregateJitterBufferDelayMs.createContributingStatistics();
jitterBufferDelayPackets = aggregateJitterBufferDelayPackets.createContributingStatistics();
nbDiscarded = aggregateNbDiscarded.createContributingStatistics();
nbDiscardedFull = aggregateNbDiscardedFull.createContributingStatistics();
nbDiscardedLate = aggregateNbDiscardedLate.createContributingStatistics();
nbDiscardedReset = aggregateNbDiscardedReset.createContributingStatistics();
nbDiscardedShrink = aggregateNbDiscardedShrink.createContributingStatistics();
nbFec = aggregateNbFec.createContributingStatistics();
nbPackets = aggregateNbPackets.createContributingStatistics();
nbPacketsLost = aggregateNbPacketsLost.createContributingStatistics();
nbReceivedBytes = aggregateNbReceivedBytes.createContributingStatistics();
nbSentBytes = aggregateNbSentBytes.createContributingStatistics();
packetQueueCountPackets = aggregatePacketQueueCountPackets.createContributingStatistics();
packetQueueSize = aggregatePacketQueueSize.createContributingStatistics();
percentDiscarded = aggregatePercentDiscarded.createContributingStatistics();
rttMs = aggregateRttMs.createContributingStatistics();
uploadJitterMs = aggregateUploadJitterMs.createContributingStatistics();
uploadPercentLoss = aggregateUploadPercentLoss.createContributingStatistics();
uploadRateKiloBitPerSec = aggregateUploadRateKiloBitPerSec.createContributingStatistics();
}