├── .travis.yml
├── .zunit.yml
├── .zvmrc
├── LICENSE
├── README.md
├── build.zsh
├── code-of-conduct.md
├── contributing.md
├── src
    ├── assertions.zsh
    ├── commands
    │   ├── init.zsh
    │   └── run.zsh
    ├── events.zsh
    ├── helpers.zsh
    ├── reports
    │   ├── html.zsh
    │   └── tap.zsh
    └── zunit.zsh
└── zunit.zsh-completion


/.travis.yml:
--------------------------------------------------------------------------------
 1 | addons:
 2 |   apt:
 3 |     packages:
 4 |     - zsh
 5 |     - ncurses-dev
 6 |     - autoconf
 7 |     - yodl
 8 |     - man
 9 | dist: trusty
10 | language: generic
11 | cache:
12 |   apt: true
13 |   directories:
14 |   - "$HOME/.zvm"
15 | jobs:
16 |   include:
17 |   - stage: linux
18 |     os: linux
19 |     env: ZVM_VERSION='4.3.12'
20 |   - os: linux
21 |     env: ZVM_VERSION='4.3.17'
22 |   - os: linux
23 |     env: ZVM_VERSION='5.0.8'
24 |   - os: linux
25 |     env: ZVM_VERSION='5.1.1'
26 |   - os: linux
27 |     env: ZVM_VERSION='5.2'
28 |   - os: linux
29 |     env: ZVM_VERSION='5.3.1'
30 |   - stage: mac os
31 |     os: osx
32 |     env: ZVM_VERSION='5.0.8'
33 |   - os: osx
34 |     env: ZVM_VERSION='5.1.1'
35 |   - os: osx
36 |     env: ZVM_VERSION='5.2'
37 |   - os: osx
38 |     env: ZVM_VERSION='5.3.1'
39 |   - stage: deploy
40 |     script: skip
41 |     deploy:
42 |       provider: releases
43 |       api_key:
44 |         secure: JudjZ9Ou15GKmgOga6qpcxtCKITpq+EnGCUvNAGefuuG/etxSAEdXQfjmC4VBzCAC9Pn1gkABFAASUtZdZ5xxXhxkuU/lTopJxWG2tdxNuvW/wflZNGdnxgWA1PcYptKrLoDRLzUpDtsnnvD75mMvAR8+YjRJk76gWVM02we2JR8WKcD1bchQiqzc7CK2X4kDL6zRayYpwFnFKhA8bTlIEJ36k92liTeW8VNwg+9CAsM2zjWpCKmLXrecNl3e5sO+4ssGU+J4gnWYSC112oEzLJzm3cYsEj8dTuFtVHby1DrLrpW1fPQdF1h1cwjHtQkbKTF5vrNKcCmSGcFxA2YbMu8aMdkEZmwN8JvShFamyyYHi90UTyv8PQ/WYER143zGZinZ2VeSaIlFEvH7R/sbS6t4DjbXV7rHF9Zbg0d3D7p71kNDpbtH1dkX6KXxtqCOOVRwAMhwRJ6c7VCXwj0AZEr6YrqZucPjbLTn9NVtI0WPZPOIL/HhyB6vzB1zunmjQERmcwNcC3gR47mmOPWfh1XaCpIurrZKjF+SfH/mDN6Tr24a9oeae6+subI5LW9G1qP2/GmibDVmlX+F1jE4xxKr6sIrzB/DLdYVtiSnzAmquZnGNunUCOMB6DN4nCajh9X3O/e2DzKImHSHZyYIThytSNyMs885ZBbev6F850=
45 |       file:
46 |       - zunit
47 |       - zunit.zsh-completion
48 |       skip_cleanup: true
49 |       on:
50 |         tags: true
51 | before_script:
52 | - if [[ $(ls "$HOME/.zvm" | wc -l) -eq 0 ]]; then rm -rf "$HOME/.zvm"; fi
53 | - mkdir .bin
54 | - curl -L https://raw.githubusercontent.com/molovo/revolver/master/revolver > .bin/revolver
55 | - curl -L https://raw.githubusercontent.com/molovo/color/master/color.zsh > .bin/color
56 | - curl -L https://raw.githubusercontent.com/molovo/zvm/master/zvm > .bin/zvm
57 | - chmod u+x .bin/{color,revolver,zvm}
58 | - export PATH="$HOME/.zvm/bin:$PWD/.bin:$PATH"
59 | - zvm use ${ZVM_VERSION}
60 | - "./build.zsh"
61 | script: "./zunit"
62 | notifications:
63 |   email: false
64 |   slack:
65 |     secure: gYbqJKOiko4AKjIY+68CxDPCyRQl22rdodRq55Wj745/ljyY5AQ8i3/Pvds19z2waX2ti232hWOczG09huYloTIDuiKNCqeedKVQQvThSqLW/8zYo1ETbOb09OPu6e68u8EAoPiwXeY56AqFEa5J3RBXP0cXl6EI9m1aL+LvGzV6AI149vh35Fib3a6Cr1JMspjf/iXf5LO9JI3YvdPI5xWGfjuqf7BWoJuQXsAIWtrpy9rHV1jfCFQNMuefwJruU0DbGEhW1er0HVWw4Sm8xP2BnIGoPDpqHUALaGs6RYBdsHTMUq9TjXVYNiYymvlpU4KpfUxOBQx8vIzzBwWjGua9YZsUMPxRw+ShVBnfVzMG/sGqG9zLSDMbMNiy5NXi9JxZi87/s9/7gUMWZqVXBucJ7L/xRr6xv/UTKe1Ur+Tb2FkZewWxkW3w8VU1uW5TgD1e72aeMHm+hXuBnKORIUB/BrNIYvfiUuKTMNZ6P78TgwGwe8BWA1NmqTwsyQip6OU7+OW5VYmB6Kv8YMZ87RtLTS6kPn2W5T+5wEYqTAMH4a1nbFglmM5Qu6i6Vf6Fhr05+YJtUToBQsB929VIqKVOlDYK8mMuS7K/B3dMSA/BjAgFQWDKaacGbM65PDhOZZTB6uTht9qvbxX0hLc7aU3Bj8Y7TRenv+BJwA26fnU=
66 | 


--------------------------------------------------------------------------------
/.zunit.yml:
--------------------------------------------------------------------------------
 1 | tap: false
 2 | directories:
 3 |   tests: tests
 4 |   output: tests/_output
 5 |   support: tests/_support
 6 | time_limit: 15
 7 | fail_fast: true
 8 | allow_risky: false
 9 | verbose: false
10 | 


