diff --git a/test/src/data-tests.el b/test/src/data-tests.el
index 7c0796c5d2a..deec9feead7 100644
--- a/test/src/data-tests.el
+++ b/test/src/data-tests.el
@@ -85,6 +85,11 @@ this is exactly representable and is greater than
   (should (equal (subr-name (symbol-function 'cons)) "cons"))
   (should (equal (subr-name (symbol-function 'if)) "if")))
 
+(ert-deftest data-tests-byteorder ()
+  (let ((bo (byteorder)))
+    (should (integerp bo))
+    (should (memq bo (list ?B ?l)))))
+
 (ert-deftest data-tests-= ()
   (should-error (=))
   (should (= 1))
diff --git a/test/src/floatfns-tests.el b/test/src/floatfns-tests.el
index 49e76b809a3..cdd8865410c 100644
--- a/test/src/floatfns-tests.el
+++ b/test/src/floatfns-tests.el
@@ -31,6 +31,21 @@
 (ert-deftest floatfns-tests-tan ()
   (should (= (tan 0) 0.0)))
 
+(ert-deftest floatfns-tests-asin-acos-atan ()
+  (let ((eps 1e-12))
+    (should (< (abs (- (asin 0.0) 0.0)) eps))
+    (should (< (abs (- (asin 1.0) (/ float-pi 2))) eps))
+    (should (< (abs (- (acos 1.0) 0.0)) eps))
+    (should (< (abs (- (acos 0.0) (/ float-pi 2))) eps))
+    (should (< (abs (- (atan 0.0) 0.0)) eps))
+    (should (< (abs (- (atan 1.0) (/ float-pi 4))) eps))))
+
+(ert-deftest floatfns-tests-copysign ()
+  (should (= (copysign 1.0 2.0) 1.0))
+  (should (= (copysign 1.0 -2.0) -1.0))
+  (should (= (copysign -1.0 2.0) 1.0))
+  (should (= (copysign -1.0 -2.0) -1.0)))
+
 (ert-deftest floatfns-tests-isnan ()
   (should (isnan 0.0e+NaN))
   (should (isnan -0.0e+NaN))
diff --git a/test/src/fns-tests.el b/test/src/fns-tests.el
index 0288e3a460e..955b3cbe7fb 100644
--- a/test/src/fns-tests.el
+++ b/test/src/fns-tests.el
@@ -535,6 +535,58 @@
   (should (equal (fns-tests--with-region base64-encode-region "\x14\xfb\x9c\x03\xd9\x7e") "FPucA9l+"))
   (should (equal (fns-tests--with-region base64-encode-region "\x14\xfb\x9c\x03\xd9\x7f") "FPucA9l/")))
 
+(defun fns-tests--base64-decode-region (input &optional base64url ignore-invalid)
+  (with-temp-buffer
+    (set-buffer-multibyte nil)
+    (insert input)
+    (let ((len (base64-decode-region (point-min) (point-max)
+                                     base64url ignore-invalid)))
+      (list len (buffer-string)))))
+
+(defun fns-tests--as-unibyte (string)
+  (encode-coding-string string 'binary))
+
+(ert-deftest fns-tests-base64-decode-region ()
+  ;; standard variant RFC2045
+  (should (equal (fns-tests--base64-decode-region "") '(0 "")))
+  (should (equal (fns-tests--base64-decode-region "Zg==") '(1 "f")))
+  (should (equal (fns-tests--base64-decode-region "Zm8=") '(2 "fo")))
+  (should (equal (fns-tests--base64-decode-region "Zm9v") '(3 "foo")))
+  (should (equal (fns-tests--base64-decode-region "Zm9vYg==") '(4 "foob")))
+  (should (equal (fns-tests--base64-decode-region "Zm9vYmE=") '(5 "fooba")))
+  (should (equal (fns-tests--base64-decode-region "Zm9vYmFy") '(6 "foobar")))
+  (let* ((res (fns-tests--base64-decode-region "FPucA9l+"))
+         (len (nth 0 res))
+         (out (nth 1 res)))
+    (should (= len (string-bytes out)))
+    (should (equal (fns-tests--as-unibyte out)
+                   (fns-tests--as-unibyte "\x14\xfb\x9c\x03\xd9\x7e"))))
+  (let* ((res (fns-tests--base64-decode-region "FPucA9l/"))
+         (len (nth 0 res))
+         (out (nth 1 res)))
+    (should (= len (string-bytes out)))
+    (should (equal (fns-tests--as-unibyte out)
+                   (fns-tests--as-unibyte "\x14\xfb\x9c\x03\xd9\x7f"))))
+
+  ;; url variant
+  (let* ((res (fns-tests--base64-decode-region "FPucA9l-" t))
+         (len (nth 0 res))
+         (out (nth 1 res)))
+    (should (= len (string-bytes out)))
+    (should (equal (fns-tests--as-unibyte out)
+                   (fns-tests--as-unibyte "\x14\xfb\x9c\x03\xd9\x7e"))))
+  (let* ((res (fns-tests--base64-decode-region "FPucA9l_" t))
+         (len (nth 0 res))
+         (out (nth 1 res)))
+    (should (= len (string-bytes out)))
+    (should (equal (fns-tests--as-unibyte out)
+                   (fns-tests--as-unibyte "\x14\xfb\x9c\x03\xd9\x7f"))))
+
+  ;; ignore invalid characters
+  (should (equal (fns-tests--base64-decode-region "Zg==@" nil t) '(1 "f")))
+  (should (equal (fns-tests--base64-decode-region "Zg==@" t t) '(1 "f")))
+  (should-error (fns-tests--base64-decode-region "Zg=")))
+
 (ert-deftest fns-tests-base64-encode-string ()
   ;; standard variant RFC2045
   (should (equal (base64-encode-string "") ""))
diff --git a/test/src/keymap-tests.el b/test/src/keymap-tests.el
index c53ab7871c3..004ec1cee04 100644
--- a/test/src/keymap-tests.el
+++ b/test/src/keymap-tests.el
@@ -37,6 +37,22 @@
 (ert-deftest keymap-make-sparse-keymap ()
   (keymap-tests--make-keymap-test #'make-sparse-keymap))
 
+(ert-deftest keymap-accessible-keymaps ()
+  (let* ((map (make-sparse-keymap))
+         (sub (make-sparse-keymap)))
+    (define-key map (kbd "C-x") sub)
+    (define-key sub (kbd "C-f") #'find-file)
+    (define-key map (kbd "C-c") #'ignore)
+    (let ((maps (accessible-keymaps map)))
+      (should (equal (caar maps) []))
+      (should (eq (cdar maps) map))
+      (should (assoc [?\C-x] maps))
+      (should (eq (cdr (assoc [?\C-x] maps)) sub))
+      (should-not (assoc [?\C-c] maps)))
+    (let ((pref (accessible-keymaps map (kbd "C-x"))))
+      (should (equal (caar pref) [?\C-x]))
+      (should (eq (cdar pref) sub)))))
+
 (ert-deftest keymap-keymapp ()
   (should (keymapp (make-keymap)))
   (should (keymapp (make-sparse-keymap)))
diff --git a/test/src/minibuf-tests.el b/test/src/minibuf-tests.el
index 5bfbe710b10..36ca3604acf 100644
--- a/test/src/minibuf-tests.el
+++ b/test/src/minibuf-tests.el
@@ -431,5 +431,9 @@
                   (error nil))
                 'inhibit))))
 
+(ert-deftest minibuf-tests-active-minibuffer-window ()
+  (should-not (active-minibuffer-window))
+  (should (windowp (minibuffer-window))))
+
 
 ;;; minibuf-tests.el ends here