/*
* Copyright (C) 2010 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.SmsMessage;
import android.telephony.TelephonyManager;
import android.telephony.Rlog;
import android.test.AndroidTestCase;
import android.test.suitebuilder.annotation.LargeTest;
import android.test.suitebuilder.annotation.MediumTest;
import android.test.suitebuilder.annotation.SmallTest;
import com.android.internal.telephony.SmsConstants;
import java.util.Random;
/**
* Test cases to verify selection of the optimal 7 bit encoding tables
* (for all combinations of enabled national language tables) for messages
* containing Turkish, Spanish, Portuguese, Greek, and other symbols
* present in the GSM default and national language tables defined in
* 3GPP TS 23.038. Also verifies correct SMS encoding for CDMA, which only
* supports the GSM 7 bit default alphabet, ASCII 8 bit, and UCS-2.
* Tests both encoding variations: unsupported characters mapped to space,
* and unsupported characters force entire message to UCS-2.
*/
public class SmsMessageBodyTest extends AndroidTestCase {
private static final String TAG = "SmsMessageBodyTest";
// ASCII chars in the GSM 7 bit default alphabet
private static final String sAsciiChars = "@$_ !\"#%&'()*+,-./0123456789" +
":;<=>?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n\r";
// Unicode chars in the GSM 7 bit default alphabet and both locking shift tables
private static final String sGsmDefaultChars = "\u00a3\u00a5\u00e9\u00c7\u0394\u00c9" +
"\u00dc\u00a7\u00fc\u00e0";
// Unicode chars in the GSM 7 bit default table and Turkish locking shift tables
private static final String sGsmDefaultAndTurkishTables = "\u00f9\u00f2\u00c5\u00e5\u00df" +
"\u00a4\u00c4\u00d6\u00d1\u00e4\u00f6\u00f1";
// Unicode chars in the GSM 7 bit default table but not the locking shift tables
private static final String sGsmDefaultTableOnly = "\u00e8\u00ec\u00d8\u00f8\u00c6\u00e6" +
"\u00a1\u00bf";
// ASCII chars in the GSM default extension table
private static final String sGsmExtendedAsciiChars = "{}[]\f";
// chars in GSM default extension table and Portuguese locking shift table
private static final String sGsmExtendedPortugueseLocking = "^\\|~";
// Euro currency symbol
private static final String sGsmExtendedEuroSymbol = "\u20ac";
// CJK ideographs, Hiragana, Katakana, full width letters, Cyrillic, etc.
private static final String sUnicodeChars = "\u4e00\u4e01\u4e02\u4e03" +
"\u4e04\u4e05\u4e06\u4e07\u4e08\u4e09\u4e0a\u4e0b\u4e0c\u4e0d" +
"\u4e0e\u4e0f\u3041\u3042\u3043\u3044\u3045\u3046\u3047\u3048" +
"\u30a1\u30a2\u30a3\u30a4\u30a5\u30a6\u30a7\u30a8" +
"\uff10\uff11\uff12\uff13\uff14\uff15\uff16\uff17\uff18" +
"\uff70\uff71\uff72\uff73\uff74\uff75\uff76\uff77\uff78" +
"\u0400\u0401\u0402\u0403\u0404\u0405\u0406\u0407\u0408" +
"\u00a2\u00a9\u00ae\u2122";
// chars in Turkish single shift and locking shift tables
private static final String sTurkishChars = "\u0131\u011e\u011f\u015e\u015f\u0130";
// chars in Spanish single shift table and Portuguese single and locking shift tables
private static final String sPortugueseAndSpanishChars = "\u00c1\u00e1\u00cd\u00ed"
+ "\u00d3\u00f3\u00da\u00fa";
// chars in all national language tables but not in the standard GSM alphabets
private static final String sNationalLanguageTablesOnly = "\u00e7";
// chars in Portuguese single shift and locking shift tables
private static final String sPortugueseChars = "\u00ea\u00d4\u00f4\u00c0\u00c2\u00e2"
+ "\u00ca\u00c3\u00d5\u00e3\u00f5";
// chars in Portuguese locking shift table only
private static final String sPortugueseLockingShiftChars = "\u00aa\u221e\u00ba`";
// Greek letters in GSM alphabet missing from Portuguese locking and single shift tables
private static final String sGreekLettersNotInPortugueseTables = "\u039b\u039e";
// Greek letters in GSM alphabet and Portuguese single shift (but not locking shift) table
private static final String sGreekLettersInPortugueseShiftTable =
"\u03a6\u0393\u03a9\u03a0\u03a8\u03a3\u0398";
// List of classes of characters in SMS tables
private static final String[] sCharacterClasses = {
sGsmExtendedAsciiChars,
sGsmExtendedPortugueseLocking,
sGsmDefaultChars,
sGsmDefaultAndTurkishTables,
sGsmDefaultTableOnly,
sGsmExtendedEuroSymbol,
sUnicodeChars,
sTurkishChars,
sPortugueseChars,
sPortugueseLockingShiftChars,
sPortugueseAndSpanishChars,
sGreekLettersNotInPortugueseTables,
sGreekLettersInPortugueseShiftTable,
sNationalLanguageTablesOnly,
sAsciiChars
};
private static final int sNumCharacterClasses = sCharacterClasses.length;
// For each character class, whether it is present in a particular char table.
// First three entries are locking shift tables, followed by four single shift tables
private static final boolean[][] sCharClassPresenceInTables = {
// ASCII chars in all GSM extension tables
{false, false, false, true, true, true, true},
// ASCII chars in all GSM extension tables and Portuguese locking shift table
{false, false, true, true, true, true, true},
// non-ASCII chars in GSM default alphabet and all locking tables
{true, true, true, false, false, false, false},
// non-ASCII chars in GSM default alphabet and Turkish locking shift table
{true, true, false, false, false, false, false},
// non-ASCII chars in GSM default alphabet table only
{true, false, false, false, false, false, false},
// Euro symbol is present in several tables
{false, true, true, true, true, true, true},
// Unicode characters not present in any 7 bit tables
{false, false, false, false, false, false, false},
// Characters specific to Turkish language
{false, true, false, false, true, false, false},
// Characters in Portuguese single shift and locking shift tables
{false, false, true, false, false, false, true},
// Characters in Portuguese locking shift table only
{false, false, true, false, false, false, false},
// Chars in Spanish single shift and Portuguese single and locking shift tables
{false, false, true, false, false, true, true},
// Greek letters in GSM default alphabet missing from Portuguese tables
{true, true, false, false, false, false, false},
// Greek letters in GSM alphabet and Portuguese single shift table
{true, true, false, false, false, false, true},
// Chars in all national language tables but not the standard GSM tables
{false, true, true, false, true, true, true},
// ASCII chars in GSM default alphabet
{true, true, true, false, false, false, false}
};
private static final int sTestLengthCount = 12;
private static final int[] sSeptetTestLengths =
{ 0, 1, 2, 80, 159, 160, 161, 240, 305, 306, 307, 320};
private static final int[] sUnicodeTestLengths =
{ 0, 1, 2, 35, 69, 70, 71, 100, 133, 134, 135, 160};
private static final int[] sTestMsgCounts =
{ 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3};
private static final int[] sSeptetUnitsRemaining =
{160, 159, 158, 80, 1, 0, 145, 66, 1, 0, 152, 139};
private static final int[] sUnicodeUnitsRemaining =
{ 70, 69, 68, 35, 1, 0, 63, 34, 1, 0, 66, 41};
// Combinations of enabled GSM national language single shift tables
private static final int[][] sEnabledSingleShiftTables = {
{}, // GSM default alphabet only
{1}, // Turkish (single shift only)
{1}, // Turkish (single and locking shift)
{2}, // Spanish
{3}, // Portuguese (single shift only)
{3}, // Portuguese (single and locking shift)
{1, 2}, // Turkish + Spanish (single shift only)
{1, 2}, // Turkish + Spanish (single and locking shift)
{1, 3}, // Turkish + Portuguese (single shift only)
{1, 3}, // Turkish + Portuguese (single and locking shift)
{2, 3}, // Spanish + Portuguese (single shift only)
{2, 3}, // Spanish + Portuguese (single and locking shift)
{1, 2, 3}, // Turkish, Spanish, Portuguese (single shift only)
{1, 2, 3}, // Turkish, Spanish, Portuguese (single and locking shift)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} // all language tables
};
// Combinations of enabled GSM national language locking shift tables
private static final int[][] sEnabledLockingShiftTables = {
{}, // GSM default alphabet only
{}, // Turkish (single shift only)
{1}, // Turkish (single and locking shift)
{}, // Spanish (no locking shift table)
{}, // Portuguese (single shift only)
{3}, // Portuguese (single and locking shift)
{}, // Turkish + Spanish (single shift only)
{1}, // Turkish + Spanish (single and locking shift)
{}, // Turkish + Portuguese (single shift only)
{1, 3}, // Turkish + Portuguese (single and locking shift)
{}, // Spanish + Portuguese (single shift only)
{3}, // Spanish + Portuguese (single and locking shift)
{}, // Turkish, Spanish, Portuguese (single shift only)
{1, 3}, // Turkish, Spanish, Portuguese (single and locking shift)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} // all language tables
};
// LanguagePair counter indexes to check for each entry above
private static final int[][] sLanguagePairIndexesByEnabledIndex = {
{0}, // default tables only
{0, 1}, // Turkish (single shift only)
{0, 1, 4, 5}, // Turkish (single and locking shift)
{0, 2}, // Spanish
{0, 3}, // Portuguese (single shift only)
{0, 3, 8, 11}, // Portuguese (single and locking shift)
{0, 1, 2}, // Turkish + Spanish (single shift only)
{0, 1, 2, 4, 5, 6}, // Turkish + Spanish (single and locking shift)
{0, 1, 3}, // Turkish + Portuguese (single shift only)
{0, 1, 3, 4, 5, 7, 8, 9, 11}, // Turkish + Portuguese (single and locking shift)
{0, 2, 3}, // Spanish + Portuguese (single shift only)
{0, 2, 3, 8, 10, 11}, // Spanish + Portuguese (single and locking shift)
{0, 1, 2, 3}, // all languages (single shift only)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}, // all languages (single and locking shift)
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11} // all languages (no Indic chars in test)
};
/**
* User data header requires one octet for length. Count as one septet, because
* all combinations of header elements below will have at least one free bit
* when padding to the nearest septet boundary.
*/
private static final int UDH_SEPTET_COST_LENGTH = 1;
/**
* Using a non-default language locking shift table OR single shift table
* requires a user data header of 3 octets, or 4 septets, plus UDH length.
*/
private static final int UDH_SEPTET_COST_ONE_SHIFT_TABLE = 4;
/**
* Using a non-default language locking shift table AND single shift table
* requires a user data header of 6 octets, or 7 septets, plus UDH length.
*/
private static final int UDH_SEPTET_COST_TWO_SHIFT_TABLES = 7;
/**
* Multi-part messages require a user data header of 5 octets, or 6 septets,
* plus UDH length.
*/
private static final int UDH_SEPTET_COST_CONCATENATED_MESSAGE = 6;
@SmallTest
public void testCalcLengthAscii() throws Exception {
StringBuilder sb = new StringBuilder(320);
int[] values = {0, 0, 0, SmsConstants.ENCODING_7BIT, 0, 0};
int startPos = 0;
int asciiCharsLen = sAsciiChars.length();
for (int i = 0; i < sTestLengthCount; i++) {
int len = sSeptetTestLengths[i];
assertTrue(sb.length() <= len);
while (sb.length() < len) {
int addCount = len - sb.length();
int endPos = (asciiCharsLen - startPos > addCount) ?
(startPos + addCount) : asciiCharsLen;
sb.append(sAsciiChars, startPos, endPos);
startPos = (endPos == asciiCharsLen) ? 0 : endPos;
}
assertEquals(len, sb.length());
String testStr = sb.toString();
values[0] = sTestMsgCounts[i];
values[1] = len;
values[2] = sSeptetUnitsRemaining[i];
callGsmLengthMethods(testStr, false, values);
callGsmLengthMethods(testStr, true, values);
callCdmaLengthMethods(testStr, false, values);
callCdmaLengthMethods(testStr, true, values);
}
}
@SmallTest
public void testCalcLengthUnicode() throws Exception {
StringBuilder sb = new StringBuilder(160);
int[] values = {0, 0, 0, SmsConstants.ENCODING_16BIT, 0, 0};
int[] values7bit = {1, 0, 0, SmsConstants.ENCODING_7BIT, 0, 0};
int startPos = 0;
int unicodeCharsLen = sUnicodeChars.length();
// start with length 1: empty string uses ENCODING_7BIT
for (int i = 1; i < sTestLengthCount; i++) {
int len = sUnicodeTestLengths[i];
assertTrue(sb.length() <= len);
while (sb.length() < len) {
int addCount = len - sb.length();
int endPos = (unicodeCharsLen - startPos > addCount) ?
(startPos + addCount) : unicodeCharsLen;
sb.append(sUnicodeChars, startPos, endPos);
startPos = (endPos == unicodeCharsLen) ? 0 : endPos;
}
assertEquals(len, sb.length());
String testStr = sb.toString();
values[0] = sTestMsgCounts[i];
values[1] = len;
values[2] = sUnicodeUnitsRemaining[i];
values7bit[1] = len;
values7bit[2] = SmsConstants.MAX_USER_DATA_SEPTETS - len;
callGsmLengthMethods(testStr, false, values);
callCdmaLengthMethods(testStr, false, values);
callGsmLengthMethods(testStr, true, values7bit);
callCdmaLengthMethods(testStr, true, values7bit);
}
}
private static class LanguagePair {
// index is 2 for Portuguese locking shift because there is no Spanish locking shift table
private final int langTableIndex;
private final int langShiftTableIndex;
int length;
int missingChars7bit;
LanguagePair(int langTable, int langShiftTable) {
langTableIndex = langTable;
langShiftTableIndex = langShiftTable;
}
void clear() {
length = 0;
missingChars7bit = 0;
}
void addChar(boolean[] charClassTableRow) {
if (charClassTableRow[langTableIndex]) {
length++;
} else if (charClassTableRow[3 + langShiftTableIndex]) {
length += 2;
} else {
length++; // use ' ' for unmapped char in 7 bit only mode
missingChars7bit++;
}
}
}
private static class CounterHelper {
LanguagePair[] mCounters;
int[] mStatsCounters;
int mUnicodeCounter;
CounterHelper() {
mCounters = new LanguagePair[12];
mStatsCounters = new int[12];
for (int i = 0; i < 12; i++) {
mCounters[i] = new LanguagePair(i/4, i%4);
}
}
void clear() {
// Note: don't clear stats counters
for (int i = 0; i < 12; i++) {
mCounters[i].clear();
}
}
void addChar(int charClass) {
boolean[] charClassTableRow = sCharClassPresenceInTables[charClass];
for (int i = 0; i < 12; i++) {
mCounters[i].addChar(charClassTableRow);
}
}
void fillData(int enabledLangsIndex, boolean use7bitOnly, int[] values, int length) {
int[] languagePairs = sLanguagePairIndexesByEnabledIndex[enabledLangsIndex];
int minNumSeptets = Integer.MAX_VALUE;
int minNumSeptetsWithHeader = Integer.MAX_VALUE;
int minNumMissingChars = Integer.MAX_VALUE;
int langIndex = -1;
int langShiftIndex = -1;
for (int i : languagePairs) {
LanguagePair pair = mCounters[i];
int udhLength = 0;
if (i != 0) {
udhLength = UDH_SEPTET_COST_LENGTH;
if (i < 4 || i % 4 == 0) {
udhLength += UDH_SEPTET_COST_ONE_SHIFT_TABLE;
} else {
udhLength += UDH_SEPTET_COST_TWO_SHIFT_TABLES;
}
}
int numSeptetsWithHeader;
if (pair.length > (SmsConstants.MAX_USER_DATA_SEPTETS - udhLength)) {
if (udhLength == 0) {
udhLength = UDH_SEPTET_COST_LENGTH;
}
udhLength += UDH_SEPTET_COST_CONCATENATED_MESSAGE;
int septetsPerPart = SmsConstants.MAX_USER_DATA_SEPTETS - udhLength;
int msgCount = (pair.length + septetsPerPart - 1) / septetsPerPart;
numSeptetsWithHeader = udhLength * msgCount + pair.length;
} else {
numSeptetsWithHeader = udhLength + pair.length;
}
if (use7bitOnly) {
if (pair.missingChars7bit < minNumMissingChars || (pair.missingChars7bit ==
minNumMissingChars && numSeptetsWithHeader < minNumSeptetsWithHeader)) {
minNumSeptets = pair.length;
minNumSeptetsWithHeader = numSeptetsWithHeader;
minNumMissingChars = pair.missingChars7bit;
langIndex = pair.langTableIndex;
langShiftIndex = pair.langShiftTableIndex;
}
} else {
if (pair.missingChars7bit == 0 && numSeptetsWithHeader < minNumSeptetsWithHeader) {
minNumSeptets = pair.length;
minNumSeptetsWithHeader = numSeptetsWithHeader;
langIndex = pair.langTableIndex;
langShiftIndex = pair.langShiftTableIndex;
}
}
}
if (langIndex == -1) {
// nothing matches, use values for Unicode
int byteCount = length * 2;
if (byteCount > SmsConstants.MAX_USER_DATA_BYTES) {
values[0] = (byteCount + SmsConstants.MAX_USER_DATA_BYTES_WITH_HEADER - 1) /
SmsConstants.MAX_USER_DATA_BYTES_WITH_HEADER;
values[2] = ((values[0] * SmsConstants.MAX_USER_DATA_BYTES_WITH_HEADER) -
byteCount) / 2;
} else {
values[0] = 1;
values[2] = (SmsConstants.MAX_USER_DATA_BYTES - byteCount) / 2;
}
values[1] = length;
values[3] = SmsConstants.ENCODING_16BIT;
values[4] = 0;
values[5] = 0;
mUnicodeCounter++;
} else {
int udhLength = 0;
if (langIndex != 0 || langShiftIndex != 0) {
udhLength = UDH_SEPTET_COST_LENGTH;
if (langIndex == 0 || langShiftIndex == 0) {
udhLength += UDH_SEPTET_COST_ONE_SHIFT_TABLE;
} else {
udhLength += UDH_SEPTET_COST_TWO_SHIFT_TABLES;
}
}
int msgCount;
if (minNumSeptets > (SmsConstants.MAX_USER_DATA_SEPTETS - udhLength)) {
if (udhLength == 0) {
udhLength = UDH_SEPTET_COST_LENGTH;
}
udhLength += UDH_SEPTET_COST_CONCATENATED_MESSAGE;
int septetsPerPart = SmsConstants.MAX_USER_DATA_SEPTETS - udhLength;
msgCount = (minNumSeptets + septetsPerPart - 1) / septetsPerPart;
} else {
msgCount = 1;
}
values[0] = msgCount;
values[1] = minNumSeptets;
values[2] = (values[0] * (SmsConstants.MAX_USER_DATA_SEPTETS - udhLength)) -
minNumSeptets;
values[3] = SmsConstants.ENCODING_7BIT;
values[4] = (langIndex == 2 ? 3 : langIndex); // Portuguese is code 3, index 2
values[5] = langShiftIndex;
assertEquals("minNumSeptetsWithHeader", minNumSeptetsWithHeader,
udhLength * msgCount + minNumSeptets);
mStatsCounters[langIndex * 4 + langShiftIndex]++;
}
}
void printStats() {
Rlog.d(TAG, "Unicode selection count: " + mUnicodeCounter);
for (int i = 0; i < 12; i++) {
Rlog.d(TAG, "Language pair index " + i + " count: " + mStatsCounters[i]);
}
}
}
@LargeTest
public void testCalcLengthMixed7bit() throws Exception {
StringBuilder sb = new StringBuilder(320);
CounterHelper ch = new CounterHelper();
Random r = new Random(0x4321); // use the same seed for reproducibility
int[] expectedValues = new int[6];
int[] origLockingShiftTables = GsmAlphabet.getEnabledLockingShiftTables();
int[] origSingleShiftTables = GsmAlphabet.getEnabledSingleShiftTables();
int enabledLanguagesTestCases = sEnabledSingleShiftTables.length;
long startTime = System.currentTimeMillis();
// Repeat for 10 test runs
for (int run = 0; run < 10; run++) {
sb.setLength(0);
ch.clear();
int unicodeOnlyCount = 0;
// Test incrementally from 1 to 320 character random messages
for (int i = 1; i < 320; i++) {
// 1% chance to add from each special character class, else add an ASCII char
int charClass = r.nextInt(100);
if (charClass >= sNumCharacterClasses) {
charClass = sNumCharacterClasses - 1; // last class is ASCII
}
int classLength = sCharacterClasses[charClass].length();
char nextChar = sCharacterClasses[charClass].charAt(r.nextInt(classLength));
sb.append(nextChar);
ch.addChar(charClass);
// if (i % 20 == 0) {
// Rlog.d(TAG, "test string: " + sb);
// }
// Test string against all combinations of enabled languages
boolean unicodeOnly = true;
for (int j = 0; j < enabledLanguagesTestCases; j++) {
GsmAlphabet.setEnabledSingleShiftTables(sEnabledSingleShiftTables[j]);
GsmAlphabet.setEnabledLockingShiftTables(sEnabledLockingShiftTables[j]);
ch.fillData(j, false, expectedValues, i);
if (expectedValues[3] == SmsConstants.ENCODING_7BIT) {
unicodeOnly = false;
}
callGsmLengthMethods(sb, false, expectedValues);
// test 7 bit only mode
ch.fillData(j, true, expectedValues, i);
callGsmLengthMethods(sb, true, expectedValues);
}
// after 10 iterations with a Unicode-only string, skip to next test string
// so we can spend more time testing strings that do encode into 7 bits.
if (unicodeOnly && ++unicodeOnlyCount == 10) {
// Rlog.d(TAG, "Unicode only: skipping to next test string");
break;
}
}
}
ch.printStats();
Rlog.d(TAG, "Completed in " + (System.currentTimeMillis() - startTime) + " ms");
GsmAlphabet.setEnabledLockingShiftTables(origLockingShiftTables);
GsmAlphabet.setEnabledSingleShiftTables(origSingleShiftTables);
}
private void callGsmLengthMethods(CharSequence msgBody, boolean use7bitOnly,
int[] expectedValues)
{
// deprecated GSM-specific method
int[] values = android.telephony.gsm.SmsMessage.calculateLength(msgBody, use7bitOnly);
assertEquals("msgCount", expectedValues[0], values[0]);
assertEquals("codeUnitCount", expectedValues[1], values[1]);
assertEquals("codeUnitsRemaining", expectedValues[2], values[2]);
assertEquals("codeUnitSize", expectedValues[3], values[3]);
int activePhone = TelephonyManager.getDefault().getPhoneType();
if (TelephonyManager.PHONE_TYPE_GSM == activePhone) {
values = android.telephony.SmsMessage.calculateLength(msgBody, use7bitOnly);
assertEquals("msgCount", expectedValues[0], values[0]);
assertEquals("codeUnitCount", expectedValues[1], values[1]);
assertEquals("codeUnitsRemaining", expectedValues[2], values[2]);
assertEquals("codeUnitSize", expectedValues[3], values[3]);
}
GsmAlphabet.TextEncodingDetails ted =
com.android.internal.telephony.gsm.SmsMessage.calculateLength(msgBody, use7bitOnly);
assertEquals("msgCount", expectedValues[0], ted.msgCount);
assertEquals("codeUnitCount", expectedValues[1], ted.codeUnitCount);
assertEquals("codeUnitsRemaining", expectedValues[2], ted.codeUnitsRemaining);
assertEquals("codeUnitSize", expectedValues[3], ted.codeUnitSize);
assertEquals("languageTable", expectedValues[4], ted.languageTable);
assertEquals("languageShiftTable", expectedValues[5], ted.languageShiftTable);
}
private void callCdmaLengthMethods(CharSequence msgBody, boolean use7bitOnly,
int[] expectedValues)
{
int activePhone = TelephonyManager.getDefault().getPhoneType();
if (TelephonyManager.PHONE_TYPE_CDMA == activePhone) {
int[] values = android.telephony.SmsMessage.calculateLength(msgBody, use7bitOnly);
assertEquals("msgCount", expectedValues[0], values[0]);
assertEquals("codeUnitCount", expectedValues[1], values[1]);
assertEquals("codeUnitsRemaining", expectedValues[2], values[2]);
assertEquals("codeUnitSize", expectedValues[3], values[3]);
}
GsmAlphabet.TextEncodingDetails ted =
com.android.internal.telephony.cdma.SmsMessage.calculateLength(msgBody, use7bitOnly, true);
assertEquals("msgCount", expectedValues[0], ted.msgCount);
assertEquals("codeUnitCount", expectedValues[1], ted.codeUnitCount);
assertEquals("codeUnitsRemaining", expectedValues[2], ted.codeUnitsRemaining);
assertEquals("codeUnitSize", expectedValues[3], ted.codeUnitSize);
ted = com.android.internal.telephony.cdma.sms.BearerData.calcTextEncodingDetails(msgBody, use7bitOnly, true);
assertEquals("msgCount", expectedValues[0], ted.msgCount);
assertEquals("codeUnitCount", expectedValues[1], ted.codeUnitCount);
assertEquals("codeUnitsRemaining", expectedValues[2], ted.codeUnitsRemaining);
assertEquals("codeUnitSize", expectedValues[3], ted.codeUnitSize);
}
}
|
