I have completed the following coding exercise. However, I got poor result for testing. I need some help to find out what is missed, incorrect, or incomplete in the testing section. I would appreciate it if anyone could please point out any mistake in the testing section or possibly any improvement in the related section.

Exercise definition:

I would like an address book application on my PC so that I can keep track of my customer contacts

Acceptance Criteria

1. Address book will hold name and phone numbers of contact entries
2. Users should be able to add new contact entries
3. Users should be able to remove existing contact entries
4. Users should be able to print all contacts in an address book
5. Users should be able to maintain multiple address books
6. Users should be able to print a unique set of all contacts across multiple address books

Written in Java

A working user interface is not required, nor the use of any frameworks.

We are looking for all acceptance criteria to be demonstrable through tests

Contact Class

public class Contact implements Comparable<Contact>{

        private String name;
        private String phoneNumber;
    
        public Contact(String name, String phoneNumber) {
            setName(name);
            setPhoneNumber(phoneNumber);
        }
    
        /** setters, getters, toString **/
    }

Constants Class

public final class Constants {
    

    public static final class Exceptions {
        /**
         * Error message for empty address book
         */
        public final static String EMPTY_ADDRESS_BOOK_ERROR_MSG = "Sorry, address book is not found or it is empty!";
        
        /**
         * Error message for invalid contact name
         */
        public final static String INVALID_CONTACT_NAME_ERROR_MSG = "Invalid contact name. contact name cannot be null or empty!";
        
        /**
         * Error message for invalid contact phone number
         */
        public final static String INVALID_CONTACT_PHONE_ERROR_MSG = "Invalid contact phone number. only digits are accepted for phone number!";
    }
}

AddressBook Class

 public class AddressBook {
    
        List<Contact> contacts;
        private String name;
    
        public AddressBook(final String name) {
            this.name = name;
            contacts = new ArrayList<Contact>();
        }
    
        public void addContact(final Contact contact) {
            contacts.add(contact);
        }
    
        public boolean removeContact(Contact contact) {
            return contacts.remove(contact);    
        }
    
        public void printContacts() {
            if (getContacts() != null && !getContacts().isEmpty()) {
                System.out.println(this);
            } else {
                throw new EmptyAddressBookException(Constants.Exceptions.EMPTY_ADDRESS_BOOK_ERROR_MSG);
            }
        }
    
        /** setters, getters, toString **/
    }

SimpleAddressBook Class

public class SimpleAddressBook extends AddressBook implements Serializable {

    private static final long serialVersionUID = 1L;
    
    /**
     * Constructor calls the parent class constructor.
     * @param name -- simple address book name
     */
    public SimpleAddressBook(final String name) {
        super(name);
    }

}

AddressBookController Class

public class AddressBookController {

    final List<AddressBook> addressBooks;
    
    public AddressBookController() {
        addressBooks = new ArrayList<AddressBook>();
    }
    
    public List<AddressBook> getAddressBooks() {
        return addressBooks;
    }
    
    public void addAddressBook(AddressBook addressBook) {
        addressBooks.add(addressBook);
    }
    
    public boolean removeAddressBook(AddressBook addressBook) {
        return addressBooks.remove(addressBook);    
    }

    public List<Contact> getAllContacts() {
        final List<Contact> allContacts = new ArrayList<Contact>();
        for (AddressBook addrBook : getAddressBooks()) {
            allContacts.addAll(addrBook.getContacts());
        }
        return allContacts;
    }


    public Set<Contact> getUniqueContacts() {
        
        Set<Contact> uniqueContacts = new TreeSet<Contact>();
        Set<Contact> commonContacts = new HashSet<Contact>();
        Set<Contact> allContacts = new HashSet<Contact>();
        List<Contact> contacts = null;
        
        for (AddressBook addrBook : addressBooks) {
            contacts = addrBook.getContacts();
            
            allContacts.addAll(uniqueContacts);
            allContacts.addAll(contacts);

            contacts.retainAll(uniqueContacts); 
            commonContacts.addAll(contacts);
            allContacts.removeAll(commonContacts); 

            uniqueContacts.clear();
            uniqueContacts.addAll(allContacts);
        }
        
        return uniqueContacts;
    }
    
    public void printUniqueContacts() {
        Set<Contact> uniqueContacts = getUniqueContacts();
        Iterator<Contact> itr = uniqueContacts.iterator();
        while (itr.hasNext()) {
            System.out.println(itr.next());
        }
    }

}

Testing Section

AddressBookControllerTest Class

public class AddressBookControllerTest {
    
