luni/src/test/java/libcore/java/io/OldObjectOutputStreamTest.java - platform/libcore-snapshot - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package libcore.java.io;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.NotActiveException;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.io.OutputStream;
 import java.io.Serializable;
 import junit.framework.TestCase;
 import tests.support.Support_ASimpleOutputStream;
 import tests.support.Support_OutputStream;

 public class OldObjectOutputStreamTest extends TestCase implements Serializable {

     static final long serialVersionUID = 1L;

     java.io.File f;

     public class SerializableTestHelper implements Serializable {
         public String aField1;

         public String aField2;

         SerializableTestHelper(String s, String t) {
             aField1 = s;
             aField2 = t;
         }

         private void readObject(ObjectInputStream ois) throws IOException {
             // note aField2 is not read
             try {
                 ObjectInputStream.GetField fields = ois.readFields();
                 aField1 = (String) fields.get("aField1", "Zap");
             } catch (Exception e) {
             }
         }

         private void writeObject(ObjectOutputStream oos) throws IOException {
             // note aField2 is not written
             ObjectOutputStream.PutField fields = oos.putFields();
             fields.put("aField1", aField1);
             oos.writeFields();
         }

         public String getText1() {
             return aField1;
         }

         public String getText2() {
             return aField2;
         }
     }

     private static class BasicObjectOutputStream extends ObjectOutputStream {
         public boolean writeStreamHeaderCalled;

         public BasicObjectOutputStream() throws IOException, SecurityException {
             super();
             writeStreamHeaderCalled = false;
         }

         public BasicObjectOutputStream(OutputStream output) throws IOException {
             super(output);
         }

         public void drain() throws IOException {
             super.drain();
         }

         public boolean enableReplaceObject(boolean enable)
                 throws SecurityException {
             return super.enableReplaceObject(enable);
         }

         public void writeObjectOverride(Object object) throws IOException {
             super.writeObjectOverride(object);
         }

         public void writeStreamHeader() throws IOException {
             super.writeStreamHeader();
             writeStreamHeaderCalled = true;
         }
 }

     private static class NoFlushTestOutputStream extends ByteArrayOutputStream {
         public boolean flushCalled;

         public NoFlushTestOutputStream() {
             super();
             flushCalled = false;
         }

         public void flush() throws IOException {
             super.flush();
             flushCalled = true;
         }
     }

     protected static final String MODE_XLOAD = "xload";

     protected static final String MODE_XDUMP = "xdump";

     static final String FOO = "foo";

     static final String MSG_WITE_FAILED = "Failed to write: ";

     private static final boolean DEBUG = false;

     protected static boolean xload = false;

     protected static boolean xdump = false;

     protected static String xFileName = null;

     protected ObjectInputStream ois;

     protected ObjectOutputStream oos;

     protected ObjectOutputStream oos_ioe;

     protected Support_OutputStream sos;

     protected ByteArrayOutputStream bao;

     static final int INIT_INT_VALUE = 7;

     static final String INIT_STR_VALUE = "a string that is blortz";

     /**
      * java.io.ObjectOutputStream#ObjectOutputStream(java.io.OutputStream)
      */
     public void test_ConstructorLjava_io_OutputStream() throws IOException {
         oos.close();
         oos = new ObjectOutputStream(new ByteArrayOutputStream());
         oos.close();

         try {
             oos = new ObjectOutputStream(null);
             fail("Test 1: NullPointerException expected.");
         } catch (NullPointerException e) {
             // Expected.
         }

         Support_ASimpleOutputStream sos = new Support_ASimpleOutputStream(true);
         try {
             oos = new ObjectOutputStream(sos);
             fail("Test 2: IOException expected.");
         } catch (IOException e) {
             // Expected.
         }
     }

     public void test_close() throws IOException {
         int outputSize = bao.size();
         // Writing of a primitive type should be buffered.
         oos.writeInt(42);
         assertTrue("Test 1: Primitive data unexpectedly written to the target stream.",
                 bao.size() == outputSize);
         // Closing should write the buffered data to the target stream.
         oos.close();
         assertTrue("Test 2: Primitive data has not been written to the the target stream.",
                 bao.size() > outputSize);

         try {
             oos_ioe.close();
             fail("Test 3: IOException expected.");
         } catch (IOException e) {
             // Expected.
         }
     }

     public void test_drain() throws IOException {
         NoFlushTestOutputStream target = new NoFlushTestOutputStream();
         BasicObjectOutputStream boos = new BasicObjectOutputStream(target);
         int initialSize = target.size();
         boolean written = false;

         boos.writeBytes("Lorem ipsum");
         // If there is no buffer then the bytes have already been written.
         written = (target.size() > initialSize);

         boos.drain();
         assertTrue("Content has not been written to the target.",
                 written || (target.size() > initialSize));
         assertFalse("flush() has been called on the target.",
                 target.flushCalled);
     }

     public void test_enableReplaceObjectB() throws IOException {
         // Start testing without a SecurityManager.
         BasicObjectOutputStream boos = new BasicObjectOutputStream();
         assertFalse("Test 1: Object resolving must be disabled by default.",
                 boos.enableReplaceObject(true));

         assertTrue("Test 2: enableReplaceObject did not return the previous value.",
                 boos.enableReplaceObject(false));
     }

     public void test_flush() throws Exception {
         // Test for method void java.io.ObjectOutputStream.flush()
         int size = bao.size();
         oos.writeByte(127);
         assertTrue("Test 1: Data already flushed.", bao.size() == size);
         oos.flush();
         assertTrue("Test 2: Failed to flush data.", bao.size() > size);

         try {
             oos_ioe.flush();
             fail("Test 3: IOException expected.");
         } catch (IOException e) {
             // Expected.
         }
     }

     public void test_putFields() throws Exception {
         /*
          * "SerializableTestHelper" is an object created for these tests with
          * two fields (Strings) and simple implementations of readObject and
          * writeObject which simply read and write the first field but not the
          * second one.
          */
         SerializableTestHelper sth;

         try {
             oos.putFields();
             fail("Test 1: NotActiveException expected.");
         } catch (NotActiveException e) {
             // Expected.
         }

         oos.writeObject(new SerializableTestHelper("Gabba", "Jabba"));
         oos.flush();
         ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
         sth = (SerializableTestHelper) (ois.readObject());
         assertEquals("Test 2: readFields or writeFields failed; first field not set.",
                 "Gabba", sth.getText1());
         assertNull("Test 3: readFields or writeFields failed; second field should not have been set.",
                 sth.getText2());
     }

     public void test_reset() throws Exception {
         String o = "HelloWorld";
         sos = new Support_OutputStream(200);
         oos.close();
         oos = new ObjectOutputStream(sos);
         oos.writeObject(o);
         oos.writeObject(o);
         oos.reset();
         oos.writeObject(o);

         sos.setThrowsException(true);
         try {
             oos.reset();
             fail("Test 1: IOException expected.");
         } catch (IOException e) {
             // Expected.
         }
         sos.setThrowsException(false);

         ois = new ObjectInputStream(new ByteArrayInputStream(sos.toByteArray()));
         assertEquals("Test 2: Incorrect object read.", o, ois.readObject());
         assertEquals("Test 3: Incorrect object read.", o, ois.readObject());
         assertEquals("Test 4: Incorrect object read.", o, ois.readObject());
         ois.close();
     }

     public void test_write$BII() throws Exception {
         byte[] buf = new byte[10];
         ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
         try {
             ois.read(buf, 0, -1);
             fail("IndexOutOfBoundsException not thrown");
         } catch (IndexOutOfBoundsException e) {
             // Expected
         }
         try {
             ois.read(buf, -1, 1);
             fail("IndexOutOfBoundsException not thrown");
         } catch (IndexOutOfBoundsException e) {
             // Expected
         }
         try {
             ois.read(buf, 10, 1);
             fail("IndexOutOfBoundsException not thrown");
         } catch (IndexOutOfBoundsException e) {
             // Expected
         }
         ois.close();

     }

     public void test_writeObjectOverrideLjava_lang_Object() throws IOException {
         BasicObjectOutputStream boos =
                 new BasicObjectOutputStream(new ByteArrayOutputStream());

         try {
             boos.writeObjectOverride(new Object());
             fail("IOException expected.");
         }
         catch (IOException e) {
         }
         finally {
             boos.close();
         }
     }

     public void test_writeStreamHeader() throws IOException {
         BasicObjectOutputStream boos;
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         short s;
         byte[] buffer;

         // Test 1: Make sure that writeStreamHeader() has been called.
         boos = new BasicObjectOutputStream(baos);
         try {
             assertTrue("Test 1: writeStreamHeader() has not been called.",
                          boos.writeStreamHeaderCalled);

             // Test 2: Check that at least four bytes have been written.
             buffer = baos.toByteArray();
             assertTrue("Test 2: At least four bytes should have been written",
                         buffer.length >= 4);

             // Test 3: Check the magic number.
             s = buffer[0];
             s <<= 8;
             s += ((short) buffer[1] & 0x00ff);
             assertEquals("Test 3: Invalid magic number written.",
                         java.io.ObjectStreamConstants.STREAM_MAGIC, s);

             // Test 4: Check the stream version number.
             s = buffer[2];
             s <<= 8;
             s += ((short) buffer[3] & 0x00ff);
             assertEquals("Invalid stream version number written.",
                         java.io.ObjectStreamConstants.STREAM_VERSION, s);
         }
         finally {
             boos.close();
         }
     }

     /**
      * Sets up the fixture, for example, open a network connection. This method
      * is called before a test is executed.
      */
     protected void setUp() throws Exception {
         super.setUp();
         oos = new ObjectOutputStream(bao = new ByteArrayOutputStream());
         oos_ioe = new ObjectOutputStream(sos = new Support_OutputStream());
         sos.setThrowsException(true);
     }

     /**
      * Tears down the fixture, for example, close a network connection. This
      * method is called after a test is executed.
      */
     protected void tearDown() throws Exception {
         super.tearDown();
         if (oos != null) {
             try {
                 oos.close();
             } catch (Exception e) {}
         }
         if (oos_ioe != null) {
             try {
                 oos_ioe.close();
             } catch (Exception e) {}
         }
         if (f != null && f.exists()) {
             if (!f.delete()) {
                 fail("Error cleaning up files during teardown");
             }
         }
     }

     protected Object reload() throws IOException, ClassNotFoundException {

         // Choose the load stream
         if (xload || xdump) {
             // Load from pre-existing file
             ois = new ObjectInputStream(new FileInputStream(xFileName + "-"
                     + getName() + ".ser"));
         } else {
             // Just load from memory, we dumped to memory
             ois = new ObjectInputStream(new ByteArrayInputStream(bao
                     .toByteArray()));
         }

         try {
             return ois.readObject();
         } finally {
             ois.close();
         }
     }

     protected void dump(Object o) throws IOException, ClassNotFoundException {

         // Choose the dump stream
         if (xdump) {
             oos = new ObjectOutputStream(new FileOutputStream(
                     f = new java.io.File(xFileName + "-" + getName() + ".ser")));
         } else {
             oos = new ObjectOutputStream(bao = new ByteArrayOutputStream());
         }

         // Dump the object
         try {
             oos.writeObject(o);
         } finally {
             oos.close();
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package libcore.java.io;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.FileInputStream;
	import java.io.FileOutputStream;
	import java.io.IOException;
	import java.io.NotActiveException;
	import java.io.ObjectInputStream;
	import java.io.ObjectOutputStream;
	import java.io.OutputStream;
	import java.io.Serializable;
	import junit.framework.TestCase;
	import tests.support.Support_ASimpleOutputStream;
	import tests.support.Support_OutputStream;

	public class OldObjectOutputStreamTest extends TestCase implements Serializable {

	static final long serialVersionUID = 1L;

	java.io.File f;

	public class SerializableTestHelper implements Serializable {
	public String aField1;

	public String aField2;

	SerializableTestHelper(String s, String t) {
	aField1 = s;
	aField2 = t;
	}

	private void readObject(ObjectInputStream ois) throws IOException {
	// note aField2 is not read
	try {
	ObjectInputStream.GetField fields = ois.readFields();
	aField1 = (String) fields.get("aField1", "Zap");
	} catch (Exception e) {
	}
	}

	private void writeObject(ObjectOutputStream oos) throws IOException {
	// note aField2 is not written
	ObjectOutputStream.PutField fields = oos.putFields();
	fields.put("aField1", aField1);
	oos.writeFields();
	}

	public String getText1() {
	return aField1;
	}

	public String getText2() {
	return aField2;
	}
	}

	private static class BasicObjectOutputStream extends ObjectOutputStream {
	public boolean writeStreamHeaderCalled;

	public BasicObjectOutputStream() throws IOException, SecurityException {
	super();
	writeStreamHeaderCalled = false;
	}

	public BasicObjectOutputStream(OutputStream output) throws IOException {
	super(output);
	}

	public void drain() throws IOException {
	super.drain();
	}

	public boolean enableReplaceObject(boolean enable)
	throws SecurityException {
	return super.enableReplaceObject(enable);
	}

	public void writeObjectOverride(Object object) throws IOException {
	super.writeObjectOverride(object);
	}

	public void writeStreamHeader() throws IOException {
	super.writeStreamHeader();
	writeStreamHeaderCalled = true;
	}
	}

	private static class NoFlushTestOutputStream extends ByteArrayOutputStream {
	public boolean flushCalled;

	public NoFlushTestOutputStream() {
	super();
	flushCalled = false;
	}

	public void flush() throws IOException {
	super.flush();
	flushCalled = true;
	}
	}

	protected static final String MODE_XLOAD = "xload";

	protected static final String MODE_XDUMP = "xdump";

	static final String FOO = "foo";

	static final String MSG_WITE_FAILED = "Failed to write: ";

	private static final boolean DEBUG = false;

	protected static boolean xload = false;

	protected static boolean xdump = false;

	protected static String xFileName = null;

	protected ObjectInputStream ois;

	protected ObjectOutputStream oos;

	protected ObjectOutputStream oos_ioe;

	protected Support_OutputStream sos;

	protected ByteArrayOutputStream bao;

	static final int INIT_INT_VALUE = 7;

	static final String INIT_STR_VALUE = "a string that is blortz";

	/**
	* java.io.ObjectOutputStream#ObjectOutputStream(java.io.OutputStream)
	*/
	public void test_ConstructorLjava_io_OutputStream() throws IOException {
	oos.close();
	oos = new ObjectOutputStream(new ByteArrayOutputStream());
	oos.close();

	try {
	oos = new ObjectOutputStream(null);
	fail("Test 1: NullPointerException expected.");
	} catch (NullPointerException e) {
	// Expected.
	}

	Support_ASimpleOutputStream sos = new Support_ASimpleOutputStream(true);
	try {
	oos = new ObjectOutputStream(sos);
	fail("Test 2: IOException expected.");
	} catch (IOException e) {
	// Expected.
	}
	}

	public void test_close() throws IOException {
	int outputSize = bao.size();
	// Writing of a primitive type should be buffered.
	oos.writeInt(42);
	assertTrue("Test 1: Primitive data unexpectedly written to the target stream.",
	bao.size() == outputSize);
	// Closing should write the buffered data to the target stream.
	oos.close();
	assertTrue("Test 2: Primitive data has not been written to the the target stream.",
	bao.size() > outputSize);

	try {
	oos_ioe.close();
	fail("Test 3: IOException expected.");
	} catch (IOException e) {
	// Expected.
	}
	}

	public void test_drain() throws IOException {
	NoFlushTestOutputStream target = new NoFlushTestOutputStream();
	BasicObjectOutputStream boos = new BasicObjectOutputStream(target);
	int initialSize = target.size();
	boolean written = false;

	boos.writeBytes("Lorem ipsum");
	// If there is no buffer then the bytes have already been written.
	written = (target.size() > initialSize);

	boos.drain();
	assertTrue("Content has not been written to the target.",
	written \|\| (target.size() > initialSize));
	assertFalse("flush() has been called on the target.",
	target.flushCalled);
	}

	public void test_enableReplaceObjectB() throws IOException {
	// Start testing without a SecurityManager.
	BasicObjectOutputStream boos = new BasicObjectOutputStream();
	assertFalse("Test 1: Object resolving must be disabled by default.",
	boos.enableReplaceObject(true));

	assertTrue("Test 2: enableReplaceObject did not return the previous value.",
	boos.enableReplaceObject(false));
	}

	public void test_flush() throws Exception {
	// Test for method void java.io.ObjectOutputStream.flush()
	int size = bao.size();
	oos.writeByte(127);
	assertTrue("Test 1: Data already flushed.", bao.size() == size);
	oos.flush();
	assertTrue("Test 2: Failed to flush data.", bao.size() > size);

	try {
	oos_ioe.flush();
	fail("Test 3: IOException expected.");
	} catch (IOException e) {
	// Expected.
	}
	}

	public void test_putFields() throws Exception {
	/*
	* "SerializableTestHelper" is an object created for these tests with
	* two fields (Strings) and simple implementations of readObject and
	* writeObject which simply read and write the first field but not the
	* second one.
	*/
	SerializableTestHelper sth;

	try {
	oos.putFields();
	fail("Test 1: NotActiveException expected.");
	} catch (NotActiveException e) {
	// Expected.
	}

	oos.writeObject(new SerializableTestHelper("Gabba", "Jabba"));
	oos.flush();
	ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
	sth = (SerializableTestHelper) (ois.readObject());
	assertEquals("Test 2: readFields or writeFields failed; first field not set.",
	"Gabba", sth.getText1());
	assertNull("Test 3: readFields or writeFields failed; second field should not have been set.",
	sth.getText2());
	}

	public void test_reset() throws Exception {
	String o = "HelloWorld";
	sos = new Support_OutputStream(200);
	oos.close();
	oos = new ObjectOutputStream(sos);
	oos.writeObject(o);
	oos.writeObject(o);
	oos.reset();
	oos.writeObject(o);

	sos.setThrowsException(true);
	try {
	oos.reset();
	fail("Test 1: IOException expected.");
	} catch (IOException e) {
	// Expected.
	}
	sos.setThrowsException(false);

	ois = new ObjectInputStream(new ByteArrayInputStream(sos.toByteArray()));
	assertEquals("Test 2: Incorrect object read.", o, ois.readObject());
	assertEquals("Test 3: Incorrect object read.", o, ois.readObject());
	assertEquals("Test 4: Incorrect object read.", o, ois.readObject());
	ois.close();
	}

	public void test_write$BII() throws Exception {
	byte[] buf = new byte[10];
	ois = new ObjectInputStream(new ByteArrayInputStream(bao.toByteArray()));
	try {
	ois.read(buf, 0, -1);
	fail("IndexOutOfBoundsException not thrown");
	} catch (IndexOutOfBoundsException e) {
	// Expected
	}
	try {
	ois.read(buf, -1, 1);
	fail("IndexOutOfBoundsException not thrown");
	} catch (IndexOutOfBoundsException e) {
	// Expected
	}
	try {
	ois.read(buf, 10, 1);
	fail("IndexOutOfBoundsException not thrown");
	} catch (IndexOutOfBoundsException e) {
	// Expected
	}
	ois.close();

	}

	public void test_writeObjectOverrideLjava_lang_Object() throws IOException {
	BasicObjectOutputStream boos =
	new BasicObjectOutputStream(new ByteArrayOutputStream());

	try {
	boos.writeObjectOverride(new Object());
	fail("IOException expected.");
	}
	catch (IOException e) {
	}
	finally {
	boos.close();
	}
	}

	public void test_writeStreamHeader() throws IOException {
	BasicObjectOutputStream boos;
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	short s;
	byte[] buffer;

	// Test 1: Make sure that writeStreamHeader() has been called.
	boos = new BasicObjectOutputStream(baos);
	try {
	assertTrue("Test 1: writeStreamHeader() has not been called.",
	boos.writeStreamHeaderCalled);

	// Test 2: Check that at least four bytes have been written.
	buffer = baos.toByteArray();
	assertTrue("Test 2: At least four bytes should have been written",
	buffer.length >= 4);

	// Test 3: Check the magic number.
	s = buffer[0];
	s <<= 8;
	s += ((short) buffer[1] & 0x00ff);
	assertEquals("Test 3: Invalid magic number written.",
	java.io.ObjectStreamConstants.STREAM_MAGIC, s);

	// Test 4: Check the stream version number.
	s = buffer[2];
	s <<= 8;
	s += ((short) buffer[3] & 0x00ff);
	assertEquals("Invalid stream version number written.",
	java.io.ObjectStreamConstants.STREAM_VERSION, s);
	}
	finally {
	boos.close();
	}
	}

	/**
	* Sets up the fixture, for example, open a network connection. This method
	* is called before a test is executed.
	*/
	protected void setUp() throws Exception {
	super.setUp();
	oos = new ObjectOutputStream(bao = new ByteArrayOutputStream());
	oos_ioe = new ObjectOutputStream(sos = new Support_OutputStream());
	sos.setThrowsException(true);
	}

	/**
	* Tears down the fixture, for example, close a network connection. This
	* method is called after a test is executed.
	*/
	protected void tearDown() throws Exception {
	super.tearDown();
	if (oos != null) {
	try {
	oos.close();
	} catch (Exception e) {}
	}
	if (oos_ioe != null) {
	try {
	oos_ioe.close();
	} catch (Exception e) {}
	}
	if (f != null && f.exists()) {
	if (!f.delete()) {
	fail("Error cleaning up files during teardown");
	}
	}
	}

	protected Object reload() throws IOException, ClassNotFoundException {

	// Choose the load stream
	if (xload \|\| xdump) {
	// Load from pre-existing file
	ois = new ObjectInputStream(new FileInputStream(xFileName + "-"
	+ getName() + ".ser"));
	} else {
	// Just load from memory, we dumped to memory
	ois = new ObjectInputStream(new ByteArrayInputStream(bao
	.toByteArray()));
	}

	try {
	return ois.readObject();
	} finally {
	ois.close();
	}
	}

	protected void dump(Object o) throws IOException, ClassNotFoundException {

	// Choose the dump stream
	if (xdump) {
	oos = new ObjectOutputStream(new FileOutputStream(
	f = new java.io.File(xFileName + "-" + getName() + ".ser")));
	} else {
	oos = new ObjectOutputStream(bao = new ByteArrayOutputStream());
	}

	// Dump the object
	try {
	oos.writeObject(o);
	} finally {
	oos.close();
	}
	}
	}