Index: configf.scm
==================================================================
--- configf.scm
+++ configf.scm
@@ -217,16 +217,17 @@
(envar (and environ-patt (string-search (regexp environ-patt) curr-section-name)))
(realval (if envar
(config:eval-string-in-environment val)
val)))
(debug:print-info 6 "read-config env setting, envar: " envar " realval: " realval " val: " val " key: " key " curr-section-name: " curr-section-name)
- (if (and envar
- (string? realval)
- (not (string-search (integer->char 0) realval)))
- ;; (debug:print-info 4 "read-config key=" key ", val=" val ", realval=" realval)
- (setenv key realval)
- (debug:print 0 "ERROR: bad value for setenv, key=" key ", value=" realval))
+ (if envar
+ (if (and (string? realval)(string? key))
+ (handle-exceptions
+ exn
+ (debug:print 0 "ERROR: bad value for setenv, key=" key ", value=" realval)
+ (setenv key realval))
+ (debug:print 0 "ERROR: bad value for setenv, key=" key ", value=" realval)))
(hash-table-set! res curr-section-name
(config:assoc-safe-add alist key realval))
(loop (configf:read-line inp res allow-system) curr-section-name key #f)))
(configf:key-no-val ( x key val) (let* ((alist (hash-table-ref/default res curr-section-name '())))
(hash-table-set! res curr-section-name
Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -44,21 +44,20 @@
(define *completed-writes* (make-hash-table))
(define *incoming-last-time* (current-seconds))
(define *incoming-mutex* (make-mutex))
(define *completed-mutex* (make-mutex))
+;; Get/open a database
+;; if run-id => get run specific db
+;; if #f => get main db
+;; if db already open - return inmem
+;; if db not open, open inmem, rundb and sync then return inmem
+;;
(define (db:get-db dbstruct run-id)
- (let ((db (if run-id
- (hash-table-ref/default (vector-ref dbstruct 1) run-id #f)
- (vector-ref dbstruct 0))))
- (if db
- db
- (let ((db (open-db run-id)))
- (if run-id
- (hash-table-set! (vector-ref dbstruct 1) run-id db)
- (vector-set! dbstruct 0 db))
- db))))
+ (if run-id
+ (db:open-rundb dbstruct run-id)
+ (db:open-main dbstruct)))
(define (db:set-sync db)
(let* ((syncval (config-lookup *configdat* "setup" "synchronous"))
(val (cond ;; 0 | OFF | 1 | NORMAL | 2 | FULL;
((not syncval) #f)
@@ -73,11 +72,10 @@
#f))))
(if val
(begin
(debug:print-info 9 "db:set-sync, setting pragma synchronous to " val)
(sqlite3:execute db (conc "PRAGMA synchronous = '" val "';"))))))
-;; (sqlite3:execute db "PRAGMA synchronous = normal;")))) ;; need a default?
;;======================================================================
;; K E E P F I L E D B I N dbstruct
;;======================================================================
@@ -99,84 +97,72 @@
;;
(define (db:get-path dbstruct id)
(let ((fdb (db:get-filedb dbstruct)))
(filedb:get-path db id)))
-;;======================================================================
-;; U S E F I L E D B T O S T O R E S T R I N G S
-;;
-;; N O T E ! ! T H I S C L O B B E R S M U L T I P L E //// T O /
-;;
-;; Replace with something proper!
-;;
-;;======================================================================
-
-;; Use to save a stored string, pad with _ to deal with trimming the prepending of /
-;;
-(define (db:save-string dbstruct str)
- (let ((fdb (db:get-filedb dbstruct)))
- (filedb:register-path fdb (conc "_" str))))
-
-;; Use to get a stored string
-;;
-(define (db:get-string dbstruct id)
- (let ((fdb (db:get-filedb dbstruct)))
- (string-drop (filedb:get-path fdb id) 2)))
+;; This routine creates the db. It is only called if the db is not already opened
+;;
+(define (db:open-rundb dbstruct run-id) ;; (conc *toppath* "/megatest.db") (car *configinfo*)))
+ (let ((rdb (dbr:dbstruct-get-runrec dbstruct run-id 'inmem)))
+ (if rdb
+ rdb
+ (let* ((toppath (dbr:dbstruct-get-path dbstruct))
+ (dbpath (conc toppath "/db/" run-id ".db"))
+ (dbexists (file-exists? dbpath))
+ (inmem (open-inmem-db))
+ (db (sqlite3:open-database dbpath))
+ (write-access (file-write-access? dbpath))
+ (handler (make-busy-timeout 136000)))
+ (if (and dbexists (not write-access))
+ (set! *db-write-access* #f)) ;; only unset so other db's also can use this control
+ (if write-access
+ (begin
+ (sqlite3:set-busy-handler! db handler)
+ (sqlite3:execute db "PRAGMA synchronous = 0;")))
+ (if (not dbexists)(db:initialize-run-id-db db run-id))
+ (dbr:dbstruct-set-runvec! dbstruct run-id 'rundb db)
+ (dbr:dbstruct-set-runvec! dbstruct run-id 'inmem inmem)
+ inmem))))
;; This routine creates the db. It is only called if the db is not already opened
;;
-(define (open-db dbstruct run-id) ;; (conc *toppath* "/megatest.db") (car *configinfo*)))
- (if (not *toppath*)
- (if (not (setup-for-run))
- (begin
- (debug:print 0 "ERROR: Attempted to open db when not in megatest area. Exiting.")
- (exit))))
- (let* ((dbpath (if run-id
- (conc *toppath* "/db/" run-id ".db")
- (let ((dbdir (conc *toppath* "/db"))) ;; use this opportunity to create our db dir
- (if (not (directory-exists? dbdir))
- (create-direcory dbdir))
- (conc *toppath* "/megatest.db"))))
- (dbexists (file-exists? dbpath))
- (db (sqlite3:open-database dbpath)) ;; (never-give-up-open-db dbpath))
- (write-access (file-write-access? dbpath))
- (handler (make-busy-timeout (if (args:get-arg "-override-timeout")
- (string->number (args:get-arg "-override-timeout"))
- 136000)))) ;; 136000))) ;; 136000 = 2.2 minutes
- (if (and dbexists
- (not write-access))
- (set! *db-write-access* write-access)) ;; only unset so other db's also can use this control
- (debug:print-info 11 "open-db, dbpath=" dbpath " argv=" (argv))
- (if write-access (sqlite3:set-busy-handler! db handler))
- (if (not dbexists)
- (if (not run-id) ;; do the megatest.db
- (db:initialize-megatest-db db)
- (db:initialize-run-id-db db run-id)))
- (sqlite3:execute db "PRAGMA synchronous = 0;")
- db))
+(define (db:open-main dbstruct) ;; (conc *toppath* "/megatest.db") (car *configinfo*)))
+ (let ((mdb (dbr:dbstruct-get-main dbstruct)))
+ (if mdb
+ mdb
+ (let* ((toppath (dbr:dbstruct-get-path dbstruct))
+ (dbpath (let ((dbdir (conc *toppath* "/db"))) ;; use this opportunity to create our db dir
+ (if (not (directory-exists? dbdir))
+ (create-direcory dbdir))
+ (conc *toppath* "/db/main.db")))
+ (dbexists (file-exists? dbpath))
+ (db (sqlite3:open-database dbpath)) ;; (never-give-up-open-db dbpath))
+ (write-access (file-write-access? dbpath))
+ (handler (make-busy-timeout 136000)))
+ (if (and dbexists (not write-access))
+ (set! *db-write-access* #f))
+ (if write-access
+ (begin
+ (sqlite3:set-busy-handler! db handler)
+ (sqlite3:execute db "PRAGMA synchronous = 0;")))
+ (if (not dbexists)
+ (db:initialize-megatest-db db))
+ (dbr:dbstruct-set-main! dbstruct db)
+ db))))
;; close all opened run-id dbs
(define (db:close-all-db)
(for-each
(lambda (db)
(finalize! db))
(hash-table-values (vector-ref *open-dbs* 1)))
(finalize! (vector-ref *open-dbs* 0)))
-(define (open-in-mem-db)
- (let* ((path (configf:lookup *configdat* "setup" "tmpdb"))
- (fname (if path (conc path "/temp-megatest.db") #f))
- (exists (and path (file-exists? fname)))
- (db (if path
- (begin
- (create-directory path #t)
- (sqlite3:open-database fname))
- (sqlite3:open-database ":memory:")))
+(define (open-inmem-db)
+ (let* ((db (sqlite3:open-database ":memory:"))
(handler (make-busy-timeout 3600)))
- (if (or (not path)
- (not exists))
- (db:initialize db))
+ (db:initialize db)
(sqlite3:set-busy-handler! db handler)
(set! sdb:qry (make-sdb:qry)) ;; we open the normalization helpers here
(set! *fdb* (filedb:open-db (conc *toppath* "/db/paths.db")))
db))
@@ -312,124 +298,10 @@
(count (cdr dat)))
(if (> count 0)
(debug:print 0 (format #f " ~10a ~5a" tblname count)))))
(sort (hash-table->alist numrecs)(lambda (a b)(> (cdr a)(cdr b))))))))
-;; (define (db:sync-to fromdb todb)
-;; ;; strategy
-;; ;; 1. Get all run-ids
-;; ;; 2. For each run-id
-;; ;; a. Sync that run in a transaction
-;; (let ((trecchgd 0)
-;; (rrecchgd 0)
-;; (tmrecchgd 0))
-;;
-;; ;; First sync test_meta data
-;; (let ((tmgetstmt (sqlite3:prepare todb "SELECT id,testname,author,owner,description,reviewed,iterated,avg_runtime,avg_disk,tags,jobgroup FROM test_meta WHERE id=?;"))
-;; (tmputstmt (sqlite3:prepare todb "INSERT OR REPLACE INTO test_meta (id,testname,author,owner,description,reviewed,iterated,avg_runtime,avg_disk,tags,jobgroup)
-;; VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);"))
-;; (tmdats (db:testmeta-get-all fromdb)))
-;; ;; (debug:print 7 "Updating as many as " (length tdats) " records for run " run-id)
-;; (for-each
-;; (lambda (tmdat) ;; iterate over tests
-;; (let ((testm-id (vector-ref tmdat 0)))
-;; (sqlite3:with-transaction
-;; todb
-;; (lambda ()
-;; (let ((curr-tmdat #f))
-;; (sqlite3:for-each-row
-;; (lambda (a . b)
-;; (set! curr-tmdat (apply vector a b)))
-;; tmgetstmt testm-id)
-;; (if (not (equal? curr-tmdat tmdat)) ;; something changed
-;; (begin
-;; (debug:print 0 " test-id: " testm-id
-;; "\ncurr-tdat: " curr-tmdat
-;; "\n tdat: " tmdat)
-;; (apply sqlite3:execute tmputstmt (vector->list tmdat))
-;; (set! tmrecchgd (+ tmrecchgd 1)))))))))
-;; tmdats)
-;; (sqlite3:finalize! tmgetstmt)
-;; (sqlite3:finalize! tmputstmt))
-;;
-;; ;; First sync tests data
-;; (let ((run-ids (db:get-all-run-ids fromdb))
-;; (tgetstmt (sqlite3:prepare todb "SELECT id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment FROM tests WHERE id=?;"))
-;; (tputstmt (sqlite3:prepare todb "INSERT OR REPLACE INTO tests (id,run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment)
-;; VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? );")))
-;; (for-each
-;; (lambda (run-id)
-;; (let ((tdats (db:get-all-tests-info-by-run-id fromdb run-id)))
-;; ;; (debug:print 7 "Updating as many as " (length tdats) " records for run " run-id)
-;; (for-each
-;; (lambda (tdat) ;; iterate over tests
-;; (let ((test-id (vector-ref tdat 0)))
-;; (sqlite3:with-transaction
-;; todb
-;; (lambda ()
-;; (let ((curr-tdat #f))
-;; (sqlite3:for-each-row
-;; (lambda (a . b)
-;; (set! curr-tdat (apply vector a b)))
-;; tgetstmt
-;; test-id)
-;; (if (not (equal? curr-tdat tdat)) ;; something changed
-;; (begin
-;; (debug:print 0 " test-id: " test-id
-;; "\ncurr-tdat: " curr-tdat
-;; "\n tdat: " tdat)
-;; (apply sqlite3:execute tputstmt (vector->list tdat))
-;; (set! trecchgd (+ trecchgd 1)))))))))
-;; tdats)))
-;; run-ids)
-;; (sqlite3:finalize! tgetstmt)
-;; (sqlite3:finalize! tputstmt))
-;;
-;; ;; Next sync runs table
-;; (let* ((rdats '())
-;; (keys (db:get-keys fromdb))
-;; (rstdfields (conc "id," (string-intersperse keys ",") ",runname,state,status,owner,event_time,comment,fail_count,pass_count"))
-;; (rnumfields (length (string-split rstdfields ",")))
-;; (runslots (string-intersperse (make-list rnumfields "?") ","))
-;; (rgetstmt (sqlite3:prepare todb (conc "SELECT " rstdfields " FROM runs WHERE id=?;")))
-;; (rputstmt (sqlite3:prepare todb (conc "INSERT OR REPLACE INTO runs (" rstdfields ") VALUES ( " runslots " );"))))
-;; ;; first collect all the source run data
-;; (sqlite3:for-each-row
-;; (lambda (a . b)
-;; (set! rdats (cons (apply vector a b) rdats)))
-;; fromdb
-;; (conc "SELECT " rstdfields " FROM runs;"))
-;; (sqlite3:with-transaction
-;; todb
-;; (lambda ()
-;; (for-each
-;; (lambda (rdat)
-;; (let ((run-id (vector-ref rdat 0))
-;; (curr-rdat #f))
-;; ;; first get the current value of the equivalent row from the target
-;; ;; read, then insert/overwrite if different
-;; (sqlite3:for-each-row
-;; (lambda (a . b)
-;; (set! curr-rdat (apply vector a b)))
-;; rgetstmt
-;; run-id)
-;; (if (not (equal? curr-rdat rdat))
-;; (begin
-;; (debug:print 0 " run-id: " run-id
-;; "\ncurr-rdat: " curr-rdat
-;; "\n rdat: " rdat)
-;; (set! rrecchgd (+ rrecchgd 1))
-;; (apply sqlite3:execute rputstmt (vector->list rdat))))))
-;; rdats)))
-;; (sqlite3:finalize! rgetstmt)
-;; (sqlite3:finalize! rputstmt))
-;;
-;; (if (> rrecchgd 0) (debug:print 0 "synced " rrecchgd " changed records in runs table"))
-;; (if (> trecchgd 0) (debug:print 0 "synced " trecchgd " changed records in tests table"))
-;; (if (> tmrecchgd 0) (debug:print 0 "sync'd " tmrecchgd " changed records in test_meta table"))
-;; (+ rrecchgd trecchgd tmrecchgd)))
-
(define (db:sync-back)
(db:sync-tables (db:tbls *inmemdb*) *inmemdb* *db*)) ;; (db:sync-to *inmemdb* *db*))
;; keeping it around for debugging purposes only
(define (open-run-close-no-exception-handling proc idb . params)
@@ -1055,11 +927,11 @@
(let ((finalres (vector header res)))
;; (hash-table-set! *run-info-cache* run-id finalres)
finalres)))
(define (db:set-comment-for-run dbstruct run-id comment)
- (sqlite3:execute db "UPDATE runs SET comment=? WHERE id=?;" (sdb:qry 'getid comment) run-id))
+ (sqlite3:execute (db:get-db dbstruct #f) "UPDATE runs SET comment=? WHERE id=?;" (sdb:qry 'getid comment) run-id))
;; does not (obviously!) removed dependent data. But why not!!?
(define (db:delete-run dbstruct run-id)
;; First set any related tests to DELETED
(let ((db (db:get-db dbstruct run-id)))
Index: db_records.scm
==================================================================
--- db_records.scm
+++ db_records.scm
@@ -1,5 +1,75 @@
+;;======================================================================
+;; dbstruct
+;;======================================================================
+
+;;
+;; -path-|-megatest.db
+;; |-db-|-main.db
+;; |-monitor.db
+;; |-sdb.db
+;; |-fdb.db
+;; |-1.db
+;; |-<N>.db
+(define (make-dbr:dbstruct #!key (path #f))
+ (make-vector
+ #f ;; the main db (contains runs, test_meta etc.) NOT CACHED IN MEM
+ (make-hash-table) ;; run-id => [ rundb inmemdb last-mod last-read last-sync ]
+ #f ;; the global string db (use for state, status etc.)
+ path)) ;; path to database files/megatest area
+
+;; get and set main db
+(define-inline (dbr:dbstruct-get-main vec) (vector-ref vec 0))
+(define-inline (dbr:dbstruct-set-main! vec db)(vector-set! vec 0 db))
+
+;; get a rundb vector
+(define (dbr:dbstruct-get-rundb-rec vec run-id)
+ (let* ((dbhash (vector-ref vec 1))
+ (runvec (hash-table-ref/default dbhash run-id)))
+ (if runvec
+ runvec
+ (begin
+ (hash-table-set! dbhash run-id (vector #f #f -1 -1 -1))
+ (dbr:dbstruct-get-rundb-rec vec run-id)))))
+
+;; [ rundb inmemdb last-mod last-read last-sync ]
+(define-inline (dbr:dbstruct-field-name->num field-name)
+ (case field-name
+ ((rundb) 0) ;; the on-disk db
+ ((inmem) 1) ;; the in-memory db
+ ((mtime) 2) ;; last modification time
+ ((rtime) 3) ;; last read time
+ ((stime) 4) ;; last sync time
+ (else -1)))
+
+;; get/set rundb fields
+(define (dbr:dbstruct-get-runrec vec run-id field-name)
+ (let ((runvec (dbr:dbstruct-get-rundb-rec vec run-id)))
+ (vector-ref runvec (dbr:dbstruct-field-name->num field-name))))
+
+(define (dbr:dbstruct-set-runvec! vec run-id field-name val)
+ (let ((runvec (dbr:dbstruct-get-rundb-rec vec run-id)))
+ (vector-set! runvec (dbr:dbstruct-field-name->num field-name) rundb)))
+
+;; get/set inmemdb
+(define (dbr:dbstruct-get-inmemdb vec run-id)
+ (let ((runvec (dbr:dbstruct-get-rundb-rec vec run-id)))
+ (vector-ref runvec 1)))
+
+(define (dbr:dbstruct-set-inmemdb! vec run-id inmemdb)
+ (let ((runvec (dbr:dbstruct-get-rundb-rec vec run-id)))
+ (vector-set! runvec 1 inmemdb)))
+
+;; the string db
+(define-inline (dbr:dbstruct-get-strdb vec) (vector-ref vec 2))
+(define-inline (dbr:dbstruct-set-strdb! vec db)(vector-set! vec 2 db))
+
+;; path
+(define-inline (dbr:dbstruct-set-path! vec path)(vector-set! vec 3))
+(define-inline (dbr:dbstruct-get-path vec) (vector-ref vec 3))
+
+
(define (make-db:test)(make-vector 20))
(define-inline (db:test-get-id vec) (vector-ref vec 0))
(define-inline (db:test-get-run_id vec) (vector-ref vec 1))
(define-inline (db:test-get-testname vec) (vector-ref vec 2))
(define-inline (db:test-get-state vec) (vector-ref vec 3))
Index: tests/rununittest.sh
==================================================================
--- tests/rununittest.sh
+++ tests/rununittest.sh
@@ -1,10 +1,13 @@
#!/bin/bash
# Usage: rununittest.sh testname debuglevel
#
+# Ensure all is made
+(cd ..;make && make install)
+
# Clean setup
#
rm -f simplerun/megatest.db simplerun/monitor.db simplerun/db/monitor.db
rm -rf simplelinks/ simpleruns/
mkdir -p simplelinks simpleruns
ADDED tests/unittests/basicserver.scm
Index: tests/unittests/basicserver.scm
==================================================================
--- /dev/null
+++ tests/unittests/basicserver.scm
@@ -0,0 +1,114 @@
+;;======================================================================
+;; S E R V E R
+;;======================================================================
+
+;; Run like this:
+;;
+;; (cd ..;make && make install) && ./rununittest.sh server 1;(cd simplerun;megatest -stop-server 0)
+
+(set! *transport-type* 'http)
+
+(test "setup for run" #t (begin (setup-for-run)
+ (string? (getenv "MT_RUN_AREA_HOME"))))
+
+(test "server-register, get-best-server" #t (let ((res #f))
+ (open-run-close tasks:server-register tasks:open-db 1 "bob" 1234 100 'live 'http)
+ (set! res (open-run-close tasks:get-best-server tasks:open-db))
+ (number? (vector-ref res 3))))
+
+(test "de-register server" #f (let ((res #f))
+ (open-run-close tasks:server-deregister tasks:open-db "bob" port: 1234)
+ (vector? (open-run-close tasks:get-best-server tasks:open-db))))
+
+(define server-pid #f)
+
+;; Not sure how the following should work, replacing it with system of megatest -server
+;; (test "launch server" #t (let ((pid (process-fork (lambda ()
+;; ;; (daemon:ize)
+;; (server:launch 'http)))))
+;; (set! server-pid pid)
+;; (number? pid)))
+(system "../../bin/megatest -server - -debug 22 > server.log 2> server.log &")
+
+(let loop ((n 10))
+ (thread-sleep! 1) ;; need to wait for server to start.
+ (let ((res (open-run-close tasks:get-best-server tasks:open-db)))
+ (print "tasks:get-best-server returned " res)
+ (if (and (not res)
+ (> n 0))
+ (loop (- n 1)))))
+
+(test "get-best-server" #t (begin
+ (client:launch)
+ (let ((dat (open-run-close tasks:get-best-server tasks:open-db)))
+ (vector? dat))))
+
+(define *keys* (keys:config-get-fields *configdat*))
+(define *keyvals* (keys:target->keyval *keys* "a/b/c"))
+
+(test #f #t (string? (car *runremote*)))
+(test #f '(#t "successful login") (rmt:login)) ;; *runremote* *toppath* *my-client-signature*)))
+
+(test #f #f (rmt:get-test-info-by-id 99)) ;; get non-existant test
+
+;; RUNS
+(test #f 1 (rmt:register-run *keyvals* "firstrun" "new" "n/a" (current-user-name)))
+(test "get run info" "firstrun" (let ((rinfo (rmt:get-run-info 1)))
+ (vector-ref (vector-ref rinfo 1) 3)))
+(test "get runname from id" "firstrun" (rmt:get-run-name-from-id 1))
+
+;; TESTS
+(test "get tests (no data)" '() (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f))
+(test "register test" #t (rmt:general-call 'register-test 1 "test1" ""))
+(test "get tests (some data)" 1 (length (rmt:get-tests-for-run 1 "%" '() '() #f #f #f #f #f #f)))
+(test "get test id" 1 (rmt:get-test-id 1 "test1" ""))
+(test "sync back" #t (> (rmt:sync-inmem->db) 0))
+(test "get test id from main" 1 (db:get-test-id *db* 1 "test1" ""))
+(test "get keys" #t (list? (rmt:get-keys)))
+(test "set comment" #t (begin (rmt:general-call 'set-test-comment "this is a comment" 1) #t))
+(test "get comment" "this is a comment" (let ((trec (rmt:get-test-info-by-id 1)))
+ (db:test-get-comment trec)))
+
+;; MORE RUNS
+(test "get runs" #t (let* ((runs (rmt:get-runs "%" #f #f '()))
+ (header (vector-ref runs 0))
+ (data (vector-ref runs 1)))
+ (and (list? header)
+ (list? data)
+ (vector? (car data)))))
+
+(test "get local testinfo" "test1" (vector-ref (db:get-testinfo-state-status *db* 1) 2))
+(test "get testinfo" "test1" (vector-ref (rmt:get-testinfo-state-status 1) 2))
+
+;;======================================================================
+;; D B
+;;======================================================================
+
+(test "pass fail counts" #t (rmt:general-call 'pass-fail-counts 10 9 1))
+(test "get pass fail counts" 19 (let ((dat (rmt:get-test-info-by-id 1)))
+ (+ (db:test-get-pass_count dat)
+ (db:test-get-fail_count dat))))
+
+(define testregistry (make-hash-table))
+(for-each
+ (lambda (tname)
+ (for-each
+ (lambda (itempath)
+ (let ((tkey (conc tname "/" itempath))
+ (rpass (random 10))
+ (rfail (random 10)))
+ (hash-table-set! testregistry tkey (list tname itempath))
+ (rmt:general-call 'register-test 1 tname itempath)
+ (let* ((tid (rmt:get-test-id 1 tname itempath))
+ (tdat (rmt:get-test-info-by-id tid)))
+ (rmt:general-call 'pass-fail-counts rpass rfail (db:test-get-id tdat))
+ (let* ((resdat (rmt:get-test-info-by-id tid)))
+ (test "set/get pass fail counts" (list rpass rfail)
+ (list (db:test-get-pass_count resdat)
+ (db:test-get-fail_count resdat)))))))
+ (list "" "a" "b" "c" "d" "e" "f" "g" "h" "i" "j")))
+ (list "test1" "test2" "test3" "test4" "test5"))
+
+
+(test #f '(#t "exit process started") (rmt:kill-server)) ;; *toppath* *my-client-signature* #f)))
+