Home/ Questions/Q 675973
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-14T00:52:37+00:00

I’ve run into this dilemma several times. Should my unit-tests duplicate the functionality of

  • 0

I’ve run into this dilemma several times. Should my unit-tests duplicate the functionality of the method they are testing to verify its integrity? OR Should unit tests strive to test the method with numerous manually created instances of inputs and expected outputs?

I’m mainly asking the question for situations where the method you are testing is reasonably simple and its proper operation can be verified by glancing at the code for a minute.

Simplified example (in ruby):

def concat_strings(str1, str2)
  return str1 + " AND " + str2
end

Simplified functionality-replicating test for the above method:

def test_concat_strings
  10.times do
    str1 = random_string_generator
    str2 = random_string_generator
    assert_equal (str1 + " AND " + str2), concat_strings(str1, str2)
  end
end

I understand that most times the method you are testing won’t be simple enough to justify doing it this way. But my question remains; is this a valid methodology in some circumstances (why or why not)?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    It’s a controversial stance, but I believe that unit testing using Derived Values is far superior to using arbitrary hard-coded input and output.

    The issue is that as an algorithm becomes even slightly complex, the relationship between input and output becomes obscure if represented by hard-coded values. The unit test ends up being a postulate. It may work technically, but hurts test maintenability because it leads to Obscure Tests.

    Using Derived Values to test against the result establishes a much clearer relationship between test input and expected output.

    The argument that this doesn’t test anything is simply not true, because any test case will exercise only a part of a path through the SUT, so no single test case will reproduce the entire algorithm being tested, but the combination of tests will do so.

    An additional benefit is that you can use fewer unit tests to cover the desired functionality, and even make them more communicative at the same time. The end result is terser and more maintainable unit tests.

    • 0