;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:03 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\307\310\311\312\313\314\315\316&\210\317\320\321\322\315\310%\210\317\323\324\325\315\310%\207" [require button debug easymenu ewoc find-func help custom-declare-group ert nil "ERT, the Emacs Lisp regression testing tool." :prefix "ert-" :group lisp custom-declare-face ert-test-result-expected ((((class color) (background light)) :background "green1") (((class color) (background dark)) :background "green3")) "Face used for expected results in the ERT results buffer." ert-test-result-unexpected ((((class color) (background light)) :background "red1") (((class color) (background dark)) :background "red3")) "Face used for unexpected results in the ERT results buffer."] 8)
#@54 Copy of `cl-do-remf'.  Modify PLIST by removing TAG.
(defalias 'ert--cl-do-remf #[(plist tag) "A\211A\203	A@\n=\204	AA\211\202	A\205%	\211AAA\241\210\303)\207" [plist p tag t] 3 (#$ . 1327)])
#@60 Copy of `cl-remprop'.  Modify SYM's plist by removing TAG.
(defalias 'ert--remprop #[(sym tag) "\303!\211\203\n	@=\203\304	AA\"\210\305\202\306	\n\")\207" [sym plist tag symbol-plist setplist t ert--cl-do-remf] 4 (#$ . 1535)])
#@94 A reimplementation of `remove-if-not'.

ERT-PRED is a predicate, ERT-LIST is the input list.
(defalias 'ert--remove-if-not #[(ert-pred ert-list) "\305\211	:\203	@\f\n!\203\nB	A\211\202\237+\207" [ert-list #1=#:--cl-var-- ert-x #2=#:--cl-var-- ert-pred nil] 3 (#$ . 1777)])
#@104 A reimplementation of `intersection'.  Intersect the sets A and B.

Elements are compared using `eql'.
(defalias 'ert--intersection #[(a b) "\305\211	:\203 	@\306\n\f\"\203\nB	A\211\202\237+\207" [a #1=#:--cl-var-- x #2=#:--cl-var-- b nil memql] 4 (#$ . 2072)])
#@113 A reimplementation of `set-difference'.  Subtract the set B from the set A.

Elements are compared using `eql'.
(defalias 'ert--set-difference #[(a b) "\305\211	:\203 	@\306\n\f\"\204\nB	A\211\202\237+\207" [a #1=#:--cl-var-- x #2=#:--cl-var-- b nil memql] 4 (#$ . 2355)])
#@112 A reimplementation of `set-difference'.  Subtract the set B from the set A.

Elements are compared using `eq'.
(defalias 'ert--set-difference-eq #[(a b) "\305\211	:\203	@\211\f>\204\nB	A\211\202\237+\207" [a #1=#:--cl-var-- x #2=#:--cl-var-- b nil] 3 (#$ . 2649)])
#@108 A reimplementation of `union'.  Compute the union of the sets A and B.

Elements are compared using `eql'.
(defalias 'ert--union #[(a b) "\302\303	\"\"\207" [a b append ert--set-difference] 5 (#$ . 2936)])
(defvar ert--gensym-counter 0)
#@52 Only allows string PREFIX, not compatible with CL.
(defalias 'ert--gensym #[(&optional prefix) "\204\302\303\304\305	\211T#!\207" [prefix ert--gensym-counter "G" make-symbol format "%s%s"] 6 (#$ . 3181)])
#@23 Coerce X to a vector.
(defalias 'ert--coerce-to-vector #[(x) "\301!\203\n\302\303!\210\304!\203\207\305!\207" [x char-table-p error "Not supported" vectorp vconcat] 2 (#$ . 3398)])
#@74 Does not support all the keywords of remove*.

(fn X LIST &key KEY TEST)
(defalias 'ert--remove* #[(x list &rest #1=#:--cl-rest--) "\306>A@\307>A@\2038@\310>\203!AA\211\202\311>A@\203/\312\211\202\313\314@\"\210\202)	\204?\315\n\204E\316\f\312\211
:\203o
@\n	!\"\204hB
A\211\202N\237-\207" [#1# key test #2=#:--cl-keys-- list #3=#:--cl-var-- :key :test (:key :test :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:key :test)" identity eql y #4=#:--cl-var-- x] 5 (#$ . 3592)])
#@72 Return the position of the first occurrence of C in S, or nil if none.
(defalias 'ert--string-position #[(c s) "\306	\307\310\311\310T\211\nGW\2036\nH\312\f\f\"\203,\310\211\202-\311\2036T\202
.\207" [i s #1=#:--cl-vec-- #2=#:--cl-idx-- x #3=#:--cl-var-- 0 -1 nil t eql #4=#:--cl-var-- c] 3 (#$ . 4155)])
#@109 Return index of first element that differs between A and B.

Like `mismatch'.  Uses `equal' for comparison.
(defalias 'ert--mismatch #[(a b) "<\204\n	<\203\306\307!\307	!\"\207G	GV\203 \306	\"\207G	G\310!\2043\311\312\313D\"\210\310	!\204@\311\312\314	D\"\210\nX\204N\311\312\315\nE\"\210\316\317\320\f
W\203}\fH	\fH\232\204r\f\320\211\202s\317\203}\fT\211\202Y\203\236\nU\204\214\202\240	\232\204\232\311\312\321	E\"\210\320\202\240.\207" [a b lb la i #1=#:--cl-var-- ert--mismatch ert--coerce-to-vector arrayp signal cl-assertion-failed (arrayp a) (arrayp b) (<= la lb) 0 t nil (equal a b) #2=#:--cl-var-- #3=#:--cl-var--] 6 (#$ . 4493)])
#@48 Return a subsequence of SEQ from START to END.
(defalias 'ert--subseq #[(seq start &optional end) "\306!\203\n\307\310!\210\311!	\nO\312!\203\202\200;\203&\260
\202\200<\2032\313\314\"\202\200\315!\203g\316G\314\"\317G
W\203b\f

HI\210*
T\211\202E\f+\202\200\306!\203w\320\321\314C\"\210\314\202\200\307\322\323#\205\200\314)\207" [seq start end vector result i char-table-p error "Not supported" ert--coerce-to-vector vectorp append nil bool-vector-p make-bool-vector 0 signal cl-assertion-failed "cl-etypecase failed: %s, %s" (vector string list bool-vector char-table) #1=#:--cl-var-- #2=#:v #3=#:v] 5 (#$ . 5190)])
#@375 Return t if A and B have similar structure and contents.

This is like `equal-including-properties' except that it compares
the property values of text properties structurally (by
recursing) rather than with `eq'.  Perhaps this is what
`equal-including-properties' should do in the first place; see
Emacs bug 6581 at URL `http://debbugs.gnu.org/cgi/bugreport.cgi?bug=6581'.
(defalias 'ert-equal-including-properties #[(a b) "\302	\"?\207" [a b ert--explain-equal-including-properties] 3 (#$ . 5861)])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-name compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-name (or (and (memq (aref cl-x 0) cl-struct-ert-test-tags)) (error "%s accessing a non-%s" 'ert-test-name 'ert-test)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-name #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-tags 0 error "%s accessing a non-%s" ert-test-name ert-test 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-documentation compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-documentation (or (and (memq (aref cl-x 0) cl-struct-ert-test-tags)) (error "%s accessing a non-%s" 'ert-test-documentation 'ert-test)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-documentation #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-tags 0 error "%s accessing a non-%s" ert-test-documentation ert-test 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-body compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-body (or (and (memq (aref cl-x 0) cl-struct-ert-test-tags)) (error "%s accessing a non-%s" 'ert-test-body 'ert-test)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-body #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-tags 0 error "%s accessing a non-%s" ert-test-body ert-test 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-most-recent-result compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-most-recent-result (or (and (memq (aref cl-x 0) cl-struct-ert-test-tags)) (error "%s accessing a non-%s" 'ert-test-most-recent-result 'ert-test)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-most-recent-result #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-tags 0 error "%s accessing a non-%s" ert-test-most-recent-result ert-test 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-expected-result-type compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-expected-result-type (or (and (memq (aref cl-x 0) cl-struct-ert-test-tags)) (error "%s accessing a non-%s" 'ert-test-expected-result-type 'ert-test)) (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-expected-result-type #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-tags 0 error "%s accessing a non-%s" ert-test-expected-result-type ert-test 5] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-tags compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-tags (or (and (memq (aref cl-x 0) cl-struct-ert-test-tags)) (error "%s accessing a non-%s" 'ert-test-tags 'ert-test)) (aref cl-x 6)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-tags #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-tags 0 error "%s accessing a non-%s" ert-test-tags ert-test 6] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-p (and (vectorp cl-x) (>= (length cl-x) 7) (memq (aref cl-x 0) cl-struct-ert-test-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert-test-tags vectorp 7 0 t] 2])
(defalias 'copy-ert-test #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert-test compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311A@\312>A@\313>\206#\314A@\315>\206-\316A@\203d@\317>\203KAA\211\2026\320>A@\203Z\321\211\2026\322\323@\"\210\2024)\324\325\326\321\321	\n\f
&.\207" [#1# name documentation body most-recent-result expected-result-type :name :documentation :body (nil (assert nil)) :most-recent-result :expected-result-type (nil ':passed) :tags (nil 'nil) (:name :documentation :body :most-recent-result :expected-result-type :tags :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :documentation :body :most-recent-result :expected-result-type :tags)" cl--defsubst-expand (name documentation body most-recent-result expected-result-type tags) (cl-block make-ert-test (vector 'cl-struct-ert-test name documentation body most-recent-result expected-result-type tags)) tags #:--cl-keys-- cl-whole] 13 "\n\n(fn CL-WHOLE &cl-quote &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@82 

(fn &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS)
(defalias 'make-ert-test #[(&rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311\312\313\311C\"\210\311DA@\314>A@\315>\206+\316A@\317>\2065\320A@\203l@\321>\203SAA\211\202>\322>A@\203b\311\211\202>\323\324@\"\210\202<)\325\326	\n\f
&.\207" [#1# name documentation body most-recent-result expected-result-type :name :documentation :body nil signal cl-assertion-failed :most-recent-result :expected-result-type (nil :passed) :tags (nil nil) (:name :documentation :body :most-recent-result :expected-result-type :tags :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:name :documentation :body :most-recent-result :expected-result-type :tags)" vector cl-struct-ert-test tags #2=#:--cl-keys--] 9 (#$ . 12381)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\313#\210\302\314\315\313#\210\302\316\315\317#\210\302\320\315\313#\210\302\321\315\313#\210\302\322\315\313#\210\302\323\315\313#\210\302\324\315\313#\210\302\325\315\313#\207" [cl-struct-ert-test-tags cl-struct-ert-test put ert-test cl-struct-slots ((cl-tag-slot) (name nil) (documentation nil) (body (assert nil)) (most-recent-result nil) (expected-result-type ':passed) (tags 'nil)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print t copy-ert-test side-effect-free ert-test-p error-free ert-test-tags ert-test-expected-result-type ert-test-most-recent-result ert-test-body ert-test-documentation ert-test-name] 4)
#@40 Return non-nil if SYMBOL names a test.
(defalias 'ert-test-boundp #[(symbol) "\301N\205\302\207" [symbol ert--test t] 2 (#$ . 13975)])
#@66 If SYMBOL names a test, return that.  Signal an error otherwise.
(defalias 'ert-get-test #[(symbol) "\301!\204\302\303\"\210\304N\207" [symbol ert-test-boundp error "No test named `%S'" ert--test] 3 (#$ . 14119)])
#@62 Make SYMBOL name the test DEFINITION, and return DEFINITION.
(defalias 'ert-set-test #[(symbol definition) "\302=\203\n\303\304!\210\305\306	#\210	\207" [symbol definition nil error "Attempt to define a test named nil" put ert--test] 4 (#$ . 14344)])
#@43 Make SYMBOL name no test.  Return SYMBOL.
(defalias 'ert-make-test-unbound #[(symbol) "\301\302\"\210\207" [symbol ert--remprop ert--test] 3 (#$ . 14604)])
#@357 Split KEYS-AND-BODY into keyword-and-value pairs and the remaining body.

KEYS-AND-BODY should have the form of a property list, with the
exception that only keywords are permitted as keys and that the
tail -- the body -- is a list of forms that does not start with a
keyword.

Returns a two-element list containing the keys-and-values plist
and the body.
(defalias 'ert--parse-keys-and-body #[(keys-and-body) "\306	:\203<\307	@!\203<	\211A@	:\204!\310\311#\210\312\n\"\203.\313\314#\210	\211A@B\nB)\202\n\237\211\306\211
\306\f:\203k\f@\211\211A@\211
B
B\fA\211\202J\237,	*D\207" [keys-and-body remaining extracted-key-accu keyword #1=#:--cl-var-- value nil keywordp error "Value expected after keyword %S in %S" assoc warn "Keyword %S appears more than once in %S" key #2=#:--cl-var--] 5 (#$ . 14769)])
#@525 Define NAME (a symbol) as a test.

BODY is evaluated as a `progn' when the test is run.  It should
signal a condition on failure or just return if the test passes.

`should', `should-not' and `should-error' are useful for
assertions in BODY.

Use `ert' to run tests interactively.

Tests that are expected to fail can be marked as such
using :expected-result.  See `ert-test-result-type-p' for a
description of valid values for RESULT-TYPE.

(fn NAME () [DOCSTRING] [:expected-result RESULT-TYPE] [:tags '(TAG...)] BODY...)
(defalias 'ert-deftest '(macro . #[(name &rest docstring-keys-and-body) "\203\f\211A@\202\306\307\310GD\"\211\203\"\306\307\310	G\311\\D\"\210\312\211@;\2034\211A@\313\314!\211G\315U\203G\f\211A@\202N\306\307\312\fGD\"\316
>\211 \205_ A@\313 !\317
>\211\"\205q\"A@\313\"#\f@$
%%\203\252%@\320>\203\221%AA\211%\202|\321
>A@\203\240\312\211%\202|\322\323%@\"\210\202z)\324\325\326&D\327\330\326&D\331\n\205\277\332D \205\310\333!D\"\205\321\317#D\334\335\312$BBD$BBBE\336\326\310&BD\337BB\326&DF.\n\207" [docstring-keys-and-body #1=#:--cl-rest-- documentation-supplied-p documentation #2=#:--cl-rest-- #3=#:--cl-rest-- signal wrong-number-of-arguments ert-deftest 0 nil t ert--parse-keys-and-body 2 :expected-result :tags (:expected-result :tags :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:expected-result :tags)" progn ert-set-test quote make-ert-test :name append :documentation :expected-result-type :body lambda push (current-load-list) expected-result-supplied-p expected-result tags-supplied-p tags body #4=#:--cl-keys-- name] 15 (#$ . 15622)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\307#\210\300\301\306\307#\210\300\310\306\311#\207" [put ert-deftest edebug-form-spec (&define :name test name sexp [&optional stringp] [&rest keywordp sexp] def-body) doc-string-elt 3 lisp-indent-function 2 ert-info 1] 4)
#@77 The regexp the `find-function' mechanisms use for finding test definitions.
(defvar ert--find-test-regexp (concat "^\\s-*(ert-deftest" find-function-space-re "%s\\(\\s-\\|$\\)") (#$ . 17585))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put ert-test-failed error-conditions (error ert-test-failed) error-message "Test failed"] 4)
#@66 Terminate the current test and mark it passed.  Does not return.
(defalias 'ert-pass #[nil "\300\301\302\"\207" [throw ert--pass nil] 3 (#$ . 17933)])
#@140 Terminate the current test and mark it failed.  Does not return.
DATA is displayed to the user and should state the reason of the failure.
(defalias 'ert-fail #[(data) "\301\302C\"\207" [data signal ert-test-failed] 3 (#$ . 18091)])
(defvar ert--should-execution-observer nil)
#@74 Tell the current `should' form observer (if any) about FORM-DESCRIPTION.
(defalias 'ert--signal-should-execution #[(form-description) "\205	!\207" [ert--should-execution-observer form-description] 2 (#$ . 18375)])
#@64 Return non-nil if THING is a symbol naming a special operator.
(defalias 'ert--special-operator-p #[(thing) "9\205\302\303\"\304	!\205\305\306	!A\307\")\207" [thing definition indirect-function t subrp eql subr-arity unevalled] 3 (#$ . 18599)])
#@58 Helper function for the `should' macro and its variants.
(defalias 'ert--expand-should-1 #[(whole form inner-expander) "\306\307\301!\203\f	\202\307\302!\205\n\"\211:\203!\310@!\203C\311\312!\313\314BC\f\315E\316\317
D\320\317D\321\257#F)\202\356@A(\211)9\204l):\203f\322)@\323\"\203f)A<\204l\324\325\326C\"\210\311\327!\311\330!\311\312!\311\331!*+,\313,\332)DD+\316(BDD\313\317*DDC\f\315\333,+EE\334\316\317
DD\316\320\335\336,CB\337+CBDCBE\340\322\317*DE\316\321EE\313\341\342\343\317)DD\344\317)D\345BBEDC\346\341\316\347\333\341+EEEE\257#FE.)\207" [form macroexpand-all-environment cl-macro-environment value inner-expander whole macroexpand boundp ert--special-operator-p ert--gensym "value-" let ((ert--gensym "ert-form-evaluation-aborted-")) setq list quote :form :value eql lambda signal cl-assertion-failed (or (symbolp fn-name) (and (consp fn-name) (eql (car fn-name) 'lambda) (listp (cdr fn-name)))) "fn-" "args-" "ert-form-evaluation-aborted-" function apply nconc \` \, \,@ unless -explainer- and symbolp get ('ert-explainer) when :explanation arg-forms fn-name default-value args fn] 20 (#$ . 18857)])
#@688 Helper function for the `should' macro and its variants.

Analyzes FORM and returns an expression that has the same
semantics under evaluation but records additional debugging
information.

INNER-EXPANDER should be a function and is called with two
arguments: INNER-FORM and FORM-DESCRIPTION-FORM, where INNER-FORM
is an expression equivalent to FORM, and FORM-DESCRIPTION-FORM is
an expression that returns a description of FORM.  INNER-EXPANDER
should return code that calls INNER-FORM and performs the checks
and error signaling specific to the particular variant of
`should'.  The code that INNER-EXPANDER returns must not call
FORM-DESCRIPTION-FORM before it has called INNER-FORM.
(defalias 'ert--expand-should #[(whole form inner-expander) "\305\306!\211\211\nL\210)\307\f\310\311\312\313\314D\313D\315FE#)\207" [#1=#:--cl-inner-expander-- #2=#:v inner-expander whole form make-symbol "--inner-expander--" ert--expand-should-1 lambda (&rest --cl-rest--) apply quote #[(#3=#:G12600 inner-form form-description-form value-var) "\305\306!\307C	J\310\n\311E\312DF\f#E)\207" [form-description #3# inner-form form-description-form value-var ert--gensym "form-description-" let unwind-protect setq ert--signal-should-execution] 8] --cl-rest--] 10 (#$ . 20037)])
#@98 Evaluate FORM.  If it returns nil, abort the current test as failed.

Returns the value of FORM.
(defalias 'should '(macro . #[(form) "\301\302D\303#\207" [form ert--expand-should should #[(inner-form form-description-form value-var) "\302\303	DE\207" [inner-form form-description-form unless ert-fail] 4]] 4 (#$ . 21315)]))
#@88 Evaluate FORM.  If it returns non-nil, abort the current test as failed.

Returns nil.
(defalias 'should-not '(macro . #[(form) "\301\302D\303#\207" [form ert--expand-should should-not #[(inner-form form-description-form value-var) "\302\303D\304	DE\207" [inner-form form-description-form unless not ert-fail] 4]] 4 (#$ . 21649)]))
#@155 Helper function for `should-error'.

Determines whether CONDITION matches TYPE and EXCLUDE-SUBTYPES,
and aborts the current test as failed if it doesn't.
(defalias 'ert--should-error-handle-error #[(form-description-fn condition type exclude-subtypes) "@\306N	<\203
	\202 	9\203	C\202 \307\310	\311#\205 \312\211\204,\313\314\303C\"\210\315\n\"\204?\316\317\f \320\321\322F\"!\210
\205V@\n\235?\205V\316\317\f \320\321\323F\"!*\207" [condition type handled-conditions signaled-conditions form-description-fn exclude-subtypes error-conditions error "cl-etypecase failed: %s, %s" (list symbol) nil signal cl-assertion-failed ert--intersection ert-fail append :condition :fail-reason "the error signaled did not have the expected type" "the error signaled was a subtype of the expected type"] 8 (#$ . 21991)])
#@607 Evaluate FORM and check that it signals an error.

The error signaled needs to match TYPE.  TYPE should be a list
of condition names.  (It can also be a non-nil symbol, which is
equivalent to a singleton list containing that symbol.)  If
EXCLUDE-SUBTYPES is nil, the error matches TYPE if one of its
condition names is an element of TYPE.  If EXCLUDE-SUBTYPES is
non-nil, the error matches TYPE if it is an element of TYPE.

If the error matches, returns (ERROR-SYMBOL . DATA) from the
error.  If not, or if no error was signaled, abort the test as
failed.

(fn FORM &rest KEYS &key TYPE EXCLUDE-SUBTYPES)
(defalias 'should-error '(macro . #[(form &rest keys) "\305>A@\306>A@\2038@\307>\203!AA\211\202\310>A@\203/\311\211\202\312\313@\"\210\202)	\204?\314\315\316\fBB\f\317#*\207" [keys type exclude-subtypes #1=#:--cl-keys-- form :type :exclude-subtypes (:type :exclude-subtypes :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:type :exclude-subtypes)" 'error ert--expand-should should-error #[(inner-form form-description-form value-var) "\306\307!\306\310!\311	\312B\313\314\nEDD\315\316\317\320	\321BB\322\316\f
\257\320\323BBFF\324	\325\326\327D\330BBDEF*\207" [form-description-fn errorp form-description-form inner-form type exclude-subtypes ert--gensym "errorp" "form-description-fn-" let (nil) lambda nil condition-case -condition- error setq (t) ert--should-error-handle-error (-condition-) unless ert-fail append funcall ((list :fail-reason "did not signal an error")) value-var] 12]] 5 (#$ . 22822)]))
#@54 Return non-nil if X is a proper list, nil otherwise.
(defalias 'ert--proper-list-p #[(x) "\300\301\215\207" [--cl-block-nil-- (byte-code "\305\211\305\306\211\205
\306\203\f\202	\211AA)\203%\f\202'\nA	\2041\307\310\306\"\210	:\204;\307\310\305\"\210	A\204E\307\310\306\"\210	A:\204P\307\310\305\"\210\204_	\n=\203_\307\310\305\"\210\305\211\202	" [firstp fast slow #1=#:--cl-var-- x nil t throw --cl-block-nil--] 4)] 2 (#$ . 24408)])
#@45 Format the atom X for `ert--explain-equal'.
(defalias 'ert--explain-format-atom #[(x) "\250\203\301\302\"\301\303\"E\207\207" [x format "#x%x" "?%c"] 5 (#$ . 24874)])
#@99 Return a programmer-readable explanation of why A and B are not `equal'.
Returns nil if they are.
(defalias 'ert--explain-equal-rec #[(a b) "\306!\306	!\232\204\307	E\207:\203\204\310!\310	!\311?\n?\"\204,\312	E\202\202\203OG	G\232\204I\313G	G	\314\315	\"\257\202\202\316\317\215\202\202\320@	@\"\211\203`\321\fD\202\201\320A	A\"\211\203q\322
D\202\200	\232\204\323\324\325	E\"\210\326))*\207\327!\203\260G	G\232\204\254\330G	G	\331!?\205\246\314\315	\"DBBBBB\207\316\332\215\207:\204\332	\232?\205\3439\203\321	9\203\321	\230\203\321\333	E\207\334\335!\335	!E\207\336\337\340#\205\343\326\207" [a b b-proper-p a-proper-p car-x cdr-x type-of different-types ert--proper-list-p eql one-list-proper-one-improper proper-lists-of-different-length first-mismatch-at ert--mismatch --cl-block-nil-- (byte-code "\306	\307\f\307\211\n:\203?\n@
:\203?
@\310\"\211\2033\311\312\313E\"\210T\nA
A\202	\f\232\204M\314\315\316	\fE\"\210.\307\207" [i a #1=#:--cl-var-- ai b #2=#:--cl-var-- 0 nil ert--explain-equal-rec throw --cl-block-nil-- list-elt signal cl-assertion-failed (equal a b) bi xi] 6) ert--explain-equal-rec car cdr signal cl-assertion-failed (equal a b) nil arrayp arrays-of-different-length char-table-p (byte-code "\306	\307\310
\307\310\211T\211\nGW\203P\nHT\211GW\203PH\311\f\"\211\203J\312\313\314E\"\210T\202	
\232\204^\315\316\317	
E\"\210.\310\207" [i a #3=#:--cl-vec-- #4=#:--cl-idx-- ai b 0 -1 nil ert--explain-equal-rec throw --cl-block-nil-- array-elt signal cl-assertion-failed (equal a b) #5=#:--cl-vec-- #6=#:--cl-idx-- bi xi] 6) different-symbols-with-the-same-name different-atoms ert--explain-format-atom error "cl-etypecase failed: %s, %s" (cons array atom)] 10 (#$ . 25054)])
#@33 Explainer function for `equal'.
(defalias 'ert--explain-equal #[(a b) "	\232?\205\302	\"\207" [a b ert--explain-equal-rec] 3 (#$ . 26887)])
(put 'equal 'ert-explainer 'ert--explain-equal)
#@63 Return the keys of PLIST that have non-null values, in order.
(defalias 'ert--significant-plist-keys #[(plist) "\306\307G\310\"!\204\311\312\313\307G\310\"D\"\210\314\211\314\211	:\203M	\211\211A@\n\211A@\211\203A
>\204A
C\244	\211
AA)\211\202 
-\207" [plist #1=#:--cl-var-- rest key value accu zerop mod 2 signal cl-assertion-failed (zerop (mod (length plist) 2)) nil x] 7 (#$ . 27085)])
#@256 Return a programmer-readable explanation of why A and B are different plists.

Returns nil if they are equivalent, i.e., have the same value for
each key, where absent values are treated as nil.  The order of
key/value pairs in each list does not matter.
(defalias 'ert--plist-difference-explanation #[(a b) "\306\307G\310\"!\204\311\312\313\307G\310\"D\"\210\306\307	G\310\"!\204*\311\312\314\307	G\310\"D\"\210\315!\315	!\316\n\"\316\n\"\317\320\321!\203J\321K\202K\322\323\216\322=\203]\324\321!\210\202b\321M\210\f\203m\321\f@!\202\272
\203x\321
@!\202\272\n\325\326\325:\203\267@\327\"\327	\"\232\204\252\321!\325\211\202\253\326\203\267A\211\202\206,.\207" [a b keys-a keys-b keys-in-a-not-in-b keys-in-b-not-in-a zerop mod 2 signal cl-assertion-failed (zerop (mod (length a) 2)) (zerop (mod (length b) 2)) ert--significant-plist-keys ert--set-difference-eq #[(key) "\305	\"\305\n	\"\211\232\203\306\307\310\f\232D\"\210\311	\312\f\"E*\207" [a key b value-b value-a plist-get signal cl-assertion-failed (not (equal value-a value-b)) different-properties-for-key ert--explain-equal-including-properties] 6] fboundp explain-with-key cl--unbound ((byte-code "\301=\203
\302\303!\210\202\303M\210\301\207" [#1=#:old cl--unbound fmakunbound explain-with-key] 2)) fmakunbound nil t plist-get #2=#:vnew #1# #3=#:--cl-var-- key #4=#:--cl-var-- #5=#:--cl-var--] 7 (#$ . 27505)])
#@107 Shorten string S to at most LEN chars.

If SUFFIXP is non-nil, returns a suffix of S, otherwise a prefix.
(defalias 'ert--abbreviate-string #[(s len suffixp) "G\211\nW\203
\202\203	\nZ\304O\202\305\nO)\207" [s n len suffixp nil 0] 4 (#$ . 28966)])
#@178 Explainer function for `ert-equal-including-properties'.

Returns a programmer-readable explanation of why A and B are not
`ert-equal-including-properties', or nil if they are.
(defalias 'ert--explain-equal-including-properties #[(a b) "	\232\204\302	\"\207;\204\303\304\305D\"\210	;\204#\303\304\306	D\"\210\307G	G\"\2046\303\304\310G	GE\"\210\311\312\215\207" [a b ert--explain-equal signal cl-assertion-failed (stringp a) (stringp b) eql (eql (length a) (length b)) --cl-block-nil-- (byte-code "\306	G\307\211\307\nX\203O\310	\"\310\"\311\f\"\211\203H\312\313\314\315	\211T#
\316\317\315	\306#\320\321#\322\317\315	T\"\320\307#\257\"\210T\211\202\f-\307\207" [i a #1=#:--cl-var-- props-a props-b difference 0 nil text-properties-at ert--plist-difference-explanation throw --cl-block-nil-- char substring-no-properties context-before ert--abbreviate-string 10 t context-after b] 14)] 5 (#$ . 29234)])
(put 'ert-equal-including-properties 'ert-explainer 'ert--explain-equal-including-properties)
#@118 The stack of `ert-info' infos that currently apply.

Bound dynamically.  This is a list of (PREFIX . MESSAGE) pairs.
(defvar ert--infos nil (#$ . 30274))
#@390 Evaluate MESSAGE-FORM and BODY, and report the message if BODY fails.

To be used within ERT tests.  MESSAGE-FORM should evaluate to a
string that will be displayed together with the test result if
the test fails.  PREFIX-FORM should evaluate to a string as well
and is displayed in front of the value of MESSAGE-FORM.

(fn (MESSAGE-FORM &key ((:prefix PREFIX-FORM) "Info: ")) &body BODY)
(defalias 'ert-info '(macro . #[(&rest body) "\203\f\211A@\202\305\306\307GD\"\211\203 	\211A@\202'\305\306\307	GD\"\310	>\206/\311A@	\f\203^\f@\312>\203G\fAA\211\2025\313	>A@\203U\314\211\2025\315\316\f@\"\210\2024)\317\320\321\211\nE\322BBDC+BB\207" [body #1=#:--cl-rest-- message-form prefix-form #2=#:--cl-keys-- signal wrong-number-of-arguments ert-info :prefix (nil "Info: ") (:prefix :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:prefix)" let ert--infos cons (ert--infos)] 7 (#$ . 30435)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put ert-info edebug-form-spec ((form &rest [sexp form]) body) lisp-indent-function 1] 4)
#@77 Non-nil means enter debugger when a test fails or terminates with an error.
(defvar ert-debug-on-error nil (#$ . 31534))
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-messages compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-messages (or (and (memq (aref cl-x 0) cl-struct-ert-test-result-tags)) (error "%s accessing a non-%s" 'ert-test-result-messages 'ert-test-result)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-messages #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-result-tags 0 error "%s accessing a non-%s" ert-test-result-messages ert-test-result 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-should-forms compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-should-forms (or (and (memq (aref cl-x 0) cl-struct-ert-test-result-tags)) (error "%s accessing a non-%s" 'ert-test-result-should-forms 'ert-test-result)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-should-forms #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-result-tags 0 error "%s accessing a non-%s" ert-test-result-should-forms ert-test-result 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-p (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-ert-test-result-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert-test-result-tags vectorp 3 0 t] 2])
(defalias 'copy-ert-test-result #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert-test-result compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\305>A@\306>A@\2038@\307>\203!AA\211\202\310>A@\203/\311\211\202\312\313@\"\210\202)\314\315\316\311\f\311	\n&*\207" [#1# messages should-forms #:--cl-keys-- cl-whole :messages :should-forms (:messages :should-forms :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms)" cl--defsubst-expand (messages should-forms) (cl-block make-ert-test-result (vector 'cl-struct-ert-test-result messages should-forms))] 9 "\n\n(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@35 

(fn &key MESSAGES SHOULD-FORMS)
(defalias 'make-ert-test-result #[(&rest #1=#:--cl-rest--) "\304>A@\305>A@\2038@\306>\203!AA\211\202\307>A@\203/\310\211\202\311\312@\"\210\202)\313\314	\n#*\207" [#1# messages should-forms #2=#:--cl-keys-- :messages :should-forms (:messages :should-forms :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms)" vector cl-struct-ert-test-result] 5 (#$ . 34643)])
(byte-code "\302C\303\304\305\306#\210\303\304\307\310#\210\303\304\311\312#\210\303\304\313\314#\210\303\315\316\314#\210\303\317\316\314#\210\303\320\316\321#\210\303\322\316\314#\210\303\323\316\314#\210\324\325\"\203E\210\202I\325B\303\326\327\330#\210\331\303\326\332\333\334	!!#\210)\312\207" [cl-struct-ert-test-result-tags file cl-struct-ert-test-result put ert-test-result cl-struct-slots ((cl-tag-slot) (messages nil) (should-forms nil)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print t make-ert-test-result side-effect-free copy-ert-test-result ert-test-result-p error-free ert-test-result-should-forms ert-test-result-messages memql cl-struct-ert-test-passed ert-test-passed-messages compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-passed-messages (or (and (memq (aref cl-x 0) cl-struct-ert-test-passed-tags)) (error "%s accessing a non-%s" 'ert-test-passed-messages 'ert-test-passed)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-passed-messages #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-passed-tags 0 error "%s accessing a non-%s" ert-test-passed-messages ert-test-passed 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-passed-should-forms compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-passed-should-forms (or (and (memq (aref cl-x 0) cl-struct-ert-test-passed-tags)) (error "%s accessing a non-%s" 'ert-test-passed-should-forms 'ert-test-passed)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-passed-should-forms #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-passed-tags 0 error "%s accessing a non-%s" ert-test-passed-should-forms ert-test-passed 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-passed-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-passed-p (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-ert-test-passed-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-passed-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert-test-passed-tags vectorp 3 0 t] 2])
(defalias 'copy-ert-test-passed #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert-test-passed compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\305>A@\306>A@\2038@\307>\203!AA\211\202\310>A@\203/\311\211\202\312\313@\"\210\202)\314\315\316\311\f\311	\n&*\207" [#1# messages should-forms #:--cl-keys-- cl-whole :messages :should-forms (:messages :should-forms :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms)" cl--defsubst-expand (messages should-forms) (cl-block make-ert-test-passed (vector 'cl-struct-ert-test-passed messages should-forms))] 9 "\n\n(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@35 

(fn &key MESSAGES SHOULD-FORMS)
(defalias 'make-ert-test-passed #[(&rest #1=#:--cl-rest--) "\304>A@\305>A@\2038@\306>\203!AA\211\202\307>A@\203/\310\211\202\311\312@\"\210\202)\313\314	\n#*\207" [#1# messages should-forms #2=#:--cl-keys-- :messages :should-forms (:messages :should-forms :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms)" vector cl-struct-ert-test-passed] 5 (#$ . 38711)])
(byte-code "\303C\304\305\306\307#\210\304\305\310\311#\210\304\305\312\313#\210\304\305\314\315#\210\304\316\317\315#\210\304\320\317\315#\210\304\321\317\322#\210\304\323\317\315#\210\304\324\317\315#\210\325\326	\"\203E	\210\202I\326	B\304\327\330\331#\210\332\304\327\333\334\335\n!!#\210)\303\207" [cl-struct-ert-test-passed-tags cl-struct-ert-test-result-tags file cl-struct-ert-test-passed put ert-test-passed cl-struct-slots ((cl-tag-slot) (messages nil) (should-forms nil)) cl-struct-type (vector nil) cl-struct-include ert-test-result cl-struct-print t make-ert-test-passed side-effect-free copy-ert-test-passed ert-test-passed-p error-free ert-test-passed-should-forms ert-test-passed-messages memql cl-struct-ert-test-result-with-condition ert-test-result-with-condition-messages compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-messages (or (and (memq (aref cl-x 0) cl-struct-ert-test-result-with-condition-tags)) (error "%s accessing a non-%s" 'ert-test-result-with-condition-messages 'ert-test-result-with-condition)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-with-condition-messages #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-result-with-condition-tags 0 error "%s accessing a non-%s" ert-test-result-with-condition-messages ert-test-result-with-condition 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-with-condition-should-forms compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-should-forms (or (and (memq (aref cl-x 0) cl-struct-ert-test-result-with-condition-tags)) (error "%s accessing a non-%s" 'ert-test-result-with-condition-should-forms 'ert-test-result-with-condition)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-with-condition-should-forms #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-result-with-condition-tags 0 error "%s accessing a non-%s" ert-test-result-with-condition-should-forms ert-test-result-with-condition 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-with-condition-condition compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-condition (or (and (memq (aref cl-x 0) cl-struct-ert-test-result-with-condition-tags)) (error "%s accessing a non-%s" 'ert-test-result-with-condition-condition 'ert-test-result-with-condition)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-with-condition-condition #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-result-with-condition-tags 0 error "%s accessing a non-%s" ert-test-result-with-condition-condition ert-test-result-with-condition 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-with-condition-backtrace compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-backtrace (or (and (memq (aref cl-x 0) cl-struct-ert-test-result-with-condition-tags)) (error "%s accessing a non-%s" 'ert-test-result-with-condition-backtrace 'ert-test-result-with-condition)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-with-condition-backtrace #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-result-with-condition-tags 0 error "%s accessing a non-%s" ert-test-result-with-condition-backtrace ert-test-result-with-condition 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-with-condition-infos compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-infos (or (and (memq (aref cl-x 0) cl-struct-ert-test-result-with-condition-tags)) (error "%s accessing a non-%s" 'ert-test-result-with-condition-infos 'ert-test-result-with-condition)) (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-with-condition-infos #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-result-with-condition-tags 0 error "%s accessing a non-%s" ert-test-result-with-condition-infos ert-test-result-with-condition 5] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-result-with-condition-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-p (and (vectorp cl-x) (>= (length cl-x) 6) (memq (aref cl-x 0) cl-struct-ert-test-result-with-condition-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-result-with-condition-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert-test-result-with-condition-tags vectorp 6 0 t] 2])
(defalias 'copy-ert-test-result-with-condition #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert-test-result-with-condition compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311A@\312>\206\313A@\314>\206'\315A@\203]@\316>\203DAA\211\202/\317>A@\203S\320\211\202/\321\322@\"\210\202-)\323\324\325\320\320	\n\f
&\n-\207" [#1# messages should-forms condition backtrace infos :messages :should-forms :condition (nil (assert nil)) :backtrace (nil (assert nil)) :infos (nil (assert nil)) (:messages :should-forms :condition :backtrace :infos :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms :condition :backtrace :infos)" cl--defsubst-expand (messages should-forms condition backtrace infos) (cl-block make-ert-test-result-with-condition (vector 'cl-struct-ert-test-result-with-condition messages should-forms condition backtrace infos)) #:--cl-keys-- cl-whole] 12 "\n\n(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS CONDITION BACKTRACE INFOS)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@61 

(fn &key MESSAGES SHOULD-FORMS CONDITION BACKTRACE INFOS)
(defalias 'make-ert-test-result-with-condition #[(&rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311\312\313\311C\"\210\311DA@\314>\206-\311\312\313\311C\"\210\311DA@\315>\206?\311\312\313\311C\"\210\311DA@\203u@\316>\203\\AA\211\202G\317>A@\203k\311\211\202G\320\321@\"\210\202E)\322\323	\n\f
&-\207" [#1# messages should-forms condition backtrace infos :messages :should-forms :condition nil signal cl-assertion-failed :backtrace :infos (:messages :should-forms :condition :backtrace :infos :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:messages :should-forms :condition :backtrace :infos)" vector cl-struct-ert-test-result-with-condition #2=#:--cl-keys--] 8 (#$ . 46172)])
(byte-code "\303C\304\305\306\307#\210\304\305\310\311#\210\304\305\312\313#\210\304\305\314\315#\210\304\316\317\315#\210\304\320\317\321#\210\304\322\317\315#\210\304\323\317\315#\210\304\324\317\315#\210\304\325\317\315#\210\304\326\317\315#\210\327\330\"\203Q\210\202U\330B\327\330	\"\203a	\210\202e\330	B\304\331\332\333#\210\334\304\331\335\336\337\n!!#\210)\303\207" [cl-struct-ert-test-result-with-condition-tags cl-struct-ert-test-result-tags file cl-struct-ert-test-result-with-condition put ert-test-result-with-condition cl-struct-slots ((cl-tag-slot) (messages nil) (should-forms nil) (condition (assert nil)) (backtrace (assert nil)) (infos (assert nil))) cl-struct-type (vector nil) cl-struct-include ert-test-result cl-struct-print t copy-ert-test-result-with-condition side-effect-free ert-test-result-with-condition-p error-free ert-test-result-with-condition-infos ert-test-result-with-condition-backtrace ert-test-result-with-condition-condition ert-test-result-with-condition-should-forms ert-test-result-with-condition-messages memql cl-struct-ert-test-quit ert-test-quit-messages compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-quit-messages (or (and (memq (aref cl-x 0) cl-struct-ert-test-quit-tags)) (error "%s accessing a non-%s" 'ert-test-quit-messages 'ert-test-quit)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-quit-messages #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-quit-tags 0 error "%s accessing a non-%s" ert-test-quit-messages ert-test-quit 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-quit-should-forms compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-quit-should-forms (or (and (memq (aref cl-x 0) cl-struct-ert-test-quit-tags)) (error "%s accessing a non-%s" 'ert-test-quit-should-forms 'ert-test-quit)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-quit-should-forms #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-quit-tags 0 error "%s accessing a non-%s" ert-test-quit-should-forms ert-test-quit 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-quit-condition compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-quit-condition (or (and (memq (aref cl-x 0) cl-struct-ert-test-quit-tags)) (error "%s accessing a non-%s" 'ert-test-quit-condition 'ert-test-quit)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-quit-condition #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-quit-tags 0 error "%s accessing a non-%s" ert-test-quit-condition ert-test-quit 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-quit-backtrace compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-quit-backtrace (or (and (memq (aref cl-x 0) cl-struct-ert-test-quit-tags)) (error "%s accessing a non-%s" 'ert-test-quit-backtrace 'ert-test-quit)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-quit-backtrace #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-quit-tags 0 error "%s accessing a non-%s" ert-test-quit-backtrace ert-test-quit 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-quit-infos compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-quit-infos (or (and (memq (aref cl-x 0) cl-struct-ert-test-quit-tags)) (error "%s accessing a non-%s" 'ert-test-quit-infos 'ert-test-quit)) (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-quit-infos #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-quit-tags 0 error "%s accessing a non-%s" ert-test-quit-infos ert-test-quit 5] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-quit-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-quit-p (and (vectorp cl-x) (>= (length cl-x) 6) (memq (aref cl-x 0) cl-struct-ert-test-quit-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-quit-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert-test-quit-tags vectorp 6 0 t] 2])
(defalias 'copy-ert-test-quit #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert-test-quit compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311A@\312>\206\313A@\314>\206'\315A@\203]@\316>\203DAA\211\202/\317>A@\203S\320\211\202/\321\322@\"\210\202-)\323\324\325\320\320	\n\f
&\n-\207" [#1# messages should-forms condition backtrace infos :messages :should-forms :condition (nil (assert nil)) :backtrace (nil (assert nil)) :infos (nil (assert nil)) (:messages :should-forms :condition :backtrace :infos :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms :condition :backtrace :infos)" cl--defsubst-expand (messages should-forms condition backtrace infos) (cl-block make-ert-test-quit (vector 'cl-struct-ert-test-quit messages should-forms condition backtrace infos)) #:--cl-keys-- cl-whole] 12 "\n\n(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS CONDITION BACKTRACE INFOS)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@61 

(fn &key MESSAGES SHOULD-FORMS CONDITION BACKTRACE INFOS)
(defalias 'make-ert-test-quit #[(&rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311\312\313\311C\"\210\311DA@\314>\206-\311\312\313\311C\"\210\311DA@\315>\206?\311\312\313\311C\"\210\311DA@\203u@\316>\203\\AA\211\202G\317>A@\203k\311\211\202G\320\321@\"\210\202E)\322\323	\n\f
&-\207" [#1# messages should-forms condition backtrace infos :messages :should-forms :condition nil signal cl-assertion-failed :backtrace :infos (:messages :should-forms :condition :backtrace :infos :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:messages :should-forms :condition :backtrace :infos)" vector cl-struct-ert-test-quit #2=#:--cl-keys--] 8 (#$ . 53387)])
(byte-code "\304C\305\306\307\310#\210\305\306\311\312#\210\305\306\313\314#\210\305\306\315\316#\210\305\317\320\316#\210\305\321\320\322#\210\305\323\320\316#\210\305\324\320\316#\210\305\325\320\316#\210\305\326\320\316#\210\305\327\320\316#\210\330\331	\"\203Q	\210\202U\331	B\330\331\n\"\203a\n\210\202e\331\nB\305\332\333\334#\210\335\305\332\336\337\340!!#\210)\304\207" [cl-struct-ert-test-quit-tags cl-struct-ert-test-result-with-condition-tags cl-struct-ert-test-result-tags file cl-struct-ert-test-quit put ert-test-quit cl-struct-slots ((cl-tag-slot) (messages nil) (should-forms nil) (condition (assert nil)) (backtrace (assert nil)) (infos (assert nil))) cl-struct-type (vector nil) cl-struct-include ert-test-result-with-condition cl-struct-print t copy-ert-test-quit side-effect-free ert-test-quit-p error-free ert-test-quit-infos ert-test-quit-backtrace ert-test-quit-condition ert-test-quit-should-forms ert-test-quit-messages memql cl-struct-ert-test-failed ert-test-failed-messages compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-failed-messages (or (and (memq (aref cl-x 0) cl-struct-ert-test-failed-tags)) (error "%s accessing a non-%s" 'ert-test-failed-messages 'ert-test-failed)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-failed-messages #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-failed-tags 0 error "%s accessing a non-%s" ert-test-failed-messages ert-test-failed 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-failed-should-forms compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-failed-should-forms (or (and (memq (aref cl-x 0) cl-struct-ert-test-failed-tags)) (error "%s accessing a non-%s" 'ert-test-failed-should-forms 'ert-test-failed)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-failed-should-forms #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-failed-tags 0 error "%s accessing a non-%s" ert-test-failed-should-forms ert-test-failed 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-failed-condition compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-failed-condition (or (and (memq (aref cl-x 0) cl-struct-ert-test-failed-tags)) (error "%s accessing a non-%s" 'ert-test-failed-condition 'ert-test-failed)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-failed-condition #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-failed-tags 0 error "%s accessing a non-%s" ert-test-failed-condition ert-test-failed 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-failed-backtrace compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-failed-backtrace (or (and (memq (aref cl-x 0) cl-struct-ert-test-failed-tags)) (error "%s accessing a non-%s" 'ert-test-failed-backtrace 'ert-test-failed)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-failed-backtrace #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-failed-tags 0 error "%s accessing a non-%s" ert-test-failed-backtrace ert-test-failed 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-failed-infos compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-failed-infos (or (and (memq (aref cl-x 0) cl-struct-ert-test-failed-tags)) (error "%s accessing a non-%s" 'ert-test-failed-infos 'ert-test-failed)) (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-failed-infos #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-failed-tags 0 error "%s accessing a non-%s" ert-test-failed-infos ert-test-failed 5] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-failed-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-failed-p (and (vectorp cl-x) (>= (length cl-x) 6) (memq (aref cl-x 0) cl-struct-ert-test-failed-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-failed-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert-test-failed-tags vectorp 6 0 t] 2])
(defalias 'copy-ert-test-failed #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert-test-failed compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311A@\312>\206\313A@\314>\206'\315A@\203]@\316>\203DAA\211\202/\317>A@\203S\320\211\202/\321\322@\"\210\202-)\323\324\325\320\320	\n\f
&\n-\207" [#1# messages should-forms condition backtrace infos :messages :should-forms :condition (nil (assert nil)) :backtrace (nil (assert nil)) :infos (nil (assert nil)) (:messages :should-forms :condition :backtrace :infos :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms :condition :backtrace :infos)" cl--defsubst-expand (messages should-forms condition backtrace infos) (cl-block make-ert-test-failed (vector 'cl-struct-ert-test-failed messages should-forms condition backtrace infos)) #:--cl-keys-- cl-whole] 12 "\n\n(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS CONDITION BACKTRACE INFOS)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@61 

(fn &key MESSAGES SHOULD-FORMS CONDITION BACKTRACE INFOS)
(defalias 'make-ert-test-failed #[(&rest #1=#:--cl-rest--) "\306>A@\307>A@\310>\206\311\312\313\311C\"\210\311DA@\314>\206-\311\312\313\311C\"\210\311DA@\315>\206?\311\312\313\311C\"\210\311DA@\203u@\316>\203\\AA\211\202G\317>A@\203k\311\211\202G\320\321@\"\210\202E)\322\323	\n\f
&-\207" [#1# messages should-forms condition backtrace infos :messages :should-forms :condition nil signal cl-assertion-failed :backtrace :infos (:messages :should-forms :condition :backtrace :infos :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:messages :should-forms :condition :backtrace :infos)" vector cl-struct-ert-test-failed #2=#:--cl-keys--] 8 (#$ . 60571)])
(byte-code "\303C\304\305\306\307#\210\304\305\310\311#\210\304\305\312\313#\210\304\305\314\315#\210\304\316\317\315#\210\304\320\317\321#\210\304\322\317\315#\210\304\323\317\315#\210\304\324\317\315#\210\304\325\317\315#\210\304\326\317\315#\210\327\330	\"\203Q	\210\202U\330	B\304\331\332\333#\210\334\304\331\335\336\337\n!!#\210)\303\207" [cl-struct-ert-test-failed-tags cl-struct-ert-test-result-tags file cl-struct-ert-test-failed put ert-test-failed cl-struct-slots ((cl-tag-slot) (messages nil) (should-forms nil) (condition (assert nil)) (backtrace (assert nil)) (infos (assert nil))) cl-struct-type (vector nil) cl-struct-include ert-test-result-with-condition cl-struct-print t copy-ert-test-failed side-effect-free ert-test-failed-p error-free ert-test-failed-infos ert-test-failed-backtrace ert-test-failed-condition ert-test-failed-should-forms ert-test-failed-messages memql cl-struct-ert-test-aborted-with-non-local-exit ert-test-aborted-with-non-local-exit-messages compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-aborted-with-non-local-exit-messages (or (and (memq (aref cl-x 0) cl-struct-ert-test-aborted-with-non-local-exit-tags)) (error "%s accessing a non-%s" 'ert-test-aborted-with-non-local-exit-messages 'ert-test-aborted-with-non-local-exit)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-aborted-with-non-local-exit-messages #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-aborted-with-non-local-exit-tags 0 error "%s accessing a non-%s" ert-test-aborted-with-non-local-exit-messages ert-test-aborted-with-non-local-exit 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-aborted-with-non-local-exit-should-forms compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-aborted-with-non-local-exit-should-forms (or (and (memq (aref cl-x 0) cl-struct-ert-test-aborted-with-non-local-exit-tags)) (error "%s accessing a non-%s" 'ert-test-aborted-with-non-local-exit-should-forms 'ert-test-aborted-with-non-local-exit)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-aborted-with-non-local-exit-should-forms #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert-test-aborted-with-non-local-exit-tags 0 error "%s accessing a non-%s" ert-test-aborted-with-non-local-exit-should-forms ert-test-aborted-with-non-local-exit 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert-test-aborted-with-non-local-exit-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert-test-aborted-with-non-local-exit-p (and (vectorp cl-x) (>= (length cl-x) 3) (memq (aref cl-x 0) cl-struct-ert-test-aborted-with-non-local-exit-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert-test-aborted-with-non-local-exit-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert-test-aborted-with-non-local-exit-tags vectorp 3 0 t] 2])
(defalias 'copy-ert-test-aborted-with-non-local-exit #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert-test-aborted-with-non-local-exit compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\305>A@\306>A@\2038@\307>\203!AA\211\202\310>A@\203/\311\211\202\312\313@\"\210\202)\314\315\316\311\f\311	\n&*\207" [#1# messages should-forms #:--cl-keys-- cl-whole :messages :should-forms (:messages :should-forms :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms)" cl--defsubst-expand (messages should-forms) (cl-block make-ert-test-aborted-with-non-local-exit (vector 'cl-struct-ert-test-aborted-with-non-local-exit messages should-forms))] 9 "\n\n(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@35 

(fn &key MESSAGES SHOULD-FORMS)
(defalias 'make-ert-test-aborted-with-non-local-exit #[(&rest #1=#:--cl-rest--) "\304>A@\305>A@\2038@\306>\203!AA\211\202\307>A@\203/\310\211\202\311\312@\"\210\202)\313\314	\n#*\207" [#1# messages should-forms #2=#:--cl-keys-- :messages :should-forms (:messages :should-forms :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms)" vector cl-struct-ert-test-aborted-with-non-local-exit] 5 (#$ . 65760)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\313#\210\302\314\315\313#\210\302\316\315\313#\210\302\317\315\320#\210\302\321\315\313#\210\302\322\315\313#\207" [cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-aborted-with-non-local-exit put ert-test-aborted-with-non-local-exit cl-struct-slots ((cl-tag-slot) (messages nil) (should-forms nil)) cl-struct-type (vector nil) cl-struct-include ert-test-result cl-struct-print t make-ert-test-aborted-with-non-local-exit side-effect-free copy-ert-test-aborted-with-non-local-exit ert-test-aborted-with-non-local-exit-p error-free ert-test-aborted-with-non-local-exit-should-forms ert-test-aborted-with-non-local-exit-messages] 4)
#@57 Record the current backtrace (as a list) and return it.
(defalias 'ert--record-backtrace #[nil "\303\304\211\305!\211\203	\nBT\202\n\237+\207" [i frame #1=#:--cl-var-- 6 nil backtrace-frame] 3 (#$ . 67024)])
#@55 Format the backtrace BACKTRACE to the current buffer.
(defalias 'ert--print-backtrace #[(backtrace) "\306\307\310\311\211\205\304
@\211@\312\313\"\203G\fA\211\203/\211A@\2027\314\315\311GD\"\316\317B\"c\210*\202\273\312\320\"\203\264\fA\211\203a\211A@\202i\314\315\311GD\"\316\321\"c\210\311\311\306\211 \205\204\306:\203\254@\204\231\322c\210\316\323\"c\210A\311\211 \202\200,\324c\210*\202\273\325\326\327#\210)
A\211\204\311-\207" [print-length print-level print-escape-newlines backtrace frame --dolist-tail-- t 8 50 nil memql (nil) signal wrong-number-of-arguments format "  %S\n" (t) "  %S(" " " "%S" ")\n" error "cl-ecase failed: %s, %s" (nil t) #1=#:--cl-var-- arg-forms special-operator args fn firstp #2=#:--cl-var-- arg #3=#:--cl-var--] 5 (#$ . 67250)])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--test-execution-info-test compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-test (or (and (memq (aref cl-x 0) cl-struct-ert--test-execution-info-tags)) (error "%s accessing a non-%s" 'ert--test-execution-info-test 'ert--test-execution-info)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--test-execution-info-test #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--test-execution-info-tags 0 error "%s accessing a non-%s" ert--test-execution-info-test ert--test-execution-info 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--test-execution-info-result compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-result (or (and (memq (aref cl-x 0) cl-struct-ert--test-execution-info-tags)) (error "%s accessing a non-%s" 'ert--test-execution-info-result 'ert--test-execution-info)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--test-execution-info-result #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--test-execution-info-tags 0 error "%s accessing a non-%s" ert--test-execution-info-result ert--test-execution-info 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--test-execution-info-exit-continuation compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-exit-continuation (or (and (memq (aref cl-x 0) cl-struct-ert--test-execution-info-tags)) (error "%s accessing a non-%s" 'ert--test-execution-info-exit-continuation 'ert--test-execution-info)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--test-execution-info-exit-continuation #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--test-execution-info-tags 0 error "%s accessing a non-%s" ert--test-execution-info-exit-continuation ert--test-execution-info 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--test-execution-info-next-debugger compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-next-debugger (or (and (memq (aref cl-x 0) cl-struct-ert--test-execution-info-tags)) (error "%s accessing a non-%s" 'ert--test-execution-info-next-debugger 'ert--test-execution-info)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--test-execution-info-next-debugger #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--test-execution-info-tags 0 error "%s accessing a non-%s" ert--test-execution-info-next-debugger ert--test-execution-info 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--test-execution-info-ert-debug-on-error compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-ert-debug-on-error (or (and (memq (aref cl-x 0) cl-struct-ert--test-execution-info-tags)) (error "%s accessing a non-%s" 'ert--test-execution-info-ert-debug-on-error 'ert--test-execution-info)) (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--test-execution-info-ert-debug-on-error #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--test-execution-info-tags 0 error "%s accessing a non-%s" ert--test-execution-info-ert-debug-on-error ert--test-execution-info 5] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--test-execution-info-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-p (and (vectorp cl-x) (>= (length cl-x) 6) (memq (aref cl-x 0) cl-struct-ert--test-execution-info-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--test-execution-info-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert--test-execution-info-tags vectorp 6 0 t] 2])
(defalias 'copy-ert--test-execution-info #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert--test-execution-info compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>\206\307A@\310>\206\311A@\312>\206\313A@\314>A@\315>A@\203]@\316>\203DAA\211\202/\317>A@\203S\320\211\202/\321\322@\"\210\202-)\323\324\325\320\320	\n\f
&\n-\207" [#1# test result exit-continuation next-debugger ert-debug-on-error :test (nil (assert nil)) :result (nil (assert nil)) :exit-continuation (nil (assert nil)) :next-debugger :ert-debug-on-error (:test :result :exit-continuation :next-debugger :ert-debug-on-error :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:test :result :exit-continuation :next-debugger :ert-debug-on-error)" cl--defsubst-expand (test result exit-continuation next-debugger ert-debug-on-error) (cl-block make-ert--test-execution-info (vector 'cl-struct-ert--test-execution-info test result exit-continuation next-debugger ert-debug-on-error)) #:--cl-keys-- cl-whole] 12 "\n\n(fn CL-WHOLE &cl-quote &key TEST RESULT EXIT-CONTINUATION NEXT-DEBUGGER ERT-DEBUG-ON-ERROR)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@76 

(fn &key TEST RESULT EXIT-CONTINUATION NEXT-DEBUGGER ERT-DEBUG-ON-ERROR)
(defalias 'make-ert--test-execution-info #[(&rest #1=#:--cl-rest--) "\306>\206\307\310\311\307C\"\210\307DA@\312>\206!\307\310\311\307C\"\210\307DA@\313>\2063\307\310\311\307C\"\210\307DA@\314>A@\315>A@\203u@\316>\203\\AA\211\202G\317>A@\203k\307\211\202G\320\321@\"\210\202E)\322\323	\n\f
&-\207" [#1# test result exit-continuation next-debugger ert-debug-on-error :test nil signal cl-assertion-failed :result :exit-continuation :next-debugger :ert-debug-on-error (:test :result :exit-continuation :next-debugger :ert-debug-on-error :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:test :result :exit-continuation :next-debugger :ert-debug-on-error)" vector cl-struct-ert--test-execution-info #2=#:--cl-keys--] 8 (#$ . 74276)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\313#\210\302\314\315\313#\210\302\316\315\317#\210\302\320\315\313#\210\302\321\315\313#\210\302\322\315\313#\210\302\323\315\313#\210\302\324\315\313#\207" [cl-struct-ert--test-execution-info-tags cl-struct-ert--test-execution-info put ert--test-execution-info cl-struct-slots ((cl-tag-slot) (test (assert nil)) (result (assert nil)) (exit-continuation (assert nil)) (next-debugger) (ert-debug-on-error)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print t copy-ert--test-execution-info side-effect-free ert--test-execution-info-p error-free ert--test-execution-info-ert-debug-on-error ert--test-execution-info-next-debugger ert--test-execution-info-exit-continuation ert--test-execution-info-result ert--test-execution-info-test] 4)
#@331 During a test run, `debugger' is bound to a closure that calls this function.

This function records failures and errors and either terminates
the test silently or calls the interactive debugger, as
appropriate.

INFO is the ert--test-execution-info corresponding to this test
run.  DEBUGGER-ARGS are the arguments to `debugger'.
(defalias 'ert--run-test-debugger #[(info debugger-args) "\211\203	\211A@\202\306\307\310	GD\"\311\n\312\"\2034\313\314H\f>\204,\315\316\317\320#\210\321H\"\202\360\322\n\315\"\203\347	@\311
@\323\"\203J\324\202K\325$\326 %\327&!'\314H\f>\204e\315\316\330\320#\210\211(\331\322$\324\"\203\200\332\333\310\211
%'&\202\240\322$\325\"\203\226\332\334\310\211
%'&\202\240\315\335$\336#\205\240\310I\210))T)\314H\f>\204\266\315\316\337\320#\210\340H\203\321\313\314H\f>\204\313\315\316\317\320#\210\321H\"\210\314H\f>\204\337\315\316\341\320#\210\342H ,\202\360\315\335\n\343#\205\360\310*\207" [debugger-args more-debugger-args first-debugger-arg info cl-struct-ert--test-execution-info-tags condition signal wrong-number-of-arguments nil memql (lambda debug t exit nil) apply 0 error "%s accessing a non-%s" ert--test-execution-info-next-debugger ert--test-execution-info 4 eql (quit) quit failed ert--record-backtrace reverse ert--test-execution-info-result 2 vector cl-struct-ert-test-quit cl-struct-ert-test-failed "cl-ecase failed: %s, %s" (quit failed) ert--test-execution-info-ert-debug-on-error 5 ert--test-execution-info-exit-continuation 3 (nil exit t debug lambda error) type backtrace ert--infos infos #1=#:v num-nonmacro-input-events] 10 (#$ . 75998)])
#@120 Low-level function to run a test according to ERT-TEST-EXECUTION-INFO.

This mainly sets up debugger-related bindings.
(defalias 'ert--run-test-internal #[(ert-test-execution-info) "\306\307!\211\211\nL\210)J\310H>\204\311\312\313\314#\210J\211\315
I\210)J\310H>\2042\311\312\316\314#\210J\211\317I\210)\320\321\215\210J\310H>\204P\311\312\322\314#\210J\211\323\324\325\326\211#I\210*\326\207" [#1=#:--cl-info-- #2=#:v ert-test-execution-info cl-struct-ert--test-execution-info-tags #3=#:v debugger make-symbol "--info--" 0 error #7="%s accessing a non-%s" ert--test-execution-info-next-debugger ert--test-execution-info 4 ert--test-execution-info-ert-debug-on-error 5 ert--pass (byte-code "\306\307!rq\210\310\216\311 \312\216\313\314\315\316\317D\316\nD\320FE\321\211\322\211\nJ\323H>\2046\324\325\326\327#\210\nJ\330H\323H >\204H\324\325\331\332#\210\nJ\323H>\204X\324\325\326\327#\210\nJ\330H\333H \210.\n\334 \207" [#4=#:temp-buffer #5=#:wconfig #1# ert--infos debug-ignored-errors debug-on-quit generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#4# buffer-name kill-buffer] 2)) current-window-configuration ((set-window-configuration #5#)) lambda (&rest --cl-rest--) apply quote #[(#6=#:G12601 &rest debugger-args) "\302J	\"\207" [#6# debugger-args ert--run-test-debugger] 3] --cl-rest-- t nil 0 error #7# ert--test-execution-info-test ert--test-execution-info 1 ert-test-body ert-test 3 ert-pass debug-on-error debugger cl-struct-ert--test-execution-info-tags cl-struct-ert-test-tags] 6) ert--test-execution-info-result 2 vector cl-struct-ert-test-passed nil #8=#:v ert-debug-on-error #9=#:v] 7 (#$ . 77652)])
#@139 Immediately truncate *Messages* buffer according to `message-log-max'.

This can be useful after reducing the value of `message-log-max'.
(defalias 'ert--force-message-log-buffer-truncation #[nil "r\303\304!q\210\250\205\"\305Y\205\"e\212db\210[y\210`)\211	|*)\207" [message-log-max end begin get-buffer-create "*Messages*" 0] 3 (#$ . 79344)])
#@295 List of tests that are currently in execution.

This list is empty while no test is running, has one element
while a test is running, two elements while a test run from
inside a test is running, etc.  The list is in order of nesting,
innermost test first.

The elements are of type `ert-test'.
(defvar ert--running-tests nil (#$ . 79702))
#@90 Run ERT-TEST.

Returns the result and stores it in ERT-TEST's `most-recent-result' slot.
(defalias 'ert-run-test #[(ert-test) "\303H	>\204\304\305\306\300#\210\211\307\310I\210)\311\312\215\210\303H	>\204(\304\305\306\300#\210\307H\207" [ert-test cl-struct-ert-test-tags #1=#:v 0 error #8="%s accessing a non-%s" ert-test-most-recent-result 4 nil --cl-block-error-- (byte-code "\306\307!\211\211r\310\311!q\210\312 d\313\223)L\210)\314\216\306\315!\306\316!\211\211\317\320
\317\321\313\211#\322\313\211&L\210)\n\211\313L\210)\323\216\324\325\326\327\330D\327\nD\327D\327D\331\257E\332
B\333J!\210.\313\207" [#2=#:--cl-begin-marker-- #3=#:v #4=#:--cl-should-form-accu-- #5=#:--cl-info-- #6=#:v ert-test make-symbol "--begin-marker--" get-buffer-create "*Messages*" make-marker nil ((byte-code "J\301\211\223\207" [#2# nil] 3)) "--info--" "--should-form-accu--" vector cl-struct-ert--test-execution-info cl-struct-ert-test-aborted-with-non-local-exit #[nil "\300\301\302\"\207" [throw --cl-block-error-- nil] 3] ((byte-code "J\306H	>\204\307\310\311\312#\210J\313H\211\306H>\204\"\307\310\314\315#\210\n\211\316r\317\320!q\210
Jd{)I\210)\321 \210\211J\237L\210)\n\306H>\204Q\307\310\322\315#\210\n\211\313JI\210)\306H>\204l\307\310\323\324#\210\211\325\nI\210*\306\207" [#5# cl-struct-ert--test-execution-info-tags result cl-struct-ert-test-result-tags #7=#:v #2# 0 error #8# ert--test-execution-info-result ert--test-execution-info 2 ert-test-result-messages ert-test-result 1 get-buffer-create "*Messages*" ert--force-message-log-buffer-truncation ert-test-result-should-forms ert-test-most-recent-result ert-test 4 #4# #9=#:v #10=#:v cl-struct-ert-test-tags #11=#:v] 5)) lambda (&rest --cl-rest--) apply quote #[(#12=#:G12602 #13=#:G12603 #14=#:G12604 form-description) "\211\nJBL)\207" [#12# #15=#:v form-description] 4] --cl-rest-- t ert--run-test-internal #16=#:v ert--running-tests message-log-max ert--should-execution-observer] 9)] 5 (#$ . 80047)])
#@48 Return the top-level test currently executing.
(defalias 'ert-running-test #[nil "\301!@\207" [ert--running-tests last] 2 (#$ . 82072)])
#@417 Return non-nil if RESULT matches type RESULT-TYPE.

Valid result types:

nil -- Never matches.
t -- Always matches.
:failed, :passed -- Matches corresponding results.
(and TYPES...) -- Matches if all TYPES match.
(or TYPES...) -- Matches if some TYPES match.
(not TYPE) -- Matches if TYPE does not match.
(satisfies PREDICATE) -- Matches if PREDICATE returns true when called with
                           RESULT.
(defalias 'ert-test-result-type-p #[(result result-type) "\306\307\"\203	\310\207\306\311\"\203\312\207\306\313\"\2030\314	!\205

	G\315Y\205

	\316H\n>\205

\312\207\306\317\"\203N\314	!\205

	G\320Y\205

	\316H>\205

\312\207:\203\370\211\203a\f\211A@\202h\321\322\310\fGD\"\323
\324\"\203\216\323\fG\316\"\203|\312\202\366\325	\f@\"\205\366\325	\324\fAB\"\202\366\323
\326\"\203\263\323\fG\316\"\203\241\310\202\366\325	\f@\"\206\366\325	\326\fAB\"\202\366\323
\327\"\203\321\323\fG\330\"\204\310\321\331\332C\"\210\325	\f@\"?\202\366\323
\333\"\203\355\323\fG\330\"\204\346\321\331\334C\"\210\f@	!\202\366\335\336
\337#\205\366\310*\207\335\340\341#\205

\310\207" [result-type result cl-struct-ert-test-failed-tags cl-struct-ert-test-passed-tags operands operator memql #1=(nil) nil #2=(t) t #3=(:failed) vectorp 6 0 #4=(:passed) 3 signal wrong-number-of-arguments eql and ert-test-result-type-p or not 1 cl-assertion-failed (eql (length operands) 1) satisfies (eql (length operands) 1) error "cl-ecase failed: %s, %s" (and or not satisfies) "cl-etypecase failed: %s, %s" ((member . #1#) (member . #2#) (member . #3#) (member . #4#) cons)] 5 (#$ . 82217)])
#@63 Return non-nil if TEST's expected result type matches RESULT.
(defalias 'ert-test-result-expected-p #[(test result) "\303	\304H\n>\204\305\306\307\310#\210	\311H\"\207" [result test cl-struct-ert-test-tags ert-test-result-type-p 0 error "%s accessing a non-%s" ert-test-expected-result-type ert-test 5] 6 (#$ . 83837)])
#@1635 Return a list of tests that match SELECTOR.

UNIVERSE specifies the set of tests to select from; it should be a list
of tests, or t, which refers to all tests named by symbols in `obarray'.

Valid SELECTORs:

nil  -- Selects the empty set.
t    -- Selects UNIVERSE.
:new -- Selects all tests that have not been run yet.
:failed, :passed       -- Select tests according to their most recent result.
:expected, :unexpected -- Select tests according to their most recent result.
a string -- A regular expression selecting all tests with matching names.
a test   -- (i.e., an object of the ert-test data-type) Selects that test.
a symbol -- Selects the test that the symbol names, errors if none.
(member TESTS...) -- Selects the elements of TESTS, a list of tests
    or symbols naming tests.
(eql TEST) -- Selects TEST, a test or a symbol naming a test.
(and SELECTORS...) -- Selects the tests that match all SELECTORS.
(or SELECTORS...)  -- Selects the tests that match any of the SELECTORS.
(not SELECTOR)     -- Selects all tests that do not match SELECTOR.
(tag TAG) -- Selects all tests that have TAG on their tags list.
    A tag is an arbitrary label you can apply when you define a test.
(satisfies PREDICATE) -- Selects all tests that satisfy PREDICATE.
    PREDICATE is a function that takes an ert-test object as argument,
    and returns non-nil if it is selected.

Only selectors that require a superset of tests, such
as (satisfies ...), strings, :new, etc. make use of UNIVERSE.
Selectors that do not, such as (member ...), just return the
set implied by them without checking whether it is really
contained in UNIVERSE.
(defalias 'ert-select-tests #[(selector universe) "\306\307\"\203	\310\207\306\311\"\203-	<\203	\207\306	\312\"\203#\313\314	\"\207\315\316	\317#\205\326
\310\207\306\320\"\203;\313\321\322D	\"\207\306\323\"\203I\313\321\324D	\"\207\306\325\"\203W\313\321\326D	\"\207\306\327\"\203e\313\321\330D	\"\207\306\331\"\203q\313\332	\"\207;\203\231\306	\333\"\203\205\334\335\336\337\"\"\207	<\203\217\340\341	\"\207\315\316	\342#\205\326
\310\207\343!\203\261G\344Y\203\261\345H\n>\203\261C\2079\203\307\337!\204\302\346\347\350C\"\210\335!C\207:\203\315
\211\203\332\211A@\202\341\346\351\310GD\"\352\f\353\"\203\360\334\354\"\202\313
\352\f\352\"\203
\352G\355\"\204
\346\347\356C\"\210\313\353B	\"\202\313
\352\f\357\"\2032
\352G\345\"\203$
\313\360	\"\202\313
\313\357AB\313@	\"\"\202\313
\352\f\361\"\203X
\352G\355\"\204G
\346\347\362C\"\210\313\360	\"\363
\313@
\"\")\202\313
\352\f\364\"\203
\352G\345\"\203n
\313\310	\"\202\313
\365\313@	\"\313\364AB	\"\"\202\313
\352\f\366\"\203\242
\352G\355\"\204\224
\346\347\367C\"\210@6\313\321\370D	\")\202\313
\352\f\321\"\203\302
\352G\355\"\204\267
\346\347\371C\"\210\340@\313\360	\"\"\202\313
\315\372\f\373#\205\313
\310*\207\315\316\374#\205\326
\310\207" [selector universe cl-struct-ert-test-tags operands operator all-tests memql #5=(nil) nil #6=(t) #1=(t) ert-select-tests "" error #4="cl-etypecase failed: %s, %s" (list (member . #1#)) #7=(:new) satisfies #[(test) "\302H	>\204\303\304\305\306#\210\307H?\207" [test cl-struct-ert-test-tags 0 error #2="%s accessing a non-%s" ert-test-most-recent-result ert-test 4] 4] #8=(:failed) #[(test) "\302\303H	>\204\304\305\306\307#\210\310H\311\"\207" [test cl-struct-ert-test-tags ert-test-result-type-p 0 error #2# ert-test-most-recent-result ert-test 4 :failed] 5] #9=(:passed) #[(test) "\302\303H	>\204\304\305\306\307#\210\310H\311\"\207" [test cl-struct-ert-test-tags ert-test-result-type-p 0 error #2# ert-test-most-recent-result ert-test 4 :passed] 5] #10=(:expected) #[(test) "\302\211\303H	>\204\304\305\306\307#\210\310H\"\207" [test cl-struct-ert-test-tags ert-test-result-expected-p 0 error #2# ert-test-most-recent-result ert-test 4] 6] #11=(:unexpected) (not :expected) #3=(t) mapcar ert-get-test apropos-internal ert-test-boundp ert--remove-if-not #[(test) "\303H	>\204\304\305\306\307#\210\310H\205(\311\n\303H	>\204$\304\305\306\307#\210\310H\"\207" [test cl-struct-ert-test-tags selector 0 error #2# ert-test-name ert-test 1 string-match] 6] ((member . #3#) list) vectorp 7 0 signal cl-assertion-failed (ert-test-boundp selector) wrong-number-of-arguments eql member #[(purported-test) "9\203\302!\204\303\304\305C\"\210\306!\207\307!\203,G\310Y\203,\311H	>\203,\207\312\313\314#\2055\315\207" [purported-test cl-struct-ert-test-tags ert-test-boundp signal cl-assertion-failed (ert-test-boundp purported-test) ert-get-test vectorp 7 0 error #4# (symbol ert-test) nil] 4] 1 (eql (length operands) 1) and t not (eql (length operands) 1) ert--set-difference or ert--union tag (eql (length operands) 1) #[(test) "	\303H\n>\204\304\305\306\307#\210	\310H\235\207" [tag test cl-struct-ert-test-tags 0 error #2# ert-test-tags ert-test 6] 5] (eql (length operands) 1) "cl-ecase failed: %s, %s" (member eql and not or tag satisfies) ((member . #5#) (member . #6#) (member . #7#) (member . #8#) (member . #9#) (member . #10#) (member . #11#) string ert-test symbol cons)] 6 (#$ . 84168)])
#@75 Insert a human-readable presentation of SELECTOR into the current buffer.
(defalias 'ert--insert-human-readable-selector #[(selector) "\304\305!\211\211\306L\210)\211\307\310\311\312\313D\312D\314FEL\210)\315\316J!\"c)\207" [#1=#:--cl---cl-rec---- #2=#:v #3=#:v selector make-symbol "----cl-rec----" nil lambda (&rest --cl-rest--) apply quote #[(#4=#:G12605 selector) "\305\306\"\204;\2049\203\207\307!\203WG\310Y\203W\311H	>\203W\311H	>\2046\312\313\314\315#\210\316H\203S\317\320\321\311H	>\204M\312\313\314\315#\210\316H\"!\207\317\322!\207:\203\231\211\203j\n\211A@\202q\323\324\325\nGD\"\305\326\"\203\203\327\fJ\n\"B\202\227\305\330\"\203\216\202\227\312\331\332#\205\227\325*\207\312\333\334#\205\242\325\207" [selector cl-struct-ert-test-tags operands operator #4# memql #5=(nil t :new :failed :passed :expected :unexpected) vectorp 7 0 error "%s accessing a non-%s" ert-test-name ert-test 1 make-symbol format "<%S>" "<unnamed test>" signal wrong-number-of-arguments nil (member eql and not or) mapcar (member tag satisfies) "cl-ecase failed: %s, %s" (or not and eql member satisfies tag member) "cl-etypecase failed: %s, %s" ((or (member . #5#) string symbol) ert-test cons)] 8] --cl-rest-- format "%S"] 8 (#$ . 89312)])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-selector compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-selector (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-selector 'ert--stats)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-selector #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-selector ert--stats 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-tests compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-tests (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-tests 'ert--stats)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-tests #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-tests ert--stats 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-test-map compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-test-map (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-test-map 'ert--stats)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-test-map #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-test-map ert--stats 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-test-results compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-test-results (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-test-results 'ert--stats)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-test-results #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-test-results ert--stats 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-test-start-times compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-test-start-times (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-test-start-times 'ert--stats)) (aref cl-x 5)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-test-start-times #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-test-start-times ert--stats 5] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-test-end-times compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-test-end-times (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-test-end-times 'ert--stats)) (aref cl-x 6)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-test-end-times #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-test-end-times ert--stats 6] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-passed-expected compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-passed-expected (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-passed-expected 'ert--stats)) (aref cl-x 7)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-passed-expected #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-passed-expected ert--stats 7] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-passed-unexpected compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-passed-unexpected (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-passed-unexpected 'ert--stats)) (aref cl-x 8)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-passed-unexpected #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-passed-unexpected ert--stats 8] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-failed-expected compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-failed-expected (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-failed-expected 'ert--stats)) (aref cl-x 9)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-failed-expected #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-failed-expected ert--stats 9] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-failed-unexpected compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-failed-unexpected (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-failed-unexpected 'ert--stats)) (aref cl-x 10)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-failed-unexpected #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-failed-unexpected ert--stats 10] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-start-time compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-start-time (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-start-time 'ert--stats)) (aref cl-x 11)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-start-time #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-start-time ert--stats 11] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-end-time compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-end-time (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-end-time 'ert--stats)) (aref cl-x 12)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-end-time #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-end-time ert--stats 12] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-aborted-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-aborted-p (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-aborted-p 'ert--stats)) (aref cl-x 13)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-aborted-p #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-aborted-p ert--stats 13] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-current-test compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-current-test (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-current-test 'ert--stats)) (aref cl-x 14)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-current-test #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-current-test ert--stats 14] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-next-redisplay compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-next-redisplay (or (and (memq (aref cl-x 0) cl-struct-ert--stats-tags)) (error "%s accessing a non-%s" 'ert--stats-next-redisplay 'ert--stats)) (aref cl-x 15)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-next-redisplay #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-next-redisplay ert--stats 15] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--stats-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--stats-p (and (vectorp cl-x) (>= (length cl-x) 16) (memq (aref cl-x 0) cl-struct-ert--stats-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--stats-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert--stats-tags vectorp 16 0 t] 2])
(defalias 'copy-ert--stats #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert--stats compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>\206\307A@\310>\206\311A@\312>\206\313A@\314>\206%\315A@\316>\206/\317A@\320>\2069\321A@(\322>\206D\323A@)\324>\206O\325A@*\326>\206Z\327A@+\330>\206e\331A@,\332>A@-\333>A@.\334>A@/\335>A@0\336>\206\214\337A@122\203\3032@\340>\203\2522AA\2112\202\225\341>A@\203\271\342\2112\202\225\343\3442@\"\210\202\223)\345\346\347\3423\342	\n\f
()*+,-./01&.\207" [#1# selector tests test-map test-results test-start-times :selector (nil (assert nil)) :tests (nil (assert nil)) :test-map (nil (assert nil)) :test-results (nil (assert nil)) :test-start-times (nil (assert nil)) :test-end-times (nil (assert nil)) :passed-expected (nil 0) :passed-unexpected (nil 0) :failed-expected (nil 0) :failed-unexpected (nil 0) :start-time :end-time :aborted-p :current-test :next-redisplay (nil 0.0) (:selector :tests :test-map :test-results :test-start-times :test-end-times :passed-expected :passed-unexpected :failed-expected :failed-unexpected :start-time :end-time :aborted-p :current-test :next-redisplay :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:selector :tests :test-map :test-results :test-start-times :test-end-times :passed-expected :passed-unexpected :failed-expected :failed-unexpected :start-time :end-time :aborted-p :current-test :next-redisplay)" cl--defsubst-expand (selector tests test-map test-results test-start-times test-end-times passed-expected passed-unexpected failed-expected failed-unexpected start-time end-time aborted-p current-test next-redisplay) (cl-block make-ert--stats (vector 'cl-struct-ert--stats selector tests test-map test-results test-start-times test-end-times passed-expected passed-unexpected failed-expected failed-unexpected start-time end-time aborted-p current-test next-redisplay)) test-end-times passed-expected passed-unexpected failed-expected failed-unexpected start-time end-time aborted-p current-test next-redisplay #:--cl-keys-- cl-whole] 22 "\n\n(fn CL-WHOLE &cl-quote &key SELECTOR TESTS TEST-MAP TEST-RESULTS TEST-START-TIMES TEST-END-TIMES PASSED-EXPECTED PASSED-UNEXPECTED FAILED-EXPECTED FAILED-UNEXPECTED START-TIME END-TIME ABORTED-P CURRENT-TEST NEXT-REDISPLAY)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@208 

(fn &key SELECTOR TESTS TEST-MAP TEST-RESULTS TEST-START-TIMES TEST-END-TIMES PASSED-EXPECTED PASSED-UNEXPECTED FAILED-EXPECTED FAILED-UNEXPECTED START-TIME END-TIME ABORTED-P CURRENT-TEST NEXT-REDISPLAY)
(defalias 'make-ert--stats #[(&rest #1=#:--cl-rest--) "\306>\206\307\310\311\307C\"\210\307DA@\312>\206!\307\310\311\307C\"\210\307DA@\313>\2063\307\310\311\307C\"\210\307DA@\314>\206E\307\310\311\307C\"\210\307DA@\315>\206W\307\310\311\307C\"\210\307DA@\316>\206i\307\310\311\307C\"\210\307DA@#\317>\206t\320A@$\321>\206\322A@%\323>\206\212\324A@&\325>\206\225\326A@'\327>A@(\330>A@)\331>A@*\332>A@+\333>\206\274\334A@,--\203\363-@\335>\203\332-AA\211-\202\305\336>A@\203\351\307\211-\202\305\337\340-@\"\210\202\303)\341\342	\n\f
#$%&'()*+,&.\207" [#1# selector tests test-map test-results test-start-times :selector nil signal cl-assertion-failed :tests :test-map :test-results :test-start-times :test-end-times :passed-expected (nil 0) :passed-unexpected (nil 0) :failed-expected (nil 0) :failed-unexpected (nil 0) :start-time :end-time :aborted-p :current-test :next-redisplay (nil 0.0) (:selector :tests :test-map :test-results :test-start-times :test-end-times :passed-expected :passed-unexpected :failed-expected :failed-unexpected :start-time :end-time :aborted-p :current-test :next-redisplay :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:selector :tests :test-map :test-results :test-start-times :test-end-times :passed-expected :passed-unexpected :failed-expected :failed-unexpected :start-time :end-time :aborted-p :current-test :next-redisplay)" vector cl-struct-ert--stats test-end-times passed-expected passed-unexpected failed-expected failed-unexpected start-time end-time aborted-p current-test next-redisplay #2=#:--cl-keys--] 18 (#$ . 104434)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\313#\210\302\314\315\313#\210\302\316\315\317#\210\302\320\315\313#\210\302\321\315\313#\210\302\322\315\313#\210\302\323\315\313#\210\302\324\315\313#\210\302\325\315\313#\210\302\326\315\313#\210\302\327\315\313#\210\302\330\315\313#\210\302\331\315\313#\210\302\332\315\313#\210\302\333\315\313#\210\302\334\315\313#\210\302\335\315\313#\210\302\336\315\313#\207" [cl-struct-ert--stats-tags cl-struct-ert--stats put ert--stats cl-struct-slots ((cl-tag-slot) (selector (assert nil)) (tests (assert nil) :type vector) (test-map (assert nil) :type hash-table) (test-results (assert nil) :type vector) (test-start-times (assert nil) :type vector) (test-end-times (assert nil) :type vector) (passed-expected 0) (passed-unexpected 0) (failed-expected 0) (failed-unexpected 0) (start-time nil) (end-time nil) (aborted-p nil) (current-test nil) (next-redisplay 0.0)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print t copy-ert--stats side-effect-free ert--stats-p error-free ert--stats-next-redisplay ert--stats-current-test ert--stats-aborted-p ert--stats-end-time ert--stats-start-time ert--stats-failed-unexpected ert--stats-failed-expected ert--stats-passed-unexpected ert--stats-passed-expected ert--stats-test-end-times ert--stats-test-start-times ert--stats-test-results ert--stats-test-map ert--stats-tests ert--stats-selector] 4)
#@64 Return the number of tests in STATS that had expected results.
(defalias 'ert-stats-completed-expected #[(stats) "\302H	>\204\303\304\305\306#\210\307H\302H	>\204\303\304\310\306#\210\311H\\\207" [stats cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-passed-expected ert--stats 7 ert--stats-failed-expected 9] 5 (#$ . 107760)])
#@66 Return the number of tests in STATS that had unexpected results.
(defalias 'ert-stats-completed-unexpected #[(stats) "\302H	>\204\303\304\305\306#\210\307H\302H	>\204\303\304\310\306#\210\311H\\\207" [stats cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-passed-unexpected ert--stats 8 ert--stats-failed-unexpected 10] 5 (#$ . 108123)])
#@48 Number of tests in STATS that have run so far.
(defalias 'ert-stats-completed #[(stats) "\301!\302!\\\207" [stats ert-stats-completed-expected ert-stats-completed-unexpected] 3 (#$ . 108495)])
#@68 Number of tests in STATS, regardless of whether they have run yet.
(defalias 'ert-stats-total #[(stats) "\302H	>\204\303\304\305\306#\210\307HG\207" [stats cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-tests ert--stats 2] 4 (#$ . 108696)])
(defvar ert--current-run-stats nil)
#@136 Return the key used for TEST in the test map of ert--stats objects.

Returns the name of TEST if it has one, or TEST itself otherwise.
(defalias 'ert--stats-test-key #[(test) "\302H	>\204\303\304\305\306#\210\307H\206\207" [test cl-struct-ert-test-tags 0 error "%s accessing a non-%s" ert-test-name ert-test 1] 4 (#$ . 109006)])
#@120 Change STATS by replacing the test at position POS with TEST and RESULT.

Also changes the counters in STATS to match.
(defalias 'ert--stats-set-test-and-result #[(stats pos test result) "\306H	>\204\307\310\311\312#\210\313H\306H	>\204 \307\310\314\312#\210\315H\n\fH\306H	>\2046\307\310\316\312#\210\317H\320\321\322!\203I\322K\202J\323\324\216\323=\203\\\325\322!\210\202a\322M\210\322\326!\210\n\f  !I\210*\"\f#\"#$I\210*\327\330
!\"\210\330!!%&\331%\f&#\210*\322\332!\210.\333\207" [stats cl-struct-ert--stats-tags tests results pos old-test 0 error #1="%s accessing a non-%s" ert--stats-tests ert--stats 2 ert--stats-test-results 4 ert--stats-test-map 3 #[(d) "\306	H\n	H\"\203\314\307\n	H!\203C\n	HG\310Y\203C\n	H\311H>\203C\f\311H
>\2044\312\313\314\315#\210\f\211\316\316H\\I)\207\307\n	H!\203|\n	HG\317Y\203|\n	H\311H>\203|\f\311H
>\204m\312\313\320\315#\210\f\211\321\321H\\I)\207\n	H\204\204\322\207\307\n	H!\203\242\n	HG\310Y\203\242\n	H\311H>\203\242\322\207\307\n	H!\203\300\n	HG\317Y\203\300\n	H\311H>\203\300\322\207\312\323\n	H\324#\205\214
\322\207\307\n	H!\203
\n	HG\310Y\203
\n	H\311H>\203
\f\311H
>\204\365\312\313\325\315#\210\f\211 \326 \326H\\I)\207\307\n	H!\203=
\n	HG\317Y\203=
\n	H\311H>\203=
\f\311H
>\204.
\312\313\327\315#\210\f\211!\330!\330H\\I)\207\n	H\204E
\322\207\307\n	H!\203c
\n	HG\310Y\203c
\n	H\311H>\203c
\322\207\307\n	H!\203\201
\n	HG\317Y\203\201
\n	H\311H>\203\201
\322\207\312\323\n	H\331#\205\214
\322\207" [tests pos results cl-struct-ert-test-passed-tags stats cl-struct-ert--stats-tags ert-test-result-expected-p vectorp 3 0 error #1# ert--stats-passed-expected ert--stats 7 6 ert--stats-failed-expected 9 nil "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-failed null ert-test-aborted-with-non-local-exit ert-test-quit) ert--stats-passed-unexpected 8 ert--stats-failed-unexpected 10 (ert-test-passed ert-test-failed null ert-test-aborted-with-non-local-exit ert-test-quit) #2=#:v d cl-struct-ert-test-failed-tags #3=#:v cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags #4=#:v #5=#:v] 5] fboundp update cl--unbound ((byte-code "\301=\203
\302\303!\210\202\303M\210\301\207" [#6=#:old cl--unbound fmakunbound update] 2)) fmakunbound -1 remhash ert--stats-test-key puthash 1 nil map #7=#:vnew #6# #8=#:v #9=#:v test #10=#:v #11=#:v result #12=#:v #13=#:v] 4 (#$ . 109349)])
#@110 Create a new `ert--stats' object for running TESTS.

SELECTOR is the selector that was used to select TESTS.
(defalias 'ert--make-stats #[(tests selector) "\306!\307\310G\"\311\312\313\211\fT\211GW\203L\fH\314
!\315	\"\2036\316\317\320C\"\210	\321\n#\210*\nT\202-\322\323\324\325	\326\327G\313\"\330\327G\313\"\331\327G\313\"&\f)\207" [tests map i #1=#:--cl-vec-- #2=#:--cl-idx-- test ert--coerce-to-vector make-hash-table :size 0 -1 nil ert--stats-test-key gethash signal cl-assertion-failed (not (gethash key map)) puthash make-ert--stats :selector :tests :test-map :test-results make-vector :test-start-times :test-end-times key #3=#:v #4=#:v selector] 16 (#$ . 111830)])
#@74 Run the single test TEST and record the result using STATS and LISTENER.
(defalias 'ert-run-or-rerun-test #[(stats test listener) "\306	\"\307\n	\310$\210\311H\f>\204\312\313\314\315#\210\211\316	I\210)\317	#\210	\311H>\204:\312\313\320\321#\210	\211\322\310I\210)\311H\f>\204Q\312\313\323\315#\210\324H\n\325 I\210*\326\216\327	!+\207" [stats test pos ert--current-run-stats cl-struct-ert--stats-tags #1=#:v ert--stats-test-pos ert--stats-set-test-and-result nil 0 error #4="%s accessing a non-%s" ert--stats-current-test ert--stats 14 test-started ert-test-most-recent-result ert-test 4 ert--stats-test-start-times 5 current-time ((byte-code "\306H	>\204\307\310\311\312#\210\313H\n\f\314 I\210*
\306H>\204*\307\310\315\316#\210
\317H\320
$\210\321
$\210)\306H	>\204O\307\310\322\312#\210\211\323\324I\210)\324\207" [stats cl-struct-ert--stats-tags #2=#:v pos #3=#:v test 0 error #4# ert--stats-test-end-times ert--stats 6 current-time ert-test-most-recent-result ert-test 4 ert--stats-set-test-and-result test-ended ert--stats-current-test 14 nil cl-struct-ert-test-tags result listener #5=#:v] 6)) ert-run-test listener cl-struct-ert-test-tags #6=#:v #7=#:v #8=#:v] 6 (#$ . 112551)])
#@76 Run the tests specified by SELECTOR, sending progress updates to LISTENER.
(defalias 'ert-run-tests #[(selector listener) "\306\307\"\310	\"\211\311H>\204\312\313\314\315#\210\n\211\316\317 I\210)
\320\n\"\210\307\321\216\n\322 \210\323\216	\324:\203T@\325\n
#\210A\211\202;*\324+\n+\207" [selector tests stats cl-struct-ert--stats-tags #1=#:v listener ert-select-tests t ert--make-stats 0 error #4="%s accessing a non-%s" ert--stats-start-time ert--stats 11 current-time run-started ((force-mode-line-update)) force-mode-line-update ((byte-code "\306H	>\204\307\310\311\312#\210\211\313I\210)\306H	>\204$\307\310\314\312#\210\211\315\316 I\210)
\317#\207" [stats cl-struct-ert--stats-tags #2=#:v abortedp #3=#:v listener 0 error #4# ert--stats-aborted-p ert--stats 13 ert--stats-end-time 12 current-time run-ended] 5)) nil ert-run-or-rerun-test abortedp ert--current-run-stats #5=#:--cl-var-- test] 5 (#$ . 113800)])
#@70 Return the position (index) of TEST in the run represented by STATS.
(defalias 'ert--stats-test-pos #[(stats test) "\303\304!	\305H\n>\204\306\307\310\311#\210	\312H\"\207" [test stats cl-struct-ert--stats-tags gethash ert--stats-test-key 0 error "%s accessing a non-%s" ert--stats-test-map ert--stats 3] 6 (#$ . 114768)])
#@68 Format TIME in the variant of ISO 8601 used for timestamps in ERT.
(defalias 'ert--format-time-iso8601 #[(time) "\301\302\"\207" [time format-time-string "%Y-%m-%d %T%z"] 3 (#$ . 115100)])
#@114 Return a character that represents the test result RESULT.

EXPECTEDP specifies whether the result was expected.
(defalias 'ert-char-for-test-result #[(result expectedp) "\306!\203G\307Y\203\310H	>\203\311\202u\306!\2032G\312Y\2032\310H\n>\2032\313\202u\204:\314\202u\306!\203SG\307Y\203S\310H>\203S\315\202u\306!\203lG\312Y\203l\310H\f>\203l\316\202u\317\320\321#\205u\322\211\203\200\310\202\201\323\234)\207" [result cl-struct-ert-test-passed-tags cl-struct-ert-test-failed-tags cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags s vectorp 3 0 ".P" 6 "fF" "--" "aA" "qQ" error "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-failed null ert-test-aborted-with-non-local-exit ert-test-quit) nil 1 expectedp] 5 (#$ . 115297)])
#@111 Return a string that represents the test result RESULT.

EXPECTEDP specifies whether the result was expected.
(defalias 'ert-string-for-test-result #[(result expectedp) "\306!\203G\307Y\203\310H	>\203\311\202u\306!\2032G\312Y\2032\310H\n>\2032\313\202u\204:\314\202u\306!\203SG\307Y\203S\310H>\203S\315\202u\306!\203lG\312Y\203l\310H\f>\203l\316\202u\317\320\321#\205u\322\211\203\200\310\202\201\323\234)\207" [result cl-struct-ert-test-passed-tags cl-struct-ert-test-failed-tags cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags s vectorp 3 0 ("passed" "PASSED") 6 ("failed" "FAILED") ("unknown" "UNKNOWN") ("aborted" "ABORTED") ("quit" "QUIT") error "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-failed null ert-test-aborted-with-non-local-exit ert-test-quit) nil 1 expectedp] 5 (#$ . 116111)])
#@104 Pretty-print OBJECT, indenting it to the current column of point.
Ensures a final newline is inserted.
(defalias 'ert--pp-with-indentation-and-newline #[(object) "`\302	p\"\210n\204\303c\210\212b\210\304 *\207" [begin object pp "\n" indent-sexp] 3 (#$ . 116999)])
#@111 Insert `ert-info' infos from RESULT into current buffer.

RESULT must be an `ert-test-result-with-condition'.
(defalias 'ert--insert-infos #[(result) "\306!\203G\307Y\203\310H	>\204\311\312\313\300E\"\210\310H	>\204+\314\315\316\313#\210\317H\320\211\205\220@\211\211\203F\f\211A@\202M\311\321\320\fGD\"`\322
G\323\\\324\"\320\325\216\f\326\261\210\327`!b\210\330
\261\210\331y\210`W\203\206c\210\331y\210\202u.A\211\2045\320*\207" [result cl-struct-ert-test-result-with-condition-tags info --dolist-tail-- message prefix vectorp 6 0 signal wrong-type-argument ert-test-result-with-condition error "%s accessing a non-%s" ert-test-result-with-condition-infos 5 nil wrong-number-of-arguments make-string 4 32 ((byte-code "\203	\301\211\223\210\301\207" [end nil] 3)) "\n" copy-marker "    " 1 end indentation begin] 6 (#$ . 117274)])
#@75 The maximum line length for printing backtraces in `ert-run-tests-batch'.
(defvar ert-batch-backtrace-right-margin 70 (#$ . 118161))
#@330 Run the tests specified by SELECTOR, printing results to the terminal.

SELECTOR works as described in `ert-select-tests', except if
SELECTOR is nil, in which case all tests rather than none will be
run; this makes the command line "emacs -batch -l my-tests.el -f
ert-run-tests-batch-and-exit" useful.

Returns the stats object.
(defalias 'ert-run-tests-batch #[(&optional selector) "\204\301\302\303\"\207" [selector t ert-run-tests #[(event-type &rest event-args) "\306\307\"\203G	\211G\310U\203\n@\202\311\312\313\nGD\"\314\315\316H\f>\204-\317\320\321\322#\210\323HG\324\316H\f>\204@\317\320\325\322#\210\326H!#*\207\306\327\"\203N
	\211G\323U\203_
\211A@\202f\311\312\313
GD\"
@@\330!\316H\f>\204|\317\320\331\322#\210\332HAB\314\333@\204\216\334\202\217\335\336!\337!\340B!\203\240\334\202\245\341\342B\"\324\316H\f>\204\264\317\320\343\322#\210\344H!\340A!\203\303\334\202\310\341\345A\"&\210\340B!?\205L
\314\346B\"\210\316H\f>\204\347\317\320\321\322#\210\323HC\347D\313\211EFDT\211DCGW\203G
CDH\211E\316HG>\204
\317\320\350\351#\210E\352HF\353EF\"\204\365\314\354\355F\313\"E\316HG>\204>
\317\320\356\351#\210E\310H#\210\202\365,\314\357\334\"-\207\306\360\"\203W
\313\207\306\361\"\203\235	\211HG\362U\203r
H\211AH@\202z
\311\312\313HGD\"H\211AH@EH@F\353EF\"\204B\363F!\203\306
FG\362Y\203\306
F\316HI>\203\306
\314\364E\316HG>\204\275
\317\320\356\351#\210E\310H\"\210\202B\363F!\203\313FG\365Y\203\313F\316HJ>\203\313\314\366E\316HG>\204\361
\317\320\356\351#\210E\310H\"\210\367\370!KrKq\210\371\216\372F\316HJ>\204\317\320\373\374#\210F\352H!\210eb\210m\204E`\313\210`LMLMN\\^L\314\357\375ML\"\"\210*\310y\210\202+\367\370!OrOq\210\376\216\377F!\210\201Wc\210\201X\201Y\201ZPQR\201[F\316HJ>\204\200\317\320\201\\\374#\210F\362H!\210+dSb\210\201]\201^!\204\237\311\201_\201`C\"\210\201a\310!\210\314\201bE\316HG>\204\271\317\320\356\351#\210E\310H\"\210\314\357\201c \"\210+\202B\363F!\203
FG\362Y\203
F\316HS>\203
\314\201dE\316HG>\204\370\317\320\356\351#\210E\310H\"\210\202B\363F!\2037FG\365Y\2037F\316HT>\2037\314\201eE\316HG>\204.\317\320\356\351#\210E\310H\"\210\202B\317\201fF\201g#\210\201h\316H\f>\204S\317\320\321\322#\210\323HG!U\201i\201hUG!\201jU\201k\260V\314V\355F\353EF\"\"\201lE\"TE\316HG>\204\225\317\320\356\351#\210E\310H$.\207\317\201m\201n#\205\252\313\207" [event-type event-args #1=#:--cl-rest-- stats cl-struct-ert--stats-tags #2=#:--cl-rest-- eql run-started 1 signal wrong-number-of-arguments nil message "Running %s tests (%s)" 0 error "%s accessing a non-%s" ert--stats-tests ert--stats 2 ert--format-time-iso8601 ert--stats-start-time 11 run-ended ert-stats-completed-unexpected ert--stats-failed-expected 9 "\n%sRan %s tests, %s results as expected%s (%s)%s\n" "" "Aborted: " ert-stats-total ert-stats-completed-expected zerop format ", %s unexpected" ert--stats-end-time 12 "\n%s expected failures" "%s unexpected results:" -1 ert-test-most-recent-result ert-test 4 ert-test-result-expected-p "%9s  %S" ert-string-for-test-result ert-test-name "%s" test-started test-ended 3 vectorp "Test %S passed unexpectedly" 6 "Test %S backtrace:" generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#3=#:temp-buffer buffer-name kill-buffer] 2)) ert--print-backtrace ert-test-result-with-condition-backtrace ert-test-result-with-condition buffer-substring-no-properties ((byte-code "\301!\203\n\302!\210\301\207" [#4=#:temp-buffer buffer-name kill-buffer] 2)) ert--insert-infos abortedp expected-failures unexpected #5=#:--cl-vec-- #6=#:--cl-idx-- test result cl-struct-ert-test-tags #7=#:--cl-rest-- cl-struct-ert-test-passed-tags cl-struct-ert-test-result-with-condition-tags #3# end start ert-batch-backtrace-right-margin #4# print-length print-level print-escape-newlines cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags max format-string "    " t 5 10 ert--pp-with-indentation-and-newline ert-test-result-with-condition-condition looking-at #8="\n" cl-assertion-failed (looking-at #8#) delete-char "Test %S condition:" buffer-string "Test %S aborted with non-local exit" "Quit during %S" "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-result-with-condition ert-test-aborted-with-non-local-exit ert-test-quit) prin1-to-string "%9s  %" "s/" "  %S" ert--stats-test-pos "cl-ecase failed: %s, %s" (run-started run-ended test-started test-ended)] 12]] 3 (#$ . 118301)])
#@266 Like `ert-run-tests-batch', but exits Emacs when done.

The exit status will be 0 if all test results were as expected, 1
on unexpected results, or 2 if the tool detected an error outside
of the tests (e.g. invalid SELECTOR or bug in the code that runs
the tests).
(defalias 'ert-run-tests-batch-and-exit #[(&optional selector) "\302\216\303!\304\305\306	!!\203\307\202\310!*\207" [selector stats ((byte-code "\300\216\301\302!\210\303 \210)\301\207" [((kill-emacs 2)) message "Error running tests" backtrace] 2)) ert-run-tests-batch kill-emacs zerop ert-stats-completed-unexpected 0 1] 4 (#$ . 122897)])
#@56 Activate font-lock keywords for some of ERT's symbols.
(defalias 'ert--activate-font-lock-keywords #[nil "\300\301\302\"\207" [font-lock-add-keywords nil (("(\\(\\<ert-deftest\\)\\>\\s *\\(\\sw+\\)?" (1 font-lock-keyword-face nil t) (2 font-lock-function-name-face nil t)))] 3 (#$ . 123514)])
#@142 Remove ELEMENT from the value of LIST-VAR if present.

This can be used as an inverse of `add-to-list'.

(fn LIST-VAR ELEMENT &key KEY TEST)
(defalias 'ert--remove-from-list #[(list-var element &rest #1=#:--cl-rest--) "\306>A@\307>A@\2038@\310>\203!AA\211\202\311>A@\203/\312\211\202\313\314@\"\210\202)	\204?\315\n\204E\316\f\211\317\fJ\306	\307\n&L+\207" [#1# key test #2=#:--cl-keys-- list-var #3=#:v :key :test (:key :test :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:key :test)" identity equal ert--remove* element] 9 (#$ . 123814)])
#@320 Read the name of a test and return it as a symbol.

Prompt with PROMPT.  If DEFAULT is a valid test name, use it as a
default.  HISTORY is the history to use; see `completing-read'.
If ADD-DEFAULT-TO-PROMPT is non-nil, PROMPT will be modified to
include the default, if any.

Signals an error if no test name was read.
(defalias 'ert-read-test-name #[(prompt &optional default history add-default-to-prompt) ";\203\306!\211\203\307	!\204\310)\202[9\203+\307!\205'\311!\202[\312!\203UG\313Y\203U\314H\n>\203U\314H\n>\204N\315\316\317\320#\210\321H\202[\315\322\323#\210\203p\204j\324\325\f\"\202o\324\326\f#\327\f
\307\330\310\310&\306!\307!\203\220\202\223\315\331!*\207" [default symbol cl-struct-ert-test-tags add-default-to-prompt prompt obarray intern-soft ert-test-boundp nil symbol-name vectorp 7 0 error "%s accessing a non-%s" ert-test-name ert-test 1 "cl-etypecase failed: %s, %s" (string symbol ert-test) format "%s: " "%s (default %s): " completing-read t "Input does not name a test" history input sym] 10 (#$ . 124426)])
#@200 Read the name of a test and return it as a symbol.
As a default, use the symbol at point, or the test at point if in
the ERT results buffer.  Prompt with PROMPT, augmented with the
default (if any).
(defalias 'ert-read-test-name-at-point #[(prompt) "\301\302 \303\304$\207" [prompt ert-read-test-name ert-test-at-point nil t] 5 (#$ . 125520)])
#@55 Find, in another window, the definition of TEST-NAME.
(defalias 'ert-find-test-other-window #[(test-name) "\301\302\303#\207" [test-name find-function-do-it ert-deftest switch-to-buffer-other-window] 4 (#$ . 125871) (list (ert-read-test-name-at-point "Find test definition: "))])
#@106 Make the test TEST-NAME unbound.

Nothing more than an interactive interface to `ert-make-test-unbound'.
(defalias 'ert-delete-test #[(test-name) "\301!\207" [test-name ert-make-test-unbound] 2 (#$ . 126159) (list (ert-read-test-name-at-point "Delete test"))])
#@45 Make all symbols in `obarray' name no test.
(defalias 'ert-delete-all-tests #[nil "\300\301!\203\302\303!\204\304\305!\210\306\307\310\311\312\"\"\210\313\207" [called-interactively-p any y-or-n-p "Delete all tests? " error "Aborted" mapc ert-make-test-unbound apropos-internal "" ert-test-boundp t] 5 (#$ . 126427) nil])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--ewoc-entry-test compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-test (or (and (memq (aref cl-x 0) cl-struct-ert--ewoc-entry-tags)) (error "%s accessing a non-%s" 'ert--ewoc-entry-test 'ert--ewoc-entry)) (aref cl-x 1)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--ewoc-entry-test #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--ewoc-entry-tags 0 error "%s accessing a non-%s" ert--ewoc-entry-test ert--ewoc-entry 1] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--ewoc-entry-hidden-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-hidden-p (or (and (memq (aref cl-x 0) cl-struct-ert--ewoc-entry-tags)) (error "%s accessing a non-%s" 'ert--ewoc-entry-hidden-p 'ert--ewoc-entry)) (aref cl-x 2)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--ewoc-entry-hidden-p #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--ewoc-entry-tags 0 error "%s accessing a non-%s" ert--ewoc-entry-hidden-p ert--ewoc-entry 2] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--ewoc-entry-expanded-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-expanded-p (or (and (memq (aref cl-x 0) cl-struct-ert--ewoc-entry-tags)) (error "%s accessing a non-%s" 'ert--ewoc-entry-expanded-p 'ert--ewoc-entry)) (aref cl-x 3)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--ewoc-entry-expanded-p #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--ewoc-entry-tags 0 error "%s accessing a non-%s" ert--ewoc-entry-expanded-p ert--ewoc-entry 3] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--ewoc-entry-extended-printer-limits-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-extended-printer-limits-p (or (and (memq (aref cl-x 0) cl-struct-ert--ewoc-entry-tags)) (error "%s accessing a non-%s" 'ert--ewoc-entry-extended-printer-limits-p 'ert--ewoc-entry)) (aref cl-x 4)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--ewoc-entry-extended-printer-limits-p #[(cl-x) "\302H	>\204\303\304\305\306#\210\307H\207" [cl-x cl-struct-ert--ewoc-entry-tags 0 error "%s accessing a non-%s" ert--ewoc-entry-extended-printer-limits-p ert--ewoc-entry 4] 4])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put ert--ewoc-entry-p compiler-macro #[(_cl-whole-arg cl-x) "\301\302\303\304\211\211&\207" [cl-x cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-p (and (vectorp cl-x) (>= (length cl-x) 5) (memq (aref cl-x 0) cl-struct-ert--ewoc-entry-tags) t)) nil] 7] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
(defalias 'ert--ewoc-entry-p #[(cl-x) "\302!\205G\303Y\205\304H	>\205\305\207" [cl-x cl-struct-ert--ewoc-entry-tags vectorp 5 0 t] 2])
(defalias 'copy-ert--ewoc-entry #[(x) "\301!\207" [x copy-sequence] 2])
(byte-code "\301\302\303\304#\210\305\301\302\306\307\310!!#\210)\301\207" [file put make-ert--ewoc-entry compiler-macro #[(cl-whole &rest #1=#:--cl-rest--) "\306>\206\307A@\310>\206\311A@\312>\206\313A@\314>A@
\203P
@\315>\2039
AA\211\202'\316>A@\203G\317\211\202'\320\321
@\"\210\202&)\322\323\324\317\317	\n\f&	,\207" [#1# test hidden-p expanded-p extended-printer-limits-p #:--cl-keys-- :test (nil (assert nil)) :hidden-p (nil (assert nil)) :expanded-p (nil t) :extended-printer-limits-p (:test :hidden-p :expanded-p :extended-printer-limits-p :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:test :hidden-p :expanded-p :extended-printer-limits-p)" cl--defsubst-expand (test hidden-p expanded-p extended-printer-limits-p) (cl-block make-ert--ewoc-entry (vector 'cl-struct-ert--ewoc-entry test hidden-p expanded-p extended-printer-limits-p)) cl-whole] 11 "\n\n(fn CL-WHOLE &cl-quote &key TEST HIDDEN-P EXPANDED-P EXTENDED-PRINTER-LIMITS-P)"] "/builddir/build/BUILD/emacs-24.3/lisp/emacs-lisp/ert.el" compiler-macro-file purecopy file-name-nondirectory] 6)
#@64 

(fn &key TEST HIDDEN-P EXPANDED-P EXTENDED-PRINTER-LIMITS-P)
(defalias 'make-ert--ewoc-entry #[(&rest #1=#:--cl-rest--) "\306>\206\307\310\311\307C\"\210\307DA@\312>\206!\307\310\311\307C\"\210\307DA@\313>\206+\314A@\315>A@
\203`
@\316>\203I
AA\211\2027\317>A@\203W\307\211\2027\320\321
@\"\210\2026)\322\323	\n\f%,\207" [#1# test hidden-p expanded-p extended-printer-limits-p #2=#:--cl-keys-- :test nil signal cl-assertion-failed :hidden-p :expanded-p (nil t) :extended-printer-limits-p (:test :hidden-p :expanded-p :extended-printer-limits-p :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:test :hidden-p :expanded-p :extended-printer-limits-p)" vector cl-struct-ert--ewoc-entry] 7 (#$ . 131577)])
(byte-code "\301C\302\303\304\305#\210\302\303\306\307#\210\302\303\310\311#\210\302\303\312\313#\210\302\314\315\313#\210\302\316\315\317#\210\302\320\315\313#\210\302\321\315\313#\210\302\322\315\313#\210\302\323\315\313#\207" [cl-struct-ert--ewoc-entry-tags cl-struct-ert--ewoc-entry put ert--ewoc-entry cl-struct-slots ((cl-tag-slot) (test (assert nil)) (hidden-p (assert nil)) (expanded-p t) (extended-printer-limits-p nil)) cl-struct-type (vector nil) cl-struct-include nil cl-struct-print t copy-ert--ewoc-entry side-effect-free ert--ewoc-entry-p error-free ert--ewoc-entry-extended-printer-limits-p ert--ewoc-entry-expanded-p ert--ewoc-entry-hidden-p ert--ewoc-entry-test] 4)
#@42 Insert a button that links to TEST-NAME.
(defalias 'ert-insert-test-name-button #[(test-name) "\301\302\303\"\304\305\306%\207" [test-name insert-text-button format "%S" :type ert--test-name-button ert-test-name] 6 (#$ . 133023)])
#@78 Return a string indicating EXPECTED expected results, UNEXPECTED unexpected.
(defalias 'ert--results-format-expected-unexpected #[(expected unexpected) "\302!\203\303\304	\"\207\303\305	\\#\207" [unexpected expected zerop format "%s" "%s (%s unexpected)"] 4 (#$ . 133262)])
#@131 Update the header and footer of EWOC to show certain information from STATS.

Also sets `ert--results-progress-bar-button-begin'.
(defalias 'ert--results-update-ewoc-hf #[(ewoc stats) "\306!p	\307
\310\311!@r@q\210\312\216\313c\210\314\315HA>\204)\316\317\320\321#\210\322H!\210\323c\210\324\325\326\315HA>\204C\316\317\327\321#\210\330H\315HA>\204U\316\317\331\321#\210\332H\"\326\315HA>\204i\316\317\333\321#\210\334H\315HA>\204{\316\317\335\321#\210\336H\"\f\337!%c\210\324\340\341\315HA>\204\230\316\317\342\321#\210\343H!\"c\210\315HA>\204\256\316\317\344\321#\210\345H\203\270\346\202\353\315HA>\204\307\316\317\347\321#\210\350H\203\321\351\202\353\315HA>\204\340\316\317\352\321#\210\353H\203\352\354\202\353\355B\356B\355\"\203\373\357c\210\202\353
\356B\346\"\203[
\315HA>\204
\316\317\347\321#\210\350H\203U
\360c\210\361\315HA>\204+
\316\317\347\321#\210\350H\315HC>\204<
\316\317\362\363#\210\315HA>\204K
\316\317\347\321#\210\350H\322H!\210\202\353
\364c\210\202\353
\356B\351\"\203\273
\315HA>\204r
\316\317\347\321#\210\350H\204~
\365\366\367C\"\210\370c\210\361\315HA>\204\221
\316\317\347\321#\210\350H\315HC>\204\242
\316\317\362\363#\210\315HA>\204\261
\316\317\347\321#\210\350H\322H!\210\202\353
\356B\354\"\203\344
\315HA>\204\322
\316\317\347\321#\210\350H\203\336
\365\366\371C\"\210\372c\210\202\353
\316\373B\374#\210\323c\210\315HA>\204\375
\316\317\352\321#\210\353H\2039\324\375\315HA>\204\316\317\344\321#\210\345H\203\376\202\377\341\315HA>\204/\316\317\352\321#\210\353H!#c\210\202<\323c\210\323c\210)rq\210D)E\201HE\201I\201J\201K\n\203c\201L!\206f\201M%Frq\210\201N\201G!\210FG+\201Oc\210\201P +\323#+\207" [stats font-lock-mode font-lock results-buffer run-count ewoc ert-stats-completed ewoc-set-hf generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) "Selector: " ert--insert-human-readable-selector 0 error "%s accessing a non-%s" ert--stats-selector ert--stats 1 "\n" format "Passed: %s\nFailed: %s\nTotal:  %s/%s\n\n" ert--results-format-expected-unexpected ert--stats-passed-expected 7 ert--stats-passed-unexpected 8 ert--stats-failed-expected 9 ert--stats-failed-unexpected 10 ert-stats-total "Started at:   %s\n" ert--format-time-iso8601 ert--stats-start-time 11 ert--stats-aborted-p 13 aborted ert--stats-current-test 14 running ert--stats-end-time 12 finished preparing eql "" "Aborted during test: " ert-insert-test-name-button ert-test-name ert-test "Aborted." signal cl-assertion-failed (ert--stats-current-test stats) "Running test: " (not (ert--stats-current-test stats)) "Finished." "cl-ecase failed: %s, %s" (preparing aborted running finished) "%s%s\n" "Aborted at:   " "Finished at:  " #1# cl-struct-ert--stats-tags state cl-struct-ert-test-tags ert--results-progress-bar-string progress-bar-string progress-bar-button-begin ert--results-progress-bar-button-begin insert-text-button :type ert--results-progress-bar-button face ert-face-for-stats button make-local-variable "\n\n" buffer-string] 11 (#$ . 133548)])
#@205 How many seconds ERT should wait between redisplays while running tests.

While running tests, ERT shows the current progress, and this variable
determines how frequently the progress display is updated.
(defvar ert-test-run-redisplay-interval-secs 0.1 (#$ . 136713))
#@56 Update EWOC and the mode line to show data from STATS.
(defalias 'ert--results-update-stats-display #[(ewoc stats) "\305	\"\210\306 \210\307\310!\210	\311H\n>\204\312\313\314\315#\210	\211\316\317 \f\\I)\207" [ewoc stats cl-struct-ert--stats-tags #1=#:v ert-test-run-redisplay-interval-secs ert--results-update-ewoc-hf force-mode-line-update redisplay t 0 error "%s accessing a non-%s" ert--stats-next-redisplay ert--stats 15 float-time] 5 (#$ . 136987)])
#@137 Call `ert--results-update-stats-display' if not called recently.

EWOC and STATS are arguments for `ert--results-update-stats-display'.
(defalias 'ert--results-update-stats-display-maybe #[(ewoc stats) "\303 \304H	>\204\305\306\307\310#\210\311HY\205\312\n\"\207" [stats cl-struct-ert--stats-tags ewoc float-time 0 error "%s accessing a non-%s" ert--stats-next-redisplay ert--stats 15 ert--results-update-stats-display] 5 (#$ . 137454)])
#@69 Return a string for the mode line that shows the test run progress.
(defalias 'ert--tests-running-mode-line-indicator #[nil "\306	!\307	!\211\nY\203\310\311\n#\202j\310\312T\n	\313H\f>\204+\314\315\316\317#\210	\320H\2045\321\202i\310\322	\313H\f>\204E\314\315\316\317#\210	\320H\313H
>\204U\314\315\323\324#\210	\313H\f>\204c\314\315\316\317#\210	\320H\325H\"$+\207" [ert--current-run-stats stats tests-total tests-completed cl-struct-ert--stats-tags cl-struct-ert-test-tags ert-stats-total ert-stats-completed format " ERT(%s/%s,finished)" " ERT(%s/%s):%s" 0 error "%s accessing a non-%s" ert--stats-current-test ert--stats 14 "?" "%S" ert-test-name ert-test 1] 11 (#$ . 137905)])
#@121 Attach cross-references to function names between BEGIN and END.

BEGIN and END specify a region in the current buffer.
(defalias 'ert--make-xrefs-region #[(begin end) "\212\214	}\210\303\304 +\207" [begin end debugger-previous-backtrace nil debugger-make-xrefs] 2 (#$ . 138610)])
#@118 Return the first line of S, or S if it contains no newlines.

The return value does not include the line terminator.
(defalias 'ert--string-first-line #[(s) "\301\302\303\"O\207" [s 0 ert--string-position 10] 5 (#$ . 138900)])
#@191 Return a face that shows whether a test result was expected or unexpected.

If EXPECTEDP is nil, returns the face for unexpected results; if
non-nil, returns the face for expected results..
(defalias 'ert-face-for-test-result #[(expectedp) "\203\301\207\302\207" [expectedp ert-test-result-expected ert-test-result-unexpected] 1 (#$ . 139136)])
#@38 Return a face that represents STATS.
(defalias 'ert-face-for-stats #[(stats) "\302H	>\204\303\304\305\306#\210\307H\203\310\207\311!\211\302V\262
\203%\312\310!\207\313\314!\315!\"\2034\312\316!\207\310\207" [stats cl-struct-ert--stats-tags 0 error "%s accessing a non-%s" ert--stats-aborted-p ert--stats 13 nil ert-stats-completed-unexpected ert-face-for-test-result eql ert-stats-completed-expected ert-stats-total t] 4 (#$ . 139490)])
#@78 The ewoc print function for ewoc test entries.  ENTRY is the entry to print.
(defalias 'ert--print-test-for-ewoc #[(entry) "\306H	>\204\307\310\311\312#\210\313H\314\f\n\"\211\204#\315\316\305C\"\210\f\306H@>\2042\307\310\317\320#\210\f\321H
H)A\306H	>\204H\307\310\322\312#\210\323HB\306H	>\204[\307\310\324\312#\210\325HC\306H	>\204n\307\310\326\312#\210\321HDB\204\316
\327\nA\"E\330\331\332\333AE\"\"\334\335\336F\203\230\337E!\206\231\340%\210)\341c\210\342\n\306HG>\204\257\307\310\343\344#\210\n\313H!\210\345c\210C\203\316
\346A\347\"\204\316
\n\306HG>\204\323\307\310\350\344#\210\n\323H\203\366\351\352\353\n\306HG>\204\353\307\310\350\344#\210\n\323H!\354\355#\345\261\210\356A!\203&
AG\325Y\203&
A\306HH>\203&
\327\nA\"\203
\357c\210\202 
\360c\210\361c\210\202\313
\356A!\203\206
AG\362Y\203\206
A\306HI>\203\206
\363A!\210\364D\203N
\365\202O
\362D\203X
\366\202Y
\367JKL\351c\210`M\370A\306HI>\204v
\307\310\371\372#\210A\325H!\210\373M`\"\210,\202\313
\356A!\203\245
AG\325Y\203\245
A\306HN>\203\245
\374c\210\202\313
\356A!\203\304
AG\362Y\203\304
A\306HO>\203\304
\375c\210\202\313
\307\376A\377#\210\345c\210.\347\207" [entry cl-struct-ert--ewoc-entry-tags test ert--results-stats stats pos 0 error "%s accessing a non-%s" ert--ewoc-entry-test ert--ewoc-entry 1 ert--stats-test-pos signal cl-assertion-failed ert--stats-test-results ert--stats 4 ert--ewoc-entry-hidden-p 2 ert--ewoc-entry-expanded-p 3 ert--ewoc-entry-extended-printer-limits-p ert-test-result-expected-p insert-text-button format "%c" ert-char-for-test-result :type ert--results-expand-collapse-button face ert-face-for-test-result button " " ert-insert-test-name-button ert-test-name ert-test "\n" eql nil ert-test-documentation "    " propertize ert--string-first-line font-lock-face font-lock-doc-face vectorp "    passed\n" "    passed unexpectedly\n" "" 6 ert--insert-infos t 12 100 10 ert--pp-with-indentation-and-newline ert-test-result-with-condition-condition ert-test-result-with-condition ert--make-xrefs-region "    aborted\n" "    quit\n" "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-result-with-condition ert-test-aborted-with-non-local-exit ert-test-quit) cl-struct-ert--stats-tags result hiddenp expandedp extended-printer-limits-p expectedp font-lock-mode cl-struct-ert-test-tags cl-struct-ert-test-passed-tags cl-struct-ert-test-result-with-condition-tags print-length print-level print-escape-newlines begin cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags] 8 (#$ . 139945)])
#@145 Redraw the ERT results buffer after font-lock-mode was switched on or off.

ENABLEDP is true if font-lock-mode is switched on, false
otherwise.
(defalias 'ert--results-font-lock-function #[(enabledp) "\303	\"\210\304!\210\305\n!\207" [ert--results-ewoc ert--results-stats enabledp ert--results-update-ewoc-hf ewoc-refresh font-lock-default-function] 3 (#$ . 142550)])
#@145 Set up a test results buffer.

STATS is the stats object; LISTENER is the results listener;
BUFFER-NAME, if non-nil, is the buffer name to use.
(defalias 'ert--setup-results-buffer #[(stats listener buffer-name) "\204\306\307!r	q\210\310\311 \210\312 \210\313 \210\312 \210\314\303!\210\315\316\317\320\211\310$\314\305!\210\f\314\321!\210\"\314\322!\210\323\324\"!\325\320\310\"\"\314\326!\210#\"\327H$>\204_\330\331\332\333#\210\"\334H%\335&\320'&T\211&%GW\203\216%&H'\336\f\337\340'\310\211\320%\"\210\202k+\341
\"\210dSb\210	,\207" [buffer-name buffer inhibit-read-only font-lock-function ewoc ert--results-ewoc "*ert*" get-buffer-create t buffer-disable-undo erase-buffer ert-results-mode make-local-variable ert--results-font-lock-function ewoc-create ert--print-test-for-ewoc nil ert--results-stats ert--results-progress-bar-string make-string ert-stats-total ert-char-for-test-result ert--results-listener 0 error "%s accessing a non-%s" ert--stats-tests ert--stats 2 -1 ewoc-enter-last vector cl-struct-ert--ewoc-entry ert--results-update-ewoc-hf stats listener cl-struct-ert--stats-tags #1=#:--cl-vec-- #2=#:--cl-idx-- test] 8 (#$ . 142927)])
#@51 List of recent test selectors read from terminal.
(defvar ert--selector-history nil (#$ . 144123))
#@283 Run the tests specified by SELECTOR and display the results in a buffer.

SELECTOR works as described in `ert-select-tests'.
OUTPUT-BUFFER-NAME and MESSAGE-FN should normally be nil; they
are used for automated self-tests and specify which buffer to use
and how to display message.
(defalias 'ert-run-tests-interactively #[(selector &optional output-buffer-name message-fn) "\204\306\307\310!\307\311!\307\312!\307\313!\211\211L\210)\211\314L\210)\n\211\314L\210)	\211L\210)\n\211\315\316\317\320\321D\320	D\320\nD\320D\320\fD\322\257EL\210)\323\nJ\",\207" [message-fn #1=#:--cl-message-fn-- #2=#:--cl-listener-- #3=#:--cl-buffer-- #4=#:--cl-output-buffer-name-- #5=#:v message make-symbol "--output-buffer-name--" "--buffer--" "--listener--" "--message-fn--" nil lambda (&rest --cl-rest--) apply quote #[(#6=#:G12606 #7=#:G12607 #8=#:G12608 #9=#:G12609 event-type &rest event-args) "\306\307\"\2032	\211G\310U\203\n@\202\311\312\313\nGD\"\f\211\314.J/J#L\210)\315\fJ!*\207\306\316\"\203\224	\2110G\317U\203M0\211A0@\202U\311\312\3130GD\"0@12J\3201\204h\321\202i\322\323!\324!\325!3\3263!\203\321\202\204\327\3303\")%\210\331r\fJq\2104)\"+\207\306\332\"\203
	\2115G\317U\203\2575\211A5@\202\267\311\312\3135GD\"5@6r\fJq\21047\3336\"8\33478\"\211\204\337\311\335\336C\"\210\317H\2119\337H:>\204\364\340\341\342\343#\2109\211;\3106I\210*<8\344\313\345\"I\210\3467\"\210\3477\".\207\306\350\"\203\301
	\211=G\351U\2033
=\211A=@\202;
\311\312\313=GD\"=\211A=@6=@>r\fJq\21047\3336\"8\33478\"\211\317H\2119\337H:>\204v
\340\341\352\343#\2109\317H)\203\242
\317H\2119\337H:>\204\223
\340\341\352\343#\2109\211?\317\3536>\"I\210*<8\344>\3536>\"\"I\210\3467\"\210\3477\".\207\340\354\355#\205\312
\313\207" [event-type event-args #10=#:--cl-rest-- stats #8# #11=#:v eql run-started 1 signal wrong-number-of-arguments nil ert--setup-results-buffer pop-to-buffer run-ended 2 "%sRan %s tests, %s results were as expected%s" "" "Aborted: " ert-stats-total ert-stats-completed-expected ert-stats-completed-unexpected zerop format ", %s unexpected" ert--results-update-stats-display test-started ert--stats-test-pos ewoc-nth cl-assertion-failed node 0 error "%s accessing a non-%s" ert--ewoc-entry-test ert--ewoc-entry ert-char-for-test-result t ert--results-update-stats-display-maybe ewoc-invalidate test-ended 3 ert--ewoc-entry-hidden-p ert-test-result-expected-p "cl-ecase failed: %s, %s" (run-started run-ended test-started test-ended) #7# #9# #12=#:--cl-rest-- abortedp #6# unexpected ert--results-ewoc #13=#:--cl-rest-- test ewoc pos cl-x cl-struct-ert--ewoc-entry-tags #14=#:v ert--results-progress-bar-string #15=#:--cl-rest-- result #16=#:v] 9] --cl-rest-- ert-run-tests output-buffer-name #17=#:v #18=#:v #19=#:v #20=#:v selector] 11 (#$ . 144229) (list (let ((default (if ert--selector-history (car ert--selector-history) "t"))) (read-from-minibuffer (if (null default) "Run tests: " (format "Run tests (default %s): " default)) nil nil t 'ert--selector-history default nil)) nil)])
(byte-code "\300\301\302\"\210\303\304N\204\305\303\304\306\307!#\210\310\311!\204\305\311\312\313#\210\300\207" [defalias ert ert-run-tests-interactively ert-simple-view-mode-hook variable-documentation put purecopy "Hook run when entering ERT-View mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ert-simple-view-mode-map definition-name ert-simple-view-mode] 5)
(defvar ert-simple-view-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [ert-simple-view-mode-map variable-documentation put purecopy "Keymap for `ert-simple-view-mode'." boundp ert-simple-view-mode-syntax-table definition-name ert-simple-view-mode] 5)
(defvar ert-simple-view-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ert-simple-view-mode-syntax-table variable-documentation put purecopy "Syntax table for `ert-simple-view-mode'." ert-simple-view-mode-abbrev-table definition-name ert-simple-view-mode] 5)
(defvar ert-simple-view-mode-abbrev-table (progn (define-abbrev-table 'ert-simple-view-mode-abbrev-table nil) ert-simple-view-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ert-simple-view-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `ert-simple-view-mode'." ert-simple-view-mode derived-mode-parent special-mode] 5)
#@250 Major mode for viewing auxiliary information in ERT.

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `ert-simple-view-mode-hook', as the final step
during initialization.

\{ert-simple-view-mode-map}
(defalias 'ert-simple-view-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V=\204V\326\325C#\210\327!\210\330\f!\210)\331\332!\207" [delay-mode-hooks major-mode mode-name ert-simple-view-mode-map ert-simple-view-mode-syntax-table parent make-local-variable t special-mode ert-simple-view-mode "ERT-View" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks ert-simple-view-mode-hook ert-simple-view-mode-abbrev-table local-abbrev-table] 6 (#$ . 148877) nil])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [ert-results-mode-hook variable-documentation put purecopy "Hook run when entering ERT-Results mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp ert-results-mode-map definition-name ert-results-mode] 5)
(defvar ert-results-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [ert-results-mode-map variable-documentation put purecopy "Keymap for `ert-results-mode'." boundp ert-results-mode-syntax-table definition-name ert-results-mode] 5)
(defvar ert-results-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ert-results-mode-syntax-table variable-documentation put purecopy "Syntax table for `ert-results-mode'." ert-results-mode-abbrev-table definition-name ert-results-mode] 5)
(defvar ert-results-mode-abbrev-table (progn (define-abbrev-table 'ert-results-mode-abbrev-table nil) ert-results-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [ert-results-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `ert-results-mode'." ert-results-mode derived-mode-parent special-mode] 5)
#@238 Major mode for viewing results of ERT test runs.

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `ert-results-mode-hook', as the final step
during initialization.

\{ert-results-mode-map}
(defalias 'ert-results-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V=\204V\326\325C#\210\327!\210\330\f!\210)\331\332!\207" [delay-mode-hooks major-mode mode-name ert-results-mode-map ert-results-mode-syntax-table parent make-local-variable t special-mode ert-results-mode "ERT-Results" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks ert-results-mode-hook ert-results-mode-abbrev-table local-abbrev-table] 6 (#$ . 151304) nil])
(byte-code "\305\306\211\306:\203&@\211\211A@	@\307\f\n#\210A\211\202	,\306\207" [#:--cl-var-- #:--cl-var-- key binding ert-results-mode-map (("	" forward-button) ([backtab] backward-button) ("j" ert-results-jump-between-summary-and-result) ("L" ert-results-toggle-printer-limits-for-test-at-point) ("n" ert-results-next-test) ("p" ert-results-previous-test) ("R" ert-results-rerun-all-tests) ("r" ert-results-rerun-test-at-point) ("d" ert-results-rerun-test-at-point-debugging-errors) ("." ert-results-find-test-at-point-other-window) ("b" ert-results-pop-to-backtrace-for-test-at-point) ("m" ert-results-pop-to-messages-for-test-at-point) ("l" ert-results-pop-to-should-forms-for-test-at-point) ("h" ert-results-describe-test-at-point) ("D" ert-delete-test) ("T" ert-results-pop-to-timings)) nil define-key] 5)
#@30 Menu for `ert-results-mode'.
(defvar ert-results-mode-menu nil (#$ . 153139))
(byte-code "\301\302\303\304$\210\305\306\307\310\311\312%\210\305\313\307\314\311\315%\210\305\316\307\317\311\320%\207" [ert-results-mode-map easy-menu-do-define ert-results-mode-menu "Menu for `ert-results-mode'." ("ERT Results" ["Re-run all tests" ert-results-rerun-all-tests] "--" ["Re-run test" ert-results-rerun-test-at-point] ["Debug test" ert-results-rerun-test-at-point-debugging-errors] ["Show test definition" ert-results-find-test-at-point-other-window] "--" ["Show backtrace" ert-results-pop-to-backtrace-for-test-at-point] ["Show messages" ert-results-pop-to-messages-for-test-at-point] ["Show `should' forms" ert-results-pop-to-should-forms-for-test-at-point] ["Describe test" ert-results-describe-test-at-point] "--" ["Delete test" ert-delete-test] "--" ["Show execution time of each test" ert-results-pop-to-timings]) define-button-type ert--results-progress-bar-button action ert--results-progress-bar-button-action help-echo "mouse-2, RET: Reveal test result" ert--test-name-button ert--test-name-button-action "mouse-2, RET: Find test definition" ert--results-expand-collapse-button ert--results-expand-collapse-button-action "mouse-2, RET: Expand/collapse test result"] 6)
#@107 If point is on a valid ewoc node, return it; return nil otherwise.

To be used in the ERT results buffer.
(defalias 'ert--results-test-node-or-null-at-point #[nil "\305	!\211\205-`\306\n!Y\205-\n\307H\211\310H\f>\204$\311\312\313\314#\210\307H)?\205-\n*\207" [ert--results-ewoc ewoc node cl-x cl-struct-ert--ewoc-entry-tags ewoc-locate ewoc-location 2 0 error "%s accessing a non-%s" ert--ewoc-entry-hidden-p ert--ewoc-entry] 5 (#$ . 154420)])
#@112 If point is on a valid ewoc node, return it; signal an error otherwise.

To be used in the ERT results buffer.
(defalias 'ert--results-test-node-at-point #[nil "\300 \206\301\302!\207" [ert--results-test-node-or-null-at-point error "No test at point"] 2 (#$ . 154880)])
#@69 Move point to the next test.

To be used in the ERT results buffer.
(defalias 'ert-results-next-test #[nil "\301\302!\303\304#\207" [ert--results-ewoc ert--results-move ewoc-locate ewoc-next "No tests below"] 4 (#$ . 155158) nil])
#@73 Move point to the previous test.

To be used in the ERT results buffer.
(defalias 'ert-results-previous-test #[nil "\301\302!\303\304#\207" [ert--results-ewoc ert--results-move ewoc-locate ewoc-prev "No tests above"] 4 (#$ . 155396) nil])
#@234 Move point from NODE to the previous or next node.

EWOC-FN specifies the direction and should be either `ewoc-prev'
or `ewoc-next'.  If there are no more nodes in that direction, an
error is signaled with the message ERROR-MESSAGE.
(defalias 'ert--results-move #[(node ewoc-fn error-message) "\300\301\215\207" [--cl-block-nil-- (byte-code "	\n\"\211\204\306\307\"\210\n\310H\211\311H
>\204 \306\312\313\314#\210\f\310H)\204\315\n!b\210\316\317\320\"\210\202" [ewoc-fn ert--results-ewoc node error-message cl-x cl-struct-ert--ewoc-entry-tags error "%s" 2 0 "%s accessing a non-%s" ert--ewoc-entry-hidden-p ert--ewoc-entry ewoc-location throw --cl-block-nil-- nil] 5)] 2 (#$ . 155643)])
#@53 Expand or collapse the test node BUTTON belongs to.
(defalias 'ert--results-expand-collapse-button-action #[(button) "\212\306 b\210\307 )\211\310H\211\311H\f>\204\312\313\314\315#\210\211\316\311H\f>\204/\312\313\314\315#\210\316H?I\210)\317	\n\"+\207" [ert--results-ewoc ewoc node entry cl-struct-ert--ewoc-entry-tags #1=#:v ert--button-action-position ert--results-test-node-at-point 2 0 error "%s accessing a non-%s" ert--ewoc-entry-expanded-p ert--ewoc-entry 3 ewoc-invalidate] 7 (#$ . 156347)])
#@100 Find the definition of the test at point in another window.

To be used in the ERT results buffer.
(defalias 'ert-results-find-test-at-point-other-window #[nil "\301 \211\204\302\303!\210\304!)\207" [name ert-test-at-point error "No test at point" ert-find-test-other-window] 3 (#$ . 156866) nil])
#@71 Find the definition of the test BUTTON belongs to, in another window.
(defalias 'ert--test-name-button-action #[(button) "\302\303\"\304	!)\207" [button name button-get ert-test-name ert-find-test-other-window] 3 (#$ . 157174)])
#@69 Return the position of NODE in EWOC, or nil if NODE is not in EWOC.
(defalias 'ert--ewoc-position #[(ewoc node) "\300\301\215\207" [--cl-block-nil-- (byte-code "\305\306\307\211\203\310\305\"\202\311	\"\312\f	\"\203\"\313\314\"\210T\306\211\202" [i node-here #1=#:--cl-var-- ewoc node 0 nil t ewoc-nth ewoc-next eql throw --cl-block-nil--] 4)] 2 (#$ . 157411)])
#@228 Jump back and forth between the test run summary and individual test results.

From an ewoc node, jumps to the character that represents the
same test in the progress bar, and vice versa.

To be used in the ERT results buffer.
(defalias 'ert-results-jump-between-summary-and-result #[nil "	\306 \203\307 \310\f\"\n
\\b*\202t\n`X\203r`\311\312\n!!W\203r\313`\nZ\"\211\314H\211\315H>\204D\316\317\320\321#\210\314H\203j\315H>\204[\316\317\320\321#\210\211\314\322I\210)\323\f\"\210\324\f\"*\202t\nb*\207" [ert--results-ewoc ert--results-progress-bar-button-begin progress-bar-begin ewoc node pos ert--results-test-node-or-null-at-point ert--results-test-node-at-point ert--ewoc-position button-end button-at ewoc-nth 2 0 error "%s accessing a non-%s" ert--ewoc-entry-hidden-p ert--ewoc-entry nil ewoc-invalidate ewoc-goto-node entry cl-struct-ert--ewoc-entry-tags #1=#:v] 5 (#$ . 157797) nil])
#@67 Return the name of the test at point as a symbol, or nil if none.
(defalias 'ert-test-at-point #[nil "\305\306\"\203#\307 \211\205	\310H\n>\204\311\312\313\314#\210	\315H)\2063\316\317!\320!\321\f!\2052\f*\207" [major-mode test cl-struct-ert-test-tags thing sym eql ert-results-mode ert--results-test-at-point-no-redefinition 0 error "%s accessing a non-%s" ert-test-name ert-test 1 thing-at-point symbol intern-soft ert-test-boundp] 5 (#$ . 158728)])
#@74 Return the test at point, or nil.

To be used in the ERT results buffer.
(defalias 'ert--results-test-at-point-no-redefinition #[nil "\306\307\"\204
\310\311\312C\"\210\313 \203,\314 \211\315H\211\316H>\204'\317\320\321\322#\210\n\323H*\207\f\211`X\205[`\324\325
!!W\205[`
Z\316H>\204S\317\320\326\327#\210\315HH))\207" [major-mode node cl-x cl-struct-ert--ewoc-entry-tags ert--results-progress-bar-button-begin progress-bar-begin eql ert-results-mode signal cl-assertion-failed (eql major-mode 'ert-results-mode) ert--results-test-node-or-null-at-point ert--results-test-node-at-point 2 0 error "%s accessing a non-%s" ert--ewoc-entry-test ert--ewoc-entry 1 button-end button-at ert--stats-tests ert--stats test-index ert--results-stats cl-struct-ert--stats-tags] 5 (#$ . 159198)])
#@599 Look up the test at point, and check whether it has been redefined.

To be used in the ERT results buffer.

Returns a list of two elements: the test (or nil) and a symbol
specifying whether the test has been redefined.

If a new test has been defined with the same name as the test at
point, replaces the test at point with the new test, and returns
the new test and the symbol `redefined'.

If the test has been deleted, returns the old test and the symbol
`deleted'.

If the test is still current, returns the test and the symbol nil.

If there is no test at point, returns a list with two nils.
(defalias 'ert--results-test-at-point-allow-redefinition #[nil "\305 \211\204\306\202d\307H	>\204\310\311\312\313#\210\314H\204%\315B\202d\307H	>\2043\310\311\312\313#\210\314H\316\n!\205@\317\n!\320\"\203N\321B\202c\204X\322B\202c\323\324\f\"\"\210\325B*)\207" [test cl-struct-ert-test-tags name new-test ert--results-stats ert--results-test-at-point-no-redefinition (nil nil) 0 error "%s accessing a non-%s" ert-test-name ert-test 1 (nil) ert-test-boundp ert-get-test eql (nil) (deleted) ert--results-update-after-test-redefinition ert--stats-test-pos (redefined)] 5 (#$ . 160009)])
#@139 Update results buffer after the test at pos POS has been redefined.

Also updates the stats object.  NEW-TEST is the new test
definition.
(defalias 'ert--results-update-after-test-redefinition #[(pos new-test) "\n\306\f\"\211\307H\310	\f\311$\210\312H>\204&\313\314\315\316#\210\211\317I\210)\f\320\311\321\"I\210*\322
\"\210,\311\207" [ert--results-stats stats ert--results-ewoc ewoc pos node ewoc-nth 2 ert--stats-set-test-and-result nil 0 error "%s accessing a non-%s" ert--ewoc-entry-test ert--ewoc-entry 1 ert-char-for-test-result t ewoc-invalidate entry new-test cl-struct-ert--ewoc-entry-tags #1=#:v ert--results-progress-bar-string #2=#:v #3=#:v] 6 (#$ . 161228)])
#@65 The buffer position where the last button action was triggered.
(defalias 'ert--button-action-position #[nil "\250\203`\207\302!\203*\303!\304	8\206(	A@:\203%	A@@\202(	A@)\207\305\306\307C\"\210\307\207" [last-command-event position eventp event-start 5 signal cl-assertion-failed nil] 3 (#$ . 161938)])
#@78 Jump to details for the test represented by the character clicked in BUTTON.
(defalias 'ert--results-progress-bar-button-action #[(button) "\300 b\210\301 \207" [ert--button-action-position ert-results-jump-between-summary-and-result] 1 (#$ . 162258)])
#@83 Re-run all tests, using the same selector.

To be used in the ERT results buffer.
(defalias 'ert-results-rerun-all-tests #[nil "\304\305\"\204
\306\307\310C\"\210	\311H\n>\204\312\313\314\315#\210	\316H\317\320 \")\207" [major-mode ert--results-stats cl-struct-ert--stats-tags selector eql ert-results-mode signal cl-assertion-failed (eql major-mode 'ert-results-mode) 0 error "%s accessing a non-%s" ert--stats-selector ert--stats 1 ert-run-tests-interactively buffer-name] 4 (#$ . 162517) nil])
#@66 Re-run the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-rerun-test-at-point #[nil "\306 \211G\307U\203\211A@\202\310\311\312GD\"@	\204%\313\314!\210\315\316\317\n\320\"\2034\321\202S\322\n\323\"\203?\324\202S\322\n\325\"\203J\326\202S\313\327\n\330#\205S\312	\331H
>\204a\313\332\333\334#\210	\335H##`$\336\216\337\216\340\341#\"\210\342\f	%#.\207" [#1=#:--cl-rest-- test redefinition-state ert--results-stats stats cl-struct-ert-test-tags ert--results-test-at-point-allow-redefinition 2 signal wrong-number-of-arguments nil error "No test at point" format "Running %stest %S" memql (nil) "" eql redefined "new definition of " deleted "deleted " "cl-ecase failed: %s, %s" (nil redefined deleted) 0 #2="%s accessing a non-%s" ert-test-name ert-test 1 ((goto-char point)) ((byte-code "\306	\"\210\307\310\n\311H\f>\204\312\313\314\315#\210\316H\317
\320
\"\")#\207" [ert--results-ewoc stats progress-message test cl-struct-ert-test-tags result ert--results-update-stats-display message "%s...%s" 0 error #2# ert-test-most-recent-result ert-test 4 ert-string-for-test-result ert-test-result-expected-p] 8)) message "%s..." ert-run-or-rerun-test progress-message point ert--results-listener] 8 (#$ . 163026) nil])
#@103 Re-run the test at point with `ert-debug-on-error' bound to t.

To be used in the ERT results buffer.
(defalias 'ert-results-rerun-test-at-point-debugging-errors #[nil "\301\302 )\207" [ert-debug-on-error t ert-results-rerun-test-at-point] 1 (#$ . 164309) nil])
#@85 Display the backtrace for the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-pop-to-backtrace-for-test-at-point #[nil "\306 	\307\n\"\n\310H\f>\204\311\312\313\314#\210\n\315HH\316
!\203:
G\317Y\203:
\310H'>\203:\311\320!\202\263\316
!\203\252
G\321Y\203\252
\310H(>\203\252
\310H(>\204_\311\312\322\323#\210
\315H\324\325!)*\326)!\210\327+\330 \210\331 \210\332 \210\333\334!\210\327,\335*!\210\336 \210eb\210\337c\210\340\310H->\204\237\311\312\341\342#\210\343H!\210\344c+\202\263\311\345
\346#\205\263\334,\207" [test ert--results-stats stats pos cl-struct-ert--stats-tags result ert--results-test-at-point-no-redefinition ert--stats-test-pos 0 error "%s accessing a non-%s" ert--stats-test-results ert--stats 4 vectorp 3 "Test passed, no backtrace available" 6 ert-test-result-with-condition-backtrace ert-test-result-with-condition get-buffer-create "*ERT Backtrace*" pop-to-buffer t buffer-disable-undo erase-buffer ert-simple-view-mode set-buffer-multibyte nil ert--print-backtrace debugger-make-xrefs "Backtrace for test `" ert-insert-test-name-button ert-test-name ert-test 1 "':\n" "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-result-with-condition) cl-struct-ert-test-passed-tags cl-struct-ert-test-result-with-condition-tags buffer backtrace inhibit-read-only truncate-lines cl-struct-ert-test-tags] 5 (#$ . 164578) nil])
#@118 Display the part of the *Messages* buffer generated during the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-pop-to-messages-for-test-at-point #[nil "\306 	\307\n\"\n\310H\f>\204\311\312\313\314#\210\n\315HH\316\317!\320!\210\321\322 \210\323 \210\324 \210
\310H>\204C\311\312\325\326#\210
\327Hc\210eb\210\330c\210\331\310H >\204^\311\312\332\333#\210\327H!\210\334c.\207" [test ert--results-stats stats pos cl-struct-ert--stats-tags result ert--results-test-at-point-no-redefinition ert--stats-test-pos 0 error "%s accessing a non-%s" ert--stats-test-results ert--stats 4 get-buffer-create "*ERT Messages*" pop-to-buffer t buffer-disable-undo erase-buffer ert-simple-view-mode ert-test-result-messages ert-test-result 1 "Messages for test `" ert-insert-test-name-button ert-test-name ert-test "':\n" buffer inhibit-read-only cl-struct-ert-test-result-tags cl-struct-ert-test-tags] 5 (#$ . 165992) nil])
#@110 Display the list of `should' forms executed during the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-pop-to-should-forms-for-test-at-point #[nil "\306 	\307\n\"\n\310H\f>\204\311\312\313\314#\210\n\315HH\316\317!&\320&!\210\321'\322 \210\323 \210\324 \210
\310H(>\204C\311\312\325\326#\210
\327H\204O\330c\210\202\233
\310H(>\204^\311\312\325\326#\210
\327H)\331*\332+):\203\232)@*\333c\210\334\335+\"c\210`,\336*!\210\337,`\"\210))A)+T+\202i+eb\210\340c\210\341\310H->\204\261\311\312\342\343#\210\332H!\210\344c\210\333c\210\345c\210\332y.\207" [test ert--results-stats stats pos cl-struct-ert--stats-tags result ert--results-test-at-point-no-redefinition ert--stats-test-pos 0 error "%s accessing a non-%s" ert--stats-test-results ert--stats 4 get-buffer-create "*ERT list of should forms*" pop-to-buffer t buffer-disable-undo erase-buffer ert-simple-view-mode ert-test-result-should-forms ert-test-result 2 "\n(No should forms during this test.)\n" nil 1 "\n" format "%s: " ert--pp-with-indentation-and-newline ert--make-xrefs-region "`should' forms executed during test `" ert-insert-test-name-button ert-test-name ert-test "':\n" "(Values are shallow copies and may have looked different during the test if they\nhave been modified destructively.)\n" buffer inhibit-read-only cl-struct-ert-test-result-tags #1=#:--cl-var-- form-description i begin cl-struct-ert-test-tags] 5 (#$ . 166957) nil])
#@105 Toggle how much of the condition to print for the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-toggle-printer-limits-for-test-at-point #[nil "\306 \211\307H\211\310H\f>\204\311\312\313\314#\210\211\315\310H\f>\204)\311\312\313\314#\210\315H?I\210)\316	\n\"+\207" [ert--results-ewoc ewoc node entry cl-struct-ert--ewoc-entry-tags #1=#:v ert--results-test-node-at-point 2 0 error "%s accessing a non-%s" ert--ewoc-entry-extended-printer-limits-p ert--ewoc-entry 4 ewoc-invalidate] 7 (#$ . 168434) nil])
#@79 Display test timings for the last run.

To be used in the ERT results buffer.
(defalias 'ert-results-pop-to-timings #[nil "\211\306H\n>\204\307\310\311\312#\210	\313H	\306H\n>\204\"\307\310\314\312#\210	\315H\316\317!	\306H\n>\2048\307\310\320\312#\210	\321H*\322+\323,	\306H\n>\204Q\307\310\311\312#\210	\313H-\322.\323/	\306H\n>\204j\307\310\314\312#\210	\315H0\3221\323\21123+T\211+*GW\203\307*+H,.T\211.-GW\203\307-.H/1T\21110GW\203\30701H2,\324\3252/\"!D3B3\202x3\237.\n4\3264\327\"4\330
!\210\3315\332 \210\333 \210\334 \2104\204\360\335c\210\202r
\336\337\340\341\342$c\21046\323\2117,\323\21189\343:\331;6:\203p
6@\2117\211A7@,7@8;\2030
8\2025
98\\9`<\336\344:89$c\210\345,\306H=>\204V
\307\310\346\347#\210,\343H!\210\350c\210)6A6:T:\323;\202
.eb\210\351c\210\343y.\207" [ert--results-stats stats cl-struct-ert--stats-tags start-times end-times buffer 0 error "%s accessing a non-%s" ert--stats-test-start-times ert--stats 5 ert--stats-test-end-times 6 get-buffer-create "*ERT timings*" ert--stats-tests 2 -1 nil float-time subtract-time sort #[(a b) "\211A@)\n\211A@)V\207" [a x b] 3] pop-to-buffer t buffer-disable-undo erase-buffer ert-simple-view-mode "(No data)\n" format "%-3s  %8s %8s\n" "" "time" "cumul" 1 "%3s: %8.3f %8.3f " ert-insert-test-name-button ert-test-name ert-test "\n" "Tests by run time (seconds):\n\n" #1=#:--cl-vec-- #2=#:--cl-idx-- test #3=#:--cl-vec-- #4=#:--cl-idx-- start-time #5=#:--cl-vec-- #6=#:--cl-idx-- end-time #7=#:--cl-var-- data inhibit-read-only #8=#:--cl-var-- #9=#:--cl-var-- time cumul-time i #10=#:--cl-var-- begin cl-struct-ert-test-tags] 6 (#$ . 168984) nil])
#@73 Display the documentation for TEST-OR-TEST-NAME (a symbol or ert-test).
(defalias 'ert-describe-test #[(test-or-test-name) "\306W\203\n\307\310!\210\311\2119\203\312!\202N\313!\203HG\314Y\203H\315H\f>\203H\315H\f>\204?\307\316\317\320#\210\321H\202N\307\322\323#\210\324\325D\326\327!\"\210\212
\311\211\223\210\311:\330;B;<=r\331\332 !q\210p\333 \210=<\311\211>?\334\211@\334AB\335 \210\336\337!\210+\211CDr\332 q\210\n\203\245\340\341\n\"\202\246\342c\210\343c\210\n\205\263\344\n\345\"\211E\203\322\346\347E!\350\261\210\212\351\352\311\334#\210\353\321\354\nE$\210)\355c\210\356e`\"\210\357c\210\360\n!\203\354\361\312\n!	\"\204\376`F\362\363\261\210\356F`\"\210)\357c\210	\315H\f>\204\f
\307\316\364\320#\210	\365H\206
\366\367\261*\370C!\210+\371:!\210-\207" [emacs-major-version test-definition test-name test-or-test-name cl-struct-ert-test-tags help-window-point-marker 24 error "Requires Emacs 24" nil ert-get-test vectorp 7 0 "%s accessing a non-%s" ert-test-name ert-test 1 "cl-etypecase failed: %s, %s" (symbol ert-test) help-setup-xref ert-describe-test called-interactively-p interactive #[nil "\301 \211\207" [help-window selected-window] 2] get-buffer-create help-buffer kill-all-local-variables t erase-buffer run-hooks temp-buffer-setup-hook format "%S" "<anonymous test>" " is a test" symbol-file ert-deftest " defined in `" file-name-nondirectory "'" re-search-backward "`\\([^`']+\\)'" help-xref-button help-function-def "." fill-region-as-paragraph "\n\n" ert-test-boundp eql "Note: This test has been redefined or deleted, " "this documentation refers to an old definition." ert-test-documentation 2 "It is not documented." "\n" internal-temp-output-buffer-show help-window-setup help-window temp-buffer-show-hook default-directory #1=#:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks inhibit-read-only #2=#:buf standard-output file-name begin] 6 (#$ . 170698) (list (ert-read-test-name-at-point "Describe test"))])
#@88 Display the documentation of the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-describe-test-at-point #[nil "\300\301 !\207" [ert-describe-test ert--results-test-at-point-no-redefinition] 2 (#$ . 172741) nil])
(byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\306\"\207" [add-to-list find-function-regexp-alist (ert-deftest . ert--find-test-regexp) minor-mode-alist (ert--current-run-stats (:eval (ert--tests-running-mode-line-indicator))) emacs-lisp-mode-hook ert--activate-font-lock-keywords] 3)
#@61 Unload function to undo the side-effects of loading ert.el.
(defalias 'ert--unload-function #[nil "\300\301\302\303\304$\210\300\305\306\303\304$\210\300\307\310\"\210\311\207" [ert--remove-from-list find-function-regexp-alist ert-deftest :key car minor-mode-alist ert--current-run-stats emacs-lisp-mode-hook ert--activate-font-lock-keywords nil] 5 (#$ . 173283)])
(defvar ert-unload-hook nil)
(byte-code "\300\301\302\"\210\303\304!\207" [add-hook ert-unload-hook ert--unload-function provide ert] 3)