summaryrefslogtreecommitdiffstats
path: root/utils-test/src/test
diff options
context:
space:
mode:
Diffstat (limited to 'utils-test/src/test')
-rw-r--r--utils-test/src/test/java/org/onap/policy/common/utils/io/SerializerTest.java73
1 files changed, 49 insertions, 24 deletions
diff --git a/utils-test/src/test/java/org/onap/policy/common/utils/io/SerializerTest.java b/utils-test/src/test/java/org/onap/policy/common/utils/io/SerializerTest.java
index bdf0dba9..613897d9 100644
--- a/utils-test/src/test/java/org/onap/policy/common/utils/io/SerializerTest.java
+++ b/utils-test/src/test/java/org/onap/policy/common/utils/io/SerializerTest.java
@@ -163,6 +163,54 @@ public class SerializerTest {
}
@Test
+ public void testSerialize_BothCloseEx() throws Exception {
+ IOException ex = new IOException("testSerialize_BothCloseEx");
+ IOException ex2 = new IOException("testSerialize_BothCloseEx_2");
+ ObjectOutputStream oos = mock(ObjectOutputStream.class);
+ doThrow(ex2).when(oos).close();
+
+ /*
+ * This stream will throw an exception when close() is invoked. However, close()
+ * is called twice, once by the ObjectOutputStream and once by the code we want to
+ * test. As a result, we'll have the first close() succeed and the second one
+ * fail.
+ */
+ ByteArrayOutputStream out = new ByteArrayOutputStream() {
+ private int nclose = 0;
+
+ @Override
+ public void close() throws IOException {
+ if (++nclose > 1) {
+ throw ex;
+ }
+ }
+ };
+
+ /*
+ * Use a factory that returns our special stream.
+ */
+ setFactory(new Factory() {
+ @Override
+ public ByteArrayOutputStream makeByteArrayOutputStream() {
+ return out;
+ }
+
+ @Override
+ public ObjectOutputStream makeObjectOutputStream(ByteArrayOutputStream out) throws IOException {
+ return oos;
+ }
+
+ @Override
+ public void writeObject(Object object, ObjectOutputStream oos) throws IOException {
+ return;
+ }
+ });
+
+ assertEquals(ex2, expectException(() -> Serializer.serialize(new MyObject(130))));
+
+ }
+
+ @Test
public void testDeserialize() throws Exception {
MyObject obj1 = new MyObject(3);
byte[] data = Serializer.serialize(obj1);
@@ -202,29 +250,6 @@ public class SerializerTest {
}
@Test
- public void testDeserialize_ObjectReadClassEx() throws Exception {
- ClassNotFoundException ex = new ClassNotFoundException("testDeserialize_ObjectReadClassEx");
-
- /*
- * Use a factory that throws a ClassNotFoundException when readObject() is
- * invoked.
- */
- setFactory(new Factory() {
- @Override
- public Object readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
- throw ex;
- }
- });
-
- byte[] data = Serializer.serialize(new MyObject(305));
-
- Exception exwrap = expectException(() -> Serializer.deserialize(MyObject.class, data));
- assertTrue(exwrap instanceof IOException);
- assertNotNull(exwrap.getCause());
- assertEquals(ex, exwrap.getCause());
- }
-
- @Test
public void testDeserialize_ObjectReadEx() throws Exception {
IOException ex = new IOException("testDeserialize_ObjectReadEx");
@@ -233,7 +258,7 @@ public class SerializerTest {
*/
setFactory(new Factory() {
@Override
- public Object readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
+ public Object readObject(ObjectInputStream ois) throws IOException {
throw ex;
}
});