001package hw4.test; 002 003import static org.junit.Assert.assertEquals; 004import static org.junit.Assert.assertTrue; 005 006import org.junit.Before; 007 008import hw4.RatPoly; 009import hw4.RatPolyStack; 010 011import org.junit.Test; 012 013/** 014 * This class contains a set of test cases that can be used to test the 015 * implementation of the RatPolyStack class. 016 * 017 * Some Test Methods are relatively longer in order to simulate proper stack functionality 018 */ 019@SuppressWarnings("nullness") 020public final class RatPolyStackTest { 021 022 /** 023 * checks that Java asserts are enabled, and exits if not 024 */ 025 @Before 026 public void testAssertsEnabled() { 027 SpecificationTests.checkAssertsEnabled(); 028 } 029 030 // create a new poly that is a constant (doesn't depend on x) 031 private RatPoly constantPoly(int constant) { 032 return new RatPoly(constant, 0); 033 } 034 035 // create a new poly that is a constant (doesn't depend on x) 036 // taking a char allows us to represent stacks as strings 037 private RatPoly constantPoly(char constant) { 038 return constantPoly(Integer.valueOf("" + constant).intValue()); 039 } 040 041 /** @return a new RatPolyStack instance */ 042 private RatPolyStack stack() { 043 return new RatPolyStack(); 044 } 045 046 // create stack of single-digit constant polys 047 private RatPolyStack stack(String desc) { 048 RatPolyStack s = new RatPolyStack(); 049 050 // go backwards to leave first element in desc on _top_ of stack 051 for (int i = desc.length() - 1; i >= 0; i--) { 052 char c = desc.charAt(i); 053 s.push(constantPoly(c)); 054 } 055 return s; 056 } 057 058 // RatPoly equality check 059 // (getting around non-definition of RatPoly.equals) 060 private boolean eqv(RatPoly p1, RatPoly p2) { 061 return p1.toString().equals(p2.toString()); 062 } 063 064 // Compares 's' to a string describing its values. 065 // desc MUST be a sequence of decimal number chars. 066 // Example call: assertStackIs(myStack, "123") 067 // 068 // NOTE: THIS CAN FAIL WITH A WORKING STACK IF RatPoly.toString IS BROKEN! 069 private void assertStackIs(RatPolyStack s, String desc) { 070 assertEquals(desc.length(), s.size()); 071 072 for (int i = 0; i < desc.length(); i++) { 073 RatPoly p = s.getNthFromTop(i); 074 char c = desc.charAt(i); 075 String asstr 076 = String.format("Elem(%d): %s, Expected %c, (Expected Stack:%s)", 077 i, p, c, desc); 078 079 assertTrue(asstr, eqv(p, constantPoly(c))); 080 } 081 } 082 083 /////////////////////////////////////////////////////////////////////////////////////// 084 //// Constructor 085 /////////////////////////////////////////////////////////////////////////////////////// 086 087 @Test 088 public void testCtor() { 089 RatPolyStack stk1 = stack(); 090 assertEquals(0, stk1.size()); 091 } 092 093 /////////////////////////////////////////////////////////////////////////////////////// 094 //// Push 095 /////////////////////////////////////////////////////////////////////////////////////// 096 097 @Test 098 public void testPush() { 099 RatPolyStack stk1 = stack(); 100 stk1.push(constantPoly(0)); 101 102 assertStackIs(stk1, "0"); 103 104 stk1.push(constantPoly(0)); 105 assertStackIs(stk1, "00"); 106 107 stk1.push(constantPoly(1)); 108 assertStackIs(stk1, "100"); 109 110 stk1 = stack("3"); 111 assertStackIs(stk1, "3"); 112 113 stk1 = stack("23"); 114 assertStackIs(stk1, "23"); 115 116 stk1 = stack("123"); 117 assertStackIs(stk1, "123"); 118 } 119 120 @Test 121 public void testPushCheckForSharingTwixtStacks() { 122 RatPolyStack stk1 = stack(); 123 RatPolyStack stk2 = stack("123"); 124 assertStackIs(stk1, ""); 125 assertStackIs(stk2, "123"); 126 127 stk1.push(constantPoly(0)); 128 assertStackIs(stk1, "0"); 129 assertStackIs(stk2, "123"); 130 131 stk1.push(constantPoly(0)); 132 assertStackIs(stk1, "00"); 133 assertStackIs(stk2, "123"); 134 135 stk1.push(constantPoly(1)); 136 assertStackIs(stk1, "100"); 137 assertStackIs(stk2, "123"); 138 139 stk2.push(constantPoly(8)); 140 assertStackIs(stk1, "100"); 141 assertStackIs(stk2, "8123"); 142 } 143 144 /////////////////////////////////////////////////////////////////////////////////////// 145 //// Pop 146 /////////////////////////////////////////////////////////////////////////////////////// 147 148 @Test 149 public void testPop() { 150 RatPolyStack stk1 = stack("123"); 151 152 RatPoly poly = stk1.pop(); 153 assertTrue(eqv(poly, constantPoly(1))); 154 assertStackIs(stk1, "23"); 155 156 poly = stk1.pop(); 157 assertTrue(eqv(poly, constantPoly(2))); 158 assertStackIs(stk1, "3"); 159 160 poly = stk1.pop(); 161 assertStackIs(stk1, ""); 162 } 163 164 /////////////////////////////////////////////////////////////////////////////////////// 165 //// Duplicate 166 /////////////////////////////////////////////////////////////////////////////////////// 167 168 @Test 169 public void testDupWithOneVal() { 170 RatPolyStack stk1 = stack("3"); 171 stk1.dup(); 172 assertStackIs(stk1, "33"); 173 stk1 = stack("123"); 174 stk1.dup(); 175 assertStackIs(stk1, "1123"); 176 } 177 178 @Test 179 public void testDupWithTwoVal() { 180 RatPolyStack stk1 = stack("23"); 181 stk1.dup(); 182 assertStackIs(stk1, "223"); 183 assertEquals(3, stk1.size()); 184 assertTrue(eqv(stk1.getNthFromTop(0), constantPoly(2))); 185 assertTrue(eqv(stk1.getNthFromTop(1), constantPoly(2))); 186 assertTrue(eqv(stk1.getNthFromTop(2), constantPoly(3))); 187 } 188 189 @Test 190 public void testDupWithMultVal() { 191 RatPolyStack stk1 = stack("123"); 192 stk1.dup(); 193 assertStackIs(stk1, "1123"); 194 } 195 196 /////////////////////////////////////////////////////////////////////////////////////// 197 //// Swap 198 /////////////////////////////////////////////////////////////////////////////////////// 199 200 @Test 201 public void testSwapWithTwoElems() { 202 RatPolyStack stk1 = stack("23"); 203 stk1.swap(); 204 assertStackIs(stk1, "32"); 205 } 206 207 @Test 208 public void testSwapWithMultElems() { 209 RatPolyStack stk1 = stack("123"); 210 stk1.swap(); 211 assertStackIs(stk1, "213"); 212 } 213 214 @Test 215 public void testSwapWitSameElems() { 216 RatPolyStack stk1 = stack("112"); 217 stk1.swap(); 218 assertStackIs(stk1, "112"); 219 } 220 221 /////////////////////////////////////////////////////////////////////////////////////// 222 //// Clear 223 /////////////////////////////////////////////////////////////////////////////////////// 224 225 @Test 226 public void testClear() { 227 RatPolyStack stk1 = stack("123"); 228 stk1.clear(); 229 assertStackIs(stk1, ""); 230 RatPolyStack stk2 = stack("112"); 231 stk2.clear(); 232 assertStackIs(stk2, ""); 233 } 234 235 /////////////////////////////////////////////////////////////////////////////////////// 236 //// Add 237 /////////////////////////////////////////////////////////////////////////////////////// 238 239 @Test 240 public void testAddTwoElems() { 241 RatPolyStack stk1 = stack("11"); 242 stk1.add(); 243 assertStackIs(stk1, "2"); 244 } 245 246 @Test 247 public void testAddMultiElems() { 248 RatPolyStack stk1 = stack("123"); 249 stk1.add(); 250 assertStackIs(stk1, "33"); 251 stk1.add(); 252 assertStackIs(stk1, "6"); 253 254 stk1 = stack("112"); 255 stk1.add(); 256 assertStackIs(stk1, "22"); 257 stk1.add(); 258 assertStackIs(stk1, "4"); 259 stk1.push(constantPoly(5)); 260 assertStackIs(stk1, "54"); 261 stk1.add(); 262 assertStackIs(stk1, "9"); 263 264 } 265 266 /////////////////////////////////////////////////////////////////////////////////////// 267 //// Subtract 268 /////////////////////////////////////////////////////////////////////////////////////// 269 270 @Test 271 public void testSubTwoElems() { 272 RatPolyStack stk1 = stack("12"); 273 stk1.sub(); 274 assertStackIs(stk1, "1"); 275 } 276 277 @Test 278 public void testSubMultiElems() { 279 RatPolyStack stk1 = stack("123"); 280 stk1.sub(); 281 assertStackIs(stk1, "13"); 282 stk1.sub(); 283 assertStackIs(stk1, "2"); 284 285 stk1 = stack("5723"); 286 stk1.sub(); 287 assertStackIs(stk1, "223"); 288 stk1.sub(); 289 assertStackIs(stk1, "03"); 290 stk1.sub(); 291 assertStackIs(stk1, "3"); 292 } 293 294 /////////////////////////////////////////////////////////////////////////////////////// 295 //// Multiplication 296 /////////////////////////////////////////////////////////////////////////////////////// 297 298 @Test 299 public void testMulTwoElems() { 300 RatPolyStack stk1 = stack("23"); 301 stk1.mul(); 302 assertStackIs(stk1, "6"); 303 } 304 305 @Test 306 public void testMulMultiElems() { 307 RatPolyStack stk1 = stack("123"); 308 stk1.mul(); 309 assertStackIs(stk1, "23"); 310 stk1.mul(); 311 assertStackIs(stk1, "6"); 312 313 stk1 = stack("112"); 314 stk1.mul(); 315 assertStackIs(stk1, "12"); 316 stk1.mul(); 317 assertStackIs(stk1, "2"); 318 stk1.push(constantPoly(4)); 319 assertStackIs(stk1, "42"); 320 stk1.mul(); 321 assertStackIs(stk1, "8"); 322 } 323 324 /////////////////////////////////////////////////////////////////////////////////////// 325 //// Division 326 /////////////////////////////////////////////////////////////////////////////////////// 327 328 @Test 329 public void testDivTwoElems() { 330 RatPolyStack stk1 = stack("28"); 331 stk1.div(); 332 assertStackIs(stk1, "4"); 333 } 334 335 @Test 336 public void testDivMultiElems() { 337 RatPolyStack stk1 = stack("123"); 338 stk1.div(); 339 assertStackIs(stk1, "23"); 340 } 341 342 /////////////////////////////////////////////////////////////////////////////////////// 343 //// Differentiate 344 /////////////////////////////////////////////////////////////////////////////////////// 345 346 @Test 347 public void testDifferentiate() { 348 RatPolyStack stk1 = stack("123"); 349 stk1.differentiate(); 350 stk1.differentiate(); 351 stk1.differentiate(); 352 stk1.differentiate(); 353 assertEquals("Test if stack size changes", 3, stk1.size()); 354 assertStackIs(stk1, "023"); 355 356 RatPoly rp1 = new RatPoly(3, 5); 357 RatPoly rp2 = new RatPoly(7, 0); 358 RatPoly rp3 = new RatPoly(4, 1); 359 stk1.push(rp1); 360 stk1.push(rp2); 361 stk1.push(rp3); 362 363 stk1.differentiate(); 364 assertEquals("Test simple differentiate1", "4", stk1.pop().toString()); 365 stk1.differentiate(); 366 assertEquals("Test simple differentiate2", "0", stk1.pop().toString()); 367 stk1.differentiate(); 368 assertEquals("Test simple differentiate3", "15*x^4", stk1.pop().toString()); 369 } 370 371 /////////////////////////////////////////////////////////////////////////////////////// 372 //// Integrate 373 /////////////////////////////////////////////////////////////////////////////////////// 374 375 @Test 376 public void testIntegrate() { 377 RatPolyStack stk1 = stack("123"); 378 stk1.integrate(); 379 stk1.integrate(); 380 stk1.integrate(); 381 stk1.integrate(); 382 assertEquals("Test if stack size changes", 3, stk1.size()); 383 assertEquals("Test simple integrate1", "1/24*x^4", stk1.pop().toString()); 384 RatPoly rp1 = new RatPoly(15, 4); 385 RatPoly rp2 = new RatPoly(7, 0); 386 RatPoly rp3 = new RatPoly(4, 0); 387 stk1.push(rp1); 388 stk1.push(rp2); 389 stk1.push(rp3); 390 391 stk1.integrate(); 392 assertEquals("Test simple integrate1", "4*x", stk1.pop().toString()); 393 stk1.integrate(); 394 assertEquals("Test simple integrate2", "7*x", stk1.pop().toString()); 395 stk1.integrate(); 396 assertEquals("Test simple integrate3", "3*x^5", stk1.pop().toString()); 397 } 398 399}