View Javadoc

1   package org.apache.helix.alerts;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.util.ArrayList;
23  import java.util.Iterator;
24  import java.util.List;
25  import java.util.Map;
26  
27  import org.apache.helix.alerts.SumEachOperator;
28  import org.apache.helix.alerts.SumOperator;
29  import org.apache.helix.alerts.Tuple;
30  import org.testng.AssertJUnit;
31  import org.testng.annotations.BeforeMethod;
32  import org.testng.annotations.Test;
33  
34  
35  
36  public class TestOperators {
37  	
38  	SumOperator _sumOp;
39  	SumEachOperator _sumEachOp;
40  	
41  	@BeforeMethod (groups = {"unitTest"})
42  	public void setup()
43  	{
44  		_sumOp = new SumOperator();
45  		_sumEachOp = new SumEachOperator();
46  	}
47  	
48  	
49  	@Test (groups = {"unitTest"})
50  	public void testTwoNulls()
51  	{
52  		Tuple<String> tup1 = null;
53  		Tuple<String> tup2 = null;
54  		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
55  		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
56  		tup1List.add(tup1);
57  		tup2List.add(tup2);
58  		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
59  		tupsList.add(tup1List.iterator());
60  		tupsList.add(tup2List.iterator());
61  		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
62  		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
63  		Iterator<Tuple<String>> resultIter = result.get(0);
64  		AssertJUnit.assertTrue(resultIter.hasNext());
65  		Tuple<String>resultTup = resultIter.next();
66  		AssertJUnit.assertEquals(null, resultTup);
67  	}
68  	
69  	@Test (groups = {"unitTest"})
70  	public void testOneNullLeft()
71  	{
72  		Tuple<String> tup1 = null;
73  		Tuple<String> tup2 = new Tuple<String>();
74  		tup2.add("1.0");
75  		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
76  		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
77  		tup1List.add(tup1);
78  		tup2List.add(tup2);
79  		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
80  		tupsList.add(tup1List.iterator());
81  		tupsList.add(tup2List.iterator());
82  		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
83  		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
84  		Iterator<Tuple<String>> resultIter = result.get(0);
85  		AssertJUnit.assertTrue(resultIter.hasNext());
86  		Tuple<String>resultTup = resultIter.next();
87  		AssertJUnit.assertEquals("1.0", resultTup.toString());
88  	}
89  	
90  	@Test (groups = {"unitTest"})
91  	public void testOneNullRight()
92  	{
93  		Tuple<String> tup1 = new Tuple<String>();
94  		Tuple<String> tup2 = null;
95  		tup1.add("1.0");
96  		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
97  		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
98  		tup1List.add(tup1);
99  		tup2List.add(tup2);
100 		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
101 		tupsList.add(tup1List.iterator());
102 		tupsList.add(tup2List.iterator());
103 		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
104 		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
105 		Iterator<Tuple<String>> resultIter = result.get(0);
106 		AssertJUnit.assertTrue(resultIter.hasNext());
107 		Tuple<String>resultTup = resultIter.next();
108 		AssertJUnit.assertEquals("1.0", resultTup.toString());
109 	}
110 	
111 	@Test (groups = {"unitTest"})
112 	public void testTwoSingeltons()
113 	{
114 		Tuple<String> tup1 = new Tuple<String>();
115 		Tuple<String> tup2 = new Tuple<String>();
116 		tup1.add("1.0");
117 		tup2.add("2.0");
118 		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
119 		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
120 		tup1List.add(tup1);
121 		tup2List.add(tup2);
122 		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
123 		tupsList.add(tup1List.iterator());
124 		tupsList.add(tup2List.iterator());
125 		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
126 		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
127 		Iterator<Tuple<String>> resultIter = result.get(0);
128 		AssertJUnit.assertTrue(resultIter.hasNext());
129 		Tuple<String>resultTup = resultIter.next();
130 		AssertJUnit.assertEquals("3.0", resultTup.toString());
131 	}
132 	
133 	@Test (groups = {"unitTest"})
134 	public void testThreeSingeltons()
135 	{
136 		Tuple<String> tup1 = new Tuple<String>();
137 		Tuple<String> tup2 = new Tuple<String>();
138 		Tuple<String> tup3 = new Tuple<String>();
139 		tup1.add("1.0");
140 		tup2.add("2.0");
141 		tup3.add("3.0");
142 		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
143 		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
144 		List<Tuple<String>> tup3List = new ArrayList<Tuple<String>>();
145 		tup1List.add(tup1);
146 		tup2List.add(tup2);
147 		tup3List.add(tup3);
148 		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
149 		tupsList.add(tup1List.iterator());
150 		tupsList.add(tup2List.iterator());
151 		tupsList.add(tup3List.iterator());
152 		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
153 		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
154 		Iterator<Tuple<String>> resultIter = result.get(0);
155 		AssertJUnit.assertTrue(resultIter.hasNext());
156 		Tuple<String>resultTup = resultIter.next();
157 		AssertJUnit.assertEquals("6.0", resultTup.toString());
158 	}
159 	
160 	@Test (groups = {"unitTest"})
161 	public void testThreeTriples()
162 	{
163 		Tuple<String> tup1 = new Tuple<String>();
164 		Tuple<String> tup2 = new Tuple<String>();
165 		Tuple<String> tup3 = new Tuple<String>();
166 		tup1.add("1.0"); tup1.add("2.0"); tup1.add("3.0");
167 		tup2.add("4.0"); tup2.add("5.0"); tup2.add("6.0");
168 		tup3.add("7.0"); tup3.add("8.0"); tup3.add("9.0");
169 		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
170 		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
171 		List<Tuple<String>> tup3List = new ArrayList<Tuple<String>>();
172 		tup1List.add(tup1);
173 		tup2List.add(tup2);
174 		tup3List.add(tup3);
175 		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
176 		tupsList.add(tup1List.iterator());
177 		tupsList.add(tup2List.iterator());
178 		tupsList.add(tup3List.iterator());
179 		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
180 		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
181 		Iterator<Tuple<String>> resultIter = result.get(0);
182 		AssertJUnit.assertTrue(resultIter.hasNext());
183 		Tuple<String>resultTup = resultIter.next();
184 		AssertJUnit.assertEquals("12.0,15.0,18.0", resultTup.toString());
185 	}
186 	
187 	@Test (groups = {"unitTest"})
188 	public void testThreeTriplesOneMissing()
189 	{
190 		Tuple<String> tup1 = new Tuple<String>();
191 		Tuple<String> tup2 = new Tuple<String>();
192 		Tuple<String> tup3 = new Tuple<String>();
193 		tup1.add("1.0"); tup1.add("2.0"); tup1.add("3.0");
194 		tup2.add("5.0"); tup2.add("6.0");
195 		tup3.add("7.0"); tup3.add("8.0"); tup3.add("9.0");
196 		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
197 		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
198 		List<Tuple<String>> tup3List = new ArrayList<Tuple<String>>();
199 		tup1List.add(tup1);
200 		tup2List.add(tup2);
201 		tup3List.add(tup3);
202 		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
203 		tupsList.add(tup1List.iterator());
204 		tupsList.add(tup2List.iterator());
205 		tupsList.add(tup3List.iterator());
206 		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
207 		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
208 		Iterator<Tuple<String>> resultIter = result.get(0);
209 		AssertJUnit.assertTrue(resultIter.hasNext());
210 		Tuple<String>resultTup = resultIter.next();
211 		//tuple 2 missing 1 entry, other 2 get bumped to right
212 		AssertJUnit.assertEquals("8.0,15.0,18.0", resultTup.toString());
213 	}
214 
215 	//test multiple rows
216 	@Test (groups = {"unitTest"})
217 	public void testThreeTriplesOneMissingTwoRows()
218 	{
219 		Tuple<String> tup1Dot1 = new Tuple<String>();
220 		Tuple<String> tup2Dot1 = new Tuple<String>();
221 		Tuple<String> tup3Dot1 = new Tuple<String>();
222 		Tuple<String> tup1Dot2 = new Tuple<String>();
223 		Tuple<String> tup2Dot2 = new Tuple<String>();
224 		Tuple<String> tup3Dot2 = new Tuple<String>();
225 		tup1Dot1.add("1.0"); tup1Dot1.add("2.0"); tup1Dot1.add("3.0");
226 		tup2Dot1.add("5.0"); tup2Dot1.add("6.0");
227 		tup3Dot1.add("7.0"); tup3Dot1.add("8.0"); tup3Dot1.add("9.0");
228 		tup1Dot2.add("10.0"); tup1Dot2.add("11.0"); tup1Dot2.add("12.0");
229 		tup2Dot2.add("13.0"); tup2Dot2.add("14.0"); tup2Dot2.add("15.0");
230 		tup3Dot2.add("16.0"); tup3Dot2.add("17.0"); tup3Dot2.add("18.0");
231 		List<Tuple<String>> tup1List = new ArrayList<Tuple<String>>();
232 		List<Tuple<String>> tup2List = new ArrayList<Tuple<String>>();
233 		List<Tuple<String>> tup3List = new ArrayList<Tuple<String>>();
234 		tup1List.add(tup1Dot1);
235 		tup2List.add(tup2Dot1);
236 		tup3List.add(tup3Dot1);
237 		tup1List.add(tup1Dot2);
238 		tup2List.add(tup2Dot2);
239 		tup3List.add(tup3Dot2);
240 		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
241 		tupsList.add(tup1List.iterator());
242 		tupsList.add(tup2List.iterator());
243 		tupsList.add(tup3List.iterator());
244 		List<Iterator<Tuple<String>>> result = _sumOp.execute(tupsList);
245 		AssertJUnit.assertEquals(1, result.size()); //should be just 1 iter
246 		Iterator<Tuple<String>> resultIter = result.get(0);
247 		AssertJUnit.assertTrue(resultIter.hasNext());
248 		Tuple<String>resultTup1 = resultIter.next();
249 		//tuple 2 missing 1 entry, other 2 get bumped to right
250 		AssertJUnit.assertEquals("8.0,15.0,18.0", resultTup1.toString());
251 		AssertJUnit.assertTrue(resultIter.hasNext());
252 		Tuple<String>resultTup2 = resultIter.next();
253 		AssertJUnit.assertEquals("39.0,42.0,45.0", resultTup2.toString());
254 	}
255 	
256 	@Test (groups = {"unitTest"})
257 	public void testSumAll()
258 	{
259 		Tuple<String> tup1 = new Tuple<String>();
260 		Tuple<String> tup2 = new Tuple<String>();
261 		Tuple<String> tup3 = new Tuple<String>();
262 		Tuple<String> tup4 = new Tuple<String>();
263 		Tuple<String> tup5 = new Tuple<String>();
264 		Tuple<String> tup6 = new Tuple<String>();
265 		tup1.add("1.0"); tup2.add("2.0"); tup3.add("3.0");
266 		tup4.add("4.0"); tup5.add("5.0"); tup6.add("6.0");
267 		List<Tuple<String>> list1 = new ArrayList<Tuple<String>>();
268 		List<Tuple<String>> list2 = new ArrayList<Tuple<String>>();
269 		List<Tuple<String>> list3 = new ArrayList<Tuple<String>>();
270 		list1.add(tup1); list1.add(tup4); 
271 		list2.add(tup2); list2.add(tup5);
272 		list3.add(tup3); list3.add(tup6);
273 		
274 		List<Iterator<Tuple<String>>> tupsList = new ArrayList<Iterator<Tuple<String>>>();
275 		tupsList.add(list1.iterator());
276 		tupsList.add(list2.iterator());
277 		tupsList.add(list3.iterator());
278 		List<Iterator<Tuple<String>>> result = _sumEachOp.execute(tupsList);
279 		AssertJUnit.assertEquals(3, result.size()); //should be just 1 iter
280 		Iterator<Tuple<String>> resultIter = result.get(0);
281 		AssertJUnit.assertTrue(resultIter.hasNext());
282 		Tuple<String>resultTup1 = resultIter.next();
283 		AssertJUnit.assertEquals("5.0", resultTup1.toString());
284 		resultIter = result.get(1);
285 		AssertJUnit.assertTrue(resultIter.hasNext());
286 		resultTup1 = resultIter.next();
287 		AssertJUnit.assertEquals("7.0", resultTup1.toString());
288 		resultIter = result.get(2);
289 		AssertJUnit.assertTrue(resultIter.hasNext());
290 		resultTup1 = resultIter.next();
291 		AssertJUnit.assertEquals("9.0", resultTup1.toString());
292 	}
293 }