/**
*
* 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.tuscany.sdo.test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;
import junit.framework.TestCase;
import org.apache.tuscany.sdo.util.SDOUtil;
import commonj.sdo.DataGraph;
import commonj.sdo.DataObject;
import commonj.sdo.Type;
import commonj.sdo.helper.DataFactory;
import commonj.sdo.helper.HelperContext;
import commonj.sdo.helper.TypeHelper;
public class JavaSerializeDeserializeTestCase extends TestCase
{
public void testScopeDefinedSerializeDeserializeOfDataObject()
{
HelperContext hc = SDOUtil.createHelperContext();
Object originalDataObject = createDynamically(hc,true);
runSerializeDeserialize((DataObject)originalDataObject, hc);
}
public void testScopeDefinedSerializeDeserializeOfDataGraph()
{
HelperContext hc = SDOUtil.createHelperContext();
DataGraph testDO = (DataGraph)createDynamically(hc,false);
runSerializeDeserializeWithDataGraph(testDO, hc);
}
private String xsdString = "" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"" +
"";
public void testLargePayload()
{
HelperContext hc = SDOUtil.createHelperContext();
hc.getXSDHelper().define(xsdString);
DataObject company = hc.getDataFactory().create("http://www.example.com/simple", "Company");
company.setString("symbol", "EXAMPLE");
company.setString("companyName", "Example Inc.");
List employees = company.getList("employees");
DataObject employee;
for (int i=0; i<1000; i++) {
employee = hc.getDataFactory().create("http://www.example.com/simple", "Employee");
employee.setString("employeeID", "ID #" + i);
employee.setString("employeeName", "Empoyee #" + i);
employees.add(employee);
}
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = SDOUtil.createObjectOutputStream(bos, hc);
oos.writeObject(company);
oos.flush();
byte[] bytes = bos.toByteArray();
oos.close();
bos.close();
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = SDOUtil.createObjectInputStream(bis, hc);
ois.readObject();
ois.close();
bis.close();
}
catch (Exception e) {
e.printStackTrace();
fail("An Exception occurred while deserializing the output of the serialization: " + e.toString());
}
}
/**
* Serialize the DataObject then Deserialize the output.
* to testDO.
* @param testDO
* @param scope
*/
public void runSerializeDeserialize(DataObject originalDataObject, HelperContext hc)
{
populateFields(originalDataObject);
DataObject tempDO = null;
ByteArrayOutputStream baos = null;
try
{
baos = serialize(originalDataObject, hc);
}
catch (Exception e)
{
e.printStackTrace();
fail("An Exception occurred while serializing the DataObject: " + e.toString());
}
try
{
tempDO = deserialize(baos, hc);
}
catch (Exception e)
{
e.printStackTrace();
fail("An Exception occurred while deserializing the output of the serialization: " + e.toString());
}
assertNotNull("Deserialization returned a null value.", tempDO);
assertSame(tempDO.getType(), originalDataObject.getType());
}
/**
* Serialize the DataGraph
* @param dataGraph
* @param scope
*/
public void runSerializeDeserializeWithDataGraph(DataGraph dataGraph, HelperContext hc)
{
DataObject originalDataObject = dataGraph.getRootObject();
populateFields(originalDataObject);
DataObject tempDO = null;
ByteArrayOutputStream baos = null;
try
{
baos = serialize(dataGraph, hc);
}
catch (Exception e)
{
e.printStackTrace();
fail("An Exception occurred while serializing the DataObject: " + e.toString());
}
try
{
tempDO = deserialize(baos, hc);
}
catch (Exception e)
{
e.printStackTrace();
fail("An Exception occurred while deserializing the output of the serialization: " + e.toString());
}
assertNotNull("Deserialization returned a null value.", tempDO);
assertSame(tempDO.getType(), originalDataObject.getType());
}
/**
* serializeDataObject is a private method to be called by the other methods
* in the ScrenarioLibrary
*
* @param dataObject
* @param fileName
* @throws IOException
*/
public ByteArrayOutputStream serialize(Object object, HelperContext hc) throws IOException
{
//FileOutputStream fos = new FileOutputStream("temp");
ByteArrayOutputStream byteArrayOutput = new ByteArrayOutputStream();
ObjectOutputStream out = SDOUtil.createObjectOutputStream(byteArrayOutput, hc);
out.writeObject(object);
out.close();
return byteArrayOutput;
}
/**
* deserializeDataObject is a private method to be called by the other
* methods in the ScrenarioLibrary
*
* @param fileName
* @return
* @throws IOException
* @throws ClassNotFoundException
*/
public DataObject deserialize(ByteArrayOutputStream baos, HelperContext hc) throws IOException, ClassNotFoundException
{
//FileInputStream fis = new FileInputStream("temp");
ObjectInputStream input = null;
ByteArrayInputStream byteArrayInput = new ByteArrayInputStream(baos.toByteArray());
input = SDOUtil.createObjectInputStream(byteArrayInput, hc);
Object object = input.readObject();
input.close();
if(object instanceof DataGraph)
return ((DataGraph)object).getRootObject();
else
return (DataObject)object;
}
/**
* populateFields uses set to set each of the fields in the
* DataObject. It is used to ensure a known set of expected values that are
* not other than the default values for the various fields.
*
* @param testDO
* @throws ExpectedConditionError
*/
public static void populateFields(DataObject testDO)
{
testDO.setString("stringVal", "Testing");
}
/**
* createDynamically() creates the SDO Types using the TypeHelper. This method should be kept in
* synch with the XSD used for createDynamicallyWithStaticResources. The same XSD is used for
* the static generation of SDO Types using XSD2JavaGenerator.
*/
public Object createDynamically(HelperContext hc, boolean createDataObject)
{
TypeHelper types = hc.getTypeHelper();
DataFactory dataFactory = hc.getDataFactory();
Type stringType = types.getType("commonj.sdo", "String");
DataObject testType = dataFactory.create("commonj.sdo", "Type");
testType.set("uri", "http://www.example.com/api_test");
testType.set("name", "APITest");
DataObject stringProperty = testType.createDataObject("property");
stringProperty.set("name", "stringVal");
stringProperty.set("type", stringType);
List types2Define = new ArrayList();
types2Define.add(testType);
List apiXSD = types.define(types2Define);
Type apiXSDType = (Type) apiXSD.get(0);
if(createDataObject)
return dataFactory.create(apiXSDType);;
// Create an empty DataGraph and attach the document root to it. Otherwise, where is the documentRoot ?
DataGraph dataGraph = SDOUtil.createDataGraph();
/*DataObject testDO =*/ dataGraph.createRootObject(apiXSDType);
return dataGraph;
}
}