When creating a new class / method, i usually write the simplest test that is possible, so that “test fails” means “does not compile” and the test passes after some trivial coding. So my first test was something like this:

public class RpnCalculatorTest {
@Test
public void shouldContainZeroInEachRegisterAfterCreation() throws Exception {
    RpnCalculator calc = new RpnCalculator();
    assertEquals(BigDecimal.ZERO, calc.getX());
    assertEquals(BigDecimal.ZERO, calc.getY());
    assertEquals(BigDecimal.ZERO, calc.getZ());
    assertEquals(BigDecimal.ZERO, calc.getT());
}
}

Next i tried to get some values into the registers. All the tests first used ints instead of BigDecimal and char, but i refactored later to these types…

@Test
public void shouldContainNumberAfterTakingIt() throws Exception {
    calc.take('1');
    assertEquals(new BigDecimal(1), calc.getX());
}
@Test
public void shouldContainTwoDigitNumberAfterTakingEachDigit()
        throws Exception {
    calc.take('4');
    calc.take('2');
    assertRegisterValues(calc, new BigDecimal(42), BigDecimal.ZERO,
            BigDecimal.ZERO, BigDecimal.ZERO);
}
@Test
public void shouldCopyContentOfXToYIfEnterIsCalled() throws Exception {
    BigDecimal two = new BigDecimal(2);
    calc.take('2');
    calc.enter();
    assertRegisterValues(calc, two, two, BigDecimal.ZERO, BigDecimal.ZERO);
}

After that i started with class OperandStack and tests like these:

@Before
public void setUp() {
    mockStack = mock(java.util.Stack.class);
    stack = new OperandStack(mockStack);
}

@Test
public void shouldDelegatePush() throws Exception {
    BigDecimal value = new BigDecimal(1);
    stack.push(value);
    verify(mockStack).push(value);
}

@Test
public void shouldDelegatePopIfStackIsNotEmpty() throws Exception {
    when(mockStack.empty()).thenReturn(false);
    stack.pop();
    verify(mockStack).pop();
}

@Test
public void shouldPopZeroIfStackIsEmpty() {
    when(mockStack.empty()).thenReturn(true);
    assertEquals(BigDecimal.ZERO, stack.pop());
    verify(mockStack, never()).pop();
}

@Test
public void shouldReturnZeroForElementFromTopWithNonExistingIndex() {
    when(mockStack.size()).thenReturn(0);
    assertEquals(BigDecimal.ZERO, stack.elementFromTop(0));
    verify(mockStack, never()).elementAt(1);
}

@Test
public void shouldReturnElementFromTopWithExistingIndex() {
    when(mockStack.size()).thenReturn(2);
    when(mockStack.elementAt(0)).thenReturn(new BigDecimal(42));
    assertEquals(new BigDecimal(42), stack.elementFromTop(1));
}

These are the first of currently 27 tests beeing now at the point where the second exercise starts.

Sorry for being a little off topic, but isn’t it funny that HP were able to market RPN as a feature, while it’s a way to make the calculator’s design simpler? A typical calculator parses the formula the user enters to create a tree and then executes it on a stack. HP calculators skipped the parsing step and required the user to work directly on the stack. It’s like RPN is the assembly language of calculators. :-)

Martin Vilcans wrote:

...isn’t it funny that HP …

Maybe. It IS easier to build (in circuits or software) for the reason you mention. However, RPN has been around since 1920, so I’m not sure if their reason was to make something that was easier to build (maybe) or something that is easier to use (well it is for me, but I love vi as well).

According to the hp museum site, they decided on RPN because of its ability to handle more complex expressions. Given the time-frame (1968), and the weigh (40 pounds), going with a simpler way to represent expressions was a good idea!

And personally, I have a much better time using RPN than infix calculators.

The core of the problem revolves around manipulating the operand stack. Looking at the worked examples in the problem definition, the simplest assertion you can make is that when popping an empty stack, the returned value should be 0, so that is where I started from. The test is at http://randomcode.net.nz/2009/06/22/yet-another-bdd-extension-for-xunit/ as I used it to drive out a BDD style extension for xUnit.

@Test public void ??? shouldContainZeroInEachRegisterAfterCreation() throws Exception { RpnCalculator calc = new RpnCalculator(); assertEquals ??? ?? (BigDecimal.ZERO, calc.getX()); assertEquals(BigDecimal.ZERO, calc.getY()); assertEquals(BigDecimal.ZERO, calc.getZ()); assertEquals(BigDecimal.ZERO, calc.getT());

Given the time-frame (1968), and the weigh (40 pounds), going with a simpler way to represent expressions was a good idea!

what is wrong with me