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



(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 ""] "Maximum length of lines in ERT backtraces in batch mode.\nUse nil for no limit (caution: backtrace lines can be very long)." :type (choice (const :tag "No truncation" nil) integer)] 8)#@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.
(defvar ert-batch-print-length 10 (#$ . 763))#@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 (#$ . 1042))#@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 (#$ . 1318))
(custom-declare-face 'ert-test-result-expected '((((class color) (background light)) :background "green1") (((class color) (background dark)) :background "green3")) "Face used for expected results in the ERT results buffer.")
(custom-declare-face 'ert-test-result-unexpected '((((class color) (background light)) :background "red1") (((class color) (background dark)) :background "red3")) "Face used for unexpected results in the ERT results buffer.")#@67 compiler-macro for inlining `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 (#$ . 2376)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-p compiler-macro ert-test-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert-test-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-tags type-of t] 3 (#$ . 2751)])
(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)#@70 compiler-macro for inlining `ert-test-name'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 3059)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-name compiler-macro ert-test-name--cmacro] 4)#@58 Access slot "name" of `ert-test' struct CL-X.

(fn CL-X)
(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 (#$ . 3492)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-name side-effect-free t] 4)#@79 compiler-macro for inlining `ert-test-documentation'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 3813)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-documentation compiler-macro ert-test-documentation--cmacro] 4)#@67 Access slot "documentation" of `ert-test' struct CL-X.

(fn CL-X)
(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 (#$ . 4291)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-documentation side-effect-free t] 4)#@70 compiler-macro for inlining `ert-test-body'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 4639)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-body compiler-macro ert-test-body--cmacro] 4)#@58 Access slot "body" of `ert-test' struct CL-X.

(fn CL-X)
(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 (#$ . 5072)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-body side-effect-free t] 4)#@84 compiler-macro for inlining `ert-test-most-recent-result'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 5393)])
(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)#@72 Access slot "most-recent-result" of `ert-test' struct CL-X.

(fn CL-X)
(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 (#$ . 5896)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-most-recent-result side-effect-free t] 4)#@86 compiler-macro for inlining `ert-test-expected-result-type'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 6259)])
(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)#@74 Access slot "expected-result-type" of `ert-test' struct CL-X.

(fn CL-X)
(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 (#$ . 6772)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-expected-result-type side-effect-free t] 4)#@70 compiler-macro for inlining `ert-test-tags'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 7141)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-tags compiler-macro ert-test-tags--cmacro] 4)#@58 Access slot "tags" of `ert-test' struct CL-X.

(fn CL-X)
(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 (#$ . 7574)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-tags side-effect-free t] 4)#@75 compiler-macro for inlining `ert-test-file-name'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 7895)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-file-name compiler-macro ert-test-file-name--cmacro] 4)#@63 Access slot "file-name" of `ert-test' struct CL-X.

(fn CL-X)
(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 (#$ . 8353)])
(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)#@155 compiler-macro for inlining `make-ert-test'.

(fn CL-WHOLE &cl-quote &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS FILE-NAME)
(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\203p \211@\313>\203X \211A\204P \314\315@\"\210\211AA\262\202: \316	>A@\203g \317\262\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 (#$ . 8737)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test compiler-macro make-ert-test--cmacro] 4)#@135 Constructor for objects of type `ert-test'.

(fn &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS FILE-NAME)
(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\203v \211@\314>\203^ \211A\204V \315\316@\"\210\211AA\262\202@ \317	>A@\203m \304\262\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 (#$ . 10026)])
(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)#@53 Return non-nil if SYMBOL names a test.

(fn SYMBOL)
(defalias 'ert-test-boundp #[257 "\211\300N\205 \301\207" [ert--test t] 3 (#$ . 11216)])#@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 (#$ . 11363)])#@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 (#$ . 11591)])#@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 (#$ . 11933)])#@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 \211\237\266\204D\207" [nil keywordp error "Value expected after keyword %S in %S" assoc warn "Keyword %S appears more than once in %S"] 9 (#$ . 12095)])#@817 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' 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@;\2035 \211A\262\242\262\306\262\307!\211G\310U\203H \211A\262\242\202O \301\302\311GD\"\312\313\"\211\205] \211A@\306\262\312\314\"\211\205k \211A@\306\262\242\211\203\244 \211@\315>\203\214 \211A\204\204 \316\317@\"\210\211AA\262\202n \320>A@\203\233 \305\262\202n \316\321@\"\210\202n \210\322\323\324\325D\326\327\325D\330\205\274 \331D\205\305 \332D\f\205\316 \314\fD\333\334\305BB\335\336 \206\334 F$BBBE\325DF\207" [buffer-file-name signal wrong-number-of-arguments ert-deftest 1 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-unless (form) `(ert--skip-unless ,form))) ert-set-test quote make-ert-test :name append :documentation :expected-result-type :body lambda :file-name macroexp-file-name] 27 (#$ . 12889)]))
(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)#@77 The regexp the `find-function' mechanisms use for finding test definitions.
(defvar ert--find-test-regexp (concat "^\\s-*(ert-deftest" find-function-space-re "%s\\(\\s-\\|$\\)") (#$ . 15146))
(byte-code "\300\301\302\"\210\300\303\304\"\207" [define-error ert-test-failed "Test failed" ert-test-skipped "Test skipped"] 3)#@66 Terminate the current test and mark it passed.  Does not return.
(defalias 'ert-pass #[0 "\300\301\302\"\207" [throw ert--pass nil] 3 (#$ . 15473)])#@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 (#$ . 15628)])#@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 (#$ . 15871)])
(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 (#$ . 16157)])#@162 Stupid hack to stop `condition-case' from catching ert signals.
It should only be stopped when ran from inside `ert--run-test-internal'.

(fn ERROR-SYMBOL DATA)
(defalias 'ert--should-signal-hook #[514 "9?\205 \301>\205 \302B\"\207" [debugger (ert-test-failed ert-test-skipped) error] 6 (#$ . 16372)])#@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 (#$ . 16686)])#@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\310\330\313\fBE\331\332\312\f\333BB\334BBDFDD\310\304DDC\312\335EE\336\313\304DD\313\314\337\340D\341DDDE\342\343\f\304DE\313\315EE\342\343\304DE\344\345\346\304DDDC\313\347\335\345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 ((signal-hook-function #'ert--should-signal-hook)) error progn (#'signal) ((list (car err) (cdr err))) apply nconc \` \, \,@ unless eql when-let -explainer- ert--get-explainer :explanation] 29 (#$ . 16924)])#@16 

(fn FN-NAME)
(defalias 'ert--get-explainer #[257 "\2119\205; \211\300!B\301\211\211\211\211:\2039 @\262\302N\262\203+ \262\301\211\262\202, \303\2039 A\262\301\262\202 \266\205\207" [function-alias-p nil ert-explainer t] 9 (#$ . 18134)])#@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)
(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 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 9 (#$ . 18394)])#@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 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 5 (#$ . 19436)]))
(put 'should 'edebug-form-spec t)#@99 Evaluate FORM.  If it returns non-nil, abort the current test as failed.

Returns nil.

(fn FORM)
(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 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 5 (#$ . 19786)]))
(put 'should-not 'edebug-form-spec t)#@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)
(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 (#$ . 20148)])#@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\203C \211@\303>\203, \211A\204$ \304\305@\"\210\211AA\262\202 \306>A@\203: \307\262\202 \304\310@\"\210\202 \210\242\204M \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 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 11 (#$ . 20862)]))
(put 'should-error 'edebug-form-spec t)#@128 Evaluate FORM.  If it returns nil, skip the current test.
Errors during evaluation are caught and handled like nil.

(fn FORM)
(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 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 5 (#$ . 22474)]))
(put 'ert--skip-unless 'edebug-form-spec t)#@53 Format the atom X for `ert--explain-equal'.

(fn X)
(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 (#$ . 22887)])#@108 Return a programmer-readable explanation of why A and B are not `equal'.
Return nil if they are.

(fn A B)
(defalias 'ert--explain-equal-rec #[514 "CC\301\242!\301\242!=\204 \302\242\242E\207\303\242:\203\373 \304\242!\304\242!??=\2045 \305\242\242E\207\203\270 U\204V \306\242\242\307\310\242\242\311\312$\257\207\3132\372 \314\242\315\242\315\211\211:\203\234 @\262:\203\234 @\262\316\"\262\203\211 \317\313\320	E\"\210T\262A\262A\262\315\262\202d \242\242\232\204\263 \321\322\315\242\242D\315$\210\266\3150\207\316\242@\242@\"\211\203\312 \323D\202\370 \316\242A\242A\"\211\203\336 \324D\202\366 \242\242\232\204\365 \321\325\315	\242	\242D\315$\210\315\262\262\207\301\242!>\203\206\3132\314\326\301\242!!\315\242\327\315\242\327\315\211\211	:\203j	@\262	T\262GW\203jH\262T\262GW\203jH\262\316\"\262\203_\317\313\330@E\"\210	A\262\n\315\262\202\f\242\f\242\232\204\201\321\331\315\242\242D\315$\210\266\n\3150\207\332\242!\203\222\211\"\207\333\242!\203\236\211\"\207\242\242\232?\205\314\2429\203\302\2429\203\302\242\242\230\203\302\334\242\242E\207\335\336\242!\336\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\316 \311\242\312\313\242\312\313\211\211T\262GW\203\263 H\262T\262GW\203\263 H\262\314\"\262\203\250 \315\310\316E\"\210T\262	\313\262\202o \n\242\n\242\232\204\312 \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 "\n\n(fn A B)"] 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) 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 (#$ . 23121)])#@43 Explainer function for `equal'.

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

(fn A B)
(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 (#$ . 25735)])
(put 'string-equal 'ert-explainer 'ert--explain-string-equal)#@75 Return the keys of PLIST that have non-null values, in order.

(fn PLIST)
(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 (#$ . 26026)])#@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)
(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 "\n\n(fn A B KEY)"] plist-get t] 15 (#$ . 26468)])#@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 (#$ . 27539)])#@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\261 \310G\303\211\211\211X\203\231 \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\303\262\202D \323\"\204\255 \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 (#$ . 27790)])#@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 (#$ . 28720)])
(put 'equal-including-properties 'ert-explainer 'ert--explain-equal-including-properties)#@118 The stack of `ert-info' infos that currently apply.

Bound dynamically.  This is a list of (PREFIX . MESSAGE) pairs.
(defvar ert--infos nil (#$ . 29057))#@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\203h \211@\306>\203Q \211A\204I \307\310@\"\210\211AA\262\2023 \311>A@\203_ \312\262\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 (#$ . 29217)]))
(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)#@77 Non-nil means enter debugger when a test fails or terminates with an error.
(defvar ert-debug-on-error nil (#$ . 30455))#@74 compiler-macro for inlining `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 (#$ . 30581)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-p compiler-macro ert-test-result-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert-test-result-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-result-tags type-of t] 3 (#$ . 30999)])
(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)#@81 compiler-macro for inlining `ert-test-result-messages'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 31336)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-messages compiler-macro ert-test-result-messages--cmacro] 4)#@69 Access slot "messages" of `ert-test-result' struct CL-X.

(fn CL-X)
(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 (#$ . 31839)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-messages side-effect-free t] 4)#@85 compiler-macro for inlining `ert-test-result-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 32208)])
(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)#@73 Access slot "should-forms" of `ert-test-result' struct CL-X.

(fn CL-X)
(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 (#$ . 32731)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-should-forms side-effect-free t] 4)#@81 compiler-macro for inlining `ert-test-result-duration'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 33112)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-result-duration compiler-macro ert-test-result-duration--cmacro] 4)#@69 Access slot "duration" of `ert-test-result' struct CL-X.

(fn CL-X)
(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 (#$ . 33615)])
(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)#@114 compiler-macro for inlining `make-ert-test-result'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION)
(defalias 'make-ert-test-result--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203L \211@\305>\2035 \211A\204- \306\307@\"\210\211AA\262\202 \310>A@\203C \311\262\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 (#$ . 34039)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-result compiler-macro make-ert-test-result--cmacro] 4)#@94 Constructor for objects of type `ert-test-result'.

(fn &key MESSAGES SHOULD-FORMS DURATION)
(defalias 'make-ert-test-result #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203L \211@\305>\2035 \211A\204- \306\307@\"\210\211AA\262\202 \310>A@\203C \311\262\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 (#$ . 34937)])
(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)#@74 compiler-macro for inlining `ert-test-passed-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 35835)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-passed-p compiler-macro ert-test-passed-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert-test-passed-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-passed-tags type-of t] 3 (#$ . 36253)])
(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)#@81 compiler-macro for inlining `ert-test-passed-messages'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 36590)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-passed-messages compiler-macro ert-test-passed-messages--cmacro] 4)#@69 Access slot "messages" of `ert-test-passed' struct CL-X.

(fn CL-X)
(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 (#$ . 37093)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-passed-messages side-effect-free t] 4)#@85 compiler-macro for inlining `ert-test-passed-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 37462)])
(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)#@73 Access slot "should-forms" of `ert-test-passed' struct CL-X.

(fn CL-X)
(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 (#$ . 37985)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-passed-should-forms side-effect-free t] 4)#@81 compiler-macro for inlining `ert-test-passed-duration'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 38366)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-passed-duration compiler-macro ert-test-passed-duration--cmacro] 4)#@69 Access slot "duration" of `ert-test-passed' struct CL-X.

(fn CL-X)
(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 (#$ . 38869)])
(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)#@114 compiler-macro for inlining `make-ert-test-passed'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION)
(defalias 'make-ert-test-passed--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203L \211@\305>\2035 \211A\204- \306\307@\"\210\211AA\262\202 \310>A@\203C \311\262\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 (#$ . 39293)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-passed compiler-macro make-ert-test-passed--cmacro] 4)#@94 Constructor for objects of type `ert-test-passed'.

(fn &key MESSAGES SHOULD-FORMS DURATION)
(defalias 'make-ert-test-passed #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203L \211@\305>\2035 \211A\204- \306\307@\"\210\211AA\262\202 \310>A@\203C \311\262\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 (#$ . 40191)])
(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)#@89 compiler-macro for inlining `ert-test-result-with-condition-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 41085)])
(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)#@13 

(fn CL-X)
(defalias 'ert-test-result-with-condition-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-result-with-condition-tags type-of t] 3 (#$ . 41593)])
(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)#@96 compiler-macro for inlining `ert-test-result-with-condition-messages'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 41990)])
(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)#@84 Access slot "messages" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(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 (#$ . 42598)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-messages side-effect-free t] 4)#@100 compiler-macro for inlining `ert-test-result-with-condition-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 43043)])
(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)#@88 Access slot "should-forms" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(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 (#$ . 43671)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-should-forms side-effect-free t] 4)#@96 compiler-macro for inlining `ert-test-result-with-condition-duration'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 44127)])
(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)#@84 Access slot "duration" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(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 (#$ . 44735)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-duration side-effect-free t] 4)#@97 compiler-macro for inlining `ert-test-result-with-condition-condition'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 45179)])
(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)#@85 Access slot "condition" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(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 (#$ . 45792)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-condition side-effect-free t] 4)#@97 compiler-macro for inlining `ert-test-result-with-condition-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 46239)])
(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)#@85 Access slot "backtrace" of `ert-test-result-with-condition' struct
CL-X.

(fn CL-X)
(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 (#$ . 46852)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-result-with-condition-backtrace side-effect-free t] 4)#@93 compiler-macro for inlining `ert-test-result-with-condition-infos'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 47299)])
(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)#@81 Access slot "infos" of `ert-test-result-with-condition' struct CL-X.

(fn CL-X)
(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 (#$ . 47892)])
(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)#@155 compiler-macro for inlining `make-ert-test-result-with-condition'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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\203m \211@\313>\203U \211A\204M \314\315@\"\210\211AA\262\2027 \316>A@\203d \317\262\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 (#$ . 48397)])
(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)#@135 Constructor for objects of type `ert-test-result-with-condition'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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>\203g \211A\204_ \313\314@\"\210\211AA\262\202I \315>A@\203v \306\262\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 (#$ . 49695)])
(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)#@72 compiler-macro for inlining `ert-test-quit-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 50924)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-p compiler-macro ert-test-quit-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert-test-quit-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-quit-tags type-of t] 3 (#$ . 51330)])
(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)#@79 compiler-macro for inlining `ert-test-quit-messages'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 51659)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-messages compiler-macro ert-test-quit-messages--cmacro] 4)#@67 Access slot "messages" of `ert-test-quit' struct CL-X.

(fn CL-X)
(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 (#$ . 52148)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-messages side-effect-free t] 4)#@83 compiler-macro for inlining `ert-test-quit-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 52507)])
(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)#@71 Access slot "should-forms" of `ert-test-quit' struct CL-X.

(fn CL-X)
(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 (#$ . 53016)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-should-forms side-effect-free t] 4)#@79 compiler-macro for inlining `ert-test-quit-duration'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 53387)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-duration compiler-macro ert-test-quit-duration--cmacro] 4)#@67 Access slot "duration" of `ert-test-quit' struct CL-X.

(fn CL-X)
(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 (#$ . 53876)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-duration side-effect-free t] 4)#@80 compiler-macro for inlining `ert-test-quit-condition'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 54235)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-condition compiler-macro ert-test-quit-condition--cmacro] 4)#@68 Access slot "condition" of `ert-test-quit' struct CL-X.

(fn CL-X)
(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 (#$ . 54729)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-condition side-effect-free t] 4)#@80 compiler-macro for inlining `ert-test-quit-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 55091)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-backtrace compiler-macro ert-test-quit-backtrace--cmacro] 4)#@68 Access slot "backtrace" of `ert-test-quit' struct CL-X.

(fn CL-X)
(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 (#$ . 55585)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-quit-backtrace side-effect-free t] 4)#@76 compiler-macro for inlining `ert-test-quit-infos'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 55947)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-quit-infos compiler-macro ert-test-quit-infos--cmacro] 4)#@64 Access slot "infos" of `ert-test-quit' struct CL-X.

(fn CL-X)
(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 (#$ . 56421)])
(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)#@138 compiler-macro for inlining `make-ert-test-quit'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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\203m \211@\313>\203U \211A\204M \314\315@\"\210\211AA\262\2027 \316>A@\203d \317\262\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 (#$ . 56824)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-quit compiler-macro make-ert-test-quit--cmacro] 4)#@118 Constructor for objects of type `ert-test-quit'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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>\203g \211A\204_ \313\314@\"\210\211AA\262\202I \315>A@\203v \306\262\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 (#$ . 58020)])
(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)#@74 compiler-macro for inlining `ert-test-failed-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 59162)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-p compiler-macro ert-test-failed-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert-test-failed-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-failed-tags type-of t] 3 (#$ . 59580)])
(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)#@81 compiler-macro for inlining `ert-test-failed-messages'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 59917)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-messages compiler-macro ert-test-failed-messages--cmacro] 4)#@69 Access slot "messages" of `ert-test-failed' struct CL-X.

(fn CL-X)
(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 (#$ . 60420)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-messages side-effect-free t] 4)#@85 compiler-macro for inlining `ert-test-failed-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 60789)])
(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)#@73 Access slot "should-forms" of `ert-test-failed' struct CL-X.

(fn CL-X)
(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 (#$ . 61312)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-should-forms side-effect-free t] 4)#@81 compiler-macro for inlining `ert-test-failed-duration'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 61693)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-duration compiler-macro ert-test-failed-duration--cmacro] 4)#@69 Access slot "duration" of `ert-test-failed' struct CL-X.

(fn CL-X)
(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 (#$ . 62196)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-duration side-effect-free t] 4)#@82 compiler-macro for inlining `ert-test-failed-condition'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 62565)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-condition compiler-macro ert-test-failed-condition--cmacro] 4)#@70 Access slot "condition" of `ert-test-failed' struct CL-X.

(fn CL-X)
(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 (#$ . 63073)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-condition side-effect-free t] 4)#@82 compiler-macro for inlining `ert-test-failed-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 63445)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-backtrace compiler-macro ert-test-failed-backtrace--cmacro] 4)#@70 Access slot "backtrace" of `ert-test-failed' struct CL-X.

(fn CL-X)
(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 (#$ . 63953)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-failed-backtrace side-effect-free t] 4)#@78 compiler-macro for inlining `ert-test-failed-infos'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 64325)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-failed-infos compiler-macro ert-test-failed-infos--cmacro] 4)#@66 Access slot "infos" of `ert-test-failed' struct CL-X.

(fn CL-X)
(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 (#$ . 64813)])
(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)#@140 compiler-macro for inlining `make-ert-test-failed'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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\203m \211@\313>\203U \211A\204M \314\315@\"\210\211AA\262\2027 \316>A@\203d \317\262\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 (#$ . 65228)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-failed compiler-macro make-ert-test-failed--cmacro] 4)#@120 Constructor for objects of type `ert-test-failed'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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>\203g \211A\204_ \313\314@\"\210\211AA\262\202I \315>A@\203v \306\262\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 (#$ . 66436)])
(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)#@75 compiler-macro for inlining `ert-test-skipped-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 67590)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-p compiler-macro ert-test-skipped-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert-test-skipped-p #[257 "\301!>\205	 \302\207" [cl-struct-ert-test-skipped-tags type-of t] 3 (#$ . 68014)])
(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)#@82 compiler-macro for inlining `ert-test-skipped-messages'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 68355)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-messages compiler-macro ert-test-skipped-messages--cmacro] 4)#@70 Access slot "messages" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(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 (#$ . 68865)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-messages side-effect-free t] 4)#@86 compiler-macro for inlining `ert-test-skipped-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 69239)])
(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)#@74 Access slot "should-forms" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(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 (#$ . 69769)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-should-forms side-effect-free t] 4)#@82 compiler-macro for inlining `ert-test-skipped-duration'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 70155)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-duration compiler-macro ert-test-skipped-duration--cmacro] 4)#@70 Access slot "duration" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(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 (#$ . 70665)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-duration side-effect-free t] 4)#@83 compiler-macro for inlining `ert-test-skipped-condition'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 71039)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-condition compiler-macro ert-test-skipped-condition--cmacro] 4)#@71 Access slot "condition" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(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 (#$ . 71554)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-condition side-effect-free t] 4)#@83 compiler-macro for inlining `ert-test-skipped-backtrace'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 71931)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-backtrace compiler-macro ert-test-skipped-backtrace--cmacro] 4)#@71 Access slot "backtrace" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(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 (#$ . 72446)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-skipped-backtrace side-effect-free t] 4)#@79 compiler-macro for inlining `ert-test-skipped-infos'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 72823)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert-test-skipped-infos compiler-macro ert-test-skipped-infos--cmacro] 4)#@67 Access slot "infos" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(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 (#$ . 73318)])
(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)#@141 compiler-macro for inlining `make-ert-test-skipped'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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\203m \211@\313>\203U \211A\204M \314\315@\"\210\211AA\262\2027 \316>A@\203d \317\262\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 (#$ . 73739)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert-test-skipped compiler-macro make-ert-test-skipped--cmacro] 4)#@121 Constructor for objects of type `ert-test-skipped'.

(fn &key MESSAGES SHOULD-FORMS DURATION CONDITION BACKTRACE INFOS)
(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>\203g \211A\204_ \313\314@\"\210\211AA\262\202I \315>A@\203v \306\262\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 (#$ . 74953)])
(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)#@95 compiler-macro for inlining `ert-test-aborted-with-non-local-exit-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 76113)])
(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)#@13 

(fn CL-X)
(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 (#$ . 76657)])
(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)#@102 compiler-macro for inlining `ert-test-aborted-with-non-local-exit-messages'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 77079)])
(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)#@90 Access slot "messages" of `ert-test-aborted-with-non-local-exit'
struct CL-X.

(fn CL-X)
(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 (#$ . 77729)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-aborted-with-non-local-exit-messages side-effect-free t] 4)#@106 compiler-macro for inlining `ert-test-aborted-with-non-local-exit-should-forms'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 78204)])
(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)#@94 Access slot "should-forms" of `ert-test-aborted-with-non-local-exit'
struct CL-X.

(fn CL-X)
(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 (#$ . 78874)])
(byte-code "\300\301\302\303#\300\207" [function-put ert-test-aborted-with-non-local-exit-should-forms side-effect-free t] 4)#@102 compiler-macro for inlining `ert-test-aborted-with-non-local-exit-duration'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 79361)])
(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)#@90 Access slot "duration" of `ert-test-aborted-with-non-local-exit'
struct CL-X.

(fn CL-X)
(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 (#$ . 80011)])
(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)#@135 compiler-macro for inlining `make-ert-test-aborted-with-non-local-exit'.

(fn CL-WHOLE &cl-quote &key MESSAGES SHOULD-FORMS DURATION)
(defalias 'make-ert-test-aborted-with-non-local-exit--cmacro #[385 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203L \211@\305>\2035 \211A\204- \306\307@\"\210\211AA\262\202 \310>A@\203C \311\262\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 (#$ . 80561)])
(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)#@115 Constructor for objects of type `ert-test-aborted-with-non-local-exit'.

(fn &key MESSAGES SHOULD-FORMS DURATION)
(defalias 'make-ert-test-aborted-with-non-local-exit #[128 "\300\301\"A@\300\302\"A@\300\303\"\206 \304A@\211\203L \211@\305>\2035 \211A\204- \306\307@\"\210\211AA\262\202 \310>A@\203C \311\262\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 (#$ . 81586)])
(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)#@83 compiler-macro for inlining `ert--test-execution-info-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 82606)])
(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)#@13 

(fn CL-X)
(defalias 'ert--test-execution-info-p #[257 "\301!>\205	 \302\207" [cl-struct-ert--test-execution-info-tags type-of t] 3 (#$ . 83078)])
(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)#@86 compiler-macro for inlining `ert--test-execution-info-test'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 83451)])
(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)#@74 Access slot "test" of `ert--test-execution-info' struct CL-X.

(fn CL-X)
(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 (#$ . 83997)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--test-execution-info-test side-effect-free t] 4)#@88 compiler-macro for inlining `ert--test-execution-info-result'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 84399)])
(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)#@76 Access slot "result" of `ert--test-execution-info' struct CL-X.

(fn CL-X)
(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 (#$ . 84955)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--test-execution-info-result side-effect-free t] 4)#@99 compiler-macro for inlining `ert--test-execution-info-exit-continuation'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 85363)])
(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)#@87 Access slot "exit-continuation" of `ert--test-execution-info' struct
CL-X.

(fn CL-X)
(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 (#$ . 85974)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--test-execution-info-exit-continuation side-effect-free t] 4)#@95 compiler-macro for inlining `ert--test-execution-info-next-debugger'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'ert--test-execution-info-next-debugger--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block ert--test-execution-info-next-debugger (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 (#$ . 86415)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--test-execution-info-next-debugger compiler-macro ert--test-execution-info-next-debugger--cmacro] 4)#@83 Access slot "next-debugger" of `ert--test-execution-info' struct
CL-X.

(fn CL-X)
(defalias 'ert--test-execution-info-next-debugger #[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 (#$ . 87006)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--test-execution-info-next-debugger side-effect-free t] 4)#@100 compiler-macro for inlining `ert--test-execution-info-ert-debug-on-error'.

(fn CL-WHOLE-ARG CL-X)
(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 5))) nil] 9 (#$ . 87436)])
(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)#@88 Access slot "ert-debug-on-error" of `ert--test-execution-info' struct
CL-X.

(fn CL-X)
(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 5] 5 (#$ . 88052)])
(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)#@155 compiler-macro for inlining `make-ert--test-execution-info'.

(fn CL-WHOLE &cl-quote &key TEST RESULT EXIT-CONTINUATION NEXT-DEBUGGER ERT-DEBUG-ON-ERROR)
(defalias 'make-ert--test-execution-info--cmacro #[385 "\301\302\"\206 \303A@\301\304\"\206 \305A@\301\306\"\206 \307A@\301\310\"A@\301\311\"A@\211\203b \211@\312>\203J \211A\204B \313\314@\"\210\211AA\262\202, \315>A@\203Y \316\262\202, \313\317@\"\210\202, \210\320\321\322\316	\316				&\n)\207" [ert-debug-on-error plist-member :test (nil (cl-assert nil)) :result (nil (cl-assert nil)) :exit-continuation (nil (cl-assert nil)) :next-debugger :ert-debug-on-error (:test :result :exit-continuation :next-debugger :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 :next-debugger :ert-debug-on-error)" cl--defsubst-expand (test result exit-continuation next-debugger ert-debug-on-error) (cl-block make-ert--test-execution-info (record 'ert--test-execution-info test result exit-continuation next-debugger ert-debug-on-error))] 17 (#$ . 88560)])
(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)#@135 Constructor for objects of type `ert--test-execution-info'.

(fn &key TEST RESULT EXIT-CONTINUATION NEXT-DEBUGGER ERT-DEBUG-ON-ERROR)
(defalias 'make-ert--test-execution-info #[128 "\301\302\"\206 \303\304\303!\210\303DA@\301\305\"\206 \303\304\303!\210\303DA@\301\306\"\206. \303\304\303!\210\303DA@\301\307\"A@\301\310\"A@\211\203t \211@\311>\203\\ \211A\204T \312\313@\"\210\211AA\262\202> \314>A@\203k \303\262\202> \312\315@\"\210\202> \210\316\317&)\207" [ert-debug-on-error plist-member :test nil cl--assertion-failed :result :exit-continuation :next-debugger :ert-debug-on-error (:test :result :exit-continuation :next-debugger :ert-debug-on-error :allow-other-keys) error "Missing argument for %s" :allow-other-keys "Keyword argument %s not one of (:test :result :exit-continuation :next-debugger :ert-debug-on-error)" record ert--test-execution-info] 12 (#$ . 89841)])
(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)) (next-debugger) (ert-debug-on-error)) 'cl-struct-ert--test-execution-info-tags 'ert--test-execution-info t)#@338 During a test run, `debugger' is bound to a closure that calls this function.

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

INFO is the ert--test-execution-info corresponding to this test
run.  ARGS are the arguments to `debugger'.

(fn INFO ARGS)
(defalias 'ert--run-test-debugger #[514 "\211\203 \211A\262\242\202 \304\305\306GD\"\211\307\267\202\366 \310\311!>\204, \304\312\313D\"\210\314H\"\207@\211@\211\315=\203@ \315\202K \211\316=\203J \317\202K \320\262\321	!A\322\n!\311!>\204e \304\312\313\nD\"\210\323\324\267\202\236 \325\326\327\211\330\n		&\202\250 \325\316\327\211\330\n		&\202\250 \325\331\327\211\330\n		&\202\250 \332\333\334#\205\250 \327I\210T\311!>\204\276 \304\312\313\nD\"\210\335H\203\337 \310\311	!>\204\327 \304\312\313D\"\210\314H\"\210\311!>\204\360 \304\312\313\nD\"\210\336H \207\332\333\337#\205\377 \327\207" [cl-struct-ert--test-execution-info-tags debugger ert--infos num-nonmacro-input-events signal wrong-number-of-arguments (first-debugger-arg &rest more-debugger-args) #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (lambda 27 debug 27 t 27 exit 27 nil 27 error 50)) apply type-of wrong-type-argument ert--test-execution-info 4 quit ert-test-skipped skipped failed backtrace-get-frames reverse 2 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (quit 110 skipped 126 failed 142)) record ert-test-quit nil 0 ert-test-failed error "cl-ecase failed: %s, %s" (quit skipped failed) 5 3 (nil exit t debug lambda error)] 18 (#$ . 91036)])#@142 Low-level function to run a test according to TEST-EXECUTION-INFO.

This mainly sets up debugger-related bindings.

(fn TEST-EXECUTION-INFO)
(defalias 'ert--run-test-internal #[257 "\306!>\204 \307\310\311D\"\210\211\312	I\210\306!>\204# \307\310\311D\"\210\211\313\nI\210\3142\245 \315\316\317\"r\211q\210\320\321\"\216\322 \320\323\"\216\317\320\324\"\317\325\317\325\211 \306\211!>\204e \307\310\311D\"\210\326H!!>\204\211 \307\310\327\306!>\204\203 \307\310\311D\"\210\326HD\"\210\306!>\204\230 \307\310\311D\"\210\326H\330H .\n\266\331 0\210\306!>\204\265 \307\310\311D\"\210\211\332\333\334\325\211\335$I\210\325\207" [cl-struct-ert--test-execution-info-tags debugger ert-debug-on-error ert--infos debug-ignored-errors debug-on-quit type-of signal wrong-type-argument ert--test-execution-info 4 5 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] #[128 "\301\300\"\207" [V0 ert--run-test-debugger] 4 "\n\n(fn &rest ARGS)"] nil 1 ert-test 3 ert-pass 2 record ert-test-passed 0 backtrace-on-error-noninteractive debug-on-error lexical-binding cl-struct-ert-test-tags] 10 (#$ . 92735)])#@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 (#$ . 94025)])#@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 (#$ . 94372))#@105 Run ERT-TEST.

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

(fn ERT-TEST)
(defalias 'ert-run-test #[257 "\304!>\204 \305\306\307D\"\210\211\310\311I\210\3122T 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\202)\2620\210\304!>\204d \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 "\n\n(fn FORM-DESCRIPTION)"] t ert--run-test-internal] 11 (#$ . 94717)])#@48 Return the top-level test currently executing.
(defalias 'ert-running-test #[0 "\301!@\207" [ert--running-tests last] 2 (#$ . 96161)])#@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 size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 6 t 8 :failed 10 :passed 20 :skipped 30)) nil t type-of #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 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'"] 9 (#$ . 96303)])#@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 (#$ . 97781)])#@1692 Return a list of tests that match SELECTOR.

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

Valid SELECTORs:

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

Only selectors that require a superset of tests, such
as (satisfies ...), strings, :new, etc. make use of UNIVERSE.
Selectors that do not, such as (member ...), just return the
set implied by them without checking whether it is really
contained in UNIVERSE.

(fn SELECTOR UNIVERSE)
(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\202w\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:\203O\211\242\243\211\204I\304\310\323\337\"D\"\207\306\307\"\207\306\307\"\207\243\211:\203r\211\242\243\211\204l\322\304\303\"\"\207\306\307\"\207\306\307\"\207\306\307\"\207\306\307\"\207" [cl-struct-ert-test-tags #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 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 "\n\n(fn TEST)"] #[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 "\n\n(fn TEST)"] #[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 "\n\n(fn TEST)"] #[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 "\n\n(fn TEST)"] (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 "\n\n(fn TEST)"] type-of signal ert-test-unbound #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (member 146 eql 153 and 187 not 223 or 262 tag 302 satisfies 340)) #[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 "\n\n(fn PURPORTED-TEST)"] 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 "\n\n(fn TEST)"]] 12 (#$ . 98105)])
(define-error 'ert-test-unbound "ERT test is unbound")#@90 Insert a human-readable presentation of SELECTOR into the current buffer.

(fn SELECTOR)
(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:\203e \211\242\243\313\267\266\202c \314\300\242\"B\207\207\266\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 size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (or 87 not 87 and 87 eql 87 member 87 satisfies 95 tag 95)) mapcar nil error "No clause matching `%S'"] 8 "\n\n(fn SELECTOR)"] format "%S"] 6 (#$ . 102813)])#@69 compiler-macro for inlining `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 (#$ . 103665)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-p compiler-macro ert--stats-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert--stats-p #[257 "\301!>\205	 \302\207" [cl-struct-ert--stats-tags type-of t] 3 (#$ . 104054)])
(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)#@76 compiler-macro for inlining `ert--stats-selector'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 104372)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-selector compiler-macro ert--stats-selector--cmacro] 4)#@64 Access slot "selector" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 104841)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-selector side-effect-free t] 4)#@73 compiler-macro for inlining `ert--stats-tests'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 105186)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-tests compiler-macro ert--stats-tests--cmacro] 4)#@61 Access slot "tests" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 105640)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-tests side-effect-free t] 4)#@76 compiler-macro for inlining `ert--stats-test-map'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 105976)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-test-map compiler-macro ert--stats-test-map--cmacro] 4)#@64 Access slot "test-map" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 106445)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-map side-effect-free t] 4)#@80 compiler-macro for inlining `ert--stats-test-results'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 106790)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-test-results compiler-macro ert--stats-test-results--cmacro] 4)#@68 Access slot "test-results" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 107279)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-results side-effect-free t] 4)#@84 compiler-macro for inlining `ert--stats-test-start-times'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 107636)])
(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)#@72 Access slot "test-start-times" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 108145)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-start-times side-effect-free t] 4)#@82 compiler-macro for inlining `ert--stats-test-end-times'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 108514)])
(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)#@70 Access slot "test-end-times" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 109013)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-test-end-times side-effect-free t] 4)#@83 compiler-macro for inlining `ert--stats-passed-expected'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 109376)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-passed-expected compiler-macro ert--stats-passed-expected--cmacro] 4)#@71 Access slot "passed-expected" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 109880)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-passed-expected side-effect-free t] 4)#@85 compiler-macro for inlining `ert--stats-passed-unexpected'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 110246)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-passed-unexpected compiler-macro ert--stats-passed-unexpected--cmacro] 4)#@73 Access slot "passed-unexpected" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 110760)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-passed-unexpected side-effect-free t] 4)#@83 compiler-macro for inlining `ert--stats-failed-expected'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 111132)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-failed-expected compiler-macro ert--stats-failed-expected--cmacro] 4)#@71 Access slot "failed-expected" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 111636)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-failed-expected side-effect-free t] 4)#@85 compiler-macro for inlining `ert--stats-failed-unexpected'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 112002)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-failed-unexpected compiler-macro ert--stats-failed-unexpected--cmacro] 4)#@73 Access slot "failed-unexpected" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 112517)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-failed-unexpected side-effect-free t] 4)#@75 compiler-macro for inlining `ert--stats-skipped'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 112890)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-skipped compiler-macro ert--stats-skipped--cmacro] 4)#@63 Access slot "skipped" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 113355)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-skipped side-effect-free t] 4)#@78 compiler-macro for inlining `ert--stats-start-time'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 113698)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-start-time compiler-macro ert--stats-start-time--cmacro] 4)#@66 Access slot "start-time" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 114178)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-start-time side-effect-free t] 4)#@76 compiler-macro for inlining `ert--stats-end-time'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 114530)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-end-time compiler-macro ert--stats-end-time--cmacro] 4)#@64 Access slot "end-time" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 115000)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-end-time side-effect-free t] 4)#@77 compiler-macro for inlining `ert--stats-aborted-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 115346)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-aborted-p compiler-macro ert--stats-aborted-p--cmacro] 4)#@65 Access slot "aborted-p" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 115821)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-aborted-p side-effect-free t] 4)#@80 compiler-macro for inlining `ert--stats-current-test'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 116170)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-current-test compiler-macro ert--stats-current-test--cmacro] 4)#@68 Access slot "current-test" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 116660)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--stats-current-test side-effect-free t] 4)#@82 compiler-macro for inlining `ert--stats-next-redisplay'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 117018)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--stats-next-redisplay compiler-macro ert--stats-next-redisplay--cmacro] 4)#@70 Access slot "next-redisplay" of `ert--stats' struct CL-X.

(fn CL-X)
(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 (#$ . 117518)])
(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)#@281 compiler-macro for inlining `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)
(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\323 \211@\335>\203\273 \211A\204\263 \336\337@\"\210\211AA\262\202\235 \340>A@\203\312 \341\262\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 (#$ . 117932)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert--stats compiler-macro make-ert--stats--cmacro] 4)#@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)
(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\367 \211@\331>\203\337 \211A\204\327 \332\333@\"\210\211AA\262\202\301 \334>A@\203\356 \302\262\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 (#$ . 120392)])
(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)#@76 Return the number of tests in STATS that had expected results.

(fn STATS)
(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 (#$ . 122794)])#@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 (#$ . 123108)])#@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 (#$ . 123427)])#@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 (#$ . 123668)])#@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 (#$ . 123896)])
(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 (#$ . 124195)])#@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)
(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%\210\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)] 10 "\n\n(fn STATS POS TESTS RESULTS D)"] -1 remhash ert--stats-test-key puthash 1 nil] 15 (#$ . 124534)])#@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\203E H\262\307!\262\310\"\2033 \311\312!\210\313#\210T\262\306\262\202 \266\314\315\316\317\320\321G\306\"\322\321G\306\"\323\321G\306\"&\f\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-ert--stats :selector :tests :test-map :test-results make-vector :test-start-times :test-end-times] 18 (#$ . 126374)])#@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 (#$ . 127033)])#@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 \323:\203x @\262\324	#\210\203q \307\211!\n>\204] \310\311\325D\"\210\326H!>\203q \327\330!\203q \331\322\323\"\210A\262\2029 \323\240\266\3230+\210\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] 13 (#$ . 128333)])#@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 (#$ . 129460)])#@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 (#$ . 129770)])#@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 (#$ . 129969)])#@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 (#$ . 130737)])#@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 (#$ . 131596)])#@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 "`\302\211\303p\"\210n\204 \304c\210\212\211b\210\305 +\207" [print-escape-control-characters pp-escape-newlines t pp "\n" indent-sexp] 5 (#$ . 132229)])#@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\205 \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\266\202\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 (#$ . 132563)])#@67 Non-nil makes ERT only print important information in batch mode.
(defvar ert-quiet nil (#$ . 133372))#@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 (#$ . 133480)])#@75 The maximum line length for printing backtraces in `ert-run-tests-batch'.
(defvar ert-batch-backtrace-right-margin 70 (#$ . 133990))#@355 Run the tests specified by SELECTOR, printing results to the terminal.

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

Returns the stats object.

(fn &optional SELECTOR)
(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\202Z	?\205i\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\206\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\345\262\202\266\313\356\330\"\210\334U\204\313\357\"\210\315!\n>\204\241\310\316\317D\"\210\320H\344\345\211\211T\262GW\203	H\262\315!>\204\307\310\316\346D\"\210\347H\262\360\361\"\203\313\351\352\345\"\315!>\204\352\310\316\346D\"\210\307H\353\354!G\211\334V\262\203 \355!\202\330$\210\345\262\202\250\266\313\356\330\"\210\353\362!\205\363!\207\345\207\211G\364U\203-\211A\262\242\2024\310\311\365GD\"\211A\262\242\242\350\"\204\316\315!\f>\203e\313\366\315!>\204]\310\316\346D\"\210\307H\"\210\202\316\315!>\203x\313\367\315!>\204\310\316\346D\"\210\307H\"\210\370\371\372\"r\211q\210\373\374\"\216@\372=\203\235A\202\237@BCDEA\375\315!>\204\271\310\316\376D\"\210\377H!c+\210F\204\322\313\356\201K ed\"\"\210\202\367eb\210m\204\367`\201L  \211F\\^\262\313\356\201K \"\"\266\307y\210\202\325*\210\370\371\372\"r\211q\210\373\201M \"\216\201N !\210\201O c\210\372BCDEG\201P \315!>\2040\310\316\376D\"\210\347H!+\210dSb\210\201Q \201R !\204L\201S \201T !\210\201U \307!\210\313\201V \315!>\204f\310\316\346D\"\210\307H\"\210\313\356\201W  \"*\266\202\316\315!H>\203\235\313\201X \315!>\204\225\310\316\346D\"\210\307H\"\210\202\316\315!I>\203\302\313\201Y \315!>\204\272\310\316\346D\"\210\307H\"\210\202\316\201Z \201[ \201\\ #\210	?\205Y\201] \315!\n>\204\346\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>\204:\310\316\201b \nD\"\210\364H\350\n\n\"\203K\330\202U\201c \201d !P&\266\202\207\201Z \201e \201f #\205i\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 size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (run-started 6 run-ended 76 test-started 538 test-ended 540)) 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 "\n\n(fn EVENT-TYPE &rest EVENT-ARGS)"] nil] 7 (#$ . 134129)])#@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!\2038 \31717 \320\311\"0\210\2028 \210\321\322!\323U\203E \323\202F \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\202 \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 (#$ . 139461)])#@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 (#$ . 140576))#@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\361\327!\f>\204\361\327!>\204\361\327!>\204\342\330\331\366D\"\210\334HG\335U\203\361\370c\210\202\340\371c\210\327!>\203!\323\372\352\373\374!!\353\"\364\365\"\"#\352\373\374!!\353\"\375\376\261\210\202\244\327!\f>\203a\323\377\325	!\364\365\"\"#\323\201@ \352\363\327!\n>\204P\330\331\360\nD\"\210\334H!\353\"\"\201A \261\210\202\244\201B \327!\n>\204u\330\331\360D\"\210\201C H\"\204\244\323\201D \352\373\374!!\353\"\364\365\"\"#\352\373\374!!\353\"\375\201E \261\210\327!>\204\263\330\331\366D\"\210\334HG\335U\204\333\201F \352\327!>\204\320\330\331\366D\"\210\334H\353\"\201G \261\210\201H c\210\357\262\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 (#$ . 140794)])#@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\266\202\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 (#$ . 144317)])#@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)
(defalias 'ert-summarize-tests-batch-and-exit #[256 "\204 \304\305!\210\306!\204 \307\262\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\377 \322 \210\323!\203U \324!\210\325\326\310\317#\204g B\262\202; \f\327\330\331!!\\\262\325\332\310\317#\204\202 B\262\202; \330\331!\203\216 B\262\327\330\333!!\\\262\f\n\327\330\334!!\\\262\330\335!\203\300 \327\330\335!!\211\307U\204\277 B\262\n\\\262\210\330\336!\203\326 B\262\327\330\336!!\\\262	\307U\204; eb\210`dW\203; \337\340!\203\371 \327\330\331!!\330\307!BB\262\310y\210\202\340 *\210Z\262\341\342!\210\341\343!\210\341\344\"\210\341\345\f	\307U\203%\346\202*\347\350\"&\210\203D\341\351G\"\210\352\353\"\210\203\217\341\354G\"\210\352\355\"\210\311\356!\204_\311\357!\203\217\315\316\317\"r\211q\210\320\360\"\216\211\203\214\211@\322 \210\324!\210\341\361\"\210\341\362\363 \"\210A\266\202\202m*\266\203\236\341\364G\"\210\352\365\"\210\211\203\304\307U\204\304\341\366!\210\341\367!\210\370\371\372\"\"\262\341\373\374\375\376#\"\210\311\356!\204\320\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 \"@\"\210A\266\202\202*\266\201G \2041\2041\307U\2045\333\202>\203=\331\202>\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 "\n\n(fn L)"] "%d files did not finish:" #[257 "\300\301\"\207" [message "  %s"] 4 "\n\n(fn L)"] "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 "\n\n(fn L)"] "\nLONG-RUNNING TESTS" "------------------" ntake sort #[514 "@@V\207" [] 4 "\n\n(fn X Y)"] "%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 "\n\n(fn L)"] kill-emacs] 22 (#$ . 146624)])#@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 (#$ . 150490)])#@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\203B \211@\303>\203+ \211A\204# \304\305@\"\210\211AA\262\202 \306>A@\2039 \307\262\202 \304\310@\"\210\202 \210\204J \311\262\211\204Q \312\262\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 (#$ . 150802)])#@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 (#$ . 151407)])#@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 (#$ . 152370)])#@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 (#$ . 152721) (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 (#$ . 153026) (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\"\"\210\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] 5 (#$ . 153315) nil])#@74 compiler-macro for inlining `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 (#$ . 153649)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--ewoc-entry-p compiler-macro ert--ewoc-entry-p--cmacro] 4)#@13 

(fn CL-X)
(defalias 'ert--ewoc-entry-p #[257 "\301!>\205	 \302\207" [cl-struct-ert--ewoc-entry-tags type-of t] 3 (#$ . 154068)])
(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)#@77 compiler-macro for inlining `ert--ewoc-entry-test'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 154406)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop ert--ewoc-entry-test compiler-macro ert--ewoc-entry-test--cmacro] 4)#@65 Access slot "test" of `ert--ewoc-entry' struct CL-X.

(fn CL-X)
(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 (#$ . 154890)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--ewoc-entry-test side-effect-free t] 4)#@81 compiler-macro for inlining `ert--ewoc-entry-hidden-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 155248)])
(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)#@69 Access slot "hidden-p" of `ert--ewoc-entry' struct CL-X.

(fn CL-X)
(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 (#$ . 155752)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--ewoc-entry-hidden-p side-effect-free t] 4)#@83 compiler-macro for inlining `ert--ewoc-entry-expanded-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 156122)])
(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)#@71 Access slot "expanded-p" of `ert--ewoc-entry' struct CL-X.

(fn CL-X)
(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 (#$ . 156636)])
(byte-code "\300\301\302\303#\300\207" [function-put ert--ewoc-entry-expanded-p side-effect-free t] 4)#@98 compiler-macro for inlining `ert--ewoc-entry-extended-printer-limits-p'.

(fn CL-WHOLE-ARG CL-X)
(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 (#$ . 157012)])
(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)#@86 Access slot "extended-printer-limits-p" of `ert--ewoc-entry' struct
CL-X.

(fn CL-X)
(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 (#$ . 157601)])
(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)#@134 compiler-macro for inlining `make-ert--ewoc-entry'.

(fn CL-WHOLE &cl-quote &key TEST HIDDEN-P EXPANDED-P EXTENDED-PRINTER-LIMITS-P)
(defalias 'make-ert--ewoc-entry--cmacro #[385 "\300\301\"\206 \302A@\300\303\"\206 \304A@\300\305\"\206 \306A@\300\307\"A@\211\203[ \211@\310>\203C \211A\204; \311\312@\"\210\211AA\262\202% \313>A@\203R \314\262\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 (#$ . 158077)])
(byte-code "\300\301\302\303#\300\207" [define-symbol-prop make-ert--ewoc-entry compiler-macro make-ert--ewoc-entry--cmacro] 4)#@114 Constructor for objects of type `ert--ewoc-entry'.

(fn &key TEST HIDDEN-P EXPANDED-P EXTENDED-PRINTER-LIMITS-P)
(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\203g \211@\310>\203O \211A\204G \311\312@\"\210\211AA\262\2021 \313>A@\203^ \302\262\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 (#$ . 159180)])
(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)#@58 Insert a button that links to TEST-NAME.

(fn TEST-NAME)
(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 (#$ . 160199)])#@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 (#$ . 160436)])#@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!\350c\210\202'\316!	>\204(\317\320\321\nD\"\210\342H\203\206\351c\210\352\316\211\n!	>\204E\317\320\321\fD\"\210	\342H!\n>\204j\317\320\353\316\f!	>\204c\317\320\321D\"\210\342HD\"\210\316	!	>\204{\317\320\321D\"\210\342H\322H!\210\202'\354c\210\202'\316!	>\204\235\317\320\321\nD\"\210\342H\204\250\355\356!\210\357c\210\352\316\211\n!	>\204\276\317\320\321\fD\"\210	\342H!\n>\204\343\317\320\353\316\f!	>\204\334\317\320\321D\"\210\342HD\"\210\316	!	>\204\364\317\320\321D\"\210\342H\322H!\210\202'\316!	>\204\317\320\321\nD\"\210\342H\203\355\360!\210\361c\210\202'\362\363\364#\210\323c\210\316!	>\204;\317\320\321\nD\"\210\344H\203~\324\365\316\n!	>\204U\317\320\321\fD\"\210	\340H\203`\366\202a\367\336\316\f!	>\204s\317\320\321D\"\210\344H!#c\210\202\201\323c\210\323c\266rq\210)\370\371\372\373	\203\234\374!\206\235\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 size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (preparing 273 aborted 279 running 396 finished 511)) "" "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 (#$ . 160708)])#@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 (#$ . 163746))#@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 (#$ . 164019)])#@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 (#$ . 164467)])#@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\205 \305\316\310\211\n!	>\204H \311\312\313\fD\"\210	\314H!\n>\204m \311\312\317\310\f!	>\204f \311\312\313D\"\210\314HD\"\210\310	!	>\204~ \311\312\313D\"\210\314H\320H\"$\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] 16 (#$ . 164899)])#@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 (#$ . 165574)])#@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 (#$ . 166118)])#@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 (#$ . 166353)])#@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 (#$ . 166707)])#@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\266\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] 15 (#$ . 167149)])#@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 (#$ . 169304)])
(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*\210\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 (#$ . 169723)])#@51 List of recent test selectors read from terminal.
(defvar ert--selector-history nil (#$ . 170751))#@141 Run the tests specified by SELECTOR and display the results in a buffer.

SELECTOR works as described in `ert-select-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\202h\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\203` \320\202d \326\327\"\262\330!\211\325U\203t \320\202x \326\331\"\262&\210\332r\301\242q\210\n)\"\207\211G\314U\203\231 \211A\262\242\202\240 \307\310\333GD\"\242r\301\242q\210\n\334\"\335\"\211\204\270 \336\337!\210\211\314H\340!>\204\312 \307\341\342D\"\210\211\306I\266\f\343\344\345\"I\210\346\"\210\347\"\266\203)\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\"\266\203)\207\353\354\355#\205q\344\207" [V0 V1 ert--results-ewoc cl-struct-ert--ewoc-entry-tags ert--results-progress-bar-string #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (run-started 6 run-ended 38 test-started 136 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 "\n\n(fn EVENT-TYPE &rest EVENT-ARGS)"] ert-run-tests t] 8 (#$ . 170856) (byte-code "\203	 @\202\n \302\303\304\305\306\"	\307\310\211\300\310&!\262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-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))
(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\303\311\320\321#\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'." derived-mode-parent special-mode] 5)#@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}
(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 (#$ . 174470) 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))
(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\303\311\320\321#\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'." derived-mode-parent special-mode] 5)#@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}
(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 "\n\n(fn &rest _)"] run-mode-hooks ert-results-mode-hook local-abbrev-table] 5 (#$ . 176673)])
(byte-code "\301\302\211\211:\203& @\262\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)#@30 Menu for `ert-results-mode'.
(defvar ert-results-mode-menu nil (#$ . 178597))
(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)#@107 If point is on a valid ewoc node, return it; return nil otherwise.

To be used in the ERT results buffer.
(defalias 'ert--results-test-node-or-null-at-point #[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 (#$ . 180241)])#@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 (#$ . 180663)])#@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 (#$ . 180943) [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 (#$ . 181199) [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 (#$ . 181464)])#@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 (#$ . 182094)])#@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 (#$ . 182559) [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 (#$ . 182884)])#@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\302\262\202 \207" [--cl-block-nil-- 0 nil t ewoc-nth ewoc-next eql throw] 8 (#$ . 183114)])#@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 (#$ . 183431) [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 (#$ . 184287)])#@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\262\262\202Y \n\211`X\205W `\320\321!!W\205W `Z\313!\f>\204P \314\315\322D\"\210\312HH\262\262\206c \211\205c \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"] 7 (#$ . 184730)])#@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 (#$ . 185608)])#@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\"\266\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] 12 (#$ . 186791)])#@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!\210\305\207" [last-command-event eventp posn-point event-start cl--assertion-failed nil] 3 (#$ . 187416)])#@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 (#$ . 187689)])#@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	\312H\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] 4 (#$ . 187955) [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 size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 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 (#$ . 188415) [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 (#$ . 189727) [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 (#$ . 190014) [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 (#$ . 191181)])#@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 (#$ . 191388) [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\207 \310!>\204X \311\312\323D\"\210\324H\326\327:\203\205 @\262\330c\210\331\332\"c\210`\333!\210\334`\"\266A\262\211T\262\202] \266eb\210\335\336!c\210\337\310!\f>\204\241 \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 (#$ . 192307) [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 (#$ . 193691) [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 \211\237\266\212\321\322\"\262\323!\210\324\325 \210\326 \210\327 \210\211\204\261 \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\337 \202\342 \\\262\331\337$c\210\340\306!>\204 \307\310\341	D\"\210\336H!\210\342c\210A\262T\262\314\262\202\300 \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 "\n\n(fn A B)"] 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 (#$ . 194182) [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!\320\321#\210\322\323\324\301\242$)\210\325c\210\326e`\"\210\327c\210\330\301\242!\203] \331\332\301\242!\300\242\"\204l `\333\334\261\210\326`\"\266\327c\210\316\335\300\242!\n>\204~ \336\337\340\300\242D\"\210\300\242\341H\206\206 \342!\343\261\210\344 )\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 "`\\([^`']+\\)'" nil t 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] 6]] 9 (#$ . 195494) (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 (#$ . 197145) [nil (ert-results-mode)]])
(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 "\n\n(fn S B F)"] 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)#@61 Unload function to undo the side-effects of loading ert.el.
(defalias 'ert--unload-function #[0 "\300\301\302\303\304$\210\300\305\306\303\304$\210\300\307\310\"\210\311\207" [ert--remove-from-list find-function-regexp-alist ert-deftest :key car minor-mode-alist ert--current-run-stats emacs-lisp-mode-hook ert--activate-font-lock-keywords nil] 5 (#$ . 197887)])#@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 (#$ . 198256)])#@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 (#$ . 199000)])
(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 \211\237)\207" [re-search-backward "^=-=-=\n" nil t 0 looking-at "\\([^ \n	:]+\\):\\([ 	]+\\)?\\(.*\\)" intern match-string 1 3 "[ 	]+\\(.*\\)" substring-no-properties] 7 (#$ . 200758)])
(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)
