001 package ps1.test;
002
003 import ps1.*;
004
005 import org.junit.Test;
006 import static org.junit.Assert.*;
007
008 /**
009 * This class contains a set of test cases that can be used to test the
010 * implementation of the RatPolyStack class.
011 */
012 public final class RatPolyStackTest {
013 // create a new poly that is a constant (doesn't depend on x)
014 private RatPoly constantPoly(int constant) {
015 return new RatPoly(constant, 0);
016 }
017
018 // create a new poly that is a constant (doesn't depend on x)
019 // taking a char allows us to represent stacks as strings
020 private RatPoly constantPoly(char constant) {
021 return constantPoly(Integer.valueOf("" + constant).intValue());
022 }
023
024 /** @return a new RatPolyStack instance */
025 private RatPolyStack stack() {
026 return new RatPolyStack();
027 }
028
029 // create stack of single-digit constant polys
030 private RatPolyStack stack(String desc) {
031 RatPolyStack s = new RatPolyStack();
032
033 // go backwards to leave first element in desc on _top_ of stack
034 for (int i = desc.length() - 1; i >= 0; i--) {
035 char c = desc.charAt(i);
036 s.push(constantPoly(c));
037 }
038 return s;
039 }
040
041 // RatPoly equality check
042 // (getting around non-definition of RatPoly.equals)
043 private boolean eqv(RatPoly p1, RatPoly p2) {
044 return p1.toString().equals(p2.toString());
045 }
046
047 // Compares 's' to a string describing its values.
048 // desc MUST be a sequence of decimal number chars.
049 // Example call: assertStackIs(myStack, "123")
050 //
051 // NOTE: THIS CAN FAIL WITH A WORKING STACK IF RatPoly.toString IS BROKEN!
052 private void assertStackIs(RatPolyStack s, String desc) {
053 assertEquals(desc.length(), s.size());
054
055 for (int i = 0; i < desc.length(); i++) {
056 RatPoly p = s.getNthFromTop(i);
057 char c = desc.charAt(i);
058 String asstr
059 = String.format("Elem(%d): %s, Expected %c, (Expected Stack:%s)",
060 i, p, c, desc);
061
062 assertTrue(asstr, eqv(p, constantPoly(c)));
063 }
064 }
065
066 @Test
067 public void testCtor() {
068 RatPolyStack stk1 = stack();
069 assertEquals(0, stk1.size());
070 }
071
072 @Test
073 public void testPush() {
074 RatPolyStack stk1 = stack();
075 stk1.push(constantPoly(0));
076
077 assertStackIs(stk1, "0");
078
079 stk1.push(constantPoly(0));
080 assertStackIs(stk1, "00");
081
082 stk1.push(constantPoly(1));
083 assertStackIs(stk1, "100");
084
085 stk1 = stack("3");
086 assertStackIs(stk1, "3");
087
088 stk1 = stack("23");
089 assertStackIs(stk1, "23");
090
091 stk1 = stack("123");
092 assertStackIs(stk1, "123");
093 }
094
095 @Test
096 public void testPushCheckForSharingTwixtStacks() {
097 RatPolyStack stk1 = stack();
098 RatPolyStack stk2 = stack("123");
099 assertStackIs(stk1, "");
100 assertStackIs(stk2, "123");
101
102 stk1.push(constantPoly(0));
103 assertStackIs(stk1, "0");
104 assertStackIs(stk2, "123");
105
106 stk1.push(constantPoly(0));
107 assertStackIs(stk1, "00");
108 assertStackIs(stk2, "123");
109
110 stk1.push(constantPoly(1));
111 assertStackIs(stk1, "100");
112 assertStackIs(stk2, "123");
113
114 stk2.push(constantPoly(8));
115 assertStackIs(stk1, "100");
116 assertStackIs(stk2, "8123");
117 }
118
119 @Test
120 public void testPop() {
121 RatPolyStack stk1 = stack("123");
122
123 RatPoly poly = stk1.pop();
124 assertTrue(eqv(poly, constantPoly(1)));
125 assertStackIs(stk1, "23");
126
127 poly = stk1.pop();
128 assertTrue(eqv(poly, constantPoly(2)));
129 assertStackIs(stk1, "3");
130
131 poly = stk1.pop();
132 assertStackIs(stk1, "");
133 }
134
135 @Test
136 public void testDup() {
137 RatPolyStack stk1 = stack("3");
138 stk1.dup();
139 assertStackIs(stk1, "33");
140
141 stk1 = stack("23");
142 stk1.dup();
143 assertStackIs(stk1, "223");
144 assertEquals(3, stk1.size());
145 assertTrue(eqv(stk1.getNthFromTop(0), constantPoly(2)));
146 assertTrue(eqv(stk1.getNthFromTop(1), constantPoly(2)));
147 assertTrue(eqv(stk1.getNthFromTop(2), constantPoly(3)));
148
149 stk1 = stack("123");
150 stk1.dup();
151 assertStackIs(stk1, "1123");
152
153 }
154
155 @Test
156 public void testSwap() {
157 RatPolyStack stk1 = stack("23");
158 stk1.swap();
159 assertStackIs(stk1, "32");
160
161 stk1 = stack("123");
162 stk1.swap();
163 assertStackIs(stk1, "213");
164
165 stk1 = stack("112");
166 stk1.swap();
167 assertStackIs(stk1, "112");
168 }
169
170 @Test
171 public void testClear() {
172 RatPolyStack stk1 = stack("123");
173 stk1.clear();
174 assertStackIs(stk1, "");
175 RatPolyStack stk2 = stack("112");
176 stk2.clear();
177 assertStackIs(stk2, "");
178 }
179
180 @Test
181 public void testAdd() {
182 RatPolyStack stk1 = stack("123");
183 stk1.add();
184 assertStackIs(stk1, "33");
185 stk1.add();
186 assertStackIs(stk1, "6");
187
188 stk1 = stack("112");
189 stk1.add();
190 assertStackIs(stk1, "22");
191 stk1.add();
192 assertStackIs(stk1, "4");
193 stk1.push(constantPoly(5));
194 assertStackIs(stk1, "54");
195 stk1.add();
196 assertStackIs(stk1, "9");
197
198 }
199
200 @Test
201 public void testSub() {
202 RatPolyStack stk1 = stack("123");
203 stk1.sub();
204 assertStackIs(stk1, "13");
205 stk1.sub();
206 assertStackIs(stk1, "2");
207
208 stk1 = stack("5723");
209 stk1.sub();
210 assertStackIs(stk1, "223");
211 stk1.sub();
212 assertStackIs(stk1, "03");
213 stk1.sub();
214 assertStackIs(stk1, "3");
215 }
216
217 @Test
218 public void testMul() {
219 RatPolyStack stk1 = stack("123");
220 stk1.mul();
221 assertStackIs(stk1, "23");
222 stk1.mul();
223 assertStackIs(stk1, "6");
224
225 stk1 = stack("112");
226 stk1.mul();
227 assertStackIs(stk1, "12");
228 stk1.mul();
229 assertStackIs(stk1, "2");
230 stk1.push(constantPoly(4));
231 assertStackIs(stk1, "42");
232 stk1.mul();
233 assertStackIs(stk1, "8");
234 }
235
236 @Test
237 public void testDiv() {
238 RatPolyStack stk1 = stack("123");
239 stk1.div();
240 assertStackIs(stk1, "23");
241 }
242
243 @Test
244 public void testDifferentiate() {
245 RatPolyStack stk1 = stack("123");
246 stk1.differentiate();
247 stk1.differentiate();
248 stk1.differentiate();
249 stk1.differentiate();
250 assertEquals("Test if stack size changes", 3, stk1.size());
251 assertStackIs(stk1, "023");
252
253 RatPoly rp1 = new RatPoly(3, 5);
254 RatPoly rp2 = new RatPoly(7, 0);
255 RatPoly rp3 = new RatPoly(4, 1);
256 stk1.push(rp1);
257 stk1.push(rp2);
258 stk1.push(rp3);
259
260 stk1.differentiate();
261 assertEquals("Test simple differentiate1", "4", stk1.pop().toString());
262 stk1.differentiate();
263 assertEquals("Test simple differentiate2", "0", stk1.pop().toString());
264 stk1.differentiate();
265 assertEquals("Test simple differentiate3", "15*x^4", stk1.pop().toString());
266 }
267
268 @Test
269 public void testIntegrate() {
270 RatPolyStack stk1 = stack("123");
271 stk1.integrate();
272 stk1.integrate();
273 stk1.integrate();
274 stk1.integrate();
275 assertEquals("Test if stack size changes", 3, stk1.size());
276 assertEquals("Test simple integrate1", "1/24*x^4", stk1.pop().toString());
277 RatPoly rp1 = new RatPoly(15, 4);
278 RatPoly rp2 = new RatPoly(7, 0);
279 RatPoly rp3 = new RatPoly(4, 0);
280 stk1.push(rp1);
281 stk1.push(rp2);
282 stk1.push(rp3);
283
284 stk1.integrate();
285 assertEquals("Test simple integrate1", "4*x", stk1.pop().toString());
286 stk1.integrate();
287 assertEquals("Test simple integrate2", "7*x", stk1.pop().toString());
288 stk1.integrate();
289 assertEquals("Test simple integrate3", "3*x^5", stk1.pop().toString());
290 }
291
292 }