Clover Coverage Report - KS Common 1.1.0-M10-SNAPSHOT (Aggregated)
Coverage timestamp: Fri Dec 17 2010 05:47:43 EST
Overview   Package   File
    FRAMES   NO FRAMES     
187   329   9   23.38
0   248   0.05   8
8     1.12  
1    
 
  SimpleBooleanMessageBuilderTest       Line # 16 187 0% 9 1 99.5% 0.9948718
 
  (7)
 
1    package org.kuali.student.common.messagebuilder.impl;
2   
3    import java.util.ArrayList;
4    import java.util.List;
5   
6    import org.antlr.runtime.Token;
7    import org.antlr.runtime.tree.CommonTreeAdaptor;
8    import org.junit.Assert;
9    import org.junit.Before;
10    import org.junit.Test;
11    import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanNode;
12    import org.kuali.student.common.messagebuilder.booleanmessage.ast.parsers.BooleanFunctionParser;
13    import org.kuali.student.common.messagebuilder.impl.BooleanOperators;
14    import org.kuali.student.common.messagebuilder.impl.exceptions.MessageBuilderException;
15   
 
16    public class SimpleBooleanMessageBuilderTest {
17    private final static CommonTreeAdaptor adapter = new CommonTreeAdaptor();
18    private SimpleBooleanMessageBuilder defaultMessageBuilder;
19    private SimpleBooleanMessageBuilder configuredMessageBuilder;
20   
 
21  7 toggle @Before
22    public void setUp() throws Exception {
23  7 BooleanOperators bo = new BooleanOperators("AND", "OR");
24  7 defaultMessageBuilder = new SimpleBooleanMessageBuilder(bo);
25   
26  7 configuredMessageBuilder = new SimpleBooleanMessageBuilder(bo);
27  7 configuredMessageBuilder.setIndentCharacter(32);
28  7 configuredMessageBuilder.setIndentNumberOfSpaces(4);
29  7 configuredMessageBuilder.setIndentString(" ");
30  7 configuredMessageBuilder.setBooleanOperatorPrefix("\n");
31  7 configuredMessageBuilder.setBooleanOperatorSuffix("\n");
32    }
33   
 
34  1 toggle @Test
35    public void testBuildMessage_DefaultConfig_SingleAndNode() throws Exception {
36    // Rule: A AND B
37  1 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
38  1 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
39  1 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
40   
41  1 BooleanNode andNode = new BooleanNode(and);
42   
43  1 BooleanNode aNode = new BooleanNode(a);
44  1 aNode.setParent(andNode);
45  1 aNode.setNodeMessage("MATH101");
46   
47  1 BooleanNode bNode = new BooleanNode(b);
48  1 bNode.setParent(andNode);
49  1 bNode.setNodeMessage("MATH201");
50   
51  1 andNode.addChild(aNode); // left node
52  1 andNode.addChild(bNode); // right node
53   
54  1 String msg = defaultMessageBuilder.buildMessage(andNode);
55   
56  1 Assert.assertEquals("MATH101 AND MATH201", msg);
57    }
58   
 
59  1 toggle @Test
60    public void testBuildMessage_DefaultConfig_ForListOfNodes() throws Exception {
61    // Rule: A AND (B OR C)
62  1 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
63  1 Token or = adapter.createToken(BooleanFunctionParser.OR, "+");
64  1 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
65  1 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
66  1 Token c = adapter.createToken(BooleanFunctionParser.ALPHA, "C");
67   
68    // root node
69  1 BooleanNode andNode = new BooleanNode(and);
70  1 BooleanNode orNode = new BooleanNode(or);
71  1 orNode.setParent(andNode);
72   
73  1 BooleanNode aNode = new BooleanNode(a);
74  1 aNode.setParent(andNode);
75  1 aNode.setNodeMessage("MATH101");
76   
77  1 BooleanNode bNode = new BooleanNode(b);
78  1 bNode.setParent(orNode);
79  1 bNode.setNodeMessage("MATH201");
80   
81  1 BooleanNode cNode = new BooleanNode(c);
82  1 cNode.setParent(orNode);
83  1 cNode.setNodeMessage("MATH301");
84   
85  1 orNode.addChild(bNode); // left node
86  1 orNode.addChild(cNode); // right node
87  1 andNode.addChild(aNode); // left node
88  1 andNode.addChild(orNode); // right node
89   
90    // List of nodes order is important for building success message
91  1 List<BooleanNode> list = new ArrayList<BooleanNode>();
92  1 list.add(cNode);
93  1 list.add(bNode);
94  1 list.add(orNode);
95  1 list.add(aNode);
96  1 list.add(andNode);
97   
98  1 defaultMessageBuilder.buildMessage(list);
99   
100  1 Assert.assertEquals("MATH101 AND (MATH201 OR MATH301)", andNode.getNodeMessage());
101    }
102   
 
103  1 toggle @Test
104    public void testBuildMessage_ForSingleAndNode() throws Exception {
105    // Rule: A AND B
106  1 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
107  1 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
108  1 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
109   
110  1 BooleanNode andNode = new BooleanNode(and);
111   
112  1 BooleanNode aNode = new BooleanNode(a);
113  1 aNode.setParent(andNode);
114  1 aNode.setNodeMessage("MATH101");
115   
116  1 BooleanNode bNode = new BooleanNode(b);
117  1 bNode.setParent(andNode);
118  1 bNode.setNodeMessage("MATH201");
119   
120  1 andNode.addChild(aNode); // left node
121  1 andNode.addChild(bNode); // right node
122   
123  1 String msg = configuredMessageBuilder.buildMessage(andNode);
124   
125  1 Assert.assertEquals(" MATH101\nAND\n MATH201", msg);
126    }
127   
 
128  1 toggle @Test
129    public void testBuildMessage_ForSingleOrNode() throws Exception {
130    // Rule: A OR B
131  1 Token and = adapter.createToken(BooleanFunctionParser.OR, "+");
132  1 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
133  1 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
134   
135    // root node
136  1 BooleanNode andNode = new BooleanNode(and);
137   
138  1 BooleanNode aNode = new BooleanNode(a);
139  1 aNode.setParent(andNode);
140  1 aNode.setValue(Boolean.TRUE);
141  1 aNode.setNodeMessage("MATH101");
142   
143  1 BooleanNode bNode = new BooleanNode(b);
144  1 bNode.setParent(andNode);
145  1 bNode.setValue(Boolean.FALSE);
146  1 bNode.setNodeMessage("MATH201");
147   
148  1 andNode.addChild(aNode); // left node
149  1 andNode.addChild(bNode); // right node
150   
151  1 String msg = configuredMessageBuilder.buildMessage(andNode);
152   
153  1 Assert.assertEquals(" MATH101\nOR\n MATH201", msg);
154    }
155   
 
156  1 toggle @Test
157    public void testBuildMessage_ForListOfNodes_Complex() throws Exception {
158    // Rule: (A AND B) OR (C AND (D OR E))
159  1 Token or1 = adapter.createToken(BooleanFunctionParser.OR, "+");
160  1 Token or2 = adapter.createToken(BooleanFunctionParser.OR, "+");
161  1 Token and1 = adapter.createToken(BooleanFunctionParser.AND, "*");
162  1 Token and2 = adapter.createToken(BooleanFunctionParser.AND, "*");
163  1 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
164  1 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
165  1 Token c = adapter.createToken(BooleanFunctionParser.ALPHA, "C");
166  1 Token d = adapter.createToken(BooleanFunctionParser.ALPHA, "D");
167  1 Token e = adapter.createToken(BooleanFunctionParser.ALPHA, "E");
168   
169    // root node
170  1 BooleanNode orNode1 = new BooleanNode(or1);
171   
172  1 BooleanNode andNode1 = new BooleanNode(and1);
173  1 andNode1.setParent(orNode1);
174   
175  1 BooleanNode andNode2 = new BooleanNode(and2);
176  1 andNode2.setParent(orNode1);
177   
178  1 BooleanNode orNode2 = new BooleanNode(or2);
179  1 orNode2.setParent(andNode2);
180   
181  1 BooleanNode aNode = new BooleanNode(a);
182  1 aNode.setParent(andNode1);
183  1 aNode.setNodeMessage("MATH101");
184   
185  1 BooleanNode bNode = new BooleanNode(b);
186  1 bNode.setParent(andNode1);
187  1 bNode.setNodeMessage("MATH102");
188   
189  1 BooleanNode cNode = new BooleanNode(c);
190  1 cNode.setParent(andNode2);
191  1 cNode.setNodeMessage("MATH201");
192   
193  1 BooleanNode dNode = new BooleanNode(d);
194  1 dNode.setParent(orNode2);
195  1 dNode.setNodeMessage("MATH202");
196   
197  1 BooleanNode eNode = new BooleanNode(e);
198  1 eNode.setParent(orNode2);
199  1 eNode.setNodeMessage("MATH301");
200   
201  1 orNode1.addChild(andNode1); // left node
202  1 orNode1.addChild(andNode2); // right node
203  1 andNode1.addChild(aNode); // left node
204  1 andNode1.addChild(bNode); // right node
205  1 andNode2.addChild(cNode); // left node
206  1 andNode2.addChild(orNode2); // right node
207  1 orNode2.addChild(dNode); // right node
208  1 orNode2.addChild(eNode); // right node
209   
210    // List of nodes order is important for building success message
211  1 List<BooleanNode> list = new ArrayList<BooleanNode>();
212  1 list.add(dNode);
213  1 list.add(eNode);
214  1 list.add(orNode2);
215  1 list.add(aNode);
216  1 list.add(bNode);
217  1 list.add(cNode);
218  1 list.add(andNode1);
219  1 list.add(andNode2);
220  1 list.add(orNode1);
221   
222  1 String successMsg = configuredMessageBuilder.buildMessage(list);
223   
224  1 Assert.assertEquals(successMsg, orNode1.getNodeMessage());
225  1 Assert.assertEquals(
226    " (MATH101" +
227    "\n AND" +
228    "\n MATH102)" +
229    "\nOR" +
230    "\n (MATH201" +
231    "\n AND" +
232    "\n (MATH202" +
233    "\n OR" +
234    "\n MATH301))",
235    successMsg);
236    }
237   
 
238  1 toggle @Test
239    public void testBuildMessage_ForListOfNodes_Complex2() throws Exception {
240    // Rule: (A OR (B AND (C OR E))
241  1 Token or1 = adapter.createToken(BooleanFunctionParser.OR, "+");
242  1 Token or2 = adapter.createToken(BooleanFunctionParser.OR, "+");
243  1 Token and1 = adapter.createToken(BooleanFunctionParser.AND, "*");
244  1 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
245  1 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
246  1 Token c = adapter.createToken(BooleanFunctionParser.ALPHA, "C");
247  1 Token d = adapter.createToken(BooleanFunctionParser.ALPHA, "D");
248   
249    // root node
250  1 BooleanNode orNode1 = new BooleanNode(or1);
251   
252  1 BooleanNode andNode1 = new BooleanNode(and1);
253  1 andNode1.setParent(orNode1);
254   
255  1 BooleanNode orNode2 = new BooleanNode(or2);
256  1 orNode2.setParent(andNode1);
257   
258  1 BooleanNode aNode = new BooleanNode(a);
259  1 aNode.setParent(orNode1);
260  1 aNode.setNodeMessage("MATH101");
261   
262  1 BooleanNode bNode = new BooleanNode(b);
263  1 bNode.setParent(andNode1);
264  1 bNode.setNodeMessage("MATH201");
265   
266  1 BooleanNode cNode = new BooleanNode(c);
267  1 cNode.setParent(orNode2);
268  1 cNode.setNodeMessage("MATH301");
269   
270  1 BooleanNode dNode = new BooleanNode(d);
271  1 dNode.setParent(orNode2);
272  1 dNode.setNodeMessage("MATH401");
273   
274  1 orNode1.addChild(aNode); // left node
275  1 orNode1.addChild(andNode1); // right node
276  1 andNode1.addChild(bNode); // left node
277  1 andNode1.addChild(orNode2); // right node
278  1 orNode2.addChild(cNode); // left node
279  1 orNode2.addChild(dNode); // right node
280   
281    // List of nodes order is important for building success message
282  1 List<BooleanNode> list = new ArrayList<BooleanNode>();
283  1 list.add(cNode);
284  1 list.add(dNode);
285  1 list.add(orNode2);
286  1 list.add(bNode);
287  1 list.add(andNode1);
288  1 list.add(orNode1);
289  1 list.add(aNode);
290   
291  1 String successMsg = configuredMessageBuilder.buildMessage(list);
292   
293  1 Assert.assertEquals(successMsg, orNode1.getNodeMessage());
294  1 Assert.assertEquals(
295    " MATH101" +
296    "\nOR" +
297    "\n (MATH201" +
298    "\n AND" +
299    "\n (MATH301" +
300    "\n OR" +
301    "\n MATH401))",
302    successMsg);
303    }
304   
305   
 
306  1 toggle @Test
307    public void testBuildMessage_ForListOfNodes_MultipleRootNodes() throws Exception {
308  1 Token or = adapter.createToken(BooleanFunctionParser.OR, "+");
309  1 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
310   
311    // root node1
312  1 BooleanNode orNode = new BooleanNode(or);
313    // root node1
314  1 BooleanNode andNode = new BooleanNode(and);
315   
316  1 List<BooleanNode> list = new ArrayList<BooleanNode>();
317  1 list.add(orNode);
318  1 list.add(andNode);
319   
320  1 try {
321  1 configuredMessageBuilder.buildMessage(list);
322  0 Assert.fail("buildSuccessMessage should have failed since list has 2 root nodes");
323    } catch (MessageBuilderException e) {
324  1 Assert.assertTrue(e.getMessage() != null);
325  1 Assert.assertTrue(e.getMessage().contains("label=+"));
326  1 Assert.assertTrue(e.getMessage().contains("label=*"));
327    }
328    }
329    }
 
CloverReport generated by Clover Code Coverage v3.0.2
Fri Dec 17 2010 05:49:23 EST.		   Clover: Open Source License registered to University of Arizona.