Clover Coverage Report - KS Common 1.3.0-SNAPSHOT (Aggregated)
Coverage timestamp: Thu Apr 28 2011 06:00:36 EDT
147   251   8   21
0   187   0.05   7
7     1.14  
1    
 
  FailureMessageBuilderTest       Line # 17 147 0% 8 154 0% 0.0
 
No Tests
 
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.FailureMessageBuilder;
15    import org.kuali.student.common.messagebuilder.impl.exceptions.MessageBuilderException;
16   
 
17    public class FailureMessageBuilderTest {
18    private final static CommonTreeAdaptor adapter = new CommonTreeAdaptor();
19    private FailureMessageBuilder failureMessageBuilder;
20   
 
21  0 toggle @Before
22    public void setUp() throws Exception {
23  0 BooleanOperators bo = new BooleanOperators();
24  0 failureMessageBuilder = new FailureMessageBuilder(bo);
25    }
26   
 
27  0 toggle @Test
28    public void testBuildFailureMessageForSingleOrNode() throws Exception {
29    // Rule: A OR B
30  0 Token or = adapter.createToken(BooleanFunctionParser.OR, "+");
31  0 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
32  0 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
33   
34    // root node
35  0 BooleanNode orNode = new BooleanNode(or);
36   
37  0 BooleanNode aNode = new BooleanNode(a);
38  0 aNode.setParent(orNode);
39  0 aNode.setValue(Boolean.FALSE);
40  0 aNode.setNodeMessage("MATH101");
41   
42  0 BooleanNode bNode = new BooleanNode(b);
43  0 bNode.setParent(orNode);
44  0 bNode.setValue(Boolean.FALSE);
45  0 bNode.setNodeMessage("MATH201");
46   
47  0 orNode.addChild(aNode); // left node
48  0 orNode.addChild(bNode); // right node
49   
50  0 String failureMsg = failureMessageBuilder.buildFailureMessage(orNode);
51   
52  0 Assert.assertEquals(failureMsg, orNode.getNodeMessage());
53  0 Assert.assertEquals("MATH101 OR MATH201", failureMsg);
54    }
55   
 
56  0 toggle @Test
57    public void testBuildFailureMessageForSingleAnd1Node() throws Exception {
58    // Rule: A AND B
59  0 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
60  0 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
61  0 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
62   
63    // root node
64  0 BooleanNode andNode = new BooleanNode(and);
65   
66  0 BooleanNode aNode = new BooleanNode(a);
67  0 aNode.setParent(andNode);
68  0 aNode.setValue(Boolean.TRUE);
69  0 aNode.setNodeMessage("MATH101");
70   
71  0 BooleanNode bNode = new BooleanNode(b);
72  0 bNode.setParent(andNode);
73  0 bNode.setValue(Boolean.FALSE);
74  0 bNode.setNodeMessage("MATH201");
75   
76  0 andNode.addChild(aNode); // left node
77  0 andNode.addChild(bNode); // right node
78   
79  0 String failureMsg = failureMessageBuilder.buildFailureMessage(andNode);
80   
81  0 Assert.assertEquals(failureMsg, andNode.getNodeMessage());
82  0 Assert.assertEquals("MATH201", failureMsg);
83    }
84   
 
85  0 toggle @Test
86    public void testBuildFailureMessageForSingleAnd2Node() throws Exception {
87    // Rule: A AND B
88  0 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
89  0 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
90  0 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
91   
92    // root node
93  0 BooleanNode andNode = new BooleanNode(and);
94   
95  0 BooleanNode aNode = new BooleanNode(a);
96  0 aNode.setParent(andNode);
97  0 aNode.setValue(Boolean.FALSE);
98  0 aNode.setNodeMessage("MATH101");
99   
100  0 BooleanNode bNode = new BooleanNode(b);
101  0 bNode.setParent(andNode);
102  0 bNode.setValue(Boolean.FALSE);
103  0 bNode.setNodeMessage("MATH201");
104   
105  0 andNode.addChild(aNode); // left node
106  0 andNode.addChild(bNode); // right node
107   
108  0 String failureMsg = failureMessageBuilder.buildFailureMessage(andNode);
109   
110  0 Assert.assertEquals(failureMsg, andNode.getNodeMessage());
111  0 Assert.assertEquals("MATH101 AND MATH201", failureMsg);
112    }
113   
 
114  0 toggle @Test
115    public void testBuildFailureMessageForListOfNodes_Simple() throws Exception {
116    // Rule: A AND (B OR C)
117  0 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
118  0 Token or = adapter.createToken(BooleanFunctionParser.OR, "+");
119  0 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
120  0 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
121  0 Token c = adapter.createToken(BooleanFunctionParser.ALPHA, "C");
122   
123    // root node
124  0 BooleanNode andNode = new BooleanNode(and);
125  0 BooleanNode orNode = new BooleanNode(or);
126  0 orNode.setParent(andNode);
127  0 orNode.setValue(Boolean.FALSE);
128   
129  0 BooleanNode aNode = new BooleanNode(a);
130  0 aNode.setParent(andNode);
131  0 aNode.setValue(Boolean.FALSE);
132  0 aNode.setNodeMessage("MATH101");
133   
134  0 BooleanNode bNode = new BooleanNode(b);
135  0 bNode.setParent(orNode);
136  0 bNode.setValue(Boolean.FALSE);
137  0 bNode.setNodeMessage("MATH201");
138   
139  0 BooleanNode cNode = new BooleanNode(c);
140  0 cNode.setParent(orNode);
141  0 cNode.setValue(Boolean.FALSE);
142  0 cNode.setNodeMessage("MATH301");
143   
144  0 orNode.addChild(bNode); // left node
145  0 orNode.addChild(cNode); // right node
146  0 andNode.addChild(aNode); // left node
147  0 andNode.addChild(orNode); // right node
148   
149    // List of nodes order is important for building failure message
150  0 List<BooleanNode> list = new ArrayList<BooleanNode>();
151  0 list.add(cNode);
152  0 list.add(bNode);
153  0 list.add(orNode);
154  0 list.add(aNode);
155  0 list.add(andNode);
156   
157  0 String failureMsg = failureMessageBuilder.buildFailureMessage(list);
158   
159  0 Assert.assertEquals(failureMsg, andNode.getNodeMessage());
160  0 Assert.assertEquals("MATH101 AND (MATH201 OR MATH301)", failureMsg);
161    }
162   
 
163  0 toggle @Test
164    public void testBuildFailureMessageForListOfNodes_Complex() throws Exception {
165    // Rule: (A OR B) AND (C OR D)
166  0 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
167  0 Token or1 = adapter.createToken(BooleanFunctionParser.OR, "+");
168  0 Token or2 = adapter.createToken(BooleanFunctionParser.OR, "+");
169  0 Token a = adapter.createToken(BooleanFunctionParser.ALPHA, "A");
170  0 Token b = adapter.createToken(BooleanFunctionParser.ALPHA, "B");
171  0 Token c = adapter.createToken(BooleanFunctionParser.ALPHA, "C");
172  0 Token d = adapter.createToken(BooleanFunctionParser.ALPHA, "D");
173   
174    // root node
175  0 BooleanNode andNode = new BooleanNode(and);
176   
177  0 BooleanNode orNode1 = new BooleanNode(or1);
178  0 orNode1.setParent(andNode);
179  0 orNode1.setValue(Boolean.TRUE);
180   
181  0 BooleanNode orNode2 = new BooleanNode(or2);
182  0 orNode2.setParent(andNode);
183  0 orNode2.setValue(Boolean.FALSE);
184   
185  0 BooleanNode aNode = new BooleanNode(a);
186  0 aNode.setParent(orNode1);
187  0 aNode.setValue(Boolean.TRUE);
188  0 aNode.setNodeMessage("MATH101");
189   
190  0 BooleanNode bNode = new BooleanNode(b);
191  0 bNode.setParent(orNode1);
192  0 bNode.setValue(Boolean.TRUE);
193  0 bNode.setNodeMessage("MATH201");
194   
195  0 BooleanNode cNode = new BooleanNode(c);
196  0 cNode.setParent(orNode2);
197  0 cNode.setValue(Boolean.FALSE);
198  0 cNode.setNodeMessage("MATH301");
199   
200  0 BooleanNode dNode = new BooleanNode(d);
201  0 dNode.setParent(orNode2);
202  0 dNode.setValue(Boolean.FALSE);
203  0 dNode.setNodeMessage("MATH401");
204   
205  0 orNode1.addChild(aNode); // left node
206  0 orNode1.addChild(bNode); // right node
207  0 orNode2.addChild(cNode); // left node
208  0 orNode2.addChild(dNode); // right node
209  0 andNode.addChild(orNode1); // left node
210  0 andNode.addChild(orNode2); // right node
211   
212    // List of nodes order is important for building failure message
213  0 List<BooleanNode> list = new ArrayList<BooleanNode>();
214  0 list.add(aNode);
215  0 list.add(bNode);
216  0 list.add(cNode);
217  0 list.add(dNode);
218  0 list.add(orNode1);
219  0 list.add(orNode2);
220  0 list.add(andNode);
221   
222  0 String failureMsg = failureMessageBuilder.buildFailureMessage(list);
223   
224  0 Assert.assertEquals(failureMsg, andNode.getNodeMessage());
225  0 Assert.assertEquals("(MATH301 OR MATH401)", failureMsg);
226    }
227   
 
228  0 toggle @Test
229    public void testBuildFailureMessageForListOfNodes_MultipleRootNodes() throws Exception {
230  0 Token or = adapter.createToken(BooleanFunctionParser.OR, "+");
231  0 Token and = adapter.createToken(BooleanFunctionParser.AND, "*");
232   
233    // root node1
234  0 BooleanNode orNode = new BooleanNode(or);
235    // root node1
236  0 BooleanNode andNode = new BooleanNode(and);
237   
238  0 List<BooleanNode> list = new ArrayList<BooleanNode>();
239  0 list.add(orNode);
240  0 list.add(andNode);
241   
242  0 try {
243  0 failureMessageBuilder.buildFailureMessage(list);
244  0 Assert.fail("buildFailureMessage should have failed since list has 2 root nodes");
245    } catch (MessageBuilderException e) {
246  0 Assert.assertTrue(e.getMessage() != null);
247  0 Assert.assertTrue(e.getMessage().contains("label=+"));
248  0 Assert.assertTrue(e.getMessage().contains("label=*"));
249    }
250    }
251    }