Index: runs.scm
==================================================================
--- runs.scm
+++ runs.scm
@@ -633,10 +633,16 @@
 
      ((and (not (member 'toplevel testmode))
 	   (member (hash-table-ref/default test-registry (db:test-make-full-name hed item-path) 'n/a)
 		   '(DONOTRUN removed CANNOTRUN))) ;; *common:cant-run-states-sym*) ;; '(COMPLETED KILLED WAIVED UNKNOWN INCOMPLETE)) ;; try to catch repeat processing of COMPLETED tests here
       (debug:print-info 1 *default-log-port* "Test " hed " set to \"" (hash-table-ref test-registry (db:test-make-full-name hed item-path)) "\". Removing it from the queue")
+      
+      (mt:test-set-state-status-by-id run-id test-id
+				      "NOT_STARTED"    ;; state
+				      (conc (hash-table-ref/default test-registry (db:test-make-full-name hed item-path) "CANNOTRUN"))
+				      "Failed to run due to failed prerequisites")
+
       (if (or (not (null? tal))
 	      (not (null? reg)))
 	  (list (runs:queue-next-hed tal reg reglen regfull)
 		(runs:queue-next-tal tal reg reglen regfull)
 		(runs:queue-next-reg tal reg reglen regfull)
@@ -802,10 +808,11 @@
 	 (test-name              (runs:testdat-test-name testdat))
 	 (item-path              (runs:testdat-item-path testdat))
 	 (jobgroup               (runs:testdat-jobgroup testdat))
 	 (waitons                (runs:testdat-waitons testdat))
 	 (item-path              (runs:testdat-item-path testdat))
+	 (tfullname              (db:test-make-full-name test-name item-path))
 	 (testmode               (runs:testdat-testmode testdat))
 	 (newtal                 (runs:testdat-newtal testdat))
 	 (itemmaps               (runs:testdat-itemmaps testdat))
 	 (test-record            (runs:testdat-test-record testdat))
 	 (prereqs-not-met        (runs:testdat-prereqs-not-met testdat))
@@ -851,13 +858,13 @@
 			      (if (vector? t)
 				  (conc (db:test-get-state t) "/" (db:test-get-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))
+		       "\nregistered? " (hash-table-ref/default test-registry tfullname #f))
 			    
-
+    (if (not (hash-table-ref/default test-registry tfullname #f))(hash-table-set! test-registry tfullname #f))
     
     (if (and (not (null? prereqs-not-met))
 	     (runs:lownoise (conc "waiting on tests " prereqs-not-met hed) 60))
 	(debug:print-info 2 *default-log-port* "waiting on tests; " (string-intersperse (runs:mixed-list-testname-and-testrec->list-of-strings prereqs-not-met) ", ")))
 
@@ -959,10 +966,19 @@
 	  (list (runs:queue-next-hed tal reg reglen regfull)
 		(runs:queue-next-tal tal reg reglen regfull)
 		(runs:queue-next-reg tal reg reglen regfull)
 		reruns)
 	  #f))
+
+     ;; this might speed things up!?
+     ((and (eq? 0 num-running)
+	   (null? (filter (lambda (x)
+			    (not (member (hash-table-ref/default test-registry (db:test-make-full-name test-name item-path) 'x)
+					 '(done removed))))
+			  (hash-table-keys test-registry))))
+      (debug:print 0 *default-log-port* "NOTHING LEFT TO RUN!")
+      #f)
      
      ;; must be we have unmet prerequisites
      ;;
      (else
       (debug:print 4 *default-log-port* "FAILS: " fails)
@@ -1003,11 +1019,11 @@
 		  (let ((nth-try (hash-table-ref/default test-registry hed 0)))
 		    (cond
 		     ((member "RUNNING" (map db:test-get-state prereqs-not-met))
 		      (if (runs:lownoise (conc "possible RUNNING prerequistes " hed) 60)
 			  (debug:print 0 *default-log-port* "WARNING: test " hed " has possible RUNNING prerequisites, don't give up on it yet."))
-		      (thread-sleep! 4)
+		      (thread-sleep! 1)
 		      (list (runs:queue-next-hed newtal reg reglen regfull)
 			    (runs:queue-next-tal newtal reg reglen regfull)
 			    (runs:queue-next-reg newtal reg reglen regfull)
 			    reruns))
 		     ((or (not nth-try)
@@ -1026,36 +1042,47 @@
 		      (list (runs:queue-next-hed newtal reg reglen regfull)
 			    (runs:queue-next-tal newtal reg reglen regfull)
 			    (runs:queue-next-reg newtal reg reglen regfull)
 			    reruns))
 		     ((symbol? nth-try)
-		      (if (eq? nth-try 'removed) ;; removed is removed - drop it NOW
-			  (if (null? tal)
-			      #f ;; yes, really
-			      (list (car tal)(cdr tal) reg reruns))
-			  (begin
-			    (if (runs:lownoise (conc "FAILED prerequisites or other issue" hed) 60)
-				(debug:print 0 *default-log-port* "WARNING: test " hed " has FAILED prerequisites or other issue. Internal state " nth-try " will be overridden and we'll retry."))
-			    (mt:test-set-state-status-by-testname run-id test-name item-path "NOT_STARTED" "KEEP_TRYING" #f)
-			    (hash-table-set! test-registry hed 0)
-			    (list (runs:queue-next-hed newtal reg reglen regfull)
-				  (runs:queue-next-tal newtal reg reglen regfull)
-				  (runs:queue-next-reg newtal reg reglen regfull)
-				  reruns))))
+		      (case nth-try
+			((removed) ;; removed is removed - drop it NOW
+			 (if (null? tal)
+			     #f ;; yes, really
+			     (list (car tal)(cdr tal) reg reruns)))
+			((done)
+			 (if (runs:lownoise (conc "FAILED prerequisites or other issue - done" hed) 60)
+			     (debug:print 0 *default-log-port* "WARNING: test " hed " has FAILED prerequisites or other issue and is marked \"done\" internally. Dropping it."))
+			 (mt:test-set-state-status-by-testname run-id test-name item-path "NOT_STARTED" "CANNOTRUN" "Failed prerequisites or other issue. CANNOTRUN")
+			 (hash-table-set! test-registry hed 'removed)
+			 (list (runs:queue-next-hed newtal reg reglen regfull)
+			       (runs:queue-next-tal newtal reg reglen regfull)
+			       (runs:queue-next-reg newtal reg reglen regfull)
+			       reruns))
+			(else
+			 (if (runs:lownoise (conc "FAILED prerequisites or other issue" hed) 60)
+			     (debug:print 0 *default-log-port* "WARNING: test " hed " has FAILED prerequisites or other issue. Internal state " nth-try " will be overridden and we'll retry."))
+			 (mt:test-set-state-status-by-testname run-id test-name item-path "NOT_STARTED" "KEEP_TRYING" #f)
+			 (hash-table-set! test-registry hed 0)
+			 (list (runs:queue-next-hed newtal reg reglen regfull)
+			       (runs:queue-next-tal newtal reg reglen regfull)
+			       (runs:queue-next-reg newtal reg reglen regfull)
+			       reruns))))
 		     (else
 		      (if (runs:lownoise (conc "FAILED prerequitests and we tried" hed) 60)
 			  (debug:print 0 *default-log-port* "WARNING: test " hed " has FAILED prerequitests and we've tried at least 10 times to run it. Giving up now."))
 		      ;; (debug:print 0 *default-log-port* "         prereqs: " prereqs-not-met)
 		      (hash-table-set! test-registry hed 'removed)
 		      (mt:test-set-state-status-by-testname run-id test-name item-path "NOT_STARTED" "TEN_STRIKES" #f)
 		      ;; I'm unclear on if this roll up is needed - it may be the root cause of the "all set to FAIL" bug.
-		      (rmt:set-state-status-and-roll-up-items run-id test-name item-path #f "FAIL" #f) ;; treat as FAIL
+		      ;; (rmt:set-state-status-and-roll-up-items run-id test-name item-path #f "FAIL" #f) ;; treat as FAIL
 		      (list (if (null? tal)(car newtal)(car tal))
 			    tal
 			    reg
 			    reruns)))))
 	      ;; can't drop this - maybe running? Just keep trying
+	      ;; else clause from (or (not (null? reg))(not (null? tal))) above
 	      (let ((runable-tests (runs:runable-tests prereqs-not-met)))
 		(if (null? runable-tests)
 		    #f   ;; I think we are truly done here
 		    (list (runs:queue-next-hed newtal reg reglen regfull)
 			    (runs:queue-next-tal newtal reg reglen regfull)
@@ -1071,11 +1098,11 @@
 		(let ((state  (db:test-get-state t))
 		      (status (db:test-get-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" ))
+		     (if (member status '("TEN_STRIKES" "BLOCKED" "PREQ_FAIL" "ZERO_ITEMS" "PREQ_DISCARDED" "TIMED_OUT" "CANNOTRUN"))
 			 #f
 			 t))
 		    ((DELETED) #f)
 		    (else t)))))
 	  tests))
@@ -1318,11 +1345,12 @@
 		     "\n  tal:         " tal
 		     "\n  reruns:      " reruns
 		     "\n  regfull:     " regfull
 		     "\n  reglen:      " reglen
 		     "\n  length reg:  " (length reg)
-		     "\n  reg:         " reg)
+		     "\n  reg:         " reg
+		     "\n  flag:        " (hash-table-ref/default test-registry tfullname 'x))
 
 	;; check for hed in waitons => this would be circular, remove it and issue an
 	;; error
 	(if (member test-name waitons)
 	    (begin
@@ -1345,13 +1373,21 @@
 				       #f))
 				 waitons))))) ;; could do this more elegantly with a marker....
 	  (debug:print 0 *default-log-port* "WARNING: Marking test " tfullname " as not runnable. It is waiting on tests that cannot be run. Giving up now.")
 	  (hash-table-set! test-registry tfullname 'removed))
 
-	 ;; items is #f then the test is ok to be handed off to launch (but not before)
+	 ;; get rid of definitively removed items
+	 ((member (hash-table-ref/default test-registry tfullname 'x) '(removed CANNOTRUN))
+	  (debug:print 0 *default-log-port* "INFO: Dropping test " tfullname " from the tests queue due to flag "
+		       (hash-table-ref/default test-registry tfullname 'x))
+	  (if (not (null? tal))
+	      (loop (car tal)(cdr tal) reg reruns)))
+	 
+	 ;; items is #f then the test is ok to be handed off to launch (but not before), check that the test was not marked for removal
 	 ;; 
-	 ((not items)
+	 ((and (not (member (hash-table-ref/default test-registry tfullname 'x) '(removed CANNOTRUN)))
+	       (not items))
 	  (debug:print-info 4 *default-log-port* "OUTER COND: (not items)")
 	  (if (and (not (tests:match test-patts (tests:testqueue-get-testname test-record) item-path required: required-tests))
 		   (not (null? tal)))
 	      (loop (car tal)(cdr tal) reg reruns))
 	  (runs:testdat-prereqs-not-met-set! testdat (rmt:get-prereqs-not-met run-id waitons hed item-path mode: testmode itemmaps: itemmaps))
@@ -1464,34 +1500,41 @@
 	    (wait-loop (rmt:get-count-tests-running-for-run-id run-id) num-running))))
     ;; LET* ((test-record
     ;; we get here on "drop through". All done!
     (debug:print-info 1 *default-log-port* "All tests launched")))
 
+;; pre-reqs that are FAIL of some kind and thus prevent dependent test from
+;; proceeding
+;;
 (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)
 			      '("PASS" "WARN" "CHECK" "WAIVED" "SKIP")))))
 	  prereqs-not-met))
 
+;; pre-req tests that are marked such that *their* prereqs have failed
+;;
 (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)
-			      '("n/a" "KEEP_TRYING")))))
+		 (member (db:test-get-status test)
+			 '("PREQ_DISCARDED"))))
+	  ;; (not (member (db:test-get-status test)
+	  ;;	      '("n/a" "KEEP_TRYING" "PASS")))))
 	  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")))))
    prereqs-not-met))
 
-;; (define (runs:calc-not-completed prereqs-not-met)
+;; (define (runs:calc-not-completed prere qs-not-met)
 ;;   (filter
 ;;    (lambda (t)
 ;;      (or (not (vector? t))
 ;; 	 (not (equal? "COMPLETED" (db:test-get-state t)))))
 ;;    prereqs-not-met))

Index: tests/fdktestqa/testqa/Makefile
==================================================================
--- tests/fdktestqa/testqa/Makefile
+++ tests/fdktestqa/testqa/Makefile
@@ -3,10 +3,11 @@
 MEGATEST  = $(BINDIR)/megatest
 DASHBOARD = $(BINDIR)/dashboard
 NEWDASHBOARD = $(BINDIR)/newdashboard
 RUNNAME   = a
 NUMTESTS  = 20
+DEBUG     = 0
 
 all :
 	$(MEGATEST) -remove-runs -target a/b -runname c -testpatt %/%
 	$(MEGATEST) -run -testpatt % -target a/b -runname c
 
@@ -22,17 +23,17 @@
 waitonall :
 	megatest -remove-runs -runname waitonall -target a/b -testpatt %
 	NUMTESTS=20 megatest -run -target a/b -runname waitonall -testpatt alltop
 
 bigrun :
-	NUMTESTS=$(NUMTESTS) $(MEGATEST) -run -testpatt bigrun -target a/bigrun -runname a$(shell date +%V)
+	NUMTESTS=$(NUMTESTS) $(MEGATEST) -run -testpatt bigrun -target a/bigrun -runname a$(shell date +%V) -debug $(DEBUG)
 
 bigrun2 :
-	NUMTESTS=$(NUMTESTS) $(MEGATEST) -run -testpatt bigrun2 -target a/bigrun2 -runname a$(shell date +%V)
+	NUMTESTS=$(NUMTESTS) $(MEGATEST) -run -testpatt bigrun2 -target a/bigrun2 -runname a$(shell date +%V) -debug $(DEBUG)
 
 bigrun3 :
-	NUMTESTS=$(NUMTESTS) $(MEGATEST) -run -testpatt bigrun3 -target a/bigrun3 -runname $(RUNNAME)
+	NUMTESTS=$(NUMTESTS) $(MEGATEST) -run -testpatt bigrun3 -target a/bigrun3 -runname $(RUNNAME) -debug $(DEBUG)
 
 dashboard : 
 	mkdir -p ../simpleruns
 	$(DASHBOARD) -rows 20 &