tests/CoreTests/com/android/internal/telephony/gsm/GsmAlphabetTest.java - platform/frameworks/base - Gitiles

 /*
  * 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));
     }
 }
	/*
	* 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));
	}
	}