testTransaction -n FRead*

testTransaction -n *Scan*
testTimeout -n *


ndb/include/kernel/signaldata/DumpStateOrd.hpp:
  Added DUMP for tc appl timeout
ndb/src/kernel/blocks/dbtc/DbtcMain.cpp:
  Send tckey conf if m_exec_flags is set
  Added dump for appl timeout
ndb/test/include/HugoOperations.hpp:
  Add scanRead
ndb/test/ndbapi/testTimeout.cpp:
  Reenable
ndb/test/ndbapi/testTransactions.cpp:
  Fix scan test cases
ndb/test/run-test/daily-basic-tests.txt:
  reenable timeout-tests
  added testTransaction -n Scan* testcases
ndb/test/src/HugoOperations.cpp:
  Fix scan
ndb/test/src/NDBT_Test.cpp:
  Drop table before test...(if createTable==true)

ndb/include/kernel/signaldata/DumpStateOrd.hpp

@@ -94,6 +94,7 @@ public:
     TcDumpOneApiConnectRec = 2505,
     TcDumpAllApiConnectRec = 2506,
     TcSetTransactionTimeout = 2507,
+    TcSetApplTransactionTimeout = 2508,
     CmvmiDumpConnections = 2600,
     CmvmiDumpLongSignalMemory = 2601,
     CmvmiSetRestartOnErrorInsert = 2602,

ndb/src/kernel/blocks/dbtc/DbtcMain.cpp

@@ -5043,11 +5043,11 @@ void Dbtc::execLQHKEYREF(Signal* signal)
 	  jam();
 	  diverify010Lab(signal);
 	  return;
-	} else if (regApiPtr->tckeyrec > 0) {
+	} else if (regApiPtr->tckeyrec > 0 || regApiPtr->m_exec_flag) {
 	  jam();
 	  sendtckeyconf(signal, 2);
 	  return;
-	}//if
+	}
       }//if
       return;
       
@@ -10533,6 +10533,13 @@ Dbtc::execDUMP_STATE_ORD(Signal* signal)
       set_timeout_value(signal->theData[1]);
     }
   }
+
+  if (dumpState->args[0] == DumpStateOrd::TcSetApplTransactionTimeout){
+    jam();
+    if(signal->getLength() > 1){
+      set_appl_timeout_value(signal->theData[1]);
+    }
+  }
 }//Dbtc::execDUMP_STATE_ORD()
 
 void Dbtc::execSET_VAR_REQ(Signal* signal)

ndb/test/include/HugoOperations.hpp

@@ -58,9 +58,6 @@ public:
 		     int recordNo,
 		     int numRecords = 1);
   
-  NdbResultSet* scanReadRecords(Ndb* pNdb, ScanLock lock = SL_Read);
-  int readTuples(NdbResultSet*);
-
   int execute_Commit(Ndb*, 
 		     AbortOption ao = AbortOnError);
   int execute_NoCommit(Ndb*,
@@ -92,7 +89,11 @@ public:
 			int recordNo,
 			int numRecords = 1,
 			int updatesValue = 0);
-  
+
+  int scanReadRecords(Ndb*, NdbScanOperation::LockMode = 
+		      NdbScanOperation::LM_CommittedRead, 
+		      int numRecords = 1);
+
 protected:
   void allocRows(int rows);
   void deallocRows();
@@ -101,6 +102,10 @@ protected:
   HugoCalculator calc;
 
   Vector<BaseString> savedRecords;
+
+  struct RsPair { NdbResultSet* m_result_set; int records; };
+  Vector<RsPair> m_result_sets;
+  Vector<RsPair> m_executed_result_sets;
 private:
   NdbConnection* pTrans;
 };

ndb/test/ndbapi/testTimeout.cpp

@@ -20,6 +20,44 @@
 #include <UtilTransactions.hpp>
 #include <random.h>
 #include <NdbConfig.hpp>
