Add more testsuites - TOPLEVEL procedures - TOPLEVEL functions
diff --git "a/java/Oracle DDL Parser \050just Parser\051 tests.launch" "b/java/Oracle DDL Parser \050just Parser\051 tests.launch"
index 2410b99..66d5fc8 100644
--- "a/java/Oracle DDL Parser \050just Parser\051 tests.launch"
+++ "b/java/Oracle DDL Parser \050just Parser\051 tests.launch"
@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<launchConfiguration type="org.eclipse.jdt.junit.launchconfig">
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
-<listEntry value="/oracleddlparser.test/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTest.java"/>
+<listEntry value="/oracleddlparser.test/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTestSuite.java"/>
</listAttribute>
<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
<listEntry value="1"/>
@@ -16,6 +16,6 @@
<listEntry value="<?xml version="1.0" encoding="UTF-8" standalone="no"?> <runtimeClasspathEntry containerPath="ORACLE_JDBC_LIB" path="3" type="3"/> "/>
</listAttribute>
<booleanAttribute key="org.eclipse.jdt.launching.DEFAULT_CLASSPATH" value="false"/>
-<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.persistence.tools.oracleddl.test.ddlparser.DDLParserTest"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.persistence.tools.oracleddl.test.ddlparser.DDLParserTestSuite"/>
<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="oracleddlparser.test"/>
</launchConfiguration>
diff --git a/java/src/org/eclipse/persistence/tools/oracleddl/test/AllTests.java b/java/src/org/eclipse/persistence/tools/oracleddl/test/AllTests.java
index 12c5eab..1d45f7e 100644
--- a/java/src/org/eclipse/persistence/tools/oracleddl/test/AllTests.java
+++ b/java/src/org/eclipse/persistence/tools/oracleddl/test/AllTests.java
@@ -25,15 +25,15 @@
//testing imports
import org.eclipse.persistence.tools.oracleddl.test.databasetypebuilder.DatabaseTypeBuilderTestSuite;
-import org.eclipse.persistence.tools.oracleddl.test.ddlparser.DDLParserTest;
+import org.eclipse.persistence.tools.oracleddl.test.ddlparser.DDLParserTestSuite;
import org.eclipse.persistence.tools.oracleddl.test.visit.VisitorsTestSuite;
import static org.eclipse.persistence.tools.oracleddl.test.TestHelper.buildConnection;
@RunWith(Suite.class)
@SuiteClasses({
- DDLParserTest.class,
- VisitorsTestSuite.class,
- DatabaseTypeBuilderTestSuite.class
+ DDLParserTestSuite.class,
+ VisitorsTestSuite.class,
+ DatabaseTypeBuilderTestSuite.class
}
)
public class AllTests {
diff --git a/java/src/org/eclipse/persistence/tools/oracleddl/test/databasetypebuilder/ProcedureDDLTestSuite.java b/java/src/org/eclipse/persistence/tools/oracleddl/test/databasetypebuilder/ProcedureDDLTestSuite.java
index d46b072..a98c547 100644
--- a/java/src/org/eclipse/persistence/tools/oracleddl/test/databasetypebuilder/ProcedureDDLTestSuite.java
+++ b/java/src/org/eclipse/persistence/tools/oracleddl/test/databasetypebuilder/ProcedureDDLTestSuite.java
@@ -16,7 +16,6 @@
//javase imports
import java.sql.Connection;
import java.sql.SQLException;
-import java.util.ArrayList;
import java.util.List;
//JUnit4 imports
@@ -56,8 +55,6 @@
static DatabaseTypeBuilder dtBuilder = DatabaseTypeBuilderTestSuite.dtBuilder;
static Connection conn = AllTests.conn;
static ProcedureType procedureType = null;
- static List<String> expectedFieldNames = new ArrayList<String>();
- static List<String> expectedPKFieldNames = new ArrayList<String>();
@BeforeClass
public static void setUp() throws SQLException, ClassNotFoundException {
conn = buildConnection();
diff --git a/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTestSuite.java b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTestSuite.java
new file mode 100644
index 0000000..aade680
--- /dev/null
+++ b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTestSuite.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ * Mike Norman - June 10 2011, created DDL parser package
+ * David McCann - July 2011, visit tests
+ ******************************************************************************/
+package org.eclipse.persistence.tools.oracleddl.test.ddlparser;
+
+//javase imports
+
+//JUnit4 imports
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+ TableDDLTestSuite.class,
+ FunctionDDLTestSuite.class,
+ ProcedureDDLTestSuite.class
+ }
+)
+public class DDLParserTestSuite {
+
+}
\ No newline at end of file
diff --git a/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/FunctionDDLTestSuite.java b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/FunctionDDLTestSuite.java
new file mode 100644
index 0000000..a2c6663
--- /dev/null
+++ b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/FunctionDDLTestSuite.java
@@ -0,0 +1,197 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ * Mike Norman - June 10 2011, created DDL parser package
+ * David McCann - July 2011, visit tests
+ ******************************************************************************/
+package org.eclipse.persistence.tools.oracleddl.test.ddlparser;
+
+//javase imports
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+
+//JUnit4 imports
+import org.junit.BeforeClass;
+//import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+//DDL imports
+import org.eclipse.persistence.tools.oracleddl.metadata.ArgumentType;
+import org.eclipse.persistence.tools.oracleddl.metadata.DatabaseType;
+import org.eclipse.persistence.tools.oracleddl.metadata.DecimalType;
+import org.eclipse.persistence.tools.oracleddl.metadata.FunctionType;
+import org.eclipse.persistence.tools.oracleddl.metadata.visit.UnresolvedTypesVisitor;
+import org.eclipse.persistence.tools.oracleddl.parser.DDLParser;
+import org.eclipse.persistence.tools.oracleddl.parser.ParseException;
+import org.eclipse.persistence.tools.oracleddl.util.DatabaseTypesRepository;
+import static org.eclipse.persistence.tools.oracleddl.metadata.ArgumentTypeDirection.IN;
+
+public class FunctionDDLTestSuite {
+
+ static final String CREATE_FUNCTION_PREFIX = "CREATE FUNCTION ";
+ //JUnit fixture(s)
+ static DDLParser parser = null;
+
+ @BeforeClass
+ static public void setUp() {
+ parser = new DDLParser(new InputStream() {
+ public int read() throws IOException {
+ return 0;
+ }
+ });
+ parser.setTypesRepository(new DatabaseTypesRepository());
+ }
+
+ static final String EMPTY_FUNCTION = "EMPTY_FUNCTION";
+ static final String CREATE_EMPTY_FUNCTION =
+ CREATE_FUNCTION_PREFIX + EMPTY_FUNCTION + " RETURN DECIMAL IS BEGIN RETURN 0; END";
+ @Test
+ public void testEmptyFunction() {
+ parser.ReInit(new StringReader(CREATE_EMPTY_FUNCTION));
+ boolean worked = true;
+ @SuppressWarnings("unused") FunctionType functionType = null;
+ try {
+ functionType = parser.parseTopLevelFunction();
+ }
+ catch (ParseException pe) {
+ worked = false;
+ }
+ assertTrue("empty function should parse", worked);
+ assertEquals("empty function wrong name", functionType.getProcedureName(), EMPTY_FUNCTION);
+ assertTrue("empty function should have no arguments", functionType.getArguments().isEmpty());
+ }
+
+ static final String SIMPLE_FUNCTION = "SIMPLE_FUNCTION";
+ static final String SIMPLE_ARG = "DEPT";
+ static final String CREATE_SIMPLE_FUNCTION =
+ CREATE_FUNCTION_PREFIX + SIMPLE_FUNCTION + " (" + SIMPLE_ARG + " IN DECIMAL) RETURN DECIMAL AS " +
+ "BEGIN " +
+ "SELECT max(SAL) INTO MAXSAL FROM SIMPLESF WHERE DEPTNO = DEPT; " +
+ "RETURN(MAXSAL); " +
+ "END";
+
+ @Test
+ public void testSimpleFunction() {
+ parser.ReInit(new StringReader(CREATE_SIMPLE_FUNCTION));
+ boolean worked = true;
+ String message = "";
+ FunctionType functionType = null;
+ try {
+ functionType = parser.parseTopLevelFunction();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("simple function did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(functionType);
+ assertTrue("simple function should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("simple function wrong name", functionType.getProcedureName(), SIMPLE_FUNCTION);
+ DatabaseType returnArg = functionType.getReturnArgument();
+ assertEquals("simple function should have DECIMAL return type",
+ new DecimalType().getTypeName(), returnArg.getTypeName());
+ assertTrue("dummy procedure should have 1 argument",
+ functionType.getArguments().size() == 1);
+ ArgumentType arg1 = functionType.getArguments().get(0);
+ assertEquals("dummy procedure's argument wrong name", arg1.getArgumentName(), SIMPLE_ARG);
+ DatabaseType arg1Type = arg1.getDataType();
+ assertEquals("incorrect type for " + arg1.getArgumentName() + " type",
+ new DecimalType().getTypeName(), arg1Type.getTypeName());
+ assertTrue("incorrect direction for " + arg1.getArgumentName(),
+ arg1.getDirection() == IN);
+ }
+
+/*
+ static final String PROCEDURE_W_SYS_REFCURSOR = "GETALL";
+ static final String SYS_REF_OUT_ARG = "SIMPL";
+ static final String CREATE_PROCEDURE_W_SYS_REFCURSOR =
+ CREATE_FUNCTION_PREFIX + PROCEDURE_W_SYS_REFCURSOR +
+ " ( " + SYS_REF_OUT_ARG + " OUT SYS_REFCURSOR) AS " +
+ "BEGIN " +
+ "OPEN SIMPL FOR SELECT * FROM simplesp;" +
+ "END";
+ @Test
+ public void testProcedure_With_Sys_Refcursor() {
+ parser.ReInit(new StringReader(CREATE_PROCEDURE_W_SYS_REFCURSOR));
+ boolean worked = true;
+ String message = "";
+ ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("procedure with SYS_REFCURSOR did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(procedureType);
+ assertTrue("procedure with SYS_REFCURSOR should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("procedure with SYS_REFCURSOR wrong name", procedureType.getProcedureName(),
+ PROCEDURE_W_SYS_REFCURSOR);
+ assertTrue("procedure with SYS_REFCURSOR should have 1 argument",
+ procedureType.getArguments().size() == 1);
+ ArgumentType arg1 = procedureType.getArguments().get(0);
+ assertEquals("procedure with SYS_REFCURSOR - arg1 wrong name", arg1.getArgumentName(),
+ SYS_REF_OUT_ARG);
+ DatabaseType arg1Type = arg1.getDataType();
+ assertEquals("incorrect type for " + arg1.getArgumentName() + " type",
+ SYS_REFCURSOR_TYPE.getTypeName(), arg1Type.getTypeName());
+ assertTrue("incorrect direction for " + arg1.getArgumentName(),
+ arg1.getDirection() == OUT);
+ }
+
+ static final String PROCEDURE_W_INOUT_ARG = "INOUTARGSP";
+ static final String INOUT_ARG = "X";
+ static final String CREATE_PROCEDURE_W_INOUT_ARG =
+ CREATE_FUNCTION_PREFIX + PROCEDURE_W_INOUT_ARG +
+ " ( " + INOUT_ARG + " IN OUT NUMERIC) AS " +
+ "BEGIN " +
+ "null;" +
+ "END";
+ @Test
+ public void testProcedure_With_InOut_Arg() {
+ parser.ReInit(new StringReader(CREATE_PROCEDURE_W_INOUT_ARG));
+ boolean worked = true;
+ String message = "";
+ ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("procedure with INOUT arg did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(procedureType);
+ assertTrue("procedure with INOUT arg should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("procedure with INOUT arg wrong name", procedureType.getProcedureName(),
+ PROCEDURE_W_INOUT_ARG);
+ assertTrue("procedure with INOUT arg should have 1 argument",
+ procedureType.getArguments().size() == 1);
+ ArgumentType arg1 = procedureType.getArguments().get(0);
+ assertEquals("procedure with INOUT arg - arg1 wrong name", arg1.getArgumentName(),
+ INOUT_ARG);
+ DatabaseType arg1Type = arg1.getDataType();
+ assertEquals("incorrect type for " + arg1.getArgumentName() + " type",
+ new NumericType().getTypeName(), arg1Type.getTypeName());
+ assertTrue("incorrect direction for " + arg1.getArgumentName(),
+ arg1.getDirection() == INOUT);
+ }
+*/
+}
\ No newline at end of file
diff --git a/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/ProcedureDDLTestSuite.java b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/ProcedureDDLTestSuite.java
new file mode 100644
index 0000000..47b4b5d
--- /dev/null
+++ b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/ProcedureDDLTestSuite.java
@@ -0,0 +1,281 @@
+/*******************************************************************************
+ * Copyright (c) 2011 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
+ * which accompanies this distribution.
+ * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
+ * and the Eclipse Distribution License is available at
+ * http://www.eclipse.org/org/documents/edl-v10.php.
+ *
+ * Contributors:
+ * Mike Norman - June 10 2011, created DDL parser package
+ * David McCann - July 2011, visit tests
+ ******************************************************************************/
+package org.eclipse.persistence.tools.oracleddl.test.ddlparser;
+
+//javase imports
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+
+//JUnit4 imports
+import org.junit.BeforeClass;
+//import org.junit.Ignore;
+import org.junit.Test;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+//DDL imports
+import org.eclipse.persistence.tools.oracleddl.metadata.ArgumentType;
+import org.eclipse.persistence.tools.oracleddl.metadata.DatabaseType;
+import org.eclipse.persistence.tools.oracleddl.metadata.NumericType;
+import org.eclipse.persistence.tools.oracleddl.metadata.ProcedureType;
+import org.eclipse.persistence.tools.oracleddl.metadata.VarChar2Type;
+import org.eclipse.persistence.tools.oracleddl.metadata.visit.UnresolvedTypesVisitor;
+import org.eclipse.persistence.tools.oracleddl.parser.DDLParser;
+import org.eclipse.persistence.tools.oracleddl.parser.ParseException;
+import org.eclipse.persistence.tools.oracleddl.util.DatabaseTypesRepository;
+import static org.eclipse.persistence.tools.oracleddl.metadata.ScalarDatabaseTypeEnum.SYS_REFCURSOR_TYPE;
+import static org.eclipse.persistence.tools.oracleddl.metadata.ArgumentTypeDirection.IN;
+import static org.eclipse.persistence.tools.oracleddl.metadata.ArgumentTypeDirection.INOUT;
+import static org.eclipse.persistence.tools.oracleddl.metadata.ArgumentTypeDirection.OUT;
+
+public class ProcedureDDLTestSuite {
+
+ static final String CREATE_PROCEDURE_PREFIX = "CREATE PROCEDURE ";
+ //JUnit fixture(s)
+ static DDLParser parser = null;
+
+ @BeforeClass
+ static public void setUp() {
+ parser = new DDLParser(new InputStream() {
+ public int read() throws IOException {
+ return 0;
+ }
+ });
+ parser.setTypesRepository(new DatabaseTypesRepository());
+ }
+
+
+ static final String EMPTY_PROCEDURE = "EMPTY_PROCEDURE";
+ static final String CREATE_EMPTY_PROCEDURE =
+ CREATE_PROCEDURE_PREFIX + EMPTY_PROCEDURE + " IS BEGIN null; END";
+ @Test
+ public void testEmptyProcedure() {
+ parser.ReInit(new StringReader(CREATE_EMPTY_PROCEDURE));
+ boolean worked = true;
+ @SuppressWarnings("unused") ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ worked = false;
+ }
+ assertTrue("empty procedure should parse", worked);
+ assertEquals("empty procedure wrong name", procedureType.getProcedureName(), EMPTY_PROCEDURE);
+ assertTrue("empty procedure should have no arguments", procedureType.getArguments().isEmpty());
+ }
+
+ static final String DUMMY_PROCEDURE = "DUMMY_PROCEDURE";
+ static final String DUMMY_ARG = "DUM";
+ static final String CREATE_DUMMY_PROCEDURE =
+ CREATE_PROCEDURE_PREFIX + DUMMY_PROCEDURE + " (" + DUMMY_ARG + " IN VARCHAR2) AS " +
+ "BEGIN " +
+ "null;" +
+ "END";
+ @Test
+ public void testDummyProcedure() {
+ parser.ReInit(new StringReader(CREATE_DUMMY_PROCEDURE));
+ boolean worked = true;
+ String message = "";
+ ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("dummy procedure did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(procedureType);
+ assertTrue("dummy procedure should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("dummy procedure wrong name", procedureType.getProcedureName(), DUMMY_PROCEDURE);
+ assertTrue("dummy procedure should have 1 argument",
+ procedureType.getArguments().size() == 1);
+ ArgumentType arg1 = procedureType.getArguments().get(0);
+ assertEquals("dummy procedure's argument wrong name", arg1.getArgumentName(), DUMMY_ARG);
+ }
+
+ static final String DUMMY_PROCEDURE_SCHEMA = "SCOTT";
+ static final String CREATE_DUMMY_PROCEDURE_SCHEMA =
+ CREATE_PROCEDURE_PREFIX + DUMMY_PROCEDURE_SCHEMA + "." + DUMMY_PROCEDURE + " (" + DUMMY_ARG + " IN VARCHAR2) AS " +
+ "BEGIN " +
+ "null;" +
+ "END";
+ @Test
+ public void testDummyProcedure_WithSchema() {
+ parser.ReInit(new StringReader(CREATE_DUMMY_PROCEDURE_SCHEMA));
+ boolean worked = true;
+ String message = "";
+ ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("dummy procedure(with schema) did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(procedureType);
+ assertTrue("dummy procedure(with schema) should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("dummy procedure wrong schema", procedureType.getSchema(), DUMMY_PROCEDURE_SCHEMA);
+ assertEquals("dummy procedure wrong name", procedureType.getProcedureName(), DUMMY_PROCEDURE);
+ assertTrue("dummy procedure should have 1 argument",
+ procedureType.getArguments().size() == 1);
+ ArgumentType arg1 = procedureType.getArguments().get(0);
+ assertEquals("dummy procedure's argument wrong name", arg1.getArgumentName(), DUMMY_ARG);
+ }
+
+ static final String PROCEDURE_W_IN_OUT_ARGS = "INOUTARGSSP";
+ static final String IN_ARG = "T";
+ static final String OUT_ARG = "U";
+ static final String OUT_ARG2 = "V";
+ static final String CREATE_PROCEDURE_W_IN_OUT_ARGS =
+ CREATE_PROCEDURE_PREFIX + PROCEDURE_W_IN_OUT_ARGS +
+ " ( " + IN_ARG + " IN VARCHAR2, " + OUT_ARG + " OUT VARCHAR2, " + OUT_ARG2 + " OUT NUMERIC) AS " +
+ "BEGIN " +
+ "null;" +
+ "END";
+ @Test
+ public void testProcedure_With_In_Out_Args() {
+ parser.ReInit(new StringReader(CREATE_PROCEDURE_W_IN_OUT_ARGS));
+ boolean worked = true;
+ String message = "";
+ ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("procedure with in and out args did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(procedureType);
+ assertTrue("procedure with in and out args should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("procedure with in and out args wrong name", procedureType.getProcedureName(),
+ PROCEDURE_W_IN_OUT_ARGS);
+ assertTrue("procedure with in and out args should have 3 arguments",
+ procedureType.getArguments().size() == 3);
+ ArgumentType arg1 = procedureType.getArguments().get(0);
+ assertEquals("procedure with in and out args - arg1 wrong name", arg1.getArgumentName(),
+ IN_ARG);
+ DatabaseType arg1Type = arg1.getDataType();
+ assertEquals("incorrect type for " + arg1.getArgumentName() + " type",
+ new VarChar2Type().getTypeName(), arg1Type.getTypeName());
+ assertTrue("incorrect direction for " + arg1.getArgumentName(),
+ arg1.getDirection() == IN);
+ ArgumentType arg2 = procedureType.getArguments().get(1);
+ assertEquals("procedure with in and out args - arg2 wrong name", arg2.getArgumentName(),
+ OUT_ARG);
+ DatabaseType arg2Type = arg2.getDataType();
+ assertEquals("incorrect type for " + arg2.getArgumentName() + " type",
+ new VarChar2Type().getTypeName(), arg2Type.getTypeName());
+ assertTrue("incorrect direction for " + arg2.getArgumentName(),
+ arg2.getDirection() == OUT);
+ ArgumentType arg3 = procedureType.getArguments().get(2);
+ assertEquals("procedure with in and out args - arg3 wrong name", arg3.getArgumentName(),
+ OUT_ARG2);
+ DatabaseType arg3Type = arg3.getDataType();
+ assertEquals("incorrect type for " + arg3.getArgumentName() + " type",
+ new NumericType().getTypeName(), arg3Type.getTypeName());
+ assertTrue("incorrect direction for " + arg3.getArgumentName(),
+ arg3.getDirection() == OUT);
+ }
+
+ static final String PROCEDURE_W_SYS_REFCURSOR = "GETALL";
+ static final String SYS_REF_OUT_ARG = "SIMPL";
+ static final String CREATE_PROCEDURE_W_SYS_REFCURSOR =
+ CREATE_PROCEDURE_PREFIX + PROCEDURE_W_SYS_REFCURSOR +
+ " ( " + SYS_REF_OUT_ARG + " OUT SYS_REFCURSOR) AS " +
+ "BEGIN " +
+ "OPEN SIMPL FOR SELECT * FROM simplesp;" +
+ "END";
+ @Test
+ public void testProcedure_With_Sys_Refcursor() {
+ parser.ReInit(new StringReader(CREATE_PROCEDURE_W_SYS_REFCURSOR));
+ boolean worked = true;
+ String message = "";
+ ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("procedure with SYS_REFCURSOR did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(procedureType);
+ assertTrue("procedure with SYS_REFCURSOR should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("procedure with SYS_REFCURSOR wrong name", procedureType.getProcedureName(),
+ PROCEDURE_W_SYS_REFCURSOR);
+ assertTrue("procedure with SYS_REFCURSOR should have 1 argument",
+ procedureType.getArguments().size() == 1);
+ ArgumentType arg1 = procedureType.getArguments().get(0);
+ assertEquals("procedure with SYS_REFCURSOR - arg1 wrong name", arg1.getArgumentName(),
+ SYS_REF_OUT_ARG);
+ DatabaseType arg1Type = arg1.getDataType();
+ assertEquals("incorrect type for " + arg1.getArgumentName() + " type",
+ SYS_REFCURSOR_TYPE.getTypeName(), arg1Type.getTypeName());
+ assertTrue("incorrect direction for " + arg1.getArgumentName(),
+ arg1.getDirection() == OUT);
+ }
+
+ static final String PROCEDURE_W_INOUT_ARG = "INOUTARGSP";
+ static final String INOUT_ARG = "X";
+ static final String CREATE_PROCEDURE_W_INOUT_ARG =
+ CREATE_PROCEDURE_PREFIX + PROCEDURE_W_INOUT_ARG +
+ " ( " + INOUT_ARG + " IN OUT NUMERIC) AS " +
+ "BEGIN " +
+ "null;" +
+ "END";
+ @Test
+ public void testProcedure_With_InOut_Arg() {
+ parser.ReInit(new StringReader(CREATE_PROCEDURE_W_INOUT_ARG));
+ boolean worked = true;
+ String message = "";
+ ProcedureType procedureType = null;
+ try {
+ procedureType = parser.parseTopLevelProcedure();
+ }
+ catch (ParseException pe) {
+ message = pe.getMessage();
+ worked = false;
+ }
+ assertTrue("procedure with INOUT arg did not parse:\n" + message, worked);
+ UnresolvedTypesVisitor l = new UnresolvedTypesVisitor();
+ l.visit(procedureType);
+ assertTrue("procedure with INOUT arg should not contain any unresolved datatypes",
+ l.getUnresolvedTypes().isEmpty());
+ assertEquals("procedure with INOUT arg wrong name", procedureType.getProcedureName(),
+ PROCEDURE_W_INOUT_ARG);
+ assertTrue("procedure with INOUT arg should have 1 argument",
+ procedureType.getArguments().size() == 1);
+ ArgumentType arg1 = procedureType.getArguments().get(0);
+ assertEquals("procedure with INOUT arg - arg1 wrong name", arg1.getArgumentName(),
+ INOUT_ARG);
+ DatabaseType arg1Type = arg1.getDataType();
+ assertEquals("incorrect type for " + arg1.getArgumentName() + " type",
+ new NumericType().getTypeName(), arg1Type.getTypeName());
+ assertTrue("incorrect direction for " + arg1.getArgumentName(),
+ arg1.getDirection() == INOUT);
+ }
+
+}
\ No newline at end of file
diff --git a/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTest.java b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/TableDDLTestSuite.java
similarity index 99%
rename from java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTest.java
rename to java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/TableDDLTestSuite.java
index 6c99840..ba33624 100644
--- a/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/DDLParserTest.java
+++ b/java/src/org/eclipse/persistence/tools/oracleddl/test/ddlparser/TableDDLTestSuite.java
@@ -37,7 +37,7 @@
import org.eclipse.persistence.tools.oracleddl.parser.ParseException;
import org.eclipse.persistence.tools.oracleddl.util.DatabaseTypesRepository;
-public class DDLParserTest {
+public class TableDDLTestSuite {
//JUnit fixture(s)
static DDLParser parser = null;
