diff --git a/user/super/com/google/gwt/emul/java/io/BufferedWriter.java b/user/super/com/google/gwt/emul/java/io/BufferedWriter.java
new file mode 100644
index 0000000..922a482
--- /dev/null
+++ b/user/super/com/google/gwt/emul/java/io/BufferedWriter.java
@@ -0,0 +1,134 @@
+/*
+ * 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 java.io;
+
+import static javaemul.internal.InternalPreconditions.checkArgument;
+import static javaemul.internal.InternalPreconditions.checkNotNull;
+import static javaemul.internal.InternalPreconditions.checkState;
+
+/**
+ * See <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/io/BufferedWriter.html">the official
+ * Java API doc</a> for details.
+ */
+public class BufferedWriter extends Writer {
+  private static int defaultCharBufferSize = 8192;
+
+  private Writer out;
+  private char[] buf;
+  private int pos;
+  private int size;
+
+  public BufferedWriter(Writer out) {
+    this(out, defaultCharBufferSize);
+  }
+
+  public BufferedWriter(Writer out, int size) {
+    super(out);
+    checkArgument(size > 0, "Buffer size <= 0");
+    this.out = out;
+    this.buf = new char[size];
+    this.size = size;
+    this.pos = 0;
+  }
+
+  @Override
+  public void close() throws IOException {
+    if (out == null) {
+      return;
+    }
+    try (Writer w = out) {
+      flushBuffer();
+    } finally {
+      out = null;
+      buf = null;
+    }
+  }
+
+  @Override
+  public void flush() throws IOException {
+    flushBuffer();
+    out.flush();
+  }
+
+  private void ensureOpen() throws IOException {
+    checkState(out != null, "stream closed");
+  }
+
+  private void flushBuffer() throws IOException {
+    ensureOpen();
+    if (pos > 0) {
+      out.write(buf, 0, pos);
+    }
+    pos = 0;
+  }
+
+  public void newLine() throws IOException {
+    write("\n");
+  }
+
+  @Override
+  public void write(char[] buffer, int offset, int count) throws IOException {
+    ensureOpen();
+    IOUtils.checkOffsetAndCount(buffer, offset, count);
+    if (count >= size) {
+      /* If the request length exceeds the size of the output buffer,
+      flush the buffer and then write the data directly.  In this
+      way buffered streams will cascade harmlessly. */
+      flushBuffer();
+      out.write(buffer, offset, count);
+      return;
+    }
+
+    int b = offset, t = offset + count;
+    while (b < t) {
+      int d = Math.min(size - pos, t - b);
+      System.arraycopy(buffer, b, buf, pos, d);
+      b += d;
+      pos += d;
+      if (pos >= size) {
+        flushBuffer();
+      }
+    }
+  }
+
+  @Override
+  public void write(int oneChar) throws IOException {
+    ensureOpen();
+    if (pos >= size) {
+      out.write(buf, 0, buf.length);
+      pos = 0;
+    }
+    buf[pos++] = (char) oneChar;
+  }
+
+  @Override
+  public void write(String str, int offset, int count) throws IOException {
+    ensureOpen();
+    // Ensure we throw a NullPointerException instead of a JavascriptException in case the
+    // given string is null.
+    checkNotNull(str);
+    int b = offset, t = offset + count;
+    while (b < t) {
+      int d = Math.min(size - pos, t - b);
+      str.getChars(b, b + d, buf, pos);
+      b += d;
+      pos += d;
+      if (pos >= size) {
+        flushBuffer();
+      }
+    }
+  }
+}
diff --git a/user/test/com/google/gwt/emultest/EmulSuite.java b/user/test/com/google/gwt/emultest/EmulSuite.java
index 0d8bf9f..d28f9ec 100644
--- a/user/test/com/google/gwt/emultest/EmulSuite.java
+++ b/user/test/com/google/gwt/emultest/EmulSuite.java
@@ -16,6 +16,7 @@
 package com.google.gwt.emultest;
 
 import com.google.gwt.emultest.java.internal.CoercionsTest;
+import com.google.gwt.emultest.java.io.BufferedWriterTest;
 import com.google.gwt.emultest.java.io.ByteArrayInputStreamTest;
 import com.google.gwt.emultest.java.io.ByteArrayOutputStreamTest;
 import com.google.gwt.emultest.java.io.FilterInputStreamTest;
@@ -70,6 +71,7 @@
   CoercionsTest.class,
 
   // -- java.io
+  BufferedWriterTest.class,
   ByteArrayInputStreamTest.class,
   ByteArrayOutputStreamTest.class,
   FilterInputStreamTest.class,
diff --git a/user/test/com/google/gwt/emultest/java/io/BufferedWriterTest.java b/user/test/com/google/gwt/emultest/java/io/BufferedWriterTest.java
new file mode 100644
index 0000000..38b9a28
--- /dev/null
+++ b/user/test/com/google/gwt/emultest/java/io/BufferedWriterTest.java
@@ -0,0 +1,299 @@
+/*
+ * 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()));
+  }
+}