;ELC   
;;; Compiled
;;; in Emacs version 30.1
;;; with all optimizations.


#@124 Maximum length of lines in ERT backtraces in batch mode.
Use nil for no limit (caution: backtrace lines can be very long).#@2 #@228 `print-length' setting used in `ert-run-tests-batch'.

When formatting lists in test conditions, `print-length' will be
temporarily set to this value.  See also
`ert-batch-backtrace-line-length' for its effect on stack
traces.
(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\210\310\311\312\"\210\313\314\315\316\317\320\321\322&\210\323\324\325\326\327DD\330\331\332%\207" [require cl-lib debug backtrace ewoc find-func pp map autoload xml-escape-string "xml.el" custom-declare-group ert nil "ERT, the Emacs Lisp regression testing tool." :prefix "ert-" :group lisp custom-declare-variable ert-batch-backtrace-right-margin funcall function #[0 "\300\207" [70] 1 (#$ . 211)] (#$ . 84) :type (choice (const :tag "No truncation" nil) integer)] 8)
(defvar ert-batch-print-length 10 (#$ . 218))#@226 `print-level' setting used in `ert-run-tests-batch'.

When formatting lists in test conditions, `print-level' will be
temporarily set to this value.  See also
`ert-batch-backtrace-line-length' for its effect on stack
traces.
(defvar ert-batch-print-level 5 (#$ . 1068))#@547 Target length for lines in ERT batch backtraces.

Even modest settings for `print-length' and `print-level' can
produce extremely long lines in backtraces and lengthy delays in
forming them.  This variable governs the target maximum line
length by manipulating these two variables while printing stack
traces.  Setting this variable to t will reuse the value of
`backtrace-line-length' while printing stack traces in ERT batch
mode.  Any other value will be temporarily bound to
`backtrace-line-length' when producing stack traces in batch
mode.
(defvar ert-batch-backtrace-line-length t (#$ . 1344))#@59 Face used for expected results in the ERT results buffer.
(custom-declare-face 'ert-test-result-expected '((((class color) (background light)) :background "green1") (((class color) (background dark)) :background "green3")) '(#$ . 1950))#@61 Face used for unexpected results in the ERT results buffer.
(custom-declare-face 'ert-test-result-unexpected '((((class color) (background light)) :background "red1") (((class color) (background dark)) :background "red3")) '(#$ . 2192))#@58 compiler-macro for `ert-test-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ert-test-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-p (and (memq (type-of cl-x) cl-struct-ert-test-tags) t)) nil] 9 (#$ . 2434)])#@13 

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-p compiler-macro ert-test-p--cmacro] 4)
(defalias 'ert-test-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-tags type-of t] 3 (#$ . 2692)])#@61 compiler-macro for `ert-test-name'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-p side-effect-free error-free pure t define-symbol-prop ert-test cl-deftype-satisfies] 6)
(defalias 'ert-test-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-name (progn (or (ert-test-p cl-x) (signal 'wrong-type-argument (list 'ert-test cl-x))) (aref cl-x 1))) nil] 9 (#$ . 2922)])#@58 Access slot "name" of `ert-test' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-name compiler-macro ert-test-name--cmacro] 4)
(defalias 'ert-test-name #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 1] 5 (#$ . 3418)])#@70 compiler-macro for `ert-test-documentation'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-name side-effect-free t] 4)
(defalias 'ert-test-documentation--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-documentation (progn (or (ert-test-p cl-x) (signal 'wrong-type-argument (list 'ert-test cl-x))) (aref cl-x 2))) nil] 9 (#$ . 3763)])#@67 Access slot "documentation" of `ert-test' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-documentation compiler-macro ert-test-documentation--cmacro] 4)
(defalias 'ert-test-documentation #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 2] 5 (#$ . 4190)])#@61 compiler-macro for `ert-test-body'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-documentation side-effect-free t] 4)
(defalias 'ert-test-body--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-body (progn (or (ert-test-p cl-x) (signal 'wrong-type-argument (list 'ert-test cl-x))) (aref cl-x 3))) nil] 9 (#$ . 4571)])#@58 Access slot "body" of `ert-test' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-body compiler-macro ert-test-body--cmacro] 4)
(defalias 'ert-test-body #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 3] 5 (#$ . 4980)])#@75 compiler-macro for `ert-test-most-recent-result'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-body side-effect-free t] 4)
(defalias 'ert-test-most-recent-result--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-most-recent-result (progn (or (ert-test-p cl-x) (signal 'wrong-type-argument (list 'ert-test cl-x))) (aref cl-x 4))) nil] 9 (#$ . 5325)])#@72 Access slot "most-recent-result" of `ert-test' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-most-recent-result compiler-macro ert-test-most-recent-result--cmacro] 4)
(defalias 'ert-test-most-recent-result #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 4] 5 (#$ . 5767)])#@77 compiler-macro for `ert-test-expected-result-type'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-most-recent-result side-effect-free t] 4)
(defalias 'ert-test-expected-result-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-expected-result-type (progn (or (ert-test-p cl-x) (signal 'wrong-type-argument (list 'ert-test cl-x))) (aref cl-x 5))) nil] 9 (#$ . 6168)])#@74 Access slot "expected-result-type" of `ert-test' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-expected-result-type compiler-macro ert-test-expected-result-type--cmacro] 4)
(defalias 'ert-test-expected-result-type #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 5] 5 (#$ . 6630)])#@61 compiler-macro for `ert-test-tags'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-expected-result-type side-effect-free t] 4)
(defalias 'ert-test-tags--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-tags (progn (or (ert-test-p cl-x) (signal 'wrong-type-argument (list 'ert-test cl-x))) (aref cl-x 6))) nil] 9 (#$ . 7039)])#@58 Access slot "tags" of `ert-test' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-tags compiler-macro ert-test-tags--cmacro] 4)
(defalias 'ert-test-tags #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 6] 5 (#$ . 7455)])#@66 compiler-macro for `ert-test-file-name'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-tags side-effect-free t] 4)
(defalias 'ert-test-file-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-file-name (progn (or (ert-test-p cl-x) (signal 'wrong-type-argument (list 'ert-test cl-x))) (aref cl-x 7))) nil] 9 (#$ . 7800)])#@63 Access slot "file-name" of `ert-test' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-file-name compiler-macro ert-test-file-name--cmacro] 4)
(defalias 'ert-test-file-name #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 7] 5 (#$ . 8215)])#@146 compiler-macro for `make-ert-test'.

(fn CL-WHOLE &cl-quote &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS FILE-NAME)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-file-name side-effect-free t defalias copy-ert-test copy-sequence] 4)
(defalias 'make-ert-test--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"A@\300\306\"\206$ \307A@\300\310\"\206/ \311A@\300\312\"A@\211\203l \211@\313>\203U \211A\204P \314\315@\"\210AA\202: \316	>A@\203c \210\317\202: \314\320@\"\210\202: \210\321\322\323\317\f\317\f\f\f\f\f\f\f&\f\207" [plist-member :name :documentation :body (nil (cl-assert nil)) :most-recent-result :expected-result-type (nil ':passed) :tags (nil 'nil) :file-name (:name :documentation :body :most-recent-result :expected-result-type :tags :file-name :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:name :documentation :body :most-recent-result :expected-result-type :tags :file-name)" cl--defsubst-expand (name documentation body most-recent-result expected-result-type tags file-name) (cl-block make-ert-test (record 'ert-test name documentation body most-recent-result expected-result-type tags file-name))] 22 (#$ . 8581)])#@135 Constructor for objects of type `ert-test'.

(fn &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS FILE-NAME)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test compiler-macro make-ert-test--cmacro] 4)
(defalias 'make-ert-test #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304\305\304!\210\304DA@\300\306\"A@\300\307\"\206* \310A@\300\311\"\2065 \312A@\300\313\"A@\211\203r \211@\314>\203[ \211A\204V \315\316@\"\210AA\202@ \317	>A@\203i \210\304\202@ \315\320@\"\210\202@ \210\321\322&\207" [plist-member :name :documentation :body nil cl--assertion-failed :most-recent-result :expected-result-type (nil :passed) :tags (nil nil) :file-name (:name :documentation :body :most-recent-result :expected-result-type :tags :file-name :allow-other-keys) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:name :documentation :body :most-recent-result :expected-result-type :tags :file-name)" record ert-test] 17 (#$ . 9879)])#@53 Return non-nil if SYMBOL names a test.

(fn SYMBOL)
(cl-struct-define 'ert-test nil 'cl-structure-object 'record nil '((cl-tag-slot) (name nil) (documentation nil) (body (cl-assert nil)) (most-recent-result nil) (expected-result-type ':passed) (tags 'nil) (file-name nil)) 'cl-struct-ert-test-tags 'ert-test t)
(defalias 'ert-test-boundp #[257 "\211\300N\205 \301\207" [ert--test t] 3 (#$ . 10913)])#@79 If SYMBOL names a test, return that.  Signal an error otherwise.

(fn SYMBOL)
(defalias 'ert-get-test #[257 "\300!\204 \301\302\"\210\211\303N\207" [ert-test-boundp error "No test named `%S'" ert--test] 4 (#$ . 11319)])#@86 Make SYMBOL name the test DEFINITION, and return DEFINITION.

(fn SYMBOL DEFINITION)
(defalias 'ert-set-test #[514 "\204 \301\302!\210\203 \303N\203 \301\304\"\210\305\303#\210\207" [noninteractive error "Attempt to define a test named nil" ert--test "Test `%s' redefined (or loaded twice)" define-symbol-prop] 6 (#$ . 11547)])#@56 Make SYMBOL name no test.  Return SYMBOL.

(fn SYMBOL)
(defalias 'ert-make-test-unbound #[257 "\300\301\"\210\207" [cl-remprop ert--test] 4 (#$ . 11889)])#@377 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.

(fn KEYS-AND-BODY)
(defalias 'ert--parse-keys-and-body #[257 "\300\301\242!\2039 \211A\262\242:\204 \302\303#\210\304\"\203) \305\306#\210\211\211A\262\242BB\262\210\202 \237\262\300\211\211:\203c @\262\211A\262\242\262B\262B\262A\262\202A \266\203\237D\207" [nil keywordp error "Value expected after keyword %S in %S" assoc warn "Keyword %S appears more than once in %S"] 9 (#$ . 12051)])#@831 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', `should-error', `skip-when', and
`skip-unless' 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.

Macros in BODY are expanded when the test is defined, not when it
is run.  If a macro (possibly with side effects) is to be tested,
it has to be wrapped in `(eval (quote ...))'.

If NAME is already defined as a test and Emacs is running
in batch mode, an error is signaled.

(fn NAME () [DOCSTRING] [:expected-result RESULT-TYPE] [:tags \='(TAG...)] BODY...)
(defalias 'ert-deftest '(macro . #[385 "\211\203 \211A\262\242\202 \301\302\303GD\"\211\203\" \301\302\303G\304\\D\"\210\305\211@;\2033 \211A\262\266\202\242\306\307!\211G\310U\203F \211A\262\242\202M \301\302\311GD\"\312\313\"\211\205[ \211A@\306\262\312\314\"\211\205i \211A@\306\262\242\211\203\236 \211@\315>\203\207 \211A\204\202 \316\317@\"\210AA\202l \320>A@\203\225 \210\305\202l \316\321@\"\210\202l \210\322\323\324\325D\326\327\325D\330\205\266 \331D\205\277 \332D\f\205\310 \314\fD\333\334\305\330\335\"BB\336\337 \206\331 F$BBBE\325DF\207" [buffer-file-name signal wrong-number-of-arguments ert-deftest 0 nil t ert--parse-keys-and-body 2 ((&key (expected-result nil expected-result-supplied-p) (tags nil tags-supplied-p)) body) plist-member :expected-result :tags (:expected-result :tags :allow-other-keys) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:expected-result :tags)" cl-macrolet ((skip-when (form) `(ert--skip-when ,form)) (skip-unless (form) `(ert--skip-unless ,form))) ert-set-test quote make-ert-test :name append :documentation :expected-result-type :body lambda (nil) :file-name macroexp-file-name] 29 (#$ . 12841)]))#@77 The regexp the `find-function' mechanisms use for finding test definitions.
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\300\207" [put ert-deftest edebug-form-spec (&define [&name "test@" symbolp] sexp [&optional stringp] [&rest keywordp sexp] def-body) function-put doc-string-elt 3 lisp-indent-function 2] 5)
(defvar ert--find-test-regexp (concat "^\\s-*(ert-deftest" find-function-space-re "%s\\(\\s-\\|$\\)") (#$ . 14902))#@66 Terminate the current test and mark it passed.  Does not return.
(byte-code "\300\301\302\"\210\300\303\304\"\207" [define-error ert-test-failed "Test failed" ert-test-skipped "Test skipped"] 3)
(defalias 'ert-pass #[0 "\300\301\302\"\207" [throw ert--pass nil] 3 (#$ . 15357)])#@151 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.

(fn DATA)
(defalias 'ert-fail #[257 "\300\301C\"\207" [signal ert-test-failed] 4 (#$ . 15642)])#@150 Terminate the current test and mark it skipped.  Does not return.
DATA is displayed to the user and should state the reason for skipping.

(fn DATA)
(defalias 'ert-skip #[257 "\300\301C\"\207" [signal ert-test-skipped] 4 (#$ . 15885)])
(defvar ert--should-execution-observer nil)#@97 Tell the current `should' form observer (if any) about FORM-DESCRIPTION.

(fn FORM-DESCRIPTION)
(defalias 'ert--signal-should-execution #[257 "\205 !\207" [ert--should-execution-observer] 3 (#$ . 16171)])#@76 Return non-nil if THING is a symbol naming a special operator.

(fn THING)
(defalias 'ert--special-operator-p #[257 "\2119\205 \300!\301!\205 \302!A\303=\262\207" [indirect-function subrp subr-arity unevalled] 4 (#$ . 16385)])#@90 Helper function for the `should' macro and its variants.

(fn WHOLE FORM INNER-EXPANDER)
(defalias 'ert--expand-should-1 #[771 "\3011\f \302\"0\202 \303\304@D\304ADE\262\211:\203$ \305@!\203F \306\307!\310\311BC\312E\313\304\nD\314\304	D\315	\257#F\207\211@A9\204e :\203a @\316=\203a A<\204e \317\320!\210\306\321!\306\322!\306\307!\306\323!\324\325DD\326\327\313\nB\330\331\312\f\332BB\333BBDFDD\310\304DDC\312\334EE\335\313\304DD\313\314\336\337D\340DDDE\341\342\f\304DE\313\315EE\341\342\304DE\343\344\345\304DDDC\313\346\334\344EEEE\257#FE\207" [macroexpand-all-environment (error) macroexpand-all signal quote ert--special-operator-p gensym "value-" let ((gensym "ert-form-evaluation-aborted-")) setq list :form :value lambda 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-" let* function condition-case err error progn (#'signal) ((list (car err) (cdr err))) apply nconc \` \, \,@ unless eql when-let -explainer- ert--get-explainer :explanation] 29 (#$ . 16623)])#@16 

(fn FN-NAME)
(defalias 'ert--get-explainer #[257 "\2119\205: \211\300!B\301\211\211\211\211:\2038 @\262\302N\262\203* \210\301\211\262\202+ \303\2038 A\262\301\262\202 \266\205\207" [function-alias-p nil ert-explainer t] 9 (#$ . 17773)])#@720 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.

(fn WHOLE FORM INNER-EXPANDER)#@51 

(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)
(defalias 'ert--expand-should #[771 "\300\301\302\"#\207" [ert--expand-should-1 make-closure #[771 "\301\302!\303C\300\304\305	E\306DF#E\207" [V0 gensym "form-description-" let unwind-protect setq ert--signal-should-execution] 12 (#$ . 18756)]] 9 (#$ . 18032)])#@109 Evaluate FORM.  If it returns nil, abort the current test as failed.

Returns the value of FORM.

(fn FORM)
(defalias 'should '(macro . #[257 "\300\301D\302#\207" [ert--expand-should should #[771 "\300\301DE\207" [unless ert-fail] 7 (#$ . 18756)]] 5 (#$ . 19088)]))#@99 Evaluate FORM.  If it returns non-nil, abort the current test as failed.

Returns nil.

(fn FORM)
(put 'should 'edebug-form-spec t)
(defalias 'should-not '(macro . #[257 "\300\301D\302#\207" [ert--expand-should should-not #[771 "\300\301D\302DE\207" [unless not ert-fail] 7 (#$ . 18756)]] 5 (#$ . 19363)]))#@213 Helper function for `should-error'.

Determines whether CONDITION matches TYPE and EXCLUDE-SUBTYPES,
and aborts the current test as failed if it doesn't.

(fn FORM-DESCRIPTION-FN CONDITION TYPE EXCLUDE-SUBTYPES)
(put 'should-not 'edebug-form-spec t)
(defalias 'ert--should-error-handle-error #[1028 "@\300N<\203 \202 9\203 C\202 \301\302\"\204# \303\304!\210\305\"\2048 \306\307 \310\311\312F\"!\210\205Q @\235?\205Q \306\307 \310\311\313F\"!\207" [error-conditions error "No clause matching `%S'" cl--assertion-failed signaled-conditions cl-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"] 13 (#$ . 19680)])#@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 . #[385 "\300\301\"A@C\300\302\"A@\211\203? \211@\303>\203) \211A\204$ \304\305@\"\210AA\202 \306>A@\2036 \210\307\202 \304\310@\"\210\202 \210\242\204I \311\240\210\312\313BB\314\315##\207" [plist-member :type :exclude-subtypes (:type :exclude-subtypes :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:type :exclude-subtypes)" 'error ert--expand-should should-error make-closure #[771 "\302\303!\302\304!\305\306B\307\310EDD\311\312\313\314\315BB\316\312\301\242\300\257\314\317BBFF\320\321\322\323D\324BBDEF\207" [V0 V1 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"))] 17 (#$ . 18756)]] 11 (#$ . 20432)]))#@124 Evaluate FORM.  If it returns t, skip the current test.
Errors during evaluation are caught and handled like t.

(fn FORM)
(put 'should-error 'edebug-form-spec t)
(defalias 'ert--skip-when '(macro . #[257 "\300\301D\302#\207" [ert--expand-should skip-when #[771 "\300\301\302\303BBB\304DE\207" [when condition-case nil ((t t)) ert-skip] 8 (#$ . 18756)]] 5 (#$ . 21953)]))#@128 Evaluate FORM.  If it returns nil, skip the current test.
Errors during evaluation are caught and handled like nil.

(fn FORM)
(put 'ert--skip-when 'edebug-form-spec t)
(defalias 'ert--skip-unless '(macro . #[257 "\300\301D\302#\207" [ert--expand-should skip-unless #[771 "\300\301D\302DE\207" [unless ignore-errors ert-skip] 7 (#$ . 18756)]] 5 (#$ . 22335)]))#@53 Format the atom X for `ert--explain-equal'.

(fn X)
(put 'ert--skip-unless 'edebug-form-spec t)
(defalias 'ert--explain-format-atom #[257 "\300!\203 \211\301\302\"\301\303\"E\207\211\250\203 \211\301\302\"D\207\207" [characterp format "#x%x" "?%c"] 6 (#$ . 22705)])#@108 Return a programmer-readable explanation of why A and B are not `equal'.
Return nil if they are.

(fn A B)#@12 

(fn A B)
(defalias 'ert--explain-equal-rec #[514 "CC\301\242!\301\242!=\204 \302\242\242E\207\303\242:\203\364 \304\242!\304\242!??=\2045 \305\242\242E\207\203\267 U\204V \306\242\242\307\310\242\242\311\312$\257\207\3132\363 \314\242\315\242\315\211\211:\203\233 @\262:\203\233 @\262\316\"\262\203\211 \317\313\320	E\"\210T\262A\262A\262\210\315\202d \242\242\232\204\262 \321\322\315\242\242D\315$\210\266\3150\207\316\242@\242@\"\211\203\307 \323D\207\316\242A\242A\"\211\203\331 \324D\207\242\242\232\204\360 \321\325\315	\242	\242D\315$\210\266\315\207\242\301!>\205\377 \326\262\203\205\3132\313\327\301\242!!\315\242\330\315\242\330\315\211\211	:\203i	@\262	T\262GW\203iH\262T\262GW\203iH\262\316\"\262\203_\317\313\331@E\"\210	A\262\n\210\315\202\f\242\f\242\232\204\200\321\332\315\242\242D\315$\210\266\n\3150\207\333\242!\203\221\211\"\207\334\242!\203\235\211\"\207\242\242\232?\205\313\2429\203\301\2429\203\301\242\242\230\203\301\335\242\242E\207\336\337\242!\337\242!E\207" [cl-struct-cl-structure-object-tags type-of different-types #[514 "\242;\2030 \300\242!\300\242!\204 \262\202 \211?\205 \266\202\2030 \301\242!\240\210\211\301\242!\240\210\242G\242GU\204` \302\242G\242G\242\242\303\242!?\205Z \304\305\242\242\306\307$DBBBBB\207\3102\315 \311\242\312\313\242\312\313\211\211T\262GW\203\262 H\262T\262GW\203\262 H\262\314\"\262\203\250 \315\310\316E\"\210T\262	\210\313\202o \n\242\n\242\232\204\311 \317\320\313\242\242D\313$\210\266	\3130\207" [multibyte-string-p string-to-multibyte arrays-of-different-length char-table-p first-mismatch-at cl-mismatch :test equal --cl-block-nil-- 0 -1 nil ert--explain-equal-rec throw array-elt cl--assertion-failed (equal a b)] 16 (#$ . 23095)] proper-list-p one-list-proper-one-improper proper-lists-of-different-length first-mismatch-at cl-mismatch :test equal --cl-block-nil-- 0 nil ert--explain-equal-rec throw list-elt cl--assertion-failed (equal a b) car cdr (equal a b) t cl-struct-slot-info -1 struct-field (equal a b) arrayp recordp different-symbols-with-the-same-name different-atoms ert--explain-format-atom] 20 (#$ . 22983)])#@43 Explainer function for `equal'.

(fn A B)
(defalias 'ert--explain-equal #[514 "\232?\205 \300\"\207" [ert--explain-equal-rec] 5 (#$ . 25413)])#@50 Explainer function for `string-equal'.

(fn A B)
(put 'equal 'ert-explainer 'ert--explain-equal)
(defalias 'ert--explain-string-equal #[514 "\230?\205% 9\203 \300!\202 9\203 \300!\202 \301\"\266\202\207" [symbol-name ert--explain-equal-rec] 7 (#$ . 25566)])#@75 Return the keys of PLIST that have non-null values, in order.

(fn PLIST)
(put 'string-equal 'ert-explainer 'ert--explain-string-equal)
(defalias 'ert--significant-plist-keys #[257 "\300G\301\"\302U\204 \303\304\305\300G\301\"C\305$\210\3062W \211\305\211\211\211:\203O \262\211A\262\242\262\211A\262\242\262\203G >\204G \211C\244\262AA\262\202 \307\306\"\266\3050\207" [mod 2 0 cl--assertion-failed (zerop (mod (length plist) 2)) nil --cl-block-nil-- throw] 9 (#$ . 25843)])#@266 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.

(fn A B)#@16 

(fn A B KEY)
(defalias 'ert--plist-difference-explanation #[514 "\300G\301\"\302U\204 \303\304\305\300G\301\"C\305$\210\300G\301\"\302U\204, \303\306\305\300G\301\"C\305$\210\307!\307!\310\311\312$\310\311\312$\313\203L \211@#\207\203Y \211@#\207\305\211\211:\203\217 @\262\314\"\314\"\232\204\204 #\262\305\211\262\202\205 \315\203\217 A\262\202] \207" [mod 2 0 cl--assertion-failed (zerop (mod (length a) 2)) nil (zerop (mod (length b) 2)) ert--significant-plist-keys cl-set-difference :test eq #[771 "\300\"\300\"\232\203 \301\302\303\232C\303$\210\304\305\"E\207" [plist-get cl--assertion-failed (not (equal value-a value-b)) nil different-properties-for-key ert--explain-equal-including-properties] 10 (#$ . 26617)] plist-get t] 15 (#$ . 26347)])#@127 Shorten string S to at most LEN chars.

If SUFFIXP is non-nil, returns a suffix of S, otherwise a prefix.

(fn S LEN SUFFIXP)
(defalias 'ert--abbreviate-string #[771 "G\211W\203\n \207\203 Z\300O\207\301O\207" [nil 0] 7 (#$ . 27432)])#@107 Return explanation of why A and B are not `equal-including-properties'.
Return nil if they are.

(fn A B)
(defalias 'ert--explain-equal-including-properties-rec #[514 "\232\204 \300\"\207;\204 \301\302\303C\303$\210\211;\204% \301\304\303C\303$\210\305GG\"\2049 \301\306\303GGD\303$\210\3072\260 \310G\303\211\211\211X\203\230 \311	\"\262\311\"\262\312\"\262\203\217 \313\307\314\315\f\211T#\316\317\315\310#\320\321#\322\317\315T\"\320\303#\257\"\210T\262\210\303\202D \323\"\204\254 \301\324\303\n\nD\303$\210\266\3030\207" [ert--explain-equal cl--assertion-failed (stringp a) nil (stringp b) eql (eql (length a) (length b)) --cl-block-nil-- 0 text-properties-at ert--plist-difference-explanation throw char substring-no-properties context-before ert--abbreviate-string 10 t context-after equal-including-properties (equal-including-properties a b)] 21 (#$ . 27683)])#@64 Explainer function for `equal-including-properties'.

(fn A B)
(defalias 'ert--explain-equal-including-properties #[514 "\300\"?\205\f \301\"\207" [equal-including-properties ert--explain-equal-including-properties-rec] 5 (#$ . 28612)])#@118 The stack of `ert-info' infos that currently apply.

Bound dynamically.  This is a list of (PREFIX . MESSAGE) pairs.
(put 'equal-including-properties 'ert-explainer 'ert--explain-equal-including-properties)
(defvar ert--infos nil (#$ . 28859))#@495 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.  MESSAGE-FORM can also evaluate to a function; in
this case, it will be called when displaying the info.

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 . #[128 "\211\203 \211A\262\242\202 \300\301\302GD\"\211\203! \211A\262\242\202( \300\301\302GD\"\303\304\"\2060 \305A@\211\203d \211@\306>\203N \211A\204I \307\310@\"\210AA\2023 \311>A@\203[ \210\312\2023 \307\313@\"\210\2023 \210\314\315\316\211E\317BBDCBB\207" [signal wrong-number-of-arguments ert-info plist-member :prefix (nil "Info: ") (:prefix :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:prefix)" let ert--infos cons (ert--infos)] 10 (#$ . 29109)]))#@77 Non-nil means enter debugger when a test fails or terminates with an error.
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put ert-info edebug-form-spec ((form &rest [sexp form]) body) function-put lisp-indent-function 1] 4)
(defvar ert-debug-on-error nil (#$ . 30174))#@65 compiler-macro for `ert-test-result-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ert-test-result-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-p (and (memq (type-of cl-x) cl-struct-ert-test-result-tags) t)) nil] 9 (#$ . 30463)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-p compiler-macro ert-test-result-p--cmacro] 4)
(defalias 'ert-test-result-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-result-tags type-of t] 3 (#$ . 2692)])#@72 compiler-macro for `ert-test-result-messages'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-result-p side-effect-free error-free pure t define-symbol-prop ert-test-result cl-deftype-satisfies] 6)
(defalias 'ert-test-result-messages--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-messages (progn (or (ert-test-result-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result cl-x))) (aref cl-x 1))) nil] 9 (#$ . 30991)])#@69 Access slot "messages" of `ert-test-result' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-messages compiler-macro ert-test-result-messages--cmacro] 4)
(defalias 'ert-test-result-messages #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-tags type-of signal wrong-type-argument ert-test-result 1] 5 (#$ . 31549)])#@76 compiler-macro for `ert-test-result-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-messages side-effect-free t] 4)
(defalias 'ert-test-result-should-forms--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-should-forms (progn (or (ert-test-result-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result cl-x))) (aref cl-x 2))) nil] 9 (#$ . 31953)])#@73 Access slot "should-forms" of `ert-test-result' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-should-forms compiler-macro ert-test-result-should-forms--cmacro] 4)
(defalias 'ert-test-result-should-forms #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-tags type-of signal wrong-type-argument ert-test-result 2] 5 (#$ . 32424)])#@72 compiler-macro for `ert-test-result-duration'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-should-forms side-effect-free t] 4)
(defalias 'ert-test-result-duration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-duration (progn (or (ert-test-result-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result cl-x))) (aref cl-x 3))) nil] 9 (#$ . 32844)])#@69 Access slot "duration" of `ert-test-result' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-duration compiler-macro ert-test-result-duration--cmacro] 4)
(defalias 'ert-test-result-duration #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-tags type-of signal wrong-type-argument ert-test-result 3] 5 (#$ . 33307)])#@105 compiler-macro for `make-ert-test-result'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-result-duration side-effect-free t defalias copy-ert-test-result copy-sequence] 4)
(defalias 'make-ert-test-result--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203H \211@\305>\2032 \211A\204- \306\307@\"\210AA\202 \310>A@\203? \210\311\202 \306\312@\"\210\202 \210\313\314\315\311\311&\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration)" cl--defsubst-expand (messages should-forms duration) (cl-block make-ert-test-result (record 'ert-test-result messages should-forms duration))] 14 (#$ . 33712)])#@94 Constructor for objects of type `ert-test-result'.

(fn &key MESSAGES SHOULD-FORMS DURATION)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-result compiler-macro make-ert-test-result--cmacro] 4)
(defalias 'make-ert-test-result #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203H \211@\305>\2032 \211A\204- \306\307@\"\210AA\202 \310>A@\203? \210\311\202 \306\312@\"\210\202 \210\313\314$\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration)" record ert-test-result] 9 (#$ . 34618)])#@65 compiler-macro for `ert-test-passed-p'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-ert-test-result side-effect-free t cl-struct-define ert-test-result nil cl-structure-object record ((cl-tag-slot) (messages nil) (should-forms nil) (duration 0)) cl-struct-ert-test-result-tags] 11)
(defalias 'ert-test-passed-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-passed-p (and (memq (type-of cl-x) cl-struct-ert-test-passed-tags) t)) nil] 9 (#$ . 35340)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-passed-p compiler-macro ert-test-passed-p--cmacro] 4)
(defalias 'ert-test-passed-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-passed-tags type-of t] 3 (#$ . 2692)])#@72 compiler-macro for `ert-test-passed-messages'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-passed-p side-effect-free error-free pure t define-symbol-prop ert-test-passed cl-deftype-satisfies] 6)
(defalias 'ert-test-passed-messages--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-passed-messages (progn (or (ert-test-passed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-passed cl-x))) (aref cl-x 1))) nil] 9 (#$ . 36162)])#@69 Access slot "messages" of `ert-test-passed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-passed-messages compiler-macro ert-test-passed-messages--cmacro] 4)
(defalias 'ert-test-passed-messages #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-passed-tags type-of signal wrong-type-argument ert-test-passed 1] 5 (#$ . 36720)])#@76 compiler-macro for `ert-test-passed-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-passed-messages side-effect-free t] 4)
(defalias 'ert-test-passed-should-forms--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-passed-should-forms (progn (or (ert-test-passed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-passed cl-x))) (aref cl-x 2))) nil] 9 (#$ . 37124)])#@73 Access slot "should-forms" of `ert-test-passed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-passed-should-forms compiler-macro ert-test-passed-should-forms--cmacro] 4)
(defalias 'ert-test-passed-should-forms #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-passed-tags type-of signal wrong-type-argument ert-test-passed 2] 5 (#$ . 37595)])#@72 compiler-macro for `ert-test-passed-duration'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-passed-should-forms side-effect-free t] 4)
(defalias 'ert-test-passed-duration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-passed-duration (progn (or (ert-test-passed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-passed cl-x))) (aref cl-x 3))) nil] 9 (#$ . 38015)])#@69 Access slot "duration" of `ert-test-passed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-passed-duration compiler-macro ert-test-passed-duration--cmacro] 4)
(defalias 'ert-test-passed-duration #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-passed-tags type-of signal wrong-type-argument ert-test-passed 3] 5 (#$ . 38478)])#@105 compiler-macro for `make-ert-test-passed'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-passed-duration side-effect-free t defalias copy-ert-test-passed copy-sequence] 4)
(defalias 'make-ert-test-passed--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203H \211@\305>\2032 \211A\204- \306\307@\"\210AA\202 \310>A@\203? \210\311\202 \306\312@\"\210\202 \210\313\314\315\311\311&\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration)" cl--defsubst-expand (messages should-forms duration) (cl-block make-ert-test-passed (record 'ert-test-passed messages should-forms duration))] 14 (#$ . 38883)])#@94 Constructor for objects of type `ert-test-passed'.

(fn &key MESSAGES SHOULD-FORMS DURATION)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-passed compiler-macro make-ert-test-passed--cmacro] 4)
(defalias 'make-ert-test-passed #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203H \211@\305>\2032 \211A\204- \306\307@\"\210AA\202 \310>A@\203? \210\311\202 \306\312@\"\210\202 \210\313\314$\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration)" record ert-test-passed] 9 (#$ . 39789)])#@80 compiler-macro for `ert-test-result-with-condition-p'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-ert-test-passed side-effect-free t cl-struct-define ert-test-passed nil ert-test-result record ((cl-tag-slot) (messages nil) (should-forms nil) (duration 0)) cl-struct-ert-test-passed-tags] 11)
(defalias 'ert-test-result-with-condition-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-p (and (memq (type-of cl-x) cl-struct-ert-test-result-with-condition-tags) t)) nil] 9 (#$ . 40511)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-with-condition-p compiler-macro ert-test-result-with-condition-p--cmacro] 4)
(defalias 'ert-test-result-with-condition-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-result-with-condition-tags type-of t] 3 (#$ . 2692)])#@87 compiler-macro for `ert-test-result-with-condition-messages'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-result-with-condition-p side-effect-free error-free pure t define-symbol-prop ert-test-result-with-condition cl-deftype-satisfies] 6)
(defalias 'ert-test-result-with-condition-messages--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-messages (progn (or (ert-test-result-with-condition-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result-with-condition cl-x))) (aref cl-x 1))) nil] 9 (#$ . 41449)])#@84 Access slot "messages" of `ert-test-result-with-condition' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-with-condition-messages compiler-macro ert-test-result-with-condition-messages--cmacro] 4)
(defalias 'ert-test-result-with-condition-messages #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-with-condition-tags type-of signal wrong-type-argument ert-test-result-with-condition 1] 5 (#$ . 42112)])#@91 compiler-macro for `ert-test-result-with-condition-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-messages side-effect-free t] 4)
(defalias 'ert-test-result-with-condition-should-forms--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-should-forms (progn (or (ert-test-result-with-condition-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result-with-condition cl-x))) (aref cl-x 2))) nil] 9 (#$ . 42606)])#@88 Access slot "should-forms" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-with-condition-should-forms compiler-macro ert-test-result-with-condition-should-forms--cmacro] 4)
(defalias 'ert-test-result-with-condition-should-forms #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-with-condition-tags type-of signal wrong-type-argument ert-test-result-with-condition 2] 5 (#$ . 43167)])#@87 compiler-macro for `ert-test-result-with-condition-duration'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-should-forms side-effect-free t] 4)
(defalias 'ert-test-result-with-condition-duration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-duration (progn (or (ert-test-result-with-condition-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result-with-condition cl-x))) (aref cl-x 3))) nil] 9 (#$ . 43677)])#@84 Access slot "duration" of `ert-test-result-with-condition' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-with-condition-duration compiler-macro ert-test-result-with-condition-duration--cmacro] 4)
(defalias 'ert-test-result-with-condition-duration #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-with-condition-tags type-of signal wrong-type-argument ert-test-result-with-condition 3] 5 (#$ . 44230)])#@88 compiler-macro for `ert-test-result-with-condition-condition'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-duration side-effect-free t] 4)
(defalias 'ert-test-result-with-condition-condition--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-condition (progn (or (ert-test-result-with-condition-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result-with-condition cl-x))) (aref cl-x 4))) nil] 9 (#$ . 44724)])#@85 Access slot "condition" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-with-condition-condition compiler-macro ert-test-result-with-condition-condition--cmacro] 4)
(defalias 'ert-test-result-with-condition-condition #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-with-condition-tags type-of signal wrong-type-argument ert-test-result-with-condition 4] 5 (#$ . 45276)])#@88 compiler-macro for `ert-test-result-with-condition-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-condition side-effect-free t] 4)
(defalias 'ert-test-result-with-condition-backtrace--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-backtrace (progn (or (ert-test-result-with-condition-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result-with-condition cl-x))) (aref cl-x 5))) nil] 9 (#$ . 45774)])#@85 Access slot "backtrace" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-with-condition-backtrace compiler-macro ert-test-result-with-condition-backtrace--cmacro] 4)
(defalias 'ert-test-result-with-condition-backtrace #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-with-condition-tags type-of signal wrong-type-argument ert-test-result-with-condition 5] 5 (#$ . 46327)])#@84 compiler-macro for `ert-test-result-with-condition-infos'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-backtrace side-effect-free t] 4)
(defalias 'ert-test-result-with-condition-infos--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-result-with-condition-infos (progn (or (ert-test-result-with-condition-p cl-x) (signal 'wrong-type-argument (list 'ert-test-result-with-condition cl-x))) (aref cl-x 6))) nil] 9 (#$ . 46825)])#@81 Access slot "infos" of `ert-test-result-with-condition' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-with-condition-infos compiler-macro ert-test-result-with-condition-infos--cmacro] 4)
(defalias 'ert-test-result-with-condition-infos #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-with-condition-tags type-of signal wrong-type-argument ert-test-result-with-condition 6] 5 (#$ . 47366)])#@146 compiler-macro for `make-ert-test-result-with-condition'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-result-with-condition-infos side-effect-free t defalias copy-ert-test-result-with-condition copy-sequence] 4)
(defalias 'make-ert-test-result-with-condition--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206 \306A@\300\307\"\206( \310A@\300\311\"\2063 \312A@\211\203i \211@\313>\203R \211A\204M \314\315@\"\210AA\2027 \316>A@\203` \210\317\2027 \314\320@\"\210\2027 \210\321\322\323\317\317&\207" [plist-member :messages :should-forms :duration (nil 0) :condition (nil (cl-assert nil)) :backtrace (nil (cl-assert nil)) :infos (nil (cl-assert nil)) (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" cl--defsubst-expand (messages should-forms duration condition backtrace infos) (cl-block make-ert-test-result-with-condition (record 'ert-test-result-with-condition messages should-forms duration condition backtrace infos))] 20 (#$ . 47849)])#@135 Constructor for objects of type `ert-test-result-with-condition'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-result-with-condition compiler-macro make-ert-test-result-with-condition--cmacro] 4)
(defalias 'make-ert-test-result-with-condition #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206$ \306\307\306!\210\306DA@\300\310\"\2064 \306\307\306!\210\306DA@\300\311\"\206E \306\307\306!\210\306DA@\211\203{ \211@\312>\203d \211A\204_ \313\314@\"\210AA\202I \315>A@\203r \210\306\202I \313\316@\"\210\202I \210\317\320&\207" [plist-member :messages :should-forms :duration (nil 0) :condition nil cl--assertion-failed :backtrace :infos (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-result-with-condition] 15 (#$ . 49152)])#@63 compiler-macro for `ert-test-quit-p'.

(fn CL-WHOLE-ARG CL-X)
(cl-struct-define 'ert-test-result-with-condition nil 'ert-test-result 'record nil '((cl-tag-slot) (messages nil) (should-forms nil) (duration 0) (condition (cl-assert nil)) (backtrace (cl-assert nil)) (infos (cl-assert nil))) 'cl-struct-ert-test-result-with-condition-tags 'ert-test-result-with-condition t)
(defalias 'ert-test-quit-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-quit-p (and (memq (type-of cl-x) cl-struct-ert-test-quit-tags) t)) nil] 9 (#$ . 50220)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-p compiler-macro ert-test-quit-p--cmacro] 4)
(defalias 'ert-test-quit-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-quit-tags type-of t] 3 (#$ . 2692)])#@70 compiler-macro for `ert-test-quit-messages'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-quit-p side-effect-free error-free pure t define-symbol-prop ert-test-quit cl-deftype-satisfies] 6)
(defalias 'ert-test-quit-messages--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-quit-messages (progn (or (ert-test-quit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-quit cl-x))) (aref cl-x 1))) nil] 9 (#$ . 51041)])#@67 Access slot "messages" of `ert-test-quit' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-messages compiler-macro ert-test-quit-messages--cmacro] 4)
(defalias 'ert-test-quit-messages #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 1] 5 (#$ . 51585)])#@74 compiler-macro for `ert-test-quit-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-messages side-effect-free t] 4)
(defalias 'ert-test-quit-should-forms--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-quit-should-forms (progn (or (ert-test-quit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-quit cl-x))) (aref cl-x 2))) nil] 9 (#$ . 51977)])#@71 Access slot "should-forms" of `ert-test-quit' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-should-forms compiler-macro ert-test-quit-should-forms--cmacro] 4)
(defalias 'ert-test-quit-should-forms #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 2] 5 (#$ . 52436)])#@70 compiler-macro for `ert-test-quit-duration'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-should-forms side-effect-free t] 4)
(defalias 'ert-test-quit-duration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-quit-duration (progn (or (ert-test-quit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-quit cl-x))) (aref cl-x 3))) nil] 9 (#$ . 52844)])#@67 Access slot "duration" of `ert-test-quit' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-duration compiler-macro ert-test-quit-duration--cmacro] 4)
(defalias 'ert-test-quit-duration #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 3] 5 (#$ . 53295)])#@71 compiler-macro for `ert-test-quit-condition'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-duration side-effect-free t] 4)
(defalias 'ert-test-quit-condition--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-quit-condition (progn (or (ert-test-quit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-quit cl-x))) (aref cl-x 4))) nil] 9 (#$ . 53687)])#@68 Access slot "condition" of `ert-test-quit' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-condition compiler-macro ert-test-quit-condition--cmacro] 4)
(defalias 'ert-test-quit-condition #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 4] 5 (#$ . 54137)])#@71 compiler-macro for `ert-test-quit-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-condition side-effect-free t] 4)
(defalias 'ert-test-quit-backtrace--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-quit-backtrace (progn (or (ert-test-quit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-quit cl-x))) (aref cl-x 5))) nil] 9 (#$ . 54533)])#@68 Access slot "backtrace" of `ert-test-quit' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-backtrace compiler-macro ert-test-quit-backtrace--cmacro] 4)
(defalias 'ert-test-quit-backtrace #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 5] 5 (#$ . 54984)])#@67 compiler-macro for `ert-test-quit-infos'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-backtrace side-effect-free t] 4)
(defalias 'ert-test-quit-infos--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-quit-infos (progn (or (ert-test-quit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-quit cl-x))) (aref cl-x 6))) nil] 9 (#$ . 55380)])#@64 Access slot "infos" of `ert-test-quit' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-infos compiler-macro ert-test-quit-infos--cmacro] 4)
(defalias 'ert-test-quit-infos #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 6] 5 (#$ . 55819)])#@129 compiler-macro for `make-ert-test-quit'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-quit-infos side-effect-free t defalias copy-ert-test-quit copy-sequence] 4)
(defalias 'make-ert-test-quit--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206 \306A@\300\307\"\206( \310A@\300\311\"\2063 \312A@\211\203i \211@\313>\203R \211A\204M \314\315@\"\210AA\2027 \316>A@\203` \210\317\2027 \314\320@\"\210\2027 \210\321\322\323\317\317&\207" [plist-member :messages :should-forms :duration (nil 0) :condition (nil (cl-assert nil)) :backtrace (nil (cl-assert nil)) :infos (nil (cl-assert nil)) (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" cl--defsubst-expand (messages should-forms duration condition backtrace infos) (cl-block make-ert-test-quit (record 'ert-test-quit messages should-forms duration condition backtrace infos))] 20 (#$ . 56200)])#@118 Constructor for objects of type `ert-test-quit'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-quit compiler-macro make-ert-test-quit--cmacro] 4)
(defalias 'make-ert-test-quit #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206$ \306\307\306!\210\306DA@\300\310\"\2064 \306\307\306!\210\306DA@\300\311\"\206E \306\307\306!\210\306DA@\211\203{ \211@\312>\203d \211A\204_ \313\314@\"\210AA\202I \315>A@\203r \210\306\202I \313\316@\"\210\202I \210\317\320&\207" [plist-member :messages :should-forms :duration (nil 0) :condition nil cl--assertion-failed :backtrace :infos (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-quit] 15 (#$ . 57401)])#@65 compiler-macro for `ert-test-failed-p'.

(fn CL-WHOLE-ARG CL-X)
(cl-struct-define 'ert-test-quit nil 'ert-test-result-with-condition 'record nil '((cl-tag-slot) (messages nil) (should-forms nil) (duration 0) (condition (cl-assert nil)) (backtrace (cl-assert nil)) (infos (cl-assert nil))) 'cl-struct-ert-test-quit-tags 'ert-test-quit t)
(defalias 'ert-test-failed-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-failed-p (and (memq (type-of cl-x) cl-struct-ert-test-failed-tags) t)) nil] 9 (#$ . 58384)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-p compiler-macro ert-test-failed-p--cmacro] 4)
(defalias 'ert-test-failed-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-failed-tags type-of t] 3 (#$ . 2692)])#@72 compiler-macro for `ert-test-failed-messages'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-failed-p side-effect-free error-free pure t define-symbol-prop ert-test-failed cl-deftype-satisfies] 6)
(defalias 'ert-test-failed-messages--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-failed-messages (progn (or (ert-test-failed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-failed cl-x))) (aref cl-x 1))) nil] 9 (#$ . 59185)])#@69 Access slot "messages" of `ert-test-failed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-messages compiler-macro ert-test-failed-messages--cmacro] 4)
(defalias 'ert-test-failed-messages #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 1] 5 (#$ . 59743)])#@76 compiler-macro for `ert-test-failed-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-messages side-effect-free t] 4)
(defalias 'ert-test-failed-should-forms--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-failed-should-forms (progn (or (ert-test-failed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-failed cl-x))) (aref cl-x 2))) nil] 9 (#$ . 60147)])#@73 Access slot "should-forms" of `ert-test-failed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-should-forms compiler-macro ert-test-failed-should-forms--cmacro] 4)
(defalias 'ert-test-failed-should-forms #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 2] 5 (#$ . 60618)])#@72 compiler-macro for `ert-test-failed-duration'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-should-forms side-effect-free t] 4)
(defalias 'ert-test-failed-duration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-failed-duration (progn (or (ert-test-failed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-failed cl-x))) (aref cl-x 3))) nil] 9 (#$ . 61038)])#@69 Access slot "duration" of `ert-test-failed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-duration compiler-macro ert-test-failed-duration--cmacro] 4)
(defalias 'ert-test-failed-duration #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 3] 5 (#$ . 61501)])#@73 compiler-macro for `ert-test-failed-condition'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-duration side-effect-free t] 4)
(defalias 'ert-test-failed-condition--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-failed-condition (progn (or (ert-test-failed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-failed cl-x))) (aref cl-x 4))) nil] 9 (#$ . 61905)])#@70 Access slot "condition" of `ert-test-failed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-condition compiler-macro ert-test-failed-condition--cmacro] 4)
(defalias 'ert-test-failed-condition #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 4] 5 (#$ . 62367)])#@73 compiler-macro for `ert-test-failed-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-condition side-effect-free t] 4)
(defalias 'ert-test-failed-backtrace--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-failed-backtrace (progn (or (ert-test-failed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-failed cl-x))) (aref cl-x 5))) nil] 9 (#$ . 62775)])#@70 Access slot "backtrace" of `ert-test-failed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-backtrace compiler-macro ert-test-failed-backtrace--cmacro] 4)
(defalias 'ert-test-failed-backtrace #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 5] 5 (#$ . 63238)])#@69 compiler-macro for `ert-test-failed-infos'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-backtrace side-effect-free t] 4)
(defalias 'ert-test-failed-infos--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-failed-infos (progn (or (ert-test-failed-p cl-x) (signal 'wrong-type-argument (list 'ert-test-failed cl-x))) (aref cl-x 6))) nil] 9 (#$ . 63646)])#@66 Access slot "infos" of `ert-test-failed' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-infos compiler-macro ert-test-failed-infos--cmacro] 4)
(defalias 'ert-test-failed-infos #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 6] 5 (#$ . 64097)])#@131 compiler-macro for `make-ert-test-failed'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-failed-infos side-effect-free t defalias copy-ert-test-failed copy-sequence] 4)
(defalias 'make-ert-test-failed--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206 \306A@\300\307\"\206( \310A@\300\311\"\2063 \312A@\211\203i \211@\313>\203R \211A\204M \314\315@\"\210AA\2027 \316>A@\203` \210\317\2027 \314\320@\"\210\2027 \210\321\322\323\317\317&\207" [plist-member :messages :should-forms :duration (nil 0) :condition (nil (cl-assert nil)) :backtrace (nil (cl-assert nil)) :infos (nil (cl-assert nil)) (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" cl--defsubst-expand (messages should-forms duration condition backtrace infos) (cl-block make-ert-test-failed (record 'ert-test-failed messages should-forms duration condition backtrace infos))] 20 (#$ . 64490)])#@120 Constructor for objects of type `ert-test-failed'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-failed compiler-macro make-ert-test-failed--cmacro] 4)
(defalias 'make-ert-test-failed #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206$ \306\307\306!\210\306DA@\300\310\"\2064 \306\307\306!\210\306DA@\300\311\"\206E \306\307\306!\210\306DA@\211\203{ \211@\312>\203d \211A\204_ \313\314@\"\210AA\202I \315>A@\203r \210\306\202I \313\316@\"\210\202I \210\317\320&\207" [plist-member :messages :should-forms :duration (nil 0) :condition nil cl--assertion-failed :backtrace :infos (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-failed] 15 (#$ . 65703)])#@66 compiler-macro for `ert-test-skipped-p'.

(fn CL-WHOLE-ARG CL-X)
(cl-struct-define 'ert-test-failed nil 'ert-test-result-with-condition 'record nil '((cl-tag-slot) (messages nil) (should-forms nil) (duration 0) (condition (cl-assert nil)) (backtrace (cl-assert nil)) (infos (cl-assert nil))) 'cl-struct-ert-test-failed-tags 'ert-test-failed t)
(defalias 'ert-test-skipped-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-skipped-p (and (memq (type-of cl-x) cl-struct-ert-test-skipped-tags) t)) nil] 9 (#$ . 66696)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-p compiler-macro ert-test-skipped-p--cmacro] 4)
(defalias 'ert-test-skipped-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-skipped-tags type-of t] 3 (#$ . 2692)])#@73 compiler-macro for `ert-test-skipped-messages'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-skipped-p side-effect-free error-free pure t define-symbol-prop ert-test-skipped cl-deftype-satisfies] 6)
(defalias 'ert-test-skipped-messages--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-skipped-messages (progn (or (ert-test-skipped-p cl-x) (signal 'wrong-type-argument (list 'ert-test-skipped cl-x))) (aref cl-x 1))) nil] 9 (#$ . 67511)])#@70 Access slot "messages" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-messages compiler-macro ert-test-skipped-messages--cmacro] 4)
(defalias 'ert-test-skipped-messages #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 1] 5 (#$ . 68076)])#@77 compiler-macro for `ert-test-skipped-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-messages side-effect-free t] 4)
(defalias 'ert-test-skipped-should-forms--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-skipped-should-forms (progn (or (ert-test-skipped-p cl-x) (signal 'wrong-type-argument (list 'ert-test-skipped cl-x))) (aref cl-x 2))) nil] 9 (#$ . 68486)])#@74 Access slot "should-forms" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-should-forms compiler-macro ert-test-skipped-should-forms--cmacro] 4)
(defalias 'ert-test-skipped-should-forms #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 2] 5 (#$ . 68963)])#@73 compiler-macro for `ert-test-skipped-duration'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-should-forms side-effect-free t] 4)
(defalias 'ert-test-skipped-duration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-skipped-duration (progn (or (ert-test-skipped-p cl-x) (signal 'wrong-type-argument (list 'ert-test-skipped cl-x))) (aref cl-x 3))) nil] 9 (#$ . 69389)])#@70 Access slot "duration" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-duration compiler-macro ert-test-skipped-duration--cmacro] 4)
(defalias 'ert-test-skipped-duration #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 3] 5 (#$ . 69858)])#@74 compiler-macro for `ert-test-skipped-condition'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-duration side-effect-free t] 4)
(defalias 'ert-test-skipped-condition--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-skipped-condition (progn (or (ert-test-skipped-p cl-x) (signal 'wrong-type-argument (list 'ert-test-skipped cl-x))) (aref cl-x 4))) nil] 9 (#$ . 70268)])#@71 Access slot "condition" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-condition compiler-macro ert-test-skipped-condition--cmacro] 4)
(defalias 'ert-test-skipped-condition #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 4] 5 (#$ . 70736)])#@74 compiler-macro for `ert-test-skipped-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-condition side-effect-free t] 4)
(defalias 'ert-test-skipped-backtrace--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-skipped-backtrace (progn (or (ert-test-skipped-p cl-x) (signal 'wrong-type-argument (list 'ert-test-skipped cl-x))) (aref cl-x 5))) nil] 9 (#$ . 71150)])#@71 Access slot "backtrace" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-backtrace compiler-macro ert-test-skipped-backtrace--cmacro] 4)
(defalias 'ert-test-skipped-backtrace #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 5] 5 (#$ . 71619)])#@70 compiler-macro for `ert-test-skipped-infos'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-backtrace side-effect-free t] 4)
(defalias 'ert-test-skipped-infos--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-skipped-infos (progn (or (ert-test-skipped-p cl-x) (signal 'wrong-type-argument (list 'ert-test-skipped cl-x))) (aref cl-x 6))) nil] 9 (#$ . 72033)])#@67 Access slot "infos" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-infos compiler-macro ert-test-skipped-infos--cmacro] 4)
(defalias 'ert-test-skipped-infos #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 6] 5 (#$ . 72490)])#@132 compiler-macro for `make-ert-test-skipped'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-skipped-infos side-effect-free t defalias copy-ert-test-skipped copy-sequence] 4)
(defalias 'make-ert-test-skipped--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206 \306A@\300\307\"\206( \310A@\300\311\"\2063 \312A@\211\203i \211@\313>\203R \211A\204M \314\315@\"\210AA\2027 \316>A@\203` \210\317\2027 \314\320@\"\210\2027 \210\321\322\323\317\317&\207" [plist-member :messages :should-forms :duration (nil 0) :condition (nil (cl-assert nil)) :backtrace (nil (cl-assert nil)) :infos (nil (cl-assert nil)) (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" cl--defsubst-expand (messages should-forms duration condition backtrace infos) (cl-block make-ert-test-skipped (record 'ert-test-skipped messages should-forms duration condition backtrace infos))] 20 (#$ . 72889)])#@121 Constructor for objects of type `ert-test-skipped'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-skipped compiler-macro make-ert-test-skipped--cmacro] 4)
(defalias 'make-ert-test-skipped #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\300\305\"\206$ \306\307\306!\210\306DA@\300\310\"\2064 \306\307\306!\210\306DA@\300\311\"\206E \306\307\306!\210\306DA@\211\203{ \211@\312>\203d \211A\204_ \313\314@\"\210AA\202I \315>A@\203r \210\306\202I \313\316@\"\210\202I \210\317\320&\207" [plist-member :messages :should-forms :duration (nil 0) :condition nil cl--assertion-failed :backtrace :infos (:messages :should-forms :duration :condition :backtrace :infos :allow-other-keys) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-skipped] 15 (#$ . 74108)])#@86 compiler-macro for `ert-test-aborted-with-non-local-exit-p'.

(fn CL-WHOLE-ARG CL-X)
(cl-struct-define 'ert-test-skipped nil 'ert-test-result-with-condition 'record nil '((cl-tag-slot) (messages nil) (should-forms nil) (duration 0) (condition (cl-assert nil)) (backtrace (cl-assert nil)) (infos (cl-assert nil))) 'cl-struct-ert-test-skipped-tags 'ert-test-skipped t)
(defalias 'ert-test-aborted-with-non-local-exit-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-aborted-with-non-local-exit-p (and (memq (type-of cl-x) cl-struct-ert-test-aborted-with-non-local-exit-tags) t)) nil] 9 (#$ . 75106)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-aborted-with-non-local-exit-p compiler-macro ert-test-aborted-with-non-local-exit-p--cmacro] 4)
(defalias 'ert-test-aborted-with-non-local-exit-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-aborted-with-non-local-exit-tags type-of t] 3 (#$ . 2692)])#@93 compiler-macro for `ert-test-aborted-with-non-local-exit-messages'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert-test-aborted-with-non-local-exit-p side-effect-free error-free pure t define-symbol-prop ert-test-aborted-with-non-local-exit cl-deftype-satisfies] 6)
(defalias 'ert-test-aborted-with-non-local-exit-messages--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-aborted-with-non-local-exit-messages (progn (or (ert-test-aborted-with-non-local-exit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-aborted-with-non-local-exit cl-x))) (aref cl-x 1))) nil] 9 (#$ . 76084)])#@90 Access slot "messages" of `ert-test-aborted-with-non-local-exit' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-aborted-with-non-local-exit-messages compiler-macro ert-test-aborted-with-non-local-exit-messages--cmacro] 4)
(defalias 'ert-test-aborted-with-non-local-exit-messages #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-aborted-with-non-local-exit-tags type-of signal wrong-type-argument ert-test-aborted-with-non-local-exit 1] 5 (#$ . 76789)])#@97 compiler-macro for `ert-test-aborted-with-non-local-exit-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-aborted-with-non-local-exit-messages side-effect-free t] 4)
(defalias 'ert-test-aborted-with-non-local-exit-should-forms--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-aborted-with-non-local-exit-should-forms (progn (or (ert-test-aborted-with-non-local-exit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-aborted-with-non-local-exit cl-x))) (aref cl-x 2))) nil] 9 (#$ . 77319)])#@105 Access slot "should-forms" of CL-X.
Struct CL-X is a `ert-test-aborted-with-non-local-exit'.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-aborted-with-non-local-exit-should-forms compiler-macro ert-test-aborted-with-non-local-exit-should-forms--cmacro] 4)
(defalias 'ert-test-aborted-with-non-local-exit-should-forms #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-aborted-with-non-local-exit-tags type-of signal wrong-type-argument ert-test-aborted-with-non-local-exit 2] 5 (#$ . 77917)])#@93 compiler-macro for `ert-test-aborted-with-non-local-exit-duration'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-aborted-with-non-local-exit-should-forms side-effect-free t] 4)
(defalias 'ert-test-aborted-with-non-local-exit-duration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert-test-aborted-with-non-local-exit-duration (progn (or (ert-test-aborted-with-non-local-exit-p cl-x) (signal 'wrong-type-argument (list 'ert-test-aborted-with-non-local-exit cl-x))) (aref cl-x 3))) nil] 9 (#$ . 78474)])#@90 Access slot "duration" of `ert-test-aborted-with-non-local-exit' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-aborted-with-non-local-exit-duration compiler-macro ert-test-aborted-with-non-local-exit-duration--cmacro] 4)
(defalias 'ert-test-aborted-with-non-local-exit-duration #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-aborted-with-non-local-exit-tags type-of signal wrong-type-argument ert-test-aborted-with-non-local-exit 3] 5 (#$ . 79063)])#@126 compiler-macro for `make-ert-test-aborted-with-non-local-exit'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-aborted-with-non-local-exit-duration side-effect-free t defalias copy-ert-test-aborted-with-non-local-exit copy-sequence] 4)
(defalias 'make-ert-test-aborted-with-non-local-exit--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203H \211@\305>\2032 \211A\204- \306\307@\"\210AA\202 \310>A@\203? \210\311\202 \306\312@\"\210\202 \210\313\314\315\311\311&\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration)" cl--defsubst-expand (messages should-forms duration) (cl-block make-ert-test-aborted-with-non-local-exit (record 'ert-test-aborted-with-non-local-exit messages should-forms duration))] 14 (#$ . 79594)])#@115 Constructor for objects of type `ert-test-aborted-with-non-local-exit'.

(fn &key MESSAGES SHOULD-FORMS DURATION)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-aborted-with-non-local-exit compiler-macro make-ert-test-aborted-with-non-local-exit--cmacro] 4)
(defalias 'make-ert-test-aborted-with-non-local-exit #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203H \211@\305>\2032 \211A\204- \306\307@\"\210AA\202 \310>A@\203? \210\311\202 \306\312@\"\210\202 \210\313\314$\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:messages :should-forms :duration)" record ert-test-aborted-with-non-local-exit] 9 (#$ . 80627)])#@74 compiler-macro for `ert--test-execution-info-p'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-ert-test-aborted-with-non-local-exit side-effect-free t cl-struct-define ert-test-aborted-with-non-local-exit nil ert-test-result record ((cl-tag-slot) (messages nil) (should-forms nil) (duration 0)) cl-struct-ert-test-aborted-with-non-local-exit-tags] 11)
(defalias 'ert--test-execution-info-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-p (and (memq (type-of cl-x) cl-struct-ert--test-execution-info-tags) t)) nil] 9 (#$ . 81454)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--test-execution-info-p compiler-macro ert--test-execution-info-p--cmacro] 4)
(defalias 'ert--test-execution-info-p #[257 "\301!>\205	 \302\207" [cl-struct-ert--test-execution-info-tags type-of t] 3 (#$ . 2692)])#@77 compiler-macro for `ert--test-execution-info-test'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert--test-execution-info-p side-effect-free error-free pure t define-symbol-prop ert--test-execution-info cl-deftype-satisfies] 6)
(defalias 'ert--test-execution-info-test--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-test (progn (or (ert--test-execution-info-p cl-x) (signal 'wrong-type-argument (list 'ert--test-execution-info cl-x))) (aref cl-x 1))) nil] 9 (#$ . 82407)])#@74 Access slot "test" of `ert--test-execution-info' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--test-execution-info-test compiler-macro ert--test-execution-info-test--cmacro] 4)
(defalias 'ert--test-execution-info-test #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 1] 5 (#$ . 83016)])#@79 compiler-macro for `ert--test-execution-info-result'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--test-execution-info-test side-effect-free t] 4)
(defalias 'ert--test-execution-info-result--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-result (progn (or (ert--test-execution-info-p cl-x) (signal 'wrong-type-argument (list 'ert--test-execution-info cl-x))) (aref cl-x 2))) nil] 9 (#$ . 83458)])#@76 Access slot "result" of `ert--test-execution-info' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--test-execution-info-result compiler-macro ert--test-execution-info-result--cmacro] 4)
(defalias 'ert--test-execution-info-result #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 2] 5 (#$ . 83961)])#@90 compiler-macro for `ert--test-execution-info-exit-continuation'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--test-execution-info-result side-effect-free t] 4)
(defalias 'ert--test-execution-info-exit-continuation--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-exit-continuation (progn (or (ert--test-execution-info-p cl-x) (signal 'wrong-type-argument (list 'ert--test-execution-info cl-x))) (aref cl-x 3))) nil] 9 (#$ . 84411)])#@87 Access slot "exit-continuation" of `ert--test-execution-info' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--test-execution-info-exit-continuation compiler-macro ert--test-execution-info-exit-continuation--cmacro] 4)
(defalias 'ert--test-execution-info-exit-continuation #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 3] 5 (#$ . 84949)])#@91 compiler-macro for `ert--test-execution-info-ert-debug-on-error'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--test-execution-info-exit-continuation side-effect-free t] 4)
(defalias 'ert--test-execution-info-ert-debug-on-error--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-ert-debug-on-error (progn (or (ert--test-execution-info-p cl-x) (signal 'wrong-type-argument (list 'ert--test-execution-info cl-x))) (aref cl-x 4))) nil] 9 (#$ . 85443)])#@88 Access slot "ert-debug-on-error" of `ert--test-execution-info' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--test-execution-info-ert-debug-on-error compiler-macro ert--test-execution-info-ert-debug-on-error--cmacro] 4)
(defalias 'ert--test-execution-info-ert-debug-on-error #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 4] 5 (#$ . 85995)])#@132 compiler-macro for `make-ert--test-execution-info'.

(fn CL-WHOLE &cl-quote &key TEST RESULT EXIT-CONTINUATION ERT-DEBUG-ON-ERROR)#@27 

(fn ERT-DEBUG-ON-ERROR)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert--test-execution-info-ert-debug-on-error side-effect-free t defalias copy-ert--test-execution-info copy-sequence] 4)
(defalias 'make-ert--test-execution-info--cmacro #[385 "\300\301\"\206 \302A@\300\303\"\206 \304A@\300\305\"\206 \306A@\307\310\n&\300\311\"A@!\207" [plist-member :test (nil (cl-assert nil)) :result (nil (cl-assert nil)) :exit-continuation (nil (cl-assert nil)) make-closure #[257 "\303\211\2032 \211@\305>\203 \211A\204 \306\307@\"\210AA\202 \310\303>A@\203) \210\311\202 \306\312@\"\210\202 \210\313\314\315\311\304\311\302\301\300	&	\207" [V0 V1 V2 V3 V4 (:test :result :exit-continuation :ert-debug-on-error :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:test :result :exit-continuation :ert-debug-on-error)" cl--defsubst-expand (test result exit-continuation ert-debug-on-error) (cl-block make-ert--test-execution-info (record 'ert--test-execution-info test result exit-continuation ert-debug-on-error))] 11 (#$ . 86630)] :ert-debug-on-error] 12 (#$ . 86494)])#@121 Constructor for objects of type `ert--test-execution-info'.

(fn &key TEST RESULT EXIT-CONTINUATION ERT-DEBUG-ON-ERROR)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert--test-execution-info compiler-macro make-ert--test-execution-info--cmacro] 4)
(defalias 'make-ert--test-execution-info #[128 "\300\301\"\206 \302\303\302!\210\302DA@\300\304\"\206 \302\303\302!\210\302DA@\300\305\"\206. \302\303\302!\210\302DA@\306\307%\300\310\"A@!\207" [plist-member :test nil cl--assertion-failed :result :exit-continuation make-closure #[257 "\303\211\2032 \211@\304>\203 \211A\204 \305\306@\"\210AA\202 \307\303>A@\203) \210\310\202 \305\311@\"\210\202 \210\312\313\302\301\300%\207" [V0 V1 V2 V3 (:test :result :exit-continuation :ert-debug-on-error :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:test :result :exit-continuation :ert-debug-on-error)" record ert--test-execution-info] 7 (#$ . 86630)] :ert-debug-on-error] 10 (#$ . 87794)])#@302 Error handler used during the test run.

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.
ERR is the error object.

(fn INFO CONDITION DEBUGFUN)
(cl-struct-define 'ert--test-execution-info nil 'cl-structure-object 'record nil '((cl-tag-slot) (test (cl-assert nil)) (result (cl-assert nil)) (exit-continuation (cl-assert nil)) (ert-debug-on-error)) 'cl-struct-ert--test-execution-info-tags 'ert--test-execution-info t)
(defalias 'ert--run-test-debugger #[771 "@\211\303=\203 \210\303\202 \211\304=\203 \210\305\202 \210\306\307!A\310!\311!	>\2042 \312\313\314D\"\210\315\316\267\202j \317\320\321\211\322		&\202t \317\304\321\211\322		&\202t \317\323\321\211\322		&\202t \324\325\326#\205t \321I\210\311!	>\204\207 \312\313\314D\"\210\327H\203\226 \n\324\330$\210\311!	>\204\247 \312\313\314D\"\210\331H \207" [ert--infos cl-struct-ert--test-execution-info-tags debugger quit ert-test-skipped skipped failed backtrace-get-frames reverse type-of signal wrong-type-argument ert--test-execution-info 2 #s(hash-table test eq purecopy t data (quit 58 skipped 74 failed 90)) record ert-test-quit nil 0 ert-test-failed error "cl-ecase failed: %s, %s" (quit skipped failed) 4 :backtrace-base 3] 16 (#$ . 88830)])#@142 Low-level function to run a test according to TEST-EXECUTION-INFO.

This mainly sets up debugger-related bindings.

(fn TEST-EXECUTION-INFO)#@12 

(fn ERR)
(defalias 'ert--run-test-internal #[257 "\304!>\204 \305\306\307D\"\210\211\310	I\210\3112K \312\313\314\"r\211q\210\315\316\"\216\317 \315\320\"\216\314\321\321C\211\315\322#\240\210\323\315\324\"\325\242#-\266\326 0\210\304!>\204[ \305\306\307D\"\210\211\327\330\331\321\211\332$I\321\207" [cl-struct-ert--test-execution-info-tags ert-debug-on-error ert--infos lexical-binding type-of signal wrong-type-argument ert--test-execution-info 4 ert--pass generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] current-window-configuration #[0 "\301\300!\207" [V0 set-window-configuration] 2] nil #[257 "\302\301\300\242#\207" [V0 V1 ert--run-test-debugger] 5 (#$ . 90386)] handler-bind-1 #[0 "\303\300!	>\204 \304\305\306\300D\"\210\300\307H\303!\n>\204! \304\305\310D\"\210\211\311H\262 \207" [V0 cl-struct-ert--test-execution-info-tags cl-struct-ert-test-tags type-of signal wrong-type-argument ert--test-execution-info 1 ert-test 3] 5] (error quit) ert-pass 2 record ert-test-passed 0] 10 (#$ . 90240)])#@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 #[0 "r\302 q\210\303!\205 e\212db\210[y\210`)\304|)\266\202)\207" [message-log-max inhibit-read-only messages-buffer natnump t] 4 (#$ . 91486)])#@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 (#$ . 91833))#@105 Run ERT-TEST.

Returns the result and stores it in ERT-TEST's `most-recent-result' slot.

(fn ERT-TEST)#@25 

(fn FORM-DESCRIPTION)
(defalias 'ert-run-test #[257 "\304!>\204 \305\306\307D\"\210\211\310\311I\210\3122Q r\313 q\210\314 )\315\316\"\216\317\320\321\322\323\311\211\324$\325\326&\311C\315\327%\216\315\330\"\331	B\332!-\266\2030\210\304!>\204a \305\306\307D\"\210\211\310H\207" [cl-struct-ert-test-tags ert--running-tests message-log-max ert--should-execution-observer type-of signal wrong-type-argument ert-test 4 nil --cl-block-error-- messages-buffer point-max-marker make-closure #[0 "\300\301\211\223\207" [V0 nil] 3] make-ert--test-execution-info :test :result record ert-test-aborted-with-non-local-exit 0 :exit-continuation #[0 "\300\301\302\"\207" [throw --cl-block-error-- nil] 3] #[0 "\306\301!\f>\204 \307\310\311\301D\"\210\301\312H\306!>\204! \307\310\313D\"\210\211\314r\315 q\210\302d{)I\210\316 \210\300\211\242\237\240\210\306!>\204F \307\310\313D\"\210\211\312\300\242I\210\306\303!>\204\\ \307\310\317\303D\"\210\303\320I\207" [V0 V1 V2 V3 cl-struct-ert--test-execution-info-tags cl-struct-ert-test-result-tags type-of signal wrong-type-argument ert--test-execution-info 2 ert-test-result 1 messages-buffer ert--force-message-log-buffer-truncation ert-test 4 cl-struct-ert-test-tags] 5] #[257 "\300\300\242B\240\207" [V0] 4 (#$ . 92287)] t ert--run-test-internal] 11 (#$ . 92178)])#@48 Return the top-level test currently executing.
(defalias 'ert-running-test #[0 "\301!@\207" [ert--running-tests last] 2 (#$ . 93630)])#@452 Return non-nil if RESULT matches type RESULT-TYPE.

Valid result types:

nil -- Never matches.
t -- Always matches.
:failed, :passed, :skipped -- 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.

(fn RESULT RESULT-TYPE)
(defalias 'ert-test-result-type-p #[514 "\211\303\267\202( \304\207\305\207\306!>\205\233 \305\207\306!	>\205\233 \305\207\306!\n>\205\233 \305\207\211:\203\227 \211\242\243\307\267\202\215 \211G\211\310=\203A \305\207\311@\"\205P \311\312AB\"\207\211G\211\310=\203[ \304\207\311@\"\206j \311\313AB\"\207\211G\314=\204v \315\316!\210\311@\"?\207\211G\314=\204\210 \315\317!\210\211@!\207\320\321\322#\205\226 \304\207\320\323\"\207" [cl-struct-ert-test-failed-tags cl-struct-ert-test-passed-tags cl-struct-ert-test-skipped-tags #s(hash-table test eq purecopy t data (nil 6 t 8 :failed 10 :passed 20 :skipped 30)) nil t type-of #s(hash-table test eq purecopy t data (and 55 or 81 not 107 satisfies 125)) 0 ert-test-result-type-p and or 1 cl--assertion-failed (eql (length operands) 1) (eql (length operands) 1) error "cl-ecase failed: %s, %s" (and or not satisfies) "No clause matching `%S'"] 10 (#$ . 93772)])#@81 Return non-nil if TEST's expected result type matches RESULT.

(fn TEST RESULT)
(defalias 'ert-test-result-expected-p #[514 "\301\302\"\206 \301\303!>\204 \304\305\306D\"\210\307H\"\207" [cl-struct-ert-test-tags ert-test-result-type-p :skipped type-of signal wrong-type-argument ert-test 5] 8 (#$ . 95157)])#@1745 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 all of UNIVERSE.  If UNIVERSE is t, selects all tests.
: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 named by the symbol, signals an
    `ert-test-unbound' error if no such test.
(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.

(fn SELECTOR UNIVERSE)#@13 

(fn TEST)#@23 

(fn PURPORTED-TEST)
(defalias 'ert-select-tests #[514 "\301\267\202? \302\207\211<\203 \207\211\303=\203 \304\305\"\207\306\307\"\207\304\310\311D\"\207\304\310\312D\"\207\304\310\313D\"\207\304\310\314D\"\207\304\315\"\207;\203d \211\303=\203R \316\317\320\321\"\"\207\211<\203_ \322\323\324\"\"\207\306\307\"\207\325!>\203o C\2079\203\205 \321!\204\200 \326\327C\"\210\317!C\207:\203{\242\211\330\267\202v\243\316\331\"\207\243\211:\203\266 \211\242\243\211\204\260 \304\332D\"\207\306\307\"\207\306\307\"\207\243\211\204\306 \304\303\"\207\211:\203\332 \211\242\243\304\333B\304\"\"\207\306\307\"\207\243\211:\203\211\242\243\211\204\373 \304\303\"\334\304\"\"\207\306\307\"\207\306\307\"\207\243\211\204\304\302\"\207\211:\203)\211\242\243\335\304\"\304\336B\"\"\207\306\307\"\207\243\211:\203N\211\242\243\211\204H\304\310\323\337\"D\"\207\306\307\"\207\306\307\"\207\243\211:\203q\211\242\243\211\204k\322\304\303\"\"\207\306\307\"\207\306\307\"\207\306\307\"\207\306\307\"\207" [cl-struct-ert-test-tags #s(hash-table test eq purecopy t data (nil 6 t 8 :new 30 :failed 37 :passed 44 :expected 51 :unexpected 58)) nil t ert-select-tests "" error #1="No clause matching `%S'" satisfies #[257 "\301!>\204 \302\303\304D\"\210\211\305H?\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 4] 5 (#$ . 97230)] #[257 "\301\302!>\204 \303\304\305D\"\210\306H\307\"\207" [cl-struct-ert-test-tags ert-test-result-type-p type-of signal wrong-type-argument ert-test 4 :failed] 6 (#$ . 97230)] #[257 "\301\302!>\204 \303\304\305D\"\210\306H\307\"\207" [cl-struct-ert-test-tags ert-test-result-type-p type-of signal wrong-type-argument ert-test 4 :passed] 6 (#$ . 97230)] #[257 "\301\302!>\204 \303\304\305D\"\210\306H\"\207" [cl-struct-ert-test-tags ert-test-result-expected-p type-of signal wrong-type-argument ert-test 4] 7 (#$ . 97230)] (not :expected) mapcar ert-get-test apropos-internal ert-test-boundp cl-remove-if-not make-closure #[257 "\302!	>\204 \303\304\305D\"\210\211\306H\205- \307\300\310\302!	>\204( \303\304\305D\"\210\306H!\"\207" [V0 cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 1 string-match symbol-name] 8 (#$ . 97230)] type-of signal ert-test-unbound #s(hash-table test eq purecopy t data (member 146 eql 153 and 187 not 223 or 262 tag 302 satisfies 339)) #[257 "\2119\203 \301!\204 \302\303C\"\210\304!\207\305!>\203 \207\306\307\"\207" [cl-struct-ert-test-tags ert-test-boundp signal ert-test-unbound ert-get-test type-of error #1#] 4 (#$ . 97247)] member and cl-set-difference cl-union or #[257 "\300\302!	>\204 \303\304\305D\"\210\306H\235\207" [V0 cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 6] 6 (#$ . 97230)]] 12 (#$ . 95481)])#@90 Insert a human-readable presentation of SELECTOR into the current buffer.

(fn SELECTOR)#@17 

(fn SELECTOR)
(define-error 'ert-test-unbound "ERT test is unbound")
(defalias 'ert--insert-human-readable-selector #[257 "\300C\211\301\302\"\240\210\303\304\242!\"c\207" [nil make-closure #[257 "\211;\203 \207\2119\203\f \207\302!	>\203F \302!	>\204# \303\304\305D\"\210\211\306H\203B \307\310\311\302!	>\204< \303\304\305D\"\210\306H\"!\207\307\312!\207\211:\203a \211\242\243\313\267\202_ \314\300\242\"B\207\207\315\207\316\317\"\207" [V0 cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 1 make-symbol format "<%S>" "<unnamed test>" #s(hash-table test eq purecopy t data (or 85 not 85 and 85 eql 85 member 85 satisfies 93 tag 93)) mapcar nil error "No clause matching `%S'"] 8 (#$ . 100199)] format "%S"] 6 (#$ . 100105)])#@60 compiler-macro for `ert--stats-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ert--stats-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-p (and (memq (type-of cl-x) cl-struct-ert--stats-tags) t)) nil] 9 (#$ . 100970)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-p compiler-macro ert--stats-p--cmacro] 4)
(defalias 'ert--stats-p #[257 "\301!>\205	 \302\207" [cl-struct-ert--stats-tags type-of t] 3 (#$ . 2692)])#@67 compiler-macro for `ert--stats-selector'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert--stats-p side-effect-free error-free pure t define-symbol-prop ert--stats cl-deftype-satisfies] 6)
(defalias 'ert--stats-selector--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-selector (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 1))) nil] 9 (#$ . 101459)])#@64 Access slot "selector" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-selector compiler-macro ert--stats-selector--cmacro] 4)
(defalias 'ert--stats-selector #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 1] 5 (#$ . 101983)])#@64 compiler-macro for `ert--stats-tests'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-selector side-effect-free t] 4)
(defalias 'ert--stats-tests--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-tests (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 2))) nil] 9 (#$ . 102358)])#@61 Access slot "tests" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-tests compiler-macro ert--stats-tests--cmacro] 4)
(defalias 'ert--stats-tests #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 2] 5 (#$ . 102779)])#@67 compiler-macro for `ert--stats-test-map'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-tests side-effect-free t] 4)
(defalias 'ert--stats-test-map--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-test-map (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 3))) nil] 9 (#$ . 103142)])#@64 Access slot "test-map" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-test-map compiler-macro ert--stats-test-map--cmacro] 4)
(defalias 'ert--stats-test-map #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 3] 5 (#$ . 103569)])#@71 compiler-macro for `ert--stats-test-results'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-map side-effect-free t] 4)
(defalias 'ert--stats-test-results--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-test-results (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 4))) nil] 9 (#$ . 103944)])#@68 Access slot "test-results" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-test-results compiler-macro ert--stats-test-results--cmacro] 4)
(defalias 'ert--stats-test-results #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 4] 5 (#$ . 104386)])#@75 compiler-macro for `ert--stats-test-start-times'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-results side-effect-free t] 4)
(defalias 'ert--stats-test-start-times--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-test-start-times (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 5))) nil] 9 (#$ . 104777)])#@72 Access slot "test-start-times" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-test-start-times compiler-macro ert--stats-test-start-times--cmacro] 4)
(defalias 'ert--stats-test-start-times #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 5] 5 (#$ . 105235)])#@73 compiler-macro for `ert--stats-test-end-times'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-start-times side-effect-free t] 4)
(defalias 'ert--stats-test-end-times--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-test-end-times (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 6))) nil] 9 (#$ . 105642)])#@70 Access slot "test-end-times" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-test-end-times compiler-macro ert--stats-test-end-times--cmacro] 4)
(defalias 'ert--stats-test-end-times #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 6] 5 (#$ . 106098)])#@74 compiler-macro for `ert--stats-passed-expected'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-end-times side-effect-free t] 4)
(defalias 'ert--stats-passed-expected--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-passed-expected (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 7))) nil] 9 (#$ . 106497)])#@71 Access slot "passed-expected" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-passed-expected compiler-macro ert--stats-passed-expected--cmacro] 4)
(defalias 'ert--stats-passed-expected #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 7] 5 (#$ . 106954)])#@76 compiler-macro for `ert--stats-passed-unexpected'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-passed-expected side-effect-free t] 4)
(defalias 'ert--stats-passed-unexpected--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-passed-unexpected (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 8))) nil] 9 (#$ . 107357)])#@73 Access slot "passed-unexpected" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-passed-unexpected compiler-macro ert--stats-passed-unexpected--cmacro] 4)
(defalias 'ert--stats-passed-unexpected #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 8] 5 (#$ . 107821)])#@74 compiler-macro for `ert--stats-failed-expected'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-passed-unexpected side-effect-free t] 4)
(defalias 'ert--stats-failed-expected--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-failed-expected (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 9))) nil] 9 (#$ . 108232)])#@71 Access slot "failed-expected" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-failed-expected compiler-macro ert--stats-failed-expected--cmacro] 4)
(defalias 'ert--stats-failed-expected #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 9] 5 (#$ . 108692)])#@76 compiler-macro for `ert--stats-failed-unexpected'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-failed-expected side-effect-free t] 4)
(defalias 'ert--stats-failed-unexpected--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-failed-unexpected (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 10))) nil] 9 (#$ . 109095)])#@73 Access slot "failed-unexpected" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-failed-unexpected compiler-macro ert--stats-failed-unexpected--cmacro] 4)
(defalias 'ert--stats-failed-unexpected #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 10] 5 (#$ . 109560)])#@66 compiler-macro for `ert--stats-skipped'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-failed-unexpected side-effect-free t] 4)
(defalias 'ert--stats-skipped--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-skipped (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 11))) nil] 9 (#$ . 109972)])#@63 Access slot "skipped" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-skipped compiler-macro ert--stats-skipped--cmacro] 4)
(defalias 'ert--stats-skipped #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 11] 5 (#$ . 110409)])#@69 compiler-macro for `ert--stats-start-time'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-skipped side-effect-free t] 4)
(defalias 'ert--stats-start-time--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-start-time (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 12))) nil] 9 (#$ . 110781)])#@66 Access slot "start-time" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-start-time compiler-macro ert--stats-start-time--cmacro] 4)
(defalias 'ert--stats-start-time #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 12] 5 (#$ . 111217)])#@67 compiler-macro for `ert--stats-end-time'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-start-time side-effect-free t] 4)
(defalias 'ert--stats-end-time--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-end-time (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 13))) nil] 9 (#$ . 111601)])#@64 Access slot "end-time" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-end-time compiler-macro ert--stats-end-time--cmacro] 4)
(defalias 'ert--stats-end-time #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 13] 5 (#$ . 112034)])#@68 compiler-macro for `ert--stats-aborted-p'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-end-time side-effect-free t] 4)
(defalias 'ert--stats-aborted-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-aborted-p (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 14))) nil] 9 (#$ . 112410)])#@65 Access slot "aborted-p" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-aborted-p compiler-macro ert--stats-aborted-p--cmacro] 4)
(defalias 'ert--stats-aborted-p #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 14] 5 (#$ . 112844)])#@71 compiler-macro for `ert--stats-current-test'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-aborted-p side-effect-free t] 4)
(defalias 'ert--stats-current-test--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-current-test (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 15))) nil] 9 (#$ . 113224)])#@68 Access slot "current-test" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-current-test compiler-macro ert--stats-current-test--cmacro] 4)
(defalias 'ert--stats-current-test #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 15] 5 (#$ . 113668)])#@73 compiler-macro for `ert--stats-next-redisplay'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-current-test side-effect-free t] 4)
(defalias 'ert--stats-next-redisplay--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--stats-next-redisplay (progn (or (ert--stats-p cl-x) (signal 'wrong-type-argument (list 'ert--stats cl-x))) (aref cl-x 16))) nil] 9 (#$ . 114060)])#@70 Access slot "next-redisplay" of `ert--stats' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-next-redisplay compiler-macro ert--stats-next-redisplay--cmacro] 4)
(defalias 'ert--stats-next-redisplay #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 16] 5 (#$ . 114513)])#@272 compiler-macro for `make-ert--stats'.

(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 SKIPPED START-TIME END-TIME ABORTED-P CURRENT-TEST NEXT-REDISPLAY)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert--stats-next-redisplay side-effect-free t defalias copy-ert--stats copy-sequence] 4)
(defalias 'make-ert--stats--cmacro #[385 "\300\301\"\206 \302A@\300\303\"\206 \304A@\300\305\"\206 \306A@\300\307\"\206& \310A@\300\311\"\2060 \312A@\300\313\"\206; \314A@\300\315\"\206F \316A@\300\317\"\206Q \320A@\300	\321\"\206\\ \322A@\300\n\323\"\206g \324A@\300\325\"\206r \326A@\300\f\327\"A@\300\330\"A@\300\331\"A@\300\332\"A@\300\333\"\206\231 \334A@\211\203\317 \211@\335>\203\270 \211A\204\263 \336\337@\"\210AA\202\235 \340>A@\203\306 \210\341\202\235 \336\342@\"\210\202\235 \210\343\344\345\341\341&\207" [plist-member :selector (nil (cl-assert nil)) :tests (nil (cl-assert nil)) :test-map (nil (cl-assert nil)) :test-results (nil (cl-assert nil)) :test-start-times (nil (cl-assert nil)) :test-end-times (nil (cl-assert nil)) :passed-expected (nil 0) :passed-unexpected (nil 0) :failed-expected (nil 0) :failed-unexpected (nil 0) :skipped (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 :skipped :start-time :end-time :aborted-p :current-test :next-redisplay :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "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 :skipped :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 skipped start-time end-time aborted-p current-test next-redisplay) (cl-block make-ert--stats (record 'ert--stats selector tests test-map test-results test-start-times test-end-times passed-expected passed-unexpected failed-expected failed-unexpected skipped start-time end-time aborted-p current-test next-redisplay))] 40 (#$ . 114914)])#@261 Constructor for objects of type `ert--stats'.

(fn &key SELECTOR TESTS TEST-MAP TEST-RESULTS TEST-START-TIMES TEST-END-TIMES PASSED-EXPECTED PASSED-UNEXPECTED FAILED-EXPECTED FAILED-UNEXPECTED SKIPPED START-TIME END-TIME ABORTED-P CURRENT-TEST NEXT-REDISPLAY)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert--stats compiler-macro make-ert--stats--cmacro] 4)
(defalias 'make-ert--stats #[128 "\300\301\"\206 \302\303\302!\210\302DA@\300\304\"\206 \302\303\302!\210\302DA@\300\305\"\206. \302\303\302!\210\302DA@\300\306\"\206> \302\303\302!\210\302DA@\300\307\"\206N \302\303\302!\210\302DA@\300\310\"\206_ \302\303\302!\210\302DA@\300\311\"\206j \312A@\300\313\"\206u \314A@\300	\315\"\206\200 \316A@\300\n\317\"\206\213 \320A@\300\321\"\206\226 \322A@\300\f\323\"A@\300\324\"A@\300\325\"A@\300\326\"A@\300\327\"\206\275 \330A@\211\203\363 \211@\331>\203\334 \211A\204\327 \332\333@\"\210AA\202\301 \334>A@\203\352 \210\302\202\301 \332\335@\"\210\202\301 \210\336\337&\207" [plist-member :selector nil 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) :skipped (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 :skipped :start-time :end-time :aborted-p :current-test :next-redisplay :allow-other-keys) error "Missing argument for %s" :allow-other-keys "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 :skipped :start-time :end-time :aborted-p :current-test :next-redisplay)" record ert--stats] 35 (#$ . 117388)])#@76 Return the number of tests in STATS that had expected results.

(fn STATS)
(cl-struct-define 'ert--stats nil 'cl-structure-object 'record nil '((cl-tag-slot) (selector (cl-assert nil)) (tests (cl-assert nil) :type vector) (test-map (cl-assert nil) :type hash-table) (test-results (cl-assert nil) :type vector) (test-start-times (cl-assert nil) :type vector) (test-end-times (cl-assert nil) :type vector) (passed-expected 0) (passed-unexpected 0) (failed-expected 0) (failed-unexpected 0) (skipped 0) (start-time nil) (end-time nil) (aborted-p nil) (current-test nil) (next-redisplay 0.0)) 'cl-struct-ert--stats-tags 'ert--stats t)
(defalias 'ert-stats-completed-expected #[257 "\301!>\204 \302\303\304D\"\210\211\305H\301!>\204! \302\303\304D\"\210\306H\\\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 7 9] 6 (#$ . 119342)])#@78 Return the number of tests in STATS that had unexpected results.

(fn STATS)
(defalias 'ert-stats-completed-unexpected #[257 "\301!>\204 \302\303\304D\"\210\211\305H\301!>\204! \302\303\304D\"\210\306H\\\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 8 10] 6 (#$ . 120212)])#@57 Number of tests in STATS that have skipped.

(fn STATS)
(defalias 'ert-stats-skipped #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 11] 5 (#$ . 120531)])#@60 Number of tests in STATS that have run so far.

(fn STATS)
(defalias 'ert-stats-completed #[257 "\300!\301!\\\302!\\\207" [ert-stats-completed-expected ert-stats-completed-unexpected ert-stats-skipped] 4 (#$ . 120772)])#@80 Number of tests in STATS, regardless of whether they have run yet.

(fn STATS)
(defalias 'ert-stats-total #[257 "\301!>\204 \302\303\304D\"\210\211\305HG\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 2] 5 (#$ . 121000)])
(defvar ert--current-run-stats nil)#@147 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.

(fn TEST)
(defalias 'ert--stats-test-key #[257 "\301!>\204 \302\303\304D\"\210\211\305H\206 \211\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 1] 5 (#$ . 121299)])#@148 Change STATS by replacing the test at position POS with TEST and RESULT.

Also changes the counters in STATS to match.

(fn STATS POS TEST RESULT)#@34 

(fn STATS POS TESTS RESULTS D)
(defalias 'ert--stats-set-test-and-result #[1028 "\301!>\204 \302\303\304D\"\210\305H\301!>\204# \302\303\304D\"\210\306HH\301!>\204: \302\303\304	D\"\210\307H\310\211		\311%\210I\210I\210\312\313!\"\210\313!\314\n#\266\211		\315%\316\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 2 4 3 #[1285 "\306HH\"\203\234 H\307!>\2032 \307!	>\204( \310\311\312D\"\210\313\313H\\I\207\307!\n>\203U \307!	>\204K \310\311\312D\"\210\314\314H\\I\207\307!>\203x \307!	>\204n \310\311\312D\"\210\315\315H\\I\207\211\204~ \316\207\307!\f>\203\210 \316\207\307!>\203\222 \316\207\317\320\321#\205\233 \316\207H\307!>\203\302 \307!	>\204\270 \310\311\312D\"\210\322\322H\\I\207\307!\n>\203\345 \307!	>\204\333 \310\311\312D\"\210\323\323H\\I\207\307!>\203\307!	>\204\376 \310\311\312D\"\210\315\315H\\I\207\211\204\316\207\307!\f>\203\316\207\307!>\203\"\316\207\317\320\324#\205+\316\207" [cl-struct-ert-test-passed-tags cl-struct-ert--stats-tags cl-struct-ert-test-failed-tags cl-struct-ert-test-skipped-tags cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags ert-test-result-expected-p type-of signal wrong-type-argument ert--stats 7 9 11 nil error "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-failed ert-test-skipped null ert-test-aborted-with-non-local-exit ert-test-quit) 8 10 (ert-test-passed ert-test-failed ert-test-skipped null ert-test-aborted-with-non-local-exit ert-test-quit)] 11 (#$ . 121790)] -1 remhash ert--stats-test-key puthash 1 nil] 16 (#$ . 121638)])#@131 Create a new `ert--stats' object for running TESTS.

SELECTOR is the selector that was used to select TESTS.

(fn TESTS SELECTOR)
(defalias 'ert--make-stats #[514 "\300\301\"\262\302\303G\"\304\305\306\211\211T\262GW\203D H\262\307!\262\310\"\2033 \311\312!\210\313#\210T\262\210\306\202 \266\314G\306\"\314G\306\"\314G\306\"\315\316\304\211\211\211\211\306\211\211\211\317&\207" [cl-coerce vector make-hash-table :size 0 -1 nil ert--stats-test-key gethash cl--assertion-failed (not (gethash key map)) puthash make-vector record ert--stats 0.0] 24 (#$ . 123489)])#@100 Run the single test TEST and record the result using STATS and LISTENER.

(fn STATS TEST LISTENER)
(defalias 'ert-run-or-rerun-test #[771 "\303\"\304\305$\210\306!	>\204 \307\310\311D\"\210\312I\210\313#\210\306!\n>\204< \307\310\314D\"\210\315\305I\210\306!	>\204Q \307\310\311D\"\210\316H\211\317 I\266\320\321	%\216\322!*\207" [ert--current-run-stats cl-struct-ert--stats-tags cl-struct-ert-test-tags ert--stats-test-pos ert--stats-set-test-and-result nil type-of signal wrong-type-argument ert--stats 15 test-started ert-test 4 5 current-time make-closure #[0 "\306\303!\f>\204 \307\310\311\303D\"\210\303\312H\211\300\313 I\266\306\302!>\204( \307\310\314\302D\"\210\302\315H\306!>\204; \307\310\316D\"\210\211\317\320\321\306\303!\f>\204N \307\310\311\303D\"\210\303\312H\300H\306\303!\f>\204b \307\310\311\303D\"\210\303\322H\300H\"!I\210\323\303\300\302$\210\301\324\303\302$\266\306\303!\f>\204\211 \307\310\311\303D\"\210\303\325\326I\207" [V0 V1 V2 V3 cl-struct-ert--stats-tags cl-struct-ert-test-tags type-of signal wrong-type-argument ert--stats 6 current-time ert-test 4 ert-test-result 3 float-time time-subtract 5 ert--stats-set-test-and-result test-ended 15 nil cl-struct-ert-test-result-tags] 10] ert-run-test] 11 (#$ . 124101)])#@124 Run the tests specified by SELECTOR, sending progress updates to LISTENER.

(fn SELECTOR LISTENER &optional INTERACTIVELY)
(defalias 'ert-run-tests #[770 "\304\305\"\306\"\307!>\204 \310\311\312D\"\210\211\313\314 I\210\315\"\210\305C\316\216\317 \210\320\321$\216\3222\204 \323:\203~ \210\211@\324	#\210\203w \307!\n>\204[ \310\311\325D\"\210\211\326H\307!>\205g \305\262\203w \327\330!\203w \331\322\323\"\210A\262\2029 \323\240\266\2020+\266\207" [cl-struct-ert--stats-tags ert--current-run-stats cl-struct-ert-test-tags cl-struct-ert-test-quit-tags ert-select-tests t ert--make-stats type-of signal wrong-type-argument ert--stats 12 current-time run-started #[0 "\300 \207" [force-mode-line-update] 1] force-mode-line-update make-closure #[0 "\304\301!>\204 \305\306\307\301D\"\210\301\310\300\242I\210\304\301!>\204$ \305\306\307\301D\"\210\301\311\312 I\210\302\313\301\300\242#\207" [V0 V1 V2 cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 14 13 current-time run-ended] 4] --cl-block-nil-- nil ert-run-or-rerun-test ert-test 4 y-or-n-p "Abort testing? " throw] 12 (#$ . 125401)])#@87 Return the position (index) of TEST in the run represented by STATS.

(fn STATS TEST)
(defalias 'ert--stats-test-pos #[514 "\301\302!\303!>\204 \304\305\306D\"\210\307H\"\207" [cl-struct-ert--stats-tags gethash ert--stats-test-key type-of signal wrong-type-argument ert--stats 3] 8 (#$ . 126551)])#@79 Format TIME in the variant of ISO 8601 used for timestamps in ERT.

(fn TIME)
(defalias 'ert--format-time-iso8601 #[257 "\300\301\"\207" [format-time-string "%Y-%m-%d %T%z"] 4 (#$ . 126861)])#@137 Return a character that represents the test result RESULT.

EXPECTEDP specifies whether the result was expected.

(fn RESULT EXPECTEDP)
(defalias 'ert-char-for-test-result #[514 "\305!>\203\f \306\202M \305!	>\203 \307\202M \305!\n>\203$ \310\202M \204, \311\202M \305!>\2038 \312\202M \305!\f>\203D \313\202M \314\315\316#\205M \317\211\203V \320\202W \321\234\207" [cl-struct-ert-test-passed-tags cl-struct-ert-test-failed-tags cl-struct-ert-test-skipped-tags cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags type-of ".P" "fF" "sS" "--" "aA" "qQ" error "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-failed ert-test-skipped null ert-test-aborted-with-non-local-exit ert-test-quit) nil 0 1] 6 (#$ . 127060)])#@134 Return a string that represents the test result RESULT.

EXPECTEDP specifies whether the result was expected.

(fn RESULT EXPECTEDP)
(defalias 'ert-string-for-test-result #[514 "\305!>\203\f \306\202M \305!	>\203 \307\202M \305!\n>\203$ \310\202M \204, \311\202M \305!>\2038 \312\202M \305!\f>\203D \313\202M \314\315\316#\205M \317\211\203V \320\202W \321\234\207" [cl-struct-ert-test-passed-tags cl-struct-ert-test-failed-tags cl-struct-ert-test-skipped-tags cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags type-of ("passed" "PASSED") ("failed" "FAILED") ("skipped" "SKIPPED") ("unknown" "UNKNOWN") ("aborted" "ABORTED") ("quit" "QUIT") error "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-failed ert-test-skipped null ert-test-aborted-with-non-local-exit ert-test-quit) nil 0 1] 6 (#$ . 127828)])#@266 Return the reason given for RESULT, as a string.

The reason is the argument given when invoking `ert-fail' or `ert-skip'.
It is output using `prin1' prefixed by two spaces.

If no reason was given, or for a successful RESULT, return the
empty string.

(fn RESULT)
(defalias 'ert-reason-for-test-result #[257 "\304!>\205 \304!>\204 \305\306\307D\"\210\211\310HA@\311\312\313\211\203- \314\315\"\202. \316+\207" [cl-struct-ert-test-result-with-condition-tags print-length print-level print-escape-newlines type-of signal wrong-type-argument ert-test-result-with-condition 4 t 6 10 format "  %S" ""] 5 (#$ . 128687)])#@117 Pretty-print OBJECT, indenting it to the current column of point.
Ensures a final newline is inserted.

(fn OBJECT)
(defalias 'ert--pp-with-indentation-and-newline #[257 "`i\302\211\303p\"\210n\204 \304c\210\305`#*\207" [print-escape-control-characters pp-escape-newlines t pp "\n" indent-rigidly] 7 (#$ . 129320)])#@124 Insert `ert-info' infos from RESULT into current buffer.

RESULT must be an `ert-test-result-with-condition'.

(fn RESULT)
(defalias 'ert--insert-infos #[257 "\301!>\204 \302\303\304\305E\"\210\301!>\204 \302\303\304D\"\210\211\306H\211\205\202 \211@\211\2036 \211A\262\242\202= \302\307\310GD\"`\311G\312\\\313\"\314C\315\316\"\216\317!\203V  \262\320\261\210\211\321 \240\210b\210\322\261\210\323y\210`\242W\203{ c\210\323y\210\202k )\266A\202\" \207" [cl-struct-ert-test-result-with-condition-tags type-of signal wrong-type-argument ert-test-result-with-condition result 6 wrong-number-of-arguments (prefix . message) make-string 4 32 nil make-closure #[0 "\300\242\205\n \300\242\301\211\223\207" [V0 nil] 3] functionp "\n" point-marker "    " 1] 11 (#$ . 129648)])#@67 Non-nil makes ERT only print important information in batch mode.
(defvar ert-quiet nil (#$ . 130448))#@69 Return a string description the source location of TEST.

(fn TEST)
(defalias 'ert-test-location #[257 "\30110 \302\303!>\204 \304\305\306D\"\210\307H\310\303!>\204( \304\305\306D\"\210\311H#0\2022 \210\312\211\205N \211@A\313\314!!rq\210\315!)\316\317#\266\204\207" [cl-struct-ert-test-tags (error) find-function-search-for-symbol type-of signal wrong-type-argument ert-test 1 ert-deftest 7 nil file-relative-name buffer-file-name line-number-at-pos format "at %s:%s"] 10 (#$ . 130556)])#@75 The maximum line length for printing backtraces in `ert-run-tests-batch'.
(defvar ert-batch-backtrace-right-margin 70 (#$ . 131066))#@416 Run the tests specified by SELECTOR, printing results to the terminal.

SELECTOR selects which tests to run as described in `ert-select-tests' when
called with its second argument t, 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.

(fn &optional SELECTOR)#@36 

(fn EVENT-TYPE &rest EVENT-ARGS)
(defalias 'ert-run-tests-batch #[256 "\211C\211\242\204 \211\300\240\210\301\242\302\303\"\304#\207" [t ert-run-tests make-closure #[385 "\306\267\202X	?\205g\211G\307U\203 \211\242\202 \310\311\312GD\"\313\314\315!\n>\204/ \310\316\317D\"\210\320HG\321\315!\n>\204D \310\316\317D\"\210\322H!\300\242$\207\211G\320U\203] \211A\262\242\202d \310\311\323GD\"\242\324!\325!\315!\n>\204| \310\316\317D\"\210\326H\313\327\204\211 \330\202\212 \331\332!\333	!\334U\203\237 \330\202\244 \335\336	\"\321\315!\n>\204\266 \310\316\317D\"\210\f\337H!\340\341\315!\n>\204\316 \310\316\317D\"\210\337H\315!\n>\204\343 \310\316\317D\"\210\322H\"!	\334U\203\364 \330\202\371 \335\342\"&	\210\334U\204\205\313\343\"\210\315!\n>\204\310\316\317D\"\210\320H\344\345\211\211T\262GW\203~H\262\315!>\204=\310\316\346D\"\210\347H\262\350\"\204y\313\351\352\345\"\315!>\204`\310\316\346D\"\210\307H\353\354!G\211\334V\262\203v\355!\202w\330$\210\210\345\202\266\313\356\330\"\210\334U\204\313\357\"\210\315!\n>\204\240\310\316\317D\"\210\320H\344\345\211\211T\262GW\203H\262\315!>\204\306\310\316\346D\"\210\347H\262\360\361\"\203\313\351\352\345\"\315!>\204\351\310\316\346D\"\210\307H\353\354!G\211\334V\262\203\377\355!\202 \330$\210\210\345\202\247\266\313\356\330\"\210\353\362!\205\363!\207\345\207\211G\364U\203+\211A\262\242\2022\310\311\365GD\"\211A\262\242\242\350\"\204\314\315!\f>\203c\313\366\315!>\204[\310\316\346D\"\210\307H\"\210\202\314\315!>\203v\313\367\315!>\204}\310\316\346D\"\210\307H\"\210\370\371\372\"r\211q\210\373\374\"\216@\372=\203\233A\202\235@BCDEA\375\315!>\204\267\310\316\376D\"\210\377H!c+\210F\204\320\313\356\201K ed\"\"\210\202\365eb\210m\204\365`\201L  \211F\\^\262\313\356\201K \"\"\266\307y\210\202\323*\210\370\371\372\"r\211q\210\373\201M \"\216\201N !\210\201O c\210\372BCDEG\201P \315!>\204.\310\316\376D\"\210\347H!+\210dSb\210\201Q \201R !\204J\201S \201T !\210\201U \307!\210\313\201V \315!>\204d\310\316\346D\"\210\307H\"\210\313\356\201W  \"*\266\202\314\315!H>\203\233\313\201X \315!>\204\223\310\316\346D\"\210\307H\"\210\202\314\315!I>\203\300\313\201Y \315!>\204\270\310\316\346D\"\210\307H\"\210\202\314\201Z \201[ \201\\ #\210	?\205W\201] \315!\n>\204\344\310\316\317D\"\210\320HG!\201^ \201] G!\201_ \201` \260\313\352\350\"\"\201a \"T\315!>\204 \310\316\346\nD\"\210\307H\315!J>\2048\310\316\201b \nD\"\210\364H\350\n\n\"\203I\330\202S\201c \201d !P&\266\202\207\201Z \201e \201f #\205g\345\207" [V0 ert-quiet cl-struct-ert--stats-tags cl-struct-ert-test-tags cl-struct-ert-test-passed-tags cl-struct-ert-test-result-with-condition-tags #s(hash-table test eq purecopy t data (run-started 6 run-ended 76 test-started 536 test-ended 538)) 1 signal wrong-number-of-arguments (stats) message "Running %s tests (%s, selector `%S')" type-of wrong-type-argument ert--stats 2 ert--format-time-iso8601 12 (stats abortedp) ert-stats-completed-unexpected ert-stats-skipped 9 "\n%sRan %s tests, %s results as expected, %s unexpected%s (%s, %f sec)%s\n" "" "Aborted: " ert-stats-total ert-stats-completed-expected 0 format ", %s skipped" 13 float-time time-subtract "\n%s expected failures" "%s unexpected results:" -1 nil ert-test 4 ert-test-result-expected-p "%9s  %S%s" ert-string-for-test-result getenv "EMACS_TEST_VERBOSE" ert-reason-for-test-result "%s" "%s skipped results:" ert-test-result-type-p :skipped "EMACS_TEST_JUNIT_REPORT" ert-write-junit-test-report 3 (stats test result) "Test %S passed unexpectedly" "Test %S backtrace:" generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] backtrace-to-string ert-test-result-with-condition 5 ert-batch-backtrace-line-length backtrace-line-length ert-batch-print-level ert-batch-print-length print-length print-level ert-batch-backtrace-right-margin print-escape-newlines cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags cl-struct-ert-test-result-tags buffer-substring-no-properties line-end-position #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] ert--insert-infos "    " ert--pp-with-indentation-and-newline looking-at #1="\n" cl--assertion-failed (looking-at #1#) delete-char "Test %S condition:" buffer-string "Test %S aborted with non-local exit" "Quit during %S" error "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 (%f sec)%s" ert--stats-test-pos ert-test-result " " ert-test-location "cl-ecase failed: %s, %s" (run-started run-ended test-started test-ended)] 23 (#$ . 131625)] nil] 7 (#$ . 131205)])#@291 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).

(fn &optional SELECTOR)
(defalias 'ert-run-tests-batch-and-exit #[256 "\204 \303\304!\210\305\306!\205 \307\310\311\"\211\203 \312!\210\313\211\314\315\"\216\316!\2034 \31713 \320\311\"0\210\321\322!\323U\203A \323\202B \324!)\207" [noninteractive attempt-stack-overflow-recovery attempt-orderly-shutdown-on-fatal-signal user-error "This function is only for use in batch mode" featurep native-compile make-temp-file "test-nativecomp-cache-" t startup-redirect-eln-cache nil make-closure #[0 "\301\302\300\"\216\303\304!\210\305 )\207" [V0 make-closure #[0 "\300\203 \3011 \302\300\303\"0\210\304\305!\207" [V0 (error) delete-directory t kill-emacs 2] 3] message "Error running tests" backtrace] 3] ert-run-tests-batch (error) delete-directory kill-emacs ert-stats-completed-unexpected 0 1] 7 (#$ . 136566)])#@168 The name of the loaded ERT test file, a string.
Usually, it is not needed to be defined, but if different ERT
test packages depend on each other, it might be helpful.
(defvar ert-load-file-name nil (#$ . 137661))#@62 Write a JUnit test report, generated from STATS.

(fn STATS)
(defalias 'ert-write-junit-test-report #[257 "\306\307\310\"@\211\205 \311\312\"\211\205 \313\206 \314\"\211\205\315\316\317\"\320\321\"\216r\211q\210\322c\210\323\324\325!\326!\327	!	>\204G \330\331\332D\"\210\333H\203R \334\202S \335\336\n!\337!\340\341\327!	>\204n \330\331\332D\"\210\342H\327!	>\204\203 \330\331\332D\"\210\343H\"!&c\210\323\344\325!\326!\327	!	>\204\247 \330\331\332D\"\210\333H\203\262 \334\202\263 \335\336\n!\337!\340\341\327!	>\204\316 \330\331\332D\"\210\342H\327!	>\204\343 \330\331\332D\"\210\343H\"!\345\327!	>\204\373 \330\331\332D\"\210\342H!&c\210\323\346\327!	>\204\330\331\332	D\"\210\334H\"G\347W\203E\350\323\351\352\323\346\327!	>\2049\330\331\332D\"\210\n\334H\"\353\"\"\354\261\210\327!	>\204U\330\331\332D\"\210\355H\356\357\211\211T\262GW\203\346H\262\327!\n>\204{\330\331\360D\"\210\361H\262\323\362\352\363\327!\n>\204\225\330\331\360	D\"\210\334H!\353\"\364\365\"\"\327!>\204\266\330\331\366D\"\210\367H$c\210\365\"\203\362\327!\f>\204\362\327!>\204\362\327!>\204\342\330\331\366D\"\210\334HG\335U\203\362\370c\266\202\342\371c\210\327!>\203\"\323\372\352\373\374!!\353\"\364\365\"\"#\352\373\374!!\353\"\375\376\261\210\202\245\327!\f>\203b\323\377\325	!\364\365\"\"#\323\201@ \352\363\327!\n>\204Q\330\331\360\nD\"\210\334H!\353\"\"\201A \261\210\202\245\201B \327!\n>\204v\330\331\360D\"\210\201C H\"\204\245\323\201D \352\373\374!!\353\"\364\365\"\"#\352\373\374!!\353\"\375\201E \261\210\327!>\204\264\330\331\366D\"\210\334HG\335U\204\334\201F \352\327!>\204\321\330\331\366D\"\210\334H\353\"\201G \261\210\201H c\266\357\202\\\266\201I c\210\201J c)rq\210\201K \357\211\357\335%*\210\262\207" [ert-load-file-name cl-struct-ert--stats-tags cl-struct-ert-test-tags cl-struct-ert-test-result-tags cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-skipped-tags apropos-internal "" ert-test-boundp symbol-file ert--test file-name-with-extension "xml" generate-new-buffer " *temp file*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" format "<testsuites name=\"%s\" tests=\"%s\" errors=\"%s\" failures=\"%s\" skipped=\"%s\" time=\"%s\">\n" file-name-nondirectory ert-stats-total type-of signal wrong-type-argument ert--stats 14 1 0 ert-stats-completed-unexpected ert-stats-skipped float-time time-subtract 13 12 "  <testsuite id=\"0\" name=\"%s\" tests=\"%s\" errors=\"%s\" failures=\"%s\" skipped=\"%s\" time=\"%s\" timestamp=\"%s\">\n" ert--format-time-iso8601 "%s" 1024 "    <properties>\n" "      <property name=\"selector\" value=\"%s\"/>\n" xml-escape-string noerror "    </properties>\n" 2 -1 nil ert-test 4 "    <testcase name=\"%s\" status=\"%s\" time=\"%s\"" symbol-name ert-string-for-test-result ert-test-result-expected-p ert-test-result 3 "/>\n" ">\n" "      <skipped message=\"%s\" type=\"%s\">\n" string-trim ert-reason-for-test-result "\n" "      </skipped>\n" "      <error message=\"%s\" type=\"%s\">\n" "Test %s aborted with non-local exit\n" "      </error>\n" ert-test-result-type-p 5 "      <failure message=\"%s\" type=\"%s\">\n" "      </failure>\n" "      <system-out>\n" "      </system-out>\n" "    </testcase>\n" "  </testsuite>\n" "</testsuites>\n" write-region] 19 (#$ . 137879)])#@82 Write a JUnit summary test report, generated from LOGFILES.

(fn &rest LOGFILES)
(defalias 'ert-write-junit-test-summary-report #[128 "\300\301\302!\303\"\304\211\211\211\211\211\305\306\307\"\310\311\"\216r\211q\210\211\203\211@\300\303\"\312!\204\227 \300\313\"\312!\205K \305\314\307\"r\211q\210\310\315\"\216\316!\210\317 *\262\211\203] \320\321\322\307$\266\203\204\222 \323\324\325\321!$c\210\323\326\327!\"c\210\323\330\327!\"c\210\211\203\202 \331\332\"c\210\333\334\335\261\210\nT\262T\262\266\202\316!\210\336\337\307\"\262\203\253 `\340\341!|\210\337\342!\203\350 	\343\344\345!!\\\262\n\343\344\341!!\\\262	\343\344\346!!\\\262\343\344\347!!\\\262\343\344\350!!\\\262`\340\341!|\210\337\351!\203\375 \352\353!\321\211\211\345%\210T\262db\210\354\304!\210\355\337\307\"\262\203`\340\341!|\210dd}\266A\202 \210\356c\210~\210eb\210\357c\210\323\360\327\n!					&c)rq\210\361\321\211\321\304%*\210\207" [file-name-with-extension getenv "EMACS_TEST_JUNIT_REPORT" "xml" 0 generate-new-buffer " *temp file*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] file-readable-p "log" " *temp*" #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents-literally buffer-string "^Running 0 tests" nil string-match format "  <testsuite id=\"%s\" name=\"%s\" tests=\"1\" errors=\"1\" failures=\"0\" skipped=\"0\" time=\"0\" timestamp=\"%s\">\n" ert--format-time-iso8601 "    <testcase name=\"Test report missing %s\" status=\"error\" time=\"0\">\n" file-name-nondirectory "      <error message=\"Test report missing %s\" type=\"error\">\n" xml-escape-string noerror "      </error>\n" "    </testcase>\n" "  </testsuite>\n" "<\\?xml version=\"1\\.0\" encoding=\"utf-8\"\\?>" looking-at line-beginning-position 2 "<testsuites name=\".+\" tests=\"\\(.+\\)\" errors=\"\\(.+\\)\" failures=\"\\(.+\\)\" skipped=\"\\(.+\\)\" time=\"\\(.+\\)\">" string-to-number match-string 1 3 4 5 "  <testsuite id=\"\\(0\\)\"" replace-match number-to-string beginning-of-line "</testsuites>" "</testsuites>\n" "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n" "<testsuites name=\"%s\" tests=\"%s\" errors=\"%s\" failures=\"%s\" skipped=\"%s\" time=\"%s\">\n" write-region] 22 (#$ . 141400)])#@351 Summarize the results of testing.
Expects to be called in batch mode, with logfiles as command-line arguments.
The logfiles should have the `ert-run-tests-batch' format.  When finished,
this exits Emacs, with status as per `ert-run-tests-batch-and-exit'.

If HIGH is a natural number, the HIGH long lasting tests are summarized.

(fn &optional HIGH)#@10 

(fn L)#@12 

(fn X Y)
(defalias 'ert-summarize-tests-batch-and-exit #[256 "\204 \304\305!\210\306!\204 \210\307\310\211\311\312!\203 \313\314\"\210G\307\211\211\211\211\310\211\211\211\211\211\211\315\316\317\"r\211q\210\320\321\"\216\211A\242\211\262\203\376 \322 \210\323!\203T \324!\210\325\326\310\317#\204f B\262\202: \f\327\330\331!!\\\262\325\332\310\317#\204\201 B\262\202: \330\331!\203\215 B\262\327\330\333!!\\\262\f\n\327\330\334!!\\\262\330\335!\203\277 \327\330\335!!\211\307U\204\276 B\262\n\\\262\210\330\336!\203\325 B\262\327\330\336!!\\\262	\307U\204: eb\210`dW\203: \337\340!\203\370 \327\330\331!!\330\307!BB\262\310y\210\202\337 *\210Z\262\341\342!\210\341\343!\210\341\344\"\210\341\345\f	\307U\203$\346\202)\347\350\"&\210\203C\341\351G\"\210\352\353\"\210\203\214\341\354G\"\210\352\355\"\210\311\356!\204^\311\357!\203\214\315\316\317\"r\211q\210\320\360\"\216\211\203\211\211@\322 \210\324!\210\341\361\"\210\341\362\363 \"\266A\202l*\266\203\233\341\364G\"\210\352\365\"\210\211\203\301\307U\204\301\341\366!\210\341\367!\210\370\371\372\"\"\262\341\373\374\375\376#\"\210\311\356!\204\315\311\357!\203\\\307U\204\341\377!\210\341\201@ !\210\315\316\317\"r\211q\210\320\201A \"\216\201B \201C E\201D \201E ED\211\203\211@\352\320\201F \"@\"\266A\202*\266\201G \204,\204,\307U\2040\333\2029\2038\331\2029\307!\207" [noninteractive attempt-stack-overflow-recovery attempt-orderly-shutdown-on-fatal-signal command-line-args-left user-error "This function is only for use in batch mode" natnump 0 nil getenv "EMACS_TEST_JUNIT_REPORT" apply ert-write-junit-test-summary-report generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] erase-buffer file-readable-p insert-file-contents re-search-forward "^Running \\([0-9]+\\) tests" string-to-number match-string 1 "^\\(Aborted: \\)?Ran \\([0-9]+\\) tests, \\([0-9]+\\) results as expected\\(?:, \\([0-9]+\\) unexpected\\)?\\(?:, \\([0-9]+\\) skipped\\)?" 2 3 4 5 looking-at "^\\s-+\\w+\\s-+[[:digit:]]+/[[:digit:]]+\\s-+\\S-+\\s-+(\\([.[:digit:]]+\\)\\s-+sec)$" message "\nSUMMARY OF TEST RESULTS" "-----------------------" "Files examined: %d" "Ran %d tests%s, %d results as expected, %d unexpected, %d skipped" "" format ", %d failed to run" "%d files did not contain any tests:" mapc #[257 "\300\301\"\207" [message "  %s"] 4 (#$ . 144053)] "%d files did not finish:" #[257 "\300\301\"\207" [message "  %s"] 4 (#$ . 144053)] "EMACS_HYDRA_CI" "EMACS_EMBA_CI" #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] "Contents of unfinished file %s:" "-----\n%s\n-----" buffer-string "%d files contained unexpected results:" #[257 "\300\301\"\207" [message "  %s"] 4 (#$ . 144053)] "\nLONG-RUNNING TESTS" "------------------" ntake sort #[514 "@@V\207" [] 4 (#$ . 144067)] "%s" mapconcat cdr "\n" "\nDETAILS" "-------" #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] "skipped" "SKIPPED" "unexpected" "\\(?:FAILED\\|PASSED\\)" #[257 "\301 \210\302!\210\303\304\"\210\305\306\307\300A@\"\310\311#\2057 \312y\313U\2057 \314\306\315\316\3008\"!\2057 \303\317\320 \321 {\"\210\202 \207" [V0 erase-buffer insert-file-contents message "%s:" re-search-forward format "^[ 	]*[0-9]+ %s results:" nil t 1 0 looking-at "^[ 	]*%s" 2 "%s" line-beginning-position line-end-position] 6 (#$ . 144053)] kill-emacs] 22 (#$ . 143698)])#@56 Activate font-lock keywords for some of ERT's symbols.
(defalias 'ert--activate-font-lock-keywords #[0 "\300\301\302\"\207" [font-lock-add-keywords nil (("(\\(\\<ert-deftest\\)\\>\\s *\\(\\(?:\\sw\\|\\s_\\)+\\)?" (1 font-lock-keyword-face nil t) (2 font-lock-function-name-face nil t)))] 3 (#$ . 147580)])#@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 #[642 "\300\301\"A@\300\302\"A@\211\203> \211@\303>\203( \211A\204# \304\305@\"\210AA\202 \306>A@\2035 \210\307\202 \304\310@\"\210\202 \210\204F \311\262\211\204L \210\312\313J\301\302&L\207" [plist-member :key :test (:key :test :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "Keyword argument %s not one of (:key :test)" identity equal cl-remove] 13 (#$ . 147892)])#@381 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.

(fn PROMPT &optional DEFAULT HISTORY ADD-DEFAULT-TO-PROMPT)
(defalias 'ert-read-test-name #[1025 ";\203 \302!\211\203 \303!\204 \304\262\210\202Q 9\203, \303!\205' \305!\262\202Q \306!>\203K \306!>\204C \307\310\311D\"\210\312H\262\202Q \313\314\315#\210\211\203[ \316\"\262\317	\303\320\304	\304&\302!\303!\203r \207\321\322!\207" [cl-struct-ert-test-tags obarray intern-soft ert-test-boundp nil symbol-name type-of signal wrong-type-argument ert-test 1 error "cl-etypecase failed: %s, %s" (string symbol ert-test) format-prompt completing-read t user-error "Input does not name a test"] 13 (#$ . 148486)])#@213 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).

(fn PROMPT)
(defalias 'ert-read-test-name-at-point #[257 "\300\301 \302\303$\207" [ert-read-test-name ert-test-at-point nil t] 6 (#$ . 149449)])#@71 Find, in another window, the definition of TEST-NAME.

(fn TEST-NAME)
(defalias 'ert-find-test-other-window #[257 "\300\301\302#\207" [find-function-do-it ert--test switch-to-buffer-other-window] 5 (#$ . 149800) (byte-code "\300\301!C\207" [ert-read-test-name-at-point "Find test definition"] 2)])#@122 Make the test TEST-NAME unbound.

Nothing more than an interactive interface to `ert-make-test-unbound'.

(fn TEST-NAME)
(defalias 'ert-delete-test #[257 "\300!\207" [ert-make-test-unbound] 3 (#$ . 150105) (byte-code "\300\301!C\207" [ert-read-test-name-at-point "Delete test"] 2)])#@45 Make all symbols in `obarray' name no test.
(defalias 'ert-delete-all-tests #[0 "\300\301!\203 \302\303!\204 \304\305!\210\306\307\310\311\312\"\"\313\207" [called-interactively-p any y-or-n-p "Delete all tests? " user-error "Aborted" mapc ert-make-test-unbound apropos-internal "" ert-test-boundp t] 6 (#$ . 150394) nil])#@65 compiler-macro for `ert--ewoc-entry-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ert--ewoc-entry-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-p (and (memq (type-of cl-x) cl-struct-ert--ewoc-entry-tags) t)) nil] 9 (#$ . 150724)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--ewoc-entry-p compiler-macro ert--ewoc-entry-p--cmacro] 4)
(defalias 'ert--ewoc-entry-p #[257 "\301!>\205	 \302\207" [cl-struct-ert--ewoc-entry-tags type-of t] 3 (#$ . 2692)])#@68 compiler-macro for `ert--ewoc-entry-test'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\301#\300\207" [function-put ert--ewoc-entry-p side-effect-free error-free pure t define-symbol-prop ert--ewoc-entry cl-deftype-satisfies] 6)
(defalias 'ert--ewoc-entry-test--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-test (progn (or (ert--ewoc-entry-p cl-x) (signal 'wrong-type-argument (list 'ert--ewoc-entry cl-x))) (aref cl-x 1))) nil] 9 (#$ . 151253)])#@65 Access slot "test" of `ert--ewoc-entry' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--ewoc-entry-test compiler-macro ert--ewoc-entry-test--cmacro] 4)
(defalias 'ert--ewoc-entry-test #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 1] 5 (#$ . 151800)])#@72 compiler-macro for `ert--ewoc-entry-hidden-p'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--ewoc-entry-test side-effect-free t] 4)
(defalias 'ert--ewoc-entry-hidden-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-hidden-p (progn (or (ert--ewoc-entry-p cl-x) (signal 'wrong-type-argument (list 'ert--ewoc-entry cl-x))) (aref cl-x 2))) nil] 9 (#$ . 152189)])#@69 Access slot "hidden-p" of `ert--ewoc-entry' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--ewoc-entry-hidden-p compiler-macro ert--ewoc-entry-hidden-p--cmacro] 4)
(defalias 'ert--ewoc-entry-hidden-p #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 2] 5 (#$ . 152645)])#@74 compiler-macro for `ert--ewoc-entry-expanded-p'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--ewoc-entry-hidden-p side-effect-free t] 4)
(defalias 'ert--ewoc-entry-expanded-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-expanded-p (progn (or (ert--ewoc-entry-p cl-x) (signal 'wrong-type-argument (list 'ert--ewoc-entry cl-x))) (aref cl-x 3))) nil] 9 (#$ . 153050)])#@71 Access slot "expanded-p" of `ert--ewoc-entry' struct CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--ewoc-entry-expanded-p compiler-macro ert--ewoc-entry-expanded-p--cmacro] 4)
(defalias 'ert--ewoc-entry-expanded-p #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 3] 5 (#$ . 153516)])#@89 compiler-macro for `ert--ewoc-entry-extended-printer-limits-p'.

(fn CL-WHOLE-ARG CL-X)
(byte-code "\300\301\302\303#\300\207" [function-put ert--ewoc-entry-expanded-p side-effect-free t] 4)
(defalias 'ert--ewoc-entry-extended-printer-limits-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--ewoc-entry-extended-printer-limits-p (progn (or (ert--ewoc-entry-p cl-x) (signal 'wrong-type-argument (list 'ert--ewoc-entry cl-x))) (aref cl-x 4))) nil] 9 (#$ . 153929)])#@86 Access slot "extended-printer-limits-p" of `ert--ewoc-entry' struct
CL-X.

(fn CL-X)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--ewoc-entry-extended-printer-limits-p compiler-macro ert--ewoc-entry-extended-printer-limits-p--cmacro] 4)
(defalias 'ert--ewoc-entry-extended-printer-limits-p #[257 "\301!>\204 \302\303\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 4] 5 (#$ . 154442)])#@125 compiler-macro for `make-ert--ewoc-entry'.

(fn CL-WHOLE &cl-quote &key TEST HIDDEN-P EXPANDED-P EXTENDED-PRINTER-LIMITS-P)
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert--ewoc-entry-extended-printer-limits-p side-effect-free t defalias copy-ert--ewoc-entry copy-sequence] 4)
(defalias 'make-ert--ewoc-entry--cmacro #[385 "\300\301\"\206 \302A@\300\303\"\206 \304A@\300\305\"\206 \306A@\300\307\"A@\211\203W \211@\310>\203@ \211A\204; \311\312@\"\210AA\202% \313>A@\203N \210\314\202% \311\315@\"\210\202% \210\316\317\320\314	\314				&	\207" [plist-member :test (nil (cl-assert nil)) :hidden-p (nil (cl-assert nil)) :expanded-p (nil t) :extended-printer-limits-p (:test :hidden-p :expanded-p :extended-printer-limits-p :allow-other-keys) error "Missing argument for %s" :allow-other-keys nil "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 (record 'ert--ewoc-entry test hidden-p expanded-p extended-printer-limits-p))] 16 (#$ . 154916)])#@114 Constructor for objects of type `ert--ewoc-entry'.

(fn &key TEST HIDDEN-P EXPANDED-P EXTENDED-PRINTER-LIMITS-P)
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert--ewoc-entry compiler-macro make-ert--ewoc-entry--cmacro] 4)
(defalias 'make-ert--ewoc-entry #[128 "\300\301\"\206 \302\303\302!\210\302DA@\300\304\"\206 \302\303\302!\210\302DA@\300\305\"\206( \306A@\300\307\"A@\211\203c \211@\310>\203L \211A\204G \311\312@\"\210AA\2021 \313>A@\203Z \210\302\2021 \311\314@\"\210\2021 \210\315\316%\207" [plist-member :test nil 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) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:test :hidden-p :expanded-p :extended-printer-limits-p)" record ert--ewoc-entry] 11 (#$ . 156044)])#@58 Insert a button that links to TEST-NAME.

(fn TEST-NAME)
(cl-struct-define 'ert--ewoc-entry nil 'cl-structure-object 'record nil '((cl-tag-slot) (test (cl-assert nil)) (hidden-p (cl-assert nil)) (expanded-p t) (extended-printer-limits-p nil)) 'cl-struct-ert--ewoc-entry-tags 'ert--ewoc-entry t)
(defalias 'ert-insert-test-name-button #[257 "\300\301\302\"\303\304\305%\207" [insert-text-button format "%S" :type ert--test-name-button ert-test-name] 7 (#$ . 156943)])#@104 Return a string indicating EXPECTED expected results, UNEXPECTED unexpected.

(fn EXPECTED UNEXPECTED)
(defalias 'ert--results-format-expected-unexpected #[514 "\211\300U\203 \301\302\"\207\301\303\\#\207" [0 format "%s" "%s (%s unexpected)"] 6 (#$ . 157418)])#@148 Update the header and footer of EWOC to show certain information from STATS.

Also sets `ert--results-progress-bar-button-begin'.

(fn EWOC STATS)
(defalias 'ert--results-update-ewoc-hf #[514 "\305!p\306\307\310\311\"r\211q\210\312\313\"\216\314c\210\315\316!	>\204) \317\320\321\nD\"\210\322H!\210\323c\210\324\325\326\316\n!	>\204F \317\320\321\fD\"\210	\327H\316!	>\204[ \317\320\321D\"\210\n\330H\"\326\316!	>\204r \317\320\321D\"\210\n\331H\316\f!	>\204\207 \317\320\321D\"\210\332H\"\333!\n\334!&c\210\324\335\336\316\n!	>\204\256 \317\320\321\fD\"\210	\337H!\"c\210\316!	>\204\307 \317\320\321	D\"\210\340H\203\322 \341\202\316!	>\204\343 \317\320\321	D\"\210\342H\203\356 \343\202\316!	>\204\377 \317\320\321	D\"\210\344H\203\n\345\202\346\211\347\267\202\327\350c\210\202\335\316!	>\204(\317\320\321\nD\"\210\342H\203a\351c\210\352\316	!	>\204D\317\320\321D\"\210\342H\316!\n>\204W\317\320\353D\"\210\211\322H\262!\210\202\335\354c\210\202\335\316!	>\204x\317\320\321\nD\"\210\342H\204\203\355\356!\210\357c\210\352\316	!	>\204\230\317\320\321D\"\210\342H\316!\n>\204\253\317\320\353D\"\210\211\322H\262!\210\202\335\316!	>\204\306\317\320\321\nD\"\210\342H\203\321\355\360!\210\361c\210\202\335\362\363\364#\210\323c\210\316!	>\204\361\317\320\321\nD\"\210\344H\2034\324\365\316\n!	>\204\317\320\321\fD\"\210	\340H\203\366\202\367\336\316\f!	>\204)\317\320\321D\"\210\344H!#c\210\2027\323c\210\323c\266rq\210)\370\371\372\373	\203R\374!\206S\375%rq\210\376\304!\210\211)\266\377c\210\201@  *\262\323#\207" [font-lock-mode cl-struct-ert--stats-tags cl-struct-ert-test-tags ert--results-progress-bar-string ert--results-progress-bar-button-begin ert-stats-completed ewoc-set-hf generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] "Selector: " ert--insert-human-readable-selector type-of signal wrong-type-argument ert--stats 1 "\n" format "Passed:  %s\nFailed:  %s\nSkipped: %s\nTotal:   %s/%s\n\n" ert--results-format-expected-unexpected 7 8 9 10 ert-stats-skipped ert-stats-total "Started at:   %s\n" ert--format-time-iso8601 12 14 aborted 15 running 13 finished preparing #s(hash-table test eq purecopy t data (preparing 273 aborted 279 running 359 finished 437)) "" "Aborted during test: " ert-insert-test-name-button ert-test "Aborted." cl--assertion-failed (ert--stats-current-test stats) "Running test: " (not (ert--stats-current-test stats)) "Finished." error "cl-ecase failed: %s, %s" (preparing aborted running finished) "%s%s\n" "Aborted at:   " "Finished at:  " insert-text-button :type ert--results-progress-bar-button face ert-face-for-stats button make-local-variable "\n\n" buffer-string] 17 (#$ . 157690)])#@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 (#$ . 160531))#@73 Update EWOC and the mode line to show data from STATS.

(fn EWOC STATS)
(defalias 'ert--results-update-stats-display #[514 "\302\"\210\303 \210\304\305!\210\306!>\204 \307\310\311D\"\210\211\312\313\314\315	\"!I\207" [cl-struct-ert--stats-tags ert-test-run-redisplay-interval-secs ert--results-update-ewoc-hf force-mode-line-update redisplay t type-of signal wrong-type-argument ert--stats 16 float-time time-add nil] 8 (#$ . 160804)])#@154 Call `ert--results-update-stats-display' if not called recently.

EWOC and STATS are arguments for `ert--results-update-stats-display'.

(fn EWOC STATS)
(defalias 'ert--results-update-stats-display-maybe #[514 "\301\302\303!>\204 \304\305\306D\"\210\307H\"?\205 \310\"\207" [cl-struct-ert--stats-tags time-less-p nil type-of signal wrong-type-argument ert--stats 16 ert--results-update-stats-display] 8 (#$ . 161252)])#@69 Return a string for the mode line that shows the test run progress.
(defalias 'ert--tests-running-mode-line-indicator #[0 "\303!\304!\211Y\203 \305\306#\207\305\307T\310!	>\204) \311\312\313	D\"\210\314H\2044 \315\202` \305\316\310	!	>\204G \311\312\313D\"\210\314H\310!\n>\204Z \311\312\317D\"\210\211\320H\262\"$\207" [ert--current-run-stats 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" type-of signal wrong-type-argument ert--stats 15 "?" "%S" ert-test 1] 14 (#$ . 161684)])#@137 Attach cross-references to function names between BEGIN and END.

BEGIN and END specify a region in the current buffer.

(fn BEGIN END)
(defalias 'ert--make-xrefs-region #[514 "\212b\210`\300\\b\210\301\302!\210`W\205A `\301\303!\210`\304\305\"!\211\205' \306\307\"\211\2039 b\210\310\311!\210\312\313\314$\210\266\315y\210\202 )\207" [2 skip-syntax-forward "^w_" "w_" intern-soft buffer-substring-no-properties symbol-file defun re-search-forward "\\(\\sw\\|\\s_\\)+" help-xref-button 0 help-function-def 1] 11 (#$ . 162278)])#@126 Return the first line of S, or S if it contains no newlines.

The return value does not include the line terminator.

(fn S)
(defalias 'ert--string-first-line #[257 "\211\300\301\302\"O\207" [0 cl-position 10] 6 (#$ . 162822)])#@207 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..

(fn EXPECTEDP)
(defalias 'ert-face-for-test-result #[257 "\211\203 \300\207\301\207" [ert-test-result-expected ert-test-result-unexpected] 2 (#$ . 163057)])#@50 Return a face that represents STATS.

(fn STATS)
(defalias 'ert-face-for-stats #[257 "\301!>\204 \302\303\304D\"\210\211\305H\203 \306\207\307!\211\310V\262\203& \311\306!\207\312\313!\314!\"\2035 \311\315!\207\306\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 14 nil ert-stats-completed-unexpected 0 ert-face-for-test-result eql ert-stats-completed-expected ert-stats-total t] 5 (#$ . 163411)])#@90 The ewoc print function for ewoc test entries.  ENTRY is the entry to print.

(fn ENTRY)
(defalias 'ert--print-test-for-ewoc #[257 "\306!>\204 \307\310\311D\"\210\211\312H	\313\"\211\204 \314\315!\210\306!\n>\204. \307\310\316D\"\210\317HH\262\306!>\204E \307\310\311D\"\210\320H\306!>\204X \307\310\311D\"\210\321H\306!>\204l \307\310\311D\"\210\317H\204\204\322\"\323\324\325\326\"\"\327\330\331\203\217 \332!\206\220 \333%\266\334c\210\335\306!\f>\204\250 \307\310\336	D\"\210\312H!\210\337c\210\203\204\203\204\306!\f>\204\312 \307\310\336D\"\210\320H\203\362 \340\341\342\343\306\n!\f>\204\345 \307\310\336\fD\"\210	\320H!!\344\345#\337\261\210\306!>\203\322\"\203\346c\210\202\347c\210\350c\210\202\201\306!8>\203]\351!\210\352\203'\353\202(\354\2030\355\2021\3569:;\340c\210`\357\306!8>\204N\307\310\360D\"\210\317H!\210\361`\"+\266\202\201\306!<>\203l\362c\210\202\201\306!=>\203{\363c\210\202\201\364\365\366#\210\337c\210\367\207" [cl-struct-ert--ewoc-entry-tags ert--results-stats cl-struct-ert--stats-tags font-lock-mode cl-struct-ert-test-tags cl-struct-ert-test-passed-tags type-of signal wrong-type-argument ert--ewoc-entry 1 ert--stats-test-pos cl--assertion-failed pos ert--stats 4 2 3 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 "\n" "    " propertize ert--string-first-line substitute-command-keys font-lock-face font-lock-doc-face "    passed\n" "    passed unexpectedly\n" "" ert--insert-infos t 12 6 100 10 ert--pp-with-indentation-and-newline ert-test-result-with-condition ert--make-xrefs-region "    aborted\n" "    quit\n" error "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-result-with-condition ert-test-aborted-with-non-local-exit ert-test-quit) nil cl-struct-ert-test-result-with-condition-tags print-length print-level print-escape-newlines cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags] 16 (#$ . 163853)])#@164 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.

(fn ENABLEDP)
(defalias 'ert--results-font-lock-function #[257 "\302	\"\210\303!\210\304!\207" [ert--results-ewoc ert--results-stats ert--results-update-ewoc-hf ewoc-refresh font-lock-default-function] 4 (#$ . 166003)])
(defvar ert--output-buffer-name "*ert*")#@114 Set up a test results buffer.

STATS is the stats object; LISTENER is the results listener.

(fn STATS LISTENER)
(defalias 'ert--setup-results-buffer #[514 "\306!r\211q\210\307\310 \210\311 \210\312 \210\311 \210\313\302!\210\314\315\316\317\211\307$\313\303!\210\211\313\304!\210\313\305!\210\320\321!\322\317\307\"\"\313\323!\210\324!>\204S \325\326\327D\"\210\330H\331\317T\262GW\203v H\262\332\333\334\307\211\317%\"\210\202X \266\335\f\"\210dSb*\266\207" [ert--output-buffer-name inhibit-read-only font-lock-function ert--results-ewoc ert--results-stats ert--results-progress-bar-string 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 make-string ert-stats-total ert-char-for-test-result ert--results-listener type-of signal wrong-type-argument ert--stats 2 -1 ewoc-enter-last record ert--ewoc-entry ert--results-update-ewoc-hf cl-struct-ert--stats-tags] 15 (#$ . 166422)])#@51 List of recent test selectors read from terminal.
(defvar ert--selector-history nil (#$ . 167450))#@285 Run the tests specified by SELECTOR and display the results in a buffer.

SELECTOR selects which tests to run as described in `ert-select-tests'
when called with its second argument t.  Interactively, prompt for
SELECTOR; the default t means run all the defined tests.

(fn SELECTOR)
(defalias 'ert-run-tests-interactively #[257 "\300C\300C\211\301\302#\240\210\303\242\304#\207" [nil make-closure #[385 "\305\267\202f\211G\306U\203 \211\242\202 \307\310\311GD\"\301\312\300\242\"\240\210\313\301\242!\207\211G\314U\2037 \211A\262\242\202> \307\310\315GD\"\242\316\317\204J \320\202K \321\322!\323!\324!\211\325U\203a \210\320\202g \326\327\"\262\330!\211\325U\203v \210\320\202| \326\331\"\262&\210\332r\301\242q\210\n)\"\207\211G\314U\203\233 \211A\262\242\202\242 \307\310\333GD\"\242r\301\242q\210\n\334\"\335\"\211\204\272 \336\337!\210\211\314H\340!>\204\314 \307\341\342D\"\210\211\306I\266\f\343\344\345\"I\210\346\"\210\347\")\207\211G\350U\203\370 \211A\262\242\202\377 \307\310\351GD\"\211A\262\242\242r\301\242q\210\n\334\"\335\"\211\314H\340!>\204'\307\341\342D\"\210\211\314H\262\203L\211\314H\340!>\204A\307\341\342D\"\210\211\314\352\"I\266\f\343\352		\"\"I\210\346\"\210\347\")\207\353\354\355#\205o\344\207" [V0 V1 ert--results-ewoc cl-struct-ert--ewoc-entry-tags ert--results-progress-bar-string #s(hash-table test eq purecopy t data (run-started 6 run-ended 38 test-started 138 test-ended 231)) 1 signal wrong-number-of-arguments (stats) ert--setup-results-buffer pop-to-buffer 2 (stats abortedp) message "%sRan %s tests, %s results were as expected%s%s" "" "Aborted: " ert-stats-total ert-stats-completed-expected ert-stats-completed-unexpected 0 format ", %s unexpected" ert-stats-skipped ", %s skipped" ert--results-update-stats-display (stats test) ert--stats-test-pos ewoc-nth cl--assertion-failed node type-of wrong-type-argument ert--ewoc-entry ert-char-for-test-result nil t ert--results-update-stats-display-maybe ewoc-invalidate 3 (stats test result) ert-test-result-expected-p error "cl-ecase failed: %s, %s" (run-started run-ended test-started test-ended)] 16 (#$ . 131625)] ert-run-tests t] 8 (#$ . 167555) (byte-code "\203	 @\202\n \302\303\304\305\306\"	\307\310\211\300\310&!C\207" [ert--selector-history obarray "t" read completing-read format-prompt "Run tests" ert-test-boundp nil] 11)])
(defalias 'ert 'ert-run-tests-interactively)
(defvar ert-simple-view-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [ert-simple-view-mode-hook variable-documentation put "Hook run after entering `ert-simple-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] 4)
(defvar ert-simple-view-mode-map (make-sparse-keymap))#@265 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 or
penultimate step during initialization.

\{ert-simple-view-mode-map}
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204* \303\307\310\311#\210\312\307\306\307!\203& \313\202( \314 \"\210\307\302N\2048 \303\307\302\304\315!#\210\306\300!\204X \303\300\310\311#\210\312\300\306\300!\203P \313\202V \316\300\313\"\210\"\210\300\302N\204f \303\300\302\304\317!#\210\320\321!\203t \321\311\322\"\210\202z \303\311\323\322#\210\313\207" [ert-simple-view-mode-abbrev-table 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 defvar-1 nil make-syntax-table "Syntax table for `ert-simple-view-mode'." define-abbrev-table "Abbrev table for `ert-simple-view-mode'." fboundp derived-mode-set-parent special-mode derived-mode-parent] 5)
(defalias 'ert-simple-view-mode #[0 "\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\2035 \211\321 =\203; \322\f\323 \"\210\210\324\325\"\204R =\204R \326\325C#\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 ert-simple-view-mode-abbrev-table 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 local-abbrev-table] 5 (#$ . 170520) nil])
(defvar ert-results-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [ert-results-mode-hook variable-documentation put "Hook run after 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] 4)
(defvar ert-results-mode-map (make-sparse-keymap))#@253 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 or
penultimate step during initialization.

\{ert-results-mode-map}#@16 

(fn &rest _)
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204* \303\307\310\311#\210\312\307\306\307!\203& \313\202( \314 \"\210\307\302N\2048 \303\307\302\304\315!#\210\306\300!\204X \303\300\310\311#\210\312\300\306\300!\203P \313\202V \316\300\313\"\210\"\210\300\302N\204f \303\300\302\304\317!#\210\320\321!\203t \321\311\322\"\210\202z \303\311\323\322#\210\313\207" [ert-results-mode-abbrev-table ert-results-mode-map variable-documentation put purecopy "Keymap for `ert-results-mode'." boundp ert-results-mode-syntax-table definition-name ert-results-mode defvar-1 nil make-syntax-table "Syntax table for `ert-results-mode'." define-abbrev-table "Abbrev table for `ert-results-mode'." fboundp derived-mode-set-parent special-mode derived-mode-parent] 5)
(defalias 'ert-results-mode #[0 "\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\2035 \211\321 =\203; \322\f\323 \"\210\210\324\325\"\204R =\204R \326\325C#\210\327!\210\330\f!\210\306\331!\210\332)\333\334!\207" [delay-mode-hooks major-mode mode-name ert-results-mode-map ert-results-mode-syntax-table ert-results-mode-abbrev-table 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 revert-buffer-function #[128 "\300 \207" [ert-results-rerun-all-tests] 2 (#$ . 173089)] run-mode-hooks ert-results-mode-hook local-abbrev-table] 5 (#$ . 172832)])#@30 Menu for `ert-results-mode'.
(byte-code "\301\302\211\211:\203% \210@\211A\262\242\262\211@\262\303#\210A\262\202 \266\207" [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] 8)
(defvar ert-results-mode-menu nil (#$ . 174736))#@107 If point is on a valid ewoc node, return it; return nil otherwise.

To be used in the ERT results buffer.
(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 :active (car (ert--results-test-at-point-allow-redefinition))] ["Debug test" ert-results-rerun-test-at-point-debugging-errors :active (car (ert--results-test-at-point-allow-redefinition))] ["Show test definition" ert-results-find-test-at-point-other-window :active (ert-test-at-point)] "--" ["Show backtrace" ert-results-pop-to-backtrace-for-test-at-point :active (ert--results-test-at-point-no-redefinition)] ["Show messages" ert-results-pop-to-messages-for-test-at-point :active (ert--results-test-at-point-no-redefinition)] ["Show `should' forms" ert-results-pop-to-should-forms-for-test-at-point :active (ert--results-test-at-point-no-redefinition)] ["Describe test" ert-results-describe-test-at-point :active (ert--results-test-at-point-no-redefinition)] "--" ["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)
(defalias 'ert--results-test-node-or-null-at-point #[0 "\302!\211\205, `\303!Y\205, \211\304H\305!	>\204\" \306\307\310D\"\210\211\304H\262?\205, \211\207" [ert--results-ewoc cl-struct-ert--ewoc-entry-tags ewoc-locate ewoc-location 2 type-of signal wrong-type-argument ert--ewoc-entry] 7 (#$ . 175622)])#@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 #[0 "\300 \206 \301\302!\207" [ert--results-test-node-or-null-at-point user-error "No test at point"] 2 (#$ . 177604)])#@69 Move point to the next test.

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

To be used in the ERT results buffer.
(defalias 'ert-results-previous-test #[0 "\301\302!\303\304#\207" [ert--results-ewoc ert--results-move ewoc-locate ewoc-prev "No tests above"] 4 (#$ . 178140) [nil (ert-results-mode)]])#@271 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, a
user-error is signaled with the message ERROR-MESSAGE.

(fn NODE EWOC-FN ERROR-MESSAGE)
(defalias 'ert--results-move #[771 "\3022: \"\262\204 \303\304\"\210\305H\306!	>\204% \307\310\311D\"\210\211\305H\262\204 \312!b\210\313\302\314\"\210\202 \207" [ert--results-ewoc cl-struct-ert--ewoc-entry-tags --cl-block-nil-- user-error "%s" 2 type-of signal wrong-type-argument ert--ewoc-entry ewoc-location throw nil] 8 (#$ . 178405)])#@66 Expand or collapse the test node BUTTON belongs to.

(fn BUTTON)
(defalias 'ert--results-expand-collapse-button-action #[257 "\212\302 b\210\303 )\211\304H\305!	>\204 \306\307\310D\"\210\211\311\305!	>\204, \306\307\310D\"\210\311H?I\210\312\"\207" [ert--results-ewoc cl-struct-ert--ewoc-entry-tags ert--button-action-position ert--results-test-node-at-point 2 type-of signal wrong-type-argument ert--ewoc-entry 3 ewoc-invalidate] 10 (#$ . 179035)])#@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 #[0 "\300 \211\204\n \301\302!\210\303!\207" [ert-test-at-point user-error "No test at point" ert-find-test-other-window] 3 (#$ . 179500) [nil (ert-results-mode)]])#@84 Find the definition of the test BUTTON belongs to, in another window.

(fn BUTTON)
(defalias 'ert--test-name-button-action #[257 "\300\301\"\302!\207" [button-get ert-test-name ert-find-test-other-window] 4 (#$ . 179825)])#@85 Return the position of NODE in EWOC, or nil if NODE is not in EWOC.

(fn EWOC NODE)
(defalias 'ert--ewoc-position #[514 "\3002- \301\302\303\211\203 \304\301\"\202 \305\"\262\306\"\203$ \307\300\"\210T\262\210\302\202 \207" [--cl-block-nil-- 0 nil t ewoc-nth ewoc-next eql throw] 8 (#$ . 180055)])#@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 #[0 "	\303 \203 \304 \305\"\\b\207\211`X\203^ `\306\307!!W\203^ \310`Z\"\211\311H\312!\n>\204: \313\314\315D\"\210\211\311H\203Y \312!\n>\204O \313\314\315D\"\210\211\311\316I\210\317\"\210\320\"\207\211b\207" [ert--results-ewoc ert--results-progress-bar-button-begin cl-struct-ert--ewoc-entry-tags ert--results-test-node-or-null-at-point ert--results-test-node-at-point ert--ewoc-position button-end button-at ewoc-nth 2 type-of signal wrong-type-argument ert--ewoc-entry nil ewoc-invalidate ewoc-goto-node] 8 (#$ . 180371) [nil (ert-results-mode)]])#@67 Return the name of the test at point as a symbol, or nil if none.
(defalias 'ert-test-at-point #[0 "\302=\203# \303 \211\205 \304!	>\204 \305\306\307D\"\210\211\310H\262\2062 \311\312!\313!\314!\2050 \211\266\202\207" [major-mode cl-struct-ert-test-tags ert-results-mode ert--results-test-at-point-no-redefinition type-of signal wrong-type-argument ert-test 1 thing-at-point symbol intern-soft ert-test-boundp] 5 (#$ . 181227)])#@174 Return the test at point, or nil.
If optional argument ERROR is non-nil, signal an error rather than return nil.
To be used in the ERT results buffer.

(fn &optional ERROR)
(defalias 'ert--results-test-at-point-no-redefinition #[256 "\305=\204\n \306\307!\210\310 \203+ \311 \211\312H\313!	>\204# \314\315\316D\"\210\211\317H\266\202\202Z \n\211`X\205X `\320\321!!W\205X `Z\313!\f>\204O \314\315\322D\"\210\211\312H\262H\262\262\206d \211\205d \323\324!\207" [major-mode cl-struct-ert--ewoc-entry-tags ert--results-progress-bar-button-begin ert--results-stats cl-struct-ert--stats-tags ert-results-mode cl--assertion-failed (eql major-mode 'ert-results-mode) ert--results-test-node-or-null-at-point ert--results-test-node-at-point 2 type-of signal wrong-type-argument ert--ewoc-entry 1 button-end button-at ert--stats user-error "No test at point"] 8 (#$ . 181670)])#@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 #[0 "\302 \211\204 \303\207\304!>\204 \305\306\307D\"\210\211\310H\204! \211\311B\207\304!>\2040 \305\306\307D\"\210\211\310H\312!\205< \313!\314\"\203G \315B\207\211\204O \316B\207\317\320	\"\"\210\211\321B\207" [cl-struct-ert-test-tags ert--results-stats ert--results-test-at-point-no-redefinition (nil nil) type-of signal wrong-type-argument ert-test 1 (nil) ert-test-boundp ert-get-test eql (nil) (deleted) ert--results-update-after-test-redefinition ert--stats-test-pos (redefined)] 7 (#$ . 182555)])#@158 Update results buffer after the test at pos POS has been redefined.

Also updates the stats object.  NEW-TEST is the new test
definition.

(fn POS NEW-TEST)
(defalias 'ert--results-update-after-test-redefinition #[514 "	\304\"\211\305H\306\307$\210\310!\n>\204! \311\312\313D\"\210\211\314I\210\211\315\307\316\"I\266\317\"\307\207" [ert--results-stats ert--results-ewoc cl-struct-ert--ewoc-entry-tags ert--results-progress-bar-string ewoc-nth 2 ert--stats-set-test-and-result nil type-of signal wrong-type-argument ert--ewoc-entry 1 ert-char-for-test-result t ewoc-invalidate] 13 (#$ . 183738)])#@65 The buffer position where the last button action was triggered.
(defalias 'ert--button-action-position #[0 "\250\203 `\207\301!\203 \302\303!!\207\304\305!\305\207" [last-command-event eventp posn-point event-start cl--assertion-failed nil] 4 (#$ . 184358)])#@91 Jump to details for the test represented by the character clicked in BUTTON.

(fn BUTTON)
(defalias 'ert--results-progress-bar-button-action #[257 "\300 b\210\301 \207" [ert--button-action-position ert-results-jump-between-summary-and-result] 2 (#$ . 184627)])#@83 Re-run all tests, using the same selector.

To be used in the ERT results buffer.
(defalias 'ert-results-rerun-all-tests #[0 "\303=\204\n \304\305!\210	\306!\n>\204 \307\310\311D\"\210\211\312H\262\313!\207" [major-mode ert--results-stats cl-struct-ert--stats-tags ert-results-mode cl--assertion-failed (eql major-mode 'ert-results-mode) type-of signal wrong-type-argument ert--stats 1 ert-run-tests-interactively] 5 (#$ . 184893) [nil (ert-results-mode)]])#@66 Re-run the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-rerun-test-at-point #[0 "\303 \211G\304U\203 \211A\262\242\202 \305\306\307GD\"\242\204# \310\311!\210\312\313\204. \314\202E \315\267\202< \316\202E \317\202E \320\321\322#\205E \323\324!	>\204V \305\325\326D\"\210\327H#`\330\331\"\216\330\332$\216\333\334\"\210\335\n#*\207" [ert--results-stats cl-struct-ert-test-tags ert--results-listener ert--results-test-at-point-allow-redefinition 2 signal wrong-number-of-arguments (test redefinition-state) user-error "No test at point" format "Running %stest %S" "" #s(hash-table test eq purecopy t data (redefined 52 deleted 56)) "new definition of " "deleted " error "cl-ecase failed: %s, %s" (nil redefined deleted) nil type-of wrong-type-argument ert-test 1 make-closure #[0 "\300b\207" [V0] 1] #[0 "\305\301\"\210\306\307\300\310\302!\f>\204 \311\312\313\302D\"\210\302\314H\315\316\302\"\"\262#\207" [V0 V1 V2 ert--results-ewoc cl-struct-ert-test-tags ert--results-update-stats-display message "%s...%s" type-of signal wrong-type-argument ert-test 4 ert-string-for-test-result ert-test-result-expected-p] 9] message "%s..." ert-run-or-rerun-test] 11 (#$ . 185362) [nil (ert-results-mode)]])#@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 #[0 "\301\302 )\207" [ert-debug-on-error t ert-results-rerun-test-at-point] 1 (#$ . 186627) [nil (ert-results-mode)]])#@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 #[0 "\306\307!\310\"\311!	>\204 \312\313\314D\"\210\315HH\311!\n>\203( \316\317!\207\311!>\203_ \320\321!\322!\210\323\324!\204@ \324 \210\325\326\"\311!>\204U \312\313\327D\"\210\330H\331 \210eb\207\316\332\333#\205h \334\207" [ert--results-stats cl-struct-ert--stats-tags cl-struct-ert-test-passed-tags cl-struct-ert-test-result-with-condition-tags backtrace-insert-header-function backtrace-frames ert--results-test-at-point-no-redefinition t ert--stats-test-pos type-of signal wrong-type-argument ert--stats 4 error "Test passed, no backtrace available" get-buffer-create "*ERT Backtrace*" pop-to-buffer derived-mode-p backtrace-mode make-closure #[0 "\302\303\300!	>\204 \304\305\306\300D\"\210\300\307H!\207" [V0 cl-struct-ert-test-tags ert--insert-backtrace-header type-of signal wrong-type-argument ert-test 1] 5] ert-test-result-with-condition 5 backtrace-print "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-result-with-condition) nil] 9 (#$ . 186914) [nil (ert-results-mode)]])#@13 

(fn NAME)
(defalias 'ert--insert-backtrace-header #[257 "\300\301!c\210\302!\210\300\303!c\207" [substitute-command-keys "Backtrace for test `" ert-insert-test-name-button "':\n"] 3 (#$ . 188081)])#@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 #[0 "\305\306!\307\"\310!	>\204 \311\312\313D\"\210\314HH\315\316!\317!\210\306\320 \210\321 \210\322 \210\310!>\204= \311\312\323D\"\210\324Hc\210eb\210\325\326!c\210\327\310!\f>\204\\ \311\312\330D\"\210\324H!\210\325\331!c)\207" [ert--results-stats cl-struct-ert--stats-tags inhibit-read-only cl-struct-ert-test-result-tags cl-struct-ert-test-tags ert--results-test-at-point-no-redefinition t ert--stats-test-pos type-of signal wrong-type-argument ert--stats 4 get-buffer-create "*ERT Messages*" pop-to-buffer buffer-disable-undo erase-buffer ert-simple-view-mode ert-test-result 1 substitute-command-keys "Messages for test `" ert-insert-test-name-button ert-test "':\n"] 10 (#$ . 188288) [nil (ert-results-mode)]])#@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 #[0 "\305\306!\307\"\310!	>\204 \311\312\313D\"\210\314HH\315\316!\317!\210\306\320 \210\321 \210\322 \210\310!>\204= \311\312\323D\"\210\324H\204I \325c\210\202\204 \310!>\204X \311\312\323D\"\210\324H\326\327:\203\202 @\262\330c\210\331\332\"c\210`\333!\210\334`\"\266A\262T\202] \266eb\210\335\336!c\210\337\310!\f>\204\236 \311\312\340D\"\210\327H!\210\335\341!c\210\330c\210\342c\210\327y)\207" [ert--results-stats cl-struct-ert--stats-tags inhibit-read-only cl-struct-ert-test-result-tags cl-struct-ert-test-tags ert--results-test-at-point-no-redefinition t ert--stats-test-pos type-of signal wrong-type-argument ert--stats 4 get-buffer-create "*ERT list of should forms*" pop-to-buffer buffer-disable-undo erase-buffer ert-simple-view-mode 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 substitute-command-keys "`should' forms executed during test `" ert-insert-test-name-button ert-test "':\n" "(Values are shallow copies and may have looked different during the test if they\nhave been modified destructively.)\n"] 12 (#$ . 189207) [nil (ert-results-mode)]])#@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 #[0 "\302 \211\303H\304!	>\204 \305\306\307D\"\210\211\310\304!	>\204& \305\306\307D\"\210\310H?I\210\311\"\207" [ert--results-ewoc cl-struct-ert--ewoc-entry-tags ert--results-test-node-at-point 2 type-of signal wrong-type-argument ert--ewoc-entry 4 ewoc-invalidate] 9 (#$ . 190582) [nil (ert-results-mode)]])#@79 Display test timings for the last run.

To be used in the ERT results buffer.
(defalias 'ert-results-pop-to-timings #[0 "\304\305!\306!	>\204 \307\310\311D\"\210\312H\313\314\306!	>\204( \307\310\311D\"\210\315H\313\314\306!	>\204> \307\310\311\nD\"\210\316H\313\314\211T\262	\nGW\203\216 		H\262T\262GW\203\216 H\262T\262GW\203\216 H\262\317\320\"!DB\262\202E \266\211\237\321\322\"\262\323!\210\324\325 \210\326 \210\327 \210\211\204\260 \330c\210\202\331\332\333\334\335$c\210\211\314\211\211\211\336\324:\203@\262\211A\262\242\262@\262\211\203\336 \202\341 \\\262\331\337$c\210\340\306!>\204\377 \307\310\341	D\"\210\336H!\210\342c\210A\262\210T\314\202\277 \266eb\210\343c\210\336y)\207" [ert--results-stats cl-struct-ert--stats-tags inhibit-read-only cl-struct-ert-test-tags get-buffer-create "*ERT timings*" type-of signal wrong-type-argument ert--stats 2 -1 nil 5 6 float-time time-subtract sort #[514 "A@A@V\207" [] 4 (#$ . 23095)] 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 "\n" "Tests by run time (seconds):\n\n"] 17 (#$ . 191073) [nil (ert-results-mode)]])#@97 Display the documentation for TEST-OR-TEST-NAME (a symbol or ert-test).

(fn TEST-OR-TEST-NAME)
(defalias 'ert-describe-test #[257 "\301C\301C9\203 \240\210\211\302!\240\210\202A \303!>\203; \303!>\204/ \304\305\306D\"\210\307H\240\210\211\240\210\202A \310\311\312#\210\313\314D\315\316!\"\210\212\317\320 \321\322#\")\207" [cl-struct-ert-test-tags nil ert-get-test type-of signal wrong-type-argument ert-test 1 error "cl-etypecase failed: %s, %s" (symbol ert-test) help-setup-xref ert-describe-test called-interactively-p interactive help--window-setup help-buffer make-closure #[0 "r\303 q\210\301\242\203 \304\305\301\242\"\202 \306c\210\307c\210\301\242\205\" \310\301\242\311\"\211\203> \312\313\314!\"c\210\212\315\316\317!!\210\320\321\322\301\242$)\210\323c\210\324e`\"\210\325c\210\326\301\242!\203[ \327\330\301\242!\300\242\"\204j `\331\332\261\210\324`\"\266\325c\210\316\300\242\333!\n>\204| \334\335\336D\"\210\211\337H\262\206\205 \340!\341\261\210\342 )\207" [V0 V1 cl-struct-ert-test-tags help-buffer format "%S" "<anonymous test>" " is a test" symbol-file ert--test format-message " defined in `%s'" file-name-nondirectory re-search-backward substitute-command-keys "`\\([^`']+\\)'" help-xref-button 1 help-function-def "." fill-region-as-paragraph "\n\n" ert-test-boundp eql ert-get-test "Note: This test has been redefined or deleted, " "this documentation refers to an old definition." type-of signal wrong-type-argument ert-test 2 "It is not documented." "\n" buffer-string] 7]] 9 (#$ . 192375) (byte-code "\300\301!C\207" [ert-read-test-name-at-point "Describe test"] 2)])#@88 Display the documentation of the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-describe-test-at-point #[0 "\300\301\302!!\207" [ert-describe-test ert--results-test-at-point-no-redefinition t] 3 (#$ . 194007) [nil (ert-results-mode)]])#@14 

(fn S B F)#@61 Unload function to undo the side-effects of loading ert.el.
(byte-code "\300\301!\210\302\303\304\305\306E\"\210\302\307\310\"\210\302\311\312\"\210\313\314\315\"\207" [require help-mode add-to-list describe-symbol-backends "ERT test" ert-test-boundp #[771 "\300!\207" [ert-describe-test] 5 (#$ . 194278)] find-function-regexp-alist (ert--test . ert--find-test-regexp) minor-mode-alist (ert--current-run-stats (:eval (ert--tests-running-mode-line-indicator))) add-hook emacs-lisp-mode-hook ert--activate-font-lock-keywords] 5)
(defalias 'ert--unload-function #[0 "\300\301\302\303\304$\210\300\305\306\303\304$\210\300\307\310\"\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] 6 (#$ . 194296)])#@350 Parse FILE as a file containing before/after parts (an erts file).

This function puts the "before" section of an .erts file into a
temporary buffer, calls the TRANSFORM function, and then compares
the result with the "after" section.

See Info node `(ert) erts files' for more information on how to
write erts files.

(fn FILE &optional TRANSFORM)
(defalias 'ert-test-erts-file #[513 "\300\301\302\"r\211q\210\303\304\"\216\305!\210\306\302B\307BD\310\311\312\302#\205- \313\"\262\310\314!\210\202 *\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents dummy code re-search-forward "^=-=\n" nil ert-test--erts-test "^=-=-=\n"] 8 (#$ . 195129)])#@23 

(fn GEN-SPECS FILE)
(defalias 'ert-test--erts-test #[514 "p\300\301\224!\302\236A`\303\304\305\306#\203 \301\224\202 d\307\236A\305\211\211\211\204) \310\311!\210\2037 \312\313!@!\204cb\210\314\315\306#\203N \301\224\262\301\225\262\202U \262\262\316	\236\211\203f \317\316A#\262\210\320	\236A\211\203{ \317\320\313!@#\262\210\321\322\306\"r\211q\210\323\324\"\216\325	#\210\326 \210\327\n\236A\211\203\256 eb\210\303\330\305\306#\203\256 \301\224\301\225|\210\210\316\236A\211\203\314 eb\210\331\305\306#\203\314 \301\224\301\225|\210`\262\210\332 *\262\210\321\322\306\"r\211q\210\323\333\"\216\325	#\210\326 \210\334\n\236A\211\203eb\210\303\330\305\306#\203\301\224\301\225|\210\210eb\210\316\236A\211\203!\331\305\306#\203!\301\224\301\225|\210\210\320\236A\211\204/\310\335!\210\211 \266\332 \232\204H\336\337\340#\332 E!\210\203a`U\204a\336\337\341`%\332 D!\210*\210\266\n\207" [ert--erts-specifications 0 name re-search-forward "^=-=-=\n" nil t skip error "No name for test case" eval read-from-string re-search-backward "^=-=\n" point-char map-insert code generate-new-buffer " *temp*" make-closure #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] insert-buffer-substring ert--erts-unquote no-after-newline "\n\\'" search-forward buffer-string #[0 "\301\300!\205	 \302\300!\207" [V0 buffer-name kill-buffer] 2] no-before-newline "No code to run the transform" ert-fail format "Mismatch in test \"%s\", file %s" "Point wrong in test \"%s\", expected point %d, actual %d, file %s"] 20 (#$ . 195873)])
(defalias 'ert--erts-unquote #[0 "eb\210\300\301\302\303#\205 \304\224\304\224T|\210\202 \207" [re-search-forward "^\\=-=\\(-=\\)$" nil t 0] 4])#@73 Find specifications before point (back to the previous test).

(fn END)
(defalias 'ert--erts-specifications #[257 "\212\211b\210\300\301\302\303#\203 \304\225\202 eb\210\302`W\203R \305\306!\203L \307\310\311!\227!\310\312!\311y\210\305\313!\203@ \211\310\311!P\262\311y\210\202- \314!BB\266\203\202 \311y\210\202 \237)\207" [re-search-backward "^=-=-=\n" nil t 0 looking-at "\\([^ \n	:]+\\):\\([ 	]+\\)?\\(.*\\)" intern match-string 1 3 "[ 	]+\\(.*\\)" substring-no-properties] 7 (#$ . 197631)])
(defvar ert-unload-hook nil)
(byte-code "\300\301\302\"\210\303\304\305\306#\210\307\304\305\310#\210\311\304\312\313#\210\314\315!\207" [add-hook ert-unload-hook ert--unload-function defalias ert-equal-including-properties equal-including-properties nil make-obsolete "29.1" put ert-explainer ert--explain-equal-including-properties provide ert] 4)