+#include <signaldata/DumpStateOrd.hpp>
+
+#define TIMEOUT 3000
+
+Uint32 g_org_timeout = 3000;
+
+int
+setTransactionTimeout(NDBT_Context* ctx, NDBT_Step* step){
+  NdbRestarter restarter;
+  
+  NdbConfig conf(GETNDB(step)->getNodeId()+1);
+  unsigned int nodeId = conf.getMasterNodeId();
+  if (!conf.getProperty(nodeId,
+			NODE_TYPE_DB, 
+			CFG_DB_TRANSACTION_INACTIVE_TIMEOUT,
+			&g_org_timeout)){
+    return NDBT_FAILED;
+  }
+
+  int val[] = { DumpStateOrd::TcSetApplTransactionTimeout, TIMEOUT };
+  if(restarter.dumpStateAllNodes(val, 2) != 0){
+    return NDBT_FAILED;
+  }
+  
+  return NDBT_OK;
+}
+
+int
+resetTransactionTimeout(NDBT_Context* ctx, NDBT_Step* step){
+  NdbRestarter restarter;
+  
+  int val[] = { DumpStateOrd::TcSetApplTransactionTimeout, g_org_timeout };
+  if(restarter.dumpStateAllNodes(val, 2) != 0){
+    return NDBT_FAILED;
+  }
+  
+  return NDBT_OK;
+}
 
 
 int runLoadTable(NDBT_Context* ctx, NDBT_Step* step){
@@ -55,16 +93,10 @@ int runTimeoutTrans(NDBT_Context* ctx, NDBT_Step* step){
   NdbConfig conf(GETNDB(step)->getNodeId()+1);
   unsigned int nodeId = conf.getMasterNodeId();
   int stepNo = step->getStepNo();
-  Uint32 timeoutVal;
-  if (!conf.getProperty(nodeId,
-			NODE_TYPE_DB, 
-			CFG_DB_TRANSACTION_INACTIVE_TIMEOUT,
-			&timeoutVal)){
-    return NDBT_FAILED;
-  }
-  int minSleep = (int)(timeoutVal * 1.5);
-  int maxSleep = timeoutVal * 2;
-  ndbout << "TransactionInactiveTimeout="<<timeoutVal
+
+  int minSleep = (int)(TIMEOUT * 1.5);
+  int maxSleep = TIMEOUT * 2;
+  ndbout << "TransactionInactiveTimeout="<< TIMEOUT
 	 << ", minSleep="<<minSleep
 	 << ", maxSleep="<<maxSleep<<endl;
 
@@ -89,7 +121,6 @@ int runTimeoutTrans(NDBT_Context* ctx, NDBT_Step* step){
     } while(false);
 
     hugoOps.closeTransaction(pNdb);
-  
   }
 
   return result;
@@ -98,28 +129,18 @@ int runTimeoutTrans(NDBT_Context* ctx, NDBT_Step* step){
 int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
   int result = NDBT_OK;
   int loops = ctx->getNumLoops();
-  NdbConfig conf(GETNDB(step)->getNodeId()+1);
-  unsigned int nodeId = conf.getMasterNodeId();
   int stepNo = step->getStepNo();
   int mul1 = ctx->getProperty("Op1", (Uint32)0);
   int mul2 = ctx->getProperty("Op2", (Uint32)0);
   int records = ctx->getNumRecords();
 
-  Uint32 timeoutVal;
-  if (!conf.getProperty(nodeId,
-			NODE_TYPE_DB, 
-			CFG_DB_TRANSACTION_INACTIVE_TIMEOUT,
-			&timeoutVal)){
-    return NDBT_FAILED;
-  }
-
-  int minSleep = (int)(timeoutVal * 1.5);
-  int maxSleep = timeoutVal * 2;
+  int minSleep = (int)(TIMEOUT * 1.5);
+  int maxSleep = TIMEOUT * 2;
   
   HugoOperations hugoOps(*ctx->getTab());
   Ndb* pNdb = GETNDB(step);
 
-  for (int l = 0; l < loops && !ctx->isTestStopped(); l++){
+  for (int l = 0; l<loops && !ctx->isTestStopped() && result == NDBT_OK; l++){
     
     int op1 = 0 + (l + stepNo) * mul1;
     int op2 = 0 + (l + stepNo) * mul2;
@@ -127,7 +148,7 @@ int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
     op1 = (op1 % 5);
     op2 = (op2 % 5);
 
-    ndbout << stepNo << ": TransactionInactiveTimeout="<<timeoutVal
+    ndbout << stepNo << ": TransactionInactiveTimeout="<< TIMEOUT
 	   << ", minSleep="<<minSleep
 	   << ", maxSleep="<<maxSleep
 	   << ", op1=" << op1
@@ -143,32 +164,36 @@ int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
       case 1:
 	if(hugoOps.pkReadRecord(pNdb, stepNo, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       case 2:
 	if(hugoOps.pkUpdateRecord(pNdb, stepNo, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       case 3:
 	if(hugoOps.pkDeleteRecord(pNdb, stepNo, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       case 4:
 	if(hugoOps.pkInsertRecord(pNdb, stepNo+records+l, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       }
+      
+      if(result != NDBT_OK)
+	break;
+
       int res = hugoOps.execute_NoCommit(pNdb);
       if(res != 0){
 	g_err << stepNo << ": Fail" << __LINE__ << endl;
-	return NDBT_FAILED;
+	result = NDBT_FAILED; break;
       }
       
       int sleep = minSleep + myRandom48(maxSleep-minSleep);   
@@ -181,25 +206,25 @@ int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
       case 1:
 	if(hugoOps.pkReadRecord(pNdb, stepNo, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       case 2:
 	if(hugoOps.pkUpdateRecord(pNdb, stepNo, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       case 3:
 	if(hugoOps.pkDeleteRecord(pNdb, stepNo, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       case 4:
 	if(hugoOps.pkInsertRecord(pNdb, stepNo+2*records+l, true) != 0){
 	  g_err << stepNo << ": Fail" << __LINE__ << endl;
-	  return NDBT_FAILED;
+	  result = NDBT_FAILED; break;
 	}
 	break;
       }
@@ -209,7 +234,7 @@ int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
       if(op1 != 0 && res != 266){
 	g_err << stepNo << ": Fail: " << res << "!= 237, op1=" 
 	      << op1 << ", op2=" << op2 << endl;
-	return NDBT_FAILED;
+	result = NDBT_FAILED; break;
       }
       
     } while(false);
@@ -223,18 +248,10 @@ int runTimeoutTrans2(NDBT_Context* ctx, NDBT_Step* step){
 int runDontTimeoutTrans(NDBT_Context* ctx, NDBT_Step* step){
   int result = NDBT_OK;
   int loops = ctx->getNumLoops();
-  NdbConfig conf(GETNDB(step)->getNodeId()+1);
-  unsigned int nodeId = conf.getMasterNodeId();
   int stepNo = step->getStepNo();
-  Uint32 timeoutVal;
-  if (!conf.getProperty(nodeId,
-			NODE_TYPE_DB, 
-			CFG_DB_TRANSACTION_INACTIVE_TIMEOUT,
-			&timeoutVal)){
-    return NDBT_FAILED;
-  }
-  int maxSleep = (int)(timeoutVal * 0.5);
-  ndbout << "TransactionInactiveTimeout="<<timeoutVal
+
+  int maxSleep = (int)(TIMEOUT * 0.5);
+  ndbout << "TransactionInactiveTimeout="<< TIMEOUT
 	 << ", maxSleep="<<maxSleep<<endl;
 
 
@@ -259,11 +276,8 @@ int runDontTimeoutTrans(NDBT_Context* ctx, NDBT_Step* step){
     } while(false);
 
     hugoOps.closeTransaction(pNdb);
-
-
   }
     
-
   return result;
 }
 
@@ -271,18 +285,9 @@ int runBuddyTransNoTimeout(NDBT_Context* ctx, NDBT_Step* step){
   int result = NDBT_OK;
   int loops = ctx->getNumLoops();
   int records = ctx->getNumRecords();
-  NdbConfig conf(GETNDB(step)->getNodeId()+1);
-  unsigned int nodeId = conf.getMasterNodeId();
   int stepNo = step->getStepNo();
-  Uint32 timeoutVal;
-  if (!conf.getProperty(nodeId,
-			NODE_TYPE_DB, 
-			CFG_DB_TRANSACTION_INACTIVE_TIMEOUT,
-			&timeoutVal)){
-    return NDBT_FAILED;
-  }
-  int maxSleep = (int)(timeoutVal * 0.3);
-  ndbout << "TransactionInactiveTimeout="<<timeoutVal
+  int maxSleep = (int)(TIMEOUT * 0.3);
+  ndbout << "TransactionInactiveTimeout="<< TIMEOUT
 	 << ", maxSleep="<<maxSleep<<endl;
 
   HugoOperations hugoOps(*ctx->getTab());
@@ -297,12 +302,10 @@ int runBuddyTransNoTimeout(NDBT_Context* ctx, NDBT_Step* step){
       CHECK(hugoOps.pkInsertRecord(pNdb, recordNo, true) == 0);
       CHECK(hugoOps.execute_NoCommit(pNdb) == 0);
       
-      for (int i = 0; i < 10; i++){
+      for (int i = 0; i < 3; i++){
 	// Perform buddy scan reads
-	NdbResultSet* rs = 0;
-	CHECK((rs = hugoOps.scanReadRecords(pNdb)) != 0);
+	CHECK((hugoOps.scanReadRecords(pNdb)) == 0);
 	CHECK(hugoOps.execute_NoCommit(pNdb) == 0); 
-	CHECK(hugoOps.readTuples(rs) == 0);
 	
 	int sleep = myRandom48(maxSleep);   	
 	ndbout << "Sleeping for " << sleep << " milliseconds" << endl;
@@ -315,10 +318,7 @@ int runBuddyTransNoTimeout(NDBT_Context* ctx, NDBT_Step* step){
     } while(false);
 
     hugoOps.closeTransaction(pNdb);
-
-
   }
-    
 
   return result;
 }
@@ -329,7 +329,9 @@ TESTCASE("DontTimeoutTransaction",
 	 "if we sleep during the transaction. Use a sleep "\
 	 "value which is smaller than TransactionInactiveTimeout"){
   INITIALIZER(runLoadTable);
+  INITIALIZER(setTransactionTimeout);
   STEPS(runDontTimeoutTrans, 1); 
+  FINALIZER(resetTransactionTimeout);
   FINALIZER(runClearTable);
 }
 TESTCASE("DontTimeoutTransaction5", 
@@ -338,7 +340,9 @@ TESTCASE("DontTimeoutTransaction5",
 	 "value which is smaller than TransactionInactiveTimeout" \
 	 "Five simultaneous threads"){
   INITIALIZER(runLoadTable);
+  INITIALIZER(setTransactionTimeout);
   STEPS(runDontTimeoutTrans, 5); 
+  FINALIZER(resetTransactionTimeout);
   FINALIZER(runClearTable);
 }
 TESTCASE("TimeoutTransaction", 
@@ -346,7 +350,9 @@ TESTCASE("TimeoutTransaction",
 	 "if we sleep during the transaction. Use a sleep "\
 	 "value which is larger than TransactionInactiveTimeout"){
   INITIALIZER(runLoadTable);
+  INITIALIZER(setTransactionTimeout);
   STEPS(runTimeoutTrans, 1);
+  FINALIZER(resetTransactionTimeout);
   FINALIZER(runClearTable);
 }
 TESTCASE("TimeoutTransaction5", 
@@ -355,7 +361,9 @@ TESTCASE("TimeoutTransaction5",
 	 "value which is larger than TransactionInactiveTimeout" \
 	 "Five simultaneous threads"){
   INITIALIZER(runLoadTable);
+  INITIALIZER(setTransactionTimeout);
   STEPS(runTimeoutTrans, 5);
+  FINALIZER(resetTransactionTimeout);
   FINALIZER(runClearTable);
 }
 TESTCASE("TimeoutRandTransaction", 
@@ -363,9 +371,11 @@ TESTCASE("TimeoutRandTransaction",
 	 "if we sleep during the transaction. Use a sleep "\
 	 "value which is larger than TransactionInactiveTimeout"){
   INITIALIZER(runLoadTable);
+  INITIALIZER(setTransactionTimeout);
   TC_PROPERTY("Op1", 7);
   TC_PROPERTY("Op2", 11);
   STEPS(runTimeoutTrans2, 5);
+  FINALIZER(resetTransactionTimeout);
   FINALIZER(runClearTable);
 }
 TESTCASE("BuddyTransNoTimeout", 
@@ -375,7 +385,9 @@ TESTCASE("BuddyTransNoTimeout",
 	 "The total sleep time is longer than TransactionInactiveTimeout" \
 	 "Commit the first transaction, it should not have timed out."){
   INITIALIZER(runLoadTable);
+  INITIALIZER(setTransactionTimeout);
   STEPS(runBuddyTransNoTimeout, 1);
+  FINALIZER(resetTransactionTimeout);
   FINALIZER(runClearTable);
 }
 TESTCASE("BuddyTransNoTimeout5", 
@@ -386,7 +398,9 @@ TESTCASE("BuddyTransNoTimeout5",
 	 "Commit the first transaction, it should not have timed out." \
 	 "Five simultaneous threads"){
   INITIALIZER(runLoadTable);
+  INITIALIZER(setTransactionTimeout);
   STEPS(runBuddyTransNoTimeout, 5);
+  FINALIZER(resetTransactionTimeout);
   FINALIZER(runClearTable);
 }
 NDBT_TESTSUITE_END(testTimeout);

ndb/test/ndbapi/testTransactions.cpp

@@ -102,7 +102,7 @@ OperationTestCase matrix[] = {
   { "ScanExInsert",     true, "SCAN-EX",1, "INSERT",  266, X,   0, 1 },
   { "ScanExUpdate",     true, "SCAN-EX",1, "UPDATE",  266, 2,   0, 1 },
   { "ScanExDelete",     true, "SCAN-EX",1, "DELETE",  266, X,   0, 1 },
-  { "ScanExScan",       true, "SCAN-EX",1, "SCAN",    274, X,   0, 1 },
+  { "ScanExScan",       true, "SCAN-EX",1, "SCAN",      0, 1,   0, 1 },
   { "ScanExScanHl",     true, "SCAN-EX",1, "SCAN-HL", 274, X,   0, 1 },
   { "ScanExScanEx",     true, "SCAN-EX",1, "SCAN-EX", 274, X,   0, 1 },
 #if 0
@@ -117,8 +117,8 @@ OperationTestCase matrix[] = {
   { "ReadExInsert",     true, "READ-EX",1, "INSERT",  266, X,   0, 1 },
   { "ReadExUpdate",     true, "READ-EX",1, "UPDATE",  266, X,   0, 1 },
   { "ReadExDelete",     true, "READ-EX",1, "DELETE",  266, X,   0, 1 },
-  { "ReadExScan",       true, "READ-EX",1, "SCAN",    274, 1,   0, 1 },
-  { "ReadExScanHl",     true, "READ-EX",1, "SCAN-HL", 274, 1,   0, 1 },
+  { "ReadExScan",       true, "READ-EX",1, "SCAN",      0, 1,   0, 1 },
+  { "ReadExScanHl",     true, "READ-EX",1, "SCAN-HL", 274, X,   0, 1 },
   { "ReadExScanEx",     true, "READ-EX",1, "SCAN-EX", 274, X,   0, 1 },
 #if 0
   { "ReadExScanUp",     true, "READ-EX",1, "SCAN-UP", 266, X,   0, 1 },
@@ -132,7 +132,7 @@ OperationTestCase matrix[] = {
   { "InsertInsert",    false, "INSERT", 1, "INSERT",  266, X,   0, 1 },
   { "InsertUpdate",    false, "INSERT", 1, "UPDATE",  266, X,   0, 1 },
   { "InsertDelete",    false, "INSERT", 1, "DELETE",  266, X,   0, 1 },
-  { "InsertScan",      false, "INSERT", 1, "SCAN",    274, X,   0, 1 },
+  { "InsertScan",      false, "INSERT", 1, "SCAN",    626, X,   0, 1 },
   { "InsertScanHl",    false, "INSERT", 1, "SCAN-HL", 274, X,   0, 1 },
   { "InsertScanEx",    false, "INSERT", 1, "SCAN-EX", 274, X,   0, 1 },
 #if 0
@@ -147,7 +147,7 @@ OperationTestCase matrix[] = {
   { "UpdateInsert",     true, "UPDATE", 2, "INSERT",  266, X,   0, 2 },
   { "UpdateUpdate",     true, "UPDATE", 2, "UPDATE",  266, X,   0, 2 },
   { "UpdateDelete",     true, "UPDATE", 2, "DELETE",  266, X,   0, 2 },
-  { "UpdateScan",       true, "UPDATE", 2, "SCAN",    274, X,   0, 2 },
+  { "UpdateScan",       true, "UPDATE", 2, "SCAN",      0, 1,   0, 2 },
   { "UpdateScanHl",     true, "UPDATE", 2, "SCAN-HL", 274, X,   0, 2 },
   { "UpdateScanEx",     true, "UPDATE", 2, "SCAN-EX", 274, X,   0, 2 },
 #if 0
@@ -162,7 +162,7 @@ OperationTestCase matrix[] = {
   { "DeleteInsert",     true, "DELETE", X, "INSERT",  266, X, 626, X },
   { "DeleteUpdate",     true, "DELETE", X, "UPDATE",  266, X, 626, X },
   { "DeleteDelete",     true, "DELETE", X, "DELETE",  266, X, 626, X },
-  { "DeleteScan",       true, "DELETE", X, "SCAN",    274, X, 626, X },
+  { "DeleteScan",       true, "DELETE", X, "SCAN",      0, 1, 626, X },
   { "DeleteScanHl",     true, "DELETE", X, "SCAN-HL", 274, X, 626, X },
   { "DeleteScanEx",     true, "DELETE", X, "SCAN-EX", 274, X, 626, X },
 #if 0
@@ -204,14 +204,11 @@ runOp(HugoOperations & hugoOps,
   } else if(strcmp(op, "DELETE") == 0){
     C2(hugoOps.pkDeleteRecord(pNdb, 1, 1) == 0);      
   } else if(strcmp(op, "SCAN") == 0){
-    abort();
-    //C2(hugoOps.scanReadRecords(pNdb) == 0);
+    C2(hugoOps.scanReadRecords(pNdb) == 0);
   } else if(strcmp(op, "SCAN-HL") == 0){
-    abort();
-    //C2(hugoOps.scanReadRecords(pNdb, 240, HugoOperations::SL_ReadHold)== 0);
+    C2(hugoOps.scanReadRecords(pNdb, NdbScanOperation::LM_Read)== 0);
   } else if(strcmp(op, "SCAN-EX") == 0){
-    abort();
-    //C2(hugoOps.scanReadRecords(pNdb, 240, HugoOperations::SL_Exclusive)== 0);
+    C2(hugoOps.scanReadRecords(pNdb, NdbScanOperation::LM_Exclusive)== 0);
   } else {
     g_err << __FILE__ << " - " << __LINE__ 
 	  << ": Unknown operation" << op << endl;

ndb/test/run-test/daily-basic-tests.txt

@@ -139,10 +139,6 @@ max-time: 500
 cmd: testBasicAsynch
 args: -n PkDeleteAsynch 
 
-max-time:
-cmd: ndb_drop_table
-args: T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14
-
 max-time: 500
 cmd: testBasic
 args: -n MassiveRollback T1 T6 T13 
@@ -152,34 +148,34 @@ cmd: testBasic
 args: -n MassiveRollback2 T1 T6 T13 
 
 #-m 500 1: testBasic -n ReadConsistency T6
-#max-time: 500
-#cmd: testTimeout
-#args: -n DontTimeoutTransaction T1 
-#
-#max-time: 500
-#cmd: testTimeout 
-#args: -n DontTimeoutTransaction5 T1 
-#
-#max-time: 500
-#cmd: testTimeout
-#args: -n TimeoutTransaction T1 
-#
-#max-time: 500
-#cmd: testTimeout 
-#args: -n TimeoutTransaction5 T1 
-#
-#max-time: 500
-#cmd: testTimeout
-#args: -n BuddyTransNoTimeout T1 
-#
-#max-time: 500
-#cmd: testTimeout
-#args: -n BuddyTransNoTimeout5 T1 
-#
-#max-time: 500
-#cmd: testTimeout
-#args: -n TimeoutRandTransaction T1
-#
+max-time: 500
+cmd: testTimeout
+args: -n DontTimeoutTransaction T1 
+
+max-time: 500
+cmd: testTimeout 
+args: -n DontTimeoutTransaction5 T1 
+
+max-time: 500
+cmd: testTimeout
+args: -n TimeoutTransaction T1 
+
+max-time: 500
+cmd: testTimeout 
+args: -n TimeoutTransaction5 T1 
+
+max-time: 500
+cmd: testTimeout
+args: -n BuddyTransNoTimeout T1 
+
+max-time: 500
+cmd: testTimeout
+args: -n BuddyTransNoTimeout5 T1 
+
+max-time: 500
+cmd: testTimeout
+args: -n TimeoutRandTransaction T1
+
 # SCAN TESTS
 #
 max-time: 500
@@ -786,6 +782,186 @@ max-time: 1500
 cmd: testTransactions
 args: -n DeleteDirtyRead 
 
+max-time: 1500
+cmd: testTransactions
+args: -n ReadScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadScanEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanScanEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanHlScanEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExReadEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExSimpleRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExDirtyRead
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExInsert
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExUpdate
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExDelete
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n ScanExScanEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n ReadExScanEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n InsertScanEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n UpdateScanEx
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteScan
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteScanHl
+
+max-time: 1500
+cmd: testTransactions
+args: -n DeleteScanEx
+
 max-time: 1500
 cmd: testRestartGci
 args: T6 

ndb/test/src/HugoOperations.cpp

@@ -40,6 +40,9 @@ int HugoOperations::closeTransaction(Ndb* pNdb){
   }
   pTrans = NULL;
 
+  m_result_sets.clear();
+  m_executed_result_sets.clear();
+
   return NDBT_OK;
 }
 
@@ -291,7 +294,7 @@ int HugoOperations::pkDeleteRecord(Ndb* pNdb,
   }
   return NDBT_OK;
 }
-
+#if 0
 NdbResultSet*
 HugoOperations::scanReadRecords(Ndb* pNdb, ScanLock lock){
   
@@ -349,6 +352,7 @@ HugoOperations::readTuples(NdbResultSet* rs){
     return NDBT_FAILED;
   return NDBT_OK;
 }
+#endif
 
 int HugoOperations::execute_Commit(Ndb* pNdb,
 				   AbortOption eao){
@@ -368,6 +372,35 @@ int HugoOperations::execute_Commit(Ndb* pNdb,
       return NDBT_FAILED;
     return err.code;
   }
+
+  for(int i = 0; i<m_result_sets.size(); i++){
+    m_executed_result_sets.push_back(m_result_sets[i]);
+
+    int rows = m_result_sets[i].records;
+    NdbResultSet* rs = m_result_sets[i].m_result_set;
+    int res = rs->nextResult();
+    switch(res){
+    case 1:
+      return 626;
+    case -1:
+      const NdbError err = pTrans->getNdbError();
+      ERR(err);
+      return (err.code > 0 ? err.code : NDBT_FAILED);
+    }
+
+    // A row found
+
+    switch(rows){
+    case 0:
+      return 4000;
+    default:
+      m_result_sets[i].records--;
+      break;
+    }
+  }
+
+  m_result_sets.clear();
+  
   return NDBT_OK;
 }
 
@@ -388,6 +421,35 @@ int HugoOperations::execute_NoCommit(Ndb* pNdb, AbortOption eao){
       return NDBT_FAILED;
     return err.code;
   }
+
+  for(int i = 0; i<m_result_sets.size(); i++){
+    m_executed_result_sets.push_back(m_result_sets[i]);
+
+    int rows = m_result_sets[i].records;
+    NdbResultSet* rs = m_result_sets[i].m_result_set;
+    int res = rs->nextResult();
+    switch(res){
+    case 1:
+      return 626;
+    case -1:
+      const NdbError err = pTrans->getNdbError();
+      ERR(err);
+      return (err.code > 0 ? err.code : NDBT_FAILED);
+    }
+
+    // A row found
+
+    switch(rows){
+    case 0:
+      return 4000;
+    default:
+    case 1:
+      break;
+    }
+  }
+
+  m_result_sets.clear();
+
   return NDBT_OK;
 }
 
@@ -704,3 +766,33 @@ HugoOperations::indexUpdateRecord(Ndb*,
   }
   return NDBT_OK;
 }
+
+int 
+HugoOperations::scanReadRecords(Ndb* pNdb, NdbScanOperation::LockMode lm,
+				int records){
+
+  allocRows(records);
+  NdbScanOperation * pOp = pTrans->getNdbScanOperation(tab.getName());
+  
+  if(!pOp)
+    return -1;
+
+  NdbResultSet * rs = pOp->readTuples(lm, 1, 1);
+  
+  if(!rs){
+    return -1;
+  }
+
+  for(int a = 0; a<tab.getNoOfColumns(); a++){
+    if((rows[0]->attributeStore(a) = 
+	pOp->getValue(tab.getColumn(a)->getName())) == 0) {
+      ERR(pTrans->getNdbError());
+      return NDBT_FAILED;
+    }
+  } 
+
+  RsPair p = {rs, records};
+  m_result_sets.push_back(p);
+  
+  return 0;
+}

ndb/test/src/NDBT_Test.cpp

@@ -820,15 +820,15 @@ void NDBT_TestSuite::execute(Ndb* ndb, const NdbDictionary::Table* pTab,
     const NdbDictionary::Table* pTab2 = pDict->getTable(pTab->getName());
     if (createTable == true){
 
-      if (pTab2 != 0 && !pTab->equal(* pTab2)){
+      if(pTab2 != 0 && pDict->dropTable(pTab->getName()) != 0){
 	numTestsFail++;
 	numTestsExecuted++;
-	g_err << "ERROR0: Failed to create table " << pTab->getName() << endl;
+	g_err << "ERROR0: Failed to drop table " << pTab->getName() << endl;
 	tests[t]->saveTestResult(pTab, FAILED_TO_CREATE);
 	continue;
       }
-
-      if(pTab2 == 0 && pDict->createTable(* pTab) != 0){
+      
+      if(pDict->createTable(* pTab) != 0){
 	numTestsFail++;
 	numTestsExecuted++;
 	g_err << "ERROR1: Failed to create table " << pTab->getName()