Code drop from //branches/cupcake/...@124589

13 files changed, 3537 insertions, 0 deletions

diff --git a/tests/CoreTests/com/android/internal/telephony/ATResponseParserTest.java b/tests/CoreTests/com/android/internal/telephony/ATResponseParserTest.java
new file mode 100644
index 0000000..81727e4
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/ATResponseParserTest.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony;
+
+import junit.framework.TestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+public class ATResponseParserTest extends TestCase {
+    @SmallTest
+    public void testBasic() throws Exception {
+        ATResponseParser p = new ATResponseParser("+CREG: 0");
+
+        assertEquals(0, p.nextInt());
+
+        assertFalse(p.hasMore());
+
+        try {
+            p.nextInt();
+            fail("exception expected");
+        } catch (ATParseEx ex) {
+            //test pass
+        }
+
+        p = new ATResponseParser("+CREG: 0,1");
+        assertEquals(0, p.nextInt());
+        assertEquals(1, p.nextInt());
+        assertFalse(p.hasMore());
+
+        p = new ATResponseParser("+CREG: 0, 1");
+        assertEquals(0, p.nextInt());
+        assertEquals(1, p.nextInt());
+        assertFalse(p.hasMore());
+
+        p = new ATResponseParser("+CREG: 0, 1,");
+        assertEquals(0, p.nextInt());
+        assertEquals(1, p.nextInt());
+        // this seems odd but is probably OK
+        assertFalse(p.hasMore());
+        try {
+            p.nextInt();
+            fail("exception expected");
+        } catch (ATParseEx ex) {
+            //test pass
+        }
+
+        p = new ATResponseParser("+CREG: 0, 1 ");
+        assertEquals(0, p.nextInt());
+        assertEquals(1, p.nextInt());
+        assertFalse(p.hasMore());
+
+        p = new ATResponseParser("0, 1 ");
+        // no prefix -> exception
+        try {
+            p.nextInt();
+            fail("exception expected");
+        } catch (ATParseEx ex) {
+            //test pass
+        }
+
+        p = new ATResponseParser("+CREG: 0, 1, 5");
+        assertFalse(p.nextBoolean());
+        assertTrue(p.nextBoolean());
+        try {
+            // is this over-constraining?
+            p.nextBoolean();
+            fail("exception expected");
+        } catch (ATParseEx ex) {
+            //test pass
+        }
+
+        p = new ATResponseParser("+CLCC: 1,0,2,0,0,\"+18005551212\",145");
+
+        assertEquals(1, p.nextInt());
+        assertFalse(p.nextBoolean());
+        assertEquals(2, p.nextInt());
+        assertEquals(0, p.nextInt());
+        assertEquals(0, p.nextInt());
+        assertEquals("+18005551212", p.nextString());
+        assertEquals(145, p.nextInt());
+        assertFalse(p.hasMore());
+
+        p = new ATResponseParser("+CLCC: 1,0,2,0,0,\"+18005551212,145");
+
+        assertEquals(1, p.nextInt());
+        assertFalse(p.nextBoolean());
+        assertEquals(2, p.nextInt());
+        assertEquals(0, p.nextInt());
+        assertEquals(0, p.nextInt());
+        try {
+            p.nextString();
+            fail("expected ex");
+        } catch (ATParseEx ex) {
+            //test pass
+        }
+
+        p = new ATResponseParser("+FOO: \"\"");
+        assertEquals("", p.nextString());
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/PhoneNumberUtilsTest.java b/tests/CoreTests/com/android/internal/telephony/PhoneNumberUtilsTest.java
new file mode 100644
index 0000000..e8bd239
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/PhoneNumberUtilsTest.java
@@ -0,0 +1,326 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony;
+
+import android.test.suitebuilder.annotation.SmallTest;
+import android.text.SpannableStringBuilder;
+import android.telephony.PhoneNumberUtils;
+
+import junit.framework.TestCase;
+
+public class PhoneNumberUtilsTest extends TestCase {
+
+    @SmallTest
+    public void testA() throws Exception {
+        assertEquals(
+                "+17005554141",
+                PhoneNumberUtils.extractNetworkPortion("+17005554141")
+        );
+
+        assertEquals(
+                "+17005554141",
+                PhoneNumberUtils.extractNetworkPortion("+1 (700).555-4141")
+        );
+
+        assertEquals(
+                "17005554141",
+                PhoneNumberUtils.extractNetworkPortion("1 (700).555-4141")
+        );
+
+        // This may seem wrong, but it's probably ok
+        assertEquals(
+                "17005554141*#",
+                PhoneNumberUtils.extractNetworkPortion("1 (700).555-4141*#")
+        );
+
+        assertEquals(
+                "170055541NN",
+                PhoneNumberUtils.extractNetworkPortion("1 (700).555-41NN")
+        );
+
+        assertEquals(
+                "170055541NN",
+                PhoneNumberUtils.extractNetworkPortion("1 (700).555-41NN,1234")
+        );
+
+        assertEquals(
+                "170055541NN",
+                PhoneNumberUtils.extractNetworkPortion("1 (700).555-41NN;1234")
+        );
+
+        // An MMI string is unperterbed, even though it contains a
+        // (valid in this case) embedded +
+        assertEquals(
+                "**21**17005554141#",
+                PhoneNumberUtils.extractNetworkPortion("**21**+17005554141#")
+                //TODO this is the correct result, although the above
+                //result has been returned since change 31776
+                //"**21**+17005554141#"
+        );
+
+        assertEquals("", PhoneNumberUtils.extractNetworkPortion(""));
+
+        assertEquals("", PhoneNumberUtils.extractNetworkPortion(",1234"));
+
+        byte [] b = new byte[20];
+        b[0] = (byte) 0x81; b[1] = (byte) 0x71; b[2] = (byte) 0x00; b[3] = (byte) 0x55;
+        b[4] = (byte) 0x05; b[5] = (byte) 0x20; b[6] = (byte) 0xF0;
+        assertEquals("17005550020",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 7));
+
+        b[0] = (byte) 0x91; b[1] = (byte) 0x71; b[2] = (byte) 0x00; b[3] = (byte) 0x55;
+        b[4] = (byte) 0x05; b[5] = (byte) 0x20; b[6] = (byte) 0xF0;
+        assertEquals("+17005550020",
+                PhoneNumberUtils.calledPartyBCDToString(b, 0, 7));
+
+        byte[] bRet = PhoneNumberUtils.networkPortionToCalledPartyBCD("+17005550020");
+        assertEquals(7, bRet.length);
+        for (int i = 0; i < 7; i++) {
+            assertEquals(b[i], bRet[i]);
+        }
+
+        bRet = PhoneNumberUtils.networkPortionToCalledPartyBCD("7005550020");
+        assertEquals("7005550020",
+            PhoneNumberUtils.calledPartyBCDToString(bRet, 0, bRet.length));
+
+        b[0] = (byte) 0x81; b[1] = (byte) 0x71; b[2] = (byte) 0x00; b[3] = (byte) 0x55;
+        b[4] = (byte) 0x05; b[5] = (byte) 0x20; b[6] = (byte) 0xB0;
+        assertEquals("17005550020#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 7));
+
+        b[0] = (byte) 0x91; b[1] = (byte) 0x71; b[2] = (byte) 0x00; b[3] = (byte) 0x55;
+        b[4] = (byte) 0x05; b[5] = (byte) 0x20; b[6] = (byte) 0xB0;
+        assertEquals("+17005550020#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 7));
+
+        b[0] = (byte) 0x81; b[1] = (byte) 0x2A; b[2] = (byte) 0xB1;
+        assertEquals("*21#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 3));
+
+        b[0] = (byte) 0x81; b[1] = (byte) 0x2B; b[2] = (byte) 0xB1;
+        assertEquals("#21#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 3));
+
+        b[0] = (byte) 0x91; b[1] = (byte) 0x2A; b[2] = (byte) 0xB1;
+        assertEquals("*21#+",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 3));
+
+        b[0] = (byte) 0x81; b[1] = (byte) 0xAA; b[2] = (byte) 0x12; b[3] = (byte) 0xFB;
+        assertEquals("**21#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 4));
+
+        b[0] = (byte) 0x91; b[1] = (byte) 0xAA; b[2] = (byte) 0x12; b[3] = (byte) 0xFB;
+        assertEquals("**21#+",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 4));
+
+        b[0] = (byte) 0x81; b[1] = (byte) 0x9A; b[2] = (byte) 0xA9; b[3] = (byte) 0x71;
+        b[4] = (byte) 0x00; b[5] = (byte) 0x55; b[6] = (byte) 0x05; b[7] = (byte) 0x20;
+        b[8] = (byte) 0xB0;
+        assertEquals("*99*17005550020#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 9));
+
+        b[0] = (byte) 0x91; b[1] = (byte) 0x9A; b[2] = (byte) 0xA9; b[3] = (byte) 0x71;
+        b[4] = (byte) 0x00; b[5] = (byte) 0x55; b[6] = (byte) 0x05; b[7] = (byte) 0x20;
+        b[8] = (byte) 0xB0;
+        assertEquals("*99*+17005550020#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 9));
+
+        b[0] = (byte) 0x81; b[1] = (byte) 0xAA; b[2] = (byte) 0x12; b[3] = (byte) 0x1A;
+        b[4] = (byte) 0x07; b[5] = (byte) 0x50; b[6] = (byte) 0x55; b[7] = (byte) 0x00;
+        b[8] = (byte) 0x02; b[9] = (byte) 0xFB;
+        assertEquals("**21*17005550020#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 10));
+
+        b[0] = (byte) 0x91; b[1] = (byte) 0xAA; b[2] = (byte) 0x12; b[3] = (byte) 0x1A;
+        b[4] = (byte) 0x07; b[5] = (byte) 0x50; b[6] = (byte) 0x55; b[7] = (byte) 0x00;
+        b[8] = (byte) 0x02; b[9] = (byte) 0xFB;
+        assertEquals("**21*+17005550020#",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 10));
+
+        b[0] = (byte) 0x81; b[1] = (byte) 0x2A; b[2] = (byte) 0xA1; b[3] = (byte) 0x71;
+        b[4] = (byte) 0x00; b[5] = (byte) 0x55; b[6] = (byte) 0x05; b[7] = (byte) 0x20;
+        b[8] = (byte) 0xF0;
+        assertEquals("*21*17005550020",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 9));
+
+        b[0] = (byte) 0x91; b[1] = (byte) 0x2A; b[2] = (byte) 0xB1; b[3] = (byte) 0x71;
+        b[4] = (byte) 0x00; b[5] = (byte) 0x55; b[6] = (byte) 0x05; b[7] = (byte) 0x20;
+        b[8] = (byte) 0xF0;
+        assertEquals("*21#+17005550020",
+            PhoneNumberUtils.calledPartyBCDToString(b, 0, 9));
+
+        assertNull(PhoneNumberUtils.extractNetworkPortion(null));
+        assertNull(PhoneNumberUtils.extractPostDialPortion(null));
+        assertTrue(PhoneNumberUtils.compare(null, null));
+        assertFalse(PhoneNumberUtils.compare(null, "123"));
+        assertFalse(PhoneNumberUtils.compare("123", null));
+        assertNull(PhoneNumberUtils.toCallerIDMinMatch(null));
+        assertNull(PhoneNumberUtils.getStrippedReversed(null));
+        assertNull(PhoneNumberUtils.stringFromStringAndTOA(null, 1));
+    }
+
+    @SmallTest
+    public void testB() throws Exception {
+        assertEquals("", PhoneNumberUtils.extractPostDialPortion("+17005554141"));
+        assertEquals("", PhoneNumberUtils.extractPostDialPortion("+1 (700).555-4141"));
+        assertEquals("", PhoneNumberUtils.extractPostDialPortion("+1 (700).555-41NN"));
+        assertEquals(",1234", PhoneNumberUtils.extractPostDialPortion("+1 (700).555-41NN,1234"));
+        assertEquals(";1234", PhoneNumberUtils.extractPostDialPortion("+1 (700).555-41NN;1234"));
+        assertEquals(";1234,;N",
+                PhoneNumberUtils.extractPostDialPortion("+1 (700).555-41NN;1-2.34 ,;N"));
+    }
+
+    @SmallTest
+    public void testCompare() throws Exception {
+        // this is odd
+        assertFalse(PhoneNumberUtils.compare("", ""));
+
+        assertTrue(PhoneNumberUtils.compare("911", "911"));
+        assertFalse(PhoneNumberUtils.compare("911", "18005550911"));
+        assertTrue(PhoneNumberUtils.compare("5555", "5555"));
+        assertFalse(PhoneNumberUtils.compare("5555", "180055555555"));
+
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "+17005554141"));
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "+1 (700).555-4141"));
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "+1 (700).555-4141,1234"));
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "17005554141"));
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "7005554141"));
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "5554141"));
+        assertTrue(PhoneNumberUtils.compare("17005554141", "5554141"));
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "01117005554141"));
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "0017005554141"));
+        assertTrue(PhoneNumberUtils.compare("17005554141", "0017005554141"));
+
+
+        assertTrue(PhoneNumberUtils.compare("+17005554141", "**31#+17005554141"));
+
+        assertFalse(PhoneNumberUtils.compare("+1 999 7005554141", "+1 7005554141"));
+        assertTrue(PhoneNumberUtils.compare("011 1 7005554141", "7005554141"));
+
+        assertFalse(PhoneNumberUtils.compare("011 11 7005554141", "+17005554141"));
+
+        assertFalse(PhoneNumberUtils.compare("+17005554141", "7085882300"));
+
+        assertTrue(PhoneNumberUtils.compare("+44 207 792 3490", "0 207 792 3490"));
+
+        assertFalse(PhoneNumberUtils.compare("+44 207 792 3490", "00 207 792 3490"));
+        assertFalse(PhoneNumberUtils.compare("+44 207 792 3490", "011 207 792 3490"));
+
+        /***** FIXME's ******/
+        //
+        // MMI header should be ignored
+        assertFalse(PhoneNumberUtils.compare("+17005554141", "**31#17005554141"));
+
+        // It's too bad this is false
+        // +44 (0) 207 792 3490 is not a dialable number
+        // but it is commonly how European phone numbers are written
+        assertFalse(PhoneNumberUtils.compare("+44 207 792 3490", "+44 (0) 207 792 3490"));
+
+        // The japanese international prefix, for example, messes us up
+        // But who uses a GSM phone in Japan?
+        assertFalse(PhoneNumberUtils.compare("+44 207 792 3490", "010 44 207 792 3490"));
+
+        // The Australian one messes us up too
+        assertFalse(PhoneNumberUtils.compare("+44 207 792 3490", "0011 44 207 792 3490"));
+
+        // The Russian trunk prefix messes us up, as does current
+        // Russian area codes (which bein with 0)
+
+        assertFalse(PhoneNumberUtils.compare("+7(095)9100766", "8(095)9100766"));
+
+        // 444 is not a valid country code, but
+        // matchIntlPrefixAndCC doesnt know this
+        assertTrue(PhoneNumberUtils.compare("+444 207 792 3490", "0 207 792 3490"));
+    }
+
+
+    @SmallTest
+    public void testToCallerIDIndexable() throws Exception {
+        assertEquals("14145", PhoneNumberUtils.toCallerIDMinMatch("17005554141"));
+        assertEquals("14145", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-4141"));
+        assertEquals("14145", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-4141,1234"));
+        assertEquals("14145", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-4141;1234"));
+
+        //this seems wrong, or at least useless
+        assertEquals("NN145", PhoneNumberUtils.toCallerIDMinMatch("1-700-555-41NN"));
+
+        //<shrug> -- these are all not useful, but not terribly wrong
+        assertEquals("", PhoneNumberUtils.toCallerIDMinMatch(""));
+        assertEquals("0032", PhoneNumberUtils.toCallerIDMinMatch("2300"));
+        assertEquals("0032+", PhoneNumberUtils.toCallerIDMinMatch("+2300"));
+        assertEquals("#130#", PhoneNumberUtils.toCallerIDMinMatch("*#031#"));
+    }
+
+    @SmallTest
+    public void testGetIndexable() throws Exception {
+        assertEquals("14145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-4141"));
+        assertEquals("14145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-4141,1234"));
+        assertEquals("14145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-4141;1234"));
+
+        //this seems wrong, or at least useless
+        assertEquals("NN145550071", PhoneNumberUtils.getStrippedReversed("1-700-555-41NN"));
+
+        //<shrug> -- these are all not useful, but not terribly wrong
+        assertEquals("", PhoneNumberUtils.getStrippedReversed(""));
+        assertEquals("0032", PhoneNumberUtils.getStrippedReversed("2300"));
+        assertEquals("0032+", PhoneNumberUtils.getStrippedReversed("+2300"));
+        assertEquals("#130#*", PhoneNumberUtils.getStrippedReversed("*#031#"));
+    }
+
+    @SmallTest
+    public void testNanpFormatting() {
+        SpannableStringBuilder number = new SpannableStringBuilder();
+        number.append("8005551212");
+        PhoneNumberUtils.formatNanpNumber(number);
+        assertEquals("800-555-1212", number.toString());
+
+        number.clear();
+        number.append("800555121");
+        PhoneNumberUtils.formatNanpNumber(number);
+        assertEquals("800-555-121", number.toString());
+
+        number.clear();
+        number.append("555-1212");
+        PhoneNumberUtils.formatNanpNumber(number);
+        assertEquals("555-1212", number.toString());
+
+        number.clear();
+        number.append("800-55512");
+        PhoneNumberUtils.formatNanpNumber(number);
+        assertEquals("800-555-12", number.toString());
+    }
+
+    @SmallTest
+    public void testConvertKeypadLettersToDigits() {
+        assertEquals("1-800-4664-411",
+                     PhoneNumberUtils.convertKeypadLettersToDigits("1-800-GOOG-411"));
+        assertEquals("18004664411",
+                     PhoneNumberUtils.convertKeypadLettersToDigits("1800GOOG411"));
+        assertEquals("1-800-466-4411",
+                     PhoneNumberUtils.convertKeypadLettersToDigits("1-800-466-4411"));
+        assertEquals("18004664411",
+                     PhoneNumberUtils.convertKeypadLettersToDigits("18004664411"));
+        assertEquals("222-333-444-555-666-7777-888-9999",
+                     PhoneNumberUtils.convertKeypadLettersToDigits(
+                             "ABC-DEF-GHI-JKL-MNO-PQRS-TUV-WXYZ"));
+        assertEquals("222-333-444-555-666-7777-888-9999",
+                     PhoneNumberUtils.convertKeypadLettersToDigits(
+                             "abc-def-ghi-jkl-mno-pqrs-tuv-wxyz"));
+        assertEquals("(800) 222-3334",
+                     PhoneNumberUtils.convertKeypadLettersToDigits("(800) ABC-DEFG"));
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/PhoneNumberWatcherTest.java b/tests/CoreTests/com/android/internal/telephony/PhoneNumberWatcherTest.java
new file mode 100644
index 0000000..88eaecd
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/PhoneNumberWatcherTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony;
+
+import android.telephony.PhoneNumberFormattingTextWatcher;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.text.Selection;
+import android.text.SpannableStringBuilder;
+import android.text.TextWatcher;
+
+import junit.framework.TestCase;
+
+public class PhoneNumberWatcherTest extends TestCase {
+    @SmallTest
+    public void testHyphenation() throws Exception {
+        SpannableStringBuilder number = new SpannableStringBuilder();
+        TextWatcher tw = new PhoneNumberFormattingTextWatcher();
+        number.append("555-1212");
+        // Move the cursor to the left edge
+        Selection.setSelection(number, 0);
+        tw.beforeTextChanged(number, 0, 0, 1);
+        // Insert an 8 at the beginning
+        number.insert(0, "8");
+        tw.afterTextChanged(number);
+        assertEquals("855-512-12", number.toString());
+    }
+    
+    @SmallTest
+    public void testHyphenDeletion() throws Exception {
+        SpannableStringBuilder number = new SpannableStringBuilder();
+        TextWatcher tw = new PhoneNumberFormattingTextWatcher();
+        number.append("555-1212");
+        // Move the cursor to after the hyphen
+        Selection.setSelection(number, 4);
+        // Delete the hyphen
+        tw.beforeTextChanged(number, 3, 1, 0);
+        number.delete(3, 4);
+        tw.afterTextChanged(number);
+        // Make sure that it deleted the character before the hyphen 
+        assertEquals("551-212", number.toString());
+        
+        // Make sure it deals with left edge boundary case
+        number.insert(0, "-");
+        Selection.setSelection(number, 1);
+        tw.beforeTextChanged(number, 0, 1, 0);
+        number.delete(0, 1);
+        tw.afterTextChanged(number);
+        // Make sure that it deleted the character before the hyphen 
+        assertEquals("551-212", number.toString());
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/TelephonyTests.java b/tests/CoreTests/com/android/internal/telephony/TelephonyTests.java
new file mode 100644
index 0000000..eb2bd23
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/TelephonyTests.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony;
+
+import com.android.internal.telephony.gsm.AdnRecordTest;
+import com.android.internal.telephony.gsm.GSMPhoneTest;
+import com.android.internal.telephony.gsm.GsmAlphabetTest;
+import com.android.internal.telephony.gsm.SMSDispatcherTest;
+import com.android.internal.telephony.gsm.SimPhoneBookTest;
+import com.android.internal.telephony.gsm.SimSmsTest;
+import com.android.internal.telephony.gsm.SimUtilsTest;
+
+import junit.framework.TestSuite;
+
+/**
+ * To run these tests:
+ * $ mmm java/tests && adb sync
+ * $ adb shell am instrument -w \
+ *    -e class com.android.internal.telephony.TelephonyTests \
+ *    android.core/android.test.InstrumentationTestRunner
+ */
+public class TelephonyTests {
+    public static TestSuite suite() {
+        TestSuite suite = new TestSuite(TelephonyTests.class.getName());
+
+        suite.addTestSuite(PhoneNumberWatcherTest.class);
+        suite.addTestSuite(ATResponseParserTest.class);
+        suite.addTestSuite(PhoneNumberUtilsTest.class);
+        suite.addTestSuite(SMSDispatcherTest.class);
+        //suite.addTestSuite(GSMPhoneTest.class);
+        suite.addTestSuite(AdnRecordTest.class);
+        suite.addTestSuite(GsmAlphabetTest.class);
+        suite.addTestSuite(SimUtilsTest.class);
+        suite.addTestSuite(SimPhoneBookTest.class);
+        suite.addTestSuite(SimSmsTest.class);
+
+        return suite;
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/TestPhoneNotifier.java b/tests/CoreTests/com/android/internal/telephony/TestPhoneNotifier.java
new file mode 100644
index 0000000..427795b
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/TestPhoneNotifier.java
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony;
+
+/**
+ * Stub class used for unit tests
+ */
+
+public class TestPhoneNotifier implements PhoneNotifier {
+    public TestPhoneNotifier() {
+    }
+
+    public void notifyPhoneState(Phone sender) {
+    }
+
+    public void notifyServiceState(Phone sender) {
+    }
+
+    public void notifyCellLocation(Phone sender) {
+    }
+    
+    public void notifySignalStrength(Phone sender) {
+    }
+
+    public void notifyMessageWaitingChanged(Phone sender) {
+    }
+
+    public void notifyCallForwardingChanged(Phone sender) {
+    }
+
+    public void notifyDataConnection(Phone sender, String reason) {
+    }
+
+    public void notifyDataConnectionFailed(Phone sender, String reason) {
+    }
+
+    public void notifyDataActivity(Phone sender) {
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/gsm/AdnRecordTest.java b/tests/CoreTests/com/android/internal/telephony/gsm/AdnRecordTest.java
new file mode 100644
index 0000000..6cafdf0
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/gsm/AdnRecordTest.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.gsm;
+
+import junit.framework.TestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+/**
+ * {@hide}
+ */
+public class AdnRecordTest extends TestCase {
+    
+    @SmallTest
+    public void testBasic() throws Exception {
+        AdnRecord adn;
+
+        //
+        // Typical record
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("566F696365204D61696C07918150367742F3FFFFFFFFFFFF"));
+
+        assertEquals("Voice Mail", adn.getAlphaTag());
+        assertEquals("+18056377243", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // Empty records, empty strings
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));
+
+        assertEquals("", adn.getAlphaTag());
+        assertEquals("", adn.getNumber());
+        assertTrue(adn.isEmpty());
+
+        //
+        // Record too short
+        // 
+        adn = new AdnRecord(SimUtils.hexStringToBytes( "FF"));
+
+        assertEquals("", adn.getAlphaTag());
+        assertEquals("", adn.getNumber());
+        assertTrue(adn.isEmpty());
+
+        //
+        // TOA = 0xff ("control string")
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("566F696365204D61696C07FF8150367742F3FFFFFFFFFFFF"));
+
+        assertEquals("Voice Mail", adn.getAlphaTag());
+        assertEquals("18056377243", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // TOA = 0x81 (unknown)
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("566F696365204D61696C07818150367742F3FFFFFFFFFFFF"));
+
+        assertEquals("Voice Mail", adn.getAlphaTag());
+        assertEquals("18056377243", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // Number Length is too long
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("566F696365204D61696C0F918150367742F3FFFFFFFFFFFF"));
+
+        assertEquals("Voice Mail", adn.getAlphaTag());
+        assertEquals("", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // Number Length is zero (invalid)
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("566F696365204D61696C00918150367742F3FFFFFFFFFFFF"));
+
+        assertEquals("Voice Mail", adn.getAlphaTag());
+        assertEquals("", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // Number Length is 2, first number byte is FF, TOA is international
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("566F696365204D61696C0291FF50367742F3FFFFFFFFFFFF"));
+
+        assertEquals("Voice Mail", adn.getAlphaTag());
+        assertEquals("", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // Number Length is 2, first number digit is valid, TOA is international
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes("566F696365204D61696C0291F150367742F3FFFFFFFFFFFF"));
+
+        assertEquals("Voice Mail", adn.getAlphaTag());
+        assertEquals("+1", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // An extended record
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes(
+                        "4164676A6DFFFFFFFFFFFFFFFFFFFFFF0B918188551512C221436587FF01"));
+
+        assertEquals("Adgjm", adn.getAlphaTag());
+        assertEquals("+18885551212,12345678", adn.getNumber());
+        assertFalse(adn.isEmpty());
+        assertTrue(adn.hasExtendedRecord());
+
+        adn.appendExtRecord(SimUtils.hexStringToBytes("0206092143658709ffffffffff"));
+
+        assertEquals("Adgjm", adn.getAlphaTag());
+        assertEquals("+18885551212,12345678901234567890", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // An extended record with an invalid extension
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes(
+                        "4164676A6DFFFFFFFFFFFFFFFFFFFFFF0B918188551512C221436587FF01"));
+
+        assertEquals("Adgjm", adn.getAlphaTag());
+        assertEquals("+18885551212,12345678", adn.getNumber());
+        assertFalse(adn.isEmpty());
+        assertTrue(adn.hasExtendedRecord());
+
+        adn.appendExtRecord(SimUtils.hexStringToBytes("0106092143658709ffffffffff"));
+
+        assertEquals("Adgjm", adn.getAlphaTag());
+        assertEquals("+18885551212,12345678", adn.getNumber());
+        assertFalse(adn.isEmpty());
+
+        //
+        // An extended record with an invalid extension
+        // 
+        adn = new AdnRecord(
+                SimUtils.hexStringToBytes(
+                        "4164676A6DFFFFFFFFFFFFFFFFFFFFFF0B918188551512C221436587FF01"));
+
+        assertEquals("Adgjm", adn.getAlphaTag());
+        assertEquals("+18885551212,12345678", adn.getNumber());
+        assertFalse(adn.isEmpty());
+        assertTrue(adn.hasExtendedRecord());
+
+        adn.appendExtRecord(SimUtils.hexStringToBytes("020B092143658709ffffffffff"));
+
+        assertEquals("Adgjm", adn.getAlphaTag());
+        assertEquals("+18885551212,12345678", adn.getNumber());
+        assertFalse(adn.isEmpty());
+    }
+}
+
+
diff --git a/tests/CoreTests/com/android/internal/telephony/gsm/GSMPhoneTest.java b/tests/CoreTests/com/android/internal/telephony/gsm/GSMPhoneTest.java
new file mode 100644
index 0000000..ec9b3ef
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/gsm/GSMPhoneTest.java
@@ -0,0 +1,2024 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.gsm;
+
+import android.core.TestHandler;
+import android.os.AsyncResult;
+import android.os.Message;
+import android.telephony.ServiceState;
+import android.test.AndroidTestCase;
+import android.test.PerformanceTestCase;
+
+import com.android.internal.telephony.Call;
+import com.android.internal.telephony.CallStateException;
+import com.android.internal.telephony.Connection;
+import com.android.internal.telephony.MmiCode;
+import com.android.internal.telephony.Phone;
+import com.android.internal.telephony.TestPhoneNotifier;
+import com.android.internal.telephony.test.SimulatedCommands;
+import com.android.internal.telephony.test.SimulatedRadioControl;
+
+import java.util.List;
+
+public class GSMPhoneTest extends AndroidTestCase implements PerformanceTestCase {
+    private SimulatedRadioControl mRadioControl;
+    private TestHandler mTestHandler;
+    private GSMPhone mGSMPhone;
+
+    private static final int EVENT_PHONE_STATE_CHANGED = 1;
+    private static final int EVENT_DISCONNECT = 2;
+    private static final int EVENT_RINGING = 3;
+    private static final int EVENT_CHANNEL_OPENED = 4;
+    private static final int EVENT_POST_DIAL = 5;
+    private static final int EVENT_DONE = 6;
+    private static final int EVENT_SSN = 7;
+    private static final int EVENT_MMI_INITIATE = 8;
+    private static final int EVENT_MMI_COMPLETE = 9;
+    private static final int EVENT_IN_SERVICE = 10;
+    private static final int SUPP_SERVICE_FAILED = 11;
+    private static final int SERVICE_STATE_CHANGED = 12;
+
+    private static final int FAIL_TIMEOUT_MILLIS = 5 * 1000;
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        mTestHandler = TestHandler.create("GSMPhoneTest TestHandler",
+                new Runnable() {
+                    public void run() {
+                        SimulatedCommands sc = new SimulatedCommands();
+                        mRadioControl = sc;
+                        mGSMPhone = new GSMPhone(
+                                mContext, sc,
+                                new TestPhoneNotifier(),
+                                true);
+
+                    }
+                }
+        );
+
+        mTestHandler.setFailTimeoutMillis(FAIL_TIMEOUT_MILLIS);
+        mGSMPhone.registerForPhoneStateChanged(mTestHandler.hh, EVENT_PHONE_STATE_CHANGED, null);
+        mGSMPhone.registerForNewRingingConnection(mTestHandler.hh, EVENT_RINGING, null);
+        mGSMPhone.registerForDisconnect(mTestHandler.hh, EVENT_DISCONNECT, null);
+
+        mGSMPhone.setOnPostDialCharacter(mTestHandler.hh, EVENT_POST_DIAL, null);
+
+        mGSMPhone.registerForSuppServiceNotification(mTestHandler.hh, EVENT_SSN, null);
+        mGSMPhone.registerForMmiInitiate(mTestHandler.hh, EVENT_MMI_INITIATE, null);
+        mGSMPhone.registerForMmiComplete(mTestHandler.hh, EVENT_MMI_COMPLETE, null);
+        mGSMPhone.registerForSuppServiceFailed(mTestHandler.hh, SUPP_SERVICE_FAILED, null);
+        
+        mGSMPhone.registerForServiceStateChanged(mTestHandler.hh, SERVICE_STATE_CHANGED, null);
+
+        // wait until we get phone in both voice and data service
+        Message msg;
+        ServiceState state;
+        do {
+            do {
+                msg = mTestHandler.getNextMessage();            
+            } while (msg.what != SERVICE_STATE_CHANGED);
+            state = (ServiceState) ((AsyncResult) msg.obj).result;        
+        } while (state.getState() != ServiceState.STATE_IN_SERVICE);
+        
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mGSMPhone.unregisterForPhoneStateChanged(mTestHandler.hh);
+        mGSMPhone.unregisterForNewRingingConnection(mTestHandler.hh);
+        mGSMPhone.unregisterForDisconnect(mTestHandler.hh);
+        mGSMPhone.setOnPostDialCharacter(null, 0, null);
+        mGSMPhone.unregisterForSuppServiceNotification(mTestHandler.hh);
+        mGSMPhone.unregisterForMmiInitiate(mTestHandler.hh);
+        mGSMPhone.unregisterForMmiComplete(mTestHandler.hh);
+
+        mRadioControl.shutdown();
+
+        mTestHandler.hh.sendMessage(mTestHandler.hh.obtainMessage(EVENT_DONE));
+
+        Message msg;
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DONE);
+
+        mTestHandler.looper.quit();
+
+        mGSMPhone = null;
+        mRadioControl = null;
+        mTestHandler = null;
+
+        super.tearDown();
+    }
+
+    // These test can only be run once.
+    public int startPerformance(Intermediates intermediates) {
+        return 1;
+    }
+
+    public boolean isPerformanceOnly() {
+        return false;
+    }
+
+    
+    //This test is causing the emulator screen to turn off. I don't understand
+    //why, but I'm removing it until we can figure it out.
+    public void brokenTestGeneral() throws Exception {
+        Connection cn;
+        Message msg;
+        AsyncResult ar;
+
+        // IDLE state
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+        assertFalse(mGSMPhone.canConference());
+
+        // One DIALING connection
+
+        mRadioControl.setAutoProgressConnectingCall(false);
+
+        mGSMPhone.dial("+13125551212");
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_PHONE_STATE_CHANGED);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertEquals(Call.State.DIALING, mGSMPhone.getForegroundCall().getState());
+        assertTrue(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        /*
+        do {
+            th.getNextMessage();
+        } while (phone.getForegroundCall().getConnections().size() == 0);
+        */
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DIALING,
+                mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
+        assertTrue(!cn.isIncoming());
+        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
+
+        assertEquals(Connection.DisconnectCause.NOT_DISCONNECTED, cn.getDisconnectCause());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // One ALERTING connection
+
+        mRadioControl.progressConnectingCallState();
+
+        do {
+            mTestHandler.getNextMessage();
+        }
+        while (mGSMPhone.getForegroundCall().getState() != Call.State.ALERTING);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ALERTING, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
+        assertTrue(!cn.isIncoming());
+        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
+        assertFalse(mGSMPhone.canConference());
+
+        // One ACTIVE connection
+
+        mRadioControl.progressConnectingCallState();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
+
+        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
+        assertTrue(!cn.isIncoming());
+        assertEquals(Connection.PostDialState.COMPLETE, cn.getPostDialState());
+        assertFalse(mGSMPhone.canConference());
+
+        // One disconnected connection
+        mGSMPhone.getForegroundCall().hangup();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
+
+        assertFalse(mGSMPhone.canConference());
+
+        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
+
+        assertEquals(Call.State.DISCONNECTED, cn.getState());
+
+        // Back to idle state
+
+        mGSMPhone.clearDisconnected();
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // cn left over from before phone.clearDisconnected();
+
+        assertEquals(Call.State.DISCONNECTED, cn.getState());
+
+        // One ringing (INCOMING) call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_RINGING);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+
+        ar = (AsyncResult) msg.obj;
+        cn = (Connection) ar.result;
+        assertTrue(cn.isRinging());
+        assertEquals(mGSMPhone.getRingingCall(), cn.getCall());
+
+        assertEquals(1, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.INCOMING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getRingingCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getRingingCall().getEarliestConnectTime());
+
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        cn = mGSMPhone.getRingingCall().getConnections().get(0);
+        assertTrue(cn.isIncoming());
+        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // One mobile terminated active call
+        mGSMPhone.acceptCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getRingingCall().getConnections().size() == 1);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE,
+                mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
+
+        cn = mGSMPhone.getForegroundCall().getConnections().get(0);
+        assertTrue(cn.isIncoming());
+        assertEquals(Connection.PostDialState.NOT_STARTED, cn.getPostDialState());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // One disconnected (local hangup) call
+
+        try {
+            Connection conn;
+            conn = mGSMPhone.getForegroundCall().getConnections().get(0);
+            conn.hangup();
+        } catch (CallStateException ex) {
+            ex.printStackTrace();
+            fail("unexpected ex");
+        }
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DISCONNECTED,
+                mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestConnectTime() > 0);
+
+        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
+
+        assertEquals(Call.State.DISCONNECTED, cn.getState());
+
+        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // Back to idle state
+
+        mGSMPhone.clearDisconnected();
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+
+        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // cn left over from before phone.clearDisconnected();
+
+        assertEquals(Call.State.DISCONNECTED, cn.getState());
+
+        // One ringing call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getRingingCall().getConnections().isEmpty());
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+
+        assertEquals(1, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.INCOMING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getRingingCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getRingingCall().getEarliestConnectTime());
+
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // One rejected call
+        mGSMPhone.rejectCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.IDLE);
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+
+        assertEquals(1, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getRingingCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getRingingCall().getEarliestConnectTime());
+
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        cn = mGSMPhone.getRingingCall().getEarliestConnection();
+        assertEquals(Call.State.DISCONNECTED, cn.getState());
+
+        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
+
+        assertFalse(mGSMPhone.canConference());
+
+        // Back to idle state
+
+        mGSMPhone.clearDisconnected();
+
+        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestCreateTime());
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        assertFalse(mGSMPhone.canConference());
+        assertEquals(Call.State.DISCONNECTED, cn.getState());
+
+        // One ringing call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getRingingCall().getConnections().isEmpty());
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+
+        cn = mGSMPhone.getRingingCall().getEarliestConnection();
+
+        // Ringing call disconnects
+
+        mRadioControl.triggerHangupForeground();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.IDLE);
+
+        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
+
+        // One Ringing Call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.RINGING);
+
+
+        cn = mGSMPhone.getRingingCall().getEarliestConnection();
+
+        // One answered call
+        mGSMPhone.acceptCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // one holding call
+        mGSMPhone.switchHoldingAndActive();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
+
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        // one active call
+        mGSMPhone.switchHoldingAndActive();
+
+        do {
+            mTestHandler.getNextMessage();
+        }
+        while (mGSMPhone.getBackgroundCall().getState() == Call.State.HOLDING);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // One disconnected call in the foreground slot
+
+        mRadioControl.triggerHangupAll();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.IDLE);
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Connection.DisconnectCause.NORMAL, cn.getDisconnectCause());
+
+        // Test missed calls
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.RINGING);
+
+        mGSMPhone.rejectCall();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        ar = (AsyncResult) msg.obj;
+        cn = (Connection) ar.result;
+
+        assertEquals(Connection.DisconnectCause.INCOMING_MISSED, cn.getDisconnectCause());
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getRingingCall().getState());
+
+        // Test incoming not missed calls
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.RINGING);
+
+        cn = mGSMPhone.getRingingCall().getEarliestConnection();
+
+        mGSMPhone.acceptCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
+
+        assertEquals(Connection.DisconnectCause.NOT_DISCONNECTED, cn.getDisconnectCause());
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+
+        try {
+            mGSMPhone.getForegroundCall().hangup();
+        } catch (CallStateException ex) {
+            ex.printStackTrace();
+            fail("unexpected ex");
+        }
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState()
+                != Call.State.DISCONNECTED);
+
+        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
+
+        //
+        // Test held and hangup held calls
+        //
+
+        // One ALERTING call
+        mGSMPhone.dial("+13125551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
+
+        assertTrue(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        mRadioControl.progressConnectingCallState();
+        mRadioControl.progressConnectingCallState();
+
+        // One ACTIVE call
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        // One ACTIVE call, one ringing call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.RINGING);
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+
+        // One HOLDING call, one ACTIVE call
+        mGSMPhone.acceptCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+        assertTrue(mGSMPhone.canConference());
+
+        // Conference the two
+        mGSMPhone.conference();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertTrue(mGSMPhone.getForegroundCall().isMultiparty());
+        assertFalse(mGSMPhone.canConference());
+
+        // Hold the multiparty call
+        mGSMPhone.switchHoldingAndActive();
+
+        do {
+            mTestHandler.getNextMessage();
+        }
+        while (mGSMPhone.getBackgroundCall().getState() != Call.State.HOLDING);
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertTrue(mGSMPhone.getBackgroundCall().isMultiparty());
+        assertFalse(mGSMPhone.canConference());
+
+        // Multiparty call on hold, call waiting added
+
+        mRadioControl.triggerRing("18005558355");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.RINGING);
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+        assertTrue(mGSMPhone.getBackgroundCall().isMultiparty());
+        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
+        assertFalse(mGSMPhone.canConference());
+
+        // Hangup conference call, ringing call still around
+        mGSMPhone.getBackgroundCall().hangup();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.DISCONNECTED);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getBackgroundCall().getState());
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+
+        // Reject waiting call
+        mGSMPhone.rejectCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.IDLE);
+
+        assertFalse(mGSMPhone.getForegroundCall().isDialingOrAlerting());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+    }
+
+    public void testOutgoingCallFailImmediately() throws Exception {
+        Message msg;
+
+        // Test outgoing call fail-immediately edge case
+        // This happens when a call terminated before ever appearing in a
+        // call list
+        // This should land the immediately-failing call in the
+        // ForegroundCall list as an IDLE call
+        mRadioControl.setNextDialFailImmediately(true);
+
+        Connection cn = mGSMPhone.dial("+13125551212");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(Connection.DisconnectCause.NORMAL, cn.getDisconnectCause());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+    }
+
+    public void testHangupOnOutgoing() throws Exception {
+        Connection cn;
+        Message msg;
+
+        mRadioControl.setAutoProgressConnectingCall(false);
+
+        // Test 1: local hangup in "DIALING" state
+        mGSMPhone.dial("+13125551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        }
+        while (mGSMPhone.getForegroundCall().getState() != Call.State.DIALING);
+
+        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
+
+        mGSMPhone.getForegroundCall().hangup();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
+
+        // Test 2: local hangup in "ALERTING" state
+        mGSMPhone.dial("+13125551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
+
+        mRadioControl.progressConnectingCallState();
+
+        do {
+            mTestHandler.getNextMessage();
+        }
+        while (mGSMPhone.getForegroundCall().getState() != Call.State.ALERTING);
+
+        cn = mGSMPhone.getForegroundCall().getEarliestConnection();
+
+        mGSMPhone.getForegroundCall().hangup();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Connection.DisconnectCause.LOCAL, cn.getDisconnectCause());
+
+        // Test 3: local immediate hangup before GSM index is
+        // assigned (CallTracker.hangupPendingMO case)
+
+        mRadioControl.pauseResponses();
+
+        cn = mGSMPhone.dial("+13125551212");
+
+        cn.hangup();
+
+        mRadioControl.resumeResponses();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+
+        assertEquals(Connection.DisconnectCause.LOCAL,
+                mGSMPhone.getForegroundCall().getEarliestConnection().getDisconnectCause());
+    }
+
+    public void testHangupOnChannelClose() throws Exception {
+        mGSMPhone.dial("+13125551212");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getConnections().isEmpty());
+
+        mRadioControl.shutdown();
+
+        do {
+            mTestHandler.getNextMessage();
+            mGSMPhone.clearDisconnected();
+        } while (!mGSMPhone.getForegroundCall().getConnections().isEmpty());
+    }
+
+    public void testIncallMmiCallDeflection() throws Exception {
+        Message msg;
+
+        // establish an active call
+        mGSMPhone.dial("+13125551212");
+
+        do {
+            mRadioControl.progressConnectingCallState();
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // establish a ringing (WAITING) call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_RINGING);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // Simulate entering 0 followed by SEND: release all held calls
+        // or sets UDUB for a waiting call.
+        mGSMPhone.handleInCallMmiCommands("0");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getRingingCall().getState() == Call.State.WAITING);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // change the active call to holding call
+        mGSMPhone.switchHoldingAndActive();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
+
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        // Simulate entering 0 followed by SEND: release all held calls
+        // or sets UDUB for a waiting call.
+        mGSMPhone.handleInCallMmiCommands("0");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.HOLDING);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getBackgroundCall().getState());
+    }
+
+    public void testIncallMmiCallWaiting() throws Exception {
+        Message msg;
+
+        // establish an active call
+        mGSMPhone.dial("+13125551212");
+
+        do {
+            mRadioControl.progressConnectingCallState();
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // establish a ringing (WAITING) call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_RINGING);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // Simulate entering 1 followed by SEND: release all active calls
+        // (if any exist) and accepts the other (held or waiting) call.
+
+        mGSMPhone.handleInCallMmiCommands("1");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getRingingCall().getState() == Call.State.WAITING);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals("18005551212",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+
+        // change the active call to holding call
+        mGSMPhone.switchHoldingAndActive();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        // Simulate entering 1 followed by SEND: release all active calls
+        // (if any exist) and accepts the other (held or waiting) call.
+        mGSMPhone.handleInCallMmiCommands("1");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+        assertEquals("18005551212",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+
+        // at this point, the active call with number==18005551212 should
+        // have the gsm index of 2
+
+        mRadioControl.triggerRing("16505550100");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_RINGING);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // Simulate entering "12" followed by SEND: release the call with
+        // gsm index equals to 2.
+        mGSMPhone.handleInCallMmiCommands("12");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        mGSMPhone.acceptCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getState() != Phone.State.OFFHOOK);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // at this point, the call with number==16505550100 should
+        // have the gsm index of 1
+        mGSMPhone.dial("+13125551212");
+
+        do {
+            mRadioControl.progressConnectingCallState();
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE ||
+                mGSMPhone.getBackgroundCall().getState() != Call.State.HOLDING);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        // at this point, the active call with number==13125551212 should
+        // have the gsm index of 2
+
+        // Simulate entering "11" followed by SEND: release the call with
+        // gsm index equals to 1. This should not be allowed, and a       
+        // Supplementary Service notification must be received.
+        mGSMPhone.handleInCallMmiCommands("11");
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg != null && msg.what != SUPP_SERVICE_FAILED);     
+        assertFalse("IncallMmiCallWaiting: command should not work on holding call", msg == null);
+        
+        // Simulate entering "12" followed by SEND: release the call with
+        // gsm index equals to 2.
+        mGSMPhone.handleInCallMmiCommands("12");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        // Simulate entering 1 followed by SEND: release all active calls
+        // (if any exist) and accepts the other (held or waiting) call.
+        mGSMPhone.handleInCallMmiCommands("1");
+        
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+        assertEquals("16505550100",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+
+        // Simulate entering "11" followed by SEND: release the call with
+        // gsm index equals to 1.
+        mGSMPhone.handleInCallMmiCommands("11");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+    }
+
+    public void testIncallMmiCallHold() throws Exception {
+        Message msg;
+
+        // establish an active call
+        mGSMPhone.dial("13125551212");
+
+        do {
+            mRadioControl.progressConnectingCallState();
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // establish a ringing (WAITING) call
+
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_RINGING);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // simulate entering 2 followed by SEND: place all active calls
+        // (if any exist) on hold and accepts the other (held or waiting)
+        // call
+
+        mGSMPhone.handleInCallMmiCommands("2");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getRingingCall().getState() == Call.State.WAITING);
+
+
+        assertFalse(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE,
+                mGSMPhone.getForegroundCall().getState());
+        assertEquals("18005551212",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+        assertEquals("13125551212",
+                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
+
+        // swap the active and holding calls
+        mGSMPhone.handleInCallMmiCommands("2");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_PHONE_STATE_CHANGED);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals("13125551212",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+        assertEquals("18005551212",
+                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
+
+        // merge the calls
+        mGSMPhone.conference();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+        assertEquals(2, mGSMPhone.getForegroundCall().getConnections().size());
+
+        // at this point, we have an active conference call, with
+        // call(1) = 13125551212 and call(2) = 18005551212
+
+        // Simulate entering "23" followed by SEND: places all active call
+        // on hold except call 3. This should fail and a supplementary service
+        // failed notification should be received.
+        
+        mGSMPhone.handleInCallMmiCommands("23");
+        
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg != null && msg.what != SUPP_SERVICE_FAILED);     
+        assertFalse("IncallMmiCallHold: separate should have failed!", msg == null);
+        
+        // Simulate entering "21" followed by SEND: places all active call
+        // on hold except call 1.
+        mGSMPhone.handleInCallMmiCommands("21");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() == Call.State.IDLE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals("13125551212",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+        assertEquals("18005551212",
+                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
+    }
+
+    public void testIncallMmiMultipartyServices() throws Exception {
+        // establish an active call
+        mGSMPhone.dial("13125551212");
+
+        do {
+            mRadioControl.progressConnectingCallState();
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        // dial another call
+        mGSMPhone.dial("18005551212");
+
+        do {
+            mRadioControl.progressConnectingCallState();
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        mGSMPhone.handleInCallMmiCommands("3");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
+
+        assertEquals(Phone.State.OFFHOOK, mGSMPhone.getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals("18005551212",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+        assertEquals("13125551212",
+                mGSMPhone.getForegroundCall().getConnections().get(1).getAddress());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+    }
+
+    public void testCallIndex() throws Exception {
+        Message msg;
+
+        // establish the first call
+        mGSMPhone.dial("16505550100");
+
+        do {
+            mRadioControl.progressConnectingCallState();
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        String baseNumber = "1650555010";
+
+        for (int i = 1; i < 6; i++) {
+            String number = baseNumber + i;
+
+            mGSMPhone.dial(number);
+
+            do {
+                mRadioControl.progressConnectingCallState();
+                mTestHandler.getNextMessage();
+            } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+            assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+            assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+            if (mGSMPhone.getBackgroundCall().getConnections().size() >= 5) {
+                break;
+            }
+
+            mGSMPhone.conference();
+
+            do {
+                mTestHandler.getNextMessage();
+            } while (mGSMPhone.getBackgroundCall().getState() != Call.State.IDLE);
+
+            assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+            assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+        }
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals("16505550105",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        // create an incoming call, this call should have the call index
+        // of 7
+        mRadioControl.triggerRing("18005551212");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_RINGING);
+
+        assertEquals(Phone.State.RINGING, mGSMPhone.getState());
+        assertTrue(mGSMPhone.getRingingCall().isRinging());
+        assertEquals(Call.State.WAITING, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+
+        // hangup the background call and accept the ringing call
+        mGSMPhone.getBackgroundCall().hangup();
+        mGSMPhone.acceptCall();
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getRingingCall().getState() != Call.State.IDLE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals("18005551212",
+                mGSMPhone.getForegroundCall().getConnections().get(0).getAddress());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+        assertEquals("16505550105",
+                mGSMPhone.getBackgroundCall().getConnections().get(0).getAddress());
+
+        mGSMPhone.handleInCallMmiCommands("17");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.HOLDING, mGSMPhone.getBackgroundCall().getState());
+        assertEquals("16505550105",
+                mGSMPhone.getBackgroundCall().getConnections().get(0).
+                        getAddress());
+
+        mGSMPhone.handleInCallMmiCommands("1");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() != Call.State.ACTIVE);
+
+        assertEquals(Call.State.ACTIVE, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        mGSMPhone.handleInCallMmiCommands("16");
+
+        do {
+            mTestHandler.getNextMessage();
+        } while (mGSMPhone.getForegroundCall().getState() == Call.State.ACTIVE);
+
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+    }
+
+    public void testPostDialSequences() throws Exception {
+        Message msg;
+        AsyncResult ar;
+        Connection cn;
+
+        mGSMPhone.dial("+13125551212,1234;5N8xx");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+            mRadioControl.progressConnectingToActive();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        ar = (AsyncResult) (msg.obj);
+        cn = (Connection) (ar.result);
+        assertEquals(',', msg.arg1);
+        assertEquals("1234;5N8", cn.getRemainingPostDialString());
+
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('1', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('2', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('3', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('4', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals(';', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        cn = (Connection) (ar.result);
+        assertEquals(Connection.PostDialState.WAIT, cn.getPostDialState());
+        assertEquals(Connection.PostDialState.WAIT, ar.userObj);
+        cn.proceedAfterWaitChar();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('5', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('N', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        cn = (Connection) (ar.result);
+        assertEquals(Connection.PostDialState.WILD, cn.getPostDialState());
+        assertEquals(Connection.PostDialState.WILD, ar.userObj);
+        cn.proceedAfterWildChar(",6;7");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        ar = (AsyncResult) (msg.obj);
+        cn = (Connection) (ar.result);
+        assertEquals(',', msg.arg1);
+        assertEquals("6;78", cn.getRemainingPostDialString());
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('6', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals(';', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        cn = (Connection) (ar.result);
+        assertEquals(Connection.PostDialState.WAIT, cn.getPostDialState());
+        assertEquals(Connection.PostDialState.WAIT, ar.userObj);
+        cn.proceedAfterWaitChar();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('7', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('8', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        assertEquals(Connection.PostDialState.STARTED, ar.userObj);
+
+        // Bogus chars at end should be ignored
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals(0, msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        cn = (Connection) (ar.result);
+        assertEquals(Connection.PostDialState.COMPLETE,
+                cn.getPostDialState());
+        assertEquals(Connection.PostDialState.COMPLETE, ar.userObj);
+    }
+
+    public void testPostDialCancel() throws Exception {
+        Message msg;
+        AsyncResult ar;
+        Connection cn;
+
+        mGSMPhone.dial("+13125551212,N");
+        mRadioControl.progressConnectingToActive();
+
+        mRadioControl.progressConnectingToActive();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals(',', msg.arg1);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_POST_DIAL);
+
+        assertEquals('N', msg.arg1);
+        ar = (AsyncResult) (msg.obj);
+        cn = (Connection) (ar.result);
+        assertEquals(Connection.PostDialState.WILD, cn.getPostDialState());
+        cn.cancelPostDial();
+
+        assertEquals(Connection.PostDialState.CANCELLED, cn.getPostDialState());
+    }
+
+    public void testOutgoingCallFail() throws Exception {
+        Message msg;
+        /*
+        * normal clearing
+        */
+
+        mRadioControl.setNextCallFailCause(CallFailCause.NORMAL_CLEARING);
+        mRadioControl.setAutoProgressConnectingCall(false);
+
+        Connection cn = mGSMPhone.dial("+13125551212");
+
+        mRadioControl.progressConnectingCallState();
+
+        // I'm just progressing the call state to
+        // ensure getCurrentCalls() gets processed...
+        // Normally these failure conditions would happen in DIALING
+        // not ALERTING
+        do {
+            mTestHandler.getNextMessage();
+        } while (cn.getState() == Call.State.DIALING);
+
+
+        mRadioControl.triggerHangupAll();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(Connection.DisconnectCause.NORMAL, cn.getDisconnectCause());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        /*
+        * busy
+        */
+
+        mRadioControl.setNextCallFailCause(CallFailCause.USER_BUSY);
+        mRadioControl.setAutoProgressConnectingCall(false);
+
+        cn = mGSMPhone.dial("+13125551212");
+
+        mRadioControl.progressConnectingCallState();
+
+        // I'm just progressing the call state to
+        // ensure getCurrentCalls() gets processed...
+        // Normally these failure conditions would happen in DIALING
+        // not ALERTING
+        do {
+            mTestHandler.getNextMessage();
+        } while (cn.getState() == Call.State.DIALING);
+
+
+        mRadioControl.triggerHangupAll();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(Connection.DisconnectCause.BUSY, cn.getDisconnectCause());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DISCONNECTED,
+                mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+
+        /*
+        * congestion
+        */
+
+        mRadioControl.setNextCallFailCause(CallFailCause.NO_CIRCUIT_AVAIL);
+        mRadioControl.setAutoProgressConnectingCall(false);
+
+        cn = mGSMPhone.dial("+13125551212");
+
+        mRadioControl.progressConnectingCallState();
+
+        // I'm just progressing the call state to
+        // ensure getCurrentCalls() gets processed...
+        // Normally these failure conditions would happen in DIALING
+        // not ALERTING
+        do {
+            mTestHandler.getNextMessage();
+        } while (cn.getState() == Call.State.DIALING);
+
+
+        mRadioControl.triggerHangupAll();
+
+        // Unlike the while loops above, this one waits
+        // for a "phone state changed" message back to "idle"
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (!(msg.what == EVENT_PHONE_STATE_CHANGED
+                && mGSMPhone.getState() == Phone.State.IDLE));
+
+        assertEquals(Phone.State.IDLE, mGSMPhone.getState());
+
+        assertEquals(Connection.DisconnectCause.CONGESTION, cn.getDisconnectCause());
+
+        assertEquals(0, mGSMPhone.getRingingCall().getConnections().size());
+        assertEquals(1, mGSMPhone.getForegroundCall().getConnections().size());
+        assertEquals(0, mGSMPhone.getBackgroundCall().getConnections().size());
+
+        assertEquals(Call.State.IDLE, mGSMPhone.getRingingCall().getState());
+        assertEquals(Call.State.DISCONNECTED, mGSMPhone.getForegroundCall().getState());
+        assertEquals(Call.State.IDLE, mGSMPhone.getBackgroundCall().getState());
+
+        assertTrue(mGSMPhone.getForegroundCall().getEarliestCreateTime() > 0);
+        assertEquals(0, mGSMPhone.getForegroundCall().getEarliestConnectTime());
+    }
+
+    public void testSSNotification() throws Exception {
+        // MO
+        runTest(0, SuppServiceNotification.MO_CODE_UNCONDITIONAL_CF_ACTIVE);
+        runTest(0, SuppServiceNotification.MO_CODE_CALL_IS_WAITING);
+        runTest(0, SuppServiceNotification.MO_CODE_CALL_DEFLECTED);
+
+        // MT
+        runTest(1, SuppServiceNotification.MT_CODE_FORWARDED_CALL);
+        runTest(1, SuppServiceNotification.MT_CODE_CALL_CONNECTED_ECT);
+        runTest(1, SuppServiceNotification.MT_CODE_ADDITIONAL_CALL_FORWARDED);
+    }
+
+    private void runTest(int type, int code) {
+        Message msg;
+
+        mRadioControl.triggerSsn(type, code);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_SSN);
+
+        AsyncResult ar = (AsyncResult) msg.obj;
+
+        assertNull(ar.exception);
+
+        SuppServiceNotification notification =
+                (SuppServiceNotification) ar.result;
+
+        assertEquals(type, notification.notificationType);
+        assertEquals(code, notification.code);
+    }
+
+    public void testUssd() throws Exception {
+        // Quick hack to work around a race condition in this test:
+        // We may initiate a USSD MMI before GSMPhone receives its initial
+        // EVENT_RADIO_OFF_OR_NOT_AVAILABLE event.  When the phone sees this
+        // event, it will cancel the just issued USSD MMI, which we don't
+        // want.  So sleep a little first.
+        try {
+            Thread.sleep(1000);
+        } catch (InterruptedException ex) {
+            // do nothing
+        }
+
+        verifyNormal();
+        verifyCancel();
+        varifyNetworkInitiated();
+    }
+
+    private void varifyNetworkInitiated() {
+        Message msg;
+        AsyncResult ar;
+        MmiCode mmi;
+
+        // Receive an incoming NOTIFY
+        mRadioControl.triggerIncomingUssd("0", "NOTIFY message");
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+
+        ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+
+        assertFalse(mmi.isUssdRequest());
+
+        // Receive a REQUEST and send response
+        mRadioControl.triggerIncomingUssd("1", "REQUEST Message");
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+        ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+
+        assertTrue(mmi.isUssdRequest());
+
+        mGSMPhone.sendUssdResponse("## TEST: TEST_GSMPhone responding...");
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_INITIATE);
+
+        ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+
+        GsmMmiCode gsmMmi = (GsmMmiCode) mmi;
+        assertTrue(gsmMmi.isPendingUSSD());
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+
+        ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+
+        assertNull(ar.exception);
+        assertFalse(mmi.isUssdRequest());
+
+        // Receive a REQUEST and cancel
+        mRadioControl.triggerIncomingUssd("1", "REQUEST Message");
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+        ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+
+        assertTrue(mmi.isUssdRequest());
+
+        mmi.cancel();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+
+        ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+
+        assertNull(ar.exception);
+        assertEquals(MmiCode.State.CANCELLED, mmi.getState());
+
+        List mmiList = mGSMPhone.getPendingMmiCodes();
+        assertEquals(0, mmiList.size());
+    }
+
+    private void verifyNormal() throws CallStateException {
+        Message msg;
+        AsyncResult ar;
+        MmiCode mmi;
+
+        mGSMPhone.dial("#646#");
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_INITIATE);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+
+        ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+        assertEquals(MmiCode.State.COMPLETE, mmi.getState());
+    }
+
+
+    private void verifyCancel() throws CallStateException {
+        /**
+         * This case makes an assumption that dial() will add the USSD
+         * to the "pending MMI codes" list before it returns.  This seems
+         * like reasonable semantics. It also assumes that the USSD
+         * request in question won't complete until we get back to the
+         * event loop, thus cancel() is safe.
+         */
+        Message msg;
+
+        mGSMPhone.dial("#646#");
+
+        List<? extends MmiCode> pendingMmis = mGSMPhone.getPendingMmiCodes();
+
+        assertEquals(1, pendingMmis.size());
+
+        MmiCode mmi = pendingMmis.get(0);
+        assertTrue(mmi.isCancelable());
+        mmi.cancel();
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_INITIATE);
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+
+        AsyncResult ar = (AsyncResult) msg.obj;
+        mmi = (MmiCode) ar.result;
+
+        assertEquals(MmiCode.State.CANCELLED, mmi.getState());
+    }
+
+    public void testRilHooks() throws Exception {
+        //
+        // These test cases all assume the RIL OEM hooks
+        // just echo back their input
+        //
+
+        Message msg;
+        AsyncResult ar;
+
+        // null byte array
+
+        mGSMPhone.invokeOemRilRequestRaw(null, mTestHandler.hh.obtainMessage(999));
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (!(msg.what == 999));
+
+        ar = ((AsyncResult) msg.obj);
+
+        assertNull(ar.result);
+        assertNull(ar.exception);
+
+        // empty byte array
+
+        mGSMPhone.invokeOemRilRequestRaw(new byte[0], mTestHandler.hh.obtainMessage(999));
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (!(msg.what == 999));
+
+        ar = ((AsyncResult) msg.obj);
+
+        assertEquals(0, ((byte[]) (ar.result)).length);
+        assertNull(ar.exception);
+
+        // byte array with data
+
+        mGSMPhone.invokeOemRilRequestRaw("Hello".getBytes("utf-8"),
+                mTestHandler.hh.obtainMessage(999));
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (!(msg.what == 999));
+
+        ar = ((AsyncResult) msg.obj);
+
+        assertEquals("Hello", new String(((byte[]) (ar.result)), "utf-8"));
+        assertNull(ar.exception);
+
+        // null strings
+
+        mGSMPhone.invokeOemRilRequestStrings(null, mTestHandler.hh.obtainMessage(999));
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (!(msg.what == 999));
+
+        ar = ((AsyncResult) msg.obj);
+
+        assertNull(ar.result);
+        assertNull(ar.exception);
+
+        // empty byte array
+
+        mGSMPhone.invokeOemRilRequestStrings(new String[0],
+                mTestHandler.hh.obtainMessage(999));
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (!(msg.what == 999));
+
+        ar = ((AsyncResult) msg.obj);
+
+        assertEquals(0, ((String[]) (ar.result)).length);
+        assertNull(ar.exception);
+
+        // Strings with data
+
+        String s[] = new String[1];
+
+        s[0] = "Hello";
+
+        mGSMPhone.invokeOemRilRequestStrings(s, mTestHandler.hh.obtainMessage(999));
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (!(msg.what == 999));
+
+        ar = ((AsyncResult) msg.obj);
+
+        assertEquals("Hello", ((String[]) (ar.result))[0]);
+        assertEquals(1, ((String[]) (ar.result)).length);
+        assertNull(ar.exception);
+    }
+
+    public void testMmi() throws Exception {
+        mRadioControl.setAutoProgressConnectingCall(false);
+
+        // "valid" MMI sequences
+        runValidMmi("*#67#", false);
+        runValidMmi("##43*11#", false);
+        runValidMmi("#33*1234*11#", false);
+        runValidMmi("*21*6505551234**5#", false);
+        runValidMmi("**03**1234*4321*4321#", false);
+        // pound string
+        runValidMmi("5308234092307540923#", true);
+        // short code
+        runValidMmi("22", true);
+        // as part of call setup
+        runValidMmiWithConnect("*31#6505551234");
+
+        // invalid MMI sequences
+        runNotMmi("6505551234");
+        runNotMmi("1234#*12#34566654");
+        runNotMmi("*#*#12#*");
+    }
+
+    private void runValidMmi(String dialString, boolean cancelable) throws CallStateException {
+        Connection c = mGSMPhone.dial(dialString);
+        assertNull(c);
+
+        Message msg;
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_INITIATE);
+
+        // Should not be cancelable.
+        AsyncResult ar = (AsyncResult) msg.obj;
+        MmiCode mmi = (MmiCode) ar.result;
+        assertEquals(cancelable, mmi.isCancelable());
+
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_MMI_COMPLETE);
+
+    }
+
+    private void runValidMmiWithConnect(String dialString) throws CallStateException {
+        mRadioControl.pauseResponses();
+
+        Connection c = mGSMPhone.dial(dialString);
+        assertNotNull(c);
+
+        hangup(c);
+    }
+
+    private void hangup(Connection cn) throws CallStateException {
+        cn.hangup();
+
+        mRadioControl.resumeResponses();
+
+        Message msg;
+        do {
+            msg = mTestHandler.getNextMessage();
+        } while (msg.what != EVENT_DISCONNECT);
+    }
+
+    private void runNotMmi(String dialString) throws CallStateException {
+        mRadioControl.pauseResponses();
+
+        Connection c = mGSMPhone.dial(dialString);
+        assertNotNull(c);
+
+        hangup(c);
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/gsm/GsmAlphabetTest.java b/tests/CoreTests/com/android/internal/telephony/gsm/GsmAlphabetTest.java
new file mode 100644
index 0000000..f36d96b
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/gsm/GsmAlphabetTest.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.gsm;
+
+import junit.framework.TestCase;
+
+import android.test.suitebuilder.annotation.LargeTest;
+import android.test.suitebuilder.annotation.SmallTest;
+import android.test.suitebuilder.annotation.Suppress;
+
+public class GsmAlphabetTest extends TestCase {
+
+    private static final String sGsmExtendedChars = "{|}\\[~]\f\u20ac";
+
+    @SmallTest
+    public void test7bitWithHeader() throws Exception {
+        byte[] data = new byte[3];
+        data[0] = (byte) 1;
+        data[1] = (byte) 2;
+        data[2] = (byte) 2;
+        SmsHeader header = new SmsHeader();
+        header.add(new SmsHeader.Element(SmsHeader.CONCATENATED_8_BIT_REFERENCE, data));
+
+        String message = "aaaaaaaaaabbbbbbbbbbcccccccccc"; 
+        byte[] userData = GsmAlphabet.stringToGsm7BitPackedWithHeader(message, header.toByteArray());
+        int septetCount = GsmAlphabet.countGsmSeptets(message, false);
+        String parsedMessage = GsmAlphabet.gsm7BitPackedToString(
+                userData, header.toByteArray().length+1, septetCount, 1);
+        assertEquals(message, parsedMessage);
+    }
+
+    // TODO: This method should *really* be a series of individual test methods.
+    @LargeTest
+    public void testBasic() throws Exception {
+        // '@' maps to char 0
+        assertEquals(0, GsmAlphabet.charToGsm('@'));
+
+        // `a (a with grave accent) maps to last GSM charater
+        assertEquals(0x7f, GsmAlphabet.charToGsm('\u00e0'));
+
+        //
+        // These are the extended chars
+        // They should all return GsmAlphabet.GSM_EXTENDED_ESCAPE
+        //
+
+        for (int i = 0, s = sGsmExtendedChars.length(); i < s; i++) {
+            assertEquals(GsmAlphabet.GSM_EXTENDED_ESCAPE,
+                    GsmAlphabet.charToGsm(sGsmExtendedChars.charAt(i)));
+
+        }
+
+        // euro symbol
+        assertEquals(GsmAlphabet.GSM_EXTENDED_ESCAPE,
+                GsmAlphabet.charToGsm('\u20ac'));
+
+        // An unmappable char (the 'cent' char) maps to a space
+        assertEquals(GsmAlphabet.charToGsm(' '),
+                GsmAlphabet.charToGsm('\u00a2'));
+
+        // unmappable = space = 1 septet
+        assertEquals(1, GsmAlphabet.countGsmSeptets('\u00a2'));
+
+        //
+        // Test extended table
+        //
+
+        for (int i = 0, s = sGsmExtendedChars.length(); i < s; i++) {
+            assertEquals(sGsmExtendedChars.charAt(i),
+                    GsmAlphabet.gsmExtendedToChar(
+                            GsmAlphabet.charToGsmExtended(sGsmExtendedChars.charAt(i))));
+
+        }
+
+        // Unmappable extended char
+        assertEquals(GsmAlphabet.charToGsm(' '),
+                GsmAlphabet.charToGsmExtended('@'));
+
+        //
+        // gsmToChar()
+        //
+
+        assertEquals('@', GsmAlphabet.gsmToChar(0));
+
+        // `a (a with grave accent) maps to last GSM charater
+        assertEquals('\u00e0', GsmAlphabet.gsmToChar(0x7f));
+
+        assertEquals('\uffff',
+                GsmAlphabet.gsmToChar(GsmAlphabet.GSM_EXTENDED_ESCAPE));
+
+        // Out-of-range/unmappable value
+        assertEquals(' ', GsmAlphabet.gsmToChar(0x80));
+
+        //
+        // gsmExtendedToChar()
+        //
+
+        assertEquals('{', GsmAlphabet.gsmExtendedToChar(0x28));
+
+        // No double-escapes
+        assertEquals(' ', GsmAlphabet.gsmExtendedToChar(
+                GsmAlphabet.GSM_EXTENDED_ESCAPE));
+
+        // Unmappable
+        assertEquals(' ', GsmAlphabet.gsmExtendedToChar(0));
+
+        //
+        // stringTo7BitPacked, gsm7BitPackedToString
+        //
+
+        byte[] packed;
+        StringBuilder testString = new StringBuilder(300);
+
+        // Check all alignment cases
+        for (int i = 0; i < 9; i++, testString.append('@')) {
+            packed = GsmAlphabet.stringToGsm7BitPacked(testString.toString());
+            assertEquals(testString.toString(),
+                    GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));
+        }
+
+        // Check full non-extended alphabet
+        for (int i = 0; i < 0x80; i++) {
+            char c;
+
+            if (i == GsmAlphabet.GSM_EXTENDED_ESCAPE) {
+                continue;
+            }
+
+            c = GsmAlphabet.gsmToChar(i);
+            testString.append(c);
+
+            // These are all non-extended chars, so it should be
+            // one septet per char
+            assertEquals(1, GsmAlphabet.countGsmSeptets(c));
+        }
+
+        packed = GsmAlphabet.stringToGsm7BitPacked(testString.toString());
+        assertEquals(testString.toString(),
+                GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));
+
+        // Test extended chars too
+
+        testString.append(sGsmExtendedChars);
+
+        for (int i = 0, s = sGsmExtendedChars.length(); i < s; i++) {
+            // These are all extended chars, so it should be
+            // two septets per char
+            assertEquals(2, GsmAlphabet.countGsmSeptets(sGsmExtendedChars.charAt(i)));
+
+        }
+
+        packed = GsmAlphabet.stringToGsm7BitPacked(testString.toString());
+        assertEquals(testString.toString(),
+                GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));
+
+        // stringTo7BitPacked handles up to 255 septets
+
+        testString.setLength(0);
+        for (int i = 0; i < 255; i++) {
+            testString.append('@');
+        }
+
+        packed = GsmAlphabet.stringToGsm7BitPacked(testString.toString());
+        assertEquals(testString.toString(),
+                GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));
+
+        // > 255 septets throws runtime exception
+        testString.append('@');
+
+        try {
+            GsmAlphabet.stringToGsm7BitPacked(testString.toString());
+            fail("expected exception");
+        } catch (EncodeException ex) {
+            // exception expected
+        }
+
+        // Try 254 septets with 127 extended chars
+
+        testString.setLength(0);
+        for (int i = 0; i < (255 / 2); i++) {
+            testString.append('{');
+        }
+
+        packed = GsmAlphabet.stringToGsm7BitPacked(testString.toString());
+        assertEquals(testString.toString(),
+                GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));
+
+        // > 255 septets throws runtime exception
+        testString.append('{');
+
+        try {
+            GsmAlphabet.stringToGsm7BitPacked(testString.toString());
+            fail("expected exception");
+        } catch (EncodeException ex) {
+            // exception expected
+        }
+
+        //
+        // 8 bit unpacked format
+        //
+        // Note: we compare hex strings here
+        // because Assert doesnt have array-comparisons
+
+        byte unpacked[];
+
+        unpacked = SimUtils.hexStringToBytes("566F696365204D61696C");
+        assertEquals("Voice Mail",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));
+
+        assertEquals(SimUtils.bytesToHexString(unpacked),
+                SimUtils.bytesToHexString(
+                        GsmAlphabet.stringToGsm8BitPacked("Voice Mail")));
+
+        unpacked = GsmAlphabet.stringToGsm8BitPacked(sGsmExtendedChars);
+        // two bytes for every extended char
+        assertEquals(2 * sGsmExtendedChars.length(), unpacked.length);
+        assertEquals(sGsmExtendedChars,
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));
+
+        // should be two bytes per extended char
+        assertEquals(2 * sGsmExtendedChars.length(), unpacked.length);
+
+        // Test truncation of unaligned extended chars
+        unpacked = new byte[3];
+        GsmAlphabet.stringToGsm8BitUnpackedField(sGsmExtendedChars, unpacked,
+                0, unpacked.length);
+
+        // Should be one extended char and an 0xff at the end
+
+        assertEquals(0xff, 0xff & unpacked[2]);
+        assertEquals(sGsmExtendedChars.substring(0, 1),
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));
+
+        // Test truncation of normal chars
+        unpacked = new byte[3];
+        GsmAlphabet.stringToGsm8BitUnpackedField("abcd", unpacked,
+                0, unpacked.length);
+
+        assertEquals("abc",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));
+
+        // Test truncation of mixed normal and extended chars
+        unpacked = new byte[3];
+        GsmAlphabet.stringToGsm8BitUnpackedField("a{cd", unpacked,
+                0, unpacked.length);
+
+        assertEquals("a{",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));
+
+        // Test padding after normal char
+        unpacked = new byte[3];
+        GsmAlphabet.stringToGsm8BitUnpackedField("a", unpacked,
+                0, unpacked.length);
+
+        assertEquals("a",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));
+
+        assertEquals(0xff, 0xff & unpacked[1]);
+        assertEquals(0xff, 0xff & unpacked[2]);
+
+        // Test malformed input -- escape char followed by end of field
+        unpacked[0] = 0;
+        unpacked[1] = 0;
+        unpacked[2] = GsmAlphabet.GSM_EXTENDED_ESCAPE;
+
+        assertEquals("@@",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));
+
+        // non-zero offset
+        assertEquals("@",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 1, unpacked.length - 1));
+
+        // test non-zero offset
+        unpacked[0] = 0;
+        GsmAlphabet.stringToGsm8BitUnpackedField("abcd", unpacked,
+                1, unpacked.length - 1);
+
+
+        assertEquals(0, unpacked[0]);
+
+        assertEquals("ab",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 1, unpacked.length - 1));
+
+        // test non-zero offset with truncated extended char
+        unpacked[0] = 0;
+
+        GsmAlphabet.stringToGsm8BitUnpackedField("a{", unpacked,
+                1, unpacked.length - 1);
+
+        assertEquals(0, unpacked[0]);
+
+        assertEquals("a",
+                GsmAlphabet.gsm8BitUnpackedToString(unpacked, 1, unpacked.length - 1));
+    }
+}
+
diff --git a/tests/CoreTests/com/android/internal/telephony/gsm/SMSDispatcherTest.java b/tests/CoreTests/com/android/internal/telephony/gsm/SMSDispatcherTest.java
new file mode 100644
index 0000000..84974ef
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/gsm/SMSDispatcherTest.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2007 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.gsm;
+
+import android.core.TestHandler;
+import android.test.suitebuilder.annotation.MediumTest;
+import com.android.internal.telephony.TestPhoneNotifier;
+import com.android.internal.telephony.test.SimulatedCommands;
+import com.android.internal.telephony.test.SimulatedRadioControl;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.Suppress;
+import android.telephony.gsm.SmsMessage;
+
+import java.util.Iterator;
+
+/**
+ * {@hide}
+ */
+public class SMSDispatcherTest extends AndroidTestCase {
+    @MediumTest
+    public void testCMT1() throws Exception {
+        SmsMessage sms;
+        SmsHeader header;
+        Iterator<SmsHeader.Element> elements;
+
+        String[] lines = new String[2];
+        
+        lines[0] = "+CMT: ,158";             
+        lines[1] = "07914140279510F6440A8111110301003BF56080426101748A8C0B05040B"
+                 + "8423F000035502010106276170706C69636174696F6E2F766E642E776170"
+                 + "2E6D6D732D6D65737361676500AF848D0185B4848C8298524F347839776F"
+                 + "7547514D4141424C3641414141536741415A4B554141414141008D908918"
+                 + "802B31363530323438363137392F545950453D504C4D4E008A808E028000"
+                 + "88058103093A8083687474703A2F2F36";
+             
+        sms = SmsMessage.newFromCMT(lines);
+        header = sms.getUserDataHeader();
+        assertNotNull(header);
+        assertNotNull(sms.getUserData());
+                    
+        elements = header.getElements().iterator();
+        assertNotNull(elements);
+    }
+    
+    @MediumTest
+    public void testCMT2() throws Exception {
+        SmsMessage sms;
+        SmsHeader header;
+        Iterator<SmsHeader.Element> elements;
+
+        String[] lines = new String[2];
+        
+
+        lines[0] = "+CMT: ,77";
+        lines[1] = "07914140279510F6440A8111110301003BF56080426101848A3B0B05040B8423F"
+                 + "00003550202362E3130322E3137312E3135302F524F347839776F7547514D4141"
+                 + "424C3641414141536741415A4B55414141414100";
+
+        sms = SmsMessage.newFromCMT(lines);
+        header = sms.getUserDataHeader();
+        System.out.println("header = " + header);
+        assertNotNull(header);
+        assertNotNull(sms.getUserData());
+                    
+        elements = header.getElements().iterator();
+        assertNotNull(elements);
+    }
+
+    @MediumTest
+    public void testEfRecord() throws Exception {
+        SmsMessage sms;
+
+        String s = "03029111000c9194981492631000f269206190022000a053e4534a05358bd3"
+                 + "69f05804259da0219418a40641536a110a0aea408080604028180e888462c1"
+                 + "50341c0f484432a1542c174c46b3e1743c9f9068442a994ea8946ac56ab95e"
+                 + "b0986c46abd96eb89c6ec7ebf97ec0a070482c1a8fc8a472c96c3a9fd0a874"
+                 + "4aad5aafd8ac76cbed7abfe0b0784c2e9bcfe8b47acd6ebbdff0b87c4eafdb"
+                 + "eff8bc7ecfeffbffffffffffffffffffffffffffff";
+       byte[] data = SimUtils.hexStringToBytes(s);
+
+       sms = SmsMessage.createFromEfRecord(1, data);
+       assertNotNull(sms.getMessageBody());
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/gsm/SimPhoneBookTest.java b/tests/CoreTests/com/android/internal/telephony/gsm/SimPhoneBookTest.java
new file mode 100644
index 0000000..53fdd51
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/gsm/SimPhoneBookTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.gsm;
+
+import android.core.TestHandler;
+import android.os.ServiceManager;
+import android.test.suitebuilder.annotation.Suppress;
+
+import java.util.List;
+
+import junit.framework.TestCase;
+
+@Suppress
+public class SimPhoneBookTest extends TestCase {
+
+    public void testBasic() throws Exception {
+        ISimPhoneBook simPhoneBook =
+                ISimPhoneBook.Stub.asInterface(ServiceManager.getService("simphonebook"));
+        assertNotNull(simPhoneBook);
+
+        int size[] = simPhoneBook.getAdnRecordsSize(SimConstants.EF_ADN);
+        assertNotNull(size);
+        assertEquals(3, size.length);
+        assertEquals(size[0] * size[2], size[1]);
+        assertTrue(size[2] >= 100);
+
+        List<AdnRecord> adnRecordList = simPhoneBook.getAdnRecordsInEf(SimConstants.EF_ADN);
+        // do it twice cause the second time shall read from cache only
+        adnRecordList = simPhoneBook.getAdnRecordsInEf(SimConstants.EF_ADN);
+        assertNotNull(adnRecordList);
+
+        // Test for phone book update
+        int adnIndex, listIndex = 0;
+        AdnRecord originalAdn = null;
+        // We need to maintain the state of the SIM before and after the test.
+        // Since this test doesn't mock the SIM we try to get a valid ADN record,
+        // for 3 tries and if this fails, we bail out. 
+        for (adnIndex = 3 ; adnIndex >= 1; adnIndex--) {
+            listIndex = adnIndex - 1; // listIndex is zero based.
+            originalAdn = adnRecordList.get(listIndex);
+            assertNotNull("Original Adn is Null.", originalAdn);
+            assertNotNull("Original Adn alpha tag is null.", originalAdn.getAlphaTag());
+            assertNotNull("Original Adn number is null.", originalAdn.getNumber());
+            
+            if (originalAdn.getNumber().length() > 0 &&  
+                originalAdn.getAlphaTag().length() > 0) {   
+                break;
+            }
+        }
+        if (adnIndex == 0) return;
+        
+        AdnRecord emptyAdn = new AdnRecord("", "");
+        AdnRecord firstAdn = new AdnRecord("John", "4085550101");
+        AdnRecord secondAdn = new AdnRecord("Andy", "6505550102");
+        String pin2 = null;
+
+        // udpate by index
+        boolean success = simPhoneBook.updateAdnRecordsInEfByIndex(SimConstants.EF_ADN,
+                firstAdn.getAlphaTag(), firstAdn.getNumber(), adnIndex, pin2);
+        adnRecordList = simPhoneBook.getAdnRecordsInEf(SimConstants.EF_ADN);
+         AdnRecord tmpAdn = adnRecordList.get(listIndex);
+        assertTrue(success);
+        assertTrue(firstAdn.isEqual(tmpAdn));
+
+        // replace by search
+        success = simPhoneBook.updateAdnRecordsInEfBySearch(SimConstants.EF_ADN,
+                firstAdn.getAlphaTag(), firstAdn.getNumber(),
+                secondAdn.getAlphaTag(), secondAdn.getNumber(), pin2);
+        adnRecordList = simPhoneBook.getAdnRecordsInEf(SimConstants.EF_ADN);
+        tmpAdn = adnRecordList.get(listIndex);
+        assertTrue(success);
+        assertFalse(firstAdn.isEqual(tmpAdn));
+        assertTrue(secondAdn.isEqual(tmpAdn));
+
+        // erase be search
+        success = simPhoneBook.updateAdnRecordsInEfBySearch(SimConstants.EF_ADN,
+                secondAdn.getAlphaTag(), secondAdn.getNumber(),
+                emptyAdn.getAlphaTag(), emptyAdn.getNumber(), pin2);
+        adnRecordList = simPhoneBook.getAdnRecordsInEf(SimConstants.EF_ADN);
+        tmpAdn = adnRecordList.get(listIndex);
+        assertTrue(success);
+        assertTrue(tmpAdn.isEmpty());
+
+        // restore the orginial adn
+        success = simPhoneBook.updateAdnRecordsInEfByIndex(SimConstants.EF_ADN,
+                originalAdn.getAlphaTag(), originalAdn.getNumber(), adnIndex,
+                pin2);
+        adnRecordList = simPhoneBook.getAdnRecordsInEf(SimConstants.EF_ADN);
+        tmpAdn = adnRecordList.get(listIndex);
+        assertTrue(success);
+        assertTrue(originalAdn.isEqual(tmpAdn));
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/gsm/SimSmsTest.java b/tests/CoreTests/com/android/internal/telephony/gsm/SimSmsTest.java
new file mode 100644
index 0000000..6ced23d
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/gsm/SimSmsTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.gsm;
+
+import android.os.ServiceManager;
+import android.test.suitebuilder.annotation.MediumTest;
+import android.test.suitebuilder.annotation.Suppress;
+
+import java.util.List;
+
+import junit.framework.TestCase;
+
+public class SimSmsTest extends TestCase {
+
+    @MediumTest
+    @Suppress // TODO: suppress this test for now since it doesn't work on the emulator
+    public void testBasic() throws Exception {
+
+        ISms sms = ISms.Stub.asInterface(ServiceManager.getService("isms"));
+        assertNotNull(sms);
+
+        List<SmsRawData> records = sms.getAllMessagesFromSimEf();
+        assertNotNull(records);
+        assertTrue(records.size() >= 0);
+
+        int firstNullIndex = -1;
+        int firstValidIndex = -1;
+        byte[] pdu = null;
+        for (int i = 0; i < records.size(); i++) {
+            SmsRawData data = records.get(i);
+            if (data != null && firstValidIndex == -1) {
+                firstValidIndex = i;
+                pdu = data.getBytes();
+            }
+            if (data == null && firstNullIndex == -1) {
+                firstNullIndex = i;
+            }
+            if (firstNullIndex != -1 && firstValidIndex != -1) {
+                break;
+            }
+        }
+        if (firstNullIndex == -1 || firstValidIndex == -1)
+            return;
+        assertNotNull(pdu);
+    }
+}
diff --git a/tests/CoreTests/com/android/internal/telephony/gsm/SimUtilsTest.java b/tests/CoreTests/com/android/internal/telephony/gsm/SimUtilsTest.java
new file mode 100644
index 0000000..3fbc8f5
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/telephony/gsm/SimUtilsTest.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.telephony.gsm;
+
+import com.android.internal.telephony.gsm.SimTlv;
+import com.android.internal.telephony.gsm.SimUtils;
+import junit.framework.TestCase;
+import android.test.suitebuilder.annotation.SmallTest;
+
+
+public class SimUtilsTest extends TestCase {
+
+    @SmallTest
+    public void testBasic() throws Exception {
+        byte[] data, data2;
+
+        /* 
+         * bcdToString()
+         */
+
+        // An EF[ICCID] record
+        data = SimUtils.hexStringToBytes("981062400510444868f2");
+        assertEquals("8901260450014484862", SimUtils.bcdToString(data, 0, data.length));
+
+        // skip the first and last bytes
+        assertEquals("0126045001448486", SimUtils.bcdToString(data, 1, data.length - 2));
+
+        // Stops on invalid BCD value
+        data = SimUtils.hexStringToBytes("98F062400510444868f2");
+        assertEquals("890", SimUtils.bcdToString(data, 0, data.length));
+
+        /*
+        * bcdByteToInt()
+        */
+
+        assertEquals(98, SimUtils.bcdByteToInt((byte) 0x89));
+
+        // Out of range is treated as 0
+        assertEquals(8, SimUtils.bcdByteToInt((byte) 0x8c));
+
+        /*
+         * adnStringFieldToString()
+         */
+
+
+        data = SimUtils.hexStringToBytes("00566f696365204d61696c07918150367742f3ffffffffffff");
+        // Again, skip prepended 0
+        // (this is an EF[ADN] record)
+        assertEquals("Voice Mail", SimUtils.adnStringFieldToString(data, 1, data.length - 15));
+
+        data = SimUtils.hexStringToBytes("809673539A5764002F004DFFFFFFFFFF");
+        // (this is from an EF[ADN] record)
+        assertEquals("\u9673\u539A\u5764/M", SimUtils.adnStringFieldToString(data, 0, data.length));
+
+        data = SimUtils.hexStringToBytes("810A01566fec6365204de0696cFFFFFF");
+        // (this is made up to test since I don't have a real one)
+        assertEquals("Vo\u00ECce M\u00E0il", SimUtils.adnStringFieldToString(data, 0, data.length));
+
+        data = SimUtils.hexStringToBytes("820505302D82d32d31");
+        // Example from 3GPP TS 11.11 V18.1.3.0 annex B
+        assertEquals("-\u0532\u0583-1", SimUtils.adnStringFieldToString(data, 0, data.length));
+    }
+
+}
+
diff --git a/tests/CoreTests/com/android/internal/util/PredicatesTest.java b/tests/CoreTests/com/android/internal/util/PredicatesTest.java
new file mode 100644
index 0000000..c46ff05
--- /dev/null
+++ b/tests/CoreTests/com/android/internal/util/PredicatesTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.internal.util;
+
+import junit.framework.TestCase;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class PredicatesTest extends TestCase {
+
+    private static final Predicate<Object> TRUE = new Predicate<Object>() {
+        public boolean apply(Object o) {
+            return true;
+        }
+    };
+
+    private static final Predicate<Object> FALSE = new Predicate<Object>() {
+        public boolean apply(Object o) {
+            return false;
+        }
+    };
+
+    public void testAndPredicate_AllConditionsTrue() throws Exception {
+        assertTrue(Predicates.and(newArrayList(TRUE)).apply(null));
+        assertTrue(Predicates.and(newArrayList(TRUE, TRUE)).apply(null));
+    }
+
+    public void testAndPredicate_AtLeastOneConditionIsFalse() throws Exception {
+        assertFalse(Predicates.and(newArrayList(FALSE, TRUE, TRUE)).apply(null));
+        assertFalse(Predicates.and(newArrayList(TRUE, FALSE, TRUE)).apply(null));
+        assertFalse(Predicates.and(newArrayList(TRUE, TRUE, FALSE)).apply(null));
+    }
+
+    public void testOrPredicate_AllConditionsTrue() throws Exception {
+        assertTrue(Predicates.or(newArrayList(TRUE, TRUE, TRUE)).apply(null));
+    }
+
+    public void testOrPredicate_AllConditionsFalse() throws Exception {
+        assertFalse(Predicates.or(newArrayList(FALSE, FALSE, FALSE)).apply(null));
+    }
+
+    public void testOrPredicate_AtLeastOneConditionIsTrue() throws Exception {
+        assertTrue(Predicates.or(newArrayList(TRUE, FALSE, FALSE)).apply(null));
+        assertTrue(Predicates.or(newArrayList(FALSE, TRUE, FALSE)).apply(null));
+        assertTrue(Predicates.or(newArrayList(FALSE, FALSE, TRUE)).apply(null));
+    }
+
+    public void testNotPredicate() throws Exception {
+        assertTrue(Predicates.not(FALSE).apply(null));
+        assertFalse(Predicates.not(TRUE).apply(null));
+    }
+
+    private static <E> ArrayList<E> newArrayList(E... elements) {
+        ArrayList<E> list = new ArrayList<E>();
+        Collections.addAll(list, elements);
+        return list;
+    }
+
+}