* mail/rmail.el (rmail-show-message-1): When displaying a mime message,

       indicate start and finish in the echo area.

       * mail/rmail.el (rmail-epa-decrypt): Disregard <pre> before armor.
       Ignore more kinds of whitespace in mime headers.
       Modify the decrypted mime part's mime type so it will be displayed
       by default when visiting this message again.

       * net/browse-url.el (browse-url-firefox-program): Prefer IceCat, doc.
       (browse-url-firefox-arguments)
       (browse-url-firefox-startup-arguments): Doc fix.

28 files changed, 2268 insertions, 556 deletions

diff --git a/test/ChangeLog b/test/ChangeLog
index 28178812a95..f7bec2ee119 100644
--- a/test/ChangeLog
+++ b/test/ChangeLog
@@ -1,10 +1,253 @@
-2015-02-01 Joakim Verona  <joakim@verona.se>
-        Support for testing xwidgets
-        * xwidget-test-manual.el:
+2015-04-01  Artur Malabarba  <bruce.connor.am@gmail.com>
 
-2015-02-01  Grégoire Jadi  <daimrod@gmail.com>
-        Support for testing xwidgets
-        * automated/xwidget-tests.el:
+        * automated/package-test.el: Avoid async while testing.
+        (package-test-update-archives): Fix test.
+
+2015-03-27  Wolfgang Jenkner  <wjenkner@inode.at>
+
+        * automated/textprop-tests.el: New file.
+        (textprop-tests-font-lock--remove-face-from-text-property): New test.
+
+2015-03-24  Michael Albinus  <michael.albinus@gmx.de>
+
+        * automated/tramp-tests.el (tramp-test18-file-attributes)
+        (tramp--test-check-files): Extend tests.
+        (tramp-test31-utf8): Do not skip for tramp-adb.el.
+
+2015-03-24  Daiki Ueno  <ueno@gnu.org>
+
+        * automated/epg-tests.el: New file.
+        * automated/data/epg/pubkey.asc: New file.
+        * automated/data/epg/seckey.asc: New file.
+
+2015-03-22  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * automated/json-tests.el: New file.
+
+2015-03-19  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * automated/eieio-tests.el (eieio-test-17-virtual-slot): Don't use
+        initarg in `oset'.
+        (eieio-test-32-slot-attribute-override-2): Adjust to new
+        slot representation.
+
+        * automated/eieio-test-persist.el (persist-test-save-and-compare):
+        Adjust to new slot representation.
+
+        * automated/eieio-test-methodinvoke.el (make-instance): Use new-style
+        `subclass' specializer for a change.
+
+2015-03-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * automated/cl-lib-tests.el: Use lexical-binding.
+        (cl-lib-arglist-performance): Refine test to the case where one of the
+        fields has a non-nil default value.  Use existing `mystruct' defstruct.
+        (cl-lib-struct-accessors): Use `pcase' to be a bit more flexible in the
+        accepted outputs.
+
+2015-03-16  Ken Brown  <kbrown@cornell.edu>
+
+        * automated/tramp-tests.el (tramp--test-special-characters):
+        Don't test "\t" in file names on Cygwin.  (Bug#20119)
+
+2015-03-10  Jackson Ray Hamilton  <jackson@jacksonrayhamilton.com>
+
+        * indent/js-indent-init-dynamic.js: Fix spelling error.
+
+2015-03-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Prefer "initialize" to "initialise"
+        * indent/js-indent-init-t.js: Rename from
+        indent/js-indent-first-initialiser-t.js.
+        * indent/js-indent-init-dynamic.js: Rename from
+        test/indent/js-indent-first-initialiser-dynamic.js.
+
+2015-03-10  Jackson Ray Hamilton  <jackson@jacksonrayhamilton.com>
+
+        * indent/js.js: Add local variables.
+
+        * indent/js-indent-first-initialiser-t.js:
+        * indent/js-indent-first-initialiser-dynamic.js:
+        New tests for `js-indent-first-initialiser'.
+
+2015-03-10  Przemyslaw Wojnowski  <esperanto@cumego.com>
+
+        * automated/cl-lib-tests.el: Add tests for plusp, second, ...
+        (cl-lib-test-plusp, cl-lib-test-minusp)
+        (cl-lib-test-oddp, cl-lib-test-evenp, cl-lib-test-first)
+        (cl-lib-test-second, cl-lib-test-third, cl-lib-test-fourth)
+        (cl-lib-test-fifth, cl-lib-test-sixth, cl-lib-test-seventh)
+        (cl-lib-test-eighth, cl-lib-test-ninth, cl-lib-test-tenth)
+        (cl-lib-test-endp, cl-lib-test-nth-value)
+        (cl-lib-nth-value-test-multiple-values, cl-test-caaar, cl-test-caadr)
+        (cl-test-ldiff): New tests.
+        (cl-digit-char-p): Tighten the test.
+
+2015-03-09  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * indent/Makefile: Call 'rm' with '-f'.  Default EMACS to
+        '../../src/emacs'.  Remove *.new in 'clean'.  Set 'all' target to
+        run all examples.
+
+2015-03-09  Nicolas Petton <nicolas@petton.fr>
+
+        * automated/seq-tests.el (test-seq-into): Add a test for seq-into.
+
+2015-03-08  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * indent/ruby.rb: Add an example for bug#20026.
+
+        * indent/js.js: Set `js-indent-level' to 2. Fix indentation in an
+        example.
+
+2015-03-04  Michael Albinus  <michael.albinus@gmx.de>
+
+        * automated/tramp-tests.el (top): Declare `tramp-get-remote-stat'
+        and `tramp-get-remote-perl'.
+        (tramp-test06-directory-file-name): Fix docstring and last test.
+        (tramp-test08-file-local-copy): Extend test.
+        (tramp-test13-make-directory): Test also PARENTS arg.
+        (tramp-test17-insert-directory): Do not expect any order in
+        directory listing.
+        (tramp--test-adb-p): New defun.
+        (tramp--test-check-files): Fix doxstring.  Extend tests.
+        (tramp--test-special-characters): New defun.  Use body from
+        `tramp-test30-special-characters'.  Adapt check for tramp-adb.el.
+        (tramp-test30-special-characters): Use it.
+        (tramp--test-utf8): New defun.  Use body from
+        `tramp-test31-utf8'.  Add test string.
+        (tramp-test31-utf8): Use it.
+        (tramp-test30-special-characters-with-stat)
+        (tramp-test30-special-characters-with-perl)
+        (tramp-test30-special-characters-with-ls):
+        (tramp-test31-utf8-with-stat, tramp-test31-utf8-with-perl)
+        (tramp-test31-utf8-with-ls): New tests.
+
+2015-03-03  Daniel Colascione  <dancol@dancol.org>
+
+        * automated/generator-tests.el (cps-testcase):
+        Use `cps-inhibit-atomic-optimization' instead of
+        `cps-disable-atomic-optimization'.
+        (cps-test-declarations-preserved): New test.
+
+        * automated/finalizer-tests.el (finalizer-basic)
+        (finalizer-circular-reference, finalizer-cross-reference)
+        (finalizer-error): Rename `gc-precise-p' to `gc-precise'.
+
+        * automated/generator-tests.el (cps-test-iter-close-finalizer):
+        Rename `gc-precise-p' to `gc-precise'.
+
+2015-03-03  Glenn Morris  <rgm@gnu.org>
+
+        * automated/generator-tests.el (cps-while-incf)
+        (cps-test-iter-cleanup-once-only): Replace undefined incf with cl-incf.
+        (cps-test-iter-do): Use should not undefined assert.
+
+2015-03-03  Daniel Colascione  <dancol@dancol.org>
+
+        * automated/finalizer-tests.el (finalizer-object-type): Test that
+        `type-of' works correctly for finalizers.
+
+2015-03-02  Daniel Colascione  <dancol@dancol.org>
+
+        * automated/generator-tests.el: New tests
+
+        * automated/finalizer-tests.el (finalizer-basic)
+        (finalizer-circular-reference, finalizer-cross-reference)
+        (finalizer-error): New tests.
+
+2015-03-01  Michael Albinus  <michael.albinus@gmx.de>
+
+        * automated/vc-tests.el (vc-test--create-repo): Add check for
+        `vc-responsible-backend'.
+        (vc-test--register): Do not print a message when unsupported.
+        (vc-test--state, vc-test--working-revision): Rework.  Raise no
+        error in case of inconsistent result, but document everything.
+        (vc-test--checkout-model): New defun.
+        (vc-test-*-checkout-model): New tests.
+
+2015-02-26  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        * automated/python-tests.el
+        (python-indent-dedent-line-backspace-2)
+        (python-indent-dedent-line-backspace-3): New tests.
+
+2015-02-26  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        * automated/python-tests.el (python-indent-pep8-1)
+        (python-indent-pep8-2, python-indent-pep8-3)
+        (python-indent-after-comment-2): Fix tests.
+        (python-indent-after-comment-3): New test.
+
+2015-02-24  Glenn Morris  <rgm@gnu.org>
+
+        * automated/f90.el (f90-test-bug-19809): New test.
+
+2015-02-22  Michael Albinus  <michael.albinus@gmx.de>
+
+        * automated/tramp-tests.el (tramp-test17-insert-directory):
+        Suppress localized settings in order to have a proper check for
+        the summary line.
+
+2015-02-16  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * automated/eieio-test-methodinvoke.el (make-instance): Add methods
+        here rather than on eieio-constructor.
+
+2015-02-13  Magnus Henoch  <magnus.henoch@gmail.com>
+
+        * automated/sasl-scram-rfc-tests.el: New file.
+
+2015-02-11  Nicolas Petton <nicolas@petton.fr>
+
+        * automated/seq-tests.el (test-seq-reverse, test-seq-group-by):
+        Add a test for seq-reverse and update test for seq-group-by to
+        test vectors and strings, not only lists.
+
+2015-02-10  Glenn Morris  <rgm@gnu.org>
+
+        * automated/package-test.el (package-test-signed):
+        More informative failure messages.
+
+2015-02-09  Nicolas Petton <nicolas@petton.fr>
+
+        * automated/seq-tests.el (test-seq-group-by): Update test for
+        seq-group-by to check that sequence elements are returned in the
+        correct order.
+
+2015-02-07  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        * automated/python-tests.el (python-eldoc--get-symbol-at-point-1)
+        (python-eldoc--get-symbol-at-point-2)
+        (python-eldoc--get-symbol-at-point-3)
+        (python-eldoc--get-symbol-at-point-4): New tests.
+
+        * automated/python-tests.el (python-tests-visible-string):
+        New function.
+        (python-parens-electric-indent-1)
+        (python-triple-quote-pairing): Fix indentation, move require calls.
+        (python-hideshow-hide-levels-1)
+        (python-hideshow-hide-levels-2): New tests.
+
+2015-02-07  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * automated/vc-tests.el (vc-test--working-revision):
+        Fix `vc-working-revision' checks to be compared against nil, which is
+        what is should return for unregistered files.
+
+2015-02-06 Nicolas Petton <nicolas@petton.fr>
+
+        * automated/seq-tests.el: New tests for seq-mapcat, seq-partition
+        and seq-group-by.
+
+2015-02-05  Artur Malabarba  <bruce.connor.am@gmail.com>
+
+        * automated/package-test.el (package-test-get-deps): Fix typo.
+        (package-test-sort-by-dependence): New test
+
+2015-02-03  Artur Malabarba  <bruce.connor.am@gmail.com>
+
+        * automated/package-test.el (package-test-get-deps): New test.
 
 2015-01-31  Stefan Monnier  <monnier@iro.umontreal.ca>
 
diff --git a/test/automated/cl-lib-tests.el b/test/automated/cl-lib-tests.el
index c83391b1cc5..ce0e5918653 100644
--- a/test/automated/cl-lib-tests.el
+++ b/test/automated/cl-lib-tests.el
@@ -1,4 +1,4 @@
-;;; cl-lib.el --- tests for emacs-lisp/cl-lib.el
+;;; cl-lib.el --- tests for emacs-lisp/cl-lib.el  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2013-2015 Free Software Foundation, Inc.
 
@@ -204,7 +204,10 @@
                     :b :a :a 42)
            '(42 :a))))
 
-(cl-defstruct mystruct (abc :readonly t) def)
+(cl-defstruct (mystruct
+               (:constructor cl-lib--con-1 (&aux (abc 1)))
+               (:constructor cl-lib--con-2 (&optional def)))
+  (abc 5 :readonly t) (def nil))
 (ert-deftest cl-lib-struct-accessors ()
   (let ((x (make-mystruct :abc 1 :def 2)))
     (should (eql (cl-struct-slot-value 'mystruct 'abc x) 1))
@@ -213,8 +216,17 @@
     (should (eql (cl-struct-slot-value 'mystruct 'def x) -1))
     (should (eql (cl-struct-slot-offset 'mystruct 'abc) 1))
     (should-error (cl-struct-slot-offset 'mystruct 'marypoppins))
-    (should (equal (cl-struct-slot-info 'mystruct)
-                   '((cl-tag-slot) (abc :readonly t) (def))))))
+    (should (pcase (cl-struct-slot-info 'mystruct)
+              (`((cl-tag-slot) (abc 5 :readonly t)
+                 (def . ,(or `nil `(nil))))
+               t)))))
+
+(ert-deftest cl-lib-arglist-performance ()
+  ;; An `&aux' should not cause lambda's arglist to be turned into an &rest
+  ;; that's parsed by hand.
+  (should (equal () (help-function-arglist 'cl-lib--con-1)))
+  (should (pcase (help-function-arglist 'cl-lib--con-2)
+            (`(&optional ,_) t))))
 
 (ert-deftest cl-the ()
   (should (eql (cl-the integer 42) 42))
@@ -223,13 +235,192 @@
     (should (= (cl-the integer (cl-incf side-effect)) 1))
     (should (= side-effect 1))))
 
