Brendan Jackman | e81fdcb | 2017-01-04 17:10:29 +0000 | [diff] [blame] | 1 | # Copyright 2015-2017 ARM Limited |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 2 | # |
Javi Merino | aace7c0 | 2015-08-10 14:10:47 +0100 | [diff] [blame] | 3 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | # you may not use this file except in compliance with the License. |
| 5 | # You may obtain a copy of the License at |
| 6 | # |
| 7 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | # |
| 9 | # Unless required by applicable law or agreed to in writing, software |
| 10 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | # See the License for the specific language governing permissions and |
| 13 | # limitations under the License. |
| 14 | # |
| 15 | |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 16 | |
| 17 | import pandas as pd |
| 18 | import unittest |
| 19 | |
Javi Merino | 435457c | 2015-08-10 15:59:10 +0100 | [diff] [blame] | 20 | from trappy.plotter import AttrConf |
Brendan Jackman | 085a026 | 2016-11-02 14:30:18 +0000 | [diff] [blame] | 21 | from trappy.plotter.Constraint import Constraint, ConstraintManager |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 22 | |
| 23 | class TestConstraintManager(unittest.TestCase): |
Javi Merino | 435457c | 2015-08-10 15:59:10 +0100 | [diff] [blame] | 24 | """Test trappy.plotter.ConstraintManager""" |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 25 | |
| 26 | def __init__(self, *args, **kwargs): |
| 27 | """Init some common data for the tests""" |
| 28 | |
| 29 | self.dfrs = [pd.DataFrame({"load": [1, 2, 2, 3], |
| 30 | "freq": [2, 3, 3, 4], |
| 31 | "cpu": [0, 1, 0, 1]}), |
| 32 | pd.DataFrame({"load": [2, 3, 2, 1], |
| 33 | "freq": [1, 2, 2, 1], |
| 34 | "cpu": [1, 0, 1, 0]})] |
Javi Merino | 9a08e4c | 2015-06-22 17:59:45 +0100 | [diff] [blame] | 35 | self.cols = ["load", "freq"] |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 36 | super(TestConstraintManager, self).__init__(*args, **kwargs) |
| 37 | |
| 38 | def test_one_constraint(self): |
| 39 | """Test that the constraint manager works with one constraint""" |
| 40 | |
| 41 | dfr = self.dfrs[0] |
| 42 | |
| 43 | c_mgr = ConstraintManager(dfr, "load", None, AttrConf.PIVOT, {}) |
| 44 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 45 | self.assertEquals(len(c_mgr), 1) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 46 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 47 | constraint = iter(c_mgr).next() |
| 48 | series = constraint.result[AttrConf.PIVOT_VAL] |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 49 | self.assertEquals(series.to_dict().values(), |
| 50 | dfr["load"].to_dict().values()) |
| 51 | |
Javi Merino | c26a323 | 2015-12-11 18:00:30 +0000 | [diff] [blame] | 52 | def test_no_pivot_multiple_traces(self): |
| 53 | """Test that the constraint manager works with multiple traces and no pivots""" |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 54 | |
| 55 | c_mgr = ConstraintManager(self.dfrs, "load", None, AttrConf.PIVOT, {}) |
| 56 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 57 | self.assertEquals(len(c_mgr), 2) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 58 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 59 | for constraint, orig_dfr in zip(c_mgr, self.dfrs): |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 60 | series = constraint.result[AttrConf.PIVOT_VAL] |
| 61 | self.assertEquals(series.to_dict().values(), |
| 62 | orig_dfr["load"].to_dict().values()) |
| 63 | |
Javi Merino | c26a323 | 2015-12-11 18:00:30 +0000 | [diff] [blame] | 64 | def test_no_pivot_zipped_columns_and_traces(self): |
| 65 | """Test the constraint manager with multiple columns and traces zipped""" |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 66 | |
Javi Merino | 9a08e4c | 2015-06-22 17:59:45 +0100 | [diff] [blame] | 67 | c_mgr = ConstraintManager(self.dfrs, self.cols, None, AttrConf.PIVOT, {}) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 68 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 69 | self.assertEquals(len(c_mgr), 2) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 70 | |
Javi Merino | 9a08e4c | 2015-06-22 17:59:45 +0100 | [diff] [blame] | 71 | for constraint, orig_dfr, col in zip(c_mgr, self.dfrs, self.cols): |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 72 | series = constraint.result[AttrConf.PIVOT_VAL] |
| 73 | self.assertEquals(series.to_dict().values(), |
| 74 | orig_dfr[col].to_dict().values()) |
| 75 | |
Javi Merino | c26a323 | 2015-12-11 18:00:30 +0000 | [diff] [blame] | 76 | def test_no_pivot_multicolumns_multitraces(self): |
| 77 | """Test the constraint manager with multiple traces that can have each multiple columns""" |
Javi Merino | 9a08e4c | 2015-06-22 17:59:45 +0100 | [diff] [blame] | 78 | |
| 79 | c_mgr = ConstraintManager(self.dfrs, self.cols, None, AttrConf.PIVOT, |
| 80 | {}, zip_constraints=False) |
| 81 | |
| 82 | self.assertEquals(len(c_mgr), 4) |
| 83 | |
| 84 | expected_series = [dfr[col] for dfr in self.dfrs for col in self.cols] |
| 85 | for constraint, orig_series in zip(c_mgr, expected_series): |
| 86 | series = constraint.result[AttrConf.PIVOT_VAL] |
| 87 | self.assertEquals(series.to_dict(), orig_series.to_dict()) |
| 88 | |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 89 | def test_no_pivot_filters(self): |
| 90 | """Test the constraint manager with filters""" |
| 91 | |
| 92 | simple_filter = {"freq": [2]} |
| 93 | |
| 94 | c_mgr = ConstraintManager(self.dfrs, "load", None, AttrConf.PIVOT, |
| 95 | simple_filter) |
| 96 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 97 | num_constraints = len(c_mgr) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 98 | self.assertEquals(num_constraints, 2) |
| 99 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 100 | constraint_iter = iter(c_mgr) |
| 101 | constraint = constraint_iter.next() |
| 102 | self.assertEquals(len(constraint.result), 1) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 103 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 104 | constraint = constraint_iter.next() |
| 105 | series_second_frame = constraint.result[AttrConf.PIVOT_VAL] |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 106 | self.assertEquals(series_second_frame.to_dict().values(), [3, 2]) |
| 107 | |
| 108 | def test_pivoted_data(self): |
Javi Merino | c26a323 | 2015-12-11 18:00:30 +0000 | [diff] [blame] | 109 | """Test the constraint manager with a pivot and one trace""" |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 110 | |
| 111 | c_mgr = ConstraintManager(self.dfrs[0], "load", None, "cpu", {}) |
| 112 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 113 | self.assertEquals(len(c_mgr), 1) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 114 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 115 | constraint = iter(c_mgr).next() |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 116 | results = dict([(k, v.to_dict().values()) for k, v in constraint.result.items()]) |
| 117 | expected_results = {0: [1, 2], 1: [2, 3]} |
| 118 | |
| 119 | self.assertEquals(results, expected_results) |
| 120 | |
Javi Merino | c26a323 | 2015-12-11 18:00:30 +0000 | [diff] [blame] | 121 | def test_pivoted_multitrace(self): |
| 122 | """Test the constraint manager with a pivot and multiple traces""" |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 123 | |
| 124 | c_mgr = ConstraintManager(self.dfrs, "load", None, "cpu", {}) |
| 125 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 126 | self.assertEquals(len(c_mgr), 2) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 127 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 128 | constraint_iter = iter(c_mgr) |
| 129 | constraint = constraint_iter.next() |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 130 | self.assertEquals(constraint.result[0].to_dict().values(), [1, 2]) |
| 131 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 132 | constraint = constraint_iter.next() |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 133 | self.assertEquals(constraint.result[1].to_dict().values(), [2, 2]) |
| 134 | |
Javi Merino | c26a323 | 2015-12-11 18:00:30 +0000 | [diff] [blame] | 135 | def test_pivoted_multitraces_multicolumns(self): |
| 136 | """Test the constraint manager with multiple traces and columns""" |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 137 | |
| 138 | c_mgr = ConstraintManager(self.dfrs, ["load", "freq"], None, "cpu", {}) |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 139 | self.assertEquals(len(c_mgr), 2) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 140 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 141 | constraint_iter = iter(c_mgr) |
| 142 | constraint = constraint_iter.next() |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 143 | self.assertEquals(constraint.result[1].to_dict().values(), [2, 3]) |
| 144 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 145 | constraint = constraint_iter.next() |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 146 | self.assertEquals(constraint.result[0].to_dict().values(), [2, 1]) |
| 147 | |
| 148 | def test_pivoted_with_filters(self): |
| 149 | """Test the constraint manager with pivoted data and filters""" |
| 150 | |
| 151 | simple_filter = {"load": [2]} |
| 152 | c_mgr = ConstraintManager(self.dfrs[0], "freq", None, "cpu", |
| 153 | simple_filter) |
| 154 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 155 | self.assertEquals(len(c_mgr), 1) |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 156 | |
Javi Merino | b23658c | 2015-06-22 17:04:02 +0100 | [diff] [blame] | 157 | constraint = iter(c_mgr).next() |
Javi Merino | e4d10d7 | 2015-06-22 16:43:04 +0100 | [diff] [blame] | 158 | result = constraint.result |
| 159 | |
| 160 | self.assertEquals(result[0].iloc[0], 3) |
| 161 | self.assertEquals(result[1].iloc[0], 3) |
Javi Merino | e6274bd | 2016-07-04 18:46:52 +0100 | [diff] [blame] | 162 | |
| 163 | def test_constraint_with_window(self): |
| 164 | """Test that the constraint manager can constraint to a window of time""" |
| 165 | c_mgr = ConstraintManager(self.dfrs[0], "freq", None, AttrConf.PIVOT, {}, |
| 166 | window=(1, 3)) |
| 167 | |
| 168 | constraint = iter(c_mgr).next() |
| 169 | series = constraint.result[AttrConf.PIVOT_VAL] |
| 170 | self.assertEquals(len(series), 3) |
| 171 | |
| 172 | # For the graph to plot a value at 0.75, the resulting series |
| 173 | # must contain the value before 0.75. Same for the upper limit. |
| 174 | c_mgr = ConstraintManager(self.dfrs[0], "freq", None, AttrConf.PIVOT, {}, |
| 175 | window=(0.75, 1.5)) |
| 176 | |
| 177 | constraint = iter(c_mgr).next() |
| 178 | series = constraint.result[AttrConf.PIVOT_VAL] |
| 179 | self.assertEquals(series.index.tolist(), [0, 1, 2]) |
| 180 | |
| 181 | c_mgr = ConstraintManager(self.dfrs[0], "freq", None, AttrConf.PIVOT, {}, |
| 182 | window=(0, 2)) |
| 183 | |
| 184 | constraint = iter(c_mgr).next() |
| 185 | series = constraint.result[AttrConf.PIVOT_VAL] |
| 186 | self.assertEquals(len(series), 3) |
Brendan Jackman | 085a026 | 2016-11-02 14:30:18 +0000 | [diff] [blame] | 187 | |
| 188 | class TestConstraint(unittest.TestCase): |
| 189 | def test_str_constraint(self): |
| 190 | """str(constraint) doesn't fail when the column is not a string""" |
| 191 | dfr = pd.DataFrame({12: [1, 2, 3], 13: [3, 4, 5]}) |
| 192 | |
| 193 | constraint = Constraint(dfr, AttrConf.PIVOT, 12, template=None, |
| 194 | trace_index=0, filters={}, window=None) |
| 195 | |
| 196 | self.assertEqual(str(constraint), "DataFrame 0:12") |