tests/telephonytests/src/com/android/internal/telephony/GsmAlphabetTest.java - platform/frameworks/opt/telephony - Git at Google

 /*
  * 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.GsmAlphabet;
 import com.android.internal.telephony.uicc.IccUtils;

 import junit.framework.TestCase;

 import android.test.suitebuilder.annotation.LargeTest;
 import android.test.suitebuilder.annotation.SmallTest;

 public class GsmAlphabetTest extends TestCase {

     private static final String sGsmExtendedChars = "{|}\\[~]\f\u20ac";

     @SmallTest
     public void test7bitWithHeader() throws Exception {
         SmsHeader.ConcatRef concatRef = new SmsHeader.ConcatRef();
         concatRef.refNumber = 1;
         concatRef.seqNumber = 2;
         concatRef.msgCount = 2;
         concatRef.isEightBits = true;
         SmsHeader header = new SmsHeader();
         header.concatRef = concatRef;

         String message = "aaaaaaaaaabbbbbbbbbbcccccccccc";
         byte[] userData = GsmAlphabet.stringToGsm7BitPackedWithHeader(message,
                 SmsHeader.toByteArray(header), 0, 0);
         int septetCount = GsmAlphabet.countGsmSeptetsUsingTables(message, true, 0, 0);
         String parsedMessage = GsmAlphabet.gsm7BitPackedToString(
                 userData, SmsHeader.toByteArray(header).length+2, septetCount, 1, 0, 0);
         assertEquals(message, parsedMessage);
     }

     // TODO: This method should *really* be a series of individual test methods.
     // However, it's a SmallTest because it executes quickly.
     @SmallTest
     public void testBasic() throws Exception {
         // '@' maps to char 0
         assertEquals(0, GsmAlphabet.charToGsm('@'));

         // `a (a with grave accent) maps to last GSM character
         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 character
         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));

         // Reserved for extension to extension table (mapped to space)
         assertEquals(' ', GsmAlphabet.gsmExtendedToChar(GsmAlphabet.GSM_EXTENDED_ESCAPE));

         // Unmappable (mapped to character in default or national locking shift table)
         assertEquals('@', GsmAlphabet.gsmExtendedToChar(0));
         assertEquals('\u00e0', GsmAlphabet.gsmExtendedToChar(0x7f));

         //
         // 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(), 0, 0);
             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(), 0, 0);
         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(), 0, 0);
         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(), 0, 0);
         assertEquals(testString.toString(),
                 GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));

         // > 255 septets throws runtime exception
         testString.append('@');

         try {
             GsmAlphabet.stringToGsm7BitPacked(testString.toString(), 0, 0);
             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(), 0, 0);
         assertEquals(testString.toString(),
                 GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));

         // > 255 septets throws runtime exception
         testString.append('{');

         try {
             GsmAlphabet.stringToGsm7BitPacked(testString.toString(), 0, 0);
             fail("expected exception");
         } catch (EncodeException ex) {
             // exception expected
         }

         // Reserved for extension to extension table (mapped to space)
         packed = new byte[]{(byte)(0x1b | 0x80), 0x1b >> 1};
         assertEquals(" ", GsmAlphabet.gsm7BitPackedToString(packed, 0, 2));

         // Unmappable (mapped to character in default alphabet table)
         packed[0] = 0x1b;
         packed[1] = 0x00;
         assertEquals("@", GsmAlphabet.gsm7BitPackedToString(packed, 0, 2));
         packed[0] = (byte)(0x1b | 0x80);
         packed[1] = (byte)(0x7f >> 1);
         assertEquals("\u00e0", GsmAlphabet.gsm7BitPackedToString(packed, 0, 2));

         //
         // 8 bit unpacked format
         //
         // Note: we compare hex strings here
         // because Assert doesn't have array comparisons

         byte unpacked[];

         unpacked = IccUtils.hexStringToBytes("566F696365204D61696C");
         assertEquals("Voice Mail",
                 GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));

         assertEquals(IccUtils.bytesToHexString(unpacked),
                 IccUtils.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));

         // Reserved for extension to extension table (mapped to space)
         unpacked[0] = 0x1b;
         unpacked[1] = 0x1b;
         assertEquals(" ", GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, 2));

         // Unmappable (mapped to character in default or national locking shift table)
         unpacked[1] = 0x00;
         assertEquals("@", GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, 2));
         unpacked[1] = 0x7f;
         assertEquals("\u00e0", GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, 2));
     }

     @SmallTest
     public void testGsm8BitUpackedWithEuckr() throws Exception {
         // Some feature phones in Korea store contacts as euc-kr.
         // Test this situations.
         byte unpacked[];

         // Test general alphabet strings.
         unpacked = IccUtils.hexStringToBytes("61626320646566FF");
         assertEquals("abc def",
                 GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length, "euc-kr"));

         // Test korean strings.
         unpacked = IccUtils.hexStringToBytes("C5D7BDBAC6AEFF");
         assertEquals("\uD14C\uC2A4\uD2B8",
                 GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length, "euc-kr"));

         // Test gsm Extented Characters.
         unpacked = GsmAlphabet.stringToGsm8BitPacked(sGsmExtendedChars);
         assertEquals(sGsmExtendedChars,
                 GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length, "euc-kr"));
     }
 }
	/*
	* 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.GsmAlphabet;
	import com.android.internal.telephony.uicc.IccUtils;

	import junit.framework.TestCase;

	import android.test.suitebuilder.annotation.LargeTest;
	import android.test.suitebuilder.annotation.SmallTest;

	public class GsmAlphabetTest extends TestCase {

	private static final String sGsmExtendedChars = "{\|}\\[~]\f\u20ac";

	@SmallTest
	public void test7bitWithHeader() throws Exception {
	SmsHeader.ConcatRef concatRef = new SmsHeader.ConcatRef();
	concatRef.refNumber = 1;
	concatRef.seqNumber = 2;
	concatRef.msgCount = 2;
	concatRef.isEightBits = true;
	SmsHeader header = new SmsHeader();
	header.concatRef = concatRef;

	String message = "aaaaaaaaaabbbbbbbbbbcccccccccc";
	byte[] userData = GsmAlphabet.stringToGsm7BitPackedWithHeader(message,
	SmsHeader.toByteArray(header), 0, 0);
	int septetCount = GsmAlphabet.countGsmSeptetsUsingTables(message, true, 0, 0);
	String parsedMessage = GsmAlphabet.gsm7BitPackedToString(
	userData, SmsHeader.toByteArray(header).length+2, septetCount, 1, 0, 0);
	assertEquals(message, parsedMessage);
	}

	// TODO: This method should really be a series of individual test methods.
	// However, it's a SmallTest because it executes quickly.
	@SmallTest
	public void testBasic() throws Exception {
	// '@' maps to char 0
	assertEquals(0, GsmAlphabet.charToGsm('@'));

	// `a (a with grave accent) maps to last GSM character
	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 character
	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));

	// Reserved for extension to extension table (mapped to space)
	assertEquals(' ', GsmAlphabet.gsmExtendedToChar(GsmAlphabet.GSM_EXTENDED_ESCAPE));

	// Unmappable (mapped to character in default or national locking shift table)
	assertEquals('@', GsmAlphabet.gsmExtendedToChar(0));
	assertEquals('\u00e0', GsmAlphabet.gsmExtendedToChar(0x7f));

	//
	// 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(), 0, 0);
	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(), 0, 0);
	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(), 0, 0);
	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(), 0, 0);
	assertEquals(testString.toString(),
	GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));

	// > 255 septets throws runtime exception
	testString.append('@');

	try {
	GsmAlphabet.stringToGsm7BitPacked(testString.toString(), 0, 0);
	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(), 0, 0);
	assertEquals(testString.toString(),
	GsmAlphabet.gsm7BitPackedToString(packed, 1, 0xff & packed[0]));

	// > 255 septets throws runtime exception
	testString.append('{');

	try {
	GsmAlphabet.stringToGsm7BitPacked(testString.toString(), 0, 0);
	fail("expected exception");
	} catch (EncodeException ex) {
	// exception expected
	}

	// Reserved for extension to extension table (mapped to space)
	packed = new byte[]{(byte)(0x1b \| 0x80), 0x1b >> 1};
	assertEquals(" ", GsmAlphabet.gsm7BitPackedToString(packed, 0, 2));

	// Unmappable (mapped to character in default alphabet table)
	packed[0] = 0x1b;
	packed[1] = 0x00;
	assertEquals("@", GsmAlphabet.gsm7BitPackedToString(packed, 0, 2));
	packed[0] = (byte)(0x1b \| 0x80);
	packed[1] = (byte)(0x7f >> 1);
	assertEquals("\u00e0", GsmAlphabet.gsm7BitPackedToString(packed, 0, 2));

	//
	// 8 bit unpacked format
	//
	// Note: we compare hex strings here
	// because Assert doesn't have array comparisons

	byte unpacked[];

	unpacked = IccUtils.hexStringToBytes("566F696365204D61696C");
	assertEquals("Voice Mail",
	GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length));

	assertEquals(IccUtils.bytesToHexString(unpacked),
	IccUtils.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));

	// Reserved for extension to extension table (mapped to space)
	unpacked[0] = 0x1b;
	unpacked[1] = 0x1b;
	assertEquals(" ", GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, 2));

	// Unmappable (mapped to character in default or national locking shift table)
	unpacked[1] = 0x00;
	assertEquals("@", GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, 2));
	unpacked[1] = 0x7f;
	assertEquals("\u00e0", GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, 2));
	}

	@SmallTest
	public void testGsm8BitUpackedWithEuckr() throws Exception {
	// Some feature phones in Korea store contacts as euc-kr.
	// Test this situations.
	byte unpacked[];

	// Test general alphabet strings.
	unpacked = IccUtils.hexStringToBytes("61626320646566FF");
	assertEquals("abc def",
	GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length, "euc-kr"));

	// Test korean strings.
	unpacked = IccUtils.hexStringToBytes("C5D7BDBAC6AEFF");
	assertEquals("\uD14C\uC2A4\uD2B8",
	GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length, "euc-kr"));

	// Test gsm Extented Characters.
	unpacked = GsmAlphabet.stringToGsm8BitPacked(sGsmExtendedChars);
	assertEquals(sGsmExtendedChars,
	GsmAlphabet.gsm8BitUnpackedToString(unpacked, 0, unpacked.length, "euc-kr"));
	}
	}