    private AddressBookController adController;
    private AddressBook addressBook1;
    private AddressBook addressBook2;
    private Contact contact1;
    private Contact contact2;
    private Contact contact3;
    private Contact contact4;
    private Contact contact5;
    private Contact contact6;


    @Before 
    public void initialize() {
        adController = new AddressBookController();
        addressBook1 = new AddressBook("addrBook1");
        addressBook2 = new AddressBook("addrBook2");
        contact1 = new Contact("John", "0422435655");
        contact2 = new Contact("John", "9999999999");
        contact3 = new Contact("Alex", "0433889977");
        contact4 = new Contact("Simon", "0423888511");
        contact5 = new Contact("Asghar", "0499888");
        contact6 = new Contact("George", "0499888");
    }
    
    /**
     * Test for adding one address book with multiple contacts to an address book controller.
     */
    @Test
    public void addOneAddressBookTest() {
        final int addrBookSizeBefore = adController.getAddressBooks().size();
        final int contactSizeBefore = addressBook1.getContacts().size();
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact2);
        addressBook1.addContact(contact3);
        addressBook1.addContact(contact4);
        adController.addAddressBook(addressBook1);
        final int addrBookSizeAfter = adController.getAddressBooks().size();
        final int contactSizeAfter = addressBook1.getContacts().size();
        assertEquals(addrBookSizeAfter - addrBookSizeBefore, 1);
        assertEquals(contactSizeAfter - contactSizeBefore, 4);
    }
    
    /**
     * Test for adding multiple address books with multiple contacts to an address book controller.
     */
    @Test
    public void addMultipleAddressBookTest() {
        final int noAddrBooksBefore = adController.getAddressBooks().size();
        final int noContactsAddr1Before = addressBook1.getContacts().size();
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact2);
        adController.addAddressBook(addressBook1);
        
        final int noContactsAddr2Before = addressBook2.getContacts().size();
        addressBook2.addContact(contact3);
        addressBook2.addContact(contact4);
        adController.addAddressBook(addressBook2);
        
        final int noAddrBooksAfter = adController.getAddressBooks().size();
        final int noContactsAddr1After = addressBook1.getContacts().size();
        final int noContactsAddr2After = addressBook2.getContacts().size();

        assertEquals(noAddrBooksAfter - noAddrBooksBefore, 2);
        assertEquals(noContactsAddr1After - noContactsAddr1Before, 2);
        assertEquals(noContactsAddr2After - noContactsAddr2Before, 2);
    }
    
    /**
     * Test for retrieving all the contacts of all address book from address book controller.
     * Duplicate contact is allowed in this list.
     */
    @Test
    public void getAllContactsTest() {
        final int noContactsBefore = adController.getAllContacts().size();
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact3);
        addressBook1.addContact(contact1);
        
        addressBook2.addContact(contact1);
        addressBook2.addContact(contact2);
        addressBook2.addContact(contact4);
        
        adController.addAddressBook(addressBook1);
        adController.addAddressBook(addressBook2);
        
        final int noContactsAfter = adController.getAllContacts().size();
        assertEquals(noContactsAfter - noContactsBefore, 6);
    }
    
    /**
     * Test for removing an address books with multiple contacts from address book controller.
     */
    @Test
    public void removeAddressBookTest() {
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact3);
        
        addressBook2.addContact(contact2);
        addressBook2.addContact(contact4);
        
        adController.addAddressBook(addressBook1);
        adController.addAddressBook(addressBook2);
        
        final int addrBookSizeBefore = adController.getAddressBooks().size();
        final int contactSizeBefore = adController.getAllContacts().size();
        adController.removeAddressBook(addressBook1);
        final int addrBookSizeAfter = adController.getAddressBooks().size();
        final int contactSizeAfter = adController.getAllContacts().size();
        
        assertEquals(addrBookSizeAfter - addrBookSizeBefore, -1);
        assertEquals(contactSizeAfter - contactSizeBefore, -2);
    }
    
    /**
     * Test for retrieving unique contacts of all address books from address book controller.
     */
    @Test
    public void getUniqueContactsAcrossAddrBooksTest() {
        
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact3);
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact5);
        addressBook1.addContact(contact6);
        
        addressBook2.addContact(contact1);
        addressBook2.addContact(contact2);
        addressBook2.addContact(contact4);
        addressBook2.addContact(contact6);
        
        adController.addAddressBook(addressBook1);
        adController.addAddressBook(addressBook2);
        
        // expected unique contacts
        List<Contact> expectedUniqueContacts = new ArrayList<Contact>();
        expectedUniqueContacts.add(contact3);
        expectedUniqueContacts.add(contact2);
        expectedUniqueContacts.add(contact4);
        expectedUniqueContacts.add(contact5);
        
        // expected common contacts
        List<Contact> expectedCommonContacts = new ArrayList<Contact>();
        expectedCommonContacts.add(contact1);
        expectedCommonContacts.add(contact6);
        
        // getting all unique contacts
        Set<Contact> uniqueContacts = adController.getUniqueContacts();
        
        // all the expected unique contacts should be included in the output unique contact list.
        for (Contact contact : expectedUniqueContacts) {
            assertTrue(uniqueContacts.contains(contact));
        }
        // none of the excepted common contacts should be in the output unique contact list.
        for (Contact contact : expectedCommonContacts) {
            assertFalse(uniqueContacts.contains(contact));
        }
    }
    
    /**
     * Test for printing unique contacts of all address books in address book controller.
     */
    @Test
    public void printUniqueContactsAcrossAddrBooksTest() {
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact3);
        addressBook1.addContact(contact1);
        addressBook1.addContact(contact5);
        addressBook1.addContact(contact6);
        
        addressBook2.addContact(contact1);
        addressBook2.addContact(contact2);
        addressBook2.addContact(contact4);
        addressBook2.addContact(contact6);
        
        adController.addAddressBook(addressBook1);
        adController.addAddressBook(addressBook2);
        adController.printUniqueContacts();
    }

}

