%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/emacs-lisp/
Current File : //usr/local/share/emacs/27.2/lisp/emacs-lisp/ert.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

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

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

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


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\210\300\310!\210\300\311!\210\312\313\314\315\316\317\320\321&\210\322\323\324\325\326DD\327\330\331%\210\332\333\334\335\320\313%\210\332\336\337\340\320\313%\207" [require cl-lib button debug backtrace easymenu ewoc find-func help pp 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) custom-declare-face ert-test-result-expected ((((class color) (background light)) :background "green1") (((class color) (background dark)) :background "green3")) "Face used for expected results in the ERT results buffer." ert-test-result-unexpected ((((class color) (background light)) :background "red1") (((class color) (background dark)) :background "red3")) "Face used for unexpected results in the ERT results buffer."] 8)
#@386 Return t if A and B have similar structure and contents.

This is like `equal-including-properties' except that it compares
the property values of text properties structurally (by
recursing) rather than with `eq'.  Perhaps this is what
`equal-including-properties' should do in the first place; see
Emacs bug 6581 at URL `https://debbugs.gnu.org/cgi/bugreport.cgi?bug=6581'.

(fn A B)
(defalias 'ert-equal-including-properties #[514 "\300\"?\207" [ert--explain-equal-including-properties] 5 (#$ . 1556)])
#@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 (#$ . 2069)])
(put 'ert-test-p 'compiler-macro 'ert-test-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert-test-p #[257 "\301!>\205	\302\207" [cl-struct-ert-test-tags type-of t] 3 (#$ . 2391)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-p side-effect-free error-free put ert-test cl-deftype-satisfies] 5)
#@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 (#$ . 2657)])
(put 'ert-test-name 'compiler-macro 'ert-test-name--cmacro)
#@58 Access slot "name" of `ert-test' struct CL-X.

(fn CL-X)
(defalias 'ert-test-name #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 1] 5 (#$ . 3037)])
(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 (#$ . 3359)])
(put 'ert-test-documentation 'compiler-macro 'ert-test-documentation--cmacro)
#@67 Access slot "documentation" of `ert-test' struct CL-X.

(fn CL-X)
(defalias 'ert-test-documentation #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 2] 5 (#$ . 3784)])
(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 (#$ . 4133)])
(put 'ert-test-body 'compiler-macro 'ert-test-body--cmacro)
#@58 Access slot "body" of `ert-test' struct CL-X.

(fn CL-X)
(defalias 'ert-test-body #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 3] 5 (#$ . 4513)])
(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 (#$ . 4835)])
(put 'ert-test-most-recent-result 'compiler-macro 'ert-test-most-recent-result--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 4] 5 (#$ . 5285)])
(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 (#$ . 5649)])
(put 'ert-test-expected-result-type 'compiler-macro 'ert-test-expected-result-type--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 5] 5 (#$ . 6109)])
(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 (#$ . 6479)])
(put 'ert-test-tags 'compiler-macro 'ert-test-tags--cmacro)
#@58 Access slot "tags" of `ert-test' struct CL-X.

(fn CL-X)
(defalias 'ert-test-tags #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 6] 5 (#$ . 6859)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put ert-test-tags side-effect-free t defalias copy-ert-test copy-sequence] 4)
#@145 compiler-macro for inlining `make-ert-test'.

(fn CL-WHOLE &cl-quote &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS)
(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@\211\203^\211@\312>\203F\211AA\262\2023\313>A@\203U\314\262\2023\315\316@\"\210\2023\210\317\320\321\314\314&\207" [plist-member :name :documentation :body (nil (cl-assert nil)) :most-recent-result :expected-result-type (nil ':passed) :tags (nil 'nil) (:name :documentation :body :most-recent-result :expected-result-type :tags :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :documentation :body :most-recent-result :expected-result-type :tags)" cl--defsubst-expand (name documentation body most-recent-result expected-result-type tags) (cl-block make-ert-test (record 'ert-test name documentation body most-recent-result expected-result-type tags))] 20 (#$ . 7229)])
(put 'make-ert-test 'compiler-macro 'make-ert-test--cmacro)
#@125 Constructor for objects of type `ert-test'.

(fn &key NAME DOCUMENTATION BODY MOST-RECENT-RESULT EXPECTED-RESULT-TYPE TAGS)
(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@\211\203d\211@\313>\203L\211AA\262\2029\314>A@\203[\304\262\2029\315\316@\"\210\2029\210\317\320&\207" [plist-member :name :documentation :body nil cl--assertion-failed :most-recent-result :expected-result-type (nil :passed) :tags (nil nil) (:name :documentation :body :most-recent-result :expected-result-type :tags :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:name :documentation :body :most-recent-result :expected-result-type :tags)" record ert-test] 15 (#$ . 8324)])
(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)) '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 (#$ . 9386)])
#@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 (#$ . 9533)])
#@86 Make SYMBOL name the test DEFINITION, and return DEFINITION.

(fn SYMBOL DEFINITION)
(defalias 'ert-set-test #[514 "\300=\203\n\301\302!\210\303\304#\210\207" [nil error "Attempt to define a test named nil" define-symbol-prop ert--test] 6 (#$ . 9761)])
#@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 (#$ . 10024)])
#@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\211A\262\242:\204\302\303#\210\304\"\203)\305\306#\210\211\211A\262\242BB\262\210\202\237\262\300\211\211:\203c@\262\211A\262\242\262B\262B\262A\262\202A\211\237\266\204D\207" [nil keywordp error "Value expected after keyword %S in %S" assoc warn "Keyword %S appears more than once in %S"] 9 (#$ . 10187)])
#@721 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 ...))'.

(fn NAME () [DOCSTRING] [:expected-result RESULT-TYPE] [:tags \='(TAG...)] BODY...)
(defalias 'ert-deftest '(macro . #[385 "\211\203
\211A\262\242\202\300\301\302GD\"\211\203\"\300\301\302G\303\\D\"\210\304\211@;\2035\211A\262\242\262\305\262\306!\211G\307U\203H\211A\262\242\202O\300\301\310GD\"\311\312\"\211\205]\211A@\305\262\311\313\"\211\205k\211A@\305\262@\211\203\231\211@\314>\203\201\211AA\262\202n\315>A@\203\220\304\262\202n\316\317@\"\210\202n\210\320\321\322\323D\324\325\323D\326\205\261\327D
\205\272\330
D\f\205\303\313\fD\331\332\304BBD$BBBE\323DF\266\207\266\202\207" [signal wrong-number-of-arguments ert-deftest 0 nil t ert--parse-keys-and-body 2 ((&key (expected-result nil expected-result-supplied-p) (tags nil tags-supplied-p)) body) plist-member :expected-result :tags (:expected-result :tags :allow-other-keys) :allow-other-keys error "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] 27 (#$ . 10982)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\304\301\307\310#\300\301\307\310#\210\300\311\307\312#\207" [put ert-deftest edebug-form-spec (&define :name test name sexp [&optional stringp] [&rest keywordp sexp] def-body) function-put doc-string-elt 3 lisp-indent-function 2 ert-info 1] 6)
#@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-\\|$\\)") (#$ . 13073))
(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 (#$ . 13401)])
#@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\301C\"\207" [signal ert-test-failed] 4 (#$ . 13557)])
#@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\301C\"\207" [signal ert-test-skipped] 4 (#$ . 13801)])
(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 (#$ . 14088)])
#@160 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\"\207" [debugger (ert-test-failed ert-test-skipped) error] 5 (#$ . 14304)])
#@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 (#$ . 14615)])
#@90 Helper function for the `should' macro and its variants.

(fn WHOLE FORM INNER-EXPANDER)
(defalias 'ert--expand-should-1 #[771 "\3031%\304\305\306\300!\205\306\301!\203	\202\306\302!\205\n\"\"0\2021\307\310@D\310ADE\262\211:\203=\311@!\203c\312\313!\314\315BC\316E\317\310\nD\320\310	D\321	\257#F\262\202\211@A9\204\202:\203~@\322=\203~A<\204\202\323\324!\210\312\325!\312\326!\312\313!\312\327!\330\331DD\332\333\314\334\317\fBE\335\336\316\f\337BB\340BBDFDD\314\310DDC\316\341EE\342\317\310DD\317\320\343\344CB\345CBDCBE\346\347\f\310
DE\317\321EE\314\350\351\352\310DD\353\310D\354BBEDC\355\350\317\356\341\350EEEE\257#FE\266\204\266\202\207" [byte-compile-macro-environment macroexpand-all-environment cl-macro-environment (error) macroexpand-all append boundp 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 -explainer- and symbolp get ('ert-explainer) when :explanation] 29 (#$ . 14854)])
#@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\303\304\305!\306\"\307\310%#\207" [ert--expand-should-1 make-byte-code 771 "\301\302!\303C\300\304\305	E\306DF#E\207" vconcat vector [gensym "form-description-" let unwind-protect setq ert--signal-should-execution] 12 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"] 12 (#$ . 16245)])
#@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\301D\302#\207" [ert--expand-should should #[771 "\300\301DE\207" [unless ert-fail] 7 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 5 (#$ . 17327)]))
(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\301D\302#\207" [ert--expand-should should-not #[771 "\300\301D\302DE\207" [unless not ert-fail] 7 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 5 (#$ . 17678)]))
(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
\2029\203C\202\301\302\"\262\204&\303\304!\210\305\"\204;\306\307 \310\311\312F\"!\210\205T@\235?\205T\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 (#$ . 18041)])
#@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\2038\211@\303>\203!\211AA\262\202\304>A@\203/\305\262\202\306\307@\"\210\202\210\242\204B\310\240\210\311\312BB\313\314\315\316\317		\"\320\"\321\322%#\207" [plist-member :type :exclude-subtypes (:type :exclude-subtypes :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:type :exclude-subtypes)" 'error ert--expand-should should-error make-byte-code 771 "\302\303!\302\304!\305\306B\307\310EDD\311\312\313\314\315BB\316\312\300\242\301\257\314\317BBFF\320\321\322\323D\324BBDEF\207" vconcat vector [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)"] 14 (#$ . 18762)]))
(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\301D\302#\207" [ert--expand-should skip-unless #[771 "\300\301D\302DE\207" [unless ignore-errors ert-skip] 7 "\n\n(fn INNER-FORM FORM-DESCRIPTION-FORM VALUE-VAR)"]] 5 (#$ . 20359)]))
(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 (#$ . 20773)])
#@109 Return a programmer-readable explanation of why A and B are not `equal'.
Returns nil if they are.

(fn A B)
(defalias 'ert--explain-equal-rec #[514 "\300!\300!=\204\301E\207:\203\327\302!\302!??=\204)\303E\202\326\203\240U\204H\304\305\306\n\n\307\310$\257\202\326\3112\326\312\313\313\211:\203\206@\262:\203\206@\262\314\"\262\211\203w\315\311\316E\"\210T\262A\262A\262\202R		\232\204\231\317\320\313\f\fD\313$\210\313\266\2060\202\326\314@@\"\211\203\260\321D\202\324\314AA\"\211\203\300\322D\202\322\232\204\321\317\323\313D\313$\210\313\262\262\207\324!\203\217;\203\325!\325!\204\361\262\202\371\211?\205\367\266\202\203\326!\262\326!\262GGU\204-\327GG\330!?\205'\305\306\307\310$DBBBBB\207\3112\300\312\331\313\331\313\211T\211\262GW\203wH\262T\211\262GW\203wH\262\314\"\262\211\203o\315\311\332\nE\"\210T\262\2029		\232\204\212\317\333\313\f\fD\313$\210\313\266\2100\207:\204\271\232?\205\3009\203\260\2119\203\260\230\203\260\334E\207\335\336!\336!E\207\337\340\"\262\207" [type-of different-types 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) arrayp multibyte-string-p string-to-multibyte arrays-of-different-length char-table-p -1 array-elt (equal a b) different-symbols-with-the-same-name different-atoms ert--explain-format-atom error "No clause matching `%S'"] 15 (#$ . 21008)])
#@43 Explainer function for `equal'.

(fn A B)
(defalias 'ert--explain-equal #[514 "\232?\205\300\"\207" [ert--explain-equal-rec] 5 (#$ . 22659)])
(put 'equal 'ert-explainer 'ert--explain-equal)
#@75 Return the keys of PLIST that have non-null values, in order.

(fn PLIST)
(defalias 'ert--significant-plist-keys #[257 "\300G\301\"\302U\204\303\304\305\300G\301\"C\305$\210\3062X\211\305\211\211\211:\203O\262\211A\262\242\262\211A\262\242\262\203G>\204G\211C\244\262AA\262\202\307\306\"\210\305\266\2050\207" [mod 2 0 cl--assertion-failed (zerop (mod (length plist) 2)) nil --cl-block-nil-- throw] 9 (#$ . 22861)])
#@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 "\300G\301\"\302U\204\303\304\305\300G\301\"C\305$\210\300G\301\"\302U\204,\303\306\305\300G\301\"C\305$\210\307!\307!\310\311\312$\310\311\312$\313\203N\211@#\202\225\203]\211@#\202\225\305\314\305:\203\223@\262\315\"\315\"\232\204\210#\262\305\211\262\202\211\314\203\223A\262\202a\266\203\262\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)"] t plist-get] 15 (#$ . 23311)])
#@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\211W\203\f\202\203\300Z\"\202\300\301#\207" [substring 0] 8 (#$ . 24406)])
#@188 Explainer function for `ert-equal-including-properties'.

Returns a programmer-readable explanation of why A and B are not
`ert-equal-including-properties', or nil if they are.

(fn A B)
(defalias 'ert--explain-equal-including-properties #[514 "\232\204\300\"\207;\204\301\302\303C\303$\210\211;\204%\301\304\303C\303$\210\305GG\"\2049\301\306\303GGD\303$\210\3072\226\310G\303\211\211X\203\222\311\"\262\311\"\262\312\"\262\211\203\213\313\307\314\315\n\211T#\316\317\315\310#\320\321#\322\317\315T\"\320\303#\257\"\210T\262\202C\303\266\2050\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] 20 (#$ . 24673)])
(put 'ert-equal-including-properties 'ert-explainer 'ert--explain-equal-including-properties)
#@118 The stack of `ert-info' infos that currently apply.

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

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

(fn (MESSAGE-FORM &key ((:prefix PREFIX-FORM) "Info: ")) &body BODY)
(defalias 'ert-info '(macro . #[128 "\211\203
\211A\262\242\202\300\301\302GD\"\211\203!\211A\262\242\202(\300\301\302GD\"\303\304\"\2060\305A@\211\203]\211@\306>\203F\211AA\262\2023\307>A@\203T\310\262\2023\311\312@\"\210\2023\210\313\314\315\211E\316BBDCBB\207" [signal wrong-number-of-arguments ert-info plist-member :prefix (nil "Info: ") (:prefix :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:prefix)" let ert--infos cons (ert--infos)] 10 (#$ . 25820)]))
(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 (#$ . 26901))
#@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 (#$ . 27028)])
(put 'ert-test-result-p 'compiler-macro 'ert-test-result-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert-test-result-p #[257 "\301!>\205	\302\207" [cl-struct-ert-test-result-tags type-of t] 3 (#$ . 27393)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-result-p side-effect-free error-free put ert-test-result cl-deftype-satisfies] 5)
#@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 (#$ . 27688)])
(put 'ert-test-result-messages 'compiler-macro 'ert-test-result-messages--cmacro)
#@69 Access slot "messages" of `ert-test-result' struct CL-X.

(fn CL-X)
(defalias 'ert-test-result-messages #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-tags type-of signal wrong-type-argument ert-test-result 1] 5 (#$ . 28138)])
(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 (#$ . 28508)])
(put 'ert-test-result-should-forms 'compiler-macro 'ert-test-result-should-forms--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert-test-result-tags type-of signal wrong-type-argument ert-test-result 2] 5 (#$ . 28978)])
(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 (#$ . 29360)])
(put 'ert-test-result-duration 'compiler-macro 'ert-test-result-duration--cmacro)
#@69 Access slot "duration" of `ert-test-result' struct CL-X.

(fn CL-X)
(defalias 'ert-test-result-duration #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-result-tags type-of signal wrong-type-argument ert-test-result 3] 5 (#$ . 29810)])
(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\203A\211@\305>\203*\211AA\262\202\306>A@\2038\307\262\202\310\311@\"\210\202\210\312\313\314\307\307&\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) :allow-other-keys nil error "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 (#$ . 30235)])
(put 'make-ert-test-result 'compiler-macro 'make-ert-test-result--cmacro)
#@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\203A\211@\305>\203*\211AA\262\202\306>A@\2038\307\262\202\310\311@\"\210\202\210\312\313$\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms :duration)" record ert-test-result] 9 (#$ . 31027)])
(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 (#$ . 31873)])
(put 'ert-test-passed-p 'compiler-macro 'ert-test-passed-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert-test-passed-p #[257 "\301!>\205	\302\207" [cl-struct-ert-test-passed-tags type-of t] 3 (#$ . 32238)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-passed-p side-effect-free error-free put ert-test-passed cl-deftype-satisfies] 5)
#@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 (#$ . 32533)])
(put 'ert-test-passed-messages 'compiler-macro 'ert-test-passed-messages--cmacro)
#@69 Access slot "messages" of `ert-test-passed' struct CL-X.

(fn CL-X)
(defalias 'ert-test-passed-messages #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-passed-tags type-of signal wrong-type-argument ert-test-passed 1] 5 (#$ . 32983)])
(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 (#$ . 33353)])
(put 'ert-test-passed-should-forms 'compiler-macro 'ert-test-passed-should-forms--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert-test-passed-tags type-of signal wrong-type-argument ert-test-passed 2] 5 (#$ . 33823)])
(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 (#$ . 34205)])
(put 'ert-test-passed-duration 'compiler-macro 'ert-test-passed-duration--cmacro)
#@69 Access slot "duration" of `ert-test-passed' struct CL-X.

(fn CL-X)
(defalias 'ert-test-passed-duration #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-passed-tags type-of signal wrong-type-argument ert-test-passed 3] 5 (#$ . 34655)])
(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\203A\211@\305>\203*\211AA\262\202\306>A@\2038\307\262\202\310\311@\"\210\202\210\312\313\314\307\307&\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) :allow-other-keys nil error "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 (#$ . 35080)])
(put 'make-ert-test-passed 'compiler-macro 'make-ert-test-passed--cmacro)
#@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\203A\211@\305>\203*\211AA\262\202\306>A@\2038\307\262\202\310\311@\"\210\202\210\312\313$\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms :duration)" record ert-test-passed] 9 (#$ . 35872)])
(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 (#$ . 36714)])
(put 'ert-test-result-with-condition-p 'compiler-macro 'ert-test-result-with-condition-p--cmacro)
#@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 (#$ . 37169)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-result-with-condition-p side-effect-free error-free put ert-test-result-with-condition cl-deftype-satisfies] 5)
#@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 (#$ . 37524)])
(put 'ert-test-result-with-condition-messages 'compiler-macro 'ert-test-result-with-condition-messages--cmacro)
#@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\304D\"\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 (#$ . 38079)])
(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 (#$ . 38525)])
(put 'ert-test-result-with-condition-should-forms 'compiler-macro 'ert-test-result-with-condition-should-forms--cmacro)
#@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\304D\"\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 (#$ . 39100)])
(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 (#$ . 39557)])
(put 'ert-test-result-with-condition-duration 'compiler-macro 'ert-test-result-with-condition-duration--cmacro)
#@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\304D\"\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 (#$ . 40112)])
(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 (#$ . 40557)])
(put 'ert-test-result-with-condition-condition 'compiler-macro 'ert-test-result-with-condition-condition--cmacro)
#@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\304D\"\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 (#$ . 41117)])
(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 (#$ . 41565)])
(put 'ert-test-result-with-condition-backtrace 'compiler-macro 'ert-test-result-with-condition-backtrace--cmacro)
#@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\304D\"\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 (#$ . 42125)])
(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 (#$ . 42573)])
(put 'ert-test-result-with-condition-infos 'compiler-macro 'ert-test-result-with-condition-infos--cmacro)
#@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\304D\"\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 (#$ . 43113)])
(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\203b\211@\313>\203J\211AA\262\2027\314>A@\203Y\315\262\2027\316\317@\"\210\2027\210\320\321\322\315\315&\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) :allow-other-keys nil error "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 (#$ . 43619)])
(put 'make-ert-test-result-with-condition 'compiler-macro 'make-ert-test-result-with-condition--cmacro)
#@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\203t\211@\312>\203\\\211AA\262\202I\313>A@\203k\306\262\202I\314\315@\"\210\202I\210\316\317&\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) :allow-other-keys error "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-result-with-condition] 15 (#$ . 44811)])
(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 (#$ . 45989)])
(put 'ert-test-quit-p 'compiler-macro 'ert-test-quit-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert-test-quit-p #[257 "\301!>\205	\302\207" [cl-struct-ert-test-quit-tags type-of t] 3 (#$ . 46342)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-quit-p side-effect-free error-free put ert-test-quit cl-deftype-satisfies] 5)
#@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 (#$ . 46629)])
(put 'ert-test-quit-messages 'compiler-macro 'ert-test-quit-messages--cmacro)
#@67 Access slot "messages" of `ert-test-quit' struct CL-X.

(fn CL-X)
(defalias 'ert-test-quit-messages #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 1] 5 (#$ . 47065)])
(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 (#$ . 47425)])
(put 'ert-test-quit-should-forms 'compiler-macro 'ert-test-quit-should-forms--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 2] 5 (#$ . 47881)])
(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 (#$ . 48253)])
(put 'ert-test-quit-duration 'compiler-macro 'ert-test-quit-duration--cmacro)
#@67 Access slot "duration" of `ert-test-quit' struct CL-X.

(fn CL-X)
(defalias 'ert-test-quit-duration #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 3] 5 (#$ . 48689)])
(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 (#$ . 49049)])
(put 'ert-test-quit-condition 'compiler-macro 'ert-test-quit-condition--cmacro)
#@68 Access slot "condition" of `ert-test-quit' struct CL-X.

(fn CL-X)
(defalias 'ert-test-quit-condition #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 4] 5 (#$ . 49490)])
(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 (#$ . 49853)])
(put 'ert-test-quit-backtrace 'compiler-macro 'ert-test-quit-backtrace--cmacro)
#@68 Access slot "backtrace" of `ert-test-quit' struct CL-X.

(fn CL-X)
(defalias 'ert-test-quit-backtrace #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 5] 5 (#$ . 50294)])
(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 (#$ . 50657)])
(put 'ert-test-quit-infos 'compiler-macro 'ert-test-quit-infos--cmacro)
#@64 Access slot "infos" of `ert-test-quit' struct CL-X.

(fn CL-X)
(defalias 'ert-test-quit-infos #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-quit-tags type-of signal wrong-type-argument ert-test-quit 6] 5 (#$ . 51078)])
(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\203b\211@\313>\203J\211AA\262\2027\314>A@\203Y\315\262\2027\316\317@\"\210\2027\210\320\321\322\315\315&\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) :allow-other-keys nil error "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 (#$ . 51482)])
(put 'make-ert-test-quit 'compiler-macro 'make-ert-test-quit--cmacro)
#@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\203t\211@\312>\203\\\211AA\262\202I\313>A@\203k\306\262\202I\314\315@\"\210\202I\210\316\317&\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) :allow-other-keys error "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-quit] 15 (#$ . 52572)])
(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 (#$ . 53663)])
(put 'ert-test-failed-p 'compiler-macro 'ert-test-failed-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert-test-failed-p #[257 "\301!>\205	\302\207" [cl-struct-ert-test-failed-tags type-of t] 3 (#$ . 54028)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-failed-p side-effect-free error-free put ert-test-failed cl-deftype-satisfies] 5)
#@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 (#$ . 54323)])
(put 'ert-test-failed-messages 'compiler-macro 'ert-test-failed-messages--cmacro)
#@69 Access slot "messages" of `ert-test-failed' struct CL-X.

(fn CL-X)
(defalias 'ert-test-failed-messages #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 1] 5 (#$ . 54773)])
(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 (#$ . 55143)])
(put 'ert-test-failed-should-forms 'compiler-macro 'ert-test-failed-should-forms--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 2] 5 (#$ . 55613)])
(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 (#$ . 55995)])
(put 'ert-test-failed-duration 'compiler-macro 'ert-test-failed-duration--cmacro)
#@69 Access slot "duration" of `ert-test-failed' struct CL-X.

(fn CL-X)
(defalias 'ert-test-failed-duration #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 3] 5 (#$ . 56445)])
(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 (#$ . 56815)])
(put 'ert-test-failed-condition 'compiler-macro 'ert-test-failed-condition--cmacro)
#@70 Access slot "condition" of `ert-test-failed' struct CL-X.

(fn CL-X)
(defalias 'ert-test-failed-condition #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 4] 5 (#$ . 57270)])
(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 (#$ . 57643)])
(put 'ert-test-failed-backtrace 'compiler-macro 'ert-test-failed-backtrace--cmacro)
#@70 Access slot "backtrace" of `ert-test-failed' struct CL-X.

(fn CL-X)
(defalias 'ert-test-failed-backtrace #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 5] 5 (#$ . 58098)])
(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 (#$ . 58471)])
(put 'ert-test-failed-infos 'compiler-macro 'ert-test-failed-infos--cmacro)
#@66 Access slot "infos" of `ert-test-failed' struct CL-X.

(fn CL-X)
(defalias 'ert-test-failed-infos #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-failed-tags type-of signal wrong-type-argument ert-test-failed 6] 5 (#$ . 58906)])
(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\203b\211@\313>\203J\211AA\262\2027\314>A@\203Y\315\262\2027\316\317@\"\210\2027\210\320\321\322\315\315&\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) :allow-other-keys nil error "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 (#$ . 59322)])
(put 'make-ert-test-failed 'compiler-macro 'make-ert-test-failed--cmacro)
#@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\203t\211@\312>\203\\\211AA\262\202I\313>A@\203k\306\262\202I\314\315@\"\210\202I\210\316\317&\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) :allow-other-keys error "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-failed] 15 (#$ . 60424)])
(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 (#$ . 61527)])
(put 'ert-test-skipped-p 'compiler-macro 'ert-test-skipped-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert-test-skipped-p #[257 "\301!>\205	\302\207" [cl-struct-ert-test-skipped-tags type-of t] 3 (#$ . 61898)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-skipped-p side-effect-free error-free put ert-test-skipped cl-deftype-satisfies] 5)
#@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 (#$ . 62197)])
(put 'ert-test-skipped-messages 'compiler-macro 'ert-test-skipped-messages--cmacro)
#@70 Access slot "messages" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(defalias 'ert-test-skipped-messages #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 1] 5 (#$ . 62654)])
(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 (#$ . 63029)])
(put 'ert-test-skipped-should-forms 'compiler-macro 'ert-test-skipped-should-forms--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 2] 5 (#$ . 63506)])
(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 (#$ . 63893)])
(put 'ert-test-skipped-duration 'compiler-macro 'ert-test-skipped-duration--cmacro)
#@70 Access slot "duration" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(defalias 'ert-test-skipped-duration #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 3] 5 (#$ . 64350)])
(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 (#$ . 64725)])
(put 'ert-test-skipped-condition 'compiler-macro 'ert-test-skipped-condition--cmacro)
#@71 Access slot "condition" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(defalias 'ert-test-skipped-condition #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 4] 5 (#$ . 65187)])
(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 (#$ . 65565)])
(put 'ert-test-skipped-backtrace 'compiler-macro 'ert-test-skipped-backtrace--cmacro)
#@71 Access slot "backtrace" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(defalias 'ert-test-skipped-backtrace #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 5] 5 (#$ . 66027)])
(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 (#$ . 66405)])
(put 'ert-test-skipped-infos 'compiler-macro 'ert-test-skipped-infos--cmacro)
#@67 Access slot "infos" of `ert-test-skipped' struct CL-X.

(fn CL-X)
(defalias 'ert-test-skipped-infos #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert-test-skipped-tags type-of signal wrong-type-argument ert-test-skipped 6] 5 (#$ . 66847)])
(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\203b\211@\313>\203J\211AA\262\2027\314>A@\203Y\315\262\2027\316\317@\"\210\2027\210\320\321\322\315\315&\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) :allow-other-keys nil error "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 (#$ . 67269)])
(put 'make-ert-test-skipped 'compiler-macro 'make-ert-test-skipped--cmacro)
#@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\203t\211@\312>\203\\\211AA\262\202I\313>A@\203k\306\262\202I\314\315@\"\210\202I\210\316\317&\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) :allow-other-keys error "Keyword argument %s not one of (:messages :should-forms :duration :condition :backtrace :infos)" record ert-test-skipped] 15 (#$ . 68377)])
(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 (#$ . 69486)])
(put 'ert-test-aborted-with-non-local-exit-p 'compiler-macro 'ert-test-aborted-with-non-local-exit-p--cmacro)
#@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 (#$ . 69977)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert-test-aborted-with-non-local-exit-p side-effect-free error-free put ert-test-aborted-with-non-local-exit cl-deftype-satisfies] 5)
#@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 (#$ . 70357)])
(put 'ert-test-aborted-with-non-local-exit-messages 'compiler-macro 'ert-test-aborted-with-non-local-exit-messages--cmacro)
#@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\304D\"\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 (#$ . 70954)])
(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 (#$ . 71430)])
(put 'ert-test-aborted-with-non-local-exit-should-forms 'compiler-macro 'ert-test-aborted-with-non-local-exit-should-forms--cmacro)
#@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\304D\"\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 (#$ . 72047)])
(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 (#$ . 72535)])
(put 'ert-test-aborted-with-non-local-exit-duration 'compiler-macro 'ert-test-aborted-with-non-local-exit-duration--cmacro)
#@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\304D\"\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 (#$ . 73132)])
(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\203A\211@\305>\203*\211AA\262\202\306>A@\2038\307\262\202\310\311@\"\210\202\210\312\313\314\307\307&\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) :allow-other-keys nil error "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 (#$ . 73683)])
(put 'make-ert-test-aborted-with-non-local-exit 'compiler-macro 'make-ert-test-aborted-with-non-local-exit--cmacro)
#@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\203A\211@\305>\203*\211AA\262\202\306>A@\2038\307\262\202\310\311@\"\210\202\210\312\313$\207" [plist-member :messages :should-forms :duration (nil 0) (:messages :should-forms :duration :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:messages :should-forms :duration)" record ert-test-aborted-with-non-local-exit] 9 (#$ . 74602)])
(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 (#$ . 75570)])
(put 'ert--test-execution-info-p 'compiler-macro 'ert--test-execution-info-p--cmacro)
#@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 (#$ . 75989)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert--test-execution-info-p side-effect-free error-free put ert--test-execution-info cl-deftype-satisfies] 5)
#@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 (#$ . 76320)])
(put 'ert--test-execution-info-test 'compiler-macro 'ert--test-execution-info-test--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 1] 5 (#$ . 76813)])
(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 (#$ . 77216)])
(put 'ert--test-execution-info-result 'compiler-macro 'ert--test-execution-info-result--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 2] 5 (#$ . 77719)])
(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 (#$ . 78128)])
(put 'ert--test-execution-info-exit-continuation 'compiler-macro 'ert--test-execution-info-exit-continuation--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 3] 5 (#$ . 78686)])
(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 (#$ . 79128)])
(put 'ert--test-execution-info-next-debugger 'compiler-macro 'ert--test-execution-info-next-debugger--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 4] 5 (#$ . 79666)])
(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 (#$ . 80097)])
(put 'ert--test-execution-info-ert-debug-on-error 'compiler-macro 'ert--test-execution-info-ert-debug-on-error--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--test-execution-info-tags type-of signal wrong-type-argument ert--test-execution-info 5] 5 (#$ . 80660)])
(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\203W\211@\312>\203?\211AA\262\202,\313>A@\203N\314\262\202,\315\316@\"\210\202,\210\317\320\321\314	\314				&\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) :allow-other-keys nil error "Keyword argument %s not one of (:test :result :exit-continuation :next-debugger :ert-debug-on-error)" cl--defsubst-expand (test result exit-continuation next-debugger ert-debug-on-error) (cl-block make-ert--test-execution-info (record 'ert--test-execution-info test result exit-continuation next-debugger ert-debug-on-error))] 17 (#$ . 81169)])
(put 'make-ert--test-execution-info 'compiler-macro 'make-ert--test-execution-info--cmacro)
#@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\203i\211@\311>\203Q\211AA\262\202>\312>A@\203`\303\262\202>\313\314@\"\210\202>\210\315\316&)\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) :allow-other-keys error "Keyword argument %s not one of (:test :result :exit-continuation :next-debugger :ert-debug-on-error)" record ert--test-execution-info] 12 (#$ . 82344)])
(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\211\203\211A\262\242\202\304\305\306GD\"\211\307\267\202\376\310\311!>\204,\304\312\313D\"\210\314H\"\202@\211@\211\315=\203B\315\202M\211\316=\203L\317\202M\320\262\321	!A\322\n!\311!>\204g\304\312\313\nD\"\210\211\323\324\267\202\241\325\326\327\211\330\n\n&\202\253\325\316\327\211\330\n\n&\202\253\325\331\327\211\330\n\n&\202\253\332\333\334#\205\253\327I\266T\311!>\204\302\304\312\313\nD\"\210\335H\203\343\310\311	!>\204\333\304\312\313D\"\210\314H\"\210\311!>\204\364\304\312\313\nD\"\210\336H \266\204\202\332\333\337#\205\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 52)) 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 113 skipped 129 failed 145)) 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)] 19 (#$ . 83486)])
#@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\311D\"\210\211\211\312	I\266\306!>\204%\307\310\311D\"\210\211\211\313\nI\266\3142\273\315\316!r\211q\210\317\320\321\322\323!\324\"\325$\216\326 \317\320\327\322\323!\330\"\325$\216\317\331\332\322\323!\333\"\312\334%\335\211\336\211%\306\211!>\204y\307\310\311D\"\210\337H!&>\204\235\307\310\340\306!>\204\227\307\310\311D\"\210\337HD\"\210\306!>\204\254\307\310\311D\"\210\337H\341H \210.\210*\210\342 0\210\306!>\204\313\307\310\311D\"\210\211\211\325\343\344\336\211\320$I\266\336\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*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 current-window-configuration "\301\300!\207" [set-window-configuration] 128 "\301\300\"\207" [ert--run-test-debugger] "\n\n(fn &rest ARGS)" t nil 1 ert-test 3 ert-pass record ert-test-passed debug-on-error cl-struct-ert-test-tags] 10 (#$ . 85206)])
#@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!\205e\212db\210[y\210`)\304|)\266\202)\207" [message-log-max inhibit-read-only messages-buffer natnump t] 4 (#$ . 86512)])
#@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 (#$ . 86860))
#@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\307D\"\210\211\211\310\311I\266\3122nr\313 q\210\314 )\315\316\317\320\321!\322\"\323$\216\324\325\326\327\330\311\211\316$\331\332&\311C\315\316\333\320\321$\334\"\335$\216\315\336\337\320\321!\340\"\310\341%\342	B\343!,\266\202)\2620\210\304!>\204~\305\306\307D\"\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-byte-code 0 "\300\301\211\223\207" vconcat vector [nil] 3 make-ert--test-execution-info :test :result record ert-test-aborted-with-non-local-exit :exit-continuation #[0 "\300\301\302\"\207" [throw --cl-block-error-- nil] 3] "\306\302!\f>\204\307\310\311\302D\"\210\302\312H\306!
>\204!\307\310\313D\"\210\211\211\314r\315 q\210\301d{)I\266\316 \210\303\211\242\237\240\210\306!
>\204H\307\310\313D\"\210\211\211\312\303\242I\266\306\300!>\204`\307\310\317\300D\"\210\300\211\320I\262\207" [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] 6 257 "\300\300\242B\240\207" [] "\n\n(fn FORM-DESCRIPTION)" t ert--run-test-internal] 13 (#$ . 87206)])
#@48 Return the top-level test currently executing.
(defalias 'ert-running-test #[0 "\301!@\207" [ert--running-tests last] 2 (#$ . 88732)])
#@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\204\303\207\211\304\267\202,\305\207\306!>\205\300\305\207\306!	>\205\300\305\207\306!\n>\205\300\305\207\211:\203\271\211@A\211\211\307\267\202\255G\310\311\"\203J\305\202[\312@\"\205[\312\313AB\"\262\202\266G\310\311\"\203m\303\202~\312@\"\206~\312\314AB\"\262\202\266\310G\315\"\204\217\316\317!\210\312@\"?\202\266\310G\315\"\204\245\316\320!\210@!\202\266\321\322\323#\205\266\303\266\202\207\211\321\324\"\262\207" [cl-struct-ert-test-failed-tags cl-struct-ert-test-passed-tags cl-struct-ert-test-skipped-tags nil #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 12 :failed 14 :passed 24 :skipped 34)) t type-of #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (and 61 or 96 not 131 satisfies 153)) eql 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'"] 11 (#$ . 88875)])
#@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\306D\"\210\307H\"\207" [cl-struct-ert-test-tags ert-test-result-type-p :skipped type-of signal wrong-type-argument ert-test 5] 8 (#$ . 90425)])
#@1659 Return a list of tests that match SELECTOR.

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

Valid SELECTORs:

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

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

(fn SELECTOR UNIVERSE)
(defalias 'ert-select-tests #[514 "\204\301\207\302\267\202D\211<\203\207\211\303=\203\304\305\"\207\211\306\307\"\207\304\310\311D\"\207\304\310\312D\"\207\304\310\313D\"\207\304\310\314D\"\207\304\315\"\207;\203s\211\303=\203W\316\317\320\321\"\"\207\211<\203m\322\323\324\325\326\327!\330\"\331\332%\"\207\211\306\307\"\207\333!>\203~C\2079\203\222\321!\204\215\334\335!\210\317!C\207:\203q@A\211\211\336\267\202e\316\337\"\202n\340G\341\"\204\266\334\342!\210\304\343B\"\202nG\340\344\"\203\321\304\303\"\202\335\304\345AB\304@	\"\"\262\202n\340G\341\"\204\356\334\346!\210\304\303\"\347\304@\"\"\262\202nG\340\344\"\203\304\301\"\202\"\350\304@\"\304\351AB	\"\"\262\202n\340G\341\"\2043\334\352!\210@\304\310\323\324\353\326\327!\354\"\355\332%D\"\262\202n\340G\341\"\204Y\334\356!\210\322@\304\303\"\"\202n\306\357\360#\205n\301\266\202\207\306\307\"\207" [cl-struct-ert-test-tags nil #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (t 12 :new 35 :failed 42 :passed 49 :expected 56 :unexpected 63)) t ert-select-tests "" error #1="No clause matching `%S'" satisfies #[257 "\301!>\204\302\303\304D\"\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\305D\"\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\305D\"\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\305D\"\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-byte-code 257 "\302!	>\204\303\304\305D\"\210\211\306H\205-\307\300\310\302!	>\204(\303\304\305D\"\210\306H!\"\207" vconcat vector [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 cl--assertion-failed (ert-test-boundp selector) #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (member 163 eql 170 and 192 not 226 or 256 tag 295 satisfies 333)) #[257 "\2119\203\301!\204\302\303!\210\304!\207\305!>\203\207\211\306\307\"\207" [cl-struct-ert-test-tags ert-test-boundp cl--assertion-failed (ert-test-boundp purported-test) ert-get-test type-of error #1#] 5 "\n\n(fn PURPORTED-TEST)"] eql 1 (eql (length operands) 1) member 0 and (eql (length operands) 1) cl-set-difference cl-union or (eql (length operands) 1) "\300\302!	>\204\303\304\305D\"\210\306H\235\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 6] 6 (eql (length operands) 1) "cl-ecase failed: %s, %s" (member eql and not or tag satisfies)] 15 (#$ . 90750)])
#@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\303\304\305!\306\"\307\310%\240\210\311\312\242!\"c\207" [nil make-byte-code 257 "\211;\203\207\2119\203\f\207\302!	>\203F\302!	>\204#\303\304\305D\"\210\211\306H\203B\307\310\311\302!	>\204<\303\304\305D\"\210\306H\"!\207\307\312!\207\211:\203i\211@A\211\211\313\267\202e\211\314\300\242\"B\202f\202f\315\266\202\207\211\316\317\"\207" vconcat vector [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 97 tag 97)) mapcar nil error "No clause matching `%S'"] 9 "\n\n(fn SELECTOR)" format "%S"] 9 (#$ . 95489)])
#@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 (#$ . 96390)])
(put 'ert--stats-p 'compiler-macro 'ert--stats-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert--stats-p #[257 "\301!>\205	\302\207" [cl-struct-ert--stats-tags type-of t] 3 (#$ . 96725)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert--stats-p side-effect-free error-free put ert--stats cl-deftype-satisfies] 5)
#@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 (#$ . 97000)])
(put 'ert--stats-selector 'compiler-macro 'ert--stats-selector--cmacro)
#@64 Access slot "selector" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-selector #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 1] 5 (#$ . 97415)])
(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 (#$ . 97760)])
(put 'ert--stats-tests 'compiler-macro 'ert--stats-tests--cmacro)
#@61 Access slot "tests" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-tests #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 2] 5 (#$ . 98160)])
(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 (#$ . 98496)])
(put 'ert--stats-test-map 'compiler-macro 'ert--stats-test-map--cmacro)
#@64 Access slot "test-map" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-test-map #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 3] 5 (#$ . 98911)])
(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 (#$ . 99256)])
(put 'ert--stats-test-results 'compiler-macro 'ert--stats-test-results--cmacro)
#@68 Access slot "test-results" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-test-results #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 4] 5 (#$ . 99691)])
(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 (#$ . 100048)])
(put 'ert--stats-test-start-times 'compiler-macro 'ert--stats-test-start-times--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 5] 5 (#$ . 100504)])
(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 (#$ . 100874)])
(put 'ert--stats-test-end-times 'compiler-macro 'ert--stats-test-end-times--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 6] 5 (#$ . 101320)])
(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 (#$ . 101684)])
(put 'ert--stats-passed-expected 'compiler-macro 'ert--stats-passed-expected--cmacro)
#@71 Access slot "passed-expected" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-passed-expected #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 7] 5 (#$ . 102135)])
(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 (#$ . 102502)])
(put 'ert--stats-passed-unexpected 'compiler-macro 'ert--stats-passed-unexpected--cmacro)
#@73 Access slot "passed-unexpected" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-passed-unexpected #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 8] 5 (#$ . 102963)])
(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 (#$ . 103336)])
(put 'ert--stats-failed-expected 'compiler-macro 'ert--stats-failed-expected--cmacro)
#@71 Access slot "failed-expected" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-failed-expected #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 9] 5 (#$ . 103787)])
(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 (#$ . 104154)])
(put 'ert--stats-failed-unexpected 'compiler-macro 'ert--stats-failed-unexpected--cmacro)
#@73 Access slot "failed-unexpected" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-failed-unexpected #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 10] 5 (#$ . 104616)])
(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 (#$ . 104990)])
(put 'ert--stats-skipped 'compiler-macro 'ert--stats-skipped--cmacro)
#@63 Access slot "skipped" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-skipped #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 11] 5 (#$ . 105402)])
(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 (#$ . 105746)])
(put 'ert--stats-start-time 'compiler-macro 'ert--stats-start-time--cmacro)
#@66 Access slot "start-time" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-start-time #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 12] 5 (#$ . 106173)])
(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 (#$ . 106526)])
(put 'ert--stats-end-time 'compiler-macro 'ert--stats-end-time--cmacro)
#@64 Access slot "end-time" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-end-time #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 13] 5 (#$ . 106943)])
(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 (#$ . 107290)])
(put 'ert--stats-aborted-p 'compiler-macro 'ert--stats-aborted-p--cmacro)
#@65 Access slot "aborted-p" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-aborted-p #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 14] 5 (#$ . 107712)])
(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 (#$ . 108062)])
(put 'ert--stats-current-test 'compiler-macro 'ert--stats-current-test--cmacro)
#@68 Access slot "current-test" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-current-test #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 15] 5 (#$ . 108499)])
(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 (#$ . 108858)])
(put 'ert--stats-next-redisplay 'compiler-macro 'ert--stats-next-redisplay--cmacro)
#@70 Access slot "next-redisplay" of `ert--stats' struct CL-X.

(fn CL-X)
(defalias 'ert--stats-next-redisplay #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 16] 5 (#$ . 109305)])
(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\310\211@\335>\203\260\211AA\262\202\235\336>A@\203\277\337\262\202\235\340\341@\"\210\202\235\210\342\343\344\337\337&\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) :allow-other-keys nil error "Keyword argument %s not one of (:selector :tests :test-map :test-results :test-start-times :test-end-times :passed-expected :passed-unexpected :failed-expected :failed-unexpected :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 (#$ . 109720)])
(put 'make-ert--stats 'compiler-macro 'make-ert--stats--cmacro)
#@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\354\211@\331>\203\324\211AA\262\202\301\332>A@\203\343\302\262\202\301\333\334@\"\210\202\301\210\335\336&\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) :allow-other-keys error "Keyword argument %s not one of (:selector :tests :test-map :test-results :test-start-times :test-end-times :passed-expected :passed-unexpected :failed-expected :failed-unexpected :skipped :start-time :end-time :aborted-p :current-test :next-redisplay)" record ert--stats] 35 (#$ . 112071)])
(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\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210\306H\\\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 7 9] 6 (#$ . 114418)])
#@78 Return the number of tests in STATS that had unexpected results.

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

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

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

(fn STATS)
(defalias 'ert-stats-total #[257 "\301!>\204\302\303\304D\"\210\211\305HG\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 2] 5 (#$ . 115527)])
(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\304D\"\210\211\305H\206\211\207" [cl-struct-ert-test-tags type-of signal wrong-type-argument ert-test 1] 5 (#$ . 115827)])
#@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\304D\"\210\305H\301!>\204#\302\303\304D\"\210\306HH\301!>\204:\302\303\304	D\"\210\307H\310\211		\311%\210\nI\266	I\266\312\313!\"\210\313!\314#\266\211		\315%\210\316\262\207" [cl-struct-ert--stats-tags type-of signal wrong-type-argument ert--stats 2 4 3 #[1285 "\306HH\"\203\256H\307!>\2036\307!	>\204(\310\311\312D\"\210\211\313\313H\\I\262\202\255\307!\n>\203]\307!	>\204O\310\311\312D\"\210\211\314\314H\\I\262\202\255\307!>\203\204\307!	>\204v\310\311\312D\"\210\211\315\315H\\I\262\202\255\211\204\214\316\202\255\307!\f>\203\230\316\202\255\307!
>\203\244\316\202\255\317\320\321#\205\255\316\207H\307!>\203\330\307!	>\204\312\310\311\312D\"\210\211\322\322H\\I\262\202O\307!\n>\203\377\307!	>\204\361\310\311\312D\"\210\211\323\323H\\I\262\202O\307!>\203&\307!	>\204\310\311\312D\"\210\211\315\315H\\I\262\202O\211\204.\316\202O\307!\f>\203:\316\202O\307!
>\203F\316\202O\317\320\324#\205O\316\207" [cl-struct-ert-test-passed-tags cl-struct-ert--stats-tags cl-struct-ert-test-failed-tags cl-struct-ert-test-skipped-tags cl-struct-ert-test-aborted-with-non-local-exit-tags cl-struct-ert-test-quit-tags ert-test-result-expected-p type-of signal wrong-type-argument ert--stats 7 9 11 nil error "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-failed ert-test-skipped null ert-test-aborted-with-non-local-exit ert-test-quit) 8 10 (ert-test-passed ert-test-failed ert-test-skipped null ert-test-aborted-with-non-local-exit ert-test-quit)] 11 "\n\n(fn STATS POS TESTS RESULTS D)"] -1 remhash ert--stats-test-key puthash 1 nil] 15 (#$ . 116167)])
#@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\303G\"\304\305\306\211T\211\262GW\203CH\262\307!\262\310\"\2031\311\312!\210\211\313#\266T\262\202\266\314\315\316\317\320\321G\306\"\322\321
G\306\"\323\321G\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 (#$ . 118112)])
#@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\311D\"\210\211\312I\266\313#\210\306!\n>\204?\307\310\314D\"\210\211\315\305I\266\306!	>\204V\307\310\311D\"\210\316H\317 I\266\320\321\322\323\324			$\325\"\326$\216\327!*\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-byte-code 0 "\306\300!\f>\204\307\310\311\300D\"\210\300\312H\303\313 I\266\306\301!
>\204)\307\310\314\301D\"\210\301\315H\306!>\204<\307\310\316D\"\210\211\211\317\320\321\306\300!\f>\204P\307\310\311\300D\"\210\300\312H\303H\306\300!\f>\204d\307\310\311\300D\"\210\300\322H\303H\"!I\266\323\300\303\301$\210\302\324\300\301$\266\306\300!\f>\204\214\307\310\311\300D\"\210\300\211\325\326I\207" vconcat vector [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] 11 ert-run-test] 14 (#$ . 118767)])
#@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\312D\"\210\211\211\313\314 I\266\315\"\210\305C\316\216\317 \210\320\321\322\323\324	#\325\"\326$\216\3272\211\330:\203\203@\262\331	#\210\203|\307\211!\n>\204h\310\311\332D\"\210\326H!>\203|\333\334!\203|\335\327\330\"\210A\262\202D\330\240\266\2020\210+\262\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-byte-code 0 "\304\301!>\204\305\306\307\301D\"\210\301\211\310\302\242I\266\304\301!>\204&\305\306\307\301D\"\210\301\211\311\312 I\266\300\313\301\302\242#\207" vconcat vector [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 y-or-n-p "Abort testing? " throw] 14 (#$ . 120111)])
#@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\306D\"\210\307H\"\207" [cl-struct-ert--stats-tags gethash ert--stats-test-key type-of signal wrong-type-argument ert--stats 3] 8 (#$ . 121292)])
#@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 (#$ . 121603)])
#@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 (#$ . 121803)])
#@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 (#$ . 122572)])
#@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 "`\301\302p\"\210n\204\303c\210\212\211b\210\304 *\207" [pp-escape-newlines nil pp "\n" indent-sexp] 5 (#$ . 123432)])
#@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\304D\"\210\211\306H\211\205\202\211@\211\211\2036\211A\262\242\202=\302\307\310GD\"`\311G\312\\\313\"\314C\315\316\317\320\321!\322\"\323$\216\324\261\210\211\325 \240\210b\210\326\261\210\327y\210`\242W\203xc\210\327y\210\202h)\266A\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-byte-code 0 "\300\242\205\n\300\242\301\211\223\207" vconcat vector [nil] 3 "\n" point-marker "    " 1] 14 (#$ . 123732)])
#@67 Non-nil makes ERT only print important information in batch mode.
(defvar ert-quiet nil (#$ . 124549))
#@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\305\306!\307\"\310\311%\312#\207" [t ert-run-tests make-byte-code 385 "\306\267\202\367	?\205\211\211G\307U\203\211@\202\310\311\312GD\"\313\314\315!\n>\2040\310\316\317D\"\210\320HG\321\315!\n>\204E\310\316\317D\"\210\322H!\300\242$\207\211\211G\320U\203^\211A\262\242\202e\310\311\323GD\"@\324!\325!\315!\n>\204}\310\316\317D\"\210\326H\313\327\204\212\330\202\213\331\332!\333	!\334U\203\240\330\202\245\335\336	\"\321\315
!\n>\204\267\310\316\317D\"\210\f\337H!\340\341\315!\n>\204\317\310\316\317D\"\210\337H\315!\n>\204\344\310\316\317D\"\210\322H\"!	\334U\203\365\330\202\372\335\342\"&	\210\334U\204n\313\343\"\210\315!\n>\204\310\316\317D\"\210\320H\344\345\211T\211\262GW\203gH\262\315!>\204=\310\316\346D\"\210\347H\262\350\"\204\313\351\352\345\"\315!>\204_\310\316\346D\"\210\307H#\210\202\266\313\353\330\"\210\334U?\205\337\313\354\"\210\315!\n>\204\212\310\316\317D\"\210\320H\344\345\211T\211\262GW\203\331H\262\315!>\204\257\310\316\346D\"\210\347H\262\355\356\"\203\220\313\351\352\345\"\315!>\204\321\310\316\346D\"\210\307H#\210\202\220\266\313\353\330\"\266\203\207\345\207\211\211G\357U\203\365\211A\262\242\202\374\310\311\360GD\"\211A\262\242@\350\"\204\203\315!\f>\203-\313\361\315!>\204%\310\316\346D\"\210\307H\"\210\202\203\315!
>\203-\313\362\315!>\204G\310\316\346D\"\210\307H\"\210\363\364!r\211q\210\365\334\366\367\370!\371\"\320$\216\372\315!
>\204o\310\316\373D\"\210\374H!c\210@\204\205\313\353\375ed\"\"\210\202\246eb\210m\204\246`\376 \211@\\^\262\313\353\375\"\"\266\307y\210\202\210*\210\363\364!r\211q\210\365\334\366\367\370!\377\"\320$\216\201G!\210\201Hc\210\201I\374\201JABC\201K\315!
>\204\345\310\316\373D\"\210\347H!\210+dSb\210\201L\201M!\204\201N\201O!\210\201P\307!\210\313\201Q\315!>\204\310\316\346D\"\210\307H\"\210\313\353\201R \"\210*\210\202\203\315!D>\203R\313\201S\315!>\204J\310\316\346D\"\210\307H\"\210\202\203\315!E>\203w\313\201T\315!>\204o\310\316\346D\"\210\307H\"\210\202\203\201U\201V\201W#\210	?\205\366\201X\315!\n>\204\233\310\316\317D\"\210\320HG!\201Y\201XG!\201Z\201[\260\313\352\350\"\"\201\\\"T\315!>\204\327\310\316\346\nD\"\210\307H\315!F>\204\357\310\316\201]\nD\"\210\357H%\266\202\207\201U\201^\201_#\205\345\207" vconcat vector [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 77 test-started 482 test-ended 484)) 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" ert-string-for-test-result "%s" "%s skipped results:" ert-test-result-type-p :skipped 3 (stats test result) "Test %S passed unexpectedly" "Test %S backtrace:" generate-new-buffer " *temp*" make-byte-code "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] backtrace-to-string ert-test-result-with-condition 5 buffer-substring-no-properties line-end-position [buffer-name kill-buffer] ert-batch-backtrace-right-margin print-length print-level 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 ert--insert-infos "    " t 10 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)" ert--stats-test-pos ert-test-result "cl-ecase failed: %s, %s" (run-started run-ended test-started test-ended)] 23 "\n\n(fn EVENT-TYPE &rest EVENT-ARGS)" nil] 10 (#$ . 124659)])
#@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\211\306\216\307!\310\311!\312U\203\312\202\313!\262)\207" [noninteractive attempt-stack-overflow-recovery attempt-orderly-shutdown-on-fatal-signal user-error "This function is only for use in batch mode" nil #[0 "\300\216\301\302!\210\303 )\207" [#[0 "\300\301!\207" [kill-emacs 2] 2] message "Error running tests" backtrace] 2] ert-run-tests-batch kill-emacs ert-stats-completed-unexpected 0 1] 6 (#$ . 129598)])
#@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\211G\307\211\211\211\211\310\211\211\211\211\211\211\311\312!r\211q\210\313\307\314\315\316!\317\"\320$\216\211A\242\211\262\203\372\321 \210\322!\203P\323!\210\324\325\310\326#\204bB\262\2026\f\327\330\331!!\\\262
\324\332\310\326#\204}B\262\2026\330\331!\203\211B\262\327\330\320!!\\\262\f\n\327\330\333!!\\\262\330\334!\203\273\327\330\334!!\211\307U\204\272B\262\n\\\262\210\330\335!\203\321B\262\327\330\335!!\\\262	\307U\2046eb\210`dW\2036\336\337!\203\364\327\330\331!!\330\307!BB\262\310y\210\202\333*\210Z\262\340\341!\210\340\342!\210\340\343\"\210\340\344\f	\307U\203 \345\202%\346\347\"


&\210\203?\340\350G\"\210\351\352\"\210\203\212\340\353G\"\210\351\354\"\210\355\356!\203\212\311\312!r\211q\210\313\307\314\315\316!\357\"\320$\216\211\203\207\211@\321 \210\323!\210\340\360\"\210\340\361\362 \"\210A\266\202\202h\210*\210\203\231\340\363G\"\210\351\364\"\210\211\203\313
\307U\204\313\340\365!\210\340\366!\210\367\370\"\262
GW\203\302
S\233\310\241\210\340\371\372\373\374#\"\210\355\356!\2033\\\307U\2043\340\375!\210\340\376!\210\311\312!r\211q\210\313\307\314\315\316!\377\"\320$\216\201@\201AE\201B\201CED\211\2030\211@\351\313\201D\201E\315\316!\201F\"\201G\201H%@\"\210A\266\202\202\210*\210\201I\204E\204E\307U\204I\320\202R\203Q\331\202R\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 generate-new-buffer " *temp*" make-byte-code "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 erase-buffer file-readable-p insert-file-contents re-search-forward "^Running \\([0-9]+\\) tests" t string-to-number match-string 1 "^\\(Aborted: \\)?Ran \\([0-9]+\\) tests, \\([0-9]+\\) results as expected\\(?:, \\([0-9]+\\) unexpected\\)?\\(?:, \\([0-9]+\\) skipped\\)?" 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)"] getenv "EMACS_HYDRA_CI" [buffer-name kill-buffer] "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" "------------------" sort #[514 "@@V\207" [] 4 "\n\n(fn X Y)"] "%s" mapconcat cdr "\n" "\nDETAILS" "-------" [buffer-name kill-buffer] "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" [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] 25 (#$ . 130390)])
#@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 (#$ . 134134)])
#@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\2037\211@\303>\203 \211AA\262\202
\304>A@\203.\305\262\202
\306\307@\"\210\202
\210\204?\310\262\211\204F\311\262\211\312J\301\302&L\262\207" [plist-member :key :test (:key :test :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:key :test)" identity equal cl-remove] 14 (#$ . 134447)])
#@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\202Q9\203,\303!\205'\305!\262\202Q\306!>\203K\306!>\204C\307\310\311D\"\210\312H\262\202Q\313\314\315#\210\211\203g\204`\316\317\"\202e\316\320#\262\321	\303\322\304	\304&\302!\303!\203\201\211\202\204\323\324!\262\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 "%s: " "%s (default %s): " completing-read t user-error "Input does not name a test"] 13 (#$ . 135010)])
#@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 (#$ . 136038)])
#@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 (#$ . 136390) (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 (#$ . 136698) (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 (#$ . 136988) 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 (#$ . 137323)])
(put 'ert--ewoc-entry-p 'compiler-macro 'ert--ewoc-entry-p--cmacro)
#@13 

(fn CL-X)
(defalias 'ert--ewoc-entry-p #[257 "\301!>\205	\302\207" [cl-struct-ert--ewoc-entry-tags type-of t] 3 (#$ . 137689)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put ert--ewoc-entry-p side-effect-free error-free put ert--ewoc-entry cl-deftype-satisfies] 5)
#@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 (#$ . 137985)])
(put 'ert--ewoc-entry-test 'compiler-macro 'ert--ewoc-entry-test--cmacro)
#@65 Access slot "test" of `ert--ewoc-entry' struct CL-X.

(fn CL-X)
(defalias 'ert--ewoc-entry-test #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 1] 5 (#$ . 138416)])
(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 (#$ . 138775)])
(put 'ert--ewoc-entry-hidden-p 'compiler-macro 'ert--ewoc-entry-hidden-p--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 2] 5 (#$ . 139226)])
(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 (#$ . 139597)])
(put 'ert--ewoc-entry-expanded-p 'compiler-macro 'ert--ewoc-entry-expanded-p--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 3] 5 (#$ . 140058)])
(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 (#$ . 140435)])
(put 'ert--ewoc-entry-extended-printer-limits-p 'compiler-macro 'ert--ewoc-entry-extended-printer-limits-p--cmacro)
#@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\304D\"\210\211\305H\207" [cl-struct-ert--ewoc-entry-tags type-of signal wrong-type-argument ert--ewoc-entry 4] 5 (#$ . 140971)])
(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\203P\211@\310>\2038\211AA\262\202%\311>A@\203G\312\262\202%\313\314@\"\210\202%\210\315\316\317\312	\312				&	\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) :allow-other-keys nil error "Keyword argument %s not one of (:test :hidden-p :expanded-p :extended-printer-limits-p)" cl--defsubst-expand (test hidden-p expanded-p extended-printer-limits-p) (cl-block make-ert--ewoc-entry (record 'ert--ewoc-entry test hidden-p expanded-p extended-printer-limits-p))] 16 (#$ . 141448)])
(put 'make-ert--ewoc-entry 'compiler-macro 'make-ert--ewoc-entry--cmacro)
#@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\203\\\211@\310>\203D\211AA\262\2021\311>A@\203S\302\262\2021\312\313@\"\210\2021\210\314\315%\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) :allow-other-keys error "Keyword argument %s not one of (:test :hidden-p :expanded-p :extended-printer-limits-p)" record ert--ewoc-entry] 11 (#$ . 142445)])
(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 (#$ . 143413)])
#@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 (#$ . 143651)])
#@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!r\211q\210\311\312\313\314\315!\316\"\317$\216\320c\210\321\322!	>\204/\323\324\325\nD\"\210\326H!\210\327c\210\330\331\332\322\n!	>\204L\323\324\325\fD\"\210	\333H\322!	>\204a\323\324\325
D\"\210\n\334H\"\332\322!	>\204x\323\324\325
D\"\210\n\335H\322\f!	>\204\215\323\324\325D\"\210\336H\"\337!\n\340
!&c\210\330\341\342\322\n!	>\204\264\323\324\325\fD\"\210	\343H!\"c\210\322!	>\204\315\323\324\325	D\"\210\344H\203\330\345\202\322!	>\204\351\323\324\325	D\"\210\346H\203\364\347\202\322!	>\204\323\324\325	D\"\210\350H\203\351\202\352\211\353\267\202'\354c\210\202-\322!	>\204.\323\324\325\nD\"\210\346H\203\214\355c\210\356\322\211\n!	>\204K\323\324\325\fD\"\210	\346H!\n>\204p\323\324\357\322\f!	>\204i\323\324\325D\"\210\346HD\"\210\322	!	>\204\201\323\324\325D\"\210\346H\326H!\210\202-\360c\210\202-\322!	>\204\243\323\324\325\nD\"\210\346H\204\256\361\362!\210\363c\210\356\322\211\n!	>\204\304\323\324\325\fD\"\210	\346H!\n>\204\351\323\324\357\322\f!	>\204\342\323\324\325D\"\210\346HD\"\210\322	!	>\204\372\323\324\325D\"\210\346H\326H!\210\202-\322!	>\204\323\324\325\nD\"\210\346H\203!\361\364!\210\365c\210\202-\366\367\370#\210\327c\210\322!	>\204A\323\324\325\nD\"\210\350H\203\204\330\371\322\n!	>\204[\323\324\325\fD\"\210	\344H\203f\372\202g\373\342\322\f!	>\204y\323\324\325D\"\210\350H!#c\210\202\207\327c\210\327c\266rq\210)\374\375\376\377	\203\244\201@
!\206\247\201A%rq\210\201B\304!\210\211)\266\201Cc\210\201D *\262\327#\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*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [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 279 aborted 285 running 402 finished 517)) "" "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 (#$ . 143924)])
#@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 (#$ . 146999))
#@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\311D\"\210\211\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] 9 (#$ . 147273)])
#@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\306D\"\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 (#$ . 147726)])
#@69 Return a string for the mode line that shows the test run progress.
(defalias 'ert--tests-running-mode-line-indicator #[0 "\303!\304!\211Y\203\305\306#\202\210\305\307T\310!	>\204+\311\312\313	D\"\210\314H\2046\315\202\207\305\316\310\211\n!	>\204J\311\312\313\fD\"\210	\314H!\n>\204o\311\312\317\310\f!	>\204h\311\312\313D\"\210\314HD\"\210\310	!	>\204\200\311\312\313D\"\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 (#$ . 148159)])
#@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 "\212b\210`\300\\b\210\301\302!\210`W\205A`\301\303!\210`\304\305\"!\211\205'\306\307\"\211\2039b\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 (#$ . 148843)])
#@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 "\300\301\302\303\"#\207" [substring 0 cl-position 10] 7 (#$ . 149388)])
#@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 (#$ . 149635)])
#@50 Return a face that represents STATS.

(fn STATS)
(defalias 'ert-face-for-stats #[257 "\301!>\204\302\303\304D\"\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 (#$ . 149990)])
#@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\311D\"\210\211\312H	\313\"\211\204\314\315!\210\306!\n>\204.\307\310\316D\"\210\317HH\262\306!>\204E\307\310\311D\"\210\320H\306!>\204X\307\310\311D\"\210\321H\306!>\204l\307\310\311D\"\210\317H\204\206\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\206\340=\204\206\306!\f>\204\314\307\310\336D\"\210\320H\203\364\341\342\343\344\306\n!\f>\204\347\307\310\336\fD\"\210	\320H!!\345\346#\337\261\210\306!
>\203\322\"\203\n\347c\210\202
\350c\210\351c\210\202\203\306!8>\203_\352!\210\353\203)\354\202*\355\2032\356\2023\3579:;\341c\210`\360\306!8>\204P\307\310\361D\"\210\317H!\210\362`\"\266+\202\203\306!<>\203n\363c\210\202\203\306!=>\203}\364c\210\202\203\365\366\367#\210\337c\210\266\340\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" nil "    " 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) 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 (#$ . 150433)])
#@160 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 (#$ . 152595)])
#@178 Set up a test results buffer.

STATS is the stats object; LISTENER is the results listener;
BUFFER-NAME, if non-nil, is the buffer name to use.

(fn STATS LISTENER BUFFER-NAME)
(defalias 'ert--setup-results-buffer #[771 "\211\204\306\262\307!r\211q\210\310\311 \210\312 \210\313 \210\312 \210\314\301!\210\315\316\317\320\211\310$\314\302!\210\211\314\303!\210\314\304!\210\321\322!\323\320\310\"\"\314\305!\210\324!>\204Z\325\326\327D\"\210\330H\331\320T\211\262GW\203}H\262\332\333\334\310\211\320%\"\210\202_\266\335\n\"\210dSb\210\262*\207" [inhibit-read-only font-lock-function ert--results-ewoc ert--results-stats ert--results-progress-bar-string ert--results-listener "*ert*" get-buffer-create t buffer-disable-undo erase-buffer ert-results-mode make-local-variable ert--results-font-lock-function ewoc-create ert--print-test-for-ewoc nil make-string ert-stats-total ert-char-for-test-result 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] 16 (#$ . 152970)])
#@51 List of recent test selectors read from terminal.
(defvar ert--selector-history nil (#$ . 154074))
#@338 Run the tests specified by SELECTOR and display the results in a buffer.

SELECTOR works as described in `ert-select-tests'.
OUTPUT-BUFFER-NAME and MESSAGE-FN should normally be nil; they
are used for automated self-tests and specify which buffer to use
and how to display message.

(fn SELECTOR &optional OUTPUT-BUFFER-NAME MESSAGE-FN)
(defalias 'ert-run-tests-interactively #[769 "\211\204\300\262\301C\301C\302\303\304\305\306				$\307\"\310\311%\240\210\312\242\313#\207" [message nil make-byte-code 385 "\306\267\202n\211\211G\307U\203\211@\202\310\311\312GD\"\301\313\302\242\300#\240\210\314\301\242!\207\211\211G\315U\2039\211A\262\242\202@\310\311\316GD\"@\303\317\204L\320\202M\321\322!\323!\324!\211\325U\203b\320\202f\326\327\"\262\330!\211\325U\203v\320\202z\326\331\"\262&\210\332r\301\242q\210\f)\"\207\211\211G\315U\203\233\211A\262\242\202\242\310\311\333GD\"@r\301\242q\210\f\334\"\335\"\211\204\272\336\337!\210\211\315H\340!
>\204\314\310\341\342D\"\210\211\211\307I\266.\343\344\345\"I\210\346\"\210\347\"\266\203)\207\211\211G\350U\203\374\211A\262\242\202\310\311\351GD\"\211A\262\242@r\301\242q\210\f\334\"\335\"\211\315H\340!
>\204+\310\341\342D\"\210\211\315H\262\203Q\211\315H\340!
>\204E\310\341\342D\"\210\211\211\315\352		\"I\266.\343\352		\"\"I\210\346\"\210\347\"\266\203)\207\353\354\355#\205w\344\207" vconcat vector [ert--results-ewoc cl-struct-ert--ewoc-entry-tags #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (run-started 6 run-ended 40 test-started 138 test-ended 235)) 1 signal wrong-number-of-arguments (stats) ert--setup-results-buffer pop-to-buffer 2 (stats abortedp) "%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) ert--results-progress-bar-string] 16 "\n\n(fn EVENT-TYPE &rest EVENT-ARGS)" ert-run-tests t] 17 (#$ . 154180) (byte-code "\203	@\202\n\302\303\304\204\305\202\306\307\"	\310\311\211\300\311&!\262\311D\207" [ert--selector-history obarray "t" read completing-read "Run tests: " format "Run tests (default %s): " 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\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\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 (lambda (#1=#:def-tmp-var) (defvar ert-simple-view-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ert-simple-view-mode'." (lambda (#1#) (defvar ert-simple-view-mode-abbrev-table #1#)) define-abbrev-table nil "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
\325C#\210\327!\210\330\f!\210
)\331\332!\207" [delay-mode-hooks major-mode mode-name ert-simple-view-mode-map ert-simple-view-mode-syntax-table 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 (#$ . 158173) 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\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\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 (lambda (#1=#:def-tmp-var) (defvar ert-results-mode-syntax-table #1#)) make-syntax-table "Syntax table for `ert-results-mode'." (lambda (#1#) (defvar ert-results-mode-abbrev-table #1#)) define-abbrev-table nil "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
\325C#\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 (#$ . 160437) nil])
(byte-code "\301\302\211\211:\203&@\262\211A\262\242\262\211@\262\303#\210A\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 (#$ . 162366))
(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\310D\"\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 (#$ . 164011)])
#@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 (#$ . 164434)])
#@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 (#$ . 164715) nil])
#@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 (#$ . 164951) nil])
#@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\311D\"\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 (#$ . 165196)])
#@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\310D\"\210\211\211\311\305!	>\204.\306\307\310D\"\210\311H?I\266\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] 11 (#$ . 165827)])
#@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 (#$ . 166299) nil])
#@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 (#$ . 166604)])
#@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\"\210T\262\302\262\202\207" [--cl-block-nil-- 0 nil t ewoc-nth ewoc-next eql throw] 8 (#$ . 166835)])
#@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\266\202\202j\211`X\203h`\306\307!!W\203h\310`Z\"\211\311H\312!\n>\204>\313\314\315D\"\210\211\311H\203_\312!\n>\204S\313\314\315D\"\210\211\211\311\316I\266\317\"\210\320\"\266\202\202j\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 (#$ . 167153) nil])
#@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\307D\"\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 (#$ . 168014)])
#@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\316D\"\210\211\317H\262\262\202Y\n\211`X\205W`\320\321!!W\205W`Z\313!\f>\204P\314\315\322D\"\210\312HH\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 (#$ . 168458)])
#@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\n\303\202d\304!>\204\305\306\307D\"\210\211\310H\204%\211\311B\202d\304!>\2044\305\306\307D\"\210\211\310H\312!\205@\313!\314\"\203M\315B\202b\211\204W\316B\202b\317\320	\"\"\210\211\321B\266\202\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 (#$ . 169337)])
#@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\313D\"\210\211\211\314I\266\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] 13 (#$ . 170538)])
#@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 (#$ . 171167)])
#@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 (#$ . 171441)])
#@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\314 \"\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 buffer-name] 4 (#$ . 171708) nil])
#@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\211A\262\242\202\305\306\307GD\"@\204#\310\311!\210\312\313\314=\2030\315\202G\316\267\202>\317\202G\320\202G\321\322\323#\205G\314\324!	>\204X\305\325\326D\"\210\327H#`\330\331\332\333\334!\335\"\327$\216\330\331\336\333\334	#\337\"\340$\216\341\342\"\210\343\n#*\262\266\202\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" nil "" #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (redefined 54 deleted 58)) "new definition of " "deleted " error "cl-ecase failed: %s, %s" (nil redefined deleted) type-of wrong-type-argument ert-test 1 make-byte-code 0 "\300b\207" vconcat vector [] "\305\301\"\210\306\307\302\310\300!\f>\204\311\312\313\300D\"\210\300\314H\315\316\300\"\"\262#\207" [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] 14 (#$ . 172166) nil])
#@103 Re-run the test at point with `ert-debug-on-error' bound to t.

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

To be used in the ERT results buffer.
(defalias 'ert-results-pop-to-backtrace-for-test-at-point #[0 "\306\307!\310\"\311!	>\204\312\313\314D\"\210\315HH\311!\n>\203*\316\317!\202u\311!>\203l\320\321!\322!\210\323\324!\204B\324 \210\325\326\327\330\331	!\332\"\333$\311!>\204^\312\313\334D\"\210\333H\335 \210eb\262\202u\316\336\337#\205u\340\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-byte-code 0 "\302\303\300!	>\204\304\305\306\300D\"\210\300\307H!\207" vconcat vector [cl-struct-ert-test-tags ert--insert-backtrace-header type-of signal wrong-type-argument ert-test 1] 5 ert-test-result-with-condition backtrace-print "cl-etypecase failed: %s, %s" (ert-test-passed ert-test-result-with-condition) nil] 11 (#$ . 173783) nil])
#@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 (#$ . 174971)])
#@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\313D\"\210\314HH\315\316!\317!\210\306\320 \210\321 \210\322 \210\310!>\204=\311\312\323D\"\210\324Hc\210eb\210\325\326!c\210\327\310!\f>\204\\\311\312\330D\"\210\324H!\210\325\331!c)\262\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 (#$ . 175179) nil])
#@110 Display the list of `should' forms executed during the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-pop-to-should-forms-for-test-at-point #[0 "\305\306!\307\"\310!	>\204\311\312\313D\"\210\314HH\315\316!\317!\210\306\320 \210\321 \210\322 \210\310!>\204=\311\312\323D\"\210\324H\204I\325c\210\202\207\310!>\204X\311\312\323D\"\210\324H\326\327:\203\205@\262\330c\210\331\332\"c\210`\333!\210\334`\"\266A\262\211T\262\202]\266eb\210\335\336!c\210\337\310!\f>\204\241\311\312\340D\"\210\327H!\210\335\341!c\210\330c\210\342c\210\327y)\262\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 (#$ . 176083) nil])
#@105 Toggle how much of the condition to print for the test at point.

To be used in the ERT results buffer.
(defalias 'ert-results-toggle-printer-limits-for-test-at-point #[0 "\302 \211\303H\304!	>\204\305\306\307D\"\210\211\211\310\304!	>\204(\305\306\307D\"\210\310H?I\266\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] 10 (#$ . 177452) nil])
#@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\311D\"\210\312H\313\314\306!	>\204(\307\310\311D\"\210\315H\313\314\306!	>\204>\307\310\311\nD\"\210\316H\313\314\211T\211\262\n\nGW\203\215		H\262T\211\262GW\203\215H\262T\211\262GW\203\215H\262\317\320\"!DB\262\202E\211\237\266\212\321\322\"\262\323!\210\324\325 \210\326 \210\327 \210\211\204\260\330c\210\202\331\332\333\334\335$c\210\211\314\211\211\211\336\324:\203@\262\211A\262\242\262@\262\211\203\336\202\341\\\262\331\337$c\210\340\306!>\204\377\307\310\341	D\"\210\336H!\210\342c\210A\262T\262\314\262\202\277\266eb\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 (#$ . 177930) nil])
#@97 Display the documentation for TEST-OR-TEST-NAME (a symbol or ert-test).

(fn TEST-OR-TEST-NAME)
(defalias 'ert-describe-test #[257 "\306\2119\203\262\307!\262\202:\310!>\2034\310!>\204)\311\312\313D\"\210\314H\262\262\202:\315\316\317#\210\320\321D\322\323!\"\210\212	\306\211\223\210\324\nB\325B\326 \327 \330!\211\306\211r\327 q\210\203n\331\332\"\202o\333c\210\334c\210\205}\335\336\"\211\203\233\337\340\341!\"c\210\212\342\343\344!\306\345#\210\346\314\347	$\210)\350c\210\351e`\"\210\352c\210\353!\203\270\354\307!\"\204\307`\355\356\261\210\351`\"\266\352c\210\343\310!>\204\331\311\312\313	D\"\210\357H\206\341\360!\361\261\210\362 \262)\262rq\210\363\306\"\262)\364\365!\203\365\"\202\211)\266\204+\207" [cl-struct-ert-test-tags help-window-point-marker temp-buffer-window-setup-hook temp-buffer-window-show-hook help-window-old-frame standard-output 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-mode-setup help-mode-finish selected-frame help-buffer temp-buffer-window-setup 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 "`\\([^`']+\\)'" t help-xref-button help-function-def "." fill-region-as-paragraph "\n\n" ert-test-boundp eql "Note: This test has been redefined or deleted, " "this documentation refers to an old definition." 2 "It is not documented." "\n" buffer-string temp-buffer-window-show functionp help-window-setup] 13 (#$ . 179234) (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 (#$ . 181013) nil])
(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 (#$ . 181735)])
(defvar ert-unload-hook nil)
(byte-code "\300\301\302\"\210\303\304!\207" [add-hook ert-unload-hook ert--unload-function provide ert] 3)
Zerion Mini Shell 1.0