oracle 0.6.3

//-----------------------------------------------------------------------------
// Copyright (c) 2017, 2022, Oracle and/or its affiliates.
//
// This software is dual-licensed to you under the Universal Permissive License
// (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
// 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose
// either license.
//
// If you elect to accept the software under the Apache License, Version 2.0,
// the following applies:
//
// 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
//
//    https://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.
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// test_1900_variables.c
//   Test suite for testing variable creation and binding.
//-----------------------------------------------------------------------------

#include "TestLib.h"

#define MAX_ARRAY_SIZE                  3

//-----------------------------------------------------------------------------
// dpiTest_1900_varWithMaxArrSize0()
//   Create a variable specifying the maxArraySize parameter as 0
// (error DPI-1031).
//-----------------------------------------------------------------------------
int dpiTest_1900_varWithMaxArrSize0(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64, 0, 0,
            0, 0, NULL, &var, &data);
    return dpiTestCase_expectError(testCase, "DPI-1031:");
}


//-----------------------------------------------------------------------------
// dpiTest_1901_invalidOracleTypeNum()
//   Create a variable specifying a value for the parameter oracleTypeNum
// which is not part of the enumeration dpiOracleTypeNum (error DPI-1021).
//-----------------------------------------------------------------------------
int dpiTest_1901_invalidOracleTypeNum(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    dpiConn_newVar(conn, 1000, DPI_NATIVE_TYPE_INT64, MAX_ARRAY_SIZE, 0, 0, 0,
            NULL, &var, &data);
    return dpiTestCase_expectError(testCase, "DPI-1021:");
}


//-----------------------------------------------------------------------------
// dpiTest_1902_incompatibleValsForParams()
//   Create a variable specifying values for the parameters oracleTypeNum and
// nativeTypeNum which are not compatible with each other (error DPI-1014).
//-----------------------------------------------------------------------------
int dpiTest_1902_incompatibleValsForParams(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    dpiConn_newVar(conn, DPI_ORACLE_TYPE_TIMESTAMP, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data);
    return dpiTestCase_expectError(testCase, "DPI-1014:");
}


//-----------------------------------------------------------------------------
// dpiTest_1903_validValsForArrsButNotSupported()
//   Create a variable specifying isArray as 1 and valid values for the
// parameters oracleTypeNum and nativeTypeNum, but that are not supported in
// arrays (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1903_validValsForArrsButNotSupported(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    dpiConn_newVar(conn, DPI_ORACLE_TYPE_BOOLEAN, DPI_NATIVE_TYPE_BOOLEAN,
            MAX_ARRAY_SIZE, 0, 0, 1, NULL, &var, &data);
    return dpiTestCase_expectError(testCase, "DPI-1013:");
}


//-----------------------------------------------------------------------------
// dpiTest_1904_maxArrSizeTooLarge()
//   Create a variable specifying values for maxArraySize and sizeInBytes that
// when multiplied together would result in an integer that exceeds INT_MAX
// (error DPI-1015).
//-----------------------------------------------------------------------------
int dpiTest_1904_maxArrSizeTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    uint32_t maxArrSize = 4294967295, size = 2;
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            maxArrSize, size, 0, 0, NULL, &var, &data);
    return dpiTestCase_expectError(testCase, "DPI-1015:");
}


