/*
 * Copyright 2005 The Apache Software Foundation.
 * 
 * Licensed 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.jdo.test;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;

import org.apache.jdo.pc.serializable.PCClass1;
import org.apache.jdo.pc.serializable.PCClass2A;
import org.apache.jdo.pc.serializable.PCClass2B;
import org.apache.jdo.pc.serializable.PCSub3;
import org.apache.jdo.pc.serializable.PCSub4A;
import org.apache.jdo.pc.serializable.PCSub4B;
import org.apache.jdo.pc.serializable.PCSuper;
import org.apache.jdo.test.util.AbstractTest;
import org.apache.jdo.test.util.JDORITestRunner;
/**
* Tests that the enhancer adds method writeObject or adds a call of 
* jdoPreSerialize to an existing method writeObject or writeReplace.
*
* @author Michael Bouschen
*/
public class Test_SerializeComplex extends AbstractTest {

    /** name of the writeObject method */
    public static String WRITE_OBJECT_NAME = "writeObject";
    /** parameter types of the writeObject method */
    public static Class[] WRITE_OBJECT_PARAMS = { ObjectOutputStream.class };

    /** */
    public static void main(String args[]) {
        JDORITestRunner.run(Test_SerializeComplex.class);
    }

    /**
     * This method checks whether the enhanced pc classes have or have not
     * the method writeObject.
     */
    public void testSerializationSupportMethods()
    {
        // PCClass1 must have writeObject
        try {
            PCClass1.class.getDeclaredMethod(WRITE_OBJECT_NAME, WRITE_OBJECT_PARAMS);
            if (debug)
                logger.debug("OK: Class PCClass1 has method " + WRITE_OBJECT_NAME);
        }
        catch (NoSuchMethodException ex) {
            fail("ERROR: missing method " + WRITE_OBJECT_NAME + " in class PCClass1");
        }

        // PCClass2A must have writeObject
        try {
            PCClass2A.class.getDeclaredMethod(WRITE_OBJECT_NAME, WRITE_OBJECT_PARAMS);
            if (debug)
                logger.debug("OK: Class PCClass2A has method " + WRITE_OBJECT_NAME);
        }
        catch (NoSuchMethodException ex) {
            fail("ERROR: missing method " + WRITE_OBJECT_NAME + " in class PCClass2A");
        }

        // PCClass2B must NOT have writeObject
        try {
            PCClass2B.class.getDeclaredMethod(WRITE_OBJECT_NAME, WRITE_OBJECT_PARAMS);
            fail("ERROR: Class PCClass1 must not have method " + WRITE_OBJECT_NAME);
        }
        catch (NoSuchMethodException ex) {
            if (debug)
                logger.debug("OK: Class PCClass2B does not have method " + WRITE_OBJECT_NAME);
        }

        // PCSuper must NOT have writeObject
        try {
            PCSuper.class.getDeclaredMethod(WRITE_OBJECT_NAME, WRITE_OBJECT_PARAMS);
            fail("ERROR: Class PCSuper must not have method " + WRITE_OBJECT_NAME);
        }
        catch (NoSuchMethodException ex) {
            if (debug)
                logger.debug("OK: Class PCSuper does not have method " + WRITE_OBJECT_NAME);
        }
        // PCSub4A must have writeObject
        try {
            PCSub4A.class.getDeclaredMethod(WRITE_OBJECT_NAME, WRITE_OBJECT_PARAMS);
            if (debug)
                logger.debug("OK: Class PCSub4A has method " + WRITE_OBJECT_NAME);
        }
        catch (NoSuchMethodException ex) {
            fail("ERROR: missing method " + WRITE_OBJECT_NAME + " in class PCSub4A");
        }

        // PCSub4B must NOT have writeObject
        try {
            PCSub4B.class.getDeclaredMethod(WRITE_OBJECT_NAME, WRITE_OBJECT_PARAMS);
            fail("ERROR: Class PCSub4B must not have method " + WRITE_OBJECT_NAME);
        }
        catch (NoSuchMethodException ex) {
            if (debug)
                logger.debug("OK: Class PCSub4B does not have method " + WRITE_OBJECT_NAME);
        }
    }

