/* --------------------------------------------------------- TestSQLDataSources No negative tests since this functionality is done at driver manager level. --------------------------------------------------------- */ PassFail TestSQLDataSources(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; char szDSN[DSRC_LEN], szDESC[DSRC_LEN]; SWORD cbDSN, pcbDESC; LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => SQLDataSources | SQLDataSources | datasrc.c\n"); TEST_INIT; //========================================================================================== TESTCASE_BEGIN("Test the positive functionality of SQLDataSources\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if (returncode == SQL_SUCCESS) { returncode = SQLDataSources(henv, SQL_FETCH_FIRST, (SQLCHAR*)szDSN, DSRC_LEN, &cbDSN, (SQLCHAR*)szDESC, DSRC_LEN, &pcbDESC); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDataSources")) { TEST_FAILED; LogMsg(ERRMSG,"Test SQLDataSources => SQL_FETCH_FIRST #1 failed.\n"); } while (returncode == SQL_SUCCESS) { returncode = SQLDataSources(henv, SQL_FETCH_NEXT, (SQLCHAR*)szDSN, DSRC_LEN, &cbDSN, (SQLCHAR*)szDESC, DSRC_LEN, &pcbDESC); if((returncode != SQL_SUCCESS) && (returncode != SQL_NO_DATA_FOUND)) { TEST_FAILED; LogMsg(ERRMSG,"Test SQLDataSources => SQL_FETCH_NEXT failed.\n"); } } returncode = SQLDataSources(henv, SQL_FETCH_FIRST, (SQLCHAR*)szDSN, DSRC_LEN, &cbDSN, (SQLCHAR*)szDESC, DSRC_LEN, &pcbDESC); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDataSources")) { TEST_FAILED; LogMsg(ERRMSG,"Test SQLDataSources => SQL_FETCH_FIRST #2 failed.\n"); } } SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLDataSources.\n"); TEST_RETURN; }
static coroutine void sf_oworker(struct sf *conn) { struct msg msg = {NULL, 0}; while(1) { int rc = chrecv(conn->ochan, &msg, sizeof(msg), -1); if(dill_slow(rc < 0 && errno == ECANCELED)) break; dill_assert(rc == 0); /* User requests that the coroutine stops. */ if(!msg.buf) {conn->ores = SF_DONE; break;} uint64_t hdr; dill_putll((uint8_t*)&hdr, msg.len); rc = bsend(conn->u, &hdr, sizeof(hdr), -1); CHECKRC(ores) rc = bsend(conn->u, msg.buf, msg.len, -1); CHECKRC(ores) free(msg.buf); msg.buf = NULL; msg.len = 0; rc = bflush(conn->u, -1); CHECKRC(ores) } free(msg.buf); int rc = chdone(conn->ochan); dill_assert(rc == 0); }
static coroutine void sf_iworker(struct sf *conn) { struct msg msg = {NULL, 0}; while(1) { uint64_t hdr; int rc = brecv(conn->u, &hdr, sizeof(hdr), -1); CHECKRC(ires) if(dill_slow(hdr == sf_termsequence)) {conn->ires = SF_DONE; break;} msg.len = (size_t)dill_getll((uint8_t*)&hdr); msg.buf = malloc(msg.len); dill_assert(msg.buf); rc = brecv(conn->u, msg.buf, msg.len, -1); CHECKRC(ires) rc = chsend(conn->ichan, &msg, sizeof(msg), -1); if(dill_slow(rc < 0 && errno == ECANCELED)) break; dill_assert(rc == 0); msg.buf = NULL; msg.len = 0; } free(msg.buf); int rc = chdone(conn->ichan); dill_assert(rc == 0); }
/* --------------------------------------------------------- TestHash2 --------------------------------------------------------- */ PassFail TestHash2(TestInfo *pTestInfo) { TEST_DECLARE; SQLRETURN returncode; SQLHENV henv = 0; SQLHDBC hdbc = 0; SQLHSTMT hstmt= 0; SQLUSMALLINT ParamStatusArray[ARRAY_SIZE]; SQLUSMALLINT expParamStatusArray[ARRAY_SIZE]; SQLUSMALLINT lastExpParamStatusArray[ARRAY_SIZE]; SQLULEN lastParamsProcessed=ARRAY_SIZE, ParamsProcessed = 0; SQLLEN rowcount = 0, expRowcount = 0, lastExpRowcount = 0; int i,j,k,counter = 1, loopcount = 0; TCHAR buffer[256]; typedef struct { TCHAR num[15]; SQLLEN numLenOrInd; TCHAR val[15]; SQLLEN valLenOrInd; }nameStruct; nameStruct nameArray1[ARRAY_SIZE]; SQLUINTEGER mode = 1; SQLUINTEGER startnode = 2; SQLUINTEGER streams_per_node = 4; SQLUINTEGER delay_error = 1; SQLUINTEGER suggested_rowset_size=0; SQLTCHAR *sqlDrvInsert = (SQLTCHAR*)_T("PLANLOADTABLE HASH2_TABLE"); SQLTCHAR *dropTbl = (SQLTCHAR *)_T("DROP TABLE HASH2_TABLE cascade"); SQLTCHAR *crtTbl = (SQLTCHAR *)_T("CREATE TABLE HASH2_TABLE (A int NOT NULL NOT DROPPABLE, B varchar(10), PRIMARY KEY (A))"); SQLTCHAR *insTbl = (SQLTCHAR *)_T("INSERT INTO HASH2_TABLE values (?,?)"); // SQLTCHAR *selTbl = (SQLTCHAR *)_T("SELECT * HASH2_TABLE"); //================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing feature => Hash2.\n")); TEST_INIT; returncode = SQLAllocEnv(&henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect( henv, &hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON,0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectAttr")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } //================================================================================================== // Set Mode to Loader returncode = SQLSetConnectAttr(hdbc, SQL_MODE_LOADER, (void *) mode, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_MODE_LOADER")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } // Set Start mode returncode = SQLSetConnectAttr(hdbc, SQL_START_NODE, (void *) startnode, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_START_NODE")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } // Set Desired Streams Per Node returncode = SQLSetConnectAttr(hdbc, SQL_STREAMS_PER_SEG, (void *) streams_per_node, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_STREAMS_PER_SEG")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } // Set delay_error mode returncode = SQLSetConnectAttr(hdbc, SQL_LOADER_DELAYERROR, (void *) delay_error, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_LOADER_DELAYERROR")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } //================================================================================================== returncode = SQLConnect(hdbc, (SQLTCHAR*)pTestInfo->DataSource,(SWORD)_tcslen(pTestInfo->DataSource), (SQLTCHAR*)pTestInfo->UserID,(SWORD)_tcslen(pTestInfo->UserID), (SQLTCHAR*)pTestInfo->Password,(SWORD)_tcslen(pTestInfo->Password) ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLAllocStmt(hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt, dropTbl, SQL_NTS); returncode = SQLExecDirect(hstmt, crtTbl, SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLPrepare(hstmt, (SQLTCHAR *) sqlDrvInsert, SQL_NTS); if (returncode != SQL_SUCCESS) { LogMsg(ERRMSG,_T("PLANLOADTABLE is expected to return SQL_SUCCESS, actual is %d\n"), returncode); LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLGetConnectAttr(hdbc, SQL_ATTR_SUG_ROWSET_SIZE, &suggested_rowset_size, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_ATTR_SUG_ROWSET_SIZE")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } LogMsg(LINEAFTER,_T("suggested_rowset_size=%d\n"), suggested_rowset_size); //================================================================================================== // Set the SQL_ATTR_PARAM_BIND_TYPE statement attribute to use row-wise binding. returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_PARAM_BIND_TYPE, (void *)sizeof(nameStruct), 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_ATTR_PARAM_BIND_TYPE")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } // Specify the number of elements in each parameter array. returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (void *)ARRAY_SIZE, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_ATTR_PARAMSET_SIZE")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } // Specify an array in which to return the status of each set of parameters. returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_PARAM_STATUS_PTR, ParamStatusArray, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_ATTR_PARAM_STATUS_PTR")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } // Specify an SQLUINTEGER value in which to return the number of sets of parameters processed. returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &ParamsProcessed, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_ATTR_PARAMS_PROCESSED_PTR")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLPrepare(hstmt, insTbl, SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_TCHAR, SQL_INTEGER, 10, 0, &nameArray1[0].num, 300, &nameArray1[0].numLenOrInd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_TCHAR, SQL_WCHAR, 10, 0, &nameArray1[0].val, 300, &nameArray1[0].valLenOrInd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } for (j=0; j<ARRAY_SIZE; j++) { lastExpParamStatusArray[j] = SQL_PARAM_SUCCESS; expParamStatusArray[j] = SQL_PARAM_SUCCESS; } //================================================================================================== TESTCASE_BEGIN("Test the positive functionality of Hash2, with delay_error mode ON.\n"); loopcount = 4; k = 0; while ( k < (loopcount+1)) { expRowcount = 0; if (k==loopcount) { //Send a dummy rowsets to get the status array of the previous rowsets in delay-mode LogMsg(LINEAFTER,_T("Insert dummy rowsets with size=0\n")); returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (void *)0, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQL_ATTR_PARAMSET_SIZE")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } } else { _stprintf(buffer, _T("Data inserted: ")); for (j=0; j<ARRAY_SIZE; j++) { if ((j+1)%(3+2*k) == 0) { counter--; expParamStatusArray[j] = SQL_PARAM_ERROR; } else { expParamStatusArray[j] = SQL_PARAM_SUCCESS; expRowcount++; } _stprintf(nameArray1[j].num,_T("%d"),counter++); nameArray1[j].numLenOrInd = SQL_NTS; _stprintf(nameArray1[j].val,_T("%s"),_T("chochet")); nameArray1[j].valLenOrInd = SQL_NTS; _tcscat(buffer,nameArray1[j].num); _tcscat(buffer,_T(" ")); } _tcscat(buffer,_T("\n")); } LogMsg(NONE,_T("%s\n"), buffer); returncode = SQLExecute(hstmt); if (delay_error == 1 && k != 0) { if(returncode != SQL_SUCCESS_WITH_INFO) { LogMsg(ERRMSG,_T("SQLExecute: returncode expected: SQL_SUCCESS_WITH_INFO, actual: %d at line=%d\n"), returncode, __LINE__); LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } } else { if(returncode != SQL_SUCCESS) { LogMsg(ERRMSG,_T("SQLExecute: returncode expected: SQL_SUCCESS, actual: %d at line=%d\n"), returncode, __LINE__); LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } } if ((k == loopcount && ParamsProcessed != 0) || (k != loopcount && ParamsProcessed != ARRAY_SIZE)) { LogMsg(ERRMSG,_T("ParamsProcessed is not the same as rowset size from client, at line=%d\n"), __LINE__); TEST_FAILED; } returncode = SQLRowCount(hstmt, &rowcount); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLRowCount")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } if (delay_error == 1) { if (lastExpRowcount != rowcount) { TEST_FAILED; LogMsg(ERRMSG,_T("Expected Rowcount=%d, Actual Rowcount=%d\n"), expRowcount, rowcount); } lastExpRowcount = expRowcount; LogMsg(NONE,_T("\n%d last rows processed, %d current rows processed, rowcount=%d\n"), lastParamsProcessed, ParamsProcessed, rowcount); for (i = 0; i < (int)lastParamsProcessed; i++) { LogMsg(NONE,_T("Parameter Set Status\n")); LogMsg(NONE,_T("------------- -------------\n")); if (ParamStatusArray[i] != lastExpParamStatusArray[i]) { TEST_FAILED; LogMsg(ERRMSG,_T("Param status array at row #%d is expected: %d, actual %d\n"), i, lastExpParamStatusArray[i], ParamStatusArray[i]); continue; } switch (ParamStatusArray[i]) { case SQL_PARAM_SUCCESS: case SQL_PARAM_SUCCESS_WITH_INFO: LogMsg(NONE,_T("%13d Success\n"), i); break; case SQL_PARAM_ERROR: LogMsg(NONE,_T("%13d Error <-------\n"), i); break; case SQL_PARAM_UNUSED: LogMsg(NONE,_T("%13d Not processed\n"), i); break; case SQL_PARAM_DIAG_UNAVAILABLE: LogMsg(NONE,_T("%13d Unknown\n"), i); break; } } LogMsg(NONE,_T("\n============================================================\n")); lastParamsProcessed = ParamsProcessed; for (j=0; j<ARRAY_SIZE; j++) { lastExpParamStatusArray[j] = expParamStatusArray[j]; } } else { if (expRowcount != rowcount) { TEST_FAILED; LogMsg(ERRMSG,_T("Expected Rowcount=%d, Actual Rowcount=%d\n"), expRowcount, rowcount); } LogMsg(NONE,_T("\n%d current rows processed, rowcount=%d\n"), ParamsProcessed, rowcount); for (i = 0; i < (int)ParamsProcessed; i++) { LogMsg(NONE,_T("Parameter Set Status\n")); LogMsg(NONE,_T("------------- -------------\n")); if (ParamStatusArray[i] != expParamStatusArray[i]) { TEST_FAILED; LogMsg(ERRMSG,_T("Param status array at row #%d is expected: %d, actual %d\n"), i, expParamStatusArray[i], ParamStatusArray[i]); continue; } switch (ParamStatusArray[i]) { case SQL_PARAM_SUCCESS: case SQL_PARAM_SUCCESS_WITH_INFO: LogMsg(NONE,_T("%13d Success\n"), i); break; case SQL_PARAM_ERROR: LogMsg(NONE,_T("%13d Error <-------\n"), i); break; case SQL_PARAM_UNUSED: LogMsg(NONE,_T("%13d Not processed\n"), i); break; case SQL_PARAM_DIAG_UNAVAILABLE: LogMsg(NONE,_T("%13d Unknown\n"), i); break; } } LogMsg(NONE,_T("\n============================================================\n")); } k++; } TESTCASE_END; SQLFreeStmt( hstmt, SQL_CLOSE ); SQLFreeStmt( hstmt, SQL_UNBIND ); SQLDisconnect( hdbc ); SQLFreeConnect( hdbc ); SQLFreeEnv( henv ); //================================================================================================== LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing feature => Hash2.\n")); TEST_RETURN; }
/*********************************************************************** ** FillTable() ** ** This function will insert the specified number of records into an SQL ** table. The table will be emptied first, before records are inserted. ************************************************************************/ short FillTable(TableDescription *TablePtr) { NomadInfo *NPtr; TableInfo *TPtr; ColumnInfo *pCol; ReturnStatus *RSPtr; long record_num=0; char parm_string[80]; char fields[80]; short i; long record_count; RETCODE rc; HSTMT hstmt; char command_line[SQL_MAX_COMMAND_LENGTH]; short abort_flag; short zerosum_value; short last_process_id_column; NPtr=TablePtr->NomadInfoPtr; TPtr=TablePtr->TableInfoPtr; hstmt=TablePtr->hstmt; /* if there are any records in the table to delete, then try to */ /* delete them because we must start with a clean table */ sprintf(command_line,"DELETE FROM %s",TPtr->TableName); rc=SQLExecDirect(hstmt,command_line,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,rc,"SQLExecDirect")){ printf("%s return code=%d on %s\n",g_errstr,rc,command_line); LogAllErrors(NULL,NULL,hstmt); if(rc!=SQL_SUCCESS_WITH_INFO) return(FAILURE); } /*>>>need to handle the case of an entry sequenced file which we */ /*>>>can not delete from. Maybe check if it has any records in it */ /*>>>so, for now we'll just ignore any errors */ /* next, fill SQL tables with random inserts */ /* allocate record bitmaps for each table to keep track of which */ /* records have been written */ NPtr->BitmapPtr=QACreateBitmap(NPtr->max_records); if(NPtr->BitmapPtr==NULL){ LogMsg(ERRMSG+LINEAFTER, "unable to allocate space for table's bitmap\n"); return(FAILURE); } /* build the SQL INSERT statement */ if(strcmp(TPtr->ColPtr[0].CName,"SYSKEY")==0){ strcpy(fields,"SYSKEY,*"); } else strcpy(fields,"*"); sprintf(command_line,"INSERT INTO %s (%s) VALUES(?p0", TPtr->TableName,fields); for(i=1;i<TPtr->NumOfCol;i++){ sprintf(parm_string,",?p%d",i); strncat(command_line,parm_string,6); } strncat(command_line,")",2); gTrace=1; rc=SQLPrepare(hstmt,command_line,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,rc,"SQLPrepare")){ LogAllErrors(NULL,NULL,hstmt); return(FAILURE); } /* are we going to fill the table with random inserts? */ if(NPtr->InitialFillMethod==FILLRANDOMLY){ if(gTrace){ LogMsg(0," -- filling table %s randomly with %ld records\n", TPtr->TableName,NPtr->InitialRecordCount); } /* randomly fill table with records */ for(record_count=0;record_count<NPtr->InitialRecordCount;record_count++){ /* randomly choose a record number which has not been chosen before */ record_num=FindNextBit(BIT_OFF,NPtr->BitmapPtr, LongRand(NPtr->max_records),CIRCULAR_SEARCH); /* if no unused records remain then something is wrong */ if(record_num<0)return(FAILURE); /* fill each field with random data appropriate to its type */ /* randomly fill values into all columns */ RSPtr=BindAndFillAllParams(hstmt,TPtr); if(RSPtr!=NULL){ LogMsg(ERRMSG+LINEAFTER, "couldn't generate random data values for all columns\n" "probable cause: row contains an unsupported data type\n" "I will continue, inserting the row as is\n"); FreeReturnStatus(RSPtr); } /* set key-column(s) */ RSPtr=SetKeyColumnValue2(TablePtr,record_num); if(RSPtr!=NULL){ LogMsg(ERRMSG+LINEAFTER, "couldn't set data value for all key columns\n" "probable cause: row contains an unsupported data type\n" "I will continue, inserting the row as is\n"); FreeReturnStatus(RSPtr); } /* set abort-column */ abort_flag=0; pCol=&(TPtr->ColPtr[NPtr->abort_column]); rc=SQLBindParameter(hstmt,(short)(NPtr->abort_column+1),SQL_PARAM_INPUT,SQL_C_SHORT, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &abort_flag,1,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(NULL,NULL,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* set zerosum-column */ zerosum_value=0; pCol=&(TPtr->ColPtr[NPtr->zerosum_column]); rc=SQLBindParameter(hstmt,(short)(NPtr->zerosum_column+1),SQL_PARAM_INPUT,SQL_C_SHORT, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &zerosum_value,0,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(NULL,NULL,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* set last process id column */ last_process_id_column=0; pCol=&(TPtr->ColPtr[NPtr->last_process_id_column]); rc=SQLBindParameter(hstmt,(short)(NPtr->last_process_id_column+1),SQL_PARAM_INPUT,SQL_C_SHORT, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &last_process_id_column,0,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(NULL,NULL,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* EXECUTE the previously prepared INSERT statement */ rc=SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,rc,"SQLExecute")){ LogAllErrors(NULL,NULL,hstmt); assert(FALSE); if(rc!=SQL_SUCCESS_WITH_INFO) return(FAILURE); } /* once sucessfully inserted (or hit allowable error) then mark bit... */ /* ...in bitmap for this table */ SetBit(BIT_ON,NPtr->BitmapPtr,record_num); }/* end: for */ } /* end: if random inserts */ /* fill the table with sequential inserts starting at record zero */ else { if(gTrace){ LogMsg(0," %s\n" " -- filling table %s sequentially starting with 0 for %ld records\n", TPtr->TableName,command_line,NPtr->InitialRecordCount); } for(record_count=0;i<NPtr->InitialRecordCount;record_count++){ /* fill each field with random data appropriate to its type */ /* randomly fill values into all columns */ RSPtr=BindAndFillAllParams(hstmt,TPtr); if(RSPtr!=NULL){ LogMsg(ERRMSG+LINEAFTER, "couldn't generate random data values for all columns\n" "probable cause: row contains an unsupported data type\n" "I will continue, inserting the row as is\n"); FreeReturnStatus(RSPtr); } /* set key-column(s) */ RSPtr=SetKeyColumnValue2(TablePtr,i); if(RSPtr!=NULL){ LogMsg(ERRMSG+LINEAFTER, "couldn't set data value for all key columns\n" "probable cause: row contains an unsupported data type\n" "I will continue, inserting the row as is\n"); FreeReturnStatus(RSPtr); } /* set abort-column */ abort_flag=0; pCol=&(TPtr->ColPtr[NPtr->abort_column]); rc=SQLBindParameter(hstmt,(short)(NPtr->abort_column+1),SQL_PARAM_INPUT,SQL_C_SHORT, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &abort_flag,1,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(NULL,NULL,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* set zerosum-column */ zerosum_value=0; pCol=&(TPtr->ColPtr[NPtr->zerosum_column]); rc=SQLBindParameter(hstmt,(short)(NPtr->zerosum_column+1),SQL_PARAM_INPUT,SQL_C_SHORT, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &zerosum_value,0,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(NULL,NULL,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* set last process id column */ last_process_id_column=0; pCol=&(TPtr->ColPtr[NPtr->last_process_id_column]); rc=SQLBindParameter(hstmt,(short)(NPtr->last_process_id_column+1),SQL_PARAM_INPUT,SQL_C_SHORT, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &last_process_id_column,0,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(NULL,NULL,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* EXECUTE the previously prepared INSERT statement */ rc=SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,rc,"SQLExecute")){ LogAllErrors(NULL,NULL,hstmt); if(rc!=SQL_SUCCESS_WITH_INFO) return(FAILURE); } /* once sucessfully inserted (or hit allowable error) then mark bit... */ /* ...in bitmap for this table */ SetBit(BIT_ON,NPtr->BitmapPtr,i); } } /* perform an UPDATE STATISTICS on the table, mainly to get rid of */ /* that annoying warning from SQL about no statistics available */ /* whenever anyone accesses the table */ sprintf(command_line,"UPDATE STATISTICS FOR TABLE %s ON EVERY COLUMN", TPtr->TableName); rc=SQLExecDirect(hstmt,command_line,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,rc,"SQLExecDirect")){ printf("return code=%d on %s\n",rc,command_line); LogAllErrors(NULL,NULL,hstmt); if(rc!=SQL_SUCCESS_WITH_INFO) return(FAILURE); } return(SUCCESS); } /* end: FillTable() */
/* --------------------------------------------------------- TestSQLTablePrivileges --------------------------------------------------------- */ PassFail TestMXSQLTablePrivileges( TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_HEADING_SIZE]; /* */char ColumnWC4_TabOwner[NAME_LEN]; RETCODE returncode; SQLHANDLE henv = (SQLHANDLE)NULL; SQLHANDLE hdbc = (SQLHANDLE)NULL; SQLHANDLE hstmt = (SQLHANDLE)NULL, hstmt1 = (SQLHANDLE)NULL; CHAR TableQualifier[NAME_LEN],TableOwner[NAME_LEN],*TableStr; CHAR *TableName; // CHAR *Grantor; //Assume that we log on as role.user CHAR Grantor[SQL_MAX_ROLENAME_LEN+2]; CHAR oTableQualifier[NAME_LEN]; CHAR oTableOwner[NAME_LEN]; CHAR oTableName[NAME_LEN]; CHAR oGrantor[NAME_LEN]; CHAR oGrantee[NAME_LEN]; CHAR oPrivilege[NAME_LEN]; CHAR oIs_Grantable[3]; SQLLEN oTableQualifierlen; SQLLEN oTableOwnerlen; SQLLEN oTableNamelen; SQLLEN oGrantorlen = SQL_NTS; SQLLEN oGranteelen; SQLLEN oPrivilegelen; SQLLEN oIs_Grantablelen; /* */ struct { CHAR *Col; CHAR *Grantee; CHAR *Is_Grantable; CHAR *Privilege; } TableCol[] = { {"--",SQ_GRANTEE,"YES","DELETE"}, {"--",SQ_GRANTEE,"NO","DELETE,SELECT"}, {"--",SQ_GRANTEE,"YES","SELECT"}, {"--",SQ_GRANTEE,"NO","DELETE"}, {"--",SQ_GRANTEE,"YES","INSERT"}, {"--",SQ_GRANTEE,"NO","UPDATE"}, {"--",SQ_GRANTEE,"YES","REFERENCES"}, {"--",SQ_GRANTEE,"NO","SELECT"}, {"--",SQ_GRANTEE,"YES","INSERT"}, {"--",SQ_GRANTEE,"NO","REFERENCES"}, {"--",SQ_GRANTEE,"YES","UPDATE"}, {"--",SQ_GRANTEE,"NO","REFERENCES"}, {"--",SQ_GRANTEE,"YES","UPDATE"}, {"--",SQ_GRANTEE,"NO","INSERT",}, {"--",SQ_GRANTEE,"YES","SELECT"}, {"--",SQ_GRANTEE,"NO","REFERENCES,SELECT"}, {"--",SQ_GRANTEE,"YES","DELETE,INSERT,SELECT"}, {"--",SQ_GRANTEE,"NO","INSERT,REFERENCES,UPDATE"}, {"--",SQ_GRANTEE,"YES","SELECT,DELETE,INSERT,UPDATE"}, {"--",SQ_GRANTEE,"NO","DELETE,INSERT,REFERENCES,UPDATE",}, {"--",SQ_GRANTEE,"YES","DELETE,INSERT,REFERENCES,SELECT,UPDATE"}, {"--",SQ_GRANTEE,"NO","DELETE"}, //Bignum {"--",SQ_GRANTEE,"YES","SELECT"}, //Bignum {"--",SQ_GRANTEE,"NO","INSERT"}, //Bignum {"--",SQ_GRANTEE,"YES","UPDATE"}, //Bignum {"--",SQ_GRANTEE,"NO","REFERENCES"}, //Bignum {"--",SQ_GRANTEE,"YES","SELECT,DELETE,INSERT,UPDATE"},//Bignum {"--",SQ_GRANTEE,"NO","INSERT,REFERENCES,UPDATE"}, //Bignum {"endloop",} }; struct { CHAR *TabQua; CHAR *TabOwner; CHAR *TabName; RETCODE CheckCode; int isEscape; } ColumnWC[] = { // wild cards from here {"--","--","--", SQL_SUCCESS,0},// Have a row with all valid values here so that {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_ERROR,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, {"--","--","--", SQL_SUCCESS,0}, // Testing escape sequences {"--","--","--", SQL_SUCCESS,1}, {"--","--","--", SQL_SUCCESS,1}, {"--","--","--", SQL_SUCCESS,1}, {"--","--","--", SQL_SUCCESS,1}, {"endloop",} }; struct { CHAR *TabQua; SWORD TabQuaLen; CHAR *TabOwner; SWORD TabOwnerLen; CHAR *TabName; SWORD TabNameLen; CHAR *ColName; SWORD ColNameLen; } ColumnWC2[] = { // wild cards from here {"--", (SWORD)-1, "--",(SWORD)-1, "--",(SWORD)-1, "", (SWORD)-1}, {"--", (SWORD)4, "--",(SWORD)2, "--",(SWORD)2, "", (SWORD)2}, // {"TEST_CATALOG", (SWORD)0, "TEST_SCHEMA",(SWORD)0, "TEST_TABLE",(SWORD)0, "", (SWORD)0}, {"endloop",} }; int cols; int iatt; SWORD numOfCols = 0; SWORD pcbDesc; SQLLEN pfDesc; CHAR cn[COLNAME_LEN]; SWORD cl; SWORD st; SQLULEN cp; SWORD cs, cnull; CHAR rgbDesc[RGB_MAX_LEN]; CHAR *CharOutput[12]; SQLLEN stringlength; // Attributes for columns added for negative testing UWORD DescrType[] = { SQL_COLUMN_AUTO_INCREMENT,SQL_COLUMN_CASE_SENSITIVE,SQL_COLUMN_COUNT, SQL_COLUMN_DISPLAY_SIZE,SQL_COLUMN_LENGTH,SQL_COLUMN_MONEY, SQL_COLUMN_NULLABLE,SQL_COLUMN_PRECISION,SQL_COLUMN_SCALE, SQL_COLUMN_SEARCHABLE,SQL_COLUMN_TYPE,SQL_COLUMN_UNSIGNED, SQL_COLUMN_UPDATABLE,SQL_COLUMN_NAME,SQL_COLUMN_TYPE_NAME, SQL_COLUMN_OWNER_NAME,SQL_COLUMN_QUALIFIER_NAME,SQL_COLUMN_TABLE_NAME, SQL_COLUMN_LABEL }; CHAR *TestColumn; int i = 0, k = 0; struct { char cat[STR_LEN]; char sch[STR_LEN]; char tab[STR_LEN]; } displayBuf; // DWORD nSize; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLTablePrivileges", charset_file); if (var_list == NULL) return FAILED; TableName = var_mapping("SQLTablePrivileges_TableName", var_list); TestColumn = var_mapping("SQLTablePrivileges_TestColumn", var_list); TableCol[0].Col = var_mapping("SQLTablePrivileges_TableCol_Col_0", var_list); TableCol[1].Col = var_mapping("SQLTablePrivileges_TableCol_Col_1", var_list); TableCol[2].Col = var_mapping("SQLTablePrivileges_TableCol_Col_2", var_list); TableCol[3].Col = var_mapping("SQLTablePrivileges_TableCol_Col_3", var_list); TableCol[4].Col = var_mapping("SQLTablePrivileges_TableCol_Col_4", var_list); TableCol[5].Col = var_mapping("SQLTablePrivileges_TableCol_Col_5", var_list); TableCol[6].Col = var_mapping("SQLTablePrivileges_TableCol_Col_6", var_list); TableCol[7].Col = var_mapping("SQLTablePrivileges_TableCol_Col_7", var_list); TableCol[8].Col = var_mapping("SQLTablePrivileges_TableCol_Col_8", var_list); TableCol[9].Col = var_mapping("SQLTablePrivileges_TableCol_Col_9", var_list); TableCol[10].Col = var_mapping("SQLTablePrivileges_TableCol_Col_10", var_list); TableCol[11].Col = var_mapping("SQLTablePrivileges_TableCol_Col_11", var_list); TableCol[12].Col = var_mapping("SQLTablePrivileges_TableCol_Col_12", var_list); TableCol[13].Col = var_mapping("SQLTablePrivileges_TableCol_Col_13", var_list); TableCol[14].Col = var_mapping("SQLTablePrivileges_TableCol_Col_14", var_list); TableCol[15].Col = var_mapping("SQLTablePrivileges_TableCol_Col_15", var_list); TableCol[16].Col = var_mapping("SQLTablePrivileges_TableCol_Col_16", var_list); TableCol[17].Col = var_mapping("SQLTablePrivileges_TableCol_Col_17", var_list); TableCol[18].Col = var_mapping("SQLTablePrivileges_TableCol_Col_18", var_list); TableCol[19].Col = var_mapping("SQLTablePrivileges_TableCol_Col_19", var_list); TableCol[20].Col = var_mapping("SQLTablePrivileges_TableCol_Col_20", var_list); TableCol[21].Col = var_mapping("SQLTablePrivileges_TableCol_Col_21", var_list); TableCol[22].Col = var_mapping("SQLTablePrivileges_TableCol_Col_22", var_list); TableCol[23].Col = var_mapping("SQLTablePrivileges_TableCol_Col_23", var_list); TableCol[24].Col = var_mapping("SQLTablePrivileges_TableCol_Col_24", var_list); TableCol[25].Col = var_mapping("SQLTablePrivileges_TableCol_Col_25", var_list); TableCol[26].Col = var_mapping("SQLTablePrivileges_TableCol_Col_26", var_list); TableCol[27].Col = var_mapping("SQLTablePrivileges_TableCol_Col_27", var_list); ColumnWC[0].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_0", var_list); ColumnWC[0].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_0", var_list); ColumnWC[0].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_0", var_list); ColumnWC[1].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_1", var_list); ColumnWC[1].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_1", var_list); ColumnWC[1].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_1", var_list); ColumnWC[2].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_2", var_list); ColumnWC[2].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_2", var_list); ColumnWC[2].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_2", var_list); ColumnWC[3].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_3", var_list); ColumnWC[3].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_3", var_list); ColumnWC[3].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_3", var_list); ColumnWC[4].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_4", var_list); ColumnWC[4].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_4", var_list); ColumnWC[4].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_4", var_list); ColumnWC[5].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_5", var_list); ColumnWC[5].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_5", var_list); ColumnWC[5].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_5", var_list); ColumnWC[6].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_6", var_list); ColumnWC[6].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_6", var_list); ColumnWC[6].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_6", var_list); ColumnWC[7].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_7", var_list); ColumnWC[7].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_7", var_list); ColumnWC[7].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_7", var_list); ColumnWC[8].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_8", var_list); ColumnWC[8].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_8", var_list); ColumnWC[8].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_8", var_list); ColumnWC[9].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_9", var_list); ColumnWC[9].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_9", var_list); ColumnWC[9].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_9", var_list); ColumnWC[10].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_10", var_list); ColumnWC[10].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_10", var_list); ColumnWC[10].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_10", var_list); ColumnWC[11].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_11", var_list); ColumnWC[11].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_11", var_list); ColumnWC[11].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_11", var_list); ColumnWC[12].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_12", var_list); ColumnWC[12].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_12", var_list); ColumnWC[12].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_12", var_list); ColumnWC[13].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_13", var_list); ColumnWC[13].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_13", var_list); ColumnWC[13].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_13", var_list); ColumnWC[14].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_14", var_list); ColumnWC[14].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_14", var_list); ColumnWC[14].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_14", var_list); ColumnWC[15].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_15", var_list); ColumnWC[15].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_15", var_list); ColumnWC[15].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_15", var_list); ColumnWC[16].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_16", var_list); ColumnWC[16].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_16", var_list); ColumnWC[16].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_16", var_list); ColumnWC[17].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_17", var_list); ColumnWC[17].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_17", var_list); ColumnWC[17].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_17", var_list); ColumnWC[18].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_18", var_list); ColumnWC[18].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_18", var_list); ColumnWC[18].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_18", var_list); ColumnWC[19].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_19", var_list); ColumnWC[19].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_19", var_list); ColumnWC[19].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_19", var_list); ColumnWC[20].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_20", var_list); ColumnWC[20].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_20", var_list); ColumnWC[20].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_20", var_list); ColumnWC[21].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_21", var_list); ColumnWC[21].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_21", var_list); ColumnWC[21].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_21", var_list); ColumnWC[22].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_22", var_list); ColumnWC[22].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_22", var_list); ColumnWC[22].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_22", var_list); ColumnWC[23].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_23", var_list); ColumnWC[23].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_23", var_list); ColumnWC[23].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_23", var_list); ColumnWC[24].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_24", var_list); ColumnWC[24].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_24", var_list); ColumnWC[24].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_24", var_list); ColumnWC[25].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_25", var_list); ColumnWC[25].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_25", var_list); ColumnWC[25].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_25", var_list); ColumnWC[26].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_26", var_list); ColumnWC[26].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_26", var_list); ColumnWC[26].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_26", var_list); ColumnWC[27].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_27", var_list); ColumnWC[27].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_27", var_list); ColumnWC[27].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_27", var_list); ColumnWC[28].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_28", var_list); ColumnWC[28].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_28", var_list); ColumnWC[28].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_28", var_list); ColumnWC[29].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_29", var_list); ColumnWC[29].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_29", var_list); ColumnWC[29].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_29", var_list); ColumnWC[30].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_30", var_list); ColumnWC[30].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_30", var_list); ColumnWC[30].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_30", var_list); ColumnWC[31].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_31", var_list); ColumnWC[31].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_31", var_list); ColumnWC[31].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_31", var_list); ColumnWC[32].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_32", var_list); ColumnWC[32].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_32", var_list); ColumnWC[32].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_32", var_list); ColumnWC[33].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_33", var_list); ColumnWC[33].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_33", var_list); ColumnWC[33].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_33", var_list); ColumnWC[34].TabQua = var_mapping("SQLTablePrivileges_ColumnWC_TabQua_34", var_list); ColumnWC[34].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC_TabOwner_34", var_list); ColumnWC[34].TabName = var_mapping("SQLTablePrivileges_ColumnWC_TabName_34", var_list); ColumnWC2[0].TabQua = var_mapping("SQLTablePrivileges_ColumnWC2_TabQua_0", var_list); ColumnWC2[0].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC2_TabOwner_0", var_list); ColumnWC2[0].TabName = var_mapping("SQLTablePrivileges_ColumnWC2_TabName_0", var_list); ColumnWC2[1].TabQua = var_mapping("SQLTablePrivileges_ColumnWC2_TabQua_1", var_list); ColumnWC2[1].TabOwner = var_mapping("SQLTablePrivileges_ColumnWC2_TabOwner_1", var_list); ColumnWC2[1].TabName = var_mapping("SQLTablePrivileges_ColumnWC2_TabName_1", var_list); //================================================================================================= LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => SQLTablePrivileges | SQLTablePriv | tabpriv.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLTablePrivileges tests\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,"Unable to connect\n"); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } #ifdef LDAP // Grantor = var_mapping("SQLTablePrivileges_Grantor", var_list); /* returncode = SQLGetConnectAttr(hdbc, (SQLINTEGER)SQL_ATTR_ROLENAME, (SQLCHAR*)Grantor, SQL_MAX_ROLENAME_LEN+2, (SQLINTEGER *) &oGrantorlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetConnectAttr")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } */ /* hardcode it for now */ strcpy (Grantor, "DB__ROOT"); #else sprintf(Grantor, "%s", var_mapping("SQLTablePrivileges_Grantor", var_list)); #endif LogMsg(NONE,"Grantor is: %s\n", Grantor); TESTCASE_END; // end of setup strcpy(TableQualifier,pTestInfo->Catalog); strcpy(TableOwner,pTestInfo->Schema); TableStr = (char *)malloc(MAX_NOS_SIZE); i = 0; while (_stricmp(TableCol[i].Col,"endloop") != 0) { sprintf(Heading,"Test #%d\n",i); TESTCASE_BEGIN(Heading); if (_stricmp(TableCol[i].Privilege,"ALL PRIVILEGES") == 0) strcpy(TableCol[i].Privilege,"DELETE"); // clean up left over table, if any. We don't care about returncode from SQLExecDirect sprintf(TableStr,"drop table %s",TableName); SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); // create table to test against sprintf(TableStr,"create table %s (%s) no partition;",TableName,TableCol[i].Col); returncode = SQLExecDirect(hstmt,(SQLCHAR*)TableStr,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { // execute GRANT statement to set up some table privileges sprintf(TableStr,"GRANT %s ON %s TO \"%s\"",TableCol[i].Privilege,TableName,TableCol[i].Grantee); if (_stricmp(TableCol[i].Is_Grantable,"YES") == 0) strcat(TableStr, " WITH GRANT OPTION"); LogMsg(NONE,"%s\n",TableStr); returncode = SQLExecDirect(hstmt,(SQLCHAR*)TableStr,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { // Execute SQLTablePrivileges for test table if (strlen(TableQualifier) == 0) returncode = SQLTablePrivileges(hstmt,NULL,0,(SQLCHAR*)TableOwner,(SWORD)strlen(TableOwner),(SQLCHAR*)TableName,(SWORD)strlen(TableName)); else returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)TableQualifier,(SWORD)strlen(TableQualifier),(SQLCHAR*)TableOwner,(SWORD)strlen(TableOwner),(SQLCHAR*)TableName,(SWORD)strlen(TableName)); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTablePrivileges")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { LogMsg(NONE,"SQLTablePrivileges function call executed correctly.\n"); // clear all buffers strcpy(oTableQualifier,""); strcpy(oTableOwner,""); strcpy(oTableName,""); strcpy(oGrantor,""); strcpy(oGrantee,""); strcpy(oPrivilege,""); strcpy(oIs_Grantable,""); // Bind all columns to recieve data returned from SQLTablePrivileges returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTableQualifier,NAME_LEN,&oTableQualifierlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,2,SQL_C_CHAR,oTableOwner,NAME_LEN,&oTableOwnerlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,3,SQL_C_CHAR,oTableName,NAME_LEN,&oTableNamelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oGrantor,NAME_LEN,&oGrantorlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oGrantee,NAME_LEN,&oGranteelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oPrivilege,NAME_LEN,&oPrivilegelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,7,SQL_C_CHAR,oIs_Grantable,NAME_LEN,&oIs_Grantablelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } // Loop, reading and checking all data retuned from SQLTablePrivileges call k = 0; while (returncode == SQL_SUCCESS) { returncode = SQLFetch(hstmt); if((returncode!=SQL_NO_DATA_FOUND) && (!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { // check for SQL_SUCCESS in case SQL_NO_DATA_FOUND was what was returned // compare results for rows where oGrantor is not the same as Grantor (super.super) if ((returncode == SQL_SUCCESS) && (_stricmp(Grantor,oGrantor) == 0) && (_stricmp(TableCol[i].Grantee,oGrantee) == 0)) { k++; // found a match, increment counter if ((_stricmp(TableQualifier,oTableQualifier) == 0) && (cstrcmp(TableOwner,oTableOwner,TRUE,isCharSet) == 0) && (cstrcmp(TableName,oTableName,TRUE,isCharSet) == 0) //&& (_stricmp(oGrantor,Grantor) == 0) //&& (_stricmp(TableCol[i].Grantee,oGrantee) == 0) // NOT NEEDED && (strstr(TableCol[i].Privilege,oPrivilege) != NULL) && (_stricmp(TableCol[i].Is_Grantable,oIs_Grantable) == 0) ) { LogMsg(NONE,"SQLTablePrivileges: compare results of rows fetched for following column.\n"); LogMsg(NONE,"TableQualifier expect: %s and actual: %s are matched\n",TableQualifier,oTableQualifier); LogMsg(NONE,"TableOwner expect: %s and actual: %s are matched\n",TableOwner,oTableOwner); LogMsg(NONE,"TableName expect: %s and actual: %s are matched\n",TableName,oTableName); LogMsg(NONE,"Grantor expect: %s and actual: %s are matched\n",Grantor,oGrantor); LogMsg(NONE,"Grantee expect: %s and actual: %s are matched\n",TableCol[i].Grantee,oGrantee); LogMsg(NONE,"Privilege expect: %s and actual: %s are matched\n",TableCol[i].Privilege,oPrivilege); LogMsg(NONE,"Is_Grantable expect: %s and actual: %s are matched\n",TableCol[i].Is_Grantable,oIs_Grantable); } else { TEST_FAILED; LogMsg(NONE,"SQLTablePrivileges: compare results of rows fetched for following column failed line %d.\n", __LINE__); if (_stricmp(TableQualifier,oTableQualifier) != 0) LogMsg(ERRMSG,"TableQualifier expect: %s and actual: %s are not matched\n",TableQualifier,oTableQualifier); if (cstrcmp(TableOwner,oTableOwner,TRUE,isCharSet) != 0) LogMsg(ERRMSG,"TableOwner expect: %s and actual: %s are not matched\n",TableOwner,oTableOwner); if (cstrcmp(TableName,oTableName,TRUE,isCharSet) != 0) LogMsg(ERRMSG,"TableName expect: %s and actual: %s are not matched\n",TableName,oTableName); //if (_stricmp(oGrantor,Grantor) != 0) // LogMsg(ERRMSG,"Grantor expect: %s and actual: %s are not matched\n",Grantor,oGrantor); //if (_stricmp(TableCol[i].Grantee,oGrantee) != 0) // LogMsg(ERRMSG,"Grantee expect: %s and actual: %s are not matched\n",TableCol[i].Grantee,oGrantee); if (strstr(TableCol[i].Privilege,oPrivilege) == NULL) LogMsg(ERRMSG,"Privilege expect: %s and actual: %s are not matched\n",TableCol[i].Privilege,oPrivilege); if (_stricmp(TableCol[i].Is_Grantable,oIs_Grantable) != 0) LogMsg(ERRMSG,"Is_Grantable expect: %s and actual: %s are not matched\n",TableCol[i].Is_Grantable,oIs_Grantable); } } } } if(k == 0){ TEST_FAILED; LogMsg(ERRMSG,"No matching grantee record for '%s' found\n" " At least one row fetched should have matched\n", TableCol[i].Grantee); } SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt,SQL_CLOSE); } } } TESTCASE_END; // clean up SQL table sprintf(TableStr,"drop table %s",TableName); SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); i++; } //======================================================================================= i = 0; sprintf(TableStr,"drop table %s.%s.%s",ColumnWC[i].TabQua, ColumnWC[i].TabOwner, ColumnWC[i].TabName); SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); LogMsg(NONE,"%s\n",TableStr); sprintf(TableStr,"drop schema %s.%s cascade",ColumnWC[i].TabQua, ColumnWC[i].TabOwner); SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); LogMsg(NONE,"%s\n",TableStr); sprintf(TableStr,"create schema %s.%s",ColumnWC[i].TabQua, ColumnWC[i].TabOwner); LogMsg(NONE,"%s\n",TableStr); returncode = SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { sprintf(TableStr,"create table %s.%s.%s(%s char(10)) no partition;",ColumnWC[i].TabQua, ColumnWC[i].TabOwner, ColumnWC[i].TabName, TestColumn); returncode = SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } LogMsg(NONE,"%s\n",TableStr); returncode = SQLSetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,(SQLPOINTER)SQL_FALSE,0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); }// end of setup if (returncode == SQL_SUCCESS) { while ((_stricmp(ColumnWC[i].TabQua,"endloop") != 0) && (ColumnWC[i].isEscape == 0)) { sprintf(Heading,"SQLTablePrivileges: wildcard options => \n" "Table Qualifier: %s \nTable Owner: %s \nTable Name: %s\n", printSymbol(ColumnWC[i].TabQua,displayBuf.cat), printSymbol(ColumnWC[i].TabOwner,displayBuf.sch), printSymbol(ColumnWC[i].TabName,displayBuf.tab)); TESTCASE_BEGIN(Heading); if (_stricmp(ColumnWC[i].TabQua,"NULL") == 0) ColumnWC[i].TabQua = NULL; if (_stricmp(ColumnWC[i].TabOwner,"NULL") == 0) ColumnWC[i].TabOwner = NULL; if (_stricmp(ColumnWC[i].TabName,"NULL") == 0) ColumnWC[i].TabName = NULL; if (ColumnWC[i].TabQua == NULL || ColumnWC[i].TabOwner == NULL || ColumnWC[i].TabName == NULL) returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC[i].TabQua,SQL_NTS, (SQLCHAR*)ColumnWC[i].TabOwner,SQL_NTS, (SQLCHAR*)removeQuotes(ColumnWC[i].TabName,displayBuf.tab),SQL_NTS); else returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua), (SQLCHAR*)ColumnWC[i].TabOwner,(SWORD)strlen(ColumnWC[i].TabOwner), (SQLCHAR*)removeQuotes(ColumnWC[i].TabName,displayBuf.tab),(SWORD)strlen(displayBuf.tab)); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTablePrivileges")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { LogMsg(NONE,"SQLTablePrivileges: SQLTablePrivileges function call executed correctly.\n"); strcpy(oTableQualifier,""); strcpy(oTableOwner,""); strcpy(oTableName,""); strcpy(oGrantor,""); strcpy(oGrantee,""); strcpy(oPrivilege,""); strcpy(oIs_Grantable,""); returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTableQualifier,NAME_LEN,&oTableQualifierlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,2,SQL_C_CHAR,oTableOwner,NAME_LEN,&oTableOwnerlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,3,SQL_C_CHAR,oTableName,NAME_LEN,&oTableNamelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oGrantor,NAME_LEN,&oGrantorlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oGrantee,NAME_LEN,&oGranteelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oPrivilege,NAME_LEN,&oPrivilegelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,7,SQL_C_CHAR,oIs_Grantable,NAME_LEN,&oIs_Grantablelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } k = 0; while (returncode == SQL_SUCCESS) { returncode = SQLFetch(hstmt); if((returncode!=SQL_NO_DATA_FOUND) && (!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (returncode == SQL_SUCCESS) k++; } if(k == 0 && ColumnWC[i].CheckCode == SQL_SUCCESS) { if(ColumnWC[i].isEscape == 1) LogMsg(ERRMSG, "Search string pattern in Catalog's Name is not supported\n"); else { TEST_FAILED; LogMsg(ERRMSG,"No Data Found => Atleast one row should be fetched\n"); } } } SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; i++; } } //====================================================================================================== TESTCASE_BEGIN("SQLTablePrivileges: Negative test with invalid handle.\n"); i = 0; returncode = SQLTablePrivileges(hstmt1,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua),(SQLCHAR*)ColumnWC[i].TabOwner,(SWORD)strlen(ColumnWC[i].TabOwner),(SQLCHAR*)ColumnWC[i].TabName,(SWORD)strlen(ColumnWC[i].TabName)); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLTables")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //========================================================================================= TESTCASE_BEGIN("SQLTables: Negative test with NULL handle.\n"); hstmt1 = (SQLHANDLE)NULL; i = 0; returncode = SQLTablePrivileges(hstmt1,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua),(SQLCHAR*)ColumnWC[i].TabOwner,(SWORD)strlen(ColumnWC[i].TabOwner),(SQLCHAR*)ColumnWC[i].TabName,(SWORD)strlen(ColumnWC[i].TabName)); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLTables")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //========================================================================================= TESTCASE_BEGIN("SQLTablePrivileges: Negative test with invalid arg lengths.\n"); returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC2[0].TabQua,ColumnWC2[0].TabQuaLen,(SQLCHAR*)ColumnWC2[0].TabOwner,ColumnWC2[0].TabOwnerLen,(SQLCHAR*)ColumnWC2[0].TabName,ColumnWC2[0].TabNameLen); LogMsg(NONE, "Input parameters: CatalogLen %d SchemaLen %d TableLen %d\n", ColumnWC2[0].TabQuaLen, ColumnWC2[0].TabOwnerLen, ColumnWC2[0].TabNameLen); if(!CHECKRC(SQL_ERROR,returncode,"SQLTablePrivileges")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //========================================================================================= TESTCASE_BEGIN("SQLTablePrivileges: Positive test with invalid arg lengths.\n"); returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC2[1].TabQua,ColumnWC2[1].TabQuaLen,(SQLCHAR*)ColumnWC2[1].TabOwner,ColumnWC2[1].TabOwnerLen,(SQLCHAR*)ColumnWC2[1].TabName,ColumnWC2[1].TabNameLen); LogMsg(NONE, "Input parameters: CatalogLen %d SchemaLen %d TableLen %d\n", ColumnWC2[1].TabQuaLen, ColumnWC2[1].TabOwnerLen, ColumnWC2[1].TabNameLen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTablePrivileges")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { LogMsg(NONE,"SQLTablePrivileges: SQLTablePrivileges function call executed correctly.\n"); strcpy(oTableQualifier,""); strcpy(oTableOwner,""); strcpy(oTableName,""); strcpy(oGrantor,""); strcpy(oGrantee,""); strcpy(oPrivilege,""); strcpy(oIs_Grantable,""); returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTableQualifier,NAME_LEN,&oTableQualifierlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,2,SQL_C_CHAR,oTableOwner,NAME_LEN,&oTableOwnerlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,3,SQL_C_CHAR,oTableName,NAME_LEN,&oTableNamelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oGrantor,NAME_LEN,&oGrantorlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oGrantee,NAME_LEN,&oGranteelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oPrivilege,NAME_LEN,&oPrivilegelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,7,SQL_C_CHAR,oIs_Grantable,NAME_LEN,&oIs_Grantablelen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } k = 0; while (returncode == SQL_SUCCESS) { returncode = SQLFetch(hstmt); if (returncode == SQL_SUCCESS) k++; } if(k > 0) { TEST_FAILED; LogMsg(ERRMSG,"Should be no data found - check for similar objects unintentionally appear\n"); } } TESTCASE_END; //========================================================================================= TESTCASE_BEGIN("Testing SQLColAttribute, SQLDescribeCol, SQLBindCol and SQLFetch functions for catalog names.\n"); returncode = SQLSetStmtAttr(hstmt,SQL_ATTR_METADATA_ID,(SQLPOINTER)SQL_FALSE,0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); }// end of setup for(i = 0; i < 5; i++) { sprintf(Heading,"======================================\n" "SQLTablePrivileges: wildcard options => \n" "Table Qualifier: %s \nTable Owner: %s \nTable Name: %s\n", printSymbol(ColumnWC[i].TabQua,displayBuf.cat), printSymbol(ColumnWC[i].TabOwner,displayBuf.sch), printSymbol(ColumnWC[i].TabName,displayBuf.tab)); LogMsg(NONE,Heading); returncode = SQLTablePrivileges(hstmt,(SQLCHAR*)ColumnWC[i].TabQua,(SWORD)strlen(ColumnWC[i].TabQua), (SQLCHAR*)removeQuotes(ColumnWC[i].TabOwner, displayBuf.sch),(SWORD)strlen(displayBuf.sch), (SQLCHAR*)removeQuotes(ColumnWC[i].TabName, displayBuf.tab),(SWORD)strlen(displayBuf.tab)); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLColumns")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } LogMsg(NONE,"after the call\n"); returncode = SQLNumResultCols(hstmt, &numOfCols); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultsCol")) { TEST_FAILED; LogMsg(ERRMSG,"Test failed while executing call for SQLNUMRESULTSCOL"); LogAllErrors(henv,hdbc,hstmt); } for(cols = 0; cols < numOfCols; cols++) { returncode = SQLDescribeCol(hstmt,(SWORD)(cols+1),(SQLCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol")) { TEST_FAILED; LogMsg(ERRMSG,"Test failed while executing call for SQLDESCRIBECOL of column"); LogAllErrors(henv,hdbc,hstmt); } CharOutput[cols] = (char *)malloc(STR_LEN); for (iatt = 0; iatt <= TOTALATTRIBS; iatt++) { strcpy(rgbDesc,""); pcbDesc = 0; pfDesc = 0; returncode = SQLColAttributes(hstmt,(SWORD)(cols+1),DescrType[iatt],rgbDesc,STR_LEN,&pcbDesc,&pfDesc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLColAttribute")) { TEST_FAILED; LogMsg(ERRMSG,"Test failed while executing call for SQLCOLATTRIBUTES of column : %d.\n",i+1); LogAllErrors(henv,hdbc,hstmt); } } returncode = SQLBindCol(hstmt,(SWORD)(cols+1),SQL_C_CHAR,CharOutput[cols],STR_LEN,&stringlength); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { TEST_FAILED; LogMsg(ERRMSG,"Test failed while executing call for SQLBindCols of column : %d.\n",cols); LogAllErrors(henv,hdbc,hstmt); } } k = 0; while (returncode == SQL_SUCCESS) { returncode = SQLFetch(hstmt); if(returncode == SQL_ERROR) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else if (returncode == SQL_NO_DATA_FOUND) { break; } else { if (returncode == SQL_SUCCESS_WITH_INFO) LogAllErrors(henv,hdbc,hstmt); k++; } } if(k == 0) { TEST_FAILED; LogMsg(ERRMSG,"No Data Found => Atleast one row should be fetched\n"); } for(cols = 0; cols < numOfCols; cols++) { free(CharOutput[cols]); } TESTCASE_END; } //========================================================================================= // Cleanup i=0; sprintf(TableStr,"drop table %s.%s.%s",ColumnWC[i].TabQua, ColumnWC[i].TabOwner, ColumnWC[i].TabName); SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); sprintf(TableStr,"drop schema %s.%s cascade",ColumnWC[i].TabQua, ColumnWC[i].TabOwner); SQLExecDirect(hstmt,(SQLCHAR*) TableStr,SQL_NTS); FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLTablePrivileges.\n"); free(TableStr); free_list(var_list); TEST_RETURN; }
PassFail TestSQLPrepare(TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; CHAR *PrepStr[6]; CHAR *szInput[] = {"Insert char","Insert varchar"}; SQLLEN cbInput = SQL_NTS; SQLUSMALLINT i; SQLSMALLINT Type[] = {SQL_CHAR,SQL_VARCHAR}; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLPrepare", charset_file); if (var_list == NULL) return FAILED; PrepStr[0] = var_mapping("SQLPrepare_PrepStr_0", var_list); PrepStr[1] = var_mapping("SQLPrepare_PrepStr_1", var_list); PrepStr[2] = var_mapping("SQLPrepare_PrepStr_2", var_list); PrepStr[3] = var_mapping("SQLPrepare_PrepStr_3", var_list); PrepStr[4] = var_mapping("SQLPrepare_PrepStr_4", var_list); PrepStr[5] = var_mapping("SQLPrepare_PrepStr_5", var_list); //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API =>SQLPrepare | SQLPrepare | prepare.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLPrepare tests\n"); if(!FullConnect(pTestInfo)){ LogMsg(NONE,"Unable to connect\n"); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup TESTCASE_BEGIN("Test Positive Functionality of SQLPrepare/SQLExecute\n"); returncode=SQLExecDirect(hstmt,(SQLCHAR*)PrepStr[0],strlen(PrepStr[0])); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLCHAR*)PrepStr[1],strlen(PrepStr[1])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } TESTCASE_END; sprintf(Heading,"Test Positive Functionality of SQLPrepare/SQLExecute with SQL_NTS\n"); TESTCASE_BEGIN(Heading); returncode=SQLExecDirect(hstmt,(SQLCHAR*)PrepStr[0],SQL_NTS); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLCHAR*)PrepStr[1],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } TESTCASE_END; sprintf(Heading,"Test Positive Functionality of SQLPrepare then SQLExecute twice\n"); TESTCASE_BEGIN(Heading); returncode = SQLPrepare(hstmt,(SQLCHAR*)PrepStr[2],strlen(PrepStr[2])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } SQLExecDirect(hstmt,(SQLCHAR*)PrepStr[0],strlen(PrepStr[0])); /* cleanup */ TESTCASE_END; sprintf(Heading,"Test Positive Functionality of SQLPrepare with params\n"); TESTCASE_BEGIN(Heading); SQLExecDirect(hstmt,(SQLCHAR*)PrepStr[3],SQL_NTS); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLCHAR*)PrepStr[4],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { for (i = 0; i <= 1; i++) { returncode = SQLBindParameter(hstmt,(SWORD)(i+1),SQL_PARAM_INPUT,SQL_C_CHAR,Type[i],PREP_LEN,0,szInput[i],0,&cbInput); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } SQLExecDirect(hstmt,(SQLCHAR*)PrepStr[3],SQL_NTS); /* cleanup */ TESTCASE_END; sprintf(Heading,"Test negative Functionality of SQLPrepare with strlen less than sqlstr\n"); TESTCASE_BEGIN(Heading); SQLExecDirect(hstmt,(SQLCHAR*)PrepStr[0],SQL_NTS); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLCHAR*)PrepStr[1],(strlen(PrepStr[1])-5)); if(!CHECKRC(SQL_ERROR,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; sprintf(Heading,"Test negative Functionality of SQLPrepare with invalid sqlstr\n"); TESTCASE_BEGIN(Heading); returncode = SQLPrepare(hstmt,NULL,strlen(PrepStr[2])); if(!CHECKRC(SQL_ERROR,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; sprintf(Heading,"Test negative Functionality of SQLPrepare with invalid handle\n"); TESTCASE_BEGIN(Heading); returncode = SQLPrepare((SQLHANDLE)NULL,(SQLCHAR*)PrepStr[2],strlen(PrepStr[2])); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLPrepare.\n"); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLProcedureColumns --------------------------------------------------------- */ PassFail TestMXSQLProcedureColumns(TestInfo *pTestInfo) { TEST_DECLARE; TCHAR Heading[MAX_HEADING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; TCHAR *ProcStr; TCHAR ProcCatalog[NAME_LEN],ProcSchema[NAME_LEN],ProcName[NAME_LEN]; TCHAR ColName[NAME_LEN]; /* SEAQUEST */ char tmpbuf[1024]; TCHAR *myTestSch; TCHAR *createSchStr; TCHAR *setSchStr; TCHAR *dropSchStr; /* end of SEAQUEST */ TCHAR oProcCatalog[NAME_LEN]; TCHAR oProcSchema[NAME_LEN]; TCHAR oProcName[NAME_LEN]; TCHAR oColName[NAME_LEN]; SWORD oColType; SWORD oColDataType; TCHAR oColTypeName[NAME_LEN]; SDWORD oColSize; SDWORD oBufferLen; SWORD oDecDigits; SWORD oColRadix; SWORD oColNullable; TCHAR oRemark[REM_LEN]; TCHAR oColDef[NAME_LEN]; SWORD oSQLDataType; SWORD oSQLDateTimeSub; SDWORD oCharOctetLen; SDWORD oOrdinalPos; TCHAR oIsNullable[NAME_LEN]; SQLLEN oProcCataloglen; // sushil SQLLEN oProcSchemalen; SQLLEN oProcNamelen; SQLLEN oColNamelen; SQLLEN oColTypelen; SQLLEN oColDataTypelen; SQLLEN oColTypeNamelen; SQLLEN oColSizelen; SQLLEN oBufferLenlen; SQLLEN oDecDigitslen; SQLLEN oColRadixlen; SQLLEN oColNullablelen; SQLLEN oRemarklen; SQLLEN oColDeflen; SQLLEN oSQLDataTypelen; SQLLEN oSQLDateTimeSublen; SQLLEN oCharOctetLenlen; SQLLEN oOrdinalPoslen; SQLLEN oIsNullablelen; struct { TCHAR *DropProc; TCHAR *CrtProc; } CreateProc[] = { {_T("DROP PROCEDURE N4210"), _T("CREATE PROCEDURE N4210 (IN IN1 TIME) EXTERNAL NAME 'Procs.N4210' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4260"), _T("CREATE PROCEDURE N4260 (IN IN1 REAL, INOUT INOUT1 INTEGER) EXTERNAL NAME 'Procs.N4260' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4261"), _T("CREATE PROCEDURE N4261 (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4261' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4264"), _T("CREATE PROCEDURE N4264 (IN IN1 VARCHAR(30) CHARACTER SET ISO88591, OUT OUT1 VARCHAR(45) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4264A"), _T("CREATE PROCEDURE N4264A (IN IN1 CHAR(30) CHARACTER SET ISO88591, OUT OUT1 CHAR(45) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4264B"), _T("CREATE PROCEDURE N4264B (IN IN1 VARCHAR(2000) CHARACTER SET ISO88591, OUT OUT1 VARCHAR(2000) CHARACTER SET ISO88591) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4264C"), _T("CREATE PROCEDURE N4264C (IN IN1 VARCHAR(30) CHARACTER SET UCS2, OUT OUT1 VARCHAR(45) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4264D"), _T("CREATE PROCEDURE N4264D (IN IN1 CHAR(30) CHARACTER SET UCS2, OUT OUT1 CHAR(45) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4264E"), _T("CREATE PROCEDURE N4264E (IN IN1 VARCHAR(2000) CHARACTER SET UCS2, OUT OUT1 VARCHAR(2000) CHARACTER SET UCS2) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("DROP PROCEDURE N4267"), _T("CREATE PROCEDURE N4267 (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4267' EXTERNAL PATH '/home/SQFQA/SPJRoot/spjrs/nci/spjrs.jar' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE")}, {_T("endloop"),_T("endloop")} }; struct { TCHAR *ProcName; TCHAR *ColName; SWORD ColType; SWORD ColDataType; TCHAR *ColTypeName; SDWORD ColSize; SDWORD BufferLen; SWORD DecDigits; SWORD ColRadix; SWORD ColNullable; TCHAR *Remark; TCHAR *ColDef; SWORD SQLDataType; SWORD SQLDateTimeSub; SDWORD CharOctetLen; SDWORD OrdinalPos; TCHAR *IsNullable; } ProcCol[] = { /* {"N4210", "IN1", SQL_PARAM_INPUT, SQL_TYPE_TIME, "TIME", 8, 6, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 9, 2, <Null>, 1, "YES"}, {"N4260", "IN1", SQL_PARAM_INPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 1, "YES"}, {"N4260", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_INTEGER, "INTEGER SIGNED", 10, 4, 0, 10, SQL_NULLABLE, <Null>, <Null>, 4, <Null>, <Null>, 2, "YES"}, {"N4261", "IN1", SQL_PARAM_INPUT, SQL_NUMERIC, "NUMERIC", 9, 11, 0, 10, SQL_NULLABLE, <Null>, <Null>, 2, <Null>, <Null>, 1, "YES"}, {"N4261", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 2, "YES"}, {"N4264", "IN1", SQL_PARAM_INPUT, SQL_WVARCHAR, "VARCHAR", 30, 30, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 12,<Null>, 30, 1, "YES"}, {"N4264", "OUT1", SQL_PARAM_OUTPUT, SQL_WVARCHAR, "VARCHAR", 45, 45, 0, <Null>, SQL_NULLABLE, <Null>, <Null>, 12,<Null>, 45, 2, "YES"}, {"N4267", "IN1", SQL_PARAM_INPUT, SQL_NUMERIC, "NUMERIC", 9, 11, 0, 10, SQL_NULLABLE, <Null>, <Null>, 2, <Null>, <Null>, 1, "YES"}, {"N4267", "INOUT1", SQL_PARAM_INPUT_OUTPUT, SQL_REAL, "REAL", 22, 4, 0, 2, SQL_NULLABLE, <Null>, <Null>, 7, <Null>, <Null>, 2, "YES"}, */ {_T("N4210"), _T("IN1"), SQL_PARAM_INPUT, SQL_TYPE_TIME, _T("TIME"), 8, 6, 0, 0, SQL_NULLABLE, _T(""), _T(""), 9, 2, 0, 1, _T("YES")}, {_T("N4260"), _T("IN1"), SQL_PARAM_INPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 1, _T("YES")}, {_T("N4260"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_INTEGER, _T("INTEGER SIGNED"),10, 4, 0, 10, SQL_NULLABLE, _T(""), _T(""), 4, 0, 0, 2, _T("YES")}, {_T("N4261"), _T("IN1"), SQL_PARAM_INPUT, SQL_NUMERIC, _T("NUMERIC SIGNED"),9, 11, 0, 10, SQL_NULLABLE, _T(""), _T(""), 2, 0, 0, 1, _T("YES")}, {_T("N4261"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 2, _T("YES")}, {_T("N4264"), _T("IN1"), SQL_PARAM_INPUT, SQL_VARCHAR, _T("VARCHAR"), 30, 30, 0, 0, SQL_NULLABLE, _T(""), _T(""), 12,0, 30,1, _T("YES")}, {_T("N4264"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_VARCHAR, _T("VARCHAR"), 45, 45, 0, 0, SQL_NULLABLE, _T(""), _T(""), 12,0, 45,2, _T("YES")}, {_T("N4264A"), _T("IN1"), SQL_PARAM_INPUT, SQL_CHAR, _T("CHAR"), 30, 30, 0, 0, SQL_NULLABLE, _T(""), _T(""), 1,0, 30,1, _T("YES")}, {_T("N4264A"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_CHAR, _T("CHAR"), 45, 45, 0, 0, SQL_NULLABLE, _T(""), _T(""), 1,0, 45,2, _T("YES")}, {_T("N4264B"), _T("IN1"), SQL_PARAM_INPUT, SQL_VARCHAR, _T("VARCHAR"),2000,2000,0,0, SQL_NULLABLE, _T(""), _T(""), 12,0,2000,1, _T("YES")}, {_T("N4264B"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_VARCHAR, _T("VARCHAR"),2000,2000,0,0, SQL_NULLABLE, _T(""), _T(""), 12,0,2000,2, _T("YES")}, {_T("N4264C"), _T("IN1"), SQL_PARAM_INPUT, SQL_WVARCHAR, _T("NCHAR VARYING"),30, 60, 0, 0, SQL_NULLABLE, _T(""), _T(""), -9,0, 60,1, _T("YES")}, {_T("N4264C"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WVARCHAR, _T("NCHAR VARYING"),45, 90, 0, 0, SQL_NULLABLE, _T(""), _T(""), -9,0, 90,2, _T("YES")}, {_T("N4264D"), _T("IN1"), SQL_PARAM_INPUT, SQL_WCHAR, _T("NCHAR"), 30, 60, 0, 0, SQL_NULLABLE, _T(""), _T(""), -8,0, 60,1, _T("YES")}, {_T("N4264D"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WCHAR, _T("NCHAR"), 45, 90, 0, 0, SQL_NULLABLE, _T(""), _T(""), -8,0, 90,2, _T("YES")}, {_T("N4264E"), _T("IN1"), SQL_PARAM_INPUT, SQL_WVARCHAR,_T("NCHAR VARYING"),2000,4000,0,0, SQL_NULLABLE, _T(""), _T(""),-9,0,4000,1, _T("YES")}, {_T("N4264E"), _T("OUT1"), SQL_PARAM_OUTPUT, SQL_WVARCHAR,_T("NCHAR VARYING"),2000,4000,0,0, SQL_NULLABLE, _T(""), _T(""),-9,0,4000,2, _T("YES")}, {_T("N4267"), _T("IN1"), SQL_PARAM_INPUT, SQL_NUMERIC, _T("NUMERIC SIGNED"),9, 11, 0, 10, SQL_NULLABLE, _T(""), _T(""), 2, 0, 0, 1, _T("YES")}, {_T("N4267"), _T("INOUT1"), SQL_PARAM_INPUT_OUTPUT, SQL_REAL, _T("REAL"), 22, 4, 0, 2, SQL_NULLABLE, _T(""), _T(""), 7, 0, 0, 2, _T("YES")}, {_T("endloop"),} }; int i = 0, k = 0; TCHAR State[STATE_SIZE]; SDWORD NativeError; TCHAR buf[MAX_STRING_SIZE]; //TCHAR *charNameUCS2 = _T("NCHAR"); //TCHAR *varcharNameUCS2 = _T("NCHAR VARYING"); LogMsg(SHORTTIMESTAMP,_T("Begin testing API => MX Specific SQLProcedureColumns.\n")); //================================================================================================= //if(isUCS2) { // LogMsg(LINEBEFORE,_T("Setup for UCS2 mode testing: ColSize,BufferLen and CharOctetlen has to be doubled\n")); // k = sizeof(ProcCol)/sizeof(ProcCol[0]); // while(i < k) { // if(ProcCol[i].ColDataType == SQL_WCHAR) // { // ProcCol[i].ColDataType = SQL_WCHAR; // ProcCol[i].SQLDataType = SQL_WCHAR; // ProcCol[i].ColTypeName = charNameUCS2; // //ProcCol[i].ColSize *= 2; --> This is in character, no need to double // ProcCol[i].BufferLen *= 2; // ProcCol[i].CharOctetLen *= 2; // } // else if (ProcCol[i].ColDataType == SQL_WVARCHAR) // { // ProcCol[i].ColDataType = SQL_WVARCHAR; // ProcCol[i].SQLDataType = SQL_WVARCHAR; // ProcCol[i].ColTypeName = varcharNameUCS2; // //ProcCol[i].ColSize *= 2; --> This is in character, no need to double // ProcCol[i].BufferLen *= 2; // ProcCol[i].CharOctetLen *= 2; // } // else if (ProcCol[i].ColDataType == SQL_WLONGVARCHAR) // { // ProcCol[i].ColDataType = SQL_WLONGVARCHAR; // ProcCol[i].SQLDataType = SQL_WLONGVARCHAR; // ProcCol[i].ColTypeName = varcharNameUCS2; // //ProcCol[i].ColSize *= 2; --> This is in character, no need to double // ProcCol[i].BufferLen *= 2; // ProcCol[i].CharOctetLen *= 2; // } // else {} // i++; // } // i = 0; // k = 0; //} //================================================================================================= TEST_INIT; TESTCASE_BEGIN("Setup for SQLProcedureColumns tests\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,_T("Unable to connect\n")); //TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect3(pTestInfo); //TEST_FAILED; TEST_RETURN; } //TESTCASE_END; ProcStr = (TCHAR *)malloc(MAX_NOS_SIZE); /* SEAQUEST */ myTestSch = (TCHAR *)malloc(MAX_NOS_SIZE); createSchStr = (TCHAR *)malloc(MAX_NOS_SIZE); setSchStr = (TCHAR *)malloc(MAX_NOS_SIZE); dropSchStr = (TCHAR *)malloc(MAX_NOS_SIZE); _tcscpy (myTestSch, _T("ODBC_PROCCOL_TEST")); _tcscpy (createSchStr, _T("create schema ")); _tcscat (createSchStr, pTestInfo->Catalog); _tcscat (createSchStr, _T(".")); _tcscat (createSchStr, myTestSch); _tcscpy (setSchStr, _T("set schema ")); _tcscat (setSchStr, pTestInfo->Catalog); _tcscat (setSchStr, _T(".")); _tcscat (setSchStr, myTestSch); _tcscpy (dropSchStr, _T("drop schema ")); _tcscat (dropSchStr, pTestInfo->Catalog); _tcscat (dropSchStr, _T(".")); _tcscat (dropSchStr, myTestSch); _tcscat (dropSchStr, _T(" cascade")); returncode = SQLExecDirect(hstmt,(SQLTCHAR*) dropSchStr,SQL_NTS); // if(!CHECKRC(SQL_SUCCESS,returncode,"Drop Schema")) // { // TEST_FAILED; // LogAllErrors(henv,hdbc,hstmt); // } returncode = SQLExecDirect(hstmt,(SQLTCHAR*) createSchStr,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"Create Schema")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLExecDirect(hstmt,(SQLTCHAR*) setSchStr,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"Set Schema")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } /* end of SEAQUEST */ while (_tcsicmp(CreateProc[i].DropProc,_T("endloop")) != 0) { _tcscpy(ProcStr,_T("")); _tcscat(ProcStr,CreateProc[i].DropProc); SQLExecDirect(hstmt,(SQLTCHAR*) ProcStr,SQL_NTS); // cleanup _tcscpy(ProcStr,_T("")); _tcscat(ProcStr,CreateProc[i].CrtProc); _stprintf(Heading,_T("Adding Procedure => ")); _tcscat(Heading,ProcStr); _tcscat(Heading,_T("\n")); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ProcStr,SQL_NTS); if(returncode != SQL_SUCCESS) { returncode = SQLError((SQLHANDLE)NULL, (SQLHANDLE)NULL, hstmt, (SQLTCHAR*)State, &NativeError, (SQLTCHAR*)buf, MAX_STRING_SIZE, NULL); if (NativeError == -2013) { LogMsg(NONE, _T("Stored Procedures not supported\n")); _gTestCount--; free(ProcStr); FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP,_T("End testing API => MX Specific SQLProcedureColumns.\n")); TEST_RETURN; } else { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } TESTCASE_END; i++; } _tcscpy(ProcCatalog, pTestInfo->Catalog); _tcscpy(ProcSchema, myTestSch /*SEAQUEST pTestInfo->Schema*/); _stprintf(Heading,_T("Test Positive Functionality of SQLProcedureColumns \n")); TESTCASE_BEGINW(Heading); returncode = SQLProcedureColumns(hstmt,(SQLTCHAR*)pTestInfo->Catalog,(SWORD)_tcslen(pTestInfo->Catalog),(SQLTCHAR*)myTestSch/* SEAQUEST pTestInfo->Schema*/,(SWORD)_tcslen(myTestSch/* SEAQUEST pTestInfo->Schema*/),(SQLTCHAR *)_T("%"),(SWORD)1,(SQLTCHAR *)_T("%"),(SWORD)1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLProcedureColumns")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (returncode == SQL_SUCCESS) { _tcscpy(oProcCatalog,_T("")); _tcscpy(oProcSchema,_T("")); _tcscpy(oProcName,_T("")); _tcscpy(oColName,_T("")); oColType = 0; oColDataType = 0; _tcscpy(oColTypeName,_T("")); oColSize = 0; oBufferLen = 0; oDecDigits = 0; oColRadix = 0; oColNullable = 0; _tcscpy(oRemark,_T("")); _tcscpy(oColDef,_T("")); oSQLDataType = 0; oSQLDateTimeSub = 0; oCharOctetLen = 0; oOrdinalPos = 0; _tcscpy(oIsNullable,_T("")); SQLBindCol(hstmt,1,SQL_C_TCHAR,oProcCatalog,NAME_LEN,&oProcCataloglen); SQLBindCol(hstmt,2,SQL_C_TCHAR,oProcSchema,NAME_LEN,&oProcSchemalen); SQLBindCol(hstmt,3,SQL_C_TCHAR,oProcName,NAME_LEN,&oProcNamelen); SQLBindCol(hstmt,4,SQL_C_TCHAR,oColName,NAME_LEN,&oColNamelen); SQLBindCol(hstmt,5,SQL_C_SHORT,&oColType,0,&oColTypelen); SQLBindCol(hstmt,6,SQL_C_SHORT,&oColDataType,0,&oColDataTypelen); SQLBindCol(hstmt,7,SQL_C_TCHAR,oColTypeName,NAME_LEN,&oColTypeNamelen); SQLBindCol(hstmt,8,SQL_C_LONG,&oColSize,0,&oColSizelen); SQLBindCol(hstmt,9,SQL_C_LONG,&oBufferLen,0,&oBufferLenlen); SQLBindCol(hstmt,10,SQL_C_SHORT,&oDecDigits,0,&oDecDigitslen); SQLBindCol(hstmt,11,SQL_C_SHORT,&oColRadix,0,&oColRadixlen); SQLBindCol(hstmt,12,SQL_C_SHORT,&oColNullable,0,&oColNullablelen); SQLBindCol(hstmt,13,SQL_C_TCHAR,oRemark,REM_LEN,&oRemarklen); SQLBindCol(hstmt,14,SQL_C_TCHAR,oColDef,NAME_LEN,&oColDeflen); SQLBindCol(hstmt,15,SQL_C_SHORT,&oSQLDataType,0,&oSQLDataTypelen); SQLBindCol(hstmt,16,SQL_C_SHORT,&oSQLDateTimeSub,0,&oSQLDateTimeSublen); SQLBindCol(hstmt,17,SQL_C_LONG,&oCharOctetLen,0,&oCharOctetLenlen); SQLBindCol(hstmt,18,SQL_C_LONG,&oOrdinalPos,0,&oOrdinalPoslen); SQLBindCol(hstmt,19,SQL_C_TCHAR,oIsNullable,NAME_LEN,&oIsNullablelen); k = 0; i = 0; while (returncode == SQL_SUCCESS) { if(_tcscmp(ProcCol[i].ProcName,_T("endloop")) == 0) break; returncode = SQLFetch(hstmt); if((returncode!=SQL_NO_DATA_FOUND) &&(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { if (returncode == SQL_SUCCESS) { k++; _stprintf(Heading,_T("SQLProcedureColumns: Comparing Results\n")); TESTCASE_BEGINW(Heading); if ((_tcsicmp(ProcCatalog,oProcCatalog) == 0) && (_tcsicmp(ProcSchema,oProcSchema) == 0) && (_tcsicmp(ProcCol[i].ProcName,oProcName) == 0) && (_tcsicmp(ProcCol[i].ColName,oColName) == 0) && (ProcCol[i].ColType == oColType) && (ProcCol[i].ColDataType == oColDataType) && (_tcsicmp(ProcCol[i].ColTypeName,oColTypeName) == 0) && (ProcCol[i].ColSize == oColSize) && (ProcCol[i].BufferLen == oBufferLen) && (ProcCol[i].DecDigits == oDecDigits) && (ProcCol[i].ColRadix == oColRadix) && (ProcCol[i].ColNullable == oColNullable) && (_tcsicmp(ProcCol[i].Remark,oRemark) == 0) && (_tcsicmp(ProcCol[i].ColDef,oColDef) == 0) && (ProcCol[i].SQLDataType == oSQLDataType) && (ProcCol[i].SQLDateTimeSub == oSQLDateTimeSub) && (ProcCol[i].CharOctetLen == oCharOctetLen) && (ProcCol[i].OrdinalPos == oOrdinalPos) && (_tcsicmp(ProcCol[i].IsNullable,oIsNullable) == 0)){ LogMsg(NONE,_T("ProcCatalog expect: %s and actual: %s are matched\n"),ProcCatalog,oProcCatalog); LogMsg(NONE,_T("ProcSchema expect: %s and actual: %s are matched\n"),ProcSchema,oProcSchema); LogMsg(NONE,_T("ProcName expect: %s and actual: %s are matched\n"),ProcCol[i].ProcName,oProcName); LogMsg(NONE,_T("ColName expect: %s and actual: %s are matched\n"),ProcCol[i].ColName,oColName); LogMsg(NONE,_T("ColType expect: %d and actual: %d are matched\n"),ProcCol[i].ColType,oColType); LogMsg(NONE,_T("ColDataType expect: %d and actual: %d are matched\n"),ProcCol[i].ColDataType,oColDataType); LogMsg(NONE,_T("ColTypeName expect: %s and actual: %s are matched\n"),ProcCol[i].ColTypeName,oColTypeName); LogMsg(NONE,_T("ColSize expect: %d and actual: %d are matched\n"),ProcCol[i].ColSize,oColSize); LogMsg(NONE,_T("BufferLen expect: %d and actual: %d are matched\n"),ProcCol[i].BufferLen,oBufferLen); LogMsg(NONE,_T("DecDigits expect: %d and actual: %d are matched\n"),ProcCol[i].DecDigits,oDecDigits); LogMsg(NONE,_T("ColRadix expect: %d and actual: %d are matched\n"),ProcCol[i].ColRadix,oColRadix); LogMsg(NONE,_T("ColNullable expect: %d and actual: %d are matched\n"),ProcCol[i].ColNullable,oColNullable); LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].Remark,oRemark); LogMsg(NONE,_T("ColDef expect: %s and actual: %s are matched\n"),ProcCol[i].ColDef,oColDef); LogMsg(NONE,_T("SQLDataType expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDataType,oSQLDataType); LogMsg(NONE,_T("SQLDateTimeSub expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub); LogMsg(NONE,_T("CharOctetLen expect: %d and actual: %d are matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen); LogMsg(NONE,_T("OrdinalPos expect: %d and actual: %d are matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos); LogMsg(NONE,_T("IsNullable expect: %s and actual: %s are matched\n"),ProcCol[i].IsNullable,oIsNullable); } else { TEST_FAILED; if (_tcsicmp(ProcCatalog,oProcCatalog) != 0) LogMsg(ERRMSG,_T("ProcCatalog expect: %s and actual: %s are not matched\n"),ProcCatalog,oProcCatalog); else LogMsg(NONE,_T("ProcCatalog expect: %s and actual: %s are matched\n"),ProcCatalog,oProcCatalog); if (_tcsicmp(ProcSchema,oProcSchema) != 0) LogMsg(ERRMSG,_T("ProcSchema expect: %s and actual: %s are not matched\n"),ProcSchema,oProcSchema); else LogMsg(NONE,_T("ProcSchema expect: %s and actual: %s are matched\n"),ProcSchema,oProcSchema); if (_tcsicmp(ProcCol[i].ProcName,oProcName) != 0) LogMsg(ERRMSG,_T("ProcName expect: %s and actual: %s are not matched\n"),ProcCol[i].ProcName,oProcName); else LogMsg(NONE,_T("ProcName expect: %s and actual: %s are matched\n"),ProcCol[i].ProcName,oProcName); if (_tcsicmp(ProcCol[i].ColName,oColName) != 0) LogMsg(ERRMSG,_T("ColName expect: %s and actual: %s are not matched\n"),ProcCol[i].ColName,oColName); else LogMsg(NONE,_T("ColName expect: %s and actual: %s are matched\n"),ProcCol[i].ColName,oColName); if (ProcCol[i].ColType != oColType) LogMsg(ERRMSG,_T("ColType expect: %d and actual: %d are not matched\n"),ProcCol[i].ColType,oColType); else LogMsg(NONE,_T("ColType expect: %d and actual: %d are matched\n"),ProcCol[i].ColType,oColType); if (ProcCol[i].ColDataType != oColDataType) LogMsg(ERRMSG,_T("ColDataType expect: %d and actual: %d are not matched\n"),ProcCol[i].ColDataType,oColDataType); else LogMsg(NONE,_T("ColDataType expect: %d and actual: %d are matched\n"),ProcCol[i].ColDataType,oColDataType); if (_tcsicmp(ProcCol[i].ColTypeName,oColTypeName) != 0) LogMsg(ERRMSG,_T("ColTypeName expect: %s and actual: %s are not matched\n"),ProcCol[i].ColTypeName,oColTypeName); else LogMsg(NONE,_T("ColTypeName expect: %s and actual: %s are matched\n"),ProcCol[i].ColTypeName,oColTypeName); if (ProcCol[i].ColSize != oColSize) LogMsg(ERRMSG,_T("ColSize expect: %d and actual: %d are not matched\n"),ProcCol[i].ColSize,oColSize); else LogMsg(NONE,_T("ColSize expect: %d and actual: %d are matched\n"),ProcCol[i].ColSize,oColSize); if (ProcCol[i].BufferLen != oBufferLen) LogMsg(ERRMSG,_T("BufferLen expect: %d and actual: %d are not matched\n"),ProcCol[i].BufferLen,oBufferLen); else LogMsg(NONE,_T("BufferLen expect: %d and actual: %d are matched\n"),ProcCol[i].BufferLen,oBufferLen); if (ProcCol[i].DecDigits != oDecDigits) LogMsg(ERRMSG,_T("DecDigits expect: %d and actual: %d are not matched\n"),ProcCol[i].DecDigits,oDecDigits); else LogMsg(NONE,_T("DecDigits expect: %d and actual: %d are matched\n"),ProcCol[i].DecDigits,oDecDigits); if (ProcCol[i].ColRadix != oColRadix) LogMsg(ERRMSG,_T("ColRadix expect: %d and actual: %d are not matched\n"),ProcCol[i].ColRadix,oColRadix); else LogMsg(NONE,_T("ColRadix expect: %d and actual: %d are matched\n"),ProcCol[i].ColRadix,oColRadix); if (ProcCol[i].ColNullable != oColNullable) LogMsg(ERRMSG,_T("ColNullable expect: %d and actual: %d are not matched\n"),ProcCol[i].ColNullable,oColNullable); else LogMsg(NONE,_T("ColNullable expect: %d and actual: %d are matched\n"),ProcCol[i].ColNullable,oColNullable); if (_tcsicmp(ProcCol[i].Remark,oRemark) != 0) LogMsg(ERRMSG,_T("Remark expect: %s and actual: %s are not matched\n"),ProcCol[i].Remark,oRemark); else LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].Remark,oRemark); if (_tcsicmp(ProcCol[i].ColDef,oColDef) != 0) LogMsg(ERRMSG,_T("Remark expect: %s and actual: %s are not matched\n"),ProcCol[i].ColDef,oColDef); else LogMsg(NONE,_T("Remark expect: %s and actual: %s are matched\n"),ProcCol[i].ColDef,oColDef); if (ProcCol[i].SQLDataType != oSQLDataType) LogMsg(ERRMSG,_T("SQLDataType expect: %d and actual: %d are not matched\n"),ProcCol[i].SQLDataType,oSQLDataType); else LogMsg(NONE,_T("SQLDataType expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDataType,oSQLDataType); if (ProcCol[i].SQLDateTimeSub != oSQLDateTimeSub) LogMsg(ERRMSG,_T("SQLDateTimeSub expect: %d and actual: %d are not matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub); else LogMsg(NONE,_T("SQLDateTimeSub expect: %d and actual: %d are matched\n"),ProcCol[i].SQLDateTimeSub,oSQLDateTimeSub); if (ProcCol[i].CharOctetLen != oCharOctetLen) LogMsg(ERRMSG,_T("CharOctetLen expect: %d and actual: %d are not matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen); else LogMsg(NONE,_T("CharOctetLen expect: %d and actual: %d are matched\n"),ProcCol[i].CharOctetLen,oCharOctetLen); if (ProcCol[i].OrdinalPos != oOrdinalPos) LogMsg(ERRMSG,_T("OrdinalPos expect: %d and actual: %d are not matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos); else LogMsg(NONE,_T("OrdinalPos expect: %d and actual: %d are matched\n"),ProcCol[i].OrdinalPos,oOrdinalPos); if (_tcsicmp(ProcCol[i].IsNullable,oIsNullable) != 0) LogMsg(ERRMSG,_T("IsNullable expect: %s and actual: %s are not matched\n"),ProcCol[i].IsNullable,oIsNullable); else LogMsg(NONE,_T("IsNullable expect: %s and actual: %s are matched\n"),ProcCol[i].IsNullable,oIsNullable); } } } if(k == 0) { TEST_FAILED; LogMsg(ERRMSG,_T("No Data Found => Atleast one row should be fetched\n")); } TESTCASE_END; _tcscpy(oProcCatalog,_T("")); _tcscpy(oProcSchema,_T("")); _tcscpy(oProcName,_T("")); _tcscpy(oColName,_T("")); oColType = 0; oColDataType = 0; _tcscpy(oColTypeName,_T("")); oColSize = 0; oBufferLen = 0; oDecDigits = 0; oColRadix = 0; oColNullable = 0; _tcscpy(oRemark,_T("")); _tcscpy(oColDef,_T("")); oSQLDataType = 0; oSQLDateTimeSub = 0; oCharOctetLen = 0; oOrdinalPos = 0; _tcscpy(oIsNullable,_T("")); i++; } // while } SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt,SQL_CLOSE); i=0; while (_tcsicmp(CreateProc[i].DropProc,_T("endloop")) != 0) { _tcscpy(ProcStr,_T("")); _tcscat(ProcStr,CreateProc[i].DropProc); returncode = SQLExecDirect(hstmt,(SQLTCHAR*) ProcStr,SQL_NTS); // cleanup if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } i++; } SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt,SQL_CLOSE); //======================================================================================================== _stprintf(Heading,_T("SQLProcedureColumns: Negative test with NULL handle\n")); TESTCASE_BEGINW(Heading); hstmt = (SQLHANDLE)NULL; _tcscpy(ProcName,_T("junkproc")); _tcscpy(ColName,_T("C1")); returncode = SQLProcedureColumns(hstmt,(SQLTCHAR*)pTestInfo->Catalog,(SWORD)_tcslen(pTestInfo->Catalog),(SQLTCHAR*)myTestSch /* SEAQUEST pTestInfo->Schema */,(SWORD)_tcslen(myTestSch /* SEAQUEST pTestInfo->Schema*/),(SQLTCHAR*)ProcName,(SWORD)_tcslen(ProcName),(SQLTCHAR*)ColName,(SWORD)_tcslen(ColName)); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLProcedureColumns")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //======================================================================================================== returncode = SQLExecDirect(hstmt,(SQLTCHAR*) dropSchStr,SQL_NTS); free(ProcStr); FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => MX Specific SQLProcedureColumns.\n")); TEST_RETURN; }
pid_t asn_fork(const char *cmd, const char *args, thash *env, int *fd_stdin, int *fd_stdout, int *fd_stderr) { int i, rc, script = 0; int fd_in[2], fd_in2[2], fd_out[2], fd_err[2]; pid_t child_pid; char *key, *val; dbg(10, "asn_fork('%s', '%s')\n", cmd, args); if (!strncmp(cmd, "#!/bin/sh", 9)) { dbg(6, "asn_fork(): interpreting as inline shell script\n"); script = 1; } if (pipe(fd_in) < 0) return 0; dbg(11, "asn_fork(): pipe(fd_in): %d %d\n", fd_in[0], fd_in[1]); if (pipe(fd_out) < 0) return 0; dbg(11, "asn_fork(): pipe(fd_out): %d %d\n", fd_out[0], fd_out[1]); if (pipe(fd_err) < 0) return 0; dbg(11, "asn_fork(): pipe(fd_err): %d %d\n", fd_err[0], fd_err[1]); if (script) { if (pipe(fd_in2) < 0) return 0; dbg(11, "asn_fork(): pipe(fd_in2): %d %d\n", fd_in2[0], fd_in2[1]); } child_pid = fork(); if (child_pid < -1) return 0; if (child_pid == 0) { /* child */ /* set environment */ if (env) { THASH_ITER_LOOP(env, key, val) putenv(tmprintf("%s=%s", key, val)); } /* close all unneeded fds */ for (i = getdtablesize()-1; i >= 0; i--) { if ((i == fd_in[0]) || (i == fd_out[1]) || (i == fd_err[1]) || (script && (i == fd_in2[0])) ) continue; if (!close(i)) /* XXX: after closing(2) dbg() wont work */ dbg(11, "asn_fork(): closed FD %d\n", i); } if (dup2(fd_in[0], 0) == -1) _exit(123); if (dup2(fd_out[1], 1) == -1) _exit(124); if (dup2(fd_err[1], 2) == -1) _exit(125); close(fd_in[0]); close(fd_out[1]); close(fd_err[1]); if (script) if (dup2(fd_in2[0], 3) == -1) _exit(126); if (script) execl("/bin/sh", "sh", "-s", "--", args, NULL); else execl("/bin/sh", "sh", "-c", "--", cmd, args, NULL); // FIXME _exit(127); } /* parent */ dbg(7, "asn_fork(): forked PID %u\n", child_pid); close(fd_in[0]); close(fd_out[1]); close(fd_err[1]); if (fd_stdout) *fd_stdout = fd_out[0]; else close(fd_out[0]); if (fd_stderr) *fd_stderr = fd_err[0]; else close(fd_err[0]); /* write cmd to stdin, swap stdin<->fd 3 */ if (script) { close(fd_in2[0]); # define CHECKRC(a) if (rc < 0) { dbg(4, "asn_fork(): write(%s): %m\n", (a)); goto writefailed; } rc = write(fd_in[1], "#!/bin/sh\n", 10); CHECKRC("shabang"); // rc = write(fd_in[1], "exec <&3\n", 9); CHECKRC("fd3 hack"); /* TODO: BUG: does not work */ rc = write(fd_in[1], cmd, strlen(cmd) + 1); CHECKRC("command"); writefailed: if (fd_stdin) *fd_stdin = fd_in2[1]; else close(fd_in2[1]); close(fd_in[1]); } else { if (fd_stdin) *fd_stdin = fd_in[1]; else close(fd_in[1]); } return child_pid; }
PassFail TestQueryID (TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv, henv2; SQLHANDLE hdbc, hdbc2 = (SQLHANDLE)NULL; SQLHANDLE hstmt, hstmt2; int loop = 0; //char preparedStmt[1024]; char infoStatsStmt[ 1024 ]; SQLCHAR cursorName[ 1024 ]; CHAR jobid[SQL_MAX_SESSIONNAME_LEN]; CHAR queryID[256]; SQLINTEGER jobidlen; SQLLEN queryIDPtr; CHAR tempStr[256]; char *droptab = "DROP TABLE JOBID cascade"; char *createtab = "CREATE TABLE JOBID (C int) NO PARTITION"; char *inserttab = "INSERT INTO JOBID VALUES (10)"; char *selecttab = "SELECT * FROM JOBID"; struct { RETCODE returncode; CHAR *jobID; CHAR *jobIDExpected; } jobIDMatrix[] = { { SQL_SUCCESS, "1" , "1"}, { SQL_SUCCESS, "11" , "11"}, { SQL_SUCCESS, "" , "" }, { SQL_SUCCESS, "H" , "H" }, { SQL_SUCCESS, "hh" , "hh" }, { SQL_SUCCESS, "0" , "0" }, { SQL_SUCCESS, "_" , "_" }, { SQL_SUCCESS, "________________________" , "________________________" }, { SQL_SUCCESS, "odbcqa" , "odbcqa" }, { SQL_SUCCESS, "odbcqa00" , "odbcqa00" }, { SQL_SUCCESS, "00odbcqa" , "00odbcqa" }, { SQL_SUCCESS, "0123_HELLOKITTY" , "0123_HELLOKITTY" }, { SQL_SUCCESS, "_Hello_Kitty_123" , "_Hello_Kitty_123" }, { SQL_SUCCESS, "Hello_Kitty_Went_To_The_" , "Hello_Kitty_Went_To_The_" }, { SQL_SUCCESS, "Hello_Kitty_Went_To_The_" , "Hello_Kitty_Went_To_The_" }, { SQL_SUCCESS, "1234567890_1234567890" , "1234567890_1234567890" }, { SQL_SUCCESS, "123456789012345678901234" , "123456789012345678901234" }, { SQL_SUCCESS, "123456789012345678901234" , "123456789012345678901234" }, { SQL_SUCCESS, "1234567890123456789012345" , "123456789012345678901234" }, { SQL_SUCCESS, "Hello_Kitty_Went_To_The_Store_To_Buy" , "Hello_Kitty_Went_To_The_" }, { SQL_SUCCESS_WITH_INFO, " " , "" }, { SQL_SUCCESS_WITH_INFO, " HelloKitty" , "" }, { SQL_SUCCESS_WITH_INFO, "Hello Kitty" , "" }, { SQL_SUCCESS_WITH_INFO, "HelloKitty " , "" }, { SQL_SUCCESS_WITH_INFO, "1 2" , "" }, { SQL_SUCCESS_WITH_INFO, "12345.67890.123456789012" , "" }, { SQL_SUCCESS_WITH_INFO, "Hello$Kitty" , "" }, { SQL_SUCCESS_WITH_INFO, "\"HelloKitty\"" , "" }, { SQL_SUCCESS_WITH_INFO, "'HelloKitty'" , "" }, { SQL_SUCCESS_WITH_INFO, "\" \"" , "" }, { SQL_SUCCESS_WITH_INFO, "\"\"" , "" }, { SQL_SUCCESS_WITH_INFO, "\"#@*()-_=+[]{}|:;'<>,.?\"" , "" }, { -101 , "" , "" } }; //struct //{ // RETCODE rtc; // CHAR *queryID; // CHAR *queryIDExpected; //} queryIDMatrix[] = { // { SQL_SUCCESS, "HELLOKITTY" , "HELLOKITTY" }, // { SQL_SUCCESS, "H" , "H" }, // { SQL_SUCCESS, "HELLOKITTYWENTTOTHESTORETOBUYDRI" , "HELLOKITTYWENTTOTHESTORETOBUYDRI" }, // { SQL_SUCCESS, "HELLOKITTYWENTTOTHESTORETOBUYDRINKSFORTHEPARTY" , "HELLOKITTYWENTTOTHESTORETOBUYDRI" }, // { SQL_SUCCESS, "HelloKitty" , "HELLOKITTY" }, // { SQL_SUCCESS, "h" , "H" }, // { SQL_SUCCESS, "HelloKittyWentToTheStoreToBuyDri" , "HELLOKITTYWENTTOTHESTORETOBUYDRI" }, // { SQL_SUCCESS, "HelloKittyWentToTheStoreToBuyDrinksForTheParty" , "HELLOKITTYWENTTOTHESTORETOBUYDRI" }, // { SQL_SUCCESS, "H_1" , "H_1" }, // { SQL_SUCCESS, "HELLO_KITTY_1234" , "HELLO_KITTY_1234" }, // { SQL_SUCCESS, "HELLO_KITTY_1234_ABCDEFGHIJKLMNO" , "HELLO_KITTY_1234_ABCDEFGHIJKLMNO" }, // { SQL_SUCCESS, "HELLO_KITTY_1234_ABCDEFGHIJKLMNOPQRSTUVWXYZ" , "HELLO_KITTY_1234_ABCDEFGHIJKLMNO" }, // { SQL_SUCCESS, "Hello_Kitty_1234" , "HELLO_KITTY_1234" }, // { SQL_SUCCESS, "Hello_Kitty_1234_abcdefghijklmno" , "HELLO_KITTY_1234_ABCDEFGHIJKLMNO" }, // { SQL_SUCCESS, "Hello_Kitty_1234_abcdefghijklmnopqrstuvwxyz" , "HELLO_KITTY_1234_ABCDEFGHIJKLMNO" }, // { SQL_SUCCESS, "\"HELLOKITTY\"" , "HELLOKITTY" }, // { SQL_SUCCESS, "\"H\"" , "H" }, // { SQL_SUCCESS, "\"HELLOKITTYWENTTOTHESTORETOBUYDRI\"" , "HELLOKITTYWENTTOTHESTORETOBUYDRI" }, // { SQL_SUCCESS, "\"HELLOKITTYWENTTOTHESTORETOBUYDRINKSFORTHEPARTY\"" , "HELLOKITTYWENTTOTHESTORETOBUYDRI" }, // { SQL_SUCCESS, "\"HelloKitty\"" , "HelloKitty" }, // { SQL_SUCCESS, "\"h\"" , "h" }, // { SQL_SUCCESS, "\"HelloKittyWentToTheStoreToBuyDri\"" , "HelloKittyWentToTheStoreToBuyDri" }, // { SQL_SUCCESS, "\"HelloKittyWentToTheStoreToBuyDrinksForTheParty\"" , "HelloKittyWentToTheStoreToBuyDri" }, // { SQL_SUCCESS, "\"H_1\"" , "H_1" }, // { SQL_SUCCESS, "\"HELLO_KITTY_1234\"" , "HELLO_KITTY_1234" }, // { SQL_SUCCESS, "\"HELLO_KITTY_1234_ABCDEFGHIJKLMNO\"" , "HELLO_KITTY_1234_ABCDEFGHIJKLMNO" }, // { SQL_SUCCESS, "\"HELLO_KITTY_1234_ABCDEFGHIJKLMNOPQRSTUVWXYZ\"" , "HELLO_KITTY_1234_ABCDEFGHIJKLMNO" }, // { SQL_SUCCESS, "\"Hello_Kitty_1234\"" , "Hello_Kitty_1234" }, // { SQL_SUCCESS, "\"Hello_Kitty_1234_abcdefghijklmno\"" , "Hello_Kitty_1234_abcdefghijklmno" }, // { SQL_SUCCESS, "\"Hello_Kitty_1234_abcdefghijklmnopqrstuvwxyz\"" , "Hello_Kitty_1234_abcdefghijklmno" }, // { SQL_SUCCESS, "\"Hello Kitty\"" , "Hello Kitty" }, // { SQL_SUCCESS, "\"Hello Kitty says \"\"MEOW!\"\"\"" , "Hello Kitty says \"MEOW\"" }, // { SQL_SUCCESS, "\"Hello Kitty's Pruse\"" , "Hello Kitty's Purse" }, // { SQL_SUCCESS, "\"CREATE\"" , "CREATE" }, // { SQL_SUCCESS, "\"SELECT * FROM T1\"" , "SELECT * FROM T1" }, // { SQL_ERROR , "" , "" }, // { SQL_ERROR , " " , "" }, // { SQL_ERROR , "1HelloKitty" , "" }, // { SQL_ERROR , "_A" , "" }, // { SQL_ERROR , "Hello Kitty" , "" }, // { SQL_ERROR , "Hello$Kitty" , "" }, // { SQL_ERROR , "\"\\HelloKitty\"" , "" }, // { SQL_ERROR , "\"$HelloKitty\"" , "" }, // { SQL_ERROR , "\" \"" , "" }, // { SQL_ERROR , "\"\"" , "" }, // { SQL_ERROR , "\"@*()-_=+[]{}|:;'<>,.?\"" , "" }, // { SQL_ERROR , "CREATE" , "" }, // { -101 , "" , "" } //}; //struct //{ // char* sqlStmt; //} sqlPrepareMatrix[] = { // { "CREATE CATALOG STMNT" }, // { "CREATE SCHEMA STMNT.TEST" }, // { "CREATE TABLE T2 ( C1 INTEGER NOT NULL NOT DROPPABLE, C2 INTEGER, PRIMARY KEY( C1 ) )" }, // { "CREATE INDEX T2_INDEX ON T2 ( C1 ) NO POPULATE" }, // { "CREATE PROCEDURE T2_PROC (IN IN1 TIME) EXTERNAL NAME 'Procs.N4210' EXTERNAL PATH '/usr/spjqa/Testware/Class' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE" }, // { "CREATE VIEW T2_VIEW AS SELECT C1 FROM T2" }, // { "INSERT INTO T2 VALUES ( 1 , 1) " }, // { "SELECT C1 FROM T2" }, // { "UPDATE T2 SET C2 = 2 WHERE C1 = 1" }, // { "DELETE FROM T2" }, // { "ALTER INDEX T2_INDEX ON T2 ( C2 ) NO POPULATE" }, // { "ALTER TABLE T2 ( C1 INTEGER NOT NULL NOT DROPPABLE, C2 INTEGER NOT NULL, PRIMARY KEY( C1 ) )" }, // { "ALTER TRIGGER" }, // { "DROP SCHEMA STMT.TEST" }, // { "DROP CATALOG STMT" }, // { "DROP INDEX T2_INDEX" }, // { "DROP VIEW T2_VIEW" }, // { "DROP PROCEDURE T2_PROC" }, // { "DROP TABLE T2" }, // { "STOP" } //}; //====================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => JobID | QueryID | QueryID.cpp\n"); TEST_INIT; TESTCASE_BEGIN("Setup for JobID tests\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,"Unable to connect as ODBC3.0 application.\n"); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt, (SQLCHAR*)droptab,SQL_NTS); returncode = SQLExecDirect(hstmt, (SQLCHAR*)createtab,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt, (SQLCHAR*)inserttab,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } FullDisconnect(pTestInfo); TESTCASE_END; //====================================================================================================== sprintf(Heading,"Test positive functionality of SessionName, single connection\n"); TESTCASE_BEGIN( Heading); // Allocate Environment Handle returncode = SQLAllocEnv(&henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetEnvAttr")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } // Allocate Connection handle returncode = SQLAllocConnect(henv,&hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } TESTCASE_END; loop = 0; while( jobIDMatrix[ loop ].returncode != -101 ) { sprintf(Heading,"Test #%d: Testing for jobID: %s\n", loop, jobIDMatrix[ loop ].jobID); TESTCASE_BEGIN( Heading); returncode = SQLSetConnectAttr(hdbc, (SQLINTEGER)SQL_ATTR_SESSIONNAME,(SQLCHAR*) jobIDMatrix[ loop ].jobID, SQL_NTS); if (jobIDMatrix[ loop ].returncode == SQL_SUCCESS) { if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectAttr")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; loop++; continue; } } else { #ifdef unixcli if(returncode != SQL_ERROR) { #else if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectAttr")) { #endif LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; loop++; continue; } } returncode = SQLGetConnectAttr(hdbc, (SQLINTEGER)SQL_ATTR_SESSIONNAME, jobid, SQL_MAX_SESSIONNAME_LEN, &jobidlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetConnectAttr")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; loop++; continue; } if (jobIDMatrix[ loop ].returncode == SQL_SUCCESS) { if (strcmp(jobIDMatrix[ loop ].jobIDExpected, jobid) == 0) { LogMsg(NONE, "JobIDs are matched. Expected: \"%s\", Actual: \"%s\" for SQLGetConnectAttr\n", jobIDMatrix[ loop ].jobIDExpected, jobid); TESTCASE_END; } else { LogMsg(ERRMSG, "JobIDs are not matched. Expected: \"%s\", Actual: \"%s\", at line=%d for SQLGetConnectAttr\n", jobIDMatrix[ loop ].jobIDExpected, jobid, __LINE__); TEST_FAILED; } } else { #ifdef unixcli if (strcmp(jobIDMatrix[ loop ].jobIDExpected, jobid) == 0) { #else if (strcmp(jobIDMatrix[ loop ].jobID, jobid) == 0) { #endif LogMsg(NONE, "JobIDs are matched. Expected: \"%s\", Actual: \"%s\" for SQLGetConnectAttr\n", jobIDMatrix[ loop ].jobID, jobid); TESTCASE_END; } else { LogMsg(ERRMSG, "JobIDs are not matched. Expected: \"%s\", Actual: \"%s\", at line=%d for SQLGetConnectAttr\n", jobIDMatrix[ loop ].jobID, jobid, __LINE__); TEST_FAILED; } } returncode = SQLConnect(hdbc, (SQLCHAR*)pTestInfo->DataSource,(SWORD)strlen(pTestInfo->DataSource), (SQLCHAR*)pTestInfo->UserID,(SWORD)strlen(pTestInfo->UserID), (SQLCHAR*)pTestInfo->Password,(SWORD)strlen(pTestInfo->Password) ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } #ifndef unixcli if (jobIDMatrix[ loop ].returncode == SQL_SUCCESS_WITH_INFO) { if (returncode != jobIDMatrix[ loop ].returncode) { LogMsg(ERRMSG, "The retcode has to be SQL_SUCCESS_WITH_INFO, with the error message \"Driver's SQLSetConnectAttr failed.\" in it, at line=%d\n", __LINE__); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } // LogAllErrors(henv,hdbc,NULL); if (!FindError("IM006",henv,hdbc,NULL)) { LogMsg(ERRMSG, "Couldn't find state error IM006, with the error message \"Driver's SQLSetConnectAttr failed.\", at line=%d\n", __LINE__); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } } #endif returncode = SQLAllocStmt(hdbc,&hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLAllocStmt(hdbc,&hstmt2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLPrepare( hstmt, (SQLCHAR *)selecttab, SQL_NTS ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLGetCursorName(hstmt, cursorName, sizeof(cursorName), NULL ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } //Get queryID sprintf( infoStatsStmt, "INFOSTATS %s", (char*)cursorName ); returncode = SQLBindCol( hstmt2, 1, SQL_C_CHAR, &queryID, 256, &queryIDPtr ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect( hstmt2, (SQLCHAR *)infoStatsStmt, SQL_NTS ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch( hstmt2 ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } LogMsg(NONE, "queryID: \"%s\"\n", queryID); SQLFreeStmt(hstmt2,SQL_CLOSE); SQLFreeStmt(hstmt2,SQL_UNBIND); //Get Jobid if(isCharSet || isUCS2) sprintf( infoStatsStmt, "SELECT queryid_extract( _ISO88591'%s',_ISO88591'SESSIONNAME') FROM JOBID", (char*)queryID ); else sprintf( infoStatsStmt, "SELECT queryid_extract('%s','SESSIONNAME') FROM JOBID", (char*)queryID ); returncode = SQLBindCol( hstmt2, 1, SQL_C_CHAR, &queryID, 256, &queryIDPtr ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect( hstmt2, (SQLCHAR *)infoStatsStmt, SQL_NTS ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch( hstmt2 ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } LogMsg(NONE, "JobID: \"%s\"\n", queryID); if (strcmp(jobIDMatrix[ loop ].jobIDExpected, queryID) == 0) { LogMsg(NONE, "JobIDs are matched. Expected: \"%s\", Actual: \"%s\" for after queryid_extract\n", jobIDMatrix[ loop ].jobIDExpected, queryID); TESTCASE_END; } else { LogMsg(ERRMSG, "JobIDs are not matched. Expected: \"%s\", Actual: \"%s\", at line=%d for after queryid_extract\n", jobIDMatrix[ loop ].jobIDExpected, queryID, __LINE__); TEST_FAILED; } SQLFreeStmt(hstmt,SQL_CLOSE); SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt2,SQL_CLOSE); SQLFreeStmt(hstmt2,SQL_UNBIND); returncode = SQLDisconnect(hdbc); if (returncode != SQL_SUCCESS) { LogAllErrors(henv,hdbc,hstmt); SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); } loop++; } returncode = SQLFreeConnect(hdbc); if (returncode != SQL_SUCCESS) { LogAllErrors(henv,hdbc,hstmt); SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); } returncode = SQLFreeEnv(henv); if (returncode != SQL_SUCCESS) { LogAllErrors(henv,hdbc,hstmt); SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); } //====================================================================================================== sprintf(Heading,"Test positive functionality of SessionName, mutiple connection using the same session name\n"); TESTCASE_BEGIN( Heading); // Allocate Environment Handle returncode = SQLAllocEnv(&henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLAllocEnv(&henv2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv2")) { LogAllErrors(henv2,hdbc2,hstmt2); TEST_FAILED; TEST_RETURN; } returncode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetEnvAttr")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLSetEnvAttr(henv2, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, 0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetEnvAttr2")) { LogAllErrors(henv2,hdbc2,hstmt2); SQLFreeEnv(henv2); TEST_FAILED; TEST_RETURN; } // Allocate Connection handle returncode = SQLAllocConnect(henv,&hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv2,&hdbc2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect2")) { LogAllErrors(henv2,hdbc2,hstmt2); SQLFreeEnv(henv2); TEST_FAILED; TEST_RETURN; } TESTCASE_END; strcpy(tempStr,"123456789012345678901234"); sprintf(Heading,"Testing for jobID: %s\n", tempStr); TESTCASE_BEGIN( Heading); returncode = SQLSetConnectAttr(hdbc, (SQLINTEGER)SQL_ATTR_SESSIONNAME,(SQLCHAR*) tempStr, SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetConnectAttr")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLSetConnectAttr(hdbc2, (SQLINTEGER)SQL_ATTR_SESSIONNAME,(SQLCHAR*) tempStr, SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetConnectAttr2")) { LogAllErrors(henv2,hdbc2,hstmt2); TEST_FAILED; TEST_RETURN; } returncode = SQLGetConnectAttr(hdbc, (SQLINTEGER)SQL_ATTR_SESSIONNAME, jobid, SQL_MAX_SESSIONNAME_LEN, &jobidlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetConnectAttr")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } if (strcmp(tempStr, jobid) == 0) { LogMsg(NONE, "JobID1 are matched. Expected: \"%s\", Actual: \"%s\" for hdbc\n", tempStr, jobid); } else { LogMsg(ERRMSG, "JobID1 are not matched. Expected: \"%s\", Actual: \"%s\", at line=%d for hdbc\n", tempStr, jobid, __LINE__); TEST_FAILED; TEST_RETURN; } returncode = SQLGetConnectAttr(hdbc2, (SQLINTEGER)SQL_ATTR_SESSIONNAME, jobid, SQL_MAX_SESSIONNAME_LEN, &jobidlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetConnectAttr2")) { LogAllErrors(henv2,hdbc2,hstmt2); TEST_FAILED; TEST_RETURN; } if (strcmp(tempStr, jobid) == 0) { LogMsg(NONE, "JobID2 are matched. Expected: \"%s\", Actual: \"%s\" for hdbc2\n", tempStr, jobid); } else { LogMsg(ERRMSG, "JobID2 are not matched. Expected: \"%s\", Actual: \"%s\", at line=%d for hdbc2\n", tempStr, jobid, __LINE__); TEST_FAILED; TEST_RETURN; } returncode = SQLConnect(hdbc, (SQLCHAR*)pTestInfo->DataSource,(SWORD)strlen(pTestInfo->DataSource), (SQLCHAR*)pTestInfo->UserID,(SWORD)strlen(pTestInfo->UserID), (SQLCHAR*)pTestInfo->Password,(SWORD)strlen(pTestInfo->Password) ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLConnect(hdbc2, (SQLCHAR*)pTestInfo->DataSource,(SWORD)strlen(pTestInfo->DataSource), (SQLCHAR*)pTestInfo->UserID,(SWORD)strlen(pTestInfo->UserID), (SQLCHAR*)pTestInfo->Password,(SWORD)strlen(pTestInfo->Password) ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect2")) { LogAllErrors(henv2,hdbc2,hstmt2); SQLFreeConnect(hdbc2); SQLFreeEnv(henv2); TEST_FAILED; TEST_RETURN; } for (loop=0; loop<2; loop++) { if (loop == 0) { returncode = SQLAllocStmt(hdbc,&hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLAllocStmt(hdbc,&hstmt2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt3")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } } else { returncode = SQLAllocStmt(hdbc2,&hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv2,hdbc2,hstmt); SQLFreeConnect(hdbc2); SQLFreeEnv(henv2); TEST_FAILED; TEST_RETURN; } returncode = SQLAllocStmt(hdbc2,&hstmt2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt3")) { LogAllErrors(henv2,hdbc2,hstmt2); SQLFreeConnect(hdbc2); SQLFreeEnv(henv2); TEST_FAILED; TEST_RETURN; } } returncode = SQLPrepare( hstmt, (SQLCHAR *)selecttab, SQL_NTS ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLGetCursorName(hstmt, cursorName, sizeof(cursorName), NULL ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } //Get queryID sprintf( infoStatsStmt, "INFOSTATS %s", (char*)cursorName ); returncode = SQLBindCol( hstmt2, 1, SQL_C_CHAR, &queryID, 256, &queryIDPtr ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect( hstmt2, (SQLCHAR *)infoStatsStmt, SQL_NTS ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch( hstmt2 ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } LogMsg(NONE, "queryID%d: \"%s\"\n", loop, queryID); SQLFreeStmt(hstmt2,SQL_CLOSE); SQLFreeStmt(hstmt2,SQL_UNBIND); //Get Jobid if(isCharSet || isUCS2) sprintf( infoStatsStmt, "SELECT queryid_extract( _ISO88591'%s', _ISO88591'SESSIONNAME') FROM JOBID", (char*)queryID ); else sprintf( infoStatsStmt, "SELECT queryid_extract('%s','SESSIONNAME') FROM JOBID", (char*)queryID ); returncode = SQLBindCol( hstmt2, 1, SQL_C_CHAR, &queryID, 256, &queryIDPtr ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect( hstmt2, (SQLCHAR *)infoStatsStmt, SQL_NTS ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch( hstmt2 ); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt2); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TEST_FAILED; TEST_RETURN; } LogMsg(NONE, "JobID%d: \"%s\"\n", loop, queryID); if (strcmp(tempStr, queryID) == 0) { LogMsg(NONE, "JobID%d are matched. Expected: \"%s\", Actual: \"%s\" for after queryid_extract\n", loop, tempStr, queryID); TESTCASE_END; } else { LogMsg(ERRMSG, "JobID%d are not matched. Expected: \"%s\", Actual: \"%s\", at line=%d for after queryid_extract\n", loop, tempStr, queryID, __LINE__); TEST_FAILED; } SQLFreeStmt(hstmt,SQL_CLOSE); SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt2,SQL_CLOSE); SQLFreeStmt(hstmt2,SQL_UNBIND); } returncode = SQLDisconnect(hdbc); if (returncode != SQL_SUCCESS) { LogAllErrors(henv,hdbc,hstmt); SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); } returncode = SQLDisconnect(hdbc2); if (returncode != SQL_SUCCESS) { LogAllErrors(henv2,hdbc2,hstmt2); SQLDisconnect(hdbc2); SQLFreeConnect(hdbc2); SQLFreeEnv(henv2); } returncode = SQLFreeConnect(hdbc); if (returncode != SQL_SUCCESS) { LogAllErrors(henv,hdbc,hstmt); SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); } returncode = SQLFreeConnect(hdbc2); if (returncode != SQL_SUCCESS) { LogAllErrors(henv2,hdbc2,hstmt2); SQLDisconnect(hdbc2); SQLFreeConnect(hdbc2); SQLFreeEnv(henv2); } returncode = SQLFreeEnv(henv); if (returncode != SQL_SUCCESS) { LogAllErrors(henv,hdbc,hstmt); SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); } returncode = SQLFreeEnv(henv2); if (returncode != SQL_SUCCESS) { LogAllErrors(henv2,hdbc2,hstmt2); SQLDisconnect(hdbc2); SQLFreeConnect(hdbc2); SQLFreeEnv(henv2); } //========================================================================================= //FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => JobID.\n"); TEST_RETURN; }
PassFail TestSQLSpecialColumns(TestInfo *pTestInfo, int MX_MP_SPECIFIC) { TEST_DECLARE; TCHAR Heading[MAX_HEADING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; TCHAR TQualifier[NAME_LEN],TOwner[NAME_LEN],TName[NAME_LEN]; UWORD fColType[NUM_COLTYPE] = {SQL_BEST_ROWID,SQL_ROWVER}; UWORD Scope[NUM_SCOPE] = {SQL_SCOPE_CURROW,SQL_SCOPE_TRANSACTION,SQL_SCOPE_SESSION}; UWORD Nullable[NUM_NULL] = {SQL_NO_NULLS,SQL_NULLABLE}; TCHAR ocname[MAX_COLUMN_NAME],octype[MAX_COLUMN_NAME]; SWORD oscope,ocdatatype,ocsca,ocpc; SDWORD ocprec,oclen; SQLLEN oscopelen,ocnamelen,ocdatatypelen,octypelen,ocpreclen,oclenlen,ocscalen,ocpclen; struct { TCHAR *ColName; SWORD ColDataType; TCHAR *ColTypeName; TCHAR *ColTypeOutput; TCHAR *ColTypeLen; SDWORD ColPrec; SWORD ColSca; SDWORD ColLen; } Columns[] = { {_T("--"),SQL_CHAR,_T("char"),_T("CHAR"),_T("(10) CHARACTER SET ISO88591"),10,0,10}, {_T("--"),SQL_VARCHAR,_T("varchar"),_T("VARCHAR"),_T("(10) CHARACTER SET ISO88591"),10,0,10}, {_T("--"),SQL_VARCHAR,_T("varchar"),_T("VARCHAR"),_T("(255) CHARACTER SET ISO88591"),255,0,255}, {_T("--"),SQL_WCHAR,_T("char"),_T("NCHAR"),_T("(10) CHARACTER SET UCS2"),10,0,20}, {_T("--"),SQL_WVARCHAR,_T("varchar"),_T("NCHAR VARYING"),_T("(10) CHARACTER SET UCS2"),10,0,20}, {_T("--"),SQL_WVARCHAR,_T("varchar"),_T("NCHAR VARYING"),_T("(255) CHARACTER SET UCS2"),255,0,510}, {_T("--"),SQL_DECIMAL,_T("decimal"),_T("DECIMAL SIGNED"),_T("(10,5)"),10,5,12}, {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC SIGNED"),_T("(10,5)"),10,5,12}, {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC SIGNED"),_T("(19,0)"),19,0,21}, //Bignum {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC SIGNED"),_T("(19,6)"),19,6,21}, //Bignum {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC SIGNED"),_T("(128,0)"),128,0,130}, //Bignum {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC SIGNED"),_T("(128,128)"),128,128,130}, //Bignum {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC SIGNED"),_T("(128,64)"),128,64,130}, //Bignum {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC UNSIGNED"),_T("(10,5) unsigned"),10,5,12}, //Bignum {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC UNSIGNED"),_T("(18,5) unsigned"),18,5,20}, //Bignum {_T("--"),SQL_NUMERIC,_T("numeric"),_T("NUMERIC UNSIGNED"),_T("(30,10) unsigned"),30,10,32}, //Bignum {_T("--"),SQL_SMALLINT,_T("smallint"),_T("SMALLINT SIGNED"),_T(""),5,0,2}, {_T("--"),SQL_INTEGER,_T("integer"),_T("INTEGER SIGNED"),_T(""),10,0,4}, {_T("--"),SQL_BIGINT,_T("bigint"),_T("BIGINT SIGNED"),_T(""),19,0,20}, {_T("--"),SQL_DATE,_T("date"),_T("DATE"),_T(""),10,0,6}, {_T("--"),SQL_TIME,_T("time"),_T("TIME"),_T(""),8,0,6}, {_T("--"),SQL_TIMESTAMP,_T("TIMESTAMP"),_T("timestamp"),_T(""),26,6,16}, {_T("--"),SQL_BIT,_T("bit"),_T("BIT"),_T(""),1,1,0}, {_T("--"),SQL_TINYINT,_T("tinyint"),_T("TINYINT"),_T(""),3,0,2}, {_T("--"),SQL_BINARY,_T("binary"),_T("BINARY"),_T("(10)"),10,0,10}, {_T("--"),SQL_VARBINARY,_T("varbinary"),_T("VARBINARY"),_T("(10)"),10,0,10}, {_T("--"),SQL_WCHAR,_T("char"),_T("NCHAR"),_T("(10) CHARACTER SET UTF8"),10,0,20}, {_T("--"),SQL_WVARCHAR,_T("varchar"),_T("NCHAR VARYING"),_T("(10) CHARACTER SET UTF8"),10,0,20}, {_T("--"),SQL_WVARCHAR,_T("varchar"),_T("NCHAR VARYING"),_T("(255) CHARACTER SET UTF8"),255,0,510}, {_T("--"),0,_T("endloop"),_T(""),0,0,0,0} }; TCHAR *TableStr[4]; TCHAR ColStr[MAX_NOS_SIZE], KeyStr[MAX_NOS_SIZE], CreateTbl[MAX_NOS_SIZE],END_LOOP[10]; int i = 0, k = 0,ct = 0, s = 0, t = 0, n = 0, psc = 1; BOOL found = FALSE; //TCHAR *charNameUCS2 = _T("NCHAR"); //TCHAR *varcharNameUCS2 = _T("NCHAR VARYING"); //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLSpecialColumns"), charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); Columns[0].ColName = var_mapping(_T("SQLSpecialColumns_Columns_1"), var_list); Columns[1].ColName = var_mapping(_T("SQLSpecialColumns_Columns_2"), var_list); Columns[2].ColName = var_mapping(_T("SQLSpecialColumns_Columns_3"), var_list); Columns[3].ColName = var_mapping(_T("SQLSpecialColumns_Columns_4"), var_list); Columns[4].ColName = var_mapping(_T("SQLSpecialColumns_Columns_5"), var_list); Columns[5].ColName = var_mapping(_T("SQLSpecialColumns_Columns_6"), var_list); Columns[6].ColName = var_mapping(_T("SQLSpecialColumns_Columns_7"), var_list); Columns[7].ColName = var_mapping(_T("SQLSpecialColumns_Columns_8"), var_list); Columns[8].ColName = var_mapping(_T("SQLSpecialColumns_Columns_9"), var_list); Columns[9].ColName = var_mapping(_T("SQLSpecialColumns_Columns_10"), var_list); Columns[10].ColName = var_mapping(_T("SQLSpecialColumns_Columns_11"), var_list); Columns[11].ColName = var_mapping(_T("SQLSpecialColumns_Columns_12"), var_list); Columns[12].ColName = var_mapping(_T("SQLSpecialColumns_Columns_13"), var_list); Columns[13].ColName = var_mapping(_T("SQLSpecialColumns_Columns_14"), var_list); Columns[14].ColName = var_mapping(_T("SQLSpecialColumns_Columns_15"), var_list); Columns[15].ColName = var_mapping(_T("SQLSpecialColumns_Columns_16"), var_list); Columns[16].ColName = var_mapping(_T("SQLSpecialColumns_Columns_17"), var_list); Columns[17].ColName = var_mapping(_T("SQLSpecialColumns_Columns_18"), var_list); Columns[18].ColName = var_mapping(_T("SQLSpecialColumns_Columns_19"), var_list); Columns[19].ColName = var_mapping(_T("SQLSpecialColumns_Columns_20"), var_list); Columns[20].ColName = var_mapping(_T("SQLSpecialColumns_Columns_21"), var_list); Columns[21].ColName = var_mapping(_T("SQLSpecialColumns_Columns_22"), var_list); Columns[22].ColName = var_mapping(_T("SQLSpecialColumns_Columns_23"), var_list); Columns[23].ColName = var_mapping(_T("SQLSpecialColumns_Columns_24"), var_list); Columns[24].ColName = var_mapping(_T("SQLSpecialColumns_Columns_25"), var_list); Columns[25].ColName = var_mapping(_T("SQLSpecialColumns_Columns_26"), var_list); Columns[26].ColName = var_mapping(_T("SQLSpecialColumns_Columns_27"), var_list); Columns[27].ColName = var_mapping(_T("SQLSpecialColumns_Columns_28"), var_list); Columns[28].ColName = var_mapping(_T("SQLSpecialColumns_Columns_29"), var_list); TableStr[0] = var_mapping(_T("SQLSpecialColumns_TableStr_1"), var_list); TableStr[1] = var_mapping(_T("SQLSpecialColumns_TableStr_2"), var_list); TableStr[2] = var_mapping(_T("SQLSpecialColumns_TableStr_3"), var_list); TableStr[3] = var_mapping(_T("SQLSpecialColumns_TableStr_4"), var_list); //========================================================================================= //if(isUCS2) { // LogMsg(NONE,_T("Setup for UCS2 mode testing: ColPrec has to be doubled\n")); // i = 0; // while(_tcsicmp(Columns[i].ColTypeName,_T("endloop")) != 0) { // if (Columns[i].ColDataType == SQL_WCHAR){ // Columns[i].ColDataType = SQL_WCHAR; // Columns[i].ColTypeOutput = charNameUCS2; // //Columns[i].ColPrec *= 2; --> This is in character, no need to double // Columns[i].ColLen *= 2; // } // else if (Columns[i].ColDataType == SQL_WVARCHAR) { // Columns[i].ColDataType = SQL_WVARCHAR; // Columns[i].ColTypeOutput = varcharNameUCS2; // //Columns[i].ColPrec *= 2; --> This is in character, no need to double // Columns[i].ColLen *= 2; // } // else if (Columns[i].ColDataType == SQL_WLONGVARCHAR) { // Columns[i].ColDataType = SQL_WLONGVARCHAR; // Columns[i].ColTypeOutput = varcharNameUCS2; // //Columns[i].ColPrec *= 2; --> This is in character, no need to double // Columns[i].ColLen *= 2; // } // i++; // } // i = 0; //} //========================================================================================= if (MX_MP_SPECIFIC == MX_SPECIFIC) LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => MX Specific SQLSpecialColumns.\n")); else LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => MP Specific SQLSpecialColumns.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLSpecialColumns tests\n"); if(!FullConnect(pTestInfo)){ LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; _tcscpy(ColStr,_T("")); _tcscpy(KeyStr,_T("")); _tcscpy(END_LOOP,_T("")); _tcscpy(TName,TableStr[2]); if (MX_MP_SPECIFIC == MX_SPECIFIC) { _tcscpy(TQualifier,pTestInfo->Catalog); _tcscpy(TOwner,pTestInfo->Schema); _tcscpy(END_LOOP,_T("bit")); } else { _tcscpy(TQualifier,_T("")); _tcscpy(TOwner,pTestInfo->UserID); _tcscpy(END_LOOP,_T("endloop")); } while (_tcsicmp(Columns[i].ColTypeName,END_LOOP) != 0) { SQLExecDirect(hstmt,(SQLTCHAR*) (SQLTCHAR *)TableStr[1],SQL_NTS); // cleanup if (i > 0) { _tcscat(ColStr,_T(",")); _tcscat(KeyStr,_T(",")); } _tcscat(ColStr,Columns[i].ColName); _tcscat(ColStr,_T(" ")); _tcscat(ColStr,Columns[i].ColTypeName); _tcscat(ColStr,Columns[i].ColTypeLen); _tcscat(ColStr,_T(" not null")); _tcscat(KeyStr,Columns[i].ColName); _tcscpy(CreateTbl,_T("")); _tcscat(CreateTbl,TableStr[0]); _tcscat(CreateTbl,_T("(")); _tcscat(CreateTbl,ColStr); _tcscat(CreateTbl,_T(", primary key(")); _tcscat(CreateTbl,KeyStr); _tcscat(CreateTbl,_T("))")); _stprintf(Heading,_T("Test Positive Functionality of SQLSpecialColumns for this table:\n")); _tcscat(Heading,CreateTbl); _tcscat(Heading,_T("\n")); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)CreateTbl,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else{ if (_tcslen(TQualifier) > 0) returncode = SQLSpecialColumns(hstmt,fColType[ct],(SQLTCHAR*)TQualifier,(SWORD)_tcslen(TQualifier),(SQLTCHAR*)TOwner,(SWORD)_tcslen(TOwner),(SQLTCHAR*)TName,(SWORD)_tcslen(TName),Scope[s],Nullable[n]); else returncode = SQLSpecialColumns(hstmt,fColType[ct],NULL,0,(SQLTCHAR*)TOwner,(SWORD)_tcslen(TOwner),(SQLTCHAR*)TName,(SWORD)_tcslen(TName),Scope[s],Nullable[n]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSpecialColumns")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else{ oscope = 0; _tcscpy(ocname,_T("")); ocdatatype = 0; _tcscpy(octype,_T("")); ocprec = 0; oclen = 0; ocsca = 0; ocpc = 0; SQLBindCol(hstmt,1,SQL_C_SHORT,&oscope,0,&oscopelen); SQLBindCol(hstmt,2,SQL_C_TCHAR,ocname,MAX_COLUMN_NAME,&ocnamelen); SQLBindCol(hstmt,3,SQL_C_SHORT,&ocdatatype,0,&ocdatatypelen); SQLBindCol(hstmt,4,SQL_C_TCHAR,octype,MAX_COLUMN_NAME,&octypelen); SQLBindCol(hstmt,5,SQL_C_LONG,&ocprec,0,&ocpreclen); SQLBindCol(hstmt,6,SQL_C_LONG,&oclen,0,&oclenlen); SQLBindCol(hstmt,7,SQL_C_SHORT,&ocsca,0,&ocscalen); SQLBindCol(hstmt,8,SQL_C_SHORT,&ocpc,0,&ocpclen); k = 0; while (returncode == SQL_SUCCESS){ returncode = SQLFetch(hstmt); if((returncode!=SQL_NO_DATA_FOUND) &&(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else{ if (returncode == SQL_SUCCESS){ if (MX_MP_SPECIFIC == MX_SPECIFIC) { psc = SQL_PC_NOT_PSEUDO; } else { psc = 1; } LogMsg(NONE,_T("Comparing results for SQLSpecialColumns\n")); t = 0; found = FALSE; while(_tcscmp(Columns[t].ColTypeName,_T("endloop"))!=0) { if(cwcscmp(ocname, Columns[t].ColName,TRUE) == 0) { if ((oscope == Scope[s]) && (ocdatatype == Columns[t].ColDataType) && (_tcsicmp(octype,Columns[t].ColTypeOutput) == 0) && (ocprec == Columns[t].ColPrec) && (oclen == Columns[t].ColLen) && (ocsca == Columns[t].ColSca) && (ocpc == (SWORD)psc)){ /* LogMsg(NONE,_T("Scope expect: %d and actual: %d are matched\n"),Scope[s],oscope); LogMsg(NONE,_T("colname expect: %s and actual: %s are matched\n"),Columns[t].ColName,ocname); LogMsg(NONE,_T("ColDataType expect: %d and actual: %d are matched\n"),Columns[t].ColDataType,ocdatatype); LogMsg(NONE,_T("ColTypeOutput expect: %s and actual: %s are matched\n"),Columns[t].ColTypeOutput,octype); LogMsg(NONE,_T("ColPrec expect: %d and actual: %d are matched\n"),Columns[t].ColPrec,ocprec); LogMsg(NONE,_T("ColLen expect: %d and actual: %d are matched\n"),Columns[t].ColLen,oclen); LogMsg(NONE,_T("ColScale expect: %d and actual: %d are matched\n"),Columns[t].ColSca,ocsca); LogMsg(NONE,_T("ColPseudoCol expect: %d and actual: %d are matched\n\n"),(SWORD)psc,ocpc); */ } else { TEST_FAILED; if (oscope != Scope[s]) LogMsg(ERRMSG,_T("Scope expect: %d and actual: %d are not matched\n"),Scope[t],oscope); if (ocdatatype != Columns[t].ColDataType) LogMsg(ERRMSG,_T("ColDataType expect: %d and actual: %d are not matched\n"),Columns[t].ColDataType,ocdatatype); if (_tcsicmp(octype,Columns[t].ColTypeOutput) != 0) LogMsg(ERRMSG,_T("ColTypeName expect: %s and actual: %s are not matched\n"),Columns[t].ColTypeOutput,octype); if (ocprec != Columns[t].ColPrec) LogMsg(ERRMSG,_T("ColPrec expect: %d and actual: %d are not matched\n"),Columns[t].ColPrec,ocprec); if (oclen != Columns[t].ColLen) LogMsg(ERRMSG,_T("ColLen expect: %d and actual: %d are not matched\n"),Columns[t].ColLen,oclen); if (ocsca != Columns[t].ColSca) LogMsg(ERRMSG,_T("ColScale expect: %d and actual: %d are not matched\n"),Columns[t].ColSca,ocsca); if (ocpc != (SWORD)psc) LogMsg(ERRMSG,_T("ColPseudoCol expect: %d and actual: %d are not matched\n\n"),(SWORD)psc,ocpc); } found = TRUE; break; } else { t++; } } if(!found) { TEST_FAILED; LogMsg(ERRMSG,_T("Unexpected returned data: %s\n"), ocname); } } } if (returncode == SQL_SUCCESS) k++; } // end while if(k == 0) { TEST_FAILED; LogMsg(ERRMSG,_T("No Data Found => Atleast one row should be fetched\n")); } } SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt,SQL_CLOSE); } SQLExecDirect(hstmt,(SQLTCHAR*) (SQLTCHAR *)TableStr[1],SQL_NTS); i++; TESTCASE_END; } // end while //======================================================================================================== _stprintf(Heading,_T("SQLSpecialColumns: Negative test with NULL handle\n")); TESTCASE_BEGINW(Heading); hstmt = (SQLHANDLE)NULL; _tcscpy(TQualifier,_T("")); _tcscpy(TOwner,pTestInfo->UserID); _tcscpy(TName,TableStr[3]); i = 0; returncode = SQLSpecialColumns(hstmt,fColType[i],(SQLTCHAR*)TQualifier,(SWORD)_tcslen(TQualifier),(SQLTCHAR*)TOwner,(SWORD)_tcslen(TOwner),(SQLTCHAR*)TName,(SWORD)_tcslen(TName),Scope[i],Nullable[i]); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLSpecialColumns")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //======================================================================================================== FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLSpecialColumns.\n")); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLNativeSql --------------------------------------------------------- */ PassFail TestSQLNativeSql(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; CHAR *szSqlStrIn[3]; CHAR szSqlStrOut[SQLSTR_LEN]; SDWORD pcbSqlStr; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLNativeSql", charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); szSqlStrIn[0] = var_mapping("SQLNativeSql_szSqlStrIn_1", var_list); szSqlStrIn[1] = var_mapping("SQLNativeSql_szSqlStrIn_2", var_list); szSqlStrIn[2] = var_mapping("SQLNativeSql_szSqlStrIn_3", var_list); //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API =>SQLNativeSql | SQLNativeSQL | natsql.c\n"); TEST_INIT; returncode=FullConnect(pTestInfo); if (pTestInfo->hdbc == (SQLHANDLE)NULL) { TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if (returncode == SQL_SUCCESS) { //================================================================================================== TESTCASE_BEGIN("Test the positive functionality of SQLNativeSql with null terminated string\n"); returncode = SQLNativeSql((SQLHANDLE)hdbc, (SQLCHAR*)szSqlStrIn[0], SQL_NTS, (SQLCHAR*)szSqlStrOut, SQLSTR_LEN, &pcbSqlStr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNativeSql")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (strcmp(szSqlStrOut,szSqlStrIn[0]) == 0) { LogMsg(NONE,"expect: %s and actual: %s are matched\n", szSqlStrIn[0], szSqlStrOut); } else { TEST_FAILED; LogMsg(NONE,"expect: %s and actual: %s are not matched\n", szSqlStrIn[0], szSqlStrOut); } TESTCASE_END; //================================================================================================== TESTCASE_BEGIN("Test the positive functionality of SQLNativeSql with string length as input\n"); returncode = SQLNativeSql((SQLHANDLE)hdbc, (SQLCHAR*)szSqlStrIn[1], strlen(szSqlStrIn[1]), (SQLCHAR*)szSqlStrOut, SQLSTR_LEN, &pcbSqlStr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNativeSql")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (strcmp(szSqlStrOut,szSqlStrIn[1]) == 0) { LogMsg(NONE,"expect: %s and actual: %s are matched\n", szSqlStrIn[1], szSqlStrOut); } else { TEST_FAILED; LogMsg(NONE,"expect: %s and actual: %s are not matched\n", szSqlStrIn[1], szSqlStrOut); } TESTCASE_END; //================================================================================================== TESTCASE_BEGIN("Test the positive functionality of SQLNativeSql with max length same as string length\n"); returncode = SQLNativeSql((SQLHANDLE)hdbc, (SQLCHAR*)szSqlStrIn[2], strlen(szSqlStrIn[2]), (SQLCHAR*)szSqlStrOut, strlen(szSqlStrIn[2])+1, &pcbSqlStr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNativeSql")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (strcmp(szSqlStrOut,szSqlStrIn[2]) == 0) { LogMsg(NONE,"expect: %s and actual: %s are matched\n", szSqlStrIn[2], szSqlStrOut); } else { TEST_FAILED; LogMsg(NONE,"expect: %s and actual: %s are not matched\n", szSqlStrIn[2], szSqlStrOut); } TESTCASE_END; } //================================================================================================== FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLNativeSql.\n"); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLDescribeColVer3 for MP Specific --------------------------------------------------------- */ PassFail TestMXSQLDescribeColVer3(TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv, hdbc, hstmt; UWORD icol; SWORD numcol, st, cs, cnull, cl, colsize = 2; SQLULEN cp; CHAR cn[COLNAME_LEN]; CHAR *colname[21]; CHAR *ExecDirStr[12]; #ifndef _WM SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_TYPE_DATE,SQL_TYPE_TIME,SQL_TYPE_TIMESTAMP,SQL_LONGVARCHAR,SQL_BIGINT, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC}; SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,19,19,128,128,10,18,30}; #else SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_CHAR,SQL_TYPE_TIME,SQL_TYPE_TIMESTAMP,SQL_LONGVARCHAR,SQL_BIGINT, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC}; SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,8,8,26,2000,19,19,19,128,128,10,18,30}; #endif SWORD ColScale[]= {0, 0, 6, 6, 0,0, 0,0, 0, 0, 0,6, 0, 0, 0, 6, 0, 128,5, 5, 10}; char TempType1[50],TempType2[50]; SWORD ColNullable[] = {SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE}; CHAR *TestCase[] = { "before preparing stmt ", "before preparing & executing stmt ", "before preparing, executing & fetching stmt ", "before execdirect stmt ", "before execdirect & fetching stmt ", "before preparing param stmt ", "before preparing & binding stmt ", "before preparing, binding & executing stmt ", "before preparing, binding, executing & fetching stmt " }; int lend = 9, iend = 3; SQLUSMALLINT i = 0, l = 0; SQLLEN cbIn = SQL_NTS; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLDescribeColumns30", charset_file); if (var_list == NULL) return FAILED; //================Modified for Longvarchar Changes=========================================================== if(!pTestInfo->bLongOn) { SWORD iNoLong = SQL_VARCHAR; SQLType[12] = iNoLong; } //================Modified for Longvarchar Changes=========================================================== //print_list(var_list); colname[0] = var_mapping("SQLDescribeColumns30_colname_1", var_list); colname[1] = var_mapping("SQLDescribeColumns30_colname_2", var_list); colname[2] = var_mapping("SQLDescribeColumns30_colname_3", var_list); colname[3] = var_mapping("SQLDescribeColumns30_colname_4", var_list); colname[4] = var_mapping("SQLDescribeColumns30_colname_5", var_list); colname[5] = var_mapping("SQLDescribeColumns30_colname_6", var_list); colname[6] = var_mapping("SQLDescribeColumns30_colname_7", var_list); colname[7] = var_mapping("SQLDescribeColumns30_colname_8", var_list); colname[8] = var_mapping("SQLDescribeColumns30_colname_9", var_list); colname[9] = var_mapping("SQLDescribeColumns30_colname_10", var_list); colname[10] = var_mapping("SQLDescribeColumns30_colname_11", var_list); colname[11] = var_mapping("SQLDescribeColumns30_colname_12", var_list); colname[12] = var_mapping("SQLDescribeColumns30_colname_13", var_list); colname[13] = var_mapping("SQLDescribeColumns30_colname_14", var_list); colname[14] = var_mapping("SQLDescribeColumns30_colname_15", var_list); colname[15] = var_mapping("SQLDescribeColumns30_colname_16", var_list); colname[16] = var_mapping("SQLDescribeColumns30_colname_17", var_list); colname[17] = var_mapping("SQLDescribeColumns30_colname_18", var_list); colname[18] = var_mapping("SQLDescribeColumns30_colname_19", var_list); colname[19] = var_mapping("SQLDescribeColumns30_colname_20", var_list); colname[20] = var_mapping("SQLDescribeColumns30_colname_21", var_list); ExecDirStr[0] = var_mapping("SQLDescribeColumns30_ExecDirStr_1", var_list); ExecDirStr[1] = var_mapping("SQLDescribeColumns30_ExecDirStr_2", var_list); ExecDirStr[2] = var_mapping("SQLDescribeColumns30_ExecDirStr_3", var_list); ExecDirStr[3] = var_mapping("SQLDescribeColumns30_ExecDirStr_4", var_list); ExecDirStr[4] = var_mapping("SQLDescribeColumns30_ExecDirStr_5", var_list); ExecDirStr[5] = var_mapping("SQLDescribeColumns30_ExecDirStr_6", var_list); ExecDirStr[6] = var_mapping("SQLDescribeColumns30_ExecDirStr_7", var_list); ExecDirStr[7] = var_mapping("SQLDescribeColumns30_ExecDirStr_8", var_list); ExecDirStr[8] = var_mapping("SQLDescribeColumns30_ExecDirStr_9", var_list); ExecDirStr[9] = var_mapping("SQLDescribeColumns30_ExecDirStr_10", var_list); ExecDirStr[10] = var_mapping("SQLDescribeColumns30_ExecDirStr_11", var_list); ExecDirStr[11] = var_mapping("SQLDescribeColumns30_ExecDirStr_12", var_list); //========================================================================================= if(isUCS2) { LogMsg(NONE,"Setup for UCS2 mode testing: ColPrec has to be doubled\n"); ExecDirStr[3] = replace_str(ExecDirStr[3],"$$$","127"); ExecDirStr[4] = replace_str(ExecDirStr[4],"$$$","127"); ExecDirStr[5] = replace_str(ExecDirStr[5],"$$$","127"); l = sizeof(SQLType)/sizeof(SQLType[0]); while(i < l) { if(SQLType[i] == SQL_CHAR) { //SQLType[i] = SQL_WCHAR; ColPrec[i] *= 2; //--> This is in character, so no need to double } else if (SQLType[i] == SQL_VARCHAR) { //SQLType[i] = SQL_WVARCHAR; } else if (SQLType[i] == SQL_LONGVARCHAR) { //SQLType[i] = SQL_WLONGVARCHAR; ColPrec[i] *= 2; //--> This is in character, so no need to double } else { } i++; } i = 0; l = 0; } else { ExecDirStr[3] = replace_str(ExecDirStr[3],"$$$","254"); ExecDirStr[4] = replace_str(ExecDirStr[4],"$$$","254"); ExecDirStr[5] = replace_str(ExecDirStr[5],"$$$","254"); } //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX Specific SQLDescribeColumns | SQLDescribeColumns30 | sqldescribecolver3.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLDescribCol tests\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,"Unable to connect\n"); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup for (l = 0; l < lend; l++) { for (i = 0; i < iend; i++) { //================================================================================== sprintf(Heading,"SQLDescribeCol: Test #%d.%d\n",l,i); TESTCASE_BEGIN(Heading); if ((i != (iend-1)) && (l < 5)) { rerutncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ LogMsg(NONE,"%s\n", ExecDirStr[i+iend]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { LogMsg(NONE,"SQLDescribeCol: %s\n",TestCase[l]); LogMsg(NONE," %s\n",ExecDirStr[i+iend+iend+iend]); switch( l ) { case 0: returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } break; case 1 : returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } } break; case 2 : returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } } } break; case 3 : returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } break; case 4 : returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } } break; } if (returncode == SQL_SUCCESS) { returncode=SQLNumResultCols(hstmt, &numcol); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } for (icol = 1; icol <= numcol; icol++) { LogMsg(LINEBEFORE,"SQLDescribeCol: checking Column #%d\n",icol); returncode = SQLDescribeCol(hstmt,icol,(SQLCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol")) { TEST_FAILED; LogAllErrorsVer3(henv,hdbc,hstmt); } colsize=strlen(colname[icol-1]); if(isCharSet == TRUE) colsize -= 2; if ((cstrcmp(cn,colname[icol-1],FALSE,isCharSet) == 0) && (cl == colsize) && (st == SQLType[icol-1]) && (cp == ColPrec[icol-1]) && (cs == ColScale[icol-1]) && (cnull == ColNullable[i])) { //LogMsg(NONE,"colname expect: %s and actual: %s are matched\n",colname[icol-1],cn); //LogMsg(NONE,"ColNameLen expect: %d and actual: %d are matched\n",colsize,cl); //LogMsg(NONE,"SQLType expect: %s and actual: %s are matched\n", //SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); //LogMsg(NONE,"ColPrec expect: %d and actual: %d are matched\n",ColPrec[icol-1],cp); //LogMsg(NONE,"ColScale expect: %d and actual: %d are matched\n",ColScale[icol-1],cs); //LogMsg(NONE,"ColNullable expect: %s and actual: %s are matched\n\n", //SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (cstrcmp(cn,colname[icol-1],FALSE,isCharSet) != 0) LogMsg(ERRMSG,"colname expect: %s and actual: %s are not matched\n",colname[icol-1],cn); if (cl != colsize) LogMsg(ERRMSG,"ColNameLen expect: %d and actual: %d are not matched\n",colsize,cl); if (st != SQLType[icol-1]) LogMsg(ERRMSG,"SQLType expect: %s and actual: %s are not matched\n", SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); if (cp != ColPrec[icol-1]) LogMsg(ERRMSG,"ColPrec expect: %d and actual: %d are not matched\n",ColPrec[icol-1],cp); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,"ColScale expect: %d and actual: %d are not matched\n",ColScale[icol-1],cs); if (cnull != ColNullable[i]) LogMsg(ERRMSG,"ColNullable expect: %s and actual: %s are not matched\n\n", SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } } /* end icol loop */ } else { TEST_FAILED; LogAllErrorsVer3(henv,hdbc,hstmt); } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */ } } } else if ((i == (iend-1)) && (l >= 5)) { SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ LogMsg(NONE,"%s\n", ExecDirStr[i+iend]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecDirect(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { LogMsg(NONE,"SQLDescribeCol: %s\n",TestCase[l]); LogMsg(NONE," %s\n",ExecDirStr[i+iend+iend+iend]); switch( l ) { case 5 : returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } break; case 6 : returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER) "0123456789",300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } } break; case 7 : returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } } break; case 8 : returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,2000,0,(SQLPOINTER)"0123456789",300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } } } break; } if (returncode == SQL_SUCCESS) { SQLNumResultCols(hstmt, &numcol); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } for (icol = 1; icol <= numcol; icol++) { LogMsg(LINEBEFORE,"SQLDescribeCol: checking Column #%d\n",icol); returncode = SQLDescribeCol(hstmt,icol,(SQLCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol")) { TEST_FAILED; LogAllErrorsVer3(henv,hdbc,hstmt); } colsize=strlen(colname[icol-1]); if(isCharSet == TRUE) colsize -= 2; if ((cstrcmp(cn,colname[icol-1],FALSE,isCharSet) == 0) && (cl == colsize) && (st == SQLType[icol-1]) && (cp == ColPrec[icol-1]) && (cs == ColScale[icol-1]) && (cnull == ColNullable[i])) { //LogMsg(NONE,"colname expect: %s and actual: %s are matched\n",colname[icol-1],cn); //LogMsg(NONE,"ColNameLen expect: %d and actual: %d are matched\n",colsize,cl); //LogMsg(NONE,"SQLType expect: %s and actual: %s are matched\n", // SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); //LogMsg(NONE,"ColPrec expect: %d and actual: %d are matched\n",ColPrec[icol-1],cp); //LogMsg(NONE,"ColScale expect: %d and actual: %d are matched\n",ColScale[icol-1],cs); //LogMsg(NONE,"ColNullable expect: %s and actual: %s are matched\n\n", // SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (cstrcmp(cn,colname[icol-1],FALSE,isCharSet) != 0) LogMsg(ERRMSG,"colname expect: %s and actual: %s are not matched\n",colname[icol-1],cn); if (cl != colsize) LogMsg(ERRMSG,"ColNameLen expect: %d and actual: %d are not matched\n",colsize,cl); if (st != SQLType[icol-1]) LogMsg(ERRMSG,"SQLType expect: %s and actual: %s are not matched\n", SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); if (cp != ColPrec[icol-1]) LogMsg(ERRMSG,"ColPrec expect: %d and actual: %d are not matched\n",ColPrec[icol-1],cp); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,"ColScale expect: %d and actual: %d are not matched\n",ColScale[icol-1],cs); if (cnull != ColNullable[i]) LogMsg(ERRMSG,"ColNullable expect: %s and actual: %s are not matched\n\n", SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } } } } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLCHAR*) ExecDirStr[i],SQL_NTS); } } TESTCASE_END; } /* iend loop */ } /* lend loop */ SQLFreeHandle(SQL_HANDLE_STMT, hstmt); FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => MX Specific SQLDescribeColumns.\n"); free_list(var_list); TEST_RETURN; }
//--------------------------------------------------------- // TestSQLAllocStmt() //--------------------------------------------------------- PassFail TestSQLAllocStmt (TestInfo *pTestInfo, int MX_MP_SPECIFIC) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt[NUM_STMT]; //RETCODE AsyncStmt[NUM_ASYNC_STMT]; char *StmtHndlStr; int i = 0, j = 0, k = 0; int AnyAsync; int AsyncOper[] = {CREATE_TABLE,INSERT_TABLE,SELECT_TABLE,DROP_TABLE,999}; char *teststmthndl[21]; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLAllocateStatement", charset_file); if (var_list == NULL) return FAILED; teststmthndl[0] = var_mapping("TestStmtHndl_0", var_list); teststmthndl[1] = var_mapping("TestStmtHndl_1", var_list); teststmthndl[2] = var_mapping("TestStmtHndl_2", var_list); teststmthndl[3] = var_mapping("TestStmtHndl_3", var_list); teststmthndl[4] = var_mapping("TestStmtHndl_4", var_list); teststmthndl[5] = var_mapping("TestStmtHndl_5", var_list); teststmthndl[6] = var_mapping("TestStmtHndl_6", var_list); teststmthndl[7] = var_mapping("TestStmtHndl_7", var_list); teststmthndl[8] = var_mapping("TestStmtHndl_8", var_list); teststmthndl[9] = var_mapping("TestStmtHndl_9", var_list); teststmthndl[10] = var_mapping("TestStmtHndl_10", var_list); teststmthndl[11] = var_mapping("TestStmtHndl_11", var_list); teststmthndl[12] = var_mapping("TestStmtHndl_12", var_list); teststmthndl[13] = var_mapping("TestStmtHndl_13", var_list); teststmthndl[14] = var_mapping("TestStmtHndl_14", var_list); teststmthndl[15] = var_mapping("TestStmtHndl_15", var_list); teststmthndl[16] = var_mapping("TestStmtHndl_16", var_list); teststmthndl[17] = var_mapping("TestStmtHndl_17", var_list); teststmthndl[18] = var_mapping("TestStmtHndl_18", var_list); teststmthndl[19] = var_mapping("TestStmtHndl_19", var_list); teststmthndl[20] = var_mapping("TestStmtHndl_20", var_list); //====================================================================================== if (MX_MP_SPECIFIC == MX_SPECIFIC) LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX specific SQLAllocStmt | SQLAllocStmt | alocstmt.c\n"); else LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MP specific SQLAllocStmt | SQLAllocStmt | alocstmt.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLAllocStmt/SQLFreeStmt tests\n"); /* 6-5-00: Need to turn Autocommit off since MX will close all open cursors that are open if the end of ANY of the cursors is reached. */ if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_2)) { LogMsg(NONE,"Unable to connect\n"); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; //set the connection attribute to SQL_AUTOCOMMIT_OFF to enable use of multiple stmt without errors SQLSetConnectAttr((SQLHANDLE)hdbc, SQL_ATTR_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF, SQL_IS_UINTEGER); TESTCASE_END; // end of setup StmtHndlStr = (char *)malloc(MAX_NOS_SIZE); //==================================================================================================== // General statement handle exercise testcases. for (k = 0; k < 2; k++) { for (i = 0; i < NUM_STMT; i++) { hstmt[i] = (SQLHANDLE)pTestInfo->hstmt; sprintf(Heading,"SQLAllocstmt: Test #%d\n",i); TESTCASE_BEGIN(Heading); returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; if (returncode == SQL_SUCCESS) { if (i == 0) // cleanup { for (j = 0; j < NUM_STMT; j++) { SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[j],StmtHndlStr),SQL_NTS); } } sprintf(Heading,"SQLAllocStmt: create table teststmthndl%d\n",i+1); TESTCASE_BEGIN(Heading); if (k == 0) // prepare & execute { returncode = SQLPrepare(hstmt[i],StmtQueries(CREATE_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } else{ returncode = SQLExecute(hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } } else // execdirect { returncode = SQLExecDirect(hstmt[i],StmtQueries(CREATE_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } } if (returncode == SQL_SUCCESS) TESTCASE_END; } for (i = 0; i < NUM_STMT; i++) { sprintf(Heading,"SQLAllocStmt: inserts on Stmt Handle(%d)\n",i); TESTCASE_BEGIN(Heading); if (k == 0) // prepare & execute { returncode = SQLPrepare(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } else { returncode = SQLExecute(hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } } else // execdirect { returncode = SQLExecDirect(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } if (returncode == SQL_SUCCESS)TESTCASE_END; } for (i = 0; i < NUM_STMT; i++) { sprintf(Heading,"SQLAllocStmt: selects on Stmt Handle(%d)\n",i); TESTCASE_BEGIN(Heading); if (k == 0) // prepare & execute { returncode = SQLPrepare(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } else{ returncode = SQLExecute(hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } } else // execdirect { returncode = SQLExecDirect(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[i],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } if (returncode == SQL_SUCCESS) TESTCASE_END; } for (i = (NUM_STMT-1); i > -1; i--) { sprintf(Heading,"SQLAllocStmt: fetches on selects on Stmt Handle(%d)\n",i); TESTCASE_BEGIN(Heading); returncode = SQLFetch(hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } if (returncode == SQL_SUCCESS) TESTCASE_END; } for (i = 0; i < NUM_STMT; i++) { sprintf(Heading,"SQLAllocStmt: SQLFreeStmt(%d) with SQL_CLOSE\n",i); TESTCASE_BEGIN(Heading); returncode = SQLFreeStmt(hstmt[i],SQL_CLOSE); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } else{ TESTCASE_END; } if (i == (NUM_STMT-1)) // cleanup { for (j = 0; j < NUM_STMT; j++) { SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[j],StmtHndlStr),SQL_NTS); } } } for (i = 0; i < NUM_STMT; i++) { sprintf(Heading,"SQLAllocStmt: SQLFreeStmt(%d) with SQL_DROP\n",i); TESTCASE_BEGIN(Heading); returncode = SQLFreeStmt(hstmt[i],SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } else{ TESTCASE_END; } } sprintf(Heading,"SLQAllocStmt: same sql operations on different of SQLAllocstmt(%d)s\n",i); TESTCASE_BEGIN(Heading); for (i = 0; i < NUM_STMT; i++) { hstmt[i] = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } if (returncode == SQL_SUCCESS) { if (i == 0) // cleanup { SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS); returncode = SQLExecDirect(hstmt[0],StmtQueries(CREATE_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[0]); } } if (k == 0) // prepare & execute { returncode = SQLPrepare(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } returncode = SQLExecute(hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } else // execdirect { returncode = SQLExecDirect(hstmt[i],StmtQueries(INSERT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } if (k == 0) // prepare & execute { returncode = SQLPrepare(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } returncode = SQLExecute(hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } else { returncode = SQLExecDirect(hstmt[i],StmtQueries(SELECT_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } returncode = SQLFetch(hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } } for (i = 0; i < NUM_STMT; i++) { returncode = SQLFreeStmt(hstmt[i],SQL_CLOSE); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } if (i == 0) { SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[20],StmtHndlStr),SQL_NTS); } returncode = SQLFreeStmt(hstmt[i],SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } TESTCASE_END; } //==================================================================================================== // Asynchronus Testcases if (MX_MP_SPECIFIC == MX_SPECIFIC) { for (i = 0; i < NUM_ASYNC_STMT; i++) { hstmt[i] = (SQLHANDLE)pTestInfo->hstmt; // Creating statement handles sprintf(Heading,"SQLAllocstmt: Test #%d and Enable the ASYNC MODE ON.\n",i); TESTCASE_BEGIN(Heading); returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } else { if (i == 0) // cleanup { // Creating tables to be used by each of the stmt handles for (j = 0; j < NUM_ASYNC_STMT; j++) { SQLExecDirect(hstmt[0],StmtQueries(DROP_TABLE,teststmthndl[j],StmtHndlStr),SQL_NTS); } } // Putting each stmthandle into Asynchronus mode returncode = SQLSetStmtOption(hstmt[i],SQL_ASYNC_ENABLE,SQL_ASYNC_ENABLE_ON); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtOptions")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } } TESTCASE_END; } // Running the Asynchronus tests // WHAT IS GOING ON // Two tests cases are being checked: // 1. That the status of an asynchronus stmt handle CAN be checked. // 2. That the stmt handle completes correctly. // // HOW IT'S BEING RUN // Steps being performed until all handles are no longer executing: // 1. Prepare the async test data structure. // 2. Generate table name based on statement handle being used. // 3. If handle's status has not been checked already, check as test case 1. // Else, check it's status NOT as a test case. // 4. Run the statement (also used to check the status of the handle). // 5. If the stmt completes, verify that it does so successfully. Test case 2. // // Once all of the handles have completed, perform the next Async Operation // until the terminating operation (a.k.a "999") is reached. k = 0; while (AsyncOper[k] != 999) { // 1. Preparing the async test data structure for (i = 0; i < NUM_ASYNC_STMT; i++) { AsyncStmt[i].status = SQL_STILL_EXECUTING; AsyncStmt[i].checked = FALSE; } AnyAsync = 1; // Testing begins while (AnyAsync > 0) { for (i = 0; i < NUM_ASYNC_STMT; i++) { if (AsyncStmt[i].status == SQL_STILL_EXECUTING) { // 3. Has the handle been checked for its status? if (AsyncStmt[i].checked) { // 4. Run the statement. returncode = SQLExecDirect(hstmt[i],StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr),SQL_NTS); AsyncStmt[i].status = returncode; // 5. Result Test: Verifying that the statement completes correctly. if (returncode != SQL_STILL_EXECUTING) { sprintf(Heading,"SQLAllocStmt: Result Test: %d; SQLStmt: %s.\n",i,StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr)); TESTCASE_BEGIN(Heading); if (returncode != SQL_SUCCESS) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; } } else { // Status Test (Test case 1): // Only EXECUTING and SUCCESS are acceptable, others are errors. // This test is only run once! sprintf(Heading,"SQLAllocStmt: Status Test: %d; SQLStmt: %s.\n",i,StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr)); TESTCASE_BEGIN(Heading); // 4. Run the statement. returncode = SQLExecDirect(hstmt[i],StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr),SQL_NTS); AsyncStmt[i].status = returncode; AsyncStmt[i].checked = TRUE; if ((returncode != SQL_STILL_EXECUTING) && (returncode != SQL_SUCCESS)) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; // 5. If the stmt completes, verify that it does so successfully. if (returncode != SQL_STILL_EXECUTING) { // Result Test: Verifying that the stmt completes successfully. sprintf(Heading,"SQLAllocStmt: Result Test: %d; SQLStmt: %s.\n",i,StmtQueries(AsyncOper[k],teststmthndl[i],StmtHndlStr)); TESTCASE_BEGIN(Heading); if (returncode != SQL_SUCCESS) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; } //Sleep (500); } } } AnyAsync = 0; for (i = 0; i < NUM_ASYNC_STMT; i++) { if (AsyncStmt[i].status == SQL_STILL_EXECUTING) { AnyAsync = AnyAsync + 1; } } } // Special tests for Fetching after doing a SELECT // Steps are identical to the above steps. if (AsyncOper[k] == SELECT_TABLE) { // Preparing data structure for (i = 0; i < NUM_ASYNC_STMT; i++) { AsyncStmt[i].status = SQL_STILL_EXECUTING; AsyncStmt[i].checked = FALSE; } AnyAsync = 1; // Select testing begins while (AnyAsync > 0) { for (i = 0; i < NUM_ASYNC_STMT; i++) { if (AsyncStmt[i].status == SQL_STILL_EXECUTING) { if (AsyncStmt[i].checked) { returncode = SQLFetch(hstmt[i]); AsyncStmt[i].status = returncode; if (returncode != SQL_STILL_EXECUTING) { // Result Test sprintf(Heading,"SQLAllocStmt: Result Test:%d; performing SQLFetch.\n",i); TESTCASE_BEGIN(Heading); if (returncode != SQL_SUCCESS) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; } } else { // Status Test sprintf(Heading,"SQLAllocStmt: Status Test:%d; performing SQLFetch.\n",i); TESTCASE_BEGIN(Heading); returncode = SQLFetch(hstmt[i]); AsyncStmt[i].status = returncode; AsyncStmt[i].checked = TRUE; if ((returncode != SQL_STILL_EXECUTING) && (returncode != SQL_SUCCESS)) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; // Result Test if (returncode != SQL_STILL_EXECUTING) { sprintf(Heading,"SQLAllocStmt: Result Test:%d; performing SQLFetch.\n",i); TESTCASE_BEGIN(Heading); if (returncode != SQL_SUCCESS) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; } } } } AnyAsync = 0; for (i = 0; i < NUM_ASYNC_STMT; i++) { if (AsyncStmt[i].status == SQL_STILL_EXECUTING) { AnyAsync = AnyAsync + 1; } } } // Closing the cursor from the SELECT stmt result set. for (i = 0; i < NUM_ASYNC_STMT; i++) { sprintf(Heading,"SQLFreeStmt: %d.\n",i); TESTCASE_BEGIN(Heading); returncode = SQLFreeStmt(hstmt[i],SQL_CLOSE); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt[i]); } TESTCASE_END; } } // End of async SELECT test. // Resetting the checked status for the next operation. for (i = 0; i < NUM_ASYNC_STMT; i++) { AsyncStmt[i].checked = FALSE; } k++; } } //==================================================================================================== free(StmtHndlStr); returncode = SQLDisconnect((SQLHANDLE)hdbc); if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect")) { TEST_FAILED; LogAllErrorsVer3(henv,hdbc,hstmt[0]); } // Free the open transactions. returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,SQL_ROLLBACK); Sleep(2); returncode=FullDisconnect(pTestInfo); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect")) { TEST_FAILED; LogAllErrorsVer3(henv,hdbc,hstmt[0]); } LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLAllocStmt.\n"); free_list(var_list); TEST_RETURN; }
/************************************************************************* ** do_select() ** ** Randomly chooses a record or subset of sequential records to be ** read from the specified table and then attempts to read them. *************************************************************************/ short do_select(table_description *tab_ptr,Bitmap *bmap_ptr, short requested_record_count,Boolean abort_flag) { long record_num; long last_record_num; long actual_record_count; long record_count; char *key_column_name; char fields[80]; char select_str[SQL_MAX_COMMAND_LENGTH]; char command_line[SQL_MAX_COMMAND_LENGTH]; RETCODE rc; ColumnInfo *pCol; HENV henv; HDBC hdbc; HSTMT hstmt; henv=tab_ptr->henv; hdbc=tab_ptr->hdbc; hstmt=tab_ptr->hstmt; // abort_flag=abort_flag; LogMsg(NONE,"\n"); /* search bitmap for a full block of the right size */ record_num=FindNextBitBlock(BIT_ON,bmap_ptr, LongRand((long)tab_ptr->max_records-1), CIRCULAR_SEARCH, requested_record_count,&record_count); /* if no records to read then nothing can be done */ if(record_num==BIT_NOT_FOUND) { if(gTrace){ LogMsg(0,"No records to select in %s\n",tab_ptr->pTable->TableName); if(gDebug) assert(FALSE); } return(SUCCESS); } /* build the SELECT statement used to read the records */ pCol=&(tab_ptr->pTable->ColPtr[tab_ptr->key_column_used]); strcpy(select_str,"SELECT %s FROM %s WHERE %s>=?p1"); rc=SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_LONG, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &record_num,0,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(henv,hdbc,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } last_record_num=record_num+record_count-1; if(last_record_num>tab_ptr->max_records){ strcat(select_str," OR %s<=?p2"); last_record_num-=tab_ptr->max_records; } else { strcat(select_str," AND %s<=?p2"); } LogMsg(TIMESTAMP+INFOMSG,"Selecting %lu records from %lu to %lu\n", record_count,record_num,last_record_num); rc=SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_LONG, pCol->pTypeInfo->SQLDataType,pCol->DataTypeLen,0, &last_record_num,0,NULL); if(!CHECKRC(SQL_SUCCESS,rc,"SQLBindParameter")){ LogAllErrors(henv,hdbc,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* handle case where key is SYSKEY */ key_column_name=pCol->CName; switch(tab_ptr->pTable->Organization){ case ENTRY_SEQ: case KEY_SEQ: strcpy(fields,"*"); break; case RELATIVE_TABLE: strcpy(fields,"SYSKEY,*"); break; } /* PREPARE the SELECT statement */ sprintf(command_line,select_str,fields,tab_ptr->pTable->TableName, key_column_name,key_column_name); /* provide trace information if flag set */ if(gTrace){ LogMsg(NONE," Parameter1=%ld, Parameter2=%ld\n",record_num,last_record_num); LogMsg(0," %s\n",command_line); } rc=SQLPrepare(hstmt,command_line,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,rc,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } /* execute the prepared SELECT statement to read each record */ rc=SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,rc,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } //>>>maybe should bind columns before doing the fetch // if(!(BindAllColumns(tab_ptr))) return(FAILURE); actual_record_count=0; while((rc>=SQL_SUCCESS)&&(rc!=SQL_NO_DATA)){ rc=SQLFetch(hstmt); if(rc!=SQL_NO_DATA){ if(!CHECKRC(SQL_SUCCESS,rc,"SQLFetch")){ LogAllErrors(henv,hdbc,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } actual_record_count++; /* >>> can't check abort bit since this transaction may have other...*/ /*...actions which set it */ /* once sucessfully read then mark bit in bitmap */ /* (just in case its out-of-date) */ SetBit(BIT_ON,bmap_ptr,record_num); } } /* check that no more than the records requested were read (sanity check) */ if((rc==SQL_NO_DATA)&&(actual_record_count>record_count)){ LogMsg(ERRMSG,"SELECT read %d but, should have read %d records\n", actual_record_count,record_count); if(gDebug) assert(FALSE); } rc=SQLFreeStmt(hstmt,SQL_CLOSE); if(!CHECKRC(SQL_SUCCESS,rc,"SQLFreeStmt")){ LogAllErrors(henv,hdbc,hstmt); if(gDebug) assert(FALSE); return(FAILURE); } if(gTrace){ LogMsg(0," -- %ld records selected\n",actual_record_count); } return(SUCCESS); }
/* --------------------------------------------------------- TestSQLDescribeCol for MP Specific --------------------------------------------------------- */ PassFail TestMXSQLDescribeCol(TestInfo *pTestInfo) { TEST_DECLARE; TCHAR Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv, hdbc, hstmt; UWORD icol; SWORD numcol, st, cs, cnull, cl, colsize = 2; SQLULEN cp; TCHAR cn[COLNAME_LEN]; TCHAR *colname[COL_LEN]; TCHAR *ExecDirStr[12]; TCHAR *colVal[2]; #ifndef _WM #ifdef UNICODE SWORD SQLType[] = {SQL_WCHAR,SQL_WVARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_WVARCHAR,SQL_BIGINT, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC, SQL_WCHAR,SQL_WVARCHAR,SQL_WVARCHAR,SQL_CHAR,SQL_VARCHAR,SQL_WVARCHAR}; SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,19,19,128,128,10,18,30,254,254,2000,1016,1016,2000}; SWORD ColScale[]= {0,0,6,6,0,0,0,0,0,0,0,6,0,0,0,6,0,128,5,5,10,0,0,0,0,0,0}; #else SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_VARCHAR,SQL_BIGINT, SQL_WCHAR,SQL_WVARCHAR,SQL_WVARCHAR, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC }; SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,254,127,2000,19,19,128,128,10,18,30}; SWORD ColScale[]= {0, 0, 6, 6, 0,0, 0,0, 0, 0, 0,6, 0, 0, 0, 0, 0, 0, 6, 0, 128,5, 5, 10}; #endif #else SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_CHAR,SQL_TIME,SQL_TIMESTAMP,SQL_LONGVARCHAR,SQL_BIGINT, SQL_WCHAR,SQL_WVARCHAR,SQL_WLONGVARCHAR, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC}; SQLULEN ColPrec[] = {254,127,18,18,5,10,7,15,15,8,8,26,2000,19,254,127,2000,19,19,128,128,10,18,30}; SWORD ColScale[]= {0,0,6,6,0,0,0,0,0,0,0,6,0,0,0,6,0,128,5,5,10,0,0,0,0,0,0}; #endif TCHAR TempType1[50],TempType2[50]; SWORD ColNullable[] = {SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE}; TCHAR *TestCase[] = { _T("before preparing stmt "), _T("before preparing & executing stmt "), _T("before preparing, executing & fetching stmt "), _T("before execdirect stmt "), _T("before execdirect & fetching stmt "), _T("before preparing param stmt "), _T("before preparing & binding stmt "), _T("before preparing, binding & executing stmt "), _T("before preparing, binding, executing & fetching stmt ") }; int lend = 9, iend = 3; SQLUSMALLINT i = 0, l = 0; SQLLEN cbIn = SQL_NTS; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLDescribeColumns"), charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); colname[0] = var_mapping(_T("SQLDescribeColumns_colname_1"), var_list); colname[1] = var_mapping(_T("SQLDescribeColumns_colname_2"), var_list); colname[2] = var_mapping(_T("SQLDescribeColumns_colname_3"), var_list); colname[3] = var_mapping(_T("SQLDescribeColumns_colname_4"), var_list); colname[4] = var_mapping(_T("SQLDescribeColumns_colname_5"), var_list); colname[5] = var_mapping(_T("SQLDescribeColumns_colname_6"), var_list); colname[6] = var_mapping(_T("SQLDescribeColumns_colname_7"), var_list); colname[7] = var_mapping(_T("SQLDescribeColumns_colname_8"), var_list); colname[8] = var_mapping(_T("SQLDescribeColumns_colname_9"), var_list); colname[9] = var_mapping(_T("SQLDescribeColumns_colname_10"), var_list); colname[10] = var_mapping(_T("SQLDescribeColumns_colname_11"), var_list); colname[11] = var_mapping(_T("SQLDescribeColumns_colname_12"), var_list); colname[12] = var_mapping(_T("SQLDescribeColumns_colname_13"), var_list); colname[13] = var_mapping(_T("SQLDescribeColumns_colname_14"), var_list); colname[14] = var_mapping(_T("SQLDescribeColumns_colname_15"), var_list); colname[15] = var_mapping(_T("SQLDescribeColumns_colname_16"), var_list); colname[16] = var_mapping(_T("SQLDescribeColumns_colname_17"), var_list); colname[17] = var_mapping(_T("SQLDescribeColumns_colname_18"), var_list); colname[18] = var_mapping(_T("SQLDescribeColumns_colname_19"), var_list); colname[19] = var_mapping(_T("SQLDescribeColumns_colname_20"), var_list); colname[20] = var_mapping(_T("SQLDescribeColumns_colname_21"), var_list); colname[21] = var_mapping(_T("SQLDescribeColumns_colname_22"), var_list); colname[22] = var_mapping(_T("SQLDescribeColumns_colname_23"), var_list); colname[23] = var_mapping(_T("SQLDescribeColumns_colname_24"), var_list); #ifdef UNICODE colname[24] = var_mapping(_T("SQLDescribeColumns_colname_25"), var_list); colname[25] = var_mapping(_T("SQLDescribeColumns_colname_26"), var_list); colname[26] = var_mapping(_T("SQLDescribeColumns_colname_27"), var_list); #endif ExecDirStr[0] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_1"), var_list); ExecDirStr[1] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_2"), var_list); ExecDirStr[2] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_3"), var_list); ExecDirStr[3] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_4"), var_list); ExecDirStr[4] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_5"), var_list); ExecDirStr[5] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_6"), var_list); ExecDirStr[6] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_7"), var_list); ExecDirStr[7] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_8"), var_list); ExecDirStr[8] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_9"), var_list); ExecDirStr[9] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_10"), var_list); ExecDirStr[10] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_11"), var_list); ExecDirStr[11] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_12"), var_list); colVal[0] = var_mapping(_T("SQLDescribeColumns_colVal_1"), var_list); colVal[1] = var_mapping(_T("SQLDescribeColumns_colVal_2"), var_list); //=========================================================================================================== //if(isUCS2) { // LogMsg(NONE,_T("Setup for UCS2 mode testing: ColPrec has to be doubled\n")); // l = sizeof(SQLType)/sizeof(SQLType[0]); // while(i < l) { // if(SQLType[i] == SQL_WCHAR) { // SQLType[i] = SQL_WCHAR; // //ColPrec[i] *= 2; --> This is in character, so no need to double // } // else if (SQLType[i] == SQL_WVARCHAR) { // SQLType[i] = SQL_WVARCHAR; // //ColPrec[i] *= 2; --> This is in character, so no need to double // } // else if (SQLType[i] == SQL_WLONGVARCHAR) { // SQLType[i] = SQL_WLONGVARCHAR; // //ColPrec[i] *= 2; --> This is in character, so no need to double // } // else { // } // i++; // } // i = 0; // l = 0; //} //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => MX Specific SQLDescribeColumns.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLDescribCol tests\n"); if(!FullConnect(pTestInfo)) { LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup for (l = 0; l < lend; l++) { for (i = 0; i < iend; i++) { //================================================================================== _stprintf(Heading,_T("SQLDescribeCol: Test #%d.%d\n"),l,i); TESTCASE_BEGINW(Heading); if ((i != (iend-1)) && (l < 5)) { SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ LogMsg(NONE,_T("%s\n"), ExecDirStr[i+iend]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { LogMsg(NONE,_T("SQLDescribeCol: %s\n"),TestCase[l]); LogMsg(NONE,_T(" %s\n"),ExecDirStr[i+iend+iend+iend]); switch( l ) { case 0: returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 1 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; case 2 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } break; case 3 : returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 4 : returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; } if (returncode == SQL_SUCCESS) { returncode=SQLNumResultCols(hstmt, &numcol); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (icol = 1; icol <= numcol; icol++) { LogMsg(LINEBEFORE,_T("SQLDescribeCol: checking Column #%d\n"),icol); returncode = SQLDescribeCol(hstmt,icol,(SQLTCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } colsize=_tcslen(colname[icol-1]); if(isCharSet == TRUE) colsize -= 2; if ((cwcscmp(cn,colname[icol-1],FALSE) == 0) && (cl == colsize) && (st == SQLType[icol-1]) && (cp == ColPrec[icol-1]) && (cs == ColScale[icol-1]) && (cnull == ColNullable[i])) { LogMsg(NONE,_T("colname expect: %s and actual: %s are matched\n"),colname[icol-1],cn); LogMsg(NONE,_T("ColNameLen expect: %d and actual: %d are matched\n"),colsize,cl); LogMsg(NONE,_T("SQLType expect: %s and actual: %s are matched\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); LogMsg(NONE,_T("ColPrec expect: %d and actual: %d are matched\n"),ColPrec[icol-1],cp); LogMsg(NONE,_T("ColScale expect: %d and actual: %d are matched\n"),ColScale[icol-1],cs); LogMsg(NONE,_T("ColNullable expect: %s and actual: %s are matched\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (cwcscmp(cn,colname[icol-1],FALSE) != 0) LogMsg(ERRMSG,_T("colname expect: %s and actual: %s are not matched line %d\n"),colname[icol-1],cn,__LINE__); if (cl != colsize) LogMsg(ERRMSG,_T("ColNameLen expect: %d and actual: %d are not matched line %d\n"),colsize,cl,__LINE__); if (st != SQLType[icol-1]) LogMsg(ERRMSG,_T("SQLType expect: %s and actual: %s are not matched line %d\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2),__LINE__); if (cp != ColPrec[icol-1]) LogMsg(ERRMSG,_T("ColPrec expect: %d and actual: %d are not matched line %d\n"),ColPrec[icol-1],cp,__LINE__); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,_T("ColScale expect: %d and actual: %d are not matched line %d\n"),ColScale[icol-1],cs,__LINE__); if (cnull != ColNullable[i]) LogMsg(ERRMSG,_T("ColNullable expect: %s and actual: %s are not matched line %d\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2),__LINE__); } } /* end icol loop */ } else { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */ } } } else if ((i == (iend-1)) && (l >= 5)) { SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ LogMsg(NONE,_T("%s\n"), ExecDirStr[i+iend]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { LogMsg(NONE,_T("SQLDescribeCol: %s\n"),TestCase[l]); LogMsg(NONE,_T(" %s\n"),ExecDirStr[i+iend+iend+iend]); switch( l ) { case 5 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 6 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; case 7 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; case 8 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } break; } if (returncode == SQL_SUCCESS) { SQLNumResultCols(hstmt, &numcol); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (icol = 1; icol <= numcol; icol++) { LogMsg(LINEBEFORE,_T("SQLDescribeCol: checking Column #%d\n"),icol); returncode = SQLDescribeCol(hstmt,icol,(SQLTCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } colsize=_tcslen(colname[icol-1]); if(isCharSet == TRUE) colsize -= 2; if ((cwcscmp(cn,colname[icol-1],FALSE) == 0) && (cl == colsize) && (st == SQLType[icol-1]) && (cp == ColPrec[icol-1]) && (cs == ColScale[icol-1]) && (cnull == ColNullable[i])) { LogMsg(NONE,_T("colname expect: %s and actual: %s are matched\n"),colname[icol-1],cn); LogMsg(NONE,_T("ColNameLen expect: %d and actual: %d are matched\n"),colsize,cl); LogMsg(NONE,_T("SQLType expect: %s and actual: %s are matched\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); LogMsg(NONE,_T("ColPrec expect: %d and actual: %d are matched\n"),ColPrec[icol-1],cp); LogMsg(NONE,_T("ColScale expect: %d and actual: %d are matched\n"),ColScale[icol-1],cs); LogMsg(NONE,_T("ColNullable expect: %s and actual: %s are matched\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (cwcscmp(cn,colname[icol-1],FALSE) != 0) LogMsg(ERRMSG,_T("colname expect: %s and actual: %s are not matched at line %d\n"),colname[icol-1],cn,__LINE__); if (cl != colsize) LogMsg(ERRMSG,_T("ColNameLen expect: %d and actual: %d are not matched at line %d\n"),colsize,cl,__LINE__); if (st != SQLType[icol-1]) LogMsg(ERRMSG,_T("SQLType expect: %s and actual: %s are not matched at line %d\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2),__LINE__); if (cp != ColPrec[icol-1]) LogMsg(ERRMSG,_T("ColPrec expect: %d and actual: %d are not matched at line %d\n"),ColPrec[icol-1],cp,__LINE__); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,_T("ColScale expect: %d and actual: %d are not matched at line %d\n"),ColScale[icol-1],cs,__LINE__); if (cnull != ColNullable[i]) LogMsg(ERRMSG,_T("ColNullable expect: %s and actual: %s are not matched at line %d\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2),__LINE__); } } } } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); } } TESTCASE_END; } /* iend loop */ } /* lend loop */ FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => MX Specific SQLDescribeColumns.\n")); free_list(var_list); TEST_RETURN; }
PassFail TestSQLDescribeParam(TestInfo *pTestInfo, int MX_MP_SPECIFIC) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; SWORD numparam; UWORD icol; SWORD st, SQLType[] = { SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,SQL_REAL, SQL_DOUBLE,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_BIGINT,SQL_LONGVARCHAR, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC }; // SQL_DOUBLE for SQL_FLOAT MX limitation //SQL_BIGINT replaced by SQL_NUMERIC in MX SWORD MPSQLType[] = { SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,SQL_REAL, SQL_FLOAT,SQL_FLOAT,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_BIGINT,SQL_LONGVARCHAR, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC }; SQLULEN cp; SQLULEN ColPrec[] = {10,10,10,10,5,10,7,15,15,10,8,26,19,2000,19,19,128,128,128,10,18,30}; SQLULEN MPColPrec[] = {10,10,10,10,5,10,7,15,15,10,8,26,19,10,19,19,128,128,128,10,18,30}; SWORD cs, cnull, ColScale[] = {0,0,5,5,0,0,0,0,0,0,0,6,0,0,0,6,0,128,64,5,5,10}; CHAR *DropStr[] = {"--","--","endloop"}; CHAR *CrtStr[] = {"--", "--", "endloop"}; CHAR *MPCrtStr[] = {"--", "--", "endloop"}; CHAR *ExecDirStr[] = {"--","--","--","--","--","--","--","--","--","--","endloop"}; char TempType1[50],TempType2[50]; SWORD ColNullable[] = {SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE,SQL_NO_NULLS}; CHAR *TestCase[] = { "before preparing stmt ", "endloop" }; SQLUSMALLINT i = 0, l = 0; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLDescribeParam", charset_file); if (var_list == NULL) return FAILED; //=====================Modified for Longvarchar Changes======================================================== if(!pTestInfo->bLongOn) { int i = 0; char *noLong = "SQL_VARCHAR"; SWORD iNoLong = SQL_VARCHAR; SQLType[13] = iNoLong; MPSQLType[13] = iNoLong; } //=====================Modified for Longvarchar Changes======================================================== //print_list(var_list); DropStr[0] = var_mapping("SQLDescribeParam_DropStr_1", var_list); DropStr[1] = var_mapping("SQLDescribeParam_DropStr_2", var_list); CrtStr[0] = var_mapping("SQLDescribeParam_CrtStr_1", var_list); CrtStr[1] = var_mapping("SQLDescribeParam_CrtStr_2", var_list); MPCrtStr[0] = var_mapping("SQLDescribeParam_MPCrtStr_1", var_list); MPCrtStr[1] = var_mapping("SQLDescribeParam_MPCrtStr_2", var_list); ExecDirStr[0] = var_mapping("SQLDescribeParam_ExecDirStr_1", var_list); ExecDirStr[1] = var_mapping("SQLDescribeParam_ExecDirStr_2", var_list); ExecDirStr[2] = var_mapping("SQLDescribeParam_ExecDirStr_3", var_list); ExecDirStr[3] = var_mapping("SQLDescribeParam_ExecDirStr_4", var_list); ExecDirStr[4] = var_mapping("SQLDescribeParam_ExecDirStr_5", var_list); ExecDirStr[5] = var_mapping("SQLDescribeParam_ExecDirStr_6", var_list); ExecDirStr[6] = var_mapping("SQLDescribeParam_ExecDirStr_7", var_list); ExecDirStr[7] = var_mapping("SQLDescribeParam_ExecDirStr_8", var_list); ExecDirStr[8] = var_mapping("SQLDescribeParam_ExecDirStr_9", var_list); ExecDirStr[9] = var_mapping("SQLDescribeParam_ExecDirStr_10", var_list); //================================================================================================= if(isUCS2) { LogMsg(NONE,"Setup for UCS2 mode testing: ColPrec has to be doubled\n"); l = sizeof(SQLType)/sizeof(SQLType[0]); while(i < l) { if(SQLType[i] == SQL_CHAR) { //SQLType[i] = SQL_WCHAR; ColPrec[i] *= 2; //--> This is in character, so no need to double } else if (SQLType[i] == SQL_VARCHAR) { //SQLType[i] = SQL_WVARCHAR; ColPrec[i] *= 2; //--> This is in character, so no need to double } else if (SQLType[i] == SQL_LONGVARCHAR) { //SQLType[i] = SQL_WLONGVARCHAR; ColPrec[i] *= 2; //--> This is in character, so no need to double } else { } i++; } i = 0; l = sizeof(MPSQLType)/sizeof(MPSQLType[0]); while(i < l) { if(MPSQLType[i] == SQL_CHAR) { //MPSQLType[i] = SQL_WCHAR; MPColPrec[i] *= 2; //--> This is in character, so no need to double } else if (MPSQLType[i] == SQL_VARCHAR) { //MPSQLType[i] = SQL_WVARCHAR; MPColPrec[i] *= 2; //--> This is in character, so no need to double } else if (MPSQLType[i] == SQL_LONGVARCHAR) { //MPSQLType[i] = SQL_WLONGVARCHAR; MPColPrec[i] *= 2; //--> This is in character, so no need to double } else { } i++; } i = 0; l = 0; } //=========================================================================================================== if (MX_MP_SPECIFIC == MX_SPECIFIC) LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX Specific SQLDescribeParam | SQLDescribeParam | desparam.c\n"); else LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MP Specific SQLDescribeParam | SQLDescribeParam | desparam.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLDescribeParam tests\n"); if(!FullConnect(pTestInfo)){ LogMsg(NONE,"Unable to connect\n"); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } i = 0; while (_stricmp(DropStr[i],"endloop") != 0) { SQLExecDirect(hstmt,(SQLCHAR*)DropStr[i],SQL_NTS); /* cleanup */ i++; } i = 0; if (MX_MP_SPECIFIC == MX_SPECIFIC) { while (_stricmp(CrtStr[i],"endloop") != 0) { returncode = SQLExecDirect(hstmt,(SQLCHAR*)CrtStr[i],SQL_NTS); /* create table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } //LogMsg(NONE,"%s\n", CrtStr[i]); i++; } } else { while (_stricmp(MPCrtStr[i],"endloop") != 0) { returncode = SQLExecDirect(hstmt,(SQLCHAR*)MPCrtStr[i],SQL_NTS); /* create table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } //LogMsg(NONE,"%s\n", MPCrtStr[i]); i++; } } TESTCASE_END; // end of setup l = 0; while (_stricmp(TestCase[l],"endloop") != 0) { i = 0; while (_stricmp(ExecDirStr[i],"endloop") != 0) { //================================================================================== sprintf(Heading,"SQLDescribeParam: Test #%d.%d\n",l,i); TESTCASE_BEGIN(Heading); returncode = SQLPrepare(hstmt,(SQLCHAR*)ExecDirStr[i], SQL_NTS); //LogMsg(NONE,"%s\n", ExecDirStr[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode=SQLNumParams(hstmt, &numparam); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } //LogMsg(NONE,"SQLNumParams returns %d\n", numparam); for (icol = 1; icol <= numparam; icol++) { LogMsg(LINEBEFORE,"SQLDescribeParam: checking Column #%d\n",icol); returncode = SQLDescribeParam(hstmt,icol,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeParam")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (MX_MP_SPECIFIC == MX_SPECIFIC) { if ((st==SQLType[icol-1]) && (cp==ColPrec[icol-1]) && (cs==ColScale[icol-1]) && (cnull==ColNullable[i])) { //LogMsg(NONE,"SQLType expect: %s and actual: %s are matched\n", // SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); //LogMsg(NONE,"ColPrec expect: %d and actual: %d are matched\n",ColPrec[icol-1],cp); //LogMsg(NONE,"ColScale expect: %d and actual: %d are matched\n",ColScale[icol-1],cs); //LogMsg(NONE,"ColNullable expect: %s and actual: %s are matched\n\n", // SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (st != SQLType[icol-1]) LogMsg(ERRMSG,"SQLType expect: %s and actual: %s are not matched\n",SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); if (cp != ColPrec[icol-1]) LogMsg(ERRMSG,"ColPrec expect: %d and actual: %d are not matched\n",ColPrec[icol-1],cp); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,"ColScale expect: %d and actual: %d are not matched\n",ColScale[icol-1],cs); if (cnull != ColNullable[i]) LogMsg(ERRMSG,"ColNullable expect: %s and actual: %s are not matched\n\n",SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } } else { if ((st==MPSQLType[icol-1]) && (cp==MPColPrec[icol-1]) && (cs==ColScale[icol-1]) && (cnull==ColNullable[i])) { //LogMsg(NONE,"SQLType expect: %s and actual: %s are matched\n", // SQLTypeToChar(MPSQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); //LogMsg(NONE,"ColPrec expect: %d and actual: %d are matched\n",MPColPrec[icol-1],cp); //LogMsg(NONE,"ColScale expect: %d and actual: %d are matched\n",ColScale[icol-1],cs); //LogMsg(NONE,"ColNullable expect: %s and actual: %s are matched\n\n", // SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (st != MPSQLType[icol-1]) LogMsg(ERRMSG,"SQLType expect: %s and actual: %s are not matched\n",SQLTypeToChar(MPSQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); if (cp != MPColPrec[icol-1]) LogMsg(ERRMSG,"ColPrec expect: %d and actual: %d are not matched\n",MPColPrec[icol-1],cp); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,"ColScale expect: %d and actual: %d are not matched\n",ColScale[icol-1],cs); if (cnull != ColNullable[i]) LogMsg(ERRMSG,"ColNullable expect: %s and actual: %s are not matched\n\n",SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } } } /* end icol loop */ } SQLFreeStmt(hstmt,SQL_CLOSE); i++; TESTCASE_END; } l++; } i = 0; while (_stricmp(DropStr[i],"endloop") != 0) { SQLExecDirect(hstmt,(SQLCHAR*)DropStr[i],SQL_NTS); /* cleanup */ i++; } FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => MX Specific SQLDescribeParam.\n"); free_list(var_list); TEST_RETURN; }
/* ------------------------------------------------------------------ TestSQLGetTypeInfo: Tests SQLGetTypeInfo ------------------------------------------------------------------ */ PassFail TestSQLGetTypeInfoR18(TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; char TempBuf[MAX_STRING_SIZE]; int j = 0,END_LOOP; struct { char *TYPE_NAME; SWORD DATA_TYPE; SDWORD PRECISION; char *LITERAL_PREFIX; char *LITERAL_SUFFIX; char *CREATE_PARAMS; SWORD NULLABLE; SWORD CASE_SENSITIVE; SWORD SEARCHABLE; SWORD UNSIGNED_ATTRIBUTE; SWORD MONEY; SWORD AUTO_INCREMENT; char *LOCAL_TYPE_NAME; SWORD MINIMUM_SCALE; SWORD MAXIMUM_SCALE; } TypeInfo[] = {//TYPENAME,DATATYPE,PREC,LITPRE,LITSUF,PARAM,NULL,CASE,SRCH,ATTR,MON,INC,LOC,MIN,MAX {"",SQL_ALL_TYPES,0,"","","",0,0,0,0,0,0,"",0,0}, // this is for get all types {"CHAR", SQL_CHAR, 254, "'", "'", "max length", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "CHARACTER", 0, 0}, {"VARCHAR", SQL_VARCHAR, 254, "'", "'", "max length", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "VARCHAR", 0, 0}, {"DECIMAL", SQL_DECIMAL, 18, "", "", "precision,scale", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DECIMAL", 0, 18}, {"NUMERIC", SQL_NUMERIC, 128, "", "", "precision,scale", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "NUMERIC", 0, 128}, {"SMALLINT", SQL_SMALLINT, 5, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "SMALLINT", 0, 0}, {"INTEGER", SQL_INTEGER, 10, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTEGER", 0, 0}, {"REAL", SQL_REAL, 7, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "REAL", 0, 0}, {"FLOAT", SQL_FLOAT, 15, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "FLOAT", 0, 0}, {"DOUBLE PRECISION", SQL_DOUBLE, 15, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DOUBLE", 0, 0}, // {"DATE", SQL_DATE, 10, "{d '", "'}","", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DATE", 0, 0}, // {"TIME", SQL_TIME, 8, "{t '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIME", 0, 0}, // {"TIMESTAMP", SQL_TIMESTAMP, 23, "{ts '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIMESTAMP", 0, 6}, {"DATE", SQL_TYPE_DATE, 10, "{d '", "'}","", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DATE", 0, 0}, {"TIME", SQL_TYPE_TIME, 8, "{t '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIME", 0, 0}, {"TIMESTAMP", SQL_TYPE_TIMESTAMP, 26, "{ts '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIMESTAMP", 0, 6}, {"BIGINT", SQL_BIGINT, 19, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "LARGEINT", 0, 0}, {"LONG VARCHAR", SQL_LONGVARCHAR, 4018, "'", "'", "", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "LONG VARCHAR", 0, 0}, // {"BINARY", SQL_BINARY, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0}, // {"VARBINARY", -3, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0}, // {"LONG VARBINARY", -4, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0}, // {"TINYINT", -6, 3, "", "", "", 1, 0, SQL_ALL_EXCEPT_LIKE, 1, 0, 0, "", 0, 0}, // {"BIT", -7, 1, "", "", "", 1, 0, SQL_UNSEARCHABLE, 0, 0, 0, "", 0, 0}, {"INTERVAL", SQL_INTERVAL_YEAR, 0, "{INTERVAL '", "' YEAR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_MONTH, 0, "{INTERVAL '", "' MONTH}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY, 0, "{INTERVAL '", "' DAY}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_HOUR, 0, "{INTERVAL '", "' HOUR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_MINUTE, 0, "{INTERVAL '", "' MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_SECOND, 0, "{INTERVAL '", "' SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_YEAR_TO_MONTH, 0, "{INTERVAL '", "' YEAR TO MONTH}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY_TO_HOUR, 0, "{INTERVAL '", "' DAY TO HOUR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY_TO_MINUTE, 0, "{INTERVAL '", "' DAY TO MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY_TO_SECOND, 0, "{INTERVAL '", "' DAY TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_HOUR_TO_MINUTE, 0, "{INTERVAL '", "' HOUR TO MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_HOUR_TO_SECOND, 0, "{INTERVAL '", "' HOUR TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_MINUTE_TO_SECOND, 0, "{INTERVAL '", "' MINUTE TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"",999,} }; char oTYPE_NAME[TYPE_LEN]; SWORD oDATA_TYPE, fSqlType1; SDWORD oPRECISION; char oLITERAL_PREFIX[TYPE_LEN]; char oLITERAL_SUFFIX[TYPE_LEN]; char oCREATE_PARAMS[TYPE_LEN]; SWORD oNULLABLE; SWORD oCASE_SENSITIVE; SWORD oSEARCHABLE; SWORD oUNSIGNED_ATTRIBUTE; SWORD oMONEY; SWORD oAUTO_INCREMENT; char oLOCAL_TYPE_NAME[TYPE_LEN]; SWORD oMINIMUM_SCALE; SWORD oMAXIMUM_SCALE; SQLLEN oTYPE_NAMElen; SQLLEN oDATA_TYPElen; SQLLEN oPRECISIONlen; SQLLEN oLITERAL_PREFIXlen; SQLLEN oLITERAL_SUFFIXlen; SQLLEN oCREATE_PARAMSlen; SQLLEN oNULLABLElen; SQLLEN oCASE_SENSITIVElen; SQLLEN oSEARCHABLElen; SQLLEN oUNSIGNED_ATTRIBUTElen; SQLLEN oMONEYlen; SQLLEN oAUTO_INCREMENTlen; SQLLEN oLOCAL_TYPE_NAMElen; SQLLEN oMINIMUM_SCALElen; SQLLEN oMAXIMUM_SCALElen; /* Set up some local variables to save on typing in longer ones */ /* This previously was R1.8 */ //================Modified for Longvarchar Changes=========================================================== if(!pTestInfo->bLongOn) { char *TYPE_NAME = "VARCHAR"; SWORD DATA_TYPE = SQL_VARCHAR; SDWORD PRECISION = 32000; char *CREATE_PARAMS = "max length"; char *LOCAL_TYPE_NAME = "VARCHAR"; TypeInfo[1].PRECISION = PRECISION; TypeInfo[2].PRECISION = PRECISION; TypeInfo[14].TYPE_NAME = TYPE_NAME; TypeInfo[14].DATA_TYPE = DATA_TYPE; TypeInfo[14].PRECISION = PRECISION; TypeInfo[14].CREATE_PARAMS = CREATE_PARAMS; TypeInfo[14].LOCAL_TYPE_NAME = LOCAL_TYPE_NAME; } //================Modified for Longvarhcar Changes=========================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API =>SQLGetTypeInfo30 | SQLGetTypeInfo3 | gettypeiR18.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLGetTypeInfo tests for ODBC 3.0\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,"Unable to connect\n"); TEST_FAILED; TEST_RETURN; } /* Set up some local variables to save on typing in longer ones */ henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")){ LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup //========================================================================================= /* if (MX_MP_SPECIFIC == MX_SPECIFIC) END_LOOP = SQL_BINARY; else if (MX_MP_SPECIFIC == MP_SPECIFIC) END_LOOP = 999; else { LogMsg(ERRMSG,"gettypeinfo test failed.\n"); TEST_RETURN; } */ END_LOOP = 999; j = 0; while (TypeInfo[j].DATA_TYPE != END_LOOP) { sprintf(Heading,"Test Positive functionality of SQLGetTypeInfo for data type: %s\n", SQLTypeToChar(TypeInfo[j].DATA_TYPE,TempBuf)); TESTCASE_BEGIN(Heading); returncode = SQLGetTypeInfo(hstmt,TypeInfo[j].DATA_TYPE); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetTypeInfo")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { if (TypeInfo[j].DATA_TYPE != 0) { strcpy(oTYPE_NAME,""); oDATA_TYPE = 0; oPRECISION = 0; strcpy(oLITERAL_PREFIX,""); strcpy(oLITERAL_SUFFIX,""); strcpy(oCREATE_PARAMS,""); oNULLABLE = 0; oCASE_SENSITIVE = 0; oSEARCHABLE = 0; oUNSIGNED_ATTRIBUTE = 0; oMONEY = 0; oAUTO_INCREMENT = 0; strcpy(oLOCAL_TYPE_NAME,""); oMINIMUM_SCALE = 0; oMAXIMUM_SCALE = 0; returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTYPE_NAME,TYPE_LEN,&oTYPE_NAMElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,2,SQL_C_SHORT,&oDATA_TYPE,0,&oDATA_TYPElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,3,SQL_C_LONG,&oPRECISION,0,&oPRECISIONlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oLITERAL_PREFIX,TYPE_LEN,&oLITERAL_PREFIXlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oLITERAL_SUFFIX,TYPE_LEN,&oLITERAL_SUFFIXlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oCREATE_PARAMS,TYPE_LEN,&oCREATE_PARAMSlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,7,SQL_C_SHORT,&oNULLABLE,0,&oNULLABLElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,8,SQL_C_SHORT,&oCASE_SENSITIVE,0,&oCASE_SENSITIVElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,9,SQL_C_SHORT,&oSEARCHABLE,0,&oSEARCHABLElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,10,SQL_C_SHORT,&oUNSIGNED_ATTRIBUTE,0,&oUNSIGNED_ATTRIBUTElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,11,SQL_C_SHORT,&oMONEY,0,&oMONEYlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,12,SQL_C_SHORT,&oAUTO_INCREMENT,0,&oAUTO_INCREMENTlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,13,SQL_C_CHAR,oLOCAL_TYPE_NAME,TYPE_LEN,&oLOCAL_TYPE_NAMElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,14,SQL_C_SHORT,&oMINIMUM_SCALE,0,&oMINIMUM_SCALElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,15,SQL_C_SHORT,&oMAXIMUM_SCALE,0,&oMAXIMUM_SCALElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { LogMsg(NONE,"Comparing results\n"); if ((_stricmp(TypeInfo[j].TYPE_NAME,oTYPE_NAME) == 0) && (TypeInfo[j].DATA_TYPE == oDATA_TYPE) && (TypeInfo[j].PRECISION == oPRECISION) && (_stricmp(TypeInfo[j].LITERAL_PREFIX,oLITERAL_PREFIX) == 0) && (_stricmp(TypeInfo[j].LITERAL_SUFFIX,oLITERAL_SUFFIX) == 0) && (_stricmp(TypeInfo[j].CREATE_PARAMS,oCREATE_PARAMS) == 0) && (TypeInfo[j].NULLABLE == oNULLABLE) && (TypeInfo[j].CASE_SENSITIVE == oCASE_SENSITIVE) && (TypeInfo[j].SEARCHABLE == oSEARCHABLE) && (TypeInfo[j].UNSIGNED_ATTRIBUTE == oUNSIGNED_ATTRIBUTE) && (TypeInfo[j].MONEY == oMONEY) && (TypeInfo[j].AUTO_INCREMENT == oAUTO_INCREMENT) && (_stricmp(TypeInfo[j].LOCAL_TYPE_NAME,oLOCAL_TYPE_NAME) == 0) && (TypeInfo[j].MINIMUM_SCALE == oMINIMUM_SCALE) && (TypeInfo[j].MAXIMUM_SCALE == oMAXIMUM_SCALE)) { //LogMsg(NONE,"Data Type Name actual: %s and expected: %s are matched\n",oTYPE_NAME,TypeInfo[j].TYPE_NAME); //LogMsg(NONE,"Data Type actual: %d and expected: %d are matched\n",oDATA_TYPE,TypeInfo[j].DATA_TYPE); //LogMsg(NONE,"Precision actual: %d and expected: %d are matched\n",oPRECISION,TypeInfo[j].PRECISION); //LogMsg(NONE,"Literal Prefix actual: %s and expected: %s are matched\n",oLITERAL_PREFIX,TypeInfo[j].LITERAL_PREFIX); //LogMsg(NONE,"Literal Suffix actual: %s and expected: %s are matched\n",oLITERAL_SUFFIX,TypeInfo[j].LITERAL_SUFFIX); //LogMsg(NONE,"Create Params actual: %s and expected: %s are matched\n",oCREATE_PARAMS,TypeInfo[j].CREATE_PARAMS); //LogMsg(NONE,"Nullable actual: %d and expected: %d are matched\n",oNULLABLE,TypeInfo[j].NULLABLE); //LogMsg(NONE,"Case sensitive actual: %d and expected: %d are matched\n",oCASE_SENSITIVE,TypeInfo[j].CASE_SENSITIVE); //LogMsg(NONE,"Searchable actual: %d and expected: %d are matched\n",oSEARCHABLE,TypeInfo[j].SEARCHABLE); //LogMsg(NONE,"Unsigned attribute actual: %d and expected: %d are matched\n",oUNSIGNED_ATTRIBUTE,TypeInfo[j].UNSIGNED_ATTRIBUTE); //LogMsg(NONE,"Money actual: %d and expected: %d are matched\n",oMONEY,TypeInfo[j].MONEY); //LogMsg(NONE,"Auto Increment actual: %d and expected: %d are matched\n",oAUTO_INCREMENT,TypeInfo[j].AUTO_INCREMENT); //LogMsg(NONE,"Local Type name actual: %s and expected: %s are matched\n",oLOCAL_TYPE_NAME,TypeInfo[j].LOCAL_TYPE_NAME); //LogMsg(NONE,"Minimum Scale actual: %d and expected: %d are matched\n",oMINIMUM_SCALE,TypeInfo[j].MINIMUM_SCALE); //LogMsg(NONE,"Maximum Scale actual: %d and expected: %d are matched\n",oMAXIMUM_SCALE,TypeInfo[j].MAXIMUM_SCALE); } else { TEST_FAILED; if (_stricmp(TypeInfo[j].TYPE_NAME,oTYPE_NAME) != 0) LogMsg(ERRMSG,"Data Type Name actual: %s and expected: %s are not matched\n",oTYPE_NAME,TypeInfo[j].TYPE_NAME); if (TypeInfo[j].DATA_TYPE != oDATA_TYPE) LogMsg(ERRMSG,"Data Type actual: %d and expected: %d are not matched\n",oDATA_TYPE,TypeInfo[j].DATA_TYPE); if (TypeInfo[j].PRECISION != oPRECISION) LogMsg(ERRMSG,"Precision actual: %d and expected: %d are not matched\n",oPRECISION,TypeInfo[j].PRECISION); if (_stricmp(TypeInfo[j].LITERAL_PREFIX,oLITERAL_PREFIX) != 0) LogMsg(ERRMSG,"Literal Prefix actual: %s and expected: %s are not matched\n",oLITERAL_PREFIX,TypeInfo[j].LITERAL_PREFIX); if (_stricmp(TypeInfo[j].LITERAL_SUFFIX,oLITERAL_SUFFIX) != 0) LogMsg(ERRMSG,"Literal Suffix actual: %s and expected: %s are not matched\n",oLITERAL_SUFFIX,TypeInfo[j].LITERAL_SUFFIX); if (_stricmp(TypeInfo[j].CREATE_PARAMS,oCREATE_PARAMS) != 0) LogMsg(ERRMSG,"Create Params actual: %s and expected: %s are not matched\n",oCREATE_PARAMS,TypeInfo[j].CREATE_PARAMS); if (TypeInfo[j].NULLABLE != oNULLABLE) LogMsg(ERRMSG,"Nullable actual: %d and expected: %d are not matched\n",oNULLABLE,TypeInfo[j].NULLABLE); if (TypeInfo[j].CASE_SENSITIVE != oCASE_SENSITIVE) LogMsg(ERRMSG,"Case sensitive actual: %d and expected: %d are not matched\n",oCASE_SENSITIVE,TypeInfo[j].CASE_SENSITIVE); if (TypeInfo[j].SEARCHABLE != oSEARCHABLE) LogMsg(ERRMSG,"Searchable actual: %d and expected: %d are not matched\n",oSEARCHABLE,TypeInfo[j].SEARCHABLE); if (TypeInfo[j].UNSIGNED_ATTRIBUTE != oUNSIGNED_ATTRIBUTE) LogMsg(ERRMSG,"Unsigned attribute actual: %d and expected: %d are not matched\n",oUNSIGNED_ATTRIBUTE,TypeInfo[j].UNSIGNED_ATTRIBUTE); if (TypeInfo[j].MONEY != oMONEY) LogMsg(ERRMSG,"Money actual: %d and expected: %d are not matched\n",oMONEY,TypeInfo[j].MONEY); if (TypeInfo[j].AUTO_INCREMENT != oAUTO_INCREMENT) LogMsg(ERRMSG,"Auto Increment actual: %d and expected: %d are not matched\n",oAUTO_INCREMENT,TypeInfo[j].AUTO_INCREMENT); if (_stricmp(TypeInfo[j].LOCAL_TYPE_NAME,oLOCAL_TYPE_NAME) != 0) LogMsg(ERRMSG,"Local Type name actual: %s and expected: %s are not matched\n",oLOCAL_TYPE_NAME,TypeInfo[j].LOCAL_TYPE_NAME); if (TypeInfo[j].MINIMUM_SCALE != oMINIMUM_SCALE) LogMsg(ERRMSG,"Minimum Scale actual: %d and expected: %d are not matched\n",oMINIMUM_SCALE,TypeInfo[j].MINIMUM_SCALE); if (TypeInfo[j].MAXIMUM_SCALE != oMAXIMUM_SCALE) LogMsg(ERRMSG,"Maximum Scale actual: %d and expected: %d are not matched\n",oMAXIMUM_SCALE,TypeInfo[j].MAXIMUM_SCALE); } } } } TESTCASE_END; SQLFreeStmt(hstmt,SQL_CLOSE); // This is a bug this should be after the inner for loop. j++; } //========================================================================================== TESTCASE_BEGIN("SQLGetTypeInfo: Negative test for invalid data type\n"); fSqlType1 = 50; returncode = SQLGetTypeInfo(hstmt,fSqlType1); if(!CHECKRC(SQL_ERROR,returncode,"SQLGetTypeInfo")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //========================================================================================= sprintf(Heading,"SQLGetTypeInfo: Negative test with invalid handle\n"); TESTCASE_BEGIN(Heading); hstmt = (SQLHANDLE)NULL; fSqlType1 = 1; returncode = SQLGetTypeInfo(hstmt,fSqlType1); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLGetTypeInfo")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //========================================================================================= FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLGetTypeInfo.\n"); TEST_RETURN; }
PassFail TestSQLAllocEnv(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; SQLHANDLE OldHenv; SQLHANDLE BadHenv; LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLAllocEnvirnoment.\n")); TEST_INIT; TESTCASE_BEGIN("Test basic functionality of SQLAllocEnv\n"); henv=(SQLHANDLE)NULL; returncode = SQLAllocEnv(&henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { /* Fatal error, no use running the remaining tests so, return */ TEST_FAILED; TEST_RETURN; } TESTCASE_END; TESTCASE_BEGIN("Test non-NULL handle value\n"); OldHenv=henv; returncode=SQLAllocEnv(&henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { SQLFreeEnv(OldHenv); LogMsg(ENDLINE,_T("Using a valid, non-NULL handle caused an error.\n")); /* Fatal error, no use running the remaining tests so, return */ TEST_FAILED; TEST_RETURN; } TESTCASE_END; TESTCASE_BEGIN("Negative test: Invalid handle pointer\n"); BadHenv=(SQLHANDLE)NULL; returncode=SQLAllocEnv((SQLHANDLE *)BadHenv); if(!CHECKRC(SQL_ERROR,returncode,"SQLAllocEnv")) { LogMsg(ENDLINE,_T("Invalid handle pointer works, it shouldn't.\n")); TEST_FAILED; } TESTCASE_END; TESTCASE_BEGIN("Test basic functionality of SQLFreeEnv\n"); returncode=SQLFreeEnv(OldHenv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeEnv")) { LogAllErrors(OldHenv,(SQLHANDLE)NULL,(SQLHANDLE)NULL); TEST_FAILED; } returncode=SQLFreeEnv(henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeEnv")) { LogAllErrors(henv,(SQLHANDLE)NULL,(SQLHANDLE)NULL); TEST_FAILED; } TESTCASE_END; /* // this is a bug in driver manager we cannot free already freed TESTCASE_BEGIN("Negative test: free an already freed handle\n"); returncode=SQLFreeEnv(henv); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLFreeEnv")) { LogMsg(ENDLINE,"Invalid handle didn't produce proper error."); TEST_FAILED } TESTCASE_END; */ LogMsg(SHORTTIMESTAMP+LINEBEFORE+LINEAFTER,_T("End testing API => SQLAllocEnvirnoment.\n")); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLGetDescRec --------------------------------------------------------- */ PassFail TestMXSQLGetDescRec(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt, hstmt1; //Common input params to the apis SQLHDESC hIrd, hImArd, hImIrd, hImApd, hImIpd, hExArd, hExApd; SWORD RecNumber = 0; //SQLGetDescRec: params SQLHDESC getDescRecHandle; //input SWORD getDescRecNumber; //input TCHAR getDescName[MAXLEN]; SWORD getNameMaxLength; //input; MAXLEN = 100 : defined in Common.h SWORD getDescNameActualLength; SQLSMALLINT getDescType; SWORD getDescIntervalCode; SQLLEN getDescOctectLength; SWORD getDescPrecision; SWORD getDescScale; SWORD getDescNullable; //SQLSetDescRec: params SQLHDESC setDescRecHandle; SQLSMALLINT setDescRecNumber; SQLSMALLINT setDescType; SQLSMALLINT setDescIntervalCode; SQLINTEGER setDescOctetLength; SQLSMALLINT setDescPrecision; SQLSMALLINT setDescScale; SQLPOINTER setDescDataPtr; SQLLEN setDescOctectLengthPtr; SQLLEN setDescIndicatorPtr; TCHAR setDescName[1]; SQLINTEGER setDescNullable = SQL_NULL_DATA; short int i; // Template for a Descriptor record typedef struct { // TCHAR DescName[MAXLEN]; TCHAR *DescName; short int DescType; short int DescDatetimeIntervalCode; short int DescOctetLength; short int DescPrecision; short int DescScale; void* DescDataPtr; short int DescOctectLengthPtr; short int DescIndicatorPtr; short int DescNullable; }DescRec; DescRec TestDataAPD[DATA_ARR_LEN] = { //APD // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; DescRec TestDataARD[DATA_ARR_LEN] = { //ARD // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; DescRec TestDataIPD[DATA_ARR_LEN] = { //IPD // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, 0, 0, 0, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, 0, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; DescRec TestDataIRD[DATA_ARR_LEN] = { //IRD can only be read // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; _tcscpy(setDescName, _T("")); // ================================================================================================================ // begin common test setup //================================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLSetDescRec and SQLGetDescRec.\n")); TEST_INIT; if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } //Explicit APD //allocate an Explicit APD desc returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } //Explicit ARD returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } //=============================================================================================================== // Begin Testing:Positive Test for Implicit APD //=============================================================================================================== //Get Implicit APD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hImApd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Implicit APD tests.\n")); TEST_FAILED; goto ExAPDtests; // transfers control to the next set of tests } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit APD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImApd ; setDescRecNumber = RecNumber; setDescType = TestDataAPD[i].DescType; setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataAPD[i].DescOctetLength; setDescPrecision = TestDataAPD[i].DescPrecision; setDescScale = TestDataAPD[i].DescScale; setDescDataPtr = TestDataAPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr; /*LogMsg(NONE,_T("SQLSetDescRec(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"), setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr, setDescOctectLengthPtr, setDescIndicatorPtr); */ returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec ")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //Get the Implicit APD Descriptor //LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n"); LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit APD.\n")); getDescRecHandle = hImApd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataAPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //begin checking APD values ---------- //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for APD //=============================================================================================================== // Begin Testing:Positive Test for Explicit APD //=============================================================================================================== ExAPDtests: ; // beginning next set of tests //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n"); //Get Explicit APD handle returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get Explicit APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Explicit APD tests.\n")); TEST_FAILED; //TEST_RETURN; goto ARDtests; // transfers control to the next set of tests } //associate with a statement returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, (SQLPOINTER)hExApd, SQL_IS_POINTER); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot set Explicit APD for statement.\n")); TEST_FAILED; } setDescRecHandle = hExApd ; for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecNumber = RecNumber; setDescType = TestDataAPD[i].DescType; setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataAPD[i].DescOctetLength; setDescPrecision = TestDataAPD[i].DescPrecision; setDescScale = TestDataAPD[i].DescScale; setDescDataPtr = TestDataAPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr; /*LogMsg(NONE,_T("SQLSetDescRect(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"), setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr, setDescOctectLengthPtr, setDescIndicatorPtr);*/ returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i); TEST_FAILED; //TEST_RETURN; continue; } //Get the Explicit APD Descriptor //LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n"); LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Explicit APD.\n")); getDescRecHandle = setDescRecHandle; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataAPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i); TEST_FAILED; continue; } //begin checking APD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for Explicit APD //=============================================================================================================== // Begin Testing: Statement reverts to Implicit APD after freeing Explicit Descriptor //=============================================================================================================== //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "SQLGetDescRec for Explicit-Implicit APD: statement reverts to implicit descriptor after explicit descriptor has been freed.\n"); //free Explicit APD returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExApd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for APD)")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("Cannot free explicit descriptor: Aborting Explicit-Implicit Descriptor tests.\n")); TEST_FAILED; goto ARDtests; // transfers control to the next set of tests } //Use the previously allocated Implicit APD handle getDescRecHandle = hImApd; TESTCASE_BEGIN("Test that the implicit descriptor get associated with statement after explicit descriptor has been freed.\n"); //set multiple Fields i = 0; RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecNumber = RecNumber; setDescType = TestDataAPD[i].DescType; setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataAPD[i].DescOctetLength; setDescPrecision = TestDataAPD[i].DescPrecision; setDescScale = TestDataAPD[i].DescScale; setDescDataPtr = TestDataAPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr; //Get the Implicit APD Descriptor LogMsg(NONE,_T("SQLGetDescRec: tests for Explicit-Implicit Descriptor.\n")); getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataAPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: tests for Explicit-Implicit APD: TestDataAPD['%d'].\n"),i); TEST_FAILED; //continue; } //begin checking APD values ---------- //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; //================================================================================================================== // Begin Testing: Positive Test for Implicit ARD //=================================================================================================================== ARDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n"); //Get Implicit ARD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImArd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n")); TEST_FAILED; goto ExARDtests; //go to next set of tests } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImArd ; setDescRecNumber = RecNumber; setDescType = TestDataARD[i].DescType; setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataARD[i].DescOctetLength; setDescPrecision = TestDataARD[i].DescPrecision; setDescScale = TestDataARD[i].DescScale; setDescDataPtr = TestDataARD[i].DescDataPtr; setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //Get the Implicit ARD Descriptor LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit ARD.\n")); getDescRecHandle = hImApd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataARD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; break; } //begin checking ARD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for ARD //================================================================================================================== // Begin Testing: Positive Test for Explicit ARD //=================================================================================================================== ExARDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n"); //Get Explicit ARD handle returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get explicit ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n")); TEST_FAILED; goto IPDtests; //go to next set of tests } //associate with a statement returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, (SQLPOINTER)hExArd, SQL_IS_POINTER); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot set Explicit ARD for statement.\n")); TEST_FAILED; } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hExArd ; setDescRecNumber = RecNumber; setDescType = TestDataARD[i].DescType; setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataARD[i].DescOctetLength; setDescPrecision = TestDataARD[i].DescPrecision; setDescScale = TestDataARD[i].DescScale; setDescDataPtr = TestDataARD[i].DescDataPtr; setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i); TEST_FAILED; continue; } //Get the Explicit ARD Descriptor LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Explicit ARD.\n")); getDescRecHandle = hExArd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataARD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i); TEST_FAILED; break; } //begin checking ARD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"), getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for Explicit ARD //free explicit ARD returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExArd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for ARD)")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } //====================================================================================================================== // Begin Testing: Positive Test for Implicit IPD //===================================================================================================================== IPDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n"); //Get Implicit IPD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImIpd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IPD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get IPD: Aborting Implicit IPD tests.\n")); TEST_FAILED; goto IRDtests; //go to next set of tests } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataIPD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImIpd ; setDescRecNumber = RecNumber; setDescType = TestDataIPD[i].DescType; setDescIntervalCode = TestDataIPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataIPD[i].DescOctetLength; setDescPrecision = TestDataIPD[i].DescPrecision; setDescScale = TestDataIPD[i].DescScale; setDescDataPtr = TestDataIPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataIPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataIPD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode, "SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //Get the Implicit IPD Descriptor LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Implicit IPD.\n")); getDescRecHandle = hImApd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataIPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //begin checking IPD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"), getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for IPD //================================================================================================================== // Begin Testing: Posituve Tests for IRD (IRD Desc Fields are read only) //================================================================================================================== IRDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IRD.\n"); //Get Implicit IRD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_ROW_DESC, &hImIrd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get IRD: Aborting Implicit IRD tests.\n")); TEST_FAILED; // TEST_RETURN; //this will abort tests and perform a full disconnect. } //--------------------------------------------------------------------------------------------------------- TESTCASE_BEGIN("Test SQLSetDescRec for Implicit IRD: IRD Descriptor Fields cannot be set by the application.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImIrd ; setDescRecNumber = RecNumber; setDescType = TestDataIRD[i].DescType; setDescIntervalCode = TestDataIRD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataIRD[i].DescOctetLength; setDescPrecision = TestDataIRD[i].DescPrecision; setDescScale = TestDataIRD[i].DescScale; setDescDataPtr = TestDataIRD[i].DescDataPtr; setDescOctectLengthPtr = TestDataIRD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataIRD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_ERROR,returncode,"SQLSetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; //------------------------------------------------------------------------------------------------------------- TESTCASE_BEGIN("Test SQLGetDescRec for Implicit IRD: IRD Descriptor Fields not populated before call to DB.\n"); //This testcases use the Implicit IRD handle obtained in previous testcase returncode = SQLGetDescRec(hImIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_NO_DATA_FOUND,returncode,"SQLGetDescField")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; //TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited. } TESTCASE_END; //=============================================================================================================== // Begin Testing:Positive Test for populated Implicit IRD //=============================================================================================================== TESTCASE_BEGIN("Test SQLGetDescRec for populated Implicit IRD.\n"); //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of (SQLSetDescRec) and SQLGetDescRec for Implicit IRD.\n"); //alloc new handle returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt1); LogMsg(ERRMSG,_T("Cannot allocate statement: Aborting populated Implicit IRD tests.\n")); FullDisconnect(pTestInfo); TEST_FAILED; goto Cleanup; // transfers control to the next set } //Get Implicit IRD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hIrd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IRD")) { LogAllErrorsVer3(henv,hdbc,hstmt1); LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting populated Implicit IRD tests.\n")); TEST_FAILED; goto Cleanup; // transfers control to the next set } //populate the IRD by executing an catalog api returncode = SQLGetTypeInfo(hstmt1, SQL_ALL_TYPES); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetTypeInfo: population of IRD")) { LogAllErrorsVer3(henv,hdbc,hstmt1); LogMsg(ERRMSG,_T("Cannot execute statement: Aborting populated Implicit IRD tests.\n")); TEST_FAILED; goto Cleanup; // transfers control to the next set } //check IRD returncode = SQLGetDescRec(hIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescField")) { LogAllErrorsVer3(henv,hdbc,hstmt1); TEST_FAILED; //TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited. } TESTCASE_END; // free implicitly allocated descriptors by freeing statement returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt1); TEST_FAILED; } //=========================================================================================================== // begin cleanup //============================================================================================================== Cleanup: ; // free implicitly allocated descriptors by freeing statement returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLSetDescRec and SQLGetDescRec.\n")); TEST_RETURN; } //end of test ****************
/* --------------------------------------------------------- TestSQLNumResultsCol --------------------------------------------------------- */ PassFail TestSQLNumResultCols(TestInfo *pTestInfo) { TEST_DECLARE; TCHAR Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; SWORD col; TCHAR *ExecDirStr[] = {_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--")}; TCHAR *TestCase[] = { _T("after preparing stmt "), _T("after preparing & executing stmt "), _T("after preparing, executing & fetching stmt "), _T("after execdirect stmt "), _T("after execdirect & fetching stmt "), _T("after preparing param stmt "), _T("after preparing & binding stmt "), _T("after preparing, binding & executing stmt "), _T("after preparing, binding, executing & fetching stmt ") }; int lend = 9, iend = 5; SQLUSMALLINT i = 0, l = 0; int expcol[] = {1,2,6,9,2}; SQLLEN cbIn = SQL_NTS; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLNumResultCols"), charset_file); if (var_list == NULL) return FAILED; ExecDirStr[0] = var_mapping(_T("SQLNumResultCols_ExecDirStr_0"), var_list); ExecDirStr[1] = var_mapping(_T("SQLNumResultCols_ExecDirStr_1"), var_list); ExecDirStr[2] = var_mapping(_T("SQLNumResultCols_ExecDirStr_2"), var_list); ExecDirStr[3] = var_mapping(_T("SQLNumResultCols_ExecDirStr_3"), var_list); ExecDirStr[4] = var_mapping(_T("SQLNumResultCols_ExecDirStr_4"), var_list); ExecDirStr[5] = var_mapping(_T("SQLNumResultCols_ExecDirStr_5"), var_list); ExecDirStr[6] = var_mapping(_T("SQLNumResultCols_ExecDirStr_6"), var_list); ExecDirStr[7] = var_mapping(_T("SQLNumResultCols_ExecDirStr_7"), var_list); ExecDirStr[8] = var_mapping(_T("SQLNumResultCols_ExecDirStr_8"), var_list); ExecDirStr[9] = var_mapping(_T("SQLNumResultCols_ExecDirStr_9"), var_list); ExecDirStr[10] = var_mapping(_T("SQLNumResultCols_ExecDirStr_10"), var_list); ExecDirStr[11] = var_mapping(_T("SQLNumResultCols_ExecDirStr_11"), var_list); ExecDirStr[12] = var_mapping(_T("SQLNumResultCols_ExecDirStr_12"), var_list); ExecDirStr[13] = var_mapping(_T("SQLNumResultCols_ExecDirStr_13"), var_list); ExecDirStr[14] = var_mapping(_T("SQLNumResultCols_ExecDirStr_14"), var_list); ExecDirStr[15] = var_mapping(_T("SQLNumResultCols_ExecDirStr_15"), var_list); ExecDirStr[16] = var_mapping(_T("SQLNumResultCols_ExecDirStr_16"), var_list); ExecDirStr[17] = var_mapping(_T("SQLNumResultCols_ExecDirStr_17"), var_list); ExecDirStr[18] = var_mapping(_T("SQLNumResultCols_ExecDirStr_18"), var_list); ExecDirStr[19] = var_mapping(_T("SQLNumResultCols_ExecDirStr_19"), var_list); //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API =>SQLNumResultcols.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLNumResultCols tests\n"); if(!FullConnect(pTestInfo)){ LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup for (l = 0; l < lend; l++){ for (i = 0; i < iend; i++){ //================================================================================== _stprintf(Heading,_T("Test Positive Functionality of SQLNumResultCols ")); _tcscat(Heading, TestCase[l]); _tcscat(Heading, ExecDirStr[i+iend+iend+iend]); _tcscat(Heading, _T("\n")); TESTCASE_BEGINW(Heading); if ((i != (iend-1)) && (l < 5)){ SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ switch( l ) { case 0: returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 1 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; case 2 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } break; case 3 : returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 4 : returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; } if (returncode == SQL_SUCCESS){ returncode = SQLNumResultCols(hstmt, &col); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } if (col == expcol[i]) { LogMsg(NONE,_T("expect: %d and actual: %d are matched\n"),expcol[i], col); } else { TEST_FAILED; LogMsg(NONE,_T("expect: %d and actual: %d are not matched\n"),expcol[i], col); } } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */ } } } else if ((i == (iend-1)) && (l >= 5)){ SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ switch( l ){ case 5 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 6 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("10"),300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindparameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("20"),300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } break; case 7 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("10"),300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindparameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("20"),300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } } break; case 8 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("10"),300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindparameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_INTEGER,0,0,(SQLPOINTER)_T("20"),300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } } } break; } if (returncode == SQL_SUCCESS){ returncode = SQLNumResultCols(hstmt, &col); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (col == expcol[i]) { LogMsg(NONE,_T("expect: %d and actual: %d are matched\n"),expcol[i], col); } else { TEST_FAILED; LogMsg(NONE,_T("expect: %d and actual: %d are not matched\n"),expcol[i], col); } } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */ } } } TESTCASE_END; } /* iend loop */ } /* lend loop */ FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLNumResultcols.\n")); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLExecute --------------------------------------------------------- */ PassFail TestSQLExecute(TestInfo *pTestInfo, int MX_MP_SPECIFIC) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; TCHAR *ExecStr[15]; TCHAR *szInput[] = {_T("Inst char"),_T("Inst vchar"),_T("1234.56789"),_T("1234.56789"),_T("1200"),_T("12000"),_T("123.45"),_T("123.45"),_T("123.45"),_T("1993-07-01"),_T("09:45:30"),_T("1993-08-02 08:44:31.001"),_T("120000"),_T("1234567890.56789"),_T("1234567890.456789"),_T("1234567890.456789"),_T("0.01234567890123456789"),_T("1234.56789"),_T("1234567890.56789"),_T("12345678901234567890.0123456789"),_T("Inst char"),_T("Inst vchar")}; SQLLEN cbInput = SQL_NTS; SQLUSMALLINT i = 0; SQLSMALLINT Type[] = {SQL_WCHAR,SQL_WVARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,SQL_REAL,SQL_FLOAT,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_BIGINT,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_WCHAR,SQL_WVARCHAR}; SQLUINTEGER ColPrec[] = {254,254,10,10,5,10,7,15,15,10,8,26,19,19,19,128,128,10,18,30,254,254}; SQLSMALLINT ColScale[]= {0,0,5,5,0,0,0,0,0,0,0,0,0,0,6,0,128,5,5,10,0,0}; short CCharOutput1,CCharOutput2; SQLLEN OutputLen1,OutputLen2; int actual_insert=0,num_insert=0; SWORD param = 0; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLExecute"), charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); ExecStr[0] = var_mapping(_T("SQLExecute_ExecStr_0"), var_list); ExecStr[1] = var_mapping(_T("SQLExecute_ExecStr_1"), var_list); ExecStr[2] = var_mapping(_T("SQLExecute_ExecStr_2"), var_list); ExecStr[3] = var_mapping(_T("SQLExecute_ExecStr_3"), var_list); ExecStr[4] = var_mapping(_T("SQLExecute_ExecStr_4"), var_list); ExecStr[5] = var_mapping(_T("SQLExecute_ExecStr_5"), var_list); ExecStr[6] = var_mapping(_T("SQLExecute_ExecStr_6"), var_list); ExecStr[7] = var_mapping(_T("SQLExecute_ExecStr_7"), var_list); ExecStr[8] = var_mapping(_T("SQLExecute_ExecStr_8"), var_list); ExecStr[9] = var_mapping(_T("SQLExecute_ExecStr_9"), var_list); ExecStr[10] = var_mapping(_T("SQLExecute_ExecStr_10"), var_list); ExecStr[11] = var_mapping(_T("SQLExecute_ExecStr_11"), var_list); ExecStr[12] = var_mapping(_T("SQLExecute_ExecStr_12"), var_list); ExecStr[13] = var_mapping(_T("SQLExecute_ExecStr_13"), var_list); ExecStr[14] = var_mapping(_T("SQLExecute_ExecStr_14"), var_list); //================================================================================================= LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLExecute.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLExecute tests\n"); if(!FullConnect(pTestInfo)){ LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[4],SQL_NTS); returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[5],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR *)ExecStr[6],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[7],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[8],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup TESTCASE_BEGIN("Test #1: Positive Functionality of SQLExecute\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR *)ExecStr[9],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,1,SQL_C_SHORT,&CCharOutput1,0,&OutputLen1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,2,SQL_C_SHORT,&CCharOutput2,0,&OutputLen2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } while (returncode != SQL_NO_DATA_FOUND) { returncode = SQLFetch(hstmt); if (returncode != SQL_NO_DATA_FOUND) { if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } } SQLFreeStmt(hstmt,SQL_CLOSE); returncode = SQLPrepare(hstmt,(SQLTCHAR *)ExecStr[10],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[4],SQL_NTS); TESTCASE_END; TESTCASE_BEGIN("Test #2: Positive Functionality of SQLExecute\n"); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[1],_tcslen(ExecStr[1])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; TESTCASE_BEGIN("Test #3: Positive Functionality of SQLExecute with SQL_NTS\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[2],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; TESTCASE_BEGIN("Test #4: Positive Functionality of SQLPrepare then SQLExecute twice\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[2],_tcslen(ExecStr[2])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; SQLFreeStmt(hstmt,SQL_CLOSE); SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt,SQL_RESET_PARAMS); TESTCASE_BEGIN("Test #5: Positive Functionality of SQLExecute with params\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[3],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ for (i = 0; i <= 3; i++){ if (i==0) Type[0] = 1; returncode = SQLBindParameter(hstmt,(SWORD)(i+1),SQL_PARAM_INPUT,SQL_C_TCHAR,Type[i],EXEC_LEN,0,szInput[i],0,&cbInput); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){ LogMsg(NONE,_T("Type[i]: %d \n"),Type[i]); LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } TESTCASE_END; TESTCASE_BEGIN("Test #6: Negative Functionality of SQLExecute with less params\n"); returncode = SQLFreeStmt(hstmt,SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[3],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,Type[0],EXEC_LEN,0,szInput[0],0,&cbInput); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_ERROR,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } } } TESTCASE_END; TESTCASE_BEGIN("Test #7: Negative Functionality of SQLExecute with not prepared stmt\n"); returncode = SQLFreeStmt(hstmt,SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_ERROR,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } TESTCASE_END; TESTCASE_BEGIN("Test #8: Negative Functionality of SQLExecute with invalid handle\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[2],_tcslen(ExecStr[2])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute((SQLHANDLE)NULL); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } TESTCASE_END; returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ TESTCASE_BEGIN("Test #9: Stress Positive Functionality of SQLExecute.\n"); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[12],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[13],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { actual_insert = 0; for (num_insert = 0; num_insert < MAX_INSERTED_ROWS; num_insert++) { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else actual_insert++; } if (actual_insert != MAX_INSERTED_ROWS) { TEST_FAILED; LogMsg(ERRMSG,_T("failed to insert rows actual => %d & excepted => %d.\n"),actual_insert,MAX_INSERTED_ROWS); } } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); TESTCASE_END; TESTCASE_BEGIN("Test #10: Stress Positive Functionality of SQLExecute with Params.\n"); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[12],SQL_NTS); LogMsg(NONE,_T("ExecStr[12]: %s\n"), ExecStr[12]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[14],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { actual_insert = 0; returncode = SQLNumParams(hstmt, ¶m); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumParams")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (num_insert = 0; num_insert < MAX_INSERTED_ROWS; num_insert++) { for (i = 0; i < param; i++) { if (i==0) Type[0] = 1; if (MX_MP_SPECIFIC == MX_SPECIFIC) { returncode = SQLBindParameter(hstmt,(SWORD)(i+1),SQL_PARAM_INPUT,SQL_C_TCHAR,Type[i],ColPrec[i],ColScale[i],szInput[i],0,&cbInput); } else { returncode = SQLBindParameter(hstmt,(SWORD)(i+1),SQL_PARAM_INPUT,SQL_C_TCHAR,Type[i],ColPrec[i],ColScale[i],szInput[i],300,&cbInput); } if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else actual_insert++; } if (actual_insert != MAX_INSERTED_ROWS) { TEST_FAILED; LogMsg(ERRMSG,_T("failed to insert rows actual => %d & excepted => %d.\n"),actual_insert,MAX_INSERTED_ROWS); } } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); TESTCASE_END; TESTCASE_BEGIN("Test #11: Negative Functionality of SQLExecute with already existing table\n"); returncode = SQLFreeStmt(hstmt,SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[1],_tcslen(ExecStr[1])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_ERROR,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ } } TESTCASE_END; //================================================================================================= FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLExecute.\n")); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLTransact --------------------------------------------------------- */ PassFail TestSQLTransact(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; TCHAR Heading[MAX_STRING_SIZE]; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; TCHAR *ExecDirStr[6]; UWORD fType[] = { SQL_ROLLBACK,SQL_COMMIT }; TCHAR *TypeDesc[] = { _T("SQL_ROLLBACK"),_T("SQL_COMMIT") }; TCHAR *Output; SQLLEN OutputLen; struct { SWORD ExeRes[2]; SWORD FetchRes[2]; TCHAR *DataRes[2]; } CheckRes[] = { {SQL_ERROR,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")}, {SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_SUCCESS,_T(""),_T("--")}, {SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,_T("--"),_T("--")}, {SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,_T("--"),_T("")}, {SQL_SUCCESS,SQL_ERROR,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")} }; int i = 0, j = 0, iend = 5, jend = 1, commit_on_off = 0; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLTransact"), charset_file); if (var_list == NULL) return FAILED; ExecDirStr[0] = var_mapping(_T("SQLTransact_ExecDirStr_0"), var_list); ExecDirStr[1] = var_mapping(_T("SQLTransact_ExecDirStr_1"), var_list); ExecDirStr[2] = var_mapping(_T("SQLTransact_ExecDirStr_2"), var_list); ExecDirStr[3] = var_mapping(_T("SQLTransact_ExecDirStr_3"), var_list); ExecDirStr[4] = var_mapping(_T("SQLTransact_ExecDirStr_4"), var_list); ExecDirStr[5] = var_mapping(_T("SQLTransact_ExecDirStr_5"), var_list); CheckRes[1].DataRes[1] = var_mapping(_T("SQLTransact_Insert"), var_list); CheckRes[2].DataRes[0] = var_mapping(_T("SQLTransact_Insert"), var_list); CheckRes[2].DataRes[1] = var_mapping(_T("SQLTransact_Update"), var_list); CheckRes[3].DataRes[0] = var_mapping(_T("SQLTransact_Update"), var_list); //======================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLTransact.\n")); TEST_INIT; TESTCASE_BEGIN("Initializing SQLTransact test environment\n"); // if(!FullConnect(pTestInfo)) { LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } for (commit_on_off = 0; commit_on_off < 10; commit_on_off++) { returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_ON); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption")) { LogAllErrors(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } TESTCASE_END; SQLExecDirect(hstmt, (SQLTCHAR*)ExecDirStr[4], SQL_NTS); /* CLEANUP */ for (i = 0; i <= (iend-1); i++) { _stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is ON and executing\n")); _tcscat(Heading, ExecDirStr[i]); _tcscat(Heading, _T("\n")); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */ returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,SQL_AUTOCOMMIT_OFF); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectOption")) { LogAllErrors(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } TESTCASE_END; for (i = 0; i <= (iend-1); i++) { for (j = 0; j <= jend; j++) { _stprintf(Heading,_T("Test Positive Functionality of SQLTransact while Autocommit is OFF and executing\n")); _tcscat(Heading, ExecDirStr[i]); _tcscat(Heading, _T(" & ")); _tcscat(Heading, TypeDesc[j]); _tcscat(Heading, _T("\n")); TESTCASE_BEGINW(Heading); //MAY 9, 2014 - TURNING AUTOCOMMIT ON FOR DDLs FOR TRAF, AS DDLs ARE NOT SUPPORTED WITH AUTOCOMMIT OFF if (i == 4 || i == 0) SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_ON); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); SQLSetConnectOption((SQLHANDLE)hdbc, SQL_AUTOCOMMIT, SQL_AUTOCOMMIT_OFF); if (!CHECKRC(SQL_SUCCESS, returncode, "SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,fType[j]); Sleep(2); // tmf rollback is slower. if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTransact")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[iend],SQL_NTS); if(!CHECKRC(CheckRes[i].ExeRes[j],returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { if (returncode == SQL_SUCCESS || returncode == SQL_SUCCESS_WITH_INFO) { Output = (TCHAR *)malloc(NAME_LEN); returncode=SQLBindCol(hstmt,1,SQL_C_TCHAR,Output,NAME_LEN,&OutputLen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(CheckRes[i].FetchRes[j],returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { if (returncode != SQL_NO_DATA_FOUND && returncode != SQL_ERROR) { if (_tcscspn(CheckRes[i].DataRes[j],Output) == 0) { LogMsg(NONE,_T("expect: %s and actual: %s are matched\n"),Output,CheckRes[i].DataRes[j]); } else { LogMsg(NONE,_T("expect: %s and actual: %s are not matched\n"),Output,CheckRes[i].DataRes[j]); TEST_FAILED; } } } free(Output); SQLFreeStmt(hstmt,SQL_CLOSE); } } } } TESTCASE_END; }/* end j loop */ }/* end i loop */ } //======================================================================================================== SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */ returncode = SQLDisconnect((SQLHANDLE)hdbc); if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } // Free the open transactions. returncode=SQLTransact((SQLHANDLE)henv,(SQLHANDLE)hdbc,SQL_ROLLBACK); Sleep(2); returncode=FullDisconnect(pTestInfo); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLTransact.\n")); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLMoreResults --------------------------------------------------------- */ PassFail TestSQLMoreResults(TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; CHAR *SetupStr[] = { "--", "--", "--", "--", "--", "--", "--", "endloop" }; CHAR *TestStr[] = { "--", "--", "--", "--", "--","endloop" }; int cnt, fail = 0; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLMoreResults", charset_file); if (var_list == NULL) return FAILED; SetupStr[0] = var_mapping("SQLMoreResults_SetupStr_0", var_list); SetupStr[1] = var_mapping("SQLMoreResults_SetupStr_1", var_list); SetupStr[2] = var_mapping("SQLMoreResults_SetupStr_2", var_list); SetupStr[3] = var_mapping("SQLMoreResults_SetupStr_3", var_list); SetupStr[4] = var_mapping("SQLMoreResults_SetupStr_4", var_list); SetupStr[5] = var_mapping("SQLMoreResults_SetupStr_5", var_list); SetupStr[6] = var_mapping("SQLMoreResults_SetupStr_6", var_list); TestStr[0] = var_mapping("SQLMoreResults_TestStr_0", var_list); TestStr[1] = var_mapping("SQLMoreResults_TestStr_1", var_list); TestStr[2] = var_mapping("SQLMoreResults_TestStr_2", var_list); TestStr[3] = var_mapping("SQLMoreResults_TestStr_3", var_list); TestStr[4] = var_mapping("SQLMoreResults_TestStr_4", var_list); //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API =>SQLMoreResults | SQLMoreResults | moreres.c\n"); TEST_INIT; returncode=FullConnect(pTestInfo); if (pTestInfo->hdbc == (SQLHANDLE)NULL) { TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if (returncode == SQL_SUCCESS) { cnt = 0; while (_stricmp(SetupStr[cnt],"endloop") != 0) { returncode = SQLExecDirect(hstmt,(SQLCHAR*) SetupStr[cnt],SQL_NTS); if (returncode == SQL_ERROR) fail++; cnt++; } if (fail != cnt) { cnt = 0; while (_stricmp(TestStr[cnt],"endloop") != 0) { sprintf(Heading,"Positive Test SQLMoreResults for "); strcat(Heading,TestStr[cnt]); strcat(Heading,"\n"); TESTCASE_BEGIN(Heading); returncode = SQLExecDirect(hstmt,(SQLCHAR*)TestStr[cnt],SQL_NTS); if (returncode == SQL_SUCCESS) { SQLFetch(hstmt); returncode=SQLMoreResults(hstmt); if(!CHECKRC(SQL_NO_DATA_FOUND,returncode,"SQLMoreResults")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } TESTCASE_END; cnt++; } SQLExecDirect(hstmt,(SQLCHAR*)SetupStr[0],SQL_NTS); // CLEANUP SQLExecDirect(hstmt,(SQLCHAR*)SetupStr[1],SQL_NTS); // CLEANUP } } //==============================================================================*/ FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLMoreResults.\n"); free_list(var_list); TEST_RETURN; }
PassFail TestSQLFetch(TestInfo *pTestInfo) { TEST_DECLARE; TCHAR Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; SQLUSMALLINT i, j, k, fn, h; SWORD col; TCHAR *CCharOutput1[MAX_NUM1], CCharOutput2[NAME_LEN]; SQLLEN OutputLen1[MAX_NUM1], OutputLen2; SQLSMALLINT CType[] = {SQL_C_TCHAR}; //TCHAR *TestCType[] = // { // "SQL_C_TCHAR","SQL_C_BINARY","SQL_C_SSHORT","SQL_C_USHORT","SQL_C_SHORT","SQL_C_SLONG", // "SQL_C_ULONG","SQL_C_FLOAT","SQL_C_DOUBLE","SQL_C_DATE","SQL_C_TIME","SQL_C_TIMESTAMP" // }; //TCHAR *TestSQLType[] = // { // "SQL_CHAR","SQL_VARCHAR","SQL_DECIMAL","SQL_NUMERIC","SQL_SMALLINT","SQL_INTEGER","SQL_REAL", // "SQL_FLOAT","SQL_DOUBLE","SQL_DATE","SQL_TIME","SQL_TIMESTAMP","SQL_BIGINT", // "SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL" // "SQL_LONGVARCHAR","SQL_WCHAR","SQL_WVARCHAR","SQL_WLONGVARCHAR" // }; TCHAR *ExecDirStr[5]; TCHAR *CResults[] = { #ifndef _WM _T("--"),_T("--"),_T("1234.56789"),_T("1234.56789"),_T("1200"),_T("12000"), _T("12345.0"),_T("123450.0"),_T("1234500.0"),_T("1993-07-01"),_T("09:45:30"), _T("1993-08-02 08:44:31.001000"),_T("120000"), _T("1234567890123456789"), _T("1234567890123.456789"), _T("1234567890123456789012345678901234567890"), _T("0.12345678901234567890123456789012345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), _T("1234567890.1234567890123456789012345678901234567890000000000000000000000000"), _T("12345.56789"), _T("1234567890123.56789"), _T("12345678901234567890.0123456789"), #ifdef UNICODE _T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--") #else _T("--"),_T("--"),_T("--"),_T("--") #endif #else _T("--"),_T("--"),_T("1234.56789"),_T("1234.56789"),_T("1200"),_T("12000"), _T("12345.0"),_T("123450.0"),_T("1234500.0"),_T("93/07/01"),_T("09:45:30"), _T("1993-08-02 08:44:31.001000"),_T("120000"), _T("1234567890123456789"), _T("1234567890123.456789"), _T("1234567890123456789012345678901234567890"), _T(".12345678901234567890123456789012345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), _T("1234567890.1234567890123456789012345678901234567890000000000000000000000000"), _T("12345.56789"), _T("1234567890123.56789"), _T("12345678901234567890.0123456789"), _T("--"),_T("--"),_T("--"),_T("--"),_T("--") #endif }; TCHAR *FetchNStr[5]; struct { SQLULEN AccessParam[2]; SQLULEN TransactParam[2]; } ConnOption = { SQL_MODE_READ_WRITE, SQL_MODE_READ_ONLY, SQL_TXN_READ_COMMITTED, SQL_TXN_READ_UNCOMMITTED }; struct _timeb fetchstarttime; struct _timeb fetchendtime; long AccessTime[2]; //Added for transaction isolation problems TCHAR *iso_level_cqd[] = { _T("control query default isolation_level 'READ_COMMITTED'"), _T("control query default isolation_level 'READ_UNCOMMITTED'"), _T("control query default isolation_level 'REPEATABLE_READ'"), _T("control query default isolation_level 'SERIALIZABLE'"), _T("endloop") }; TCHAR *access_mode[] = { _T("default"), _T("set transaction READ ONLY"), _T("set transaction READ WRITE"), _T("endloop") }; SQLTCHAR *sqlstring0 = (SQLTCHAR*)_T("DROP TABLE YRWK_TY_POS_2"); SQLTCHAR *sqlstring1 = (SQLTCHAR*)_T("CREATE TABLE YRWK_TY_POS_2 ( C1 NUMERIC (9, 2) , C2 NUMERIC (9, 2)) NO PARTITION"); SQLTCHAR *sqlstring2 = (SQLTCHAR*)_T("INSERT INTO YRWK_TY_POS_2 VALUES (119.28, 6)"); SQLTCHAR *sqlstring3 = (SQLTCHAR*)_T("SELECT SUM(C1) + SUM(C2) FROM YRWK_TY_POS_2"); //SQLTCHAR sqlstring0[] = _T("DROP TABLE YRWK_TY_POS_2"); //SQLTCHAR sqlstring1[] = _T("CREATE TABLE YRWK_TY_POS_2 ( C1 NUMERIC (9, 2) , C2 NUMERIC (9, 2)) NO PARTITION"); //SQLTCHAR sqlstring2[] = _T("INSERT INTO YRWK_TY_POS_2 VALUES (119.28, 6)"); //SQLTCHAR sqlstring3[] = _T("SELECT SUM(C1) + SUM(C2) FROM YRWK_TY_POS_2"); //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLFetch"), charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); ExecDirStr[0] = var_mapping(_T("SQLFetch_ExecDirStr_1"), var_list); ExecDirStr[1] = var_mapping(_T("SQLFetch_ExecDirStr_2"), var_list); ExecDirStr[2] = var_mapping(_T("SQLFetch_ExecDirStr_3"), var_list); ExecDirStr[3] = var_mapping(_T("SQLFetch_ExecDirStr_4"), var_list); ExecDirStr[4] = var_mapping(_T("SQLFetch_ExecDirStr_5"), var_list); CResults[0] = var_mapping(_T("SQLFetch_CResults_1"), var_list); CResults[1] = var_mapping(_T("SQLFetch_CResults_2"), var_list); #ifdef UNICODE CResults[21] = var_mapping(_T("SQLFetch_datastr1"), var_list); CResults[22] = var_mapping(_T("SQLFetch_datastr2"), var_list); CResults[23] = var_mapping(_T("SQLFetch_datastr3"), var_list); CResults[24] = var_mapping(_T("SQLFetch_CResults_24"), var_list); CResults[25] = var_mapping(_T("SQLFetch_CResults_25"), var_list); CResults[26] = var_mapping(_T("SQLFetch_CResults_26"), var_list); #else CResults[21] = var_mapping(_T("SQLFetch_CResults_21"), var_list); CResults[22] = var_mapping(_T("SQLFetch_CResults_22"), var_list); CResults[23] = var_mapping(_T("SQLFetch_CResults_23"), var_list); CResults[24] = var_mapping(_T("SQLFetch_CResults_24"), var_list); #endif FetchNStr[0] = var_mapping(_T("SQLFetch_FetchNStr_1"), var_list); FetchNStr[1] = var_mapping(_T("SQLFetch_FetchNStr_2"), var_list); FetchNStr[2] = var_mapping(_T("SQLFetch_FetchNStr_3"), var_list); FetchNStr[3] = var_mapping(_T("SQLFetch_FetchNStr_4"), var_list); FetchNStr[4] = var_mapping(_T("SQLFetch_FetchNStr_5"), var_list); //================================================================================================= LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API =>SQLFetch.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLFetch tests\n"); if(!FullConnect(pTestInfo)) { LogMsg(ERRMSG,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[0],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[1],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup for (i = 0; i < 1; i++) { // begin of 1st for loop _stprintf(Heading,_T("Test 1.%d: Positive functionality of SQLFetch by doing SQLBindcol\n"),i); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } for (j=0; j<MAX_NUM1; j++) { CCharOutput1[j] = (TCHAR *)malloc(sizeof(TCHAR)*NAME_LEN); *(CCharOutput1[j])=(TCHAR)'\0'; returncode = SQLBindCol(hstmt,(SWORD)(j+1),CType[i],CCharOutput1[j],NAME_LEN,&OutputLen1[j]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { for (j=0; j<MAX_NUM1; j++) { if (_tcscmp(CCharOutput1[j],CResults[j]) == 0) { LogMsg(NONE,_T("expect: '%s' and actual: '%s' of column %d are matched\n"),CResults[j],CCharOutput1[j],j+1); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '%s' and actual: '%s' of column %d are not match, at line %d\n"), CResults[j],CCharOutput1[j],j+1,__LINE__); } free(CCharOutput1[j]); } } SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; } // end of 1st for loop //============================================================================================ TESTCASE_BEGIN("Setup for more SQLFetch tests\n"); SQLFreeStmt(hstmt,SQL_DROP); SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; for (i = 0; i < 1; i++) { _stprintf(Heading,_T("Test 2.%d: Positive functionality of SQLFetch by doing SQLGetData\n"),i); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { for (j=0; j<MAX_NUM1; j++) { returncode = SQLGetData(hstmt,(SWORD)(j+1),CType[i],CCharOutput2,NAME_LEN,&OutputLen2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetData")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (_tcscmp(CCharOutput2,CResults[j]) == 0) { LogMsg(NONE,_T("expect: '%s' and actual: '%s' of column %d are matched\n"), CResults[j],CCharOutput2,j+1); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '%s' and actual: '%s' of column %d are not match, at line %d\n"),CResults[j],CCharOutput2,j+1,__LINE__); } } } SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; } //============================================================================================ for (fn = 0; fn < NUM_FETCH_LOOP; fn++) { _stprintf(Heading,_T("Setup for Fetch %d tests\n"),(ROWS_INSERTED*(fn+1))); TESTCASE_BEGINW(Heading); SQLFreeStmt(hstmt,SQL_DROP); SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); SQLSetConnectOption((SQLHANDLE)hdbc,SQL_ACCESS_MODE,SQL_MODE_READ_WRITE); SQLSetConnectOption((SQLHANDLE)hdbc,SQL_TXN_ISOLATION,SQL_TXN_READ_COMMITTED); SQLExecDirect(hstmt,(SQLTCHAR*) FetchNStr[0],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)FetchNStr[1],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } for (i = 0; i < (ROWS_INSERTED*(fn+1)); i++) { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)FetchNStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } } TESTCASE_END; // end of setup _stprintf(Heading,_T("Test Positive functionality of Fetch %d by doing SQLBindcol\n"),(ROWS_INSERTED*(fn+1))); TESTCASE_BEGINW(Heading); for (k = 0; k < 2; k++) { returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_ACCESS_MODE,ConnOption.AccessParam[k]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnection Access")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_TXN_ISOLATION,ConnOption.TransactParam[k]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnection Transact")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } returncode = SQLSetStmtOption(hstmt,SQL_ROWSET_SIZE,1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtOption")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)FetchNStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLNumResultCols(hstmt, &col); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (j = 0; j < col; j++) { CCharOutput1[j] = (TCHAR *)malloc(NAME_LEN); *(CCharOutput1[j])=(TCHAR)'\0'; returncode = SQLBindCol(hstmt,(SWORD)(j+1),SQL_C_TCHAR,CCharOutput1[j],NAME_LEN,&OutputLen1[j]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } } // end of 2nd for loop returncode = SQL_SUCCESS; _ftime(&fetchstarttime); j = 0; while (returncode == SQL_SUCCESS) { returncode = SQLFetch(hstmt); if((returncode != SQL_SUCCESS) && (j < col)) // need to make sure we haven't fallen off the end of the table { if (returncode == SQL_NO_DATA_FOUND) { if (!FindError(_T("00000"),henv,hdbc,hstmt)) // SQLState should be "00000" when return code is SQL_NO_DATA_FOUND. { TEST_FAILED; //assert(0); LogMsg(NONE,_T("Rows #: %d : array %d suppose to be %d at line %d.\n"),j,k, (ROWS_INSERTED*(fn+1)),__LINE__); LogAllErrors(henv,hdbc,hstmt); } } else { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } if (returncode == SQL_SUCCESS) j++; } _ftime(&fetchendtime); if (j == (ROWS_INSERTED*(fn+1))) { LogMsg(NONE,_T("Rows inserted Expected: %d and Actual: %d.\n"),(ROWS_INSERTED*(fn+1)),j); } else { TEST_FAILED; LogMsg(ERRMSG,_T("Rows inserted Expected: %d and Actual: %d at line%d.\n"),(ROWS_INSERTED*(fn+1)),j,__LINE__); } AccessTime[k] = (long)(((fetchendtime.time - fetchstarttime.time) * 1000) + (fetchendtime.millitm - fetchstarttime.millitm)); for (j = 0; j < col; j++) { free(CCharOutput1[j]); } // end of 3rd for loop SQLFreeStmt(hstmt,SQL_CLOSE); } /* if (AccessTime[0] >= AccessTime[1]) { LogMsg(NONE,_T("FETCH ONE: %d millisecs and FETCH N: %d millisecs.\n"),AccessTime[0],AccessTime[1]); } else { TEST_FAILED; LogMsg(ERRMSG,_T("FETCH ONE: %d millisecs and FETCH N: %d millisecs.\n"),AccessTime[0],AccessTime[1]); } */ LogMsg(NONE,_T("FETCH ONE: %d millisecs and FETCH N: %d millisecs.\n"),AccessTime[0],AccessTime[1]); TESTCASE_END; SQLSetConnectOption((SQLHANDLE)hdbc,SQL_ACCESS_MODE,SQL_MODE_READ_WRITE); SQLSetConnectOption((SQLHANDLE)hdbc,SQL_TXN_ISOLATION,SQL_TXN_READ_COMMITTED); SQLExecDirect(hstmt,(SQLTCHAR*) FetchNStr[0],SQL_NTS); /* cleanup */ } SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[0],SQL_NTS); /* cleanup */ //===================================================================================================== TESTCASE_BEGIN("Setup for SQLFetch isolation level tests\n"); SQLFreeStmt(hstmt,SQL_DROP); SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[0],SQL_NTS);/*clean up*/ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[1], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; i = 0; k = 0; while (_tcsicmp(iso_level_cqd[k],_T("endloop")) != 0) { h = 0; while (_tcsicmp(access_mode[h],_T("endloop")) != 0) { if ((_tcsstr(iso_level_cqd[k],_T("READ_UNCOMMITTED")) != NULL && _tcsstr(access_mode[h],_T("READ WRITE")) != NULL) || (_tcsstr(iso_level_cqd[k],_T("REPEATABLE_READ")) != NULL && _tcsstr(access_mode[h],_T("default")) != NULL) || (_tcsstr(iso_level_cqd[k],_T("SERIALIZABLE")) != NULL && _tcsstr(access_mode[h],_T("default")) != NULL)) { h++; continue; } FullDisconnect(pTestInfo); _stprintf(Heading, _T("Setup for SQLFetch with: %s\nAnd access-mode: %s\n"), iso_level_cqd[k], access_mode[h]); TESTCASE_BEGINW(Heading); if(!FullConnect(pTestInfo)) { LogMsg(ERRMSG,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)iso_level_cqd[k],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } if (_tcsicmp(access_mode[h],_T("default")) != 0) { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)access_mode[h],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } } TESTCASE_END; // end of setup _stprintf(Heading,_T("SQLFetch by doing SQLGetData\n")); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; //TEST_RETURN; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { for (j=0; j<MAX_NUM1; j++) { returncode = SQLGetData(hstmt,(SWORD)(j+1),CType[i],CCharOutput2,NAME_LEN,&OutputLen2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetData")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (_tcscmp(CCharOutput2,CResults[j]) == 0) { LogMsg(NONE,_T("expect: '%s' and actual: '%s' of column %d are matched\n"),CResults[j],CCharOutput2,j+1); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '%s' and actual: '%s' of column %d are not match, at line %d\n"),CResults[j],CCharOutput2,j+1,__LINE__); } } } SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; h++; } k++; }//End while SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[0],SQL_NTS); /* cleanup */ //============================================================================================ TESTCASE_BEGIN("Testcase for Mode_special_1\n"); returncode = SQLExecDirect(hstmt,sqlstring0,SQL_NTS); returncode = SQLExecDirect(hstmt,sqlstring1,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,sqlstring2,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLPrepare(hstmt,sqlstring3,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBindCol(hstmt,1,SQL_C_TCHAR,CCharOutput2,300,NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } #ifndef _WM if (_tcscmp(CCharOutput2,_T("125.2")) == 0) { LogMsg(NONE,_T("expect: '125.2' and actual: '%s' are matched\n"),CCharOutput2); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '125.2' and actual: '%s' are not match, at line %d\n"),CCharOutput2,__LINE__); } #else if (_tcscmp(CCharOutput2,"125.28") == 0) { LogMsg(NONE,_T("expect: '125.28' and actual: '%s' are matched\n"),CCharOutput2); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '125.28' and actual: '%s' are not match, at line %d\n"),CCharOutput2,__LINE__); } #endif //============================================================================================ FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLFetch.\n")); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLEndTran --------------------------------------------------------- */ PassFail TestMXSQLEndTran(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; TCHAR Heading[MAX_STRING_SIZE]; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; TCHAR *ExecDirStr[] = { //"create table testtransact(c1 TCHAR(20),c2 integer)", //"create table testtransact(c1 TCHAR(20),c2 integer) NO PARTITION", // The NO PARTITION is to help speed up this test on NEO/clustered systems with POS turned on. _T("--"), _T("--"), _T("--"), _T("--"), _T("--"), _T("--") }; UWORD fType[] = { SQL_ROLLBACK, SQL_COMMIT }; TCHAR *TypeDesc[] = { _T("SQL_ROLLBACK"), _T("SQL_COMMIT") }; TCHAR *Output; SQLLEN OutputLen; // sushil struct { SWORD ExeRes[2]; SWORD FetchRes[2]; TCHAR *DataRes[2]; } CheckRes[] = { {SQL_ERROR,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")}, {SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,SQL_SUCCESS,_T(""),_T("--")}, {SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,_T("--"),_T("--")}, {SQL_SUCCESS,SQL_SUCCESS,SQL_SUCCESS,SQL_NO_DATA_FOUND,_T("--"),_T("")}, {SQL_SUCCESS,SQL_ERROR,SQL_NO_DATA_FOUND,SQL_NO_DATA_FOUND,_T(""),_T("")} }; int i = 0, j = 0, iend = 5, jend = 1, commit_on_off = 0; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLEndTran"), charset_file); if (var_list == NULL) return FAILED; ExecDirStr[0] = var_mapping(_T("SQLEndTran_ExecDirStr_0"), var_list); ExecDirStr[1] = var_mapping(_T("SQLEndTran_ExecDirStr_1"), var_list); ExecDirStr[2] = var_mapping(_T("SQLEndTran_ExecDirStr_2"), var_list); ExecDirStr[3] = var_mapping(_T("SQLEndTran_ExecDirStr_3"), var_list); ExecDirStr[4] = var_mapping(_T("SQLEndTran_ExecDirStr_4"), var_list); ExecDirStr[5] = var_mapping(_T("SQLEndTran_ExecDirStr_5"), var_list); CheckRes[1].DataRes[1] = var_mapping(_T("SQLEndTran_Insert"), var_list); CheckRes[2].DataRes[0] = var_mapping(_T("SQLEndTran_Insert"), var_list); CheckRes[2].DataRes[1] = var_mapping(_T("SQLEndTran_Update"), var_list); CheckRes[3].DataRes[0] = var_mapping(_T("SQLEndTran_Update"), var_list); //======================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLEndTran.\n")); TEST_INIT; TESTCASE_BEGIN("Initializing SQLEndTran test environment\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } //setting CQD to set POS OFF,as some tests fail otherwise. (to be fixed) //SQLExecDirect (hstmt,"CONTROL QUERY DEFAULT POS 'OFF'",SQL_NTS); for (commit_on_off = 0; commit_on_off < 10; commit_on_off++) { returncode = SQLSetConnectAttr((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,(void *)SQL_AUTOCOMMIT_ON,0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectAttr")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } TESTCASE_END; SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */ for (i = 0; i <= (iend-1); i++) { _stprintf(Heading,_T("Test Positive Functionality of SQLEndTran while Autocommit is ON and executing\n")); _tcscat(Heading, ExecDirStr[i]); _tcscat(Heading, _T("\n")); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */ returncode = SQLSetConnectAttr((SQLHANDLE)hdbc,SQL_AUTOCOMMIT,(void *)SQL_AUTOCOMMIT_OFF,0); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnectAttr")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } TESTCASE_END; for (i = 0; i <= (iend-1); i++) { for (j = 0; j <= jend; j++) { _stprintf(Heading,_T("Test Positive Functionality of SQLEndTran while Autocommit is OFF and executing\n")); _tcscat(Heading, ExecDirStr[i]); _tcscat(Heading, _T(" & ")); _tcscat(Heading, TypeDesc[j]); _tcscat(Heading, _T("\n")); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode=SQLEndTran(SQL_HANDLE_DBC,(SQLHANDLE)hdbc,fType[j]); Sleep(2); // tmf rollback is slower. if(!CHECKRC(SQL_SUCCESS,returncode,"SQLTransact")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[iend],SQL_NTS); if(!CHECKRC(CheckRes[i].ExeRes[j],returncode,"SQLExecDirect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { if (returncode == SQL_SUCCESS || returncode == SQL_SUCCESS_WITH_INFO) { Output = (TCHAR *)malloc(NAME_LEN); returncode=SQLBindCol(hstmt,1,SQL_C_TCHAR,Output,NAME_LEN,&OutputLen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(CheckRes[i].FetchRes[j],returncode,"SQLFetch")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } else { if (returncode != SQL_NO_DATA_FOUND && returncode != SQL_ERROR) { if (_tcscspn(CheckRes[i].DataRes[j],Output) == 0) { //LogMsg(NONE,_T("expect: %s and actual: %s are matched\n"),Output,CheckRes[i].DataRes[j]); } else { LogMsg(ERRMSG,_T("expect: %s and actual: %s are not matched at line %d \n"),Output,CheckRes[i].DataRes[j],__LINE__); TEST_FAILED; } } } free(Output); SQLFreeStmt(hstmt,SQL_CLOSE); } } } } //SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; }/* end i loop */ //SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */ }/* end j loop */ } //======================================================================================================== SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); /* CLEANUP */ returncode = SQLDisconnect((SQLHANDLE)hdbc); if(!CHECKRC(SQL_ERROR,returncode,"SQLDisconnect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } // Free the open transactions. returncode=SQLEndTran(SQL_HANDLE_DBC,(SQLHANDLE)hdbc,SQL_ROLLBACK); Sleep(2); returncode=FullDisconnect3(pTestInfo); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFullDisconnect")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLEndTran.\n")); free_list(var_list); TEST_RETURN; }
/*********************************************************************** ** CreateSQLTable() ** ** This function creates the SQL tables (and some day indexes and views) ** which don't already exist and will be used by the processes. ************************************************************************/ short CreateSQLTable(TableDescription *table_ptr) { char command_line[SQL_MAX_COMMAND_LENGTH]; char *StringPtr; NomadInfo *NPtr; TableInfo *TPtr; TableInfo *TempTPtr; ReturnStatus *RSPtr; RETCODE rc; HENV henv; HDBC hdbc; HSTMT hstmt; short table_num; NPtr=table_ptr->NomadInfoPtr; TPtr=table_ptr->TableInfoPtr; RSPtr=NULL; henv=table_ptr->henv; hdbc=table_ptr->hdbc; hstmt=table_ptr->hstmt; printf("NOMAD: creating SQL table '%s'\n",TPtr->TableName); /* First, make sure any old SQL tables are deleted */ /* handle the case where NOPURGEUNTIL and SECURE */ /* are set so that we can't drop the tables */ /* sprintf(command_line,"ALTER TABLE %s SECURE 'OOOO' " "NOPURGEUNTIL 01 JAN 1980",TPtr->Tname); blank_pad(command_line,SQL_MAX_COMMAND_LENGTH); exec sql EXECUTE IMMEDIATE :command_line; if((sqlcode!=0)&&(sqlcode!=SQL_TABLE_NOT_FOUND)){ //>>> handle error somehow sql_error(); } */ // now drop the tables (ignore errors since we don't care if table are there or not) sprintf(command_line,"DROP TABLE %s",TPtr->TableName); rc=SQLExecDirect(hstmt,command_line,SQL_NTS); sprintf(command_line,"DROP TABLE %sV",TPtr->TableName); rc=SQLExecDirect(hstmt,command_line,SQL_NTS); /* handle creation like an existing table */ if(strlen(NPtr->like_name)!=0){ sprintf(command_line,"CREATE TABLE %s LIKE %s", TPtr->TableName,NPtr->like_name); rc=SQLExecDirect(hstmt,command_line,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,rc,"SQLExecDirect")){ printf("%s return code=%d on %s\n",g_errstr,rc,command_line); LogAllErrors(henv,hdbc,hstmt); return(FAILURE); } } /* handle creation of a new table from scratch */ else { StringPtr=BuildCreateTableString(TPtr); if(strlen(StringPtr)==0) return(FAILURE); strncpy(g_CommandLine,StringPtr,sizeof(g_CommandLine)); rc=SQLExecDirect(hstmt,g_CommandLine,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,rc,"SQLExecDirect")){ printf("%s return code=%d\n",g_errstr,rc); LogAllErrors(henv,hdbc,hstmt); if(gDebug) assert(FALSE); FormatForSQLCI(StringPtr); return(FAILURE); } free(StringPtr); } // get info about table we just created if(TPtr->Organization==KEY_SEQ){ TempTPtr=GetTableInfo(hdbc,TPtr->TableName,FALSE,&RSPtr); } else{ TempTPtr=GetTableInfo(hdbc,TPtr->TableName,TRUE,&RSPtr); } FreeTableInfo(TPtr); TPtr=TempTPtr; table_ptr->TableInfoPtr=TempTPtr; RSPtr=FindRequiredColumns(table_ptr); if(RSPtr!=NULL){ printf("ReturnType=%d ReturnCode=%d\n%s\n%s\n", RSPtr->ReturnType,RSPtr->ReturnCode, RSPtr->Message1,RSPtr->Message2); return(FAILURE); } /* add the table name to the list (if it's already in... */ /* ...the list then only its number is returned) */ table_num=add_table(TPtr->TableName); if(table_num<0) { printf("%s Problem with table '%s'\n",g_errstr,TPtr->TableName); return(FAILURE); } return(SUCCESS); } /* end: CreateSQLTable() */
/* --------------------------------------------------------- TestSQLProcedures --------------------------------------------------------- */ PassFail TestMXSQLProcedures(TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_HEADING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; CHAR *ProcStr; CHAR *myTestSch = "ODBC_PROC_TEST"; CHAR createSchStr[128]; CHAR setSchStr[128]; CHAR dropSchStr[128]; CHAR ProcName[NAME_LEN]; CHAR ServerName[NAME_LEN]; char SerName[4]; SQLSMALLINT serLen; SWORD ProcType = SQL_PT_PROCEDURE; CHAR opqua[NAME_LEN],opowner[NAME_LEN],opname[NAME_LEN],oremark[REM_LEN]; SWORD onuminpar,onumoutpar,onumresset,optype; SQLLEN opqualen,opownerlen,opnamelen,onuminparlen,onumoutparlen,onumressetlen,oremarklen,optypelen; struct { CHAR *DropProc; CHAR *CrtProc; } CreateProc[] = { {"DROP PROCEDURE N4210_REG", "CREATE PROCEDURE N4210_REG (IN IN1 TIME) EXTERNAL NAME 'Procs.N4210' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"}, {"DROP PROCEDURE N4260_REG", "CREATE PROCEDURE N4260_REG (IN IN1 REAL, INOUT INOUT1 INTEGER) EXTERNAL NAME 'Procs.N4260' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"}, {"DROP PROCEDURE N4261_REG", "CREATE PROCEDURE N4261_REG (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4261' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"}, {"DROP PROCEDURE N4264_REG", "CREATE PROCEDURE N4264_REG (IN IN1 VARCHAR(30), OUT OUT1 VARCHAR(45)) EXTERNAL NAME 'Procs.N4264' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"}, {"DROP PROCEDURE N4267_REG", "CREATE PROCEDURE N4267_REG (IN IN1 NUMERIC, INOUT INOUT1 REAL) EXTERNAL NAME 'Procs.N4267' EXTERNAL PATH '/home/SQFQA/SPJRoot/odbctest_spjs' LANGUAGE JAVA PARAMETER STYLE JAVA NO SQL NO ISOLATE"}, {"endloop","endloop"} }; struct { CHAR *ProcName; SDWORD NumInParams; SDWORD NumOutParams; SDWORD NumResSet; CHAR *Remark; } Procedure[] = { {"N4210_REG",0,0,0,""}, {"N4260_REG",0,0,0,""}, {"N4261_REG",0,0,0,""}, {"N4264_REG",0,0,0,""}, {"N4267_REG",0,0,0,""}, {"endloop",0,0,0,""} }; int i = 0, k = 0; //=========================================================================================================== // Initialization Test Case LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => MX Specific SQLProcedures | SQLProcedures | MXProc.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLProcedures tests\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,"Unable to connect\n"); TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect3(pTestInfo); TEST_RETURN; } returncode = SQLGetInfo(hdbc, SQL_SERVER_NAME, (SQLPOINTER)&ServerName, NAME_LEN, &serLen); strncpy(SerName, ServerName+1, 3); SerName[3] = '\0'; /* sq: This test calls SQLProcedures() with wildcard characters. It * needs its own empty schema to create the procedures, Otherwise the * standard schema that everybody uses may already have other procedures * created and will be returned by SQLProcedures() to confuse the test. */ sprintf (createSchStr, "CREATE SCHEMA %s.%s", pTestInfo->Catalog, myTestSch); sprintf (setSchStr, "SET SCHEMA %s.%s", pTestInfo->Catalog, myTestSch); sprintf (dropSchStr, "DROP SCHEMA %s.%s cascade", pTestInfo->Catalog, myTestSch); returncode = SQLExecDirect(hstmt,(SQLCHAR*) dropSchStr,SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLCHAR*) createSchStr,SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLCHAR*) setSchStr,SQL_NTS); ProcStr = (char *)malloc(MAX_NOS_SIZE); while (_stricmp(CreateProc[i].DropProc,"endloop") != 0) { sprintf(ProcStr,"%s",CreateProc[i].DropProc); returncode = SQLExecDirect(hstmt,(SQLCHAR*) ProcStr,SQL_NTS); // cleanup sprintf(ProcStr,"%s",CreateProc[i].CrtProc); replace_str(ProcStr,"$$$",SerName); sprintf(Heading,"Procedure => %s\n",ProcStr); TESTCASE_BEGIN(Heading); returncode = SQLExecDirect(hstmt,(SQLCHAR*)ProcStr,SQL_NTS); if(returncode != SQL_SUCCESS) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; i++; } sprintf(Heading,"Test Positive Functionality of SQLProcedures \n"); TESTCASE_BEGIN(Heading); returncode = SQLProcedures(hstmt,(SQLCHAR*)pTestInfo->Catalog,(SWORD)strlen(pTestInfo->Catalog),(SQLCHAR*)myTestSch/*pTestInfo->Schema*/,(SWORD)strlen(myTestSch/*pTestInfo->Schema*/),(SQLCHAR *)"%",(SWORD)1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLProcedures")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (returncode == SQL_SUCCESS) { strcpy(opqua,""); strcpy(opowner,""); strcpy(opname,""); onuminpar = 0; onumoutpar = 0; onumresset = 0; strcpy(oremark,""); optype = 0; SQLBindCol(hstmt,1,SQL_C_CHAR,opqua,NAME_LEN,&opqualen); SQLBindCol(hstmt,2,SQL_C_CHAR,opowner,NAME_LEN,&opownerlen); SQLBindCol(hstmt,3,SQL_C_CHAR,opname,NAME_LEN,&opnamelen); SQLBindCol(hstmt,4,SQL_C_SHORT,&onuminpar,0,&onuminparlen); SQLBindCol(hstmt,5,SQL_C_SHORT,&onumoutpar,0,&onumoutparlen); SQLBindCol(hstmt,6,SQL_C_SHORT,&onumresset,0,&onumressetlen); SQLBindCol(hstmt,7,SQL_C_CHAR,oremark,NAME_LEN,&oremarklen); SQLBindCol(hstmt,8,SQL_C_SHORT,&optype,0,&optypelen); k = 0; i = 0; while (returncode == SQL_SUCCESS) { if(strcmp(Procedure[i].ProcName,"endloop") == 0) break; returncode = SQLFetch(hstmt); if((returncode!=SQL_NO_DATA_FOUND) &&(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch"))) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { if (returncode == SQL_SUCCESS) { k++; sprintf(Heading,"SQLProcedures: Comparing Results\n"); TESTCASE_BEGIN(Heading); if ((_stricmp(pTestInfo->Catalog,opqua) == 0) && (_stricmp(myTestSch/*pTestInfo->Schema*/,opowner) == 0) && (_stricmp(Procedure[i].ProcName,opname) == 0) && (Procedure[i].NumInParams == onuminpar) && (Procedure[i].NumOutParams == onumoutpar) && (Procedure[i].NumResSet == onumresset) && (_stricmp(Procedure[i].Remark,oremark) == 0) && (ProcType == optype)) { //LogMsg(NONE,"Catalog Name expect: %s and actual: %s are matched\n",pTestInfo->Catalog,opqua); //LogMsg(NONE,"Schema Name expect: %s and actual: %s are matched\n",pTestInfo->Schema,opowner); //LogMsg(NONE,"ProcName expect: %s and actual: %s are matched\n",Procedure[i].ProcName,opname); //LogMsg(NONE,"NumInParams expect: %d and actual: %d are matched\n",Procedure[i].NumInParams,onuminpar); //LogMsg(NONE,"NumOutParams expect: %d and actual: %d are matched\n",Procedure[i].NumOutParams,onumoutpar); //LogMsg(NONE,"NumResSet expect: %d and actual: %d are matched\n",Procedure[i].NumResSet, onumresset); //LogMsg(NONE,"Remark expect: %s and actual: %s are matched\n",Procedure[i].Remark,oremark); //LogMsg(NONE,"ProcType expect: %d and actual: %d are matched\n",ProcType,optype); } else { TEST_FAILED; if (_stricmp(pTestInfo->Catalog,opqua) != 0) LogMsg(ERRMSG,"Catalog Name expect: %s and actual: %s are not matched\n",pTestInfo->Catalog,opqua); if (_stricmp(myTestSch/*pTestInfo->Schema*/,opowner) != 0) LogMsg(ERRMSG,"Schema Name expect: %s and actual: %s are not matched\n",myTestSch/*pTestInfo->Schema*/,opowner); if (_stricmp(Procedure[i].ProcName,opname) != 0) LogMsg(ERRMSG,"ProcName expect: %s and actual: %s are not matched\n",Procedure[i].ProcName,opname); if (Procedure[i].NumInParams != onuminpar) LogMsg(ERRMSG,"NumInParams expect: %d and actual: %d are not matched\n",Procedure[i].NumInParams,onuminpar); if (Procedure[i].NumOutParams != onumoutpar) LogMsg(ERRMSG,"NumOutParams expect: %d and actual: %d are not matched\n",Procedure[i].NumOutParams,onumoutpar); if (Procedure[i].NumResSet != onumresset) LogMsg(ERRMSG,"NumResSet expect: %d and actual: %d are not matched\n",Procedure[i].NumResSet, onumresset); if (_stricmp(Procedure[i].Remark,oremark) != 0) LogMsg(ERRMSG,"Remark expect: %s and actual: %s are not matched\n",Procedure[i].Remark,oremark); if (ProcType != optype) LogMsg(ERRMSG,"ProcType expect: %d and actual: %d are not matched\n",ProcType,optype); } } } if(k == 0) { TEST_FAILED; LogMsg(ERRMSG,"No Data Found => Atleast one row should be fetched\n"); } TESTCASE_END; i++; } // while } SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt,SQL_CLOSE); //======================================================================================================== sprintf(Heading,"SQLProcedures: Negative test with NULL handle\n"); TESTCASE_BEGIN(Heading); hstmt = (SQLHANDLE)NULL; strcpy(ProcName,"junkproc"); returncode = SQLProcedures(hstmt,(SQLCHAR*)pTestInfo->Catalog,(SWORD)strlen(pTestInfo->Catalog),(SQLCHAR*)myTestSch/*pTestInfo->Schema*/,(SWORD)strlen(myTestSch/*pTestInfo->Schema*/),(SQLCHAR*)ProcName,(SWORD)strlen(ProcName)); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLProcedures")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLExecDirect(hstmt,(SQLCHAR*) dropSchStr,SQL_NTS); TESTCASE_END; //======================================================================================================== free(ProcStr); FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => MX Specific SQLProcedures.\n"); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLError Minimum tests since this is tested all over the places --------------------------------------------------------- */ PassFail TestSQLError(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; CHAR SqlState[STATE_SIZE]; SDWORD NativeError; CHAR ErrorMsg[MAX_STRING_SIZE]; SWORD ErrorMsglen; CHAR *CrtTab = "--"; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars("SQLError", charset_file); if (var_list == NULL) return FAILED; CrtTab = var_mapping("SQLError_CrtTab", var_list); //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API =>SQLError | SQLError | error.c\n"); TEST_INIT; returncode=FullConnect(pTestInfo); if (pTestInfo->hdbc == (SQLHANDLE)NULL) { TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if (returncode == SQL_SUCCESS) { TESTCASE_BEGIN("Test syntax while creating a table SQLError\n"); returncode = SQLExecDirect(hstmt,(SQLCHAR*)CrtTab,SQL_NTS); if (returncode == SQL_ERROR) { returncode = SQLError((SQLHANDLE)henv, (SQLHANDLE)hdbc, hstmt, (SQLCHAR*)SqlState, &NativeError, (SQLCHAR*)ErrorMsg, MAX_STRING_SIZE, &ErrorMsglen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLError")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { LogMsg(NONE,"SqlState: %s and ErrorMsg: %s\n",SqlState,ErrorMsg); TESTCASE_END; } } } FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLError.\n"); free_list(var_list); TEST_RETURN; }
/* --------------------------------------------------------- TestSQLBrowseConnect --------------------------------------------------------- */ PassFail TestSQLBrowseConnect(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv = (SQLHANDLE)NULL, henv1[NUM_ENV_HND]; SQLHANDLE hdbc = (SQLHANDLE)NULL, badhdbc, hdbc1[NUM_ENV_HND * NUM_CONN_HND]; SQLHANDLE hstmt = (SQLHANDLE)NULL; SQLCHAR szConnStrIn[BRWS_LEN], szConnStrOut[BRWS_LEN]; char connstr[BRWS_LEN]; char tstConnStr[BRWS_LEN]; SWORD cbConnStrOut; int i = 0, j = 0; LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API => SQLBrowseConnect | SQLBrowseConnect | browse.c\n"); TEST_INIT; //========================================================================================== TESTCASE_BEGIN("Test Negative Functionality of SQLBrowseConnect: Invalid CONN handle pointer\n"); badhdbc = (SQLHANDLE)NULL; //strcpy(connstr,""); //strcat(connstr,"DSN="); //strcat(connstr,pTestInfo->DataSource); //strcat(connstr,";"); //strcat(connstr,"UID="); //strcat(connstr,pTestInfo->UserID); //strcat(connstr,";"); //strcat(connstr,"PWD="); //strcat(connstr,pTestInfo->Password); //strcat(connstr,";"); strcpy(connstr,""); sprintf(connstr, "DSN=%s;UID=%s;PWD=%s;",pTestInfo->DataSource,pTestInfo->UserID,pTestInfo->Password); strcpy((char*)szConnStrIn,""); strcat((char*)szConnStrIn,connstr); returncode = SQLBrowseConnect(badhdbc, szConnStrIn, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLDisconnect(badhdbc); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Negative Functionality of SQLBrowseConnect: NULL szConnStrIn\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc, NULL, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_ERROR,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Negative Functionality of SQLBrowseConnect: Invalid szConnStrIn length\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc, szConnStrIn, (SWORD)(strlen(pTestInfo->DataSource)+4), szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_NEED_DATA,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Negative Functionality of SQLBrowseConnect: zero length\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc, szConnStrIn,0, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_ERROR,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Negative Functionality of SQLBrowseConnect: Invalid DSN\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } strcpy(connstr,""); strcat(connstr,"DSN="); strcat(connstr,"baddsn"); strcat(connstr,";"); strcat(connstr,"UID="); strcat(connstr,pTestInfo->UserID); strcat(connstr,";"); strcat(connstr,"PWD="); strcat(connstr,pTestInfo->Password); strcat(connstr,";"); returncode = SQLBrowseConnect(hdbc,(SQLCHAR*)connstr,SQL_NTS,szConnStrOut,BRWS_LEN,&cbConnStrOut); if(!CHECKRC(SQL_ERROR,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Positive Functionality of SQLBrowseConnect with SQL_NTS\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc,szConnStrIn,SQL_NTS,szConnStrOut,BRWS_LEN,&cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBrowseConnect")){ TEST_FAILED; printf("\nIn string = %s\n",szConnStrIn); printf("Out string = %s\n",szConnStrOut); LogAllErrors(henv,hdbc,hstmt); } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Positive Functionality of SQLBrowseConnect with strlen\n"); returncode = SQLAllocEnv(&henv); // Environment handle if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); // Connection handle if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc,szConnStrIn,(SWORD)strlen((char*)szConnStrIn),szConnStrOut,BRWS_LEN,&cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Positive Functionality of SQLBrowseConnect to check need data\n"); returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ TEST_FAILED; TEST_RETURN; } sprintf(tstConnStr,"DSN=%s;",pTestInfo->DataSource); //printf("\nIn string = %s\n",tstConnStr); returncode = SQLBrowseConnect(hdbc, (SQLCHAR*)tstConnStr, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_NEED_DATA,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } strcat(tstConnStr,"UID="); strcat(tstConnStr,pTestInfo->UserID); strcat(tstConnStr,";"); //printf("\nIn string = %s\n",tstConnStr); returncode = SQLBrowseConnect(hdbc, (SQLCHAR*)tstConnStr, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if((returncode != SQL_NEED_DATA) && (returncode != SQL_SUCCESS)){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if(returncode == SQL_NEED_DATA) { strcat(tstConnStr,"PWD="); strcat(tstConnStr,pTestInfo->Password); strcat(tstConnStr,";"); //printf("\nIn string = %s\n",tstConnStr); returncode = SQLBrowseConnect(hdbc, (SQLCHAR*)tstConnStr, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBrowseConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Positive Functionality of SQLBrowseConnect, SQLDisconnect then SQLBrowseConnect.\n"); for (i = 0; i < 3; i++) { returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc, szConnStrIn, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } switch (i) { case 0: returncode = SQLDisconnect(hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLBrowseConnect(hdbc, szConnStrIn, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } break; case 1: returncode = SQLDisconnect(hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLFreeConnect(hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc, szConnStrIn, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } break; case 2: returncode = SQLDisconnect(hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLFreeConnect(hdbc); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLFreeEnv(henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } returncode = SQLAllocEnv(&henv); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { TEST_FAILED; TEST_RETURN; } returncode = SQLAllocConnect(henv, &hdbc); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc, szConnStrIn, SQL_NTS, szConnStrOut, BRWS_LEN, &cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLConnect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } break; default: // End break; } SQLDisconnect(hdbc); SQLFreeConnect(hdbc); SQLFreeEnv(henv); } TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Positive Functionality of SQLBrowseConnect with different connection handles\n"); returncode = SQLAllocEnv(&henv); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")){ TEST_FAILED; TEST_RETURN; } for (i = 0; i < NUM_CONN_HND; i++){ returncode = SQLAllocConnect(henv, &hdbc1[i]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc1[i],szConnStrIn,SQL_NTS,szConnStrOut,BRWS_LEN,&cbConnStrOut); //printf("\n\nret=%d i=%d %s\n%s\n\n", returncode, i, szConnStrIn, szConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBrowseConnect")){ TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } for (i = 0; i < NUM_CONN_HND; i++){ //printf("%d %d\n", i, NUM_CONN_HND); SQLDisconnect(hdbc1[i]); SQLFreeConnect(hdbc1[i]); } SQLFreeEnv(henv); TESTCASE_END; //========================================================================================== TESTCASE_BEGIN("Test Positive Functionality of SQLBrowseConnect with different env & conn handles\n"); for (j = 0; j < NUM_ENV_HND / 5; j++) { returncode = SQLAllocEnv(&henv1[j]); /* Environment handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocEnv")) { TEST_FAILED; TEST_RETURN; } for (i = 0; i < NUM_CONN_HND / 2; i++) { returncode = SQLAllocConnect(henv1[j], &hdbc1[j * NUM_CONN_HND + i]); /* Connection handle */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocConnect")) { LogAllErrors(henv1[j],hdbc1[j * NUM_CONN_HND + i],hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBrowseConnect(hdbc1[j * NUM_CONN_HND + i],szConnStrIn,SQL_NTS,szConnStrOut,BRWS_LEN,&cbConnStrOut); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBrowseConnect")) { TEST_FAILED; LogAllErrors(henv1[j],hdbc1[j * NUM_CONN_HND + i],hstmt); } } } for (j = 0; j < NUM_ENV_HND / 5; j++) { for (i = 0; i < NUM_CONN_HND / 2; i++) { //printf("%d %d %d \n", j, i, NUM_CONN_HND); SQLDisconnect(hdbc1[j * NUM_CONN_HND + i]); SQLFreeConnect(hdbc1[j * NUM_CONN_HND + i]); } SQLFreeEnv(henv1[j]); } TESTCASE_END; LogMsg(SHORTTIMESTAMP+LINEAFTER,"End of testing API ===> SQLBrowseConnect \n"); //========================================================================================== TEST_RETURN; }