Merge 5735e5c4c7c3e028aa50b14f31e914ccd66fb5e1 into 74a9673e36c7d25c28315cb54247a91792f8fbc0

pom.xml

@@ -7,6 +7,16 @@
     <groupId>com.zipcodewilmington</groupId>
     <artifactId>phonebok</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <!-- https://mvnrepository.com/artifact/junit/junit -->
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+
+    </dependencies>
 
 
 </project>

src/main/java/com/zipcodewilmington/phonebook/Person.java

@@ -0,0 +1,43 @@
+package com.zipcodewilmington.phonebook;
+
+
+import java.util.ArrayList;
+
+public class Person {
+
+    //variables
+
+    /**
+     * we made these private bc we don't want the user to be able to change the data. Another reason we want to do this
+     * is that you want to "hide" how you store the information from the users.
+     */
+
+
+    private String name;
+    private ArrayList<String> phoneNumber;
+
+    public Person (String entryName, String entryNumber) {
+        this.name = entryName;
+        this.phoneNumber = new ArrayList<String>();
+        this.phoneNumber.add(entryNumber);
+
+    }
+
+    public String getNumbers(){
+
+        return phoneNumber.toString();
+    }
+
+    public void removeSingleNumber (String number){
+
+        phoneNumber.remove(number);
+    }
+
+    public void addAdditionalNumber(String number){
+
+        phoneNumber.add(number);
+    }
+}
+
+
+

src/main/java/com/zipcodewilmington/phonebook/PhoneBook.java

@@ -1,7 +1,95 @@
 package com.zipcodewilmington.phonebook;
 
-/**
- * Created by leon on 1/23/18.
- */
+import com.sun.tools.doclets.formats.html.SourceToHTMLConverter;
+
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+//phoneBook class is like the cover of the book.
 public class PhoneBook {
-}
+
+    public static void main(String[] args) {
+
+        PhoneBook myPhoneBookActualObjectInstance= new PhoneBook();
+        //adding two people:
+        myPhoneBookActualObjectInstance.add("vince", "1123456789");
+        myPhoneBookActualObjectInstance.add("amy", "29387429");
+        //asking the program to get a person using it's name and adding an additional number to it:
+        myPhoneBookActualObjectInstance.addAdditionalNumberToEntry("amy", "2344");
+        //printing out the entire phonebook
+        System.out.println(myPhoneBookActualObjectInstance.displayEntirePhoneBookContents());
+    }
+
+
+    /*the treeMap is like the t structure with key/values. key is person's name in this example, value is the arraylist
+    which can hold multiple numbers, fields etc.
+    */
+    TreeMap<String, Person> personTreeMap = new TreeMap<String, Person>();
+
+    public PhoneBook() {
+
+    }
+
+    public void add(String name, String number) {
+        Person phoneBookEntry = new Person(name, number);
+        personTreeMap.put(name, phoneBookEntry);
+    }
+
+
+    public void removeEntireEntry (String name) {
+
+        personTreeMap.remove(name);
+    }
+
+    //newly added thanks to "the falcon"
+    public void addAdditionalNumberToEntry (String name, String number){
+        personTreeMap.get(name).addAdditionalNumber(number);
+
+    }
+
+    public String lookup(String name) {
+
+        return personTreeMap.get(name).getNumbers();
+
+    }
+
+    public String reverseLookup(String number) {
+
+        for (Map.Entry<String, Person> phoneBookEntry : personTreeMap.entrySet()){
+            if (phoneBookEntry.getValue().getNumbers().contains(number)){
+                String foundName = phoneBookEntry.getKey();
+                return foundName;
+            }
+        }
+
+        return "We're sorry. We could not find that number. Have a nice day.";
+
+    }
+
+    public String showNamesOnly() {
+
+        String phoneListOfNamesOnly= "";
+        Set<String> nameTreeKeys = personTreeMap.keySet();
+        for (String personsName : nameTreeKeys) {
+            phoneListOfNamesOnly += (personsName + "\n");
+            }
+
+        return phoneListOfNamesOnly;
+
+        }
+
+    public String displayEntirePhoneBookContents() {
+
+        String entirePhoneBook = "";
+        Set<String> nameTreeKeys = personTreeMap.keySet();
+        for (String personsName : nameTreeKeys) {
+             entirePhoneBook += (personsName + "'s phone number(s): " +  personTreeMap.get(personsName).getNumbers() + "\n");
+        }
+
+        return entirePhoneBook;
+
+        }
+
+    }

