1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
package org.qedeq.kernel.bo.parser; |
17 |
|
|
18 |
|
import org.qedeq.kernel.bo.test.QedeqBoTestCase; |
19 |
|
|
20 |
|
|
21 |
|
|
22 |
|
|
23 |
|
@author |
24 |
|
|
|
|
| 98.1% |
Uncovered Elements: 2 (107) |
Complexity: 8 |
Complexity Density: 0.08 |
|
25 |
|
public class OperatorTest extends QedeqBoTestCase { |
26 |
|
|
27 |
|
private Operator not; |
28 |
|
private Operator and; |
29 |
|
private Operator or; |
30 |
|
private Operator impl; |
31 |
|
private Operator equi; |
32 |
|
private Operator forall; |
33 |
|
private Operator exists; |
34 |
|
private Operator equal; |
35 |
|
private Operator in; |
36 |
|
private Operator isSet; |
37 |
|
private Operator classList; |
38 |
|
private Operator clasDef; |
39 |
|
private Operator union; |
40 |
|
private Operator intersection; |
41 |
|
private Operator subset; |
42 |
|
private Operator superset; |
43 |
|
private Operator phi; |
44 |
|
private Operator psi; |
45 |
|
private Operator alpha; |
46 |
|
private Operator beta; |
47 |
|
private Operator gamma; |
48 |
|
private Operator post1; |
49 |
|
private Operator post2; |
50 |
|
|
51 |
|
|
52 |
|
|
53 |
|
|
54 |
|
|
55 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
56 |
0
|
public OperatorTest() {... |
57 |
0
|
super(); |
58 |
|
} |
59 |
|
|
60 |
|
|
61 |
|
|
62 |
|
|
63 |
|
@param |
64 |
|
|
65 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
66 |
5
|
public OperatorTest(final String name) {... |
67 |
5
|
super(name); |
68 |
|
} |
69 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (24) |
Complexity: 1 |
Complexity Density: 0.04 |
|
70 |
5
|
protected void setUp() throws Exception {... |
71 |
5
|
super.setUp(); |
72 |
5
|
not = new Operator("neg", "NOT", null, 110, 1, 1, 1); |
73 |
5
|
and = new Operator("land", "AND", null, 100, 0, 2); |
74 |
5
|
or = new Operator("lor", "OR", null, 90, 0, 2); |
75 |
5
|
impl = new Operator("impl", "IMPL", null, 80, 0, 2, 2); |
76 |
5
|
equi = new Operator("equi", "EQUI", null, 80, 0, 2); |
77 |
5
|
forall = new Operator("forall", "ALL", null, 140, 1, 2, 2); |
78 |
5
|
exists = new Operator("exists", "EXISTS", null, 140, 1, 2, 2); |
79 |
5
|
in = new Operator("in", "PREDCON", "IN", 200, 0, 2, 2); |
80 |
5
|
equal = new Operator("=", "PREDCON", "EQUAL", 200, 0, 2); |
81 |
5
|
isSet = new Operator("isSet", "PREDCON", "isSet", 200, 1, 1, 1); |
82 |
5
|
classList = new Operator("{", ",", "}", "CLASSLIST", null, 10, 0); |
83 |
5
|
clasDef = new Operator("{", "|", "}", "CLASS", null, 10, 2, 2); |
84 |
5
|
union = new Operator("cup", "UNION", null, 30, 0, 2); |
85 |
5
|
intersection = new Operator("cap", "INTER", null, 40, 0, 2); |
86 |
5
|
subset = new Operator("subset", "PREDCON", "subset", 10, 2, 2, 2); |
87 |
5
|
superset = new Operator("superset", "PREDCON", "superset", 10, 2, 2, 2); |
88 |
5
|
phi = new Operator("phi", "PREDVAR", "1", 200, 1, 1, 2); |
89 |
5
|
psi = new Operator("psi", "PREDVAR", "2", 200, 1, 1, 2); |
90 |
5
|
alpha = new Operator("alpha", "PREDVAR", "3", 200, 4, 0, -1); |
91 |
5
|
beta = new Operator("beta", "PREDVAR", "4", 200, 4, 0, -1); |
92 |
5
|
gamma = new Operator("gamma", "PREDVAR", "5", 200, 4, 0, -1); |
93 |
5
|
post1 = new Operator("post", "POST", "5", 1003, 2, 0, -1); |
94 |
5
|
post2 = new Operator("post", "POST", "5", 1005, 2, 0, -1); |
95 |
|
} |
96 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (23) |
Complexity: 1 |
Complexity Density: 0.04 |
1
PASS
|
|
97 |
1
|
public void testGetMin() throws Exception {... |
98 |
1
|
assertEquals(1, not.getMin()); |
99 |
1
|
assertEquals(2, and.getMin()); |
100 |
1
|
assertEquals(2, or.getMin()); |
101 |
1
|
assertEquals(2, impl.getMin()); |
102 |
1
|
assertEquals(2, equi.getMin()); |
103 |
1
|
assertEquals(2, forall.getMin()); |
104 |
1
|
assertEquals(2, exists.getMin()); |
105 |
1
|
assertEquals(2, equal.getMin()); |
106 |
1
|
assertEquals(2, in.getMin()); |
107 |
1
|
assertEquals(1, isSet.getMin()); |
108 |
1
|
assertEquals(2, subset.getMin()); |
109 |
1
|
assertEquals(2, superset.getMin()); |
110 |
1
|
assertEquals(0, classList.getMin()); |
111 |
1
|
assertEquals(2, clasDef.getMin()); |
112 |
1
|
assertEquals(2, union.getMin()); |
113 |
1
|
assertEquals(2, intersection.getMin()); |
114 |
1
|
assertEquals(1, phi.getMin()); |
115 |
1
|
assertEquals(1, psi.getMin()); |
116 |
1
|
assertEquals(0, alpha.getMin()); |
117 |
1
|
assertEquals(0, beta.getMin()); |
118 |
1
|
assertEquals(0, gamma.getMin()); |
119 |
1
|
assertEquals(0, post1.getMin()); |
120 |
1
|
assertEquals(0, post2.getMin()); |
121 |
|
} |
122 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (21) |
Complexity: 1 |
Complexity Density: 0.05 |
1
PASS
|
|
123 |
1
|
public void testGetMax() throws Exception {... |
124 |
1
|
assertEquals(1, not.getMax()); |
125 |
1
|
assertEquals(-1, and.getMax()); |
126 |
1
|
assertEquals(-1, or.getMax()); |
127 |
1
|
assertEquals(2, impl.getMax()); |
128 |
1
|
assertEquals(-1, equi.getMax()); |
129 |
1
|
assertEquals(2, forall.getMax()); |
130 |
1
|
assertEquals(2, exists.getMax()); |
131 |
1
|
assertEquals(-1, equal.getMax()); |
132 |
1
|
assertEquals(2, in.getMax()); |
133 |
1
|
assertEquals(1, isSet.getMax()); |
134 |
1
|
assertEquals(-1, classList.getMax()); |
135 |
1
|
assertEquals(2, clasDef.getMax()); |
136 |
1
|
assertEquals(-1, union.getMax()); |
137 |
1
|
assertEquals(-1, intersection.getMax()); |
138 |
1
|
assertEquals(2, subset.getMax()); |
139 |
1
|
assertEquals(2, superset.getMax()); |
140 |
1
|
assertEquals(2, phi.getMax()); |
141 |
1
|
assertEquals(2, psi.getMax()); |
142 |
1
|
assertEquals(-1, alpha.getMax()); |
143 |
1
|
assertEquals(-1, beta.getMax()); |
144 |
1
|
assertEquals(-1, gamma.getMax()); |
145 |
|
} |
146 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1
PASS
|
|
147 |
1
|
public void testEquals() throws Exception {... |
148 |
1
|
assertEquals(and, and); |
149 |
1
|
assertEquals(not, not); |
150 |
1
|
assertEquals(post1, post1); |
151 |
1
|
assertFalse(post1.equals(post2)); |
152 |
1
|
assertFalse(not.equals(and)); |
153 |
1
|
assertFalse(not.equals(null)); |
154 |
1
|
assertFalse(or.equals(and)); |
155 |
|
} |
156 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1
PASS
|
|
157 |
1
|
public void testToString() throws Exception {... |
158 |
1
|
assertEquals("land[2, ..], is infix", and.toString()); |
159 |
1
|
assertEquals("impl[2, 2], is infix", impl.toString()); |
160 |
1
|
assertEquals("forall[2, 2], is prefix", forall.toString()); |
161 |
1
|
assertEquals("{[2, 2] | }, is prefix", clasDef.toString()); |
162 |
1
|
assertEquals("{[0, ..] , }, is prefix", classList.toString()); |
163 |
1
|
assertEquals("post[0, ..], is postfix", post1.toString()); |
164 |
|
} |
165 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 1 |
Complexity Density: 0.06 |
1
PASS
|
|
166 |
1
|
public void testIsFix() {... |
167 |
1
|
assertTrue(and.isInfix()); |
168 |
1
|
assertFalse(and.isPrefix()); |
169 |
1
|
assertFalse(and.isPostfix()); |
170 |
1
|
assertFalse(and.isFunction()); |
171 |
1
|
assertTrue(impl.isInfix()); |
172 |
1
|
assertFalse(impl.isPrefix()); |
173 |
1
|
assertFalse(impl.isPostfix()); |
174 |
1
|
assertFalse(impl.isFunction()); |
175 |
1
|
assertFalse(alpha.isInfix()); |
176 |
1
|
assertTrue(alpha.isPrefix()); |
177 |
1
|
assertFalse(alpha.isPostfix()); |
178 |
1
|
assertTrue(alpha.isFunction()); |
179 |
1
|
assertFalse(post1.isPrefix()); |
180 |
1
|
assertTrue(post1.isPostfix()); |
181 |
1
|
assertFalse(post1.isFunction()); |
182 |
1
|
assertFalse(post1.isInfix()); |
183 |
|
} |
184 |
|
|
185 |
|
} |