Coverage Report

Coverage Report - org.kuali.student.common.messagebuilder.impl.SuccessMessageBuilder

Classes in this File

Line Coverage

Branch Coverage

Complexity

SuccessMessageBuilder

100%

37/37

73%

59/80

7.833

 package org.kuali.student.common.messagebuilder.impl;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanNode;
 import org.kuali.student.common.messagebuilder.impl.exceptions.MessageBuilderException;
 
 /**
  * This class creates success messages for boolean binary tree nodes.
  */
 public class SuccessMessageBuilder {
         /** Boolean operators to use in creating the success message */
         private BooleanOperators booleanOperators;
 
         /**
          * Creates a success message builder with boolean operators to use in 
          * building the success message.
          * 
          * @param bo Boolean operators to build success message
          */
         public SuccessMessageBuilder(BooleanOperators bo) {
                 this.booleanOperators = bo;
         }
 
         /**
          * Builds and sets the success message for each of the boolean nodes 
          * (binary tree) in the <code>nodeList</code>.
          * 
          * @param nodeList List of boolean nodes 
          * @return Complete success message 
          */
         public String buildSuccessMessage(List<BooleanNode> nodeList) throws MessageBuilderException {
                 // List must only contain one root node
                 List<BooleanNode> rootNodeList = new ArrayList<BooleanNode>();
                 for(BooleanNode node : nodeList) {
                         if(node.getParent() == null) {
                                 rootNodeList.add(node);
                         }
                         buildSuccessMessage(node);
                 }
                 if(rootNodeList.size() > 1) {
                         throw new MessageBuilderException("Node list contains more than one root node: " + rootNodeList);
                 }
                 return rootNodeList.get(0).getNodeMessage();
         }
 
         /**
          * Builds and sets the success message for a single 
          * boolean <code>node</code> (b-tree node).
          * 
          * @param node Boolean node
          */
         public String buildSuccessMessage(final BooleanNode node) {
                 // AND node
                 if(node.getLabel().equals("*")) {
                         buildAndNodeSuccessMessage(node);
                 } 
                 // OR node
                 else if(node.getLabel().equals("+")) {
                         buildOr1NodeSuccessMessage(node);
                         buildOr2NodeSuccessMessage(node);
                 }
                 return node.getNodeMessage();
         }
 
         /**
          * Builds a success message for an AND node (b-tree node) where 
          * left node and right node are true.
          * 
          * @param node Boolean node
          */
         private void buildAndNodeSuccessMessage(BooleanNode node) {
                 if(node.getLabel().equals("*") && 
                                 node.getLeftNode() != null && 
                                 node.getRightNode() != null &&
                                 node.getLeftNode().getValue() == true && 
                                 node.getRightNode().getValue() == true &&
                                 node.getLeftNode().getNodeMessage() != null && 
                                 node.getRightNode().getNodeMessage() != null) {
                 String logMessage = node.getLeftNode().getNodeMessage() + " " + 
                         this.booleanOperators.getAndOperator() + " " + 
                         node.getRightNode().getNodeMessage();
                         
                         if(node.getParent() != null && 
                                         ( (node.getLabel().equals("+") && 
                                                         node.getParent().getLabel().equals("*")) || 
                                                         (node.getLabel().equals("*") && 
                                                                         node.getParent().getLabel().equals("+")))) {
                             logMessage = "(" + logMessage + ")";
                         }
                         node.setNodeMessage(logMessage);
                 }
         }
 
         /**
          * Builds a success message for an OR node (b-tree node) where 
          * left node is true and right node is false or 
          * left node is false and right node is true.
          * 
          * @param node Boolean node
          */
         private void buildOr1NodeSuccessMessage(BooleanNode node) {
                 // OR1
                 if(node.getLabel().equals("+") && 
                                 node.getLeftNode() != null && 
                                 node.getRightNode() != null &&
                                 ((node.getLeftNode().getValue() == false && 
                                                 node.getRightNode().getValue() == true && 
                                                 node.getRightNode().getNodeMessage() != null ) || 
                                 (node.getLeftNode().getValue() == true && 
                                                 node.getRightNode().getValue() == false && 
                                                 node.getLeftNode().getNodeMessage() != null))) {
                         String logMessage = "test";
                         
                         if (node.getLeftNode().getValue() == true)
                                 logMessage = node.getLeftNode().getNodeMessage();
                         else if (node.getRightNode().getValue() == true)
                                 logMessage = node.getRightNode().getNodeMessage();
                         
                         node.setNodeMessage(logMessage);
                 }
         }        
         
         /**
          * Builds a success message for an OR node (b-tree node) where 
          * left node and right node are true.
          * 
          * @param node
          */
         private void buildOr2NodeSuccessMessage(BooleanNode node) {
                 // OR2
                 if(node.getLabel().equals("+") &&
                                 node.getLeftNode() != null && 
                                 node.getRightNode() != null &&
                                 node.getLeftNode().getValue() == true && 
                                 node.getRightNode().getValue() == true && 
                                 node.getLeftNode().getNodeMessage() != null && 
                                 node.getRightNode().getNodeMessage() != null) {
                 String logMessage = node.getLeftNode().getNodeMessage() + " " + 
                         this.booleanOperators.getOrOperator() + " " + 
                         node.getRightNode().getNodeMessage();
 
                         if(node.getParent() != null && 
                                         ( (node.getLabel().equals("+") && 
                                                         node.getParent().getLabel().equals("*")) || 
                                                         (node.getLabel().equals("*") && 
                                                                         node.getParent().getLabel().equals("+")))) {
                             logMessage = "(" + logMessage + ")";
                         }
                         node.setNodeMessage(logMessage);
                 } 
         }        
 }

