001 package ps1.test;
002
003 import ps1.*;
004
005 import junit.framework.*;
006
007 /**
008 * This class contains a set of test cases that can be used to test the
009 * implementation of the RatPolyStack class.
010 * <p>
011 */
012 public final class RatPolyStackTest extends TestCase {
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 // thus stack123 = "123". desc MUST be a sequence of
049 // decimal number chars
050 //
051 // NOTE: THIS CAN FAIL WITH A WORKING STACK IF RatPoly.toString IS BROKEN!
052 private void assertStackIs(RatPolyStack s, String desc) {
053 assertTrue(s.size() == desc.length());
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 = "Elem(" + i + "): " + p.toString() + ", Expected "
059 + c + ", (Expected Stack:" + desc + ")";
060
061 assertTrue(asstr, eqv(p, constantPoly(c)));
062 }
063 }
064
065 public RatPolyStackTest(String name) {
066 super(name);
067 }
068
069 public void testCtor() {
070 RatPolyStack stk1 = stack();
071 assertTrue(stk1.size() == 0);
072 }
073
074 public void testPush() {
075 RatPolyStack stk1 = stack();
076 stk1.push(constantPoly(0));
077
078 assertStackIs(stk1, "0");
079
080 stk1.push(constantPoly(0));
081 assertStackIs(stk1, "00");
082
083 stk1.push(constantPoly(1));
084 assertStackIs(stk1, "100");
085
086 stk1 = stack("3");
087 assertStackIs(stk1, "3");
088
089 stk1 = stack("23");
090 assertStackIs(stk1, "23");
091
092 stk1 = stack("123");
093 assertStackIs(stk1, "123");
094 }
095
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 public void testPop() {
120 RatPolyStack stk1 = stack("123");
121
122 RatPoly poly = stk1.pop();
123 assertTrue(eqv(poly, constantPoly(1)));
124 assertStackIs(stk1, "23");
125
126 poly = stk1.pop();
127 assertTrue(eqv(poly, constantPoly(2)));
128 assertStackIs(stk1, "3");
129
130 poly = stk1.pop();
131 assertStackIs(stk1, "");
132 }
133
134 public void testDup() {
135 RatPolyStack stk1 = stack("3");
136 stk1.dup();
137 assertStackIs(stk1, "33");
138
139 stk1 = stack("23");
140 stk1.dup();
141 assertStackIs(stk1, "223");
142 assertTrue(stk1.size() == 3);
143 assertTrue(eqv(stk1.getNthFromTop(0), constantPoly(2)));
144 assertTrue(eqv(stk1.getNthFromTop(1), constantPoly(2)));
145 assertTrue(eqv(stk1.getNthFromTop(2), constantPoly(3)));
146
147 stk1 = stack("123");
148 stk1.dup();
149 assertStackIs(stk1, "1123");
150
151 }
152
153 public void testSwap() {
154 RatPolyStack stk1 = stack("23");
155 stk1.swap();
156 assertStackIs(stk1, "32");
157
158 stk1 = stack("123");
159 stk1.swap();
160 assertStackIs(stk1, "213");
161
162 stk1 = stack("112");
163 stk1.swap();
164 assertStackIs(stk1, "112");
165 }
166
167 public void testClear() {
168 RatPolyStack stk1 = stack("123");
169 stk1.clear();
170 assertStackIs(stk1, "");
171 RatPolyStack stk2 = stack("112");
172 stk2.clear();
173 assertStackIs(stk2, "");
174 }
175
176 public void testAdd() {
177 RatPolyStack stk1 = stack("123");
178 stk1.add();
179 assertStackIs(stk1, "33");
180 stk1.add();
181 assertStackIs(stk1, "6");
182
183 stk1 = stack("112");
184 stk1.add();
185 assertStackIs(stk1, "22");
186 stk1.add();
187 assertStackIs(stk1, "4");
188 stk1.push(constantPoly(5));
189 assertStackIs(stk1, "54");
190 stk1.add();
191 assertStackIs(stk1, "9");
192
193 }
194
195 public void testSub() {
196 RatPolyStack stk1 = stack("123");
197 stk1.sub();
198 assertStackIs(stk1, "13");
199 stk1.sub();
200 assertStackIs(stk1, "2");
201
202 stk1 = stack("5723");
203 stk1.sub();
204 assertStackIs(stk1, "223");
205 stk1.sub();
206 assertStackIs(stk1, "03");
207 stk1.sub();
208 assertStackIs(stk1, "3");
209 }
210
211 public void testMul() {
212 RatPolyStack stk1 = stack("123");
213 stk1.mul();
214 assertStackIs(stk1, "23");
215 stk1.mul();
216 assertStackIs(stk1, "6");
217
218 stk1 = stack("112");
219 stk1.mul();
220 assertStackIs(stk1, "12");
221 stk1.mul();
222 assertStackIs(stk1, "2");
223 stk1.push(constantPoly(4));
224 assertStackIs(stk1, "42");
225 stk1.mul();
226 assertStackIs(stk1, "8");
227 }
228
229 public void testDiv() {
230 RatPolyStack stk1 = stack("123");
231 stk1.div();
232 assertStackIs(stk1, "23");
233 }
234
235 public void testDifferentiate() {
236 RatPolyStack stk1 = stack("123");
237 stk1.differentiate();
238 stk1.differentiate();
239 stk1.differentiate();
240 stk1.differentiate();
241 assertTrue("Test if stack size changes", stk1.size() == 3);
242 assertStackIs(stk1, "023");
243
244 RatPoly rp1 = new RatPoly(3, 5);
245 RatPoly rp2 = new RatPoly(7, 0);
246 RatPoly rp3 = new RatPoly(4, 1);
247 stk1.push(rp1);
248 stk1.push(rp2);
249 stk1.push(rp3);
250
251 stk1.differentiate();
252 assertTrue("Test simple differentiate1", stk1.pop().toString().equals(
253 "4"));
254 stk1.differentiate();
255 assertTrue("Test simple differentiate2", stk1.pop().toString().equals(
256 "0"));
257 stk1.differentiate();
258 assertTrue("Test simple differentiate3", stk1.pop().toString().equals(
259 "15*x^4"));
260 }
261
262 public void testIntegrate() {
263 RatPolyStack stk1 = stack("123");
264 stk1.integrate();
265 stk1.integrate();
266 stk1.integrate();
267 stk1.integrate();
268 assertTrue("Test if stack size changes", stk1.size() == 3);
269 assertTrue("Test simple integrate1", stk1.pop().toString().equals(
270 "1/24*x^4"));
271 RatPoly rp1 = new RatPoly(15, 4);
272 RatPoly rp2 = new RatPoly(7, 0);
273 RatPoly rp3 = new RatPoly(4, 0);
274 stk1.push(rp1);
275 stk1.push(rp2);
276 stk1.push(rp3);
277
278 stk1.integrate();
279 assertTrue("Test simple integrate1", stk1.pop().toString()
280 .equals("4*x"));
281 stk1.integrate();
282 assertTrue("Test simple integrate2", stk1.pop().toString()
283 .equals("7*x"));
284 stk1.integrate();
285 assertTrue("Test simple integrate3", stk1.pop().toString().equals(
286 "3*x^5"));
287 }
288
289 // Tell JUnit what order to run the tests in
290 public static Test suite() {
291 TestSuite suite = new TestSuite();
292 suite.addTest(new RatPolyStackTest("testCtor"));
293 suite.addTest(new RatPolyStackTest("testPush"));
294 suite
295 .addTest(new RatPolyStackTest(
296 "testPushCheckForSharingTwixtStacks"));
297 suite.addTest(new RatPolyStackTest("testPop"));
298 suite.addTest(new RatPolyStackTest("testDup"));
299 suite.addTest(new RatPolyStackTest("testSwap"));
300 suite.addTest(new RatPolyStackTest("testClear"));
301 suite.addTest(new RatPolyStackTest("testAdd"));
302 suite.addTest(new RatPolyStackTest("testSub"));
303 suite.addTest(new RatPolyStackTest("testMul"));
304 suite.addTest(new RatPolyStackTest("testDiv"));
305 suite.addTest(new RatPolyStackTest("testDifferentiate"));
306 suite.addTest(new RatPolyStackTest("testIntegrate"));
307 return suite;
308 }
309 }