user/test/com/google/gwt/emultest/java/io/BufferedWriterTest.java

/*
 * Copyright 2020 Google Inc.
 *
 * 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.google.gwt.emultest.java.io;

import com.google.gwt.junit.client.GWTTestCase;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;

/** Unit test for the {@link java.io.BufferedWriter} emulated class. */
public class BufferedWriterTest extends GWTTestCase {

  /** Default buffer size for the {@link java.io.BufferedWriter} object being tested. */
  private static final int DEFAULT_BUFFER_SIZE = 2;

  /** Array of characters that exceeds the default buffer size. */
  private static final char[] BIG_CHAR_ARRAY = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};

  /** {@link java.io.BufferedWriter} object being tested. */
  private BufferedWriter writer;

  /** Underliying writer used by the {@link BufferedWriter} object. */
  private SinkWriter sink;

  /**
   * {@link java.io.Writer} we pass to the {@link java.io.BufferedWriter} object being tested. It
   * allows checking that the characters written by the buffered writter is what we expect.
   */
  private static class SinkWriter extends Writer {

    private boolean closed;

    private boolean flushed;

    private ArrayList<Character> chars;

    SinkWriter() {
      closed = false;
      flushed = false;
      chars = new ArrayList<>(1024);
    }

    @Override
    public void close() {
      closed = true;
    }

    @Override
    public void flush() {
      flushed = true;
    }

    public ArrayList<Character> getChars() {
      return chars;
    }

    public boolean isClosed() {
      return closed;
    }

    public boolean isFlushed() {
      return flushed;
    }

    /**
     * Converts {@code outputChars} to primitive character array.
     *
     * @return primitive char array
     */
    public char[] toCharArray() {
      char[] charArray = new char[chars.size()];
      for (int i = 0; i < chars.size(); i++) {
        charArray[i] = chars.get(i);
      }
      return charArray;
    }

    @Override
    public void write(char[] cbuf, int off, int len) {
      for (int i = off; i < (off + len); i++) {
        chars.add(cbuf[i]);
      }
    }
  }

  /** Sets module name so that javascript compiler can operate. */
  @Override
  public String getModuleName() {
    return "com.google.gwt.emultest.EmulSuite";
  }

  @Override
  protected void gwtSetUp() throws Exception {
    super.gwtSetUp();
    sink = new SinkWriter();
    writer = new BufferedWriter(sink, DEFAULT_BUFFER_SIZE);
  }

  public void testWriteChar() throws IOException {
    writer.write('a');
    assertTrue(sink.getChars().isEmpty());

    writer.write('b');
    assertTrue(sink.getChars().isEmpty());

    writer.write('c');
    assertTrue(Arrays.equals(new char[] {'a', 'b'}, sink.toCharArray()));
  }

  public void testWriteArrayUsingNullArray() throws IOException {
    final char[] b = null;
    try {
      writer.write(b, 0, 2);
      fail("should have thrown NullPointerException");
    } catch (NullPointerException expected) {
    }
  }

  public void testWriteArrayUsingNegativeOffsetValue() throws IOException {
    final char[] b = {'a', 'b'};
    try {
      writer.write(b, -1, 1);
      fail("should have thrown IndexOutOfBoundsException");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testWriteArrayUsingNegativeLengthValue() throws IOException {
    final char[] b = {'a', 'b'};
    try {
      writer.write(b, 0, -1);
      fail("should have thrown IndexOutOfBoundsException");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testWriteArrayUsingInvalidRangeValue() throws IOException {
    final char[] b = {'a', 'b'};
    try {
      writer.write(b, 1, 2);
      fail("should have thrown IndexOutOfBoundsException");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testWriteArraySmallerThanBufferSize() throws IOException {
    final char[] b = {'a'};
    writer.write(b, 0, 1);
    assertTrue(sink.getChars().isEmpty());
  }

  public void testWriteArrayEqualThanBufferSize() throws IOException {
    final int len = DEFAULT_BUFFER_SIZE;
    writer.write(BIG_CHAR_ARRAY, 1, len);
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 1, len + 1), sink.toCharArray()));
  }

  public void testWriteArrayLargerThanBufferSize() throws IOException {
    final int len = DEFAULT_BUFFER_SIZE + 1;
    writer.write(BIG_CHAR_ARRAY, 1, len);
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 1, len + 1), sink.toCharArray()));
  }

  public void testWriteArrayMultipleTimes() throws IOException {
    writer.write(BIG_CHAR_ARRAY, 0, 1);
    // writer: [ 'a' ], sink: [ ]
    assertTrue(sink.getChars().isEmpty());

    writer.write(BIG_CHAR_ARRAY, 1, 2);
    // writer: [ ], sink: [ 'a', 'b', 'c' ]
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 0, 3), sink.toCharArray()));

    writer.write(BIG_CHAR_ARRAY, 3, 3);
    // writer: [ ], sink: [ 'a', 'b', 'c', 'd', 'e', 'f' ]
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 0, 6), sink.toCharArray()));

    writer.write(BIG_CHAR_ARRAY, 6, 1);
    // writer: [ 'g' ], sink: [ 'a', 'b', 'c', 'd', 'e', 'f' ]
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 0, 6), sink.toCharArray()));
  }

  public void testWriteStringUsingNullString() throws IOException {
    final String s = null;
    try {
      writer.write(s, 0, 2);
      fail("should have thrown NullPointerException");
    } catch (NullPointerException expected) {
    }
  }

  public void testWriteStringUsingNegativeOffsetValue() throws IOException {
    final String s = "ab";
    try {
      writer.write(s, -1, 1);
      fail("should have thrown IndexOutOfBoundsException");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testWriteStringUsingNegativeLengthValue() throws IOException {
    final String s = "ab";
    writer.write(s, 0, -1);
    assertTrue(sink.getChars().isEmpty());
  }

  public void testWriteStringUsingInvalidRangeValue() throws IOException {
    final String s = "ab";
    try {
      writer.write(s, 1, 2);
      fail("should have thrown IndexOutOfBoundsException");
    } catch (IndexOutOfBoundsException expected) {
    }
  }

  public void testWriteStringSmallerThanBufferSize() throws IOException {
    final String s = "a";
    writer.write(s, 0, 1);
    assertTrue(sink.getChars().isEmpty());
  }

  public void testWriteStringEqualThanBufferSize() throws IOException {
    final String s = new String(BIG_CHAR_ARRAY);
    writer.write(s, 0, 1);
    assertTrue(sink.getChars().isEmpty());
  }

  public void testWriteStringLargerThanBufferSize() throws IOException {
    final String s = new String(BIG_CHAR_ARRAY);
    final int len = DEFAULT_BUFFER_SIZE + 1;
    writer.write(s, 1, len);
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 1, len), sink.toCharArray()));
  }

  public void testWriteStringMultipleTimes() throws IOException {
    final String s = new String(BIG_CHAR_ARRAY);
    writer.write(s, 0, 1);
    // writer: [ 'a' ], sink: [ ]
    assertTrue(sink.getChars().isEmpty());

    writer.write(s, 1, 2);
    // writer: [ 'c' ], sink: [ 'a', 'b' ]
    assertTrue(
        Arrays.equals(
            Arrays.copyOfRange(BIG_CHAR_ARRAY, 0, DEFAULT_BUFFER_SIZE), sink.toCharArray()));

    writer.write(s, 3, 3);
    // writer: [ ], sink: [ 'a', 'b', 'c', 'd', 'e', 'f' ]
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 0, 6), sink.toCharArray()));

    writer.write(s, 6, 1);
    // writer: [ 'g' ], sink: [ 'a', 'b', 'c', 'd', 'e', 'f' ]
    assertTrue(Arrays.equals(Arrays.copyOfRange(BIG_CHAR_ARRAY, 0, 6), sink.toCharArray()));
  }

  public void testFlushWithEmptyBuffer() throws IOException {
    writer.flush();
    assertTrue(sink.getChars().isEmpty());
    assertTrue(sink.isFlushed());
  }

  public void testFlushWithNonEmptyBuffer() throws IOException {
    final char[] b = new char[] {'a'};
    writer.write(b, 0, 1);
    assertTrue(sink.getChars().isEmpty());

    writer.flush();
    assertTrue(Arrays.equals(b, sink.toCharArray()));
  }

  public void testCloseWithEmptyBuffer() throws IOException {
    writer.close();
    assertTrue(sink.getChars().isEmpty());
    assertTrue(sink.isClosed());
  }

  public void testCloseWithNonEmptyBuffer() throws IOException {
    final char[] b = new char[] {'a'};
    writer.write(b, 0, 1);
    assertTrue(sink.getChars().isEmpty());

    writer.close();
    assertTrue(Arrays.equals(b, sink.toCharArray()));
  }
}