Esempio n. 1
0
void MovingMinMaxAvgTests::testQuint64() {
    // quint64 test

    const int INTERVAL_LENGTH = 100;
    const int WINDOW_INTERVALS = 50;

    MovingMinMaxAvg<quint64> stats(INTERVAL_LENGTH, WINDOW_INTERVALS);

    quint64 min = std::numeric_limits<quint64>::max();
    quint64 max = 0;
    double average = 0.0;
    int totalSamples = 0;

    quint64 windowMin;
    quint64 windowMax;
    double windowAverage;

    QQueue<quint64> windowSamples;
    // fill window samples
    for (int i = 0; i < 100000; i++) {

        quint64 sample = randQuint64();

        windowSamples.enqueue(sample);
        if (windowSamples.size() > INTERVAL_LENGTH * WINDOW_INTERVALS) {
            windowSamples.dequeue();
        }

        stats.update(sample);

        min = std::min(min, sample);
        max = std::max(max, sample);
        average = (average * totalSamples + sample) / (totalSamples + 1);
        totalSamples++;

        QCOMPARE(stats.getMin(), min);
        QCOMPARE(stats.getMax(), max);
        
        QCOMPARE_WITH_ABS_ERROR((float) stats.getAverage() / (float) average, 1.0f, EPSILON);
        QCOMPARE_WITH_ABS_ERROR((float) stats.getAverage(), (float) average, EPSILON);
        
        if ((i + 1) % INTERVAL_LENGTH == 0) {
            QVERIFY(stats.getNewStatsAvailableFlag());
            stats.clearNewStatsAvailableFlag();

            windowMin = std::numeric_limits<quint64>::max();
            windowMax = 0;
            windowAverage = 0.0;
            for (quint64 s : windowSamples) {
                windowMin = std::min(windowMin, s);
                windowMax = std::max(windowMax, s);
                windowAverage += (double)s;
            }
            windowAverage /= (double)windowSamples.size();

            QCOMPARE(stats.getWindowMin(), windowMin);
            QCOMPARE(stats.getWindowMax(), windowMax);
            QCOMPARE_WITH_ABS_ERROR((float)stats.getAverage(), (float)average, EPSILON);
        } else {
            QVERIFY(!stats.getNewStatsAvailableFlag());
        }
    }
}
Esempio n. 2
0
void MovingMinMaxAvgTests::runAllTests() {
    {
        // quint64 test

        const int INTERVAL_LENGTH = 100;
        const int WINDOW_INTERVALS = 50;

        MovingMinMaxAvg<quint64> stats(INTERVAL_LENGTH, WINDOW_INTERVALS);

        quint64 min = std::numeric_limits<quint64>::max();
        quint64 max = 0;
        double average = 0.0;
        int totalSamples = 0;

        quint64 windowMin;
        quint64 windowMax;
        double windowAverage;

        QQueue<quint64> windowSamples;
        // fill window samples
        for (int i = 0; i < 100000; i++) {

            quint64 sample = randQuint64();

            windowSamples.enqueue(sample);
            if (windowSamples.size() > INTERVAL_LENGTH * WINDOW_INTERVALS) {
                windowSamples.dequeue();
            }

            stats.update(sample);

            min = std::min(min, sample);
            max = std::max(max, sample);
            average = (average * totalSamples + sample) / (totalSamples + 1);
            totalSamples++;

            assert(stats.getMin() == min);
            assert(stats.getMax() == max);
            assert(fabsf((float)stats.getAverage() / (float)average - 1.0f) < EPSILON ||
                   fabsf((float)stats.getAverage() - (float)average) < EPSILON);

            if ((i + 1) % INTERVAL_LENGTH == 0) {

                assert(stats.getNewStatsAvailableFlag());
                stats.clearNewStatsAvailableFlag();

                windowMin = std::numeric_limits<quint64>::max();
                windowMax = 0;
                windowAverage = 0.0;
                foreach(quint64 s, windowSamples) {
                    windowMin = std::min(windowMin, s);
                    windowMax = std::max(windowMax, s);
                    windowAverage += (double)s;
                }
                windowAverage /= (double)windowSamples.size();

                assert(stats.getWindowMin() == windowMin);
                assert(stats.getWindowMax() == windowMax);
                assert(fabsf((float)stats.getAverage() / (float)average - 1.0f) < EPSILON ||
                       fabsf((float)stats.getAverage() - (float)average) < EPSILON);

            } else {