Initial revision

From-SVN: r102074

46 files changed, 4151 insertions, 0 deletions

diff --git a/libjava/classpath/test/java.io/.cvsignore b/libjava/classpath/test/java.io/.cvsignore
new file mode 100644
index 0000000..70845e0
--- /dev/null
+++ b/libjava/classpath/test/java.io/.cvsignore
@@ -0,0 +1 @@
+Makefile.in
diff --git a/libjava/classpath/test/java.io/BufferedByteOutputStreamTest.java b/libjava/classpath/test/java.io/BufferedByteOutputStreamTest.java
new file mode 100644
index 0000000..e2785e6
--- /dev/null
+++ b/libjava/classpath/test/java.io/BufferedByteOutputStreamTest.java
@@ -0,0 +1,87 @@
+/*************************************************************************
+/* BufferedByteOutputStreamTest.java -- Test {Buffered,ByteArray}OutputStream
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+/**
+  * Class to test BufferedOutputStream and ByteOutputStream
+  *
+  * @version 0.0
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  */
+public class BufferedByteOutputStreamTest
+{
+
+public static void 
+main(String argv[])
+{
+  System.out.println("Started test of BufferedOutputStream and ByteArrayOutputStream");
+
+  try
+    {
+      System.out.println("Test 1: Write Tests");
+
+      ByteArrayOutputStream baos = new ByteArrayOutputStream(24);
+      BufferedOutputStream bos = new BufferedOutputStream(baos, 12);
+
+      String str = "The Kroger on College Mall Rd. in Bloomington " +
+        "used to sell Kroger brand froze pizzas for 68 cents. " +
+        "I ate a lot of those in college.  It was kind of embarrassing " +
+        "walking out of the grocery with nothing but 15 frozen pizzas.\n";
+
+      boolean passed = true;
+
+      byte[] buf = str.getBytes();
+      bos.write(buf, 0, 5);
+      if (baos.toByteArray().length != 0)
+        {
+          passed = false;
+          System.out.println("ByteArrayOutputStream has too many bytes #1");
+        }
+      bos.write(buf, 5, 8);
+      bos.write(buf, 13, 12);
+      bos.write(buf[25]);
+      bos.write(buf, 26, buf.length - 26);
+      bos.close();
+
+      String str2 = new String(baos.toByteArray());
+      if (!str.equals(str2))
+        {
+          passed = false;
+          System.out.println("Unexpected string: " + str2);
+        }
+
+      if (passed)
+        System.out.println("PASSED: Write Tests");
+      else
+        System.out.println("FAILED: Write Tests");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Write Tests: " + e);
+    }
+
+  System.out.println("Finished test of BufferedOutputStream and ByteArrayOutputStream");
+}
+
+} // class BufferedByteOutputStreamTest
+
diff --git a/libjava/classpath/test/java.io/BufferedCharWriterTest.java b/libjava/classpath/test/java.io/BufferedCharWriterTest.java
new file mode 100644
index 0000000..2893b4b
--- /dev/null
+++ b/libjava/classpath/test/java.io/BufferedCharWriterTest.java
@@ -0,0 +1,89 @@
+/*************************************************************************
+/* BufferedCharWriterTest.java -- Test {Buffered,CharArray}Writer
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+/**
+  * Class to test BufferedWriter and CharArrayWriter
+  *
+  * @version 0.0
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  */
+public class BufferedCharWriterTest
+{
+
+public static void 
+main(String argv[])
+{
+  System.out.println("Started test of BufferedWriter and CharArrayWriter");
+
+  try
+    {
+      System.out.println("Test 1: Write Tests");
+
+      CharArrayWriter caw = new CharArrayWriter(24);
+      BufferedWriter bw = new BufferedWriter(caw, 12);
+
+      String str = "I used to live right behind this super-cool bar in\n" +
+        "Chicago called Lounge Ax.  They have the best music of pretty\n" +
+        "much anyplace in town with a great atmosphere and $1 Huber\n" +
+        "on tap.  I go to tons of shows there, even though I moved.\n";
+
+      boolean passed = true;
+
+      char[] buf = new char[str.length()];
+      str.getChars(0, str.length(), buf, 0);
+
+      bw.write(buf, 0, 5);
+      if (caw.toCharArray().length != 0)
+        {
+          passed = false;
+          System.out.println("CharArrayWriter has too many bytes #1");
+        }
+      bw.write(buf, 5, 8);
+      bw.write(buf, 13, 12);
+      bw.write(buf[25]);
+      bw.write(buf, 26, buf.length - 26);
+      bw.close();
+
+      String str2 = new String(caw.toCharArray());
+      if (!str.equals(str2))
+        {
+          passed = false;
+          System.out.println("Unexpected string: " + str2);
+        }
+
+      if (passed)
+        System.out.println("PASSED: Write Tests");
+      else
+        System.out.println("FAILED: Write Tests");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Write Tests: " + e);
+    }
+
+  System.out.println("Finished test of BufferedOutputStream and ByteArrayOutputStream");
+}
+
+} // class BufferedByteOutputStreamTest
+
diff --git a/libjava/classpath/test/java.io/BufferedInputStreamTest.java b/libjava/classpath/test/java.io/BufferedInputStreamTest.java
new file mode 100644
index 0000000..c7d73e3
--- /dev/null
+++ b/libjava/classpath/test/java.io/BufferedInputStreamTest.java
@@ -0,0 +1,241 @@
+/*************************************************************************
+/* BufferedInputStreamTest.java -- Tests BufferedInputStream's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class BufferedInputStreamTest extends BufferedInputStream
+{
+
+public
+BufferedInputStreamTest(InputStream in, int size)
+{
+  super(in, size);
+}
+
+public static int
+marktest(InputStream ins) throws IOException
+{
+  BufferedInputStream bis = new BufferedInputStream(ins, 15);
+
+  int bytes_read;  
+  int total_read = 0;
+  byte[] buf = new byte[12];
+
+  bytes_read = bis.read(buf);
+  total_read += bytes_read;
+  System.out.print(new String(buf, 0, bytes_read));
+
+  bytes_read = bis.read(buf);
+  total_read += bytes_read;
+  System.out.print(new String(buf, 0, bytes_read));
+
+  bis.mark(75);
+  bis.read();
+  bis.read(buf);
+  bis.read(buf);
+  bis.read(buf);
+  bis.reset();
+
+  bytes_read = bis.read(buf);
+  total_read += bytes_read;
+  System.out.print(new String(buf, 0, bytes_read));
+
+  bis.mark(555);
+
+  bytes_read = bis.read(buf);
+  total_read += bytes_read;
+  System.out.print(new String(buf, 0, bytes_read));
+
+  bis.reset();
+
+  bis.read(buf);
+  bytes_read = bis.read(buf);
+  total_read += bytes_read;
+  System.out.print(new String(buf, 0, bytes_read));
+
+  bytes_read = bis.read(buf);
+  total_read += bytes_read;
+  System.out.print(new String(buf, 0, bytes_read));
+
+  bis.mark(14);
+
+  bis.read(buf);
+
+  bis.reset();
+
+  bytes_read = bis.read(buf);
+  total_read += bytes_read;
+  System.out.print(new String(buf, 0, bytes_read));
+
+  while ((bytes_read = bis.read(buf)) != -1)
+    {
+      System.out.print(new String(buf, 0, bytes_read));
+      total_read += bytes_read;
+    }
+
+  return(total_read);
+}
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Started test of BufferedInputStream");
+
+  try
+    {
+      System.out.println("Test 1: Protected Variables Test");
+
+      String str = "This is a test line of text for this pass";
+
+      StringBufferInputStream sbis = new StringBufferInputStream(str);
+      BufferedInputStreamTest bist = new BufferedInputStreamTest(sbis, 12); 
+
+      bist.read();
+      bist.mark(5);
+
+      boolean passed = true;
+
+      if (bist.buf.length != 12)
+        {
+          passed = false;
+          System.out.println("buf.length is wrong.  Expected 12, but got " + 
+                             bist.buf.length);
+        }
+      if (bist.count != 12)
+        {
+          passed = false;
+          System.out.println("count is wrong.  Expected 12, but got " + 
+                             bist.count);
+        }
+      if (bist.marklimit != 5)
+        {
+          passed = false;
+          System.out.println("marklimit is wrong.  Expected 5, but got " + 
+                             bist.marklimit);
+        }
+      if (bist.markpos != 1)
+        {
+          passed = false;
+          System.out.println("markpos is wrong.  Expected 5, but got " + 
+                             bist.markpos);
+        }
+      if (bist.pos != 1)
+        {
+          passed = false;
+          System.out.println("pos is wrong.  Expected 1, but got " + 
+                             bist.pos);
+        }
+
+      if (passed)
+        System.out.println("PASSED: Protected Variables Test");
+      else
+        System.out.println("FAILED: Protected Variables Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Protected Variables Test: " + e);
+    }
+
+  try
+    {
+      System.out.println("Test 2: Simple Read Test");
+
+      String str = "One of my 8th grade teachers was Mr. Russell.\n" +
+         "He used to start each year off by telling the class that the\n" +
+         "earth was flat.  He did it to teach people to question\n" +
+         "things they are told.  But everybody knew that he did it\n" +
+         "so it lost its effect.\n";
+
+      StringBufferInputStream sbis = new StringBufferInputStream(str);
+      BufferedInputStream bis = new BufferedInputStream(sbis, 15);
+
+      byte[] buf = new byte[12];
+      int bytes_read;
+      while((bytes_read = bis.read(buf)) != -1)
+        System.out.print(new String(buf, 0, bytes_read));
+
+      bis.close();
+      System.out.println("PASSED: Simple Read Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Simple Read Test: " + e);
+    }
+
+  try
+    {
+      System.out.println("Test 3: First mark/reset Test");
+
+      String str = "My 6th grade teacher was named Mrs. Hostetler.\n" +
+        "She had a whole list of rules that you were supposed to follow\n" +
+        "in class and if you broke a rule she would make you write the\n" +
+        "rules out several times.  The number varied depending on what\n" +
+        "rule you broke.  Since I knew I would get in trouble, I would\n" +
+        "just go ahead and write out a few sets on the long school bus\n" +
+        "ride home so that if had to stay in during recess and write\n" +
+        "rules, five minutes later I could just tell the teacher I was\n" +
+        "done so I could go outside and play kickball.\n";
+
+      StringBufferInputStream sbis = new StringBufferInputStream(str);
+
+      int total_read = marktest(sbis);
+
+      if (total_read == str.length())
+        System.out.println("PASSED: First mark/reset Test");
+      else
+        System.out.println("FAILED: First mark/reset Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: First mark/reset Test: " + e);
+    }
+   
+  try
+    {
+      System.out.println("Test 4: Second mark/reset Test");
+
+      String str = "My first day of college was fun.  A bunch of us\n" +
+         "got pretty drunk, then this guy named Rick Flake (I'm not\n" +
+         "making that name up) took a piss in the bed of a Physical\n" +
+         "Plant dept pickup truck.  Later on we were walking across\n" +
+         "campus, saw a cop, and took off running for no reason.\n" +
+         "When we got back to the dorm we found an even drunker guy\n" +
+         "passed out in a shopping cart outside.\n";
+
+      ByteArrayInputStream sbis = new ByteArrayInputStream(str.getBytes());
+
+      int total_read = marktest(sbis);
+
+      if (total_read == str.length())
+        System.out.println("PASSED: Second mark/reset Test");
+      else
+        System.out.println("FAILED: Second mark/reset Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Second mark/reset Test: " + e);
+    }
+
+  System.out.println("Finished test of BufferedInputStream");
+} // main
+
+} // class BufferedInputStreamTest
+
diff --git a/libjava/classpath/test/java.io/BufferedReaderTest.java b/libjava/classpath/test/java.io/BufferedReaderTest.java
new file mode 100644
index 0000000..d3c1d4f
--- /dev/null
+++ b/libjava/classpath/test/java.io/BufferedReaderTest.java
@@ -0,0 +1,200 @@
+/*************************************************************************
+/* BufferedReaderTest.java -- Tests BufferedReader's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class BufferedReaderTest extends CharArrayReader
+{
+
+// Hehe.  We override CharArrayReader.markSupported() in order to return
+// false so that we can test BufferedReader's handling of mark/reset in
+// both the case where the underlying stream does and does not support
+// mark/reset
+public boolean
+markSupported()
+{
+  return(false);
+}
+
+public
+BufferedReaderTest(char[] buf)
+{
+  super(buf);
+}
+
+public static int
+marktest(Reader ins) throws IOException
+{
+  BufferedReader br = new BufferedReader(ins, 15);
+
+  int chars_read;  
+  int total_read = 0;
+  char[] buf = new char[12];
+
+  chars_read = br.read(buf);
+  total_read += chars_read;
+  System.out.print(new String(buf, 0, chars_read));
+
+  chars_read = br.read(buf);
+  total_read += chars_read;
+  System.out.print(new String(buf, 0, chars_read));
+
+  br.mark(75);
+  br.read();
+  br.read(buf);
+  br.read(buf);
+  br.read(buf);
+  br.reset();
+
+  chars_read = br.read(buf);
+  total_read += chars_read;
+  System.out.print(new String(buf, 0, chars_read));
+
+  br.mark(555);
+
+  chars_read = br.read(buf);
+  total_read += chars_read;
+  System.out.print(new String(buf, 0, chars_read));
+
+  br.reset();
+
+  br.read(buf);
+  chars_read = br.read(buf);
+  total_read += chars_read;
+  System.out.print(new String(buf, 0, chars_read));
+
+  chars_read = br.read(buf);
+  total_read += chars_read;
+  System.out.print(new String(buf, 0, chars_read));
+
+  br.mark(14);
+
+  br.read(buf);
+
+  br.reset();
+
+  chars_read = br.read(buf);
+  total_read += chars_read;
+  System.out.print(new String(buf, 0, chars_read));
+
+  while ((chars_read = br.read(buf)) != -1)
+    {
+      System.out.print(new String(buf, 0, chars_read));
+      total_read += chars_read;
+    }
+
+  return(total_read);
+}
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Started test of BufferedReader");
+
+  try
+    {
+      System.out.println("Test 1: Simple Read Test");
+
+      String str = "My 5th grade teacher was named Mr. Thompson.  Terry\n" +
+        "George Thompson to be precise.  He had these sideburns like\n" +
+        "Isaac Asimov's, only uglier.  One time he had a contest and said\n" +
+        "that if any kid who could lift 50lbs worth of weights on a barbell\n" +
+        "all the way over their head, he would shave it off.  Nobody could\n" +
+        "though.  One time I guess I made a comment about how stupid his\n" +
+        "sideburns worked and he not only kicked me out of class, he called\n" +
+        "my mother.  Jerk.\n";
+
+      StringReader sr = new StringReader(str);
+      BufferedReader br = new BufferedReader(sr, 15);
+
+      char[] buf = new char[12];
+      int chars_read;
+      while((chars_read = br.read(buf)) != -1)
+        System.out.print(new String(buf, 0, chars_read));
+
+      br.close();
+      System.out.println("PASSED: Simple Read Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Simple Read Test: " + e);
+    }
+
+  try
+    {
+      System.out.println("Test 2: First mark/reset Test");
+
+      String str = "Growing up in a rural area brings such delights.  One\n" +
+        "time my uncle called me up and asked me to come over and help him\n" +
+        "out with something.  Since he lived right across the field, I\n" +
+        "walked right over.  Turned out he wanted me to come down to the\n" +
+        "barn and help him castrate a calf.  Oh, that was fun.  Not.\n";
+
+      StringReader sr = new StringReader(str);
+//      BufferedReader br = new BufferedReader(sr);
+
+      int total_read = marktest(sr);
+
+      if (total_read == str.length())
+        System.out.println("PASSED: First mark/reset Test");
+      else
+        System.out.println("FAILED: First mark/reset Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: First mark/reset Test: " + e);
+    }
+   
+  try
+    {
+      System.out.println("Test 3: Second mark/reset Test");
+
+      String str = "Growing up we heated our house with a wood stove.  That\n" +
+        "thing could pump out some BTU's, let me tell you.  No matter how\n" +
+        "cold it got outside, it was always warm inside.  Of course the\n" +
+        "downside is that somebody had to chop the wood for the stove. That\n" +
+        "somebody was me.  I was slave labor.  My uncle would go back and\n" +
+        "chain saw up dead trees and I would load the wood in wagons and\n" +
+        "split it with a maul. Somehow my no account brother always seemed\n" +
+        "to get out of having to work.\n";
+
+      char[] buf = new char[str.length()];
+      str.getChars(0, str.length(), buf, 0);
+      BufferedReaderTest brt = new BufferedReaderTest(buf);
+//      BufferedReader br = new BufferedReader(car);
+
+      int total_read = marktest(brt);
+
+      if (total_read == str.length())
+        System.out.println("PASSED: Second mark/reset Test");
+      else
+        System.out.println("FAILED: Second mark/reset Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Second mark/reset Test: " + e);
+    }
+
+  System.out.println("Finished test of BufferedReader");
+} // main
+
+} // class BufferedReaderTest
+
diff --git a/libjava/classpath/test/java.io/ByteArrayInputStreamTest.java b/libjava/classpath/test/java.io/ByteArrayInputStreamTest.java
new file mode 100644
index 0000000..1b44985
--- /dev/null
+++ b/libjava/classpath/test/java.io/ByteArrayInputStreamTest.java
@@ -0,0 +1,174 @@
+/*************************************************************************
+/* ByteArrayInputStreamTest.java -- Test ByteArrayInputStream's of course
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class ByteArrayInputStreamTest extends ByteArrayInputStream
+{
+
+public
+ByteArrayInputStreamTest(byte[] b)
+{
+  super(b);
+}
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Starting test of ByteArrayInputStream.");
+  System.out.flush();
+
+  String str = "My sophomore year of college I moved out of the dorms. I\n" +
+     "moved in with three friends into a brand new townhouse in east\n" +
+     "Bloomington at 771 Woodbridge Drive.  To this day that was the\n" +
+     "nicest place I've ever lived.\n";
+
+  byte[] str_bytes = str.getBytes();  
+
+  System.out.println("Test 1: Protected Variables"); 
+
+  ByteArrayInputStreamTest bais = new ByteArrayInputStreamTest(str_bytes);
+  byte[] read_buf = new byte[12];
+
+  try 
+    {
+      bais.read(read_buf);
+      bais.mark(0);
+    
+      boolean passed = true;
+    
+      if (bais.mark != read_buf.length)
+        {
+          passed = false;
+          System.out.println("The mark variable is wrong.  Expected " +
+                             read_buf.length + " and got " + bais.mark);
+        }
+      bais.read(read_buf);
+      if (bais.pos != (read_buf.length * 2))
+        {
+          passed = false;
+          System.out.println("The pos variable is wrong.  Expected 24 and got " + 
+                             bais.pos);
+        }
+      if (bais.count != str_bytes.length)
+        {
+          passed = false;
+          System.out.println("The count variable is wrong.  Expected " +
+                             str_bytes.length + " and got " + bais.pos);
+        }
+      if (bais.buf != str_bytes)
+        {
+          passed = false;
+          System.out.println("The buf variable is not correct");
+        }
+    
+      if (passed)
+        System.out.println("PASSED: Protected Variables Test");
+      else
+        System.out.println("FAILED: Protected Variables Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Protected Variables Test: " + e);
+    }
+
+  System.out.println("Test 2: Simple Read Test");
+
+  bais = new ByteArrayInputStreamTest(str_bytes);
+
+  try
+    {
+      int bytes_read, total_read = 0;
+      while ((bytes_read = bais.read(read_buf, 0, read_buf.length)) != -1)
+        {
+          System.out.print(new String(read_buf, 0, bytes_read));
+          total_read += bytes_read;
+        }
+
+      bais.close();
+      if (total_read == str.length())
+        System.out.println("PASSED: Simple Read Test");
+      else
+        System.out.println("FAILED: Simple Read Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Simple Read Test: " + e);
+    }
+
+  System.out.println("Test 3: mark/reset/available/skip test");
+  bais = new ByteArrayInputStreamTest(str_bytes);
+
+  try
+    {
+      boolean passed = true;
+
+      bais.read(read_buf);      
+      if (bais.available() != (str_bytes.length - read_buf.length))
+        {
+          passed = false;
+          System.out.println("available() reported " + bais.available() +
+                             " and " + (str_bytes.length - read_buf.length) +
+                             " was expected");
+        }
+
+      if (bais.skip(5) != 5)
+        {
+          passed = false;
+          System.out.println("skip() didn't work");
+        }
+      if (bais.available() != (str_bytes.length - (read_buf.length + 5)))
+        {
+          passed = false;
+          System.out.println("skip() lied");
+        }
+
+      if (!bais.markSupported())
+        {
+          passed = false;
+          System.out.println("markSupported() should have returned true but returned false");
+        }
+    
+      bais.mark(0);
+      int availsave = bais.available();
+      bais.read();
+      bais.reset();
+      if (bais.available() != availsave) 
+        {
+          passed = false;
+          System.out.println("mark/reset failed to work");
+        }
+
+      if (passed)
+        System.out.println("PASSED: mark/reset/available/skip test");
+      else
+        System.out.println("FAILED: mark/reset/available/skip test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: mark/reset/available/skip test: " + e);
+    }
+
+  System.out.println("Finished ByteArrayInputStream test");
+}
+
+}
+
diff --git a/libjava/classpath/test/java.io/CharArrayReaderTest.java b/libjava/classpath/test/java.io/CharArrayReaderTest.java
new file mode 100644
index 0000000..8b652b8
--- /dev/null
+++ b/libjava/classpath/test/java.io/CharArrayReaderTest.java
@@ -0,0 +1,169 @@
+/*************************************************************************
+/* CharArrayReaderTest.java -- Test CharArrayReaders's of course
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class CharArrayReaderTest extends CharArrayReader
+{
+
+public
+CharArrayReaderTest(char[] b)
+{
+  super(b);
+}
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Starting test of CharArrayReader.");
+  System.out.flush();
+
+  String str = "In junior high, I did a lot writing.  I wrote a science\n" +
+     "fiction novel length story that was called 'The Destruction of\n" +
+     "Planet Earth'.  All the characters in the story were my friends \n" +
+     "from school because I couldn't think up any cool names.";
+
+  char[] str_chars = new char[str.length()];
+  str.getChars(0, str.length(), str_chars, 0);
+
+  System.out.println("Test 1: Protected Variables"); 
+
+  CharArrayReaderTest car = new CharArrayReaderTest(str_chars);
+  char[] read_buf = new char[12];
+
+  try 
+    {
+      car.read(read_buf);
+      car.mark(0);
+    
+      boolean passed = true;
+    
+      if (car.markedPos != read_buf.length)
+        {
+          passed = false;
+          System.out.println("The mark variable is wrong.  Expected " +
+                             read_buf.length + " and got " + car.markedPos);
+        }
+      car.read(read_buf);
+      if (car.pos != (read_buf.length * 2))
+        {
+          passed = false;
+          System.out.println("The pos variable is wrong.  Expected 24 and got " + 
+                             car.pos);
+        }
+      if (car.count != str_chars.length)
+        {
+          passed = false;
+          System.out.println("The count variable is wrong.  Expected " +
+                             str_chars.length + " and got " + car.pos);
+        }
+      if (car.buf != str_chars)
+        {
+          passed = false;
+          System.out.println("The buf variable is not correct");
+        }
+    
+      if (passed)
+        System.out.println("PASSED: Protected Variables Test");
+      else
+        System.out.println("FAILED: Protected Variables Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Protected Variables Test: " + e);
+    }
+
+  System.out.println("Test 2: Simple Read Test");
+
+  car = new CharArrayReaderTest(str_chars);
+
+  try
+    {
+      int chars_read, total_read = 0;
+      while ((chars_read = car.read(read_buf, 0, read_buf.length)) != -1)
+        {
+          System.out.print(new String(read_buf, 0, chars_read));
+          total_read += chars_read;
+        }
+
+      car.close();
+      if (total_read == str.length())
+        System.out.println("PASSED: Simple Read Test");
+      else
+        System.out.println("FAILED: Simple Read Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Simple Read Test: " + e);
+    }
+
+  System.out.println("Test 3: mark/reset/available/skip test");
+  car = new CharArrayReaderTest(str_chars);
+
+  try
+    {
+      boolean passed = true;
+
+      car.read(read_buf);      
+      if (!car.ready())
+        {
+          passed = false;
+          System.out.println("ready() reported false and should have " +
+                             "reported true.");
+        }
+
+      if (car.skip(5) != 5)
+        {
+          passed = false;
+          System.out.println("skip() didn't work");
+        }
+
+      if (!car.markSupported())
+        {
+          passed = false;
+          System.out.println("markSupported() should have returned true but returned false");
+        }
+    
+      car.mark(0);
+      int pos_save = car.pos;
+      car.read();
+      car.reset();
+      if (car.pos != pos_save) 
+        {
+          passed = false;
+          System.out.println("mark/reset failed to work");
+        }
+
+      if (passed)
+        System.out.println("PASSED: mark/reset/available/skip test");
+      else
+        System.out.println("FAILED: mark/reset/available/skip test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: mark/reset/available/skip test: " + e);
+    }
+
+  System.out.println("Finished CharArrayReader test");
+}
+
+}
+
diff --git a/libjava/classpath/test/java.io/DataInputOutputTest.java b/libjava/classpath/test/java.io/DataInputOutputTest.java
new file mode 100644
index 0000000..dd03fb0
--- /dev/null
+++ b/libjava/classpath/test/java.io/DataInputOutputTest.java
@@ -0,0 +1,174 @@
+/*************************************************************************
+/* DataInputOutputTest.java -- Tests Data{Input,Output}Stream's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+// Write some data using DataOutput and read it using DataInput.
+
+public class DataInputOutputTest
+{
+
+public static void
+runReadTest(String filename, int seq, String testname)
+{
+  try
+    {
+      System.out.println("Test " + seq + ": " + testname);
+
+      FileInputStream fis = new FileInputStream(filename);
+      DataInputStream dis = new DataInputStream(fis); 
+
+      boolean passed = true;
+
+      boolean b = dis.readBoolean();
+      if (b != true)
+        {
+          passed = false;
+          System.out.println("Failed to read boolean. Expected true and got false");
+        }
+      b = dis.readBoolean();
+      if (b != false)
+        {
+          passed = false;
+          System.out.println("Failed to read boolean. Expected false and got true");
+        }
+      byte bt = dis.readByte();
+      if (bt != 8)
+        {
+          passed = false;
+          System.out.println("Failed to read byte. Expected 8 and got "+ bt);
+        }
+      bt = dis.readByte();
+      if (bt != -122)
+        {
+          passed = false;
+          System.out.println("Failed to read byte. Expected -122 and got "+ bt);
+        }
+      char c = dis.readChar();
+      if (c != 'a')
+        {
+          passed = false;
+          System.out.println("Failed to read char. Expected a and got " + c);
+        }
+      c = dis.readChar();
+      if (c != '\uE2D2')
+        {
+          passed = false;
+          System.out.println("Failed to read char. Expected \\uE2D2 and got " + c);
+        }
+      short s = dis.readShort();
+      if (s != 32000)
+        {
+          passed = false;
+          System.out.println("Failed to read short. Expected 32000 and got " + s);
+        }
+      int i = dis.readInt();
+      if (i != 8675309)
+        {
+          passed = false;
+          System.out.println("Failed to read int. Expected 8675309 and got " + i);
+        }
+      long l = dis.readLong();
+      if (l != 696969696969L)
+        {
+          passed = false;
+          System.out.println("Failed to read long. Expected 696969696969 and got " + l);
+        }
+      float f = dis.readFloat();
+      if (!Float.toString(f).equals("3.1415"))
+        {
+          passed = false;
+          System.out.println("Failed to read float. Expected 3.1415 and got " + f);
+        }
+      double d = dis.readDouble();
+      if (d != 999999999.999)
+        {
+          passed = false;
+          System.out.println("Failed to read double.  Expected 999999999.999 and got " + d);
+        }
+      String str = dis.readUTF();
+      if (!str.equals("Testing code is such a boring activity but it must be done"))
+        {
+          passed = false;
+          System.out.println("Read unexpected String: " + str);
+        }
+      str = dis.readUTF();
+      if (!str.equals("a-->\u01FF\uA000\u6666\u0200RRR"))
+        {
+          passed = false;
+          System.out.println("Read unexpected String: " + str);
+        }
+    
+      if (passed)
+        System.out.println("PASSED: " + testname + " read test");
+      else
+        System.out.println("FAILED: " + testname + " read test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: " + testname + " read test: " + e);
+    }
+
+}
+
+public static void 
+main(String[] argv)
+{
+  System.out.println("Started test of DataInputStream and DataOutputStream");
+
+  try
+    {
+      System.out.println("Test 1: DataOutputStream write test");
+
+      FileOutputStream fos = new FileOutputStream("dataoutput.out");
+      DataOutputStream dos = new DataOutputStream(fos);
+
+      dos.writeBoolean(true);
+      dos.writeBoolean(false);
+      dos.writeByte((byte)8);
+      dos.writeByte((byte)-122);
+      dos.writeChar((char)'a');
+      dos.writeChar((char)'\uE2D2');
+      dos.writeShort((short)32000);
+      dos.writeInt((int)8675309);
+      dos.writeLong(696969696969L);
+      dos.writeFloat((float)3.1415);
+      dos.writeDouble((double)999999999.999);
+      dos.writeUTF("Testing code is such a boring activity but it must be done");
+      dos.writeUTF("a-->\u01FF\uA000\u6666\u0200RRR");
+      dos.close();
+
+      // We'll find out if this was really right later, but conditionally
+      // report success for now
+      System.out.println("PASSED: DataOutputStream write test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: DataOutputStream write test: " + e);
+    }
+
+  runReadTest("dataoutput.out", 2, "Read of JCL written data file");
+  runReadTest("dataoutput-jdk.out", 3, "Read of JDK written data file");
+
+} // main
+
+} // class DataInputOutputTest
+
diff --git a/libjava/classpath/test/java.io/FileInputStreamTest.java b/libjava/classpath/test/java.io/FileInputStreamTest.java
new file mode 100644
index 0000000..e42b93e
--- /dev/null
+++ b/libjava/classpath/test/java.io/FileInputStreamTest.java
@@ -0,0 +1,71 @@
+/*************************************************************************
+/* FileInputStreamTest.java -- Test of FileInputStream class
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class FileInputStreamTest
+{
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Starting test of FileInputStream");
+
+  System.out.println("Test 1: File Read Test");
+  try
+    {
+      FileInputStream fis = new FileInputStream("/etc/services");
+
+      System.out.println("Available: " + fis.available());
+      System.out.println("FileDescriptor: " + fis.getFD());
+      System.out.println("Dumping file. Note that first 100 bytes will be skipped");
+      fis.skip(100);
+
+      byte[] buf = new byte[32];
+      int bytes_read = 0;
+
+      while((bytes_read = fis.read(buf)) != -1)
+        System.out.print(new String(buf, 0, bytes_read));
+
+      fis.close();
+      System.out.println("PASSED: File read test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: File read test: " + e);
+    }
+
+  System.out.println("Test 2: File Not Found Test");
+  try
+    {
+      FileInputStream fis = new FileInputStream("/etc/yourmommasawhore");
+      System.out.println("FAILED: File Not Found Test");
+    }
+  catch (FileNotFoundException e)
+    {
+      System.out.println("PASSED: File Not Found Test");
+    }
+
+  System.out.println("Finished test of FileInputStream");
+}
+
+} // class FileInputStreamTest
+
diff --git a/libjava/classpath/test/java.io/FileOutputStreamTest.java b/libjava/classpath/test/java.io/FileOutputStreamTest.java
new file mode 100644
index 0000000..1917f4e
--- /dev/null
+++ b/libjava/classpath/test/java.io/FileOutputStreamTest.java
@@ -0,0 +1,81 @@
+/*************************************************************************
+/* FileOutputStreamTest.java -- Test of FileOutputStream class
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class FileOutputStreamTest
+{
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Starting test of FileOutputStream");
+
+  System.out.println("Test 1: File Write Test");
+  try
+    {
+      String s1 = "Ok, what are some of the great flame wars that we have " +
+         "had lately.  Let us see, there was emacs vs. xemacs, " +
+         "KDE vs. Gnome, and Tcl vs. Guile";
+
+      String s2 = "Operating systems I have known include: solaris, sco, " +
+         "hp-ux, linux, freebsd, winblows, os400, mvs, tpf, its, multics";
+
+      //File f = File.createTempFile("fostest", new File("/tmp"));
+      File f = new File("/tmp/000000");
+      FileOutputStream fos = new FileOutputStream(f.getPath());
+
+      fos.write(s1.getBytes(), 0, 32);
+      fos.write(s1.getBytes(), 32, s1.getBytes().length - 32);
+      fos.close();
+
+      fos = new FileOutputStream(f.getPath(), true);
+      fos.write(s2.getBytes());
+      fos.close();
+
+      if (f.length() != (s1.length() + s2.length()))
+        throw new IOException("Incorrect number of bytes written");
+
+      f.delete();
+
+      System.out.println("PASSED: File Write Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: File Write Test: " + e);
+    }
+
+  System.out.println("Test 2: Permission Denied Test");
+  try
+    {
+      FileOutputStream fos = new FileOutputStream("/etc/newtempfile");
+      System.out.println("FAILED: Permission Denied Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("PASSED: Permission Denied Test: " + e);
+    }
+
+  System.out.println("Finished test of FileOutputStream");
+}
+
+} // class FileOutputStreamTest
+
diff --git a/libjava/classpath/test/java.io/FileReaderTest.java b/libjava/classpath/test/java.io/FileReaderTest.java
new file mode 100644
index 0000000..e22cec5
--- /dev/null
+++ b/libjava/classpath/test/java.io/FileReaderTest.java
@@ -0,0 +1,69 @@
+/*************************************************************************
+/* FileReaderTest.java -- Test of FileReader and InputStreamReader classes
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class FileReaderTest
+{
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Starting test of FileReader and InputStreamReader");
+
+  System.out.println("Test 1: File Read Test");
+  try
+    {
+      FileReader fr = new FileReader("/etc/services");
+
+      System.out.println("Dumping file. Note that first 100 bytes will be skipped");
+      fr.skip(100);
+
+      char[] buf = new char[32];
+      int chars_read = 0;
+
+      while((chars_read = fr.read(buf)) != -1)
+        System.out.print(new String(buf, 0, chars_read));
+
+      fr.close();
+      System.out.println("PASSED: File read test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: File read test: " + e);
+    }
+
+  System.out.println("Test 2: File Not Found Test");
+  try
+    {
+      FileReader fr = new FileReader("/etc/yourmommasawhore");
+      System.out.println("FAILED: File Not Found Test");
+    }
+  catch (FileNotFoundException e)
+    {
+      System.out.println("PASSED: File Not Found Test");
+    }
+
+  System.out.println("Finished test of FileReader");
+}
+
+} // class FileReaderTest
+
diff --git a/libjava/classpath/test/java.io/FileTest.java b/libjava/classpath/test/java.io/FileTest.java
new file mode 100644
index 0000000..838b99e
--- /dev/null
+++ b/libjava/classpath/test/java.io/FileTest.java
@@ -0,0 +1,205 @@
+/*************************************************************************
+/* File.java -- Tests File class
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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, version 2. (see COPYING)
+/*
+/* 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class FileTest
+{
+
+static PrintWriter pw;
+
+public static void
+dumpFile(File f) throws IOException
+{
+    pw.println("Name: " + f.getName());
+    pw.println("Parent: " + f.getParent());
+    pw.println("Path: " + f.getPath());
+    pw.println("Absolute: " + f.getAbsolutePath());
+    pw.println("Canonical: " + f.getCanonicalPath());
+    pw.println("String: " + f.toString());
+}
+
+public static void
+deleteTempDirs() throws IOException
+{
+  File f = new File("tempfiletest/tmp/tmp");
+  if (!f.delete())
+    throw new IOException("Could not delete " + f.getPath());
+
+  f = new File("tempfiletest/tmp");
+  if (!f.delete())
+    throw new IOException("Could not delete " + f.getPath());
+
+  f = new File("tempfiletest/");
+  if (!f.delete())
+    throw new IOException("Could not delete " + f.getPath());
+}
+
+public static void main(String[] argv)
+{
+  System.out.println("Started test of File");
+
+  // This test writes a bunch of things to a file.  That file should
+  // be "diff-ed" against one generated when this test is run against
+  // the JDK java.io package.
+  System.out.println("Test 1: Path Operations Test");
+  try
+    {
+      pw = new PrintWriter(new OutputStreamWriter(new 
+                    FileOutputStream("./file-test.out"))); 
+
+      dumpFile(new File("/"));
+      dumpFile(new File("~arenn/foo"));
+      dumpFile(new File("foo"));
+      dumpFile(new File("../../../jcl/"));
+      dumpFile(new File("/tmp/bar.txt"));
+      dumpFile(new File("/usr"));
+      dumpFile(new File("../.."));
+      pw.flush();
+
+      File f = new File("gimme");
+      if (f.isAbsolute())
+        throw new IOException("isAbsolute() failed");
+
+      f = new File("/etc/services");
+      if (!f.isFile())
+        throw new IOException("isFile() failed");
+
+      pw.println("length: " + f.length());
+      pw.println("lastModified: " + f.lastModified());
+      pw.println("hashCode: " + f.hashCode());
+
+      f = new File("/etc/");
+      if (!f.isDirectory())
+        throw new IOException("isDirectory() failed");
+
+      pw.close();
+      System.out.println("PASSED: Conditionally Passed Path Operations Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Path Operations Test: " + e);
+      pw.close();
+    }
+
+  System.out.println("Test 2: File/Directory Manipulation Test");
+  try
+    {
+      File f = new File("filetest");
+      if (!f.exists())
+        throw new IOException("The filetest directory doesn't exist");
+
+      String[] filelist = f.list();
+      if ((filelist == null) || (filelist.length != 3))
+        throw new IOException("Failed to read directory list");
+
+      for (int i = 0; i < filelist.length; i++)
+        System.out.println(filelist[i]);
+
+      System.out.println("Listing /etc/");
+      f = new File("/etc/");
+      filelist = f.list();
+      for (int i = 0; i < filelist.length; i++)
+        System.out.println(filelist[i]);
+
+      f = new File("tempfiletest/tmp/tmp");
+      if (!f.mkdirs())
+        throw new IOException("Failed to create directories: " + f.getPath());
+
+      deleteTempDirs();
+
+      f = new File("tempfiletest/tmp/tmp/");
+      if (!f.mkdirs())
+        throw new IOException("Failed to create directories: " + f.getPath());
+
+      deleteTempDirs();
+
+      //f = File.createTempFile("tempfile#old", new File("."));
+      f = new File("000000");
+      
+      if (!f.renameTo(new File("tempfiletemp")))
+        throw new IOException("Failed to rename file: " + f.getPath());
+        
+      if (!f.delete())
+        throw new IOException("Failed to delete file: " + f.getPath());
+
+      System.out.println("PASSED: File/Directory Manipulation Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: File/Directory Manipulation Test: " + e);
+    }
+
+  System.out.println("Test 3: Read/Write Permissions Test");
+  try
+    {
+      if ((new File("/")).canWrite() == true) 
+        throw new IOException("Permission to write / unexpectedly");
+
+      if ((new File("/etc/services")).canRead() == false) 
+        throw new IOException("No permission to read /etc/services");
+
+      System.out.println("PASSED: Read/Write Permissions Test");
+    }
+  catch (IOException e) 
+    {
+      System.out.println("FAILED: Read/Write Permissions Test: " + e);
+    }
+
+  System.out.println("Test 4: Name Comparison Tests");
+  try
+    {
+      File f1, f2;
+
+      f1 = new File("/etc/");
+      f2 = new File("/etc/");
+      if (!f1.equals(f2))
+        throw new IOException(f1 + " " + f2);
+
+      f2 = new File("/etc");
+      if (f1.equals(f2))
+        throw new IOException(f1 + " " + f2);
+/*
+      f1 = new File("a");
+      f2 = new File("b");
+      if (f1.compareTo(f2) >= 0)
+        throw new IOException(f1 + " " + f2);
+
+      f1 = new File("z");
+      f2 = new File("y");
+      if (f1.compareTo(f2) <= 0)
+        throw new IOException(f1 + " " + f2);
+
+      f1 = new File("../../jcl/");
+      f2 = new File(".././.././jcl/.");
+      if (f1.compareTo(f2) != 0)
+        throw new IOException(f1 + " " + f2);
+*/
+      System.out.println("PASSED: Name Comparison Tests");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Name Comparison Tests: " + e);
+    }
+
+  System.out.println("Finished test of File");
+}
+}
+
diff --git a/libjava/classpath/test/java.io/FileWriterTest.java b/libjava/classpath/test/java.io/FileWriterTest.java
new file mode 100644
index 0000000..3602c04
--- /dev/null
+++ b/libjava/classpath/test/java.io/FileWriterTest.java
@@ -0,0 +1,85 @@
+/*************************************************************************
+/* FileWriterTest.java -- Test of FileWriter and OutputStreamWriter classes
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class FileWriterTest
+{
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Starting test of FileWriter and OutputStreamWriter");
+
+  System.out.println("Test 1: File Write Test");
+  try
+    {
+      String s1 = "Ok, what are some of the great flame wars that we have " +
+         "had lately.  Let us see, there was emacs vs. xemacs, " +
+         "KDE vs. Gnome, and Tcl vs. Guile";
+
+      String s2 = "Operating systems I have known include: solaris, sco, " +
+         "hp-ux, linux, freebsd, winblows, os400, mvs, tpf, its, multics";
+
+      //File f = File.createTempFile("fostest", new File("/tmp"));
+      File f = new File("/tmp/000001");
+      FileWriter fw = new FileWriter(f.getPath());
+
+      char buf[] = new char[s1.length()];
+      s1.getChars(0, s1.length(), buf, 0);
+      fw.write(buf, 0, 32);
+      fw.write(buf, 32, s1.getBytes().length - 32);
+      fw.close();
+
+      fw = new FileWriter(f.getPath(), true);
+      buf = new char[s2.length()];
+      s2.getChars(0, s2.length(), buf, 0);
+      fw.write(buf);
+      fw.close();
+
+      if (f.length() != (s1.length() + s2.length()))
+        throw new IOException("Incorrect number of chars written");
+
+      f.delete();
+
+      System.out.println("PASSED: File Write Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: File Write Test: " + e);
+    }
+
+  System.out.println("Test 2: Permission Denied Test");
+  try
+    {
+      FileWriter fw = new FileWriter("/etc/newtempfile");
+      System.out.println("FAILED: Permission Denied Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("PASSED: Permission Denied Test: " + e);
+    }
+
+  System.out.println("Finished test of FileWriter");
+}
+
+} // class FileWriter
+
diff --git a/libjava/classpath/test/java.io/HairyGraph.java b/libjava/classpath/test/java.io/HairyGraph.java
new file mode 100644
index 0000000..ca9a713
--- /dev/null
+++ b/libjava/classpath/test/java.io/HairyGraph.java
@@ -0,0 +1,75 @@
+
+import java.io.*;
+
+class GraphNode implements Serializable
+{
+  GraphNode( String s )
+  {
+    this.s = s;
+  }
+
+  public String toString()
+  {
+    return this.s;
+  }
+  
+  String s;
+  GraphNode a;
+  GraphNode b;
+  GraphNode c;
+  GraphNode d;
+}
+
+
+public class HairyGraph implements Serializable
+{
+  GraphNode A;
+  GraphNode B;
+  GraphNode C;
+  GraphNode D;
+  
+  HairyGraph()
+  {
+    A = new GraphNode( "A" );
+    B = new GraphNode( "B" );
+    C = new GraphNode( "C" );
+    D = new GraphNode( "D" );
+
+    A.a = B;
+    A.b = C;
+    A.c = D;
+    A.d = A;
+    
+    B.a = C;
+    B.b = D;
+    B.c = A;
+    B.d = B;
+
+    C.a = D;
+    C.b = A;
+    C.c = B;
+    C.d = C;
+    
+    D.a = A;
+    D.b = B;
+    D.c = C;
+    D.d = D;
+  }
+
+  public boolean equals( Object o )
+  {
+    HairyGraph hg = (HairyGraph)o;
+
+    return (A.a == B.d) && (A.a == C.c) && (A.a == D.b)
+      && (A.b == B.a) && (A.b == C.d) && (A.b == D.c)
+      && (A.c == B.b) && (A.c == C.a) && (A.c == D.d)
+      && (A.d == B.c) && (A.d == C.b) && (A.d == D.a);
+  }
+
+  void printOneLevel( GraphNode gn )
+  {
+    System.out.println( "GraphNode< " + gn + ": " + gn.a + ", " + gn.b
+			+ ", " + gn.c + ", " + gn.d + " >" );
+  }
+  
+}
diff --git a/libjava/classpath/test/java.io/LineNumberInputStreamTest.java b/libjava/classpath/test/java.io/LineNumberInputStreamTest.java
new file mode 100644
index 0000000..fbc726f
--- /dev/null
+++ b/libjava/classpath/test/java.io/LineNumberInputStreamTest.java
@@ -0,0 +1,119 @@
+/*************************************************************************
+/* LineNumberInputStreamTest.java -- Tests LineNumberInputStream's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class LineNumberInputStreamTest
+{
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Started test of LineNumberInputStream");
+
+  try
+    {
+      System.out.println("Test 1: First test series");
+
+      boolean passed = true;
+
+      String str = "I grew up by a small town called Laconia, Indiana\r" +
+         "which has a population of about 64 people.  But I didn't live\r\n" +
+         "in town.  I lived on a gravel road about 4 miles away\n" +
+         "They paved that road\n";
+
+      StringBufferInputStream sbis = new StringBufferInputStream(str);
+      LineNumberInputStream lnis = new LineNumberInputStream(sbis);
+
+      lnis.setLineNumber(2);
+
+      byte[] buf = new byte[32];
+      int bytes_read; 
+      while ((bytes_read = lnis.read(buf)) != -1)
+        {
+          str = new String(buf, 0, bytes_read);
+          if (str.indexOf("\r") != -1)
+            {
+              passed = false;
+              System.out.println("\nFound an unexpected \\r\n");
+            }
+            
+          System.out.print(str);
+        }
+
+      if (lnis.getLineNumber() != 6)
+        {
+          passed = false;
+          System.out.println("Line number was wrong.  Expected 6 but got " +
+            lnis.getLineNumber());
+        }
+
+      if (passed)
+        System.out.println("PASSED: First test series");
+      else
+        System.out.println("FAILED: First test series");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: First test series: " + e);
+    }
+
+  try
+    {
+      System.out.println("Test 2: Second test series");
+
+      boolean passed = true;
+
+      String str = "One time I was playing kickball on the playground\n" +
+         "in 4th grade and my friends kept talking about how they smelled\n" +
+         "pot.  I kept asking them what they smelled because I couldn't\n" +
+         "figure out how a pot could have a smell";
+
+      StringBufferInputStream sbis = new StringBufferInputStream(str);
+      LineNumberInputStream lnis = new LineNumberInputStream(sbis);
+
+      byte[] buf = new byte[32];
+      int bytes_read; 
+      while ((bytes_read = lnis.read(buf)) != -1)
+        System.out.print(new String(buf, 0, bytes_read));
+
+      if (lnis.getLineNumber() != 3)
+        {
+          passed = false;
+          System.out.println("\nLine number was wrong.  Expected 3 but got " +
+            lnis.getLineNumber());
+        }
+
+      if (passed)
+        System.out.println("PASSED: Second test series");
+      else
+        System.out.println("FAILED: Second test series");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Second test series: " + e);
+    }
+
+  System.out.println("Finished test of LineNumberInputStream");
+}
+
+} // class LineNumberInputStreamTest
+
diff --git a/libjava/classpath/test/java.io/LineNumberReaderTest.java b/libjava/classpath/test/java.io/LineNumberReaderTest.java
new file mode 100644
index 0000000..1a20b70
--- /dev/null
+++ b/libjava/classpath/test/java.io/LineNumberReaderTest.java
@@ -0,0 +1,120 @@
+/*************************************************************************
+/* LineNumberReaderTest.java -- Tests LineNumberReader's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class LineNumberReaderTest
+{
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Started test of LineNumberReader");
+
+  try
+    {
+      System.out.println("Test 1: First test series");
+
+      boolean passed = true;
+
+      String str = "In 6th grade I had a crush on this girl named Leanne\n" +
+        "Dean.  I thought she was pretty hot.  I saw her at my ten year\n" +
+        "high school reunion.  I still think she's pretty hot.  (She's\n" +
+        "married to my brother's college roommate).\n";
+
+      StringReader sbr = new StringReader(str);
+      LineNumberReader lnr = new LineNumberReader(sbr);
+
+      lnr.setLineNumber(2);
+
+      char[] buf = new char[32];
+      int chars_read; 
+      while ((chars_read = lnr.read(buf)) != -1)
+        {
+          str = new String(buf, 0, chars_read);
+          if (str.indexOf("\r") != -1)
+            {
+              passed = false;
+              System.out.println("\nFound an unexpected \\r\n");
+            }
+            
+          System.out.print(str);
+        }
+
+      if (lnr.getLineNumber() != 6)
+        {
+          passed = false;
+          System.out.println("Line number was wrong.  Expected 6 but got " +
+            lnr.getLineNumber());
+        }
+
+      if (passed)
+        System.out.println("PASSED: First test series");
+      else
+        System.out.println("FAILED: First test series");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: First test series: " + e);
+    }
+
+  try
+    {
+      System.out.println("Test 2: Second test series");
+
+      boolean passed = true;
+
+      String str = "Exiting off the expressway in Chicago is not an easy\n" +
+        "thing to do.  For example, at Fullerton you have to run a\n" +
+        "gauntlet of people selling flowers, begging for money, or trying\n" +
+        "to 'clean' your windshield for tips.";
+
+      StringReader sbr = new StringReader(str);
+      LineNumberReader lnr = new LineNumberReader(sbr);
+
+      char[] buf = new char[32];
+      int chars_read; 
+      while ((chars_read = lnr.read(buf)) != -1)
+        System.out.print(new String(buf, 0, chars_read));
+      System.out.println("");
+
+      if (lnr.getLineNumber() != 3)
+        {
+          passed = false;
+          System.out.println("\nLine number was wrong.  Expected 3 but got " +
+            lnr.getLineNumber());
+        }
+
+      if (passed)
+        System.out.println("PASSED: Second test series");
+      else
+        System.out.println("FAILED: Second test series");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Second test series: " + e);
+    }
+
+  System.out.println("Finished test of LineNumberReader");
+}
+
+} // class LineNumberReaderTest
+
diff --git a/libjava/classpath/test/java.io/Makefile.am b/libjava/classpath/test/java.io/Makefile.am
new file mode 100644
index 0000000..923e378
--- /dev/null
+++ b/libjava/classpath/test/java.io/Makefile.am
@@ -0,0 +1,9 @@
+## Input file for automake to generate the Makefile.in used by configure
+
+JAVAROOT = .
+
+check_JAVA = BufferedInputStreamTest.java ByteArrayInputStreamTest.java \
+             DataInputOutputTest.java LineNumberInputStreamTest.java \
+             PushbackInputStreamTest.java SequenceInputStreamTest.java \
+             StringBufferInputStreamTest.java
+
diff --git a/libjava/classpath/test/java.io/OOSCallDefault.java b/libjava/classpath/test/java.io/OOSCallDefault.java
new file mode 100644
index 0000000..c0465c1
--- /dev/null
+++ b/libjava/classpath/test/java.io/OOSCallDefault.java
@@ -0,0 +1,39 @@
+
+import java.io.*;
+
+public class OOSCallDefault implements Serializable
+{
+  int x;
+  double y;
+  transient String s;
+
+  OOSCallDefault( int X, double Y, String S )
+  {
+    x = X;
+    y = Y;
+    s = S;
+  }
+
+  public boolean equals( Object o )
+  {
+    OOSCallDefault oo = (OOSCallDefault)o;
+    return oo.x == x
+      && oo.y == y
+      && oo.s.equals( s );
+  }
+  
+  private void writeObject( ObjectOutputStream oos ) throws IOException
+  {
+    oos.writeObject( s );
+    oos.defaultWriteObject();
+    oos.writeObject( s );
+  }
+
+  private void readObject( ObjectInputStream ois )
+    throws ClassNotFoundException, IOException
+  {
+    ois.readObject();
+    ois.defaultReadObject();
+    s = (String)ois.readObject();
+  }
+}
diff --git a/libjava/classpath/test/java.io/OOSExtern.java b/libjava/classpath/test/java.io/OOSExtern.java
new file mode 100644
index 0000000..7394c5b
--- /dev/null
+++ b/libjava/classpath/test/java.io/OOSExtern.java
@@ -0,0 +1,37 @@
+
+import java.io.*;
+
+public class OOSExtern extends OOSNoCallDefault implements Externalizable
+{
+  public OOSExtern()
+  {}
+
+  OOSExtern( int X, String S, boolean B )
+  {
+    super( X, S, B );
+  }
+
+  public void writeExternal( ObjectOutput oo ) throws IOException
+  {
+    oo.writeInt( super.x );
+    oo.writeObject( super.s );
+    oo.writeBoolean( super.b );
+  }
+  
+  public void readExternal( ObjectInput oi )
+    throws ClassNotFoundException, IOException
+  {
+    super.x = oi.readInt();
+    super.s = (String)oi.readObject();
+    super.b = oi.readBoolean();
+  }
+
+  public boolean equals( Object o )
+  {
+    OOSExtern e = (OOSExtern)o;
+    return e.x == super.x
+      && e.s.equals( super.s )
+      && e.b == super.b;
+  }
+  
+}
diff --git a/libjava/classpath/test/java.io/OOSNoCallDefault.java b/libjava/classpath/test/java.io/OOSNoCallDefault.java
new file mode 100644
index 0000000..1e41754
--- /dev/null
+++ b/libjava/classpath/test/java.io/OOSNoCallDefault.java
@@ -0,0 +1,42 @@
+
+import java.io.*;
+
+public class OOSNoCallDefault implements Serializable
+{
+  int x;
+  String s;
+  boolean b;
+  
+  OOSNoCallDefault()
+  {}
+
+  OOSNoCallDefault( int X, String S, boolean B )
+  {
+    x = X;
+    s = S;
+    b = B;
+  }
+
+  public boolean equals( Object o )
+  {
+    OOSNoCallDefault oo = (OOSNoCallDefault)o;
+    return oo.x == x
+      && oo.b == b
+      && oo.s.equals( s );
+  }
+  
+  private void writeObject( ObjectOutputStream oos ) throws IOException
+  {
+    oos.writeInt( x );
+    oos.writeObject( s );
+    oos.writeBoolean( b );
+  }
+
+  private void readObject( ObjectInputStream ois )
+    throws ClassNotFoundException, IOException
+  {
+    x = ois.readInt();
+    s = (String)ois.readObject();
+    b = ois.readBoolean();
+  }
+}
diff --git a/libjava/classpath/test/java.io/ObjectInputStreamTest.java b/libjava/classpath/test/java.io/ObjectInputStreamTest.java
new file mode 100644
index 0000000..af236dd
--- /dev/null
+++ b/libjava/classpath/test/java.io/ObjectInputStreamTest.java
@@ -0,0 +1,65 @@
+/*************************************************************************
+/* ObjectInputStreamTest.java -- Tests ObjectInputStream class
+/*
+/* Copyright (c) 1998 by Free Software Foundation, Inc.
+/*
+/* 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, version 2. (see COPYING)
+/*
+/* 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.FileInputStream;
+import java.io.ObjectInputStream;
+
+public class ObjectInputStreamTest extends Test
+{
+  public static void testSerial( Object obj, String filename )
+  {
+    try
+    {
+      ObjectInputStream ois =
+	new ObjectInputStream( new FileInputStream( filename ) );
+
+      Object read_object = ois.readObject();
+      ois.close();
+
+      if( read_object.equals( obj ) )
+	pass();
+      else
+	fail();
+    }
+    catch( Exception e )
+    {
+      e.printStackTrace();
+      fail();
+    }
+  }
+  
+  
+  public static void main( String[] args )
+  {
+    testSerial( new OOSCallDefault( 1, 3.14, "test" ),
+		"calldefault.data" );
+    System.out.println( "Object calling defaultWriteObject()" );
+
+    testSerial( new OOSNoCallDefault( 17, "no\ndefault", false ),
+		"nocalldefault.data" );
+    System.out.println( "Object not calling defaultWriteObject()" );
+
+    testSerial( new OOSExtern( -1, "", true ), "external.data" );
+    System.out.println( "Externalizable class" );
+
+    testSerial( new HairyGraph(), "graph.data" );
+    System.out.println( "Graph of objects with circular references" );
+  }
+
+}
diff --git a/libjava/classpath/test/java.io/ObjectOutputStreamTest.java b/libjava/classpath/test/java.io/ObjectOutputStreamTest.java
new file mode 100644
index 0000000..62f60dc
--- /dev/null
+++ b/libjava/classpath/test/java.io/ObjectOutputStreamTest.java
@@ -0,0 +1,157 @@
+/*************************************************************************
+/* ObjectOutputStreamTest.java -- Tests ObjectOutputStream class
+/*
+/* Copyright (c) 1998 by Free Software Foundation, Inc.
+/*
+/* 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, version 2. (see COPYING)
+/*
+/* 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.ByteArrayOutputStream;
+import java.io.Externalizable;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInput;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutput;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
+
+public class ObjectOutputStreamTest extends Test
+{
+  public static void testSerial( Object obj, String filename )
+  {
+    if( writeMode )
+    {
+      try
+      {
+	ObjectOutputStream oos =
+	  new ObjectOutputStream( new FileOutputStream( filename ) );
+	oos.writeObject( obj );
+	oos.close();
+      }
+      catch( ObjectStreamException e )
+      {}
+      catch( IOException ioe )
+      {
+	ioe.printStackTrace();
+      }
+    }
+    else
+    { 
+      ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+
+      try
+      {
+	ObjectOutputStream oos = new ObjectOutputStream( bytes );
+	oos.writeObject( obj );
+	oos.close();
+      }
+      catch( ObjectStreamException e )
+      {}
+      catch( IOException ioe )
+      {
+	fail();
+	return;
+      }
+    
+      byte[] jcl_bytes = bytes.toByteArray();
+      int data;
+      
+      FileInputStream jdk_file;
+      try
+      {
+	jdk_file = new FileInputStream( filename );
+
+	for( int i=0; i < jcl_bytes.length; i++ )
+	{
+	  data = jdk_file.read();
+	  
+	  if( data == -1 )
+	  {
+	    fail();
+	    return;
+	  }
+	  
+	  if( (byte)data != jcl_bytes[i] )
+	  {
+	    fail();
+	    return;
+	  }
+	}
+
+	if( jdk_file.read() != -1 )
+	{
+	  fail();
+	  return;
+	}
+      }
+      catch( IOException e )
+      {
+	error();
+	return;
+      }
+    
+      pass();
+    }
+  }
+  
+  
+  public static void main( String[] args )
+  {
+    writeMode = (args.length != 0);
+
+    testSerial( new OOSNotSerial(), "notserial.data" );
+    System.out.println( "Non-serializable class" );
+
+    testSerial( new OOSBadField( 1, 2, new OOSNotSerial() ),
+		"notserialfield.data" );
+    System.out.println( "Object with non-serializable field" );
+
+    testSerial( new OOSCallDefault( 1, 3.14, "test" ),
+		"calldefault.data" );
+    System.out.println( "Object calling defaultWriteObject()" );
+
+    testSerial( new OOSNoCallDefault( 17, "no\ndefault", false ),
+		"nocalldefault.data" );
+    System.out.println( "Object not calling defaultWriteObject()" );
+
+    testSerial( new OOSExtern( -1, "", true ), "external.data" );
+    System.out.println( "Externalizable class" );
+
+    testSerial( new HairyGraph(), "graph.data" );
+    System.out.println( "Graph of objects with circular references" );
+  }
+
+  
+  public static boolean writeMode;
+}
+
+
+class OOSNotSerial {}
+
+class OOSBadField implements Serializable
+{
+  int x;
+  int y;
+  OOSNotSerial o;
+
+  OOSBadField( int X, int Y, OOSNotSerial O )
+  {
+    x = X;
+    y = Y;
+    o = O;
+  }
+}
diff --git a/libjava/classpath/test/java.io/ObjectStreamClassTest.java b/libjava/classpath/test/java.io/ObjectStreamClassTest.java
new file mode 100644
index 0000000..7002bf7
--- /dev/null
+++ b/libjava/classpath/test/java.io/ObjectStreamClassTest.java
@@ -0,0 +1,282 @@
+/*************************************************************************
+/* ObjectStreamClassTest.java -- Tests ObjectStreamClass class
+/*
+/* Copyright (c) 1998 by Free Software Foundation, Inc.
+/*
+/* 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, version 2. (see COPYING)
+/*
+/* 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.Externalizable;
+import java.io.ObjectInput;
+import java.io.ObjectOutput;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamClass;
+import java.io.Serializable;
+import java.util.Hashtable;
+import java.util.Vector;
+
+public class ObjectStreamClassTest
+{
+  public static void pass()
+  {
+    System.out.print( "PASSED: " );
+  }
+  
+  public static void fail()
+  {
+    System.out.print( "FAILED: " );
+  }
+
+  public static void pass( boolean exp_pass )
+  {
+    if( exp_pass )
+      pass();
+    else
+      System.out.print( "XPASSED: " );
+  }
+  
+  public static void fail( boolean exp_pass )
+  {
+    if( exp_pass )
+      fail();
+    else
+      System.out.print( "XFAIL: " );
+  }
+
+  public static void testLookup( Class cl, boolean non_null )
+  {
+    if( non_null == (ObjectStreamClass.lookup( cl ) != null) )
+      pass();
+    else
+      fail();
+
+    System.out.println( "lookup() for " + cl );
+  }
+
+  public static void testGetName( Class cl, String name )
+  {
+    if( ObjectStreamClass.lookup( cl ).getName().equals( name ) )
+      pass();
+    else
+      fail();
+    
+    System.out.println( "getName() for " + cl );
+  }
+
+  public static void testForClass( Class cl, Class clazz )
+  {
+    if( ObjectStreamClass.lookup( cl ).forClass() == clazz )
+      pass();
+    else
+      fail();
+    
+    System.out.println( "forClass() for " + cl );
+  }
+
+  public static void testSUID( Class cl, long suid )
+  {
+    testSUID( cl, suid, true );
+  }
+
+  public static void testSUID( Class cl, long suid, boolean exp_pass )
+  {
+    if( ObjectStreamClass.lookup( cl ).getSerialVersionUID() == suid )
+      pass( exp_pass );
+    else
+      fail( exp_pass );
+    
+    System.out.println( "getSerialVersionUID() for " + cl );
+  }
+
+  public static void testHasWrite( Class cl, boolean has_write )
+  {
+    if( ObjectStreamClass.lookup( cl ).hasWriteMethod() == has_write )
+      pass();
+    else
+      fail();
+    
+    System.out.println( "hasWriteMethod() for " + cl );
+  }
+
+  public static void testIsSerial( Class cl, boolean is_serial )
+  {
+    if( ObjectStreamClass.lookup( cl ).isSerializable() == is_serial )
+      pass();
+    else
+      fail();
+    
+    System.out.println( "isSerializable() for " + cl );
+  }
+
+  public static void testIsExtern( Class cl, boolean is_extern )
+  {
+    if( ObjectStreamClass.lookup( cl ).isExternalizable() == is_extern )
+      pass();
+    else
+      fail();
+    
+    System.out.println( "isExternalizable() for " + cl );
+  }
+
+  public static void main( String[] args )
+  {
+    try
+    {
+      // lookup
+      testLookup( Serial.class, true );
+      testLookup( NotSerial.class, false );
+
+      // getName
+      testGetName( java.lang.String.class, "java.lang.String" );
+      testGetName( java.util.Hashtable.class, "java.util.Hashtable" );
+      
+      // forClass
+      testForClass( java.lang.String.class, java.lang.String.class );
+      testForClass( java.util.Vector.class, (new Vector()).getClass() );      
+      
+      // getSerialVersionUID
+      testSUID( A.class, 1577839372146469075L );
+      testSUID( B.class, -7069956958769787679L );
+
+      // NOTE: this fails for JDK 1.1.5v5 on linux because a non-null
+      // jmethodID is returned from
+      // GetStaticMethodID( env, C, "<clinit>", "()V" )
+      // even though class C does not have a class initializer.
+      // The JDK's serialver tool does not have this problem somehow.
+      // I have not tested this on other platforms.
+      testSUID( C.class, 7441756018870420732L, false );
+
+      testSUID( Defined.class, 17 );
+      testSUID( DefinedNotStatic.class, 8797806279193632512L );
+      testSUID( DefinedNotFinal.class, -1014973327673071657L );
+
+      // hasWriteMethod
+      testHasWrite( Serial.class, false );
+      testHasWrite( HasWrite.class, true );
+      testHasWrite( InherWrite.class, false );
+      testHasWrite( PubWrite.class, false );
+      testHasWrite( StaticWrite.class, false );
+      testHasWrite( ReturnWrite.class, false );
+
+      // isSerializable
+      testIsSerial( Serial.class, true );
+      testIsSerial( Extern.class, false );
+      testIsSerial( InherSerial.class, true );
+      testIsSerial( InherExtern.class, false );
+
+      // isExternalizable
+      testIsExtern( Serial.class, false );
+      testIsExtern( Extern.class, true );
+      testIsExtern( InherSerial.class, false );
+      testIsExtern( InherExtern.class, true );
+    }
+    catch( Exception e )
+    {
+      e.printStackTrace();
+    }
+  }
+}
+
+class NotSerial {}
+
+class A implements Serializable
+{
+  int b;
+  int a;
+
+  public int f() { return 0; }
+  float g() { return 3; }
+
+  private float c;
+}
+  
+abstract class B extends A
+{
+  private B( int[] ar ) {}
+  public B() {}
+  public static void foo() {}
+  public abstract void absfoo();
+  
+  private static String s;
+  public int[] a;
+
+  static
+  {
+    s = "hello";
+  }
+}
+
+class C extends B implements Cloneable, Externalizable
+{
+  public void absfoo() {}
+  public void readExternal( ObjectInput i ) {}
+  public void writeExternal( ObjectOutput o ) {}
+}
+
+
+class Defined implements Serializable
+{
+  static final long serialVersionUID = 17;
+}
+
+class DefinedNotStatic implements Serializable
+{
+  final long serialVersionUID = 17;
+}
+
+class DefinedNotFinal implements Serializable
+{
+  static long serialVersionUID = 17;
+}
+
+class HasWrite implements Serializable
+{
+  private void writeObject( ObjectOutputStream o ) {}
+}
+
+class InherWrite extends HasWrite {}
+
+class PubWrite implements Serializable
+{
+  public void writeObject( ObjectOutputStream o ) {}
+}
+
+class StaticWrite implements Serializable
+{
+  private static void writeObject( ObjectOutputStream o ) {}
+}
+
+class ReturnWrite implements Serializable
+{
+  private int writeObject( ObjectOutputStream o ) 
+  {
+    return -1;
+  }
+}
+
+
+class Serial implements Serializable {}
+
+class Extern implements Externalizable
+{
+  public void readExternal( ObjectInput i )
+  {}
+
+  public void writeExternal( ObjectOutput o )
+  {}
+}
+
+class InherExtern extends Extern implements Serializable {}
+
+class InherSerial extends Serial {}
diff --git a/libjava/classpath/test/java.io/PipedReaderWriterTest.java b/libjava/classpath/test/java.io/PipedReaderWriterTest.java
new file mode 100644
index 0000000..827598e
--- /dev/null
+++ b/libjava/classpath/test/java.io/PipedReaderWriterTest.java
@@ -0,0 +1,136 @@
+/*************************************************************************
+/* PipedReaderWriterTest.java -- Tests Piped{Reader,Writers}'s
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class PipedReaderWriterTest
+{
+
+public static void
+main(String[] argv) throws InterruptedException
+{
+  // Set up a reasonable buffer size for this test if one is not already
+  // specified
+  String prop = System.getProperty("gnu.java.io.pipe_size");
+//  if (prop == null)
+//    System.setProperty("gnu.java.io.pipe_size", "32");
+
+  try
+    {
+      System.out.println("Started test of PipedReader and PipedWriter");
+
+      System.out.println("Test 1: Basic pipe test");
+
+      // Set up the thread to write
+      PipedTestWriter ptw = new PipedTestWriter();
+      String str = ptw.getStr();
+      PipedWriter pw = ptw.getWriter();
+
+      // Now set up our reader
+      PipedReader pr = new PipedReader();
+      pr.connect(pw); 
+      new Thread(ptw).start();
+
+      char[] buf = new char[12];
+      int chars_read, total_read = 0;
+      while((chars_read = pr.read(buf)) != -1)
+        {
+          System.out.print(new String(buf, 0, chars_read));
+          System.out.flush();
+	  Thread.sleep(10); // A short delay
+          total_read += chars_read;
+        }
+
+      if (total_read == str.length())
+        System.out.println("PASSED: Basic pipe test");
+      else
+        System.out.println("FAILED: Basic pipe test");
+    }
+  catch (IOException e) 
+    {
+      System.out.println("FAILED: Basic pipe test: " + e);
+    }
+}
+
+} // class PipedReaderWriterTest
+
+class PipedTestWriter implements Runnable
+{
+
+String str;
+StringReader sbr;
+PipedWriter out;
+
+public
+PipedTestWriter()
+{
+  str = "In college, there was a tradition going for a while that people\n" +
+    "would get together and hang out at Showalter Fountain - in the center\n" +
+    "of Indiana University's campus - around midnight.  It was mostly folks\n" +
+    "from the computer lab and just people who liked to use the Forum\n" +
+    "bbs system on the VAX.  IU pulled the plug on the Forum after I left\n" +
+    "despite its huge popularity.  Now they claim they are just giving\n" +
+    "students what they want by cutting deals to make the campus all\n" +
+    "Microsoft.\n";
+
+  sbr = new StringReader(str);
+
+  out = new PipedWriter();
+}
+
+public PipedWriter
+getWriter()
+{
+  return(out);
+}
+
+public String
+getStr()
+{
+  return(str);
+}
+
+public void
+run() 
+{
+  char[] buf = new char[32];
+
+  int chars_read;
+
+  try
+    {
+      int b = sbr.read();
+      out.write(b);
+
+      while ((chars_read = sbr.read(buf)) != -1)
+        out.write(buf, 0, chars_read);
+
+      out.close();
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Basic pipe test: " + e);
+    }
+
+}
+
+} // PipedTestWriter
+
diff --git a/libjava/classpath/test/java.io/PipedStreamTest.java b/libjava/classpath/test/java.io/PipedStreamTest.java
new file mode 100644
index 0000000..d30bfa3
--- /dev/null
+++ b/libjava/classpath/test/java.io/PipedStreamTest.java
@@ -0,0 +1,134 @@
+/*************************************************************************
+/* PipedStreamTest.java -- Tests Piped{Input,Output}Stream's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class PipedStreamTest
+{
+
+public static void
+main(String[] argv) throws InterruptedException
+{
+  // Set up a reasonable buffer size for this test if one is not already
+  // specified
+  String prop = System.getProperty("gnu.java.io.pipe_size");
+//  if (prop == null)
+//    System.setProperty("gnu.java.io.pipe_size", "32");
+
+  try
+    {
+      System.out.println("Started test of PipedInputStream and " +
+                         "PipedOutputStream");
+
+      System.out.println("Test 1: Basic piped stream test");
+
+      // Set up the thread to write
+      PipedStreamTestWriter pstw = new PipedStreamTestWriter();
+      String str = pstw.getStr();
+      PipedOutputStream pos = pstw.getStream();
+
+      // Now set up our reader
+      PipedInputStream pis = new PipedInputStream();
+      pis.connect(pos); 
+      new Thread(pstw).start();
+
+      byte[] buf = new byte[12];
+      int bytes_read, total_read = 0;
+      while((bytes_read = pis.read(buf)) != -1)
+        {
+          System.out.print(new String(buf, 0, bytes_read));
+          System.out.flush();
+          Thread.sleep(10); // A short delay
+          total_read += bytes_read;
+        }
+
+      if (total_read == str.length())
+        System.out.println("PASSED: Basic piped stream test");
+      else
+        System.out.println("FAILED: Basic piped stream test");
+    }
+  catch (IOException e) 
+    {
+      System.out.println("FAILED: Basic piped stream test: " + e);
+    }
+}
+
+} // class PipedStreamTest
+
+class PipedStreamTestWriter implements Runnable
+{
+
+String str;
+StringBufferInputStream sbis;
+PipedOutputStream out;
+
+public
+PipedStreamTestWriter()
+{
+  str = "I went to work for Andersen Consulting after I graduated\n" +
+     "from college.  They sent me to their training facility in St. Charles,\n" +
+     "Illinois and tried to teach me COBOL.  I didn't want to learn it.\n" +
+     "The instructors said I had a bad attitude and I got a green sheet\n" +
+     "which is a nasty note in your file saying what a jerk you are.\n";
+
+  sbis = new StringBufferInputStream(str);
+
+  out = new PipedOutputStream();
+}
+
+public PipedOutputStream
+getStream()
+{
+  return(out);
+}
+
+public String
+getStr()
+{
+  return(str);
+}
+
+public void
+run() 
+{
+  byte[] buf = new byte[32];
+
+  int bytes_read;
+
+  try
+    {
+      int b = sbis.read();
+      out.write(b);
+
+      while ((bytes_read = sbis.read(buf)) != -1)
+        out.write(buf, 0, bytes_read);
+
+      out.close();
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Basic piped stream test: " + e);
+    }
+
+}
+
+}
+
diff --git a/libjava/classpath/test/java.io/PrintStreamTest.java b/libjava/classpath/test/java.io/PrintStreamTest.java
new file mode 100644
index 0000000..bd4dde5
--- /dev/null
+++ b/libjava/classpath/test/java.io/PrintStreamTest.java
@@ -0,0 +1,83 @@
+/*************************************************************************
+/* PrintStreamTest.java -- Test of the PrintStream class
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class PrintStreamTest
+{
+
+public static void main(String[] argv) throws IOException
+{
+  System.out.println("Started test of PrintStream");
+  System.out.println("Test 1: Printing Test");
+
+  char[] carray = { 'h', 'i' };
+  byte[] barray = { 'b', 'y', 'e' };
+
+  PrintStream ps = new PrintStream(new FileOutputStream("printstream.out"));
+  ps.print(true);
+  ps.print('|');
+  ps.print(false);
+  ps.print('|');
+  ps.print('A');
+  ps.print('|');
+  ps.flush();
+  ps.print(0xFFFFF);
+  ps.print('|');
+  ps.print(0xFFFFFFFFFFL);
+  ps.print('|');
+  ps.print(3.141592);
+  ps.print('|');
+  ps.print((double)99999999999.9999);
+  ps.print('|');
+  ps.print(carray);
+  ps.print('|');
+  ps.print("This is a string"); 
+  ps.print('|');
+  ps.print(ps);
+  ps.println();
+  ps.println(true);
+  ps.println(false);
+  ps.println('A');
+  ps.flush();
+  ps.println(0xFFFFF);
+  ps.println(0xFFFFFFFFFFL);
+  ps.println(3.141592);
+  ps.println((double)99999999999.9999);
+  ps.println(carray);
+  ps.println("This is a string"); 
+  ps.println(ps);
+  ps.write('B');
+  ps.println();
+  ps.write(barray, 0, barray.length);
+  ps.println();
+  ps.close();
+
+  if (ps.checkError())
+    System.out.println("FAILED: Printing Test");
+  else
+    System.out.println("PASSED: Printing Test");
+ 
+  System.out.println("PASSED: Test of PrintStream");
+}
+
+} // class PrintStreamTest
+
diff --git a/libjava/classpath/test/java.io/PrintWriterTest.java b/libjava/classpath/test/java.io/PrintWriterTest.java
new file mode 100644
index 0000000..d466f44
--- /dev/null
+++ b/libjava/classpath/test/java.io/PrintWriterTest.java
@@ -0,0 +1,83 @@
+/*************************************************************************
+/* PrintWriterTest.java -- Test of the PrintWriter class
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class PrintWriterTest
+{
+
+public static void main(String[] argv) throws IOException
+{
+  System.out.println("Started test of PrintWriter");
+  System.out.println("Test 1: Printing Test");
+
+  char[] carray = { 'h', 'i' };
+  char[] carray2 = { 'b', 'y', 'e' };
+
+  PrintWriter pw = new PrintWriter(new FileWriter("printwriter.out"));
+  pw.print(true);
+  pw.print('|');
+  pw.print(false);
+  pw.print('|');
+  pw.print('A');
+  pw.print('|');
+  pw.flush();
+  pw.print(0xFFFFF);
+  pw.print('|');
+  pw.print(0xFFFFFFFFFFL);
+  pw.print('|');
+  pw.print(3.141592);
+  pw.print('|');
+  pw.print((double)99999999999.9999);
+  pw.print('|');
+  pw.print(carray);
+  pw.print('|');
+  pw.print("This is a string"); 
+  pw.print('|');
+  pw.print(pw);
+  pw.println();
+  pw.println(true);
+  pw.println(false);
+  pw.println('A');
+  pw.flush();
+  pw.println(0xFFFFF);
+  pw.println(0xFFFFFFFFFFL);
+  pw.println(3.141592);
+  pw.println((double)99999999999.9999);
+  pw.println(carray);
+  pw.println("This is a string"); 
+  pw.println(pw);
+  pw.write('B');
+  pw.println();
+  pw.write(carray2, 0, carray2.length);
+  pw.println();
+  pw.close();
+
+  if (pw.checkError())
+    System.out.println("FAILED: Printing Test");
+  else
+    System.out.println("PASSED: Printing Test");
+ 
+  System.out.println("PASSED: Test of PrintWriter");
+}
+
+} // class PrintWriterTest
+
diff --git a/libjava/classpath/test/java.io/PushbackInputStreamTest.java b/libjava/classpath/test/java.io/PushbackInputStreamTest.java
new file mode 100644
index 0000000..9d67623
--- /dev/null
+++ b/libjava/classpath/test/java.io/PushbackInputStreamTest.java
@@ -0,0 +1,133 @@
+/*************************************************************************
+/* PushbackInputStreamTest.java -- Tests PushbackInputStream's of course
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class PushbackInputStreamTest extends PushbackInputStream
+{
+
+public
+PushbackInputStreamTest(InputStream is, int size)
+{
+  super(is, size);
+}
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Started test of PushbackInputStream");
+
+  String str = "Once when I was in fourth grade, my friend Lloyd\n" +
+    "Saltsgaver and I got in trouble for kicking a bunch of\n" +
+    "Kindergartners off the horse swings so we could play a game\n" +
+    "of 'road hog'\n";
+
+  System.out.println("Test 1: Protected Variables Test");
+  {
+  PushbackInputStreamTest pist = new PushbackInputStreamTest(
+    new StringBufferInputStream(str), 15);
+
+  boolean passed = true;
+  if (pist.pos != pist.buf.length)
+    {
+       passed = false;
+       System.out.println("The pos variable is wrong.  Expected " +
+             pist.buf.length + " but got " + pist.pos);
+    }
+  if (pist.buf.length != 15)
+    {
+       passed = false;
+       System.out.println("The buf.length is wrong.  Expected 15" +
+             " but got " + pist.buf.length);
+    }
+
+   if (passed)
+     System.out.println("PASSED: Protected Variables Test");
+   else
+     System.out.println("FAILED: Protected Variables Test");
+  }
+  
+  System.out.println("Test 2: Basic Unread Tests");
+  try
+    {
+      PushbackInputStreamTest pist = new PushbackInputStreamTest(
+        new StringBufferInputStream(str), 15);
+
+      byte[] read_buf1 = new byte[12]; 
+      byte[] read_buf2 = new byte[12]; 
+      
+      boolean passed = true;
+
+      pist.read(read_buf1); 
+      pist.unread(read_buf1);
+      pist.read(read_buf2);
+      
+      for (int i = 0; i < read_buf1.length; i++)
+        {
+          if (read_buf1[i] != read_buf2[i])
+            passed = false;
+        }
+
+      pist.unread(read_buf2, 1, read_buf2.length - 1);      
+      pist.unread(read_buf2[0]);
+
+      int bytes_read, total_read = 0;
+      while ((bytes_read = pist.read(read_buf1)) != -1)
+        {
+          System.out.print(new String(read_buf1, 0, bytes_read));
+          total_read += bytes_read;
+        }
+
+      if (total_read != str.length())
+        passed = false;
+
+      if (passed)
+        System.out.println("PASSED: Basic Unread Tests");
+      else
+        System.out.println("FAILED: Basic Unread Tests");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Basic Unread Tests: " + e);
+    }
+
+  System.out.println("Test 3: Buffer Overflow Test");
+  try
+    {
+      PushbackInputStreamTest pist = new PushbackInputStreamTest(
+        new StringBufferInputStream(str), 10);
+
+      byte[] read_buf = new byte[12]; 
+
+      pist.read(read_buf);
+      pist.unread(read_buf);
+      System.out.println("FAILED: Buffer Overflow Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("PASSED: Buffer Overflow Test: " + e);
+    }
+  
+  System.out.println("Finished tests of PushbackInputStream");
+} // main
+
+} // class PushbackInputStreamTest
+
diff --git a/libjava/classpath/test/java.io/PushbackReaderTest.java b/libjava/classpath/test/java.io/PushbackReaderTest.java
new file mode 100644
index 0000000..3378306
--- /dev/null
+++ b/libjava/classpath/test/java.io/PushbackReaderTest.java
@@ -0,0 +1,115 @@
+/*************************************************************************
+/* PushbackReaderTest.java -- Tests PushbackReader's of course
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class PushbackReaderTest extends PushbackReader
+{
+
+public
+PushbackReaderTest(Reader r, int size)
+{
+  super(r, size);
+}
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Started test of PushbackReader");
+
+  String str = "I used to idolize my older cousin Kurt.  I wanted to be\n" +
+    "just like him when I was a kid.  (Now we are as different as night\n" +
+    "and day - but still like each other).  One thing he did for a while\n" +
+    "was set traps for foxes thinking he would make money off sellnig furs.\n" +
+    "Now I never saw a fox in all my years of Southern Indiana.  That\n" +
+    "didn't deter us.  One time we went out in the middle of winter to\n" +
+    "check our traps.  It was freezing and I stepped onto a frozen over\n" +
+    "stream. The ice broke and I got my foot soak.  Despite the fact that\n" +
+    "it made me look like a girl, I turned around and went straight home.\n" +
+    "Good thing too since I couldn't even feel my foot by the time I got\n" +
+    "there.\n";
+
+  System.out.println("Test 1: Basic Unread Tests");
+  try
+    {
+      PushbackReaderTest prt = new PushbackReaderTest(
+        new StringReader(str), 15);
+
+      char[] read_buf1 = new char[12]; 
+      char[] read_buf2 = new char[12]; 
+      
+      boolean passed = true;
+
+      prt.read(read_buf1); 
+      prt.unread(read_buf1);
+      prt.read(read_buf2);
+      
+      for (int i = 0; i < read_buf1.length; i++)
+        {
+          if (read_buf1[i] != read_buf2[i])
+            passed = false;
+        }
+
+      prt.unread(read_buf2, 1, read_buf2.length - 1);      
+      prt.unread(read_buf2[0]);
+
+      int chars_read, total_read = 0;
+      while ((chars_read = prt.read(read_buf1)) != -1)
+        {
+          System.out.print(new String(read_buf1, 0, chars_read));
+          total_read += chars_read;
+        }
+
+      if (total_read != str.length())
+        passed = false;
+
+      if (passed)
+        System.out.println("PASSED: Basic Unread Tests");
+      else
+        System.out.println("FAILED: Basic Unread Tests");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Basic Unread Tests: " + e);
+    }
+
+  System.out.println("Test 3: Buffer Overflow Test");
+  try
+    {
+      PushbackReaderTest prt = new PushbackReaderTest(
+        new StringReader(str), 10);
+
+      char[] read_buf = new char[12]; 
+
+      prt.read(read_buf);
+      prt.unread(read_buf);
+      System.out.println("FAILED: Buffer Overflow Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("PASSED: Buffer Overflow Test: " + e);
+    }
+  
+  System.out.println("Finished tests of PushbackReader");
+} // main
+
+} // class PushbackReaderTest
+
diff --git a/libjava/classpath/test/java.io/README b/libjava/classpath/test/java.io/README
new file mode 100644
index 0000000..d5ab4f5
--- /dev/null
+++ b/libjava/classpath/test/java.io/README
@@ -0,0 +1,12 @@
+This directory contains tests for the java.io package.  Some important
+things to note:
+
+-- The file dataoutput-jdk.out is the results of the DataInputOutputTest
+   test run through the JDK.  It is needed for the real test so please
+   don't delete it.
+
+-- The directory filetest and its contents are used for the FileTest test.
+   If that test bombs in the middle, it may leave the directory renamed
+   to something else.  In that case, you will need to rename it back
+   manually to re-run the test after making fixes.
+
diff --git a/libjava/classpath/test/java.io/RandomAccessFileTest.java b/libjava/classpath/test/java.io/RandomAccessFileTest.java
new file mode 100644
index 0000000..8ee53b7
--- /dev/null
+++ b/libjava/classpath/test/java.io/RandomAccessFileTest.java
@@ -0,0 +1,269 @@
+/*************************************************************************
+/* RandomAccessFileTest.java -- Tests RandomAccessFile's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+// Write some data using DataOutput and read it using DataInput.
+
+public class RandomAccessFileTest
+{
+
+public static void
+runReadTest(String filename, int seq, String testname)
+{
+  try
+    {
+      System.out.println("Test " + seq + ": " + testname);
+
+      RandomAccessFile ras = new RandomAccessFile(filename, "r");
+
+      boolean passed = true;
+
+      boolean b = ras.readBoolean();
+      if (b != true)
+        {
+          passed = false;
+          System.out.println("Failed to read boolean. Expected true and got false");
+        }
+      b = ras.readBoolean();
+      if (b != false)
+        {
+          passed = false;
+          System.out.println("Failed to read boolean. Expected false and got true");
+        }
+      byte bt = ras.readByte();
+      if (bt != 8)
+        {
+          passed = false;
+          System.out.println("Failed to read byte. Expected 8 and got "+ bt);
+        }
+      bt = ras.readByte();
+      if (bt != -122)
+        {
+          passed = false;
+          System.out.println("Failed to read byte. Expected -122 and got "+ bt);
+        }
+      char c = ras.readChar();
+      if (c != 'a')
+        {
+          passed = false;
+          System.out.println("Failed to read char. Expected a and got " + c);
+        }
+      c = ras.readChar();
+      if (c != '\uE2D2')
+        {
+          passed = false;
+          System.out.println("Failed to read char. Expected \\uE2D2 and got " + c);
+        }
+      short s = ras.readShort();
+      if (s != 32000)
+        {
+          passed = false;
+          System.out.println("Failed to read short. Expected 32000 and got " + s);
+        }
+      int i = ras.readInt();
+      if (i != 8675309)
+        {
+          passed = false;
+          System.out.println("Failed to read int. Expected 8675309 and got " + i);
+        }
+      long l = ras.readLong();
+      if (l != 696969696969L)
+        {
+          passed = false;
+          System.out.println("Failed to read long. Expected 696969696969 and got " + l);
+        }
+      float f = ras.readFloat();
+      if (!Float.toString(f).equals("3.1415"))
+        {
+          passed = false;
+          System.out.println("Failed to read float. Expected 3.1415 and got " + f);
+        }
+      double d = ras.readDouble();
+      if (d != 999999999.999)
+        {
+          passed = false;
+          System.out.println("Failed to read double.  Expected 999999999.999 and got " + d);
+        }
+      String str = ras.readUTF();
+      if (!str.equals("Testing code is such a boring activity but it must be done"))
+        {
+          passed = false;
+          System.out.println("Read unexpected String: " + str);
+        }
+      str = ras.readUTF();
+      if (!str.equals("a-->\u01FF\uA000\u6666\u0200RRR"))
+        {
+          passed = false;
+          System.out.println("Read unexpected String: " + str);
+        }
+    
+      if (passed)
+        System.out.println("PASSED: " + testname + " read test");
+      else
+        System.out.println("FAILED: " + testname + " read test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: " + testname + " read test: " + e);
+    }
+
+}
+
+public static void 
+main(String[] argv)
+{
+  System.out.println("Started test of RandomAccessFile");
+
+  System.out.println("Test 1: RandomAccessFile write test");
+  try
+    {
+      RandomAccessFile raf = new RandomAccessFile("dataoutput.out", "rw");
+
+      raf.writeBoolean(true);
+      raf.writeBoolean(false);
+      raf.writeByte((byte)8);
+      raf.writeByte((byte)-122);
+      raf.writeChar((char)'a');
+      raf.writeChar((char)'\uE2D2');
+      raf.writeShort((short)32000);
+      raf.writeInt((int)8675309);
+      raf.writeLong((long) 696969696969L);
+      raf.writeFloat((float)3.1415);
+      raf.writeDouble((double)999999999.999);
+      raf.writeUTF("Testing code is such a boring activity but it must be done");
+      raf.writeUTF("a-->\u01FF\uA000\u6666\u0200RRR");
+      raf.close();
+
+      // We'll find out if this was really right later, but conditionally
+      // report success for now
+      System.out.println("PASSED: RandomAccessFile write test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: RandomAccessFile write test: " + e);
+    }
+
+  runReadTest("dataoutput.out", 2, "Read of JCL written data file");
+  runReadTest("dataoutput-jdk.out", 3, "Read of JDK written data file");
+
+  System.out.println("Test 2: Seek Test");  
+  try
+    {
+      RandomAccessFile raf = new RandomAccessFile("/etc/services", "r");
+
+      System.out.println("Length: " + raf.length());
+
+      raf.skipBytes(24);
+      if (raf.getFilePointer() != 24)
+        throw new IOException("Unexpected file pointer value " + 
+                              raf.getFilePointer());     
+
+      raf.seek(0);
+      if (raf.getFilePointer() != 0)
+        throw new IOException("Unexpected file pointer value " + 
+                              raf.getFilePointer());     
+
+      raf.seek(100);
+      if (raf.getFilePointer() != 100)
+        throw new IOException("Unexpected file pointer value " + 
+                              raf.getFilePointer());     
+
+      System.out.println("PASSED: Seek Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Seek Test: " + e);
+    }
+
+  System.out.println("Test 3: Validation Test");
+  boolean failed = false;
+  try
+    {
+      new RandomAccessFile("/vmlinuz", "rwx"); 
+      System.out.println("Did not detect invalid mode");
+      failed = true;
+    }
+  catch (IllegalArgumentException e) { ; }
+  catch (IOException e) { ; }
+
+  try
+    {
+      new RandomAccessFile("/vmlinuz", "rw");
+      System.out.println("Did not detect read only file opened for write");
+      failed = true;
+    }
+  catch (IOException e) { ; }
+  
+  try
+    {
+      new RandomAccessFile("/sherlockholmes", "r");
+      System.out.println("Did not detect non-existent file");
+      failed = true;
+    }
+  catch (IOException e) { ; }
+
+  try
+    {
+      RandomAccessFile raf = new RandomAccessFile("/etc/services", "r");
+      raf.seek(raf.length());
+      raf.write('\n');
+      System.out.println("Did not detect invalid write operation on read only file");
+      failed = true;
+    } 
+  catch (IOException e) { ; }
+
+  if (failed)
+    System.out.println("FAILED: Validation Test");
+  else
+    System.out.println("PASSED: Validation Test");
+
+/*
+  System.out.println("Test 4: Set File Length Rest");
+  try
+    {
+      File f = new File("tmptmptmp");
+      RandomAccessFile raf = new RandomAccessFile("tmptmptmp", "rw");
+
+      raf.setLength(50L);
+      if (raf.length() != 50)
+        throw new IOException("Bad length on extending file of " + raf.length());      
+
+      raf.setLength(25L);
+      if (raf.length() != 25)
+        throw new IOException("Bad length on extending file of " + raf.length());      
+
+      raf.close();
+      f.delete();
+
+      System.out.println("PASSED: Set File Length Test");
+    }
+  catch(IOException e) 
+    {
+      System.out.println("FAILED: Set File Length Test: " + e);
+      (new File("tmptmptmp")).delete();
+    }
+*/
+  System.out.println("Finished test of RandomAccessFile");
+} // main
+
+} // class DataInputOutputTest
+
diff --git a/libjava/classpath/test/java.io/SequenceInputStreamTest.java b/libjava/classpath/test/java.io/SequenceInputStreamTest.java
new file mode 100644
index 0000000..7b2c916
--- /dev/null
+++ b/libjava/classpath/test/java.io/SequenceInputStreamTest.java
@@ -0,0 +1,85 @@
+/*************************************************************************
+/* SequenceInputStreamTest.java -- Tests SequenceInputStream's
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class SequenceInputStreamTest
+{
+
+public static void
+main(String argv[])
+{
+  System.out.println("Started test of SequenceInputStream");
+
+  String str1 = "I don't believe in going to chain restaurants.  I think\n" +
+    "they are evil.  I can't believe all the suburban folks who go to \n";
+
+  String str2 = "places like the Olive Garden.  Not only does the food make\n" +
+    "me want to puke, non of these chains has the slightest bit of character.\n";
+
+  byte[] buf = new byte[10];
+
+  System.out.println("Test 1: Simple read test");
+  try
+    {
+      StringBufferInputStream is1 = new StringBufferInputStream(str1);
+      ByteArrayInputStream is2 = new ByteArrayInputStream(str2.getBytes());
+      SequenceInputStream sis = new SequenceInputStream(is1, is2);
+
+      int bytes_read;
+      while((bytes_read = sis.read(buf)) != -1)
+        {
+          System.out.print(new String(buf,0,bytes_read));
+        }
+
+      sis.close();
+      System.out.println("PASSED: Simple read test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Simple read test: " + e);
+    }
+
+  System.out.println("Test 2: close() test");
+
+  try
+    { 
+      StringBufferInputStream is1 = new StringBufferInputStream(str1);
+      ByteArrayInputStream is2 = new ByteArrayInputStream(str2.getBytes());
+      SequenceInputStream sis = new SequenceInputStream(is1, is2);
+
+      sis.read(buf);
+      sis.close();
+      if (sis.read() != -1)
+         System.out.println("FAILED: close() test");
+      else
+         System.out.println("PASSED: close() test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: close() test: " + e);
+    }
+
+  System.out.println("Finished test of SequenceInputStream");
+}
+
+} // class SequenceInputStream
+
diff --git a/libjava/classpath/test/java.io/StreamTokenizerTest.java b/libjava/classpath/test/java.io/StreamTokenizerTest.java
new file mode 100644
index 0000000..e2d023f
--- /dev/null
+++ b/libjava/classpath/test/java.io/StreamTokenizerTest.java
@@ -0,0 +1,94 @@
+/*************************************************************************
+/* StreamTokenizerTest.java -- Test the StreamTokenizer class
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class StreamTokenizerTest
+{
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Started test of StreamTokenizer");
+  
+  try
+    {
+      System.out.println("Test 1: Basic Parsing Test");
+
+      StreamTokenizer st = new StreamTokenizer(new 
+                               FileInputStream("./stream-tokenizer.data"));
+
+      System.out.println("No tokens read: " + st.toString());
+      int j = 0;
+      for (;;)
+        {
+          int ttype = st.nextToken();
+          switch(ttype)
+            {
+              case StreamTokenizer.TT_NUMBER:
+                System.out.println("Read a number: " + st.toString());
+                break;
+
+              case StreamTokenizer.TT_WORD:
+                System.out.println("Read a word: " + st.toString());
+                ++j;
+                if (j == 2)
+                  {
+                    st.ordinaryChar('/');
+                    st.eolIsSignificant(true);
+                    st.lowerCaseMode(true);
+                    st.slashStarComments(true);
+                    st.slashSlashComments(true);
+                  }
+                break;
+
+              case StreamTokenizer.TT_EOL:
+                System.out.println("Read an EOL: " + st.toString());
+                break;
+
+              case StreamTokenizer.TT_EOF:
+                System.out.println("Read an EOF: " + st.toString());
+
+              case '\'':
+              case '"':
+                System.out.println("Got a quote:" + st.toString());
+                break;
+
+              default:
+                System.out.println("Got an ordinary:" + st.toString());
+                break; 
+           }
+         if (ttype == StreamTokenizer.TT_EOF)
+           break;
+        }
+
+      System.out.println("PASSED: Basic Parsing Test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Basic Parsing Test: " + e);
+    } 
+
+  System.out.println("Finished test of StreamTokenizer");
+}
+
+} // class StreamTokenizerTest
+
diff --git a/libjava/classpath/test/java.io/StringBufferInputStreamTest.java b/libjava/classpath/test/java.io/StringBufferInputStreamTest.java
new file mode 100644
index 0000000..adafac6
--- /dev/null
+++ b/libjava/classpath/test/java.io/StringBufferInputStreamTest.java
@@ -0,0 +1,163 @@
+/*************************************************************************
+/* StringBufferInputStreamTest.java -- Test StringBufferInputStream's of course
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class StringBufferInputStreamTest extends StringBufferInputStream
+{
+
+public
+StringBufferInputStreamTest(String b)
+{
+  super(b);
+}
+
+public static void
+main(String[] argv)
+{
+  System.out.println("Starting test of StringBufferInputStream.");
+  System.out.flush();
+
+  String str = "Between my freshman and sophomore years of high school\n" +
+    "we moved into a brand new building.  The old high school was turned\n" +
+    "into an elementary school.\n";
+
+  System.out.println("Test 1: Protected Variables"); 
+
+  StringBufferInputStreamTest sbis = new StringBufferInputStreamTest(str);
+  byte[] read_buf = new byte[12];
+
+  try 
+    {
+      sbis.read(read_buf);
+      sbis.mark(0);
+    
+      boolean passed = true;
+    
+      sbis.read(read_buf);
+      if (sbis.pos != (read_buf.length * 2))
+        {
+          passed = false;
+          System.out.println("The pos variable is wrong.  Expected 24 and got " + 
+                             sbis.pos);
+        }
+      if (sbis.count != str.length())
+        {
+          passed = false;
+          System.out.println("The count variable is wrong.  Expected " +
+                             str.length() + " and got " + sbis.pos);
+        }
+      if (sbis.buffer != str)
+        {
+          passed = false;
+          System.out.println("The buf variable is not correct");
+        }
+    
+      if (passed)
+        System.out.println("PASSED: Protected Variables Test");
+      else
+        System.out.println("FAILED: Protected Variables Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Protected Variables Test: " + e);
+    }
+
+  System.out.println("Test 2: Simple Read Test");
+
+  sbis = new StringBufferInputStreamTest(str);
+
+  try
+    {
+      int bytes_read, total_read = 0;
+      while ((bytes_read = sbis.read(read_buf, 0, read_buf.length)) != -1)
+        {
+          System.out.print(new String(read_buf, 0, bytes_read));
+          total_read += bytes_read;
+        }
+
+      sbis.close();
+      if (total_read == str.length())
+        System.out.println("PASSED: Simple Read Test");
+      else
+        System.out.println("FAILED: Simple Read Test");
+    }
+  catch (IOException e)
+    {
+      System.out.println("FAILED: Simple Read Test: " + e);
+    }
+
+  System.out.println("Test 3: mark/reset/available/skip test");
+  sbis = new StringBufferInputStreamTest(str);
+
+  try
+    {
+      boolean passed = true;
+
+      sbis.read(read_buf);      
+      if (sbis.available() != (str.length() - read_buf.length))
+        {
+          passed = false;
+          System.out.println("available() reported " + sbis.available() +
+                             " and " + (str.length() - read_buf.length) +
+                             " was expected");
+        }
+
+      if (sbis.skip(5) != 5)
+        {
+          passed = false;
+          System.out.println("skip() didn't work");
+        }
+      if (sbis.available() != (str.length() - (read_buf.length + 5)))
+        {
+          passed = false;
+          System.out.println("skip() lied");
+        }
+
+      if (sbis.markSupported())
+        {
+          passed = false;
+          System.out.println("markSupported() should have returned false but returned true");
+        }
+    
+      int availsave = sbis.available();
+      sbis.reset();
+      if (sbis.pos != 0) 
+        {
+          passed = false;
+          System.out.println("mark/reset failed to work");
+        }
+
+      if (passed)
+        System.out.println("PASSED: mark/reset/available/skip test");
+      else
+        System.out.println("FAILED: mark/reset/available/skip test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: mark/reset/available/skip test: " + e);
+    }
+
+  System.out.println("Finished StringBufferInputStream test");
+}
+
+}
+
diff --git a/libjava/classpath/test/java.io/StringWriterTest.java b/libjava/classpath/test/java.io/StringWriterTest.java
new file mode 100644
index 0000000..5433606
--- /dev/null
+++ b/libjava/classpath/test/java.io/StringWriterTest.java
@@ -0,0 +1,91 @@
+/*************************************************************************
+/* StringWriterTest.java -- Test StringWriter
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+/**
+  * Class to test StringWriter. This is just a rehash of the
+  * BufferedCharWriterTest using a StringWriter instead of a 
+  * CharArrayWriter underneath.
+  *
+  * @version 0.0
+  *
+  * @author Aaron M. Renn (arenn@urbanophile.com)
+  */
+public class StringWriterTest
+{
+
+public static void 
+main(String argv[])
+{
+  System.out.println("Started test of StringWriter");
+
+  try
+    {
+      System.out.println("Test 1: Write Tests");
+
+      StringWriter sw = new StringWriter(24);
+      BufferedWriter bw = new BufferedWriter(sw, 12);
+
+      String str = "There are a ton of great places to see live, original\n" +
+        "music in Chicago.  Places like Lounge Ax, Schuba's, the Empty\n" +
+        "Bottle, and even the dreaded Metro with their sometimes asshole\n" +
+        "bouncers.\n";
+
+      boolean passed = true;
+
+      char[] buf = new char[str.length()];
+      str.getChars(0, str.length(), buf, 0);
+
+      bw.write(buf, 0, 5);
+      if (sw.toString().length() != 0)
+        {
+          passed = false;
+          System.out.println("StringWriter has too many bytes #1");
+        }
+      bw.write(buf, 5, 8);
+      bw.write(buf, 13, 12);
+      bw.write(buf[25]);
+      bw.write(buf, 26, buf.length - 26);
+      bw.close();
+
+      String str2 = sw.toString();
+      if (!str.equals(str2))
+        {
+          passed = false;
+          System.out.println("Unexpected string: " + str2);
+        }
+
+      if (passed)
+        System.out.println("PASSED: Write Tests");
+      else
+        System.out.println("FAILED: Write Tests");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Write Tests: " + e);
+    }
+
+  System.out.println("Finished test of BufferedOutputStream and ByteArrayOutputStream");
+}
+
+} // class BufferedByteOutputStreamTest
+
diff --git a/libjava/classpath/test/java.io/Test.java b/libjava/classpath/test/java.io/Test.java
new file mode 100644
index 0000000..154884e
--- /dev/null
+++ b/libjava/classpath/test/java.io/Test.java
@@ -0,0 +1,52 @@
+/*************************************************************************
+/* Test.java -- Base class for test classes
+/*
+/* Copyright (c) 1998 by Free Software Foundation, Inc.
+/*
+/* 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, version 2. (see COPYING)
+/*
+/* 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+public class Test
+{
+  public static void error()
+  {
+    System.out.print( "ERROR: " );
+  }
+  
+  public static void pass()
+  {
+    System.out.print( "PASSED: " );
+  }
+  
+  public static void fail()
+  {
+    System.out.print( "FAILED: " );
+  }
+
+  public static void pass( boolean exp_pass )
+  {
+    if( exp_pass )
+      pass();
+    else
+      System.out.print( "XPASSED: " );
+  }
+  
+  public static void fail( boolean exp_pass )
+  {
+    if( exp_pass )
+      fail();
+    else
+      System.out.print( "XFAIL: " );
+  }
+}
diff --git a/libjava/classpath/test/java.io/UTF8EncodingTest.java b/libjava/classpath/test/java.io/UTF8EncodingTest.java
new file mode 100644
index 0000000..0c8d975
--- /dev/null
+++ b/libjava/classpath/test/java.io/UTF8EncodingTest.java
@@ -0,0 +1,100 @@
+/*************************************************************************
+/* UTF8EncodingTest.java -- A quick test of the UTF8 encoding
+/*
+/* Copyright (c) 1998 Free Software Foundation, Inc.
+/* Written by Aaron M. Renn (arenn@urbanophile.com)
+/*
+/* 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
+/* (at your option) 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+/*************************************************************************/
+
+import java.io.*;
+
+public class UTF8EncodingTest
+{
+
+public static void main(String[] argv)
+{
+  System.out.println("Started test of UTF8 encoding handling");
+
+  String str1 = "This is the first line of text\n";
+  String str2 = "This has some \u01FF\uA000\u6666\u0200 weird characters\n";
+
+  System.out.println("Test 1: Write test");
+  try
+    {
+      FileOutputStream fos = new FileOutputStream("utf8test.out");
+      OutputStreamWriter osr = new OutputStreamWriter(fos, "UTF8");
+      osr.write(str1);
+      osr.write(str2);
+      osr.close();
+
+      System.out.println("PASSED: Write test (conditionally)");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Write Test: " + e);
+    }
+
+  System.out.println("Test 2: Read JDK file test");
+  try
+    {
+      FileInputStream fis = new FileInputStream("utf8test-jdk.out");
+      InputStreamReader isr = new InputStreamReader(fis, "UTF8");
+      char[] buf = new char[255];
+
+      int chars_read = isr.read(buf, 0, str1.length());
+      String str3 = new String(buf, 0, chars_read);
+
+      chars_read = isr.read(buf, 0, str2.length());
+      String str4 = new String(buf, 0, chars_read);
+
+      if (!str1.equals(str3) || !str2.equals(str4))
+        System.out.println("FAILED: Read JDK file test");
+      else
+        System.out.println("PASSED: Read JDK file test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Read JDK file test: " + e); 
+    }
+
+  System.out.println("Test 3: Read classpath file test");
+  try
+    {
+      FileInputStream fis = new FileInputStream("utf8test.out");
+      InputStreamReader isr = new InputStreamReader(fis, "UTF8");
+      char[] buf = new char[255];
+
+      int chars_read = isr.read(buf, 0, str1.length());
+      String str3 = new String(buf, 0, chars_read);
+
+      chars_read = isr.read(buf, 0, str2.length());
+      String str4 = new String(buf, 0, chars_read);
+
+      if (!str1.equals(str3) || !str2.equals(str4))
+        System.out.println("FAILED: Read classpath file test");
+      else
+        System.out.println("PASSED: Read classpath file test");
+    }
+  catch(IOException e)
+    {
+      System.out.println("FAILED: Read classpath file test: " + e); 
+    }
+
+  System.out.println("Finished test of UTF8 encoding handling");
+}
+
+} // class UTF8EncodingTest
+
diff --git a/libjava/classpath/test/java.io/calldefault.data b/libjava/classpath/test/java.io/calldefault.data
new file mode 100644
index 0000000..60dcc00
--- /dev/null
+++ b/libjava/classpath/test/java.io/calldefault.data
diff --git a/libjava/classpath/test/java.io/dataoutput-jdk.out b/libjava/classpath/test/java.io/dataoutput-jdk.out
new file mode 100644
index 0000000..ba9875c
--- /dev/null
+++ b/libjava/classpath/test/java.io/dataoutput-jdk.out
diff --git a/libjava/classpath/test/java.io/external.data b/libjava/classpath/test/java.io/external.data
new file mode 100644
index 0000000..139cc01
--- /dev/null
+++ b/libjava/classpath/test/java.io/external.data
diff --git a/libjava/classpath/test/java.io/graph.data b/libjava/classpath/test/java.io/graph.data
new file mode 100644
index 0000000..55d5b11
--- /dev/null
+++ b/libjava/classpath/test/java.io/graph.data
diff --git a/libjava/classpath/test/java.io/nocalldefault.data b/libjava/classpath/test/java.io/nocalldefault.data
new file mode 100644
index 0000000..ba987bb
--- /dev/null
+++ b/libjava/classpath/test/java.io/nocalldefault.data
diff --git a/libjava/classpath/test/java.io/notserial.data b/libjava/classpath/test/java.io/notserial.data
new file mode 100644
index 0000000..16b4971
--- /dev/null
+++ b/libjava/classpath/test/java.io/notserial.data
diff --git a/libjava/classpath/test/java.io/notserialfield.data b/libjava/classpath/test/java.io/notserialfield.data
new file mode 100644
index 0000000..a31f046
--- /dev/null
+++ b/libjava/classpath/test/java.io/notserialfield.data
diff --git a/libjava/classpath/test/java.io/stream-tokenizer.data b/libjava/classpath/test/java.io/stream-tokenizer.data
new file mode 100644
index 0000000..d09ff25
--- /dev/null
+++ b/libjava/classpath/test/java.io/stream-tokenizer.data
@@ -0,0 +1,8 @@
+	 -.1254.ab8/this is to the end of the line
+'This would be a string of quoted text'|||||||
+'\277\444\\\r\n'
+LOWER case ME
+ARE/*C type comments
+recognized even with EOL signficant?*/
+What//is up with C++ comments?
+Will this be pushed back?
diff --git a/libjava/classpath/test/java.io/utf8test-jdk.out b/libjava/classpath/test/java.io/utf8test-jdk.out
new file mode 100644
index 0000000..0e8ea1f
--- /dev/null
+++ b/libjava/classpath/test/java.io/utf8test-jdk.out
@@ -0,0 +1,2 @@
+This is the first line of text
+This has some ǿꀀ晦Ȁ weird characters