src/main/java/com/zipcodewilmington/phonebook/oldPhonebookClass.java

@@ -0,0 +1,96 @@
+
+/*
+package com.zipcodewilmington.phonebook;
+
+        import java.util.ArrayList;
+        import java.util.Map;
+        import java.util.Set;
+        import java.util.TreeMap;
+
+public class oldPhonebookClass {
+
+    //the below defines what kind of attribute you have, which in this case is your "contacts"
+    TreeMap<String, String> personMap;
+
+    String name = "";
+
+    //this is your constructor. whenever you see public + the classname, that is your constructor
+    //
+    // (this phoneBook constructor is like the "cover" of your phonebook (the binding and the spine). it creates an empty book.)
+
+    //this can make as many phonebook objects as you want
+    public PhoneBook() {
+
+        //when we make our phonebooks, this is the form they will take (below)
+        //
+        // this treeMap initializes the "blank pages of the book". the treemap is the structure of how your book will hold info
+
+        //if you were to not set this, your person map would be null(default setting)
+        this.personMap = new TreeMap<String, String>();
+    }
+
+    // this is our method below. it describes what we can do with this phonebook
+
+    //so later, when you call "phonebook.add", that's like someone literally writing a new name and number in your phonebook object
+
+
+    public void add(String name, String number) {
+        Person JohnDoe = new Person(name, number);
+        personMap.put(name, number);
+    }
+
+
+
+    /*
+    //this method would really be better for if you need more information on your person objects (like address, etc).
+
+    public void add(Person person){
+        this.personMap.put(person.getName(), person);
+    }
+
+
+
+    public void remove(String name, String number) {
+
+        personMap.remove(name);
+    }
+
+    public String lookup(String name) {
+
+        return personMap.get(name);
+
+    }
+
+   /* public String reverseLookup (String phoneNumber){
+
+        //this will "grab" all the listings in your book. it does NOT print them.
+        Set<Map.Entry<String, String> = personMap.entrySet();
+
+        for (Map.Entry<String, String> phoneBookEntry : entries) {
+
+            Person person = phoneBookEntry.getValue();
+
+            if (person.getPhoneNumber().equals(phoneNumber)){
+                return phoneBookEntry.getKey();
+            }
+        }
+
+       return "We're sorry. The requested phone number could not be found. Have fun when you code!!!!!!!!";
+
+    }
+
+
+
+    public void displayAllEntries() {
+
+        for (Map.Entry<String, String> entry : personMap.entrySet()) {
+            String name = entry.getKey();
+            String number = entry.getValue();
+        }
+
+    }
+
+
+}
+
+*/

src/test/java/com/zipcodewilmington/phonebook/PersonTest.java

@@ -0,0 +1,20 @@
+package com.zipcodewilmington.phonebook;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class PersonTest {
+
+    @Test
+    public void getNumbers() {
+    }
+
+    @Test
+    public void removeSingleNumber() {
+    }
+
+    @Test
+    public void addAdditionalNumber() {
+    }
+}

src/test/java/com/zipcodewilmington/phonebook/PhoneBookTest.java

