### ----------------------------------------------------
### -- Config::TOML
### -- Licenses: Unlicense
### -- Authors: 
### -- File: t/grammar-actions/02-arrays.rakutest
### ----------------------------------------------------
### -- Chunk 1 of 3
use Test;
use Config::TOML::Parser::Actions;
use Config::TOML::Parser::Grammar;

plan 9;

# empty array grammar-actions tests {{{

subtest({
    my Str $empty-array = '[]';
    my Str $empty-array-space = '[ ]';
    my Str $empty-array-spaces = '[   ]';
    my Str $empty-array-tab = '[	]';
    my Str $empty-array-tabs = '[			]';
    my Str $empty-array-newline = Q:to/EOF/.trim;
    [
    ]
    EOF
    my Str $empty-array-newlines = Q:to/EOF/.trim;
    [


    ]
    EOF
    my Str $empty-array-newlines-tabbed = Q:to/EOF/.trim;
    [


		]
    EOF

    my Config::TOML::Parser::Actions $actions .= new;
    my $match-empty-array =
        Config::TOML::Parser::Grammar.parse(
            $empty-array,
            :$actions,
            :rule<array>
        );
    my $match-empty-array-space =
        Config::TOML::Parser::Grammar.parse(
            $empty-array-space,
            :$actions,
            :rule<array>
        );
    my $match-empty-array-spaces =
        Config::TOML::Parser::Grammar.parse(
            $empty-array-spaces,
            :$actions,
            :rule<array>
        );
    my $match-empty-array-tab =
        Config::TOML::Parser::Grammar.parse(
            $empty-array-tab,
            :$actions,
            :rule<array>
        );
    my $match-empty-array-tabs =
        Config::TOML::Parser::Grammar.parse(
            $empty-array-tabs,
            :$actions,
            :rule<array>
        );
    my $match-empty-array-newline =
        Config::TOML::Parser::Grammar.parse(
            $empty-array-newline,
            :$actions,
            :rule<array>
        );
    my $match-empty-array-newlines =
        Config::TOML::Parser::Grammar.parse(
            $empty-array-newlines,
            :$actions,
            :rule<array>
        );
    my $match-empty-array-newlines-tabbed =
        Config::TOML::Parser::Grammar.parse(
            $empty-array-newlines-tabbed,
            :$actions,
            :rule<array>
        );

    is(
        $match-empty-array.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array, :rule<array>)] - 1 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array successfully
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-space.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array-space, :rule<array>)] - 2 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array (with
        ┃   Success   ┃    single space) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-spaces.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array-spaces, :rule<array>)] - 3 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array (with
        ┃   Success   ┃    spaces) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-tab.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array-tab, :rule<array>)] - 4 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array (with
        ┃   Success   ┃    single tab) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-tabs.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array-tabs, :rule<array>)] - 5 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array (with
        ┃   Success   ┃    tabs) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newline.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array-newline, :rule<array>)] - 6 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array (with
        ┃   Success   ┃    single newline) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newlines.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array-newlines, :rule<array>)] - 7 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array (with
        ┃   Success   ┃    newlines) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newlines-tabbed.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($empty-array-newlines-tabbed, :rule<array>)] - 8 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal empty array (with
        ┃   Success   ┃    newlines and tab) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );

    is(
        $match-empty-array.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 9 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array.made.WHAT ~~ Array
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-space.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 10 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-space.made.WHAT ~~ Array
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-spaces.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 11 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-spaces.made.WHAT ~~ Array
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-tab.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 12 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-tab.made.WHAT ~~ Array
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-tabs.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 13 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-tabs.made.WHAT ~~ Array
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newline.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 14 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-newline.made.WHAT ~~ Array
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newlines.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 15 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-newlines.made.WHAT ~~ Array
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newlines-tabbed.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 16 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-newlines-tabbed.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );

    is(
        $match-empty-array.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 17 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array.made ~~ []
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-space.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 18 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-space.made ~~ []
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-spaces.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 19 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-spaces.made ~~ []
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-tab.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 20 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-tab.made ~~ []
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-tabs.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 21 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-tabs.made ~~ []
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newline.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 22 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-newline.made ~~ []
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newlines.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 23 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-newlines.made ~~ []
        ┃   Success   ┃
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-empty-array-newlines-tabbed.made,
        [],
        q:to/EOF/
        ♪ [Is expected array value?] - 24 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-empty-array-newlines-tabbed.made
        ┃   Success   ┃        ~~ []
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
});

