Source code

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}