/*
 * Copyright (c) 2012, 2020 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Mike Norman: Jan 2012 - Initial implementation
package dbws.testing.shadowddlgeneration;

import static dbws.testing.DBWSTestSuite.DATABASE_DDL_CREATE_KEY;
import static dbws.testing.DBWSTestSuite.DATABASE_DDL_DEBUG_KEY;
import static dbws.testing.DBWSTestSuite.DATABASE_DDL_DROP_KEY;
import static dbws.testing.DBWSTestSuite.DATABASE_USERNAME_KEY;
import static dbws.testing.DBWSTestSuite.DEFAULT_DATABASE_DDL_CREATE;
import static dbws.testing.DBWSTestSuite.DEFAULT_DATABASE_DDL_DEBUG;
import static dbws.testing.DBWSTestSuite.DEFAULT_DATABASE_DDL_DROP;
import static dbws.testing.DBWSTestSuite.DEFAULT_DATABASE_USERNAME;
import static dbws.testing.DBWSTestSuite.buildConnection;
import static dbws.testing.DBWSTestSuite.removeLineTerminators;
import static dbws.testing.DBWSTestSuite.runDdl;
import static dbws.testing.shadowddlgeneration.oldjpub.Util.IS_PACKAGE;
import static org.eclipse.persistence.tools.dbws.Util.sqlMatch;
import static org.junit.Assert.assertEquals;

//javase imports
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;

//EclipseLink imports
import org.eclipse.persistence.tools.dbws.oracle.ShadowDDLGenerator;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLCollectionType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLPackageType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLRecordType;
import org.eclipse.persistence.tools.oracleddl.parser.ParseException;
import org.eclipse.persistence.tools.oracleddl.util.DatabaseTypeBuilder;

//java eXtension imports

//JUnit4 imports
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

//test imports
import dbws.testing.shadowddlgeneration.oldjpub.AttributeField;
import dbws.testing.shadowddlgeneration.oldjpub.MethodFilter;
import dbws.testing.shadowddlgeneration.oldjpub.PlsqlRecordType;
import dbws.testing.shadowddlgeneration.oldjpub.PlsqlTableType;
import dbws.testing.shadowddlgeneration.oldjpub.ProcedureMethod;
import dbws.testing.shadowddlgeneration.oldjpub.PublisherException;
import dbws.testing.shadowddlgeneration.oldjpub.SqlReflector;
import dbws.testing.shadowddlgeneration.oldjpub.SqlTypeWithMethods;
import dbws.testing.shadowddlgeneration.oldjpub.TypeClass;

public class ShadowDDLGenerationTestSuite {

    static final String SHADOWDDLTEST_PACKAGE = "SHADOWDDLTEST";
    static final String SHADOWDDLTEST_PROCEDURE = "P1";
    static final String SHADOWDDLTEST_RECORD_TYPE = "NUM_RECORD";
    static final String SHADOWDDLTEST_TABLE_TYPE = "NUM_TBL";
    static final String SHADOWDDLTEST_TABLE_TYPE2 = "NUM_TBL2";
    static final String SHADOWDDLTEST_TABLE_TYPE3 = "NONASSO_ARRAY";
    static final String SHADOWDDLTEST_RECORD_TYPE2 = "NUM_RECORD2";
    static final String SHADOWDDLTEST_RECORD_TYPE3 = "NUM_RECORD3";
    static final String CREATE_SHADOWDDLTEST_PACKAGE =
        "CREATE OR REPLACE PACKAGE " + SHADOWDDLTEST_PACKAGE + " AS" +
            "\nTYPE " + SHADOWDDLTEST_TABLE_TYPE + " IS TABLE OF NUMBER INDEX BY BINARY_INTEGER;" +
            "\nTYPE " + SHADOWDDLTEST_RECORD_TYPE3 + " IS RECORD (" +
                "\nF1 VARCHAR2(10)," +
                "\nF2 NUMBER," +
                "\nF3 DATE" +
            "\n);" +
            "\nTYPE " + SHADOWDDLTEST_TABLE_TYPE3 + " IS TABLE OF VARCHAR2(20);" +
            "\nTYPE " + SHADOWDDLTEST_RECORD_TYPE + " IS RECORD (" +
                "\nN1 INTEGER," +
                "\nN2 SMALLINT," +
                "\nN3 NUMERIC," +
                "\nN4 DEC," +
                "\nN5 DECIMAL," +
                "\nN6 DECIMAL(7,2)," +
                "\nN7 NUMBER," +
                "\nN8 VARCHAR(10)," +
                "\nN9 VARCHAR2(10)," +
                "\nN10 CHAR," +
                "\nN11 REAL," +
                "\nN12 FLOAT," +
                "\nN13 DOUBLE PRECISION," +
                "\nN14 DATE," +
                "\nN15 TIMESTAMP," +
                "\nN16 CLOB," +
                "\nN17 BLOB," +
                "\nN18 LONG," +
                "\nN19 LONG RAW," +
                "\nN20 RAW(50)," +
                "\nN21 BINARY_DOUBLE," +
                "\nN22 BINARY_FLOAT," +
                "\nN23 BINARY_INTEGER," +
                "\nN24 BOOLEAN," +
                "\nN25 NATURAL," +
                "\nN26 PLS_INTEGER," +
                "\nN27 POSITIVE," +
                "\nN28 ROWID," +
                "\nN29 SIGNTYPE," +
                "\nN30 SIMPLE_INTEGER DEFAULT 0," +
                "\nN31 SIMPLE_DOUBLE DEFAULT 0," +
                "\nN32 SIMPLE_FLOAT DEFAULT 0," +
                "\nN33 " + SHADOWDDLTEST_TABLE_TYPE + "," +
                "\nN34 " + SHADOWDDLTEST_TABLE_TYPE3 + "," +
                "\nN35 " + SHADOWDDLTEST_RECORD_TYPE3 +
            "\n);" +
            "\nTYPE " + SHADOWDDLTEST_TABLE_TYPE2 + " IS TABLE OF " + SHADOWDDLTEST_RECORD_TYPE + ";" +
            "\nTYPE " + SHADOWDDLTEST_RECORD_TYPE2 + " IS RECORD (" +
                "\nA1 " + SHADOWDDLTEST_TABLE_TYPE2 + "," +
                "\nA2 " + SHADOWDDLTEST_RECORD_TYPE +
            "\n);" +
            "\nPROCEDURE " + SHADOWDDLTEST_PROCEDURE + "(NR2 IN " + SHADOWDDLTEST_RECORD_TYPE2 + ");" +
        "\nEND " + SHADOWDDLTEST_PACKAGE + ";";
    static final String CREATE_SHADOWDDLTEST_PACKAGE_BODY =
        "CREATE OR REPLACE PACKAGE BODY " + SHADOWDDLTEST_PACKAGE + " AS" +
            "\nPROCEDURE " + SHADOWDDLTEST_PROCEDURE + "(NR2 IN " + SHADOWDDLTEST_RECORD_TYPE2 + ") AS" +
            "\nBEGIN" +
                "\nnull;" +
            "\nEND " + SHADOWDDLTEST_PROCEDURE + ";" +
        "\nEND " + SHADOWDDLTEST_PACKAGE + ";";
    static final String DROP_SHADOWDDLTEST_PACKAGE =
        "DROP PACKAGE " + SHADOWDDLTEST_PACKAGE;

    //JUnit 'fixture's
    static boolean ddlCreate = false;
    static boolean ddlDrop = false;
    static boolean ddlDebug = false;
    static String username = null;
    static Connection conn = null;
    static PLSQLPackageType shadowDDLTestPackage = null;

    @BeforeClass
    public static void setUp() throws ParseException, ClassNotFoundException, SQLException {
        username = System.getProperty(DATABASE_USERNAME_KEY, DEFAULT_DATABASE_USERNAME);
        conn = buildConnection();
        String ddlCreateProp = System.getProperty(DATABASE_DDL_CREATE_KEY, DEFAULT_DATABASE_DDL_CREATE);
        if ("true".equalsIgnoreCase(ddlCreateProp)) {
            ddlCreate = true;
        }
        String ddlDropProp = System.getProperty(DATABASE_DDL_DROP_KEY, DEFAULT_DATABASE_DDL_DROP);
        if ("true".equalsIgnoreCase(ddlDropProp)) {
            ddlDrop = true;
        }
        String ddlDebugProp = System.getProperty(DATABASE_DDL_DEBUG_KEY, DEFAULT_DATABASE_DDL_DEBUG);
        if ("true".equalsIgnoreCase(ddlDebugProp)) {
            ddlDebug = true;
        }
        if (ddlCreate) {
            runDdl(conn, CREATE_SHADOWDDLTEST_PACKAGE, ddlDebug);
            runDdl(conn, CREATE_SHADOWDDLTEST_PACKAGE_BODY, ddlDebug);
        }
        shadowDDLTestPackage = new DatabaseTypeBuilder().buildPackages(conn, username,
            SHADOWDDLTEST_PACKAGE).get(0);
    }

    @AfterClass
    public static void tearDown() {
        if (ddlDrop) {
            runDdl(conn, DROP_SHADOWDDLTEST_PACKAGE, ddlDebug);
        }
    }

    @Test
    public void testOldJPubDDLGeneration() throws SQLException, PublisherException {
        SqlReflector sqlReflector = new SqlReflector(conn, username);
        SqlTypeWithMethods methodType = (SqlTypeWithMethods)sqlReflector.addSqlUserType(
            username.toUpperCase(), SHADOWDDLTEST_PACKAGE, IS_PACKAGE, true, 0, 0,
            new MethodFilter() {
                @Override
                public boolean acceptMethod(ProcedureMethod method, boolean preApprove) {
                    String methodName = method.getName();
                    if (sqlMatch(SHADOWDDLTEST_PROCEDURE, methodName)) {
                        return true;
                    }
                    return false;
                }

            }
         );
        String numRecord2CreateDDL = null;
        String numRecord2DropDDL = null;
        String numRecordCreateDDL = null;
        String numRecordDropDDL = null;
        String numTblCreateDDL = null;
        String numTblDropDDL = null;
        String numTbl2CreateDDL = null;
        String numTbl2DropDDL = null;
        String numTbl3CreateDDL = null;
        String numTbl3DropDDL = null;
        String numRecord3CreateDDL = null;
        String numRecord3DropDDL = null;
        List<ProcedureMethod> methods = methodType.getDeclaredMethods();
        for (TypeClass typeClass : methods.get(0).getParamTypes()) {
            if (typeClass.getName().contains(SHADOWDDLTEST_RECORD_TYPE2)) {
                PlsqlRecordType record2Type = (PlsqlRecordType)typeClass;
                numRecord2CreateDDL = removeLineTerminators(record2Type.getSqlTypeDecl());
                numRecord2DropDDL = removeLineTerminators(record2Type.getSqlTypeDrop());
                List<AttributeField> record2Fields = record2Type.getFields(false);
                TypeClass fieldA1 = getFieldFromRecords(record2Fields, "A1").getType();
                PlsqlTableType numTbl2Type = (PlsqlTableType)fieldA1;
                numTbl2CreateDDL = removeLineTerminators(numTbl2Type.getSqlTypeDecl());
                numTbl2DropDDL = removeLineTerminators(numTbl2Type.getSqlTypeDrop());
                TypeClass fieldA2 = getFieldFromRecords(record2Fields, "A2").getType();
                PlsqlRecordType recordType = (PlsqlRecordType)fieldA2;
                numRecordCreateDDL = removeLineTerminators(recordType.getSqlTypeDecl());
                numRecordDropDDL = removeLineTerminators(recordType.getSqlTypeDrop());
                List<AttributeField> recordFields = recordType.getFields(false);
                TypeClass fieldN33 = getFieldFromRecords(recordFields, "N33").getType();
                PlsqlTableType numTblType = (PlsqlTableType)fieldN33;
                numTblCreateDDL = removeLineTerminators(numTblType.getSqlTypeDecl());
                numTblDropDDL = removeLineTerminators(numTblType.getSqlTypeDrop());
                TypeClass fieldN34 = getFieldFromRecords(recordFields, "N34").getType();
                PlsqlTableType numTbl3Type = (PlsqlTableType)fieldN34;
                numTbl3CreateDDL = removeLineTerminators(numTbl3Type.getSqlTypeDecl());
                numTbl3DropDDL = removeLineTerminators(numTbl3Type.getSqlTypeDrop());
                TypeClass fieldN35 = getFieldFromRecords(recordFields, "N35").getType();
                PlsqlRecordType recordType3 = (PlsqlRecordType)fieldN35;
                numRecord3CreateDDL = removeLineTerminators(recordType3.getSqlTypeDecl());
                numRecord3DropDDL = removeLineTerminators(recordType3.getSqlTypeDrop());
            }
        }
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE2 +
            " does not match expected shadow DDL", numRecord2CreateDDL,
            EXPECTED_NUMRECORD2_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE2 +
            " does not match expected shadow DDL", numRecord2DropDDL,
            EXPECTED_NUMRECORD2_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE +
            " does not match expected shadow DDL", numRecordCreateDDL,
            EXPECTED_NUMRECORD_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE +
            " does not match expected shadow DDL", numRecordDropDDL, EXPECTED_NUMRECORD_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE +
            " does not match expected shadow DDL", numTblCreateDDL, EXPECTED_NUMTBL_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE +
            " does not match expected shadow DDL", numTblDropDDL, EXPECTED_NUMTBL_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE2 +
            " does not match expected shadow DDL", numTbl2CreateDDL, EXPECTED_NUMTBL2_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE2 +
            " does not match expected shadow DDL", numTbl2DropDDL, EXPECTED_NUMTBL2_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE3 +
            " does not match expected shadow DDL", numTbl3CreateDDL, EXPECTED_NUMTBL3_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE3 +
            " does not match expected shadow DDL", numTbl3DropDDL, EXPECTED_NUMTBL3_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE3 +
            " does not match expected shadow DDL", numRecord3CreateDDL , EXPECTED_NUMRECORD3_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE3 +
            " does not match expected shadow DDL", numRecord3DropDDL, EXPECTED_NUMRECORD3_DROP_SHADOWDDL);
    }

    private AttributeField getFieldFromRecords(List<AttributeField> record2Fields, String name) {
        for (AttributeField f: record2Fields) {
            if (name.equals(f.getName())) {
                return f;
            }
        }
        return null;
    }

    static final String EXPECTED_NUMRECORD2_CREATE_SHADOWDDL =
        "CREATE OR REPLACE TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE2 + " AS OBJECT (" +
        "      A1 " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE2 + "," + //original definition: NUM_TBL2
        "      A2 " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE +       //original definition: NUM_RECORD
        ");";
    static final String EXPECTED_NUMRECORD2_DROP_SHADOWDDL =
        "DROP TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE2 + " FORCE;";
    static final String EXPECTED_NUMRECORD_CREATE_SHADOWDDL =
        "CREATE OR REPLACE TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE + " AS OBJECT (" +
        "      N1 NUMBER(38)," +                //original definition: INTEGER
        "      N2 NUMBER(38)," +                //original definition: SMALLINT
        "      N3 NUMBER(38)," +                //original definition: NUMERIC
        "      N4 NUMBER(38)," +                //original definition: DEC
        "      N5 NUMBER(38)," +                //original definition: DECIMAL
        "      N6 NUMBER(7, 2)," +              //original definition: DECIMAL(7,2)
        "      N7 NUMBER," +                    //original definition: NUMBER
        "      N8 VARCHAR2(10)," +              //original definition: VARCHAR(10)
        "      N9 VARCHAR2(10)," +              //original definition: VARCHAR2(10)
        "      N10 CHAR(1)," +                  //original definition: CHAR
        "      N11 FLOAT(63)," +                //original definition: REAL
        "      N12 FLOAT(126)," +               //original definition: FLOAT
        "      N13 FLOAT(126)," +               //original definition: DOUBLE PRECISION
        "      N14 DATE," +                     //original definition: DATE
        "      N15 TIMESTAMP," +                //original definition: TIMESTAMP
        "      N16 CLOB," +                     //original definition: CLOB
        "      N17 BLOB," +                     //original definition: BLOB
        "      N18 VARCHAR2(32760)," +          //original definition: LONG
        "      N19 RAW(32760)," +               //original definition: LONG RAW
        "      N20 RAW(50)," +                  //original definition: RAW(50)
        "      N21 BINARY_DOUBLE," +            //original definition: BINARY_DOUBLE
        "      N22 BINARY_FLOAT," +             //original definition: BINARY_FLOAT
        "      N23 INTEGER," +                  //original definition: BINARY_INTEGER
        "      N24 INTEGER," +                  //original definition: BOOLEAN
        "      N25 INTEGER," +                  //original definition: NATURAL
        "      N26 INTEGER," +                  //original definition: PLS_INTEGER
        "      N27 INTEGER," +                  //original definition: POSITIVE
        "      N28 VARCHAR2(256)," +            //original definition: ROWID
        "      N29 INTEGER," +                  //original definition: SIGNTYPE
        "      N30 INTEGER," +                  //original definition: SIMPLE_INTEGER
        "      N31 BINARY_DOUBLE," +            //original definition: SIMPLE_DOUBLE
        "      N32 BINARY_FLOAT," +             //original definition: SIMPLE_FLOAT
        "      N33 " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE + "," +
        "      N34 " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE3 + "," +
        "      N35 " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE3 +
        ");";
    static final String EXPECTED_NUMRECORD_DROP_SHADOWDDL =
        "DROP TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE + " FORCE;";
    static final String EXPECTED_NUMTBL_CREATE_SHADOWDDL =
        "CREATE OR REPLACE TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE +
            " AS TABLE OF NUMBER;";
    static final String EXPECTED_NUMTBL_DROP_SHADOWDDL =
        "DROP TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE + " FORCE;";
    static final String EXPECTED_NUMTBL2_CREATE_SHADOWDDL =
        "CREATE OR REPLACE TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE2 +
            " AS TABLE OF " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE + ";";
    static final String EXPECTED_NUMTBL2_DROP_SHADOWDDL =
        "DROP TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE2 + " FORCE;";
    static final String EXPECTED_NUMTBL3_CREATE_SHADOWDDL =
        "CREATE OR REPLACE TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE3 +
            " AS TABLE OF VARCHAR2(20);";
    static final String EXPECTED_NUMTBL3_DROP_SHADOWDDL =
        "DROP TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_TABLE_TYPE3 + " FORCE;";
    static final String EXPECTED_NUMRECORD3_CREATE_SHADOWDDL =
        "CREATE OR REPLACE TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE3 + " AS OBJECT (" +
        "      F1 VARCHAR2(10)," +
        "      F2 NUMBER," +
        "      F3 DATE" +
        ");";
    static final String EXPECTED_NUMRECORD3_DROP_SHADOWDDL =
        "DROP TYPE " + SHADOWDDLTEST_PACKAGE + "_" + SHADOWDDLTEST_RECORD_TYPE3 + " FORCE;";

    @Test
    public void testNewShadowDDLGeneration() {
        ShadowDDLGenerator shadowDDLGenerator = new ShadowDDLGenerator(shadowDDLTestPackage);
        PLSQLCollectionType collectionType = (PLSQLCollectionType)shadowDDLTestPackage.getTypes().get(0);
        String numTblCreateDDL = removeLineTerminators(shadowDDLGenerator.getCreateDDLFor(collectionType));
        String numTblDropDDL = removeLineTerminators(shadowDDLGenerator.getDropDDLFor(collectionType));
        PLSQLRecordType recordType3 = (PLSQLRecordType)shadowDDLTestPackage.getTypes().get(1);
        String numRecord3CreateDDL = removeLineTerminators(shadowDDLGenerator.getCreateDDLFor(recordType3));
        String numRecord3DropDDL = removeLineTerminators(shadowDDLGenerator.getDropDDLFor(recordType3));
        PLSQLCollectionType collectionType3 = (PLSQLCollectionType)shadowDDLTestPackage.getTypes().get(2);
        String numTbl3CreateDDL = removeLineTerminators(shadowDDLGenerator.getCreateDDLFor(collectionType3));
        String numTbl3DropDDL = removeLineTerminators(shadowDDLGenerator.getDropDDLFor(collectionType3));
        PLSQLRecordType recordType = (PLSQLRecordType)shadowDDLTestPackage.getTypes().get(3);
        String numRecordCreateDDL = removeLineTerminators(shadowDDLGenerator.getCreateDDLFor(recordType));
        String numRecordDropDDL = removeLineTerminators(shadowDDLGenerator.getDropDDLFor(recordType));
        PLSQLCollectionType collectionType2 = (PLSQLCollectionType)shadowDDLTestPackage.getTypes().get(4);
        String numTbl2CreateDDL = removeLineTerminators(shadowDDLGenerator.getCreateDDLFor(collectionType2));
        String numTbl2DropDDL = removeLineTerminators(shadowDDLGenerator.getDropDDLFor(collectionType2));
        PLSQLRecordType recordType2 = (PLSQLRecordType)shadowDDLTestPackage.getTypes().get(5);
        String numRecord2CreateDDL = removeLineTerminators(shadowDDLGenerator.getCreateDDLFor(recordType2));
        String numRecord2DropDDL = removeLineTerminators(shadowDDLGenerator.getDropDDLFor(recordType2));
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE2 +
            " does not match expected shadow DDL", numRecord2CreateDDL,
            EXPECTED_NUMRECORD2_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE2 +
            " does not match expected shadow DDL", numRecord2DropDDL,
            EXPECTED_NUMRECORD2_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE +
            " does not match expected shadow DDL", numRecordCreateDDL,
            EXPECTED_NUMRECORD_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE +
            " does not match expected shadow DDL", numRecordDropDDL, EXPECTED_NUMRECORD_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE +
            " does not match expected shadow DDL", numTblCreateDDL, EXPECTED_NUMTBL_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE +
            " does not match expected shadow DDL", numTblDropDDL, EXPECTED_NUMTBL_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE2 +
            " does not match expected shadow DDL", numTbl2CreateDDL, EXPECTED_NUMTBL2_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE2 +
            " does not match expected shadow DDL", numTbl2DropDDL, EXPECTED_NUMTBL2_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE3 +
            " does not match expected shadow DDL", numTbl3CreateDDL, EXPECTED_NUMTBL3_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_TABLE_TYPE3 +
            " does not match expected shadow DDL", numTbl3DropDDL, EXPECTED_NUMTBL3_DROP_SHADOWDDL);
        assertEquals("generated create shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE3 +
            " does not match expected shadow DDL", numRecord3CreateDDL , EXPECTED_NUMRECORD3_CREATE_SHADOWDDL);
        assertEquals("generated drop shadow DDL for " + SHADOWDDLTEST_RECORD_TYPE3 +
            " does not match expected shadow DDL", numRecord3DropDDL, EXPECTED_NUMRECORD3_DROP_SHADOWDDL);
    }

}