/*
* 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();
}
}
}