Reformulate jni tests to not require the -ea jvm flag to enable assert().

FossilOrigin-Name: dc356667a8f4fa31a3fef1ae35873d834d27fd6a9f0818d6fb85e4751fde9fe5

diff --git a/ext/jni/src/org/sqlite/jni/Tester1.java b/ext/jni/src/org/sqlite/jni/Tester1.java
index 49c09531845f4ae35d17ee239ca4d3c3934366ea..4b760661db413d0ad4fd4e8f2a5e53c40f385196 100644 (file)
--- a/ext/jni/src/org/sqlite/jni/Tester1.java
+++ b/ext/jni/src/org/sqlite/jni/Tester1.java
@@ -10,8 +10,6 @@
 **
 *************************************************************************
 ** This file contains a set of tests for the sqlite3 JNI bindings.
-** They make heavy use of assert(), so must be run with java's -ea
-** (enble assert) flag.
 */
 package org.sqlite.jni;
 import static org.sqlite.jni.SQLite3Jni.*;
@@ -28,10 +26,10 @@ public class Tester1 {
     System.out.println(val);
   }
 
-  private static int assertCount = 0;
-  private static void myassert(Boolean v){
-    ++assertCount;
-    assert( v );
+  private static int affirmCount = 0;
+  private static void affirm(Boolean v){
+    ++affirmCount;
+    if( !v ) throw new RuntimeException("Assertion failed.");
   }
 
   private static void test1(){
@@ -41,10 +39,10 @@ public class Tester1 {
           + sqlite3_libversion()
           + "\n"
           + SQLITE_SOURCE_ID);
-    myassert(sqlite3_libversion_number() == SQLITE_VERSION_NUMBER);
+    affirm(sqlite3_libversion_number() == SQLITE_VERSION_NUMBER);
     //outln("threadsafe = "+sqlite3_threadsafe());
-    myassert(SQLITE_MAX_LENGTH > 0);
-    myassert(SQLITE_MAX_TRIGGER_DEPTH>0);
+    affirm(SQLITE_MAX_LENGTH > 0);
+    affirm(SQLITE_MAX_TRIGGER_DEPTH>0);
   }
 
   private static void testCompileOption(){
@@ -74,12 +72,12 @@ public class Tester1 {
         }
         if( 0==sqlChunk.length ) break;
         int rc = sqlite3_prepare_v2(db, sqlChunk, stmt, oTail);
-        myassert(0 == rc);
+        affirm(0 == rc);
         pos = oTail.getValue();
-        myassert(0 != stmt.getNativePointer());
+        affirm(0 != stmt.getNativePointer());
         rc = sqlite3_step(stmt);
         sqlite3_finalize(stmt);
-        myassert(0 == stmt.getNativePointer());
+        affirm(0 == stmt.getNativePointer());
         if(0!=rc && SQLITE_ROW!=rc && SQLITE_DONE!=rc){
           throw new RuntimeException("db op failed with rc="+rc);
         }
@@ -87,34 +85,34 @@ public class Tester1 {
   }
   private static void testOpenDb1(){
       sqlite3 db = new sqlite3();
-      myassert(0 == db.getNativePointer());
+      affirm(0 == db.getNativePointer());
       int rc = sqlite3_open(":memory:", db);
-      myassert(0 == rc);
-      myassert(0 < db.getNativePointer());
+      affirm(0 == rc);
+      affirm(0 < db.getNativePointer());
       sqlite3_close(db);
-      myassert(0 == db.getNativePointer());
+      affirm(0 == db.getNativePointer());
   }
 
   private static void testOpenDb2(){
     sqlite3 db = new sqlite3();
-    myassert(0 == db.getNativePointer());
+    affirm(0 == db.getNativePointer());
     int rc = sqlite3_open_v2(":memory:", db,
                              SQLITE_OPEN_READWRITE
                              | SQLITE_OPEN_CREATE, null);
-    myassert(0 == rc);
-    myassert(0 < db.getNativePointer());
+    affirm(0 == rc);
+    affirm(0 < db.getNativePointer());
     sqlite3_close_v2(db);
-    myassert(0 == db.getNativePointer());
+    affirm(0 == db.getNativePointer());
   }
 
   private static sqlite3 createNewDb(){
     sqlite3 db = new sqlite3();
-    myassert(0 == db.getNativePointer());
+    affirm(0 == db.getNativePointer());
     int rc = sqlite3_open(":memory:", db);
-    myassert(0 == rc);
-    myassert(0 != db.getNativePointer());
+    affirm(0 == rc);
+    affirm(0 != db.getNativePointer());
     rc = sqlite3_busy_timeout(db, 2000);
-    myassert( 0 == rc );
+    affirm( 0 == rc );
     return db;
   }
 
@@ -122,14 +120,14 @@ public class Tester1 {
     sqlite3 db = createNewDb();
     int rc;
     sqlite3_stmt stmt = new sqlite3_stmt();
-    myassert(0 == stmt.getNativePointer());
+    affirm(0 == stmt.getNativePointer());
     rc = sqlite3_prepare(db, "CREATE TABLE t1(a);", stmt);
-    myassert(0 == rc);
-    myassert(0 != stmt.getNativePointer());
+    affirm(0 == rc);
+    affirm(0 != stmt.getNativePointer());
     rc = sqlite3_step(stmt);
-    myassert(SQLITE_DONE == rc);
+    affirm(SQLITE_DONE == rc);
     sqlite3_finalize(stmt);
-    myassert(0 == stmt.getNativePointer());
+    affirm(0 == stmt.getNativePointer());
 
     { /* Demonstrate how to use the "zTail" option of
          sqlite3_prepare() family of functions. */
@@ -146,33 +144,33 @@ public class Tester1 {
         //outln("SQL chunk #"+n+" length = "+sqlChunk.length+", pos = "+pos);
         if( 0==sqlChunk.length ) break;
         rc = sqlite3_prepare_v2(db, sqlChunk, stmt, oTail);
-        myassert(0 == rc);
+        affirm(0 == rc);
         pos = oTail.getValue();
         /*outln("SQL tail pos = "+pos+". Chunk = "+
               (new String(Arrays.copyOfRange(sqlChunk,0,pos),
               StandardCharsets.UTF_8)));*/
         switch(n){
-          case 1: myassert(19 == pos); break;
-          case 2: myassert(36 == pos); break;
-          default: myassert( false /* can't happen */ );
+          case 1: affirm(19 == pos); break;
+          case 2: affirm(36 == pos); break;
+          default: affirm( false /* can't happen */ );
 
         }
         ++n;
-        myassert(0 != stmt.getNativePointer());
+        affirm(0 != stmt.getNativePointer());
         rc = sqlite3_step(stmt);
-        myassert(SQLITE_DONE == rc);
+        affirm(SQLITE_DONE == rc);
         sqlite3_finalize(stmt);
-        myassert(0 == stmt.getNativePointer());
+        affirm(0 == stmt.getNativePointer());
       }
     }
 
 
     rc = sqlite3_prepare_v3(db, "INSERT INTO t2(a) VALUES(1),(2),(3)",
                             SQLITE_PREPARE_NORMALIZE, stmt);
-    myassert(0 == rc);
-    myassert(0 != stmt.getNativePointer());
+    affirm(0 == rc);
+    affirm(0 != stmt.getNativePointer());
     sqlite3_finalize(stmt);
-    myassert(0 == stmt.getNativePointer() );
+    affirm(0 == stmt.getNativePointer() );
     sqlite3_close_v2(db);
   }
 
@@ -182,10 +180,10 @@ public class Tester1 {
 
     sqlite3_stmt stmt = new sqlite3_stmt();
     int rc = sqlite3_prepare(db, "INSERT INTO t(a) VALUES(:a);", stmt);
-    myassert(0 == rc);
-    myassert(1 == sqlite3_bind_parameter_count(stmt));
+    affirm(0 == rc);
+    affirm(1 == sqlite3_bind_parameter_count(stmt));
     final int paramNdx = sqlite3_bind_parameter_index(stmt, ":a");
-    myassert(1 == paramNdx);
+    affirm(1 == paramNdx);
     int total1 = 0;
     long rowid = -1;
     int changes = sqlite3_changes(db);
@@ -195,34 +193,34 @@ public class Tester1 {
     for(int i = 99; i < 102; ++i ){
       total1 += i;
       rc = sqlite3_bind_int(stmt, paramNdx, i);
-      myassert(0 == rc);
+      affirm(0 == rc);
       rc = sqlite3_step(stmt);
       sqlite3_reset(stmt);
-      myassert(SQLITE_DONE == rc);
+      affirm(SQLITE_DONE == rc);
       long x = sqlite3_last_insert_rowid(db);
-      myassert(x > rowid);
+      affirm(x > rowid);
       rowid = x;
     }
     sqlite3_finalize(stmt);
-    myassert(total1 > 0);
-    myassert(sqlite3_changes(db) > changes);
-    myassert(sqlite3_total_changes(db) > changesT);
-    myassert(sqlite3_changes64(db) > changes64);
-    myassert(sqlite3_total_changes64(db) > changesT64);
+    affirm(total1 > 0);
+    affirm(sqlite3_changes(db) > changes);
+    affirm(sqlite3_total_changes(db) > changesT);
+    affirm(sqlite3_changes64(db) > changes64);
+    affirm(sqlite3_total_changes64(db) > changesT64);
     rc = sqlite3_prepare(db, "SELECT a FROM t ORDER BY a DESC;", stmt);
-    myassert(0 == rc);
+    affirm(0 == rc);
     int total2 = 0;
     while( SQLITE_ROW == sqlite3_step(stmt) ){
       total2 += sqlite3_column_int(stmt, 0);
       sqlite3_value sv = sqlite3_column_value(stmt, 0);
-      myassert( null != sv );
-      myassert( 0 != sv.getNativePointer() );
-      myassert( SQLITE_INTEGER == sqlite3_value_type(sv) );
+      affirm( null != sv );
+      affirm( 0 != sv.getNativePointer() );
+      affirm( SQLITE_INTEGER == sqlite3_value_type(sv) );
     }
     sqlite3_finalize(stmt);
-    myassert(total1 == total2);
+    affirm(total1 == total2);
     sqlite3_close_v2(db);
-    myassert(0 == db.getNativePointer());
+    affirm(0 == db.getNativePointer());
   }
 
   private static void testBindFetchInt64(){
@@ -239,13 +237,13 @@ public class Tester1 {
     }
     sqlite3_finalize(stmt);
     rc = sqlite3_prepare(db, "SELECT a FROM t ORDER BY a DESC;", stmt);
-    myassert(0 == rc);
+    affirm(0 == rc);
     long total2 = 0;
     while( SQLITE_ROW == sqlite3_step(stmt) ){
       total2 += sqlite3_column_int64(stmt, 0);
     }
     sqlite3_finalize(stmt);
-    myassert(total1 == total2);
+    affirm(total1 == total2);
     sqlite3_close_v2(db);
   }
 
@@ -263,16 +261,16 @@ public class Tester1 {
     }
     sqlite3_finalize(stmt);
     rc = sqlite3_prepare(db, "SELECT a FROM t ORDER BY a DESC;", stmt);
-    myassert(0 == rc);
+    affirm(0 == rc);
     double total2 = 0;
     int counter = 0;
     while( SQLITE_ROW == sqlite3_step(stmt) ){
       ++counter;
       total2 += sqlite3_column_double(stmt, 0);
     }
-    myassert(4 == counter);
+    affirm(4 == counter);
     sqlite3_finalize(stmt);
-    myassert(total2<=total1+0.01 && total2>=total1-0.01);
+    affirm(total2<=total1+0.01 && total2>=total1-0.01);
     sqlite3_close_v2(db);
   }
 
@@ -284,14 +282,14 @@ public class Tester1 {
     String list1[] = { "hell🤩", "w😃rld", "!" };
     for( String e : list1 ){
       rc = sqlite3_bind_text(stmt, 1, e);
-      myassert(0 == rc);
+      affirm(0 == rc);
       rc = sqlite3_step(stmt);
-      myassert(SQLITE_DONE==rc);
+      affirm(SQLITE_DONE==rc);
       sqlite3_reset(stmt);
     }
     sqlite3_finalize(stmt);
     rc = sqlite3_prepare(db, "SELECT a FROM t ORDER BY a DESC;", stmt);
-    myassert(0 == rc);
+    affirm(0 == rc);
     StringBuffer sbuf = new StringBuffer();
     int n = 0;
     while( SQLITE_ROW == sqlite3_step(stmt) ){
@@ -301,8 +299,8 @@ public class Tester1 {
       ++n;
     }
     sqlite3_finalize(stmt);
-    myassert(3 == n);
-    myassert("w😃rldhell🤩!".equals(sbuf.toString()));
+    affirm(3 == n);
+    affirm("w😃rldhell🤩!".equals(sbuf.toString()));
     sqlite3_close_v2(db);
   }
 
@@ -314,25 +312,25 @@ public class Tester1 {
     byte list1[] = { 0x32, 0x33, 0x34 };
     rc = sqlite3_bind_blob(stmt, 1, list1);
     rc = sqlite3_step(stmt);
-    myassert(SQLITE_DONE == rc);
+    affirm(SQLITE_DONE == rc);
     sqlite3_finalize(stmt);
     rc = sqlite3_prepare(db, "SELECT a FROM t ORDER BY a DESC;", stmt);
-    myassert(0 == rc);
+    affirm(0 == rc);
     int n = 0;
     int total = 0;
     while( SQLITE_ROW == sqlite3_step(stmt) ){
       byte blob[] = sqlite3_column_blob(stmt, 0);
-      myassert(3 == blob.length);
+      affirm(3 == blob.length);
       int i = 0;
       for(byte b : blob){
-        myassert(b == list1[i++]);
+        affirm(b == list1[i++]);
         total += b;
       }
       ++n;
     }
     sqlite3_finalize(stmt);
-    myassert(1 == n);
-    myassert(total == 0x32 + 0x33 + 0x34);
+    affirm(1 == n);
+    affirm(total == 0x32 + 0x33 + 0x34);
     sqlite3_close_v2(db);
   }
 
@@ -365,7 +363,7 @@ public class Tester1 {
         }
       };
     int rc = sqlite3_create_collation(db, "reversi", SQLITE_UTF8, myCollation);
-    myassert(0 == rc);
+    affirm(0 == rc);
     sqlite3_stmt stmt = new sqlite3_stmt();
     sqlite3_prepare(db, "SELECT a FROM t ORDER BY a COLLATE reversi", stmt);
     int counter = 0;
@@ -374,12 +372,12 @@ public class Tester1 {
       ++counter;
       //outln("REVERSI'd row#"+counter+": "+val);
       switch(counter){
-        case 1: myassert("c".equals(val)); break;
-        case 2: myassert("b".equals(val)); break;
-        case 3: myassert("a".equals(val)); break;
+        case 1: affirm("c".equals(val)); break;
+        case 2: affirm("b".equals(val)); break;
+        case 3: affirm("a".equals(val)); break;
       }
     }
-    myassert(3 == counter);
+    affirm(3 == counter);
     sqlite3_finalize(stmt);
     sqlite3_prepare(db, "SELECT a FROM t ORDER BY a", stmt);
     counter = 0;
@@ -388,16 +386,16 @@ public class Tester1 {
       ++counter;
       //outln("Non-REVERSI'd row#"+counter+": "+val);
       switch(counter){
-        case 3: myassert("c".equals(val)); break;
-        case 2: myassert("b".equals(val)); break;
-        case 1: myassert("a".equals(val)); break;
+        case 3: affirm("c".equals(val)); break;
+        case 2: affirm("b".equals(val)); break;
+        case 1: affirm("a".equals(val)); break;
       }
     }
-    myassert(3 == counter);
+    affirm(3 == counter);
     sqlite3_finalize(stmt);
-    myassert(!xDestroyCalled.value);
+    affirm(!xDestroyCalled.value);
     sqlite3_close(db);
-    myassert(xDestroyCalled.value);
+    affirm(xDestroyCalled.value);
   }
 
   private static void testToUtf8(){
@@ -409,7 +407,7 @@ public class Tester1 {
     */
     final byte[] ba = "a \0 b".getBytes(StandardCharsets.UTF_8);
     //out("\"a NUL b\" via getBytes(): ");
-    myassert( 5 == ba.length /* as opposed to 6 in modified utf-8 */);
+    affirm( 5 == ba.length /* as opposed to 6 in modified utf-8 */);
     //for( byte b : ba ) out( ""+b );
     //outln("");
   }
@@ -430,7 +428,7 @@ public class Tester1 {
       // Java...
       new SQLFunction.Scalar(){
         public void xFunc(sqlite3_context cx, sqlite3_value args[]){
-          myassert(db.getNativePointer()
+          affirm(db.getNativePointer()
                    == sqlite3_context_db_handle(cx).getNativePointer());
           int result = 0;
           for( sqlite3_value v : args ) result += sqlite3_value_int(v);
@@ -445,13 +443,13 @@ public class Tester1 {
 
     // Register and use the function...
     int rc = sqlite3_create_function(db, "myfunc", -1, SQLITE_UTF8, func);
-    assert(0 == rc);
-    assert(0 == xFuncAccum.value);
+    affirm(0 == rc);
+    affirm(0 == xFuncAccum.value);
     execSql(db, "SELECT myfunc(1,2,3)");
-    assert(6 == xFuncAccum.value);
-    assert( !xDestroyCalled.value );
+    affirm(6 == xFuncAccum.value);
+    affirm( !xDestroyCalled.value );
     sqlite3_close(db);
-    assert( xDestroyCalled.value );
+    affirm( xDestroyCalled.value );
   }
 
   private static void testUdfJavaObject(){
@@ -463,22 +461,22 @@ public class Tester1 {
         }
       };
     int rc = sqlite3_create_function(db, "myfunc", -1, SQLITE_UTF8, func);
-    assert(0 == rc);
+    affirm(0 == rc);
     sqlite3_stmt stmt = new sqlite3_stmt();
     sqlite3_prepare(db, "select myfunc()", stmt);
-    assert( 0 != stmt.getNativePointer() );
+    affirm( 0 != stmt.getNativePointer() );
     int n = 0;
     if( SQLITE_ROW == sqlite3_step(stmt) ){
       sqlite3_value v = sqlite3_column_value(stmt, 0);
-      assert( testResult.value == sqlite3_value_java_object(v) );
-      assert( testResult.value == sqlite3_value_java_casted(v, Long.class) );
-      assert( testResult.value ==
+      affirm( testResult.value == sqlite3_value_java_object(v) );
+      affirm( testResult.value == sqlite3_value_java_casted(v, Long.class) );
+      affirm( testResult.value ==
               sqlite3_value_java_casted(v, testResult.value.getClass()) );
-      assert( null == sqlite3_value_java_casted(v, Double.class) );
+      affirm( null == sqlite3_value_java_casted(v, Double.class) );
       ++n;
     }
     sqlite3_finalize(stmt);
-    assert( 1 == n );
+    affirm( 1 == n );
     sqlite3_close(db);
   }
 
@@ -496,14 +494,14 @@ public class Tester1 {
       };
     execSql(db, "CREATE TABLE t(a); INSERT INTO t(a) VALUES(1),(2),(3)");
     int rc = sqlite3_create_function(db, "myfunc", 1, SQLITE_UTF8, func);
-    assert(0 == rc);
+    affirm(0 == rc);
     sqlite3_stmt stmt = new sqlite3_stmt();
     sqlite3_prepare(db, "select myfunc(a) from t", stmt);
-    assert( 0 != stmt.getNativePointer() );
+    affirm( 0 != stmt.getNativePointer() );
     int n = 0;
     if( SQLITE_ROW == sqlite3_step(stmt) ){
       final int v = sqlite3_column_int(stmt, 0);
-      myassert( 6 == v );
+      affirm( 6 == v );
       ++n;
     }
     sqlite3_reset(stmt);
@@ -511,11 +509,11 @@ public class Tester1 {
     n = 0;
     if( SQLITE_ROW == sqlite3_step(stmt) ){
       final int v = sqlite3_column_int(stmt, 0);
-      myassert( 6 == v );
+      affirm( 6 == v );
       ++n;
     }
     sqlite3_finalize(stmt);
-    assert( 1==n );
+    affirm( 1==n );
     sqlite3_close(db);
   }
 
@@ -546,7 +544,7 @@ public class Tester1 {
         }
       };
     int rc = sqlite3_create_function(db, "winsumint", 1, SQLITE_UTF8, func);
-    myassert( 0 == rc );
+    affirm( 0 == rc );
     execSql(db, new String[] {
         "CREATE TEMP TABLE twin(x, y); INSERT INTO twin VALUES",
         "('a', 4),('b', 5),('c', 3),('d', 8),('e', 1)"
@@ -557,22 +555,22 @@ public class Tester1 {
                          "ORDER BY x ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING"+
                          ") AS sum_y "+
                          "FROM twin ORDER BY x;", stmt);
-    myassert( 0 == rc );
+    affirm( 0 == rc );
     int n = 0;
     while( SQLITE_ROW == sqlite3_step(stmt) ){
       final String s = sqlite3_column_text(stmt, 0);
       final int i = sqlite3_column_int(stmt, 1);
       switch(++n){
-        case 1: myassert( "a".equals(s) && 9==i ); break;
-        case 2: myassert( "b".equals(s) && 12==i ); break;
-        case 3: myassert( "c".equals(s) && 16==i ); break;
-        case 4: myassert( "d".equals(s) && 12==i ); break;
-        case 5: myassert( "e".equals(s) && 9==i ); break;
-        default: myassert( false /* cannot happen */ );
+        case 1: affirm( "a".equals(s) && 9==i ); break;
+        case 2: affirm( "b".equals(s) && 12==i ); break;
+        case 3: affirm( "c".equals(s) && 16==i ); break;
+        case 4: affirm( "d".equals(s) && 12==i ); break;
+        case 5: affirm( "e".equals(s) && 9==i ); break;
+        default: affirm( false /* cannot happen */ );
       }
     }
     sqlite3_finalize(stmt);
-    myassert( 5 == n );
+    affirm( 5 == n );
     sqlite3_close(db);
   }
 
@@ -621,23 +619,23 @@ public class Tester1 {
           switch(traceFlag){
             case SQLITE_TRACE_STMT:
               // pNative ==> sqlite3_stmt
-              myassert(x instanceof String); break;
+              affirm(x instanceof String); break;
             case SQLITE_TRACE_PROFILE:
               // pNative ==> sqlite3_stmt
-              myassert(x instanceof Long); break;
+              affirm(x instanceof Long); break;
             case SQLITE_TRACE_ROW:
               // pNative ==> sqlite3_stmt
             case SQLITE_TRACE_CLOSE:
               // pNative ==> sqlite3
-              myassert(null == x);
+              affirm(null == x);
           }
           return 0;
         }
       });
     execSql(db, "SELECT 1; SELECT 2");
-    myassert( 6 == counter.value );
+    affirm( 6 == counter.value );
     sqlite3_close(db);
-    myassert( 7 == counter.value );
+    affirm( 7 == counter.value );
   }
 
   private static void testBusy(){
@@ -647,10 +645,10 @@ public class Tester1 {
     final sqlite3 db2 = new sqlite3();
 
     int rc = sqlite3_open(dbName, db1);
-    myassert( 0 == rc );
+    affirm( 0 == rc );
     execSql(db1, "CREATE TABLE IF NOT EXISTS t(a)");
     rc = sqlite3_open(dbName, db2);
-    myassert( 0 == rc );
+    affirm( 0 == rc );
 
     final ValueHolder<Boolean> xDestroyed = new ValueHolder<>(false);
     final ValueHolder<Integer> xBusyCalled = new ValueHolder<>(0);
@@ -664,20 +662,20 @@ public class Tester1 {
         }
       };
     rc = sqlite3_busy_handler(db2, handler);
-    myassert(0 == rc);
+    affirm(0 == rc);
 
     // Force a locked condition...
     execSql(db1, "BEGIN EXCLUSIVE");
-    myassert( false == xDestroyed.value );
+    affirm( false == xDestroyed.value );
     sqlite3_stmt stmt = new sqlite3_stmt();
     rc = sqlite3_prepare(db2, "SELECT * from t", stmt);
-    myassert( SQLITE_BUSY == rc);
-    myassert( 3 == xBusyCalled.value );
+    affirm( SQLITE_BUSY == rc);
+    affirm( 3 == xBusyCalled.value );
     sqlite3_finalize(stmt);
     sqlite3_close(db1);
-    myassert( false == xDestroyed.value );
+    affirm( false == xDestroyed.value );
     sqlite3_close(db2);
-    myassert( true == xDestroyed.value );
+    affirm( true == xDestroyed.value );
     try{
       final java.io.File f = new java.io.File(dbName);
       f.delete();
@@ -686,9 +684,9 @@ public class Tester1 {
     }
   }
 
-  private static void testMisc(){
-    outln("Sleeping...");
-    sqlite3_sleep(500);
+  private static void testSleep(){
+    out("Sleeping briefly... ");
+    sqlite3_sleep(600);
     outln("Woke up.");
   }
 
@@ -713,10 +711,10 @@ public class Tester1 {
     testUdfWindow();
     testTrace();
     testBusy();
-    testMisc();
+    testSleep();
     if(liArgs.indexOf("-v")>0){
       listBoundMethods();
     }
-    outln("Tests done. "+assertCount+" assertion(s) checked.");
+    outln("Tests done. "+affirmCount+" assertion checked.");
   }
 }

diff --git a/manifest b/manifest
index 45a4ee951561139f765b5160bed61917db20d422..67eaf440842b7dda270bd369ca58c89f6eaea935 100644 (file)
--- a/manifest
+++ b/manifest
@@ -1,5 +1,5 @@
-C Add\slocking\stest\sfor\sBusyHandler\sand\sclear\sup\snew\s-Xlint:jni\swarnings\sintroduced\sby\sthe\sbusy-handler\sbinding.
-D 2023-07-27T22:42:25.017
+C Reformulate\sjni\stests\sto\snot\srequire\sthe\s-ea\sjvm\sflag\sto\senable\sassert().
+D 2023-07-27T22:53:02.373
 F .fossil-settings/empty-dirs dbb81e8fc0401ac46a1491ab34a7f2c7c0452f2f06b54ebb845d024ca8283ef1
 F .fossil-settings/ignore-glob 35175cdfcf539b2318cb04a9901442804be81cd677d8b889fcc9149c21f239ea
 F LICENSE.md df5091916dbb40e6e9686186587125e1b2ff51f022cc334e886c19a0e9982724
@@ -241,7 +241,7 @@ F ext/jni/src/org/sqlite/jni/OutputPointer.java 08a752b58a33696c5eaf0eb9361a0966
 F ext/jni/src/org/sqlite/jni/ProgressHandler.java 5a1d7b2607eb2ef596fcf4492a49d1b3a5bdea3af9918e11716831ffd2f02284
 F ext/jni/src/org/sqlite/jni/SQLFunction.java 2f5d197f6c7d73b6031ba1a19598d7e3eee5ebad467eeee62c72e585bd6556a5
 F ext/jni/src/org/sqlite/jni/SQLite3Jni.java 3582b30c0fb1cb39e25b9069fe8c9e2fe4f2659f4d38437b610e46143e163610
-F ext/jni/src/org/sqlite/jni/Tester1.java 7a5cc47aabca372a3bc9d078bdd90e10d00d517c3ebff19d023fd74272725ed9
+F ext/jni/src/org/sqlite/jni/Tester1.java 460d4a521bf3386a6aafc30c382817560b8dc1001472f6b8459cadeedb9a58ea
 F ext/jni/src/org/sqlite/jni/Tracer.java c2fe1eba4a76581b93b375a7b95ab1919e5ae60accfb06d6beb067b033e9bae1
 F ext/jni/src/org/sqlite/jni/ValueHolder.java f022873abaabf64f3dd71ab0d6037c6e71cece3b8819fa10bf26a5461dc973ee
 F ext/jni/src/org/sqlite/jni/sqlite3.java c7d0500c7269882243aafb41425928d094b2fcbdbc2fd1caffc276871cd3fae3
@@ -2067,8 +2067,8 @@ F vsixtest/vsixtest.tcl 6a9a6ab600c25a91a7acc6293828957a386a8a93
 F vsixtest/vsixtest.vcxproj.data 2ed517e100c66dc455b492e1a33350c1b20fbcdc
 F vsixtest/vsixtest.vcxproj.filters 37e51ffedcdb064aad6ff33b6148725226cd608e
 F vsixtest/vsixtest_TemporaryKey.pfx e5b1b036facdb453873e7084e1cae9102ccc67a0
-P 524747796a30a5c1c6c7567b49ffb1e35e2626c73e09c335c0ab74d4ddb5f005
-R 3c532f44a6a487cc227202d8226f03e9
+P 7dcde2bfce54b18f391776fa1cb93c0ff6153634bedcab0007b374c06c4d4079
+R ba5fe9ad4149aefc21881fee22f6fa73
 U stephan
-Z d6942649a24407ffbbac534429e75b47
+Z 2639e54196b7b2c8fbce104e63109714
 # Remove this line to create a well-formed Fossil manifest.

diff --git a/manifest.uuid b/manifest.uuid
index ab1bac84150a75334283505b32293e2027cbf34b..dea2791cda621a88ac93447481579efa30a755f9 100644 (file)
--- a/manifest.uuid
+++ b/manifest.uuid
@@ -1 +1 @@
-7dcde2bfce54b18f391776fa1cb93c0ff6153634bedcab0007b374c06c4d4079
\ No newline at end of file
+dc356667a8f4fa31a3fef1ae35873d834d27fd6a9f0818d6fb85e4751fde9fe5
\ No newline at end of file