Using old code to verify results in unit tests

Question

Lets says I'm replacing an over complicated method with a much simpler implementation that I believe does the same thing.

Would it make sense for me to copy the old code into a class with my unit tests so I can assert the result of both is the same?

Thanks

Answer 1

Yes. It's a fine way to get started.

But don't stop there.

Also write a test that has the "final answer" that the old code used to produce.

At some point you will want to delete the old code from your unit tests because it's wrong and unmaintainable.

Answer 2

You could also make your test assert both methods return the same value. Something like

Assert.equals(oldMethod(someInput), newMethod(someInput));

Then you could slowly "set yourself free" from the old method.

Answer 3

Assuming you're using source control, here's what I'd do:

1. Write the tests for the old code.
2. Make sure the tests pass.
3. Check that in to source control.
4. Now, as a separate change, replace the implementation (ie: add new implementation and delete old implementation) and make sure the tests still pass.

As part of step 1 you may want to write a little "harness" for the old code so you can see what values it spits out if your primary goal is just to preserve the existing behavior. The important thing is that you have tests that pass on the old implementation.

The reason for step 3 is that if you ever discover that you missed an important case you can sync to the change where you submitted the tests against the old code, add the new test, verify that it works, and then resync to head and verify that it still works (fixing the new implementation if necessary).

Answer 4

Definitely not. You should have tests to cover each of the cases, boundary conditions, errors, etc., that the old code handles. If your tests are good, your new code is equivalent when the tests pass.

Being able to confidently refactor and eliminate old code is one of the prime benefits of unit testing.

Answer 5

it would make sense to

write the tests first

and make sure the old code passes them before rewriting it

then replace the old code with your new code, and make sure it passes the same tests