    /**
     * This method creates pc instances, commits the transaction and then
     * seralizes the pc instances.
     */
    public void testSerialization() throws Exception {
        PersistenceManager pm = null;
        Transaction tx = null;
        try {
            if (debug) logger.debug("\nINSERT");
            pm = pmf.getPersistenceManager();
            tx = pm.currentTransaction();
            tx.setRetainValues(false);

            tx.begin();
            PCClass1 o1 = new PCClass1(1, 1); 
            pm.makePersistent(o1);
            Object o1Oid = pm.getObjectId(o1);
            PCClass2A o2 = new PCClass2A(2, 2); 
            pm.makePersistent(o2);
            Object o2Oid = pm.getObjectId(o2);
            PCClass2B o3 = new PCClass2B(3, 3); 
            pm.makePersistent(o3);
            Object o3Oid = pm.getObjectId(o3);
            PCSub3 o4 = new PCSub3(4, 4, "4", "4"); 
            pm.makePersistent(o4);
            Object o4Oid = pm.getObjectId(o4);
            PCSub4A o5 = new PCSub4A(5, 5, "5", "5"); 
            pm.makePersistent(o5);
            Object o5Oid = pm.getObjectId(o5);
            PCSub4B o6 = new PCSub4B(6, 6, "6", "6"); 
            pm.makePersistent(o6);
            Object o6Oid = pm.getObjectId(o6);
            tx.commit(); tx = null;
            pm.close(); pm = null;

            if (debug) logger.debug("\nSERIALIZE HOLLOW instances");
            doSerialize(o1Oid, false, new PCClass1(1, 0));
            doSerialize(o1Oid, true,  new PCClass1(Integer.MIN_VALUE, 0));
            doSerialize(o2Oid, false, new PCClass2A(2, 0));
            doSerialize(o2Oid, true,  new PCClass2A(Integer.MIN_VALUE, 0));
            doSerialize(o3Oid, false, new PCClass2B(3, 0));
            doSerialize(o3Oid, true,  new PCClass2B(Integer.MIN_VALUE, 0));
            doSerialize(o4Oid, false, new PCSub3(Integer.MIN_VALUE,
                        Integer.MIN_VALUE, "4", null));
            doSerialize(o4Oid, true,  new PCSub3(Integer.MIN_VALUE,
                        Integer.MIN_VALUE, "empty", null));
            doSerialize(o5Oid, false, new PCSub4A(Integer.MIN_VALUE,
                        Integer.MIN_VALUE, "5", null));
            doSerialize(o5Oid, true,  new PCSub4A(Integer.MIN_VALUE,
                        Integer.MIN_VALUE, "empty", null));
            doSerialize(o6Oid, false, new PCSub4B(Integer.MIN_VALUE,
                        Integer.MIN_VALUE, "6", null));
            doSerialize(o6Oid, true,  new PCSub4B(Integer.MIN_VALUE,
                        Integer.MIN_VALUE, "empty", null));
        }
        finally {
            if (tx != null && tx.isActive())
                tx.rollback();
            if (pm != null && !pm.isClosed())
                pm.close();
        }
    }

    /**
     *
     */
    protected void doSerialize(Object oid, 
                               boolean makeTransient, 
                               Object expected) throws Exception 
    {
        PersistenceManager pm = null;
        try {
            // get the object
            pm = pmf.getPersistenceManager();
            Object o = pm.getObjectById(oid, false);
            
            // makeTransient?
            if (makeTransient)
                pm.makeTransient(o);

            // serialize
            ByteArrayOutputStream bout = new ByteArrayOutputStream ();
            ObjectOutputStream oout = new ObjectOutputStream (bout);
            oout.writeObject(o);
            oout.flush ();
            if (debug) logger.debug("Wrote: " + o);
            byte[] bytes = bout.toByteArray();
            oout.close ();
            
            // deserialize 
            ByteArrayInputStream bin = new ByteArrayInputStream (bytes);
            ObjectInputStream oin = new ObjectInputStream (bin);
            Object read = oin.readObject();
            if (debug) logger.debug("Read:  " + read);
            oin.close ();

            assertEquals("Unexpected deserialized object", expected, read);
        } 
        finally {
            if (pm != null && !pm.isClosed())
                pm.close();
        }
    }
    
    
}