| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 libcore.java.nio.charset; |
| |
| import java.nio.ByteBuffer; |
| import java.nio.CharBuffer; |
| import java.nio.charset.CharacterCodingException; |
| import java.nio.charset.CodingErrorAction; |
| |
| /** |
| * Super class for concrete charset test suites. |
| */ |
| public abstract class OldCharset_SingleByteAbstractTest extends OldCharset_AbstractTest { |
| |
| static byte[] allBytes; |
| static char[] allChars; |
| |
| @Override |
| protected void setUp() throws Exception { |
| allBytes = new byte[256]; |
| for (int i = 0; i < 256; i++) { |
| allBytes[i] = (byte) i; |
| } |
| super.setUp(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| } |
| |
| |
| |
| public static void dumpDecoded () { |
| Charset_TestGenerator.Dumper out = new Charset_TestGenerator.Dumper1(); |
| ByteBuffer inputBB = ByteBuffer.wrap(allBytes); |
| CharBuffer outputCB; |
| decoder.onMalformedInput(CodingErrorAction.REPLACE); |
| try { |
| outputCB = decoder.decode(inputBB); |
| outputCB.rewind(); |
| while (outputCB.hasRemaining()) { |
| out.consume(outputCB.get()); |
| } |
| } catch (CharacterCodingException e) { |
| System.out.println(e); |
| // e.printStackTrace(); |
| } |
| } |
| |
| public static void decodeReplace (byte[] input, char[] expectedOutput) throws CharacterCodingException { |
| ByteBuffer inputBB = ByteBuffer.wrap(input); |
| CharBuffer outputCB; |
| decoder.onMalformedInput(CodingErrorAction.REPLACE); |
| decoder.onUnmappableCharacter(CodingErrorAction.REPLACE); |
| outputCB = decoder.decode(inputBB); |
| outputCB.rewind(); |
| assertEqualChars2("Decoded charactes must match!", |
| expectedOutput, |
| outputCB.array(), |
| input); |
| // assertTrue("Decoded charactes (REPLACEed ones INCLUSIVE) must match!", |
| // Arrays.equals(expectedOutput, outputCB.array())); |
| |
| // assertEqualChars("Decoded charactes (REPLACEed ones INCLUSIVE) must match!", |
| // expectedOutput, |
| // outputCB.array()); |
| |
| // assertEquals("Decoded charactes must match!", |
| // String.valueOf(allChars), |
| // outputCB.toString()); |
| } |
| |
| @Override |
| public void test_Decode () throws CharacterCodingException { |
| decodeReplace(allBytes, allChars); |
| // ByteBuffer inputBB = ByteBuffer.wrap(allBytes); |
| // CharBuffer outputCB; |
| // decoder.onMalformedInput(CodingErrorAction.REPLACE); |
| // outputCB = decoder.decode(inputBB); |
| // outputCB.rewind(); |
| // assertEqualChars("Decoded charactes must match!", |
| // allChars, |
| // outputCB.array()); |
| //// assertEquals("Decoded charactes must match!", |
| //// String.valueOf(allChars), |
| //// outputCB.toString()); |
| } |
| |
| @Override |
| public void test_Encode () throws CharacterCodingException { |
| CharBuffer inputCB = CharBuffer.wrap(allChars); |
| ByteBuffer outputBB; |
| encoder.onUnmappableCharacter(CodingErrorAction.REPLACE); |
| outputBB = encoder.encode(inputCB); |
| outputBB.rewind(); |
| assertEqualBytes2("Encoded bytes must match!", allBytes, outputBB.array(), allChars); |
| } |
| |
| // static void assertEqualChars (String msg, char[] expected, char[] actual) { |
| // int len = expected.length; |
| // if (actual.length < len) len = actual.length; |
| // for (int i = 0; i < len; i++) { |
| // if (actual[i] != expected[i]) { |
| // System.out.format("Mismatch at index %d: %d instead of expected %d.\n", |
| // i, (int) actual[i], (int) expected[i]); |
| // } |
| //// else { |
| //// System.out.format("Match index %d: %d = %d\n", |
| //// i, (int) actual[i], (int) expected[i]); |
| //// } |
| // } |
| // assertTrue(msg, Arrays.equals(actual, expected)); |
| // } |
| |
| static void assertEqualChars2 (String msg, char[] expected, char[] actual, byte[] bytes) { |
| boolean match = true; |
| boolean replaceMatch = true; |
| int len = expected.length; |
| if (actual.length < len) len = actual.length; |
| for (int i = 0; i < len; i++) { |
| if (actual[i] == expected[i]) { |
| // Fine! |
| } |
| else { |
| if (expected[i] == 65533) { |
| if (actual[i] == (bytes[i] & 0xff)) { |
| // System.out.format("REPLACE mismatch at index %d (byte %d): %d instead of expected %d.\n", |
| // i, bytes[i] & 0xff, (int) actual[i], (int) expected[i]); |
| } else { |
| // System.out.format("REPLACE mismatch at index %d (byte %d): %d instead of expected %d.\n", |
| // i, bytes[i] & 0xff, (int) actual[i], (int) expected[i]); |
| } |
| replaceMatch = false; |
| } else { |
| // System.out.format("MISMATCH at index %d (byte %d): %d instead of expected %d.\n", |
| // i, bytes[i] & 0xff, (int) actual[i], (int) expected[i]); |
| match = false; |
| } |
| } |
| // if ((actual[i] != expected[i]) && |
| // !((actual[i] == bytes[i]) && (expected[i] == 65533))) { |
| // |
| // match = false; |
| // } |
| } |
| assertTrue(msg, match); |
| if (!replaceMatch) { |
| // System.out.println("for charset " + charsetName); |
| } |
| } |
| |
| // static void assertEqualBytes (String msg, byte[] expected, byte[] actual) { |
| // int len = expected.length; |
| // if (actual.length < len) len = actual.length; |
| // for (int i = 0; i < len; i++) { |
| // if (actual[i] != expected[i]) { |
| // System.out.format("MISMATCH at index %d: %d instead of expected %d.\n", |
| // i, actual[i], expected[i]); |
| // } |
| // } |
| // assertTrue(msg, Arrays.equals(actual, expected)); |
| // } |
| |
| static void assertEqualBytes2 (String msg, byte[] expected, byte[] actual, char[] chars) { |
| boolean match = true; |
| int len = expected.length; |
| if (actual.length < len) len = actual.length; |
| for (int i = 0; i < len; i++) { |
| if ((actual[i] != expected[i]) && |
| !((chars[i] == 65533)) && (actual[i] == 63)) { |
| // System.out.format("MISMATCH at index %d: %d instead of expected %d.\n", |
| // i, actual[i], expected[i]); |
| match = false; |
| } |
| } |
| assertTrue(msg, match); |
| } |
| |
| } |