如何创建虚假数据和数据对象以进行单元测试？

Question

I have a class that implements a cache and I want to write a JUnit test for it.
The class implements and interface with methods like:

public void insert(Object key, Object value);  
public Object getFromCache(Object key);

and the basic implementation is a singleton.
I am writing a JUnit test but I don't know how to properly create a dummy cache with data in order to use for testing.
Right now I am doing:

@Test
public void myTest() {  
    MyCache cache = MyCache.getInstance();  
    populateWithData(cache);  
    //test cache  
    asserEquals etc  
}  

How can I avoid using the getInstance() and not populate on each test?

Answer 1

Apparently I slightly misread your question.

As the other two answers state, if you want to have a specific cache which you can read from when running each testcase, you could use a ´@before´ method, which initializes your object to be used in your testcase. Each ´@before´ method defined is called prior to calling each testcase . This means that you can write the code to instantiate the object once instead of many times.

Note that if you want to do something different in a testcase, consider adding the customization at the top of that, instead of edition your @before method, since that will impact all your testcases.

Just for clarity's sake, I will include some code:

MyCache cache = null;

@before
public void initCache(){
    cache = MyCache.getInstance();  
    populateWithData(cache);  
}

// ... rest of your program here ...

Original answer :

You can use this if you want to do more fancy testing of more complicated objects. This can still be used in conjunction with the ´@before´ annotation

You could try mockito ...

This is basically a framework to mock off a function or class, that you are not interested in implementing in its totally, especially for testing.

Here is a sample using a mocked off list:

import static org.mockito.Mockito.*;

// mock creation
List mockedList = mock(List.class);

// using mock object - it does not throw any "unexpected interaction" exception
mockedList.add("one");
mockedList.clear();

// selective, explicit, highly readable verification
verify(mockedList).add("one");
verify(mockedList).clear();

// you can mock concrete classes, not only interfaces
LinkedList mockedList = mock(LinkedList.class);

// stubbing appears before the actual execution
when(mockedList.get(0)).thenReturn("first");

// the following prints "first"
System.out.println(mockedList.get(0));

// the following prints "null" because get(999) was not stubbed
System.out.println(mockedList.get(999));

You can basically tell mockito which functions you expect to call on the object, and what you expect the result to be... very versatile. I expect that it will fulfill your needs.

Answer 2

'Reset' singleton before each test. More details can be found here .

For example:

@Before
public void resetMyCacheSingleton() throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
   Field instance = MyCache.class.getDeclaredField("instance");
   instance.setAccessible(true);
   instance.set(null, null);
}

Answer 3

You can use @BeforeClass annotation to do something which will be common and may be computational expensive stuff.

This will ran only once before all the testcases .

@BeforeClass
public static void myTest() {  
    MyCache cache = MyCache.getInstance();  
    populateWithData(cache);  
    //test cache  
    asserEquals etc  
} 

PS Since @BeforeClass can be used with static method only, populateWithData() needs to be static as well. and since populateWithData() method is static, variables used inside it must be static as well.

You can also check @AfterClass to clean/reset some data/resources.