/*
* jEdit - Programmer's Text Editor
* :tabSize=8:indentSize=8:noTabs=false:
* :folding=explicit:collapseFolds=1:
*
* Copyright © 2012 jEdit contributors
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
package org.jedit.io;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Closeable;
import java.io.IOException;
import java.io.InputStream;
import java.io.PushbackReader;
import java.io.Reader;
import java.io.Writer;
import java.lang.reflect.InvocationTargetException;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.MalformedInputException;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.gjt.sp.util.IOUtilities.closeQuietly;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.sameInstance;
public class Native2ASCIIEncodingTest
{
@BeforeClass
public static void oneTimeSetUp()
{
native2ASCIIEncoding = new Native2ASCIIEncoding();
iso_8859_1 = Charset.forName("ISO-8859-1");
bufferArray = new char[1024];
buffer = CharBuffer.wrap(bufferArray);
}
@AfterClass
public static void oneTimeTearDown()
{
native2ASCIIEncoding = null;
iso_8859_1 = null;
bufferArray = null;
buffer = null;
}
@Before
public void setUp()
{
buffer.clear();
}
@After
public void tearDown()
{
closeQuietly((Closeable)reader);
closeQuietly((Closeable)writer);
}
private Reader getReader(String input) throws IOException
{
InputStream inputStream = new ByteArrayInputStream(input.getBytes(iso_8859_1));
reader = native2ASCIIEncoding.getTextReader(inputStream);
return reader;
}
private Reader getThrottledReader(String input)
throws IOException, InvocationTargetException, NoSuchMethodException, IllegalAccessException,
InstantiationException
{
InputStream inputStream = new ByteArrayInputStream(input.getBytes(iso_8859_1));
reader = native2ASCIIEncoding.getTextReader(inputStream, ThrottledPushbackReader.class);
return reader;
}
private Reader getPermissiveReader(String input) throws IOException
{
InputStream inputStream = new ByteArrayInputStream(input.getBytes(iso_8859_1));
reader = native2ASCIIEncoding.getPermissiveTextReader(inputStream);
return reader;
}
private Reader getThrottledPermissiveReader(String input)
throws IOException, InvocationTargetException, NoSuchMethodException, IllegalAccessException,
InstantiationException
{
InputStream inputStream = new ByteArrayInputStream(input.getBytes(iso_8859_1));
reader = native2ASCIIEncoding.getPermissiveTextReader(inputStream, ThrottledPushbackReader.class);
return reader;
}
@Test
public void readShouldConvertEscapeSequence() throws IOException
{
int c = getReader("\\u21aF").read();
assertThat((char) c, is(equalTo('\u21aF')));
}
@Test
public void read_charArray_ShouldConvertEscapeSequence() throws IOException
{
int c = getReader("\\u21aF").read(bufferArray);
assertThat(c, is(equalTo(1)));
assertThat(bufferArray[0], is(equalTo('\u21aF')));
}
@Test
public void read_charArray_int_int_ShouldConvertEscapeSequence() throws IOException
{
int c = getReader("\\u21aF").read(bufferArray, 0, 1);
assertThat(c, is(equalTo(1)));
assertThat(bufferArray[0], is(equalTo('\u21aF')));
}
@Test
public void read_CharBuffer_ShouldConvertEscapeSequence() throws IOException
{
int c = getReader("\\u21aF").read(buffer);
buffer.flip();
assertThat(c, is(equalTo(1)));
assertThat(buffer.length(), is(equalTo(1)));
assertThat(buffer.toString(), is(equalTo("\u21aF")));
}
@Test(expected = MalformedInputException.class)
public void readShouldThrowExceptionOnIncompleteEscapeSequence() throws IOException
{
getReader("\\u21a").read();
}
@Test(expected = MalformedInputException.class)
public void read_charArray_ShouldThrowExceptionOnIncompleteEscapeSequence() throws IOException
{
getReader("\\u21a").read(bufferArray);
}
@Test(expected = MalformedInputException.class)
public void read_charArray_int_int_ShouldThrowExceptionOnIncompleteEscapeSequence() throws IOException
{
getReader("\\u21a").read(bufferArray, 0, 1);
}
@Test(expected = MalformedInputException.class)
public void read_CharBuffer_ShouldThrowExceptionOnIncompleteEscapeSequence() throws IOException
{
getReader("\\u21a").read(buffer);
}
@Test(expected = MalformedInputException.class)
public void readShouldThrowExceptionOnMissingInputAfterU() throws IOException
{
getReader("\\u").read();
}
@Test(expected = MalformedInputException.class)
public void read_charArray_ShouldThrowExceptionOnMissingInputAfterU() throws IOException
{
getReader("\\u").read(bufferArray);
}
@Test(expected = MalformedInputException.class)
public void read_charArray_int_int_ShouldThrowExceptionOnMissingInputAfterU() throws IOException
{
getReader("\\u").read(bufferArray, 0, 1);
}
@Test(expected = MalformedInputException.class)
public void read_CharBuffer_ShouldThrowExceptionOnMissingInputAfterU() throws IOException
{
getReader("\\u").read(buffer);
}
@Test(expected = MalformedInputException.class)
public void readShouldThrowExceptionOnMalformedInput() throws IOException
{
Reader reader = getReader("asdf\\: \\u21alasdf");
while (reader.read() != -1)
{
}
}
@Test(expected = MalformedInputException.class)
public void read_charArray_ShouldThrowExceptionOnMalformedInput() throws IOException
{
getReader("asdf\\: \\u21alasdf").read(bufferArray);
}
@Test(expected = MalformedInputException.class)
public void read_charArray_int_int_ShouldThrowExceptionOnMalformedInput() throws IOException
{
getReader("asdf\\: \\u21alasdf").read(bufferArray, 0, 15);
}
@Test(expected = MalformedInputException.class)
public void read_CharBuffer_ShouldThrowExceptionOnMalformedInput() throws IOException
{
getReader("asdf\\: \\u21alasdf").read(buffer);
}
@Test
public void permissiveReadShouldAcceptIncompleteEscapeSequence() throws IOException
{
Reader reader = getPermissiveReader("\\u21a");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void permissiveRead_charArray_ShouldAcceptIncompleteEscapeSequence() throws IOException
{
Reader reader = getPermissiveReader("\\u21a");
int c = reader.read(bufferArray);
assertThat(c, is(equalTo(5)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
}
@Test
public void permissiveRead_charArray_int_int_ShouldAcceptIncompleteEscapeSequence() throws IOException
{
Reader reader = getPermissiveReader("\\u21a");
int c = reader.read(bufferArray, 0, 5);
assertThat(c, is(equalTo(5)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
}
@Test
public void permissiveRead_CharBuffer_ShouldAcceptIncompleteEscapeSequence() throws IOException
{
String input = "\\u21a";
Reader reader = getPermissiveReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(5)));
assertThat(buffer.length(), is(equalTo(5)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void permissiveReadShouldAcceptMissingInputAfterU() throws IOException
{
Reader reader = getPermissiveReader("\\u");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void permissiveRead_charArray_ShouldAcceptMissingInputAfterU() throws IOException
{
Reader reader = getPermissiveReader("\\u");
int c = reader.read(bufferArray);
assertThat(c, is(equalTo(2)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
}
@Test
public void permissiveRead_charArray_int_int_ShouldAcceptMissingInputAfterU() throws IOException
{
Reader reader = getPermissiveReader("\\u");
int c = reader.read(bufferArray, 0, 2);
assertThat(c, is(equalTo(2)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
}
@Test
public void permissiveRead_CharBuffer_ShouldAcceptMissingInputAfterU() throws IOException
{
String input = "\\u";
Reader reader = getPermissiveReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(2)));
assertThat(buffer.length(), is(equalTo(2)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void permissiveReadShouldAcceptMalformedInput() throws IOException
{
Reader reader = getPermissiveReader("asdf\\: \\u21a/asdf");
int c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('s')));
c = reader.read();
assertThat((char) c, is(equalTo('d')));
c = reader.read();
assertThat((char) c, is(equalTo('f')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo(':')));
c = reader.read();
assertThat((char) c, is(equalTo(' ')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('/')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('s')));
c = reader.read();
assertThat((char) c, is(equalTo('d')));
c = reader.read();
assertThat((char) c, is(equalTo('f')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void permissiveRead_charArray_ShouldAcceptMalformedInput() throws IOException
{
int c = getPermissiveReader("asdf\\: \\u21a/asdf").read(bufferArray);
assertThat(c, is(equalTo(17)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
assertThat(bufferArray[i++], is(equalTo(' ')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('/')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void permissiveRead_charArray_int_int_ShouldAcceptMalformedInput() throws IOException
{
int c = getPermissiveReader("asdf\\: \\u21a/asdf").read(bufferArray, 0, 17);
assertThat(c, is(equalTo(17)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
assertThat(bufferArray[i++], is(equalTo(' ')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('/')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void permissiveRead_CharBuffer_ShouldAcceptMalformedInput() throws IOException
{
String input = "asdf\\: \\u21a/asdf";
Reader reader = getPermissiveReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(17)));
assertThat(buffer.length(), is(equalTo(17)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void readShouldCorrectlyHandleEOF() throws IOException
{
int c = getReader("").read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldCorrectlyHandleEOF() throws IOException
{
int c = getReader("").read(bufferArray);
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_int_int_ShouldCorrectlyHandleEOF() throws IOException
{
int c = getReader("").read(bufferArray, 0, 1);
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_CharBuffer_ShouldCorrectlyHandleEOF() throws IOException
{
int c = getReader("").read(buffer);
buffer.flip();
assertThat(c, is(equalTo(-1)));
assertThat(buffer.length(), is(equalTo(0)));
}
@Test
public void readShouldCorrectlyHandleEOFAfterBackslash() throws IOException
{
Reader reader = getReader("\\");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldCorrectlyHandleEOFAfterBackslash() throws IOException
{
int c = getReader("\\").read(bufferArray);
assertThat(c, is(equalTo(1)));
assertThat(bufferArray[0], is(equalTo('\\')));
}
@Test
public void read_charArray_int_int_ShouldCorrectlyHandleEOFAfterBackslash() throws IOException
{
int c = getReader("\\").read(bufferArray, 0, 1);
assertThat(c, is(equalTo(1)));
assertThat(bufferArray[0], is(equalTo('\\')));
}
@Test
public void read_CharBuffer_ShouldCorrectlyHandleEOFAfterBackslash() throws IOException
{
String input = "\\";
int c = getReader(input).read(buffer);
buffer.flip();
assertThat(c, is(equalTo(1)));
assertThat(buffer.length(), is(equalTo(1)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void readShouldCorrectlyHandleLessThan5NonEscapeCharactersAfterBackslash() throws IOException
{
Reader reader = getReader("\\asdf");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('s')));
c = reader.read();
assertThat((char) c, is(equalTo('d')));
c = reader.read();
assertThat((char) c, is(equalTo('f')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldCorrectlyHandleLessThan5NonEscapeCharactersAfterBackslash() throws IOException
{
int c = getReader("\\asdf").read(bufferArray);
assertThat(c, is(equalTo(5)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void read_charArray_int_int_ShouldCorrectlyHandleLessThan5NonEscapeCharactersAfterBackslash()
throws IOException
{
int c = getReader("\\asdf").read(bufferArray, 0, 5);
assertThat(c, is(equalTo(5)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void read_CharBuffer_ShouldCorrectlyHandleLessThan5NonEscapeCharactersAfterBackslash() throws IOException
{
String input = "\\asdf";
int c = getReader(input).read(buffer);
buffer.flip();
assertThat(c, is(equalTo(5)));
assertThat(buffer.length(), is(equalTo(5)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test(expected = MalformedInputException.class)
public void readShouldThrowExceptionOnMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
getThrottledReader("\\u21aL").read();
}
@Test(expected = MalformedInputException.class)
public void read_charArray_ShouldThrowExceptionOnMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
getThrottledReader("\\u21aL").read(bufferArray);
}
@Test(expected = MalformedInputException.class)
public void read_charArray_int_int_ShouldThrowExceptionOnMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
getThrottledReader("\\u21aL").read(bufferArray, 0, 1);
}
@Test(expected = MalformedInputException.class)
public void read_CharBuffer_ShouldThrowExceptionOnMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
getThrottledReader("\\u21aL").read(buffer);
}
@Test
public void readShouldConvertEscapeSequenceWithThrottledInputStream()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
int c = getThrottledReader("\\u21aF").read();
assertThat((char) c, is(equalTo('\u21aF')));
}
@Test
public void read_charArray_ShouldConvertEscapeSequenceWithThrottledInputStream()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
int c = getThrottledReader("\\u21aF").read(bufferArray);
assertThat(c, is(equalTo(1)));
assertThat(bufferArray[0], is(equalTo('\u21aF')));
}
@Test
public void read_charArray_int_int_ShouldConvertEscapeSequenceWithThrottledInputStream()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
int c = getThrottledReader("\\u21aF").read(bufferArray, 0, 1);
assertThat(c, is(equalTo(1)));
assertThat(bufferArray[0], is(equalTo('\u21aF')));
}
@Test
public void read_CharBuffer_ShouldConvertEscapeSequenceWithThrottledInputStream()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
int c = getThrottledReader("\\u21aF").read(buffer);
buffer.flip();
assertThat(c, is(equalTo(1)));
assertThat(buffer.toString(), is(equalTo("\u21aF")));
}
@Test
public void readShouldReadBackslashWithoutFollowingUAsBackslash() throws IOException
{
Reader reader = getReader("\\nu21aF");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('n')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('F')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldReadBackslashWithoutFollowingUAsBackslash() throws IOException
{
int c = getReader("\\nu21aF").read(bufferArray);
assertThat(c, is(equalTo(7)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('n')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('F')));
}
@Test
public void read_charArray_int_int_ShouldReadBackslashWithoutFollowingUAsBackslash() throws IOException
{
int c = getReader("\\nu21aF").read(bufferArray, 0, 7);
assertThat(c, is(equalTo(7)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('n')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('F')));
}
@Test
public void read_CharBuffer_ShouldReadBackslashWithoutFollowingUAsBackslash() throws IOException
{
String input = "\\nu21aF";
Reader reader = getReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(7)));
assertThat(buffer.length(), is(equalTo(7)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void permissiveReadShouldAcceptMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
Reader reader = getThrottledPermissiveReader("\\u21a;");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo(';')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void permissiveRead_charArray_ShouldAcceptMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
int c = getThrottledPermissiveReader("\\u21a;").read(bufferArray);
assertThat(c, is(equalTo(6)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo(';')));
}
@Test
public void permissiveRead_charArray_int_int_ShouldAcceptMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
int c = getThrottledPermissiveReader("\\u21a;").read(bufferArray, 0, 6);
assertThat(c, is(equalTo(6)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo(';')));
}
@Test
public void permissiveRead_CharBuffer_ShouldAcceptMalformedInputWithThrottledReader()
throws IOException, InvocationTargetException, NoSuchMethodException, InstantiationException,
IllegalAccessException
{
String input = "\\u21a;";
Reader reader = getThrottledPermissiveReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(6)));
assertThat(buffer.length(), is(equalTo(6)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void read_charArray_shouldReadOnAfterCollapsingEscapeSequences() throws IOException
{
int c = getReader("asdf\\: \\u21aFasdf").read(bufferArray);
assertThat(c, is(equalTo(12)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
assertThat(bufferArray[i++], is(equalTo(' ')));
assertThat(bufferArray[i++], is(equalTo('\u21aF')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void read_charArray_int_int_shouldReadOnAfterCollapsingEscapeSequences() throws IOException
{
int c = getReader("asdf\\: \\u21aFasdf").read(bufferArray, 0, 12);
assertThat(c, is(equalTo(12)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
assertThat(bufferArray[i++], is(equalTo(' ')));
assertThat(bufferArray[i++], is(equalTo('\u21aF')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void read_CharBuffer_shouldReadOnAfterCollapsingEscapeSequences() throws IOException
{
int c = getReader("asdf\\: \\u21aFasdf").read(buffer);
buffer.flip();
assertThat(c, is(equalTo(12)));
assertThat(buffer.length(), is(equalTo(12)));
assertThat(buffer.toString(), is(equalTo("asdf\\: \u21aFasdf")));
}
@Test
public void readShouldIgnoreEscapeSequenceThatFollowsOneBackslash() throws IOException
{
Reader reader = getReader("\\\\u21aF");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('F')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldIgnoreEscapeSequenceThatFollowsOneBackslash() throws IOException
{
int c = getReader("\\\\u21aF").read(bufferArray);
assertThat(c, is(equalTo(7)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('F')));
}
@Test
public void read_charArray_int_int_ShouldIgnoreEscapeSequenceThatFollowsOneBackslash() throws IOException
{
int c = getReader("\\\\u21aF").read(bufferArray, 0, 7);
assertThat(c, is(equalTo(7)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('F')));
}
@Test
public void read_CharBuffer_ShouldIgnoreEscapeSequenceThatFollowsOneBackslash() throws IOException
{
String input = "\\\\u21aF";
Reader reader = getReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(7)));
assertThat(buffer.length(), is(equalTo(7)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void readShouldConvertEscapeSequenceThatFollowsTwoBackslashes() throws IOException
{
Reader reader = getReader("\\\\\\u21aF");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\u21aF')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldConvertEscapeSequenceThatFollowsTwoBackslashes() throws IOException
{
int c = getReader("\\\\\\u21aF").read(bufferArray);
assertThat(c, is(equalTo(3)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\u21aF')));
}
@Test
public void read_charArray_int_int_ShouldConvertEscapeSequenceThatFollowsTwoBackslashes() throws IOException
{
int c = getReader("\\\\\\u21aF").read(bufferArray, 0, 3);
assertThat(c, is(equalTo(3)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\u21af')));
}
@Test
public void read_CharBuffer_ShouldConvertEscapeSequenceThatFollowsTwoBackslashes() throws IOException
{
Reader reader = getReader("\\\\\\u21aF");
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(3)));
assertThat(buffer.length(), is(equalTo(3)));
assertThat(buffer.toString(), is(equalTo("\\\\\u21aF")));
}
@Test
public void differentReadMethodsShouldBeUsableOnTheSameStream() throws IOException
{
Reader reader = getReader("asdf\\: \\u21aFasdf");
int c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('s')));
c = reader.read();
assertThat((char) c, is(equalTo('d')));
c = reader.read(bufferArray, 0, 3);
assertThat(c, is(equalTo(3)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
c = reader.read();
assertThat((char) c, is(equalTo(' ')));
c = reader.read();
assertThat((char) c, is(equalTo('\u21aF')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(3)));
assertThat(buffer.length(), is(equalTo(3)));
assertThat(buffer.toString(), is(equalTo("sdf")));
}
@Test
public void readShouldIgnoreEscapeSequenceThatFollowsThreeBackslashes() throws IOException
{
Reader reader = getReader("\\\\\\\\u21aF");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('F')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldIgnoreEscapeSequenceThatFollowsThreeBackslashes() throws IOException
{
int c = getReader("\\\\\\\\u21aF").read(bufferArray);
assertThat(c, is(equalTo(9)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('F')));
}
@Test
public void read_charArray_int_int_ShouldIgnoreEscapeSequenceThatFollowsThreeBackslashes() throws IOException
{
int c = getReader("\\\\\\\\u21aF").read(bufferArray, 0, 9);
assertThat(c, is(equalTo(9)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('F')));
}
@Test
public void read_CharBuffer_ShouldIgnoreEscapeSequenceThatFollowsThreeBackslashes() throws IOException
{
String input = "\\\\\\\\u21aF";
Reader reader = getReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(9)));
assertThat(buffer.length(), is(equalTo(9)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void readShouldIgnoreIncompleteEscapeSequenceThatFollowsOneBackslash() throws IOException
{
Reader reader = getReader("\\\\u21a");
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldIgnoreIncompleteEscapeSequenceThatFollowsOneBackslash() throws IOException
{
int c = getReader("\\\\u21a").read(bufferArray);
assertThat(c, is(equalTo(6)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
}
@Test
public void read_charArray_int_int_ShouldIgnoreIncompleteEscapeSequenceThatFollowsOneBackslash()
throws IOException
{
int c = getReader("\\\\u21a").read(bufferArray, 0, 6);
assertThat(c, is(equalTo(6)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
}
@Test
public void read_CharBuffer_ShouldIgnoreIncompleteEscapeSequenceThatFollowsOneBackslash() throws IOException
{
String input = "\\\\u21a";
Reader reader = getReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(6)));
assertThat(buffer.length(), is(equalTo(6)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void readShouldIgnoreMalformedEscapeSequenceThatFollowsOneBackslash() throws IOException
{
Reader reader = getReader("asdf\\: \\\\u21alasdf");
int c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('s')));
c = reader.read();
assertThat((char) c, is(equalTo('d')));
c = reader.read();
assertThat((char) c, is(equalTo('f')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo(':')));
c = reader.read();
assertThat((char) c, is(equalTo(' ')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('l')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read();
assertThat((char) c, is(equalTo('s')));
c = reader.read();
assertThat((char) c, is(equalTo('d')));
c = reader.read();
assertThat((char) c, is(equalTo('f')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void read_charArray_ShouldIgnoreMalformedEscapeSequenceThatFollowsOneBackslash() throws IOException
{
int c = getReader("asdf\\: \\\\u21alasdf").read(bufferArray);
assertThat(c, is(equalTo(18)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
assertThat(bufferArray[i++], is(equalTo(' ')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('l')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void read_charArray_int_int_ShouldIgnoreMalformedEscapeSequenceThatFollowsOneBackslash()
throws IOException
{
int c = getReader("asdf\\: \\\\u21alasdf").read(bufferArray, 0, 18);
assertThat(c, is(equalTo(18)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
assertThat(bufferArray[i++], is(equalTo(' ')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo('u')));
assertThat(bufferArray[i++], is(equalTo('2')));
assertThat(bufferArray[i++], is(equalTo('1')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('l')));
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
}
@Test
public void read_CharBuffer_ShouldIgnoreMalformedEscapeSequenceThatFollowsOneBackslash() throws IOException
{
String input = "asdf\\: \\\\u21alasdf";
Reader reader = getReader(input);
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(18)));
assertThat(buffer.length(), is(equalTo(18)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void differentReadMethodsShouldHaveACommonEscapeSequenceHandling() throws IOException
{
Reader reader = getReader("asdf\\: \\\\u21aFasdf");
int c = reader.read(bufferArray, 0, 8);
assertThat(c, is(equalTo(8)));
int i = 0;
assertThat(bufferArray[i++], is(equalTo('a')));
assertThat(bufferArray[i++], is(equalTo('s')));
assertThat(bufferArray[i++], is(equalTo('d')));
assertThat(bufferArray[i++], is(equalTo('f')));
assertThat(bufferArray[i++], is(equalTo('\\')));
assertThat(bufferArray[i++], is(equalTo(':')));
assertThat(bufferArray[i++], is(equalTo(' ')));
assertThat(bufferArray[i++], is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('a')));
c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(5)));
assertThat(buffer.length(), is(equalTo(5)));
assertThat(buffer.toString(), is(equalTo("Fasdf")));
}
@Test(expected = IllegalArgumentException.class)
public void skipShouldThrowExceptionIfToSkipIsNegative() throws IOException
{
getReader("asdf\\: \\\\u21alasdf").skip(-1);
}
@Test
public void skipShouldNotDoAnythingIfToSkipIsZero() throws IOException
{
String input = "asdf\\: \\\\u21alasdf";
Reader reader = getReader(input);
long skipped = reader.skip(0);
assertThat(skipped, is(equalTo(0L)));
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(18)));
assertThat(buffer.length(), is(equalTo(18)));
assertThat(buffer.toString(), is(equalTo(input)));
}
@Test
public void skipShouldSkipGivenAmountIfAvailable() throws IOException
{
Reader reader = getReader("asdf\\: \\\\u21alasdf");
long skipped = reader.skip(8);
assertThat(skipped, is(equalTo(8L)));
int c = reader.read(buffer);
buffer.flip();
assertThat(c, is(equalTo(10)));
assertThat(buffer.length(), is(equalTo(10)));
assertThat(buffer.toString(), is(equalTo("\\u21alasdf")));
}
@Test
public void skipShouldSkipAllIfToSkipIsGreaterThanInputLength() throws IOException
{
Reader reader = getReader("asdf\\: \\\\u21alasdf");
long skipped = reader.skip(20);
assertThat(skipped, is(equalTo(18L)));
int c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void multipleSkipCallsShouldWork() throws IOException
{
Reader reader = getReader("asdf\\: \\\\u21alasdf");
long skipped = reader.skip(5);
assertThat(skipped, is(equalTo(5L)));
skipped = reader.skip(10);
assertThat(skipped, is(equalTo(10L)));
skipped = reader.skip(5);
assertThat(skipped, is(equalTo(3L)));
int c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void textReaderWithNullAsClassParameterShouldWork()
throws IOException, InvocationTargetException, NoSuchMethodException, IllegalAccessException,
InstantiationException
{
InputStream inputStream = new ByteArrayInputStream("asdf\\: \\\\u21alasdf".getBytes(iso_8859_1));
reader = native2ASCIIEncoding.getTextReader(inputStream, null);
long skipped = reader.skip(18);
assertThat(skipped, is(equalTo(18L)));
int c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void readerShouldBeAbleToDecodeWhatWriterHasEncoded() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write('\u21AF');
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
reader = native2ASCIIEncoding.getTextReader(bais);
int c = reader.read();
assertThat((char) c, is(equalTo('\u21AF')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void readerShouldReadSingleCharactersIfWriterAddedAnEscapingBackslash() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write('\\');
writer.write('\u21AF');
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\\\u21AF")));
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
reader = native2ASCIIEncoding.getTextReader(bais);
int c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('\\')));
c = reader.read();
assertThat((char) c, is(equalTo('u')));
c = reader.read();
assertThat((char) c, is(equalTo('2')));
c = reader.read();
assertThat((char) c, is(equalTo('1')));
c = reader.read();
assertThat((char) c, is(equalTo('A')));
c = reader.read();
assertThat((char) c, is(equalTo('F')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void readerShouldDecodeIfWriterHasWrittenEscapeSequenceAsSingleCharacters() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write('\\');
writer.write('u');
writer.write('2');
writer.write('1');
writer.write('a');
writer.write('F');
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
reader = native2ASCIIEncoding.getTextReader(bais);
int c = reader.read();
assertThat((char) c, is(equalTo('\u21aF')));
c = reader.read();
assertThat(c, is(equalTo(-1)));
}
@Test
public void write_int_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write('\\');
writer.write('u');
writer.write('2');
writer.write('1');
writer.write('a');
writer.write('F');
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void write_charArray_int_int_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write(new char[] { '\\', 'u', '2', '1', 'a', 'F' }, 0, 6);
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void write_String_int_int_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write("\\u21aF", 0, 6);
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void write_charArray_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write(new char[] { '\\', 'u', '2', '1', 'a', 'F' });
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void write_String_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write("\\u21aF");
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void append_char_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append('\\').append('u').append('2').append('1').append('a').append('F');
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void append_CharSequence_int_int_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append("\\u21aF", 0, 6);
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void append_CharSequence_ShouldEncodeASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append("\\u21aF");
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21aF")));
}
@Test
public void write_int_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write('\u21AF');
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void write_charArray_int_int_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write(new char[] { '\u21AF' }, 0, 1);
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void write_String_int_int_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write("\u21AF", 0, 1);
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void write_charArray_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write(new char[] { '\u21AF' });
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void write_String_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
writer.write("\u21AF");
writer.flush();
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void append_char_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append('\u21AF');
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void append_CharSequence_int_int_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append("\u21AF", 0, 1);
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void append_CharSequence_ShouldEncodeNonASCIICharactersCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append("\u21AF");
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("\\u21AF")));
}
@Test
public void append_CharSequence_int_int_ShouldEncodeNullCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append(null, 0, 4);
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("null")));
}
@Test
public void append_CharSequence_ShouldEncodeNullCorrectly() throws IOException
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
writer = native2ASCIIEncoding.getTextWriter(baos);
Writer returnedWriter = writer.append(null);
writer.flush();
assertThat(returnedWriter, is(sameInstance(writer)));
assertThat(baos.toString("ISO-8859-1"), is(equalTo("null")));
}
private Reader reader;
private Writer writer;
private static Native2ASCIIEncoding native2ASCIIEncoding;
private static Charset iso_8859_1;
private static char[] bufferArray;
private static CharBuffer buffer;
private static class ThrottledPushbackReader extends PushbackReader
{
public ThrottledPushbackReader(Reader in, int size)
{
super(in, size);
}
@Override
public int read(char[] cbuf, int off, int len) throws IOException
{
if (cbuf == null)
{
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > cbuf.length - off)
{
throw new IndexOutOfBoundsException();
}
int readChar = read();
if (readChar == -1)
{
return -1;
}
if (len == 0)
{
return 0;
}
cbuf[off] = (char) readChar;
return 1;
}
}
}