AddContactTest Class

public class AddContactTest {

    /**
     * Test 1 for invalid contact with empty contact name
     */
    @Test(expected=IllegalArgumentException.class)
    public void testInvalidContactName1() {
        new Contact("", "0422435655");
    }
    
    /**
     * Test 2 for invalid contact with null contact name
     */
    @Test(expected=IllegalArgumentException.class)
    public void testInvalidContactName2() {
        new Contact(null, "9999999999");
    }

    /**
     * Test 3 for invalid contact with null contact phone number
     */
    @Test(expected=IllegalArgumentException.class)
    public void testInvalidContactPhoneNo1() {
        new Contact("Simon", null);
    }
    
    /**
     * Test 4 for invalid contact with empty contact phone number
     */
    @Test(expected=IllegalArgumentException.class)
    public void testInvalidContactPhoneNo2() {
        new Contact("Simon", "");
    }
    
    /**
     * Test 5 for invalid contact with a contact phone number having non-digit characters
     */
    @Test(expected=IllegalArgumentException.class)
    public void testInvalidContactPhoneNo3() {
        new Contact("Alex", "043C8+9977");
    }
    
    /**
     * Test 6 for invalid contact with a contact phone number having non-digit characters
     */
    @Test(expected=IllegalArgumentException.class)
    public void testInvalidContactPhoneNo4() {
        new Contact("Simon", "9877c9876");
    }
    
    /**
     * Test 7 for valid contact with valid contact names and phone numbers
     */
    @Test
    public void testValidContacts() {
        Contact contact = new Contact("Simon", "9");
        assertEquals(contact.getName(), "Simon");
        assertEquals(contact.getPhoneNumber(), "9");
        
        contact = new Contact("Sn", "9980980");
        assertEquals(contact.getName(), "Sn");
        assertEquals(contact.getPhoneNumber(), "9980980");
    }
}

AddressBookAddContactTest Class

public class AddressBookAddContactTest {
    
    private Contact contact1;
    private Contact contact2;
    private Contact contact3;
    /**
     * Address book
     */
    private AddressBook addressBook;
    /**
     * Contact list size before calling a specific method.
     */
    private int contactSizeBefore;
    /**
     * Contact list size after calling a specific method.
     */
    private int contactSizeAfter;

    /**
     * Initializing new contacts and an address book
     */
    @Before 
    public void initialize() {
        contact1 = new Contact("John", "0422435655");
        contact2 = new Contact("John", "9999999999");
        contact3 = new Contact("Alex", "0433889977");
        addressBook = new SimpleAddressBook("addrBook1");
    }
    
    /**
     * Test add zero contact to address book
     */
    @Test
    public void testAddZeroContactToAddressBook() {
        assertEquals(addressBook.getContacts().size(), 0);  
    }
    
    /**
     * Test add one contact to address book
     */
    @Test
    public void testAddOneContactToAddressBook() {
        contactSizeBefore = addressBook.getContacts().size();
        addressBook.addContact(contact1);
        contactSizeAfter = addressBook.getContacts().size();
        assertEquals(contactSizeAfter - contactSizeBefore, 1);
        
        Iterator<Contact> contactIt = addressBook.getContacts().iterator();
        while (contactIt.hasNext()) {
            assertEquals(contactIt.next(), contact1);
        }   
    }
    