@@ -1,7 +1,193 @@
 package com.zipcodewilmington.phonebook;
 
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Map;
+import java.util.TreeMap;
+
 /**
  * Created by leon on 1/23/18.
  */
 public class PhoneBookTest {
+
+//Start off here. google "how to write a test for a map"
+//    PhoneBook testPhonebook = new PhoneBook(); <=why didn't this work?
+    PhoneBook testPhonebook;
+
+    @Before
+    public void setup() {
+            testPhonebook = new PhoneBook();
+    }
+
+    @Test
+    public void addEntryTestCase1(){
+        //Given
+            //a person object
+            // a name and a number object
+        new Person("Addison", "1234");
+
+
+        //When
+            //we add the person to the phonebook
+        testPhonebook.add("Addison", "1234");
+        String testNumber = testPhonebook.lookup("Addison");
+
+        //Then
+            //we expect to see that person object with assigned name and number
+
+        Assert.assertTrue(testNumber.equals("[1234]"));
+    }
+
+    @Test
+    public void addEntryTestCase2(){
+        new Person("AdDy", "123.4");
+        testPhonebook.add("AdDy", "123.4");
+        String testNumber = testPhonebook.lookup("AdDy");
+        Assert.assertTrue(testNumber.equals("[123.4]"));
+    }
+
+//    @Test
+//    public void removeEntireEntryTest1(){
+//        testPhonebook.add("Allessandra", "4321");
+//        testPhonebook.add("Essarella", "4421");
+//        testPhonebook.removeEntireEntry("Allessandra");
+//        String testNumber = testPhonebook.lookup("Essarella");
+//        Assert.assertNotEquals(null, testNumber);
+//    }
+
+    @Test
+    public void removeEntireEntryTest2(){
+        //Given
+            //2 person objects
+            // 2 names and 2 phone numbers
+
+        testPhonebook.add("Andrea", "8888");
+        testPhonebook.add("Alexei", "8877");
+
+        //When
+            //a user/dev removes one entry from the phonebook
+        testPhonebook.removeEntireEntry("Alexei");
+        String testList = testPhonebook.showNamesOnly();
+
+        //Then
+            //we expect to see that entry gone. we expect only to see all the other entries.
+        Assert.assertTrue(testList.equals("Andrea\n"));
+
+    }
+
+        //newly added thanks to "the falcon"
+    @Test
+    public void addAddtionalNumberToEntryTest() {
+        //Given
+            //A name and a number
+        testPhonebook.add("test", "123");
+
+
+        //When
+            //we add additional number
+        testPhonebook.addAdditionalNumberToEntry("test", "200");
+
+
+        //Then
+            //we expect expect to see that additional number added to the entry
+            String expected = "[123, 200]";
+            String actual = testPhonebook.lookup("test");
+            Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testLookup() {
+
+        //Given
+            //a person object with name and number
+
+        testPhonebook.add("JohnDoe", "1123");
+
+        //When
+            //we try and look up a person's phone number by using their name as the search thing
+        String expected = "[1123]";
+        String actual = testPhonebook.lookup("JohnDoe");
+
+        //Then
+            //we expect to see their number
+
+        Assert.assertEquals(expected, actual);
+
+    }
+
+    @Test
+    public void testListNamesOnly1 (){
+        //Given
+            //a bunch of people with names and numbers
+        testPhonebook.add("Andrea", "8888");
+        testPhonebook.add("Alexei", "8877");
+        testPhonebook.add("Addison", "1234");
+        testPhonebook.add("AdDy", "1234");
+
+        //When
+            //we ask the program to display just the names
+        String actual = testPhonebook.showNamesOnly();
+        String expected = "AdDy\nAddison\nAlexei\nAndrea\n";
+
+        //Then
+            //we expect to see just the names
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void displayEntirePhoneBookContentsTest(){
+        //Given
+            //a list of peoples name and numbers
+        testPhonebook.add("Andrea", "8888");
+        testPhonebook.add("Alexei", "8877");
+        //When
+            //we ask to see all entries with name and numbers
+        String actual = testPhonebook.displayEntirePhoneBookContents();
+        String expected = "Alexei's phone number(s): [8877]\nAndrea's phone number(s): [8888]\n";
+        //Then
+            //we expect to see all entries with name and numbers
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void addAdditionalNumberTest(){
+        //Given
+            //a person object with an existing number
+        testPhonebook.add("Andrea", "8888");
+        //When
+            // we add an addtional number to that person object
+        testPhonebook.personTreeMap.get("Andrea").addAdditionalNumber("1111");
+
+        //Then
+            // we expect to see that number added
+        String actual= testPhonebook.displayEntirePhoneBookContents();
+        String expected = "Andrea's phone number(s): [8888, 1111]\n";
+//        String actual = testPhonebook.lookup("Andrea");
+//        String expected = "[8888, 1111]";
+        Assert.assertEquals(expected, actual);
+
+    }
+    @Test
+    public void removeSingleNumberTest(){
+        //Given
+            //an entry with more than 1 number
+        testPhonebook.add("Andrea", "8888");
+        testPhonebook.personTreeMap.get("Andrea").addAdditionalNumber("1111");
+        testPhonebook.personTreeMap.get("Andrea").addAdditionalNumber("2222");
+
+        //When
+            //we try to remove a number
+        testPhonebook.personTreeMap.get("Andrea").removeSingleNumber("1111");
+
+        //Then
+            //we expect to see the original entry with all of its numbers except the one we removed
+        String actual = testPhonebook.displayEntirePhoneBookContents();
+        String expected = "Andrea's phone number(s): [8888, 2222]\n";
+        Assert.assertEquals(expected, actual);
+    }
+
+
+
 }