# end empty array grammar-actions tests }}}
# array of strings grammar-actions tests {{{

subtest({
    my Str $array-of-basic-strings = Q:to/EOF/.trim;
    ["red", "maroon", "crimson"]
    EOF

    my Str $array-of-basic-strings-newlines = Q:to/EOF/.trim;
    [
        "red",
        "maroon",
        "crimson",
    ]
    EOF

    my Str $array-of-basic-empty-strings = Q:to/EOF/.trim;
    ["", " ", "		"]
    EOF

    my Str $array-of-basic-multiline-string = Q:to/EOF/.trim;
    ["""red""",]
    EOF

    my Str $array-of-basic-multiline-strings = Q:to/EOF/.trim;
    ["""red""", """maroon""", """crimson"""]
    EOF

    my Str $array-of-basic-multiline-strings-newlines = Q:to/EOF/.trim;
    [
        """
        red \
        maroon \n\
        crimson
        """,
        """
        blue
        aqua
        turquoise
        """, """ brown tan\n auburn""", ]
    EOF

    my Str $array-of-literal-strings = Q:to/EOF/.trim;
    ['red', 'maroon', 'crimson']
    EOF

    my Str $array-of-literal-strings-newlines = Q:to/EOF/.trim;
    [
        'red',
        'maroon',
        'crimson',
    ]
    EOF

    my Str $array-of-literal-empty-strings = Q:to/EOF/.trim;
    ['', ' ', '		']
    EOF

    my Str $array-of-literal-multiline-string = Q:to/EOF/.trim;
    ['''red''',]
    EOF

    my Str $array-of-literal-multiline-strings = Q:to/EOF/.trim;
    ['''red''', '''maroon''', '''crimson''']
    EOF

    my Str $array-of-literal-multiline-strings-newlines = Q:to/EOF/.trim;
    [
        '''
        red \
        maroon \
        crimson
        ''',
        '''
        blue
        aqua
        turquoise
        ''', ''' brown tan auburn''', ]
    EOF

    my Str $array-of-mixed-strings = Q:to/EOF/.trim;
    [ "first", 'second', """third""", '''fourth''', "", '', ]
    EOF

    my Str $array-of-difficult-strings = q:to/EOF/.trim;
    [ "] ", " # ", '\ ', '\', '''\ ''', '''\''']
    EOF

    my Str $array-of-difficult-strings-leading-commas = q:to/EOF/.trim;
    [
        "] "
        , " # "
        , '\ '
        , '\'
        , '''\ '''
        , '''\'''
    ]
    EOF

    my Config::TOML::Parser::Actions $actions .= new;
    my $match-array-of-basic-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-basic-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-basic-strings-newlines =
        Config::TOML::Parser::Grammar.parse(
            $array-of-basic-strings-newlines,
            :$actions,
            :rule<array>
        );
    my $match-array-of-basic-empty-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-basic-empty-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-basic-multiline-string =
        Config::TOML::Parser::Grammar.parse(
            $array-of-basic-multiline-string,
            :$actions,
            :rule<array>
        );
    my $match-array-of-basic-multiline-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-basic-multiline-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-basic-multiline-strings-newlines =
        Config::TOML::Parser::Grammar.parse(
            $array-of-basic-multiline-strings-newlines,
            :$actions,
            :rule<array>
        );
    my $match-array-of-literal-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-literal-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-literal-strings-newlines =
        Config::TOML::Parser::Grammar.parse(
            $array-of-literal-strings-newlines,
            :$actions,
            :rule<array>
        );
    my $match-array-of-literal-empty-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-literal-empty-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-literal-multiline-string =
        Config::TOML::Parser::Grammar.parse(
            $array-of-literal-multiline-string,
            :$actions,
            :rule<array>
        );
    my $match-array-of-literal-multiline-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-literal-multiline-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-literal-multiline-strings-newlines =
        Config::TOML::Parser::Grammar.parse(
            $array-of-literal-multiline-strings-newlines,
            :$actions,
            :rule<array>
        );
    my $match-array-of-mixed-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-mixed-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-difficult-strings =
        Config::TOML::Parser::Grammar.parse(
            $array-of-difficult-strings,
            :$actions,
            :rule<array>
        );
    my $match-array-of-difficult-strings-leading-commas =
        Config::TOML::Parser::Grammar.parse(
            $array-of-difficult-strings-leading-commas,
            :$actions,
            :rule<array>
        );

    is(
        $match-array-of-basic-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($array-of-basic-strings, :rule<array>)] - 25 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of basic strings
        ┃   Success   ┃    successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-strings-newlines.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-basic-strings-newlines,
              :rule<array>
           )] - 26 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of basic strings
        ┃   Success   ┃    (with newlines) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-empty-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-basic-empty-strings,
              :rule<array>
           )] - 27 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of empty basic
        ┃   Success   ┃    strings successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-multiline-string.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-basic-multiline-string,
              :rule<array>
           )] - 28 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of single basic
        ┃   Success   ┃    multiline string successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-multiline-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-basic-multiline-strings,
              :rule<array>
           )] - 29 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of basic multiline
        ┃   Success   ┃    strings successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-multiline-strings-newlines.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-basic-multiline-strings-newlines,
              :rule<array>
           )] - 30 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of basic multiline
        ┃   Success   ┃    strings (with newlines) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($array-of-literal-strings, :rule<array>)] - 31 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of literal strings
        ┃   Success   ┃    successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-strings-newlines.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-literal-strings-newlines,
              :rule<array>
           )] - 32 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of literal strings
        ┃   Success   ┃    (with newlines) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-empty-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-literal-empty-strings,
              :rule<array>
           )] - 33 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of empty literal
        ┃   Success   ┃    strings successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-multiline-string.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-literal-multiline-string,
              :rule<array>
           )] - 34 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of single literal
        ┃   Success   ┃    multiline string successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-multiline-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-literal-multiline-strings,
              :rule<array>
           )] - 35 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of literal
        ┃   Success   ┃    multiline strings successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-multiline-strings-newlines.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-literal-multiline-strings-newlines,
              :rule<array>
           )] - 36 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of literal
        ┃   Success   ┃    multiline strings (with newlines) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-mixed-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($array-of-mixed-strings, :rule<array>)] - 37 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of mixed strings
        ┃   Success   ┃    successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-difficult-strings.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse($array-of-difficult-strings, :rule<array>)] - 38 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of difficult
        ┃   Success   ┃    strings successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-difficult-strings-leading-commas.WHAT,
        Config::TOML::Parser::Grammar,
        q:to/EOF/
        ♪ [Grammar.parse(
              $array-of-difficult-strings-leading-commas,
              :rule<array>
           )] - 39 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ Parses string literal array of difficult
        ┃   Success   ┃    strings (with leading commas) successfully
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );

    is(
        $match-array-of-basic-strings.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 40 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-basic-strings.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-strings-newlines.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 41 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-basic-strings-newlines.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-empty-strings.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 42 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-basic-empty-strings.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-multiline-string.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 43 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-basic-multiline-string.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-multiline-strings.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 44 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-basic-multiline-strings.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-basic-multiline-strings-newlines.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 45 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-basic-multiline-strings-newlines
        ┃   Success   ┃        .made
        ┃             ┃        .WHAT ~~ Array
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-strings.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 46 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-literal-strings.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-strings-newlines.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 47 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-literal-strings-newlines
        ┃   Success   ┃        .made
        ┃             ┃        .WHAT ~~ Array
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-empty-strings.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 48 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-literal-empty-strings.made.WHAT
        ┃   Success   ┃        ~~ Array
        ┃             ┃
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-multiline-string.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 49 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-literal-multiline-string
        ┃   Success   ┃        .made
        ┃             ┃        .WHAT ~~ Array
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-multiline-strings.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 50 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-literal-multiline-strings
        ┃   Success   ┃        .made
        ┃             ┃        .WHAT ~~ Array
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-literal-multiline-strings-newlines.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 51 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match-array-of-literal-multiline-strings-newlines
        ┃   Success   ┃        .made
        ┃             ┃        .WHAT ~~ Array
        ┗━━━━━━━━━━━━━┛
        EOF
    );
    is(
        $match-array-of-mixed-strings.made.WHAT,
        Array,
        q:to/EOF/
        ♪ [Is array?] - 52 of 123
        ┏━━━━━━━━━━━━━┓
        ┃             ┃  ∙ $match