merge from trunk; clean up some issues

11 files changed, 1152 insertions, 427 deletions

diff --git a/test/ChangeLog b/test/ChangeLog
index 43648ad1bb1..98fb2e3da1f 100644
--- a/test/ChangeLog
+++ b/test/ChangeLog
@@ -1,3 +1,73 @@
+2013-05-31  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * automated/ruby-mode-tests.el: New tests, for percent literals
+        and expression expansion.
+
+2013-05-29  Leo Liu  <sdl.web@gmail.com>
+
+        * indent/octave.m: Tweak.
+
+2013-05-26  Aidan Gauland  <aidalgol@amuri.net>
+
+        * tests/eshell.el: Rewrite tests using ERT.
+
+2013-05-25  Leo Liu  <sdl.web@gmail.com>
+
+        * indent/octave.m: Add tests for %!, # and ### comments.
+
+2013-05-23  Kenichi Handa  <handa@gnu.org>
+
+        * automated/decoder-tests.el: New file.
+
+2013-05-19  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * indent/ruby.rb: Add multiline regexp example.
+
+        * automated/ruby-mode-tests.el (ruby-heredoc-highlights-interpolations)
+        (ruby-regexp-skips-over-interpolation)
+        (ruby-regexp-continues-till-end-when-unclosed)
+        (ruby-regexp-can-be-multiline)
+        (ruby-interpolation-inside-percent-literal): New tests.
+
+2013-05-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * indent/ruby.rb: Fix indentation after =; add more cases.
+
+2013-05-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * indent/pascal.pas: Add test for mis-identified comments.
+
+2013-04-01  Masatake YAMATO  <yamato@redhat.com>
+
+        * automated/imenu-tests.el: New file.  (Bug#14112)
+
+2013-04-19  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        * automated/python-tests.el (python-imenu-prev-index-position-1):
+        Remove test.
+        (python-imenu-create-index-1, python-imenu-create-flat-index-1):
+        New tests.
+
+2013-04-17  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        * automated/python-tests.el (python-nav-backward-defun-2)
+        (python-nav-backward-defun-3, python-nav-forward-defun-2)
+        (python-nav-forward-defun-3): New tests.
+
+2013-04-17  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        * automated/python-tests.el (python-nav-backward-defun-1)
+        (python-nav-forward-defun-1): New tests.
+
+2013-04-09  Masatake YAMATO  <yamato@redhat.com>
+
+        * automated/add-log-tests.el: New file. (Bug#14112)
+
+2013-03-30  Fabián Ezequiel Gallina  <fabian@anue.biz>
+
+        * automated/python-tests.el (python-indent-block-enders): New test.
+        (python-info-current-defun-2): Fix test.
+
 2013-03-05  Paul Eggert  <eggert@cs.ucla.edu>
 
         * indent/octave.m: Fix encoding error in comment.  Add coding tag.
@@ -31,8 +101,8 @@
         (ruby-move-to-block-skips-percent-literal): Add depth-affecting
         bits inside the examples.
         (ruby-move-to-block-skips-heredoc): New test.
-        (ruby-add-log-current-method-after-inner-class): Lower
-        expectations: move point inside a method, initially.
+        (ruby-add-log-current-method-after-inner-class):
+        Lower expectations: move point inside a method, initially.
 
 2013-02-13  Dmitry Gutov  <dgutov@yandex.ru>
 
@@ -45,8 +115,8 @@
 
 2013-02-03  Chong Yidong  <cyd@gnu.org>
 
-        * automated/files.el (file-test--do-local-variables-test): Avoid
-        compilation warning message.
+        * automated/files.el (file-test--do-local-variables-test):
+        Avoid compilation warning message.
 
 2013-01-27  Dmitry Gutov  <dgutov@yandex.ru>
 
@@ -350,7 +420,7 @@
 2011-07-26  Ulf Jasper  <ulf.jasper@web.de>
 
         * automated/icalendar-tests.el (icalendar-tests--compare-strings):
-        Removed, simply use string=.
+        Remove, simply use string=.
         (icalendar--diarytime-to-isotime)
         (icalendar--datetime-to-diary-date)
         (icalendar--datestring-to-isodate)
diff --git a/test/automated/add-log-tests.el b/test/automated/add-log-tests.el
new file mode 100644
index 00000000000..f6e803cd317
--- /dev/null
+++ b/test/automated/add-log-tests.el
@@ -0,0 +1,84 @@
+;;; add-log-tests.el --- Test suite for add-log.
+
+;; Copyright (C) 2013 Free Software Foundation, Inc.
+
+;; Author: Masatake YAMATO <yamato@redhat.com>
+;; Keywords: vc tools
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'add-log)
+
+(defmacro add-log-current-defun-deftest (name doc major-mode
+                                              content marker expected-defun)
+  "Generate an ert test for mode-own `add-log-current-defun-function'.
+Run `add-log-current-defun' at the point where MARKER specifies in a
+buffer which content is CONTENT under MAJOR-MODE. Then it compares the
+result with EXPECTED-DEFUN."
+  (let ((xname (intern (concat "add-log-current-defun-test-"
+                               (symbol-name name)
+                               ))))
+    `(ert-deftest ,xname ()
+         ,doc
+       (with-temp-buffer
+         (insert ,content)
+         (goto-char (point-min))
+         (funcall ',major-mode)
+         (should (equal (when (search-forward ,marker nil t)
+                          (replace-match "" nil t)
+                          (add-log-current-defun))
+                        ,expected-defun))))))
+
+(add-log-current-defun-deftest
+ sh-func1
+ "Test sh-current-defun-name can find function."
+ sh-mode "
+function foo
+{
+        ><
+}" "><" "foo")
+
+(add-log-current-defun-deftest
+ sh-func2
+ "Test sh-current-defun-name can find function."
+ sh-mode "
+foo()
+{
+        ><
+}" "><" "foo")
+
+(add-log-current-defun-deftest
+ sh-func3
+ "Test sh-current-defun-name can find function."
+ sh-mode "
+function foo()
+{
+        ><
+}" "><" "foo")
+
+(add-log-current-defun-deftest
+ sh-var
+ "Test sh-current-defun-name can find variable definition."
+ sh-mode "
+PATH=a:/ab:/usr/abc
+DIR=/pr><oc"
+"><" "DIR")
+
+(provide 'add-log-tests)
+
+;;; add-log-tests.el ends here
diff --git a/test/automated/decoder-tests.el b/test/automated/decoder-tests.el
new file mode 100644
index 00000000000..055626491c0
--- /dev/null
+++ b/test/automated/decoder-tests.el
@@ -0,0 +1,279 @@
+;;; decoder-tests.el --- test for text decoder
+
+;; Copyright (C) 2013 Free Software Foundation, Inc.
+
+;; Author: Kenichi Handa <handa@gnu.org>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'ert)
+
+;;; Check ASCII optimizing decoder
+
+;; Directory to hold test data files.
+(defvar decoder-tests-workdir
+  (expand-file-name "decoder-tests" temporary-file-directory))
+
+;; Return the contents (specified by CONTENT-TYPE; ascii, latin, or
+;; binary) of a test file.
+(defun decoder-tests-file-contents (content-type)
+  (let* ((ascii "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n")
+         (latin (concat ascii "ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏ\n"))
+         (binary (string-to-multibyte
+                  (concat (string-as-unibyte latin)
+                          (unibyte-string #xC0 #xC1 ?\n)))))
+    (cond ((eq content-type 'ascii) ascii)
+          ((eq content-type 'latin) latin)
+          ((eq content-type 'binary) binary)
+          (t
+           (error "Invalid file content type: %s" content-type)))))
+
+;; Return the name of test file whose contents specified by
+;; CONTENT-TYPE and whose encoding specified by CODING-SYSTEM.
+(defun decoder-tests-filename (content-type coding-system)
+  (expand-file-name (format "%s-%s" content-type coding-system)
+                    decoder-tests-workdir))
+
+;; Generate a test file whose contents specified by CONTENT-TYPE and
+;; whose encoding specified by CODING-SYSTEM.
+(defun decoder-tests-gen-file (content-type coding-system)
+  (or (file-directory-p decoder-tests-workdir)
+      (mkdir decoder-tests-workdir t))
+  (let ((file (decoder-tests-filename content-type coding-system)))
+    (with-temp-file file
+      (set-buffer-file-coding-system coding-system)
+      (insert (decoder-tests-file-contents content-type)))))
+
+;; Remove all generated test files.
+(defun decoder-tests-remove-files ()
+  (delete-directory decoder-tests-workdir t))
+
+;;; The following three functions are filters for contents of a test
+;;; file.
+
+;; Convert all LFs to CR LF sequences in the string STR.
+(defun decoder-tests-lf-to-crlf (str)
+  (with-temp-buffer
+    (insert str)
+    (goto-char (point-min))
+    (while (search-forward "\n" nil t)
+      (delete-char -1)
+      (insert "\r\n"))
+    (buffer-string)))
+
+;; Convert all LFs to CRs in the string STR.
+(defun decoder-tests-lf-to-cr (str)
+  (with-temp-buffer
+    (insert str)
+    (subst-char-in-region (point-min) (point-max) ?\n ?\r)
+    (buffer-string)))
+
+;; Convert all LFs to LF LF sequences in the string STR.
+(defun decoder-tests-lf-to-lflf (str)
+  (with-temp-buffer
+    (insert str)
+    (goto-char (point-min))
+    (while (search-forward "\n" nil t)
+      (insert "\n"))
+    (buffer-string)))
+
+;; Prepend the UTF-8 BOM to STR.
+(defun decoder-tests-add-bom (str)
+  (concat "\xfeff" str))
+
+;; Test the decoding of a file whose contents and encoding are
+;; specified by CONTENT-TYPE and WRITE-CODING.  The test passes if the
+;; file is read by READ-CODING and detected as DETECTED-CODING and the
+;; contents is correctly decoded.
+;; Optional 5th arg TRANSLATOR is a function to translate the original
+;; file contents to match with the expected result of decoding.  For
+;; instance, when a file of dos eol-type is read by unix eol-type,
+;; `decode-test-lf-to-crlf' must be specified.
+
+(defun decoder-tests (content-type write-coding read-coding detected-coding
+                                   &optional translator)
+  (prefer-coding-system 'utf-8-auto)
+  (let ((filename (decoder-tests-filename content-type write-coding)))
+    (with-temp-buffer
+      (let ((coding-system-for-read read-coding)
+            (contents (decoder-tests-file-contents content-type))
+            (disable-ascii-optimization nil))
+        (if translator
+            (setq contents (funcall translator contents)))
+        (insert-file-contents filename)
+        (if (and (coding-system-equal buffer-file-coding-system detected-coding)
+                 (string= (buffer-string) contents))
+            nil
+          (list buffer-file-coding-system
+                (string-to-list (buffer-string))
+                (string-to-list contents)))))))
+
+(ert-deftest ert-test-decoder-ascii ()
+  (unwind-protect
+      (progn
+        (dolist (eol-type '(unix dos mac))
+          (decoder-tests-gen-file 'ascii eol-type))
+        (should-not (decoder-tests 'ascii 'unix 'undecided 'unix))
+        (should-not (decoder-tests 'ascii 'dos 'undecided 'dos))
+        (should-not (decoder-tests 'ascii 'dos 'dos 'dos))
+        (should-not (decoder-tests 'ascii 'mac 'undecided 'mac))
+        (should-not (decoder-tests 'ascii 'mac 'mac 'mac))
+        (should-not (decoder-tests 'ascii 'dos 'utf-8 'utf-8-dos))
+        (should-not (decoder-tests 'ascii 'dos 'unix 'unix
+                                   'decoder-tests-lf-to-crlf))
+        (should-not (decoder-tests 'ascii 'mac 'dos 'dos
+                                   'decoder-tests-lf-to-cr))
+        (should-not (decoder-tests 'ascii 'dos 'mac 'mac
+                                   'decoder-tests-lf-to-lflf)))
+    (decoder-tests-remove-files)))
+
+(ert-deftest ert-test-decoder-latin ()
+  (unwind-protect
+      (progn
+        (dolist (coding '("utf-8" "utf-8-with-signature"))
+          (dolist (eol-type '("unix" "dos" "mac"))
+            (decoder-tests-gen-file 'latin
+                                    (intern (concat coding "-" eol-type)))))
+        (should-not (decoder-tests 'latin 'utf-8-unix 'undecided 'utf-8-unix))
+        (should-not (decoder-tests 'latin 'utf-8-unix 'utf-8-unix 'utf-8-unix))
+        (should-not (decoder-tests 'latin 'utf-8-dos 'undecided 'utf-8-dos))
+        (should-not (decoder-tests 'latin 'utf-8-dos 'utf-8-dos 'utf-8-dos))
+        (should-not (decoder-tests 'latin 'utf-8-mac 'undecided 'utf-8-mac))
+        (should-not (decoder-tests 'latin 'utf-8-mac 'utf-8-mac 'utf-8-mac))
+        (should-not (decoder-tests 'latin 'utf-8-dos 'unix 'utf-8-unix
+                                   'decoder-tests-lf-to-crlf))
+        (should-not (decoder-tests 'latin 'utf-8-mac 'dos 'utf-8-dos
+                                   'decoder-tests-lf-to-cr))
+        (should-not (decoder-tests 'latin 'utf-8-dos 'mac 'utf-8-mac
+                                   'decoder-tests-lf-to-lflf))
+        (should-not (decoder-tests 'latin 'utf-8-with-signature-unix 'undecided
+                                   'utf-8-with-signature-unix))
+        (should-not (decoder-tests 'latin 'utf-8-with-signature-unix 'utf-8-auto
+                                   'utf-8-with-signature-unix))
+        (should-not (decoder-tests 'latin 'utf-8-with-signature-dos 'undecided
+                                   'utf-8-with-signature-dos))
+        (should-not (decoder-tests 'latin 'utf-8-with-signature-unix 'utf-8
+                                   'utf-8-unix 'decoder-tests-add-bom))
+        (should-not (decoder-tests 'latin 'utf-8-with-signature-unix 'utf-8
+                                   'utf-8-unix 'decoder-tests-add-bom)))
+    (decoder-tests-remove-files)))
+
+(ert-deftest ert-test-decoder-binary ()
+  (unwind-protect
+      (progn
+        (dolist (eol-type '("unix" "dos" "mac"))
+          (decoder-tests-gen-file 'binary
+                                  (intern (concat "raw-text" "-" eol-type))))
+        (should-not (decoder-tests 'binary 'raw-text-unix 'undecided
+                                   'raw-text-unix))
+        (should-not (decoder-tests 'binary 'raw-text-dos 'undecided
+                                   'raw-text-dos))
+        (should-not (decoder-tests 'binary 'raw-text-mac 'undecided
+                                   'raw-text-mac))
+        (should-not (decoder-tests 'binary 'raw-text-dos 'unix
+                                   'raw-text-unix 'decoder-tests-lf-to-crlf))
+        (should-not (decoder-tests 'binary 'raw-text-mac 'dos
+                                   'raw-text-dos 'decoder-tests-lf-to-cr))
+        (should-not (decoder-tests 'binary 'raw-text-dos 'mac
+                                   'raw-text-mac 'decoder-tests-lf-to-lflf)))
+    (decoder-tests-remove-files)))
+
+
+
+;;; The following is for benchmark testing of the new optimized
+;;; decoder, not for regression testing.
+
+(defun generate-ascii-file ()
+  (dotimes (i 100000)
+    (insert-char ?a 80)
+    (insert "\n")))
+
+(defun generate-rarely-nonascii-file ()
+  (dotimes (i 100000)
+    (if (/= i 50000)
+        (insert-char ?a 80)
+      (insert ?À)
+      (insert-char ?a 79))
+    (insert "\n")))
+
+(defun generate-mostly-nonascii-file ()
+  (dotimes (i 30000)
+    (insert-char ?a 80)
+    (insert "\n"))
+  (dotimes (i 20000)
+    (insert-char ?À 80)
+    (insert "\n"))
+  (dotimes (i 10000)
+    (insert-char ?あ 80)
+    (insert "\n")))
+
+
+(defvar test-file-list
+  '((generate-ascii-file
+     ("~/ascii-tag-utf-8-unix.unix" ";; -*- coding: utf-8-unix; -*-" unix)
+     ("~/ascii-tag-utf-8.unix" ";; -*- coding: utf-8; -*-" unix)
+     ("~/ascii-tag-none.unix" "" unix)
+     ("~/ascii-tag-utf-8-dos.dos" ";; -*- coding: utf-8-dos; -*-" dos)
+     ("~/ascii-tag-utf-8.dos" ";; -*- coding: utf-8; -*-" dos)
+     ("~/ascii-tag-none.dos" "" dos))
+    (generate-rarely-nonascii-file
+     ("~/utf-8-r-tag-utf-8-unix.unix" ";; -*- coding: utf-8-unix; -*-" utf-8-unix)
+     ("~/utf-8-r-tag-utf-8.unix" ";; -*- coding: utf-8; -*-" utf-8-unix)
+     ("~/utf-8-r-tag-none.unix" "" utf-8-unix)
+     ("~/utf-8-r-tag-utf-8-dos.dos" ";; -*- coding: utf-8-dos; -*-" utf-8-dos)
+     ("~/utf-8-r-tag-utf-8.dos" ";; -*- coding: utf-8; -*-" utf-8-dos)
+     ("~/utf-8-r-tag-none.dos" "" utf-8-dos))
+    (generate-mostly-nonascii-file
+     ("~/utf-8-m-tag-utf-8-unix.unix" ";; -*- coding: utf-8-unix; -*-" utf-8-unix)
+     ("~/utf-8-m-tag-utf-8.unix" ";; -*- coding: utf-8; -*-" utf-8-unix)
+     ("~/utf-8-m-tag-none.unix" "" utf-8-unix)
+     ("~/utf-8-m-tag-utf-8-dos.dos" ";; -*- coding: utf-8-dos; -*-" utf-8-dos)
+     ("~/utf-8-m-tag-utf-8.dos" ";; -*- coding: utf-8; -*-" utf-8-dos)
+     ("~/utf-8-m-tag-none.dos" "" utf-8-dos))))
+
+(defun generate-benchmark-test-file ()
+  (interactive)
+  (with-temp-buffer
+    (message "Generating data...")
+    (dolist (files test-file-list)
+      (delete-region (point-min) (point-max))
+      (funcall (car files))
+      (dolist (file (cdr files))
+        (message "Writing %s..." (car file))
+        (goto-char (point-min))
+        (insert (nth 1 file) "\n")
+        (let ((coding-system-for-write (nth 2 file)))
+          (write-region (point-min) (point-max) (car file)))
+        (delete-region (point-min) (point))))))
+
+(defun benchmark-decoder ()
+  (let ((gc-cons-threshold 4000000))
+    (insert "Without optimization:\n")
+    (dolist (files test-file-list)
+      (dolist (file (cdr files))
+        (let* ((disable-ascii-optimization t)
+               (result (benchmark-run 10
+                         (with-temp-buffer (insert-file-contents (car file))))))
+          (insert (format "%s: %s\n"  (car file) result)))))
+    (insert "With optimization:\n")
+    (dolist (files test-file-list)
+      (dolist (file (cdr files))
+        (let* ((disable-ascii-optimization nil)
+               (result (benchmark-run 10
+                         (with-temp-buffer (insert-file-contents (car file))))))
+          (insert (format "%s: %s\n" (car file) result)))))))
diff --git a/test/automated/imenu-test.el b/test/automated/imenu-test.el
new file mode 100644
index 00000000000..83e19ebd914
--- /dev/null
+++ b/test/automated/imenu-test.el
@@ -0,0 +1,87 @@
+;;; imenu-tests.el --- Test suite for imenu.
+
+;; Copyright (C) 2013 Free Software Foundation, Inc.
+
+;; Author: Masatake YAMATO <yamato@redhat.com>
+;; Keywords: tools convenience
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'imenu)
+
+;; (imenu-simple-scan-deftest-gather-strings-from-list
+;;     '(nil t 'a (0 . "x") ("c" . "d") ("a" 0 "b") ))
+;; => ("b" "a" "d" "c" "x")
+(defun imenu-simple-scan-deftest-gather-strings-from-list(input)
+  "Gather strings from INPUT, a list."
+  (let ((result ()))
+    (while input
+      (cond
+       ((stringp input)
+        (setq result (cons input result)
+              input nil))
+       ((atom input)
+        (setq input nil))
+       ((listp (car input))
+        (setq result (append
+                      (imenu-simple-scan-deftest-gather-strings-from-list (car input))
+                      result)
+              input (cdr input)))
+       ((stringp (car input))
+        (setq result (cons (car input) result)
+              input (cdr input)))
+       (t
+        (setq input (cdr input)))))
+    result))
+
+(defmacro imenu-simple-scan-deftest (name doc major-mode content expected-items)
+  "Generate an ert test for mode-own imenu expression.
+Run `imenu-create-index-function' at the buffer which content is
+CONTENT with MAJOR-MODE. A generated test runs `imenu-create-index-function'
+at the buffer which content is CONTENT with MAJOR-MODE. Then it compares a list
+of strings which are picked up from the result with EXPECTED-ITEMS."
+  (let ((xname (intern (concat "imenu-simple-scan-deftest-" (symbol-name name)))))
+    `(ert-deftest ,xname ()
+         ,doc
+       (with-temp-buffer
+         (insert ,content)
+         (funcall ',major-mode)
+         (let ((result-items (sort (imenu-simple-scan-deftest-gather-strings-from-list
+                                    (funcall imenu-create-index-function))
+                                   #'string-lessp))
+               (expected-items (sort (copy-sequence ,expected-items) #'string-lessp)))
+           (should (equal result-items expected-items))
+           )))))
+
+(imenu-simple-scan-deftest sh "Test imenu expression for sh-mode." sh-mode "a()
+{
+}
+function b
+{
+}
+function c()
+{
+}
+function ABC_D()
+{
+}
+" '("a" "b" "c" "ABC_D"))
+
+(provide 'imenu-tests)
+
+;;; imenu-tests.el ends here
diff --git a/test/automated/python-tests.el b/test/automated/python-tests.el
index ab8eb4816d3..8462a863b84 100644
--- a/test/automated/python-tests.el
+++ b/test/automated/python-tests.el
@@ -444,6 +444,28 @@ objects = Thing.objects.all() \\\\
    (should (eq (car (python-indent-context)) 'after-line))
    (should (= (python-indent-calculate-indentation) 0))))
 
+(ert-deftest python-indent-block-enders ()
+  "Test `python-indent-block-enders' value honoring."
+  (python-tests-with-temp-buffer
+   "
+Class foo(object):
+
+    def bar(self):
+        if self.baz:
+            return (1,
+                    2,
+                    3)
+
+        else:
+            pass
+"
+   (python-tests-look-at "3)")
+   (forward-line 1)
+   (= (python-indent-calculate-indentation) 12)
+   (python-tests-look-at "pass")
+   (forward-line 1)
+   (= (python-indent-calculate-indentation) 8)))
+
 
 ;;; Navigation
 
@@ -652,6 +674,201 @@ def decoratorFunctionWithArguments(arg1, arg2, arg3):
                 (python-tests-look-at "return wrapped_f")
                 (line-beginning-position))))))
 
+(ert-deftest python-nav-backward-defun-1 ()
+  (python-tests-with-temp-buffer
+   "
+class A(object): # A
+
+    def a(self): # a
+        pass
+
+    def b(self): # b
+        pass
+
+    class B(object): # B
+
+        class C(object): # C
+
+            def d(self): # d
+                pass
+
+            # def e(self): # e
+            #     pass
+
+    def c(self): # c
+        pass
+
+    # def d(self): # d
+    #     pass
+"
+   (goto-char (point-max))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "    def c(self): # c" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "            def d(self): # d" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "        class C(object): # C" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "    class B(object): # B" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "    def b(self): # b" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "    def a(self): # a" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "class A(object): # A" -1)))
+   (should (not (python-nav-backward-defun)))))
+
+(ert-deftest python-nav-backward-defun-2 ()
+  (python-tests-with-temp-buffer
+   "
+def decoratorFunctionWithArguments(arg1, arg2, arg3):
+    '''print decorated function call data to stdout.
+
+    Usage:
+
+    @decoratorFunctionWithArguments('arg1', 'arg2')
+    def func(a, b, c=True):
+        pass
+    '''
+
+    def wwrap(f):
+        print 'Inside wwrap()'
+        def wrapped_f(*args):
+            print 'Inside wrapped_f()'
+            print 'Decorator arguments:', arg1, arg2, arg3
+            f(*args)
+            print 'After f(*args)'
+        return wrapped_f
+    return wwrap
+"
+   (goto-char (point-max))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "        def wrapped_f(*args):" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "    def wwrap(f):" -1)))
+   (should (= (save-excursion (python-nav-backward-defun))
+              (python-tests-look-at "def decoratorFunctionWithArguments(arg1, arg2, arg3):" -1)))
+   (should (not (python-nav-backward-defun)))))
+
+(ert-deftest python-nav-backward-defun-3 ()
+  (python-tests-with-temp-buffer
+   "
+'''
+    def u(self):
+        pass
+
+    def v(self):
+        pass
+
+    def w(self):
+        pass
+'''
+
+class A(object):
+    pass
+"
+   (goto-char (point-min))
+   (let ((point (python-tests-look-at "class A(object):")))
+     (should (not (python-nav-backward-defun)))
+     (should (= point (point))))))
+
+(ert-deftest python-nav-forward-defun-1 ()
+  (python-tests-with-temp-buffer
+   "
+class A(object): # A
+
+    def a(self): # a
+        pass
+
+    def b(self): # b
+        pass
+
+    class B(object): # B
+
+        class C(object): # C
+
+            def d(self): # d
+                pass
+
+            # def e(self): # e
+            #     pass
+
+    def c(self): # c
+        pass
+
+    # def d(self): # d
+    #     pass
+"
+   (goto-char (point-min))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(object): # A")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(self): # a")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(self): # b")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(object): # B")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(object): # C")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(self): # d")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(self): # c")))
+   (should (not (python-nav-forward-defun)))))
+
+(ert-deftest python-nav-forward-defun-2 ()
+  (python-tests-with-temp-buffer
+   "
+def decoratorFunctionWithArguments(arg1, arg2, arg3):
+    '''print decorated function call data to stdout.
+
+    Usage:
+
+    @decoratorFunctionWithArguments('arg1', 'arg2')
+    def func(a, b, c=True):
+        pass
+    '''
+
+    def wwrap(f):
+        print 'Inside wwrap()'
+        def wrapped_f(*args):
+            print 'Inside wrapped_f()'
+            print 'Decorator arguments:', arg1, arg2, arg3
+            f(*args)
+            print 'After f(*args)'
+        return wrapped_f
+    return wwrap
+"
+   (goto-char (point-min))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(arg1, arg2, arg3):")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(f):")))
+   (should (= (save-excursion (python-nav-forward-defun))
+              (python-tests-look-at "(*args):")))
+   (should (not (python-nav-forward-defun)))))
+
+(ert-deftest python-nav-forward-defun-3 ()
+  (python-tests-with-temp-buffer
+   "
+class A(object):
+    pass
+
+'''
+    def u(self):
+        pass
+
+    def v(self):
+        pass
+
+    def w(self):
+        pass
+'''
+"
+   (goto-char (point-min))
+   (let ((point (python-tests-look-at "(object):")))
+     (should (not (python-nav-forward-defun)))
+     (should (= point (point))))))
 
 (ert-deftest python-nav-beginning-of-statement-1 ()
   (python-tests-with-temp-buffer
@@ -1456,66 +1673,133 @@ Using `python-shell-interpreter' and
 
 
 ;;; Imenu
-(ert-deftest python-imenu-prev-index-position-1 ()
-  (require 'imenu)
+
+(ert-deftest python-imenu-create-index-1 ()
   (python-tests-with-temp-buffer
    "
-def decoratorFunctionWithArguments(arg1, arg2, arg3):
+class Foo(models.Model):
+    pass
+
+
+class Bar(models.Model):
+    pass
+
+
+def decorator(arg1, arg2, arg3):
     '''print decorated function call data to stdout.
 
     Usage:
 
-    @decoratorFunctionWithArguments('arg1', 'arg2')
+    @decorator('arg1', 'arg2')
     def func(a, b, c=True):
         pass
     '''
 
-    def wwrap(f):
-        print 'Inside wwrap()'
+    def wrap(f):
+        print ('wrap')
         def wrapped_f(*args):
-            print 'Inside wrapped_f()'
-            print 'Decorator arguments:', arg1, arg2, arg3
+            print ('wrapped_f')
+            print ('Decorator arguments:', arg1, arg2, arg3)
             f(*args)
-            print 'After f(*args)'
+            print ('called f(*args)')
         return wrapped_f
-    return wwrap
+    return wrap
 
-def test(): # Some comment
-    'This is a test function'
-    print 'test'
 
-class C(object):
+class Baz(object):
 
-    def m(self):
-        self.c()
+    def a(self):
+        pass
 
-        def b():
-            pass
+    def b(self):
+        pass
 
-        def a():
+    class Frob(object):
+
+        def c(self):
             pass
+"
+   (goto-char (point-max))
+   (should (equal
+            (list
+             (cons "Foo (class)" (copy-marker 2))
+             (cons "Bar (class)" (copy-marker 38))
+             (list
+              "decorator (def)"
+              (cons "*function definition*" (copy-marker 74))
+              (list
+               "wrap (def)"
+               (cons "*function definition*" (copy-marker 254))
+               (cons "wrapped_f (def)" (copy-marker 294))))
+             (list
+              "Baz (class)"
+              (cons "*class definition*" (copy-marker 519))
+              (cons "a (def)" (copy-marker 539))
+              (cons "b (def)" (copy-marker 570))
+              (list
+               "Frob (class)"
+               (cons "*class definition*" (copy-marker 601))
+               (cons "c (def)" (copy-marker 626)))))
+            (python-imenu-create-index)))))
+
+(ert-deftest python-imenu-create-flat-index-1 ()
+  (python-tests-with-temp-buffer
+   "
+class Foo(models.Model):
+    pass
 
-    def c(self):
+
+class Bar(models.Model):
+    pass
+
+
+def decorator(arg1, arg2, arg3):
+    '''print decorated function call data to stdout.
+
+    Usage:
+
+    @decorator('arg1', 'arg2')
+    def func(a, b, c=True):
         pass
+    '''
+
+    def wrap(f):
+        print ('wrap')
+        def wrapped_f(*args):
+            print ('wrapped_f')
+            print ('Decorator arguments:', arg1, arg2, arg3)
+            f(*args)
+            print ('called f(*args)')
+        return wrapped_f
+    return wrap
+
+
+class Baz(object):
+
+    def a(self):
+        pass
+
+    def b(self):
+        pass
+
+    class Frob(object):
+
+        def c(self):
+            pass
 "
-   (let ((expected
-          '(("*Rescan*" . -99)
-            ("decoratorFunctionWithArguments" . 2)
-            ("decoratorFunctionWithArguments.wwrap" . 224)
-            ("decoratorFunctionWithArguments.wwrap.wrapped_f" . 273)
-            ("test" . 500)
-            ("C" . 575)
-            ("C.m" . 593)
-            ("C.m.b" . 628)
-            ("C.m.a" . 663)
-            ("C.c" . 698))))
-     (mapc
-      (lambda (elt)
-        (should (= (cdr (assoc-string (car elt) expected))
-                   (if (markerp (cdr elt))
-                       (marker-position (cdr elt))
-                     (cdr elt)))))
-      (imenu--make-index-alist)))))
+   (goto-char (point-max))
+   (should (equal
+            (list (cons "Foo" (copy-marker 2))
+                  (cons "Bar" (copy-marker 38))
+                  (cons "decorator" (copy-marker 74))
+                  (cons "decorator.wrap" (copy-marker 254))
+                  (cons "decorator.wrap.wrapped_f" (copy-marker 294))
+                  (cons "Baz" (copy-marker 519))
+                  (cons "Baz.a" (copy-marker 539))
+                  (cons "Baz.b" (copy-marker 570))
+                  (cons "Baz.Frob" (copy-marker 601))
+                  (cons "Baz.Frob.c" (copy-marker 626)))
+            (python-imenu-create-flat-index)))))
 
 
 ;;; Misc helpers
@@ -1546,13 +1830,13 @@ class C(object):
             return []
 
         def b():
-            pass
+            do_b()
 
         def a():
-            pass
+            do_a()
 
     def c(self):
-        pass
+        do_c()
 "
    (forward-line 1)
    (should (string= "C" (python-info-current-defun)))
@@ -1582,7 +1866,7 @@ class C(object):
    (python-tests-look-at "def c(self):")
    (should (string= "C.c" (python-info-current-defun)))
    (should (string= "def C.c" (python-info-current-defun t)))
-   (python-tests-look-at "pass")
+   (python-tests-look-at "do_c()")
    (should (string= "C.c" (python-info-current-defun)))
    (should (string= "def C.c" (python-info-current-defun t)))))
 
diff --git a/test/automated/ruby-mode-tests.el b/test/automated/ruby-mode-tests.el
index 0ebe6d44e34..77dd62821f7 100644
--- a/test/automated/ruby-mode-tests.el
+++ b/test/automated/ruby-mode-tests.el
@@ -84,6 +84,9 @@ VALUES-PLIST is a list with alternating index and value elements."
 (ert-deftest ruby-singleton-class-no-heredoc-font-lock ()
   (ruby-assert-face "class<<a" 8 nil))
 
+(ert-deftest ruby-heredoc-highlights-interpolations ()
+  (ruby-assert-face "s = <<EOS\n  #{foo}\nEOS" 15 font-lock-variable-name-face))
+
 (ert-deftest ruby-deep-indent ()
   (let ((ruby-deep-arglist nil)
         (ruby-deep-indent-paren '(?\( ?\{ ?\[ ?\] t)))
@@ -109,6 +112,18 @@ VALUES-PLIST is a list with alternating index and value elements."
 (ert-deftest ruby-regexp-starts-after-string ()
   (ruby-assert-state "'(/', /\d+/" 3 ?/ 8))
 
+(ert-deftest ruby-regexp-interpolation-is-highlighted ()
+  (ruby-assert-face "/#{foobs}/" 4 font-lock-variable-name-face))
+
+(ert-deftest ruby-regexp-skips-over-interpolation ()
+  (ruby-assert-state "/#{foobs.join('/')}/" 3 nil))
+
+(ert-deftest ruby-regexp-continues-till-end-when-unclosed ()
+  (ruby-assert-state "/bars" 3 ?/))
+
+(ert-deftest ruby-regexp-can-be-multiline ()
+  (ruby-assert-state "/bars\ntees # toots \nfoos/" 3 nil))
+
 (ert-deftest ruby-indent-simple ()
   (ruby-should-indent-buffer
    "if foo
@@ -325,6 +340,13 @@ VALUES-PLIST is a list with alternating index and value elements."
       (search-forward "tee")
       (should (string= (thing-at-point 'symbol) "tee")))))
 
+(ert-deftest ruby-interpolation-inside-percent-literal ()
+  (let ((s "%( #{boo} )"))
+    (ruby-assert-face s 1 font-lock-string-face)
+    (ruby-assert-face s 4 font-lock-variable-name-face)
+    (ruby-assert-face s 10 font-lock-string-face)
+    (ruby-assert-state s 8 nil)))
+
 (ert-deftest ruby-interpolation-inside-percent-literal-with-paren ()
   :expected-result :failed
   (let ((s "%(^#{\")\"}^)"))
@@ -334,6 +356,23 @@ VALUES-PLIST is a list with alternating index and value elements."
     ;; It's confused by the closing paren in the middle.
     (ruby-assert-state s 8 nil)))
 
+(ert-deftest ruby-interpolation-inside-double-quoted-percent-literals ()
+  (ruby-assert-face "%Q{foo #@bar}" 8 font-lock-variable-name-face)
+  (ruby-assert-face "%W{foo #@bar}" 8 font-lock-variable-name-face)
+  (ruby-assert-face "%r{foo #@bar}" 8 font-lock-variable-name-face)
+  (ruby-assert-face "%x{foo #@bar}" 8 font-lock-variable-name-face))
+
+(ert-deftest ruby-no-interpolation-in-single-quoted-literals ()
+  (ruby-assert-face "'foo #@bar'" 7 font-lock-string-face)
+  (ruby-assert-face "%q{foo #@bar}" 8 font-lock-string-face)
+  (ruby-assert-face "%w{foo #@bar}" 8 font-lock-string-face)
+  (ruby-assert-face "%s{foo #@bar}" 8 font-lock-string-face))
+
+(ert-deftest ruby-no-unknown-percent-literals ()
+  ;; No folding of case.
+  (ruby-assert-face "%S{foo}" 4 nil)
+  (ruby-assert-face "%R{foo}" 4 nil))
+
 (ert-deftest ruby-add-log-current-method-examples ()
   (let ((pairs '(("foo" . "#foo")
                  ("C.foo" . ".foo")
@@ -487,6 +526,42 @@ VALUES-PLIST is a list with alternating index and value elements."
     (ruby-beginning-of-block)
     (should (= 1 (line-number-at-pos)))))
 
+(ert-deftest ruby-move-to-block-does-not-fold-case ()
+  (ruby-with-temp-buffer
+      (ruby-test-string
+       "foo do
+       |  Module.to_s
+       |end")
+    (end-of-buffer)
+    (let ((case-fold-search t))
+      (ruby-beginning-of-block))
+    (should (= 1 (line-number-at-pos)))))
+
+(ert-deftest ruby-beginning-of-defun-does-not-fold-case ()
+  (ruby-with-temp-buffer
+      (ruby-test-string
+       "class C
+       |  def bar
+       |    Class.to_s
+       |  end
+       |end")
+    (goto-line 4)
+    (let ((case-fold-search t))
+      (beginning-of-defun))
+    (should (= 2 (line-number-at-pos)))))
+
+(ert-deftest ruby-end-of-defun-skips-to-next-line-after-the-method ()
+  (ruby-with-temp-buffer
+      (ruby-test-string
+       "class D
+       |  def tee
+       |    'ho hum'
+       |  end
+       |end")
+    (goto-line 2)
+    (end-of-defun)
+    (should (= 5 (line-number-at-pos)))))
+
 (provide 'ruby-mode-tests)
 
 ;;; ruby-mode-tests.el ends here
diff --git a/test/eshell.el b/test/eshell.el
index 7baeb58a56a..126a47220c4 100644
--- a/test/eshell.el
+++ b/test/eshell.el
@@ -1,4 +1,4 @@
-;;; esh-test.el --- Eshell test suite
+;;; tests/eshell.el --- Eshell test suite
 
 ;; Copyright (C) 1999-2013 Free Software Foundation, Inc.
 
@@ -21,55 +21,20 @@
 
 ;;; Commentary:
 
-;; The purpose of this module is to verify that Eshell works as
-;; expected.  To run it on your system, use the command
-;; \\[eshell-test].
+;; Eshell test suite.
 
 ;;; Code:
 
-(eval-when-compile
-  (require 'cl-lib)
-  (require 'eshell)
-  (require 'esh-util))
-(require 'esh-mode)
-
-(defgroup eshell-test nil
-  "This module is meant to ensure that Eshell is working correctly."
-  :tag "Eshell test suite"
-  :group 'eshell)
-
-;;; User Variables:
-
-(defface eshell-test-ok
-  '((((class color) (background light)) (:foreground "Green" :bold t))
-    (((class color) (background dark)) (:foreground "Green" :bold t)))
-  "The face used to highlight OK result strings."
-  :group 'eshell-test)
-(define-obsolete-face-alias 'eshell-test-ok-face 'eshell-test-ok "22.1")
-
-(defface eshell-test-failed
-  '((((class color) (background light)) (:foreground "OrangeRed" :bold t))
-    (((class color) (background dark)) (:foreground "OrangeRed" :bold t))
-    (t (:bold t)))
-  "The face used to highlight FAILED result strings."
-  :group 'eshell-test)
-(define-obsolete-face-alias 'eshell-test-failed-face 'eshell-test-failed "22.1")
-
-(defcustom eshell-show-usage-metrics nil
-  "If non-nil, display different usage metrics for each Eshell command."
-  :set (lambda (symbol value)
-         (if value
-             (add-hook 'eshell-mode-hook 'eshell-show-usage-metrics)
-           (remove-hook 'eshell-mode-hook 'eshell-show-usage-metrics))
-         (set symbol value))
-  :type '(choice (const :tag "No metrics" nil)
-                 (const :tag "Cons cells consumed" t)
-                 (const :tag "Time elapsed" 0))
-  :group 'eshell-test)
+(require 'ert)
+(require 'eshell)
 
-;;; Code:
-
-(defvar test-buffer)
+(defmacro with-temp-eshell (&rest body)
+  "Evaluate BODY in a temporary Eshell buffer."
+  `(let ((eshell-buffer (eshell t)))
+     (unwind-protect
+         (with-current-buffer eshell-buffer
+           ,@body)
+       (kill-buffer eshell-buffer))))
 
 (defun eshell-insert-command (text &optional func)
   "Insert a command at the end of the buffer."
@@ -87,335 +52,141 @@
   (eshell-insert-command text func)
   (eshell-match-result regexp))
 
-(defvar eshell-test-failures nil)
-
-(defun eshell-run-test (module funcsym label command)
-  "Test whether FORM evaluates to a non-nil value."
-  (when (let ((sym (intern-soft (concat "eshell-" (symbol-name module)))))
-          (or (memq sym (eshell-subgroups 'eshell))
-              (eshell-using-module sym)))
-    (with-current-buffer test-buffer
-      (insert-before-markers
-       (format "%-70s " (substring label 0 (min 70 (length label)))))
-      (insert-before-markers "  ....")
-      (eshell-redisplay))
-    (let ((truth (eval command)))
-      (with-current-buffer test-buffer
-        (delete-char -6)
-        (insert-before-markers
-         "[" (let (str)
-               (if truth
-                   (progn
-                     (setq str "  OK  ")
-                     (put-text-property 0 6 'face 'eshell-test-ok str))
-                 (setq str "FAILED")
-                 (setq eshell-test-failures (1+ eshell-test-failures))
-                 (put-text-property 0 6 'face 'eshell-test-failed str))
-               str) "]")
-        (add-text-properties (line-beginning-position) (point)
-                             (list 'test-func funcsym))
-        (eshell-redisplay)))))
-
-(defun eshell-test-goto-func ()
-  "Jump to the function that defines a particular test."
-  (interactive)
-  (let ((fsym (get-text-property (point) 'test-func)))
-    (when fsym
-      (let* ((def (symbol-function fsym))
-             (library (locate-library (symbol-file fsym 'defun)))
-             (name (substring (symbol-name fsym)
-                              (length "eshell-test--")))
-             (inhibit-redisplay t))
-        (find-file library)
-        (goto-char (point-min))
-        (re-search-forward (concat "^(eshell-deftest\\s-+\\w+\\s-+"
-                                   name))
-        (beginning-of-line)))))
-
-(defun eshell-run-one-test (&optional arg)
-  "Jump to the function that defines a particular test."
-  (interactive "P")
-  (let ((fsym (get-text-property (point) 'test-func)))
-    (when fsym
-      (beginning-of-line)
-      (delete-region (point) (line-end-position))
-      (let ((test-buffer (current-buffer)))
-        (set-buffer (let ((inhibit-redisplay t))
-                      (save-window-excursion (eshell t))))
-        (funcall fsym)
-        (unless arg
-          (kill-buffer (current-buffer)))))))
-
-;;;###autoload
-(defun eshell-test (&optional arg)
-  "Test Eshell to verify that it works as expected."
-  (interactive "P")
-  (let* ((begin (float-time))
-         (test-buffer (get-buffer-create "*eshell test*")))
-    (set-buffer (let ((inhibit-redisplay t))
-                  (save-window-excursion (eshell t))))
-    (with-current-buffer test-buffer
-      (erase-buffer)
-      (setq major-mode 'eshell-test-mode)
-      (setq mode-name "EShell Test")
-      (set (make-local-variable 'eshell-test-failures) 0)
-      (local-set-key [(control ?c) (control ?c)] 'eshell-test-goto-func)
-      (local-set-key [(control ?c) (control ?r)] 'eshell-run-one-test)
-      (local-set-key [(control ?m)] 'eshell-test-goto-func)
-      (local-set-key [return] 'eshell-test-goto-func)
-
-      (insert "Testing Eshell under " (emacs-version))
-      (switch-to-buffer test-buffer)
-      (delete-other-windows))
-    (dolist (funcname (sort (all-completions "eshell-test--"
-                                                obarray 'functionp)
-                               'string-lessp))
-      (with-current-buffer test-buffer
-        (insert "\n"))
-      (funcall (intern-soft funcname)))
-    (with-current-buffer test-buffer
-      (insert (format "\n\n--- %s --- (completed in %d seconds)\n"
-                      (current-time-string)
-                      (- (float-time) begin)))
-      (message "Eshell test suite completed: %s failure%s"
-               (if (> eshell-test-failures 0)
-                   (number-to-string eshell-test-failures)
-                 "No")
-               (if (= eshell-test-failures 1) "" "s"))))
-  (goto-char eshell-last-output-end)
-  (unless arg
-    (kill-buffer (current-buffer))))
-
-
-(defvar eshell-metric-before-command 0)
-(defvar eshell-metric-after-command 0)
-
-(defun eshell-show-usage-metrics ()
-  "If run at Eshell mode startup, metrics are shown after each command."
-  (set (make-local-variable 'eshell-metric-before-command)
-       (if (eq eshell-show-usage-metrics t)
-           0
-         (current-time)))
-  (set (make-local-variable 'eshell-metric-after-command)
-       (if (eq eshell-show-usage-metrics t)
-           0
-         (current-time)))
-
-  (add-hook 'eshell-pre-command-hook
-            (function
-             (lambda ()
-               (setq eshell-metric-before-command
-                     (if (eq eshell-show-usage-metrics t)
-                         (car (memory-use-counts))
-                       (current-time))))) nil t)
-
-  (add-hook 'eshell-post-command-hook
-            (function
-             (lambda ()
-               (setq eshell-metric-after-command
-                     (if (eq eshell-show-usage-metrics t)
-                         (car (memory-use-counts))
-                       (current-time)))
-               (eshell-interactive-print
-                (concat
-                 (int-to-string
-                  (if (eq eshell-show-usage-metrics t)
-                      (- eshell-metric-after-command
-                         eshell-metric-before-command 7)
-                    (- (float-time
-                        eshell-metric-after-command)
-                       (float-time
-                        eshell-metric-before-command))))
-                 "\n"))))
-            nil t))
-
-
-;;; The tests.
-
-(defmacro eshell-deftest (module name label &rest forms)
-  (declare (indent 2))
-  (if (and (fboundp 'cl-compiling-file) (cl-compiling-file))
-      nil
-    (let ((fsym (intern (concat "eshell-test--" (symbol-name name)))))
-      `(eval-when-compile
-         (ignore
-          (defun ,fsym () ,label
-            (eshell-run-test (quote ,module) (quote ,fsym) ,label
-                             (quote (progn ,@forms)))))))))
-
-
-(eshell-deftest mode same-window-buffer-names
-  "`eshell-buffer-name' is a member of `same-window-buffer-names'"
-  (member eshell-buffer-name same-window-buffer-names))
-
-(eshell-deftest mode eshell-directory-exists
-  "`eshell-directory-name' exists and is writable"
-  (file-writable-p eshell-directory-name))
-
-(eshell-deftest mode eshell-directory-modes
-  "`eshell-directory-name' has correct access protections"
-  (or (eshell-under-windows-p)
-      (= (file-modes eshell-directory-name)
-         eshell-private-directory-modes)))
-
-(eshell-deftest mode simple-command-result
-  "`eshell-command-result' works with a simple command."
-  (= (eshell-command-result "+ 1 2") 3))
-
-
-(require 'em-banner)
-
-(eshell-deftest banner banner-displayed
-  "Startup banner is displayed at point-min"
-  (cl-assert eshell-banner-message)
-  (let ((msg (eval eshell-banner-message)))
-    (cl-assert msg)
-    (goto-char (point-min))
-    (looking-at msg)))
-
-
-(require 'esh-cmd)
-
-(eshell-deftest var last-result-var
-  "\"last result\" variable"
-  (eshell-command-result-p "+ 1 2; + $$ 2" "3\n5\n"))
-
-(eshell-deftest var last-result-var2
-  "\"last result\" variable"
-  (eshell-command-result-p "+ 1 2; + $$ $$" "3\n6\n"))
-
-(eshell-deftest var last-arg-var
-  "\"last arg\" variable"
-  (eshell-command-result-p "+ 1 2; + $_ 4" "3\n6\n"))
-
-(eshell-deftest cmd lisp-command
-  "Evaluate Lisp command"
-  (eshell-command-result-p "(+ 1 2)" "3"))
-
-(eshell-deftest cmd lisp-command-args
-  "Evaluate Lisp command (ignore args)"
-  (eshell-command-result-p "(+ 1 2) 3" "3"))
-
-(eshell-deftest cmd subcommand
-  "Run subcommand"
-  (eshell-command-result-p "{+ 1 2}" "3\n"))
-
-(eshell-deftest cmd subcommand-args
-  "Run subcommand (ignore args)"
-  (eshell-command-result-p "{+ 1 2} 3" "3\n"))
-
-(eshell-deftest cmd subcommand-lisp
-  "Run subcommand + Lisp form"
-  (eshell-command-result-p "{(+ 1 2)}" "3\n"))
-
-(eshell-deftest cmd named-command
-  "Execute named command"
-  (eshell-command-result-p "+ 1 2" "3\n"))
-
-
-(require 'esh-mode)
-
-(eshell-deftest mode major-mode
-  "Major mode is correct"
-  (eq major-mode 'eshell-mode))
-
-(eshell-deftest mode eshell-mode-variable
-  "`eshell-mode' is true"
-  (eq eshell-mode t))
-
-(eshell-deftest var window-height
-  "LINES equals window height"
-  (let ((eshell-stringify-t t))
-    (eshell-command-result-p "= $LINES (window-height)" "t\n")))
-
-(eshell-deftest mode command-running-p
-  "Modeline shows no command running"
-  (or (featurep 'xemacs)
-      (not eshell-status-in-modeline)
-      (and (memq 'eshell-command-running-string mode-line-format)
-           (equal eshell-command-running-string "--"))))
-
-(eshell-deftest arg forward-arg
-  "Move across command arguments"
-  (eshell-insert-command "echo $(+ 1 (- 4 3)) \"alpha beta\" file" 'ignore)
-  (let ((here (point)) begin valid)
-    (eshell-bol)
-    (setq begin (point))
-    (eshell-forward-argument 4)
-    (setq valid (= here (point)))
-    (eshell-backward-argument 4)
-    (prog1
-        (and valid (= begin (point)))
-      (eshell-bol)
-      (delete-region (point) (point-max)))))
-
-(eshell-deftest mode queue-input
-  "Queue command input"
-  (eshell-insert-command "sleep 2")
-  (eshell-insert-command "echo alpha" 'eshell-queue-input)
-  (let ((count 10))
-    (while (and eshell-current-command
-                (> count 0))
-      (sit-for 1 0)
-      (setq count (1- count))))
-  (eshell-match-result "alpha\n"))
-
-; (eshell-deftest proc send-to-subprocess
-;   "Send input to a subprocess"
-;   ;; jww (1999-12-06): what about when bc is unavailable?
-;   (if (not (eshell-search-path "bc"))
-;       t
-;     (eshell-insert-command "bc")
-;     (eshell-insert-command "1 + 2")
-;     (sit-for 1 0)
-;     (forward-line -1)
-;     (prog1
-;       (looking-at "3\n")
-;       (eshell-insert-command "quit")
-;       (sit-for 1 0))))
-
-(eshell-deftest io flush-output
-  "Flush previous output"
-  (eshell-insert-command "echo alpha")
-  (eshell-kill-output)
-  (and (eshell-match-result (regexp-quote "*** output flushed ***\n"))
-       (forward-line)
-       (= (point) eshell-last-output-start)))
-
-(eshell-deftest mode run-old-command
-  "Re-run an old command"
-  (eshell-insert-command "echo alpha")
-  (goto-char eshell-last-input-start)
-  (string= (eshell-get-old-input) "echo alpha"))
+;;; Tests:
+
+(ert-deftest eshell-test/simple-command-result ()
+  "Test `eshell-command-result' with a simple command."
+  (should (equal (eshell-command-result "+ 1 2") 3)))
 
+(ert-deftest eshell-test/lisp-command ()
+  "Test `eshell-command-result' with an elisp command."
+  (should (equal (eshell-command-result "(+ 1 2)") 3)))
 
-(require 'esh-var)
+(ert-deftest eshell-test/lisp-command-args ()
+  "Test `eshell-command-result' with elisp and trailing args.
+Test that trailing arguments outside the S-expression are
+ignored.  e.g. \"(+ 1 2) 3\" => 3"
+  (should (equal (eshell-command-result "(+ 1 2) 3") 3)))
 
-(eshell-deftest var interp-cmd
+(ert-deftest eshell-test/subcommand ()
+  "Test `eshell-command-result' with a simple subcommand."
+  (should (equal (eshell-command-result "{+ 1 2}") 3)))
+
+(ert-deftest eshell-test/subcommand-args ()
+  "Test `eshell-command-result' with a subcommand and trailing args.
+Test that trailing arguments outside the subcommand are ignored.
+e.g. \"{+ 1 2} 3\" => 3"
+  (should (equal (eshell-command-result "{+ 1 2} 3") 3)))
+
+(ert-deftest eshell-test/subcommand-lisp ()
+  "Test `eshell-command-result' with an elisp subcommand and trailing args.
+Test that trailing arguments outside the subcommand are ignored.
+e.g. \"{(+ 1 2)} 3\" => 3"
+  (should (equal (eshell-command-result "{(+ 1 2)} 3") 3)))
+
+(ert-deftest eshell-test/interp-cmd ()
   "Interpolate command result"
-  (eshell-command-result-p "+ ${+ 1 2} 3" "6\n"))
+  (should (equal (eshell-command-result "+ ${+ 1 2} 3") 6)))
 
-(eshell-deftest var interp-lisp
+(ert-deftest eshell-test/interp-lisp ()
   "Interpolate Lisp form evaluation"
-  (eshell-command-result-p "+ $(+ 1 2) 3" "6\n"))
+  (should (equal (eshell-command-result "+ $(+ 1 2) 3") 6)))
 
-(eshell-deftest var interp-concat
+(ert-deftest eshell-test/interp-concat ()
   "Interpolate and concat command"
-  (eshell-command-result-p "+ ${+ 1 2}3 3" "36\n"))
+  (should (equal (eshell-command-result "+ ${+ 1 2}3 3") 36)))
 
-(eshell-deftest var interp-concat-lisp
+(ert-deftest eshell-test/interp-concat-lisp ()
   "Interpolate and concat Lisp form"
-  (eshell-command-result-p "+ $(+ 1 2)3 3" "36\n"))
+  (should (equal (eshell-command-result "+ $(+ 1 2)3 3") 36)))
 
-(eshell-deftest var interp-concat2
+(ert-deftest eshell-test/interp-concat2 ()
   "Interpolate and concat two commands"
-  (eshell-command-result-p "+ ${+ 1 2}${+ 1 2} 3" "36\n"))
+  (should (equal (eshell-command-result "+ ${+ 1 2}${+ 1 2} 3") 36)))
 
-(eshell-deftest var interp-concat-lisp2
+(ert-deftest eshell-test/interp-concat-lisp2 ()
   "Interpolate and concat two Lisp forms"
-  (eshell-command-result-p "+ $(+ 1 2)$(+ 1 2) 3" "36\n"))
-
+  (should (equal (eshell-command-result "+ $(+ 1 2)$(+ 1 2) 3") 36)))
+
+(ert-deftest eshell-test/window-height ()
+  "$LINES should equal (window-height)"
+  (should (eshell-command-result "= $LINES (window-height)")))
+
+(ert-deftest eshell-test/window-width ()
+  "$COLUMNS should equal (window-width)"
+  (should (eshell-command-result "= $COLUMNS (window-width)")))
+
+(ert-deftest eshell-test/last-result-var ()
+  "Test using the \"last result\" ($$) variable"
+  (with-temp-eshell
+   (should
+    (eshell-command-result-p "+ 1 2; + $$ 2"
+                             "3\n5\n"))))
+
+(ert-deftest eshell-test/last-result-var2 ()
+  "Test using the \"last result\" ($$) variable twice"
+  (with-temp-eshell
+   (should
+    (eshell-command-result-p "+ 1 2; + $$ $$"
+                             "3\n6\n"))))
+
+(ert-deftest eshell-test/last-arg-var ()
+  "Test using the \"last arg\" ($_) variable"
+  (with-temp-eshell
+   (should
+    (eshell-command-result-p "+ 1 2; + $_ 4"
+                             "3\n6\n"))))
+
+(ert-deftest eshell-test/command-running-p ()
+  "Modeline should show no command running"
+  (with-temp-eshell
+   (let ((eshell-status-in-mode-line t))
+     (should (memq 'eshell-command-running-string mode-line-format))
+     (should (equal eshell-command-running-string "--")))))
+
+(ert-deftest eshell-test/forward-arg ()
+  "Test moving across command arguments"
+  (with-temp-eshell
+   (eshell-insert-command "echo $(+ 1 (- 4 3)) \"alpha beta\" file" 'ignore)
+   (let ((here (point)) begin valid)
+     (eshell-bol)
+     (setq begin (point))
+     (eshell-forward-argument 4)
+     (setq valid (= here (point)))
+     (eshell-backward-argument 4)
+     (prog1
+         (and valid (= begin (point)))
+       (eshell-bol)
+       (delete-region (point) (point-max))))))
+
+(ert-deftest eshell-test/queue-input ()
+  "Test queuing command input"
+  (with-temp-eshell
+   (eshell-insert-command "sleep 2")
+   (eshell-insert-command "echo alpha" 'eshell-queue-input)
+   (let ((count 10))
+     (while (and eshell-current-command
+                 (> count 0))
+       (sit-for 1)
+       (setq count (1- count))))
+   (should (eshell-match-result "alpha\n"))))
+
+(ert-deftest eshell-test/flush-output ()
+  "Test flushing of previous output"
+  (with-temp-eshell
+   (eshell-insert-command "echo alpha")
+   (eshell-kill-output)
+   (should (eshell-match-result (regexp-quote "*** output flushed ***\n")))
+   (should (forward-line))
+   (should (= (point) eshell-last-output-start))))
+
+(ert-deftest eshell-test/run-old-command ()
+  "Re-run an old command"
+  (with-temp-eshell
+   (eshell-insert-command "echo alpha")
+   (goto-char eshell-last-input-start)
+   (string= (eshell-get-old-input) "echo alpha")))
 
 (provide 'esh-test)
 
-;;; esh-test.el ends here
+;;; tests/eshell.el ends here
diff --git a/test/indent/octave.m b/test/indent/octave.m
index bc7784f1ba2..e5bae850589 100644
--- a/test/indent/octave.m
+++ b/test/indent/octave.m
@@ -1,5 +1,5 @@
 ## -*- mode: octave; coding: utf-8 -*-
-
+0;                              # Don't make this a function file
 function res = tcomp (fn)
   %% res = tcomp (fn)
   %%     imports components and rearranges them.
@@ -1089,13 +1089,13 @@ function [pkg_idx_struct] = parse_pkg_idx (packdir)
 
   while (! feof (fid) || line != -1)
     if (! any (! isspace (line)) || line(1) == "#" || any (line == "="))
-    ## Comments,  blank lines or comments about unimplemented
-    ## functions: do nothing
-    ## FIXME: probably comments and pointers to external functions
-    ## could be treated better when printing to screen?
+      ## Comments,  blank lines or comments about unimplemented
+      ## functions: do nothing
+      ## FIXME: probably comments and pointers to external functions
+      ## could be treated better when printing to screen?
     elseif (! isempty (strfind (line, ">>")))
-    ## Skip package name and description as they are in DESCRIPTION
-    ## already.
+      ## Skip package name and description as they are in DESCRIPTION
+      ## already.
     elseif (! isspace (line(1)))
       ## Category.
       if (! isempty (pkg_idx_struct{cat_num}.functions))
@@ -1658,7 +1658,7 @@ function desc = get_description (filename)
   line = fgetl (fid);
   while (line != -1)
     if (line(1) == "#")
-    ## Comments, do nothing.
+      ## Comments, do nothing.
     elseif (isspace(line(1)))
       ## Continuation lines
       if (exist ("keyword", "var") && isfield (desc, keyword))
@@ -1752,9 +1752,9 @@ function deps_cell = fix_depends (depends)
       endif
       version  = fix_version (parts{2});
 
-    ## If no version is specified for the dependency
-    ## we say that the version should be greater than
-    ## or equal to "0.0.0".
+      ## If no version is specified for the dependency
+      ## we say that the version should be greater than
+      ## or equal to "0.0.0".
     else
       package = tolower (strip (dep));
       operator = ">=";
@@ -1859,7 +1859,7 @@ function bad_deps = get_unsatisfied_deps (desc, installed_pkgs_lst)
       if (! compare_versions (OCTAVE_VERSION, dep.version, dep.operator))
         bad_deps{end+1} = dep;
       endif
-    ## Is the current dependency not Octave?
+      ## Is the current dependency not Octave?
     else
       ok = false;
       for i = 1:length (installed_pkgs_lst)
@@ -2025,7 +2025,7 @@ function load_packages (files, handle_deps, local_list, global_list)
   ## Load all.
   if (length (files) == 1 && strcmp (files{1}, "all"))
     idx = [1:length(installed_pkgs_lst)];
-  ## Load auto.
+    ## Load auto.
   elseif (length (files) == 1 && strcmp (files{1}, "auto"))
     idx = [];
     for i = 1:length (installed_pkgs_lst)
@@ -2033,7 +2033,7 @@ function load_packages (files, handle_deps, local_list, global_list)
         idx (end + 1) = i;
       endif
     endfor
-  ## Load package_name1 ...
+    ## Load package_name1 ...
   else
     idx = [];
     for i = 1:length (files)
@@ -2100,8 +2100,8 @@ function unload_packages (files, handle_deps, local_list, global_list)
     idx = strcmp (p, d);
     if (any (idx))
       rmpath (d);
-    ## FIXME: We should also check if we need to remove items from
-    ## EXEC_PATH.
+      ## FIXME: We should also check if we need to remove items from
+      ## EXEC_PATH.
     endif
   endfor
 endfunction
@@ -2310,7 +2310,9 @@ function dep = is_architecture_dependent (nm)
       isglob = true;
       ext(end) = [];
     else
-      isglob = false;
+      isglob = false;           # I am a test
+                                #%% me too
+### I shall align to column 0
     endif
     pos = findstr (nm, ext);
     if (pos)
@@ -2322,3 +2324,17 @@ function dep = is_architecture_dependent (nm)
     endif
   endfor
 endfunction
+
+%!assert(norm(logm([1 -1;0 1]) - [0 -1; 0 0]) < 1e-5);
+%!assert(norm(expm(logm([-1 2 ; 4 -1])) - [-1 2 ; 4 -1]) < 1e-5);
+%!assert(logm([1 -1 -1;0 1 -1; 0 0 1]), [0 -1 -1.5; 0 0 -1; 0 0 0], 1e-5);
+%!assert (logm (expm ([0 1i; -1i 0])), [0 1i; -1i 0], 10 * eps)
+
+%% Test input validation
+%!error logm ();
+%!error logm (1, 2, 3);
+%!error <logm: A must be a square matrix> logm([1 0;0 1; 2 2]);
+
+%!assert (logm (10), log (10))
+%!assert (full (logm (eye (3))), logm (full (eye (3))))
+%!assert (full (logm (10*eye (3))), logm (full (10*eye (3))), 8*eps)
diff --git a/test/indent/pascal.pas b/test/indent/pascal.pas
index 0dda0c47fef..e7203fece68 100644
--- a/test/indent/pascal.pas
+++ b/test/indent/pascal.pas
@@ -6,7 +6,7 @@ Author: Frank Heckenbach <frank@pascal.gnu.de>
 
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License as
-published by the Free Software Foundation, version 2.
+published by the Free Software Foundation, version 3.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -25,7 +25,10 @@ by the GNU General Public License. }
 
 {$gnu-pascal,I+}
 
+(* second style of comment *)
 // Free-pascal style comment.
+var x:Char = 12 /* 45;   // This /* does not start a comment.
+var x:Char = (/ 4);      // This (/ does not start a comment.
 
 program CRTDemo;
 
diff --git a/test/indent/perl.perl b/test/indent/perl.perl
index 2411c96a5e4..69c1f90c807 100755
--- a/test/indent/perl.perl
+++ b/test/indent/perl.perl
@@ -1,5 +1,20 @@
 #!/usr/bin/perl
 # -*- eval: (bug-reference-mode 1) -*-
 
+print <<"EOF1" . s/he"llo/th'ere/;
+foo
+EOF2
+bar
+EOF1
+
+
+print <<"EOF1" . <<\EOF2 . s/he"llo/th'ere/;
+foo
+EOF2
+bar
+EOF1
+bar
+EOF2
+
 $fileType_filesButNot           # bug#12373?
     = join( '|', map { quotemeta($_).'$' } @{$fileType->{filesButNot}} );
diff --git a/test/indent/ruby.rb b/test/indent/ruby.rb
index 4f2e9e63377..853f4dbf992 100644
--- a/test/indent/ruby.rb
+++ b/test/indent/ruby.rb
@@ -10,7 +10,7 @@ d = %(hello (nested) world)
 
 # Or inside comments.
 x = # "tot %q/to"; =
-y = 2 / 3
+  y = 2 / 3
 
 # Regexp after whitelisted method.
 "abc".sub /b/, 'd'
@@ -21,6 +21,47 @@ a = asub / aslb + bsub / bslb;
 # Highlight the regexp after "if".
 x = toto / foo if /do bar/ =~ "dobar"
 
+# Multiline regexp.
+/bars
+ tees # toots
+ nfoos/
+
+def test1(arg)
+  puts "hello"
+end
+
+def test2 (arg)
+  a = "apple"
+
+  if a == 2
+    puts "hello"
+  else
+    puts "there"
+  end
+
+  if a == 2 then
+    puts "hello"
+  elsif a == 3
+    puts "hello3"
+  elsif a == 3 then
+    puts "hello3"
+  else
+    puts "there"
+  end
+
+  case a
+  when "a"
+    6
+  # Support for this syntax was removed in Ruby 1.9, so we
+  # probably don't need to handle it either.
+  # when "b" :
+  #   7
+  # when "c" : 2
+  when "d"  then 4
+  else 5
+  end
+end
+
 # Some Cucumber code:
 Given /toto/ do
   print "hello"