diff --git a/test/test-bundle.script b/test/test-bundle.script
index 8111f48fdaaefcc5e092982ce398349fb8371ccc..1442acb0271e06c2a797fddfd95d58c57b680a31 100644
--- a/test/test-bundle.script
+++ b/test/test-bundle.script
@@ -13,13 +13,6 @@
 #+(and os-macosx ecl)
 (leave-test "Bundle test doesn't work on Mac on this lisp." 0)
 
-#+abcl
-(when (and (member :abcl *features*)
-           (os-macosx-p)
-           ;; bundles don't work on pre-1.3.0
-           (second (third (sys::arglist 'directory))))
-  (leave-test "Bundle test doesn't work on Mac on this version of ABCL." 0))
-
 #+(or (and ecl ecl-bytecmp) gcl)
 (leave-test "bundles not on this implementation" 0)
 
diff --git a/test/test-encodings.script b/test/test-encodings.script
index 04f39ee44970f90fee200daa0e575026c9243222..f0050d342022a2b40c421795bb4d9d12bec312c6 100644
--- a/test/test-encodings.script
+++ b/test/test-encodings.script
@@ -117,8 +117,21 @@
   (def-test-system :test-system-encoding-l1
     :encoding :latin-1
     :components ((:file "lambda"))))
-#-ecl-bytecmp
-(with-expected-failure ()
+(let ((file (first (output-files (make-operation 'compile-op) (find-component (find-system "test-system-encoding-l1") "lambda")))))
+  (DBG (format nil "Checking for previously-compiled file ~a.~a" (pathname-name file) (pathname-type file)))
+  (if (file-exists-p file)
+      (progn
+       (delete-file file)
+       (DBG "Deleted file.")
+       (assert (not (file-exists-p file))))
+      (DBG "No such file.")))
+(defun permissive-parse-version (string)
+  (uiop:parse-version (subseq string 0 (position #\- string)) #'error))
+(with-expected-failure ((or (and (featurep :ecl-bytecmp) :ecl-bytecmp "ECL Byte compiler does not handle LATIN-1")
+                             (and (featurep :abcl)
+                                  (equalp (subseq (permissive-parse-version (uiop:lisp-version-string)) 0 2)
+                                          '(1 8))
+                                 "ABCL version 1.8 does not properly handle latin-1 in the compiler")))
   (with-encoding-test (:latin-1 :op load-op)
     (def-test-system :test-system-encoding-l1-load-op
         :encoding :latin-1
diff --git a/test/test-run-program-unix.script b/test/test-run-program-unix.script
index 953373aa047e225b93d9847133fb4a660e54b37c..0b327e291c49bc96b20c1b34f453323313cbccfa 100644
--- a/test/test-run-program-unix.script
+++ b/test/test-run-program-unix.script
@@ -3,13 +3,6 @@
 
 (chdir *test-directory*)
 
-#+abcl
-(unless (version-satisfies
-         (second (split-string (implementation-identifier) :separator '(#\-)))
-         "1.4")
-  (leave-test
-   "This test is not meant to be run on versions of ABCL that predate 1.4" 0))
-
 #+clasp
 (unless (find-symbol* '#:run-program :ext nil)
   (leave-test "This clasp does not have a run-program function" 0))
@@ -215,6 +208,13 @@
                  :implemented))
        (error 'unexpected-test-success :test-designator ,test-designator))))
 
+#+abcl
+(let* ((raw-version (uiop:lisp-version-string))
+       (version
+         (subseq raw-version 0 (position #\- raw-version))))
+  (when (not (asdf:version-satisfies version "1.8"))
+    (push :old-abcl *features*)))
+
 
 ;;; The actual tests
 
@@ -242,16 +242,20 @@
 
 (define-test
     "launch-program :output t"
-    (expected-unimplemented ((:lispworks :abcl) :test-designator "launch-program :output t")
-       (launch-program (list "echo" "echoing output")
-                       :output t)))
+    (expected-unimplemented ((:lispworks :old-abcl) :test-designator "launch-program :output t")
+       (progn
+         (launch-program (list "echo" "echoing output")
+                         :output t)
+         t)))
 
 (define-test
     "launch-program :error-output t"
-    (expected-unimplemented ((:lispworks :abcl) :test-designator "launch-program :error-output t")
-       (uiop:wait-process
-        (launch-program (format nil "./exiter.sh 0 ~a" output-string)
-                        :error-output t))))
+    (expected-unimplemented ((:lispworks :old-abcl) :test-designator "launch-program :error-output t")
+  (progn
+    (uiop:wait-process
+     (launch-program (format nil "./exiter.sh 0 ~a" output-string)
+                     :error-output t))
+    t)))
 
 (define-test
     ":output <file> (file e.)"
diff --git a/uiop/common-lisp.lisp b/uiop/common-lisp.lisp
index 86f4d7e484da4f99705002deee583f3e7ba7606a..c76cb4720b079d08cb587d52c6d3e0ddbe5d5465 100644
--- a/uiop/common-lisp.lisp
+++ b/uiop/common-lisp.lisp
@@ -29,12 +29,13 @@
 
 ;;;; Early meta-level tweaks
 
-#+(or allegro clasp clisp clozure cmucl ecl lispworks mezzano mkcl sbcl)
+#+(or allegro clasp clisp clozure cmucl ecl lispworks mezzano mkcl sbcl abcl)
 (eval-when (:load-toplevel :compile-toplevel :execute)
   (when (and #+allegro (member :ics *features*)
              #+(or clasp clisp cmucl ecl lispworks mkcl) (member :unicode *features*)
              #+clozure (member :openmcl-unicode-strings *features*)
-             #+sbcl (member :sb-unicode *features*))
+             #+sbcl (member :sb-unicode *features*)
+             #+abcl t)
     ;; Check for unicode at runtime, so that a hypothetical FASL compiled with unicode
     ;; but loaded in a non-unicode setting (e.g. on Allegro) won't tell a lie.
     (pushnew :asdf-unicode *features*)))