Project 2: Generics and Unit Testing

Due: Monday, 15 Aug 2011, at 23:59:59 PST

Overview

In Project 1 you implemented a non-generic doubly-linked list. In Project 2 you will be "generifying" your linked-list. You will also be developing unit tests to ensure that your linked-list implementation works correctly. Your unit tests will also be used to test the linked-lists of your classmates to make sure they work properly as well. (We may also throw in some faulty and non-faulty linked-list implelmentations of our own.)

Part 1: 3 points

Generify your DoublyLinkedList12 from P1 so that it accepts objects of type T, not object. your new, generic, DoublyLinkedList12 must implement the generic List12 interface (its Javadoc can also be viewed here). Since List12 extends Iterable, your linked-list must support the iterator() method, which should return an object of type Iterator.

Your source file DoublyLinkedList12.java should clearly contain your full name and student ID in a comment at the very top of the file.

Grading

Your generic linked-list will be graded using an automatic script and possibly also manually inspected.

Part 2: 5 points

Using the junit 4.8.2 (note the version number!) unit testing framework (download it here), you will develop a set of unit tests with which to verify the correctness of your linked-list. You should create one single Java file, DoublyLinkedList12Tester.java, which contains all the tests. You can use this "tester" to test your (generic) DoublyLinkedList12 implementation from Part 1 of this assignment. However, your tests must also detect bugs in someone else's (possibly faulty) linked-list implementation. We will test multiple implementations of DoublyLinkedList12 -- some faulty, and some correct -- using your test code. You must use junit-4.8.2 -- you cannot use an earlier version of junit.

Black-box versus white-box testing

In P2, you will be conducting black-box testing of the generic version of DoublyLinkedList12. This means that your test routines should not "peer" into the internal workings (e.g., instance variables) of the DoublyLinkedList12 class you are testing. If you do so (despite this warning), then you will likely get 0 credit because your test code will not compile against someone else's DoublyLinkedList12 implementation (which may use different instance variables). Note that this contrasts with white-box testing, where you do inspect the "inner workings" of a class. For the sake of clarity: In your test code in P2, you should test the DoublyLinkedList12 implementation using only the methods specified in the public List12 interface.

Getting started

Create a file called DoublyLinkedList12Tester.java and import the following classes:

import java.util.*; import org.junit.*; import org.junit.Assert.*;

Then, create a class called DoublyLinkedList12Tester which contains a number of unit test methods. To mark a method as being a "unit test", you should annotate the method using the @Test keyword. Here's an example:

@Test public void testAddOneElement () { // Pretty weak test! final DoublyLinkedList12<String> list = new DoublyLinkedList12<String>(); list.add("test"); Assert.assertEquals(list.size(), 1); }

Note: your test methods should not return anything, nor should they print out anything. Instead, each of your test methods should include at least one call to an "assert" static method in the Assert class to verify that a specific condition is true.

Compiling your code

To compile your test code, first copy the junit-4.8.2.jar file into your current directory. Assuming DoublyLinkedList12.java and DoublyLinkedList12Tester.java are also in the current directory, run: javac -cp .:junit-4.8.2.jar DoublyLinkedList12Tester.java.

Running your code

To run your tester, you will invoke junit's unit testing framework -- it will scan your DoublyLinkedList12Tester.class file for all methods annotated with the @Test keyword (using something called "reflection"), and it will run each of these tests. At the command line, run java -cp .:junit-4.8.2.jar org.junit.runner.JUnitCore DoublyLinkedList12Tester.

Grading

We will be grading according to the following scheme: On any DoublyLinkedList12 implementation that is correct, all of your unit tests in DoublyLinkedList12Tester must pass. On any DoublyLinkedList12 implementation that is incorrect, at least one of your unit tests must fail. Now, suppose that we submit N different implementations of DoublyLinkedList12 to your tester. For every implementation that your tester "classifies correctly" (correctly passes, or correctly fails), your "testing score" S will be increased by 1 point. However, for every implementation that your tester "classifies incorrectly" (incorrectly passes, or incorrectly fails), your testing score S will be decreased by one point. After all N tests are complete, your score will be normalized (as S/N*5) so that the maximum is 5 points. If, however, S is negative (because your tester incorrectly classified more implementations than it correctly classified), then you will receive 0 points (instead of a negative score) for Part 2 of the assignment.

Your tester will be graded using an automatic script and possibly also manually inspected.

Submission

Submit your work using the bundleP2 script in the directory containing your (generic) DoublyLinkedList12.java and DoublyLinkedList12Tester.java files. Make sure you are logged on to ieng6.ucsd.edu using your CSE 12-specific account. As always, make sure to submit before the deadline -- the script will show you (or anyone else) no mercy!