Eliminate redundant methods in Address class

THIS DOES NOT CHANGE ANY EXISTING FUNCTIONALITY.

Address.pack() has been removed and all calls replaced with its synonym Address.toHeader().
Address.unpack() has been renamed to Address.fromHeader() to follow the new naming convention.

In days of yore, pack() and toHeader() used to do different things. Now they are identical and
thus one is superfluous. We have standardized on toHeader() and fromHeader().

Change-Id: I199d7718e6816385c9433c3bd7201f80f2287f10

1 files changed, 44 insertions, 45 deletions

diff --git a/tests/src/com/android/emailcommon/mail/AddressUnitTests.java b/tests/src/com/android/emailcommon/mail/AddressUnitTests.java
index 13bf686ed..48186e464 100644
--- a/tests/src/com/android/emailcommon/mail/AddressUnitTests.java
+++ b/tests/src/com/android/emailcommon/mail/AddressUnitTests.java
@@ -44,15 +44,14 @@ public class AddressUnitTests extends AndroidTestCase {
             ;
     private static final int MULTI_ADDRESSES_COUNT = 10;
 
-    private static final Address PACK_ADDR_1 = new Address("john@gmail.com", "John Doe");
-    private static final Address PACK_ADDR_2 = new Address("foo@bar.com", null);
-    private static final Address PACK_ADDR_3 = new Address(
-            "mar.y+test@gmail.com", "Mar-y, B; B*arr");
-    private static final Address[][] PACK_CASES = {
-            {PACK_ADDR_2}, {PACK_ADDR_1},
-            {PACK_ADDR_1, PACK_ADDR_2}, {PACK_ADDR_2, PACK_ADDR_1},
-            {PACK_ADDR_1, PACK_ADDR_3}, {PACK_ADDR_2, PACK_ADDR_2},
-            {PACK_ADDR_1, PACK_ADDR_2, PACK_ADDR_3}, {PACK_ADDR_3, PACK_ADDR_1, PACK_ADDR_2}
+    private static final Address ADDR_1 = new Address("john@gmail.com", "John Doe");
+    private static final Address ADDR_2 = new Address("foo@bar.com", null);
+    private static final Address ADDR_3 = new Address("mar.y+test@gmail.com", "Mar-y, B; B*arr");
+    private static final Address[][] TO_HEADER_CASES = {
+            {ADDR_2}, {ADDR_1},
+            {ADDR_1, ADDR_2}, {ADDR_2, ADDR_1},
+            {ADDR_1, ADDR_3}, {ADDR_2, ADDR_2},
+            {ADDR_1, ADDR_2, ADDR_3}, {ADDR_3, ADDR_1, ADDR_2}
     };
 
     Address mAddress1;
@@ -557,34 +556,34 @@ public class AddressUnitTests extends AndroidTestCase {
      * NOTE:  This is not a claim that these edge cases are "correct", only to maintain consistent
      * behavior while I am changing some of the code in the function under test.
      */
-    public void testEmptyPack() {
+    public void testEmptyToHeader() {
         String result;
 
         // null input => null string
-        result = Address.pack(null);
+        result = Address.toHeader(null);
         assertNull("packing null", result);
 
         // zero-length input => null string
-        result = Address.pack(new Address[] { });
+        result = Address.toHeader(new Address[] { });
         assertNull("packing empty array", result);
     }
 
     /**
-     * Simple quick checks of empty-input edge conditions for unpack()
+     * Simple quick checks of empty-input edge conditions for fromHeader()
      *
      * NOTE:  This is not a claim that these edge cases are "correct", only to maintain consistent
      * behavior while I am changing some of the code in the function under test.
      */
-    public void testEmptyUnpack() {
+    public void testEmptyFromHeader() {
         Address[] result;
 
         /*
         // null input => empty array
-        result = Address.unpack(null);
+        result = Address.fromHeader(null);
         assertTrue("unpacking null address", result != null && result.length == 0);
         */
         // empty string input => empty array
-        result = Address.unpack("");
+        result = Address.fromHeader("");
         assertTrue("unpacking zero-length", result != null && result.length == 0);
     }
 
@@ -613,60 +612,60 @@ public class AddressUnitTests extends AndroidTestCase {
         return true;
     }
 
-    public void testPackUnpack() {
-        for (Address[] list : PACK_CASES) {
-            String packed = Address.pack(list);
-            assertTrue(packed, addressArrayEquals(list, Address.unpack(packed)));
+    public void testToHeaderFromHeader() {
+        for (Address[] list : TO_HEADER_CASES) {
+            String packed = Address.toHeader(list);
+            assertTrue(packed, addressArrayEquals(list, Address.fromHeader(packed)));
         }
     }
 
     /**
-     * Tests that unpackToString() returns the same result as toString(unpack()).
+     * Tests that fromHeaderToString() returns the same result as toString(fromHeader()).
      */
-    public void testUnpackToString() {
-        assertNull(Address.unpackToString(null));
-        assertNull(Address.unpackToString(""));
-
-        for (Address[] list : PACK_CASES) {
-            String packed = Address.pack(list);
-            String s1 = Address.unpackToString(packed);
-            String s2 = Address.toString(Address.unpack(packed));
+    public void testFromHeaderToString() {
+        assertNull(Address.fromHeaderToString(null));
+        assertNull(Address.fromHeaderToString(""));
+
+        for (Address[] list : TO_HEADER_CASES) {
+            String packed = Address.toHeader(list);
+            String s1 = Address.fromHeaderToString(packed);
+            String s2 = Address.toString(Address.fromHeader(packed));
             assertEquals(s2, s2, s1);
         }
     }
 
     /**
-     * Tests that parseAndPack() returns the same result as pack(parse()).
+     * Tests that parseToHeader() returns the same result as toHeader(parse()).
      */
     public void testParseAndPack() {
-        String s1 = Address.parseAndPack(MULTI_ADDRESSES_LIST);
-        String s2 = Address.pack(Address.parse(MULTI_ADDRESSES_LIST));
+        String s1 = Address.parseToHeader(MULTI_ADDRESSES_LIST);
+        String s2 = Address.toHeader(Address.parse(MULTI_ADDRESSES_LIST));
         assertEquals(s2, s1);
     }
 
     public void testSinglePack() {
         Address[] addrArray = new Address[1];
-        for (Address address : new Address[]{PACK_ADDR_1, PACK_ADDR_2, PACK_ADDR_3}) {
-            String packed1 = address.pack();
+        for (Address address : new Address[]{ADDR_1, ADDR_2, ADDR_3}) {
+            String packed1 = address.toHeader();
             addrArray[0] = address;
-            String packed2 = Address.pack(addrArray);
+            String packed2 = Address.toHeader(addrArray);
             assertEquals(packed1, packed2);
         }
     }
 
     /**
      * Tests that:
-     * 1. unpackFirst() with empty list returns null.
-     * 2. unpackFirst() with non-empty returns the same as unpack()[0]
+     * 1. firstAddress() with empty list returns null.
+     * 2. firstAddress() with non-empty returns the same as fromHeader()[0]
      */
-    public void testUnpackFirst() {
-        assertNull(Address.unpackFirst(null));
-        assertNull(Address.unpackFirst(""));
-
-        for (Address[] list : PACK_CASES) {
-            String packed = Address.pack(list);
-            Address[] array = Address.unpack(packed);
-            Address first = Address.unpackFirst(packed);
+    public void testFirstAddress() {
+        assertNull(Address.firstAddress(null));
+        assertNull(Address.firstAddress(""));
+
+        for (Address[] list : TO_HEADER_CASES) {
+            String packed = Address.toHeader(list);
+            Address[] array = Address.fromHeader(packed);
+            Address first = Address.firstAddress(packed);
             assertTrue(packed, addressEquals(array[0], first));
         }
     }