//-----------------------------------------------------------------------------
// dpiTest_1905_setFromBytesNotSupported()
//   Create a variable that does not use native type DPI_NATIVE_TYPE_BYTES and
// then call dpiVar_setFromBytes() (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1905_setFromBytesNotSupported(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *strVal = "string1";
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromBytes(var, 0, strVal, strlen(strVal));
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1906_setFromBytesValueTooLarge()
//   Create a variable that does use native type DPI_NATIVE_TYPE_BYTES and then
// call dpiVar_setFromBytes() with a valueLength that exceeds the size
// specified when the variable was created (error DPI-1019).
//-----------------------------------------------------------------------------
int dpiTest_1906_setFromBytesValueTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *strVal = "string_that_is_too_long";
    dpiData *data;
    dpiVar *var;
    dpiConn *conn;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_VARCHAR, DPI_NATIVE_TYPE_BYTES,
            MAX_ARRAY_SIZE, 2, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromBytes(var, 0, strVal, strlen(strVal));
    if (dpiTestCase_expectError(testCase, "DPI-1019:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1907_setFromBytesPositionTooLarge()
//   Create a variable that uses native type DPI_NATIVE_TYPE_BYTES; call
// dpiVar_setFromBytes() with position >= the value for maxArraySize used when
// the variable was created (error DPI-1009).
//-----------------------------------------------------------------------------
int dpiTest_1907_setFromBytesPositionTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *strVal = "string1";
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromBytes(var, 4, strVal, strlen(strVal));
    if (dpiTestCase_expectError(testCase, "DPI-1009:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1908_setFromLobUnsupportedType()
//   Create a variable that does not use native type DPI_NATIVE_TYPE_LOB and
// then call dpiVar_setFromLob() (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1908_setFromLobUnsupportedType(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *lobStr = "dpiTest";
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;
    dpiLob *lob;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newTempLob(conn, DPI_ORACLE_TYPE_CLOB, &lob) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiLob_setFromBytes(lob, lobStr, strlen(lobStr)) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromLob(var, 0, lob);
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiLob_release(lob);
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1909_setFromLobPositionTooLarge()
//   Create a variable that uses native type DPI_NATIVE_TYPE_LOB; call
// dpiVar_setFromLob() with position >= the value for maxArraySize used when
// the variable was created (error DPI-1009).
//-----------------------------------------------------------------------------
int dpiTest_1909_setFromLobPositionTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *lobStr = "dpiTest";
    dpiData *lobValue;
    dpiVar *lobVar;
    dpiConn *conn;
    dpiLob *lob;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newTempLob(conn, DPI_ORACLE_TYPE_CLOB, &lob) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiLob_setFromBytes(lob, lobStr, strlen(lobStr)) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_CLOB, DPI_NATIVE_TYPE_LOB,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &lobVar, &lobValue) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromLob(lobVar, 3, lob);
    if (dpiTestCase_expectError(testCase, "DPI-1009:") < 0)
        return DPI_FAILURE;
    dpiVar_release(lobVar);
    dpiLob_release(lob);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1910_setFromObjectUnsupportedType()
//   Create a variable that does not use native type DPI_NATIVE_TYPE_OBJECT and
// then call dpiVar_setFromObject() (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1910_setFromObjectUnsupportedType(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *objStr = "UDT_OBJECT";
    dpiObjectType *objType;
    dpiObject *obj;
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_getObjectType(conn, objStr, strlen(objStr), &objType) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiObjectType_createObject(objType, &obj) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromObject(var, 0, obj);
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);
    dpiObject_release(obj);
    dpiObjectType_release(objType);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1911_setFromObjectPositionTooLarge()
//   Create a variable that uses native type DPI_NATIVE_TYPE_OBJECT; call
// dpiVar_setFromObject() with position >= the value for maxArraySize used when
// the variable was created (error DPI-1009).
//-----------------------------------------------------------------------------
int dpiTest_1911_setFromObjectPositionTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *objStr = "UDT_OBJECT";
    uint32_t maxArrSize = 1;
    dpiObjectType *objType;
    dpiData *objectValue;
    dpiVar *objectVar;
    dpiObject *obj;
    dpiConn *conn;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_getObjectType(conn, objStr, strlen(objStr), &objType) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiObjectType_createObject(objType, &obj) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_OBJECT, DPI_NATIVE_TYPE_OBJECT,
            maxArrSize, 0, 0, 0, objType, &objectVar, &objectValue) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromObject(objectVar, 1, obj);
    if (dpiTestCase_expectError(testCase, "DPI-1009:") < 0)
        return DPI_FAILURE;
    dpiVar_release(objectVar);
    dpiObject_release(obj);
    dpiObjectType_release(objType);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1912_setFromRowidUnsupportedType()
//   Create a variable that does not use native type DPI_NATIVE_TYPE_ROWID and
// then call dpiVar_setFromRowid() (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1912_setFromRowidUnsupportedType(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiRowid *rowid = NULL;
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromRowid(var, 0, rowid);
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1913_setFromRowidPositionTooLarge()
//   Create a variable that uses native type DPI_NATIVE_TYPE_ROWID; call
// dpiVar_setFromRowid() with position >= the value for maxArraySize used when
// the variable was created (error DPI-1009).
//-----------------------------------------------------------------------------
int dpiTest_1913_setFromRowidPositionTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiRowid *rowid = NULL;
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_ROWID, DPI_NATIVE_TYPE_ROWID,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromRowid(var, 3, rowid);
    if (dpiTestCase_expectError(testCase, "DPI-1009:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1914_setFromStmtUnsupportedType()
//   Create a variable that does not use native type DPI_NATIVE_TYPE_STMT and
// then call dpiVar_setFromStmt() (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1914_setFromStmtUnsupportedType(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiStmt *stmt = NULL;
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromStmt(var, 0, stmt);
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1915_setFromStmtPositionTooLarge()
//   Create a variable that uses native type DPI_NATIVE_TYPE_STMT; call
// dpiVar_setFromStmt() with position >= the value for maxArraySize used when
// the variable was created (error DPI-1009).
//-----------------------------------------------------------------------------
int dpiTest_1915_setFromStmtPositionTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiStmt *stmt = NULL;
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_STMT, DPI_NATIVE_TYPE_STMT,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromStmt(var, 3, stmt);
    if (dpiTestCase_expectError(testCase, "DPI-1009:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1916_objectVarWithNullType()
//   Create a variable that uses native type DPI_NATIVE_TYPE_OBJECT but the
// object type parameter is set to NULL (error DPI-1025).
//-----------------------------------------------------------------------------
int dpiTest_1916_objectVarWithNullType(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiData *objectValue;
    dpiVar *objectVar;
    dpiConn *conn;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    dpiConn_newVar(conn, DPI_ORACLE_TYPE_OBJECT, DPI_NATIVE_TYPE_OBJECT,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &objectVar, &objectValue);
    if (dpiTestCase_expectError(testCase, "DPI-1025:") < 0)
        return DPI_FAILURE;
    dpiVar_release(objectVar);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1917_stmtDefineInvalidPositions()
//   Prepare and execute a query; call dpiStmt_define() with position set to 0
// and with position set to a value that exceeds the number of columns that are
// available in the query (error DPI-1028).
//-----------------------------------------------------------------------------
int dpiTest_1917_stmtDefineInvalidPositions(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *sql = "select * from TestLongs";
    uint32_t numQueryColumns;
    dpiConn *conn;
    dpiStmt *stmt;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_prepareStmt(conn, 0, sql, strlen(sql), NULL, 0, &stmt) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiStmt_execute(stmt, DPI_MODE_EXEC_DEFAULT, &numQueryColumns) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiStmt_define(stmt, 0, var);
    if (dpiTestCase_expectError(testCase, "DPI-1028:") < 0)
        return DPI_FAILURE;
    dpiStmt_define(stmt, 3, var);
    if (dpiTestCase_expectError(testCase, "DPI-1028:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);
    dpiStmt_release(stmt);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1918_stmtDefineWithNullVar()
//   Prepare and execute a query; call dpistmt_define() with the variable set
// to NULL (error DPI-1002).
//-----------------------------------------------------------------------------
int dpiTest_1918_stmtDefineWithNullVar(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *sql = "select * from TestLongs";
    uint32_t numQueryColumns;
    dpiConn *conn;
    dpiStmt *stmt;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_prepareStmt(conn, 0, sql, strlen(sql), NULL, 0, &stmt) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiStmt_execute(stmt, DPI_MODE_EXEC_DEFAULT, &numQueryColumns) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiStmt_define(stmt, 1, NULL);
    if (dpiTestCase_expectError(testCase, "DPI-1002:") < 0)
        return DPI_FAILURE;
    dpiStmt_release(stmt);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1919_bindByPosWithPosition0()
//   Prepare and execute a statement with bind variables identified in the
// statement text; create a variable and call dpiStmt_bindByPos() with the
// position parameter set to 0 (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1919_bindByPosWithPosition0(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *sql = "select :1 from dual";
    uint32_t maxArrSize = 1;
    dpiData *varData;
    dpiConn *conn;
    dpiStmt *stmt;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_prepareStmt(conn, 0, sql, strlen(sql), NULL, 0, &stmt) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_UINT64,
            maxArrSize, 0, 0, 0, NULL, &var, &varData) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiStmt_bindByPos(stmt, 0, var);
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);
    dpiStmt_release(stmt);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1920_copyDataWithInvalidPosition()
//   Create two variables with the same native type; call dpiVar_copyData()
// with the position parameter set to a value that exceeds the maxArraySize of
// at least one of the variables (error DPI-1009).
//-----------------------------------------------------------------------------
int dpiTest_1920_copyDataWithInvalidPosition(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiData *data1, *data2;
    dpiVar *var1, *var2;
    dpiConn *conn;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var1, &data1) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var2, &data2) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_copyData(var1, 3, var2, 0);
    if (dpiTestCase_expectError(testCase, "DPI-1009:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var1);
    dpiVar_release(var2);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1921_copyDataWithDifferentVarTypes()
//   Create two variables with different native types; call dpiVar_copyData()
// with either variable as the source (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1921_copyDataWithDifferentVarTypes(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiData *intColValue, *longColValue;
    dpiVar *intColVar, *longColVar;
    dpiConn *conn;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &intColVar, &intColValue) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_LONG_VARCHAR,
            DPI_NATIVE_TYPE_BYTES, MAX_ARRAY_SIZE, 0, 0, 0, NULL, &longColVar,
            &longColValue) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_copyData(longColVar, 0, intColVar, 0);
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiVar_release(intColVar);
    dpiVar_release(longColVar);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1922_setNumElementsInArrayTooLarge()
//   Create an array variable of any type; call dpiVar_setNumElementsInArray()
// with a value for the numElements parameter that exceeds the maxArraySize
// value that was used to create the variable (DPI-1018).
//-----------------------------------------------------------------------------
int dpiTest_1922_setNumElementsInArrayTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    uint32_t numElements = 4;
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setNumElementsInArray(var, numElements);
    if (dpiTestCase_expectError(testCase, "DPI-1018:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1923_bindByNameWithNameLen0()
//   Prepare and execute a statement with bind variables identified in the
// statement text; create a variable and call dpiStmt_bindByName() with the
// nameLength parameter set to 0 (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1923_bindByNameWithNameLen0(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *sql = "select :test from dual";
    dpiData *varData;
    dpiConn *conn;
    dpiStmt *stmt;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_prepareStmt(conn, 0, sql, strlen(sql), NULL, 0, &stmt) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_UINT64, 1,
            0, 0, 0, NULL, &var, &varData) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiStmt_bindByName(stmt, "test", 0, var);
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    dpiVar_release(var);
    dpiStmt_release(stmt);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1924_verifySetFromBytesWithValueLenAsZero()
//   Verify dpiVar_setFromBytes() allows the value parameter to be NULL when
// the valueLength parameter is zero.
//-----------------------------------------------------------------------------
int dpiTest_1924_verifySetFromBytesWithValueLenAsZero(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_VARCHAR, DPI_NATIVE_TYPE_BYTES,
            MAX_ARRAY_SIZE, 100, 1, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiVar_setFromBytes(var, 0, NULL, 0) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiVar_release(var) < 0)
        return dpiTestCase_setFailedFromError(testCase);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1925_verifySetFromBytesWithValueLenAsNonZero()
//   Verify dpiVar_setFromBytes() does not allow the value parameter to be NULL
// when the valueLength is set to a non-zero value.
//-----------------------------------------------------------------------------
int dpiTest_1925_verifySetFromBytesWithValueLenAsNonZero(dpiTestCase *testCase,
        dpiTestParams *params)
{
    dpiConn *conn;
    dpiData *data;
    dpiVar *var;

    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_VARCHAR, DPI_NATIVE_TYPE_BYTES,
            MAX_ARRAY_SIZE, 100, 1, 0, NULL, &var, &data) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromBytes(var, 0, NULL, 1);
    if (dpiTestCase_expectError(testCase, "DPI-1053:") < 0)
        return DPI_FAILURE;
    if (dpiVar_release(var) < 0)
        return dpiTestCase_setFailedFromError(testCase);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1926_setFromJsonUnsupportedType()
//   Create a variable that does not use native type DPI_NATIVE_TYPE_JSON and
// then call dpiVar_setFromJson() (error DPI-1013).
//-----------------------------------------------------------------------------
int dpiTest_1926_setFromJsonUnsupportedType(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *strVal = "{\"key\":1026}";
    dpiData *intData, *jsonData;
    dpiVar *intVar, *jsonVar;
    dpiConn *conn;

    if (dpiTestCase_setSkippedIfVersionTooOld(testCase, 0, 21, 0) < 0)
        return DPI_FAILURE;
    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_JSON, DPI_NATIVE_TYPE_JSON,
            1, 0, 0, 0, NULL, &jsonVar, &jsonData) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_NUMBER, DPI_NATIVE_TYPE_INT64,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &intVar, &intData) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiJson_setFromText(dpiData_getJson(jsonData), strVal,
            strlen(strVal), 0) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromJson(intVar, 0, dpiData_getJson(jsonData));
    if (dpiTestCase_expectError(testCase, "DPI-1013:") < 0)
        return DPI_FAILURE;
    if (dpiVar_release(jsonVar) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiVar_release(intVar) < 0)
        return dpiTestCase_setFailedFromError(testCase);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1927_setFromJsonPositionTooLarge()
//   Create a variable that uses native type DPI_NATIVE_TYPE_JSON; call
// dpiVar_setFromJson() with position >= the value for maxArraySize used when
// the variable was created (error DPI-1009).
//-----------------------------------------------------------------------------
int dpiTest_1927_setFromJsonPositionTooLarge(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *strVal = "{\"key\":1027}";
    dpiData *jsonData1, *jsonData2;
    dpiVar *jsonVar1, *jsonVar2;
    dpiConn *conn;

    if (dpiTestCase_setSkippedIfVersionTooOld(testCase, 0, 21, 0) < 0)
        return DPI_FAILURE;
    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_JSON, DPI_NATIVE_TYPE_JSON, 1, 0,
            0, 0, NULL, &jsonVar1, &jsonData1) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_JSON, DPI_NATIVE_TYPE_JSON,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &jsonVar2, &jsonData2) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiJson_setFromText(dpiData_getJson(jsonData1), strVal,
            strlen(strVal), 0) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    dpiVar_setFromJson(jsonVar2, 3, dpiData_getJson(jsonData1));
    if (dpiTestCase_expectError(testCase, "DPI-1009:") < 0)
        return DPI_FAILURE;
    if (dpiVar_release(jsonVar1) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiVar_release(jsonVar2) < 0)
        return dpiTestCase_setFailedFromError(testCase);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1928_setFromJsonWithValidArguments()
//   Create a variable that uses native type DPI_NATIVE_TYPE_JSON; call
// dpiVar_setFromJson() with valid arguments.
//-----------------------------------------------------------------------------
int dpiTest_1928_setFromJsonWithValidArguments(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *strVal = "{\"key\":1028}";
    dpiData *jsonData1, *jsonData2;
    dpiVar *jsonVar1, *jsonVar2;
    dpiConn *conn;

    if (dpiTestCase_setSkippedIfVersionTooOld(testCase, 0, 21, 0) < 0)
        return DPI_FAILURE;
    if (dpiTestCase_getConnection(testCase, &conn) < 0)
        return DPI_FAILURE;
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_JSON, DPI_NATIVE_TYPE_JSON,
            1, 0, 0, 0, NULL, &jsonVar1, &jsonData1) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiConn_newVar(conn, DPI_ORACLE_TYPE_JSON, DPI_NATIVE_TYPE_JSON,
            MAX_ARRAY_SIZE, 0, 0, 0, NULL, &jsonVar2, &jsonData2) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiJson_setFromText(dpiData_getJson(jsonData1), strVal,
            strlen(strVal), 0) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiVar_setFromJson(jsonVar2, 0, dpiData_getJson(jsonData1)) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiVar_release(jsonVar1) < 0)
        return dpiTestCase_setFailedFromError(testCase);
    if (dpiVar_release(jsonVar2) < 0)
        return dpiTestCase_setFailedFromError(testCase);

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// dpiTest_1929_verifySetFromJsonWithNull()
//   Call each of the dpiJson public functions with the json parameter set to
// NULL (error DPI-1002).
//-----------------------------------------------------------------------------
int dpiTest_1929_verifySetFromJsonWithNull(dpiTestCase *testCase,
        dpiTestParams *params)
{
    const char *expectedError = "DPI-1002:";

    if (dpiTestCase_setSkippedIfVersionTooOld(testCase, 0, 21, 0) < 0)
        return DPI_FAILURE;
    dpiVar_setFromJson(NULL, 0, NULL);
    if (dpiTestCase_expectError(testCase, expectedError) < 0)
        return DPI_FAILURE;

    return DPI_SUCCESS;
}


//-----------------------------------------------------------------------------
// main()
//-----------------------------------------------------------------------------
int main(int argc, char **argv)
{
    dpiTestSuite_initialize(1900);
    dpiTestSuite_addCase(dpiTest_1900_varWithMaxArrSize0,
            "dpiConn_newVar() with max array size as 0");
    dpiTestSuite_addCase(dpiTest_1901_invalidOracleTypeNum,
            "dpiConn_newVar() with an invalid value for Oracle type");
    dpiTestSuite_addCase(dpiTest_1902_incompatibleValsForParams,
            "dpiConn_newVar() with incompatible values for Oracle and native "
            "types");
    dpiTestSuite_addCase(dpiTest_1903_validValsForArrsButNotSupported,
            "dpiConn_newVar() with invalid array type for array");
    dpiTestSuite_addCase(dpiTest_1904_maxArrSizeTooLarge,
            "dpiConn_newVar() with max array size that is too large");
    dpiTestSuite_addCase(dpiTest_1905_setFromBytesNotSupported,
            "dpiVar_setFromBytes() with unsupported variable");
    dpiTestSuite_addCase(dpiTest_1906_setFromBytesValueTooLarge,
            "dpiVar_setFromBytes() with value too large");
    dpiTestSuite_addCase(dpiTest_1907_setFromBytesPositionTooLarge,
            "dpiVar_setFromBytes() with position too large");
    dpiTestSuite_addCase(dpiTest_1908_setFromLobUnsupportedType,
            "dpiVar_setFromLob() with unsupported type");
    dpiTestSuite_addCase(dpiTest_1909_setFromLobPositionTooLarge,
            "dpiVar_setFromLob() with position too large");
    dpiTestSuite_addCase(dpiTest_1910_setFromObjectUnsupportedType,
            "dpiVar_setFromObject() with unsupported type");
    dpiTestSuite_addCase(dpiTest_1911_setFromObjectPositionTooLarge,
            "dpiVar_setFromObject() with position too large");
    dpiTestSuite_addCase(dpiTest_1912_setFromRowidUnsupportedType,
            "dpiVar_setFromRowid() with unsupported type");
    dpiTestSuite_addCase(dpiTest_1913_setFromRowidPositionTooLarge,
            "dpiVar_setFromRowid() with position too large");
    dpiTestSuite_addCase(dpiTest_1914_setFromStmtUnsupportedType,
            "dpiVar_setFromStmt() with unsupported type");
    dpiTestSuite_addCase(dpiTest_1915_setFromStmtPositionTooLarge,
            "dpiVar_setFromStmt() with position too large");
    dpiTestSuite_addCase(dpiTest_1916_objectVarWithNullType,
            "dpiConn_newVar() with NULL object type for object variable");
    dpiTestSuite_addCase(dpiTest_1917_stmtDefineInvalidPositions,
            "dpiStmt_define() with invalid positions");
    dpiTestSuite_addCase(dpiTest_1918_stmtDefineWithNullVar,
            "dpiStmt_define() with NULL variable");
    dpiTestSuite_addCase(dpiTest_1919_bindByPosWithPosition0,
            "dpiStmt_bindByPos() with position 0");
    dpiTestSuite_addCase(dpiTest_1920_copyDataWithInvalidPosition,
            "dpiVar_copyData() with invalid position");
    dpiTestSuite_addCase(dpiTest_1921_copyDataWithDifferentVarTypes,
            "dpiVar_copyData() with different variable types");
    dpiTestSuite_addCase(dpiTest_1922_setNumElementsInArrayTooLarge,
            "dpiVar_setNumElementsInArray() with value too large");
    dpiTestSuite_addCase(dpiTest_1923_bindByNameWithNameLen0,
            "dpiStmt_bindByName() with name length parameter 0");
    dpiTestSuite_addCase(dpiTest_1924_verifySetFromBytesWithValueLenAsZero,
            "dpiVar_setFromBytes() with value NULL and valueLength zero");
    dpiTestSuite_addCase(dpiTest_1925_verifySetFromBytesWithValueLenAsNonZero,
            "dpiVar_setFromBytes() with value not NULL and valueLength "
            "non zero");
    dpiTestSuite_addCase(dpiTest_1926_setFromJsonUnsupportedType,
            "dpiVar_setFromJson() with unsupported type");
    dpiTestSuite_addCase(dpiTest_1927_setFromJsonPositionTooLarge,
            "dpiVar_setFromJson() with position too large");
    dpiTestSuite_addCase(dpiTest_1928_setFromJsonWithValidArguments,
            "dpiVar_setFromJson() with valid arguments");
    dpiTestSuite_addCase(dpiTest_1929_verifySetFromJsonWithNull,
            "verify dpiVar_setFromJson() with NULL");
    return dpiTestSuite_run();
}