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 }