    /**
     * Test add multiple contacts to address book
     */
    @Test
    public void testAddMultipleContactsToAddressBook() {
        contactSizeBefore = addressBook.getContacts().size();
        addressBook.addContact(contact1);
        addressBook.addContact(contact2);
        addressBook.addContact(contact3);
        contactSizeAfter = addressBook.getContacts().size();
        assertEquals(contactSizeAfter - contactSizeBefore, 3);  
    }
    
    /**
     * Test add multiple contacts with duplicates to address book
     */
    @Test
    public void testAddMultipleContactsWithDuplicateToAddressBook() {
        // contact list accepts duplicate contact
        contactSizeBefore = addressBook.getContacts().size();
        addressBook.addContact(contact1);
        addressBook.addContact(contact1);
        contactSizeAfter = addressBook.getContacts().size();
        assertEquals(contactSizeAfter - contactSizeBefore, 2);  
    }
    
    /**
     * Test add multiple contacts without duplicates to address book
     */
    @Test
    public void testAddContactsWithoutDuplicateToAddressBook() {    
        // contact list accepts duplicate contact
        contactSizeBefore = addressBook.getContacts().size();
        addressBook.addContact(contact1);
        addressBook.addContact(contact2);
        contactSizeAfter = addressBook.getContacts().size();
        assertEquals(contactSizeAfter - contactSizeBefore, 2);
    }
}

AddressBookPrintContactTest Class

public class AddressBookPrintContactTest {

    /**
     * Address book
     */
    private AddressBook addressBook;

    /**
     * Initializing an empty address book
     */
    @Before 
    public void initialize() {
        addressBook = new SimpleAddressBook("addrBook1");
    }
    
    /**
     * Test expects EmptyAddressBookException when printing an empty address book.
     */
    @Test(expected=EmptyAddressBookException.class)
    public void testPrintContacts() {
        addressBook.printContacts();
    }
    
}

AddressBookRemoveContactTest Class

public class AddressBookRemoveContactTest {
    
    private Contact contact1;
    private Contact contact2;
    private Contact contact3;
    /**
     * Address book
     */
    private AddressBook addressBook;

    /**
     * Initializing few contacts and a simple address book
     */
    @Before 
    public void initialize() {
        contact1 = new Contact("John", "0422435655");
        contact2 = new Contact("John", "9999999999");
        contact3 = new Contact("Nic", "049982845");
        addressBook = new SimpleAddressBook("addrBook1");
    }
    
    /**
     * Test for removing none-existent contact from address book
     */
    @Test
    public void testRemoveNonExistentContactFromAddressBook() {
        assertFalse(addressBook.getContacts().contains(contact3));
        assertFalse(addressBook.removeContact(contact3));
        assertFalse(addressBook.getContacts().contains(contact3));  
    }
    
    /**
     * Test for removing a contact from address book
     */
    @Test
    public void testRemoveContactFromAddressBook() {
        addressBook.addContact(contact1);
        addressBook.addContact(contact2);
        addressBook.removeContact(contact1);
        assertFalse(addressBook.getContacts().contains(contact1));
    }
}

CompareContactTest Class

public class CompareContactTest {
    
    private Contact contact1;
    private Contact contact2;
    private Contact contact3;
    private Contact contact4;
    private Contact contact5;

    /**
     * Initializing few contacts
     */
    @Before 
    public void initialize() {
        contact1 = new Contact("John", "0422435655");
        contact2 = new Contact("JOHN", "0422435655");
        contact3 = new Contact("John", "9999999999");
        contact4 = new Contact("Alex", "0433889977");
        contact5 = new Contact("Simon", "0443889977");
    }
    
    /**
     * Test for equals method of Contact class. Two Contacts are equal only if the contact names and phone numbers are equal.
     */
    @Test
    public void testEqualContacts() {
        assertTrue(contact1.equals(contact2));
        assertTrue(contact2.equals(contact1));
        assertFalse(contact1.equals(contact3));
        assertFalse(contact3.equals(contact1));
        assertFalse(contact4.equals(contact5));
    }
    /**
     * Test for compareTo method of Contact class. 
     * compareTo returns 0 if contacts are equal, greater than 0 if this Contact is greater than specified Contact, and less.
     */
    @Test
    public void testCompareContacts() {
        assertTrue(contact1.compareTo(contact2) == 0);
        assertTrue(contact2.compareTo(contact1) == 0);
        assertTrue(contact1.compareTo(contact3) < 0);
        assertTrue(contact3.compareTo(contact1) > 0);
        assertTrue(contact4.compareTo(contact5) < 0);
    }
    
}