/*******************************************************************************
* 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 org.apache.ofbiz.base.util.test;
import java.io.ByteArrayInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Set;
import org.apache.ofbiz.base.lang.Factory;
import org.apache.ofbiz.base.lang.SourceMonitored;
import org.apache.ofbiz.base.test.GenericTestCaseBase;
import org.apache.ofbiz.base.util.Debug;
import org.apache.ofbiz.base.util.GroovyUtil;
import org.apache.ofbiz.base.util.UtilObject;
@SourceMonitored
public class UtilObjectTests extends GenericTestCaseBase {
public UtilObjectTests(String name) {
super(name);
}
@Override
protected void setUp() throws Exception {
super.setUp();
}
@Override
protected void tearDown() throws Exception {
super.tearDown();
}
public void testStaticHelperClass() throws Exception {
assertStaticHelperClass(UtilObject.class);
}
public static final class ErrorInjector extends FilterInputStream {
private int after;
private final boolean onClose;
public ErrorInjector(InputStream in, boolean onClose) {
this(in, -1, onClose);
}
public ErrorInjector(InputStream in, int after) {
this(in, after, false);
}
public ErrorInjector(InputStream in, int after, boolean onClose) {
super(in);
this.after = after;
this.onClose = onClose;
}
@Override
public int read() throws IOException {
if (after == 0) {
throw new IOException();
}
if (after > 0) {
after--;
}
return super.read();
}
@Override
public int read(byte[] buf) throws IOException {
return read(buf, 0, buf.length);
}
@Override
public int read(byte[] buf, int offset, int length) throws IOException {
if (after == 0) {
throw new IOException();
}
if (after > 0) {
if (length > after) {
length = after;
}
int r = super.read(buf, offset, length);
after -= r;
return r;
} else {
return super.read(buf, offset, length);
}
}
@Override
public void close() throws IOException {
if (onClose) {
throw new IOException();
}
super.close();
}
}
public void testErrorInjector() throws Exception {
byte[] source = new byte[] { 0, 1, 2, 3, 4, 5, 6 };
InputStream in = new ErrorInjector(new ByteArrayInputStream(source), true);
byte[] result = new byte[source.length];
int r = in.read();
assertEquals("onClose, read short length", 2, in.read(new byte[2]));
assertNotSame("onClose, not read/eof", -1, r);
assertEquals("onClose, read length", source.length - 3, in.read(result, 3, result.length - 3));
Exception caught = null;
try {
in.close();
} catch (IOException e) {
caught = e;
} finally {
assertNotNull("onClose, exception", caught);
}
in = new ErrorInjector(new ByteArrayInputStream(source), 4);
result = new byte[source.length];
r = in.read();
assertNotSame("after, not read/eof", -1, r);
assertEquals("after, read short length", 2, in.read(result, 0, 2));
assertEquals("after, read long length", 1, in.read(result, 3, result.length - 3));
caught = null;
try {
in.read(result, 4, result.length - 4);
} catch (IOException e) {
caught = e;
} finally {
assertNotNull("read, buffer exception", caught);
}
caught = null;
try {
in.read();
} catch (IOException e) {
caught = e;
} finally {
assertNotNull("read, singleton exception", caught);
}
in.close();
}
public void testGetBytes_Stream() {
boolean errorOn = Debug.isOn(Debug.ERROR);
try {
Debug.set(Debug.ERROR, false);
byte[] source = new byte[] { 0, 1, 2, 3, 4, 5, 6 };
byte[] result = UtilObject.getBytes(new ByteArrayInputStream(source));
assertNotNull("initial result", result);
assertEquals("initial equals", source, result);
assertNull("error after read", UtilObject.getBytes(new ErrorInjector(new ByteArrayInputStream(source), 3)));
byte[] closeResult = UtilObject.getBytes(new ErrorInjector(new ByteArrayInputStream(source), true));
assertNotNull("error on close", closeResult);
assertEquals("error on close equals", source, result);
Exception caught = null;
try {
UtilObject.getBytes(null);
} catch (NullPointerException e) {
caught = e;
} finally {
assertNotNull("null stream exception", caught);
}
} finally {
Debug.set(Debug.ERROR, errorOn);
}
}
@SuppressWarnings("serial")
public static class SerializationInjector implements Serializable {
private boolean onRead;
private boolean onWrite;
public SerializationInjector(boolean onRead, boolean onWrite) {
this.onRead = onRead;
this.onWrite = onWrite;
}
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
onRead = stream.readBoolean();
onWrite = stream.readBoolean();
if (onRead) {
throw new IOException();
}
}
private void writeObject(ObjectOutputStream stream) throws IOException {
if (onWrite) {
throw new IOException();
}
stream.writeBoolean(onRead);
stream.writeBoolean(onWrite);
}
}
public void testGetBytes_Object() {
assertNotNull("long", UtilObject.getBytes(Long.valueOf(0)));
assertNotNull("injector good", UtilObject.getBytes(new SerializationInjector(false, false)));
boolean errorOn = Debug.isOn(Debug.ERROR);
try {
Debug.set(Debug.ERROR, false);
assertNull("injector bad", UtilObject.getBytes(new SerializationInjector(false, true)));
assertNull("long", UtilObject.getBytes(this));
} finally {
Debug.set(Debug.ERROR, errorOn);
}
}
public void testGetObject() {
Long one = Long.valueOf(1);
byte[] oneBytes = UtilObject.getBytes(one);
assertNotNull("oneBytes", oneBytes);
assertEquals("one getObject", one, UtilObject.getObject(oneBytes));
boolean errorOn = Debug.isOn(Debug.ERROR);
try {
Debug.set(Debug.ERROR, false);
assertNull("parse empty array", UtilObject.getObject(new byte[0]));
// simulate a ClassNotFoundException
Object groovySerializable = GroovyUtil.eval("class foo implements java.io.Serializable { }; return new foo()", new HashMap<String, Object>());
byte[] groovySerializableBytes = UtilObject.getBytes(groovySerializable);
assertNotNull("groovySerializableBytes", groovySerializableBytes);
assertNull("groovyDeserializable", UtilObject.getObject(groovySerializableBytes));
byte[] injectorBytes = UtilObject.getBytes(new SerializationInjector(false, false));
assertNotNull("injectorBytes good", injectorBytes);
assertNotNull("injector good", UtilObject.getObject(injectorBytes));
injectorBytes = UtilObject.getBytes(new SerializationInjector(true, false));
assertNotNull("injectorBytes bad", injectorBytes);
assertNull("injector bad", UtilObject.getObject(injectorBytes));
} finally {
Debug.set(Debug.ERROR, errorOn);
}
}
public void testGetByteCount() throws Exception {
assertNotSame("long", 0, UtilObject.getByteCount(Long.valueOf(0)));
Exception caught = null;
try {
UtilObject.getByteCount(this);
} catch (IOException e) {
caught = e;
} finally {
assertNotNull("exception thrown", caught);
}
}
public void testEqualsHelper() {
assertTrue("a == a", UtilObject.equalsHelper(this, this));
assertFalse("null == a", UtilObject.equalsHelper(null, this));
assertFalse("a == null", UtilObject.equalsHelper(this, null));
assertTrue("null == null", UtilObject.equalsHelper(null, null));
assertTrue("map == map", UtilObject.equalsHelper(new HashMap<String, Object>(), new HashMap<String, Object>()));
assertFalse("map == this", UtilObject.equalsHelper(new HashMap<String, Object>(), this));
assertFalse("this == map", UtilObject.equalsHelper(this, new HashMap<String, Object>()));
}
public void testCompareToHelper() {
Long one = Long.valueOf(1);
Long two = Long.valueOf(2);
assertComparison("one <-> two", -1, UtilObject.compareToHelper(one, two));
assertComparison("one <-> one", 0, UtilObject.compareToHelper(one, one));
assertComparison("two <-> one", 1, UtilObject.compareToHelper(two, one));
assertComparison("one <-> null", 1, UtilObject.compareToHelper(one, null));
assertComparison("null <-> one", -1, UtilObject.compareToHelper(null, one));
}
public void testDoHashCode() throws Exception {
UtilObject.doHashCode(this);
UtilObject.doHashCode(null);
UtilObject.doHashCode(0);
UtilObject.doHashCode(new Object[] { this, Object.class });
UtilObject.doHashCode(new Object[] { null, Object.class });
UtilObject.doHashCode(new int[] { 1, 3 });
}
public interface TestFactoryIntf extends Factory<Object, Set<String>> {
}
public static class FirstTestFactory implements TestFactoryIntf {
public Object getInstance(Set<String> set) {
if (!set.contains("first")) return null;
if (set.contains("one")) return "ONE";
if (set.contains("two")) return "TWO";
if (set.contains("three")) return "THREE";
return null;
}
}
public static class SecondTestFactory implements TestFactoryIntf {
public Object getInstance(Set<String> set) {
if (!set.contains("second")) return null;
if (set.contains("ONE")) return "1";
if (set.contains("TWO")) return "2";
if (set.contains("THREE")) return "3";
return null;
}
}
public void testGetObjectFromFactory() throws Exception {
assertEquals("first one", "ONE", UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("first", "one")));
assertEquals("first two", "TWO", UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("first", "two")));
assertEquals("first three", "THREE", UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("first", "three")));
assertEquals("first null", "1", UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("first", "second", "ONE")));
assertEquals("second one", "1", UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("second", "ONE")));
assertEquals("second two", "2", UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("second", "TWO")));
assertEquals("second three", "3", UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("second", "THREE")));
Exception caught = null;
try {
UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("first"));
} catch (ClassNotFoundException e) {
caught = e;
} finally {
assertNotNull("nothing found first", caught);
}
caught = null;
try {
UtilObject.getObjectFromFactory(TestFactoryIntf.class, set("second"));
} catch (ClassNotFoundException e) {
caught = e;
} finally {
assertNotNull("nothing found second", caught);
}
}
}