Index: archive.scm
==================================================================
--- archive.scm
+++ archive.scm
@@ -125,17 +125,17 @@
 
     ;; from the test info bin the path to the test by stem
     ;;
     (for-each
      (lambda (test-dat)
-       (let* ((item-path         (db:test-get-item-path test-dat))
-	      (test-name         (db:test-get-testname  test-dat))
-	      (test-id           (db:test-get-id        test-dat))
-	      (run-id            (db:test-get-run_id    test-dat))
+       (let* ((item-path         (db:test-item-path test-dat))
+	      (test-name         (db:test-testname  test-dat))
+	      (test-id           (db:test-id        test-dat))
+	      (run-id            (db:test-run_id    test-dat))
 	      (target            (string-intersperse (map cadr (rmt:get-key-val-pairs run-id)) "/"))
 	      
-	      (toplevel/children (and (db:test-get-is-toplevel test-dat)
+	      (toplevel/children (and (db:test-is-toplevel test-dat)
 				      (> (rmt:test-toplevel-num-items run-id test-name) 0)))
 	      (test-partial-path (conc target "/" run-name "/" (db:test-make-full-name test-name item-path)))
 	      ;; note the trailing slash to get the dir inspite of it being a link
 	      (test-path         (conc linktree "/" test-partial-path))
 	      (mutex-lock! rp-mutex)
@@ -198,12 +198,12 @@
 	 (debug:print-info 0 "Archiving data with bup")
 	 (run-n-wait bup-exe params: bup-save-params print-cmd: print-prefix)
 	 ;; (mutex-unlock! bup-mutex)
 	 (for-each
 	  (lambda (test-dat)
-	    (let ((test-id           (db:test-get-id        test-dat))
-		  (run-id            (db:test-get-run_id    test-dat)))
+	    (let ((test-id           (db:test-id        test-dat))
+		  (run-id            (db:test-run_id    test-dat)))
 	      (rmt:test-set-archive-block-id run-id test-id archive-id)
 	      (if (member archive-command '("save-remove"))
 		  (runs:remove-test-directory test-dat 'archive-remove))))
 	  (hash-table-ref test-groups disk-group))))
      (hash-table-keys disk-groups))
@@ -219,18 +219,18 @@
     ;;
     (for-each
      (lambda (test-dat)
        ;; When restoring test-dat will initially contain an old and invalid path to the test
        (let* ((best-disk         (get-best-disk *configdat* #f)) ;; BUG: get the testconfig and use it here. Otherwise data pulled out of archive could end up on the wrong kind of disk.
-	      (item-path         (db:test-get-item-path test-dat))
-	      (test-name         (db:test-get-testname  test-dat))
-	      (test-id           (db:test-get-id        test-dat))
-	      (run-id            (db:test-get-run_id    test-dat))
+	      (item-path         (db:test-item-path test-dat))
+	      (test-name         (db:test-testname  test-dat))
+	      (test-id           (db:test-id        test-dat))
+	      (run-id            (db:test-run_id    test-dat))
 	      (keyvals           (rmt:get-key-val-pairs run-id))
 	      (target            (string-intersperse (map cadr keyvals) "/"))
 	      
-	      (toplevel/children (and (db:test-get-is-toplevel test-dat)
+	      (toplevel/children (and (db:test-is-toplevel test-dat)
 				      (> (rmt:test-toplevel-num-items run-id test-name) 0)))
 	      (test-partial-path (conc target "/" run-name "/" (db:test-make-full-name test-name item-path)))
 	      ;; note the trailing slash to get the dir inspite of it being a link
 	      (test-path         (conc linktree "/" test-partial-path))
 	      ;; if the old path was not deleted then prev-test-physical-path will end up pointing to a real directory
@@ -239,11 +239,11 @@
 					   ;; (read-symbolic-link test-path #t)
 					   (common:real-path test-path)
 					   #f))
 	      (mutex-unlock! rp-mutex)
 	      (new-test-physical-path  (conc best-disk "/" test-partial-path))
-	      (archive-block-id        (db:test-get-archived test-dat))
+	      (archive-block-id        (db:test-archived test-dat))
 	      (archive-block-info      (rmt:test-get-archive-block-info archive-block-id))
 	      (archive-path            (if (vector? archive-block-info)
 					   (vector-ref archive-block-info 2) ;; look in db.scm for test-get-archive-block-info for the vector record info
 					   #f)) ;; no archive found?
 	      (archive-internal-path   (conc (common:get-testsuite-name) "-" run-id "/latest/" test-partial-path)))
@@ -274,11 +274,11 @@
 	       ;; bup -d /tmp/matt/adisk1/2015_q1/fullrun_e1a40/ restore -C /tmp/seeme fullrun-30/latest/ubuntu/nfs/none/w02.1.20.54_b/
 
 	       ;; DO BUP RESTORE
 	       (let* ((new-test-dat        (rmt:get-test-info-by-id run-id test-id))
 		      (new-test-path       (if (vector? new-test-dat )
-					       (db:test-get-rundir new-test-dat)
+					       (db:test-rundir new-test-dat)
 					       (begin
 						 (debug:print 0 "ERROR: unable to get data for run-id=" run-id ", test-id=" test-id)
 						 (exit 1))))
 		      ;; new-test-path won't work - must use best-disk instead? Nope, new-test-path but tack on /..
 		      (bup-restore-params  (list "-d" archive-path "restore" "-C" (conc new-test-path "/..") archive-internal-path)))

Index: dashboard-tests.scm
==================================================================
--- dashboard-tests.scm
+++ dashboard-tests.scm
@@ -67,35 +67,35 @@
 			      "Test date: "))
 		   (list (iup:label "" #:expand "VERTICAL"))))
     (apply iup:vbox  ; #:expand "YES"
 	   (list 
 	    (store-label "testname"
-			 (iup:label (db:test-get-testname  testdat) #:expand "HORIZONTAL")
-			 (lambda (testdat)(db:test-get-testname testdat)))
+			 (iup:label (db:test-testname  testdat) #:expand "HORIZONTAL")
+			 (lambda (testdat)(db:test-testname testdat)))
 	    (store-label "item-path"
-			 (iup:label (db:test-get-item-path testdat) #:expand "HORIZONTAL")
-			 (lambda (testdat)(db:test-get-item-path testdat)))
+			 (iup:label (db:test-item-path testdat) #:expand "HORIZONTAL")
+			 (lambda (testdat)(db:test-item-path testdat)))
 	    (store-label "teststate" 
-			 (iup:label (db:test-get-state testdat) #:expand "HORIZONTAL")
+			 (iup:label (db:test-state testdat) #:expand "HORIZONTAL")
 			 (lambda (testdat)
-			   (db:test-get-state testdat)))
-	    (let ((lbl   (iup:label (db:test-get-status testdat) #:expand "HORIZONTAL")))
+			   (db:test-state testdat)))
+	    (let ((lbl   (iup:label (db:test-status testdat) #:expand "HORIZONTAL")))
 	      (hash-table-set! widgets "teststatus"
 			       (lambda (testdat)
-				 (let ((newstatus (db:test-get-status testdat))
+				 (let ((newstatus (db:test-status testdat))
 				       (oldstatus (iup:attribute lbl "TITLE")))
 				   (if (not (equal? oldstatus newstatus))
 				       (begin
-					 (iup:attribute-set! lbl "FGCOLOR" (car (gutils:get-color-for-state-status (db:test-get-state testdat)
-														   (db:test-get-status testdat))))
-					 (iup:attribute-set! lbl "TITLE" (db:test-get-status testdat)))))))
+					 (iup:attribute-set! lbl "FGCOLOR" (car (gutils:get-color-for-state-status (db:test-state testdat)
+														   (db:test-status testdat))))
+					 (iup:attribute-set! lbl "TITLE" (db:test-status testdat)))))))
 	      lbl)
 	    (store-label "testcomment"
 			 (iup:label "TestComment                             "
 				    #:expand "HORIZONTAL")
 			 (lambda (testdat)
-			   (let ((newcomment (db:test-get-comment testdat)))
+			   (let ((newcomment (db:test-comment testdat)))
 			     (if *dashboard-comment-share-slot*
 				 (if (not (equal? (iup:attribute *dashboard-comment-share-slot* "VALUE")
 						  newcomment))
 				     (iup:attribute-set! *dashboard-comment-share-slot*
 							 "VALUE"
@@ -103,16 +103,16 @@
 			     newcomment)))
 	    (store-label "testid"
 			 (iup:label "TestId                             "
 				    #:expand "HORIZONTAL")
 			 (lambda (testdat)
-			   (db:test-get-id testdat)))
+			   (db:test-id testdat)))
 	    (store-label "testdate" 
 			 (iup:label "TestDate                           "
 				    #:expand "HORIZONTAL")
 			 (lambda (testdat)
-			   (seconds->work-week/day-time (db:test-get-event_time testdat))))
+			   (seconds->work-week/day-time (db:test-event_time testdat))))
 	    )))))
 
 ;;======================================================================
 ;; Test meta panel
 ;;======================================================================
@@ -157,11 +157,11 @@
 
 ;;======================================================================
 ;; Run info panel
 ;;======================================================================
 (define (run-info-panel db keydat testdat runname)
-  (let* ((run-id     (db:test-get-run_id testdat))
+  (let* ((run-id     (db:test-run_id testdat))
 	 (rundat     (db:get-run-info db run-id))
 	 (header     (db:get-header rundat))
 	 (event_time (db:get-value-by-header (db:get-rows rundat)
 					     (db:get-header rundat)
 					     "event_time")))
@@ -206,32 +206,32 @@
     (apply iup:vbox ; #:expand "YES"
 	   (list
 	    ;; NOTE: Yes, the host can change!
 	    (store-label "HostName"
 			 (iup:label ;; (sdb:qry 'getstr 
-			  (db:test-get-host testdat) ;; )
+			  (db:test-host testdat) ;; )
 			  #:expand "HORIZONTAL")
-			 (lambda (testdat)(db:test-get-host testdat)))
+			 (lambda (testdat)(db:test-host testdat)))
 	    (store-label "DiskFree"
-			 (iup:label (conc (db:test-get-diskfree testdat)) #:expand "HORIZONTAL")
-			 (lambda (testdat)(conc (db:test-get-diskfree testdat))))
+			 (iup:label (conc (db:test-diskfree testdat)) #:expand "HORIZONTAL")
+			 (lambda (testdat)(conc (db:test-diskfree testdat))))
 	    (store-label "CPULoad"
-			 (iup:label (conc (db:test-get-cpuload testdat)) #:expand "HORIZONTAL")
-			 (lambda (testdat)(conc (db:test-get-cpuload testdat))))
+			 (iup:label (conc (db:test-cpuload testdat)) #:expand "HORIZONTAL")
+			 (lambda (testdat)(conc (db:test-cpuload testdat))))
 	    (store-label "RunDuration"
-			 (iup:label (conc (seconds->hr-min-sec (db:test-get-run_duration testdat))) #:expand "HORIZONTAL")
-			 (lambda (testdat)(conc (seconds->hr-min-sec (db:test-get-run_duration testdat)))))
+			 (iup:label (conc (seconds->hr-min-sec (db:test-run_duration testdat))) #:expand "HORIZONTAL")
+			 (lambda (testdat)(conc (seconds->hr-min-sec (db:test-run_duration testdat)))))
 	    (store-label "LogFile"
-			 (iup:label (conc (db:test-get-final_logf testdat)) #:expand "HORIZONTAL")
-			 (lambda (testdat)(conc (db:test-get-final_logf testdat))))
+			 (iup:label (conc (db:test-final_logf testdat)) #:expand "HORIZONTAL")
+			 (lambda (testdat)(conc (db:test-final_logf testdat))))
 	    (store-label "ProcessId"
-			 (iup:label (conc (db:test-get-process_id testdat)) #:expand "HORIZONTAL")
-			 (lambda (testdat)(conc (db:test-get-process_id testdat))))
+			 (iup:label (conc (db:test-process_id testdat)) #:expand "HORIZONTAL")
+			 (lambda (testdat)(conc (db:test-process_id testdat))))
 	    (store-label "Uname"
 			 (iup:label "                                                   " #:expand "HORIZONTAL") ;;  #:wordwrap "YES")
 			 (lambda (testdat) ;; (sdb:qry 'getstr 
-			   (db:test-get-uname testdat))) ;; )
+			   (db:test-uname testdat))) ;; )
 	    )))))
 
 ;; if there is a submegatest create a button to launch dashboard in that area
 ;;
 (define (submegatest-panel dbstruct keydat testdat runname testconfig)
@@ -249,12 +249,12 @@
 
 ;; use a global for setting the buttons colors
 ;;                           state status teststeps
 (define *state-status* (vector #f #f #f))
 (define (update-state-status-buttons testdat)
-  (let* ((state  (db:test-get-state  testdat))
-	 (status (db:test-get-status testdat))
+  (let* ((state  (db:test-state  testdat))
+	 (status (db:test-status testdat))
 	 (color  (car (gutils:get-color-for-state-status state status))))
     ((vector-ref *state-status* 0) state color)
     ((vector-ref *state-status* 1) status color)))
 
 (define *dashboard-test-db* #t)
@@ -275,11 +275,11 @@
 		(let ((txtbox (iup:textbox #:action (lambda (val a b)
 						      (rmt:test-set-state-status-by-id run-id test-id #f #f b)
 						      ;; IDEA: Just set a variable with the proc to call?
 						      (rmt:test-set-state-status-by-id run-id test-id #f #f b)
 						      (set! newcomment b))
-					   #:value (db:test-get-comment testdat)
+					   #:value (db:test-comment testdat)
 					   #:expand "HORIZONTAL")))
 		  (set! wtxtbox txtbox)
 		  txtbox))
 		  
       (apply iup:hbox
@@ -287,11 +287,11 @@
 	     (let* ((btns  (map (lambda (state)
 				  (let ((btn (iup:button state
 							 #:expand "HORIZONTAL" #:size "50x" #:font "Courier New, -10"
 							 #:action (lambda (x)
 								    (rmt:test-set-state-status-by-id run-id test-id state #f #f)
-								    (db:test-set-state! testdat state)))))
+								    (db:test-state-set! testdat state)))))
 				    btn))
 				(map cadr *common:std-states*)))) ;; (list "COMPLETED" "NOT_STARTED" "RUNNING" "REMOTEHOSTSTART" "LAUNCHED" "KILLED" "KILLREQ"))))
 	       (vector-set! *state-status* 0
 			    (lambda (state color)
 			      (for-each 
@@ -320,11 +320,11 @@
 														    (if (not *dashboard-comment-share-slot*)
 															(set! *dashboard-comment-share-slot* wtxtbox)))
 														  ))))
 									  (begin
 									    (rmt:test-set-state-status-by-id run-id test-id #f status #f)
-									    (db:test-set-status! testdat status))))))))
+									    (db:test-status-set! testdat status))))))))
 				    btn))
 				(map cadr *common:std-statuses*)))) ;; (list  "PASS" "WARN" "FAIL" "CHECK" "n/a" "WAIVED" "SKIP"))))
 	       (vector-set! *state-status* 1
 			    (lambda (status color)
 			      (for-each 
@@ -378,34 +378,34 @@
 					(if wpatt
 					    (if (string-match wregx b)
 						(iup:attribute-set! wmesg "TITLE" (conc "Comment matches " wpatt))
 						(iup:attribute-set! wmesg "TITLE" (conc "Comment does not match " wpatt))
 						)))
-			     #:value (if ovrdval ovrdval (db:test-get-comment testdat))
+			     #:value (if ovrdval ovrdval (db:test-comment testdat))
 			     #:expand "HORIZONTAL"))
 	 (dlog  #f))
     (set! dlog (iup:dialog ;; #:close_cb (lambda (a)(exit)) ; #:expand "YES"
 		#:title "SET WAIVER"
 		(iup:vbox ; #:expand "YES"
 		 (iup:label (conc "Enter justification for waiving test "
-				  (db:test-get-testname testdat)
-				  (if (equal? (db:test-get-item-path testdat) "") 
+				  (db:test-testname testdat)
+				  (if (equal? (db:test-item-path testdat) "") 
 				      ""
-				      (conc "/" (db:test-get-item-path testdat)))))
+				      (conc "/" (db:test-item-path testdat)))))
 		 wmesg ;; the informational msg on whether it matches
 		 comnt
 		 (iup:hbox
 		  (iup:button "Apply and Close "
 			      #:expand "HORIZONTAL"
 			      #:action (lambda (obj)
 					 (let ((comment (iup:attribute comnt "VALUE"))
-					       (test-id (db:test-get-id testdat)))
+					       (test-id (db:test-id testdat)))
 					   (if (or (not wpatt)
 						   (string-match wregx comment))
 					       (begin
 						 (rmt:test-set-state-status-by-id run-id test-id #f "WAIVED" comment)
-						 (db:test-set-status! testdat "WAIVED")
+						 (db:test-status-set! testdat "WAIVED")
 						 (cmtcmd comment)
 						 (iup:destroy! dlog))))))
 		  (iup:button "Cancel"
 			      #:expand "HORIZONTAL" 
 			      #:action (lambda (obj)
@@ -426,11 +426,11 @@
 	 (request-update #t))
     (if (not testdat)
 	(begin
 	  (debug:print 2 "ERROR: No test data found for test " test-id ", exiting")
 	  (exit 1))
-	(let* (;; (run-id        (if testdat (db:test-get-run_id testdat) #f))
+	(let* (;; (run-id        (if testdat (db:test-run_id testdat) #f))
 	       (test-registry (tests:get-all))
 	       (keydat        (if testdat (rmt:get-key-val-pairs run-id) #f))
 	       (rundat        (if testdat (rmt:get-run-info run-id) #f))
 	       (runname       (if testdat (db:get-value-by-header (db:get-rows rundat)
 								  (db:get-header rundat)
@@ -438,16 +438,16 @@
 	       ;; (tdb           (tdb:open-test-db-by-test-id-local dbstruct run-id test-id))
 	       ;; These next two are intentional bad values to ensure errors if they should not
 	       ;; get filled in properly.
 	       (logfile       "/this/dir/better/not/exist")
 	       (rundir        (if testdat 
-				  (db:test-get-rundir testdat)
+				  (db:test-rundir testdat)
 				  logfile))
 	       ;; (testdat-path  (conc rundir "/testdat.db")) ;; this gets recalculated until found 
 	       (teststeps     (if testdat (tests:get-compressed-steps #f run-id test-id) '()))
-	       (testfullname  (if testdat (db:test-get-fullname testdat) "Gathering data ..."))
-	       (testname      (if testdat (db:test-get-testname testdat) "n/a"))
+	       (testfullname  (if testdat (db:test-fullname testdat) "Gathering data ..."))
+	       (testname      (if testdat (db:test-testname testdat) "n/a"))
 	       ;; (tests:get-testconfig testdat testname 'return-procs))
 	       (testmeta      (if testdat 
 				  (let ((tm (rmt:testmeta-get-record testname)))
 				    (if tm tm (make-db:testmeta)))
 				  (make-db:testmeta)))
@@ -456,11 +456,11 @@
 			    (map (lambda (keyval)
 				   ;; (conc ":" (car keyval) " " (cadr keyval)))
 				   (cadr keyval))
 				 keydat)
 			    "/"))
-	       (item-path  (db:test-get-item-path testdat))
+	       (item-path  (db:test-item-path testdat))
 	       ;; this next block was added to fix a bug where variables were
                ;; needed. Revisit this.
 	       (runconfig  (let ((runconfigf (conc  *toppath* "/runconfigs.config")))
 	 		     (if (file-exists? runconfigf)
 	 			 (handle-exceptions
@@ -471,12 +471,12 @@
 	       (testconfig    (begin
 				;; (runs:set-megatest-env-vars run-id inrunname: runname testname: test-name itempath: item-path)
 				(runs:set-megatest-env-vars run-id inkeyvals: keydat inrunname: runname intarget: keystring testname: testname itempath: item-path) ;; these may be needed by the launching process
 				(handle-exceptions
 				 exn
-				 (tests:get-testconfig (db:test-get-testname testdat) test-registry #f)
-				 (tests:get-testconfig (db:test-get-testname testdat) test-registry #t))))
+				 (tests:get-testconfig (db:test-testname testdat) test-registry #f)
+				 (tests:get-testconfig (db:test-testname testdat) test-registry #t))))
 	       (viewlog    (lambda (x)
 			     (if (file-exists? logfile)
 					;(system (conc "firefox " logfile "&"))
 				 (dashboard-tests:run-html-viewer logfile)
 				 (message-window (conc "File " logfile " not found")))))
@@ -518,14 +518,14 @@
 			       ;; (debug:print-info 0 "need-update= " need-update " curr-mod-time = " curr-mod-time)
 			       (cond
 				((and need-update newtestdat)
 				 (set! testdat newtestdat)
 				 (set! teststeps    (tests:get-compressed-steps #f run-id test-id))
-				 (set! logfile      (conc (db:test-get-rundir testdat) "/" (db:test-get-final_logf testdat)))
+				 (set! logfile      (conc (db:test-rundir testdat) "/" (db:test-final_logf testdat)))
 				 (set! rundir       ;; (filedb:get-path *fdb* 
-				       (db:test-get-rundir testdat)) ;; )
-				 (set! testfullname (db:test-get-fullname testdat))
+				       (db:test-rundir testdat)) ;; )
+				 (set! testfullname (db:test-fullname testdat))
 				 ;; (debug:print 0 "INFO: teststeps=" (intersperse teststeps "\n    "))
 				 
 				 ;; I don't see why this was implemented this way. Please comment it ...
 				 ;; (if (eq? curr-mod-time db-mod-time) ;; do only once if same
 				 ;;     (set! db-mod-time (+ curr-mod-time 1))
@@ -535,11 +535,11 @@
 				     (set! db-mod-time curr-mod-time))
 				 (set! last-update (current-milliseconds))
 				 (set! request-update #f) ;; met the need ...
 				 )
 				(need-update ;; if this was true and yet there is no data ....
-				 (db:test-set-testname! testdat "DEAD OR DELETED TEST")))
+				 (db:test-testname-set! testdat "DEAD OR DELETED TEST")))
 			       (if need-update
 				   (begin
 				     ;; update the gui elements here
 				     (for-each 
 				      (lambda (key)

Index: dashboard.scm
==================================================================
--- dashboard.scm
+++ dashboard.scm
@@ -216,16 +216,16 @@
 	 (c2    (map string->number (string-split color2)))
 	 (delta (map (lambda (a b)(abs (- a b))) c1 c2)))
     (null? (filter (lambda (x)(> x 3)) delta))))
 
 (define (compare-tests test1 test2)
-  (let* ((test-name1  (db:test-get-testname  test1))
-	 (item-path1  (db:test-get-item-path test1))
-	 (eventtime1  (db:test-get-event_time test1))
-	 (test-name2  (db:test-get-testname  test2))
-	 (item-path2  (db:test-get-item-path test2))
-	 (eventtime2  (db:test-get-event_time test2))
+  (let* ((test-name1  (db:test-testname  test1))
+	 (item-path1  (db:test-item-path test1))
+	 (eventtime1  (db:test-event_time test1))
+	 (test-name2  (db:test-testname  test2))
+	 (item-path2  (db:test-item-path test2))
+	 (eventtime2  (db:test-event_time test2))
 	 (same-name   (equal? test-name1 test-name2))
 	 (test1-top   (equal? item-path1 ""))
 	 (test2-top   (equal? item-path2 ""))
 	 (test1-older (> eventtime1 eventtime2))
 	 (same-time   (equal? eventtime1 eventtime2)))			 
@@ -388,12 +388,12 @@
 
 ;; 
 (define (get-itemized-tests test-dats)
   (let ((tnames '()))
     (for-each (lambda (tdat)
-		(let ((tname (vector-ref tdat 0))  ;; (db:test-get-testname tdat))
-		      (ipath (vector-ref tdat 1))) ;; (db:test-get-item-path tdat)))
+		(let ((tname (vector-ref tdat 0))  ;; (db:test-testname tdat))
+		      (ipath (vector-ref tdat 1))) ;; (db:test-item-path tdat)))
 		  (if (not (equal? ipath ""))
 		      (if (and (list? tnames)
 			       (string? tname)
 			       (not (member tname tnames)))
 			  (set! tnames (append tnames (list tname)))))))
@@ -410,12 +410,12 @@
 	(let* ((tnames   '())                ;; list of names used to reserve order
 	       (tests    (make-hash-table))  ;; hash of lists, used to build as we go
 	       (itemized (get-itemized-tests test-dats)))
 	  (for-each 
 	   (lambda (testdat)
-	     (let* ((tname (vector-ref testdat 0))  ;; db:test-get-testname testdat))
-		    (ipath (vector-ref testdat 1))) ;; db:test-get-item-path testdat)))
+	     (let* ((tname (vector-ref testdat 0))  ;; db:test-testname testdat))
+		    (ipath (vector-ref testdat 1))) ;; db:test-item-path testdat)))
 	       ;;   (seen  (hash-table-ref/default tests tname #f)))
 	       (if (not (member tname tnames))
 		   (if (or (and (eq? priority 'itempath)
 				(not (equal? ipath "")))
 			   (and (eq? priority 'testname)
@@ -510,17 +510,17 @@
 							(lambda (x)(equal? (test:test-get-fullname x) testname))
 							testsdat)))
 					 (if (null? matching)
 					     (vector -1 -1 "" "" "" 0 "" "" 0 "" "" "" 0 "" "")
 					     (car matching))))
-			   (testname   (db:test-get-testname  test))
-			   (itempath   (db:test-get-item-path test))
+			   (testname   (db:test-testname  test))
+			   (itempath   (db:test-item-path test))
 			   (testfullname (test:test-get-fullname test))
-			   (teststatus (db:test-get-status   test))
-			   (teststate  (db:test-get-state    test))
-			   ;;(teststart  (db:test-get-event_time test))
-			   ;;(runtime    (db:test-get-run_duration test))
+			   (teststatus (db:test-status   test))
+			   (teststate  (db:test-state    test))
+			   ;;(teststart  (db:test-event_time test))
+			   ;;(runtime    (db:test-run_duration test))
 			   (buttontxt  (cond
 					((member teststate '("COMPLETED" "ARCHIVED")) teststatus)
 					((and (equal? teststate "NOT_STARTED")
 					      (member teststatus '("ZERO_ITEMS" "BLOCKED" "PREQ_FAIL" "PREQ_DISCARDED" "TIMED_OUT" "KEEP_TRYING" "TEN_STRIKES")))
 					 teststatus)
@@ -1452,12 +1452,12 @@
 				       #:expand "HORIZONTAL"
 				       #:fontsize "10" 
 				       #:action (lambda (x)
 						  (let* ((toolpath (car (argv)))
 							 (buttndat (hash-table-ref *buttondat* button-key))
-							 (test-id  (db:test-get-id (vector-ref buttndat 3)))
-							 (run-id   (db:test-get-run_id (vector-ref buttndat 3)))
+							 (test-id  (db:test-id (vector-ref buttndat 3)))
+							 (run-id   (db:test-run_id (vector-ref buttndat 3)))
 							 (cmd  (conc toolpath " -test " run-id "," test-id "&")))
 					;(print "Launching " cmd)
 						    (system cmd))))))
 	  (hash-table-set! *buttondat* button-key (vector 0 "100 100 100" button-key #f #f)) 
 	  (vector-set! testvec testnum butn)

ADDED   db-test.sh
Index: db-test.sh
==================================================================
--- /dev/null
+++ db-test.sh
@@ -0,0 +1,38 @@
+perl -pi -e 's/db:test-set-testname!/db:test-testname-set!/g' *.scm
+perl -pi -e 's/db:test-set-status!/db:test-status-set!/g' *.scm
+perl -pi -e 's/db:test-set-state!/db:test-state-set!/g' *.scm
+perl -pi -e 's/db:test-set-run_duration!/db:test-run_duration-set!/g' *.scm
+perl -pi -e 's/db:test-set-final_logf!/db:test-final_logf-set!/g' *.scm
+perl -pi -e 's/db:test-set-diskfree!/db:test-diskfree-set!/g' *.scm
+perl -pi -e 's/db:test-set-cpuload!/db:test-cpuload-set!/g' *.scm
+
+# fix few special cases
+perl -pi -e 's/db:test-get-rundir-from-test-id/dbx:test-get-rundir-from-test-id/g' *scm
+perl -pi -e 's/db:test-get-is-toplevel/dbx:test-is-toplevel/g' *.scm
+
+perl -pi -e 's/db:test-get-uname/db:test-uname/g' *.scm
+perl -pi -e 's/db:test-get-testname/db:test-testname/g' *.scm
+perl -pi -e 's/db:test-get-status/db:test-status/g' *.scm
+perl -pi -e 's/db:test-get-state/db:test-state/g' *.scm
+perl -pi -e 's/db:test-get-rundir/db:test-rundir/g' *.scm
+perl -pi -e 's/db:test-get-run_id/db:test-run_id/g' *.scm
+perl -pi -e 's/db:test-get-run_duration/db:test-run_duration/g' *.scm
+perl -pi -e 's/db:test-get-process_id/db:test-process_id/g' *.scm
+perl -pi -e 's/db:test-get-pass_count/db:test-pass_count/g' *.scm
+perl -pi -e 's/db:test-get-item-path/db:test-item-path/g' *.scm
+perl -pi -e 's/db:test-get-id/db:test-id/g' *.scm
+perl -pi -e 's/db:test-get-host/db:test-host/g' *.scm
+perl -pi -e 's/db:test-get-fullname/db:test-fullname/g' *.scm
+perl -pi -e 's/db:test-get-first_warn/db:test-first_warn/g' *.scm
+perl -pi -e 's/db:test-get-first_err/db:test-first_err/g' *.scm
+perl -pi -e 's/db:test-get-final_logf/db:test-final_logf/g' *.scm
+perl -pi -e 's/db:test-get-fail_count/db:test-fail_count/g' *.scm
+perl -pi -e 's/db:test-get-event_time/db:test-event_time/g' *.scm
+perl -pi -e 's/db:test-get-diskfree/db:test-diskfree/g' *.scm
+perl -pi -e 's/db:test-get-cpuload/db:test-cpuload/g' *.scm
+perl -pi -e 's/db:test-get-comment/db:test-comment/g' *.scm
+perl -pi -e 's/db:test-get-archived/db:test-archived/g' *.scm
+
+perl -pi -e 's/dbx:test-get-rundir-from-test-id/db:test-get-rundir-from-test-id/g' *scm
+perl -pi -e 's/dbx:test-is-toplevel/db:test-is-toplevel/g' *.scm
+

Index: db.scm
==================================================================
--- db.scm
+++ db.scm
@@ -1219,12 +1219,12 @@
     (if (number? ovr-deadtime)(set! deadtime ovr-deadtime))
     
     ;; in RUNNING or REMOTEHOSTSTART for more than 10 minutes
     ;;
     ;; HOWEVER: this code in run:test seems to work fine
-    ;;              (> (- (current-seconds)(+ (db:test-get-event_time testdat)
-    ;;                     (db:test-get-run_duration testdat)))
+    ;;              (> (- (current-seconds)(+ (db:test-event_time testdat)
+    ;;                     (db:test-run_duration testdat)))
     ;;                    600) 
     (db:delay-if-busy dbdat)
     (sqlite3:for-each-row 
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
@@ -1278,12 +1278,12 @@
     (if (number? ovr-deadtime)(set! deadtime ovr-deadtime))
     
     ;; in RUNNING or REMOTEHOSTSTART for more than 10 minutes
     ;;
     ;; HOWEVER: this code in run:test seems to work fine
-    ;;              (> (- (current-seconds)(+ (db:test-get-event_time testdat)
-    ;;                     (db:test-get-run_duration testdat)))
+    ;;              (> (- (current-seconds)(+ (db:test-event_time testdat)
+    ;;                     (db:test-run_duration testdat)))
     ;;                    600) 
     (db:delay-if-busy dbdat)
     (sqlite3:for-each-row 
      (lambda (test-id run-dir uname testname item-path)
        (if (and (equal? uname "n/a")
@@ -3149,15 +3149,15 @@
 		  (debug:print 4 "Got tests for run-id " run-id ", test-name " test-name 
 			       ", item-path " item-path " results: " (intersperse results "\n"))
 		  ;; Keep only the youngest of any test/item combination
 		  (for-each 
 		   (lambda (testdat)
-		     (let* ((full-testname (conc (db:test-get-testname testdat) "/" (db:test-get-item-path testdat)))
+		     (let* ((full-testname (conc (db:test-testname testdat) "/" (db:test-item-path testdat)))
 			    (stored-test   (hash-table-ref/default tests-hash full-testname #f)))
 		       (if (or (not stored-test)
 			       (and stored-test
-				    (> (db:test-get-event_time testdat)(db:test-get-event_time stored-test))))
+				    (> (db:test-event_time testdat)(db:test-event_time stored-test))))
 			   ;; this test is younger, store it in the hash
 			   (hash-table-set! tests-hash full-testname testdat))))
 		   results)
 		  (if (null? tal)
 		      (map cdr (hash-table->alist tests-hash)) ;; return a list of the most recent tests
@@ -3343,14 +3343,14 @@
 		 (ever-seen         #f)
 		 (parent-waiton-met #f)
 		 (item-waiton-met   #f))
 	     (for-each 
 	      (lambda (test)
-		;; (if (equal? waitontest-name (db:test-get-testname test)) ;; by defintion this had better be true ...
-		(let* ((state             (db:test-get-state test))
-		       (status            (db:test-get-status test))
-		       (item-path         (db:test-get-item-path test))
+		;; (if (equal? waitontest-name (db:test-testname test)) ;; by defintion this had better be true ...
+		(let* ((state             (db:test-state test))
+		       (status            (db:test-status test))
+		       (item-path         (db:test-item-path test))
 		       (is-completed      (equal? state "COMPLETED"))
 		       (is-running        (equal? state "RUNNING"))
 		       (is-killed         (equal? state "KILLED"))
 		       (is-ok             (member status '("PASS" "WARN" "CHECK" "WAIVED" "SKIP")))
 		       ;;                                       testname-b    path-a    path-b

Index: db_records.scm
==================================================================
--- db_records.scm
+++ db_records.scm
@@ -65,56 +65,56 @@
 (define (dbr:dbstruct-localdb-set! v run-id db)
   (hash-table-set! (dbr:dbstruct-locdbs v) run-id db))
 
 
 (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))
-(define-inline (db:test-get-status       vec) (vector-ref vec 4))
-(define-inline (db:test-get-event_time   vec) (vector-ref vec 5))
-(define-inline (db:test-get-host         vec) (vector-ref vec 6))
-(define-inline (db:test-get-cpuload      vec) (vector-ref vec 7))
-(define-inline (db:test-get-diskfree     vec) (vector-ref vec 8))
-(define-inline (db:test-get-uname        vec) (vector-ref vec 9))
-;; (define-inline (db:test-get-rundir       vec) (sdb:qry 'getstr (vector-ref vec 10)))
-(define-inline (db:test-get-rundir       vec) (vector-ref vec 10))
-(define-inline (db:test-get-item-path    vec) (vector-ref vec 11))
-(define-inline (db:test-get-run_duration vec) (vector-ref vec 12))
-(define-inline (db:test-get-final_logf   vec) (vector-ref vec 13))
-(define-inline (db:test-get-comment      vec) (vector-ref vec 14))
-(define-inline (db:test-get-process_id   vec) (vector-ref vec 16))
-(define-inline (db:test-get-archived     vec) (vector-ref vec 17))
-
-;; (define-inline (db:test-get-pass_count   vec) (vector-ref vec 15))
-;; (define-inline (db:test-get-fail_count   vec) (vector-ref vec 16))
-(define-inline (db:test-get-fullname     vec)
-  (conc (db:test-get-testname vec) "/" (db:test-get-item-path vec)))
+(define-inline (db:test-id           vec) (vector-ref vec 0))
+(define-inline (db:test-run_id       vec) (vector-ref vec 1))
+(define-inline (db:test-testname     vec) (vector-ref vec 2))
+(define-inline (db:test-state        vec) (vector-ref vec 3))
+(define-inline (db:test-status       vec) (vector-ref vec 4))
+(define-inline (db:test-event_time   vec) (vector-ref vec 5))
+(define-inline (db:test-host         vec) (vector-ref vec 6))
+(define-inline (db:test-cpuload      vec) (vector-ref vec 7))
+(define-inline (db:test-diskfree     vec) (vector-ref vec 8))
+(define-inline (db:test-uname        vec) (vector-ref vec 9))
+;; (define-inline (db:test-rundir       vec) (sdb:qry 'getstr (vector-ref vec 10)))
+(define-inline (db:test-rundir       vec) (vector-ref vec 10))
+(define-inline (db:test-item-path    vec) (vector-ref vec 11))
+(define-inline (db:test-run_duration vec) (vector-ref vec 12))
+(define-inline (db:test-final_logf   vec) (vector-ref vec 13))
+(define-inline (db:test-comment      vec) (vector-ref vec 14))
+(define-inline (db:test-process_id   vec) (vector-ref vec 16))
+(define-inline (db:test-archived     vec) (vector-ref vec 17))
+
+;; (define-inline (db:test-pass_count   vec) (vector-ref vec 15))
+;; (define-inline (db:test-fail_count   vec) (vector-ref vec 16))
+(define-inline (db:test-fullname     vec)
+  (conc (db:test-testname vec) "/" (db:test-item-path vec)))
 
 ;; replace runs:make-full-test-name with this routine
 (define (db:test-make-full-name testname itempath)
   (if (equal? itempath "") testname (conc testname "/" itempath)))
 
-(define-inline (db:test-get-first_err    vec) (printable (vector-ref vec 15)))
-(define-inline (db:test-get-first_warn   vec) (printable (vector-ref vec 16)))
-
-(define-inline (db:test-set-cpuload!  vec val)(vector-set! vec 7 val))
-(define-inline (db:test-set-diskfree! vec val)(vector-set! vec 8 val))
-(define-inline (db:test-set-testname! vec val)(vector-set! vec 2 val))
-(define-inline (db:test-set-state!    vec val)(vector-set! vec 3 val))
-(define-inline (db:test-set-status!   vec val)(vector-set! vec 4 val))
-(define-inline (db:test-set-run_duration! vec val)(vector-set! vec 12 val))
-(define-inline (db:test-set-final_logf! vec val)(vector-set! vec 13 val))
+(define-inline (db:test-first_err    vec) (printable (vector-ref vec 15)))
+(define-inline (db:test-first_warn   vec) (printable (vector-ref vec 16)))
+
+(define-inline (db:test-cpuload-set!  vec val)(vector-set! vec 7 val))
+(define-inline (db:test-diskfree-set! vec val)(vector-set! vec 8 val))
+(define-inline (db:test-testname-set! vec val)(vector-set! vec 2 val))
+(define-inline (db:test-state-set!    vec val)(vector-set! vec 3 val))
+(define-inline (db:test-status-set!   vec val)(vector-set! vec 4 val))
+(define-inline (db:test-run_duration-set! vec val)(vector-set! vec 12 val))
+(define-inline (db:test-final_logf-set! vec val)(vector-set! vec 13 val))
 
 ;; Test record utility functions
 
 ;; Is a test a toplevel?
 ;;
-(define (db:test-get-is-toplevel vec)
-  (and (equal? (db:test-get-item-path vec) "")      ;; test is not an item
-       (equal? (db:test-get-uname vec)     "n/a"))) ;; test has never been run
+(define (db:test-is-toplevel vec)
+  (and (equal? (db:test-item-path vec) "")      ;; test is not an item
+       (equal? (db:test-uname vec)     "n/a"))) ;; test has never been run
 
 ;; make-vector-record "" db mintest id run_id testname state status event_time item_path
 ;;
 (define (make-db:mintest)(make-vector 7))
 (define-inline (db:mintest-get-id           vec)    (vector-ref  vec 0))

ADDED   dbr-convert.sh
Index: dbr-convert.sh
==================================================================
--- /dev/null
+++ dbr-convert.sh
@@ -0,0 +1,36 @@
+perl -pi -e 's/dbr:dbstruct-set-strdb/dbr:dbstruct-strdb-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-stime/dbr:dbstruct-stime-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-rundb-path/dbr:dbstruct-set-rupath-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-rundb/dbr:dbstruct-rundb-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-run-id/dbr:dbstruct-run-id-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-rtime/dbr:dbstruct-rtime-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-refdb/dbr:dbstruct-refdb-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-path/dbr:dbstruct-path-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-olddb/dbr:dbstruct-olddb-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-mtime/dbr:dbstruct-mtime-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-main-path/dbr:dbstruct-main-path-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-main/dbr:dbstruct-main-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-locdbs/dbr:dbstruct-locdbs-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-localdb/dbr:dbstruct-localdb-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-local/dbr:dbstruct-local-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-inuse/dbr:dbstruct-inuse-set/g' *.scm
+perl -pi -e 's/dbr:dbstruct-set-inmem/dbr:dbstruct-inmem-set/g' *.scm
+
+perl -pi -e 's/dbr:dbstruct-get-strdb/dbr:dbstruct-strdb/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-stime/dbr:dbstruct-stime/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-runrec/dbr:dbstruct-runrec/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-rundb-path/dbr:dbstruct-rundb-path/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-rundb/dbr:dbstruct-rundb/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-run-id/dbr:dbstruct-run-id/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-rtime/dbr:dbstruct-rtime/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-refdb/dbr:dbstruct-refdb/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-path/dbr:dbstruct-path/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-olddb/dbr:dbstruct-olddb/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-mtime/dbr:dbstruct-mtime/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-main-path/dbr:dbstruct-main-path/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-main/dbr:dbstruct-main/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-locdbs/dbr:dbstruct-locdbs/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-localdb/dbr:dbstruct-localdb/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-local/dbr:dbstruct-local/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-inuse/dbr:dbstruct-inuse/g' *.scm
+perl -pi -e 's/dbr:dbstruct-get-inmem/dbr:dbstruct-inmem/g' *.scm

Index: dcommon.scm
==================================================================
--- dcommon.scm
+++ dcommon.scm
@@ -178,11 +178,11 @@
 	 (colnum       1)
 	 (rownum       0)) ;; rownum = 0 is the header
 ;; (debug:print 0 "test-ids " test-ids ", tests-detail-changes " tests-detail-changes)
     
 	 ;; tests related stuff
-	 ;; (all-testnames (delete-duplicates (map db:test-get-testname test-changes))))
+	 ;; (all-testnames (delete-duplicates (map db:test-testname test-changes))))
 
     ;; Given a run-id and testname/item_path calculate a cell R:C
 
     ;; NOTE: Also build the test tree browser and look up table
     ;;

Index: ezsteps.scm
==================================================================
--- ezsteps.scm
+++ ezsteps.scm
@@ -26,19 +26,19 @@
 (include "db_records.scm")
 (include "run_records.scm")
 
 (define (ezsteps:run-from testdat start-step-name run-one)
   (let* ((test-run-dir  ;; (filedb:get-path *fdb* 
-	  (db:test-get-rundir testdat)) ;; )
+	  (db:test-rundir testdat)) ;; )
 	 (testconfig    (read-config (conc test-run-dir "/testconfig") #f #t environ-patt: "pre-launch-env-vars"))
 	 (ezstepslst    (hash-table-ref/default testconfig "ezsteps" '()))
 	 (run-mutex     (make-mutex))
 	 (rollup-status 0)
 	 (exit-info     (vector #t #t #t))
-	 (test-id       (db:test-get-id testdat))
-	 (run-id        (db:test-get-run_id testdat))
-	 (test-name     (db:test-get-testname testdat))
+	 (test-id       (db:test-id testdat))
+	 (run-id        (db:test-run_id testdat))
+	 (test-name     (db:test-testname testdat))
 	 (kill-job      #f)) ;; for future use (on re-factoring with launch.scm code
     (let loop ((count 5))
       (if (file-exists? test-run-dir)
 	  (push-directory test-run-dir)
 	  (if (> count 0)
@@ -139,29 +139,29 @@
 			  (loop (car tal) (cdr tal) stepname runflag))))
 		(debug:print 4 "WARNING: a prior step failed, stopping at " ezstep)))
 	  
 	  ;; Once done with step/steps update the test record
 	  ;;
-	  (let* ((item-path (db:test-get-item-path testdat)) ;; (item-list->path itemdat))
+	  (let* ((item-path (db:test-item-path testdat)) ;; (item-list->path itemdat))
 		 (testinfo  (rmt:get-testinfo-by-id run-id test-id))) ;; refresh the testdat, call it iteminfo in case need prev/curr
 	    ;; Am I completed?
-	    (if (equal? (db:test-get-state testinfo) "RUNNING") ;; (not (equal? (db:test-get-state testinfo) "COMPLETED"))
+	    (if (equal? (db:test-state testinfo) "RUNNING") ;; (not (equal? (db:test-state testinfo) "COMPLETED"))
 		(let ((new-state  (if kill-job "KILLED" "COMPLETED") ;; (if (eq? (vector-ref exit-info 2) 0) ;; exited with "good" status
 				  ;; "COMPLETED"
-				  ;; (db:test-get-state testinfo)))   ;; else preseve the state as set within the test
+				  ;; (db:test-state testinfo)))   ;; else preseve the state as set within the test
 				  )
 		      (new-status (cond
 				   ((not (vector-ref exit-info 1)) "FAIL") ;; job failed to run
 				   ((eq? rollup-status 0)
 				    ;; if the current status is AUTO the defer to the calculated value (i.e. leave this AUTO)
-				    (if (equal? (db:test-get-status testinfo) "AUTO") "AUTO" "PASS"))
+				    (if (equal? (db:test-status testinfo) "AUTO") "AUTO" "PASS"))
 				   ((eq? rollup-status 1) "FAIL")
 				   ((eq? rollup-status 2)
 				    ;; if the current status is AUTO the defer to the calculated value but qualify (i.e. make this AUTO-WARN)
-				    (if (equal? (db:test-get-status testinfo) "AUTO") "AUTO-WARN" "WARN"))
-				   (else "FAIL")))) ;; (db:test-get-status testinfo)))
-		  (debug:print-info 2 "Test NOT logged as COMPLETED, (state=" (db:test-get-state testinfo) "), updating result, rollup-status is " rollup-status)
+				    (if (equal? (db:test-status testinfo) "AUTO") "AUTO-WARN" "WARN"))
+				   (else "FAIL")))) ;; (db:test-status testinfo)))
+		  (debug:print-info 2 "Test NOT logged as COMPLETED, (state=" (db:test-state testinfo) "), updating result, rollup-status is " rollup-status)
 		  (tests:test-set-status! test-id 
 					  new-state
 					  new-status
 					  (args:get-arg "-m") #f)
 		  ;; need to update the top test record if PASS or FAIL and this is a subtest

Index: launch.scm
==================================================================
--- launch.scm
+++ launch.scm
@@ -271,17 +271,17 @@
 	  ;; Do not run the test if it is REMOVING, RUNNING, KILLREQ or REMOTEHOSTSTART,
 	  ;; Mark the test as REMOTEHOSTSTART *IMMEDIATELY*
 	  ;;
 	  (let ((test-info (rmt:get-testinfo-state-status run-id test-id)))
 	    (cond
-	     ((member (db:test-get-state test-info) '("INCOMPLETE" "KILLED" "UNKNOWN" "KILLREQ" "STUCK")) ;; prior run of this test didn't complete, go ahead and try to rerun
+	     ((member (db:test-state test-info) '("INCOMPLETE" "KILLED" "UNKNOWN" "KILLREQ" "STUCK")) ;; prior run of this test didn't complete, go ahead and try to rerun
 	      (debug:print 0 "INFO: test is INCOMPLETE or KILLED, treat this execute call as a rerun request")
 	      (tests:test-force-state-status! run-id test-id "REMOTEHOSTSTART" "n/a")) ;; prime it for running
-	     ((not (member (db:test-get-state test-info) '("REMOVING" "REMOTEHOSTSTART" "RUNNING" "KILLREQ")))
+	     ((not (member (db:test-state test-info) '("REMOVING" "REMOTEHOSTSTART" "RUNNING" "KILLREQ")))
 	      (tests:test-force-state-status! run-id test-id "REMOTEHOSTSTART" "n/a"))
-	     (else ;; (member (db:test-get-state test-info) '("REMOVING" "REMOTEHOSTSTART" "RUNNING" "KILLREQ"))
-	      (debug:print 0 "ERROR: test state is " (db:test-get-state test-info) ", cannot proceed")
+	     (else ;; (member (db:test-state test-info) '("REMOVING" "REMOTEHOSTSTART" "RUNNING" "KILLREQ"))
+	      (debug:print 0 "ERROR: test state is " (db:test-state test-info) ", cannot proceed")
 	      (exit))))
 	  
 	  (debug:print 2 "Exectuing " test-name " (id: " test-id ") on " (get-host-name))
 	  (set! keys       (rmt:get-keys))
 	  ;; (runs:set-megatest-env-vars run-id inkeys: keys inkeyvals: keyvals) ;; these may be needed by the launching process
@@ -545,26 +545,26 @@
 	    (mutex-lock! m)
 	    (let* ((item-path (item-list->path itemdat))
 		   ;; only state and status needed - use lazy routine
 		   (testinfo  (rmt:get-testinfo-state-status run-id test-id)))
 	      ;; Am I completed?
-	      (if (member (db:test-get-state testinfo) '("REMOTEHOSTSTART" "RUNNING")) ;; NOTE: It should *not* be REMOTEHOSTSTART but for reasons I don't yet understand it sometimes gets stuck in that state ;; (not (equal? (db:test-get-state testinfo) "COMPLETED"))
+	      (if (member (db:test-state testinfo) '("REMOTEHOSTSTART" "RUNNING")) ;; NOTE: It should *not* be REMOTEHOSTSTART but for reasons I don't yet understand it sometimes gets stuck in that state ;; (not (equal? (db:test-state testinfo) "COMPLETED"))
 		  (let ((new-state  (if kill-job? "KILLED" "COMPLETED") ;; (if (eq? (vector-ref exit-info 2) 0) ;; exited with "good" status
 				                                        ;; "COMPLETED"
-							                ;; (db:test-get-state testinfo)))   ;; else preseve the state as set within the test
+							                ;; (db:test-state testinfo)))   ;; else preseve the state as set within the test
 				    )
 			(new-status (cond
 				     ((not (launch:einf-exit-status exit-info)) "FAIL") ;; job failed to run ... (vector-ref exit-info 1)
 				     ((eq? (launch:einf-rollup-status exit-info) 0)     ;; (vector-ref exit-info 3)
 				      ;; if the current status is AUTO then defer to the calculated value (i.e. leave this AUTO)
-				      (if (equal? (db:test-get-status testinfo) "AUTO") "AUTO" "PASS"))
+				      (if (equal? (db:test-status testinfo) "AUTO") "AUTO" "PASS"))
 				     ((eq? (launch:einf-rollup-status exit-info) 1) "FAIL")  ;; (vector-ref exit-info 3)
 				     ((eq? (launch:einf-rollup-status exit-info) 2)	     ;;	(vector-ref exit-info 3)
 				      ;; if the current status is AUTO the defer to the calculated value but qualify (i.e. make this AUTO-WARN)
-				      (if (equal? (db:test-get-status testinfo) "AUTO") "AUTO-WARN" "WARN"))
-				     (else "FAIL")))) ;; (db:test-get-status testinfo)))
-		    (debug:print-info 1 "Test exited in state=" (db:test-get-state testinfo) ", setting state/status based on exit code of " (launch:einf-exit-status exit-info) " and rollup-status of " (launch:einf-rollup-status exit-info))
+				      (if (equal? (db:test-status testinfo) "AUTO") "AUTO-WARN" "WARN"))
+				     (else "FAIL")))) ;; (db:test-status testinfo)))
+		    (debug:print-info 1 "Test exited in state=" (db:test-state testinfo) ", setting state/status based on exit code of " (launch:einf-exit-status exit-info) " and rollup-status of " (launch:einf-rollup-status exit-info))
 		    (tests:test-set-status! run-id 
 					    test-id 
 					    new-state
 					    new-status
 					    (args:get-arg "-m") #f)
@@ -801,11 +801,11 @@
     (if (not (hash-table-ref/default *toptest-paths* testname #f))
 	(let* ((testinfo       (rmt:get-test-info-by-id run-id test-id)) ;;  run-id testname item-path))
 	       (curr-test-path (if testinfo ;; (filedb:get-path *fdb*
 							     ;; (db:get-path dbstruct
 				   ;; (rmt:sdb-qry 'getstr 
-				   (db:test-get-rundir testinfo) ;; ) ;; )
+				   (db:test-rundir testinfo) ;; ) ;; )
 				   #f)))
 	  (hash-table-set! *toptest-paths* testname curr-test-path)
 	  ;; NB// Was this for the test or for the parent in an iterated test?
 	  (rmt:general-call 'test-set-rundir-shortdir run-id lnkpath 
 			    (if (file-exists? lnkpath)
@@ -943,13 +943,13 @@
     (if (not remote-megatest)(set! remote-megatest local-megatest)) ;; "megatest"))
     (set! mt-bindir-path (pathname-directory remote-megatest))
     (if launcher (set! launcher (string-split launcher)))
     ;; set up the run work area for this test
     (if (and (args:get-arg "-preclean") ;; user has requested to preclean for this run
-	     (not (member (db:test-get-rundir testinfo)(list "n/a" "/tmp/badname")))) ;; n/a is a placeholder and thus not a read dir
+	     (not (member (db:test-rundir testinfo)(list "n/a" "/tmp/badname")))) ;; n/a is a placeholder and thus not a read dir
 	(begin
-	  (debug:print-info 0 "attempting to preclean directory " (db:test-get-rundir testinfo) " for test " test-name "/" item-path)
+	  (debug:print-info 0 "attempting to preclean directory " (db:test-rundir testinfo) " for test " test-name "/" item-path)
 	  (runs:remove-test-directory testinfo 'remove-data-only))) ;; remove data only, do not perturb the record
 
     ;; prevent overlapping actions - set to LAUNCHED as early as possible
     ;;
     (tests:test-set-status! run-id test-id "LAUNCHED" "n/a" #f #f) ;; (if launch-results launch-results "FAILED"))

Index: megatest.scm
==================================================================
--- megatest.scm
+++ megatest.scm
@@ -1082,20 +1082,20 @@
 			 (begin
 			   (debug:print 0 "ERROR: Bad data in test record? " test)
 			   (print "exn=" (condition->list exn))
 			   (debug:print 0 " message: " ((condition-property-accessor 'exn 'message) exn))
 			   (print-call-chain (current-error-port)))
-			 (let* ((test-id      (if (member "id"           tests-spec)(get-value-by-fieldname test test-field-index "id"          ) #f)) ;; (db:test-get-id         test))
-				(testname     (if (member "testname"     tests-spec)(get-value-by-fieldname test test-field-index "testname"    ) #f)) ;; (db:test-get-testname   test))
-				(itempath     (if (member "item_path"    tests-spec)(get-value-by-fieldname test test-field-index "item_path"   ) #f)) ;; (db:test-get-item-path  test))
-				(comment      (if (member "comment"      tests-spec)(get-value-by-fieldname test test-field-index "comment"     ) #f)) ;; (db:test-get-comment    test))
-				(tstate       (if (member "state"        tests-spec)(get-value-by-fieldname test test-field-index "state"       ) #f)) ;; (db:test-get-state      test))
-				(tstatus      (if (member "status"       tests-spec)(get-value-by-fieldname test test-field-index "status"      ) #f)) ;; (db:test-get-status     test))
-				(event-time   (if (member "event_time"   tests-spec)(get-value-by-fieldname test test-field-index "event_time"  ) #f)) ;; (db:test-get-event_time test))
-				(rundir       (if (member "rundir"       tests-spec)(get-value-by-fieldname test test-field-index "rundir"      ) #f)) ;; (db:test-get-rundir     test))
-				(final_logf   (if (member "final_logf"   tests-spec)(get-value-by-fieldname test test-field-index "final_logf"  ) #f)) ;; (db:test-get-final_logf test))
-				(run_duration (if (member "run_duration" tests-spec)(get-value-by-fieldname test test-field-index "run_duration") #f)) ;; (db:test-get-run_duration test))
+			 (let* ((test-id      (if (member "id"           tests-spec)(get-value-by-fieldname test test-field-index "id"          ) #f)) ;; (db:test-id         test))
+				(testname     (if (member "testname"     tests-spec)(get-value-by-fieldname test test-field-index "testname"    ) #f)) ;; (db:test-testname   test))
+				(itempath     (if (member "item_path"    tests-spec)(get-value-by-fieldname test test-field-index "item_path"   ) #f)) ;; (db:test-item-path  test))
+				(comment      (if (member "comment"      tests-spec)(get-value-by-fieldname test test-field-index "comment"     ) #f)) ;; (db:test-comment    test))
+				(tstate       (if (member "state"        tests-spec)(get-value-by-fieldname test test-field-index "state"       ) #f)) ;; (db:test-state      test))
+				(tstatus      (if (member "status"       tests-spec)(get-value-by-fieldname test test-field-index "status"      ) #f)) ;; (db:test-status     test))
+				(event-time   (if (member "event_time"   tests-spec)(get-value-by-fieldname test test-field-index "event_time"  ) #f)) ;; (db:test-event_time test))
+				(rundir       (if (member "rundir"       tests-spec)(get-value-by-fieldname test test-field-index "rundir"      ) #f)) ;; (db:test-rundir     test))
+				(final_logf   (if (member "final_logf"   tests-spec)(get-value-by-fieldname test test-field-index "final_logf"  ) #f)) ;; (db:test-final_logf test))
+				(run_duration (if (member "run_duration" tests-spec)(get-value-by-fieldname test test-field-index "run_duration") #f)) ;; (db:test-run_duration test))
 				(fullname     (conc testname
 						    (if (equal? itempath "")
 							"" 
 							(conc "(" itempath ")")))))
 			   (case dmode
@@ -1123,13 +1123,13 @@
 				  (format #t
 					  "  Test: ~25a State: ~15a Status: ~15a Runtime: ~5@as Time: ~22a Host: ~10a\n"
 					  (if fullname fullname "")
 					  (if tstate   tstate   "")
 					  (if tstatus  tstatus  "")
-					  (get-value-by-fieldname test test-field-index "run_duration");;(if test     (db:test-get-run_duration test) "")
+					  (get-value-by-fieldname test test-field-index "run_duration");;(if test     (db:test-run_duration test) "")
 					  (if event-time event-time "")
-					  (get-value-by-fieldname test test-field-index "host")) ;;(if test (db:test-get-host test)) "")
+					  (get-value-by-fieldname test test-field-index "host")) ;;(if test (db:test-host test)) "")
 				  (print "  Test: " fullname
 					 (if tstate  (conc " State: "  tstate)  "")
 					 (if tstatus (conc " Status: " tstatus) "")
 					 (if (get-value-by-fieldname test test-field-index "run_duration")
 					     (conc " Runtime: " (get-value-by-fieldname test test-field-index "run_duration"))
@@ -1142,26 +1142,26 @@
 					   (equal? (get-value-by-fieldname test test-field-index "status") "WARN")
 					   (equal? (get-value-by-fieldname test test-field-index "state")  "NOT_STARTED")))
 				  (begin
 				    (print   (if (get-value-by-fieldname test test-field-index "cpuload")
 						 (conc "         cpuload:  "   (get-value-by-fieldname test test-field-index "cpuload"))
-						 "") ;; (db:test-get-cpuload test)
+						 "") ;; (db:test-cpuload test)
 					     (if (get-value-by-fieldname test test-field-index "diskfree")
-						 (conc "\n         diskfree: " (get-value-by-fieldname test test-field-index "diskfree")) ;; (db:test-get-diskfree test)
+						 (conc "\n         diskfree: " (get-value-by-fieldname test test-field-index "diskfree")) ;; (db:test-diskfree test)
 						 "")
 					     (if (get-value-by-fieldname test test-field-index "uname")
-						 (conc "\n         uname:    " (get-value-by-fieldname test test-field-index "uname")) ;; (db:test-get-uname test)
+						 (conc "\n         uname:    " (get-value-by-fieldname test test-field-index "uname")) ;; (db:test-uname test)
 						 "")
 					     (if (get-value-by-fieldname test test-field-index "rundir")
-						 (conc "\n         rundir:   " (get-value-by-fieldname test test-field-index "rundir")) ;; (db:test-get-rundir test)
+						 (conc "\n         rundir:   " (get-value-by-fieldname test test-field-index "rundir")) ;; (db:test-rundir test)
 						 "")
 ;;					     "\n         rundir:   " (get-value-by-fieldname test test-field-index "") ;; (sdb:qry 'getstr ;; (filedb:get-path *fdb* 
-;; 					     (db:test-get-rundir test) ;; )
+;; 					     (db:test-rundir test) ;; )
 					     )
 				    ;; Each test
 				    ;; DO NOT remote run
-				    (let ((steps (rmt:get-steps-for-test run-id (db:test-get-id test)))) ;; (db:get-steps-for-test dbstruct run-id (db:test-get-id test))))
+				    (let ((steps (rmt:get-steps-for-test run-id (db:test-id test)))) ;; (db:get-steps-for-test dbstruct run-id (db:test-id test))))
 				      (for-each 
 				       (lambda (step)
 					 (format #t 
 						 "    Step: ~20a State: ~10a Status: ~10a Time ~22a\n"
 						 (tdb:step-get-stepname step)

Index: mt.scm
==================================================================
--- mt.scm
+++ mt.scm
@@ -132,22 +132,22 @@
 
 (define (mt:process-triggers run-id test-id newstate newstatus)
   (let* ((test-dat      (rmt:get-test-info-by-id run-id test-id)))
     (if test-dat
 	(let* ((test-rundir   ;; (rmt:sdb-qry 'getstr ;; (filedb:get-path *fdb*
-		(db:test-get-rundir test-dat)) ;; ) ;; )
-	       (test-name     (db:test-get-testname test-dat))
+		(db:test-rundir test-dat)) ;; ) ;; )
+	       (test-name     (db:test-testname test-dat))
 	       (tconfig       #f)
-	       (state         (if newstate  newstate  (db:test-get-state  test-dat)))
-	       (status        (if newstatus newstatus (db:test-get-status test-dat))))
+	       (state         (if newstate  newstate  (db:test-state  test-dat)))
+	       (status        (if newstatus newstatus (db:test-status test-dat))))
 	  (if (and test-rundir   ;; #f means no dir set yet
 		   (file-exists? test-rundir)
 		   (directory? test-rundir))
 	      (call-with-environment-variables
 	       (list (cons "MT_TEST_NAME" test-name)
 		     (cons "MT_TEST_RUN_DIR" test-rundir)
-		     (cons "MT_ITEMPATH"     (db:test-get-item-path test-dat)))
+		     (cons "MT_ITEMPATH"     (db:test-item-path test-dat)))
 	       (lambda ()
 		 (push-directory test-rundir)
 		 (set! tconfig (mt:lazy-read-test-config test-name))
 		 (for-each (lambda (trigger)
 			     (let ((cmd  (configf:lookup tconfig "triggers" trigger))

Index: newdashboard.scm
==================================================================
--- newdashboard.scm
+++ newdashboard.scm
@@ -464,11 +464,11 @@
   ;; get test-id
   ;; then get test record
   (if testdat
       (let* ((test-id      (hash-table-ref/default (dboard:data-get-curr-test-ids *data*) window-id #f))
 	     (test-data    (hash-table-ref/default testdat test-id #f))
-	     (run-id       (db:test-get-run_id test-data))
+	     (run-id       (db:test-run_id test-data))
 	     (targ/runname (hash-table-ref/default (dboard:data-get-run-keys *data*) 
 						   run-id
 						   '()))
 	     (target       (if (null? targ/runname) "" (string-intersperse (reverse (cdr (reverse targ/runname))) "/")))
 	     (runname      (if (null? targ/runname) "" (car (cdr targ/runname))))
@@ -493,56 +493,56 @@
 			(set! rownum (+ rownum 1))))
 		    vals)))
 	       (list 
 		(list run-info-matrix
 		      (if test-id
-			  (list (db:test-get-run_id test-data)
+			  (list (db:test-run_id test-data)
 				target
 				runname
 				"n/a")
 			  (make-list 4 "")))
 		(list test-info-matrix
 		      (if test-id
 			  (list test-id
-				(db:test-get-testname test-data)
-				(db:test-get-item-path test-data)
-				(db:test-get-state    test-data)
-				(db:test-get-status   test-data)
-				(seconds->string (db:test-get-event_time test-data))
-				(db:test-get-comment  test-data))
+				(db:test-testname test-data)
+				(db:test-item-path test-data)
+				(db:test-state    test-data)
+				(db:test-status   test-data)
+				(seconds->string (db:test-event_time test-data))
+				(db:test-comment  test-data))
 			  (make-list 7 "")))
 		(list test-run-matrix
 		      (if test-id
-			  (list (db:test-get-host     test-data)
-				(db:test-get-uname    test-data)
-				(db:test-get-diskfree test-data)
-				(db:test-get-cpuload  test-data)
-				(seconds->hr-min-sec (db:test-get-run_duration test-data)))
+			  (list (db:test-host     test-data)
+				(db:test-uname    test-data)
+				(db:test-diskfree test-data)
+				(db:test-cpuload  test-data)
+				(seconds->hr-min-sec (db:test-run_duration test-data)))
 			  (make-list 5 "")))
 		))
 	      (dcommon:populate-steps steps-dat steps-matrix))))))
 		;;(list meta-dat-matrix
 		;;      (if test-id
 		;;	  (list (
 
   
-;; db:test-get-id           
-;; db:test-get-run_id       
-;; db:test-get-testname     
-;; db:test-get-state        
-;; db:test-get-status       
-;; db:test-get-event_time   
-;; db:test-get-host         
-;; db:test-get-cpuload      
-;; db:test-get-diskfree     
-;; db:test-get-uname        
-;; db:test-get-rundir       
-;; db:test-get-item-path    
-;; db:test-get-run_duration 
-;; db:test-get-final_logf   
-;; db:test-get-comment      
-;; db:test-get-fullname     	  
+;; db:test-id           
+;; db:test-run_id       
+;; db:test-testname     
+;; db:test-state        
+;; db:test-status       
+;; db:test-event_time   
+;; db:test-host         
+;; db:test-cpuload      
+;; db:test-diskfree     
+;; db:test-uname        
+;; db:test-rundir       
+;; db:test-item-path    
+;; db:test-run_duration 
+;; db:test-final_logf   
+;; db:test-comment      
+;; db:test-fullname     	  
 
 
 ;;======================================================================
 ;; R U N   C O N T R O L
 ;;======================================================================

Index: run_records.scm
==================================================================
--- run_records.scm
+++ run_records.scm
@@ -30,10 +30,10 @@
 (define-inline (test:get-state vec)    (vector-ref vec 3))
 (define-inline (test:get-status vec)   (vector-ref vec 4))
 (define-inline (test:get-item-path vec)(vector-ref vec 5))
 
 (define-inline (test:test-get-fullname test)
-   (conc (db:test-get-testname test)
-	 (if (equal? (db:test-get-item-path test) "")
+   (conc (db:test-testname test)
+	 (if (equal? (db:test-item-path test) "")
 	     ""
-	     (conc "(" (db:test-get-item-path test) ")"))))
+	     (conc "(" (db:test-item-path test) ")"))))
 

Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -29,12 +29,12 @@
 (include "db_records.scm")
 (include "run_records.scm")
 (include "test_records.scm")
 
 (define (runs:test-get-full-path test)
-  (let* ((testname (db:test-get-testname   test))
-	 (itempath (db:test-get-item-path test)))
+  (let* ((testname (db:test-testname   test))
+	 (itempath (db:test-item-path test)))
     (conc testname (if (equal? itempath "") "" (conc "(" itempath ")")))))
 
 ;; This is the *new* methodology. One record to inform them and in the chaos, organise them.
 ;;
 ;; NOT YET UTILIZED
@@ -611,14 +611,14 @@
 		(exit 1))))))
 
      ((and (null? fails)
 	   (null? prereq-fails)
 	   (not (null? non-completed)))
-      (let* ((allinqueue (map (lambda (x)(if (string? x) x (db:test-get-testname x)))
+      (let* ((allinqueue (map (lambda (x)(if (string? x) x (db:test-testname x)))
         		      (append newtal reruns)))
 	     ;; prereqstrs is a list of test names as strings that are prereqs for hed
-             (prereqstrs (delete-duplicates (map (lambda (x)(if (string? x) x (db:test-get-testname x)))
+             (prereqstrs (delete-duplicates (map (lambda (x)(if (string? x) x (db:test-testname x)))
 						 prereqs-not-met)))
 	     ;; a prereq that is not found in allinqueue will be put in the notinqueue list
 	     ;; 
              ;; (notinqueue (filter (lambda (x)
              ;;    		   (not (member x allinqueue)))
@@ -676,11 +676,11 @@
      ((and 
        (or (not (null? fails))
 	   (not (null? prereq-fails)))
        (member 'normal testmode))
       (debug:print-info 1 "test "  hed " (mode=" testmode ") has failed prerequisite(s); "
-			(string-intersperse (map (lambda (t)(conc (db:test-get-testname t) ":" (db:test-get-state t)"/"(db:test-get-status t))) fails) ", ")
+			(string-intersperse (map (lambda (t)(conc (db:test-testname t) ":" (db:test-state t)"/"(db:test-status t))) fails) ", ")
 			", removing it from to-do list")
       (let ((test-id (rmt:get-test-id run-id hed "")))
 	(if test-id
 	    (if (not (null? prereq-fails))
 		(mt:test-set-state-status-by-id run-id test-id "NOT_STARTED" "PREQ_DISCARDED" "Failed to run due to prior failed prerequisites")
@@ -711,14 +711,14 @@
   (if (null? inlst)
       '()
       (map (lambda (t)
 	     (cond
 	      ((vector? t)
-	       (let ((test-name (db:test-get-testname t))
-		     (item-path (db:test-get-item-path t))
-		     (test-state (db:test-get-state t))
-		     (test-status (db:test-get-status t)))
+	       (let ((test-name (db:test-testname t))
+		     (item-path (db:test-item-path t))
+		     (test-state (db:test-state t))
+		     (test-status (db:test-status t)))
 		 (conc test-name (if (equal? item-path "") "" "/") item-path ":" test-state "/" test-status)))
 	      ((string? t)
 	       t)
 	      (else 
 	       (conc t))))
@@ -744,11 +744,11 @@
 	 (waitdelay               (string->number (or (configf:lookup *configdat* "jobtools" "waitdelay") "60"))))
     (debug:print-info 4 "have-resources: " have-resources " prereqs-not-met: (" 
 		      (string-intersperse 
 		       (map (lambda (t)
 			      (if (vector? t)
-				  (conc (db:test-get-state t) "/" (db:test-get-status t))
+				  (conc (db:test-state t) "/" (db:test-status t))
 				  (conc " WARNING: t is not a vector=" t )))
 			    prereqs-not-met)
 		       ", ") ") fails: " fails
 		       "\nregistered? " (hash-table-ref/default test-registry (db:test-make-full-name test-name item-path) #f))
 			    
@@ -895,11 +895,11 @@
 			  (runs:queue-next-reg tal reg reglen regfull)
 			  reruns ;; WAS: (cons hed reruns) ;; but that makes no sense?
 			  ))
 		  (let ((nth-try (hash-table-ref/default test-registry hed 0)))
 		    (cond
-		     ((member "RUNNING" (map db:test-get-state prereqs-not-met))
+		     ((member "RUNNING" (map db:test-state prereqs-not-met))
 		      (if (runs:lownoise (conc "possible RUNNING prerequistes " hed) 60)
 			  (debug:print 0 "WARNING: test " hed " has possible RUNNING prerequisites, don't give up on it yet."))
 		      (thread-sleep! 4)
 		      (list (runs:queue-next-hed newtal reg reglen regfull)
 			    (runs:queue-next-tal newtal reg reglen regfull)
@@ -960,12 +960,12 @@
 ;; scan a list of tests looking to see if any are potentially runnable
 (define (runs:runable-tests tests)
   (filter (lambda (t)
 	    (if (not (vector? t))
 		t
-		(let ((state  (db:test-get-state t))
-		      (status (db:test-get-status t)))
+		(let ((state  (db:test-state t))
+		      (status (db:test-status t)))
 		  (case (string->symbol state)
 		    ((COMPLETED INCOMPLETE) #f)
 		    ((NOT_STARTED)
 		     (if (member status '("TEN_STRIKES" "BLOCKED" "PREQ_FAIL" "ZERO_ITEMS" "PREQ_DISCARDED" "TIMED_OUT" ))
 			 #f
@@ -1006,14 +1006,14 @@
 	(tdbdat                (tasks:open-db)))
 
     ;; Initialize the test-registery hash with tests that already have a record
     ;; convert state to symbol and use that as the hash value
     (for-each (lambda (trec)
-		(let ((id (db:test-get-id        trec))
-		      (tn (db:test-get-testname  trec))
-		      (ip (db:test-get-item-path trec))
-		      (st (db:test-get-state     trec)))
+		(let ((id (db:test-id        trec))
+		      (tn (db:test-testname  trec))
+		      (ip (db:test-item-path trec))
+		      (st (db:test-state     trec)))
 		  (if (not (equal? st "DELETED"))
 		      (hash-table-set! test-registry (db:test-make-full-name tn ip) (string->symbol st)))))
 	      tests-info)
     (set! max-retries (if (and max-retries (string->number max-retries))(string->number max-retries) 100))
 
@@ -1243,51 +1243,51 @@
     (debug:print-info 1 "All tests launched")))
 
 (define (runs:calc-fails prereqs-not-met)
   (filter (lambda (test)
 	    (and (vector? test) ;; not (string? test))
-		 (member (db:test-get-state test) '("INCOMPLETE" "COMPLETED"))
-		 (not (member (db:test-get-status test)
+		 (member (db:test-state test) '("INCOMPLETE" "COMPLETED"))
+		 (not (member (db:test-status test)
 			      '("PASS" "WARN" "CHECK" "WAIVED" "SKIP")))))
 	  prereqs-not-met))
 
 (define (runs:calc-prereq-fail prereqs-not-met)
   (filter (lambda (test)
 	    (and (vector? test) ;; not (string? test))
-		 (equal? (db:test-get-state test) "NOT_STARTED")
-		 (not (member (db:test-get-status test)
+		 (equal? (db:test-state test) "NOT_STARTED")
+		 (not (member (db:test-status test)
 			      '("n/a" "KEEP_TRYING")))))
 	  prereqs-not-met))
 
 (define (runs:calc-not-completed prereqs-not-met)
   (filter
    (lambda (t)
      (or (not (vector? t))
-	 (not (member (db:test-get-state t) '("INCOMPLETE" "COMPLETED")))))
+	 (not (member (db:test-state t) '("INCOMPLETE" "COMPLETED")))))
    prereqs-not-met))
 
 ;; (define (runs:calc-not-completed prereqs-not-met)
 ;;   (filter
 ;;    (lambda (t)
 ;;      (or (not (vector? t))
-;; 	 (not (equal? "COMPLETED" (db:test-get-state t)))))
+;; 	 (not (equal? "COMPLETED" (db:test-state t)))))
 ;;    prereqs-not-met))
 
 (define (runs:calc-runnable prereqs-not-met)
   (filter 
    (lambda (t)
      (or (not (vector? t))
-	 (and (equal? "NOT_STARTED" (db:test-get-state t))
-	      (member (db:test-get-status t)
+	 (and (equal? "NOT_STARTED" (db:test-state t))
+	      (member (db:test-status t)
 			      '("n/a" "KEEP_TRYING")))))
    prereqs-not-met))
 
 (define (runs:pretty-string lst)
   (map (lambda (t)
 	 (if (not (vector? t))
 	     (conc t)
-	     (conc (db:test-get-testname t) ":" (db:test-get-state t) "/" (db:test-get-status t))))
+	     (conc (db:test-testname t) ":" (db:test-state t) "/" (db:test-status t))))
        lst))
 
 ;; parent-test is there as a placeholder for when parent-tests can be run as a setup step
 (define (run:test run-id run-info keyvals runname test-record flags parent-test test-registry all-tests-registry)
   ;; All these vars might be referenced by the testconfig file reader
@@ -1359,11 +1359,11 @@
 		  (debug:print-info 0 "WARNING: server is overloaded, trying again in one second")
 		  (thread-sleep! 1)
 		  (loop)))))
       (if (not testdat) ;; should NOT happen
 	  (debug:print 0 "ERROR: failed to get test record for test-id " test-id))
-      (set! test-id (db:test-get-id testdat))
+      (set! test-id (db:test-id testdat))
       (if (file-exists? test-path)
 	  (change-directory test-path)
 	  (begin
 	    (debug:print "ERROR: test run path not created before attempting to run the test. Perhaps you are running -remove-runs at the same time?")
 	    (change-directory *toppath*)))
@@ -1457,12 +1457,12 @@
 	((KILLED) 
 	 (debug:print 1 "NOTE: " full-test-name " is already running or was explictly killed, use -force to launch it.")
 	 (hash-table-set! test-registry (db:test-make-full-name test-name test-path) 'DONOTRUN)) ;; KILLED))
 	((LAUNCHED REMOTEHOSTSTART RUNNING)  
 	 (debug:print 2 "NOTE: " test-name " is already running"))
-	;; (if (> (- (current-seconds)(+ (db:test-get-event_time testdat)
-	;; 			       (db:test-get-run_duration testdat)))
+	;; (if (> (- (current-seconds)(+ (db:test-event_time testdat)
+	;; 			       (db:test-run_duration testdat)))
 	;; 	(or incomplete-timeout
 	;; 	    6000)) ;; i.e. no update for more than 6000 seconds
 	;;      (begin
 	;;        (debug:print 0 "WARNING: Test " test-name " appears to be dead. Forcing it to state INCOMPLETE and status STUCK/DEAD")
 	;;        (tests:test-set-status! run-id test-id "INCOMPLETE" "STUCK/DEAD" "" #f))
@@ -1596,37 +1596,37 @@
 		 ;; actions that operate on one test at a time can be handled below
 		 ;;
 		 (let ((sorted-tests     (filter 
 					  vector?
 					  (sort tests (lambda (a b)(let ((dira ;; (rmt:sdb-qry 'getstr 
-									  (db:test-get-rundir a)) ;; )  ;; (filedb:get-path *fdb* (db:test-get-rundir a)))
+									  (db:test-rundir a)) ;; )  ;; (filedb:get-path *fdb* (db:test-rundir a)))
 									 (dirb ;; (rmt:sdb-qry 'getstr 
-									  (db:test-get-rundir b))) ;; ) ;; ((filedb:get-path *fdb* (db:test-get-rundir b))))
+									  (db:test-rundir b))) ;; ) ;; ((filedb:get-path *fdb* (db:test-rundir b))))
 								     (if (and (string? dira)(string? dirb))
 									 (> (string-length dira)(string-length dirb))
 									 #f))))))
 		       (toplevel-retries (make-hash-table)) ;; try three times to loop through and remove top level tests
 		       (test-retry-time  (make-hash-table))
 		       (allow-run-time   10)) ;; seconds to allow for killing tests before just brutally killing 'em
 		   (let loop ((test (car sorted-tests))
 			      (tal  (cdr sorted-tests)))
-		     (let* ((test-id       (db:test-get-id test))
+		     (let* ((test-id       (db:test-id test))
 			    (new-test-dat  (rmt:get-test-info-by-id run-id test-id)))
 		       (if (not new-test-dat)
 			   (begin
 			     (debug:print 0 "ERROR: We have a test-id of " test-id " but no record was found. NOTE: No locking of records is done between processes, do not simultaneously remove the same run from two processes!")
 			     (if (not (null? tal))
 				 (loop (car tal)(cdr tal))))
-			   (let* ((item-path     (db:test-get-item-path new-test-dat))
-				  (test-name     (db:test-get-testname new-test-dat))
+			   (let* ((item-path     (db:test-item-path new-test-dat))
+				  (test-name     (db:test-testname new-test-dat))
 				  (run-dir       ;;(filedb:get-path *fdb*
 				   ;; (rmt:sdb-qry 'getid 
-				   (db:test-get-rundir new-test-dat)) ;; )    ;; run dir is from the link tree
-				  (test-state    (db:test-get-state new-test-dat))
-				  (test-fulln    (db:test-get-fullname new-test-dat))
-				  (uname         (db:test-get-uname    new-test-dat))
-				  (toplevel-with-children (and (db:test-get-is-toplevel test)
+				   (db:test-rundir new-test-dat)) ;; )    ;; run dir is from the link tree
+				  (test-state    (db:test-state new-test-dat))
+				  (test-fulln    (db:test-fullname new-test-dat))
+				  (uname         (db:test-uname    new-test-dat))
+				  (toplevel-with-children (and (db:test-is-toplevel test)
 							       (> (rmt:test-toplevel-num-items run-id test-name) 0))))
 			     (case action
 			       ((remove-runs)
 				;; if the test is a toplevel-with-children issue an error and do not remove
 				(if toplevel-with-children
@@ -1650,14 +1650,14 @@
 						;; This test is not in a correct state for cleaning up. Let's try some graceful shutdown steps first
 						;; Set the test to "KILLREQ" and wait five seconds then try again. Repeat up to five times then give
 						;; up and blow it away.
 						(begin
 						  (debug:print 0 "WARNING: could not gracefully remove test " test-fulln ", tried to kill it to no avail. Forcing state to FAILEDKILL and continuing")
-					    (mt:test-set-state-status-by-id run-id (db:test-get-id test) "FAILEDKILL" "n/a" #f)
+					    (mt:test-set-state-status-by-id run-id (db:test-id test) "FAILEDKILL" "n/a" #f)
 						  (thread-sleep! 1))
 						(begin
-					    (mt:test-set-state-status-by-id run-id (db:test-get-id test) "KILLREQ" "n/a" #f)
+					    (mt:test-set-state-status-by-id run-id (db:test-id test) "KILLREQ" "n/a" #f)
 						  (thread-sleep! 1)))
 					    ;; NOTE: This is suboptimal as the testdata will be used later and the state/status may have changed ...
 					    (if (null? tal)
 						(loop new-test-dat tal)
 						(loop (car tal)(append tal (list new-test-dat)))))
@@ -1665,11 +1665,11 @@
 					    (runs:remove-test-directory new-test-dat mode) ;; 'remove-all)
 					    (if (not (null? tal))
 						(loop (car tal)(cdr tal))))))))
 			       ((set-state-status)
 				(debug:print-info 2 "new state " (car state-status) ", new status " (cadr state-status))
-				(mt:test-set-state-status-by-id run-id (db:test-get-id test) (car state-status)(cadr state-status) #f)
+				(mt:test-set-state-status-by-id run-id (db:test-id test) (car state-status)(cadr state-status) #f)
 				(if (not (null? tal))
 				    (loop (car tal)(cdr tal))))
 			       ((run-wait)
 				(debug:print-info 2 "still waiting, " (length tests) " tests still running")
 				(thread-sleep! 10)
@@ -1712,18 +1712,18 @@
     ;; (sqlite3:finalize! (db:delay-if-busy tdbdat))
     )
   #t)
 
 (define (runs:remove-test-directory test mode) ;; remove-data-only)
-  (let* ((run-dir       (db:test-get-rundir test))    ;; run dir is from the link tree
+  (let* ((run-dir       (db:test-rundir test))    ;; run dir is from the link tree
 	 (real-dir      (if (file-exists? run-dir)
 			    (resolve-pathname run-dir)
 			    #f)))
     (case mode
-      ((remove-data-only)(mt:test-set-state-status-by-id (db:test-get-run_id test)(db:test-get-id test) "CLEANING" "LOCKED" #f))
-      ((remove-all)      (mt:test-set-state-status-by-id (db:test-get-run_id test)(db:test-get-id test) "REMOVING" "LOCKED" #f))
-      ((archive-remove)  (mt:test-set-state-status-by-id (db:test-get-run_id test)(db:test-get-id test) "ARCHIVE_REMOVING" #f #f)))
+      ((remove-data-only)(mt:test-set-state-status-by-id (db:test-run_id test)(db:test-id test) "CLEANING" "LOCKED" #f))
+      ((remove-all)      (mt:test-set-state-status-by-id (db:test-run_id test)(db:test-id test) "REMOVING" "LOCKED" #f))
+      ((archive-remove)  (mt:test-set-state-status-by-id (db:test-run_id test)(db:test-id test) "ARCHIVE_REMOVING" #f #f)))
     (debug:print-info 1 "Attempting to remove " (if real-dir (conc " dir " real-dir " and ") "") " link " run-dir)
     (if (and real-dir 
 	     (> (string-length real-dir) 5)
 	     (file-exists? real-dir)) ;; bad heuristic but should prevent /tmp /home etc.
 	(begin ;; let* ((realpath (resolve-pathname run-dir)))
@@ -1753,13 +1753,13 @@
 		(debug:print 0 "WARNING: not removing " run-dir " as it either doesn't exist or is not a symlink")
 		(debug:print 0 "NOTE: the run dir for this test is undefined. Test may have already been deleted."))
 	    ))
     ;; Only delete the records *after* removing the directory. If things fail we have a record 
     (case mode
-      ((remove-data-only)(mt:test-set-state-status-by-id (db:test-get-run_id test)(db:test-get-id test) "NOT_STARTED" "n/a" #f))
-      ((archive-remove)  (mt:test-set-state-status-by-id (db:test-get-run_id test)(db:test-get-id test) "ARCHIVED" #f #f))
-      (else (rmt:delete-test-records (db:test-get-run_id test) (db:test-get-id test))))))
+      ((remove-data-only)(mt:test-set-state-status-by-id (db:test-run_id test)(db:test-id test) "NOT_STARTED" "n/a" #f))
+      ((archive-remove)  (mt:test-set-state-status-by-id (db:test-run_id test)(db:test-id test) "ARCHIVED" #f #f))
+      (else (rmt:delete-test-records (db:test-run_id test) (db:test-id test))))))
 
 ;;======================================================================
 ;; Routines for manipulating runs
 ;;======================================================================
 
@@ -1873,25 +1873,25 @@
 	 (curr-tests-hash (make-hash-table)))
     (rmt:update-run-event_time new-run-id)
     ;; index the already saved tests by testname and itemdat in curr-tests-hash
     (for-each
      (lambda (testdat)
-       (let* ((testname  (db:test-get-testname testdat))
-	      (item-path (db:test-get-item-path testdat))
+       (let* ((testname  (db:test-testname testdat))
+	      (item-path (db:test-item-path testdat))
 	      (full-name (conc testname "/" item-path)))
 	 (hash-table-set! curr-tests-hash full-name testdat)))
      curr-tests)
     ;; NOPE: Non-optimal approach. Try this instead.
     ;;   1. tests are received in a list, most recent first
     ;;   2. replace the rollup test with the new *always*
     (for-each 
      (lambda (testdat)
-       (let* ((testname  (db:test-get-testname testdat))
-	      (item-path (db:test-get-item-path testdat))
+       (let* ((testname  (db:test-testname testdat))
+	      (item-path (db:test-item-path testdat))
 	      (full-name (conc testname "/" item-path))
 	      (prev-test-dat (hash-table-ref/default curr-tests-hash full-name #f))
-	      (test-steps    (rmt:get-steps-for-test (db:test-get-id testdat)))
+	      (test-steps    (rmt:get-steps-for-test (db:test-id testdat)))
 	      (new-test-record #f))
 	 ;; replace these with insert ... select
 	 (apply sqlite3:execute 
 		db 
 		(conc "INSERT OR REPLACE INTO tests (run_id,testname,state,status,event_time,host,cpuload,diskfree,uname,rundir,item_path,run_duration,final_logf,comment) "
@@ -1898,24 +1898,24 @@
 		      "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?);")
 		new-run-id (cddr (vector->list testdat)))
 	 (set! new-testdat (car (mt:get-tests-for-run new-run-id (conc testname "/" item-path) '() '())))
 	 (hash-table-set! curr-tests-hash full-name new-testdat) ;; this could be confusing, which record should go into the lookup table?
 	 ;; Now duplicate the test steps
-	 (debug:print 4 "Copying records in test_steps from test_id=" (db:test-get-id testdat) " to " (db:test-get-id new-testdat))
+	 (debug:print 4 "Copying records in test_steps from test_id=" (db:test-id testdat) " to " (db:test-id new-testdat))
 	 (cdb:remote-run ;; to be replaced, note: this routine is not used currently
 	  (lambda ()
 	    (sqlite3:execute 
 	     db 
 	     (conc "INSERT OR REPLACE INTO test_steps (test_id,stepname,state,status,event_time,comment) "
-		   "SELECT " (db:test-get-id new-testdat) ",stepname,state,status,event_time,comment FROM test_steps WHERE test_id=?;")
-	     (db:test-get-id testdat))
+		   "SELECT " (db:test-id new-testdat) ",stepname,state,status,event_time,comment FROM test_steps WHERE test_id=?;")
+	     (db:test-id testdat))
 	    ;; Now duplicate the test data
-	    (debug:print 4 "Copying records in test_data from test_id=" (db:test-get-id testdat) " to " (db:test-get-id new-testdat))
+	    (debug:print 4 "Copying records in test_data from test_id=" (db:test-id testdat) " to " (db:test-id new-testdat))
 	    (sqlite3:execute 
 	     db 
 	     (conc "INSERT OR REPLACE INTO test_data (test_id,category,variable,value,expected,tol,units,comment) "
-		   "SELECT " (db:test-get-id new-testdat) ",category,variable,value,expected,tol,units,comment FROM test_data WHERE test_id=?;")
-	     (db:test-get-id testdat))))
+		   "SELECT " (db:test-id new-testdat) ",category,variable,value,expected,tol,units,comment FROM test_data WHERE test_id=?;")
+	     (db:test-id testdat))))
 	 ))
      prev-tests)))
 	 
      

Index: tests.scm
==================================================================
--- tests.scm
+++ tests.scm
@@ -260,15 +260,15 @@
 
 ;; Check for waiver eligibility
 ;;
 (define (tests:check-waiver-eligibility testdat prev-testdat)
   (let* ((test-registry (make-hash-table))
-	 (testconfig  (tests:get-testconfig (db:test-get-testname testdat) test-registry #f))
+	 (testconfig  (tests:get-testconfig (db:test-testname testdat) test-registry #f))
 	 (test-rundir ;; (sdb:qry 'passstr 
-	  (db:test-get-rundir testdat)) ;; )
+	  (db:test-rundir testdat)) ;; )
 	 (prev-rundir ;; (sdb:qry 'passstr 
-	  (db:test-get-rundir prev-testdat)) ;; )
+	  (db:test-rundir prev-testdat)) ;; )
 	 (waivers     (if testconfig (configf:section-vars testconfig "waivers") '()))
 	 (waiver-rx   (regexp "^(\\S+)\\s+(.*)$"))
 	 (diff-rule   "diff %file1% %file2%")
 	 (logpro-rule "diff %file1% %file2% | logpro %waivername%.logpro %waivername%.html"))
     (if (not (file-exists? test-rundir))
@@ -329,12 +329,12 @@
 ;; Do not rpc this one, do the underlying calls!!!
 (define (tests:test-set-status! run-id test-id state status comment dat #!key (work-area #f))
   (let* ((real-status status)
 	 (otherdat    (if dat dat (make-hash-table)))
 	 (testdat     (rmt:get-test-info-by-id run-id test-id))
-	 (test-name   (db:test-get-testname  testdat))
-	 (item-path   (db:test-get-item-path testdat))
+	 (test-name   (db:test-testname  testdat))
+	 (item-path   (db:test-item-path testdat))
 	 ;; before proceeding we must find out if the previous test (where all keys matched except runname)
 	 ;; was WAIVED if this test is FAIL
 
 	 ;; NOTES:
 	 ;;  1. Is the call to test:get-previous-run-record remotified?
@@ -343,13 +343,13 @@
 	 (prev-test   (if (equal? status "FAIL")
 			  (rmt:get-previous-test-run-record run-id test-name item-path)
 			  #f))
 	 (waived   (if prev-test
 		       (if prev-test ;; true if we found a previous test in this run series
-			   (let ((prev-status  (db:test-get-status  prev-test))
-				 (prev-state   (db:test-get-state   prev-test))
-				 (prev-comment (db:test-get-comment prev-test)))
+			   (let ((prev-status  (db:test-status  prev-test))
+				 (prev-state   (db:test-state   prev-test))
+				 (prev-comment (db:test-comment prev-test)))
 			     (debug:print 4 "prev-status " prev-status ", prev-state " prev-state ", prev-comment " prev-comment)
 			     (if (and (equal? prev-state  "COMPLETED")
 				      (equal? prev-status "WAIVED"))
 				 (if comment
 				     comment
@@ -631,17 +631,17 @@
 
 ;; summarize test
 (define (tests:summarize-test run-id test-id)
   (let* ((test-dat  (rmt:get-test-info-by-id run-id test-id))
 	 (steps-dat (rmt:get-steps-for-test run-id test-id))
-	 (test-name (db:test-get-testname test-dat))
-	 (item-path (db:test-get-item-path test-dat))
+	 (test-name (db:test-testname test-dat))
+	 (item-path (db:test-item-path test-dat))
 	 (full-name (db:test-make-full-name test-name item-path))
-	 (oup       (open-output-file (conc (db:test-get-rundir test-dat) "/test-summary.html")))
-	 (status    (db:test-get-status   test-dat))
+	 (oup       (open-output-file (conc (db:test-rundir test-dat) "/test-summary.html")))
+	 (status    (db:test-status   test-dat))
 	 (color     (common:get-color-from-status status))
-	 (logf      (db:test-get-final_logf test-dat))
+	 (logf      (db:test-final_logf test-dat))
 	 (steps-dat (tests:get-compressed-steps #f run-id test-id)))
     ;; (dcommon:get-compressed-steps #f 1 30045)
     ;; (#("wasting_time" "23:36:13" "23:36:21" "0" "8.0s" "wasting_time.log"))
 
     (s:output-new
@@ -649,19 +649,19 @@
      (s:html
       (s:title "Summary for " full-name)
       (s:body 
        (s:h2 "Summary for " full-name)
        (s:table 'cellspacing "0" 'border "1"
-	(s:tr (s:td "run id")   (s:td (db:test-get-run_id   test-dat))
-	      (s:td "test id")  (s:td (db:test-get-id       test-dat)))
+	(s:tr (s:td "run id")   (s:td (db:test-run_id   test-dat))
+	      (s:td "test id")  (s:td (db:test-id       test-dat)))
 	(s:tr (s:td "testname") (s:td test-name)
 	      (s:td "itempath") (s:td item-path))
-	(s:tr (s:td "state")    (s:td (db:test-get-state    test-dat))
+	(s:tr (s:td "state")    (s:td (db:test-state    test-dat))
 	      (s:td "status")   (s:td (s:a 'href logf (s:font 'color color status))))
 	(s:tr (s:td "TestDate") (s:td (seconds->work-week/day-time 
-				       (db:test-get-event_time test-dat)))
-	      (s:td "Duration") (s:td (seconds->hr-min-sec (db:test-get-run_duration test-dat)))))
+				       (db:test-event_time test-dat)))
+	      (s:td "Duration") (s:td (seconds->hr-min-sec (db:test-run_duration test-dat)))))
        (s:h3 "Log files")
        (s:table
 	'cellspacing "0" 'border "1"
 	(s:tr (s:td "Final log")(s:td (s:a 'href logf logf))))
        (s:table
@@ -940,14 +940,14 @@
 	      (test-id     (rmt:get-test-id run-id test-name item-path))
 	      (tdat        (rmt:get-testinfo-state-status run-id test-id))) ;; (cdb:get-test-info-by-id *runremote* test-id)))
 	 (if tdat
 	     (begin
 	       ;; Look at the test state and status
-	       (if (or (and (member (db:test-get-status tdat) 
+	       (if (or (and (member (db:test-status tdat) 
 				    '("PASS" "WARN" "WAIVED" "CHECK" "SKIP"))
-			    (equal? (db:test-get-state tdat) "COMPLETED"))
-		       (member (db:test-get-state tdat)
+			    (equal? (db:test-state tdat) "COMPLETED"))
+		       (member (db:test-state tdat)
 				    '("INCOMPLETE" "KILLED")))
 		   (set! keep-test #f))
 
 	       ;; examine waitons for any fails. If it is FAIL or INCOMPLETE then eliminate this test
 	       ;; from the runnable list
@@ -954,17 +954,17 @@
 	       (if keep-test
 		   (for-each (lambda (waiton)
 			       ;; for now we are waiting only on the parent test
 			       (let* ((parent-test-id (rmt:get-test-id run-id waiton ""))
 				      (wtdat          (rmt:get-testinfo-state-status run-id test-id))) ;; (cdb:get-test-info-by-id *runremote* test-id)))
-				 (if (or (and (equal? (db:test-get-state wtdat) "COMPLETED")
-					      (member (db:test-get-status wtdat) '("FAIL" "ABORT")))
-					 (member (db:test-get-status wtdat)  '("KILLED"))
-					 (member (db:test-get-state wtdat)   '("INCOMPETE")))
-				 ;; (if (or (member (db:test-get-status wtdat)
+				 (if (or (and (equal? (db:test-state wtdat) "COMPLETED")
+					      (member (db:test-status wtdat) '("FAIL" "ABORT")))
+					 (member (db:test-status wtdat)  '("KILLED"))
+					 (member (db:test-state wtdat)   '("INCOMPETE")))
+				 ;; (if (or (member (db:test-status wtdat)
 				 ;;        	 '("FAIL" "KILLED"))
-				 ;;         (member (db:test-get-state wtdat)
+				 ;;         (member (db:test-state wtdat)
 				 ;;        	 '("INCOMPETE")))
 				     (set! keep-test #f)))) ;; no point in running this one again
 			     waitons))))
 	 (if keep-test (set! runnables (cons testkeyname runnables)))))
      testkeynames)