user/test/com/google/gwt/emultest/java/io/PrintStreamTest.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 static java.nio.charset.StandardCharsets.UTF_8;

import com.google.gwt.junit.client.GWTTestCase;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;

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

  /** {@link java.io.PrintStream} object being tested. */
  private PrintStream ps;

  /** Underlying output stream used by the {@link PrintStream} object. */
  private ByteArrayOutputStream baos;

  private static class MockPrintStream extends PrintStream {

    public MockPrintStream(OutputStream os) {
      super(os);
    }

    @Override
    public void clearError() {
      super.clearError();
    }

    @Override
    public void setError() {
      super.setError();
    }
  }

  /** 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();
    baos = new ByteArrayOutputStream();
    ps = new PrintStream(baos);
  }

  public void testPrintCharArray() {
    char[] charArray = {'a', 'b', 'c', '"', '&', '<', '>'};
    ps.print(charArray);
    ps.close();
    assertTrue(
        "Incorrect char[] written",
        Arrays.equals(new String(charArray).getBytes(UTF_8), baos.toByteArray()));
  }

  public void testPrintChar() {
    ps.print('t');
    ps.close();
    assertEquals("Incorrect char written", "t", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintDouble() {
    ps.print(2345.76834720202);
    ps.close();
    assertEquals(
        "Incorrect double written", "2345.76834720202", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintInt() {
    ps.print(768347202);
    ps.close();
    assertEquals("Incorrect int written", "768347202", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintLong() {
    ps.print(919728433988L);
    ps.close();
    assertEquals("Incorrect long written", "919728433988", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintFloat() {
    ps.print(29.08764);
    ps.close();
    assertEquals("Incorrect float written", "29.08764", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintNullObject() {
    ps.print((Object) null);
    ps.close();
    assertEquals("null should be written", "null", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintObject() {
    ps.print(new ArrayList<String>());
    ps.close();
    assertEquals("Incorrect Object written", "[]", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintNullString() {
    ps.print((String) null);
    ps.close();
    assertEquals("null should be written", "null", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintString() {
    ps.print("Hello World");
    ps.close();
    assertEquals("Incorrect String written", "Hello World", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintBoolean() {
    ps.print(true);
    ps.close();
    assertEquals("Incorrect boolean written", "true", new String(baos.toByteArray(), UTF_8));
  }

  public void testPrintln() {
    ps.println();
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnCharArray() {
    char[] charArray = {'a', 'b', 'c', '"', '&', '<', '>'};
    ps.println(charArray);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[7];
    bais.read(outBytes, 0, 7);
    assertTrue(
        "Incorrect char[] written", Arrays.equals(new String(charArray).getBytes(UTF_8), outBytes));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnChar() {
    ps.println('t');
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    assertEquals("Incorrect char written", 't', bais.read());
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnDouble() {
    ps.println(2345.76834720202);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[16];
    bais.read(outBytes, 0, 16);
    assertEquals("Incorrect double written", "2345.76834720202", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnInt() {
    ps.println(768347202);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[9];
    bais.read(outBytes, 0, 9);
    assertEquals("Incorrect int written", "768347202", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnLong() {
    ps.println(919728433988L);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[12];
    bais.read(outBytes, 0, 12);
    assertEquals("Incorrect double written", "919728433988", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnFloat() {
    ps.println(29.08764);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[8];
    bais.read(outBytes, 0, 8);
    assertEquals("Incorrect float written", "29.08764", new String(outBytes, 0, 8, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnNullObject() {
    ps.println((Object) null);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[4];
    bais.read(outBytes, 0, 4);
    assertEquals("null should be written", "null", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnObject() {
    ps.println(new ArrayList<String>());
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[2];
    bais.read(outBytes, 0, 2);
    assertEquals("Incorrect Object written", "[]", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnNullString() {
    ps.println((String) null);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[4];
    bais.read(outBytes, 0, 4);
    assertEquals("null should be written", "null", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnString() {
    ps.println("Hello World");
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[11];
    bais.read(outBytes, 0, 11);
    assertEquals("Incorrect String written", "Hello World", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testPrintlnBoolean() {
    ps.println(true);
    ps.close();
    ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
    byte[] outBytes = new byte[4];
    bais.read(outBytes, 0, 4);
    assertEquals("Incorrect boolean written", "true", new String(outBytes, UTF_8));
    assertEquals("Newline not written", '\n', bais.read());
  }

  public void testCheckError() {
    ps =
        new PrintStream(
            new OutputStream() {

              @Override
              public void write(int b) throws IOException {
                throw new IOException();
              }

              @Override
              public void write(byte[] b, int o, int l) throws IOException {
                throw new IOException();
              }
            });
    ps.print("Hello World");
    assertTrue(ps.checkError());
  }

  public void testClearError() {
    MockPrintStream ps = new MockPrintStream(baos);
    assertFalse(ps.checkError());
    ps.setError();
    assertTrue(ps.checkError());
    ps.clearError();
    assertFalse(ps.checkError());
    ps.close();
  }
}