1		package org.kuali.student.common.messagebuilder.impl;
2
3		import java.util.ArrayList;
4		import java.util.List;
5
6		import org.kuali.student.common.messagebuilder.booleanmessage.ast.BooleanNode;
7		import org.kuali.student.common.messagebuilder.impl.exceptions.MessageBuilderException;
8
9		/**
10		* This class creates success messages for boolean binary tree nodes.
11		*/
12		public class SuccessMessageBuilder {
13		/** Boolean operators to use in creating the success message */
14		private BooleanOperators booleanOperators;
15
16		/**
17		* Creates a success message builder with boolean operators to use in
18		* building the success message.
19		*
20		* @param bo Boolean operators to build success message
21		*/
22	28	public SuccessMessageBuilder(BooleanOperators bo) {
23	28	this.booleanOperators = bo;
24	28	}
25
26		/**
27		* Builds and sets the success message for each of the boolean nodes
28		* (binary tree) in the <code>nodeList</code>.
29		*
30		* @param nodeList List of boolean nodes
31		* @return Complete success message
32		*/
33		public String buildSuccessMessage(List<BooleanNode> nodeList) throws MessageBuilderException {
34		// List must only contain one root node
35	3	List<BooleanNode> rootNodeList = new ArrayList<BooleanNode>();
36	3	for(BooleanNode node : nodeList) {
37	14	if(node.getParent() == null) {
38	4	rootNodeList.add(node);
39		}
40	14	buildSuccessMessage(node);
41		}
42	3	if(rootNodeList.size() > 1) {
43	1	throw new MessageBuilderException("Node list contains more than one root node: " + rootNodeList);
44		}
45	2	return rootNodeList.get(0).getNodeMessage();
46		}
47
48		/**
49		* Builds and sets the success message for a single
50		* boolean <code>node</code> (b-tree node).
51		*
52		* @param node Boolean node
53		*/
54		public String buildSuccessMessage(final BooleanNode node) {
55		// AND node
56	146	if(node.getLabel().equals("*")) {
57	34	buildAndNodeSuccessMessage(node);
58		}
59		// OR node
60	112	else if(node.getLabel().equals("+")) {
61	31	buildOr1NodeSuccessMessage(node);
62	31	buildOr2NodeSuccessMessage(node);
63		}
64	146	return node.getNodeMessage();
65		}
66
67		/**
68		* Builds a success message for an AND node (b-tree node) where
69		* left node and right node are true.
70		*
71		* @param node Boolean node
72		*/
73		private void buildAndNodeSuccessMessage(BooleanNode node) {
74	34	if(node.getLabel().equals("*") &&
75		node.getLeftNode() != null &&
76		node.getRightNode() != null &&
77		node.getLeftNode().getValue() == true &&
78		node.getRightNode().getValue() == true &&
79		node.getLeftNode().getNodeMessage() != null &&
80		node.getRightNode().getNodeMessage() != null) {
81	22	String logMessage = node.getLeftNode().getNodeMessage() + " " +
82		this.booleanOperators.getAndOperator() + " " +
83		node.getRightNode().getNodeMessage();
84
85	22	if(node.getParent() != null &&
86		( (node.getLabel().equals("+") &&
87		node.getParent().getLabel().equals("*")) \|\|
88		(node.getLabel().equals("*") &&
89		node.getParent().getLabel().equals("+")))) {
90	10	logMessage = "(" + logMessage + ")";
91		}
92	22	node.setNodeMessage(logMessage);
93		}
94	34	}
95
96		/**
97		* Builds a success message for an OR node (b-tree node) where
98		* left node is true and right node is false or
99		* left node is false and right node is true.
100		*
101		* @param node Boolean node
102		*/
103		private void buildOr1NodeSuccessMessage(BooleanNode node) {
104		// OR1
105	31	if(node.getLabel().equals("+") &&
106		node.getLeftNode() != null &&
107		node.getRightNode() != null &&
108		((node.getLeftNode().getValue() == false &&
109		node.getRightNode().getValue() == true &&
110		node.getRightNode().getNodeMessage() != null ) \|\|
111		(node.getLeftNode().getValue() == true &&
112		node.getRightNode().getValue() == false &&
113		node.getLeftNode().getNodeMessage() != null))) {
114	14	String logMessage = "test";
115
116	14	if (node.getLeftNode().getValue() == true)
117	10	logMessage = node.getLeftNode().getNodeMessage();
118	4	else if (node.getRightNode().getValue() == true)
119	4	logMessage = node.getRightNode().getNodeMessage();
120
121	14	node.setNodeMessage(logMessage);
122		}
123	31	}
124
125		/**
126		* Builds a success message for an OR node (b-tree node) where
127		* left node and right node are true.
128		*
129		* @param node
130		*/
131		private void buildOr2NodeSuccessMessage(BooleanNode node) {
132		// OR2
133	31	if(node.getLabel().equals("+") &&
134		node.getLeftNode() != null &&
135		node.getRightNode() != null &&
136		node.getLeftNode().getValue() == true &&
137		node.getRightNode().getValue() == true &&
138		node.getLeftNode().getNodeMessage() != null &&
139		node.getRightNode().getNodeMessage() != null) {
140	12	String logMessage = node.getLeftNode().getNodeMessage() + " " +
141		this.booleanOperators.getOrOperator() + " " +
142		node.getRightNode().getNodeMessage();
143
144	12	if(node.getParent() != null &&
145		( (node.getLabel().equals("+") &&
146		node.getParent().getLabel().equals("*")) \|\|
147		(node.getLabel().equals("*") &&
148		node.getParent().getLabel().equals("+")))) {
149	4	logMessage = "(" + logMessage + ")";
150		}
151	12	node.setNodeMessage(logMessage);
152		}
153	31	}
154		}