mirror of
git://git.gnu.org.ua/wordsplit.git
synced 2025-04-26 08:39:54 +03:00
b834e13ac4
* tests/wsp.c (help): Update. (wsp_getvar): New function. (main): Callect all arguments in form X=Y to an array and set ws_getvar member if this array is not empty. * tests/wordsplit.at: Add tests for ws_getenv function.
539 lines
8.9 KiB
Text
539 lines
8.9 KiB
Text
# This file is part of grecs -*- Autotest -*-
|
|
# Copyright (C) 2014 Sergey Poznyakoff
|
|
#
|
|
# Grecs is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 3, or (at your option)
|
|
# any later version.
|
|
#
|
|
# Grecs is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with Grecs. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
AT_BANNER(Wordsplit)
|
|
|
|
dnl ------------------------------------------------------------
|
|
dnl TESTWSP([NAME], [KW = `'], [OPTS], [INPUT], [STDOUT = `'],
|
|
dnl [STDERR = `'], [ENV])
|
|
dnl
|
|
m4_pushdef([TESTWSP],[
|
|
AT_SETUP([$1])
|
|
AT_KEYWORDS([wordsplit wsp $2])
|
|
AT_CHECK([$7 wsp $3 <<'EOT'
|
|
[$4]
|
|
EOT
|
|
],
|
|
[0],
|
|
[$5],
|
|
[$6])
|
|
AT_CLEANUP
|
|
])
|
|
|
|
dnl ------------------------------------------------------------
|
|
dnl The first part reproduces legacy argcv tests
|
|
dnl ------------------------------------------------------------
|
|
|
|
TESTWSP([simple input],[wsp-simple wsp00],[],
|
|
[1 2 3],
|
|
[NF: 3
|
|
0: 1
|
|
1: 2
|
|
2: 3
|
|
])
|
|
|
|
TESTWSP([quoted space],[wsp-quoted wsp01],[],
|
|
[quoted\ space],
|
|
[NF: 1
|
|
0: "quoted space"
|
|
])
|
|
|
|
TESTWSP([tab character],[wsp-tab wsp02],[],
|
|
[a "tab character"],
|
|
[NF: 2
|
|
0: a
|
|
1: tab\tcharacter
|
|
])
|
|
|
|
TESTWSP([octal and hex escapes],[wsp-escape wsp-escape0 wsp03],[],
|
|
[\157\143\164\141\154\40and\x20\x68\x65\x78],
|
|
[NF: 1
|
|
0: "octal and hex"
|
|
])
|
|
|
|
TESTWSP([octal and hex escapes 2],[wsp-escape wsp-escape1 wsp04],[],
|
|
[\157\143\164\141\154\40 and \x20\x68\x65\x78],
|
|
[NF: 3
|
|
0: "octal "
|
|
1: and
|
|
2: " hex"
|
|
])
|
|
|
|
TESTWSP([escape representation],[wsp-escape wsp-escape2 wsp05],[],
|
|
[A\x3-\48\39],
|
|
[NF: 1
|
|
0: A\003-\0048\0039
|
|
])
|
|
|
|
dnl ------------------------------------------------------------
|
|
dnl Test worsplit-specific behavior
|
|
dnl ------------------------------------------------------------
|
|
TESTWSP([append],[wsp-append wsp06],[append],
|
|
[jeden dwa trzy
|
|
cztery
|
|
piec szesc],
|
|
[NF: 3
|
|
0: jeden
|
|
1: dwa
|
|
2: trzy
|
|
NF: 4
|
|
0: jeden
|
|
1: dwa
|
|
2: trzy
|
|
3: cztery
|
|
NF: 6
|
|
0: jeden
|
|
1: dwa
|
|
2: trzy
|
|
3: cztery
|
|
4: piec
|
|
5: szesc
|
|
])
|
|
|
|
TESTWSP([dooffs],[wsp-doofs wsp07],[dooffs 3 jeden dwa trzy],
|
|
[cztery piec],
|
|
[NF: 2 (3)
|
|
(0): jeden
|
|
(1): dwa
|
|
(2): trzy
|
|
3: cztery
|
|
4: piec
|
|
])
|
|
|
|
TESTWSP([variable substitutions: single var],[wsp-var wsp-var00 wsp08],[],
|
|
[a $FOO test],
|
|
[NF: 3
|
|
0: a
|
|
1: bar
|
|
2: test
|
|
],
|
|
[],
|
|
[FOO=bar])
|
|
|
|
TESTWSP([variable substitutions: concatenated vars],[wsp-var wsp-var01 wsp09],
|
|
[],
|
|
[a $FOO${BAR}ent test],
|
|
[NF: 3
|
|
0: a
|
|
1: stringent
|
|
2: test
|
|
],
|
|
[],
|
|
[FOO=str BAR=ing])
|
|
|
|
TESTWSP([variable substitutions: field splitting],[wsp-var wsp-var02 wsp10],[],
|
|
[a $FOO test],
|
|
[NF: 4
|
|
0: a
|
|
1: variable
|
|
2: substitution
|
|
3: test
|
|
],
|
|
[],
|
|
[FOO="variable substitution"])
|
|
|
|
TESTWSP([variable substitutions: double-quoted variable],
|
|
[wsp-var wsp-var03 wsp11],[],
|
|
[a "$FOO" test],
|
|
[NF: 3
|
|
0: a
|
|
1: "variable substitution"
|
|
2: test
|
|
],
|
|
[],
|
|
[FOO="variable substitution"])
|
|
|
|
TESTWSP([variable substitutions: single-quoted variable],
|
|
[wsp-var wsp-var04 wsp12],[],
|
|
[a '$FOO' test],
|
|
[NF: 3
|
|
0: a
|
|
1: $FOO
|
|
2: test
|
|
],
|
|
[],
|
|
[FOO="variable substitution"])
|
|
|
|
TESTWSP([undefined variables 1],[wsp-var wsp-var05 wsp13],[],
|
|
[a $FOO test a${FOO}b],
|
|
[NF: 3
|
|
0: a
|
|
1: test
|
|
2: ab
|
|
],
|
|
[],
|
|
[unset FOO;])
|
|
|
|
TESTWSP([undefined variables 2],[wsp-var wsp-var06 wsp14],[keepundef],
|
|
[a $FOO test a${FOO}b],
|
|
[NF: 4
|
|
0: a
|
|
1: $FOO
|
|
2: test
|
|
3: a${FOO}b
|
|
],
|
|
[],
|
|
[unset FOO;])
|
|
|
|
TESTWSP([warn about undefined variables],[wsp-var wsp-var07 wsp15],[warnundef],
|
|
[$FOO],
|
|
[NF: 0
|
|
],
|
|
[warning: undefined variable `FOO'
|
|
],
|
|
[unset FOO;])
|
|
|
|
TESTWSP([bail out on undefined variables],[wsp-var wsp-var08 wsp16],[undef],
|
|
[$FOO],
|
|
[],
|
|
[undefined variable
|
|
],
|
|
[unset FOO;])
|
|
|
|
TESTWSP([disable variable expansion],[wsp-var wsp-var09 wsp17],[novar],
|
|
[$FOO],
|
|
[NF: 1
|
|
0: $FOO
|
|
],
|
|
[],
|
|
[FOO=bar])
|
|
|
|
TESTWSP([K/V environment],[wsp-var wsp-var10 wsp18 wsp-env-kv wsp-env_kv],
|
|
[env_kv],
|
|
[$FOO a$BAZ],
|
|
[NF: 2
|
|
0: bar
|
|
1: aqux
|
|
],
|
|
[],
|
|
[FOO=bar BAZ=qux])
|
|
|
|
TESTWSP([nosplit with expansion],
|
|
[wsp-var wsp-var11 wsp19 wsp-var-nosplit],[nosplit],
|
|
[a $FOO test],
|
|
[NF: 1
|
|
0: "a variable expansion test\n"
|
|
],
|
|
[],
|
|
[FOO="variable expansion"])
|
|
|
|
TESTWSP([nosplit without expansion],[wsp-var wsp-var12 wsp20],[nosplit novar],
|
|
[a $FOO test],
|
|
[NF: 1
|
|
0: "a $FOO test\n"
|
|
],
|
|
[],
|
|
[FOO="variable expansion"])
|
|
|
|
TESTWSP([ignore quotes],[wsp-ignore-quotes wsp21],[-quote],
|
|
["a text"],
|
|
[NF: 2
|
|
0: "\"a"
|
|
1: "text\""
|
|
])
|
|
|
|
TESTWSP([custom delimiters (squeeze)],[wsp-delim wsp-delim00 wsp22],
|
|
[delim : -ws trimnl],
|
|
[semicolon: separated::list: of :words],
|
|
[NF: 5
|
|
0: semicolon
|
|
1: " separated"
|
|
2: list
|
|
3: " of "
|
|
4: words
|
|
])
|
|
|
|
TESTWSP([custom delimiters (no squeeze)],[wsp-delim wsp-delim01 wsp23],
|
|
[delim : -ws -squeeze_delims trimnl],
|
|
[semicolon: separated::list: of :words],
|
|
[NF: 6
|
|
0: semicolon
|
|
1: " separated"
|
|
2: ""
|
|
3: list
|
|
4: " of "
|
|
5: words
|
|
])
|
|
|
|
TESTWSP([custom, with returned delimiters],[wsp-delim wsp-delim02 wsp24],
|
|
[delim : -ws trimnl return_delims],
|
|
[semicolon: separated::list: of :words],
|
|
[NF: 9
|
|
0: semicolon
|
|
1: :
|
|
2: " separated"
|
|
3: :
|
|
4: list
|
|
5: :
|
|
6: " of "
|
|
7: :
|
|
8: words
|
|
])
|
|
|
|
TESTWSP([custom, with returned & squeezed delimiters],
|
|
[wsp-delim wsp-delim03 wsp25],
|
|
[delim : -ws trimnl return_delims -squeeze_delims],
|
|
[semicolon: separated::list: of :words],
|
|
[NF: 10
|
|
0: semicolon
|
|
1: :
|
|
2: " separated"
|
|
3: :
|
|
4: :
|
|
5: list
|
|
6: :
|
|
7: " of "
|
|
8: :
|
|
9: words
|
|
])
|
|
|
|
TESTWSP([sed expressions],[wsp-sed wsp-sed00 wsp26],[sed],
|
|
[arg1 s/foo/bar/g;s/bar baz/quz quux/ arg2],
|
|
[NF: 3
|
|
0: arg1
|
|
1: "s/foo/bar/g;s/bar baz/quz quux/"
|
|
2: arg2
|
|
])
|
|
|
|
TESTWSP([C escapes on],[wcp-c-escape wsp27],[cescapes],
|
|
[a\ttab form\ffeed and new\nline],
|
|
[NF: 4
|
|
0: a\ttab
|
|
1: form\ffeed
|
|
2: and
|
|
3: new\nline
|
|
])
|
|
|
|
TESTWSP([C escapes off],[wcp-c-escape-off wsp28],[-cescapes],
|
|
[a\ttab form\ffeed and new\nline],
|
|
[NF: 4
|
|
0: attab
|
|
1: formffeed
|
|
2: and
|
|
3: newnline
|
|
])
|
|
|
|
TESTWSP([ws elimination],[wsp-ws-elim wsp29],[delim ' ()' ws return_delims],
|
|
[( list items )],
|
|
[NF: 4
|
|
0: (
|
|
1: list
|
|
2: items
|
|
3: )
|
|
])
|
|
|
|
TESTWSP([empty quotes],[wsp-empty-quotes wsp30],[delim : ws return_delims],
|
|
[t=""],
|
|
[NF: 1
|
|
0: t=
|
|
])
|
|
|
|
TESTWSP([delimiter following empty quotes],
|
|
[wsp31],[delim : ws return_delims],
|
|
[t="":r],
|
|
[NF: 3
|
|
0: t=
|
|
1: :
|
|
2: r
|
|
])
|
|
|
|
TESTWSP([suppress ws trimming within quotes],
|
|
[wsp32],
|
|
[default delim , ws return_delims],
|
|
[nocomponent,nonewline, formatfield="In message %{text}, "],
|
|
[NF: 5
|
|
0: nocomponent
|
|
1: ,
|
|
2: nonewline
|
|
3: ,
|
|
4: "formatfield=In message %{text}, "
|
|
])
|
|
|
|
TESTWSP([unescape],
|
|
[wsp-unescape wsp33],[-default novar nocmd quote escape '\"'],
|
|
[\Seen "quote \"" "bs \\"],
|
|
[NF: 3
|
|
0: \\Seen
|
|
1: "quote \""
|
|
2: "bs \\"
|
|
])
|
|
|
|
TESTWSP([dquote],[wsp34],[-default novar nocmd dquote],
|
|
[a "quoted example" isn't it],
|
|
[NF: 4
|
|
0: a
|
|
1: "quoted example"
|
|
2: isn't
|
|
3: it
|
|
])
|
|
|
|
TESTWSP([squote],[wsp35],[-default novar nocmd squote],
|
|
[a 'quoted example' isn"t it],
|
|
[NF: 4
|
|
0: a
|
|
1: "quoted example"
|
|
2: "isn\"t"
|
|
3: it
|
|
])
|
|
|
|
TESTWSP([incremental],[wsp-incr wsp36],[incremental],
|
|
[incremental "input test" line
|
|
|
|
|
|
],
|
|
[NF: 1
|
|
0: incremental
|
|
NF: 1
|
|
0: "input test"
|
|
NF: 1
|
|
0: line
|
|
],
|
|
[input exhausted
|
|
])
|
|
|
|
TESTWSP([incremental append],[wsp-incr wsp37],[incremental append],
|
|
[incremental "input test" line
|
|
|
|
|
|
],
|
|
[NF: 1
|
|
0: incremental
|
|
NF: 2
|
|
0: incremental
|
|
1: "input test"
|
|
NF: 3
|
|
0: incremental
|
|
1: "input test"
|
|
2: line
|
|
],
|
|
[input exhausted
|
|
])
|
|
|
|
TESTWSP([incremental ws],
|
|
[wsp-incr wsp38],[return_delims -squeeze_delims incremental ws],
|
|
[a list test
|
|
|
|
|
|
],
|
|
[NF: 1
|
|
0: a
|
|
NF: 1
|
|
0: list
|
|
NF: 1
|
|
0: test
|
|
],
|
|
[input exhausted
|
|
])
|
|
|
|
TESTWSP([default value (defined)],[wsp-var wsp-var13 wsp39],[],
|
|
[${FOO:-bar}],
|
|
[NF: 1
|
|
0: qux
|
|
],
|
|
[],
|
|
[FOO=qux])
|
|
|
|
TESTWSP([default value],[wsp-var wsp-var14 wsp40],[],
|
|
[${FOO:-bar}],
|
|
[NF: 1
|
|
0: bar
|
|
])
|
|
|
|
TESTWSP([default error message (var defined)],[wsp-var wsp-var15 wsp41],[],
|
|
[a ${FOO:?} test],
|
|
[NF: 3
|
|
0: a
|
|
1: bar
|
|
2: test
|
|
],
|
|
[],
|
|
[FOO=bar])
|
|
|
|
TESTWSP([default error message],[wsp-var wsp-var16 wsp42],[],
|
|
[${FOO:?}],
|
|
[NF: 0
|
|
],
|
|
[FOO: variable null or not set
|
|
])
|
|
|
|
TESTWSP([custom error message (defined)],[wsp-var wsp-var17 wsp-custom-err wsp-custom-err00 wsp43],[],
|
|
[a ${FOO:?please define it} test],
|
|
[NF: 3
|
|
0: a
|
|
1: bar
|
|
2: test
|
|
],
|
|
[],
|
|
[FOO=bar])
|
|
|
|
TESTWSP([custom error message],[wsp-var wsp-var18 wsp-custom-err wsp-custom-err01 wsp44],[],
|
|
[a ${FOO:?please define it} test],
|
|
[NF: 2
|
|
0: a
|
|
1: test
|
|
],
|
|
[FOO: please define it
|
|
])
|
|
|
|
TESTWSP([alternate value (defined)],[wsp-var wsp-var19 wsp-alt wsp-alt00 wsp45],[],
|
|
[a ${FOO:+isset} test],
|
|
[NF: 3
|
|
0: a
|
|
1: isset
|
|
2: test
|
|
],
|
|
[],
|
|
[FOO=bar])
|
|
|
|
TESTWSP([alternate value],[wsp-var wsp-var20 wsp-alt wsp-alt01 wsp46],[],
|
|
[a ${FOO:+isset} test],
|
|
[NF: 2
|
|
0: a
|
|
1: test
|
|
])
|
|
|
|
TESTWSP([getvar],[wsp-var wsp-var21 wsp-getvar wsp-getvar00 wsp47],
|
|
[foo=bar x=quux],
|
|
[begin $foo $x end],
|
|
[NF: 4
|
|
0: begin
|
|
1: bar
|
|
2: quux
|
|
3: end
|
|
])
|
|
|
|
TESTWSP([getvar and env],[wsp-var wsp-var22 wsp-getvar wsp-getvar01 wsp48],
|
|
[foo=bar x=quux],
|
|
[begin $foo $TVAR $x end],
|
|
[NF: 5
|
|
0: begin
|
|
1: bar
|
|
2: 12
|
|
3: quux
|
|
4: end
|
|
],
|
|
[],
|
|
[TVAR=12])
|
|
|
|
TESTWSP([getvar, alternate value],[wsp-var wsp-var23 wsp-alt wsp-alt02 wsp-getvar02 wsp49],
|
|
[foo=bar],
|
|
[a ${foo:+isset}],
|
|
[NF: 2
|
|
0: a
|
|
1: isset
|
|
])
|
|
|
|
m4_popdef([TESTWSP])
|