--------------------------------------------------------------------------------
/.zvmrc:
--------------------------------------------------------------------------------
1 | 4.3.12
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 James Dinsdale <hi@molovo.co> (molovo.co)
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ![ZUnit](https://zunit.xyz/img/logo.png)
 2 | 
 3 | [![GitHub release](https://img.shields.io/github/release/zunit-zsh/zunit.svg)](https://github.com/zunit-zsh/zunit/releases/latest) [![Build Status](https://travis-ci.org/zunit-zsh/zunit.svg?branch=master)](https://travis-ci.org/zunit-zsh/zunit) [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/zunit-zsh/zunit?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 4 | 
 5 | ZUnit is a powerful unit testing framework for ZSH
 6 | 
 7 | ## Installation
 8 | 
 9 | > **WARNING**: Although the majority of ZUnit's functionality works as expected, it is in the early stages of development, and as such bugs are likely to be present. Please continue with caution, and [report any issues](https://github.com/zunit-zsh/zunit/issues/new) you may have.
10 | 
11 | ### [Zulu](https://github.com/zulu-zsh/zulu)
12 | 
13 | ```sh
14 | zulu install zunit
15 | ```
16 | 
17 | > **NOTE:** In versions of Zulu prior to `1.2.0`, there is an additional step required after install:
18 | 
19 |   ```sh
20 |   cd ~/.zulu/packages/zunit
21 |   ./build.zsh
22 |   zulu link zunit
23 |   ```
24 |   
25 | ### [zplug](https://github.com/zplug/zplug)
26 | 
27 | ZUnit and its dependencies can all be installed with zplug.
28 | 
29 | ```sh
30 | zplug 'molovo/revolver', \
31 |   as:command, \
32 |   use:revolver
33 | zplug 'zunit-zsh/zunit', \
34 |   as:command, \
35 |   use:zunit, \
36 |   hook-build:'./build.zsh'
37 | ```
38 | 
39 | 
40 | ### Homebrew
41 | 
42 | ```sh
43 | brew install zunit-zsh/zunit/zunit
44 | ```
45 | 
46 | ### Manual
47 | 
48 | ```sh
49 | git clone https://github.com/zunit-zsh/zunit
50 | cd ./zunit
51 | ./build.zsh
52 | chmod u+x ./zunit
53 | cp ./zunit /usr/local/bin
54 | ```
55 | 
56 | > ZUnit requires [Revolver](https://github.com/molovo/revolver) to be installed, and in your `$PATH`. The zulu or homebrew installation methods will install this dependency for you.
57 | 
58 | ## Writing Tests
59 | 
60 | ### Test syntax
61 | 
62 | Tests in ZUnit have a simple syntax, which is inspired by the [BATS](https://github.com/sstephenson/bats) framework.
63 | 
64 | ```sh
65 | #!/usr/bin/env zunit
66 | 
67 | @test 'My first test' {
68 | 	# Test contents here
69 | }
70 | ```
71 | 
72 | The body of each test can contain any valid ZSH code. The zunit shebang `#!/usr/bin/env zunit` **MUST** appear at the top of each test file, or ZUnit will not run it.
73 | 
74 | ## Documentation
75 | 
76 | For a full breakdown of ZUnit's syntax and functionality, check out the [official documentation](https://zunit.xyz/docs/).
77 | 
78 | ## Contributing
79 | 
80 | All contributions are welcome, and encouraged. Please read our [contribution guidelines](contributing.md) and [code of conduct](code-of-conduct.md) for more information.
81 | 
82 | ## License
83 | 
84 | Copyright (c) 2016 James Dinsdale <hi@molovo.co> (molovo.co)
85 | 
86 | ZUnit is licensed under The MIT License (MIT)
87 | 
88 | ## Team
89 | 
90 | * [James Dinsdale](http://molovo.co)
91 | 


--------------------------------------------------------------------------------
/build.zsh:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env zsh
 2 | 
 3 | # Clear the file to start with
 4 | cat /dev/null > zunit
 5 | 
 6 | # Start with the shebang
 7 | echo "#!/usr/bin/env zsh\n" >> zunit
 8 | 
 9 | # We need to do some fancy globbing
10 | setopt EXTENDED_GLOB
11 | 
12 | # Print each of the source files into the target, removing any comments
13 | # and blank lines from the compiled executable
14 | cat src/**/(^zunit).zsh | grep -v -E '^(\s*#.*[^"]|\s*)$' >> zunit
15 | 
16 | # Print the main command last
17 | cat src/zunit.zsh | grep -v -E '^(\s*#.*[^"]|\s*)$' >> zunit
18 | 
19 | # Make sure the file is executable
20 | chmod u+x zunit
21 | 
22 | # Let the user know we're finished
23 | echo "\033[0;32m✔\033[0;m ZUnit built successfully"
24 | 


--------------------------------------------------------------------------------
/code-of-conduct.md:
--------------------------------------------------------------------------------
 1 | # Contributor Covenant Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as
 6 | contributors and maintainers pledge to making participation in our project and
 7 | our community a harassment-free experience for everyone, regardless of age, body
 8 | size, disability, ethnicity, gender identity and expression, level of experience,
 9 | nationality, personal appearance, race, religion, or sexual identity and
10 | orientation.
11 | 
12 | ## Our Standards
13 | 
14 | Examples of behavior that contributes to creating a positive environment
15 | include:
16 | 
17 | * Using welcoming and inclusive language
18 | * Being respectful of differing viewpoints and experiences
19 | * Gracefully accepting constructive criticism
20 | * Focusing on what is best for the community
21 | * Showing empathy towards other community members
22 | 
23 | Examples of unacceptable behavior by participants include:
24 | 
25 | * The use of sexualized language or imagery and unwelcome sexual attention or
26 | advances
27 | * Trolling, insulting/derogatory comments, and personal or political attacks
28 | * Public or private harassment
29 | * Publishing others' private information, such as a physical or electronic
30 |   address, without explicit permission
31 | * Other conduct which could reasonably be considered inappropriate in a
32 |   professional setting
33 | 
34 | ## Our Responsibilities
35 | 
36 | Project maintainers are responsible for clarifying the standards of acceptable
37 | behavior and are expected to take appropriate and fair corrective action in
38 | response to any instances of unacceptable behavior.
39 | 
40 | Project maintainers have the right and responsibility to remove, edit, or
41 | reject comments, commits, code, wiki edits, issues, and other contributions
42 | that are not aligned to this Code of Conduct, or to ban temporarily or
43 | permanently any contributor for other behaviors that they deem inappropriate,
44 | threatening, offensive, or harmful.
45 | 
46 | ## Scope
47 | 
48 | This Code of Conduct applies both within project spaces and in public spaces
49 | when an individual is representing the project or its community. Examples of
50 | representing a project or community include using an official project e-mail
51 | address, posting via an official social media account, or acting as an appointed
52 | representative at an online or offline event. Representation of a project may be
53 | further defined and clarified by project maintainers.
54 | 
55 | ## Enforcement
56 | 
57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
58 | reported by contacting the project team at hi@molovo.co. All
59 | complaints will be reviewed and investigated and will result in a response that
60 | is deemed necessary and appropriate to the circumstances. The project team is
61 | obligated to maintain confidentiality with regard to the reporter of an incident.
62 | Further details of specific enforcement policies may be posted separately.
63 | 
64 | Project maintainers who do not follow or enforce the Code of Conduct in good
65 | faith may face temporary or permanent repercussions as determined by other
66 | members of the project's leadership.
67 | 
68 | ## Attribution
69 | 
70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
71 | available at [http://contributor-covenant.org/version/1/4][version]
72 | 
73 | [homepage]: http://contributor-covenant.org
74 | [version]: http://contributor-covenant.org/version/1/4/
75 | 


--------------------------------------------------------------------------------
/contributing.md:
--------------------------------------------------------------------------------
 1 | # Contributing to ZUnit
 2 | 
 3 | ✨ Thanks for contributing to ZUnit! ✨
 4 | 
 5 | Please note that this project is released with a [Contributor Code of Conduct](code-of-conduct.md). By participating in this project you agree to abide by its terms.
 6 | 
 7 | ## How can I contribute?
 8 | 
 9 | ### Improve documentation
10 | 
11 | As a user of ZUnit you're the perfect candidate to help us improve our documentation. Typo corrections, error fixes, better explanations, more examples, etc. Open issues for things that could be improved. Anything. Even improvements to this document.
12 | 
13 | Use the [`docs` label](https://github.com/zunit-zsh/zunit/labels/docs) to find suggestions for what we'd love to see more documentation on.
14 | 
15 | ### Improve issues
16 | 
17 | Some issues are created with missing information, not reproducible, or plain invalid. Help make them easier to resolve. Handling issues takes a lot of time that we could rather spend on fixing bugs and adding features.
18 | 
19 | ### Give feedback on issues
20 | 
21 | We're always looking for more opinions on discussions in the issue tracker. It's a good opportunity to influence the future direction of ZUnit.
22 | 
23 | The [`question` label](https://github.com/zunit-zsh/zunit/labels/question) is a good place to find ongoing discussions.
24 | 
25 | ### Write code
26 | 
27 | You can use issue labels to discover issues you could help out with:
28 | 
29 | * [`blocked` issues](https://github.com/zunit-zsh/zunit/labels/blocked) need help getting unstuck
30 | * [`bug` issues](https://github.com/zunit-zsh/zunit/labels/bug) are known bugs we'd like to fix
31 | * [`enhancement` issues](https://github.com/zunit-zsh/zunit/labels/enhancement) are features we're open to including
32 | * [`performance` issues](https://github.com/zunit-zsh/zunit/labels/performance) track ideas on how to improve ZUnit’s performance
33 | 
34 | The [`help wanted`](https://github.com/zunit-zsh/zunit/labels/help%20wanted) and [`good for beginner`](https://github.com/zunit-zsh/zunit/labels/good%20for%20beginner) labels are especially useful.
35 | 
36 | You may find an issue is assigned, or has the [`assigned` label](https://github.com/zunit-zsh/zunit/labels/assigned). Please double-check before starting on this issue because somebody else is likely already working on it.
37 | 
38 | We'd like to fix [`priority` issues](https://github.com/zunit-zsh/zunit/labels/priority) first. We'd love to see progress on [`low-priority` issues](https://github.com/zunit-zsh/zunit/labels/low%20priority) too. [`future` issues](https://github.com/zunit-zsh/zunit/labels/future) are those that we'd like to get to, but not anytime soon. Please check before working on these since we may not yet want to take on the burden of supporting those features.
39 | 
40 | ### Hang out in our chat
41 | 
42 | We have a [chat](https://gitter.im/zunit-zsh/zunit). Jump in there and lurk, talk to us, and help others.
43 | 
44 | ## Submitting an issue
45 | 
46 | - The issue tracker is for issues. Use our [chat](https://gitter.im/zunit-zsh/zunit) for support.
47 | - Search the issue tracker before opening an issue.
48 | - Ensure you're using the latest version of ZUnit.
49 | - Use a clear and descriptive title.
50 | - Include as much information as possible: Steps to reproduce the issue, error message, ZSH version, operating system, etc.
51 | - The more time you put into an issue, the more we will.
52 | - [The best issue report is a failing test proving it.](https://twitter.com/sindresorhus/status/579306280495357953)
53 | 
54 | ## Submitting a pull request
55 | 
56 | - Most pull requests should target the `next` branch, so they can be included in the next release.
57 | - Urgent bug fixes may be targeted to the `master` branch, and a new patch release will be created immediately after they are merged. If in doubt, ask.
58 | - Non-trivial changes are often best discussed in an issue first, to prevent you from doing unnecessary work.
59 | - For ambitious tasks, you should try to get your work in front of the community for feedback as soon as possible. Open a pull request as soon as you have done the minimum needed to demonstrate your idea. At this early stage, don't worry about making things perfect, or 100% complete. Add a [WIP] prefix to the title, and describe what you still need to do. This lets reviewers know not to nit-pick small details or point out improvements you already know you need to make.
60 | - New features should be accompanied with tests and documentation.
61 | - Don't include unrelated changes.
62 | - Make the pull request from a [topic branch](https://github.com/dchelimsky/rspec/wiki/Topic-Branches), not master.
63 | - Use a clear and descriptive title for the pull request and commits.
64 | - Write a convincing description of why we should land your pull request. It's your job to convince us. Answer "why" it's needed and provide use-cases.
65 | - You might be asked to do changes to your pull request. There's never a need to open another pull request. [Just update the existing one.](https://github.com/RichardLitt/docs/blob/master/amending-a-commit-guide.md)
66 | 


--------------------------------------------------------------------------------
/src/assertions.zsh:
--------------------------------------------------------------------------------
  1 | ################################
  2 | # Internal assertion functions #
  3 | ################################
  4 | 
  5 | ###
  6 | # Assert one string is a substring of another
  7 | ###
  8 | function _zunit_assert_is_substring_of() {
  9 |   local value=$1 comparison=$2
 10 | 
 11 |   [[ "$comparison" = *"$value"* ]] && return 0
 12 | 
 13 |   echo "'$value' is not a substring of '$comparison'"
 14 |   exit 1
 15 | }
 16 | 
 17 | ###
 18 | # Assert one string is not a substring of another
 19 | ###
 20 | function _zunit_assert_is_not_substring_of() {
 21 |   local value=$1 comparison=$2
 22 | 
 23 |   [[ "$comparison" != *"$value"* ]] && return 0
 24 | 
 25 |   echo "'$value' is a substring of '$comparison'"
 26 |   exit 1
 27 | }
 28 | 
 29 | ###
 30 | # Assert one string contains another
 31 | ###
 32 | function _zunit_assert_contains() {
 33 |   local value=$1 comparison=$2
 34 | 
 35 |   [[ "$value" = *"$comparison"* ]] && return 0
 36 | 
 37 |   echo "'$value' does not contain '$comparison'"
 38 |   exit 1
 39 | }
 40 | 
 41 | ###
 42 | # Assert one string does not contain another
 43 | ###
 44 | function _zunit_assert_does_not_contain() {
 45 |   local value=$1 comparison=$2
 46 | 
 47 |   [[ "$value" != *"$comparison"* ]] && return 0
 48 | 
 49 |   echo "'$value' contains '$comparison'"
 50 |   exit 1
 51 | }
 52 | 
 53 | ###
 54 | # Assert that two integers are equal
 55 | ###
 56 | function _zunit_assert_equals() {
 57 |   local value=$1 comparison=$2
 58 | 
 59 |   [[ $value -eq $comparison ]] && return 0
 60 | 
 61 |   echo "'$value' is not equal to '$comparison'"
 62 |   exit 1
 63 | }
 64 | 
 65 | ###
 66 | # Assert that two integers are not equal
 67 | ###
 68 | function _zunit_assert_not_equal_to() {
 69 |   local value=$1 comparison=$2
 70 | 
 71 |   [[ $value -ne $comparison ]] && return 0
 72 | 
 73 |   echo "'$value' is equal to '$comparison'"
 74 |   exit 1
 75 | }
 76 | 
 77 | ###
 78 | # Assert that an integer is positive
 79 | ###
 80 | function _zunit_assert_is_positive() {
 81 |   local value=$1 comparison=$2
 82 | 
 83 |   [[ $value -gt 0 ]] && return 0
 84 | 
 85 |   echo "'$value' is not positive"
 86 |   exit 1
 87 | }
 88 | 
 89 | ###
 90 | # Assert that an integer is negative
 91 | ###
 92 | function _zunit_assert_is_negative() {
 93 |   local value=$1 comparison=$2
 94 | 
 95 |   [[ $value -lt 0 ]] && return 0
 96 | 
 97 |   echo "'$value' is not negative"
 98 |   exit 1
 99 | }
100 | 
101 | ###
102 | # Assert that an integer is greater than the comparison
103 | ###
104 | function _zunit_assert_is_greater_than() {
105 |   local value=$1 comparison=$2
106 | 
107 |   [[ $value -gt $comparison ]] && return 0
108 | 
109 |   echo "'$value' is not greater than '$comparison'"
110 |   exit 1
111 | }
112 | 
113 | ###
114 | # Assert that an integer is less than the comparison
115 | ###
116 | function _zunit_assert_is_less_than() {
117 |   local value=$1 comparison=$2
118 | 
119 |   [[ $value -lt $comparison ]] && return 0
120 | 
121 |   echo "'$value' is not less than '$comparison'"
122 |   exit 1
123 | }
124 | 
125 | ###
126 | # Assert that two string are the same
127 | ###
128 | function _zunit_assert_same_as() {
129 |   local value=$1 comparison=$2
130 | 
131 |   [[ $value = $comparison ]] && return 0
132 | 
133 |   echo "'$value' is not the same as '$comparison'"
134 |   exit 1
135 | }
136 | 
137 | ###
138 | # Assert that two string are different
139 | ###
140 | function _zunit_assert_different_to() {
141 |   local value=$1 comparison=$2
142 | 
143 |   [[ $value != $comparison ]] && return 0
144 | 
145 |   echo "'$value' is the same as '$comparison'"
146 |   exit 1
147 | }
148 | 
149 | ###
150 | # Assert that a value is empty
151 | ###
152 | function _zunit_assert_is_empty() {
153 |   local value=$1
154 | 
155 |   [[ -z ${value[@]} ]] && return 0
156 | 
157 |   echo "'${value[@]}' is not empty"
158 |   exit 1
159 | }
160 | 
161 | ###
162 | # Assert that a value is not empty
163 | ###
164 | function _zunit_assert_is_not_empty() {
165 |   local value=$1
166 | 
167 |   [[ -n ${value[@]} ]] && return 0
168 | 
169 |   echo "value is empty"
170 |   exit 1
171 | }
172 | 
173 | ###
174 | # Assert that the value matches a regex pattern
175 | ###
176 | function _zunit_assert_matches() {
177 |   local value=$1 pattern=$2
178 | 
179 |   [[ $value =~ $pattern ]] && return 0
180 | 
181 |   echo "'$value' does not match /$pattern/"
182 |   exit 1
183 | }
184 | 
185 | ###
186 | # Assert that the value does not match a regex pattern
187 | ###
188 | function _zunit_assert_does_not_match() {
189 |   local value=$1 pattern=$2
190 | 
191 |   [[ ! $value =~ $pattern ]] && return 0
192 | 
193 |   echo "'$value' matches /$pattern/"
194 |   exit 1
195 | }
196 | 
197 | ###
198 | # Assert that a value is found in an array
199 | ###
200 | function _zunit_assert_in() {
201 |   local i found=0 value=$1
202 |   local -a array
203 |   array=(${(@)@:2})
204 | 
205 |   for i in ${(@f)array}; do
206 |     [[ $i = $value ]] && found=1
207 |   done
208 | 
209 | 
210 |   [[ $found -eq 1 ]] && return 0
211 | 
212 |   echo "'$value' is not in (${(@f)array})"
213 |   exit 1
214 | }
215 | 
216 | ###
217 | # Assert that a value is not found in an array
218 | ###
219 | function _zunit_assert_not_in() {
220 |   local i found=0 value=$1
221 |   local -a array
222 |   array=(${(@)@:2})
223 | 
224 |   for i in ${(@f)array}; do
225 |     [[ $i = $value ]] && found=1
226 |   done
227 | 
228 |   [[ $found -eq 0 ]] && return 0
229 | 
230 |   echo "'$value' is in (${(@f)array})"
231 |   exit 1
232 | }
233 | 
234 | ###
235 | # Assert that a value is a key in a hash
236 | ###
237 | function _zunit_assert_is_key_in() {
238 |   local i found=0 value=$1
239 |   local -A hash
240 |   hash=(${(@)@:2})
241 | 
242 |   for k v in ${(@kv)hash}; do
243 |     [[ $k = $value ]] && found=1
244 |   done
245 | 
246 |   [[ $found -eq 1 ]] && return 0
247 | 
248 |   echo "'$value' is not a key in (${(@kv)hash})"
249 |   exit 1
250 | }
251 | 
252 | ###
253 | # Assert that a value is not a key in a hash
254 | ###
255 | function _zunit_assert_is_not_key_in() {
256 |   local i found=0 value=$1
257 |   local -A hash
258 |   hash=(${(@)@:2})
259 | 
260 |   for k v in ${(@kv)hash}; do
261 |     [[ $k = $value ]] && found=1
262 |   done
263 | 
264 |   [[ $found -eq 0 ]] && return 0
265 | 
266 |   echo "'$value' is a key in (${(@kv)hash})"
267 |   exit 1
268 | }
269 | 
270 | ###
271 | # Assert that a value is a value in a hash
272 | ###
273 | function _zunit_assert_is_value_in() {
274 |   local i found=0 value=$1
275 |   local -A hash
276 |   hash=(${(@)@:2})
277 | 
278 |   for k v in ${(@kv)hash}; do
279 |     [[ $v = $value ]] && found=1
280 |   done
281 | 
282 |   [[ $found -eq 1 ]] && return 0
283 | 
284 |   echo "'$value' is not a value in (${(@kv)hash})"
285 |   exit 1
286 | }
287 | 
288 | ###
289 | # Assert that a value is not a value in a hash
290 | ###
291 | function _zunit_assert_is_not_value_in() {
292 |   local i found=0 value=$1
293 |   local -A hash
294 |   hash=(${(@)@:2})
295 | 
296 |   for k v in ${(@kv)hash}; do
297 |     [[ $v = $value ]] && found=1
298 |   done
299 | 
300 |   [[ $found -eq 0 ]] && return 0
301 | 
302 |   echo "'$value' is a value in (${(@kv)hash})"
303 |   exit 1
304 | }
305 | 
306 | ###
307 | # Assert the a path exists
308 | ###
309 | function _zunit_assert_exists() {
310 |   local pathname=$1 filepath
311 | 
312 |   # If filepath is relative, prepend the test directory
313 |   if [[ "${pathname:0:1}" != "/" ]]; then
314 |     filepath="$testdir/${pathname}"
315 |   else
316 |     filepath="$pathname"
317 |   fi
318 | 
319 |   [[ -e "$filepath" ]] && return 0
320 | 
321 |   echo "'$pathname' does not exist"
322 |   exit 1
323 | }
324 | 
325 | ###
326 | # Assert the a path exists and is a file
327 | ###
328 | function _zunit_assert_is_file() {
329 |   local pathname=$1 filepath
330 | 
331 |   # If filepath is relative, prepend the test directory
332 |   if [[ "${pathname:0:1}" != "/" ]]; then
333 |     filepath="$testdir/${pathname}"
334 |   else
335 |     filepath="$pathname"
336 |   fi
337 | 
338 |   [[ -f "$filepath" ]] && return 0
339 | 
340 |   echo "'$pathname' does not exist or is not a file"
341 |   exit 1
342 | }
343 | 
344 | ###
345 | # Assert the a path exists and is a directory
346 | ###
347 | function _zunit_assert_is_dir() {
348 |   local pathname=$1 filepath
349 | 
350 |   # If filepath is relative, prepend the test directory
351 |   if [[ "${pathname:0:1}" != "/" ]]; then
352 |     filepath="$testdir/$pathname"
353 |   else
354 |     filepath="$pathname"
355 |   fi
356 | 
357 |   [[ -d "$filepath" ]] && return 0
358 | 
359 |   echo "'$pathname' does not exist or is not a directory"
360 |   exit 1
361 | }
362 | 
363 | ###
364 | # Assert the a path exists and is a symbolic link
365 | ###
366 | function _zunit_assert_is_link() {
367 |   local pathname=$1 filepath
368 | 
369 |   # If filepath is relative, prepend the test directory
370 |   if [[ "${pathname:0:1}" != "/" ]]; then
371 |     filepath="$testdir/${pathname}"
372 |   else
373 |     filepath="$pathname"
374 |   fi
375 | 
376 |   [[ -h "$filepath" ]] && return 0
377 | 
378 |   echo "'$pathname' does not exist or is not a symbolic link"
379 |   exit 1
380 | }
381 | 
382 | ###
383 | # Assert the a path exists and is readable
384 | ###
385 | function _zunit_assert_is_readable() {
386 |   local pathname=$1 filepath
387 | 
388 |   # If filepath is relative, prepend the test directory
389 |   if [[ "${pathname:0:1}" != "/" ]]; then
390 |     filepath="$testdir/${pathname}"
391 |   else
392 |     filepath="$pathname"
393 |   fi
394 | 
395 |   [[ -r "$filepath" ]] && return 0
396 | 
397 |   echo "'$pathname' does not exist or is not readable"
398 |   exit 1
399 | }
400 | 
401 | ###
402 | # Assert the a path exists and is writable
403 | ###
404 | function _zunit_assert_is_writable() {
405 |   local pathname=$1 filepath
406 | 
407 |   # If filepath is relative, prepend the test directory
408 |   if [[ "${pathname:0:1}" != "/" ]]; then
409 |     filepath="$testdir/${pathname}"
410 |   else
411 |     filepath="$pathname"
412 |   fi
413 | 
414 |   [[ -w "$filepath" ]] && return 0
415 | 
416 |   echo "'$pathname' does not exist or is not writable"
417 |   exit 1
418 | }
419 | 
420 | ###
421 | # Assert the a path exists and is executable
422 | ###
423 | function _zunit_assert_is_executable() {
424 |   local pathname=$1 filepath
425 | 
426 |   # If filepath is relative, prepend the test directory
427 |   if [[ "${pathname:0:1}" != "/" ]]; then
428 |     filepath="$testdir/${pathname}"
429 |   else
430 |     filepath="$pathname"
431 |   fi
432 | 
433 |   [[ -x "$filepath" ]] && return 0
434 | 
435 |   echo "'$pathname' does not exist or is not executable"
436 |   exit 1
437 | }
438 | 


--------------------------------------------------------------------------------
/src/commands/init.zsh:
--------------------------------------------------------------------------------
  1 | ############################
  2 | # The 'zunit init' command #
  3 | ############################
  4 | 
  5 | ###
  6 | # Output usage information and exit
  7 | ###
  8 | function _zunit_init_usage() {
  9 |   echo "$(color yellow 'Usage:')"
 10 |   echo "  zunit init [options]"
 11 |   echo
 12 |   echo "$(color yellow 'Options:')"
 13 |   echo "  -h, --help         Output help text and exit"
 14 |   echo "  -v, --version      Output version information and exit"
 15 |   echo "  -t, --travis       Generate .travis.yml in project"
 16 | }
 17 | 
 18 | ###
 19 | # Parse a YAML config file
 20 | # Based on https://gist.github.com/pkuczynski/8665367
 21 | ###
 22 | function _zunit_parse_yaml() {
 23 |   local s w fs prefix=$2
 24 |   s='[[:space:]]*'
 25 |   w='[a-zA-Z0-9_]*'
 26 |   fs="$(echo @|tr @ '\034')"
 27 |   sed -ne "s|^\(${s}\)\(${w}\)${s}:${s}\"\(.*\)\"${s}\$|\1${fs}\2${fs}\3|p" \
 28 |       -e "s|^\(${s}\)\(${w}\)${s}[:-]${s}\(.*\)${s}\$|\1${fs}\2${fs}\3|p" "$1" |
 29 |   awk -F"${fs}" '{
 30 |   indent = length($1)/2;
 31 |   vname[indent] = $2;
 32 |   for (i in vname) {if (i > indent) {delete vname[i]}}
 33 |       if (length($3) > 0) {
 34 |           vn=""; for (i=0; i<indent; i++) {vn=(vn)(vname[i])("_")}
 35 |           printf("%s%s%s=(\"%s\")\n", "'"$prefix"'",vn, $2, $3);
 36 |       }
 37 |   }' | sed 's/_=/+=/g'
 38 | }
 39 | 
 40 | function _zunit_init() {
 41 |   local with_travis
 42 | 
 43 |   zparseopts -D t=with_travis -travis=with_travis
 44 | 
 45 |   # The contents of .zunit.yml
 46 |   local yaml="tap: false
 47 | directories:
 48 |   tests: tests
 49 |   output: tests/_output
 50 |   support: tests/_support
 51 | time_limit: 0
 52 | fail_fast: false
 53 | allow_risky: false"
 54 | 
 55 |   # An example test file
 56 |   local example="#!/usr/bin/env zunit
 57 | 
 58 | @test 'Example' {
 59 |   assert "'"true"'" same_as "'"false"'"
 60 | }"
 61 | 
 62 |   # An empty bootstrap script
 63 |   local bootstrap="#!/usr/bin/env zsh
 64 | 
 65 | # Write your bootstrap code here"
 66 | 
 67 |   # An example .travis.yml config
 68 |   local travis_yml="addons:
 69 |   apt:
 70 |     packages:
 71 |       zsh
 72 | install:
 73 |   - mkdir .bin
 74 |   - curl -L https://github.com/zunit-zsh/zunit/releases/download/v$(_zunit_version)/zunit > .bin/zunit
 75 |   - curl -L https://raw.githubusercontent.com/molovo/revolver/master/revolver > .bin/revolver
 76 |   - curl -L https://raw.githubusercontent.com/molovo/color/master/color.zsh > .bin/color
 77 | before_script:
 78 |   - chmod u+x .bin/{color,revolver,zunit}
 79 |   - export PATH=\"\$PWD/.bin:\$PATH\"
 80 | script: zunit"
 81 | 
 82 |   # Check that a config file doesn't already exist so that
 83 |   # we don't overwrite it
 84 |   if [[ -f "$PWD/.zunit.yml" ]]; then
 85 |     echo $(color yellow "ZUnit config file already exists at $PWD/.zunit.yml. Skipping...")
 86 |   else
 87 |     # Write the contents to the config file
 88 |     echo "Writing ZUnit config file to $PWD/.zunit.yml"
 89 |     echo "$yaml" > "$PWD/.zunit.yml"
 90 |   fi
 91 | 
 92 |   # Check that the tests directory doesn't already exist so that
 93 |   # we don't overwrite it
 94 |   if [[ -d "$PWD/tests" ]]; then
 95 |     echo $(color yellow "Test directory already exists at $PWD/tests. Skipping...")
 96 |   else
 97 |     echo "Creating test directory at $PWD/tests"
 98 |     # Create the directory structure for tests
 99 |     mkdir -p tests/_{output,support}
100 |     touch tests/_{output,support}/.gitkeep
101 | 
102 |     # Save the bootstrap script and example test
103 |     echo "$bootstrap" > "$PWD/tests/_support/bootstrap"
104 |     echo "$example" > "$PWD/tests/example.zunit"
105 |   fi
106 | 
107 |   # If travis config has been requested
108 |   if [[ -n $with_travis ]]; then
109 |     # Check that a travis config doesn't already exist so that
110 |     # we don't overwrite it
111 |     if [[ -f "$PWD/.travis.yml" ]]; then
112 |       echo $(color yellow "Travis config already exists at $PWD/.travis.yml. Skipping...")
113 |     else
114 |       echo "Writing Travis CI config to $PWD/.travis.yml"
115 |       # Write the contents to the config file
116 |       echo "$travis_yml" > "$PWD/.travis.yml"
117 |     fi
118 |   fi
119 | }
120 | 


--------------------------------------------------------------------------------
/src/commands/run.zsh:
--------------------------------------------------------------------------------
  1 | ###########################
  2 | # The 'zunit run' command #
  3 | ###########################
  4 | 
  5 | ###
  6 | # Output usage information and exit
  7 | ###
  8 | function _zunit_run_usage() {
  9 |   echo "$(color yellow 'Usage:')"
 10 |   echo "  zunit run [options] [tests...]"
 11 |   echo
 12 |   echo "$(color yellow 'Options:')"
 13 |   echo "  -h, --help             Output help text and exit"
 14 |   echo "  -v, --version          Output version information and exit"
 15 |   echo "  -f, --fail-fast        Stop the test runner immediately after the first failure"
 16 |   echo "  -t, --tap              Output results in a TAP compatible format"
 17 |   echo "      --verbose          Prints full output from each test"
 18 |   echo "      --output-text      Print results to a text log, in TAP compatible format"
 19 |   echo "      --output-html      Print results to a HTML page"
 20 |   echo "      --allow-risky      Supress warnings generated for risky tests"
 21 |   echo "      --time-limit <n>   Set a time limit of n seconds for each test"
 22 | }
 23 | 
 24 | ###
 25 | # Format a ms timestamp in a human-readable format
 26 | ###
 27 | function _zunit_human_time() {
 28 |   local tmp=$(( $1 / 1000 ))
 29 |   local days=$(( tmp / 60 / 60 / 24 ))
 30 |   local hours=$(( tmp / 60 / 60 % 24 ))
 31 |   local minutes=$(( tmp / 60 % 60 ))
 32 |   local seconds=$(( tmp % 60 ))
 33 |   local ms=$(( $1 % 1000 ))
 34 |   (( $days > 0 )) && print -n "${days}d "
 35 |   (( $hours > 0 )) && print -n "${hours}h "
 36 |   (( $minutes > 0 )) && print -n "${minutes}m "
 37 |   (( $seconds > 5 )) && print -n "${seconds}s "
 38 |   (( $seconds < 30 )) && (( $seconds > 5 )) && print -n "${ms}ms"
 39 |   (( $seconds <= 5 )) && print -n "${1}ms"
 40 | }
 41 | 
 42 | ###
 43 | # Output test results
 44 | ###
 45 | function _zunit_output_results() {
 46 |   integer elapsed=$(( end_time - start_time ))
 47 |   echo
 48 |   echo "$total tests run in $(_zunit_human_time $elapsed)"
 49 |   echo
 50 |   echo "$(color yellow underline 'Results')                        "
 51 |   echo "$(color green '✔') Passed      $passed                    "
 52 |   echo "$(color red '✘') Failed      $failed                      "
 53 |   echo "$(color red '‼') Errors      $errors                      "
 54 |   echo "$(color magenta '●') Skipped     $skipped                 "
 55 |   echo "$(color yellow '‼') Warnings    $warnings                 "
 56 |   echo
 57 | 
 58 |   [[ -n $output_text ]] && echo "TAP report written at $PWD/$logfile_text"
 59 |   [[ -n $output_html ]] && echo "HTML report written at $PWD/$logfile_html"
 60 | }
 61 | 
 62 | ###
 63 | # Execute a test and store the result
 64 | ###
 65 | function _zunit_execute_test() {
 66 |   local name="$1" body="$2"
 67 | 
 68 |   if [[ -n $body ]] && [[ -n $name ]]; then
 69 |     # Update the progress indicator
 70 |     [[ -z $tap ]] && revolver update "${name}"
 71 | 
 72 |     # Make sure we don't already have a function defined
 73 |     (( $+functions[__zunit_tmp_test_function] )) && \
 74 |       unfunction __zunit_tmp_test_function
 75 | 
 76 |     # Create a wrapper function with our test body inside it
 77 |     func="function __zunit_tmp_test_function() {
 78 |       # Exit on errors. We do this so that execution stops immediately,
 79 |       # and the error will be reported back to the test runner
 80 |       setopt ERR_EXIT
 81 | 
 82 |       # Add an exit handler which calls the teardown function if it is
 83 |       # defined and the test exits early
 84 |       if (( \$+functions[__zunit_test_teardown] )); then
 85 |         zshexit() {
 86 |           __zunit_test_teardown 2>&1
 87 |         }
 88 |       fi
 89 | 
 90 |       # Create some local variables to store test state in
 91 |       integer _zunit_assertion_count=0
 92 |       integer state
 93 |       local output
 94 |       typeset -a lines
 95 | 
 96 |       # If a setup function is defined, run it now
 97 |       if (( \$+functions[__zunit_test_setup] )); then
 98 |         __zunit_test_setup 2>&1
 99 |       fi
100 | 
101 |       # The test body is printed here, so when we eval the wrapper
102 |       # function it will be read as part of the body of this function
103 |       ${body}
104 | 
105 |       # If a teardown function is defined, run it now
106 |       if (( \$+functions[__zunit_test_teardown] )); then
107 |         __zunit_test_teardown 2>&1
108 |       fi
109 | 
110 |       # Remove the error handler
111 |       zshexit() {}
112 | 
113 |       # Check the assertion count, and if it is 0, return
114 |       # the warning exit code
115 |       [[ \$_zunit_assertion_count -gt 0 ]] || return 248
116 |     }"
117 | 
118 |     # Increment the test count
119 |     total=$(( total + 1 ))
120 | 
121 |     # Quietly eval the body into a variable as a first test
122 |     output=$(eval "$(echo "$func")" 2>&1)
123 | 
124 |     # Check the status of the eval, and output any errors
125 |     if [[ $? -ne 0 ]]; then
126 |       _zunit_error 'Failed to parse test body' $output
127 | 
128 |       return 126
129 |     fi
130 | 
131 |     # Run the eval again, this time within the current context so that
132 |     # the function is registered in the current scope
133 |     eval "$(echo "$func")" 2>/dev/null
134 | 
135 |     # Any errors should have been caught above, but if the function
136 |     # does not exist, we can't go any further
137 |     if (( ! $+functions[__zunit_tmp_test_function] )); then
138 |       _zunit_error 'Failed to parse test body'
139 | 
140 |       return 126
141 |     fi
142 | 
143 |     # Check if a time limit has been specified. We only do this if
144 |     # the ZSH version is at least 5.1.0, since older versions of ZSH
145 |     # are unable to handle asynchronous processes in the way we need
146 |     autoload is-at-least
147 |     if is-at-least 5.1.0 && [[ -n ${time_limit:#0} ]]; then
148 |       # Create another wrapper function around the test
149 |       __zunit_async_test_wrapper() {
150 |         local pid
151 | 
152 |         # Get the current timestamp, and the time limit in ms, and use
153 |         # those to work out the kill time for the sub process
154 |         integer time_limit_ms=$(( time_limit * 1000 ))
155 |         integer time=$(( EPOCHREALTIME * 1000 ))
156 |         integer kill_time=$(( $time + $time_limit_ms ))
157 | 
158 |         # Launch the test function asynchronously and store its PID
159 |         __zunit_tmp_test_function &
160 |         pid=$!
161 | 
162 |         # While the child process is still running
163 |         while kill -0 $pid >/dev/null 2>&1; do
164 |           # Check that the kill time has not yet been reached
165 |           time=$(( EPOCHREALTIME * 1000 ))
166 |           if [[ $time -gt $kill_time ]]; then
167 |             # The kill time has been reached, kill the child process,
168 |             # and exit the wrapper function
169 |             kill -9 $pid >/dev/null 2>&1
170 |             echo "Test took too long to run. Terminated after $time_limit seconds"
171 |             exit 78
172 |           fi
173 |         done
174 | 
175 |         # Use wait to get the exit code from the background process,
176 |         # and return that so that the test result can be deduced
177 |         wait $pid
178 |         return $?
179 |       }
180 | 
181 |       # Launch the async wrapper, and capture the output in a variable
182 |       output="$(__zunit_async_test_wrapper 2>&1)"
183 |     else
184 |       # Launch the test, and capture the output in a variable
185 |       output="$(__zunit_tmp_test_function 2>&1)"
186 |     fi
187 | 
188 |     # Output the result to the user
189 |     state=$?
190 |     if [[ $state -eq 48 ]]; then
191 |       _zunit_skip $output
192 | 
193 |       return
194 |     elif [[ $state -eq 78 ]]; then
195 |       _zunit_error $output
196 | 
197 |       return
198 |     elif [[ -z $allow_risky && $state -eq 248 ]]; then
199 |       # If --verbose is specified, print test output to screen
200 |       [[ -n $verbose && -n $output ]] && echo $output
201 | 
202 |       _zunit_warn 'No assertions were run, test is risky'
203 | 
204 |       return
205 |     elif [[ -n $allow_risky && $state -eq 248 ]] || [[ $state -eq 0 ]]; then
206 |       # If --verbose is specified, print test output to screen
207 |       [[ -n $verbose && -n $output ]] && echo $output
208 | 
209 |       _zunit_success
210 | 
211 |       return
212 |     else
213 |       _zunit_failure $output
214 | 
215 |       return 1
216 |     fi
217 |   fi
218 | }
219 | 
220 | ###
221 | # Encode test name into a value which can be used as a hash key
222 | ###
223 | function _zunit_encode_test_name() {
224 |   echo "$1" | tr A-Z a-z \
225 |             | tr _ ' ' \
226 |             | tr - ' ' \
227 |             | tr -s ' ' \
228 |             | sed 's/\- /-/' \
229 |             | sed 's/ \-/-/' \
230 |             | tr ' ' "-"
231 | }
232 | 
233 | ###
234 | # Run all tests within a file
235 | ###
236 | function _zunit_run_testfile() {
237 |   local testbody testname pattern \
238 |         setup teardown
239 |   local -a bits; bits=("${(s/@/)1}")
240 |   local testfile="${bits[1]}" test_to_run="${bits[2]}" testdir="$(dirname "$testfile")"
241 |   local -a lines tests test_names
242 |   tests=()
243 |   test_names=()
244 | 
245 |   # Update status message
246 |   [[ -z $tap ]] && revolver update "Loading tests from $testfile"
247 | 
248 |   # A regex pattern to match test declarations
249 |   pattern='^ *@test  *([^ ].*)  *\{ *(.*)$'
250 | 
251 |   # Loop through each of the lines in the file
252 |   local oldIFS=$IFS
253 |   IFS=$'\n' lines=($(cat $testfile))
254 |   IFS=$oldIFS
255 |   for line in $lines[@]; do
256 |     # Match current line against pattern
257 |     if [[ "$line" =~ $pattern ]]; then
258 |       # Get test name from matches
259 |       testname="${line[(( ${line[(i)[\']]}+1 )),(( ${line[(I)[\']]}-1 ))]}"
260 | 
261 |       # If a test name has been passed to the CLI, don't parse this test
262 |       # unless it matches the name passed
263 |       if [[ -n $test_to_run && $testname != $test_to_run ]]; then
264 |         testname=''
265 |         continue
266 |       fi
267 | 
268 |       # Store the test name and body in the arrays so we have somewhere to
269 |       # store the test body
270 |       test_names=($test_names $testname)
271 |       tests[${#test_names}]=''
272 |     elif [[ "$line" =~ '^@setup([ ])?\{$' ]]; then
273 |       setup=''
274 |       parsing_setup=true
275 |     elif [[ "$line" =~ '^@teardown([ ])?\{$' ]]; then
276 |       teardown=''
277 |       parsing_teardown=true
278 |     elif [[ "$line" = '}' ]]; then
279 |       # We've hit a closing brace as the only character on a line,
280 |       # therefore we are at the end of either a test or a setup or teardown
281 |       # function. We'll just clear all three here rather than work out which.
282 |       testname=''
283 |       parsing_setup=''
284 |       parsing_teardown=''
285 |     else
286 |       # A test name is set, so we are parsing a test. Add the
287 |       # current line to the function body.
288 |       if [[ -n $testname ]]; then
289 |         tests[${#test_names}]+="$line"$'\n'
290 |         continue
291 |       fi
292 | 
293 |       # Add the current line to the body of the setup function
294 |       if [[ -n $parsing_setup ]]; then
295 |         setup+="$line"$'\n'
296 |         continue
297 |       fi
298 | 
299 |       # Add the current line to the body of the teardown function
300 |       if [[ -n $parsing_teardown ]]; then
301 |         teardown+="$line"$'\n'
302 |         continue
303 |       fi
304 |     fi
305 |   done
306 | 
307 |   # A setup function has been defined
308 |   if [[ -n $setup ]]; then
309 |     # Print the body into a function declaration
310 |     setupfunc="function __zunit_test_setup() {
311 |       ${setup}
312 |     }"
313 | 
314 |     # Quietly eval the body into a variable as a first test
315 |     output=$(eval "$(echo "$setupfunc")" 2>&1)
316 | 
317 |     # Check the status of the eval, and output any errors
318 |     if [[ $? -ne 0 ]]; then
319 |       _zunit_error "Failed to parse setup method" $output
320 | 
321 |       return 126
322 |     fi
323 | 
324 |     # Run the eval again, this time within the current context so that
325 |     # the function is registered in the current scope
326 |     eval "$(echo "$setupfunc")" 2>/dev/null
327 | 
328 |     # Any errors should have been caught above, but if the function
329 |     # does not exist, we can't go any further
330 |     if (( ! $+functions[__zunit_test_setup] )); then
331 |       _zunit_error "Failed to parse setup method"
332 | 
333 |       return 126
334 |     fi
335 |   fi
336 | 
337 |   # A teardown function has been defined
338 |   if [[ -n $teardown ]]; then
339 |     # Print the body into a function declaration
340 |     teardownfunc="function __zunit_test_teardown() {
341 |       ${teardown}
342 |     }"
343 | 
344 |     # Quietly eval the body into a variable as a first test
345 |     output=$(eval "$(echo "$teardownfunc")" 2>&1)
346 | 
347 |     # Check the status of the eval, and output any errors
348 |     if [[ $? -ne 0 ]]; then
349 |       _zunit_error "Failed to parse teardown method" $output
350 | 
351 |       return 126
352 |     fi
353 | 
354 |     # Run the eval again, this time within the current context so that
355 |     # the function is registered in the current scope
356 |     eval "$(echo "$teardownfunc")" 2>/dev/null
357 | 
358 |     # Any errors should have been caught above, but if the function
359 |     # does not exist, we can't go any further
360 |     if (( ! $+functions[__zunit_test_teardown] )); then
361 |       _zunit_error "Failed to parse teardown method"
362 | 
363 |       return 126
364 |     fi
365 |   fi
366 | 
367 |   # Loop through each of the tests and execute it
368 |   integer i=1
369 |   local name body
370 |   for name in "${test_names[@]}"; do
371 |     body="${tests[$i]}"
372 |     _zunit_execute_test "$name" "$body"
373 |     i=$(( i + 1 ))
374 |   done
375 | 
376 |   # Remove the temporary functions
377 |   (( $+functions[__zunit_test_setup] )) && unfunction __zunit_test_setup
378 |   (( $+functions[__zunit_test_teardown] )) && unfunction __zunit_test_teardown
379 |   (( $+functions[__zunit_tmp_test_function] )) && unfunction __zunit_tmp_test_function
380 | }
381 | 
382 | ###
383 | # Parse a list of arguments
384 | ###
385 | function _zunit_parse_argument() {
386 |   local -a bits; bits=("${(s/@/)1}")
387 |   local argument="$bits[1]" test_name="$bits[2]"
388 | 
389 |   # If the argument begins with an underscore, then it
390 |   # should not be run, so we skip it
391 |   if [[ "${argument:0:1}" = "_" || "$(basename $argument | cut -c 1)" = "_" ]]; then
392 |     return
393 |   fi
394 | 
395 |   # If the argument is a directory
396 |   if [[ -d $argument ]]; then
397 |     # Loop through each of the files in the directory
398 |     for file in $(find $argument -mindepth 1 -maxdepth 1); do
399 |       # Run it through the parser again
400 |       _zunit_parse_argument $file
401 |     done
402 | 
403 |     return
404 |   fi
405 | 
406 |   # If it is a valid file
407 |   if [[ -f $argument ]]; then
408 |     # Grab the first line of the file
409 |     line=$(cat $argument | head -n 1)
410 | 
411 |     # Check for the zunit shebang
412 |     if [[ $line =~ "#! ?/usr/bin/env zunit" ]]; then
413 |       # Add it to the array
414 |       testfiles[(( ${#testfiles} + 1 ))]=("$argument${test_name+"@$test_name"}")
415 |       return
416 |     fi
417 | 
418 |     # The test file does not contain the zunit shebang, therefore
419 |     # we can't trust that running it will not be harmful, and throw
420 |     # a fatal error
421 |     echo $(color red "File '$argument' is not a valid zunit test file") >&2
422 |     echo "Test files must contain the following shebang on the first line" >&2
423 |     echo "  #!/usr/bin/env zunit" >&2
424 |     exit 126
425 |   fi
426 | 
427 |   # The file could not be found, so we throw a fatal error
428 |   echo $(color red "Test file or directory '$argument' could not be found") >&2
429 |   exit 126
430 | }
431 | 
432 | ###
433 | # Run tests
434 | ###
435 | function _zunit_run() {
436 |   local -a arguments testfiles
437 |   local fail_fast tap allow_risky verbose
438 |   local output_text logfile_text output_html logfile_html
439 | 
440 |   # Load the datetime module, and record the start time
441 |   zmodload zsh/datetime
442 |   local start_time=$((EPOCHREALTIME*1000)) end_time
443 | 
444 |   zparseopts -D -E \
445 |     h=help -help=help \
446 |     v=version -version=version \
447 |     f=fail_fast -fail-fast=fail_fast \
448 |     t=tap -tap=tap \
449 |     -verbose=verbose \
450 |     -output-text=output_text \
451 |     -output-html=output_html \
452 |     -allow-risky=allow_risky \
453 |     -time-limit:=time_limit
454 | 
455 |   # TAP output is enabled
456 |   if [[ -n $tap ]] || [[ "$zunit_config_tap" = "true" ]]; then
457 |     # Set the $tap variable, so we can check it later
458 |     tap=1
459 | 
460 |     # Print the TAP header
461 |     echo 'TAP version 13'
462 |   fi
463 | 
464 |   # TAP output is disabled
465 |   if [[ -z $tap ]]; then
466 |     # Print version information
467 |     echo $(color yellow 'Launching ZUnit')
468 |     echo "ZUnit: $(_zunit_version)"
469 |     echo "ZSH:   $(zsh --version)"
470 |     echo
471 |   fi
472 | 
473 |   # Text output has been requested
474 |   if [[ -n $output_text || -n $output_html ]]; then
475 |     # Make sure we have a config file, otherwise we can't determine
476 |     # which directory to write logs to
477 |     if [[ $missing_config -eq 1 ]]; then
478 |       echo $(color red '.zunit.yml could not be found. Run `zulu init`')
479 |       exit 1
480 |     fi
481 | 
482 |     # If the output directory still isn't defined, it must not
483 |     # be defined in the config file
484 |     if [[ -z $zunit_config_directories_output ]]; then
485 |       echo $(color red 'Output directory must be specified in .zunit.yml')
486 |       exit 1
487 |     fi
488 |   fi
489 | 
490 |   if [[ -n $output_text ]]; then
491 |     # Set the log filepath
492 |     logfile_text="$zunit_config_directories_output/output.txt"
493 | 
494 |     # Print the header to the logfile
495 |     echo 'TAP version 13' > $logfile_text
496 |   fi
497 | 
498 |   if [[ -n $output_html ]]; then
499 |     # Set the log filepath
500 |     logfile_html="$zunit_config_directories_output/output.html"
501 | 
502 |     # Print the header to the logfile
503 |     _zunit_html_header > $logfile_html
504 |   fi
505 | 
506 |   if [[ -n $zunit_config_directories_support ]]; then
507 |     # Check that the support directory exists
508 |     local support="$zunit_config_directories_support"
509 |     if [[ ! -d $support ]]; then
510 |       echo $(color red "Support directory at $support is missing")
511 |       exit 1
512 |     fi
513 | 
514 |     # Look for a bootstrap script in the support directory,
515 |     # and run it if it is available
516 |     if [[ -f "$support/bootstrap" ]]; then
517 |       source "$support/bootstrap"
518 |       echo "$(color green '✔') Sourced bootstrap script $support/bootstrap"
519 |     fi
520 |   fi
521 | 
522 |   # Check if fail_fast is specified in the config or as an option
523 |   if [[ -z $fail_fast ]] && [[ "$zunit_config_fail_fast" = "true" ]]; then
524 |     fail_fast=1
525 |   fi
526 | 
527 |   # Check if allow_risky is specified in the config or as an option
528 |   if [[ -z $allow_risky ]] && [[ "$zunit_config_allow_risky" = "true" ]]; then
529 |     allow_risky=1
530 |   fi
531 | 
532 |   # Check if verbose is specified in the config or as an option
533 |   if [[ -z $verbose ]] && [[ "$zunit_config_verbose" = "true" ]]; then
534 |     verbose=1
535 |   fi
536 | 
537 |   # Check if time_limit is specified in the config or as an option
538 |   if [[ -n $time_limit ]]; then
539 |     shift time_limit
540 |   elif [[ -n $zunit_config_time_limit ]]; then
541 |     time_limit=$zunit_config_time_limit
542 |   fi
543 | 
544 |   arguments=("$@")
545 |   testfiles=()
546 | 
547 |   # Start the progress indicator
548 |   [[ -z $tap ]] && revolver start 'Loading tests'
549 | 
550 |   # If no arguments are passed, try to work out where the tests are
551 |   if [[ ${#arguments} -eq 0 ]]; then
552 |     # Check for a path defined in .zunit.yml
553 |     if [[ -n $zunit_config_directories_tests ]]; then
554 |       arguments=("$zunit_config_directories_tests")
555 | 
556 |     # Fall back to the directory 'tests' by default
557 |     else
558 |       arguments=("tests")
559 |     fi
560 |   fi
561 | 
562 |   # Loop through each of the passed arguments
563 |   local argument
564 |   for argument in $arguments; do
565 |     # Parse the argument, so that we end up with a list of valid files
566 |     _zunit_parse_argument $argument
567 |   done
568 | 
569 |   # Loop through each of the test files and run them
570 |   local line
571 |   local total=0 passed=0 failed=0 errors=0 warnings=0 skipped=0
572 |   for testfile in ${(o)testfiles}; do
573 |     _zunit_run_testfile $testfile
574 |   done
575 | 
576 |   end_time=$((EPOCHREALTIME*1000))
577 | 
578 |   # Print report footers
579 |   [[ -n $tap ]] && echo "1..$total"
580 |   [[ -n $output_text ]] && echo "1..$total" >> $logfile_text
581 |   [[ -n $output_html ]] && _zunit_html_footer >> $logfile_html
582 | 
583 |   # Output results to screen and kill the progress indicator
584 |   [[ -z $tap ]] && _zunit_output_results && revolver stop
585 | 
586 |   # If the total of ($passed + $skipped) is not equal to the
587 |   # total, then there must have been failures, errors or warnings,
588 |   # in which case this assertion will return the correct exit code
589 |   # for the test run as a whole
590 |   [[ $(( $passed + $skipped )) -eq $total ]]
591 | }
592 | 


--------------------------------------------------------------------------------
/src/events.zsh:
--------------------------------------------------------------------------------
  1 | ##########################################
  2 | # Functions for handling internal events #
  3 | ##########################################
  4 | 
  5 | ###
  6 | # Shutdown testing early. Called if --fail-fast is specified
  7 | # or if a fatal error occurred during testing
  8 | ###
  9 | function _zunit_fail_shutdown() {
 10 |   # Kill the revolver process
 11 |   [[ -z $tap ]] && revolver stop
 12 | 
 13 |   # Print a message to screen
 14 |   echo $(color red bold 'Execution halted after failure')
 15 | 
 16 |   # Record the time at which testing ended
 17 |   end_time=$((EPOCHREALTIME*1000))
 18 | 
 19 |   # If we're not printing TAP output, then print the
 20 |   # results table to screen
 21 |   [[ -z $tap ]] && _zunit_output_results
 22 | 
 23 |   # If a HTML report has been requested, then print
 24 |   # the end of the HTML report
 25 |   if [[ -n $output_html ]]; then
 26 |     name='Execution halted after failure'
 27 |     _zunit_html_error >> $logfile_html
 28 |     _zunit_html_footer >> $logfile_html
 29 |   fi
 30 | 
 31 |   # Return a error exit code
 32 |   exit 1
 33 | }
 34 | 
 35 | ###
 36 | # Output a success message
 37 | ###
 38 | function _zunit_success() {
 39 |   # Write to reports
 40 |   [[ -n $output_text ]] && _zunit_tap_success "$@" >> $logfile_text
 41 |   [[ -n $output_html ]] && _zunit_html_success "$@" >> $logfile_html
 42 | 
 43 |   passed=$(( passed + 1 ))
 44 | 
 45 |   if [[ -n $tap ]]; then
 46 |     _zunit_tap_success "$@"
 47 |     return
 48 |   fi
 49 | 
 50 |   echo "$(color green '✔') ${name}"
 51 | }
 52 | 
 53 | ###
 54 | # Output a failure message
 55 | ###
 56 | function _zunit_failure() {
 57 |   local message="$1" output="${(@)@:2}"
 58 | 
 59 |   failed=$(( failed + 1 ))
 60 | 
 61 |   # Write to reports
 62 |   [[ -n $output_text ]] && _zunit_tap_failure "$@" >> $logfile_text
 63 |   [[ -n $output_html ]] && _zunit_html_failure "$@" >> $logfile_html
 64 | 
 65 |   if [[ -n $tap ]]; then
 66 |     _zunit_tap_failure "$@"
 67 |   else
 68 |     echo "$(color red '✘' ${name})"
 69 |     echo "  $(color red underline ${message})"
 70 |     echo "  $(color red ${output})"
 71 |   fi
 72 | 
 73 |   [[ -n $fail_fast ]] && _zunit_fail_shutdown
 74 | }
 75 | 
 76 | ###
 77 | # Output a error message
 78 | ###
 79 | function _zunit_error() {
 80 |   local message="$1" output="${(@)@:2}"
 81 | 
 82 |   errors=$(( errors + 1 ))
 83 | 
 84 |   # Write to reports
 85 |   [[ -n $output_text ]] && _zunit_tap_error "$@" >> $logfile_text
 86 |   [[ -n $output_html ]] && _zunit_html_error "$@" >> $logfile_html
 87 | 
 88 |   if [[ -n $tap ]]; then
 89 |     _zunit_tap_error "$@"
 90 |   else
 91 |     echo "$(color red '‼' ${name})"
 92 |     echo "  $(color red underline ${message})"
 93 |     echo "  $(color red ${output})"
 94 |   fi
 95 | 
 96 |   [[ -n $fail_fast ]] && _zunit_fail_shutdown
 97 | }
 98 | 
 99 | ###
100 | # Output a warning message
101 | ###
102 | function _zunit_warn() {
103 |   local message="$@"
104 | 
105 |   warnings=$(( warnings + 1 ))
106 | 
107 |   # Write to reports
108 |   [[ -n $output_text ]] && _zunit_tap_warn "$@" >> $logfile_text
109 |   [[ -n $output_html ]] && _zunit_html_warn "$@" >> $logfile_html
110 | 
111 |   if [[ -n $tap ]]; then
112 |     _zunit_tap_warn "$@"
113 |     return
114 |   fi
115 | 
116 |   echo "$(color yellow '‼') ${name}"
117 |   echo "  $(color yellow underline ${message})"
118 | }
119 | 
120 | ###
121 | # Output a skipped test message
122 | ###
123 | function _zunit_skip() {
124 |   local message="$@"
125 | 
126 |   skipped=$(( skipped + 1 ))
127 | 
128 |   # Write to reports
129 |   [[ -n $output_text ]] && _zunit_tap_skip "$@" >> $logfile_text
130 |   [[ -n $output_html ]] && _zunit_html_skip "$@" >> $logfile_html
131 | 
132 |   if [[ -n $tap ]]; then
133 |     _zunit_tap_skip "$@"
134 |     return
135 |   fi
136 | 
137 |   echo "$(color magenta '●') Skipped: ${name}"
138 |   echo "  \033[0;38;5;242m# ${message}\033[0;m"
139 | }
140 | 


--------------------------------------------------------------------------------
/src/helpers.zsh:
--------------------------------------------------------------------------------
  1 | ################################
  2 | # Helpers for use within tests #
  3 | ################################
  4 | 
  5 | ###
  6 | # Colorise and style a string
  7 | ###
  8 | function color() {
  9 |   local color=$1 style=$2 b=0
 10 | 
 11 |   shift
 12 | 
 13 |   case $style in
 14 |     bold|b)           b=1; shift ;;
 15 |     italic|i)         b=2; shift ;;
 16 |     underline|u)      b=4; shift ;;
 17 |     inverse|in)       b=7; shift ;;
 18 |     strikethrough|s)  b=9; shift ;;
 19 |   esac
 20 | 
 21 |   case $color in
 22 |     black|b)    echo "\033[${b};30m${@}\033[0;m" ;;
 23 |     red|r)      echo "\033[${b};31m${@}\033[0;m" ;;
 24 |     green|g)    echo "\033[${b};32m${@}\033[0;m" ;;
 25 |     yellow|y)   echo "\033[${b};33m${@}\033[0;m" ;;
 26 |     blue|bl)    echo "\033[${b};34m${@}\033[0;m" ;;
 27 |     magenta|m)  echo "\033[${b};35m${@}\033[0;m" ;;
 28 |     cyan|c)     echo "\033[${b};36m${@}\033[0;m" ;;
 29 |     white|w)    echo "\033[${b};37m${@}\033[0;m" ;;
 30 |     *)          echo "\033[${b};38;5;$(( ${color} ))m${@}\033[0;m" ;;
 31 |   esac
 32 | }
 33 | 
 34 | ###
 35 | # Find a file, and load it into the environment
 36 | ###
 37 | function load() {
 38 |   local name="$1"
 39 |   local filename
 40 | 
 41 |   # If filepath is absolute, then use it as is
 42 |   if [[ "${name:0:1}" = "/" ]]; then
 43 |     filename="${name}"
 44 |   # If it's relative, prepend the test directory
 45 |   else
 46 |     filename="$testdir/${name}"
 47 |   fi
 48 | 
 49 |   # Check if the file exists
 50 |   if [[ -f "$filename" ]]; then
 51 |     # Source the file and exit if it's found
 52 |     source "$filename"
 53 |     return 0
 54 |   fi
 55 | 
 56 |   # Perform the check again, adding the .zsh extension
 57 |   if [[ -f "$filename.zsh" ]]; then
 58 |     # Source the file and exit if it's found
 59 |     source "$filename.zsh"
 60 |     return 0
 61 |   fi
 62 | 
 63 |   # We couldn't find the file, so output an error message to the user
 64 |   # and fail the test
 65 |   echo "File $filename does not exist" >&2
 66 |   exit 1
 67 | }
 68 | 
 69 | ###
 70 | # Run an external command and capture its output and exit status
 71 | ###
 72 | function run() {
 73 |   # Within tests, the shell is set to exit immediately when errors
 74 |   # occur. Since we want to capture the exit code of the command
 75 |   # we're running, we stop the shell from exiting on error temporarily
 76 |   unsetopt ERR_EXIT
 77 | 
 78 |   # Preserve current $IFS
 79 |   local oldIFS=$IFS name
 80 |   local -a cmd
 81 | 
 82 |   # Store each word of the command in an array, and grab the first
 83 |   # argument which is the command name
 84 |   cmd=("${@[@]}")
 85 |   name="${cmd[1]}"
 86 | 
 87 |   # If the command is not an existing command or file,
 88 |   # then prepend the test directory to the path
 89 |   type -- $name > /dev/null
 90 |   if [[ $? -ne 0 && ! -f $name && -f "$testdir/${name}" ]]; then
 91 |     cmd[1]="$testdir/${name}"
 92 |   fi
 93 | 
 94 |   # Store full output in a variable
 95 | 
 96 |   local -a dont_quote
 97 |   dont_quote=(
 98 |     # Allow redirections and running multiple commands
 99 |     "[[:digit:]]#(>|>>)(&|)[[:digit:]]#"
100 |     "[[:digit:]]#(<|<<)(&|)[[:digit:]]#"
101 |     "<<<" ";" "\\|" "\\|\\|" "&" "&&"
102 | 
103 |     # Skip quoting of var=... -like strings and also of a single
104 |     # `)' as it might follow var=( ... array assignment
105 |     "([0-9]#|[a-zA-Z_][a-zA-Z0-9_]#)=*" "\\)"
106 |   )
107 | 
108 |   # The new line is important, it makes the error messages include the line
109 |   # number, i.e. e.g.:
110 |   #   run:1: command not found: a-non-existent-command
111 |   # It would be skipped otherwise, i.e. "run: command ..." would be printed
112 |   IFS=$'\n' eval "output=\$( function run {
113 |   ${cmd[@]/(#m)*/${${${${${(M)MATCH:#(${(j:|:)~dont_quote})}:+$MATCH}}:-\"${MATCH//(#b)([\"\`\\])/\\${match[1]}}\"}}} 2>&1 }; run )";
114 | 
115 |   # Get the process exit state
116 |   state="$?"
117 | 
118 |   # Store individual lines of output in an array
119 |   IFS=$'\n'
120 |   lines=("${(@f)output}")
121 | 
122 |   # Restore $IFS
123 |   IFS=$oldIFS
124 | 
125 |   # Print the command output if --verbose is specified
126 |   if [[ -n $verbose && -n $output ]]; then
127 |     echo $output
128 |   fi
129 | 
130 |   # Restore the exit on error state
131 |   setopt ERR_EXIT
132 | }
133 | 
134 | ###
135 | # Eval given code and capture its output and exit status
136 | ###
137 | function evl() {
138 |   # Separation of the main zunit option scope
139 |   setopt localoptions
140 | 
141 |   # Within tests, the shell is set to exit immediately when errors
142 |   # occur. Since we want to capture the exit code of the command
143 |   # we're running, we stop the shell from exiting on error temporarily
144 |   unsetopt ERR_EXIT
145 | 
146 |   # Preserve current $IFS
147 |   local ___oldIFS=$IFS ___name
148 |   local -a ___cmd
149 | 
150 |   # Store each word of the command in an array, and grab the first
151 |   # argument which is the command ___name
152 |   ___cmd=("${@[@]}")
153 |   ___name="${___cmd[1]}"
154 | 
155 |   # If the command is not an existing command or file,
156 |   # then prepend the test directory to the path
157 |   type -- $___name > /dev/null
158 |   if [[ $? -ne 0 && ! -f $___name && -f "$testdir/${___name}" ]]; then
159 |     ___cmd[1]="$testdir/${___name}"
160 |   fi
161 | 
162 |   # Store full output in a variable
163 | 
164 |   local -a ___dont_quote
165 |   ___dont_quote=(
166 |     # Allow redirections and running multiple commands
167 |     "[[:digit:]]#(>|>>)(&|)[[:digit:]]#"
168 |     "[[:digit:]]#(<|<<)(&|)[[:digit:]]#"
169 |     "<<<" ";" "\\|" "\\|\\|" "&" "&&"
170 | 
171 |     # Skip quoting of var=... -like strings and also of a single
172 |     # `)' as it might follow var=( ... array assignment
173 |     "([0-9]#|[a-zA-Z_][a-zA-Z0-9_]#)=*" "\\)"
174 |   )
175 | 
176 |   # Prepare the output file
177 |   local ___OUTFILE=$(mktemp)
178 | 
179 |   # The new line is important, it makes the error messages include the line
180 |   # number, i.e. e.g.:
181 |   #   eval:1: command not found: a-non-existent-command
182 |   # It would be skipped otherwise, i.e. "eval: command ..." would be printed.
183 |   # This is to maintain consistency with the messages printed from run().
184 |   IFS=$'\n' builtin eval "function __eval {
185 |         ${___cmd[@]/(#m)*/${${${${${(M)MATCH:#(${(j:|:)~___dont_quote})}:+$MATCH}}:-\"${MATCH//(#b)([\"\`\\])/\\${match[1]}}\"}}} \
186 |         }; __eval >!$___OUTFILE 2>&1";
187 | 
188 |   # Get the process exit state
189 |   state="$?"
190 | 
191 |   # $(<...) trims all trailing \n-s, therefore cat is being used
192 |   output="$(cat "$___OUTFILE")"
193 | 
194 |   # Cleanup
195 |   unset -f __eval;
196 |   command rm -f "$___OUTFILE"
197 | 
198 |   # Store individual lines of output in an array
199 |   IFS=$'\n'
200 |   lines=("${(@f)output}")
201 | 
202 |   # Restore $IFS
203 |   IFS=$___oldIFS
204 | 
205 |   # Print the command output if --verbose is specified
206 |   if [[ -n $verbose && -n $output ]]; then
207 |     echo $output
208 |   fi
209 | }
210 | 
211 | ###
212 | # Redirect the assertion shorthand to the correct function
213 | ###
214 | function assert() {
215 |   local value=$1 assertion=$2
216 |   local -a comparisons
217 | 
218 |   # Preserve current $IFS
219 |   local oldIFS=$IFS
220 |   IFS=$'\n'
221 | 
222 |   # Store all comparison values in an array
223 |   comparisons=(${(@)@:3})
224 | 
225 |   # If no assertion is passed, then use the first value, as it
226 |   # could be that the value is simply empty
227 |   if [[ -z $assertion ]]; then
228 |     assertion=$value
229 |     value=""
230 |   fi
231 | 
232 |   # Check that the requested assertion method exists
233 |   if (( ! $+functions[_zunit_assert_${assertion}] )); then
234 |     echo "$(color red "Assertion $assertion does not exist")"
235 |     exit 127
236 |   fi
237 | 
238 |   # Increment the assertion count
239 |   _zunit_assertion_count=$(( _zunit_assertion_count + 1 ))
240 | 
241 |   # Run the assertion
242 |   "_zunit_assert_${assertion}" "$value" ${(@f)comparisons[@]}
243 | 
244 |   local state=$?
245 | 
246 |   # If the assertion failed, then return that exit code to the
247 |   # test, which will stop its execution and mark it as failed
248 |   if [[ $state -ne 0 ]]; then
249 |     exit $state
250 |   fi
251 | 
252 |   # Reset $IFS
253 |   IFS=$oldIFS
254 | }
255 | 
256 | ###
257 | # Mark the current test as passed
258 | ###
259 | function pass() {
260 |   # Exit code 0 will end the test, and mark is as passed. The reason for
261 |   # skipping is echoed to stdout first, so that it can be picked up by the
262 |   # error handler
263 |   exit 0
264 | }
265 | 
266 | ###
267 | # Mark the current test as failed
268 | ###
269 | function fail() {
270 |   # Any non-zero exit code without special meaning will mark the test as failed.
271 |   # The failure message is echoed to stdout first, so that it can be picked up
272 |   # by the error handler
273 |   echo "$@"
274 |   exit 1
275 | }
276 | 
277 | ###
278 | # Mark the current test as skipped
279 | ###
280 | function error() {
281 |   # Exit code 78 will end the test, and report an error. The error message
282 |   # is echoed to stdout first, so that it can be picked up by the error handler
283 |   echo "$@"
284 |   exit 78
285 | }
286 | 
287 | ###
288 | # Mark the current test as skipped
289 | ###
290 | function skip() {
291 |   # Exit code 48 will skip the test, so all we have to do
292 |   # to mark the test as skipped is exit.
293 |   # The reason for skipping is echoed to stdout first, so that
294 |   # it can be picked up by the error handler
295 |   echo "$@"
296 |   exit 48
297 | }
298 | 
299 | # vim:ft=zsh:et:sts=2:sw=2
300 | 


--------------------------------------------------------------------------------
/src/reports/html.zsh:
--------------------------------------------------------------------------------
 1 | #########################################
 2 | # Functions for handling HTML reporting #
 3 | #########################################
 4 | 
 5 | ###
 6 | # The head of the HTML document used to display results
 7 | ###
 8 | function _zunit_html_header() {
 9 |   echo '<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="ie=edge"> <title>ZUnit Test Results</title> <link href="https://fonts.googleapis.com/css?family=Fira+Mono" rel="stylesheet"> <style> html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, em, img, ins, kbd, q, s, samp, small, strike, strong, sub, sup, tt, var, b, u, i, center, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, canvas, details, embed, figure, figcaption, footer, header, hgroup, main, menu, nav, output, ruby, section, summary, time, mark, audio, video { margin: 0; padding: 0; border: 0; font-size: 100%; font: inherit; vertical-align: baseline; box-sizing: border-box; } /* HTML5 display-role reset for older browsers */ article, aside, details, figcaption, figure, footer, header, hgroup, main, menu, nav, section { display: block; } body { line-height: 1; } ol, ul { list-style: none; } blockquote, q { quotes: none; } blockquote:before, blockquote:after, q:before, q:after { content: ""; content: none; } table { border-collapse: collapse; border-spacing: 0; } html { font: 100%/1.5em "Fira Code", "Fira Mono", monospace} body { line-height: 1.5em; color: #394648; font-size: 1.125em; } h1, h2, h3, h4, h5, h6 { font-weight: 700; } h1 { font-size: 3em; line-height: 1em; margin-bottom: 0.5em; } h2 { font-size: 2.25em; line-height: 1.35em; margin-bottom: 0.66667em; } h3 { font-size: 1.5em; line-height: 1em; margin-bottom: 1em; } h4 { font-size: 1.3125em; line-height: 1.14286em; margin-bottom: 1.14286em; } h5 { font-size: 1.125em; line-height: 1.35em; margin-bottom: 1.33333em; } h6 { font-size: 1em; line-height: 1.5em; margin-bottom: 1.5em; } p.lead { font-size: 1.5em; } p, ul, ol, dl, blockquote { margin-bottom: 1.5em; } ul { list-style: disc inside; } ol { list-style: decimal inside; } ul ul, ol ul { list-style: circle inside; margin-bottom: 0; margin-left: 1.5em; } ul ol, ol ol { list-style: lower-roman inside; margin-bottom: 0; margin-left: 1.5em; } em { font-style: italic; } strong { font-weight: 700; } small { font-size: .75em; line-height: .5em; } hr { height: 0; margin: calc(3em - 1px) auto 3em; border: solid rgba(53, 12, 16, 0.05); border-width: 0 0 1px; } a { color: #4897da; text-decoration: none; } blockquote, figcaption { display: block; } pre { margin: 0 0 1.5em; } code { font-family: "Fira Code", "Courier New", "Inconsolata", monospace; line-height: 0; } body { padding: 3em 1.5em; } @media (min-width: 36em) { body { padding: 3em; } } @media (min-width: 60em) { body { padding: 3em 6em; } } .header { border-bottom: 1px solid rgba(0,0,0,.1); margin-bottom: 3em; } .header--nav a, .header--nav span { margin-right: 1.5em; } .main { display: flex; } .results { flex: 0 1 100%; padding-right: 15em; } .sidebar--nav { flex: 0 0 12em; position: fixed; right: 6em; top: 7.5em; width: 12em; } .results { list-style: none; } .results--item { border-radius: .15em; display: none; padding: 0 .75em; } .results--item.visible { display: block; } .results--item.expanded { border: 1px solid rgba(0,0,0,.1); margin: 0 0 .375em; } .results--item span { display: none; } .results--item.expanded span { display: block; } .results--item pre { display: none; font-size: .75em; margin: 0; padding: 0; } .results--item.expanded pre { display: block; } .results--item h6 { line-height: 2.25em; margin: 0; } .results--item h6::before { box-sizing: border-box; display: inline-block; margin-right: .375em; vertical-align: middle; } .results--item:not(.passed) h6::after { content: "+"; float: right; } .results--item:not(.passed).expanded h6::after { content: "⌃"; } .results--item.passed h6::before { color: #4ecdc4; content: "✔"; } .results--item.failed h6 { color: #ff6b6b; } .results--item.failed h6::before { color: #ff6b6b; content: "✘"; } .results--item.error { background: #b23939; color: #fff; } .results--item.error h6::before { content: "‼"; } .results--item.warning h6::before { color: #dccb80; content: "‼"; } .results--item.skipped h6::before { color: #d567c6; content: "•"; } .sidebar--nav ul { list-style: none; } .sidebar--nav-item { background: rgba(0,0,0,.1); border-radius: .15em; margin-bottom: .375em; padding: .375em .75em; } .sidebar--nav-item_total, .sidebar--nav-item_elapsed { padding: 0 .75em; } .sidebar--nav-item_elapsed { margin-bottom: 1.5em; } .sidebar--nav-item-count { float: right; font-weight: 700; } .sidebar--nav-item_all.selected { background: #4897da; color: #fff; } .sidebar--nav-item_passed.selected { background: #4ecdc4; color: #fff; } .sidebar--nav-item_failed.selected { background: #ff6b6b; color: #fff; } .sidebar--nav-item_errors.selected { background: #b23939; color: #fff; } .sidebar--nav-item_skipped.selected { background: #d567c6; color: #fff; } .sidebar--nav-item_warnings.selected { background: #dccb80; } </style> <script>;(function() { "use strict"; window.addEventListener("DOMContentLoaded", function() { var results = document.querySelectorAll(".results--item"), links = document.querySelectorAll(".sidebar--nav-item"); var hideAll = function(evt) { for (var i = 0; i < links.length; i++) { (function(link) { if (link.classList.contains("sidebar--nav-item_all")) { return; } if (!link.classList.contains("selected")) { link.classList.add("selected"); } toggleVisibility({currentTarget: link}) }(links[i])); } }; var showAll = function(evt) { for (var i = 0; i < links.length; i++) { (function(link) { if (link.classList.contains("sidebar--nav-item_all")) { return; } if (link.classList.contains("selected")) { link.classList.remove("selected"); } toggleVisibility({currentTarget: link}); }(links[i])); } }; var allLinksAreVisible = function() { var visible = true; for (var i = 0; i < links.length; i++) { if (!links[i].classList.contains("sidebar--nav-item_all") && !links[i].classList.contains("selected")) { visible = false; } } return visible; }; var toggleVisibility = function(evt) { evt = evt || window.evt; var link = evt.currentTarget, target = link.dataset.target; if (link.classList.contains("selected")) { link.classList.remove("selected"); if (link.classList.contains("sidebar--nav-item_all")) { hideAll(); } else { document.querySelector(".sidebar--nav-item_all").classList.remove("selected"); } } else { link.classList.add("selected"); if (link.classList.contains("sidebar--nav-item_all")) { showAll(); } else { if (allLinksAreVisible()) { document.querySelector(".sidebar--nav-item_all").classList.add("selected"); } } } for (var i = 0; i < results.length; i++) { (function(result) { if (result.classList.contains(target)) { if (link.classList.contains("selected")) { result.classList.add("visible"); } else { result.classList.remove("visible"); } } }(results[i])); } }; var toggleResultExpansion = function(evt) { evt = evt || window.event; var result = evt.currentTarget; if (result.classList.contains("expanded")) { result.classList.remove("expanded"); } else { result.classList.add("expanded"); } }; for (var i = 0; i < results.length; i++) { (function(result) { if (!result.classList.contains("passed")) { result.addEventListener("click", toggleResultExpansion, true); } }(results[i])); }; for (var i = 0; i < links.length; i++) { (function(link) { link.addEventListener("click", toggleVisibility, true); }(links[i])); }; }); })();</script> </head> <body> <header class="header"> <nav class="header--nav"> <span>ZUnit Test Results</span> <a href="https://github.com/zunit-zsh/zunit">Documentation</a> </nav> </header> <main role="main" class="main"> <ul class="results">'
10 | }
11 | 
12 | ###
13 | # The footer of the HTML document used to display results
14 | ###
15 | function _zunit_html_footer() {
16 |   integer elapsed=$(( end_time - start_time ))
17 |   output="</ul> <nav class='sidebar--nav'> <ul> <li class='sidebar--nav-item_total'><strong>$total</strong> tests run</li> <li class='sidebar--nav-item_elapsed'>taking <strong>$(_zunit_human_time $elapsed)</strong></li> <li class='sidebar--nav-item sidebar--nav-item_all selected'> All <span class='sidebar--nav-item-count'>$total</span> </li> <li class='sidebar--nav-item sidebar--nav-item_passed selected' data-target='passed'> Passed <span class='sidebar--nav-item-count'>$passed</span> </li> <li class='sidebar--nav-item sidebar--nav-item_failed selected' data-target='failed'> Failed <span class='sidebar--nav-item-count'>$failed</span> </li> <li class='sidebar--nav-item sidebar--nav-item_errors selected' data-target='error'> Errors <span class='sidebar--nav-item-count'>$errors</span> </li> <li class='sidebar--nav-item sidebar--nav-item_warnings selected' data-target='warning'> Warnings <span class='sidebar--nav-item-count'>$warnings</span> </li> <li class='sidebar--nav-item sidebar--nav-item_skipped selected' data-target='skipped'> Skipped <span class='sidebar--nav-item-count'>$skipped</span> </li> </ul> </nav> </main> </body> </html>"
18 |   echo $output
19 | }
20 | 
21 | ###
22 | # Output a HTML success message
23 | ###
24 | _zunit_html_success() {
25 |   echo "<li class='results--item passed visible'>
26 |     <h6>$name</h6>
27 |   </li>"
28 | }
29 | 
30 | ###
31 | # Output a HTML failure message
32 | ###
33 | _zunit_html_failure() {
34 |   echo "<li class='results--item failed visible'>
35 |     <h6>$name</h6>
36 |     <pre><code>$message</code></pre>
37 |   </li>"
38 | }
39 | 
40 | ###
41 | # Output a HTML error message
42 | ###
43 | _zunit_html_error() {
44 |   echo "<li class='results--item error visible'>
45 |     <h6>$name</h6>
46 |     <pre><code>$message</code></pre>
47 |   </li>"
48 | }
49 | 
50 | ###
51 | # Output a HTML warning message
52 | ###
53 | _zunit_html_warn() {
54 |   echo "<li class='results--item warning visible'>
55 |     <h6>$name</h6>
56 |     <span class='results--item_warning'>$message</span>
57 |   </li>"
58 | }
59 | 
60 | ###
61 | # Output a HTML skipped test message
62 | ###
63 | _zunit_html_skip() {
64 |   echo "<li class='results--item skipped visible'>
65 |     <h6>$name</h6>
66 |     <span class='results--item_skip-reason'>$message</span>
67 |   </li>"
68 | }
69 | 
70 | ###
71 | # Output a HTML fatal error message
72 | ###
73 | _zunit_html_fatal_error() {
74 |   message="$@"
75 |   echo "<li class='results--item error fatal visible'>
76 |     <h6>$message</h6>
77 |   </li>"
78 | }
79 | 


--------------------------------------------------------------------------------
/src/reports/tap.zsh:
--------------------------------------------------------------------------------
 1 | ########################################
 2 | # Functions for handling TAP reporting #
 3 | ########################################
 4 | 
 5 | ###
 6 | # Output a TAP compatible success message
 7 | ###
 8 | function _zunit_tap_success() {
 9 |   echo "ok ${total} - ${name}"
10 | }
11 | 
12 | ###
13 | # Output a TAP compatible failure message
14 | ###
15 | function _zunit_tap_failure() {
16 |   local message="$@"
17 | 
18 |   echo "not ok ${total} - Failure: ${name}"
19 |   echo "  ---"
20 |   echo "  message: ${message}"
21 |   echo "  severity: fail"
22 |   echo "  ..."
23 | 
24 |   [[ -n $fail_fast ]] && echo "Bail out!"
25 | }
26 | 
27 | ###
28 | # Output a TAP compatible error message
29 | ###
30 | function _zunit_tap_error() {
31 |   local message="$@"
32 | 
33 |   echo "not ok ${total} - Error: ${name}"
34 |   echo "  ---"
35 |   echo "  message: ${message}"
36 |   echo "  severity: fail"
37 |   echo "  ..."
38 | 
39 |   [[ -n $fail_fast ]] && echo "Bail out!"
40 | }
41 | 
42 | ###
43 | # Output a TAP compatible warning message
44 | ###
45 | function _zunit_tap_warn() {
46 |   local message="$@"
47 | 
48 |   echo "ok ${total} - Warning: ${name}"
49 |   echo "  ---"
50 |   echo "  message: ${message}"
51 |   echo "  severity: comment"
52 |   echo "  ..."
53 | }
54 | 
55 | ###
56 | # Output a TAP compatible skipped test message
57 | ###
58 | function _zunit_tap_skip() {
59 |   local message="$@"
60 | 
61 |   echo "ok ${total} - # SKIP ${name}"
62 |   echo "  ---"
63 |   echo "  message: ${message}"
64 |   echo "  severity: comment"
65 |   echo "  ..."
66 | }
67 | 


--------------------------------------------------------------------------------
/src/zunit.zsh:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env zsh
  2 | 
  3 | setopt extendedglob typesetsilent
  4 | 
  5 | ######################
  6 | # Main zunit process #
  7 | ######################
  8 | 
  9 | ###
 10 | # Output usage information and exit
 11 | ###
 12 | function _zunit_usage() {
 13 |   echo "$(color yellow 'Usage:')"
 14 |   echo "  zunit [options] [command] [tests...]"
 15 |   echo
 16 |   echo "$(color yellow 'Commands:')"
 17 |   echo "  init               Bootstrap zunit in a new project"
 18 |   echo "  run [tests...]     Run tests"
 19 |   echo
 20 |   echo "$(color yellow 'Options:')"
 21 |   echo "  -h, --help         Output help text and exit"
 22 |   echo "  -v, --version      Output version information and exit"
 23 |   echo "  -f, --fail-fast    Stop the test runner immediately after the first failure"
 24 |   echo "  -t, --tap          Output results in a TAP compatible format"
 25 |   echo "      --verbose      Prints full output from each test"
 26 |   echo "      --output-text  Print results to a text log, in TAP compatible format"
 27 |   echo "      --output-html  Print results to a HTML page"
 28 |   echo "      --allow-risky  Supress warnings generated for risky tests"
 29 |   echo "      --time-limit   Set a time limit in seconds for each test"
 30 | }
 31 | 
 32 | ###
 33 | # Output the version number
 34 | ###
 35 | function _zunit_version() {
 36 |   echo '0.8.2'
 37 | }
 38 | 
 39 | ###
 40 | # The main zunit process
 41 | ###
 42 | function _zunit() {
 43 |   local help version ctx="$1" missing_dependencies=0 missing_config=1
 44 | 
 45 |   if [[ -f .zunit.yml ]]; then
 46 |     # Try and parse the config file within a subprocess,
 47 |     # to avoid killing the main thread
 48 |     $(eval $(_zunit_parse_yaml .zunit.yml 'zunit_config_') >/dev/null 2>&1)
 49 |     if [[ $? -eq 0 ]]; then
 50 |       # The config file was parsed successfully, so we Perform the parse
 51 |       # again, but this time on the main thread so that the config vars are
 52 |       # loaded into the enviroment
 53 |       eval $(_zunit_parse_yaml .zunit.yml 'zunit_config_') >/dev/null 2>&1
 54 |       missing_config=0
 55 |     else
 56 |       # The config file failed to parse, so we report this to the user and exit
 57 |       echo "\033[0;31mFailed to parse config file\033[0;m" >&2
 58 |       exit 1
 59 |     fi
 60 |   fi
 61 | 
 62 |   # Check for the 'revolver' dependency
 63 |   $(type revolver >/dev/null 2>&1)
 64 |   if [[ $? -ne 0 ]]; then
 65 |     # 'revolver' could not be found, so print an error message
 66 |     echo "\033[0;31mMissing required dependency: Revolver - https://github.com/molovo/revolver\033[0;m" >&2
 67 |     exit 1
 68 |   fi
 69 | 
 70 |   zparseopts -D -E \
 71 |     h=help -help=help \
 72 |     v=version -version=version
 73 | 
 74 |   # If the version option is passed,
 75 |   # output version information and exit
 76 |   if [[ -n $version ]]; then
 77 |     _zunit_version
 78 |     exit 0
 79 |   fi
 80 | 
 81 |   # Check which command has been passed, and run it. If the command
 82 |   # is not recognised, then we'll assume it's a test file and pass
 83 |   # it to `zunit run`, since that will catch it if it's not a valid file
 84 |   case "$ctx" in
 85 |     init )
 86 |       # If the help option is passed,
 87 |       # output usage information and exit
 88 |       if [[ -n $help ]]; then
 89 |         _zunit_init_usage
 90 |         exit 0
 91 |       fi
 92 | 
 93 |       _zunit_init "${(@)@:2}"
 94 |       ;;
 95 |     run )
 96 |       # If the help option is passed,
 97 |       # output usage information and exit
 98 |       if [[ -n $help ]]; then
 99 |         _zunit_run_usage
100 |         exit 0
101 |       fi
102 | 
103 |       _zunit_run "${(@)@:2}"
104 |       ;;
105 |     * )
106 |       # If the help option is passed,
107 |       # output usage information and exit
108 |       if [[ -n $help ]]; then
109 |         _zunit_usage
110 |         exit 0
111 |       fi
112 | 
113 |       _zunit_run "$@"
114 |       ;;
115 |   esac
116 | }
117 | 
118 | _zunit "$@"
119 | 


--------------------------------------------------------------------------------
/zunit.zsh-completion:
--------------------------------------------------------------------------------
 1 | #compdef zunit
 2 | 
 3 | _zunit_commands=(
 4 |   'run:Run tests'
 5 |   'init:Bootstrap ZUnit in a new project'
 6 | )
 7 | 
 8 | _zunit() {
 9 |   typeset -A opt_args
10 |   local context state line curcontext="$curcontext"
11 | 
12 |   _arguments \
13 |     '1: :_zunit_cmds' \
14 |     '*::arg:->args'
15 | 
16 |   _arguments \
17 |     '*:tests:_files'
18 | 
19 |   _arguments -A \
20 |     '(-h --help)'{-h,--help}'[show help text and exit]' \
21 |     '(-v --version)'{-v,--version}'[show version information and exit]' \
22 |     '(-f --fail-fast)'{-f,--fail-fast}'[stop execution after the first failure]' \
23 |     '(-t --tap)'{-t,--tap}'[output results in a TAP compatible format]' \
24 |     '--verbose[prints full output from each test]' \
25 |     '--output-text[print results to a text log, in TAP compatible format]' \
26 |     '--output-html[print results to a HTML page]' \
27 |     '--allow-risky[supress warnings generated for risky tests]' \
28 |     '--time-limit[set a time limit in seconds for each test]'
29 | 
30 |   case "$state" in
31 |     args )
32 |       case "$words[1]" in
33 |         init )
34 |           _arguments -A \
35 |             '(-h --help)'{-h,--help}'[show help text and exit]' \
36 |             '(-t --travis)'{-t,--travis}'[generate a .travis.yml file]'
37 | 
38 |           _arguments \
39 |             '*::arg:->args'
40 |           ;;
41 |         run )
42 |           _arguments -A \
43 |             '(-h --help)'{-h,--help}'[show help text and exit]' \
44 |             '(-f --fail-fast)'{-f,--fail-fast}'[stop execution after the first failure]' \
45 |             '(-t --tap)'{-t,--tap}'[output results in a TAP compatible format]' \
46 |             '--verbose[prints full output from each test]' \
47 |             '--output-text[print results to a text log, in TAP compatible format]' \
48 |             '--output-html[print results to a HTML page]' \
49 |             '--allow-risky[supress warnings generated for risky tests]' \
50 |             '--time-limit[set a time limit in seconds for each test]'
51 | 
52 |           _arguments \
53 |             '*:tests:_files'
54 |           ;;
55 |       esac
56 |       ;;
57 |   esac
58 | }
59 | 
60 | (( $+functions[_zunit_cmds] )) || _zunit_cmds() {
61 |   _describe -t commands 'commands' _zunit_commands "$@"
62 | }
63 | 
64 | _zunit "$@"
65 | 


--------------------------------------------------------------------------------