ltcmd004.lvt

%
% Copyright (C) 2012,2014,2015,2017-2021 LaTeX Project
%
\documentclass{minimal}
\input{regression-test}
\RequirePackage[enable-debug]{expl3}
\ExplSyntaxOn
\debug_on:n { check-declarations , deprecation , log-functions }
\ExplSyntaxOff
% \RequirePackage{xparse}
\begin{document}
\START
\AUTHOR{Joseph Wright, Bruno Le Floch}
\ExplSyntaxOn
\OMIT
\cs_new:Npn \TYPELONG #1 {
  \if_meaning:w #1 \par
    \TYPE { <<par>> }
  \else:
    \TYPE { (#1) }
  \fi:
}
\TIMO

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\TEST { Basic~definitions~r-type~arguments }
  {
    \DeclareDocumentCommand \foo { o r ( ) m } { \TYPE { (#1) (#2) (#3) } }
    \foo ( here ) { there }
    \foo [ nothing ] ( here ) { there }
    \foo [ ] ( ( ) here ( ) ) { there }
    \DeclareDocumentCommand \foo { o m r [ ] } { \TYPE { (#1) (#2) (#3) } }
    \foo [ stuff ] { is } [ [ here ] ]
    \foo { is } [ [ here ] ]
    \DeclareDocumentCommand \foo { r ( ) r ( ) } { \TYPE { (#1) (#2) } }
    \foo ( bar ) ( baz )
  }

\TEST { Basic~definitions~R-type~arguments }
  {
    \DeclareDocumentCommand \foo { o R ( ) { drat } m }
      { \TYPE { (#1) (#2) (#3) } }
    \foo ( here ) { there }
    \foo [ nothing ] ( here ) { there }
    \foo [ ] ( ( ) here ( ) ) { there }
    \DeclareDocumentCommand \foo { o m R [ ] { drat } }
      { \TYPE { (#1) (#2) (#3) } }
    \foo [ stuff ] { is } [ [ here ] ]
    \foo { is } [ [ here ] ]
    \DeclareDocumentCommand \foo { R ( ) { drat }R ( ) { drat } }
      { \TYPE { (#1) (#2) } }
    \foo ( bar ) ( baz )
  }

\TEST { r-type~argument~errors }
  {
    \DeclareDocumentCommand \foo { o r ( ) m } { \TYPE { (#1) (#2) (#3) } }
    \foo { there }
    \foo [ nothing ] { there }
    \DeclareDocumentCommand \foo { o m r [ ] } { \TYPE { (#1) (#2) (#3) } }
    \foo [ stuff ] { is }
    \DeclareDocumentCommand \foo { r ( ) r ( ) } { \TYPE { (#1) (#2) } }
    \foo stop
  }

\TEST { R-type~argument~errors }
  {
    \DeclareDocumentCommand \foo { o R ( ) { drat } m }
      { \TYPE { (#1) (#2) (#3) } }
    \foo { there }
    \foo [ nothing ] { there }
    \DeclareDocumentCommand \foo { o m R [ ] { drat } }
      { \TYPE { (#1) (#2) (#3) } }
    \foo [ stuff ] { is }
    \DeclareDocumentCommand \foo { R ( ) { drat } R ( ) { drat } }
      { \TYPE { (#1) (#2) } }
    \foo stop
  }

\TEST { Basic~e-type~argument~definitions }
  {
    \DeclareDocumentCommand \foo { e { ^ _ } m }
      { \TYPE { ({#1}{#2}) (#3) } }
    \foo { there }
    \foo ^ { up } { here }
    \foo _ { down } { here }
    \foo ^ { up } _ { down } { here }
    \DeclareDocumentCommand \foo { e { ^ _ } }
      { \TYPE { ({#1}{#2}) } }
    \foo stop
    \foo ^ { up } stop
    \foo _ { down } stop
    \foo ^ { up } _ { down } stop
  }

\TEST { Basic~E-type~argument~definitions }
  {
    \DeclareDocumentCommand \foo { E { ^ _ } { } }
      { \TYPE { ({#1}{#2}) } }
    \foo { there }
    \foo ^ { up } { here }
    \foo _ { down } { here }
    \foo ^ { up } _ { down } { here }
    \DeclareDocumentCommand \foo { E { ^ _ } { { UP } } }
      { \TYPE { ({#1}{#2}) } }
    \foo { there }
    \foo ^ { up } { here }
    \foo _ { down } { here }
    \foo ^ { up } _ { down } { here }
    \DeclareDocumentCommand \foo { E { ^ _ } { { UP } { DOWN } } }
      { \TYPE { ({#1}{#2}) } }
    \foo { there }
    \foo ^ { up } { here }
    \foo _ { down } { here }
    \foo ^ { up } _ { down } { here }
  }

\TEST { Bad~arg~specs }
  {
    \OMIT
    \cs_undefine:N \foo
    \TIMO
    \DeclareDocumentCommand \foo { d m } { }
    \cs_log:N \foo
    \DeclareDocumentCommand \foo { t } { }
    \cs_log:N \foo
    \DeclareDocumentCommand \foo { r { oh } { no } } { }
    \cs_log:N \foo
    \DeclareDocumentCommand \foo { D { } { } { } } { }
    \cs_log:N \foo
    \DeclareDocumentCommand \foo { D { ~ X ~ } { { Y } } { } } { }
    \cs_log:N \foo
    \DeclareDocumentCommand \foo { + >{\ReverseBoolean} } { }
    \cs_log:N \foo
    \DeclareDocumentCommand \foo { e { _ _ } } { }
    \cs_log:N \foo
    \DeclareExpandableDocumentCommand \foo { + >{\ReverseBoolean} } { }
    \cs_log:N \foo
  }

\TEST { Stripping~braces~in~optional~args }
  {
    \DeclareDocumentCommand \foo { o m } { \TYPE { (#1) (#2) }}
    \foo [ ] { baz }
    \foo [ { bar } ] { baz }
    \foo [ { ~ bar } ] { baz }
    \foo [ { bar ~ } ] { baz }
    \foo [ ~ { bar } ] { baz }
    \foo [ { bar } ~ ] { baz }
    \foo [ ~ ] { baz }
    \foo [ { } ] { baz }
    \foo [ { ~ } ] { baz }
    \foo [ [ { bar } ] ] { baz }
  }

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\TEST { Get~and~show~argument~spec }
  {
    \OMIT
    \DeclareDocumentCommand { \null } { } { }
    % Disabled: test requires deprecated xparse.sty
    % \DeclareDocumentCommand { \foo } { >{\SplitList{;}} m +o g } { }
    \DeclareDocumentEnvironment { nullenv } { } { } { }
    % \DeclareDocumentEnvironment { fooenv } { v D{$}{$} l u{!} } { } { }
    \TIMO
    \GetDocumentCommandArgSpec { \null } \TYPE { | \ArgumentSpecification | }
    \ShowDocumentCommandArgSpec { \null }
    % \GetDocumentCommandArgSpec { \foo } \TYPE { | \ArgumentSpecification | }
    % \ShowDocumentCommandArgSpec { \foo }
    \GetDocumentEnvironmentArgSpec { nullenv } \TYPE { | \ArgumentSpecification | }
    \ShowDocumentEnvironmentArgSpec { nullenv }
    % \GetDocumentEnvironmentArgSpec { fooenv } \TYPE { | \ArgumentSpecification | }
    % \ShowDocumentEnvironmentArgSpec { fooenv }
  }

\TEST { First~argument~must~be~a~command }
  {
    \DeclareDocumentCommand           { \foo! } { x } { y }
    \NewDocumentCommand               { \foo! } { x } { y }
    \RenewDocumentCommand             { \foo! } { x } { y }
    \ProvideDocumentCommand           { \foo! } { x } { y }
    \DeclareExpandableDocumentCommand { \foo! } { x } { y }
    \NewExpandableDocumentCommand     { \foo! } { x } { y }
    \RenewExpandableDocumentCommand   { \foo! } { x } { y }
    \ProvideExpandableDocumentCommand { \foo! } { x } { y }
    \GetDocumentCommandArgSpec        { \foo! }
    \ShowDocumentCommandArgSpec       { \foo! }
    \DeclareDocumentCommand           { foo } { x } { y }
    \NewDocumentCommand               { foo } { x } { y }
    \RenewDocumentCommand             { foo } { x } { y }
    \ProvideDocumentCommand           { foo } { x } { y }
    \DeclareExpandableDocumentCommand { foo } { x } { y }
    \NewExpandableDocumentCommand     { foo } { x } { y }
    \RenewExpandableDocumentCommand   { foo } { x } { y }
    \ProvideExpandableDocumentCommand { foo } { x } { y }
    \GetDocumentCommandArgSpec        { foo }
    \ShowDocumentCommandArgSpec       { foo }
    \DeclareDocumentCommand           { # } { x } { y }
    \NewDocumentCommand               { # } { x } { y }
    \RenewDocumentCommand             { # } { x } { y }
    \ProvideDocumentCommand           { # } { x } { y }
    \DeclareExpandableDocumentCommand { # } { x } { y }
    \NewExpandableDocumentCommand     { # } { x } { y }
    \RenewExpandableDocumentCommand   { # } { x } { y }
    \ProvideExpandableDocumentCommand { # } { x } { y }
    \GetDocumentCommandArgSpec        { # }
    \ShowDocumentCommandArgSpec       { # }
    \DeclareDocumentCommand           { ~\?~ } { m } { y }
    \NewDocumentCommand               { ~\?~ } { m } { y }
    \RenewDocumentCommand             { ~\?~ } { m } { y }
    \ProvideDocumentCommand           { ~\?~ } { m } { y }
    \DeclareExpandableDocumentCommand { ~\?~ } { m } { y }
    \NewExpandableDocumentCommand     { ~\?~ } { m } { y }
    \RenewExpandableDocumentCommand   { ~\?~ } { m } { y }
    \ProvideExpandableDocumentCommand { ~\?~ } { m } { y }
    \GetDocumentCommandArgSpec        { ~\?~ }
    \ShowDocumentCommandArgSpec       { ~\?~ }
  }

\TEST { SplitList }
  {
    \DeclareDocumentCommand { \foo } { > { \SplitList {)||(\BOOM\c_false_bool} } m } { \tl_log:n {#1} }
    { \foo { a ( b } }
  }

% Disabled: test requires deprecated xparse.sty
% \TEST { Test~#~in~argument~specification }
%   {
%     \DeclareDocumentCommand { \foo }
%       { D<>{##} G{##} t* E{_^}{{1##}{2##}} l m R(){##} u{...} }
%       { \TYPE { #1 | #2 | #3 | {#4}{#5} | #6 | #7 | #8 | #9 | D } }
%     \foo<1>...{A}C...
%     \foo{1}...{A}(B)C...
%     \foo*...{A}(B)C...
%     \foo^1...{A}(B)C...
%     \foo<1>{2}*_3^4...{A}(B)C...
%     \DeclareDocumentCommand { \foo }
%       { +D<>{##} +G{##} +t* +E{_^}{{1##}{2##}} +l +m +R(){##} +u{...} }
%       { \TYPE { #1 | #2 | #3 | {#4}{#5} | #6 | #7 | #8 | #9 | D } }
%     \foo<1>...{A}C...
%     \foo{1}...{A}(B)C...
%     \foo*...{A}(B)C...
%     \foo^1...{A}(B)C...
%     \foo<1>{2}*_3^4...{A}(B)C...
%   }

\TEST { Defaults~referring~to~other~arguments }
  {
    \DeclareDocumentCommand {\conjugate} { m O{#1ed} O{#2} }
      { \TYPE { (#1,#2,#3) } }
    \conjugate {walk}
    \conjugate {find} [found]
    \conjugate {do} [did] [done]
    \DeclareDocumentCommand {\margins} { O{#3} m O{#1} m }
      { \TYPE { (#1,#2,#3,#4) } }
    \margins {a} {b}
    \margins [1cm] {a} {b}
    \margins {a} [1cm] {b}
    \margins [1cm] {a} [2cm] {b}
    % Disabled: test requires deprecated xparse.sty
    % \DeclareDocumentCommand {\foo}
    %   { D<>{#2} G{#5#1} E{_^}{{1}{2}} O{{#3}{#4}#6} m }
    %   { \TYPE { \exp_not:n { #1 | #2 | {#3}{#4} | #5 | #6 } } }
    % \foo<\A>_{\B}{\C}
    % \foo{\A}{\B}
    % \foo{\A}[\B]{\C}
    % \foo ^{\A}{\B}
    % \foo[]{\B}
    % \foo<\A>_{\B}^{\C}{\D}
    \DeclareDocumentCommand {\foo}
      { O{#2} O{#3} O{#4} O{#5} O{#6} O{#7} O{#8} O{#9} m }
      { \TYPE { \exp_not:n {#1} } }
    \foo{\A}
    \DeclareDocumentCommand {\foo}
      { E{_^}{{{#3}{#4}}{#5}} E{*+}{{{#1}{#2}}} m } { \TYPE { \exp_not:n { {#1}{#2} | {#3}{#4} | #5 } } }
    \foo *{\C}  {\E}
    \foo _{\A}  {\E}
    \foo ^{\A} *{\C}  {\E}
    \foo ^{\B} _{\A} +{\D} {\E}
  }

\DeclareExpandableDocumentCommand { \foobar }
  { D<>{##} t* m R(){##} }
  { \TYPE { #1 | #2 | #3 | #4 } }
\TESTEXP { Test~#~in~expandable~argument~specification }
  {
    \foobar <1>{#}\relax\NEWLINE
    \foobar *{#}(2#)\NEWLINE
    \foobar {#}(2#)\NEWLINE
    \foobar <1>*{#}(2#)\NEWLINE
  }

\DeclareExpandableDocumentCommand { \foobar }
  { D<>{#2} O{#4#1} m O{#3#5} m }
  { \TYPE { \exp_not:n { #1 | #2 | #3 | #4 | #5 } } }
\DeclareExpandableDocumentCommand {\baz}
  { O{#2} O{#3} O{#4} O{#5} O{#6} O{#7} O{#8} O{#9} m }
  { \TYPE { \exp_not:n {#1} } }
\TESTEXP { Refer~to~other~args~(expandable) }
  {
    \foobar <\A>{\C}{\E}     \NEWLINE
    \foobar {\C}{\E}         \NEWLINE
    \foobar {\C}[\D]{\E}     \NEWLINE
    \foobar [\B]{\C}{\E}     \NEWLINE
    \foobar <\A>[\B]{\C}{\E} \NEWLINE
    \baz{\A}
  }

\TEST { Bad~arguments }
  {
    \DeclareDocumentCommand { \foo } { {abc} {def} } { }
    \TYPE { \cs_meaning:N \foo }
    \DeclareDocumentCommand { \foo } { D{abc}{def}{ghi} } { }
    \TYPE { \cs_meaning:N \foo }
    \DeclareDocumentCommand { \foo } { D{abc}{def} } { }
    \TYPE { \cs_meaning:N \foo }
    \DeclareDocumentCommand { \foo } { D } { }
    \TYPE { \cs_meaning:N \foo }
    \DeclareDocumentCommand { \foo } { O } { }
    \TYPE { \cs_meaning:N \foo }
    \DeclareExpandableDocumentCommand { \foo } { >{\abc} m } { }
    \TYPE { \cs_meaning:N \foo }
  }

\TEST { Optional+mandatory~with~same~delimiter }
  {
    \DeclareDocumentCommand { \foo } { o R[]{} } { \TYPE{|#1|#2|} }
    \foo [a][b]
    \DeclareDocumentCommand { \foo } { O{} r[] } { \TYPE{|#1|#2|} }
    \foo [a][b]
    \DeclareDocumentCommand { \foo } { d:, r:. } { \TYPE{|#1|#2|} }
    \foo :a:b,c,:d.
    \DeclareDocumentCommand { \foo } { D:,{} R:.{} } { \TYPE{|#1|#2|} }
    \foo :a:b,c,:d.
    \DeclareDocumentCommand { \foo } { o s r[] } { \TYPE{|#1|#2|#3|} }
    \foo *[a]
    % Disabled: test requires deprecated xparse.sty
    % \DeclareDocumentCommand { \foo } { g m } { \TYPE{|#1|#2|} }
    % \foo a     \foo {a}{b}
    % \DeclareDocumentCommand { \foo } { G{} m } { \TYPE{|#1|#2|} }
    % \foo a     \foo {a}{b}
    \DeclareDocumentCommand { \foo } { s r** } { \TYPE{|#1|#2|} }
    \foo **a*
    \DeclareDocumentCommand { \foo } { t( r() t) } { \TYPE{|#1|#2|#3|} }
    \foo ((a(b)c))
    \DeclareDocumentCommand { \foo } { e{_^} s r__ } { \TYPE{|{#1}{#2}|#3|#4|} }
    \foo ^{a}____ \foo _a_abc_ \foo *_a_
  }

\DeclareExpandableDocumentCommand { \foo } { s O{\par} m } { \TYPE { |#1|#2|#3| } }
\TESTEXP { par~in~short~expandable }
  {
    \foo{a} \NEWLINE
    \foo[a]{b} \NEWLINE
    \foo[\par \NEWLINE
    \foo\par \NEWLINE
  }

\TEST { Environments~and~expansion }
  {
    \DeclareDocumentEnvironment { foo } { o }
      { \TYPE { \exp_not:n {#1} } }
      { \TYPE { \exp_not:n {#1} } }
    \begin{foo}[\A\B\C]
    \end{foo}
  }

\TEST { Expandable~r~type }
  {
    \DeclareExpandableDocumentCommand { \foo } { o R[]{} } { \TYPE{|#1|#2|} }
    \foo [a][b]    
    \DeclareExpandableDocumentCommand { \foo } { o R''{} } { \TYPE{|#1|#2|} }
    \foo [a]'b'
  }

\TEST { Expandable~e-type~argument~definitions }
  {
    \DeclareExpandableDocumentCommand \foo { e { ^ _ } m }
      { \exp_not:n { ({#1}{#2}) (#3) } }
    \TYPE { \foo { \the re } }
    \TYPE { \foo ^ { \u p } { \he re } }
    \TYPE { \foo _ { \do wn } { \he re } }
    \TYPE { \foo ^ { \u p } _ { \do wn } { \he re } }
    \DeclareExpandableDocumentCommand \foo { E { ^ _ } { { \U P } } m }
      { \exp_not:n { ({#1}{#2}) (#3) } }
    \TYPE { \foo { \the re } }
    \TYPE { \foo ^ { \u p } { \he re } }
    \TYPE { \foo _ { \do wn } { \he re } }
    \TYPE { \foo ^ { \u p } _ { \do wn } { \he re } }
    \DeclareExpandableDocumentCommand \foo { E { ^ _ } { { \U P } { \DO WN } } m }
      { \exp_not:n { ({#1}{#2}) (#3) } }
    \TYPE { \foo { \the re } }
    \TYPE { \foo ^ { \u p } { \he re } }
    \TYPE { \foo _ { \do wn } { \he re } }
    \TYPE { \foo ^ { \u p } _ { \do wn } { \he re } }
    \DeclareExpandableDocumentCommand \foo { E { ^ _ } { {#3} { \DO WN } } O{##} m }
      { \exp_not:n { ({#1}{#2}) (#3) (#4) } }
    \TYPE { \foo { \A } }
    \TYPE { \foo [ \A ] { \B } }
    \TYPE { \foo ^ { \A } [ \B ] { \C } }
    \TYPE { \foo _ { \A } { \B } }
    \TYPE { \foo _ { \A } ^ { \B } [ \C ] { \D } }
  }

\TEST { Long~status~of~t-type~ignored }
  {
    \DeclareExpandableDocumentCommand { \foo } { t- t{\par} +o +m }
      { \exp_not:n { |#1|#2|#3|#4| } }
    \TYPE { \foo - \par [ \par ] { \par } }
    \TYPE { \foo { \par } { \par \A } }
    \DeclareExpandableDocumentCommand { \foo } { +t- s o m }
      { \exp_not:n { |#1|#2|#3|#4| } }
    \TYPE { \foo \par }
    \TYPE { \foo * [ [ \A ] ] { \B } }
  }

% Disabled: test requires deprecated xparse.sty
% \TEST { Expandable~l/u~arguments }
%   {
%     \DeclareExpandableDocumentCommand { \A } { u{def} } { \exp_not:n { |#1| } }
%     \TYPE { \A {def} ghi def }
%     \DeclareExpandableDocumentCommand { \B } { l } { \exp_not:n { |#1| } }
%     \TYPE { \B abc { def } }
%     \DeclareExpandableDocumentCommand { \C } { o l m } { \exp_not:n { |#1|#2|#3| } }
%     \TYPE { \C [abc]{def} }
%     \DeclareDocumentCommand { \D } { o l m } { \TYPE { |#1|#2|#3| } }
%     \D [abc]{def}
%   }

\TEST { Same~expandable~command~with/without~defaults }
  {
    \DeclareExpandableDocumentCommand { \foo } { O{a} m } { |#1|#2| }
    \TYPE { \foo {b} {c} }
    \DeclareExpandableDocumentCommand { \foo } { m m } { |#1|#2| }
    \TYPE { \foo {b} {c} }
  }

\TEST { Wrongly~undefining~an~xparse~command }
  {
    \DeclareDocumentCommand { \foo } { m } {#1}
    \let\foo\relax
    \DeclareDocumentCommand { \foo } { m } {|#1|}
  }

\TEST { NoValue~passed~to~another~command }
  {
    \DeclareDocumentCommand { \foo } { o o m } { \baz {#1} [#2] {#3} }
    \DeclareDocumentCommand { \baz } { m O{B} m } { \TYPE { \tl_to_str:n { | #1 | #2 | #3 | } } }
    \foo{C}
  }

\TEST { Two~processors }
  {
    \cs_new_protected:Npn \CountArg #1 { \tl_set:Nx \ProcessedArgument { \tl_count:n {#1} } }
    \DeclareDocumentCommand { \foo } { >{\CountArg} >{\SplitList{,}} m >{\SplitList{,}} >{\CountArg} m }
      { \TYPE { \tl_to_str:n { |#1|#2| } } }
    \foo { a , bcd } { a , bcd }
  }

\TEST { Non-character~token~delimiters }
  {
    \DeclareDocumentCommand { \foo } { d\[\] } { \TYPE {#1} } \foo \[abc\]
    \DeclareDocumentCommand { \foo } { r\(\) } { \TYPE {#1} } \foo \(def\)
    \DeclareDocumentCommand { \foo } { d\(\)r\(\) } { \TYPE {#1/#2} } \foo \(abc\) \(def\)
    \DeclareDocumentCommand { \foo } { r\(\)d\(\) } { \TYPE {#1/#2} } \foo \(abc\) \(def\)
    \DeclareDocumentCommand { \foo } { r\(\)d\(\) } { \TYPE {#1/#2} } \foo \(abc\)
    \DeclareDocumentCommand\foo
      { e {\undefinedFirstArgument\undefinedSecondArgument}}
      { \TYPE {#1/#2} }
    \foo \undefinedSecondArgument {something}
  }

\TEST { Non-character~delimiters:~delimiters~with~the~same~definition }
  {
    \cs_set:Npn \( {abc}
    \cs_set:Npn \) {abc}
    \cs_set:Npn \clean #1 \z
      { \tl_if_empty:nF {#1} { \TYPE { Removed:~( \exp_not:n {#1} ) } } }
    \DeclareDocumentCommand { \foo } { d\(\) } { \TYPE { (#1) } \clean }
    \foo\(abc\)\z
    \foo\)abc\)\z
    \DeclareExpandableDocumentCommand { \foo } { d\(\) m } { \TYPE { (#1) } \clean }
    \foo\(abc\){}\z
    \foo\)abc\){}\z
    \DeclareDocumentCommand { \foo } { t\( } { \TYPE { (#1) } }
    \foo\(
    \foo\)
    \DeclareDocumentCommand { \foo } { e{\(\)} } { \TYPE { (#1|#2) } \clean }
    \foo\({l}\z
    \foo\){r}\z
    \foo\({l}\({l}\z
    \foo\){r}\){r}\z
    \foo\({l}\){r}\z
    \foo\){r}\({l}\z
  }

\TEST { Non-character~delimiters:~delimiters~\let~to~the~same~token }
  {
    \cs_set_eq:NN \( ?
    \cs_set_eq:NN \) ?
    \cs_set:Npn \clean #1 \z
      { \tl_if_empty:nF {#1} { \TYPE { Removed:~( \exp_not:n {#1} ) } } }
    \DeclareDocumentCommand { \foo } { d\(\) } { \TYPE { (#1) } \clean }
    \foo\(abc\)\z
    \foo\)abc\)\z
    \DeclareExpandableDocumentCommand { \foo } { d\(\) m } { \TYPE { (#1) } \clean }
    \foo\(abc\){}\z
    \foo\)abc\){}\z
    \DeclareDocumentCommand { \foo } { t\( } { \TYPE { (#1) } }
    \foo\(
    \foo\)
    \DeclareDocumentCommand { \foo } { e{\(\)} } { \TYPE { (#1|#2) } \clean }
    \foo\({l}\z
    \foo\){r}\z
    \foo\({l}\({l}\z
    \foo\){r}\){r}\z
    \foo\({l}\){r}\z
    \foo\){r}\({l}\z
  }

\TEST { Non-character~delimiters:~forbidden~delimiters }
  {
    \cs_set_eq:NN \( \c_group_begin_token
    \cs_set_eq:NN \) \c_group_end_token
    \cs_set:Npn \clean #1 \z
      { \tl_if_empty:nF {#1} { \TYPE { Removed:~( \exp_not:n {#1} ) } } }
    % Invalid defitions:
    \DeclareDocumentCommand { \foo } { d\(\) } { }
    \DeclareExpandableDocumentCommand { \foo } { d\(\) m } { }
    \DeclareDocumentCommand { \foo } { d\)\( } { }
    \DeclareExpandableDocumentCommand { \foo } { d\)\( m } { }
    \DeclareDocumentCommand { \foo } { t\( } { }
    \DeclareDocumentCommand { \foo } { t\) } { }
    \DeclareDocumentCommand { \foo } { e{\(\)} } { }
    % Valid defitions:
    \DeclareDocumentCommand { \foo } { d? \) } { \TYPE { (#1) } }
    \foo? abc\)
    \foo? abc\)
    \DeclareExpandableDocumentCommand { \foo } { d? \) m } { \TYPE { (#1) } \clean }
    \foo? abc\){}\z
    \foo? abc\){}\z
  }

\TEST { delimited~commands~in~alignments }
  {
    \NewDocumentCommand\MyCmd                 {D[]{A} } {\message{#1}}
    \NewDocumentCommand\MyCmdTab              {D&&{B} } {\message{#1}}
    \NewExpandableDocumentCommand\MyExpCmd    {D[]{C}m} {\message{#1}}
    \NewExpandableDocumentCommand\MyExpCmdTab {D&&{D}m} {\message{#1}}
    \NewDocumentEnvironment{MyEnv} {b} {\message{E~x~#1}} { }
    %
    \TYPE{}\halign{#\cr \MyCmd         \MyCmd      [x]   \MyCmd      [y&z]   \cr}
    \TYPE{}\halign{#\cr \MyCmdTab      \MyCmdTab   &x&   \MyCmdTab   &yXz&   \cr}
    \TYPE{}\halign{#\cr \MyExpCmd{}    \MyExpCmd   [x]{} \MyExpCmd   [y&z]{} \cr}
    \TYPE{}\halign{#\cr \MyExpCmdTab{} \MyExpCmdTab&x&{} \MyExpCmdTab&yXz&{} \cr}
    \TYPE{}\halign{#\cr \begin{MyEnv} y&z \end{MyEnv} \cr}
    \TYPE{}
  }

\TEST { IfBoolean~multi~token }
  {
    \IfBooleanT { } { \ERROR }
    \IfBooleanTF { } { \ERROR } { \FALSE }
    \IfBooleanF { \ERROR \ERROR } { \FALSE }
  }

\TEST { Processor~spaces }
  {
    \hbox_set:Nn \l_tmpa_box {
      \DeclareDocumentCommand ~ { ~ \foo ~ } ~ { ~ > ~ { ~ \SplitList ~ {,} ~ } ~ m ~ } ~ {\TYPE ~ {|#1|}}
      \foo ~ { ~ a ~ , ~ bcd ~ }
    }
    \dim_log:n { \box_wd:N \l_tmpa_box }
  }

\TEST { Processor~depending~on~other~argument }
  {
    \DeclareDocumentCommand { \foo } { >{\SplitList{#2}} m >{\CountArg} O{,} }
      { \TYPE { \tl_to_str:n { |#1|#2| } } }
    \foo { a , bcd ; e }
    \DeclareDocumentCommand { \baz } { } { }
    \foo { a , bcd ; e } [;]
  }

\END