Package: LENode

LENode

name	instruction	branch	complexity	line	method
LENode(AbstractNode, AbstractNode)	M: 0 C: 5 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 2 100%	M: 0 C: 1 100%
equals(Object)	M: 0 C: 11 100%	M: 0 C: 4 100%	M: 0 C: 3 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
hashCode()	M: 0 C: 6 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 1 100%	M: 0 C: 1 100%
interpret(CommunicationManager)	M: 0 C: 93 100%	M: 0 C: 18 100%	M: 0 C: 10 100%	M: 0 C: 13 100%	M: 0 C: 1 100%
toString()	M: 0 C: 12 100%	M: 0 C: 0 100%	M: 0 C: 1 100%	M: 0 C: 2 100%	M: 0 C: 1 100%

Coverage

1: package pruefskript.parser.nodes;
2:
3: import basic.PruefskriptConstants;
4: import pruefskript.CommunicationManager;
5: import pruefskript.parser.exceptions.CheckScriptException;
6: import pruefskript.parser.exceptions.WrongNodeException;
7: import pruefskript.parser.values.AbstractReturnValue;
8: import pruefskript.parser.values.BooleanValue;
9:
10: /**
11: * LENode.
12: *
13: * @author Group B5
14: *
15: */
16: public class LENode extends AbstractBinaryOperationNode {
17:         /**
18:          * LENode.
19:          *
20:          * @param operand1
21:          * AbstractNode
22:          * @param operand2
23:          * AbstractNode
24:          */
25:         public LENode(final AbstractNode operand1, final AbstractNode operand2) {
26:                 super(operand1, operand2);
27:         }
28:
29:         @Override
30:         public String toString() {
31:                 return PruefskriptConstants.LENODETITLE + PruefskriptConstants.BRACKET_OPEN
32:                                 + super.toString() + PruefskriptConstants.BRACKET_CLOSE;
33:         }
34:
35:         @Override
36:         public boolean equals(final Object obj) {
37:•                return super.equals(obj) && obj instanceof LENode;
38:
39:         }
40:
41:         @Override
42:         public int hashCode() {
43:                 return super.hashCode() + PruefskriptConstants.LENODE_HASHCODE;
44:         }
45:
46:         /**
47:          * Die beiden Operanten werden zunaechst separat ausgewertet. Handlet es sich bei beiden um
48:          * numerische Werte, wird ein ein Boolscher Wert erzeugt, indem geprueft wird, ob operant1
49:          * kleiner gleich oeprant2 ist. Handelt es sich bei beiden um Versions-Werte, wird ein Boolscher
50:          * Wert erzeugt, indem grprueft wird, ob der Versionswert von operant 1 verglichen mit den von
51:          * operant2 kleiner gleich 0 ist. Handelt es sich um String-Werte, wird ein boolscher Wert
52:          * erzeugt indem der String-Wert von Operant1 verglichen mit dem von Operant2 kleiner gleich 0
53:          * ist.
54:          *
55:          * Ansonsten wird eine Exception geworfen.
56:          */
57:         @Override
58:         public BooleanValue interpret(final CommunicationManager mgr) throws CheckScriptException {
59:                 final BooleanValue result;
60:                 final AbstractReturnValue op1 = this.getOperand1().interpret(mgr);
61:                 final AbstractReturnValue op2 = this.getOperand2().interpret(mgr);
62:•                if (op1.isNumericValue() && op2.isNumericValue()) {
63:                         result = new BooleanValue(
64:•                                        op1.toNumericValue().getValue() <= op2.toNumericValue().getValue());
65:•                } else if (op1.isVersionValue() && op2.isVersionValue()) {
66:                         result = new BooleanValue(op1.toVersionValue().getValue()
67:•                                        .compareToIgnoreCase(op2.toVersionValue().getValue()) <= 0);
68:•                } else if (op1.isStringValue() && op2.isStringValue()) {
69:                         result = new BooleanValue(op1.toStringValue().getValue()
70:•                                        .compareToIgnoreCase(op2.toStringValue().getValue()) <= 0);
71:                 } else {
72:                         throw new WrongNodeException(PruefskriptConstants.UNEXPECTED_BOOL_OPERATION);
73:                 }
74:                 return result;
75:         }
76: }