diff --git a/tests/bats/bats-assert/.github/workflows/sync-master.yml b/tests/bats/bats-assert/.github/workflows/sync-master.yml
deleted file mode 100644
index 4577123..0000000
--- a/tests/bats/bats-assert/.github/workflows/sync-master.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-name: Sync Master
-on:
- push: { branches: main }
- workflow_dispatch:
-
-jobs:
- sync:
- uses: bats-core/.github/.github/workflows/sync-master.yml@v1
diff --git a/tests/bats/bats-assert/.github/workflows/test.yml b/tests/bats/bats-assert/.github/workflows/test.yml
deleted file mode 100644
index 6c95ce2..0000000
--- a/tests/bats/bats-assert/.github/workflows/test.yml
+++ /dev/null
@@ -1,9 +0,0 @@
-name: Test
-on:
- push:
- pull_request:
- workflow_dispatch:
-
-jobs:
- test:
- uses: bats-core/.github/.github/workflows/test.yml@v1
diff --git a/tests/bats/bats-assert/.gitignore b/tests/bats/bats-assert/.gitignore
deleted file mode 100644
index 41a3ee1..0000000
--- a/tests/bats/bats-assert/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-/node_modules
-/yarn.lock
-/bats-assert-*.tgz
diff --git a/tests/bats/bats-assert/LICENSE b/tests/bats/bats-assert/LICENSE
deleted file mode 100644
index 670154e..0000000
--- a/tests/bats/bats-assert/LICENSE
+++ /dev/null
@@ -1,116 +0,0 @@
-CC0 1.0 Universal
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator and
-subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for the
-purpose of contributing to a commons of creative, cultural and scientific
-works ("Commons") that the public can reliably and without fear of later
-claims of infringement build upon, modify, incorporate in other works, reuse
-and redistribute as freely as possible in any form whatsoever and for any
-purposes, including without limitation commercial purposes. These owners may
-contribute to the Commons to promote the ideal of a free culture and the
-further production of creative, cultural and scientific works, or to gain
-reputation or greater distribution for their Work in part through the use and
-efforts of others.
-
-For these and/or other purposes and motivations, and without any expectation
-of additional consideration or compensation, the person associating CC0 with a
-Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
-and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
-and publicly distribute the Work under its terms, with knowledge of his or her
-Copyright and Related Rights in the Work and the meaning and intended legal
-effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not limited
-to, the following:
-
- i. the right to reproduce, adapt, distribute, perform, display, communicate,
- and translate a Work;
-
- ii. moral rights retained by the original author(s) and/or performer(s);
-
- iii. publicity and privacy rights pertaining to a person's image or likeness
- depicted in a Work;
-
- iv. rights protecting against unfair competition in regards to a Work,
- subject to the limitations in paragraph 4(a), below;
-
- v. rights protecting the extraction, dissemination, use and reuse of data in
- a Work;
-
- vi. database rights (such as those arising under Directive 96/9/EC of the
- European Parliament and of the Council of 11 March 1996 on the legal
- protection of databases, and under any national implementation thereof,
- including any amended or successor version of such directive); and
-
- vii. other similar, equivalent or corresponding rights throughout the world
- based on applicable law or treaty, and any national implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention of,
-applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
-unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
-and Related Rights and associated claims and causes of action, whether now
-known or unknown (including existing as well as future claims and causes of
-action), in the Work (i) in all territories worldwide, (ii) for the maximum
-duration provided by applicable law or treaty (including future time
-extensions), (iii) in any current or future medium and for any number of
-copies, and (iv) for any purpose whatsoever, including without limitation
-commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
-the Waiver for the benefit of each member of the public at large and to the
-detriment of Affirmer's heirs and successors, fully intending that such Waiver
-shall not be subject to revocation, rescission, cancellation, termination, or
-any other legal or equitable action to disrupt the quiet enjoyment of the Work
-by the public as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason be
-judged legally invalid or ineffective under applicable law, then the Waiver
-shall be preserved to the maximum extent permitted taking into account
-Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
-is so judged Affirmer hereby grants to each affected person a royalty-free,
-non transferable, non sublicensable, non exclusive, irrevocable and
-unconditional license to exercise Affirmer's Copyright and Related Rights in
-the Work (i) in all territories worldwide, (ii) for the maximum duration
-provided by applicable law or treaty (including future time extensions), (iii)
-in any current or future medium and for any number of copies, and (iv) for any
-purpose whatsoever, including without limitation commercial, advertising or
-promotional purposes (the "License"). The License shall be deemed effective as
-of the date CC0 was applied by Affirmer to the Work. Should any part of the
-License for any reason be judged legally invalid or ineffective under
-applicable law, such partial invalidity or ineffectiveness shall not
-invalidate the remainder of the License, and in such case Affirmer hereby
-affirms that he or she will not (i) exercise any of his or her remaining
-Copyright and Related Rights in the Work or (ii) assert any associated claims
-and causes of action with respect to the Work, in either case contrary to
-Affirmer's express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
- a. No trademark or patent rights held by Affirmer are waived, abandoned,
- surrendered, licensed or otherwise affected by this document.
-
- b. Affirmer offers the Work as-is and makes no representations or warranties
- of any kind concerning the Work, express, implied, statutory or otherwise,
- including without limitation warranties of title, merchantability, fitness
- for a particular purpose, non infringement, or the absence of latent or
- other defects, accuracy, or the present or absence of errors, whether or not
- discoverable, all to the greatest extent permissible under applicable law.
-
- c. Affirmer disclaims responsibility for clearing rights of other persons
- that may apply to the Work or any use thereof, including without limitation
- any person's Copyright and Related Rights in the Work. Further, Affirmer
- disclaims responsibility for obtaining any necessary consents, permissions
- or other rights required for any use of the Work.
-
- d. Affirmer understands and acknowledges that Creative Commons is not a
- party to this document and has no duty or obligation with respect to this
- CC0 or use of the Work.
-
-For more information, please see
-
diff --git a/tests/bats/bats-assert/README.md b/tests/bats/bats-assert/README.md
deleted file mode 100644
index 6f1f80e..0000000
--- a/tests/bats/bats-assert/README.md
+++ /dev/null
@@ -1,788 +0,0 @@
-# bats-assert
-
-[](https://github.com/bats-core/bats-assert/blob/master/LICENSE)
-[](https://github.com/bats-core/bats-assert/releases/latest)
-[](https://www.npmjs.com/package/bats-assert)
-[](https://github.com/bats-core/bats-assert/actions/workflows/test.yml)
-
-`bats-assert` is a helper library providing common assertions for [Bats][bats].
-
-- [Install](#install)
-- [Usage](#usage)
-- [Options](#options)
-- [Full Assertion API](#full-assertion-api)
-
-In the context of this project, an [assertion][wikipedia-assertions] is a function that perform a test and returns `1` on failure or `0` on success.
-To make debugging easier, the assertion also outputs relevant information on failure.
-The output is [formatted][bats-support-output] for readability.
-To make assertions usable outside of `@test` blocks, the output is sent to [stderr][wikipedia-stderr].
-
-The most recent invocation of Bats' `run` function is used for testing assertions on output and status code.
-
-[wikipedia-assertions]: https://en.wikipedia.org/wiki/Assertion_(software_development)
-[wikipedia-stderr]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)
-
-## Install
-
-This project has one dependency, for output formatting: [`bats-support`][bats-support]
-
-Read the [shared documentation][bats-docs] to learn how to install and load both libraries.
-
-## Usage
-
-This project provides the following functions:
-
- - [assert](#assert) / [refute](#refute) Assert a given expression evaluates to `true` or `false`.
- - [assert_equal](#assert_equal) Assert two parameters are equal.
- - [assert_not_equal](#assert_not_equal) Assert two parameters are not equal.
- - [assert_success](#assert_success) / [assert_failure](#assert_failure) Assert exit status is `0` or `1`.
- - [assert_output](#assert_output) / [refute_output](#refute_output) Assert output does (or does not) contain given content.
- - [assert_line](#assert_line) / [refute_line](#refute_line) Assert a specific line of output does (or does not) contain given content.
- - [assert_regex](#assert_regex) / [refute_regex](#refute_regex) Assert a parameter does (or does not) match given pattern.
-
-These commands are described in more detail below.
-
-## Options
-
-For functions that have options, `--` disables option parsing for the remaining arguments to allow using arguments identical to one of the allowed options.
-
-```bash
-assert_output -- '-p'
-```
-
-Specifying `--` as an argument is similarly simple.
-
-```bash
-refute_line -- '--'
-```
-
-
-## Full Assertion API
-
-### `assert`
-
-Fail if the given expression evaluates to false.
-
-> _**Note**:
-> The expression must be a simple command.
-> [Compound commands][bash-comp-cmd], such as `[[`, can be used only when executed with `bash -c`._
-
-```bash
-@test 'assert()' {
- assert [ 1 -lt 0 ]
-}
-```
-
-On failure, the failed expression is displayed.
-
-```
--- assertion failed --
-expression : [ 1 -lt 0 ]
---
-```
-
-
-### `refute`
-
-Fail if the given expression evaluates to true.
-
-> _**Note**
-> The expression must be a simple command.
-> [Compound commands][bash-comp-cmd], such as `[[`, can be used only when executed with `bash -c`._
-
-```bash
-@test 'refute()' {
- refute [ 1 -gt 0 ]
-}
-```
-
-On failure, the successful expression is displayed.
-
-```
--- assertion succeeded, but it was expected to fail --
-expression : [ 1 -gt 0 ]
---
-```
-
-
-### `assert_equal`
-
-Fail if the two parameters, actual and expected value respectively, do not equal.
-
-```bash
-@test 'assert_equal()' {
- assert_equal 'have' 'want'
-}
-```
-
-On failure, the expected and actual values are displayed.
-
-```
--- values do not equal --
-expected : want
-actual : have
---
-```
-
-If either value is longer than one line both are displayed in *multi-line* format.
-
-
-### `assert_not_equal`
-
-Fail if the two parameters, actual and unexpected value respectively, are equal.
-
-```bash
-@test 'assert_not_equal()' {
- assert_not_equal 'foobar' 'foobar'
-}
-```
-
-On failure, the expected and actual values are displayed.
-
-```
--- values should not be equal --
-unexpected : foobar
-actual : foobar
---
-```
-
-If either value is longer than one line both are displayed in *multi-line* format.
-
-
-### `assert_success`
-
-Fail if `$status` is not 0.
-
-```bash
-@test 'assert_success() status only' {
- run bash -c "echo 'Error!'; exit 1"
- assert_success
-}
-```
-
-On failure, `$status` and `$output` are displayed.
-
-```
--- command failed --
-status : 1
-output : Error!
---
-```
-
-If `$output` is longer than one line, it is displayed in *multi-line* format.
-
-
-### `assert_failure`
-
-Fail if `$status` is 0.
-
-```bash
-@test 'assert_failure() status only' {
- run echo 'Success!'
- assert_failure
-}
-```
-
-On failure, `$output` is displayed.
-
-```
--- command succeeded, but it was expected to fail --
-output : Success!
---
-```
-
-If `$output` is longer than one line, it is displayed in *multi-line* format.
-
-#### Expected status
-
-When one parameter is specified, fail if `$status` does not equal the expected status specified by the parameter.
-
-```bash
-@test 'assert_failure() with expected status' {
- run bash -c "echo 'Error!'; exit 1"
- assert_failure 2
-}
-```
-
-On failure, the expected and actual status, and `$output` are displayed.
-
-```
--- command failed as expected, but status differs --
-expected : 2
-actual : 1
-output : Error!
---
-```
-
-If `$output` is longer than one line, it is displayed in *multi-line* format.
-
-
-### `assert_output`
-
-This function helps to verify that a command or function produces the correct output by checking that the specified expected output matches the actual output.
-Matching can be literal (default), partial or regular expression.
-This function is the logical complement of `refute_output`.
-
-#### Literal matching
-
-By default, literal matching is performed.
-The assertion fails if `$output` does not equal the expected output.
-
-```bash
-@test 'assert_output()' {
- run echo 'have'
- assert_output 'want'
-}
-```
-
-On failure, the expected and actual output are displayed.
-
-```
--- output differs --
-expected : want
-actual : have
---
-```
-
-If either value is longer than one line both are displayed in *multi-line* format.
-
-#### Existence
-
-To assert that any (non-empty) output exists at all, simply omit the matching argument.
-
-```bash
-@test 'assert_output()' {
- run echo 'have'
- assert_output
-}
-```
-
-On failure, an error message is displayed.
-
-```
--- no output --
-expected non-empty output, but output was empty
---
-```
-
-#### Partial matching
-
-Partial matching can be enabled with the `--partial` option (`-p` for short).
-When used, the assertion fails if the expected *substring* is not found in `$output`.
-
-```bash
-@test 'assert_output() partial matching' {
- run echo 'ERROR: no such file or directory'
- assert_output --partial 'SUCCESS'
-}
-```
-
-On failure, the substring and the output are displayed.
-
-```
--- output does not contain substring --
-substring : SUCCESS
-output : ERROR: no such file or directory
---
-```
-
-This option and regular expression matching (`--regexp` or `-e`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-#### Regular expression matching
-
-Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-When used, the assertion fails if the *extended regular expression* does not match `$output`.
-
-> _**Note**:
-> The anchors `^` and `$` bind to the beginning and the end of the entire output (not individual lines), respectively._
-
-```bash
-@test 'assert_output() regular expression matching' {
- run echo 'Foobar 0.1.0'
- assert_output --regexp '^Foobar v[0-9]+\.[0-9]+\.[0-9]$'
-}
-```
-
-On failure, the regular expression and the output are displayed.
-
-```
--- regular expression does not match output --
-regexp : ^Foobar v[0-9]+\.[0-9]+\.[0-9]$
-output : Foobar 0.1.0
---
-```
-
-An error is displayed if the specified extended regular expression is invalid.
-
-This option and partial matching (`--partial` or `-p`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-#### Standard Input, HereDocs and HereStrings
-
-The expected output can be specified via standard input (also heredoc/herestring) with the `-`/`--stdin` option.
-
-```bash
-@test 'assert_output() with pipe' {
- run echo 'hello'
- echo 'hello' | assert_output -
-}
-
-@test 'assert_output() with herestring' {
- run echo 'hello'
- assert_output - <<< hello
-}
-```
-
-
-### `refute_output`
-
-This function helps to verify that a command or function produces the correct output by checking that the specified unexpected output does not match the actual output.
-Matching can be literal (default), partial or regular expression.
-This function is the logical complement of `assert_output`.
-
-#### Literal matching
-
-By default, literal matching is performed.
-The assertion fails if `$output` equals the unexpected output.
-
-```bash
-@test 'refute_output()' {
- run echo 'want'
- refute_output 'want'
-}
-```
-
-On failure, the output is displayed.
-
-```
--- output equals, but it was expected to differ --
-output : want
---
-```
-
-If output is longer than one line it is displayed in *multi-line* format.
-
-#### Existence
-
-To assert that there is no output at all, simply omit the matching argument.
-
-```bash
-@test 'refute_output()' {
- run foo --silent
- refute_output
-}
-```
-
-On failure, an error message is displayed.
-
-```
--- unexpected output --
-expected no output, but output was non-empty
---
-```
-
-#### Partial matching
-
-Partial matching can be enabled with the `--partial` option (`-p` for short).
-When used, the assertion fails if the unexpected *substring* is found in `$output`.
-
-```bash
-@test 'refute_output() partial matching' {
- run echo 'ERROR: no such file or directory'
- refute_output --partial 'ERROR'
-}
-```
-
-On failure, the substring and the output are displayed.
-
-```
--- output should not contain substring --
-substring : ERROR
-output : ERROR: no such file or directory
---
-```
-
-This option and regular expression matching (`--regexp` or `-e`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-#### Regular expression matching
-
-Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-When used, the assertion fails if the *extended regular expression* matches `$output`.
-
-> _**Note**:
-> The anchors `^` and `$` bind to the beginning and the end of the entire output (not individual lines), respectively._
-
-```bash
-@test 'refute_output() regular expression matching' {
- run echo 'Foobar v0.1.0'
- refute_output --regexp '^Foobar v[0-9]+\.[0-9]+\.[0-9]$'
-}
-```
-
-On failure, the regular expression and the output are displayed.
-
-```
--- regular expression should not match output --
-regexp : ^Foobar v[0-9]+\.[0-9]+\.[0-9]$
-output : Foobar v0.1.0
---
-```
-
-An error is displayed if the specified extended regular expression is invalid.
-
-This option and partial matching (`--partial` or `-p`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-#### Standard Input, HereDocs and HereStrings
-
-The unexpected output can be specified via standard input (also heredoc/herestring) with the `-`/`--stdin` option.
-
-```bash
-@test 'refute_output() with pipe' {
- run echo 'hello'
- echo 'world' | refute_output -
-}
-
-@test 'refute_output() with herestring' {
- run echo 'hello'
- refute_output - <<< world
-}
-```
-
-
-### `assert_line`
-
-Similarly to `assert_output`, this function helps to verify that a command or function produces the correct output.
-It checks that the expected line appears in the output (default) or in a specific line of it.
-Matching can be literal (default), partial or regular expression.
-This function is the logical complement of `refute_line`.
-
-> _**Warning**:
-> Due to a [bug in Bats][bats-93], empty lines are discarded from `${lines[@]}`,
-> causing line indices to change and preventing testing for empty lines._
-
-[bats-93]: https://github.com/sstephenson/bats/pull/93
-
-#### Looking for a line in the output
-
-By default, the entire output is searched for the expected line.
-The assertion fails if the expected line is not found in `${lines[@]}`.
-
-```bash
-@test 'assert_line() looking for line' {
- run echo $'have-0\nhave-1\nhave-2'
- assert_line 'want'
-}
-```
-
-On failure, the expected line and the output are displayed.
-
-> _**Warning**:
-> The output displayed does not contain empty lines.
-> See the Warning above for more._
-
-```
--- output does not contain line --
-line : want
-output (3 lines):
- have-0
- have-1
- have-2
---
-```
-
-If output is not longer than one line, it is displayed in *two-column* format.
-
-#### Matching a specific line
-
-When the `--index ` option is used (`-n ` for short), the expected line is matched only against the line identified by the given index.
-The assertion fails if the expected line does not equal `${lines[]}`.
-
-```bash
-@test 'assert_line() specific line' {
- run echo $'have-0\nhave-1\nhave-2'
- assert_line --index 1 'want-1'
-}
-```
-
-On failure, the index and the compared lines are displayed.
-
-```
--- line differs --
-index : 1
-expected : want-1
-actual : have-1
---
-```
-
-#### Partial matching
-
-Partial matching can be enabled with the `--partial` option (`-p` for short).
-When used, a match fails if the expected *substring* is not found in the matched line.
-
-```bash
-@test 'assert_line() partial matching' {
- run echo $'have 1\nhave 2\nhave 3'
- assert_line --partial 'want'
-}
-```
-
-On failure, the same details are displayed as for literal matching, except that the substring replaces the expected line.
-
-```
--- no output line contains substring --
-substring : want
-output (3 lines):
- have 1
- have 2
- have 3
---
-```
-
-This option and regular expression matching (`--regexp` or `-e`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-#### Regular expression matching
-
-Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-When used, a match fails if the *extended regular expression* does not match the line being tested.
-
-> _**Note**:
-> As expected, the anchors `^` and `$` bind to the beginning and the end of the matched line, respectively._
-
-```bash
-@test 'assert_line() regular expression matching' {
- run echo $'have-0\nhave-1\nhave-2'
- assert_line --index 1 --regexp '^want-[0-9]$'
-}
-```
-
-On failure, the same details are displayed as for literal matching, except that the regular expression replaces the expected line.
-
-```
--- regular expression does not match line --
-index : 1
-regexp : ^want-[0-9]$
-line : have-1
---
-```
-
-An error is displayed if the specified extended regular expression is invalid.
-
-This option and partial matching (`--partial` or `-p`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-
-### `refute_line`
-
-Similarly to `refute_output`, this function helps to verify that a command or function produces the correct output.
-It checks that the unexpected line does not appear in the output (default) or in a specific line of it.
-Matching can be literal (default), partial or regular expression.
-This function is the logical complement of `assert_line`.
-
-> _**Warning**:
-> Due to a [bug in Bats][bats-93], empty lines are discarded from `${lines[@]}`,
-> causing line indices to change and preventing testing for empty lines._
-
-[bats-93]: https://github.com/sstephenson/bats/pull/93
-
-#### Looking for a line in the output
-
-By default, the entire output is searched for the unexpected line.
-The assertion fails if the unexpected line is found in `${lines[@]}`.
-
-```bash
-@test 'refute_line() looking for line' {
- run echo $'have-0\nwant\nhave-2'
- refute_line 'want'
-}
-```
-
-On failure, the unexpected line, the index of its first match and the output with the matching line highlighted are displayed.
-
-> _**Warning**:
-> The output displayed does not contain empty lines.
-> See the Warning above for more._
-
-```
--- line should not be in output --
-line : want
-index : 1
-output (3 lines):
- have-0
-> want
- have-2
---
-```
-
-If output is not longer than one line, it is displayed in *two-column* format.
-
-#### Matching a specific line
-
-When the `--index ` option is used (`-n ` for short), the unexpected line is matched only against the line identified by the given index.
-The assertion fails if the unexpected line equals `${lines[]}`.
-
-```bash
-@test 'refute_line() specific line' {
- run echo $'have-0\nwant-1\nhave-2'
- refute_line --index 1 'want-1'
-}
-```
-
-On failure, the index and the unexpected line are displayed.
-
-```
--- line should differ --
-index : 1
-line : want-1
---
-```
-
-#### Partial matching
-
-Partial matching can be enabled with the `--partial` option (`-p` for short).
-When used, a match fails if the unexpected *substring* is found in the matched line.
-
-```bash
-@test 'refute_line() partial matching' {
- run echo $'have 1\nwant 2\nhave 3'
- refute_line --partial 'want'
-}
-```
-
-On failure, in addition to the details of literal matching, the substring is also displayed.
-When used with `--index ` the substring replaces the unexpected line.
-
-```
--- no line should contain substring --
-substring : want
-index : 1
-output (3 lines):
- have 1
-> want 2
- have 3
---
-```
-
-This option and regular expression matching (`--regexp` or `-e`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-#### Regular expression matching
-
-Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-When used, a match fails if the *extended regular expression* matches the line being tested.
-
-> _**Note**:
-> As expected, the anchors `^` and `$` bind to the beginning and the end of the matched line, respectively._
-
-```bash
-@test 'refute_line() regular expression matching' {
- run echo $'Foobar v0.1.0\nRelease date: 2015-11-29'
- refute_line --index 0 --regexp '^Foobar v[0-9]+\.[0-9]+\.[0-9]$'
-}
-```
-
-On failure, in addition to the details of literal matching, the regular expression is also displayed.
-When used with `--index ` the regular expression replaces the unexpected line.
-
-```
--- regular expression should not match line --
-index : 0
-regexp : ^Foobar v[0-9]+\.[0-9]+\.[0-9]$
-line : Foobar v0.1.0
---
-```
-
-An error is displayed if the specified extended regular expression is invalid.
-
-This option and partial matching (`--partial` or `-p`) are mutually exclusive.
-An error is displayed when used simultaneously.
-
-### `assert_regex`
-
-This function is similar to `assert_equal` but uses pattern matching instead of
-equality, by wrapping `[[ value =~ pattern ]]`.
-
-Fail if the value (first parameter) does not match the pattern (second
-parameter).
-
-```bash
-@test 'assert_regex()' {
- assert_regex 'what' 'x$'
-}
-```
-
-On failure, the value and the pattern are displayed.
-
-```
--- values does not match regular expression --
-value : what
-pattern : x$
---
-```
-
-If the value is longer than one line then it is displayed in *multi-line*
-format.
-
-An error is displayed if the specified extended regular expression is invalid.
-
-For description of the matching behavior, refer to the documentation of the
-`=~` operator in the [Bash manual][bash-conditional].
-
-> _**Note**:
-> the `BASH_REMATCH` array is available immediately after the assertion succeeds but is fragile;
-> i.e. prone to being overwritten as a side effect of other actions._
-
-### `refute_regex`
-
-This function is similar to `refute_equal` but uses pattern matching instead of
-equality, by wrapping `! [[ value =~ pattern ]]`.
-
-Fail if the value (first parameter) matches the pattern (second parameter).
-
-```bash
-@test 'refute_regex()' {
- refute_regex 'WhatsApp' 'Threema'
-}
-```
-
-On failure, the value, the pattern and the match are displayed.
-
-```
-@test 'refute_regex()' {
- refute_regex 'WhatsApp' 'What.'
-}
-
--- value matches regular expression --
-value : WhatsApp
-pattern : What.
-match : Whats
-case : sensitive
---
-```
-
-If the value or pattern is longer than one line then it is displayed in
-*multi-line* format.
-
-An error is displayed if the specified extended regular expression is invalid.
-
-For description of the matching behavior, refer to the documentation of the
-`=~` operator in the [Bash manual][bash-conditional].
-
-> _**Note**:
-> the `BASH_REMATCH` array is available immediately after the assertion fails but is fragile;
-> i.e. prone to being overwritten as a side effect of other actions like calling `run`.
-> Thus, it's good practice to avoid using `BASH_REMATCH` in conjunction with `refute_regex()`.
-> The valuable information the array contains is the matching part of the value which is printed in the failing test log, as mentioned above._
-
-
-
-[bats]: https://github.com/bats-core/bats-core
-[bash-comp-cmd]: https://www.gnu.org/software/bash/manual/bash.html#Compound-Commands
-[bash-conditional]: https://www.gnu.org/software/bash/manual/bash.html#Conditional-Constructs
-
-[bats-docs]: https://bats-core.readthedocs.io/
-[bats-support-output]: https://github.com/bats-core/bats-support#output-formatting
-[bats-support]: https://github.com/bats-core/bats-support
diff --git a/tests/bats/bats-assert/load.bash b/tests/bats/bats-assert/load.bash
deleted file mode 100644
index c67d9e8..0000000
--- a/tests/bats/bats-assert/load.bash
+++ /dev/null
@@ -1,33 +0,0 @@
-# bats-assert - Common assertions for Bats
-#
-# Written in 2016 by Zoltan Tombol
-#
-# To the extent possible under law, the author(s) have dedicated all
-# copyright and related and neighboring rights to this software to the
-# public domain worldwide. This software is distributed without any
-# warranty.
-#
-# You should have received a copy of the CC0 Public Domain Dedication
-# along with this software. If not, see
-# .
-#
-# Assertions are functions that perform a test and output relevant
-# information on failure to help debugging. They return 1 on failure
-# and 0 otherwise.
-#
-# All output is formatted for readability using the functions of
-# `output.bash' and sent to the standard error.
-
-# shellcheck disable=1090
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/refute.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert_equal.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert_not_equal.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert_success.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert_failure.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert_output.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/refute_output.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert_line.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/refute_line.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/assert_regex.bash"
-source "$(dirname "${BASH_SOURCE[0]}")/src/refute_regex.bash"
diff --git a/tests/bats/bats-assert/package-lock.json b/tests/bats/bats-assert/package-lock.json
deleted file mode 100644
index 8f0dcc6..0000000
--- a/tests/bats/bats-assert/package-lock.json
+++ /dev/null
@@ -1,36 +0,0 @@
-{
- "name": "bats-assert",
- "version": "2.1.0",
- "lockfileVersion": 3,
- "requires": true,
- "packages": {
- "": {
- "name": "bats-assert",
- "version": "2.1.0",
- "license": "CC0-1.0",
- "devDependencies": {
- "bats": "^1",
- "bats-support": "^0.3"
- },
- "peerDependencies": {
- "bats": "0.4 || ^1",
- "bats-support": "^0.3"
- }
- },
- "node_modules/bats": {
- "version": "1.9.0",
- "resolved": "https://registry.npmjs.org/bats/-/bats-1.9.0.tgz",
- "integrity": "sha512-Z5BJaAmmHv/ujj7obhjEzJ//OL+ZtjVq0iRnHu+2fE9OeUaPMbJpBgYiOdNbDrG3E2hqe84/AXNnS/UiXl/UcA==",
- "dev": true,
- "bin": {
- "bats": "bin/bats"
- }
- },
- "node_modules/bats-support": {
- "version": "0.3.0",
- "resolved": "git+ssh://git@github.com/jasonkarns/bats-support.git#24a72e14349690bcbf7c151b9d2d1cdd32d36eb1",
- "integrity": "sha512-42f2THEaN02dVj7Zhj0C4AM5FdePq3YPlXvnu/fKUQwCv1qM2dyACBKFXQkLw9QMzhDmwuFcke90XwHMUsBjGQ==",
- "dev": true
- }
- }
-}
diff --git a/tests/bats/bats-assert/package.json b/tests/bats/bats-assert/package.json
deleted file mode 100644
index 7048995..0000000
--- a/tests/bats/bats-assert/package.json
+++ /dev/null
@@ -1,48 +0,0 @@
-{
- "name": "bats-assert",
- "version": "2.1.0",
- "description": "Common assertions for Bats",
- "homepage": "https://github.com/bats-core/bats-assert",
- "license": "CC0-1.0",
- "author": "Zoltán Tömböl (https://github.com/ztombol)",
- "contributors": [
- "Sam Stephenson (http://sstephenson.us/)",
- "Jason Karns (http://jason.karns.name)",
- "Mislav Marohnić (http://mislav.net/)",
- "Tim Pope (https://github.com/tpope)"
- ],
- "repository": "github:bats-core/bats-assert",
- "bugs": "https://github.com/bats-core/bats-assert/issues",
- "directories": {
- "lib": "src",
- "test": "test"
- },
- "files": [
- "load.bash",
- "src"
- ],
- "scripts": {
- "test": "bats ${CI+-t} test",
- "postversion": "npm publish",
- "prepublishOnly": "npm run publish:github",
- "publish:github": "git push --follow-tags"
- },
- "devDependencies": {
- "bats": "^1",
- "bats-support": "^0.3"
- },
- "peerDependencies": {
- "bats": "0.4 || ^1",
- "bats-support": "^0.3"
- },
- "keywords": [
- "bats",
- "bash",
- "shell",
- "test",
- "unit",
- "assert",
- "assertion",
- "helper"
- ]
-}
diff --git a/tests/bats/bats-assert/src/assert.bash b/tests/bats/bats-assert/src/assert.bash
deleted file mode 100644
index 0260ce2..0000000
--- a/tests/bats/bats-assert/src/assert.bash
+++ /dev/null
@@ -1,42 +0,0 @@
-# assert
-# ======
-#
-# Summary: Fail if the given expression evaluates to false.
-#
-# Usage: assert
-
-# Options:
-# The expression to evaluate for truthiness.
-# *__Note:__ The expression must be a simple command.
-# [Compound commands](https://www.gnu.org/software/bash/manual/bash.html#Compound-Commands),
-# such as `[[`, can be used only when executed with `bash -c`.*
-#
-# IO:
-# STDERR - the failed expression, on failure
-# Globals:
-# none
-# Returns:
-# 0 - if expression evaluates to true
-# 1 - otherwise
-#
-# ```bash
-# @test 'assert()' {
-# touch '/var/log/test.log'
-# assert [ -e '/var/log/test.log' ]
-# }
-# ```
-#
-# On failure, the failed expression is displayed.
-#
-# ```
-# -- assertion failed --
-# expression : [ -e /var/log/test.log ]
-# --
-# ```
-assert() {
- if ! "$@"; then
- batslib_print_kv_single 10 'expression' "$*" \
- | batslib_decorate 'assertion failed' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/src/assert_equal.bash b/tests/bats/bats-assert/src/assert_equal.bash
deleted file mode 100644
index 4ef1297..0000000
--- a/tests/bats/bats-assert/src/assert_equal.bash
+++ /dev/null
@@ -1,42 +0,0 @@
-# assert_equal
-# ============
-#
-# Summary: Fail if the actual and expected values are not equal.
-#
-# Usage: assert_equal
-#
-# Options:
-# The value being compared.
-# The value to compare against.
-#
-# ```bash
-# @test 'assert_equal()' {
-# assert_equal 'have' 'want'
-# }
-# ```
-#
-# IO:
-# STDERR - expected and actual values, on failure
-# Globals:
-# none
-# Returns:
-# 0 - if values equal
-# 1 - otherwise
-#
-# On failure, the expected and actual values are displayed.
-#
-# ```
-# -- values do not equal --
-# expected : want
-# actual : have
-# --
-# ```
-assert_equal() {
- if [[ $1 != "$2" ]]; then
- batslib_print_kv_single_or_multi 8 \
- 'expected' "$2" \
- 'actual' "$1" \
- | batslib_decorate 'values do not equal' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/src/assert_failure.bash b/tests/bats/bats-assert/src/assert_failure.bash
deleted file mode 100644
index d906059..0000000
--- a/tests/bats/bats-assert/src/assert_failure.bash
+++ /dev/null
@@ -1,78 +0,0 @@
-# assert_failure
-# ==============
-#
-# Summary: Fail if `$status` is 0; or is not equal to the optionally provided status.
-#
-# Usage: assert_failure []
-#
-# Options:
-# The specific status code to check against.
-# If not provided, simply asserts status is != 0.
-#
-# IO:
-# STDERR - `$output`, on failure;
-# - also, `$status` and `expected_status`, if provided
-# Globals:
-# status
-# output
-# Returns:
-# 0 - if `$status' is 0,
-# or if expected_status is provided but does not equal `$status'
-# 1 - otherwise
-#
-# ```bash
-# @test 'assert_failure() status only' {
-# run echo 'Success!'
-# assert_failure
-# }
-# ```
-#
-# On failure, `$output` is displayed.
-#
-# ```
-# -- command succeeded, but it was expected to fail --
-# output : Success!
-# --
-# ```
-#
-# ## Expected status
-#
-# When `expected_status` is provided, fail if `$status` does not equal the `expected_status`.
-#
-# ```bash
-# @test 'assert_failure() with expected status' {
-# run bash -c "echo 'Error!'; exit 1"
-# assert_failure 2
-# }
-# ```
-#
-# On failure, both the expected and actual statuses, and `$output` are displayed.
-#
-# ```
-# -- command failed as expected, but status differs --
-# expected : 2
-# actual : 1
-# output : Error!
-# --
-# ```
-assert_failure() {
- : "${output?}"
- : "${status?}"
-
- (( $# > 0 )) && local -r expected="$1"
- if (( status == 0 )); then
- batslib_print_kv_single_or_multi 6 'output' "$output" \
- | batslib_decorate 'command succeeded, but it was expected to fail' \
- | fail
- elif (( $# > 0 )) && (( status != expected )); then
- { local -ir width=8
- batslib_print_kv_single "$width" \
- 'expected' "$expected" \
- 'actual' "$status"
- batslib_print_kv_single_or_multi "$width" \
- 'output' "$output"
- } \
- | batslib_decorate 'command failed as expected, but status differs' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/src/assert_line.bash b/tests/bats/bats-assert/src/assert_line.bash
deleted file mode 100644
index ee05bb8..0000000
--- a/tests/bats/bats-assert/src/assert_line.bash
+++ /dev/null
@@ -1,248 +0,0 @@
-# assert_line
-# ===========
-#
-# Summary: Fail if the expected line is not found in the output (default) or at a specific line number.
-#
-# Usage: assert_line [-n index] [-p | -e] [--]
-#
-# Options:
-# -n, --index Match the th line
-# -p, --partial Match if `expected` is a substring of `$output` or line
-# -e, --regexp Treat `expected` as an extended regular expression
-# The expected line string, substring, or regular expression
-#
-# IO:
-# STDERR - details, on failure
-# error message, on error
-# Globals:
-# output
-# lines
-# Returns:
-# 0 - if matching line found
-# 1 - otherwise
-#
-# Similarly to `assert_output`, this function verifies that a command or function produces the expected output.
-# (It is the logical complement of `refute_line`.)
-# It checks that the expected line appears in the output (default) or at a specific line number.
-# Matching can be literal (default), partial or regular expression.
-#
-# *__Warning:__
-# Due to a [bug in Bats][bats-93], empty lines are discarded from `${lines[@]}`,
-# causing line indices to change and preventing testing for empty lines.*
-#
-# [bats-93]: https://github.com/sstephenson/bats/pull/93
-#
-# ## Looking for a line in the output
-#
-# By default, the entire output is searched for the expected line.
-# The assertion fails if the expected line is not found in `${lines[@]}`.
-#
-# ```bash
-# @test 'assert_line() looking for line' {
-# run echo $'have-0\nhave-1\nhave-2'
-# assert_line 'want'
-# }
-# ```
-#
-# On failure, the expected line and the output are displayed.
-#
-# ```
-# -- output does not contain line --
-# line : want
-# output (3 lines):
-# have-0
-# have-1
-# have-2
-# --
-# ```
-#
-# ## Matching a specific line
-#
-# When the `--index ` option is used (`-n ` for short), the expected line is matched only against the line identified by the given index.
-# The assertion fails if the expected line does not equal `${lines[]}`.
-#
-# ```bash
-# @test 'assert_line() specific line' {
-# run echo $'have-0\nhave-1\nhave-2'
-# assert_line --index 1 'want-1'
-# }
-# ```
-#
-# On failure, the index and the compared lines are displayed.
-#
-# ```
-# -- line differs --
-# index : 1
-# expected : want-1
-# actual : have-1
-# --
-# ```
-#
-# ## Partial matching
-#
-# Partial matching can be enabled with the `--partial` option (`-p` for short).
-# When used, a match fails if the expected *substring* is not found in the matched line.
-#
-# ```bash
-# @test 'assert_line() partial matching' {
-# run echo $'have 1\nhave 2\nhave 3'
-# assert_line --partial 'want'
-# }
-# ```
-#
-# On failure, the same details are displayed as for literal matching, except that the substring replaces the expected line.
-#
-# ```
-# -- no output line contains substring --
-# substring : want
-# output (3 lines):
-# have 1
-# have 2
-# have 3
-# --
-# ```
-#
-# ## Regular expression matching
-#
-# Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-# When used, a match fails if the *extended regular expression* does not match the line being tested.
-#
-# *__Note__:
-# As expected, the anchors `^` and `$` bind to the beginning and the end (respectively) of the matched line.*
-#
-# ```bash
-# @test 'assert_line() regular expression matching' {
-# run echo $'have-0\nhave-1\nhave-2'
-# assert_line --index 1 --regexp '^want-[0-9]$'
-# }
-# ```
-#
-# On failure, the same details are displayed as for literal matching, except that the regular expression replaces the expected line.
-#
-# ```
-# -- regular expression does not match line --
-# index : 1
-# regexp : ^want-[0-9]$
-# line : have-1
-# --
-# ```
-# FIXME(ztombol): Display `${lines[@]}' instead of `$output'!
-assert_line() {
- local -i is_match_line=0
- local -i is_mode_partial=0
- local -i is_mode_regexp=0
- : "${lines?}"
-
- # Handle options.
- while (( $# > 0 )); do
- case "$1" in
- -n|--index)
- if (( $# < 2 )) || ! [[ $2 =~ ^-?([0-9]|[1-9][0-9]+)$ ]]; then
- echo "\`--index' requires an integer argument: \`$2'" \
- | batslib_decorate 'ERROR: assert_line' \
- | fail
- return $?
- fi
- is_match_line=1
- local -ri idx="$2"
- shift 2
- ;;
- -p|--partial) is_mode_partial=1; shift ;;
- -e|--regexp) is_mode_regexp=1; shift ;;
- --) shift; break ;;
- *) break ;;
- esac
- done
-
- if (( is_mode_partial )) && (( is_mode_regexp )); then
- echo "\`--partial' and \`--regexp' are mutually exclusive" \
- | batslib_decorate 'ERROR: assert_line' \
- | fail
- return $?
- fi
-
- # Arguments.
- local -r expected="$1"
-
- if (( is_mode_regexp == 1 )) && [[ '' =~ $expected ]] || (( $? == 2 )); then
- echo "Invalid extended regular expression: \`$expected'" \
- | batslib_decorate 'ERROR: assert_line' \
- | fail
- return $?
- fi
-
- # Matching.
- if (( is_match_line )); then
- # Specific line.
- if (( is_mode_regexp )); then
- if ! [[ ${lines[$idx]} =~ $expected ]]; then
- batslib_print_kv_single 6 \
- 'index' "$idx" \
- 'regexp' "$expected" \
- 'line' "${lines[$idx]}" \
- | batslib_decorate 'regular expression does not match line' \
- | fail
- fi
- elif (( is_mode_partial )); then
- if [[ ${lines[$idx]} != *"$expected"* ]]; then
- batslib_print_kv_single 9 \
- 'index' "$idx" \
- 'substring' "$expected" \
- 'line' "${lines[$idx]}" \
- | batslib_decorate 'line does not contain substring' \
- | fail
- fi
- else
- if [[ ${lines[$idx]} != "$expected" ]]; then
- batslib_print_kv_single 8 \
- 'index' "$idx" \
- 'expected' "$expected" \
- 'actual' "${lines[$idx]}" \
- | batslib_decorate 'line differs' \
- | fail
- fi
- fi
- else
- # Contained in output.
- if (( is_mode_regexp )); then
- local -i idx
- for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
- [[ ${lines[$idx]} =~ $expected ]] && return 0
- done
- { local -ar single=( 'regexp' "$expected" )
- local -ar may_be_multi=( 'output' "$output" )
- local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
- batslib_print_kv_single "$width" "${single[@]}"
- batslib_print_kv_single_or_multi "$width" "${may_be_multi[@]}"
- } \
- | batslib_decorate 'no output line matches regular expression' \
- | fail
- elif (( is_mode_partial )); then
- local -i idx
- for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
- [[ ${lines[$idx]} == *"$expected"* ]] && return 0
- done
- { local -ar single=( 'substring' "$expected" )
- local -ar may_be_multi=( 'output' "$output" )
- local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
- batslib_print_kv_single "$width" "${single[@]}"
- batslib_print_kv_single_or_multi "$width" "${may_be_multi[@]}"
- } \
- | batslib_decorate 'no output line contains substring' \
- | fail
- else
- local -i idx
- for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
- [[ ${lines[$idx]} == "$expected" ]] && return 0
- done
- { local -ar single=( 'line' "$expected" )
- local -ar may_be_multi=( 'output' "$output" )
- local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
- batslib_print_kv_single "$width" "${single[@]}"
- batslib_print_kv_single_or_multi "$width" "${may_be_multi[@]}"
- } \
- | batslib_decorate 'output does not contain line' \
- | fail
- fi
- fi
-}
diff --git a/tests/bats/bats-assert/src/assert_not_equal.bash b/tests/bats/bats-assert/src/assert_not_equal.bash
deleted file mode 100644
index 933bb71..0000000
--- a/tests/bats/bats-assert/src/assert_not_equal.bash
+++ /dev/null
@@ -1,42 +0,0 @@
-# assert_not_equal
-# ============
-#
-# Summary: Fail if the actual and unexpected values are equal.
-#
-# Usage: assert_not_equal
-#
-# Options:
-# The value being compared.
-# The value to compare against.
-#
-# ```bash
-# @test 'assert_not_equal()' {
-# assert_not_equal 'foo' 'foo'
-# }
-# ```
-#
-# IO:
-# STDERR - expected and actual values, on failure
-# Globals:
-# none
-# Returns:
-# 0 - if actual does not equal unexpected
-# 1 - otherwise
-#
-# On failure, the unexpected and actual values are displayed.
-#
-# ```
-# -- values should not be equal --
-# unexpected : foo
-# actual : foo
-# --
-# ```
-assert_not_equal() {
- if [[ "$1" == "$2" ]]; then
- batslib_print_kv_single_or_multi 10 \
- 'unexpected' "$2" \
- 'actual' "$1" \
- | batslib_decorate 'values should not be equal' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/src/assert_output.bash b/tests/bats/bats-assert/src/assert_output.bash
deleted file mode 100644
index 82d0a0c..0000000
--- a/tests/bats/bats-assert/src/assert_output.bash
+++ /dev/null
@@ -1,197 +0,0 @@
-# assert_output
-# =============
-#
-# Summary: Fail if `$output' does not match the expected output.
-#
-# Usage: assert_output [-p | -e] [- | [--] ]
-#
-# Options:
-# -p, --partial Match if `expected` is a substring of `$output`
-# -e, --regexp Treat `expected` as an extended regular expression
-# -, --stdin Read `expected` value from STDIN
-# The expected value, substring or regular expression
-#
-# IO:
-# STDIN - [=$1] expected output
-# STDERR - details, on failure
-# error message, on error
-# Globals:
-# output
-# Returns:
-# 0 - if output matches the expected value/partial/regexp
-# 1 - otherwise
-#
-# This function verifies that a command or function produces the expected output.
-# (It is the logical complement of `refute_output`.)
-# Output matching can be literal (the default), partial or by regular expression.
-# The expected output can be specified either by positional argument or read from STDIN by passing the `-`/`--stdin` flag.
-#
-# ## Literal matching
-#
-# By default, literal matching is performed.
-# The assertion fails if `$output` does not equal the expected output.
-#
-# ```bash
-# @test 'assert_output()' {
-# run echo 'have'
-# assert_output 'want'
-# }
-#
-# @test 'assert_output() with pipe' {
-# run echo 'hello'
-# echo 'hello' | assert_output -
-# }
-#
-# @test 'assert_output() with herestring' {
-# run echo 'hello'
-# assert_output - <<< hello
-# }
-# ```
-#
-# On failure, the expected and actual output are displayed.
-#
-# ```
-# -- output differs --
-# expected : want
-# actual : have
-# --
-# ```
-#
-# ## Existence
-#
-# To assert that any output exists at all, omit the `expected` argument.
-#
-# ```bash
-# @test 'assert_output()' {
-# run echo 'have'
-# assert_output
-# }
-# ```
-#
-# On failure, an error message is displayed.
-#
-# ```
-# -- no output --
-# expected non-empty output, but output was empty
-# --
-# ```
-#
-# ## Partial matching
-#
-# Partial matching can be enabled with the `--partial` option (`-p` for short).
-# When used, the assertion fails if the expected _substring_ is not found in `$output`.
-#
-# ```bash
-# @test 'assert_output() partial matching' {
-# run echo 'ERROR: no such file or directory'
-# assert_output --partial 'SUCCESS'
-# }
-# ```
-#
-# On failure, the substring and the output are displayed.
-#
-# ```
-# -- output does not contain substring --
-# substring : SUCCESS
-# output : ERROR: no such file or directory
-# --
-# ```
-#
-# ## Regular expression matching
-#
-# Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-# When used, the assertion fails if the *extended regular expression* does not match `$output`.
-#
-# *__Note__:
-# The anchors `^` and `$` bind to the beginning and the end (respectively) of the entire output;
-# not individual lines.*
-#
-# ```bash
-# @test 'assert_output() regular expression matching' {
-# run echo 'Foobar 0.1.0'
-# assert_output --regexp '^Foobar v[0-9]+\.[0-9]+\.[0-9]$'
-# }
-# ```
-#
-# On failure, the regular expression and the output are displayed.
-#
-# ```
-# -- regular expression does not match output --
-# regexp : ^Foobar v[0-9]+\.[0-9]+\.[0-9]$
-# output : Foobar 0.1.0
-# --
-# ```
-assert_output() {
- local -i is_mode_partial=0
- local -i is_mode_regexp=0
- local -i is_mode_nonempty=0
- local -i use_stdin=0
- : "${output?}"
-
- # Handle options.
- if (( $# == 0 )); then
- is_mode_nonempty=1
- fi
-
- while (( $# > 0 )); do
- case "$1" in
- -p|--partial) is_mode_partial=1; shift ;;
- -e|--regexp) is_mode_regexp=1; shift ;;
- -|--stdin) use_stdin=1; shift ;;
- --) shift; break ;;
- *) break ;;
- esac
- done
-
- if (( is_mode_partial )) && (( is_mode_regexp )); then
- echo "\`--partial' and \`--regexp' are mutually exclusive" \
- | batslib_decorate 'ERROR: assert_output' \
- | fail
- return $?
- fi
-
- # Arguments.
- local expected
- if (( use_stdin )); then
- expected="$(cat -)"
- else
- expected="${1-}"
- fi
-
- # Matching.
- if (( is_mode_nonempty )); then
- if [ -z "$output" ]; then
- echo 'expected non-empty output, but output was empty' \
- | batslib_decorate 'no output' \
- | fail
- fi
- elif (( is_mode_regexp )); then
- if [[ '' =~ $expected ]] || (( $? == 2 )); then
- echo "Invalid extended regular expression: \`$expected'" \
- | batslib_decorate 'ERROR: assert_output' \
- | fail
- elif ! [[ $output =~ $expected ]]; then
- batslib_print_kv_single_or_multi 6 \
- 'regexp' "$expected" \
- 'output' "$output" \
- | batslib_decorate 'regular expression does not match output' \
- | fail
- fi
- elif (( is_mode_partial )); then
- if [[ $output != *"$expected"* ]]; then
- batslib_print_kv_single_or_multi 9 \
- 'substring' "$expected" \
- 'output' "$output" \
- | batslib_decorate 'output does not contain substring' \
- | fail
- fi
- else
- if [[ $output != "$expected" ]]; then
- batslib_print_kv_single_or_multi 8 \
- 'expected' "$expected" \
- 'actual' "$output" \
- | batslib_decorate 'output differs' \
- | fail
- fi
- fi
-}
diff --git a/tests/bats/bats-assert/src/assert_regex.bash b/tests/bats/bats-assert/src/assert_regex.bash
deleted file mode 100644
index 17a7057..0000000
--- a/tests/bats/bats-assert/src/assert_regex.bash
+++ /dev/null
@@ -1,56 +0,0 @@
-# `assert_regex`
-#
-# This function is similar to `assert_equal` but uses pattern matching instead
-# of equality, by wrapping `[[ value =~ pattern ]]`.
-#
-# Fail if the value (first parameter) does not match the pattern (second
-# parameter).
-#
-# ```bash
-# @test 'assert_regex()' {
-# assert_regex 'what' 'x$'
-# }
-# ```
-#
-# On failure, the value and the pattern are displayed.
-#
-# ```
-# -- values does not match regular expression --
-# value : what
-# pattern : x$
-# --
-# ```
-#
-# If the value is longer than one line then it is displayed in *multi-line*
-# format.
-#
-# An error is displayed if the specified extended regular expression is invalid.
-#
-# For description of the matching behavior, refer to the documentation of the
-# `=~` operator in the
-# [Bash manual]: https://www.gnu.org/software/bash/manual/html_node/Conditional-Constructs.html.
-# Note that the `BASH_REMATCH` array is available immediately after the
-# assertion succeeds but is fragile, i.e. prone to being overwritten as a side
-# effect of other actions.
-assert_regex() {
- local -r value="${1}"
- local -r pattern="${2}"
-
- if [[ '' =~ ${pattern} ]]; (( ${?} == 2 )); then
- echo "Invalid extended regular expression: \`${pattern}'" \
- | batslib_decorate 'ERROR: assert_regex' \
- | fail
- elif ! [[ "${value}" =~ ${pattern} ]]; then
- if shopt -p nocasematch &>/dev/null; then
- local case_sensitive=insensitive
- else
- local case_sensitive=sensitive
- fi
- batslib_print_kv_single_or_multi 8 \
- 'value' "${value}" \
- 'pattern' "${pattern}" \
- 'case' "${case_sensitive}" \
- | batslib_decorate 'value does not match regular expression' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/src/assert_success.bash b/tests/bats/bats-assert/src/assert_success.bash
deleted file mode 100644
index a8b2a38..0000000
--- a/tests/bats/bats-assert/src/assert_success.bash
+++ /dev/null
@@ -1,44 +0,0 @@
-# assert_success
-# ==============
-#
-# Summary: Fail if `$status` is not 0.
-#
-# Usage: assert_success
-#
-# IO:
-# STDERR - `$status` and `$output`, on failure
-# Globals:
-# status
-# output
-# Returns:
-# 0 - if `$status' is 0
-# 1 - otherwise
-#
-# ```bash
-# @test 'assert_success() status only' {
-# run bash -c "echo 'Error!'; exit 1"
-# assert_success
-# }
-# ```
-#
-# On failure, `$status` and `$output` are displayed.
-#
-# ```
-# -- command failed --
-# status : 1
-# output : Error!
-# --
-# ```
-assert_success() {
- : "${output?}"
- : "${status?}"
-
- if (( status != 0 )); then
- { local -ir width=6
- batslib_print_kv_single "$width" 'status' "$status"
- batslib_print_kv_single_or_multi "$width" 'output' "$output"
- } \
- | batslib_decorate 'command failed' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/src/refute.bash b/tests/bats/bats-assert/src/refute.bash
deleted file mode 100644
index e7c47da..0000000
--- a/tests/bats/bats-assert/src/refute.bash
+++ /dev/null
@@ -1,42 +0,0 @@
-# refute
-# ======
-#
-# Summary: Fail if the given expression evaluates to true.
-#
-# Usage: refute
-#
-# Options:
-# The expression to evaluate for falsiness.
-# *__Note:__ The expression must be a simple command.
-# [Compound commands](https://www.gnu.org/software/bash/manual/bash.html#Compound-Commands),
-# such as `[[`, can be used only when executed with `bash -c`.*
-#
-# IO:
-# STDERR - the successful expression, on failure
-# Globals:
-# none
-# Returns:
-# 0 - if expression evaluates to false
-# 1 - otherwise
-#
-# ```bash
-# @test 'refute()' {
-# rm -f '/var/log/test.log'
-# refute [ -e '/var/log/test.log' ]
-# }
-# ```
-#
-# On failure, the successful expression is displayed.
-#
-# ```
-# -- assertion succeeded, but it was expected to fail --
-# expression : [ -e /var/log/test.log ]
-# --
-# ```
-refute() {
- if "$@"; then
- batslib_print_kv_single 10 'expression' "$*" \
- | batslib_decorate 'assertion succeeded, but it was expected to fail' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/src/refute_line.bash b/tests/bats/bats-assert/src/refute_line.bash
deleted file mode 100644
index 689bea1..0000000
--- a/tests/bats/bats-assert/src/refute_line.bash
+++ /dev/null
@@ -1,271 +0,0 @@
-# refute_line
-# ===========
-#
-# Summary: Fail if the unexpected line is found in the output (default) or at a specific line number.
-#
-# Usage: refute_line [-n index] [-p | -e] [--]
-#
-# Options:
-# -n, --index Match the th line
-# -p, --partial Match if `unexpected` is a substring of `$output` or line
-# -e, --regexp Treat `unexpected` as an extended regular expression
-# The unexpected line string, substring, or regular expression.
-#
-# IO:
-# STDERR - details, on failure
-# error message, on error
-# Globals:
-# output
-# lines
-# Returns:
-# 0 - if match not found
-# 1 - otherwise
-#
-# Similarly to `refute_output`, this function verifies that a command or function does not produce the unexpected output.
-# (It is the logical complement of `assert_line`.)
-# It checks that the unexpected line does not appear in the output (default) or at a specific line number.
-# Matching can be literal (default), partial or regular expression.
-#
-# *__Warning:__
-# Due to a [bug in Bats][bats-93], empty lines are discarded from `${lines[@]}`,
-# causing line indices to change and preventing testing for empty lines.*
-#
-# [bats-93]: https://github.com/sstephenson/bats/pull/93
-#
-# ## Looking for a line in the output
-#
-# By default, the entire output is searched for the unexpected line.
-# The assertion fails if the unexpected line is found in `${lines[@]}`.
-#
-# ```bash
-# @test 'refute_line() looking for line' {
-# run echo $'have-0\nwant\nhave-2'
-# refute_line 'want'
-# }
-# ```
-#
-# On failure, the unexpected line, the index of its first match and the output with the matching line highlighted are displayed.
-#
-# ```
-# -- line should not be in output --
-# line : want
-# index : 1
-# output (3 lines):
-# have-0
-# > want
-# have-2
-# --
-# ```
-#
-# ## Matching a specific line
-#
-# When the `--index ` option is used (`-n ` for short), the unexpected line is matched only against the line identified by the given index.
-# The assertion fails if the unexpected line equals `${lines[]}`.
-#
-# ```bash
-# @test 'refute_line() specific line' {
-# run echo $'have-0\nwant-1\nhave-2'
-# refute_line --index 1 'want-1'
-# }
-# ```
-#
-# On failure, the index and the unexpected line are displayed.
-#
-# ```
-# -- line should differ --
-# index : 1
-# line : want-1
-# --
-# ```
-#
-# ## Partial matching
-#
-# Partial matching can be enabled with the `--partial` option (`-p` for short).
-# When used, a match fails if the unexpected *substring* is found in the matched line.
-#
-# ```bash
-# @test 'refute_line() partial matching' {
-# run echo $'have 1\nwant 2\nhave 3'
-# refute_line --partial 'want'
-# }
-# ```
-#
-# On failure, in addition to the details of literal matching, the substring is also displayed.
-# When used with `--index ` the substring replaces the unexpected line.
-#
-# ```
-# -- no line should contain substring --
-# substring : want
-# index : 1
-# output (3 lines):
-# have 1
-# > want 2
-# have 3
-# --
-# ```
-#
-# ## Regular expression matching
-#
-# Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-# When used, a match fails if the *extended regular expression* matches the line being tested.
-#
-# *__Note__:
-# As expected, the anchors `^` and `$` bind to the beginning and the end (respectively) of the matched line.*
-#
-# ```bash
-# @test 'refute_line() regular expression matching' {
-# run echo $'Foobar v0.1.0\nRelease date: 2015-11-29'
-# refute_line --index 0 --regexp '^Foobar v[0-9]+\.[0-9]+\.[0-9]$'
-# }
-# ```
-#
-# On failure, in addition to the details of literal matching, the regular expression is also displayed.
-# When used with `--index ` the regular expression replaces the unexpected line.
-#
-# ```
-# -- regular expression should not match line --
-# index : 0
-# regexp : ^Foobar v[0-9]+\.[0-9]+\.[0-9]$
-# line : Foobar v0.1.0
-# --
-# ```
-# FIXME(ztombol): Display `${lines[@]}' instead of `$output'!
-refute_line() {
- local -i is_match_line=0
- local -i is_mode_partial=0
- local -i is_mode_regexp=0
- : "${lines?}"
-
- # Handle options.
- while (( $# > 0 )); do
- case "$1" in
- -n|--index)
- if (( $# < 2 )) || ! [[ $2 =~ ^-?([0-9]|[1-9][0-9]+)$ ]]; then
- echo "\`--index' requires an integer argument: \`$2'" \
- | batslib_decorate 'ERROR: refute_line' \
- | fail
- return $?
- fi
- is_match_line=1
- local -ri idx="$2"
- shift 2
- ;;
- -p|--partial) is_mode_partial=1; shift ;;
- -e|--regexp) is_mode_regexp=1; shift ;;
- --) shift; break ;;
- *) break ;;
- esac
- done
-
- if (( is_mode_partial )) && (( is_mode_regexp )); then
- echo "\`--partial' and \`--regexp' are mutually exclusive" \
- | batslib_decorate 'ERROR: refute_line' \
- | fail
- return $?
- fi
-
- # Arguments.
- local -r unexpected="$1"
-
- if (( is_mode_regexp == 1 )) && [[ '' =~ $unexpected ]] || (( $? == 2 )); then
- echo "Invalid extended regular expression: \`$unexpected'" \
- | batslib_decorate 'ERROR: refute_line' \
- | fail
- return $?
- fi
-
- # Matching.
- if (( is_match_line )); then
- # Specific line.
- if (( is_mode_regexp )); then
- if [[ ${lines[$idx]} =~ $unexpected ]]; then
- batslib_print_kv_single 6 \
- 'index' "$idx" \
- 'regexp' "$unexpected" \
- 'line' "${lines[$idx]}" \
- | batslib_decorate 'regular expression should not match line' \
- | fail
- fi
- elif (( is_mode_partial )); then
- if [[ ${lines[$idx]} == *"$unexpected"* ]]; then
- batslib_print_kv_single 9 \
- 'index' "$idx" \
- 'substring' "$unexpected" \
- 'line' "${lines[$idx]}" \
- | batslib_decorate 'line should not contain substring' \
- | fail
- fi
- else
- if [[ ${lines[$idx]} == "$unexpected" ]]; then
- batslib_print_kv_single 5 \
- 'index' "$idx" \
- 'line' "${lines[$idx]}" \
- | batslib_decorate 'line should differ' \
- | fail
- fi
- fi
- else
- # Line contained in output.
- if (( is_mode_regexp )); then
- local -i idx
- for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
- if [[ ${lines[$idx]} =~ $unexpected ]]; then
- { local -ar single=( 'regexp' "$unexpected" 'index' "$idx" )
- local -a may_be_multi=( 'output' "$output" )
- local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
- batslib_print_kv_single "$width" "${single[@]}"
- if batslib_is_single_line "${may_be_multi[1]}"; then
- batslib_print_kv_single "$width" "${may_be_multi[@]}"
- else
- may_be_multi[1]="$( printf '%s' "${may_be_multi[1]}" | batslib_prefix | batslib_mark '>' "$idx" )"
- batslib_print_kv_multi "${may_be_multi[@]}"
- fi
- } \
- | batslib_decorate 'no line should match the regular expression' \
- | fail
- return $?
- fi
- done
- elif (( is_mode_partial )); then
- local -i idx
- for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
- if [[ ${lines[$idx]} == *"$unexpected"* ]]; then
- { local -ar single=( 'substring' "$unexpected" 'index' "$idx" )
- local -a may_be_multi=( 'output' "$output" )
- local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
- batslib_print_kv_single "$width" "${single[@]}"
- if batslib_is_single_line "${may_be_multi[1]}"; then
- batslib_print_kv_single "$width" "${may_be_multi[@]}"
- else
- may_be_multi[1]="$( printf '%s' "${may_be_multi[1]}" | batslib_prefix | batslib_mark '>' "$idx" )"
- batslib_print_kv_multi "${may_be_multi[@]}"
- fi
- } \
- | batslib_decorate 'no line should contain substring' \
- | fail
- return $?
- fi
- done
- else
- local -i idx
- for (( idx = 0; idx < ${#lines[@]}; ++idx )); do
- if [[ ${lines[$idx]} == "$unexpected" ]]; then
- { local -ar single=( 'line' "$unexpected" 'index' "$idx" )
- local -a may_be_multi=( 'output' "$output" )
- local -ir width="$( batslib_get_max_single_line_key_width "${single[@]}" "${may_be_multi[@]}" )"
- batslib_print_kv_single "$width" "${single[@]}"
- if batslib_is_single_line "${may_be_multi[1]}"; then
- batslib_print_kv_single "$width" "${may_be_multi[@]}"
- else
- may_be_multi[1]="$( printf '%s' "${may_be_multi[1]}" | batslib_prefix | batslib_mark '>' "$idx" )"
- batslib_print_kv_multi "${may_be_multi[@]}"
- fi
- } \
- | batslib_decorate 'line should not be in output' \
- | fail
- return $?
- fi
- done
- fi
- fi
-}
diff --git a/tests/bats/bats-assert/src/refute_output.bash b/tests/bats/bats-assert/src/refute_output.bash
deleted file mode 100644
index 92d7e8f..0000000
--- a/tests/bats/bats-assert/src/refute_output.bash
+++ /dev/null
@@ -1,199 +0,0 @@
-# refute_output
-# =============
-#
-# Summary: Fail if `$output' matches the unexpected output.
-#
-# Usage: refute_output [-p | -e] [- | [--] ]
-#
-# Options:
-# -p, --partial Match if `unexpected` is a substring of `$output`
-# -e, --regexp Treat `unexpected` as an extended regular expression
-# -, --stdin Read `unexpected` value from STDIN
-# The unexpected value, substring, or regular expression
-#
-# IO:
-# STDIN - [=$1] unexpected output
-# STDERR - details, on failure
-# error message, on error
-# Globals:
-# output
-# Returns:
-# 0 - if output matches the unexpected value/partial/regexp
-# 1 - otherwise
-#
-# This function verifies that a command or function does not produce the unexpected output.
-# (It is the logical complement of `assert_output`.)
-# Output matching can be literal (the default), partial or by regular expression.
-# The unexpected output can be specified either by positional argument or read from STDIN by passing the `-`/`--stdin` flag.
-#
-# ## Literal matching
-#
-# By default, literal matching is performed.
-# The assertion fails if `$output` equals the unexpected output.
-#
-# ```bash
-# @test 'refute_output()' {
-# run echo 'want'
-# refute_output 'want'
-# }
-#
-# @test 'refute_output() with pipe' {
-# run echo 'hello'
-# echo 'world' | refute_output -
-# }
-#
-# @test 'refute_output() with herestring' {
-# run echo 'hello'
-# refute_output - <<< world
-# }
-# ```
-#
-# On failure, the output is displayed.
-#
-# ```
-# -- output equals, but it was expected to differ --
-# output : want
-# --
-# ```
-#
-# ## Existence
-#
-# To assert that there is no output at all, omit the matching argument.
-#
-# ```bash
-# @test 'refute_output()' {
-# run foo --silent
-# refute_output
-# }
-# ```
-#
-# On failure, an error message is displayed.
-#
-# ```
-# -- unexpected output --
-# expected no output, but output was non-empty
-# --
-# ```
-#
-# ## Partial matching
-#
-# Partial matching can be enabled with the `--partial` option (`-p` for short).
-# When used, the assertion fails if the unexpected _substring_ is found in `$output`.
-#
-# ```bash
-# @test 'refute_output() partial matching' {
-# run echo 'ERROR: no such file or directory'
-# refute_output --partial 'ERROR'
-# }
-# ```
-#
-# On failure, the substring and the output are displayed.
-#
-# ```
-# -- output should not contain substring --
-# substring : ERROR
-# output : ERROR: no such file or directory
-# --
-# ```
-#
-# ## Regular expression matching
-#
-# Regular expression matching can be enabled with the `--regexp` option (`-e` for short).
-# When used, the assertion fails if the *extended regular expression* matches `$output`.
-#
-# *__Note__:
-# The anchors `^` and `$` bind to the beginning and the end (respectively) of the entire output;
-# not individual lines.*
-#
-# ```bash
-# @test 'refute_output() regular expression matching' {
-# run echo 'Foobar v0.1.0'
-# refute_output --regexp '^Foobar v[0-9]+\.[0-9]+\.[0-9]$'
-# }
-# ```
-#
-# On failure, the regular expression and the output are displayed.
-#
-# ```
-# -- regular expression should not match output --
-# regexp : ^Foobar v[0-9]+\.[0-9]+\.[0-9]$
-# output : Foobar v0.1.0
-# --
-# ```
-refute_output() {
- local -i is_mode_partial=0
- local -i is_mode_regexp=0
- local -i is_mode_empty=0
- local -i use_stdin=0
- : "${output?}"
-
- # Handle options.
- if (( $# == 0 )); then
- is_mode_empty=1
- fi
-
- while (( $# > 0 )); do
- case "$1" in
- -p|--partial) is_mode_partial=1; shift ;;
- -e|--regexp) is_mode_regexp=1; shift ;;
- -|--stdin) use_stdin=1; shift ;;
- --) shift; break ;;
- *) break ;;
- esac
- done
-
- if (( is_mode_partial )) && (( is_mode_regexp )); then
- echo "\`--partial' and \`--regexp' are mutually exclusive" \
- | batslib_decorate 'ERROR: refute_output' \
- | fail
- return $?
- fi
-
- # Arguments.
- local unexpected
- if (( use_stdin )); then
- unexpected="$(cat -)"
- else
- unexpected="${1-}"
- fi
-
- if (( is_mode_regexp == 1 )) && [[ '' =~ $unexpected ]] || (( $? == 2 )); then
- echo "Invalid extended regular expression: \`$unexpected'" \
- | batslib_decorate 'ERROR: refute_output' \
- | fail
- return $?
- fi
-
- # Matching.
- if (( is_mode_empty )); then
- if [ -n "$output" ]; then
- batslib_print_kv_single_or_multi 6 \
- 'output' "$output" \
- | batslib_decorate 'output non-empty, but expected no output' \
- | fail
- fi
- elif (( is_mode_regexp )); then
- if [[ $output =~ $unexpected ]]; then
- batslib_print_kv_single_or_multi 6 \
- 'regexp' "$unexpected" \
- 'output' "$output" \
- | batslib_decorate 'regular expression should not match output' \
- | fail
- fi
- elif (( is_mode_partial )); then
- if [[ $output == *"$unexpected"* ]]; then
- batslib_print_kv_single_or_multi 9 \
- 'substring' "$unexpected" \
- 'output' "$output" \
- | batslib_decorate 'output should not contain substring' \
- | fail
- fi
- else
- if [[ $output == "$unexpected" ]]; then
- batslib_print_kv_single_or_multi 6 \
- 'output' "$output" \
- | batslib_decorate 'output equals, but it was expected to differ' \
- | fail
- fi
- fi
-}
diff --git a/tests/bats/bats-assert/src/refute_regex.bash b/tests/bats/bats-assert/src/refute_regex.bash
deleted file mode 100644
index 0918793..0000000
--- a/tests/bats/bats-assert/src/refute_regex.bash
+++ /dev/null
@@ -1,66 +0,0 @@
-# `refute_regex`
-#
-# This function is similar to `refute_equal` but uses pattern matching instead
-# of equality, by wrapping `! [[ value =~ pattern ]]`.
-#
-# Fail if the value (first parameter) matches the pattern (second parameter).
-#
-# ```bash
-# @test 'refute_regex()' {
-# refute_regex 'WhatsApp' 'Threema'
-# }
-# ```
-#
-# On failure, the value, the pattern and the match are displayed.
-#
-# ```
-# @test 'refute_regex()' {
-# refute_regex 'WhatsApp' 'What.'
-# }
-#
-# -- value matches regular expression --
-# value : WhatsApp
-# pattern : What.
-# match : Whats
-# case : sensitive
-# --
-# ```
-#
-# If the value or pattern is longer than one line then it is displayed in
-# *multi-line* format.
-#
-# An error is displayed if the specified extended regular expression is invalid.
-#
-# For description of the matching behavior, refer to the documentation of the
-# `=~` operator in the
-# [Bash manual]: https://www.gnu.org/software/bash/manual/html_node/Conditional-Constructs.html.
-#
-# Note that the `BASH_REMATCH` array is available immediately after the
-# assertion fails but is fragile, i.e. prone to being overwritten as a side
-# effect of other actions like calling `run`. Thus, it's good practice to avoid
-# using `BASH_REMATCH` in conjunction with `refute_regex()`. The valuable
-# information the array contains is the matching part of the value which is
-# printed in the failing test log, as mentioned above.
-refute_regex() {
- local -r value="${1}"
- local -r pattern="${2}"
-
- if [[ '' =~ ${pattern} ]] || (( ${?} == 2 )); then
- echo "Invalid extended regular expression: \`${pattern}'" \
- | batslib_decorate 'ERROR: refute_regex' \
- | fail
- elif [[ "${value}" =~ ${pattern} ]]; then
- if shopt -p nocasematch &>/dev/null; then
- local case_sensitive=insensitive
- else
- local case_sensitive=sensitive
- fi
- batslib_print_kv_single_or_multi 8 \
- 'value' "${value}" \
- 'pattern' "${pattern}" \
- 'match' "${BASH_REMATCH[0]}" \
- 'case' "${case_sensitive}" \
- | batslib_decorate 'value matches regular expression' \
- | fail
- fi
-}
diff --git a/tests/bats/bats-assert/test/assert.bats b/tests/bats/bats-assert/test/assert.bats
deleted file mode 100755
index d1a34a2..0000000
--- a/tests/bats/bats-assert/test/assert.bats
+++ /dev/null
@@ -1,19 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-@test 'assert() : returns 0 if evaluates to TRUE' {
- run assert true
- assert_test_pass
-}
-
-@test 'assert() : returns 1 and displays if it evaluates to FALSE' {
- run assert false
-
- assert_test_fail <<'ERR_MSG'
-
--- assertion failed --
-expression : false
---
-ERR_MSG
-}
diff --git a/tests/bats/bats-assert/test/assert_equal.bats b/tests/bats/bats-assert/test/assert_equal.bats
deleted file mode 100755
index 7d3fc86..0000000
--- a/tests/bats/bats-assert/test/assert_equal.bats
+++ /dev/null
@@ -1,62 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-@test 'assert_equal() : returns 0 if equals ' {
- run assert_equal 'a' 'a'
- assert_test_pass
-}
-
-@test 'assert_equal() : returns 1 and displays details if does not equal ' {
- run assert_equal 'a' 'b'
-
- assert_test_fail <<'ERR_MSG'
-
--- values do not equal --
-expected : b
-actual : a
---
-ERR_MSG
-}
-
-@test 'assert_equal() : displays details in multi-line format if is longer than one line' {
- run assert_equal $'a 0\na 1' 'b'
-
- assert_test_fail <<'ERR_MSG'
-
--- values do not equal --
-expected (1 lines):
- b
-actual (2 lines):
- a 0
- a 1
---
-ERR_MSG
-}
-
-@test 'assert_equal() : displays details in multi-line format if is longer than one line' {
- run assert_equal 'a' $'b 0\nb 1'
-
- assert_test_fail <<'ERR_MSG'
-
--- values do not equal --
-expected (2 lines):
- b 0
- b 1
-actual (1 lines):
- a
---
-ERR_MSG
-}
-
-@test 'assert_equal() : performs literal matching' {
- run assert_equal 'a' '*'
-
- assert_test_fail <<'ERR_MSG'
-
--- values do not equal --
-expected : *
-actual : a
---
-ERR_MSG
-}
diff --git a/tests/bats/bats-assert/test/assert_failure.bats b/tests/bats/bats-assert/test/assert_failure.bats
deleted file mode 100755
index 6291afe..0000000
--- a/tests/bats/bats-assert/test/assert_failure.bats
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-@test "assert_failure(): returns 0 if \`\$status' is not 0" {
- run false
- run assert_failure
- assert_test_pass
-}
-
-@test "assert_failure(): returns 1 and displays details if \`\$status' is 0" {
- run bash -c 'echo "a"
- exit 0'
- run assert_failure
-
- assert_test_fail <<'ERR_MSG'
-
--- command succeeded, but it was expected to fail --
-output : a
---
-ERR_MSG
-}
-
-@test "assert_failure(): displays \`\$output' in multi-line format if it is longer then one line" {
- run bash -c 'printf "a 0\na 1"
- exit 0'
- run assert_failure
-
- assert_test_fail <<'ERR_MSG'
-
--- command succeeded, but it was expected to fail --
-output (2 lines):
- a 0
- a 1
---
-ERR_MSG
-}
-
-@test "assert_failure() : returns 0 if \`\$status' equals " {
- run bash -c 'exit 1'
- run assert_failure 1
- assert_test_pass
-}
-
-@test "assert_failure() : returns 1 and displays details if \`\$status' does not equal " {
- run bash -c 'echo "a"
- exit 1'
- run assert_failure 2
-
- assert_test_fail <<'ERR_MSG'
-
--- command failed as expected, but status differs --
-expected : 2
-actual : 1
-output : a
---
-ERR_MSG
-}
-
-@test "assert_failure() : displays \`\$output' in multi-line format if it is longer then one line" {
- run bash -c 'printf "a 0\na 1"
- exit 1'
- run assert_failure 2
-
- assert_test_fail <<'ERR_MSG'
-
--- command failed as expected, but status differs --
-expected : 2
-actual : 1
-output (2 lines):
- a 0
- a 1
---
-ERR_MSG
-}
diff --git a/tests/bats/bats-assert/test/assert_line.bats b/tests/bats/bats-assert/test/assert_line.bats
deleted file mode 100755
index 151f688..0000000
--- a/tests/bats/bats-assert/test/assert_line.bats
+++ /dev/null
@@ -1,351 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-
-###############################################################################
-# Containing a line
-###############################################################################
-
-#
-# Literal matching
-#
-
-# Correctness
-@test "assert_line() : returns 0 if is a line in \`\${lines[@]}'" {
- run printf 'a\nb\nc'
- run assert_line 'b'
- assert_test_pass
-}
-
-@test "assert_line() : returns 1 and displays details if is not a line in \`\${lines[@]}'" {
- run echo 'b'
- run assert_line 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- output does not contain line --
-line : a
-output : b
---
-ERR_MSG
-}
-
-# Output formatting
-@test "assert_line() : displays \`\$output' in multi-line format if it is longer than one line" {
- run printf 'b 0\nb 1'
- run assert_line 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- output does not contain line --
-line : a
-output (2 lines):
- b 0
- b 1
---
-ERR_MSG
-}
-
-# Options
-@test 'assert_line() : performs literal matching by default' {
- run echo 'a'
- run assert_line '*'
-
- assert_test_fail <<'ERR_MSG'
-
--- output does not contain line --
-line : *
-output : a
---
-ERR_MSG
-}
-
-
-#
-# Partial matching: `-p' and `--partial'
-#
-
-# Options
-@test 'assert_line() -p : enables partial matching' {
- run printf 'a\n_b_\nc'
- run assert_line -p 'b'
- assert_test_pass
-}
-
-@test 'assert_line() --partial : enables partial matching' {
- run printf 'a\n_b_\nc'
- run assert_line --partial 'b'
- assert_test_pass
-}
-
-# Correctness
-@test "assert_line() --partial : returns 0 if is a substring in any line in \`\${lines[@]}'" {
- run printf 'a\n_b_\nc'
- run assert_line --partial 'b'
- assert_test_pass
-}
-
-@test "assert_line() --partial : returns 1 and displays details if is not a substring in any lines in \`\${lines[@]}'" {
- run echo 'b'
- run assert_line --partial 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- no output line contains substring --
-substring : a
-output : b
---
-ERR_MSG
-}
-
-# Output formatting
-@test "assert_line() --partial : displays \`\$output' in multi-line format if it is longer than one line" {
- run printf 'b 0\nb 1'
- run assert_line --partial 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- no output line contains substring --
-substring : a
-output (2 lines):
- b 0
- b 1
---
-ERR_MSG
-}
-
-
-#
-# Regular expression matching: `-e' and `--regexp'
-#
-
-# Options
-@test 'assert_line() -e : enables regular expression matching' {
- run printf 'a\n_b_\nc'
- run assert_line -e '^.b'
- assert_test_pass
-}
-
-@test 'assert_line() --regexp : enables regular expression matching' {
- run printf 'a\n_b_\nc'
- run assert_line --regexp '^.b'
- assert_test_pass
-}
-
-# Correctness
-@test "assert_line() --regexp : returns 0 if matches any line in \`\${lines[@]}'" {
- run printf 'a\n_b_\nc'
- run assert_line --regexp '^.b'
- assert_test_pass
-}
-
-@test "assert_line() --regexp : returns 1 and displays details if does not match any lines in \`\${lines[@]}'" {
- run echo 'b'
- run assert_line --regexp '^.a'
-
- assert_test_fail <<'ERR_MSG'
-
--- no output line matches regular expression --
-regexp : ^.a
-output : b
---
-ERR_MSG
-}
-
-# Output formatting
-@test "assert_line() --regexp : displays \`\$output' in multi-line format if longer than one line" {
- run printf 'b 0\nb 1'
- run assert_line --regexp '^.a'
-
- assert_test_fail <<'ERR_MSG'
-
--- no output line matches regular expression --
-regexp : ^.a
-output (2 lines):
- b 0
- b 1
---
-ERR_MSG
-}
-
-
-###############################################################################
-# Matching single line: `-n' and `--index'
-###############################################################################
-
-# Options
-@test 'assert_line() -n : matches against the -th line only' {
- run printf 'a\nb\nc'
- run assert_line -n 1 'b'
- assert_test_pass
-}
-
-@test 'assert_line() --index : matches against the -th line only' {
- run printf 'a\nb\nc'
- run assert_line --index 1 'b'
- assert_test_pass
-}
-
-@test 'assert_line() --index : returns 1 and displays an error message if is not an integer' {
- run assert_line --index 1a
-
- assert_test_fail <<'ERR_MSG'
-
--- ERROR: assert_line --
-`--index' requires an integer argument: `1a'
---
-ERR_MSG
-}
-
-
-#
-# Literal matching
-#
-
-# Correctness
-@test "assert_line() --index : returns 0 if equals \`\${lines[]}'" {
- run printf 'a\nb\nc'
- run assert_line --index 1 'b'
- assert_test_pass
-}
-
-@test "assert_line() --index : returns 1 and displays details if does not equal \`\${lines[]}'" {
- run printf 'a\nb\nc'
- run assert_line --index 1 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- line differs --
-index : 1
-expected : a
-actual : b
---
-ERR_MSG
-}
-
-# Options
-@test 'assert_line() --index : performs literal matching by default' {
- run printf 'a\nb\nc'
- run assert_line --index 1 '*'
-
- assert_test_fail <<'ERR_MSG'
-
--- line differs --
-index : 1
-expected : *
-actual : b
---
-ERR_MSG
-}
-
-
-#
-# Partial matching: `-p' and `--partial'
-#
-
-# Options
-@test 'assert_line() --index -p : enables partial matching' {
- run printf 'a\n_b_\nc'
- run assert_line --index 1 -p 'b'
- assert_test_pass
-}
-
-@test 'assert_line() --index --partial : enables partial matching' {
- run printf 'a\n_b_\nc'
- run assert_line --index 1 --partial 'b'
- assert_test_pass
-}
-
-# Correctness
-@test "assert_line() --index --partial : returns 0 if is a substring in \`\${lines[]}'" {
- run printf 'a\n_b_\nc'
- run assert_line --index 1 --partial 'b'
- assert_test_pass
-}
-
-@test "assert_line() --index --partial : returns 1 and displays details if is not a substring in \`\${lines[]}'" {
- run printf 'b 0\nb 1'
- run assert_line --index 1 --partial 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- line does not contain substring --
-index : 1
-substring : a
-line : b 1
---
-ERR_MSG
-}
-
-
-#
-# Regular expression matching: `-e' and `--regexp'
-#
-
-# Options
-@test 'assert_line() --index -e : enables regular expression matching' {
- run printf 'a\n_b_\nc'
- run assert_line --index 1 -e '^.b'
- assert_test_pass
-}
-
-@test 'assert_line() --index --regexp : enables regular expression matching' {
- run printf 'a\n_b_\nc'
- run assert_line --index 1 --regexp '^.b'
- assert_test_pass
-}
-
-# Correctness
-@test "assert_line() --index --regexp : returns 0 if matches \`\${lines[]}'" {
- run printf 'a\n_b_\nc'
- run assert_line --index 1 --regexp '^.b'
- assert_test_pass
-}
-
-@test "assert_line() --index --regexp : returns 1 and displays details if does not match \`\${lines[]}'" {
- run printf 'a\nb\nc'
- run assert_line --index 1 --regexp '^.a'
-
- assert_test_fail <<'ERR_MSG'
-
--- regular expression does not match line --
-index : 1
-regexp : ^.a
-line : b
---
-ERR_MSG
-}
-
-
-###############################################################################
-# Common
-###############################################################################
-
-@test "assert_line(): \`--partial' and \`--regexp' are mutually exclusive" {
- run assert_line --partial --regexp
-
- assert_test_fail <<'ERR_MSG'
-
--- ERROR: assert_line --
-`--partial' and `--regexp' are mutually exclusive
---
-ERR_MSG
-}
-
-@test 'assert_line() --regexp : returns 1 and displays an error message if is not a valid extended regular expression' {
- run assert_line --regexp '[.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- ERROR: assert_line --
-Invalid extended regular expression: `[.*'
---
-ERR_MSG
-}
-
-@test "assert_line(): \`--' stops parsing options" {
- run printf 'a\n-p\nc'
- run assert_line -- '-p'
- assert_test_pass
-}
diff --git a/tests/bats/bats-assert/test/assert_not_equal.bats b/tests/bats/bats-assert/test/assert_not_equal.bats
deleted file mode 100644
index 42b5315..0000000
--- a/tests/bats/bats-assert/test/assert_not_equal.bats
+++ /dev/null
@@ -1,57 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-@test 'assert_not_equal() : returns 0 if does not equal ' {
- run assert_not_equal foo bar
- assert_test_pass
-
- run assert_not_equal "foo" "bar"
- assert_test_pass
-
- run assert_not_equal "foo" ""
- assert_test_pass
-
- run assert_not_equal "" "foo"
- assert_test_pass
-}
-
-@test 'assert_not_equal() : returns 1 and displays details if equals ' {
- run assert_not_equal 'foobar' 'foobar'
- assert_test_fail <<'ERR_MSG'
-
--- values should not be equal --
-unexpected : foobar
-actual : foobar
---
-ERR_MSG
-
- run assert_not_equal 1 1
- assert_test_fail <<'ERR_MSG'
-
--- values should not be equal --
-unexpected : 1
-actual : 1
---
-ERR_MSG
-}
-
-@test 'assert_not_equal() : displays details in multi-line format if and are longer than one line' {
- run assert_not_equal $'foo\nbar' $'foo\nbar'
- assert_test_fail <<'ERR_MSG'
-
--- values should not be equal --
-unexpected (2 lines):
- foo
- bar
-actual (2 lines):
- foo
- bar
---
-ERR_MSG
-}
-
-@test 'assert_not_equal() : performs literal matching' {
- run assert_not_equal 'a' '*'
- assert_test_pass
-}
\ No newline at end of file
diff --git a/tests/bats/bats-assert/test/assert_output.bats b/tests/bats/bats-assert/test/assert_output.bats
deleted file mode 100755
index e9609e0..0000000
--- a/tests/bats/bats-assert/test/assert_output.bats
+++ /dev/null
@@ -1,285 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-#
-# Literal matching
-#
-
-# Correctness
-@test "assert_output() : returns 0 if equals \`\$output'" {
- run echo 'a'
- run assert_output 'a'
- assert_test_pass
-}
-
-@test "assert_output() : returns 1 and displays details if does not equal \`\$output'" {
- run echo 'b'
- run assert_output 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- output differs --
-expected : a
-actual : b
---
-ERR_MSG
-}
-
-@test 'assert_output(): succeeds if output is non-empty' {
- run echo 'a'
- run assert_output
-
- assert_test_pass
-}
-
-@test 'assert_output(): fails if output is empty' {
- run echo ''
- run assert_output
-
- assert_test_fail <<'ERR_MSG'
-
--- no output --
-expected non-empty output, but output was empty
---
-ERR_MSG
-}
-
-@test 'assert_output() - : reads from STDIN' {
- run echo 'a'
- run assert_output - < from STDIN' {
- run echo 'a'
- run assert_output --stdin <: displays details in multi-line format if \`\$output' is longer than one line" {
- run printf 'b 0\nb 1'
- run assert_output 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- output differs --
-expected (1 lines):
- a
-actual (2 lines):
- b 0
- b 1
---
-ERR_MSG
-}
-
-@test 'assert_output() : displays details in multi-line format if is longer than one line' {
- run echo 'b'
- run assert_output $'a 0\na 1'
-
- assert_test_fail <<'ERR_MSG'
-
--- output differs --
-expected (2 lines):
- a 0
- a 1
-actual (1 lines):
- b
---
-ERR_MSG
-}
-
-# Options
-@test 'assert_output() : performs literal matching by default' {
- run echo 'a'
- run assert_output '*'
-
- assert_test_fail <<'ERR_MSG'
-
--- output differs --
-expected : *
-actual : a
---
-ERR_MSG
-}
-
-
-#
-# Partial matching: `-p' and `--partial'
-#
-
-@test 'assert_output() -p : enables partial matching' {
- run echo 'abc'
- run assert_output -p 'b'
- assert_test_pass
-}
-
-@test 'assert_output() --partial : enables partial matching' {
- run echo 'abc'
- run assert_output --partial 'b'
- assert_test_pass
-}
-
-# Correctness
-@test "assert_output() --partial : returns 0 if is a substring in \`\$output'" {
- run printf 'a\nb\nc'
- run assert_output --partial 'b'
- assert_test_pass
-}
-
-@test "assert_output() --partial : returns 1 and displays details if is not a substring in \`\$output'" {
- run echo 'b'
- run assert_output --partial 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- output does not contain substring --
-substring : a
-output : b
---
-ERR_MSG
-}
-
-# Output formatting
-@test "assert_output() --partial : displays details in multi-line format if \`\$output' is longer than one line" {
- run printf 'b 0\nb 1'
- run assert_output --partial 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- output does not contain substring --
-substring (1 lines):
- a
-output (2 lines):
- b 0
- b 1
---
-ERR_MSG
-}
-
-@test 'assert_output() --partial : displays details in multi-line format if is longer than one line' {
- run echo 'b'
- run assert_output --partial $'a 0\na 1'
-
- assert_test_fail <<'ERR_MSG'
-
--- output does not contain substring --
-substring (2 lines):
- a 0
- a 1
-output (1 lines):
- b
---
-ERR_MSG
-}
-
-
-#
-# Regular expression matching: `-e' and `--regexp'
-#
-
-@test 'assert_output() -e : enables regular expression matching' {
- run echo 'abc'
- run assert_output -e '^a'
- assert_test_pass
-}
-
-@test 'assert_output() --regexp : enables regular expression matching' {
- run echo 'abc'
- run assert_output --regexp '^a'
- assert_test_pass
-}
-
-# Correctness
-@test "assert_output() --regexp : returns 0 if matches \`\$output'" {
- run printf 'a\nb\nc'
- run assert_output --regexp '.*b.*'
- assert_test_pass
-}
-
-@test "assert_output() --regexp : returns 1 and displays details if does not match \`\$output'" {
- run echo 'b'
- run assert_output --regexp '.*a.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- regular expression does not match output --
-regexp : .*a.*
-output : b
---
-ERR_MSG
-}
-
-# Output formatting
-@test "assert_output() --regexp : displays details in multi-line format if \`\$output' is longer than one line" {
- run printf 'b 0\nb 1'
- run assert_output --regexp '.*a.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- regular expression does not match output --
-regexp (1 lines):
- .*a.*
-output (2 lines):
- b 0
- b 1
---
-ERR_MSG
-}
-
-@test 'assert_output() --regexp : displays details in multi-line format if is longer than one line' {
- run echo 'b'
- run assert_output --regexp $'.*a\nb.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- regular expression does not match output --
-regexp (2 lines):
- .*a
- b.*
-output (1 lines):
- b
---
-ERR_MSG
-}
-
-# Error handling
-@test 'assert_output() --regexp : returns 1 and displays an error message if is not a valid extended regular expression' {
- run assert_output --regexp '[.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- ERROR: assert_output --
-Invalid extended regular expression: `[.*'
---
-ERR_MSG
-}
-
-
-#
-# Common
-#
-
-@test "assert_output(): \`--partial' and \`--regexp' are mutually exclusive" {
- run assert_output --partial --regexp
-
- assert_test_fail <<'ERR_MSG'
-
--- ERROR: assert_output --
-`--partial' and `--regexp' are mutually exclusive
---
-ERR_MSG
-}
-
-@test "assert_output(): \`--' stops parsing options" {
- run echo '-p'
- run assert_output -- '-p'
- assert_test_pass
-}
diff --git a/tests/bats/bats-assert/test/assert_regex.bats b/tests/bats/bats-assert/test/assert_regex.bats
deleted file mode 100644
index 0a9c902..0000000
--- a/tests/bats/bats-assert/test/assert_regex.bats
+++ /dev/null
@@ -1,87 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-#
-# Literal matching
-#
-
-# Correctness
-@test "assert_regex() : succeeds if a substring matches extended regular expression " {
- run assert_regex 'abc' '^[a-z]b[c-z]+'
- assert_test_pass
-}
-
-@test "assert_regex() : fails if no substring matches extended regular expression " {
- run assert_regex 'bcd' '^[a-z]b[c-z]+'
- assert_test_fail <<'ERR_MSG'
-
--- value does not match regular expression --
-value : bcd
-pattern : ^[a-z]b[c-z]+
-case : sensitive
---
-ERR_MSG
-}
-
-@test "assert_regex() : provides results in BASH_REMATCH" {
- unset -v BASH_REMATCH
-
- assert_regex 'abcd' 'b.d'
- declare -p BASH_REMATCH
- [ "${BASH_REMATCH[0]}" = 'bcd' ]
-}
-
-@test "assert_regex() : matches case-insensitively when 'nocasematch' is set" {
- shopt -s nocasematch
-
- assert_regex 'aBc' 'ABC'
-}
-
-@test "assert_regex() : outputs multi-line nicely when it fails" {
- run assert_regex $'bcd\n123' '^[a-z]b[c-z]+'
- assert_test_fail <<'ERR_MSG'
-
--- value does not match regular expression --
-value (2 lines):
- bcd
- 123
-pattern (1 lines):
- ^[a-z]b[c-z]+
-case (1 lines):
- sensitive
---
-ERR_MSG
-
- shopt -s nocasematch
- run assert_regex $'bcd\n123' '^[a-z]b[c-z]+'
- assert_test_fail <<'ERR_MSG'
-
--- value does not match regular expression --
-value (2 lines):
- bcd
- 123
-pattern (1 lines):
- ^[a-z]b[c-z]+
-case (1 lines):
- insensitive
---
-ERR_MSG
-}
-
-# Error handling
-@test "assert_regex() : returns 1 and displays an error message if is not a valid extended regular expression" {
- run assert_regex value '[.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- ERROR: assert_regex --
-Invalid extended regular expression: `[.*'
---
-ERR_MSG
-}
-
-@test "assert_regex allows regex matching empty string (see #53)" {
- run assert_regex any_value '.*'
- assert_success
-}
diff --git a/tests/bats/bats-assert/test/assert_success.bats b/tests/bats/bats-assert/test/assert_success.bats
deleted file mode 100755
index 66f5aa7..0000000
--- a/tests/bats/bats-assert/test/assert_success.bats
+++ /dev/null
@@ -1,40 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-@test "assert_success(): returns 0 if \`\$status' is 0" {
- run true
- run assert_success
-
- assert_test_pass
-}
-
-@test "assert_success(): returns 1 and displays details if \`\$status' is not 0" {
- run bash -c 'echo "a"
- exit 1'
- run assert_success
-
- assert_test_fail <<'ERR_MSG'
-
--- command failed --
-status : 1
-output : a
---
-ERR_MSG
-}
-
-@test "assert_success(): displays \`\$output' in multi-line format if it is longer than one line" {
- run bash -c 'printf "a 0\na 1"
- exit 1'
- run assert_success
-
- assert_test_fail <<'ERR_MSG'
-
--- command failed --
-status : 1
-output (2 lines):
- a 0
- a 1
---
-ERR_MSG
-}
diff --git a/tests/bats/bats-assert/test/refute.bats b/tests/bats/bats-assert/test/refute.bats
deleted file mode 100755
index f9e2737..0000000
--- a/tests/bats/bats-assert/test/refute.bats
+++ /dev/null
@@ -1,18 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-@test 'refute() : returns 0 if evaluates to FALSE' {
- run refute false
- assert_test_pass
-}
-
-@test 'refute() : returns 1 and displays if it evaluates to TRUE' {
- run refute true
- assert_test_fail <<'ERR_MSG'
-
--- assertion succeeded, but it was expected to fail --
-expression : true
---
-ERR_MSG
-}
diff --git a/tests/bats/bats-assert/test/refute_line.bats b/tests/bats/bats-assert/test/refute_line.bats
deleted file mode 100755
index fd6221c..0000000
--- a/tests/bats/bats-assert/test/refute_line.bats
+++ /dev/null
@@ -1,344 +0,0 @@
-#!/usr/bin/env bats
-
-load test_helper
-
-
-###############################################################################
-# Containing a line
-###############################################################################
-
-#
-# Literal matching
-#
-
-# Correctness
-@test "refute_line() : returns 0 if is not a line in \`\${lines[@]}'" {
- run printf 'a\nb\nc'
- run refute_line 'd'
- assert_test_pass
-}
-
-@test "refute_line() : returns 1 and displays details if is not a line in \`\${lines[@]}'" {
- run echo 'a'
- run refute_line 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- line should not be in output --
-line : a
-index : 0
-output : a
---
-ERR_MSG
-}
-
-# Output formatting
-@test "refute_line() : displays \`\$output' in multi-line format if it is longer than one line" {
- run printf 'a 0\na 1\na 2'
- run refute_line 'a 1'
-
- assert_test_fail <<'ERR_MSG'
-
--- line should not be in output --
-line : a 1
-index : 1
-output (3 lines):
- a 0
-> a 1
- a 2
---
-ERR_MSG
-}
-
-# Options
-@test 'refute_line() : performs literal matching by default' {
- run echo 'a'
- run refute_line '*'
- assert_test_pass
-}
-
-
-#
-# Partial matching: `-p' and `--partial'
-#
-
-# Options
-@test 'refute_line() -p : enables partial matching' {
- run printf 'a\nb\nc'
- run refute_line -p 'd'
- assert_test_pass
-}
-
-@test 'refute_line() --partial : enables partial matching' {
- run printf 'a\nb\nc'
- run refute_line --partial 'd'
- assert_test_pass
-}
-
-# Correctness
-@test "refute_line() --partial : returns 0 if is not a substring in any line in \`\${lines[@]}'" {
- run printf 'a\nb\nc'
- run refute_line --partial 'd'
- assert_test_pass
-}
-
-@test "refute_line() --partial : returns 1 and displays details if is a substring in any line in \`\${lines[@]}'" {
- run echo 'a'
- run refute_line --partial 'a'
-
- assert_test_fail <<'ERR_MSG'
-
--- no line should contain substring --
-substring : a
-index : 0
-output : a
---
-ERR_MSG
-}
-
-# Output formatting
-@test "refute_line() --partial : displays \`\$output' in multi-line format if it is longer than one line" {
- run printf 'a\nabc\nc'
- run refute_line --partial 'b'
-
- assert_test_fail <<'ERR_MSG'
-
--- no line should contain substring --
-substring : b
-index : 1
-output (3 lines):
- a
-> abc
- c
---
-ERR_MSG
-}
-
-
-#
-# Regular expression matching: `-e' and `--regexp'
-#
-
-# Options
-@test 'refute_line() -e : enables regular expression matching' {
- run printf 'a\nb\nc'
- run refute_line -e '^.d'
- assert_test_pass
-}
-
-@test 'refute_line() --regexp : enables regular expression matching' {
- run printf 'a\nb\nc'
- run refute_line --regexp '^.d'
- assert_test_pass
-}
-
-# Correctness
-@test "refute_line() --regexp : returns 0 if does not match any line in \`\${lines[@]}'" {
- run printf 'a\nb\nc'
- run refute_line --regexp '.*d.*'
- assert_test_pass
-}
-
-@test "refute_line() --regexp : returns 1 and displays details if matches any lines in \`\${lines[@]}'" {
- run echo 'a'
- run refute_line --regexp '.*a.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- no line should match the regular expression --
-regexp : .*a.*
-index : 0
-output : a
---
-ERR_MSG
-}
-
-# Output formatting
-@test "refute_line() --regexp : displays \`\$output' in multi-line format if longer than one line" {
- run printf 'a\nabc\nc'
- run refute_line --regexp '.*b.*'
-
- assert_test_fail <<'ERR_MSG'
-
--- no line should match the regular expression --
-regexp : .*b.*
-index : 1
-output (3 lines):
- a
-> abc
- c
---
-ERR_MSG
-}
-
-
-###############################################################################
-# Matching single line: `-n' and `--index'
-###############################################################################
-
-# Options
-@test 'refute_line() -n : matches against the -th line only' {
- run printf 'a\nb\nc'
- run refute_line -n 1 'd'
- assert_test_pass
-}
-
-@test 'refute_line() --index : matches against the -th line only' {
- run printf 'a\nb\nc'
- run refute_line --index 1 'd'
- assert_test_pass
-}
-
-@test 'refute_line() --index : returns 1 and displays an error message if is not an integer' {
- run refute_line --index 1a
-
- assert_test_fail <<'ERR_MSG'
-
--- ERROR: refute_line --
-`--index' requires an integer argument: `1a'
---
-ERR_MSG
-}
-
-
-#
-# Literal matching
-#
-
-# Correctness
-@test "refute_line() --index : returns 0 if does not equal \`\${lines[]}'" {
- run printf 'a\nb\nc'
- run refute_line --index 1 'd'
- assert_test_pass
-}
-
-@test "refute_line() --index : returns 1 and displays details if equals \`\${lines[]}'" {
- run printf 'a\nb\nc'
- run refute_line --index 1 'b'
-
- assert_test_fail <<'ERR_MSG'
-
--- line should differ --
-index : 1
-line : b
---
-ERR_MSG
-}
-
-# Options
-@test 'refute_line() --index : performs literal matching by default' {
- run printf 'a\nb\nc'
- run refute_line --index 1 '*'
- assert_test_pass
-}
-
-
-#
-# Partial matching: `-p' and `--partial'
-#
-
-# Options
-@test 'refute_line() --index -p : enables partial matching' {
- run printf 'a\nb\nc'
- run refute_line --index 1 -p 'd'
- assert_test_pass
-}
-
-@test 'refute_line() --index --partial : enables partial matching' {
- run printf 'a\nb\nc'
- run refute_line --index 1 --partial 'd'
- assert_test_pass
-}
-
-# Correctness
-@test "refute_line() --index --partial : returns 0 if is not a substring in \`\${lines[]}'" {
- run printf 'a\nabc\nc'
- run refute_line --index 1 --partial 'd'
- assert_test_pass
-}
-
-@test "refute_line() --index --partial : returns 1 and displays details if is a substring in \`\${lines[]}'" {
- run printf 'a\nabc\nc'
- run refute_line --index 1 --partial 'b'
-
- assert_test_fail <<'ERR_MSG'
-
--- line should not contain substring --
-index : 1
-substring : b
-line : abc
---
-ERR_MSG
-}
-
-
-#
-# Regular expression matching: `-e' and `--regexp'
-#
-
-# Options
-@test 'refute_line() --index -e