Testing a file that relies heavily on a static array

Question

I have a .c file that basically manages its own little database of people. There are add, remove, edit and search functions among some others. It has a static array which it uses to store the data.

What is a good way to go about unit testing a file like this? Because the array is static I can't put in my own data.

Should I employ some trickery and make a function that passes out a pointer to the array that gets compiled out in the production version? Should I just test the functions as is and make the data they way I want it via a series of adds and removes? What is the best way to test a file like this?

Answer 1

The best thing you can do is to refactor the code to make it more testable. Not only does this yield immediate benefits in testablity, it has long-term benefits like improved code readability.

If for some reason you can't refactor this code, you add some test-specific code that improves testablity. Namely, something that lets you set the content of the array. You can use #define in C to filter this code out of non-test mode execution.

Answer 2

If you have a public interface for manipulating and querying the data, use it to verify that the behavior is as expected. It's only better not to access the static array directly; the static array is an implementation detail and manipulating it directly will only make it harder to refactor the module in the future.

What might be a problem is if the module internally interacts with the filesystem for e.g. loading and storing data without being explicitly told so; i.e. there is no public load/save API. That's hopefully out of scope for you, because that requires some more work to get testable.

Answer 3

you can refactor you code like this

old code

   static MyType[] myArray = ...
   void oldFuncThatUsesStaticArray(Type param1, Type param2, Type param3, ...)
   {
      // ... do the processing by accessing global static myArray  
   }

new code

   static MyType[] myArray = ...
   void oldFuncThatUsesStaticArray(Type param1, Type param2, Type param3, ...)
   {
      newFuncWithArrayParameter(param1, param2, param3, ..., myArray);
   }

   void newFuncWithArrayParameter(Type param1, Type param2, ..., MyType[] myArray)
   {
      // ... do the processing by accessing the parameter myArray
      // ... that hides global static myStaticArray  
   }

for the testing you call newFuncWithArrayParameter() while your app is still using oldFuncThatUsesStaticArray()

Note this is pseudo-syntax as i am not a c-developper

Answer 4

As Joel said in Things You Should Never Do, you should never rewrite the code. You can write your test codes to call the add, remove, edit and search functions in this file which verify the correctness of the functions and the static array. If the test codes can judge the testing result automatically, you have the base to refactor the code. Every programmer wants to change the original codes to their own, but the key element lies in whether the original codes are stable or not. Otherwise you will just do the useless work.