uitest/src/test/java/com/vaadin/tests/performance/MemoryIT.java


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

package com.vaadin.tests.performance;

import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.junit.Test;
import org.junit.experimental.categories.Category;

import com.vaadin.testbench.By;
import com.vaadin.testcategory.MeasurementTest;
import com.vaadin.tests.tb3.SingleBrowserTest;

@Category(MeasurementTest.class)
public class MemoryIT extends SingleBrowserTest {

    private static final int MAX_ITERATIONS = 20;

    @Test
    public void measureMemory() {
        performTest(GridMemory.PATH + "?items=1", "grid-v8-one-item-");
        performTest(CompatibilityGridMemory.PATH + "?items=1",
                "grid-v7-one-item-");

        performTest(GridMemory.PATH + "?items=1", "grid-v8-100thousand-items-");
        performTest(CompatibilityGridMemory.PATH + "?items=100000",
                "grid-v7-100thousand-items-");

        performTest(TreeGridMemory.PATH + "?items=1", "tree-grid-one-item-");
        performTest(TreeTableMemory.PATH + "?items=1", "tree-table-one-item-");

        performTest(TreeGridMemory.PATH + "?items=100&initiallyExpanded",
                "tree-grid-100-items-initially-expanded-");
        performTest(TreeTableMemory.PATH + "?items=100&initiallyExpanded",
                "tree-table-100-items-initially-expanded-");

        performTest(TreeGridMemory.PATH + "?items=100000",
                "tree-grid-100thousand-items-");
        performTest(TreeTableMemory.PATH + "?items=100000",
                "tree-table-100thousand-items-");
    }

    @Override
    protected void closeApplication() {
    }

    private void performTest(String path, String teamcityStatPrefix) {
        double lastResult = 0;
        int stableNumber = 0;
        List<Long> renderingTimes = new ArrayList<>();
        List<Long> requestTimes = new ArrayList<>();
        for (int i = 0; i < MAX_ITERATIONS; i++) {
            openUI(path);
            renderingTimes.add(testBench().totalTimeSpentRendering());
            requestTimes.add(testBench().totalTimeSpentServicingRequests());
            long currentResult = Long
                    .parseLong(findElement(By.id("memory")).getText());
            close();

            if (approx(lastResult, currentResult, 0.001)) {
                stableNumber++;
            }
            lastResult = currentResult;
            if (stableNumber == 5) {
                System.out.println(
                        "Memory usage stabilized after " + i + " iterations");
                printTeamcityStats(teamcityStatPrefix + "size", currentResult);
                printTeamcityStats(teamcityStatPrefix + "rendering-time",
                        median(renderingTimes));
                printTeamcityStats(teamcityStatPrefix + "request-time",
                        median(requestTimes));
                return;
            }
            if (i == MAX_ITERATIONS) {
                fail("Memory size does not stabilize");
            }
        }
    }

    private long median(List<Long> values) {
        values.sort(Long::compareTo);
        int middle = values.size() / 2;
        if (values.size() % 2 == 1) {
            return values.get(middle);
        } else {
            return (values.get(middle - 1) + values.get(middle)) / 2;
        }
    }

    private boolean approx(double num1, double num2, double epsilon) {
        double delta = Math.abs(num1 - num2);
        double deltaLimit = num2 * epsilon;
        return delta < deltaLimit;
    }

    private void openUI(String path) {
        getDriver().get(StringUtils.strip(getBaseURL(), "/") + path);
        assertTrue(isElementPresent(By.className("v-grid"))
                || isElementPresent(By.className("v-treegrid"))
                || isElementPresent(By.className("v-table")));
    }

    private void close() {
        findElement(By.id("close")).click();
    }

    private void printTeamcityStats(String key, long value) {
        // ##teamcity[buildStatisticValue key=&#39;&lt;valueTypeKey&gt;&#39;
        // value=&#39;&lt;value&gt;&#39;]
        System.out.println("##teamcity[buildStatisticValue key='" + key
                + "' value='" + value + "']");

    }
}