Return to ctime.test CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / test

sqlite3

    1: # 2009 February 24
    2: #
    3: # The author disclaims copyright to this source code.  In place of
    4: # a legal notice, here is a blessing:
    5: #
    6: #    May you do good and not evil.
    7: #    May you find forgiveness for yourself and forgive others.
    8: #    May you share freely, never taking more than you give.
    9: #
   10: #***********************************************************************
   11: # This file implements regression tests for SQLite library.
   12: #
   13: # This file implements tests for the compile time diagnostic 
   14: # functions.
   15: #
   16: 
   17: set testdir [file dirname $argv0]
   18: source $testdir/tester.tcl
   19: 
   20: # Test organization:
   21: #
   22: # ctime-1.*: Test pragma support.
   23: # ctime-2.*: Test function support.
   24: #
   25: 
   26: ifcapable !pragma||!compileoption_diags {
   27:   finish_test
   28:   return
   29: }
   30: 
   31: #####################
   32: # ctime-1.*: Test pragma support.
   33: 
   34: do_test ctime-1.1.1 {
   35:   catchsql {
   36:     PRAGMA compile_options();
   37:   }
   38: } {1 {near ")": syntax error}}
   39: do_test ctime-1.1.2 {
   40:   catchsql {
   41:     PRAGMA compile_options(NULL);
   42:   }
   43: } {1 {near "NULL": syntax error}}
   44: do_test ctime-1.1.3 {
   45:   catchsql {
   46:     PRAGMA compile_options *;
   47:   }
   48: } {1 {near "*": syntax error}}
   49: 
   50: do_test ctime-1.2.1 {
   51:   set ans [ catchsql {
   52:     PRAGMA compile_options;
   53:   } ]
   54:   list [ lindex $ans 0 ]
   55: } {0}
   56: # the results should be in sorted order already
   57: do_test ctime-1.2.2 {
   58:   set ans [ catchsql {
   59:     PRAGMA compile_options;
   60:   } ]
   61:   list [ lindex $ans 0 ] [ expr { [lsort [lindex $ans 1]]==[lindex $ans 1] } ]
   62: } {0 1}
   63: 
   64: # SQLITE_THREADSAFE should pretty much always be defined
   65: # one way or the other, and it must have a value of 0 or 1.
   66: do_test ctime-1.4.1 {
   67:   catchsql {
   68:     SELECT sqlite_compileoption_used('SQLITE_THREADSAFE');
   69:   }
   70: } {0 1}
   71: do_test ctime-1.4.2 {
   72:   catchsql {
   73:     SELECT sqlite_compileoption_used('THREADSAFE');
   74:   }
   75: } {0 1}
   76: do_test ctime-1.4.3 {
   77:   catchsql {
   78:     SELECT sqlite_compileoption_used("THREADSAFE");
   79:   }
   80: } {0 1}
   81: 
   82: do_test ctime-1.5 {
   83:   set ans1 [ catchsql {
   84:     SELECT sqlite_compileoption_used('THREADSAFE=0');
   85:   } ]
   86:   set ans2 [ catchsql {
   87:     SELECT sqlite_compileoption_used('THREADSAFE=1');
   88:   } ]
   89:   set ans3 [ catchsql {
   90:     SELECT sqlite_compileoption_used('THREADSAFE=2');
   91:   } ]
   92:   lsort [ list $ans1 $ans2 $ans3 ]
   93: } {{0 0} {0 0} {0 1}}
   94: 
   95: do_test ctime-1.6 {
   96:   execsql {
   97:     SELECT sqlite_compileoption_used('THREADSAFE=');
   98:   }
   99: } {0}
  100: 
  101: do_test ctime-1.7.1 {
  102:   execsql {
  103:     SELECT sqlite_compileoption_used('SQLITE_OMIT_COMPILEOPTION_DIAGS');
  104:   }
  105: } {0}
  106: do_test ctime-1.7.2 {
  107:   execsql {
  108:     SELECT sqlite_compileoption_used('OMIT_COMPILEOPTION_DIAGS');
  109:   }
  110: } {0}
  111: 
  112: #####################
  113: # ctime-2.*: Test function support.
  114: 
  115: do_test ctime-2.1.1 {
  116:   catchsql {
  117:     SELECT sqlite_compileoption_used();
  118:   }
  119: } {1 {wrong number of arguments to function sqlite_compileoption_used()}}
  120: do_test ctime-2.1.2 {
  121:   catchsql {
  122:     SELECT sqlite_compileoption_used(NULL);
  123:   }
  124: } {0 {{}}}
  125: do_test ctime-2.1.3 {
  126:   catchsql {
  127:     SELECT sqlite_compileoption_used("");
  128:   }
  129: } {0 0}
  130: do_test ctime-2.1.4 {
  131:   catchsql {
  132:     SELECT sqlite_compileoption_used('');
  133:   }
  134: } {0 0}
  135: do_test ctime-2.1.5 {
  136:   catchsql {
  137:     SELECT sqlite_compileoption_used(foo);
  138:   }
  139: } {1 {no such column: foo}}
  140: do_test ctime-2.1.6 {
  141:   catchsql {
  142:     SELECT sqlite_compileoption_used('THREADSAFE', 0);
  143:   }
  144: } {1 {wrong number of arguments to function sqlite_compileoption_used()}}
  145: do_test ctime-2.1.7 {
  146:   catchsql {
  147:     SELECT sqlite_compileoption_used(0);
  148:   }
  149: } {0 0}
  150: do_test ctime-2.1.8 {
  151:   catchsql {
  152:     SELECT sqlite_compileoption_used('0');
  153:   }
  154: } {0 0}
  155: do_test ctime-2.1.9 {
  156:   catchsql {
  157:     SELECT sqlite_compileoption_used(1.0);
  158:   }
  159: } {0 0}
  160: 
  161: do_test ctime-2.2.1 {
  162:   catchsql {
  163:     SELECT sqlite_compileoption_get();
  164:   }
  165: } {1 {wrong number of arguments to function sqlite_compileoption_get()}}
  166: do_test ctime-2.2.2 {
  167:   catchsql {
  168:     SELECT sqlite_compileoption_get(0, 0);
  169:   }
  170: } {1 {wrong number of arguments to function sqlite_compileoption_get()}}
  171: 
  172: # This assumes there is at least 1 compile time option
  173: # (see SQLITE_THREADSAFE above).
  174: do_test ctime-2.3 {
  175:   catchsql {
  176:     SELECT sqlite_compileoption_used(sqlite_compileoption_get(0));
  177:   }
  178: } {0 1}
  179: 
  180: # This assumes there is at least 1 compile time option
  181: # (see SQLITE_THREADSAFE above).
  182: do_test ctime-2.4 {
  183:   set ans [ catchsql {
  184:     SELECT sqlite_compileoption_get(0);
  185:   } ]
  186:   list [lindex $ans 0]
  187: } {0}
  188: 
  189: # Get the list of defines using the pragma,
  190: # then try querying each one with the functions.
  191: set ans [ catchsql {
  192:   PRAGMA compile_options;
  193: } ]
  194: set opts [ lindex $ans 1 ]
  195: set tc 1
  196: foreach opt $opts {
  197:   do_test ctime-2.5.$tc {
  198:     set N [ expr {$tc-1} ]
  199:     set ans1 [ catchsql {
  200:       SELECT sqlite_compileoption_get($N);
  201:     } ]
  202:     set ans2 [ catchsql {
  203:       SELECT sqlite_compileoption_used($opt);
  204:     } ]
  205:     list [ lindex $ans1 0 ] [ expr { [lindex $ans1 1]==$opt } ] \
  206:          [ expr { $ans2 } ]
  207:   } {0 1 {0 1}}
  208:   incr tc 1
  209: }
  210: # test 1 past array bounds
  211: do_test ctime-2.5.$tc {
  212:   set N [ expr {$tc-1} ]
  213:   set ans [ catchsql {
  214:     SELECT sqlite_compileoption_get($N);
  215:   } ]
  216: } {0 {{}}}
  217: incr tc 1
  218: # test 1 before array bounds (N=-1)
  219: do_test ctime-2.5.$tc {
  220:   set N -1
  221:   set ans [ catchsql {
  222:     SELECT sqlite_compileoption_get($N);
  223:   } ]
  224: } {0 {{}}}
  225: 
  226: 
  227: finish_test