+(ert-deftest cl-lib-test-plusp ()
+  (should-not (cl-plusp -1.0e+INF))
+  (should-not (cl-plusp -1.5e2))
+  (should-not (cl-plusp -3.14))
+  (should-not (cl-plusp -1))
+  (should-not (cl-plusp -0.0))
+  (should-not (cl-plusp 0))
+  (should-not (cl-plusp 0.0))
+  (should-not (cl-plusp -0.0e+NaN))
+  (should-not (cl-plusp 0.0e+NaN))
+  (should (cl-plusp 1))
+  (should (cl-plusp 3.14))
+  (should (cl-plusp 1.5e2))
+  (should (cl-plusp 1.0e+INF))
+  (should-error (cl-plusp "42") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-minusp ()
+  (should (cl-minusp -1.0e+INF))
+  (should (cl-minusp -1.5e2))
+  (should (cl-minusp -3.14))
+  (should (cl-minusp -1))
+  (should-not (cl-minusp -0.0))
+  (should-not (cl-minusp 0))
+  (should-not (cl-minusp 0.0))
+  (should-not (cl-minusp -0.0e+NaN))
+  (should-not (cl-minusp 0.0e+NaN))
+  (should-not (cl-minusp 1))
+  (should-not (cl-minusp 3.14))
+  (should-not (cl-minusp 1.5e2))
+  (should-not (cl-minusp 1.0e+INF))
+  (should-error (cl-minusp "-42") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-oddp ()
+  (should (cl-oddp -3))
+  (should (cl-oddp 3))
+  (should-not (cl-oddp -2))
+  (should-not (cl-oddp 0))
+  (should-not (cl-oddp 2))
+  (should-error (cl-oddp 3.0e+NaN) :type 'wrong-type-argument)
+  (should-error (cl-oddp 3.0) :type 'wrong-type-argument)
+  (should-error (cl-oddp "3") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-evenp ()
+  (should (cl-evenp -2))
+  (should (cl-evenp 0))
+  (should (cl-evenp 2))
+  (should-not (cl-evenp -3))
+  (should-not (cl-evenp 3))
+  (should-error (cl-evenp 2.0e+NaN) :type 'wrong-type-argument)
+  (should-error (cl-evenp 2.0) :type 'wrong-type-argument)
+  (should-error (cl-evenp "2") :type 'wrong-type-argument))
+
 (ert-deftest cl-digit-char-p ()
-  (should (cl-digit-char-p ?3))
-  (should (cl-digit-char-p ?a 11))
+  (should (eql 3 (cl-digit-char-p ?3)))
+  (should (eql 10 (cl-digit-char-p ?a 11)))
+  (should (eql 10 (cl-digit-char-p ?A 11)))
   (should-not (cl-digit-char-p ?a))
-  (should (cl-digit-char-p ?w 36))
-  (should-error (cl-digit-char-p ?a 37))
-  (should-error (cl-digit-char-p ?a 1)))
+  (should (eql 32 (cl-digit-char-p ?w 36)))
+  (should-error (cl-digit-char-p ?a 37) :type 'args-out-of-range)
+  (should-error (cl-digit-char-p ?a 1) :type 'args-out-of-range))
+
+(ert-deftest cl-lib-test-first ()
+  (should (null (cl-first '())))
+  (should (= 4 (cl-first '(4))))
+  (should (= 4 (cl-first '(4 2))))
+  (should-error (cl-first "42") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-second ()
+  (should (null (cl-second '())))
+  (should (null (cl-second '(4))))
+  (should (= 2 (cl-second '(1 2))))
+  (should (= 2 (cl-second '(1 2 3))))
+  (should-error (cl-second "1 2 3") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-third ()
+  (should (null (cl-third '())))
+  (should (null (cl-third '(1 2))))
+  (should (= 3 (cl-third '(1 2 3))))
+  (should (= 3 (cl-third '(1 2 3 4))))
+  (should-error (cl-third "123") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-fourth ()
+  (should (null (cl-fourth '())))
+  (should (null (cl-fourth '(1 2 3))))
+  (should (= 4 (cl-fourth '(1 2 3 4))))
+  (should (= 4 (cl-fourth '(1 2 3 4 5))))
+  (should-error (cl-fourth "1234") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-fifth ()
+  (should (null (cl-fifth '())))
+  (should (null (cl-fifth '(1 2 3 4))))
+  (should (= 5 (cl-fifth '(1 2 3 4 5))))
+  (should (= 5 (cl-fifth '(1 2 3 4 5 6))))
+  (should-error (cl-fifth "12345") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-fifth ()
+  (should (null (cl-fifth '())))
+  (should (null (cl-fifth '(1 2 3 4))))
+  (should (= 5 (cl-fifth '(1 2 3 4 5))))
+  (should (= 5 (cl-fifth '(1 2 3 4 5 6))))
+  (should-error (cl-fifth "12345") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-sixth ()
+  (should (null (cl-sixth '())))
+  (should (null (cl-sixth '(1 2 3 4 5))))
+  (should (= 6 (cl-sixth '(1 2 3 4 5 6))))
+  (should (= 6 (cl-sixth '(1 2 3 4 5 6 7))))
+  (should-error (cl-sixth "123456") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-seventh ()
+  (should (null (cl-seventh '())))
+  (should (null (cl-seventh '(1 2 3 4 5 6))))
+  (should (= 7 (cl-seventh '(1 2 3 4 5 6 7))))
+  (should (= 7 (cl-seventh '(1 2 3 4 5 6 7 8))))
+  (should-error (cl-seventh "1234567") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-eighth ()
+  (should (null (cl-eighth '())))
+  (should (null (cl-eighth '(1 2 3 4 5 6 7))))
+  (should (= 8 (cl-eighth '(1 2 3 4 5 6 7 8))))
+  (should (= 8 (cl-eighth '(1 2 3 4 5 6 7 8 9))))
+  (should-error (cl-eighth "12345678") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-ninth ()
+  (should (null (cl-ninth '())))
+  (should (null (cl-ninth '(1 2 3 4 5 6 7 8))))
+  (should (= 9 (cl-ninth '(1 2 3 4 5 6 7 8 9))))
+  (should (= 9 (cl-ninth '(1 2 3 4 5 6 7 8 9 10))))
+  (should-error (cl-ninth "123456789") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-tenth ()
+  (should (null (cl-tenth '())))
+  (should (null (cl-tenth '(1 2 3 4 5 6 7 8 9))))
+  (should (= 10 (cl-tenth '(1 2 3 4 5 6 7 8 9 10))))
+  (should (= 10 (cl-tenth '(1 2 3 4 5 6 7 8 9 10 11))))
+  (should-error (cl-tenth "1234567890") :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-endp ()
+  (should (cl-endp '()))
+  (should-not (cl-endp '(1)))
+  (should-error (cl-endp 1) :type 'wrong-type-argument)
+  (should-error (cl-endp [1]) :type 'wrong-type-argument))
+
+(ert-deftest cl-lib-test-nth-value ()
+  (let ((vals (cl-values 2 3)))
+    (should (= (cl-nth-value 0 vals) 2))
+    (should (= (cl-nth-value 1 vals) 3))
+    (should (null (cl-nth-value 2 vals)))
+    (should-error (cl-nth-value 0.0 vals) :type 'wrong-type-argument)))
+
+(ert-deftest cl-lib-nth-value-test-multiple-values ()
+  "While CL multiple values are an alias to list, these won't work."
+  :expected-result :failed
+  (should (eq (cl-nth-value 0 '(2 3)) '(2 3)))
+  (should (= (cl-nth-value 0 1) 1))
+  (should (null (cl-nth-value 1 1)))
+  (should-error (cl-nth-value -1 (cl-values 2 3)) :type 'args-out-of-range)
+  (should (string= (cl-nth-value 0 "only lists") "only lists")))
+
+(ert-deftest cl-test-caaar ()
+  (should (null (cl-caaar '())))
+  (should (null (cl-caaar '(() (2)))))
+  (should (null (cl-caaar '((() (2)) (a b)))))
+  (should-error (cl-caaar '(1 2)) :type 'wrong-type-argument)
+  (should-error (cl-caaar '((1 2))) :type 'wrong-type-argument)
+  (should (=  1 (cl-caaar '(((1 2) (3 4))))))
+  (should (null (cl-caaar '((() (3 4)))))))
+
+(ert-deftest cl-test-caadr ()
+  (should (null (cl-caadr '())))
+  (should (null (cl-caadr '(1))))
+  (should-error (cl-caadr '(1 2)) :type 'wrong-type-argument)
+  (should (= 2 (cl-caadr '(1 (2 3)))))
+  (should (equal '((2) (3)) (cl-caadr '((1) (((2) (3))) (4))))))
+
+(ert-deftest cl-test-ldiff ()
+  (let ((l '(1 2 3)))
+    (should (null (cl-ldiff '() '())))
+    (should (null (cl-ldiff '() l)))
+    (should (null (cl-ldiff l l)))
+    (should (equal l (cl-ldiff l '())))
+    ;; must be part of the list
+    (should (equal l (cl-ldiff l '(2 3))))
+    (should (equal '(1) (cl-ldiff l (nthcdr 1 l))))
+    ;; should return a copy
+    (should-not (eq (cl-ldiff l '()) l))))
 
 (ert-deftest cl-parse-integer ()
   (should-error (cl-parse-integer "abc"))
@@ -248,4 +439,11 @@
 (ert-deftest cl-flet-test ()
   (should (equal (cl-flet ((f1 (x) x)) (let ((x #'f1)) (funcall x 5))) 5)))
 
+(ert-deftest cl-lib-test-typep ()
+  (cl-deftype cl-lib-test-type (&optional x) `(member ,x))
+  ;; Make sure we correctly implement the rule that deftype's optional args
+  ;; default to `*' rather than to nil.
+  (should (cl-typep '* 'cl-lib-test-type))
+  (should-not (cl-typep 1 'cl-lib-test-type)))
+
 ;;; cl-lib.el ends here
diff --git a/test/automated/data/epg/pubkey.asc b/test/automated/data/epg/pubkey.asc
new file mode 100644
index 00000000000..c0bf28f6200
--- /dev/null
+++ b/test/automated/data/epg/pubkey.asc
@@ -0,0 +1,20 @@
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: GnuPG v1
+
+mI0EVRDxCAEEALcScrRmxq5N+Hh+NxPg75RJJdtEi824pwtqMlT/3wG1esmP5gNu
+ZIPVaTTSGNZkEzeYdhaLXBUe5qD+RQIQVh+MLt9nisF9nD35imyOrhHwAHnglOPx
+GdylH8nQ/tIO5p/lfUlw+iCBlPH7eZHqFJhwP0hJML4PKE8ArWG6RtsxABEBAAG0
+J0pvZSBUZXN0ZXIgKHRlc3Qga2V5KSA8am9lQGV4YW1wbGUuY29tPoi4BBMBAgAi
+BQJVEPEIAhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRAoscCWMvu4GGYO
+A/0Zzoc2z/dvAtFVLh4ovKqP2qliQt2qschJHVP30hJnKT7dmJfJl7kz9mXmMfSt
+Ym0luYmeSzdeWORM9SygLRYXuDfN6G4ZPJTlsRhgnARhNzNhSx+YlcFh48Z+a5zR
+goBMn7DgYVqfU4UteZOSXMlnuA2Z5ao1qgGhVqESSJgU5riNBFUQ8QgBBADacLkK
+D0U11nmlsScxPGkrDr0aJPrG8MEaDRnKjHJKNp3XTp1psGBUpWF/ErjQAIu+psFt
+LO8owCGsg/vJM7CzTv2dVBRbrZXjIKvdq7HdivosTMaHArQBpEtSO9rmgVHO+jaQ
+q/M2oGvNEB86zo3nfTWhOgBiB32m8kttWRiuWQARAQABiJ8EGAECAAkFAlUQ8QgC
+GwwACgkQKLHAljL7uBj44AQAkMJRm7VJUryrDKFtfIfytQx/vmyU/cZcVV6IpKqP
+KhztgR+QD9czlHvQhz+y3hqtLRShu2Eyf75dNexcUvKs/lS4LIDXg5V7pWSRk9eQ
+G403muqR/NGu6+QmUx09rJl72trdaGxNkyHA7Zy7ZDGkcMvQsd3qoSNGsPR5TKes
+w7Q=
+=NMxb
+-----END PGP PUBLIC KEY BLOCK-----
diff --git a/test/automated/data/epg/seckey.asc b/test/automated/data/epg/seckey.asc
new file mode 100644
index 00000000000..4ac7ba4a502
--- /dev/null
+++ b/test/automated/data/epg/seckey.asc
@@ -0,0 +1,33 @@
+-----BEGIN PGP PRIVATE KEY BLOCK-----
+Version: GnuPG v1
+
+lQHYBFUQ8QgBBAC3EnK0ZsauTfh4fjcT4O+USSXbRIvNuKcLajJU/98BtXrJj+YD
+bmSD1Wk00hjWZBM3mHYWi1wVHuag/kUCEFYfjC7fZ4rBfZw9+Ypsjq4R8AB54JTj
+8RncpR/J0P7SDuaf5X1JcPoggZTx+3mR6hSYcD9ISTC+DyhPAK1hukbbMQARAQAB
+AAP9Hs9agZTobA5QOksXjt9kwqJ63gePtbwVVNz3AoobaGi39PMkRUCPZwaEEbEo
+H/CwsUMV4J5sjVtpef/A8mN4csai7NYp82mbo+dPim4p+SUtBg4Ms8ujGVcQeRQd
+1CXtIkixDu6fw4wDtNw03ZyNJOhBOXVTgAyOTSlIz3D+6n8CAMeCqEFBHQIVoQpf
+Bza4YvFtJRdfGMTix3u7Cb6y9CHGBok7uUgQAeWnzQvMGTCHc3e8iHGAYBQ88GPF
+v1TpiusCAOroRe69Aiid5JMVTjWoJ0SHKd47nIj0gQFiDfa5de0BNq9gYj7JLg+R
+EjsJbJN39z+Z9HWjIOCUOIXDvucmM1MB/iNxW1Z8mEMflEYK5rop+PDxwqUbr8uZ
+kzogw98ZdmuEuN0bheGWUiJI+0Pd8jb40zlR1KgOEMx1mZchToAJdtybMLQnSm9l
+IFRlc3RlciAodGVzdCBrZXkpIDxqb2VAZXhhbXBsZS5jb20+iLgEEwECACIFAlUQ
+8QgCGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJECixwJYy+7gYZg4D/RnO
+hzbP928C0VUuHii8qo/aqWJC3aqxyEkdU/fSEmcpPt2Yl8mXuTP2ZeYx9K1ibSW5
+iZ5LN15Y5Ez1LKAtFhe4N83obhk8lOWxGGCcBGE3M2FLH5iVwWHjxn5rnNGCgEyf
+sOBhWp9ThS15k5JcyWe4DZnlqjWqAaFWoRJImBTmnQHYBFUQ8QgBBADacLkKD0U1
+1nmlsScxPGkrDr0aJPrG8MEaDRnKjHJKNp3XTp1psGBUpWF/ErjQAIu+psFtLO8o
+wCGsg/vJM7CzTv2dVBRbrZXjIKvdq7HdivosTMaHArQBpEtSO9rmgVHO+jaQq/M2
+oGvNEB86zo3nfTWhOgBiB32m8kttWRiuWQARAQABAAP7B8uNtb/DLvGoRfL+mA0Q
+REhgOJ1WpRcU6rvKYNPh8xTkKMvM+EK0nVU/znBedEpXjb0pY1WRT0uvXs2pzY2V
+YeaugyKIkdUpPWnyWoEQwI8hFvHOWmU2rNHyXLW0MY7bxcGgqv2XbkL4m7/D6VQS
+SR8hQ2CxBbW+9ov6aBMwv/UCAOW89+5xxuzkv48AVraWlMnaU0ggVOf6ht0Qa40+
++uw2yziNlD403gAAAycoICiB/oqwslx61B2xOHn0laCKrgsCAPNpIsHRlAwWbAsq
+uCtfIQxg+C3mPXkqsNTMjeK5NjLNytrmO49NXco36zVEG6q7qz5Zj9d9IPYoGOSa
+I+dQZ6sB/RKF5aonR5/e7IHJgc8BG7I0yiya4llE0AB9ghnRI/3uHwnCBnmo/32a
+n4+rQkx6vm+rg3JA/09Gi7W4R9SwV+ane4ifBBgBAgAJBQJVEPEIAhsMAAoJECix
+wJYy+7gY+OAEAJDCUZu1SVK8qwyhbXyH8rUMf75slP3GXFVeiKSqjyoc7YEfkA/X
+M5R70Ic/st4arS0UobthMn++XTXsXFLyrP5UuCyA14OVe6VkkZPXkBuNN5rqkfzR
+ruvkJlMdPayZe9ra3WhsTZMhwO2cu2QxpHDL0LHd6qEjRrD0eUynrMO0
+=iCIm
+-----END PGP PRIVATE KEY BLOCK-----
diff --git a/test/automated/eieio-test-methodinvoke.el b/test/automated/eieio-test-methodinvoke.el
index da5f59a4654..5263013434e 100644
--- a/test/automated/eieio-test-methodinvoke.el
+++ b/test/automated/eieio-test-methodinvoke.el
@@ -179,12 +179,12 @@
   (if (next-method-p) (call-next-method))
   )
 
-(defmethod eieio-constructor :STATIC ((p C-base2) &rest args)
+(defmethod make-instance :STATIC ((p C-base2) &rest args)
   (eieio-test-method-store :STATIC 'C-base2)
   (if (next-method-p) (call-next-method))
   )
 
-(defmethod eieio-constructor :STATIC ((p C) &rest args)
+(cl-defmethod make-instance ((p (subclass C)) &rest args)
   (eieio-test-method-store :STATIC 'C)
   (call-next-method)
   )
diff --git a/test/automated/eieio-test-persist.el b/test/automated/eieio-test-persist.el
index 7bb2f1ca779..6710ead2e77 100644
--- a/test/automated/eieio-test-persist.el
+++ b/test/automated/eieio-test-persist.el
@@ -45,20 +45,20 @@ This is usually a symbol that starts with `:'."
 
   (eieio-persistent-save original)
 
-  (let* ((file (oref original :file))
+  (let* ((file (oref original file))
          (class (eieio-object-class original))
          (fromdisk (eieio-persistent-read file class))
          (cv (eieio--class-v class))
-         (slot-names  (eieio--class-public-a cv))
-         (slot-deflt  (eieio--class-public-d cv))
+         (slots  (eieio--class-slots cv))
          )
     (unless (object-of-class-p fromdisk class)
       (error "Persistent class %S != original class %S"
              (eieio-object-class fromdisk)
              class))
 
-    (while slot-names
-      (let* ((oneslot (car slot-names))
+    (dotimes (i (length slots))
+      (let* ((slot (aref slots i))
+             (oneslot (cl--slot-descriptor-name slot))
              (origvalue (eieio-oref original oneslot))
              (fromdiskvalue (eieio-oref fromdisk oneslot))
              (initarg-p (eieio--attribute-to-initarg
@@ -70,12 +70,9 @@ This is usually a symbol that starts with `:'."
               (error "Slot %S Original Val %S != Persistent Val %S"
                      oneslot origvalue fromdiskvalue))
           ;; Else !initarg-p
-          (unless (equal (car slot-deflt) fromdiskvalue)
+          (unless (equal (cl--slot-descriptor-initform slot) fromdiskvalue)
             (error "Slot %S Persistent Val %S != Default Value %S"
-                   oneslot fromdiskvalue (car slot-deflt))))
-        
-        (setq slot-names (cdr slot-names)
-              slot-deflt (cdr slot-deflt))
+                   oneslot fromdiskvalue (cl--slot-descriptor-initform slot))))
         ))))
 
 ;;; Simple Case
diff --git a/test/automated/eieio-tests.el b/test/automated/eieio-tests.el
index 7532609c4c3..01131d886dd 100644
--- a/test/automated/eieio-tests.el
+++ b/test/automated/eieio-tests.el
@@ -406,21 +406,21 @@ METHOD is the method that was attempting to be called."
 (ert-deftest eieio-test-17-virtual-slot ()
   (setq eitest-vsca (virtual-slot-class :base-value 1))
   ;; Check slot values
-  (should (= (oref eitest-vsca :base-value) 1))
+  (should (= (oref eitest-vsca base-value) 1))
   (should (= (oref eitest-vsca :derived-value) 2))
 
-  (oset eitest-vsca :derived-value 3)
-  (should (= (oref eitest-vsca :base-value) 2))
+  (oset eitest-vsca derived-value 3)
+  (should (= (oref eitest-vsca base-value) 2))
   (should (= (oref eitest-vsca :derived-value) 3))
 
-  (oset eitest-vsca :base-value 3)
-  (should (= (oref eitest-vsca :base-value) 3))
+  (oset eitest-vsca base-value 3)
+  (should (= (oref eitest-vsca base-value) 3))
   (should (= (oref eitest-vsca :derived-value) 4))
 
   ;; should also be possible to initialize instance using virtual slot
 
   (setq eitest-vscb (virtual-slot-class :derived-value 5))
-  (should (= (oref eitest-vscb :base-value) 4))
+  (should (= (oref eitest-vscb base-value) 4))
   (should (= (oref eitest-vscb :derived-value) 5)))
 
 (ert-deftest eieio-test-18-slot-unbound ()
@@ -560,7 +560,8 @@ METHOD is the method that was attempting to be called."
   (setq eitest-t1 (class-c))
   ;; Slot initialization
   (should (eq (oref eitest-t1 slot-1) 'moose))
-  (should (eq (oref eitest-t1 :moose) 'moose))
+  ;; Accessing via the initarg name is deprecated!
+  ;; (should (eq (oref eitest-t1 :moose) 'moose))
   ;; Don't pass reference of private slot
   ;;PRIVATE (should-error (oref eitest-t1 slot-2) :type 'invalid-slot-name)
   ;; Check private slot accessor
@@ -580,7 +581,8 @@ METHOD is the method that was attempting to be called."
   ;; See previous test, nor for subclass
   (setq eitest-t2 (class-subc))
   (should (eq (oref eitest-t2 slot-1) 'moose))
-  (should (eq (oref eitest-t2 :moose) 'moose))
+  ;; Accessing via the initarg name is deprecated!
+  ;;(should (eq (oref eitest-t2 :moose) 'moose))
   (should (string= (get-slot-2 eitest-t2) "linux"))
   ;;PRIVATE (should-error (oref eitest-t2 slot-2) :type 'invalid-slot-name)
   (should (string= (get-slot-2 eitest-t2) "linux"))
@@ -802,30 +804,24 @@ Subclasses to override slot attributes.")
 
 (ert-deftest eieio-test-32-slot-attribute-override-2 ()
   (let* ((cv (eieio--class-v 'slotattr-ok))
-         (docs   (eieio--class-public-doc cv))
-         (names  (eieio--class-public-a cv))
-         (cust   (eieio--class-public-custom cv))
-         (label  (eieio--class-public-custom-label cv))
-         (group  (eieio--class-public-custom-group cv))
-         (types  (eieio--class-public-type cv))
-         (args   (eieio--class-initarg-tuples cv))
-         (i 0))
+         (slots  (eieio--class-slots cv))
+         (args   (eieio--class-initarg-tuples cv)))
     ;; :initarg should override for subclass
     (should (assoc :initblarg args))
 
-  (while (< i (length names))
-    (cond
-     ((eq (nth i names) 'custom)
-      ;; Custom slot attributes must override
-      (should (eq (nth i cust) 'string))
-      ;; Custom label slot attribute must override
-      (should (string= (nth i label) "One String"))
-      (let ((grp (nth i group)))
-        ;; Custom group slot attribute must combine
-        (should (and (memq 'moose grp) (memq 'cow grp)))))
-     (t nil))
-
-    (setq i (1+ i)))))
+    (dotimes (i (length slots))
+      (let* ((slot (aref slots i))
+             (props (cl--slot-descriptor-props slot)))
+        (cond
+         ((eq (cl--slot-descriptor-name slot) 'custom)
+          ;; Custom slot attributes must override
+          (should (eq (alist-get :custom props) 'string))
+          ;; Custom label slot attribute must override
+          (should (string= (alist-get :label props) "One String"))
+          (let ((grp (alist-get :group props)))
+            ;; Custom group slot attribute must combine
+            (should (and (memq 'moose grp) (memq 'cow grp)))))
+         (t nil))))))
 
 (defvar eitest-CLONETEST1 nil)
 (defvar eitest-CLONETEST2 nil)
@@ -891,8 +887,7 @@ Subclasses to override slot attributes.")
   (should (= (length (eieio-build-class-alist 'opt-test1 nil)) 2))
   (should (= (length (eieio-build-class-alist 'opt-test1 t)) 1)))
 
-(defclass eieio--testing ()
-  ())
+(defclass eieio--testing () ())
 
 (defmethod constructor :static ((_x eieio--testing) newname &rest _args)
   (list newname 2))
diff --git a/test/automated/epg-tests.el b/test/automated/epg-tests.el
new file mode 100644
index 00000000000..a958d82bd03
--- /dev/null
+++ b/test/automated/epg-tests.el
@@ -0,0 +1,172 @@
+;;; epg-tests.el --- Test suite for epg.el -*- lexical-binding: t -*-
+
+;; Copyright (C) 2013-2015 Free Software Foundation, Inc.
+
+;; 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/>.
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'ert)
+(require 'epg)
+
+(defvar epg-tests-context nil)
+
+(defvar epg-tests-data-directory
+  (expand-file-name "data/epg" (getenv "EMACS_TEST_DIRECTORY"))
+  "Directory containing epg test data.")
+
+(defun epg-tests-gpg-usable (&optional require-passphrase)
+  (and (executable-find epg-gpg-program)
+       (condition-case nil
+           (progn
+             (epg-check-configuration (epg-configuration))
+             (if require-passphrase
+                 (string-match "\\`1\\."
+                               (cdr (assq 'version (epg-configuration))))
+               t))
+         (error nil))))
+
+(defun epg-tests-passphrase-callback (_c _k _d)
+  ;; Need to create a copy here, since the string will be wiped out
+  ;; after the use.
+  (copy-sequence "test0123456789"))
+
+(cl-defmacro with-epg-tests ((&optional &key require-passphrase
+                                        require-public-key
+                                        require-secret-key)
+                            &rest body)
+  "Set up temporary locations and variables for testing."
+  (declare (indent 1))
+  `(let* ((epg-tests-home-directory (make-temp-file "epg-tests-homedir" t)))
+     (unwind-protect
+         (let ((context (epg-make-context 'OpenPGP)))
+           (setf (epg-context-home-directory context)
+                 epg-tests-home-directory)
+           (setenv "GPG_AGENT_INFO")
+           ,(if require-passphrase
+                `(epg-context-set-passphrase-callback
+                  context
+                  #'epg-tests-passphrase-callback))
+           ,(if require-public-key
+                `(epg-import-keys-from-file
+                  context
+                  (expand-file-name "pubkey.asc" epg-tests-data-directory)))
+           ,(if require-secret-key
+                `(epg-import-keys-from-file
+                  context
+                  (expand-file-name "seckey.asc" epg-tests-data-directory)))
+           (with-temp-buffer
+             (make-local-variable 'epg-tests-context)
+             (setq epg-tests-context context)
+             ,@body))
+       (when (file-directory-p epg-tests-home-directory)
+         (delete-directory epg-tests-home-directory t)))))
+
+(ert-deftest epg-decrypt-1 ()
+  (skip-unless (epg-tests-gpg-usable 'require-passphrase))
+  (with-epg-tests (:require-passphrase t)
+    (should (equal "test"
+                   (epg-decrypt-string epg-tests-context "\
+-----BEGIN PGP MESSAGE-----
+Version: GnuPG v2
+
+jA0EAwMCE19JBLTvvmhgyRrGGglRbnKkK9PJG8fDwO5ccjysrR7IcdNcnA==
+=U8z7
+-----END PGP MESSAGE-----")))))
+
+(ert-deftest epg-roundtrip-1 ()
+  (skip-unless (epg-tests-gpg-usable 'require-passphrase))
+  (with-epg-tests (:require-passphrase t)
+    (let ((cipher (epg-encrypt-string epg-tests-context "symmetric" nil)))
+      (should (equal "symmetric"
+                     (epg-decrypt-string epg-tests-context cipher))))))
+
+(ert-deftest epg-roundtrip-2 ()
+  (skip-unless (epg-tests-gpg-usable 'require-passphrase))
+  (with-epg-tests (:require-passphrase t
+                   :require-public-key t
+                   :require-secret-key t)
+    (let* ((recipients (epg-list-keys epg-tests-context "joe@example.com"))
+           (cipher (epg-encrypt-string epg-tests-context "public key"
+                                       recipients nil t)))
+      (should (equal "public key"
+                     (epg-decrypt-string epg-tests-context cipher))))))
+
+(ert-deftest epg-sign-verify-1 ()
+  (skip-unless (epg-tests-gpg-usable 'require-passphrase))
+  (with-epg-tests (:require-passphrase t
+                   :require-public-key t
+                   :require-secret-key t)
+    (let (signature verify-result)
+      (setf (epg-context-signers epg-tests-context)
+            (epg-list-keys epg-tests-context "joe@example.com"))
+      (setq signature (epg-sign-string epg-tests-context "signed" t))
+      (epg-verify-string epg-tests-context signature "signed")
+      (setq verify-result (epg-context-result-for context 'verify))
+      (should (= 1 (length verify-result)))
+      (should (eq 'good (epg-signature-status (car verify-result)))))))
+
+(ert-deftest epg-sign-verify-2 ()
+  (skip-unless (epg-tests-gpg-usable 'require-passphrase))
+  (with-epg-tests (:require-passphrase t
+                   :require-public-key t
+                   :require-secret-key t)
+    (let (signature verify-result)
+      (setf (epg-context-signers epg-tests-context)
+            (epg-list-keys epg-tests-context "joe@example.com"))
+      (setq signature (epg-sign-string epg-tests-context "clearsigned" 'clear))
+      ;; Clearsign signature always ends with a new line.
+      (should (equal "clearsigned\n"
+                     (epg-verify-string epg-tests-context signature)))
+      (setq verify-result (epg-context-result-for context 'verify))
+      (should (= 1 (length verify-result)))
+      (should (eq 'good (epg-signature-status (car verify-result)))))))
+
+(ert-deftest epg-sign-verify-3 ()
+  (skip-unless (epg-tests-gpg-usable 'require-passphrase))
+  (with-epg-tests (:require-passphrase t
+                   :require-public-key t
+                   :require-secret-key t)
+    (let (signature verify-result)
+      (setf (epg-context-signers epg-tests-context)
+            (epg-list-keys epg-tests-context "joe@example.com"))
+      (setq signature (epg-sign-string epg-tests-context "normal signed"))
+      (should (equal "normal signed"
+                     (epg-verify-string epg-tests-context signature)))
+      (setq verify-result (epg-context-result-for context 'verify))
+      (should (= 1 (length verify-result)))
+      (should (eq 'good (epg-signature-status (car verify-result)))))))
+
+(ert-deftest epg-import-1 ()
+  (skip-unless (epg-tests-gpg-usable 'require-passphrase))
+  (with-epg-tests (:require-passphrase nil)
+    (should (= 0 (length (epg-list-keys epg-tests-context))))
+    (should (= 0 (length (epg-list-keys epg-tests-context nil t)))))
+  (with-epg-tests (:require-passphrase nil
+                   :require-public-key t)
+    (should (= 1 (length (epg-list-keys epg-tests-context))))
+    (should (= 0 (length (epg-list-keys epg-tests-context nil t)))))
+  (with-epg-tests (:require-public-key nil
+                   :require-public-key t
+                   :require-secret-key t)
+    (should (= 1 (length (epg-list-keys epg-tests-context))))
+    (should (= 1 (length (epg-list-keys epg-tests-context nil t))))))
+
+(provide 'epg-tests)
+
+;;; epg-tests.el ends here
diff --git a/test/automated/f90.el b/test/automated/f90.el
index c6bc41f799a..1cb2f035a6b 100644
--- a/test/automated/f90.el
+++ b/test/automated/f90.el
@@ -173,4 +173,20 @@ end program prog")
     (f90-indent-subprogram)
     (should (= 0 (current-indentation)))))
 
+(ert-deftest f90-test-bug-19809 ()
+  "Test for http://debbugs.gnu.org/19809 ."
+  (with-temp-buffer
+    (f90-mode)
+    ;; The Fortran standard says that continued strings should have
+    ;; '&' at the start of continuation lines, but it seems gfortran
+    ;; allows them to be absent (albeit with a warning).
+    (insert "program prog
+  write (*,*), '&
+end program prog'
+end program prog")
+    (goto-char (point-min))
+    (f90-end-of-subprogram)
+    (should (= (point) (point-max)))))
+
+
 ;;; f90.el ends here
diff --git a/test/automated/finalizer-tests.el b/test/automated/finalizer-tests.el
new file mode 100644
index 00000000000..142152e3fb0
--- /dev/null
+++ b/test/automated/finalizer-tests.el
@@ -0,0 +1,83 @@
+;;; finalizer-tests.el --- Finalizer tests -*- lexical-binding: t -*-
+
+;; Copyright (C) 2015 Free Software Foundation, Inc.
+
+;; Author: Daniel Colascione <dancol@dancol.org>
+;; Keywords:
+
+;; 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/>.
+
+;;; Commentary:
+
+;;
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+
+(ert-deftest finalizer-basic ()
+  "Test that finalizers run at all."
+  (skip-unless gc-precise)
+  (let* ((finalized nil)
+         (finalizer (make-finalizer (lambda () (setf finalized t)))))
+    (garbage-collect)
+    (should (equal finalized nil))
+    (setf finalizer nil)
+    (garbage-collect)
+    (should (equal finalized t))))
+
+(ert-deftest finalizer-circular-reference ()
+  "Test references from a callback to a finalizer."
+  (skip-unless gc-precise)
+  (let ((finalized nil))
+    (let* ((value nil)
+           (finalizer (make-finalizer (lambda () (setf finalized value)))))
+      (setf value finalizer)
+      (setf finalizer nil))
+    (garbage-collect)
+    (should finalized)))
+
+(ert-deftest finalizer-cross-reference ()
+  "Test that between-finalizer references do not prevent collection."
+  (skip-unless gc-precise)
+  (let ((d nil) (fc 0))
+    (let* ((f1-data (cons nil nil))
+           (f2-data (cons nil nil))
+           (f1 (make-finalizer
+                (lambda () (cl-incf fc) (setf d f1-data))))
+           (f2 (make-finalizer
+                (lambda () (cl-incf fc) (setf d f2-data)))))
+      (setcar f1-data f2)
+      (setcar f2-data f1))
+    (garbage-collect)
+    (should (equal fc 2))))
+
+(ert-deftest finalizer-error ()
+  "Test that finalizer errors are suppressed"
+  (skip-unless gc-precise)
+  (make-finalizer (lambda () (error "ABCDEF")))
+  (garbage-collect)
+  (with-current-buffer "*Messages*"
+    (save-excursion
+      (goto-char (point-max))
+      (forward-line -1)
+      (should (equal
+               (buffer-substring (point) (point-at-eol))
+               "finalizer failed: (error \"ABCDEF\")")))))
+
+(ert-deftest finalizer-object-type ()
+  (should (equal (type-of (make-finalizer nil)) 'finalizer)))
diff --git a/test/automated/generator-tests.el b/test/automated/generator-tests.el
new file mode 100644
index 00000000000..d9c81b59a23
--- /dev/null
+++ b/test/automated/generator-tests.el
@@ -0,0 +1,298 @@
+;;; generator-tests.el --- Testing generators -*- lexical-binding: t -*-
+
+;; Copyright (C) 2015 Free Software Foundation, Inc.
+
+;; Author: Daniel Colascione <dancol@dancol.org>
+;; Keywords:
+
+;; 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/>.
+
+;;; Commentary:
+
+(require 'generator)
+(require 'ert)
+(require 'cl-lib)
+
+(defun generator-list-subrs ()
+  (cl-loop for x being the symbols
+        when (and (fboundp x)
+                  (cps--special-form-p (symbol-function x)))
+        collect x))
+
+(defmacro cps-testcase (name &rest body)
+  "Perform a simple test of the continuation-transforming code.
+
+`cps-testcase' defines an ERT testcase called NAME that evaluates
+BODY twice: once using ordinary `eval' and once using
+lambda-generators.  The test ensures that the two forms produce
+identical output.
+"
+  `(progn
+     (ert-deftest ,name ()
+       (should
+        (equal
+         (funcall (lambda () ,@body))
+         (iter-next
+          (funcall
+           (iter-lambda () (iter-yield (progn ,@body))))))))
+     (ert-deftest ,(intern (format "%s-noopt" name)) ()
+       (should
+        (equal
+         (funcall (lambda () ,@body))
+         (iter-next
+          (funcall
+           (let ((cps-inhibit-atomic-optimization t))
+             (iter-lambda () (iter-yield (progn ,@body)))))))))))
+
+(put 'cps-testcase 'lisp-indent-function 1)
+
+(defvar *cps-test-i* nil)
+(defun cps-get-test-i ()
+  *cps-test-i*)
+
+(cps-testcase cps-simple-1 (progn 1 2 3))
+(cps-testcase cps-empty-progn (progn))
+(cps-testcase cps-inline-not-progn (inline 1 2 3))
+(cps-testcase cps-prog1-a (prog1 1 2 3))
+(cps-testcase cps-prog1-b (prog1 1))
+(cps-testcase cps-prog1-c (prog2 1 2 3))
+(cps-testcase cps-quote (progn 'hello))
+(cps-testcase cps-function (progn #'hello))
+
+(cps-testcase cps-and-fail (and 1 nil 2))
+(cps-testcase cps-and-succeed (and 1 2 3))
+(cps-testcase cps-and-empty (and))
+
+(cps-testcase cps-or-fallthrough (or nil 1 2))
+(cps-testcase cps-or-alltrue (or 1 2 3))
+(cps-testcase cps-or-empty (or))
+
+(cps-testcase cps-let* (let* ((i 10)) i))
+(cps-testcase cps-let*-shadow-empty (let* ((i 10)) (let (i) i)))
+(cps-testcase cps-let (let ((i 10)) i))
+(cps-testcase cps-let-shadow-empty (let ((i 10)) (let (i) i)))
+(cps-testcase cps-let-novars (let nil 42))
+(cps-testcase cps-let*-novars (let* nil 42))
+
+(cps-testcase cps-let-parallel
+  (let ((a 5) (b 6)) (let ((a b) (b a)) (list a b))))
+
+(cps-testcase cps-let*-parallel
+  (let* ((a 5) (b 6)) (let* ((a b) (b a)) (list a b))))
+
+(cps-testcase cps-while-dynamic
+  (setq *cps-test-i* 0)
+  (while (< *cps-test-i* 10)
+    (setf *cps-test-i* (+ *cps-test-i* 1)))
+  *cps-test-i*)
+
+(cps-testcase cps-while-lexical
+ (let* ((i 0) (j 10))
+   (while (< i 10)
+     (setf i (+ i 1))
+     (setf j (+ j (* i 10))))
+   j))
+
+(cps-testcase cps-while-incf
+ (let* ((i 0) (j 10))
+   (while (< i 10)
+     (cl-incf i)
+     (setf j (+ j (* i 10))))
+   j))
+
+(cps-testcase cps-dynbind
+ (setf *cps-test-i* 0)
+ (let* ((*cps-test-i* 5))
+   (cps-get-test-i)))
+
+(cps-testcase cps-nested-application
+ (+ (+ 3 5) 1))
+
+(cps-testcase cps-unwind-protect
+ (setf *cps-test-i* 0)
+ (unwind-protect
+     (setf *cps-test-i* 1)
+   (setf *cps-test-i* 2))
+ *cps-test-i*)
+
+(cps-testcase cps-catch-unused
+ (catch 'mytag 42))
+
+(cps-testcase cps-catch-thrown
+ (1+ (catch 'mytag
+       (throw 'mytag (+ 2 2)))))
+
+(cps-testcase cps-loop
+ (cl-loop for x from 1 to 10 collect x))
+
+(cps-testcase cps-loop-backquote
+ `(a b ,(cl-loop for x from 1 to 10 collect x) -1))
+
+(cps-testcase cps-if-branch-a
+ (if t 'abc))
+
+(cps-testcase cps-if-branch-b
+ (if t 'abc 'def))
+
+(cps-testcase cps-if-condition-fail
+ (if nil 'abc 'def))
+
+(cps-testcase cps-cond-empty
+ (cond))
+
+(cps-testcase cps-cond-atomi
+ (cond (42)))
+
+(cps-testcase cps-cond-complex
+ (cond (nil 22) ((1+ 1) 42) (t 'bad)))
+
+(put 'cps-test-error 'error-conditions '(cps-test-condition))
+
+(cps-testcase cps-condition-case
+  (condition-case
+      condvar
+      (signal 'cps-test-error 'test-data)
+    (cps-test-condition condvar)))
+
+(cps-testcase cps-condition-case-no-error
+  (condition-case
+      condvar
+      42
+    (cps-test-condition condvar)))
+
+(ert-deftest cps-generator-basic ()
+  (let* ((gen (iter-lambda ()
+                (iter-yield 1)
+                (iter-yield 2)
+                (iter-yield 3)
+                4))
+         (gen-inst (funcall gen)))
+    (should (eql (iter-next gen-inst) 1))
+    (should (eql (iter-next gen-inst) 2))
+    (should (eql (iter-next gen-inst) 3))
+
+    ;; should-error doesn't catch the generator-end condition (which
+    ;; isn't an error), so we write our own.
+    (let (errored)
+      (condition-case x
+          (iter-next gen-inst)
+        (iter-end-of-sequence
+         (setf errored (cdr x))))
+      (should (eql errored 4)))))
+
+(iter-defun mygenerator (i)
+  (iter-yield 1)
+  (iter-yield i)
+  (iter-yield 2))
+
+(ert-deftest cps-test-iter-do ()
+  (let (mylist)
+    (iter-do (x (mygenerator 4))
+      (push x mylist))
+    (should (equal mylist '(2 4 1)))))
+
+(iter-defun gen-using-yield-value ()
+  (let (f)
+    (setf f (iter-yield 42))
+    (iter-yield f)
+    -8))
+
+(ert-deftest cps-yield-value ()
+  (let ((it (gen-using-yield-value)))
+    (should (eql (iter-next it -1) 42))
+    (should (eql (iter-next it -1) -1))))
+
+(ert-deftest cps-loop ()
+  (should
+   (equal (cl-loop for x iter-by (mygenerator 42)
+             collect x)
+          '(1 42 2))))
+
+(iter-defun gen-using-yield-from ()
+  (let ((sub-iter (gen-using-yield-value)))
+    (iter-yield (1+ (iter-yield-from sub-iter)))))
+
+(ert-deftest cps-test-yield-from-works ()
+  (let ((it (gen-using-yield-from)))
+    (should (eql (iter-next it -1) 42))
+    (should (eql (iter-next it -1) -1))
+    (should (eql (iter-next it -1) -7))))
+
+(defvar cps-test-closed-flag nil)
+
+(ert-deftest cps-test-iter-close ()
+  (garbage-collect)
+  (let ((cps-test-closed-flag nil))
+    (let ((iter (funcall
+                 (iter-lambda ()
+                   (unwind-protect (iter-yield 1)
+                     (setf cps-test-closed-flag t))))))
+      (should (equal (iter-next iter) 1))
+      (should (not cps-test-closed-flag))
+      (iter-close iter)
+      (should cps-test-closed-flag))))
+
+(ert-deftest cps-test-iter-close-idempotent ()
+  (garbage-collect)
+  (let ((cps-test-closed-flag nil))
+    (let ((iter (funcall
+                 (iter-lambda ()
+                   (unwind-protect (iter-yield 1)
+                     (setf cps-test-closed-flag t))))))
+      (should (equal (iter-next iter) 1))
+      (should (not cps-test-closed-flag))
+      (iter-close iter)
+      (should cps-test-closed-flag)
+      (setf cps-test-closed-flag nil)
+      (iter-close iter)
+      (should (not cps-test-closed-flag)))))
+
+(ert-deftest cps-test-iter-close-finalizer ()
+  (skip-unless gc-precise)
+  (garbage-collect)
+  (let ((cps-test-closed-flag nil))
+    (let ((iter (funcall
+                 (iter-lambda ()
+                   (unwind-protect (iter-yield 1)
+                     (setf cps-test-closed-flag t))))))
+      (should (equal (iter-next iter) 1))
+      (should (not cps-test-closed-flag))
+      (setf iter nil)
+      (garbage-collect)
+      (should cps-test-closed-flag))))
+
+(ert-deftest cps-test-iter-cleanup-once-only ()
+  (let* ((nr-unwound 0)
+         (iter
+          (funcall (iter-lambda ()
+                     (unwind-protect
+                          (progn
+                            (iter-yield 1)
+                            (error "test")
+                            (iter-yield 2))
+                       (cl-incf nr-unwound))))))
+    (should (equal (iter-next iter) 1))
+    (should-error (iter-next iter))
+    (should (equal nr-unwound 1))))
+
+(iter-defun generator-with-docstring ()
+  "Documentation!"
+  (declare (indent 5))
+  nil)
+
+(ert-deftest cps-test-declarations-preserved ()
+  (should (equal (documentation 'generator-with-docstring) "Documentation!"))
+  (should (equal (get 'generator-with-docstring 'lisp-indent-function) 5)))
diff --git a/test/automated/json-tests.el b/test/automated/json-tests.el
new file mode 100644
index 00000000000..fd89b7aa994
--- /dev/null
+++ b/test/automated/json-tests.el
@@ -0,0 +1,46 @@
+;;; json-tests.el --- Test suite for json.el
+
+;; Copyright (C) 2015 Free Software Foundation, Inc.
+
+;; Author: Dmitry Gutov <dgutov@yandex.ru>
+
+;; 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, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'ert)
+(require 'json)
+
+(ert-deftest json-encode-simple-alist ()
+  (should (equal (json-encode '((a . 1)
+                                (b . 2)))
+                 "{\"a\":1,\"b\":2}")))
+
+(ert-deftest json-read-simple-alist ()
+  (should (equal (json-read-from-string "{\"a\": 1, \"b\": 2}")
+                 '((b . 2)
+                   (a . 1)))))
+
+(ert-deftest json-encode-string-with-special-chars ()
+  (should (equal (json-encode-string "a\n\fb")
+                 "\"a\\n\\fb\""))
+  (should (equal (json-encode-string "\nasdфыв\u001f\u007ffgh\t")
+                 "\"\\nasdфыв\\u001f\u007ffgh\\t\"")))
+
+(ert-deftest json-read-string-with-special-chars ()
+  (should (equal (json-read-from-string "\"\\nasd\\u0444\\u044b\\u0432fgh\\t\"")
+                 "\nasdфывfgh\t")))
+
+(provide 'json-tests)
+;;; json-tests.el ends here
diff --git a/test/automated/package-test.el b/test/automated/package-test.el
index a8488652c2f..359f3541b41 100644
--- a/test/automated/package-test.el
+++ b/test/automated/package-test.el
@@ -36,6 +36,8 @@
 (require 'ert)
 (require 'cl-lib)
 
+(setq package-menu-async nil)
+
 (defvar package-test-user-dir nil
   "Directory to use for installing packages during testing.")
 
@@ -73,6 +75,24 @@
                        :kind 'single)
   "Expected `package-desc' parsed from new-pkg-1.0.el.")
 
+(defvar simple-depend-desc-1
+  (package-desc-create :name 'simple-depend-1
+                       :version '(1 0)
+                       :summary "A single-file package with a dependency."
+                       :kind 'single
+                       :reqs '((simple-depend (1 0))
+                               (multi-file (0 1))))
+  "`package-desc' used for testing dependencies.")
+
+(defvar simple-depend-desc-2
+  (package-desc-create :name 'simple-depend-2
+                       :version '(1 0)
+                       :summary "A single-file package with a dependency."
+                       :kind 'single
+                       :reqs '((simple-depend-1 (1 0))
+                               (multi-file (0 1))))
+  "`package-desc' used for testing dependencies.")
+
 (defvar package-test-data-dir (expand-file-name "data/package" package-test-file-dir)
   "Base directory of package test files.")
 
@@ -306,7 +326,7 @@ Must called from within a `tar-mode' buffer."
 
         ;; New version should be available and old version should be installed
         (goto-char (point-min))
-        (should (re-search-forward "^\\s-+simple-single\\s-+1.4\\s-+new" nil t))
+        (should (re-search-forward "^\\s-+simple-single\\s-+1.4\\s-+available" nil t))
         (should (re-search-forward "^\\s-+simple-single\\s-+1.3\\s-+installed" nil t))
 
         (goto-char (point-min))
@@ -401,13 +421,17 @@ Must called from within a `tar-mode' buffer."
       ;; Check if the installed package status is updated.
       (let ((buf (package-list-packages)))
         (package-menu-refresh)
-        (should (re-search-forward "^\\s-+signed-good\\s-+1\\.0\\s-+installed"
-                                   nil t)))
+        (should (re-search-forward
+                 "^\\s-+signed-good\\s-+\\(\\S-+\\)\\s-+\\(\\S-+\\)\\s-"
+                 nil t))
+        (should (string-equal (match-string-no-properties 1) "1.0"))
+        (should (string-equal (match-string-no-properties 2) "installed")))
       ;; Check if the package description is updated.
       (with-fake-help-buffer
        (describe-package 'signed-good)
        (goto-char (point-min))
-       (should (search-forward "signed-good is an installed package." nil t))
+       (should (re-search-forward "signed-good is an? \\(\\S-+\\) package." nil t))
+       (should (string-equal (match-string-no-properties 1) "installed"))
        (should (search-forward
                 "Status: Installed in `~/signed-good-1.0/'."
                 nil t))))))
@@ -479,6 +503,61 @@ Must called from within a `tar-mode' buffer."
       (should (equal archive-contents
                      (list 1 package-x-test--single-archive-entry-1-4))))))
 
+(ert-deftest package-test-get-deps ()
+  "Test `package--get-deps' with complex structures."
+  (let ((package-alist
+         (mapcar (lambda (p) (list (package-desc-name p) p))
+           (list simple-single-desc
+                 simple-depend-desc
+                 multi-file-desc
+                 new-pkg-desc
+                 simple-depend-desc-1
+                 simple-depend-desc-2))))
+    (should
+     (equal (package--get-deps 'simple-depend)
+            '(simple-single)))
+    (should
+     (equal (package--get-deps 'simple-depend 'indirect)
+            nil))
+    (should
+     (equal (package--get-deps 'simple-depend 'direct)
+            '(simple-single)))
+    (should
+     (equal (package--get-deps 'simple-depend-2)
+            '(simple-depend-1 multi-file simple-depend simple-single)))
+    (should
+     (equal (package--get-deps 'simple-depend-2 'indirect)
+            '(simple-depend multi-file simple-single)))
+    (should
+     (equal (package--get-deps 'simple-depend-2 'direct)
+            '(simple-depend-1 multi-file)))))
+
+(ert-deftest package-test-sort-by-dependence ()
+  "Test `package--sort-by-dependence' with complex structures."
+  (let ((package-alist
+         (mapcar (lambda (p) (list (package-desc-name p) p))
+           (list simple-single-desc
+                 simple-depend-desc
+                 multi-file-desc
+                 new-pkg-desc
+                 simple-depend-desc-1
+                 simple-depend-desc-2)))
+        (delete-list
+         (list simple-single-desc
+               simple-depend-desc
+               multi-file-desc
+               new-pkg-desc
+               simple-depend-desc-1
+               simple-depend-desc-2)))
+    (should
+     (equal (package--sort-by-dependence delete-list)
+            (list simple-depend-desc-2 simple-depend-desc-1 new-pkg-desc
+                  multi-file-desc simple-depend-desc simple-single-desc)))
+    (should
+     (equal (package--sort-by-dependence (reverse delete-list))
+            (list new-pkg-desc simple-depend-desc-2 simple-depend-desc-1
+                  multi-file-desc simple-depend-desc simple-single-desc)))))
+
 (provide 'package-test)
 
 ;;; package-test.el ends here
diff --git a/test/automated/python-tests.el b/test/automated/python-tests.el
index 672b05c39de..b377a26f77a 100644
--- a/test/automated/python-tests.el
+++ b/test/automated/python-tests.el
@@ -24,6 +24,11 @@
 (require 'ert)
 (require 'python)
 
+;; Dependencies for testing:
+(require 'electric)
+(require 'hideshow)
+
+
 (defmacro python-tests-with-temp-buffer (contents &rest body)
   "Create a `python-mode' enabled temp buffer with CONTENTS.
 BODY is code to be executed within the temp buffer.  Point is
@@ -104,6 +109,28 @@ STRING, it is skipped so the next STRING occurrence is selected."
          (call-interactively 'self-insert-command)))
      chars)))
 
+(defun python-tests-visible-string (&optional min max)
+  "Return the buffer string excluding invisible overlays.
+Argument MIN and MAX delimit the region to be returned and
+default to `point-min' and `point-max' respectively."
+  (let* ((min (or min (point-min)))
+         (max (or max (point-max)))
+         (buffer (current-buffer))
+         (buffer-contents (buffer-substring-no-properties min max))
+         (overlays
+          (sort (overlays-in min max)
+                (lambda (a b)
+                  (let ((overlay-end-a (overlay-end a))
+                        (overlay-end-b (overlay-end b)))
+                    (> overlay-end-a overlay-end-b))))))
+    (with-temp-buffer
+      (insert buffer-contents)
+      (dolist (overlay overlays)
+        (if (overlay-get overlay 'invisible)
+            (delete-region (overlay-start overlay)
+                           (overlay-end overlay))))
+      (buffer-substring-no-properties (point-min) (point-max)))))
+
 
 ;;; Tests for your tests, so you can test while you test.
 
@@ -177,7 +204,7 @@ foo = long_function_name(var_one, var_two,
    (should (eq (car (python-indent-context)) :no-indent))
    (should (= (python-indent-calculate-indentation) 0))
    (python-tests-look-at "foo = long_function_name(var_one, var_two,")
-   (should (eq (car (python-indent-context)) :after-line))
+   (should (eq (car (python-indent-context)) :after-comment))
    (should (= (python-indent-calculate-indentation) 0))
    (python-tests-look-at "var_three, var_four)")
    (should (eq (car (python-indent-context)) :inside-paren))
@@ -195,7 +222,7 @@ def long_function_name(
    (should (eq (car (python-indent-context)) :no-indent))
    (should (= (python-indent-calculate-indentation) 0))
    (python-tests-look-at "def long_function_name(")
-   (should (eq (car (python-indent-context)) :after-line))
+   (should (eq (car (python-indent-context)) :after-comment))
    (should (= (python-indent-calculate-indentation) 0))
    (python-tests-look-at "var_one, var_two, var_three,")
    (should (eq (car (python-indent-context))
@@ -221,7 +248,7 @@ foo = long_function_name(
    (should (eq (car (python-indent-context)) :no-indent))
    (should (= (python-indent-calculate-indentation) 0))
    (python-tests-look-at "foo = long_function_name(")
-   (should (eq (car (python-indent-context)) :after-line))
+   (should (eq (car (python-indent-context)) :after-comment))
    (should (= (python-indent-calculate-indentation) 0))
    (python-tests-look-at "var_one, var_two,")
    (should (eq (car (python-indent-context)) :inside-paren-newline-start))
@@ -286,10 +313,10 @@ class Blag(object):
 def func(arg):
     # I don't do much
     return arg
-    # This comment is badly indented just because.
-    # But we won't mess with the user in this line.
+    # This comment is badly indented because the user forced so.
+    # At this line python.el wont dedent, user is always right.
 
-now_we_do_mess_cause_this_is_not_a_comment = 1
+comment_wins_over_ender = True
 
 # yeah, that.
 "
@@ -301,28 +328,49 @@ now_we_do_mess_cause_this_is_not_a_comment = 1
    ;; the rules won't apply here.
    (should (eq (car (python-indent-context)) :after-block-start))
    (should (= (python-indent-calculate-indentation) 4))
-   (python-tests-look-at "# This comment is badly")
+   (python-tests-look-at "# This comment is badly indented")
    (should (eq (car (python-indent-context)) :after-block-end))
-   ;; The return keyword moves indentation backwards 4 spaces, but
-   ;; let's assume this comment was placed there because the user
-   ;; wanted to (manually adding spaces or whatever).
+   ;; The return keyword do make indentation lose a level...
    (should (= (python-indent-calculate-indentation) 0))
-   (python-tests-look-at "# but we won't mess")
+   ;; ...but the current indentation was forced by the user.
+   (python-tests-look-at "# At this line python.el wont dedent")
    (should (eq (car (python-indent-context)) :after-comment))
    (should (= (python-indent-calculate-indentation) 4))
-   ;; Behave the same for blank lines: potentially a comment.
+   ;; Should behave the same for blank lines: potentially a comment.
    (forward-line 1)
    (should (eq (car (python-indent-context)) :after-comment))
    (should (= (python-indent-calculate-indentation) 4))
-   (python-tests-look-at "now_we_do_mess")
-   ;; Here is where comment indentation starts to get ignored and
-   ;; where the user can't freely indent anymore.
-   (should (eq (car (python-indent-context)) :after-block-end))
-   (should (= (python-indent-calculate-indentation) 0))
+   (python-tests-look-at "comment_wins_over_ender")
+   ;; The comment won over the ender because the user said so.
+   (should (eq (car (python-indent-context)) :after-comment))
+   (should (= (python-indent-calculate-indentation) 4))
+   ;; The indentation calculated fine for the assignment, but the user
+   ;; choose to force it back to the first column.  Next line should
+   ;; be aware of that.
    (python-tests-look-at "# yeah, that.")
    (should (eq (car (python-indent-context)) :after-line))
    (should (= (python-indent-calculate-indentation) 0))))
 
+(ert-deftest python-indent-after-comment-3 ()
+  "Test after-comment in buggy case."
+  (python-tests-with-temp-buffer
+   "
+class A(object):
+
+    def something(self, arg):
+        if True:
+            return arg
+
+    # A comment
+
+    @adecorator
+    def method(self, a, b):
+        pass
+"
+   (python-tests-look-at "@adecorator")
+   (should (eq (car (python-indent-context)) :after-comment))
+   (should (= (python-indent-calculate-indentation) 4))))
+
 (ert-deftest python-indent-inside-paren-1 ()
   "The most simple inside-paren case that shouldn't fail."
   (python-tests-with-temp-buffer
@@ -2106,6 +2154,55 @@ if True:
    (call-interactively #'python-indent-dedent-line-backspace)
    (should (zerop (current-indentation)))))
 
+(ert-deftest python-indent-dedent-line-backspace-2 ()
+  "Check de-indentation with tabs.  Bug#19730."
+  (let ((tab-width 8))
+    (python-tests-with-temp-buffer
+     "
+if x:
+\tabcdefg
+"
+     (python-tests-look-at "abcdefg")
+     (goto-char (line-end-position))
+     (call-interactively #'python-indent-dedent-line-backspace)
+     (should
+      (string= (buffer-substring-no-properties
+                (line-beginning-position) (line-end-position))
+               "\tabcdef")))))
+
+(ert-deftest python-indent-dedent-line-backspace-3 ()
+  "Paranoid check of de-indentation with tabs.  Bug#19730."
+  (let ((tab-width 8))
+    (python-tests-with-temp-buffer
+     "
+if x:
+\tif y:
+\t abcdefg
+"
+     (python-tests-look-at "abcdefg")
+     (goto-char (line-end-position))
+     (call-interactively #'python-indent-dedent-line-backspace)
+     (should
+      (string= (buffer-substring-no-properties
+                (line-beginning-position) (line-end-position))
+               "\t abcdef"))
+     (back-to-indentation)
+     (call-interactively #'python-indent-dedent-line-backspace)
+     (should
+      (string= (buffer-substring-no-properties
+                (line-beginning-position) (line-end-position))
+               "\tabcdef"))
+     (call-interactively #'python-indent-dedent-line-backspace)
+     (should
+      (string= (buffer-substring-no-properties
+                (line-beginning-position) (line-end-position))
+               "    abcdef"))
+     (call-interactively #'python-indent-dedent-line-backspace)
+     (should
+      (string= (buffer-substring-no-properties
+                (line-beginning-position) (line-end-position))
+               "abcdef")))))
+
 
 ;;; Shell integration
 
@@ -2916,6 +3013,63 @@ class Foo(models.Model):
 
 ;;; Eldoc
 
+(ert-deftest python-eldoc--get-symbol-at-point-1 ()
+  "Test paren handling."
+  (python-tests-with-temp-buffer
+   "
+map(xx
+map(codecs.open('somefile'
+"
+   (python-tests-look-at "ap(xx")
+   (should (string= (python-eldoc--get-symbol-at-point) "map"))
+   (goto-char (line-end-position))
+   (should (string= (python-eldoc--get-symbol-at-point) "map"))
+   (python-tests-look-at "('somefile'")
+   (should (string= (python-eldoc--get-symbol-at-point) "map"))
+   (goto-char (line-end-position))
+   (should (string= (python-eldoc--get-symbol-at-point) "codecs.open"))))
+
+(ert-deftest python-eldoc--get-symbol-at-point-2 ()
+  "Ensure self is replaced with the class name."
+  (python-tests-with-temp-buffer
+   "
+class TheClass:
+
+    def some_method(self, n):
+        return n
+
+    def other(self):
+        return self.some_method(1234)
+
+"
+   (python-tests-look-at "self.some_method")
+   (should (string= (python-eldoc--get-symbol-at-point)
+                    "TheClass.some_method"))
+   (python-tests-look-at "1234)")
+   (should (string= (python-eldoc--get-symbol-at-point)
+                    "TheClass.some_method"))))
+
+(ert-deftest python-eldoc--get-symbol-at-point-3 ()
+  "Ensure symbol is found when point is at end of buffer."
+  (python-tests-with-temp-buffer
+   "
+some_symbol
+
+"
+   (goto-char (point-max))
+   (should (string= (python-eldoc--get-symbol-at-point)
+                    "some_symbol"))))
+
+(ert-deftest python-eldoc--get-symbol-at-point-4 ()
+  "Ensure symbol is found when point is at whitespace."
+  (python-tests-with-temp-buffer
+   "
+some_symbol   some_other_symbol
+"
+   (python-tests-look-at "  some_other_symbol")
+   (should (string= (python-eldoc--get-symbol-at-point)
+                    "some_symbol"))))
+
 
 ;;; Imenu
 
@@ -4358,12 +4512,11 @@ def foo(a, b, c):
 ;;; Electricity
 
 (ert-deftest python-parens-electric-indent-1 ()
-  (require 'electric)
   (let ((eim electric-indent-mode))
     (unwind-protect
         (progn
           (python-tests-with-temp-buffer
-              "
+           "
 from django.conf.urls import patterns, include, url
 
 from django.contrib import admin
@@ -4375,66 +4528,148 @@ urlpatterns = patterns('',
     url(r'^$', views.index
 )
 "
-            (electric-indent-mode 1)
-            (python-tests-look-at "views.index")
-            (end-of-line)
+           (electric-indent-mode 1)
+           (python-tests-look-at "views.index")
+           (end-of-line)
 
-            ;; Inserting commas within the same line should leave
-            ;; indentation unchanged.
-            (python-tests-self-insert ",")
-            (should (= (current-indentation) 4))
+           ;; Inserting commas within the same line should leave
+           ;; indentation unchanged.
+           (python-tests-self-insert ",")
+           (should (= (current-indentation) 4))
 
-            ;; As well as any other input happening within the same
-            ;; set of parens.
-            (python-tests-self-insert " name='index')")
-            (should (= (current-indentation) 4))
+           ;; As well as any other input happening within the same
+           ;; set of parens.
+           (python-tests-self-insert " name='index')")
+           (should (= (current-indentation) 4))
 
-            ;; But a comma outside it, should trigger indentation.
-            (python-tests-self-insert ",")
-            (should (= (current-indentation) 23))
+           ;; But a comma outside it, should trigger indentation.
+           (python-tests-self-insert ",")
+           (should (= (current-indentation) 23))
 
-            ;; Newline indents to the first argument column
-            (python-tests-self-insert "\n")
-            (should (= (current-indentation) 23))
+           ;; Newline indents to the first argument column
+           (python-tests-self-insert "\n")
+           (should (= (current-indentation) 23))
 
-            ;; All this input must not change indentation
-            (indent-line-to 4)
-            (python-tests-self-insert "url(r'^/login$', views.login)")
-            (should (= (current-indentation) 4))
+           ;; All this input must not change indentation
+           (indent-line-to 4)
+           (python-tests-self-insert "url(r'^/login$', views.login)")
+           (should (= (current-indentation) 4))
 
-            ;; But this comma does
-            (python-tests-self-insert ",")
-            (should (= (current-indentation) 23))))
+           ;; But this comma does
+           (python-tests-self-insert ",")
+           (should (= (current-indentation) 23))))
       (or eim (electric-indent-mode -1)))))
 
 (ert-deftest python-triple-quote-pairing ()
-  (require 'electric)
   (let ((epm electric-pair-mode))
     (unwind-protect
         (progn
           (python-tests-with-temp-buffer
-              "\"\"\n"
-            (or epm (electric-pair-mode 1))
-            (goto-char (1- (point-max)))
-            (python-tests-self-insert ?\")
-            (should (string= (buffer-string)
-                             "\"\"\"\"\"\"\n"))
-            (should (= (point) 4)))
+           "\"\"\n"
+           (or epm (electric-pair-mode 1))
+           (goto-char (1- (point-max)))
+           (python-tests-self-insert ?\")
+           (should (string= (buffer-string)
+                            "\"\"\"\"\"\"\n"))
+           (should (= (point) 4)))
           (python-tests-with-temp-buffer
-              "\n"
-            (python-tests-self-insert (list ?\" ?\" ?\"))
-            (should (string= (buffer-string)
-                             "\"\"\"\"\"\"\n"))
-            (should (= (point) 4)))
+           "\n"
+           (python-tests-self-insert (list ?\" ?\" ?\"))
+           (should (string= (buffer-string)
+                            "\"\"\"\"\"\"\n"))
+           (should (= (point) 4)))
           (python-tests-with-temp-buffer
-              "\"\n\"\"\n"
-            (goto-char (1- (point-max)))
-            (python-tests-self-insert ?\")
-            (should (= (point) (1- (point-max))))
-            (should (string= (buffer-string)
-                             "\"\n\"\"\"\n"))))
+           "\"\n\"\"\n"
+           (goto-char (1- (point-max)))
+           (python-tests-self-insert ?\")
+           (should (= (point) (1- (point-max))))
+           (should (string= (buffer-string)
+                            "\"\n\"\"\"\n"))))
       (or epm (electric-pair-mode -1)))))
 
+
+;;; Hideshow support
+
+(ert-deftest python-hideshow-hide-levels-1 ()
+  "Should hide all methods when called after class start."
+  (let ((enabled hs-minor-mode))
+    (unwind-protect
+        (progn
+          (python-tests-with-temp-buffer
+           "
+class SomeClass:
+
+    def __init__(self, arg, kwarg=1):
+        self.arg = arg
+        self.kwarg = kwarg
+
+    def filter(self, nums):
+        def fn(item):
+            return item in [self.arg, self.kwarg]
+        return filter(fn, nums)
+
+    def __str__(self):
+        return '%s-%s' % (self.arg, self.kwarg)
+"
+           (hs-minor-mode 1)
+           (python-tests-look-at "class SomeClass:")
+           (forward-line)
+           (hs-hide-level 1)
+           (should
+            (string=
+             (python-tests-visible-string)
+             "
+class SomeClass:
+
+    def __init__(self, arg, kwarg=1):
+    def filter(self, nums):
+    def __str__(self):"))))
+      (or enabled (hs-minor-mode -1)))))
+
+(ert-deftest python-hideshow-hide-levels-2 ()
+  "Should hide nested methods and parens at end of defun."
+  (let ((enabled hs-minor-mode))
+    (unwind-protect
+        (progn
+          (python-tests-with-temp-buffer
+           "
+class SomeClass:
+
+    def __init__(self, arg, kwarg=1):
+        self.arg = arg
+        self.kwarg = kwarg
+
+    def filter(self, nums):
+        def fn(item):
+            return item in [self.arg, self.kwarg]
+        return filter(fn, nums)
+
+    def __str__(self):
+        return '%s-%s' % (self.arg, self.kwarg)
+"
+           (hs-minor-mode 1)
+           (python-tests-look-at "def fn(item):")
+           (hs-hide-block)
+           (should
+            (string=
+             (python-tests-visible-string)
+             "
+class SomeClass:
+
+    def __init__(self, arg, kwarg=1):
+        self.arg = arg
+        self.kwarg = kwarg
+
+    def filter(self, nums):
+        def fn(item):
+        return filter(fn, nums)
+
+    def __str__(self):
+        return '%s-%s' % (self.arg, self.kwarg)
+"))))
+      (or enabled (hs-minor-mode -1)))))
+
+
 
 (provide 'python-tests)
 
diff --git a/test/automated/sasl-scram-rfc-tests.el b/test/automated/sasl-scram-rfc-tests.el
new file mode 100644
index 00000000000..46b139b21a7
--- /dev/null
+++ b/test/automated/sasl-scram-rfc-tests.el
@@ -0,0 +1,50 @@
+;;; sasl-scram-rfc-tests.el --- tests for SCRAM-SHA-1       -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2014-2015 Free Software Foundation, Inc.
+
+;; Author: Magnus Henoch <magnus.henoch@gmail.com>
+
+;; 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/>.
+
+;;; Commentary:
+
+;; Test cases from RFC 5802.
+
+;;; Code:
+
+(require 'sasl)
+(require 'sasl-scram-rfc)
+
+(ert-deftest sasl-scram-sha-1-test ()
+  ;; The following strings are taken from section 5 of RFC 5802.
+  (let ((client
+         (sasl-make-client (sasl-find-mechanism '("SCRAM-SHA-1"))
+                           "user"
+                           "imap"
+                           "localhost"))
+        (data "r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,s=QSXCR+Q6sek8bf92,i=4096")
+        (c-nonce "fyko+d2lbbFgONRv9qkxdawL")
+        (sasl-read-passphrase
+         (lambda (_prompt) (copy-sequence "pencil"))))
+    (sasl-client-set-property client 'c-nonce c-nonce)
+    (should
+     (equal
+      (sasl-scram-sha-1-client-final-message client (vector nil data))
+      "c=biws,r=fyko+d2lbbFgONRv9qkxdawL3rfcNHYJY1ZVvWVs7j,p=v0X8v3Bz2T0CJGbJQyF0X+HI4Ts="))
+
+    ;; This should not throw an error:
+    (sasl-scram-sha-1-authenticate-server client (vector nil "v=rmF9pqV8S7suAoZWja4dJRkFsKQ=
+"))))
+
+;;; sasl-scram-rfc-tests.el ends here
diff --git a/test/automated/seq-tests.el b/test/automated/seq-tests.el
index 23989799306..d3536b6f9a6 100644
--- a/test/automated/seq-tests.el
+++ b/test/automated/seq-tests.el
@@ -2,7 +2,7 @@
 
 ;; Copyright (C) 2014-2015 Free Software Foundation, Inc.
 
-;; Author: Nicolas Petton <petton.nicolas@gmail.com>
+;; Author: Nicolas Petton <nicolas@petton.fr>
 ;; Maintainer: emacs-devel@gnu.org
 
 ;; This file is part of GNU Emacs.
@@ -197,5 +197,58 @@ Evaluate BODY for each created sequence.
     (should (equal (seq-concatenate 'vector nil '(8 10)) [8 10]))
     (should (equal (seq-concatenate 'vector seq nil) [2 4 6]))))
 
+(ert-deftest test-seq-mapcat ()
+  (should (equal (seq-mapcat #'seq-reverse '((3 2 1) (6 5 4)))
+                 '(1 2 3 4 5 6)))
+  (should (equal (seq-mapcat #'seq-reverse '[(3 2 1) (6 5 4)])
+                 '(1 2 3 4 5 6)))
+  (should (equal (seq-mapcat #'seq-reverse '((3 2 1) (6 5 4)) 'vector)
+                 '[1 2 3 4 5 6])))
+
+(ert-deftest test-seq-partition ()
+  (should (same-contents-p (seq-partition '(0 1 2 3 4 5 6 7) 3)
+                           '((0 1 2) (3 4 5) (6 7))))
+  (should (same-contents-p (seq-partition '[0 1 2 3 4 5 6 7] 3)
+                           '([0 1 2] [3 4 5] [6 7])))
+  (should (same-contents-p (seq-partition "Hello world" 2)
+                           '("He" "ll" "o " "wo" "rl" "d")))
+  (should (equal (seq-partition '() 2) '()))
+  (should (equal (seq-partition '(1 2 3) -1) '())))
+
+(ert-deftest test-seq-group-by ()
+  (with-test-sequences (seq '(1 2 3 4))
+   (should (equal (seq-group-by #'test-sequences-oddp seq)
+                  '((t 1 3) (nil 2 4)))))
+  (should (equal (seq-group-by #'car '((a 1) (b 3) (c 4) (a 2)))
+                 '((b (b 3)) (c (c 4)) (a (a 1) (a 2))))))
+
+(ert-deftest test-seq-reverse ()
+  (with-test-sequences (seq '(1 2 3 4))
+    (should (same-contents-p (seq-reverse seq) '(4 3 2 1)))
+    (should (equal (type-of (seq-reverse seq))
+                   (type-of seq)))))
+
+(ert-deftest test-seq-into ()
+  (let* ((vector [1 2 3])
+         (list (seq-into vector 'list)))
+    (should (same-contents-p vector list))
+    (should (listp list)))
+  (let* ((list '(hello world))
+         (vector (seq-into list 'vector)))
+    (should (same-contents-p vector list))
+    (should (vectorp vector)))
+  (let* ((string "hello")
+         (list (seq-into string 'list)))
+    (should (same-contents-p string list))
+    (should (stringp string)))
+  (let* ((string "hello")
+         (vector (seq-into string 'vector)))
+    (should (same-contents-p string vector))
+    (should (stringp string)))
+  (let* ((list nil)
+         (vector (seq-into list 'vector)))
+    (should (same-contents-p list vector))
+    (should (vectorp vector))))
+
 (provide 'seq-tests)
 ;;; seq-tests.el ends here
diff --git a/test/automated/textprop-tests.el b/test/automated/textprop-tests.el
new file mode 100644
index 00000000000..310a7a0e976
--- /dev/null
+++ b/test/automated/textprop-tests.el
@@ -0,0 +1,57 @@
+;;; textprop-tests.el --- Test suite for text properties.
+
+;; Copyright (C) 2015 Free Software Foundation, Inc.
+
+;; Author: Wolfgang Jenkner <wjenkner@inode.at>
+;; Keywords: internal
+
+;; 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)
+
+(ert-deftest textprop-tests-font-lock--remove-face-from-text-property ()
+  "Test `font-lock--remove-face-from-text-property'."
+  (let* ((string "foobar")
+         (stack (list string))
+         (faces '(bold (:foreground "red") underline)))
+    ;; Build each string in `stack' by adding a face to the previous
+    ;; string.
+    (let ((faces (reverse faces)))
+      (push (copy-sequence (car stack)) stack)
+      (put-text-property 0 3 'font-lock-face (pop faces) (car stack))
+      (push (copy-sequence (car stack)) stack)
+      (put-text-property 3 6 'font-lock-face (pop faces) (car stack))
+      (push (copy-sequence (car stack)) stack)
+      (font-lock-prepend-text-property 2 5
+                                       'font-lock-face (pop faces) (car stack)))
+    ;; Check that removing the corresponding face from each string
+    ;; yields the previous string in `stack'.
+    (while faces
+      ;; (message "%S" (car stack))
+      (should (equal-including-properties
+               (progn
+                 (font-lock--remove-face-from-text-property 0 6
+                                                            'font-lock-face
+                                                            (pop faces)
+                                                            (car stack))
+                 (pop stack))
+               (car stack))))
+    ;; Sanity check.
+    ;; (message "%S" (car stack))
+    (should (and (equal-including-properties (pop stack) string)
+                 (null stack)))))
diff --git a/test/automated/tramp-tests.el b/test/automated/tramp-tests.el
index 2c4610c8113..cc2c753b9d5 100644
--- a/test/automated/tramp-tests.el
+++ b/test/automated/tramp-tests.el
@@ -46,6 +46,8 @@
 
 (declare-function tramp-find-executable "tramp-sh")
 (declare-function tramp-get-remote-path "tramp-sh")
+(declare-function tramp-get-remote-stat "tramp-sh")
+(declare-function tramp-get-remote-perl "tramp-sh")
 (defvar tramp-copy-size-limit)
 (defvar tramp-remote-process-environment)
 
@@ -122,8 +124,7 @@ shall not contain a timeout."
          (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
            (with-current-buffer (tramp-get-connection-buffer v)
              (message "%s" (buffer-string)))
-           (with-current-buffer
-               (tramp-get-debug-buffer v)
+           (with-current-buffer (tramp-get-debug-buffer v)
              (message "%s" (buffer-string))))))))
 
 (ert-deftest tramp-test00-availability ()
@@ -558,8 +559,8 @@ shall not contain a timeout."
 
 (ert-deftest tramp-test06-directory-file-name ()
   "Check `directory-file-name'.
-This checks also `file-name-as-directory', `file-name-directory'
-and `file-name-nondirectory'."
+This checks also `file-name-as-directory', `file-name-directory',
+`file-name-nondirectory' and `unhandled-file-name-directory'."
   (should
    (string-equal
     (directory-file-name "/method:host:/path/to/file")
@@ -589,8 +590,7 @@ and `file-name-nondirectory'."
   (should
    (string-equal (file-name-nondirectory "/method:host:/path/to/file/") ""))
   (should-not
-   (file-remote-p
-    (unhandled-file-name-directory "/method:host:/path/to/file"))))
+   (unhandled-file-name-directory "/method:host:/path/to/file")))
 
 (ert-deftest tramp-test07-file-exists-p ()
   "Check `file-exist-p', `write-region' and `delete-file'."
@@ -615,7 +615,13 @@ and `file-name-nondirectory'."
           (should (setq tmp-name2 (file-local-copy tmp-name1)))
           (with-temp-buffer
             (insert-file-contents tmp-name2)
-            (should (string-equal (buffer-string) "foo"))))
+            (should (string-equal (buffer-string) "foo")))
+          ;; Check also that a file transfer with compression works.
+          (let ((default-directory tramp-test-temporary-file-directory)
+                (tramp-copy-size-limit 4)
+                (tramp-inline-compress-start-size 2))
+            (delete-file tmp-name2)
+            (should (setq tmp-name2 (file-local-copy tmp-name1)))))
       (ignore-errors
         (delete-file tmp-name1)
         (delete-file tmp-name2)))))
@@ -840,7 +846,14 @@ This tests also `file-directory-p' and `file-accessible-directory-p'."
         (progn
           (make-directory tmp-name)
           (should (file-directory-p tmp-name))
-          (should (file-accessible-directory-p tmp-name)))
+          (should (file-accessible-directory-p tmp-name))
+          (should-error
+           (make-directory (expand-file-name "foo/bar" tmp-name))
+           :type 'file-error)
+          (make-directory (expand-file-name "foo/bar" tmp-name) 'parents)
+          (should (file-directory-p (expand-file-name "foo/bar" tmp-name)))
+          (should
+           (file-accessible-directory-p (expand-file-name "foo/bar" tmp-name))))
       (ignore-errors (delete-directory tmp-name)))))
 
 (ert-deftest tramp-test14-delete-directory ()
@@ -927,7 +940,10 @@ This tests also `file-directory-p' and `file-accessible-directory-p'."
   (skip-unless (tramp--test-enabled))
 
   (let* ((tmp-name1 (tramp--test-make-temp-name))
-         (tmp-name2 (expand-file-name "foo" tmp-name1)))
+         (tmp-name2 (expand-file-name "foo" tmp-name1))
+         ;; We test for the summary line.  Keyword "total" could be localized.
+         (process-environment
+          (append '("LANG=C" "LANGUAGE=C" "LC_ALL=C") process-environment)))
     (unwind-protect
         (progn
           (make-directory tmp-name1)
@@ -956,9 +972,8 @@ This tests also `file-directory-p' and `file-accessible-directory-p'."
               (concat
                ;; There might be a summary line.
                "\\(total.+[[:digit:]]+\n\\)?"
-               ;; We don't know in which order "." and ".." appear.
-               "\\(.+ \\.?\\.\n\\)\\{2\\}"
-               ".+ foo$")))))
+               ;; We don't know in which order ".", ".." and "foo" appear.
+               "\\(.+ \\(\\.?\\.\\|foo\\)\n\\)\\{3\\}")))))
       (ignore-errors (delete-directory tmp-name1 'recursive)))))
 
 (ert-deftest tramp-test18-file-attributes ()
@@ -966,17 +981,18 @@ This tests also `file-directory-p' and `file-accessible-directory-p'."
 This tests also `file-readable-p' and `file-regular-p'."
   (skip-unless (tramp--test-enabled))
 
-  (let ((tmp-name (tramp--test-make-temp-name))
+  (let ((tmp-name1 (tramp--test-make-temp-name))
+        (tmp-name2 (tramp--test-make-temp-name))
         attr)
     (unwind-protect
         (progn
-          (write-region "foo" nil tmp-name)
-          (should (file-exists-p tmp-name))
-          (setq attr (file-attributes tmp-name))
+          (write-region "foo" nil tmp-name1)
+          (should (file-exists-p tmp-name1))
+          (setq attr (file-attributes tmp-name1))
           (should (consp attr))
-          (should (file-exists-p tmp-name))
-          (should (file-readable-p tmp-name))
-          (should (file-regular-p tmp-name))
+          (should (file-exists-p tmp-name1))
+          (should (file-readable-p tmp-name1))
+          (should (file-regular-p tmp-name1))
           ;; We do not test inodes and device numbers.
           (should (null (car attr)))
           (should (numberp (nth 1 attr))) ;; Link.
@@ -991,18 +1007,33 @@ This tests also `file-readable-p' and `file-regular-p'."
           (should (numberp (nth 7 attr))) ;; Size.
           (should (stringp (nth 8 attr))) ;; Modes.
 
-          (setq attr (file-attributes tmp-name 'string))
+          (setq attr (file-attributes tmp-name1 'string))
           (should (stringp (nth 2 attr))) ;; Uid.
           (should (stringp (nth 3 attr))) ;; Gid.
-          (delete-file tmp-name)
 
-          (make-directory tmp-name)
-          (should (file-exists-p tmp-name))
-          (should (file-readable-p tmp-name))
-          (should-not (file-regular-p tmp-name))
-          (setq attr (file-attributes tmp-name))
+          (condition-case err
+              (progn
+                (make-symbolic-link tmp-name1 tmp-name2)
+                (should (file-exists-p tmp-name2))
+                (should (file-symlink-p tmp-name2))
+                (setq attr (file-attributes tmp-name2))
+                (should (string-equal
+                         (car attr)
+                         (file-remote-p (file-truename tmp-name1) 'localname)))
+                (delete-file tmp-name2))
+            (file-error
+             (should (string-equal (error-message-string err)
+                                   "make-symbolic-link not supported"))))
+          (delete-file tmp-name1)
+
+          (make-directory tmp-name1)
+          (should (file-exists-p tmp-name1))
+          (should (file-readable-p tmp-name1))
+          (should-not (file-regular-p tmp-name1))
+          (setq attr (file-attributes tmp-name1))
           (should (eq (car attr) t)))
-      (ignore-errors (delete-directory tmp-name)))))
+
+      (ignore-errors (delete-directory tmp-name1)))))
 
 (ert-deftest tramp-test19-directory-files-and-attributes ()
   "Check `directory-files-and-attributes'."
@@ -1487,38 +1518,72 @@ This tests also `make-symbolic-link', `file-truename' and `add-name-to-file'."
 
         (ignore-errors (delete-directory tmp-name1 'recursive)))))
 
+(defun tramp--test-adb-p ()
+  "Check, whether the remote host runs Android.
+This requires restrictions of file name syntax."
+  (eq (tramp-find-foreign-file-name-handler
+       tramp-test-temporary-file-directory)
+      'tramp-adb-file-name-handler))
+
 (defun tramp--test-smb-or-windows-nt-p ()
   "Check, whether the locale or remote host runs MS Windows.
 This requires restrictions of file name syntax."
   (or (eq system-type 'windows-nt)
       (eq (tramp-find-foreign-file-name-handler
            tramp-test-temporary-file-directory)
-       'tramp-smb-file-name-handler)))
+          'tramp-smb-file-name-handler)))
 
 (defun tramp--test-check-files (&rest files)
-  "Runs a simple but comprehensive test over every file in FILES."
+  "Run a simple but comprehensive test over every file in FILES."
   (let ((tmp-name1 (tramp--test-make-temp-name))
-        (tmp-name2 (tramp--test-make-temp-name 'local)))
+        (tmp-name2 (tramp--test-make-temp-name 'local))
+        (files (delq nil files)))
     (unwind-protect
         (progn
           (make-directory tmp-name1)
           (make-directory tmp-name2)
-          (dolist (elt (delq nil files))
-            (let ((file1 (expand-file-name elt tmp-name1))
-                  (file2 (expand-file-name elt tmp-name2)))
+          (dolist (elt files)
+            (let* ((file1 (expand-file-name elt tmp-name1))
+                   (file2 (expand-file-name elt tmp-name2))
+                   (file3 (expand-file-name (concat elt "foo") tmp-name1)))
               (write-region elt nil file1)
               (should (file-exists-p file1))
+
               ;; Check file contents.
               (with-temp-buffer
                 (insert-file-contents file1)
                 (should (string-equal (buffer-string) elt)))
+
               ;; Copy file both directions.
               (copy-file file1 tmp-name2)
               (should (file-exists-p file2))
               (delete-file file1)
               (should-not (file-exists-p file1))
               (copy-file file2 tmp-name1)
-              (should (file-exists-p file1))))
+              (should (file-exists-p file1))
+
+              ;; Method "smb" supports `make-symbolic-link' only if the
+              ;; remote host has CIFS capabilities.  tramp-adb.el and
+              ;; tramp-gvfs.el do not support symbolic links at all.
+              (condition-case err
+                  (progn
+                    (make-symbolic-link file1 file3)
+                    (should (file-symlink-p file3))
+                    (should
+                     (string-equal
+                      (expand-file-name file1) (file-truename file3)))
+                    (should
+                     (string-equal
+                      (car (file-attributes file3))
+                      (file-remote-p (file-truename file1) 'localname)))
+                    ;; Check file contents.
+                    (with-temp-buffer
+                      (insert-file-contents file3)
+                      (should (string-equal (buffer-string) elt)))
+                    (delete-file file3))
+                (file-error
+                 (should (string-equal (error-message-string err)
+                                       "make-symbolic-link not supported"))))))
 
           ;; Check file names.
           (should (equal (directory-files
@@ -1545,26 +1610,71 @@ This requires restrictions of file name syntax."
           (should (equal (directory-files
                           tmp-name1 nil directory-files-no-dot-files-regexp)
                          (directory-files
-                          tmp-name2 nil directory-files-no-dot-files-regexp))))
+                          tmp-name2 nil directory-files-no-dot-files-regexp)))
+
+          ;; Check directory creation.  We use a subdirectory "foo"
+          ;; in order to avoid conflicts with previous file name tests.
+          (dolist (elt files)
+            (let* ((elt1 (concat elt "foo"))
+                   (file1 (expand-file-name (concat "foo/" elt) tmp-name1))
+                   (file2 (expand-file-name elt file1))
+                   (file3 (expand-file-name elt1 file1)))
+              (make-directory file1 'parents)
+              (should (file-directory-p file1))
+              (write-region elt nil file2)
+              (should (file-exists-p file2))
+              (should
+               (equal
+                (directory-files file1 nil directory-files-no-dot-files-regexp)
+                `(,elt)))
+              (should
+               (equal
+                (caar (directory-files-and-attributes
+                       file1 nil directory-files-no-dot-files-regexp))
+                elt))
+
+              ;; Check symlink in `directory-files-and-attributes'.
+              (condition-case err
+                  (progn
+                    (make-symbolic-link file2 file3)
+                    (should (file-symlink-p file3))
+                    (should
+                     (string-equal
+                      (caar (directory-files-and-attributes
+                             file1 nil (regexp-quote elt1)))
+                      elt1))
+                    (should
+                     (string-equal
+                      (cadr (car (directory-files-and-attributes
+                                  file1 nil (regexp-quote elt1))))
+                      (file-remote-p (file-truename file2) 'localname)))
+                    (delete-file file3)
+                    (should-not (file-exists-p file3)))
+                (file-error
+                 (should (string-equal (error-message-string err)
+                                       "make-symbolic-link not supported"))))
+
+              (delete-file file2)
+              (should-not (file-exists-p file2))
+              (delete-directory file1)
+              (should-not (file-exists-p file1)))))
 
       (ignore-errors (delete-directory tmp-name1 'recursive))
       (ignore-errors (delete-directory tmp-name2 'recursive)))))
 
-;; This test is inspired by Bug#17238.
-(ert-deftest tramp-test30-special-characters ()
-  "Check special characters in file names."
-  (skip-unless (tramp--test-enabled))
-  (skip-unless
-   (not
-    (memq
-     (tramp-find-foreign-file-name-handler tramp-test-temporary-file-directory)
-     '(tramp-adb-file-name-handler
-       tramp-gvfs-file-name-handler))))
-
-  ;; Newlines, slashes and backslashes in file names are not supported.
-  ;; So we don't test.
+(defun tramp--test-special-characters ()
+  "Perform the test in `tramp-test30-special-characters*'."
+  ;; Newlines, slashes and backslashes in file names are not
+  ;; supported.  So we don't test.  And we don't test the tab
+  ;; character on Windows or Cygwin, because the backslash is
+  ;; interpreted as a path separator, preventing "\t" from being
+  ;; expanded to <TAB>.
   (tramp--test-check-files
-   (if (tramp--test-smb-or-windows-nt-p) "foo bar baz" " foo\tbar baz\t")
+   (if (tramp--test-smb-or-windows-nt-p)
+       "foo bar baz"
+     (if (or (tramp--test-adb-p) (eq system-type 'cygwin))
+         " foo bar baz "
+       " foo\tbar baz\t"))
    "$foo$bar$$baz$"
    "-foo-bar-baz-"
    "%foo%bar%baz%"
@@ -1580,18 +1690,144 @@ This requires restrictions of file name syntax."
    "[foo]bar[baz]"
    "{foo}bar{baz}"))
 
-(ert-deftest tramp-test31-utf8 ()
-  "Check UTF8 encoding in file names and file contents."
+;; These tests are inspired by Bug#17238.
+(ert-deftest tramp-test30-special-characters ()
+  "Check special characters in file names."
+  (skip-unless (tramp--test-enabled))
+
+  (tramp--test-special-characters))
+
+(ert-deftest tramp-test30-special-characters-with-stat ()
+  "Check special characters in file names.
+Use the `stat' command."
+  (skip-unless (tramp--test-enabled))
+  (skip-unless
+   (eq
+    (tramp-find-foreign-file-name-handler tramp-test-temporary-file-directory)
+    'tramp-sh-file-name-handler))
+  (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+    (skip-unless (tramp-get-remote-stat v)))
+
+  (unwind-protect
+      (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+        (tramp-set-connection-property v "perl" nil)
+        (tramp--test-special-characters))
+    ;; Reset suppressed properties.
+    (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+      (tramp-set-connection-property v "perl" 'undef))))
+
+(ert-deftest tramp-test30-special-characters-with-perl ()
+  "Check special characters in file names.
+Use the `perl' command."
+  (skip-unless (tramp--test-enabled))
+  (skip-unless
+   (eq
+    (tramp-find-foreign-file-name-handler tramp-test-temporary-file-directory)
+    'tramp-sh-file-name-handler))
+  (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+    (skip-unless (tramp-get-remote-perl v)))
+
+  (unwind-protect
+      (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+        (tramp-set-connection-property v "stat" nil)
+        (tramp--test-special-characters))
+    ;; Reset suppressed properties.
+    (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+      (tramp-set-connection-property v "stat" 'undef))))
+
+(ert-deftest tramp-test30-special-characters-with-ls ()
+  "Check special characters in file names.
+Use the `ls' command."
   (skip-unless (tramp--test-enabled))
+  (skip-unless
+   (eq
+    (tramp-find-foreign-file-name-handler tramp-test-temporary-file-directory)
+    'tramp-sh-file-name-handler))
 
+  (unwind-protect
+      (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+        (tramp-set-connection-property v "stat" nil)
+        (tramp-set-connection-property v "perl" nil)
+        (tramp--test-special-characters))
+    ;; Reset suppressed properties.
+    (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+      (tramp-set-connection-property v "stat" 'undef)
+      (tramp-set-connection-property v "perl" 'undef))))
+
+(defun tramp--test-utf8 ()
+  "Perform the test in `tramp-test31-utf8*'."
   (let ((coding-system-for-read 'utf-8)
         (coding-system-for-write 'utf-8)
         (file-name-coding-system 'utf-8))
     (tramp--test-check-files
+     "Γυρίστε το Γαλαξία με Ώτο Στοπ"
      "أصبح بوسعك الآن تنزيل نسخة كاملة من موسوعة ويكيبيديا العربية لتصفحها بلا اتصال بالإنترنت"
      "银河系漫游指南系列"
      "Автостопом по гала́ктике")))
 
+(ert-deftest tramp-test31-utf8 ()
+  "Check UTF8 encoding in file names and file contents."
+  (skip-unless (tramp--test-enabled))
+
+  (tramp--test-utf8))
+
+(ert-deftest tramp-test31-utf8-with-stat ()
+  "Check UTF8 encoding in file names and file contents.
+Use the `stat' command."
+  (skip-unless (tramp--test-enabled))
+  (skip-unless
+   (eq
+    (tramp-find-foreign-file-name-handler tramp-test-temporary-file-directory)
+    'tramp-sh-file-name-handler))
+  (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+    (skip-unless (tramp-get-remote-stat v)))
+
+  (unwind-protect
+      (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+        (tramp-set-connection-property v "perl" nil)
+        (tramp--test-utf8))
+    ;; Reset suppressed properties.
+    (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+      (tramp-set-connection-property v "perl" 'undef))))
+
+(ert-deftest tramp-test31-utf8-with-perl ()
+  "Check UTF8 encoding in file names and file contents.
+Use the `perl' command."
+  (skip-unless (tramp--test-enabled))
+  (skip-unless
+   (eq
+    (tramp-find-foreign-file-name-handler tramp-test-temporary-file-directory)
+    'tramp-sh-file-name-handler))
+  (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+    (skip-unless (tramp-get-remote-perl v)))
+
+  (unwind-protect
+      (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+        (tramp-set-connection-property v "stat" nil)
+        (tramp--test-utf8))
+    ;; Reset suppressed properties.
+    (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+      (tramp-set-connection-property v "stat" 'undef))))
+
+(ert-deftest tramp-test31-utf8-with-ls ()
+  "Check UTF8 encoding in file names and file contents.
+Use the `ls' command."
+  (skip-unless (tramp--test-enabled))
+  (skip-unless
+   (eq
+    (tramp-find-foreign-file-name-handler tramp-test-temporary-file-directory)
+    'tramp-sh-file-name-handler))
+
+  (unwind-protect
+      (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+        (tramp-set-connection-property v "stat" nil)
+        (tramp-set-connection-property v "perl" nil)
+        (tramp--test-utf8))
+    ;; Reset suppressed properties.
+    (with-parsed-tramp-file-name tramp-test-temporary-file-directory nil
+      (tramp-set-connection-property v "stat" 'undef)
+      (tramp-set-connection-property v "perl" 'undef))))
+
 ;; This test is inspired by Bug#16928.
 (ert-deftest tramp-test32-asynchronous-requests ()
   "Check parallel asynchronous requests.
@@ -1726,7 +1962,6 @@ Since it unloads Tramp, it shall be the last test to run."
             (not (string-match "^tramp--?test" (symbol-name x)))
             (not (string-match "unload-hook$" (symbol-name x)))
             (ert-fail (format "`%s' still bound" x)))))
-;           (progn (message "`%s' still bound" x)))))
     ;; There shouldn't be left a hook function containing a Tramp
     ;; function.  We do not regard the Tramp unload hooks.
     (mapatoms
@@ -1755,7 +1990,7 @@ Since it unloads Tramp, it shall be the last test to run."
 ;;   doesn't work well when an interactive password must be provided.
 ;; * Fix `tramp-test27-start-file-process' for `nc' and on MS
 ;;   Windows (`process-send-eof'?).
-;; * Fix `tramp-test30-special-characters' for `adb' and `nc'.
+;; * Fix `tramp-test30-special-characters' for `nc'.
 ;; * Fix `tramp-test31-utf8' for `nc'/`telnet' (when target is a dumb
 ;;   busybox).  Seems to be in `directory-files'.
 ;; * Fix Bug#16928.  Set expected error of `tramp-test32-asynchronous-requests'.
diff --git a/test/automated/vc-tests.el b/test/automated/vc-tests.el
index 5b7b3cce039..44f25728447 100644
--- a/test/automated/vc-tests.el
+++ b/test/automated/vc-tests.el
@@ -27,29 +27,29 @@
 
 ;; BACKEND PROPERTIES
 ;;
-;; * revision-granularity
+;; * revision-granularity                                       DONE
 
 ;; STATE-QUERYING FUNCTIONS
 ;;
-;; * registered (file)
-;; * state (file)
+;; * registered (file)                                          DONE
+;; * state (file)                                               DONE
 ;; - dir-status (dir update-function)
 ;; - dir-status-files (dir files default-state update-function)
 ;; - dir-extra-headers (dir)
 ;; - dir-printer (fileinfo)
 ;; - status-fileinfo-extra (file)
-;; * working-revision (file)
+;; * working-revision (file)                                    DONE
 ;; - latest-on-branch-p (file)
-;; * checkout-model (files)
+;; * checkout-model (files)                                     DONE
 ;; - mode-line-string (file)
 
 ;; STATE-CHANGING FUNCTIONS
 ;;
-;; * create-repo (backend)
-;; * register (files &optional comment)
+;; * create-repo (backend)                                      DONE
+;; * register (files &optional comment)                         DONE
 ;; - responsible-p (file)
 ;; - receive-file (file rev)
-;; - unregister (file)
+;; - unregister (file)                                          DONE
 ;; * checkin (files comment)
 ;; * find-revision (file rev buffer)
 ;; * checkout (file &optional rev)
@@ -178,12 +178,13 @@ For backends which dont support it, it is emulated."
 
           ;; Check the revision granularity.
           (should (memq (vc-test--revision-granularity-function backend)
-                 '(file repository)))
+                        '(file repository)))
 
           ;; Create empty repository.
           (make-directory default-directory)
           (should (file-directory-p default-directory))
-          (vc-test--create-repo-function backend))
+          (vc-test--create-repo-function backend)
+          (should (eq (vc-responsible-backend default-directory) backend)))
 
       ;; Save exit.
       (ignore-errors (run-hooks 'vc-test--cleanup-hook)))))
@@ -229,8 +230,7 @@ For backends which dont support it, `vc-not-supported' is signalled."
             (write-region "bla" nil tmp-name2 nil 'nomessage)
             (should (file-exists-p tmp-name2))
             (should-not (vc-registered tmp-name2))
-            (vc-register
-             (list backend (list tmp-name1 tmp-name2)))
+            (vc-register (list backend (list tmp-name1 tmp-name2)))
             (should (file-exists-p tmp-name1))
             (should (vc-registered tmp-name1))
             (should (file-exists-p tmp-name2))
@@ -244,15 +244,14 @@ For backends which dont support it, `vc-not-supported' is signalled."
                   (vc-test--unregister-function backend tmp-name2)
                   (should-not (vc-registered tmp-name2)))
               ;; CVS, SVN, SCCS, SRC and Mtn are not supported.
-              (vc-not-supported (message "%s" (error-message-string err))))
+              (vc-not-supported t))
+            ;; The files shall still exist.
             (should (file-exists-p tmp-name1))
             (should (file-exists-p tmp-name2))))
 
       ;; Save exit.
       (ignore-errors (run-hooks 'vc-test--cleanup-hook)))))
 
-;; `vc-state' returns different results for different backends.  So we
-;; don't check with `should', but print the results for analysis.
 (defun vc-test--state (backend)
   "Check the different states of a file."
 
@@ -261,7 +260,7 @@ For backends which dont support it, `vc-not-supported' is signalled."
           (file-name-as-directory
            (expand-file-name
             (make-temp-name "vc-test") temporary-file-directory)))
-        vc-test--cleanup-hook errors)
+        vc-test--cleanup-hook)
 
     (unwind-protect
         (progn
@@ -270,36 +269,64 @@ For backends which dont support it, `vc-not-supported' is signalled."
            'vc-test--cleanup-hook
            `(lambda () (delete-directory ,default-directory 'recursive)))
 
-          ;; Create empty repository.
+          ;; Create empty repository.  Check repository state.
           (make-directory default-directory)
           (vc-test--create-repo-function backend)
 
-          (message "%s" (vc-state default-directory backend))
-          ;(should (eq (vc-state default-directory backend) 'up-to-date))
+          ;; nil: Hg Mtn RCS
+          ;; added: Git
+          ;; unregistered: CVS SCCS SRC
+          ;; up-to-date: Bzr SVN
+          (should (eq (vc-state default-directory)
+                      (vc-state default-directory backend)))
+          (should (memq (vc-state default-directory)
+                        '(nil added unregistered up-to-date)))
 
           (let ((tmp-name (expand-file-name "foo" default-directory)))
-            ;; Check for initial state.
-            (message "%s" (vc-state tmp-name backend))
-            ;(should (eq (vc-state tmp-name backend) 'unregistered))
+            ;; Check state of an empty file.
 
-            ;; Write a new file.  Check for state.
+            ;; nil: Hg Mtn SRC SVN
+            ;; added: Git
+            ;; unregistered: RCS SCCS
+            ;; up-to-date: Bzr CVS
+            (should (eq (vc-state tmp-name) (vc-state tmp-name backend)))
+            (should (memq (vc-state tmp-name)
+                          '(nil added unregistered up-to-date)))
+
+            ;; Write a new file.  Check state.
             (write-region "foo" nil tmp-name nil 'nomessage)
-            (message "%s" (vc-state tmp-name backend))
-            ;(should (eq (vc-state tmp-name backend) 'unregistered))
 
-            ;; Register a file.  Check for state.
+            ;; nil: Mtn
+            ;; added: Git
+            ;; unregistered: Hg RCS SCCS SRC SVN
+            ;; up-to-date: Bzr CVS
+            (should (eq (vc-state tmp-name) (vc-state tmp-name backend)))
+            (should (memq (vc-state tmp-name)
+                          '(nil added unregistered up-to-date)))
+
+            ;; Register a file.  Check state.
             (vc-register
              (list backend (list (file-name-nondirectory tmp-name))))
-            (message "%s" (vc-state tmp-name backend))
-            ;(should (eq (vc-state tmp-name backend) 'added))
 
-            ;; Unregister the file.  Check for state.
+            ;; added: Git Mtn
+            ;; unregistered: Hg RCS SCCS SRC SVN
+            ;; up-to-date: Bzr CVS
+            (should (eq (vc-state tmp-name) (vc-state tmp-name backend)))
+            (should (memq (vc-state tmp-name) '(added unregistered up-to-date)))
+
+            ;; Unregister the file.  Check state.
             (condition-case nil
                 (progn
                   (vc-test--unregister-function backend tmp-name)
-                  (message "%s" (vc-state tmp-name backend))
-                  );(should (eq (vc-state tmp-name backend) 'unregistered)))
-              (vc-not-supported (message "%s" 'unsupported)))))
+
+                  ;; added: Git
+                  ;; unregistered: Hg
+                  ;; unsupported: CVS Mtn SCCS SRC SVN
+                  ;; up-to-date: Bzr
+                  (should (eq (vc-state tmp-name) (vc-state tmp-name backend)))
+                  (should (memq (vc-state tmp-name)
+                                '(added unregistered up-to-date))))
+              (vc-not-supported t))))
 
       ;; Save exit.
       (ignore-errors (run-hooks 'vc-test--cleanup-hook)))))
@@ -312,7 +339,7 @@ For backends which dont support it, `vc-not-supported' is signalled."
           (file-name-as-directory
            (expand-file-name
             (make-temp-name "vc-test") temporary-file-directory)))
-        vc-test--cleanup-hook errors)
+        vc-test--cleanup-hook)
 
     (unwind-protect
         (progn
@@ -321,38 +348,141 @@ For backends which dont support it, `vc-not-supported' is signalled."
            'vc-test--cleanup-hook
            `(lambda () (delete-directory ,default-directory 'recursive)))
 
-          ;; Create empty repository.
+          ;; Create empty repository.  Check working revision of
+          ;; repository, should be nil.
           (make-directory default-directory)
           (vc-test--create-repo-function backend)
 
+          ;; nil: CVS Mtn RCS SCCS
+          ;; "0": Bzr Hg SRC SVN
+          ;; "master": Git
+          (should (eq (vc-working-revision default-directory)
+                      (vc-working-revision default-directory backend)))
           (should
            (member
-            (vc-working-revision default-directory backend) '("0" "master")))
+            (vc-working-revision default-directory) '(nil "0" "master")))
 
           (let ((tmp-name (expand-file-name "foo" default-directory)))
-            ;; Check for initial state.
+            ;; Check initial working revision, should be nil until
+            ;; it's registered.
+
+            ;; nil: CVS Mtn RCS SCCS SVN
+            ;; "0": Bzr Hg SRC
+            ;; "master": Git
+            (should (eq (vc-working-revision tmp-name)
+                        (vc-working-revision tmp-name backend)))
             (should
-             (member (vc-working-revision tmp-name backend) '("0" "master")))
+             (member (vc-working-revision tmp-name) '(nil "0" "master")))
 
-            ;; Write a new file.  Check for state.
+            ;; Write a new file.  Check working revision.
             (write-region "foo" nil tmp-name nil 'nomessage)
+
+            ;; nil: CVS Mtn RCS SCCS SVN
+            ;; "0": Bzr Hg SRC
+            ;; "master": Git
+            (should (eq (vc-working-revision tmp-name)
+                        (vc-working-revision tmp-name backend)))
             (should
-             (member (vc-working-revision tmp-name backend) '("0" "master")))
+             (member (vc-working-revision tmp-name) '(nil "0" "master")))
 
-            ;; Register a file.  Check for state.
+            ;; Register a file.  Check working revision.
             (vc-register
              (list backend (list (file-name-nondirectory tmp-name))))
+
+            ;; nil: Mtn RCS SCCS
+            ;; "0": Bzr CVS Hg SRC SVN
+            ;; "master": Git
+            (should (eq (vc-working-revision tmp-name)
+                        (vc-working-revision tmp-name backend)))
             (should
-             (member (vc-working-revision tmp-name backend) '("0" "master")))
+             (member (vc-working-revision tmp-name) '(nil "0" "master")))
 
-            ;; Unregister the file.  Check for working-revision.
+            ;; Unregister the file.  Check working revision.
             (condition-case nil
                 (progn
                   (vc-test--unregister-function backend tmp-name)
+
+                  ;; nil: RCS
+                  ;; "0": Bzr Hg
+                  ;; "master": Git
+                  ;; unsupported: CVS Mtn SCCS SRC SVN
+                  (should (eq (vc-working-revision tmp-name)
+                              (vc-working-revision tmp-name backend)))
                   (should
                    (member
-                    (vc-working-revision tmp-name backend) '("0" "master"))))
-              (vc-not-supported (message "%s" 'unsupported)))))
+                    (vc-working-revision tmp-name) '(nil "0" "master"))))
+              (vc-not-supported t))))
+
+      ;; Save exit.
+      (ignore-errors (run-hooks 'vc-test--cleanup-hook)))))
+
+(defun vc-test--checkout-model (backend)
+  "Check the checkout model of a repository."
+
+  (let ((vc-handled-backends `(,backend))
+        (default-directory
+          (file-name-as-directory
+           (expand-file-name
+            (make-temp-name "vc-test") temporary-file-directory)))
+        vc-test--cleanup-hook)
+
+    (unwind-protect
+        (progn
+          ;; Cleanup.
+          (add-hook
+           'vc-test--cleanup-hook
+           `(lambda () (delete-directory ,default-directory 'recursive)))
+
+          ;; Create empty repository.  Check repository checkout model.
+          (make-directory default-directory)
+          (vc-test--create-repo-function backend)
+
+          ;; Surprisingly, none of the backends returns 'announce.
+          ;; nil: RCS
+          ;; implicit: Bzr CVS Git Hg Mtn SRC SVN
+          ;; locking: SCCS
+          (should (memq (vc-checkout-model backend default-directory)
+                        '(announce implicit locking)))
+
+          (let ((tmp-name (expand-file-name "foo" default-directory)))
+            ;; Check checkout model of an empty file.
+
+            ;; nil: RCS
+            ;; implicit: Bzr CVS Git Hg Mtn SRC SVN
+            ;; locking: SCCS
+            (should (memq (vc-checkout-model backend tmp-name)
+                          '(announce implicit locking)))
+
+            ;; Write a new file.  Check checkout model.
+            (write-region "foo" nil tmp-name nil 'nomessage)
+
+            ;; nil: RCS
+            ;; implicit: Bzr CVS Git Hg Mtn SRC SVN
+            ;; locking: SCCS
+            (should (memq (vc-checkout-model backend tmp-name)
+                          '(announce implicit locking)))
+
+            ;; Register a file.  Check checkout model.
+            (vc-register
+             (list backend (list (file-name-nondirectory tmp-name))))
+
+            ;; nil: RCS
+            ;; implicit: Bzr CVS Git Hg Mtn SRC SVN
+            ;; locking: SCCS
+            (should (memq (vc-checkout-model backend tmp-name)
+                          '(announce implicit locking)))
+
+            ;; Unregister the file.  Check checkout model.
+            (condition-case nil
+                (progn
+                  (vc-test--unregister-function backend tmp-name)
+
+                  ;; nil: RCS
+                  ;; implicit: Bzr Git Hg
+                  ;; unsupported: CVS Mtn SCCS SRC SVN
+                  (should (memq (vc-checkout-model backend tmp-name)
+                                '(announce implicit locking))))
+              (vc-not-supported t))))
 
       ;; Save exit.
       (ignore-errors (run-hooks 'vc-test--cleanup-hook)))))
@@ -392,11 +522,11 @@ For backends which dont support it, `vc-not-supported' is signalled."
 (defun vc-test--mtn-enabled ()
   (executable-find vc-mtn-program))
 
+;; Obsoleted.
 (defvar vc-arch-program)
 (defun vc-test--arch-enabled ()
   (executable-find vc-arch-program))
 
-
 ;; There are too many failed test cases yet.  We suppress them on hydra.
 (if (getenv "NIX_STORE")
     (ert-deftest vc-test ()
@@ -413,7 +543,8 @@ For backends which dont support it, `vc-not-supported' is signalled."
 
           (ert-deftest
               ,(intern (format "vc-test-%s00-create-repo" backend-string)) ()
-            ,(format "Check `vc-create-repo' for the %s backend." backend-string)
+            ,(format "Check `vc-create-repo' for the %s backend."
+                     backend-string)
             (vc-test--create-repo ',backend))
 
           (ert-deftest
@@ -442,14 +573,27 @@ For backends which dont support it, `vc-not-supported' is signalled."
 
           (ert-deftest
               ,(intern (format "vc-test-%s03-working-revision" backend-string)) ()
-            ,(format "Check `vc-working-revision' for the %s backend." backend-string)
+            ,(format "Check `vc-working-revision' for the %s backend."
+                     backend-string)
+            (skip-unless
+             (ert-test-passed-p
+              (ert-test-most-recent-result
+               (ert-get-test
+                ',(intern
+                   (format "vc-test-%s01-register" backend-string))))))
+            (vc-test--working-revision ',backend))
+
+          (ert-deftest
+              ,(intern (format "vc-test-%s04-checkout-model" backend-string)) ()
+            ,(format "Check `vc-checkout-model' for the %s backend."
+                     backend-string)
             (skip-unless
              (ert-test-passed-p
               (ert-test-most-recent-result
                (ert-get-test
                 ',(intern
                    (format "vc-test-%s01-register" backend-string))))))
-            (vc-test--working-revision ',backend)))))))
+            (vc-test--checkout-model ',backend)))))))
 
 (provide 'vc-tests)
 ;;; vc-tests.el ends here
diff --git a/test/automated/xwidget-tests.el b/test/automated/xwidget-tests.el
deleted file mode 100644
index 7f79c9422f6..00000000000
--- a/test/automated/xwidget-tests.el
+++ /dev/null
@@ -1,121 +0,0 @@
-;; -*- lexical-binding: t; -*-
-
-(require 'cl)
-(require 'xwidget)
-(require 'xwidget-test)
-(require 'parallel)
-
-(defvar xwidget-parallel-config (list :emacs-path (expand-file-name
-                                                   "~/packages/xwidget-build/src/emacs")))
-
-(defmacro xwidget-deftest (name types &rest body)
-  (declare (indent defun))
-  (if (null types)
-      `(ert-deftest ,(intern (format "%s" name)) ()
-         (let ((parallel-config xwidget-parallel-config))
-           ,@body))
-    `(progn
-       ,@(loop for type in types
-               collect
-               `(ert-deftest ,(intern (format "%s-%s" name type)) ()
-                  (let ((parallel-config xwidget-parallel-config)
-                        (type ',type)
-                        (title ,(symbol-name type)))
-                    ,@body))))))
-
-(xwidget-deftest xwidget-make-xwidget (Button ToggleButton slider socket cairo)
-  (let* ((beg 1)
-         (end 1)
-         (width 100)
-         (height 100)
-         (data nil)
-         (proc (parallel-start
-                (lambda (beg end type title width height data)
-                  (require 'xwidget)
-                  (require 'cl)
-                  (with-temp-buffer
-                    (insert ?\0)
-                    (let* ((buffer (current-buffer))
-                           (xwidget (make-xwidget beg end type title width height data buffer)))
-                      (set-xwidget-query-on-exit-flag xwidget nil)
-                      (parallel-remote-send (coerce (xwidget-info xwidget) 'list))
-                      (parallel-remote-send (buffer-name buffer))
-                      (buffer-name (xwidget-buffer xwidget)))))
-                :env (list beg end type title width height data)))
-         (results (parallel-get-results proc)))
-    (should (parallel-success-p proc))
-    (when (parallel-success-p proc)
-      (destructuring-bind (xwidget-buffer temp-buffer xwidget-info)
-          results
-        (should (equal (list type title width height)
-                       xwidget-info))
-        (should (equal temp-buffer xwidget-buffer))))))
-
-(xwidget-deftest xwidget-query-on-exit-flag ()
-  (should (equal '(nil t)
-                 (parallel-get-results
-                  (parallel-start (lambda ()
-                                    (require 'xwidget)
-                                    (let ((xwidget (make-xwidget 1 1 'Button "Button" 100 100 nil)))
-                                      (parallel-remote-send (xwidget-query-on-exit-flag xwidget))
-                                      (set-xwidget-query-on-exit-flag xwidget nil)
-                                      (xwidget-query-on-exit-flag xwidget))))))))
-
-(xwidget-deftest xwidget-query-on-exit-flag (Button ToggleButton slider socket cairo)
-  (should (parallel-get-result
-           (parallel-start (lambda (type title)
-                             (require 'xwidget)
-                             (with-temp-buffer
-                               (let ((xwidget (make-xwidget 1 1 type title 10 10 nil)))
-                                 (set-xwidget-query-on-exit-flag xwidget nil)
-                                 (xwidgetp xwidget))))
-                           :env (list type title)))))
-
-(xwidget-deftest xwidget-CHECK_XWIDGET ()
-  (should (equal (parallel-get-result
-                  (parallel-start (lambda ()
-                                    (require 'xwidget)
-                                    (xwidget-info nil))))
-                 '(wrong-type-argument xwidgetp nil)))
-  (should (equal (parallel-get-result
-                  (parallel-start (lambda ()
-                                    (require 'xwidget)
-                                    (xwidget-view-info nil))))
-                 '(wrong-type-argument xwidget-view-p nil))))
-
-(xwidget-deftest xwidget-view-p (Button ToggleButton slider socket cairo)
-  (should (parallel-get-result
-           (parallel-start (lambda (type title)
-                             (require 'xwidget)
-                             (with-temp-buffer
-                               (insert ?\0)
-                               (let* ((xwidget (xwidget-insert 1 type title 100 100))
-                                      (window (xwidget-display xwidget)))
-                                 (set-xwidget-query-on-exit-flag xwidget nil)
-                                 (xwidget-view-p
-                                  (xwidget-view-lookup xwidget window)))))
-                           :env (list type title)
-                           :graphical t
-                           :emacs-args '("-T" "emacs-debug")))))
-
-(defun xwidget-interactive-tests ()
-  "Interactively test Button ToggleButton and slider.
-
-Start Emacs instances and try to insert the xwidget."
-  (interactive)
-  (flet ((test-xwidget (type)
-                       (parallel-get-result
-                        (parallel-start (lambda ()
-                                          (require 'xwidget)
-                                          (with-temp-buffer
-                                            (insert ?\0)
-                                            (set-xwidget-query-on-exit-flag
-                                             (xwidget-insert 1 type (format "%s" type) 100 100) nil)
-                                            (display-buffer (current-buffer))
-                                            (cons type (or (y-or-n-p (format "Do you see a %s?" type)) 'failed))))
-                                        :graphical t
-                                        :debug t
-                                        :config xwidget-parallel-config))))
-    (message "%S" (mapcar #'test-xwidget '(Button ToggleButton slider)))))
-
-(provide 'xwidget-tests)
diff --git a/test/cedet/srecode-tests.el b/test/cedet/srecode-tests.el
index 423df72d5ac..f7529ecb5e3 100644
--- a/test/cedet/srecode-tests.el
+++ b/test/cedet/srecode-tests.el
@@ -272,7 +272,7 @@ Dump out the extracted dictionary."
               (not (semantic-tag-of-class-p fcn-in 'function)))
       (error "No tag of class 'function to insert comment for"))
 
-    (let ((lextok (semantic-documentation-comment-preceeding-tag fcn-in 'lex))
+    (let ((lextok (semantic-documentation-comment-preceding-tag fcn-in 'lex))
           )
 
       (when (not lextok)
diff --git a/test/indent/Makefile b/test/indent/Makefile
index 9e75f3dad57..83162681d72 100644
--- a/test/indent/Makefile
+++ b/test/indent/Makefile
@@ -1,14 +1,15 @@
 RM=rm
-EMACS=emacs
+EMACS=../../src/emacs
+
+all: clean $(addsuffix .test,$(wildcard *.*))
 
 clean:
-        -$(RM) *.test
+        -$(RM) -f *.new
 
 # TODO:
 # - mark the places where the indentation is known to be incorrect,
 #   and allow either ignoring those errors or not.
 %.test: %
-        -$(RM) $<.new
         $(EMACS) --batch $< \
             --eval '(indent-region (point-min) (point-max) nil)' \
             --eval '(write-region (point-min) (point-max) "$<.new")'
diff --git a/test/indent/js-indent-init-dynamic.js b/test/indent/js-indent-init-dynamic.js
new file mode 100644
index 00000000000..536a976e86e
--- /dev/null
+++ b/test/indent/js-indent-init-dynamic.js
@@ -0,0 +1,30 @@
+var foo = function() {
+  return 7;
+};
+
+var foo = function() {
+      return 7;
+    },
+    bar = 8;
+
+var foo = function() {
+      return 7;
+    },
+    bar = function() {
+      return 8;
+    };
+
+// Local Variables:
+// indent-tabs-mode: nil
+// js-indent-level: 2
+// js-indent-first-init: dynamic
+// End:
+
+// The following test intentionally produces a scan error and should
+// be placed below all other tests to prevent awkward indentation.
+// (It still thinks it's within the body of a function.)
+
+var foo = function() {
+  return 7;
+  ,
+  bar = 8;
diff --git a/test/indent/js-indent-init-t.js b/test/indent/js-indent-init-t.js
new file mode 100644
index 00000000000..bb755420ba7
--- /dev/null
+++ b/test/indent/js-indent-init-t.js
@@ -0,0 +1,21 @@
+var foo = function() {
+      return 7;
+    };
+
+var foo = function() {
+      return 7;
+    },
+    bar = 8;
+
+var foo = function() {
+      return 7;
+    },
+    bar = function() {
+      return 8;
+    };
+
+// Local Variables:
+// indent-tabs-mode: nil
+// js-indent-level: 2
+// js-indent-first-init: t
+// End:
diff --git a/test/indent/js.js b/test/indent/js.js
index 2d458e1b769..2120233259a 100644
--- a/test/indent/js.js
+++ b/test/indent/js.js
@@ -9,7 +9,7 @@ var e = 100500,
 
 function test ()
 {
-     return /[/]/.test ('/')     // (bug#19397)
+  return /[/]/.test ('/')     // (bug#19397)
 }
 
 var f = bar('/protocols/')
@@ -60,3 +60,16 @@ var evens = [e for each (e in range(0, 21))
 a++
 b +=
   c
+
+baz(`http://foo.bar/${tee}`)
+  .qux();
+
+`multiline string
+       contents
+  are kept
+        unchanged!`
+
+// Local Variables:
+// indent-tabs-mode: nil
+// js-indent-level: 2
+// End:
diff --git a/test/indent/ruby.rb b/test/indent/ruby.rb
index 82cc63f9168..dec6de98605 100644
--- a/test/indent/ruby.rb
+++ b/test/indent/ruby.rb
@@ -40,6 +40,10 @@ x = toto / foo if /do bar/ =~ "dobar"
 
 /foo/xi != %r{bar}mo.tee
 
+foo { /"tee/
+  bar { |qux| /'fee"/ }         # bug#20026
+}
+
 bar(class: XXX) do              # ruby-indent-keyword-label
   foo
 end
diff --git a/test/indent/sgml-mode-attribute.html b/test/indent/sgml-mode-attribute.html
new file mode 100644
index 00000000000..4cbec0af2c6
--- /dev/null
+++ b/test/indent/sgml-mode-attribute.html
@@ -0,0 +1,14 @@
+<element attribute="value"></element>
+
+<element
+    attribute="value">
+  <element
+      attribute="value">
+  </element>
+</element>
+
+<!--
+    Local Variables:
+    sgml-attribute-offset: 2
+    End:
+  -->
diff --git a/test/xwidget-test-manual.el b/test/xwidget-test-manual.el
deleted file mode 100644
index 3732dca4e93..00000000000
--- a/test/xwidget-test-manual.el
+++ /dev/null
@@ -1,204 +0,0 @@
-;;test like:
-;; cd /path/to/xwidgets-emacs-dir
-;; make   all&&  src/emacs -q --eval "(progn (load \"`pwd`/lisp/xwidget-test.el\") (xwidget-demo-basic))"
-
-
-;; you should see:
-;; - a gtk button
-;; - a gtk toggle button
-;; - a gtk slider button
-;; - an xembed window(using gtk_socket) showing another emacs instance
-;; - an xembed window(using gtk_socket) showing an uzbl web browser if its installed
-
-;;the widgets will move when you type in the buffer. good!
-
-;;there will be redrawing issues when widgets change rows, etc. bad!
-
-;;its currently difficult to give kbd focus to the xembedded emacs,
-;;but try evaling the following:
-
-;; (xwidget-set-keyboard-grab 3 1)
-
-
-
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; demo/test functions
-(require 'xwidget)
-
-(defmacro xwidget-demo (name &rest body)
-  `(defun ,(intern (concat "xwidget-demo-" name)) ()
-     (interactive)
-     (switch-to-buffer ,(format "*xwidget-demo-%s*" name))
-     (text-mode);;otherwise no local keymap
-     (insert "Some random text for xwidgets to be inserted in for demo purposes.\n")
-     ,@body))
-
-(xwidget-demo "a-button"
-              (xwidget-insert (point-min) 'Button  "button" 60  50)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-button-bidi"
-              (xwidget-insert (+ 5 (point-min)) 'Button  "button" 60  50)
-              (set (make-local-variable 'bidi-paragraph-direction) 'right-to-left)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-
-(xwidget-demo "a-toggle-button"
-              (xwidget-insert (point-min) 'ToggleButton  "toggle" 60  50)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-big-button"
-              (xwidget-insert (point-min)  'Button "button" 400  500)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-socket"
-              (xwidget-insert (point-min)  'socket "socket" 500  500)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-socket-osr-broken"
-              (xwidget-insert (point-min)  'socket-osr "socket-osr" 500  500)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-
-(xwidget-demo "a-slider"
-              (xwidget-insert (point-min)  'slider "slider" 500  100)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-canvas"
-              (xwidget-insert (point-min)  'cairo "canvas" 1000  1000)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-webkit-broken"
-              (xwidget-insert (point-min)  'webkit "webkit" 1000  1000)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-webkit-osr"
-              (xwidget-insert (point-min)  'webkit-osr "webkit-osr" 1000  1000)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic)
-              (xwidget-webkit-goto-uri (xwidget-at 1) "http://www.fsf.org"))
-
-(xwidget-demo "a-xwgir"
-              (xwidget-insert (point-min)  'xwgir "xwgir" 1000  1000)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-xwgir-color-button"
-              (xwgir-require-namespace "Gtk" "3.0")
-              (put 'ColorButton :xwgir-class '("Gtk" "ColorSelection"))
-              (xwidget-insert (point-min)  'ColorButton "xwgir-color-button" 1000  1000)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-xwgir-button"
-              (xwgir-require-namespace "Gtk" "3.0")
-              (put 'xwgirButton :xwgir-class '("Gtk" "Button"))
-
-              (xwidget-insert (point-min)  'xwgirButton "xwgir label didnt work..." 700  700)
-              (xwgir-xwidget-call-method (xwidget-at 1) "set_label" '( "xwgir label worked!"))
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-xwgir-check-button"
-              (xwgir-require-namespace "Gtk" "3.0")
-              (put 'xwgirCheckButton :xwgir-class '("Gtk" "CheckButton"))
-
-              (xwidget-insert (point-min)  'xwgirCheckButton "xwgir label didnt work..." 700  700)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-xwgir-hscale"
-              (xwgir-require-namespace "Gtk" "3.0")
-              (put 'xwgirHScale :xwgir-class '("Gtk" "HScale"))
-
-              (xwidget-insert (point-min)  'xwgirHScale "xwgir label didnt work..." 700  700)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-(xwidget-demo "a-xwgir-webkit"
-              (xwgir-require-namespace "WebKit" "3.0")
-              (put 'xwgirWebkit :xwgir-class '("WebKit" "WebView"))
-
-              (xwidget-insert (point-min)  'xwgirWebkit "xwgir webkit..." 700  700)
-              (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic))
-
-
-
-;; tentative testcase:
-;; (xwgir-require-namespace "WebKit" "3.0")
-
-;; (put 'webkit-osr :xwgir-class '("WebKit" "WebView"))
-;; (xwgir-call-method (xwidget-at 1) "set_zoom_level" '(3.0))
-
-;; (xwgir-require-namespace "Gtk" "3.0")
-;; (put 'color-selection :xwgir-class '("Gtk" "ColorSelection"))
-
-
-(xwidget-demo "basic"
-  (xwidget-insert (point-min)  'button "button" 40  50 )
-  (xwidget-insert          15  'toggle "toggle" 60  30  )
-  (xwidget-insert          30  'socket "emacs"  400 200 )
-  (xwidget-insert          20  'slider "slider" 100 50  )
-  (xwidget-insert          40  'socket "uzbl-core"   400 400 )
-  (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-basic)
-)
-
-
-;it doesnt seem gtk_socket_steal works very well. its deprecated.
-; xwininfo -int
-; then (xwidget-embed-steal 3 <winid>)
-(defun xwidget-demo-grab ()
-  (interactive)
-  (insert "0 <<< grabbed appp will appear here\n")
-  (xwidget-insert          1 1 3 "1" 1000 )
-  (define-key (current-local-map) [xwidget-event] 'xwidget-handler-demo-grab)
-  )
-
-;ive basically found these xembeddable things:
-;openvrml
-;emacs
-;mplayer
-;surf
-;uzbl
-
-;try the openvrml:
-;/usr/libexec/openvrml-xembed 0 ~/Desktop/HelloWorld.wrl
-
-(defun xwidget-handler-demo-basic ()
-  (interactive)
-  (message "stuff happened to xwidget %S" last-input-event)
-  (let*
-      ((xwidget-event-type (nth 1 last-input-event))
-       (xwidget (nth 2 last-input-event)))
-    (cond ( (eq xwidget-event-type 'xembed-ready)
-            (let*
-                ((xembed-id (nth 3 last-input-event)))
-              (message "xembed ready  event: %S xw-id:%s" xembed-id xwidget)
-              ;;will start emacs/uzbl in a xembed socket when its ready
-              (cond
-               (t;;(eq 3 xwidget)
-                (start-process "xembed" "*xembed*" "/var/lib/jenkins/jobs/emacs-xwidgets-automerge/workspace/src/emacs" "-q" "--parent-id" (number-to-string xembed-id) ) )
-;;               ((eq 5 xwidget-id)
-;;                (start-process "xembed2" "*xembed2*" "uzbl-core"  "-s" (number-to-string xembed-id)  "http://www.fsf.org" )
-               )
-
-               )
-            ))))
-
-
-
-(defun xwidget-handler-demo-grab ()
-  (interactive)
-  (message "stuff happened to xwidget %S" last-input-event)
-  (let*
-      ((xwidget-event-type (nth 2 last-input-event)))
-    (cond ( (eq xwidget-event-type 'xembed-ready)
-            (let*
-                ((xembed-id (nth 3 last-input-event)))
-              (message "xembed ready  %S" xembed-id)
-              )
-            ))))
-(defun xwidget-dummy-hook ()
-  (message "xwidget dummy hook called"))
-
-;  (xwidget-resize-hack 1 200 200)
-
-;(xwidget-demo-basic)
-
-(provide 'xwidget-test-manual)