← Back to branch summary

~ubuntu-branches/ubuntu/vivid/eclipse-linuxtools/vivid-proposed

« back to all changes in this revision

Viewing changes to perf/org.eclipse.linuxtools.perf.tests/src/org/eclipse/linuxtools/internal/perf/tests/StatsComparisonTest.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam, Jakub Adam, tony mancill
  • Date: 2014-10-11 11:44:05 UTC
  • mfrom: (1.2.4)
  • Revision ID: package-import@ubuntu.com-20141011114405-yazjvxfzzhmi5sgj
Tags: 3.1.0-1
http://bugs.debian.org/761524
[ Jakub Adam ]
* New upstream release (Closes: #761524).
* Refreshed d/patches.
* Don't build removed feature org.eclipse.linuxtools.tools.launch
  - merged into org.eclipse.linuxtools.profiling.
* Use javac target 1.7.
* Build new feature org.eclipse.linuxtools.dataviewers.feature
  - required by Valgrind integration.
* Build-depend on eclipse-remote-services-api and eclipse-cdt-autotools.
* Bump Standards-Version to 3.9.6.
* Override incompatible-java-bytecode-format - linuxtools needs Java 7.
* Remove unused codeless-jar override.

[ tony mancill ]
* Tweak short package description to make lintian happy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
perf/org.eclipse.linuxtools.perf.tests/src/org/eclipse/linuxtools/internal/perf/tests/StatsComparisonTest.java
14
14
import static org.junit.Assert.assertEquals;
15
15
import static org.junit.Assert.assertFalse;
16
16
import static org.junit.Assert.assertNotNull;
17
 
import static org.junit.Assert.assertNull;
18
17
import static org.junit.Assert.assertTrue;
19
18
 
20
19
import java.io.BufferedReader;
24
23
 
25
24
import org.eclipse.core.runtime.IPath;
26
25
import org.eclipse.core.runtime.Path;
27
 
import org.eclipse.linuxtools.internal.perf.BaseDataManipulator;
28
 
import org.eclipse.linuxtools.internal.perf.PerfPlugin;
29
26
import org.eclipse.linuxtools.internal.perf.StatComparisonData;
30
27
import org.eclipse.linuxtools.internal.perf.model.PMStatEntry;
31
28
import org.junit.Before;
32
29
import org.junit.Test;
33
30
 
34
31
public class StatsComparisonTest {
35
 
        private PMStatEntry statEntry;
36
 
        private PMStatEntry statEntry2;
37
 
        private PMStatEntry statEntry3;
38
 
        private PMStatEntry statEntry4;
39
 
        private static final String STAT_RES = "resources/stat-data/";
40
 
 
41
 
        @Before
42
 
        public void setUp() {
43
 
                String event = "event";
44
 
                String units = "unit";
45
 
                float samples = 1;
46
 
                float metrics = 2;
47
 
                float deviation = 3;
48
 
                float scaling = 4;
49
 
 
50
 
                statEntry = new PMStatEntry(samples, event, metrics, units, deviation,
51
 
                                scaling);
52
 
                statEntry2 = new PMStatEntry(samples, event, metrics, units, deviation,
53
 
                                scaling);
54
 
                statEntry3 = new PMStatEntry(samples++, event, metrics++, units,
55
 
                                deviation++, scaling);
56
 
                statEntry4 = new PMStatEntry(samples--, "event2", metrics--, units,
57
 
                                deviation--, scaling);
58
 
        }
59
 
 
60
 
        @Test
61
 
        public void testPMStatEntryGetters() {
62
 
                assertEquals("event", statEntry.getEvent());
63
 
                assertEquals("unit", statEntry.getUnits());
64
 
                assertEquals(1, statEntry.getSamples(), 0);
65
 
                assertEquals(2, statEntry.getMetrics(), 0);
66
 
                assertEquals(3, statEntry.getDeviation(), 0);
67
 
                assertEquals(4, statEntry.getScaling(), 0);
68
 
        }
69
 
 
70
 
        @Test
71
 
        public void testPMStatEntryEquality() {
72
 
                assertTrue(statEntry.equalEvents(statEntry3));
73
 
                assertFalse(statEntry.equalEvents(statEntry4));
74
 
                assertTrue(statEntry.equals(statEntry2));
75
 
        }
76
 
 
77
 
        @Test
78
 
        public void testPMStatEntryArray() {
79
 
                String[] expectedList = new String[] {
80
 
                                String.valueOf(statEntry.getSamples()), statEntry.getEvent(),
81
 
                                String.valueOf(statEntry.getFormattedMetrics()), statEntry.getUnits(),
82
 
                                String.valueOf(statEntry.getFormattedDeviation()) };
83
 
 
84
 
                String[] actualList = statEntry.toStringArray();
85
 
 
86
 
                // test string array representation
87
 
                assertArrayEquals(expectedList, actualList);
88
 
        }
89
 
 
90
 
        @Test
91
 
        public void testPMStatEntryComparison() {
92
 
                String expectedEvent = "event";
93
 
                String expectedUnits = "unit";
94
 
                float expectedSamples = statEntry.getSamples() - statEntry2.getSamples();
95
 
                float expectedMetrics = statEntry.getMetrics() - statEntry2.getMetrics();
96
 
                float expectedDeviation = statEntry.getDeviation() + statEntry2.getDeviation();
97
 
                float expectedScaling = statEntry.getScaling() + statEntry2.getScaling();
98
 
 
99
 
                PMStatEntry expectedDiff = new PMStatEntry(expectedSamples,
100
 
                                expectedEvent, expectedMetrics, expectedUnits,
101
 
                                expectedDeviation, expectedScaling);
102
 
 
103
 
                PMStatEntry actualDiff = statEntry.compare(statEntry2);
104
 
 
105
 
                // test stat entry comparison
106
 
                assertEquals(expectedDiff,actualDiff);
107
 
 
108
 
        }
109
 
 
110
 
        @Test
111
 
        public void testStatDataCollection() {
112
 
                IPath statData = Path.fromOSString(STAT_RES + "perf_simple.stat");
113
 
 
114
 
                //set up expected result
115
 
                ArrayList<PMStatEntry> expectedStatList = new ArrayList<PMStatEntry>();
116
 
 
117
 
                expectedStatList.add(new PMStatEntry((float) 4.78, "cpu-clock",
118
 
                                (float) 0.0, null, (float) 0.37, (float) 0.0));
119
 
                expectedStatList.add(new PMStatEntry((float) 4.78, "task-clock",
120
 
                                (float) 0.08, "CPUs utilized", (float) 0.37, (float) 0.0));
121
 
                expectedStatList.add(new PMStatEntry((float) 1164.0, "page-faults",
122
 
                                (float) 0.05, "M/sec", (float) 0.01, (float) 0.0));
123
 
                expectedStatList.add(new PMStatEntry((float) 2164.0, "minor-faults",
124
 
                                (float) 0.06, "M/sec", (float) 0.01, (float) 0.0));
125
 
                expectedStatList.add(new PMStatEntry((float) 9.6418E-4,
126
 
                                "seconds time elapsed", (float) 0.0, null, (float) 0.46,
127
 
                                (float) 0.0));
128
 
 
129
 
                ArrayList<PMStatEntry> actualStatList = StatComparisonData.collectStats(statData);
130
 
 
131
 
                assertFalse(actualStatList.isEmpty());
132
 
 
133
 
                for(PMStatEntry expectedEntry : expectedStatList){
134
 
                        assertTrue(actualStatList.contains(expectedEntry));
135
 
                }
136
 
        }
137
 
 
138
 
        @Test
139
 
        public void testStatDataComparisonFieldGetters() {
140
 
                IPath oldStatData = Path.fromOSString(STAT_RES + "perf_old.stat");
141
 
                IPath newStatData = Path.fromOSString(STAT_RES + "perf_new.stat");
142
 
                String dataTitle = "title";
143
 
                StatComparisonData diffData = new StatComparisonData(dataTitle,
144
 
                                oldStatData, newStatData);
145
 
 
146
 
                assertEquals(dataTitle, diffData.getTitle());
147
 
                assertEquals("", diffData.getPerfData());
148
 
                assertNotNull(diffData.getDataID());
149
 
                assertEquals(oldStatData.toOSString(), diffData.getOldDataPath());
150
 
                assertEquals(newStatData.toOSString(), diffData.getNewDataPath());
151
 
                assertEquals(oldStatData.toOSString() + diffData.getDataID(),diffData.getOldDataID());
152
 
                assertEquals(newStatData.toOSString() + diffData.getDataID(),diffData.getNewDataID());
153
 
        }
154
 
 
155
 
        @Test
156
 
        public void testStatDataComparison() {
157
 
                IPath oldStatData = Path.fromOSString(STAT_RES + "perf_old.stat");
158
 
                IPath newStatData = Path.fromOSString(STAT_RES + "perf_new.stat");
159
 
                StatComparisonData diffData = new StatComparisonData("title",
160
 
                                oldStatData, newStatData);
161
 
 
162
 
                // expected comparison list
163
 
                ArrayList<PMStatEntry> expectedDiff = new ArrayList<PMStatEntry>();
164
 
 
165
 
                expectedDiff.add(new PMStatEntry((float) -4.0, "cpu-clock",
166
 
                                (float) 0.0, null, (float) 0.54, (float) 0.0));
167
 
                expectedDiff.add(new PMStatEntry((float) -2000.0, "page-faults",
168
 
                                (float) -0.31, "M/sec", (float) 0.02, (float) 0.0));
169
 
                expectedDiff.add(new PMStatEntry((float) 0.0, "context-switches",
170
 
                                (float) -0.13, "K/sec", (float) 36.34, (float) 0.0));
171
 
                expectedDiff.add(new PMStatEntry((float) -1000.0, "minor-faults",
172
 
                                (float) -0.3, "M/sec", (float) 0.02, (float) 0.0));
173
 
                expectedDiff.add(new PMStatEntry((float) 0.0, "major-faults",
174
 
                                (float) 0.0, "K/sec", (float) 0.0, (float) 0.0));
175
 
                expectedDiff.add(new PMStatEntry((float) -0.008,
176
 
                                "seconds time elapsed", (float) 0.0, null, (float) 0.92,
177
 
                                (float) 0.0));
178
 
 
179
 
                ArrayList<PMStatEntry> actualDiff = diffData.getComparisonStats();
180
 
 
181
 
                assertFalse(actualDiff.isEmpty());
182
 
 
183
 
                for (PMStatEntry expectedEntry : expectedDiff) {
184
 
                        assertTrue(actualDiff.contains(expectedEntry));
185
 
                }
186
 
        }
187
 
 
188
 
        @Test
189
 
        public void testStatComparisonResult() throws IOException {
190
 
                IPath oldStatData = Path.fromOSString(STAT_RES + "perf_old.stat");
191
 
                IPath newStatData = Path.fromOSString(STAT_RES + "perf_new.stat");
192
 
                IPath diffStatData = Path.fromOSString(STAT_RES + "perf_diff.stat");
193
 
 
194
 
                BufferedReader diffDataReader = new BufferedReader(new FileReader(
195
 
                                diffStatData.toFile()));
196
 
                StatComparisonData diffData = new StatComparisonData("title",
197
 
                                oldStatData, newStatData);
198
 
 
199
 
                diffData.runComparison();
200
 
                String actualResult = diffData.getPerfData();
201
 
                String[] actualResultLines = actualResult.split("\n");
202
 
 
203
 
                String curLine;
204
 
                for (int i = 0; i < actualResultLines.length; i++) {
205
 
                        curLine = diffDataReader.readLine();
206
 
 
207
 
                        /**
208
 
                         * Elapsed seconds are usually very close to zero, and thus prone to
209
 
                         * some small formatting differences across systems. Total time
210
 
                         * entry items are checked more thoroughly to avoid test failures.
211
 
                         */
212
 
                        if (curLine.contains(PMStatEntry.TIME)) {
213
 
                                String expectedEntry = curLine.trim();
214
 
                                String actualEntry = actualResultLines[i].trim();
215
 
 
216
 
                                String expectedSamples = expectedEntry.substring(0, expectedEntry.indexOf(" "));
217
 
                                String expectedRest = expectedEntry.substring(expectedEntry.indexOf(" ") + 1);
218
 
 
219
 
                                String actualSamples = actualEntry.substring(0, actualEntry.indexOf(" "));
220
 
                                String actualRest = actualEntry.substring(actualEntry.indexOf(" ") + 1);
221
 
 
222
 
                                assertEquals(StatComparisonData.toFloat(actualSamples),
223
 
                                                StatComparisonData.toFloat(expectedSamples), 0);
224
 
                                assertEquals(actualRest, expectedRest);
225
 
                        } else {
226
 
                                assertEquals(actualResultLines[i], curLine);
227
 
                        }
228
 
                }
229
 
 
230
 
                diffDataReader.close();
231
 
        }
 
32
    private PMStatEntry statEntry;
 
33
    private PMStatEntry statEntry2;
 
34
    private PMStatEntry statEntry3;
 
35
    private PMStatEntry statEntry4;
 
36
    private static final String STAT_RES = "resources/stat-data/";
 
37
 
 
38
    @Before
 
39
    public void setUp() {
 
40
        String event = "event";
 
41
        String units = "unit";
 
42
        float samples = 1;
 
43
        float metrics = 2;
 
44
        float deviation = 3;
 
45
        float scaling = 4;
 
46
 
 
47
        statEntry = new PMStatEntry(samples, event, metrics, units, deviation,
 
48
                scaling);
 
49
        statEntry2 = new PMStatEntry(samples, event, metrics, units, deviation,
 
50
                scaling);
 
51
        statEntry3 = new PMStatEntry(samples++, event, metrics++, units,
 
52
                deviation++, scaling);
 
53
        statEntry4 = new PMStatEntry(samples--, "event2", metrics--, units,
 
54
                deviation--, scaling);
 
55
    }
 
56
 
 
57
    @Test
 
58
    public void testPMStatEntryGetters() {
 
59
        assertEquals("event", statEntry.getEvent());
 
60
        assertEquals("unit", statEntry.getUnits());
 
61
        assertEquals(1, statEntry.getSamples(), 0);
 
62
        assertEquals(2, statEntry.getMetrics(), 0);
 
63
        assertEquals(3, statEntry.getDeviation(), 0);
 
64
        assertEquals(4, statEntry.getScaling(), 0);
 
65
    }
 
66
 
 
67
    @Test
 
68
    public void testPMStatEntryEquality() {
 
69
        assertTrue(statEntry.equalEvents(statEntry3));
 
70
        assertFalse(statEntry.equalEvents(statEntry4));
 
71
        assertTrue(statEntry.equals(statEntry2));
 
72
    }
 
73
 
 
74
    @Test
 
75
    public void testPMStatEntryArray() {
 
76
        String[] expectedList = new String[] {
 
77
                String.valueOf(statEntry.getSamples()), statEntry.getEvent(),
 
78
                String.valueOf(statEntry.getFormattedMetrics()), statEntry.getUnits(),
 
79
                String.valueOf(statEntry.getFormattedDeviation()) };
 
80
 
 
81
        String[] actualList = statEntry.toStringArray();
 
82
 
 
83
        // test string array representation
 
84
        assertArrayEquals(expectedList, actualList);
 
85
    }
 
86
 
 
87
    @Test
 
88
    public void testPMStatEntryComparison() {
 
89
        String expectedEvent = "event";
 
90
        String expectedUnits = "unit";
 
91
        float expectedSamples = statEntry.getSamples() - statEntry2.getSamples();
 
92
        float expectedMetrics = statEntry.getMetrics() - statEntry2.getMetrics();
 
93
        float expectedDeviation = statEntry.getDeviation() + statEntry2.getDeviation();
 
94
        float expectedScaling = statEntry.getScaling() + statEntry2.getScaling();
 
95
 
 
96
        PMStatEntry expectedDiff = new PMStatEntry(expectedSamples,
 
97
                expectedEvent, expectedMetrics, expectedUnits,
 
98
                expectedDeviation, expectedScaling);
 
99
 
 
100
        PMStatEntry actualDiff = statEntry.compare(statEntry2);
 
101
 
 
102
        // test stat entry comparison
 
103
        assertEquals(expectedDiff,actualDiff);
 
104
 
 
105
    }
 
106
 
 
107
    @Test
 
108
    public void testStatDataComparisonFieldGetters() {
 
109
        IPath oldStatData = Path.fromOSString(STAT_RES + "perf_old.stat");
 
110
        IPath newStatData = Path.fromOSString(STAT_RES + "perf_new.stat");
 
111
        String dataTitle = "title";
 
112
        StatComparisonData diffData = new StatComparisonData(dataTitle,
 
113
                oldStatData, newStatData);
 
114
 
 
115
        assertEquals(dataTitle, diffData.getTitle());
 
116
        assertEquals("", diffData.getPerfData());
 
117
        assertNotNull(diffData.getDataID());
 
118
        assertEquals(oldStatData.toOSString(), diffData.getOldDataPath());
 
119
        assertEquals(newStatData.toOSString(), diffData.getNewDataPath());
 
120
        assertEquals(oldStatData.toOSString() + diffData.getDataID(),diffData.getOldDataID());
 
121
        assertEquals(newStatData.toOSString() + diffData.getDataID(),diffData.getNewDataID());
 
122
    }
 
123
 
 
124
    @Test
 
125
    public void testStatDataComparison() {
 
126
        IPath oldStatData = Path.fromOSString(STAT_RES + "perf_old.stat");
 
127
        IPath newStatData = Path.fromOSString(STAT_RES + "perf_new.stat");
 
128
        StatComparisonData diffData = new StatComparisonData("title",
 
129
                oldStatData, newStatData);
 
130
 
 
131
        // expected comparison list
 
132
        ArrayList<PMStatEntry> expectedDiff = new ArrayList<>();
 
133
 
 
134
        expectedDiff.add(new PMStatEntry((float) -4.0, "cpu-clock",
 
135
                (float) 0.0, null, (float) 0.54, (float) 0.0));
 
136
        expectedDiff.add(new PMStatEntry((float) -2000.0, "page-faults",
 
137
                (float) -0.31, "M/sec", (float) 0.02, (float) 0.0));
 
138
        expectedDiff.add(new PMStatEntry((float) 0.0, "context-switches",
 
139
                (float) -0.13, "K/sec", (float) 36.34, (float) 0.0));
 
140
        expectedDiff.add(new PMStatEntry((float) -1000.0, "minor-faults",
 
141
                (float) -0.3, "M/sec", (float) 0.02, (float) 0.0));
 
142
        expectedDiff.add(new PMStatEntry((float) 0.0, "major-faults",
 
143
                (float) 0.0, "K/sec", (float) 0.0, (float) 0.0));
 
144
        expectedDiff.add(new PMStatEntry((float) -0.008,
 
145
                "seconds time elapsed", (float) 0.0, null, (float) 0.92,
 
146
                (float) 0.0));
 
147
 
 
148
        ArrayList<PMStatEntry> actualDiff = diffData.getComparisonStats();
 
149
 
 
150
        assertFalse(actualDiff.isEmpty());
 
151
 
 
152
        for (PMStatEntry expectedEntry : expectedDiff) {
 
153
            assertTrue(actualDiff.contains(expectedEntry));
 
154
        }
 
155
    }
 
156
 
 
157
    @Test
 
158
    public void testStatComparisonResult() throws IOException {
 
159
        IPath oldStatData = Path.fromOSString(STAT_RES + "perf_old.stat");
 
160
        IPath newStatData = Path.fromOSString(STAT_RES + "perf_new.stat");
 
161
        IPath diffStatData = Path.fromOSString(STAT_RES + "perf_diff.stat");
 
162
 
 
163
        try (BufferedReader diffDataReader = new BufferedReader(new FileReader(
 
164
                diffStatData.toFile()))) {
 
165
            StatComparisonData diffData = new StatComparisonData("title",
 
166
                    oldStatData, newStatData);
 
167
 
 
168
            diffData.runComparison();
 
169
            String actualResult = diffData.getPerfData();
 
170
            String[] actualResultLines = actualResult.split("\n");
 
171
 
 
172
            String curLine;
 
173
            for (int i = 0; i < actualResultLines.length; i++) {
 
174
                curLine = diffDataReader.readLine();
 
175
 
 
176
                /**
 
177
                 * Elapsed seconds are usually very close to zero, and thus
 
178
                 * prone to some small formatting differences across systems.
 
179
                 * Total time entry items are checked more thoroughly to avoid
 
180
                 * test failures.
 
181
                 */
 
182
                if (curLine.contains(PMStatEntry.TIME)) {
 
183
                    String expectedEntry = curLine.trim();
 
184
                    String actualEntry = actualResultLines[i].trim();
 
185
 
 
186
                    String expectedSamples = expectedEntry.substring(0,
 
187
                            expectedEntry.indexOf(" "));
 
188
                    String expectedRest = expectedEntry.substring(expectedEntry
 
189
                            .indexOf(" ") + 1);
 
190
 
 
191
                    String actualSamples = actualEntry.substring(0,
 
192
                            actualEntry.indexOf(" "));
 
193
                    String actualRest = actualEntry.substring(actualEntry
 
194
                            .indexOf(" ") + 1);
 
195
 
 
196
                    assertEquals(StatComparisonData.toFloat(actualSamples),
 
197
                            StatComparisonData.toFloat(expectedSamples), 0);
 
198
                    assertEquals(actualRest, expectedRest);
 
199
                } else {
 
200
                    assertEquals(actualResultLines[i], curLine);
 
201
                }
 
202
            }
 
203
        }
 
204
 
 
205
    }
232
206
}