[verifier] model.patch applied (39806 bytes)
[verifier] Resetting files touched by test.patch
[verifier] Applying test.patch
Warning: Ignoring extra certs from `/etc/ssl/certs/runta-ca-bundle.crt`, load failed: error:80000002:system library::No such file or directory
PASS test/katex-spec.ts
  A parser
    ✓ should not fail on an empty string (1 ms)
    ✓ should ignore whitespace
    ✓ should ignore whitespace in atom (1 ms)
  An ord parser
    ✓ should not fail
    ✓ should build a list of ords (1 ms)
    ✓ should parse the right number of ords
  A bin parser
    ✓ should not fail
    ✓ should build a list of bins (1 ms)
  A rel parser
    ✓ should not fail (1 ms)
    ✓ should build a list of rels
  A mathinner parser
    ✓ should not fail (1 ms)
    ✓ should return one group, not a fragment
  A punct parser
    ✓ should not fail
    ✓ should build a list of puncts
  An open parser
    ✓ should not fail
    ✓ should build a list of opens
  A close parser
    ✓ should not fail
    ✓ should build a list of closes
  A \KaTeX parser
    ✓ should not fail
  A subscript and superscript parser
    ✓ should not fail on superscripts
    ✓ should not fail on subscripts
    ✓ should not fail on both subscripts and superscripts
    ✓ should not fail when there is no nucleus
    ✓ should produce supsubs for superscript
    ✓ should produce supsubs for subscript (1 ms)
    ✓ should produce supsubs for ^_
    ✓ should produce supsubs for _^
    ✓ should produce the same thing regardless of order
    ✓ should not parse double subscripts or superscripts
    ✓ should work correctly with {}s (1 ms)
    ✓ should work with nested super/subscripts
    ✓ should work with Unicode (sub|super)script characters
    ✓ should not fail if \relax is in an atom
    ✓ should skip \relax in super/subscripts
  A subscript and superscript tree-builder
    ✓ should not fail when there is no nucleus
  A parser with limit controls
    ✓ should fail when the limit control is not preceded by an op node
    ✓ should parse when the limit control directly follows an op node (1 ms)
    ✓ should parse when the limit control is in the sup/sub area of an op node
    ✓ should allow multiple limit controls in the sup/sub area of an op node
    ✓ should have the rightmost limit control determine the limits property of the preceding op node
  A group parser
    ✓ should not fail
    ✓ should produce a single ord
  A \begingroup...\endgroup parser
    ✓ should not fail
    ✓ should fail when it is mismatched (1 ms)
    ✓ should produce a semi-simple group
    ✓ should not affect spacing in math mode
  An implicit group parser
    ✓ should not fail
    ✓ should produce a single object (1 ms)
    ✓ should apply only after the function
    ✓ should stop at the ends of groups
    within optional groups
      ✓ should work with sizing commands: \sqrt[\small 3]{x} (1 ms)
      ✓ should work with \color: \sqrt[\color{red} 3]{x}
      ✓ should work style commands \sqrt[\textstyle 3]{x}
      ✓ should work with old font functions: \sqrt[\tt 3]{x}
  A function parser
    ✓ should parse no argument functions
    ✓ should parse 1 argument functions
    ✓ should parse 2 argument functions
    ✓ should not parse 1 argument functions with no arguments
    ✓ should not parse 2 argument functions with 0 or 1 arguments
    ✓ should not parse a function with text right after it
    ✓ should parse a function with a number right after it
    ✓ should parse some functions with text right after it
  A frac parser
    ✓ should not fail
    ✓ should produce a frac
    ✓ should also parse cfrac, dfrac, tfrac, and genfrac
    ✓ should parse cfrac, dfrac, tfrac, and genfrac as fracs (1 ms)
    ✓ should fail, given math as a line thickness to genfrac
    ✓ should fail if genfrac is given less than 6 arguments
    ✓ should parse atop
  An over/brace/brack parser
    ✓ should not fail (1 ms)
    ✓ should produce a frac
    ✓ should create a numerator from the atoms before \over
    ✓ should create a denominator from the atoms after \over
    ✓ should handle empty numerators
    ✓ should handle empty denominators (1 ms)
    ✓ should handle \displaystyle correctly
    ✓ should handle \textstyle correctly
    ✓ should handle nested factions
    ✓ should fail with multiple overs in the same group
  A genfrac builder
    ✓ should not fail (2 ms)
    ✓ should render \tfrac like \textstyle\frac
    ✓ should render \dfrac like \displaystyle\frac in subscripts (1 ms)
  A infix builder
    ✓ should not fail (1 ms)
  A sizing parser
    ✓ should not fail
    ✓ should produce a sizing node
  A text parser
    ✓ should not fail
    ✓ should produce a text
    ✓ should produce textords instead of mathords
    ✓ should not parse bad text
    ✓ should not parse bad functions inside text (1 ms)
    ✓ should parse text with no braces around it
    ✓ should parse nested expressions
    ✓ should contract spaces
    ✓ should handle backslash followed by newline
    ✓ should accept math mode tokens after its argument
    ✓ should ignore a space before the text group
    ✓ should parse math within text group
    ✓ should parse math within text within math within text
    ✓ should forbid \( within math mode
    ✓ should forbid $ within math mode
    ✓ should detect unbalanced \)
    ✓ should detect unbalanced $
    ✓ should not mix $ and \(..\) (1 ms)
    ✓ should parse spacing functions
    ✓ should omit spaces after commands
    ✓ should handle ⋮ and \vdots
  A texvc builder
    ✓ should not fail (5 ms)
  A color parser
    ✓ should not fail (1 ms)
    ✓ should build a color node
    ✓ should parse a custom color
    ✓ should correctly extract the custom color
    ✓ should not parse a bad custom color
    ✓ should parse new colors from the branding guide
    ✓ should use one-argument \color by default
    ✓ should use one-argument \color if requested
    ✓ should use two-argument \color if requested
    ✓ should not define \color in global context
  Alpha hex color parser
    ✓ should correctly extract alpha hex colors
    ✓ should not parse invalid alpha hex colors
    ✓ should build correctly with alpha colors
  A tie parser
    ✓ should parse ties in math mode
    ✓ should parse ties in text mode
    ✓ should produce spacing in math mode
    ✓ should produce spacing in text mode
    ✓ should not contract with spaces in text mode
  A delimiter sizing parser
    ✓ should parse normal delimiters (1 ms)
    ✓ should not parse not-delimiters
    ✓ should produce a delimsizing
    ✓ should produce the correct direction delimiter
    ✓ should parse the correct size delimiter
  An overline parser
    ✓ should not fail
    ✓ should produce an overline
  An lap parser
    ✓ should not fail on a text argument (1 ms)
    ✓ should not fail if math version is used
    ✓ should fail on math if AMS version is used
    ✓ should produce a lap
  A rule parser
    ✓ should not fail
    ✓ should not parse invalid units
    ✓ should not parse incomplete rules
    ✓ should produce a rule (1 ms)
    ✓ should list the correct units
    ✓ should parse the number correctly
    ✓ should parse negative sizes
    ✓ should parse in text mode
  A kern parser
    ✓ should list the correct units
    ✓ should not parse invalid units (1 ms)
    ✓ should parse negative sizes
    ✓ should parse positive sizes
  A non-braced kern parser
    ✓ should list the correct units
    ✓ should parse elements on either side of a kern
    ✓ should not parse invalid units
    ✓ should parse negative sizes (1 ms)
    ✓ should parse positive sizes
    ✓ should handle whitespace
  A left/right parser
    ✓ should not fail
    ✓ should produce a leftright
    ✓ should error when it is mismatched
    ✓ should error when braces are mismatched
    ✓ should error when non-delimiters are provided
    ✓ should parse the empty '.' delimiter
    ✓ should parse the '.' delimiter with normal sizes
    ✓ should handle \middle
    ✓ should handle multiple \middles
    ✓ should handle nested \middles
    ✓ should error when \middle is not in \left...\right
  left/right builder
    ✓ should build "\left\langle \right\rangle" like "\left< \right>" (1 ms)
    ✓ should build "\left\langle \right\rangle" like "\left⟨ \right⟩"
    ✓ should build "\left\lparen \right\rparen" like "\left( \right)"
  A begin/end parser
    ✓ should parse a simple environment (1 ms)
    ✓ should parse an environment with argument
    ✓ should parse and build an empty environment (1 ms)
    ✓ should parse an environment with hlines
    ✓ should forbid hlines outside array environment
    ✓ should error when name is mismatched
    ✓ should error when commands are mismatched
    ✓ should error when end is missing
    ✓ should error when braces are mismatched (1 ms)
    ✓ should cooperate with infix notation
    ✓ should nest
    ✓ should allow \cr and \\ as a line terminator
    ✓ should not allow \cr to scan for an optional size argument
    ✓ should not treat [ after space as optional argument to \\
    ✓ should eat a final newline
    ✓ should grab \arraystretch
    ✓ should allow an optional argument in {matrix*} and company. (2 ms)
    ✓ should allow blank columns
  A sqrt parser
    ✓ should parse square roots
    ✓ should error when there is no group
    ✓ should produce sqrts
    ✓ should build sized square roots (1 ms)
    ✓ should expand argument if optional argument doesn't exist
    ✓ should not expand argument if optional argument exists
  A TeX-compliant parser
    ✓ should work
    ✓ should fail if there are not enough arguments
    ✓ should fail when there are missing sup/subscripts
    ✓ should fail when arguments require arguments (1 ms)
    ✓ should work when the arguments have braces
    ✓ should fail when sup/subscripts require arguments
    ✓ should work when sup/subscripts arguments have braces (1 ms)
    ✓ should allow \imath in sup/subscripts
    ✓ should parse multiple primes correctly
    ✓ should fail when sup/subscripts are interspersed with arguments
    ✓ should succeed when sup/subscripts come after whole functions
    ✓ should succeed with a sqrt around a text/frac
    ✓ should fail when arguments are \left (1 ms)
    ✓ should succeed when there are braces around the \left/\right
  An op symbol builder
    ✓ should not fail (1 ms)
  A style change parser
    ✓ should not fail
    ✓ should produce the correct style
    ✓ should only change the style within its group (1 ms)
  A font parser
    ✓ should parse \mathrm, \mathbb, \mathit, and \mathnormal
    ✓ should parse \mathcal and \mathfrak
    ✓ should produce the correct fonts
    ✓ should parse nested font commands (1 ms)
    ✓ should work with \textcolor
    ✓ should not parse a series of font commands
    ✓ should nest fonts correctly
    ✓ should be allowed in the argument
    ✓ \boldsymbol should inherit mbin/mrel from argument (1 ms)
    ✓ old-style fonts work like new-style fonts
  A \pmb builder
    ✓ should not fail
  A raise parser
    ✓ should parse and build text in \raisebox (1 ms)
    ✓ should parse and build math in non-strict \vcenter
    ✓ should fail to parse math in \raisebox
    ✓ should fail to parse math in an \hbox
    ✓ should fail to build, given an unbraced length
    ✓ should build math in an hbox when math mode is set (1 ms)
  A comment parser
    ✓ should parse comments at the end of a line
    ✓ should parse comments at the start of a line
    ✓ should parse multiple lines of comments in a row
    ✓ should parse comments between subscript and superscript
    ✓ should parse comments in size and color groups
    ✓ should parse comments before an expression
    ✓ should parse comments before and between \hline (1 ms)
    ✓ should parse comments in the macro definition
    ✓ should not expand nor ignore spaces after a command sequence in a comment
    ✓ should not parse a comment without newline in strict mode
    ✓ should not produce or consume space
    ✓ should not include comments in the output
  An HTML font tree-builder
    ✓ should render \mathbb{R} with the correct font
    ✓ should render \mathrm{R} with the correct font (1 ms)
    ✓ should render \mathcal{R} with the correct font
    ✓ should render \mathfrak{R} with the correct font
    ✓ should render \text{R} with the correct font
    ✓ should render \textit{R} with the correct font
    ✓ should render \text{\textit{R}} with the correct font
    ✓ should render \textup{R} with the correct font (1 ms)
    ✓ should render \text{R\textit{S}T} with the correct fonts
    ✓ should render \textbf{R } with the correct font
    ✓ should render \textmd{R} with the correct font
    ✓ should render \textsf{R} with the correct font
    ✓ should render \textsf{\textit{R}G\textbf{B}} with the correct font (1 ms)
    ✓ should render \textsf{\textbf{$\mathrm{A}$}} with the correct font
    ✓ should render \textsf{\textbf{$\mathrm{\textsf{A}}$}} with the correct font
    ✓ should render \texttt{R} with the correct font
    ✓ should render a combination of font and color changes
    ✓ should render wide characters with mord and with the correct font
    ✓ should throw TypeError when the expression is of the wrong type (33 ms)
    ✓ should not throw TypeError when the expression is a supported type (1 ms)
  A MathML font tree-builder
    ✓ should render Ax2k\omega\Omega\imath+ with the correct mathvariants
    ✓ should render \mathbb{Ax2k\omega\Omega\imath+} with the correct mathvariants (1 ms)
    ✓ should render \mathrm{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathit{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathnormal{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathbf{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathcal{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathfrak{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathscr{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathsf{Ax2k\omega\Omega\imath+} with the correct mathvariants
    ✓ should render \mathsfit{Ax2k\omega\Omega\imath+} with the correct mathvariants (1 ms)
    ✓ should render a combination of font and color changes
    ✓ should render text as <mtext>
    ✓ should render math within text as side-by-side children
  An includegraphics builder
    ✓ should not fail (1 ms)
    ✓ should produce mords
    ✓ should not render without trust setting
    ✓ should render with trust setting (1 ms)
    ✓ should escape source
    ✓ should escape alt
  An HTML extension builder
    ✓ should not fail
    ✓ should set HTML attributes (1 ms)
    ✓ should not affect spacing
    ✓ should render with trust and strict setting
    ✓ should throw Error when HTML attribute name is invalid (1 ms)
  The \htmlData macro
    ✓ should not fail if an argument contains a single equals sign
    ✓ should allow equals signs in value (1 ms)
    ✓ should accept empty values
    ✓ should accept empty keys
    ✓ should preserve spaces in value
    ✓ should throw Error if an argument contains no equals signs
  A bin builder
    ✓ should create mbins normally
    ✓ should create ords when at the beginning of lists
    ✓ should create ords after some other objects (1 ms)
    ✓ should correctly interact with color objects
  A \phantom builder and \smash builder
    ✓ should both build a mord
    ✓ should use smash class for hphantom (1 ms)
    ✓ should avoid vlist for symmetric smash
    ✓ should keep vlist for asymmetric smash
  A markup generator
    ✓ marks trees up
    ✓ doesn't combine mathnormal glyphs across italic correction
    ✓ still combines mathnormal glyphs when italic correction is zero
    ✓ still combines non-mathnormal glyphs with italic correction (1 ms)
    ✓ still combines \mathit glyphs with nonzero font italic correction
    ✓ generates both MathML and HTML
  A parse tree generator
    ✓ generates a tree
  An accent parser
    ✓ should not fail
    ✓ should produce accents (1 ms)
    ✓ should be grouped more tightly than supsubs
    ✓ should parse stretchy, shifty accents
    ✓ should parse stretchy, non-shifty accents
  An accent builder
    ✓ should not fail
    ✓ should produce mords (1 ms)
    ✓ should keep accent shifts consistent across font wrappers
  A stretchy and shifty accent builder
    ✓ should not fail (1 ms)
    ✓ should produce mords
  A stretchy and non-shifty accent builder
    ✓ should not fail (1 ms)
    ✓ should produce mords
  A stretchy MathML builder
    ✓ should properly render stretchy accents
  An under-accent parser
    ✓ should not fail
    ✓ should produce accentUnder (1 ms)
    ✓ should be grouped more tightly than supsubs
  An under-accent builder
    ✓ should not fail (4 ms)
    ✓ should produce mords (1 ms)
  An extensible arrow parser
    ✓ should not fail
    ✓ should produce xArrow
    ✓ should be grouped more tightly than supsubs
  An extensible arrow builder
    ✓ should not fail (1 ms)
    ✓ should produce mrell
  A horizontal brace parser
    ✓ should not fail
    ✓ should produce horizBrace
    ✓ should be grouped more tightly than supsubs (1 ms)
  A horizontal brace builder
    ✓ should not fail
    ✓ should produce mords
  A boxed parser
    ✓ should not fail (1 ms)
    ✓ should produce enclose
  A boxed builder
    ✓ should not fail
    ✓ should produce mords (1 ms)
  An fbox parser, unlike a boxed parser,
    ✓ should fail when given math
  A colorbox parser
    ✓ should not fail, given a text argument
    ✓ should fail, given a math argument
    ✓ should parse a color
    ✓ should produce enclose (1 ms)
  A colorbox builder
    ✓ should not fail
    ✓ should produce mords
  An fcolorbox parser
    ✓ should not fail, given a text argument
    ✓ should fail, given a math argument
    ✓ should parse a color
    ✓ should produce enclose (1 ms)
  A fcolorbox builder
    ✓ should not fail
    ✓ should produce mords
  A strike-through parser
    ✓ should not fail
    ✓ should produce enclose
    ✓ should be grouped more tightly than supsubs
  A strike-through builder
    ✓ should not fail (1 ms)
    ✓ should produce mords
  A actuarial angle parser
    ✓ should not fail in math mode
    ✓ should fail in text mode (1 ms)
  A actuarial angle builder
    ✓ should not fail
  \phase
    ✓ should fail in text mode
    ✓ should not fail in math mode
  A phantom parser
    ✓ should not fail
    ✓ should build a phantom node
  A phantom builder
    ✓ should not fail
    ✓ should make the children transparent
    ✓ should make all descendants transparent
  A smash parser
    ✓ should not fail (1 ms)
    ✓ should build a smash node
  A smash builder
    ✓ should not fail
  A parser error
    ✓ should report the position of an error
  An optional argument parser
    ✓ should not fail
    ✓ should work with sqrts with optional arguments
    ✓ should work when the optional argument is missing
    ✓ should fail when the optional argument is malformed
    ✓ should not work if the optional argument isn't closed
  An array environment
    ✓ should accept a single alignment character
    ✓ should accept vertical separators
  A subarray environment
    ✓ should accept only a single alignment character (1 ms)
  A substack function
    ✓ should build
    ✓ should accommodate spaces in the argument
    ✓ should accommodate macros in the argument
    ✓ should accommodate an empty argument (1 ms)
  A smallmatrix environment
    ✓ should build
  A cases environment
    ✓ should parse its input
  An rcases environment
    ✓ should build
  A multicolumn command
    ✓ should parse and build in supported environments (2 ms)
    ✓ should produce a multicolumn node with span and alignment
    ✓ should accept vertical rules in the alignment
    ✓ should allow a span of 1
    ✓ should error outside array environments (1 ms)
    ✓ should error in unsupported environments
    ✓ should error on invalid column counts (1 ms)
    ✓ should error when the span exceeds the remaining columns
    ✓ should error on invalid alignments
    ✓ should error when it is not the only content of a cell (1 ms)
    ✓ should count spanned columns when sizing a matrix
    ✓ should work in a nested environment
    ✓ should suppress internal vertical rules on a per-row basis in HTML
    ✓ should override the column alignment in HTML (1 ms)
  An aligned environment
    ✓ should parse its input
    ✓ should allow cells in brackets
    ✓ should forbid cells in brackets without space
    ✓ should not eat the last row when its first cell is empty
  AMS environments
    ✓ should fail outside display mode
    ✓ should build if in display mode (2 ms)
    ✓ should build an empty environment (1 ms)
    ✓ {equation} should fail if argument contains two rows.
    ✓ {equation} should fail if argument contains two columns.
    ✓ {split} should fail if argument contains three columns.
    ✓ {array} should fail if body contains more columns than specification.
  The CD environment
    ✓ should fail if not is display mode
    ✓ should fail if the character after '@' is not in <>AV=|.
    ✓ should fail if an arrow does not have its final character. (1 ms)
    ✓ should fail without an \\end.
    ✓ should succeed without the flaws noted above.
  operatorname support
    ✓ should not fail (1 ms)
  href and url commands
    ✓ should parse its input (1 ms)
    ✓ should allow empty URLs
    ✓ should allow single-character URLs
    ✓ should allow spaces single-character URLs
    ✓ should allow letters [#$%&~_^] without escaping
    ✓ should allow balanced braces in url
    ✓ should not allow unbalanced brace(s) in url
    ✓ should allow escape for letters [#$%&~_^{}]
    ✓ should allow comments after URLs
    ✓ should be marked up correctly
    ✓ should not affect spacing around
    ✓ should forbid relative URLs when trust option is false (1 ms)
    ✓ should allow explicitly allowed protocols
    ✓ should allow all protocols when trust option is true
    ✓ should not allow explicitly disallowed protocols
    ✓ should not allow explicitly uppercased disallowed protocols
    ✓ should get protocols correctly (1 ms)
  A raw text parser
    ✓ should return null for a omitted optional string
  A parser that does not throw on unsupported commands
    ✓ should still parse on unrecognized control sequences
    ✓ should produce color nodes with a color value given by errorColor
    ✓ should build katex-error span for other type of KaTeX error
    ✓ should properly escape LaTeX in errors (1 ms)
    should allow unrecognized controls sequences anywhere, including
      ✓ in superscripts and subscripts
      ✓ in fractions
      ✓ in square roots (1 ms)
      ✓ in text boxes
  ParseError properties
    ✓ should contain affected position and length information
    ✓ should contain position and length information at end of input
    ✓ should contain no position and length information if unavailable
  The symbol table integrity
    ✓ should treat certain symbols as synonyms (1 ms)
  Symbols
    ✓ should support AMS symbols in both text and math mode
    ✓ should parse \text{\i\j} (1 ms)
    ✓ should parse spacing functions in math or text mode
    ✓ should build \minuso
    ✓ should render ligature commands like their unicode characters
  A macro expander
    ✓ should produce individual tokens
    ✓ should preserve leading spaces inside macro definition
    ✓ should preserve leading spaces inside macro argument
    ✓ should ignore expanded spaces in math mode
    ✓ should consume spaces after control-word macro (1 ms)
    ✓ should consume spaces after macro with \relax
    ✓ should not consume spaces after control-word expansion
    ✓ should consume spaces after \relax
    ✓ should consume spaces after control-word function
    ✓ should preserve spaces after control-symbol macro
    ✓ should preserve spaces after control-symbol function
    ✓ should consume spaces between arguments
    ✓ should allow for multiple expansion (1 ms)
    ✓ should allow for multiple expansion with argument
    ✓ should allow for macro argument
    ✓ should allow properly nested group for macro argument
    ✓ should delay expansion if preceded by \expandafter
    ✓ should not expand if preceded by \noexpand
    ✓ should allow for space macro argument (text version)
    ✓ should allow for space macro argument (math version) (1 ms)
    ✓ should allow for space second argument (text version)
    ✓ should treat \relax as empty argument
    ✓ should allow for space second argument (math version)
    ✓ should allow for empty macro argument
    ✓ should allow for space function arguments
    ✓ should build \overset and \underset
    ✓ should build \iff, \implies, \impliedby (1 ms)
    ✓ should allow aliasing characters
    ✓ \@firstoftwo should consume both, and avoid errors
    ✓ \@ifstar should consume star but nothing else
    ✓ \@ifnextchar should not consume nonspaces
    ✓ \@ifnextchar should consume spaces
    ✓ \@ifstar should consume star but nothing else
    ✓ \TextOrMath should work immediately
    ✓ \TextOrMath should work after other math
    ✓ \TextOrMath should work immediately after \text
    ✓ \TextOrMath should work later after \text
    ✓ \TextOrMath should work immediately after \text ends
    ✓ \TextOrMath should work immediately after $
    ✓ \TextOrMath should work later after $
    ✓ \TextOrMath should work immediately after $ ends
    ✓ \TextOrMath should work in a macro
    ✓ \TextOrMath should work in a macro passed to \text
    ✓ \char produces literal characters (1 ms)
    ✓ \char escapes ~ correctly
    ✓ \char handles >16-bit characters
    ✓ should build Unicode private area characters
    ✓ \TextOrMath should work in a macro passed to \text
    ✓ \gdef defines macros
    ✓ \gdef defines macros with delimited parameter
    ✓ \xdef should expand definition (1 ms)
    ✓ \def should be handled in Parser
    ✓ \def works locally (1 ms)
    ✓ \gdef overrides at all levels
    ✓ \global needs to followed by macro prefixes, \def or \edef
    ✓ \long needs to followed by macro prefixes, \def or \edef
    ✓ Macro arguments do not generate groups
    ✓ \textbf arguments do generate groups
    ✓ \sqrt optional arguments generate groups
    ✓ array cells generate groups
    ✓ \gdef changes settings.macros
    ✓ \def doesn't change settings.macros
    ✓ \def doesn't change settings.macros on error (1 ms)
    ✓ \def changes settings.macros with globalGroup
    ✓ \let copies the definition
    ✓ \let should consume one optional space after equals sign (1 ms)
    ✓ \futurelet should parse correctly
    ✓ macros argument can simulate \let
    ✓ macros argument can simulate \def with arguments
    ✓ \newcommand doesn't change settings.macros
    ✓ \newcommand changes settings.macros with globalGroup (1 ms)
    ✓ \newcommand defines new macros
    ✓ \renewcommand redefines macros
    ✓ \providecommand defines but does not redefine macros
    ✓ \newcommand is local (1 ms)
    ✓ \newcommand accepts number of arguments
    ✓ should treat \hspace, \hskip like \kern
    ✓ should expand \limsup as expected
    ✓ should expand \liminf as expected
    ✓ should expand AMS log-like symbols as expected (1 ms)
    ✓ should expand \plim as expected
    ✓ should expand \argmin as expected
    ✓ should expand \argmax as expected
    ✓ should expand \bra as expected
    ✓ should expand \ket as expected (1 ms)
    ✓ should expand \braket as expected
    ✓ should expand \Bra as expected
    ✓ should expand \Ket as expected
    ✓ should expand \Braket as expected
    ✓ should expand \set as expected (1 ms)
    ✓ should expand \Set as expected
  \tag support
    ✓ should fail outside display mode
    ✓ should fail with multiple tags (1 ms)
    ✓ should fail with multiple tags in one row
    ✓ should work with one tag per row
    ✓ should work with \nonumber/\notag
    ✓ should build (1 ms)
    ✓ should ignore location of \tag
    ✓ should handle \tag* like \tag
  leqno and fleqn rendering options
    ✓ should not add leqno class by default
    ✓ should not add leqno class when false
    ✓ should add leqno class when true (1 ms)
    ✓ should not add fleqn class by default
    ✓ should not add fleqn class when false
    ✓ should add fleqn class when true
  \@binrel automatic bin/rel/ord
    ✓ should generate proper class (2 ms)
    ✓ should base on just first character in group
  A parser taking String objects
    ✓ should not fail on an empty String object
    ✓ should parse the same as a regular string
  Unicode accents
    ✓ should parse Latin-1 letters in math mode (1 ms)
    ✓ should parse Latin-1 letters in text mode
    ✓ should support \aa in text mode
    ✓ should parse combining characters (1 ms)
    ✓ should parse multi-accented characters
    ✓ should parse accented i's and j's
  Unicode
    ✓ should parse negated relations
    ✓ should build relations (1 ms)
    ✓ should parse relations
    ✓ should build big operators
    ✓ should build more relations
    ✓ should parse symbols (1 ms)
    ✓ should not treat emoji variation selectors as registered signs (1 ms)
    ✓ should build Greek capital letters
    ✓ should build arrows
    ✓ should build more arrows
    ✓ should build binary operators
    ✓ should build common ords
    ✓ should build delimiters (1 ms)
    ✓ should build some surrogate pairs
  The maxSize setting
    ✓ should clamp size when set
    ✓ should not clamp size when not set
    ✓ should make zero-width rules if a negative maxSize is passed
  The maxExpand setting
    ✓ should prevent expansion (1 ms)
    ✓ should prevent infinite loops
    ✓ should prevent exponential blowup via \edef
    ✓ should count correctly
    ✓ should count correctly with Unicode sub/superscripts
  The \mathchoice function
    ✓ should render as if there is nothing other in display math (1 ms)
    ✓ should render as if there is nothing other in text
    ✓ should render as if there is nothing other in scriptstyle
    ✓ should render  as if there is nothing other in scriptscriptstyle (1 ms)
  Newlines via \\ and \newline
    ✓ should build \\ without the optional argument and \newline the same
    ✓ should not allow \newline to scan for an optional size argument
    ✓ should not allow \cr at top level
    ✓ \\ causes newline, even after mrel and mop (1 ms)
  Automatic line breaking
    ✓ should keep \not with the following relation
    ✓ should still allow breaks after \neq
  strict setting
    ✓ should allow unicode text when not strict
    ✓ should forbid unicode text when strict (1 ms)
    ✓ should warn about unicode text when default
    ✓ should always allow unicode text in text mode
    ✓ should warn about top-level \newline in display mode
  Internal __* interface
    ✓ __parse renders same as renderToString
    ✓ __renderToDomTree renders same as renderToString (1 ms)
    ✓ __renderToHTMLTree renders same as renderToString sans MathML
  Extending katex by new fonts and symbols
    ✓ should throw on rendering new symbols with no font metrics (6 ms)
    ✓ should add font metrics to metrics map and render successfully
    ✓ Add new font class to new extended symbols
  debugging macros
    message
      ✓ should print the argument using console.log (1 ms)
    errmessage
      ✓ should print the argument using console.error
  \relax
    ✓ should stop the expansion
  \emph
    ✓ should toggle italics (1 ms)
    ✓ should toggle italics within text
    ✓ should toggle italics within textup
    ✓ should toggle italics within textit

jest-ctrf-json-reporter: successfully written ctrf json to ctrf/ctrf-report.json
Test Suites: 1 passed, 1 total
Tests:       615 passed, 615 total
Snapshots:   22 passed, 22 total
Time:        1.823 s
Ran all test suites matching test/katex-spec.ts.
PASS test/multicolumn-spec.ts
  \multicolumn basic functionality
    ✓ should render a simple multicolumn spanning 2 columns (3 ms)
    ✓ should render multicolumn with left alignment (1 ms)
    ✓ should render multicolumn with right alignment
    ✓ should render multicolumn with center alignment (1 ms)
    ✓ should render multicolumn spanning all columns in a row
    ✓ should render multiple multicolumns in same row
    ✓ should render multicolumns in different rows (1 ms)
    ✓ should preserve content inside multicolumn
    ✓ should handle multicolumn with math content (1 ms)
  \multicolumn MathML output
    ✓ should add columnspan attribute with various values
    ✓ should have correct mtd count with multiple multicolumns in row
    ✓ should produce valid MathML structure (1 ms)
  \multicolumn with vertical rules
    ✓ should render multicolumn with left vertical rule
    ✓ should render multicolumn with both vertical rules
    ✓ should suppress internal vertical separators per-row when spanning columns (2 ms)
    ✓ should handle multicolumn overriding column rules (1 ms)
  \multicolumn in different environments
    ✓ should work in matrix environment
    ✓ should work in pmatrix environment (1 ms)
    ✓ should work in bmatrix environment
    ✓ should work in Bmatrix environment
    ✓ should work in vmatrix environment
    ✓ should work in Vmatrix environment (1 ms)
    ✓ should work in cases environment
    ✓ should work in rcases environment
    ✓ should work in aligned environment
    ✓ should work in smallmatrix environment (1 ms)
    ✓ should produce delimiters correctly in pmatrix with multicolumn
    ✓ should produce delimiters correctly in bmatrix with multicolumn (1 ms)
  \multicolumn edge cases
    ✓ should handle multicolumn with colspan 1
    ✓ should handle multicolumn at first cell
    ✓ should handle multicolumn at last cells
    ✓ should handle consecutive multicolumn cells
    ✓ should handle multicolumn with fraction content (1 ms)
    ✓ should handle multicolumn with sqrt content
    ✓ should handle multicolumn with subscript content
    ✓ should handle multicolumn with superscript content
    ✓ should handle multicolumn with nested array (1 ms)
    ✓ should handle empty multicolumn content
    ✓ should handle multicolumn with text content
    ✓ should handle large colspan value
    ✓ should handle multicolumn in single-row array
    ✓ should handle multicolumn in single-cell array
    ✓ should handle multicolumn with bold content
    ✓ should handle multicolumn with color
  \multicolumn error cases
    ✓ should throw for colspan of 0 (17 ms)
    ✓ should throw for negative colspan
    ✓ should throw for non-integer colspan
    ✓ should throw for non-numeric colspan (1 ms)
    ✓ should throw for colspan exceeding remaining columns
    ✓ should throw for colspan exceeding total columns
    ✓ should throw for invalid alignment character x
    ✓ should throw for invalid alignment character m (1 ms)
    ✓ should throw for invalid alignment character p
    ✓ should throw for empty alignment specifier (1 ms)
    ✓ should throw for multicolumn outside array environment
    ✓ should throw for multiple alignment characters lc
    ✓ should throw for multiple alignment characters lr
    ✓ should throw for multiple alignment characters cc
    ✓ should throw for only vertical bars
    ✓ should throw for alignment with numbers (1 ms)
  \multicolumn with horizontal rules
    ✓ should work with hline and multicolumn
    ✓ should work with hdashline and multicolumn (1 ms)
  \multicolumn alignment override
    ✓ should override column alignment
  \multicolumn row structure
    ✓ should maintain correct row count with multicolumn
    ✓ should handle different multicolumn spans in different rows
  \multicolumn structural output verification
    ✓ should produce correct delimiter structure in pmatrix (1 ms)
    ✓ should produce correct delimiter structure in bmatrix
  \multicolumn nested environment errors
    ✓ should throw when used inside nested non-array math like frac (1 ms)
    ✓ should throw when used in plain math mode
    ✓ should throw when used inside sqrt (1 ms)
    ✓ should work when nested array is inside multicolumn content
  \multicolumn MathML attribute precision
    ✓ should produce columnalign without trailing spaces for center
    ✓ should produce columnalign without trailing spaces for left (1 ms)
    ✓ should produce columnalign without trailing spaces for right
  \multicolumn with complete separator suppression
    ✓ should have fewer separators when all rows have multicolumn at same position (1 ms)
    ✓ should produce valid MathML when full row is spanned
  \multicolumn environment robustness
    ✓ should work in array with styling nodes (1 ms)
    ✓ should work alongside substack in same expression
    ✓ should handle empty cells adjacent to multicolumn
    ✓ should handle multicolumn with complex content
  \multicolumn colspan validation
    ✓ should throw for colspan of 0 (1 ms)
    ✓ should throw for negative colspan
    ✓ should throw for non-integer colspan (1 ms)
    ✓ should throw for letter colspan (1 ms)
    ✓ should throw for colspan exceeding remaining columns (1 ms)
    ✓ should throw for colspan exceeding total columns (4 ms)
    ✓ should handle large valid colspan
  \multicolumn empty content handling
    ✓ should handle empty multicolumn content
    ✓ should handle empty multicolumn in multi-row array
  \multicolumn CD environment compatibility
    ✓ should not break CD environment when multicolumn is used elsewhere
    ✓ should work after CD environment in same document
  \multicolumn multi-digit colspan
    ✓ should correctly parse two-digit colspan (1 ms)
  \multicolumn styling node interactions
    ✓ should work with textbf inside multicolumn
    ✓ should work with color command inside multicolumn

jest-ctrf-json-reporter: successfully written ctrf json to ctrf/ctrf-report.json
Test Suites: 1 passed, 1 total
Tests:       94 passed, 94 total
Snapshots:   0 total
Time:        0.377 s
Ran all test suites matching test/multicolumn-spec.ts.
===== grade =====
P2P 599/599 pass 0 fail; F2P 94/94 pass 0 fail; PARTIAL 1.0; BINARY 1
[verifier] reward.json={"reward": 1, "f2p_total": 94, "f2p_passed": 94, "p2p_total": 599, "p2p_passed": 599, "f2p": 1.0, "p2p": 1.0, "partial": 1.0}
