pax_global_header00006660000000000000000000000064142747527620014532gustar00rootroot0000000000000052 comment=f8631511001c69a5d2fdae986f87405b9152a68d gotestsum-1.8.2/000077500000000000000000000000001427475276200135745ustar00rootroot00000000000000gotestsum-1.8.2/.circleci/000077500000000000000000000000001427475276200154275ustar00rootroot00000000000000gotestsum-1.8.2/.circleci/config.yml000066400000000000000000000101511427475276200174150ustar00rootroot00000000000000version: 2.1 orbs: go: gotest/tools@0.0.14 workflows: ci: jobs: - go/test: name: test-go-1.16 gotestsum-format: testname executor: name: go/golang tag: 1.16-alpine - go/test: name: test-go-1.17 gotestsum-format: testname executor: name: go/golang tag: 1.17-alpine - go/test: name: test-go-1.18 gotestsum-format: testname executor: name: go/golang tag: 1.18-alpine - go/test: name: test-go-1.19 gotestsum-format: testname executor: name: go/golang tag: 1.19-alpine - go/test: name: test-windows executor: windows pre-steps: - run: | git config --global core.autocrlf false git config --global core.symlinks true - run: | choco upgrade golang echo 'export PATH="$PATH:/c/Program Files/Go/bin"' > $BASH_ENV - run: go version - lint - build - run - update-windows-golden: filters: branches: {ignore: '/.*/'} - build: name: release publish: true filters: tags: {only: '/v[0-9]+(\.[0-9]+)*/'} branches: {ignore: '/.*/'} executors: windows: machine: image: windows-server-2019-vs2019:stable resource_class: windows.medium shell: bash.exe commands: install-goreleaser: description: Install goreleaser steps: - run: name: Install goreleaser command: | wget https://github.com/goreleaser/goreleaser/releases/download/v1.7.0/goreleaser_Linux_x86_64.tar.gz echo "e74934e7571991522324642ac7b032310f04baf192ce2a54db1dc323b97bcd7d goreleaser_Linux_x86_64.tar.gz" > checksum.txt sha256sum -c checksum.txt tar -xf goreleaser_Linux_x86_64.tar.gz mkdir -p ./bin mv goreleaser ./bin jobs: build: parameters: publish: type: boolean default: false executor: name: go/golang tag: 1.19-alpine steps: - go/install: {package: git} - go/install-ssh - checkout - go/mod-download - go/mod-tidy-check - install-goreleaser - unless: condition: << parameters.publish >> steps: run: name: build binaries command: bin/goreleaser --rm-dist --snapshot --config .project/goreleaser.yml - when: condition: << parameters.publish >> steps: run: name: build and publish binaries command: bin/goreleaser --rm-dist --skip-validate --config .project/goreleaser.yml - store_artifacts: path: ./dist destination: dist run: executor: go/golang steps: - go/install: {package: git} - go/install-ssh - checkout - go/mod-download - run: | mkdir -p dist go build -o dist/gotestsum . - run: dist/gotestsum lint: executor: name: go/golang tag: 1.19-alpine steps: - checkout - run: go mod download - run: name: Install golangci-lint command: | mkdir -p /go/bin download=https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh wget -O- -q "$download" | sh -s -- -b /go/bin/ v1.48.0 - run: name: Lint command: | golangci-lint run -v --concurrency 2 --config .project/golangci-lint.yml update-windows-golden: executor: windows steps: - checkout - go/install-gotestsum - run: | git config --global core.autocrlf false git config --global core.symlinks true - run: | choco upgrade golang go version - run: | /go/bin/gotestsum ./testjson ./internal/junitxml -test.update-golden - store_artifacts: path: testjson/testdata/ destination: golden gotestsum-1.8.2/.gitignore000066400000000000000000000000401427475276200155560ustar00rootroot00000000000000vendor/ dist/ junit.xml .plsdo/ gotestsum-1.8.2/.project/000077500000000000000000000000001427475276200153205ustar00rootroot00000000000000gotestsum-1.8.2/.project/Dockerfile000066400000000000000000000011111427475276200173040ustar00rootroot00000000000000 ARG GOLANG_VERSION FROM golang:${GOLANG_VERSION:-1.18-alpine} as golang RUN apk add -U curl git bash ENV CGO_ENABLED=0 \ PS1="# " \ GO111MODULE=on ARG UID=1000 RUN adduser --uid=${UID} --disabled-password devuser USER ${UID}:${UID} FROM golang as tools RUN wget -O- -q https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sh -s && \ mv bin/golangci-lint /go/bin FROM golang as dev COPY --from=tools /go/bin/golangci-lint /usr/bin/golangci-lint FROM dev as dev-with-source COPY . . gotestsum-1.8.2/.project/docs/000077500000000000000000000000001427475276200162505ustar00rootroot00000000000000gotestsum-1.8.2/.project/docs/running-without-go.md000066400000000000000000000017571427475276200223700ustar00rootroot00000000000000# Running without Go `gotestsum` may be run without Go as long as the package to be tested has already been compiled using `go test -c`, and the `test2json` tool is available. The `test2json` tool can be compiled from the Go source tree so that it can be distributed to the environment that needs it. ```sh GOVERSION=1.17.6 OS=$(uname -s | sed 's/.*/\L&/') mkdir -p gopath GOPATH=$(realpath gopath) HOME=$(realpath ./) curl -L --silent https://go.dev/dl/go${GOVERSION}.${OS}-amd64.tar.gz | tar xz -C ./ env HOME=$HOME GOOS=linux GOARCH=amd64 CGO_ENABLED=0 GOPATH=$GOPATH ./go/bin/go build -o test2json -ldflags="-s -w" cmd/test2json mv test2json /usr/local/bin/test2json ``` Or if you have Go installed already: ```sh env GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -o test2json -ldflags="-s -w" cmd/test2json mv test2json /usr/local/bin/test2json ``` Example: running without a Go installation ``` export GOVERSION=1.13 gotestsum --raw-command -- test2json -t -p pkgname ./binary.test -test.v ``` gotestsum-1.8.2/.project/golangci-lint.yml000066400000000000000000000021501427475276200205700ustar00rootroot00000000000000linters-settings: gocyclo: min-complexity: 12 goconst: min-len: 2 min-occurrences: 4 lll: line-length: 120 issues: exclude-use-default: false exclude-rules: - linters: [revive] text: 'should have comment .*or be unexported' - linters: [stylecheck] text: 'ST1000: at least one file in a package should have a package comment' - linters: [errcheck] text: 'Error return value of `.*\.WriteString` is not checked' - linters: [unparam] text: 'result .* is always' - linters: [unparam] text: 'always receives' # Remove once go1.16 is dropped - linters: staticcheck text: 'env.Patch is deprecated' linters: disable-all: true enable: - bodyclose - deadcode - depguard - errcheck - gocognit - goconst - gocyclo - gofmt - goimports - gosimple - govet - ineffassign - interfacer - lll - misspell - nakedret - prealloc - revive - staticcheck - structcheck - stylecheck - typecheck - unconvert - unparam - unused - varcheck - whitespace gotestsum-1.8.2/.project/goreleaser.yml000066400000000000000000000011641427475276200201750ustar00rootroot00000000000000 project_name: gotestsum release: github: owner: gotestyourself name: gotestsum builds: - binary: gotestsum goos: - darwin - windows - linux goarch: - amd64 - arm64 - arm - s390x - ppc64le env: [CGO_ENABLED=0] ldflags: ["-s -w -X gotest.tools/gotestsum/cmd.version={{.Version}}"] ignore: - goos: darwin goarch: s390x - goos: darwin goarch: ppc64le - goos: windows goarch: s390x - goos: windows goarch: ppc64le checksum: name_template: '{{ .ProjectName }}-{{ .Version }}-checksums.txt' gotestsum-1.8.2/LICENSE000066400000000000000000000261361427475276200146110ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. gotestsum-1.8.2/NOTICE000066400000000000000000000011141427475276200144750ustar00rootroot00000000000000 Copyright The gotestsum Authors. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. gotestsum-1.8.2/README.md000066400000000000000000000341411427475276200150560ustar00rootroot00000000000000# gotestsum `gotestsum` runs tests using `go test -json`, prints formatted test output, and a summary of the test run. It is designed to work well for both local development, and for automation like CI. ## Install Download a binary from [releases](https://github.com/gotestyourself/gotestsum/releases), or build from source with `go install gotest.tools/gotestsum@latest`. With `go` version before 1.17, use `go get gotest.tools/gotestsum`. ## Documentation **Core features** - [Output Format](#output-format) from compact to verbose, with color highlighting. - [Summary](#summary) of the test run. - [Add `go test` flags](#custom-go-test-command), or [run a compiled test binary](#executing-a-compiled-test-binary). **CI and Automation** - [`--junitfile`](#junit-xml-output) - write a JUnit XML file for integration with CI systems. - [`--jsonfile`](#json-file-output) - write the `test2json` output in a file. - [`--rerun-fails`](#re-running-failed-tests) - run failed tests again to save time when dealing with flaky test suites. **Local Development** - [`--watch`](#run-tests-when-a-file-is-saved) - when a file is saved, run the tests for the package that includes the file. - [`--post-run-command`](#post-run-command) - run a command after the tests, can be used for desktop notification. - [`gotestsum tool slowest`](#finding-and-skipping-slow-tests) - find the slowest tests, also update slow tests to be skipepd with `-short`. ### Output Format The `--format` flag or `GOTESTSUM_FORMAT` environment variable set the format that is used to print the test names, and possibly test output, as the tests run. Most outputs use color to highlight pass, fail, or skip. Commonly used formats (see `--help` for a full list): * `dots` - print a character for each test. * `pkgname` (default) - print a line for each package. * `testname` - print a line for each test and package. * `standard-quiet` - the standard `go test` format. * `standard-verbose` - the standard `go test -v` format. Have an idea for a new format? Please [share it on github](https://github.com/gotestyourself/gotestsum/issues/new)! #### Demo A demonstration of three `--format` options. ![Demo](https://user-images.githubusercontent.com/442180/182284939-e08a0aa5-4504-4e30-9e88-207ef47f4537.gif)
[Source](https://github.com/gotestyourself/gotestsum/tree/readme-demo/scripts) ### Summary Following the formatted output is a summary of the test run. The summary includes: * The test output, and elapsed time, for any test that fails or is skipped. * The build errors for any package that fails to build. * A `DONE` line with a count of tests run, tests skipped, tests failed, package build errors, and the elapsed time including time to build. ``` DONE 101 tests[, 3 skipped][, 2 failures][, 1 error] in 0.103s ``` To hide parts of the summary use `--hide-summary section`. **Example: hide skipped tests in the summary** ``` gotestsum --hide-summary=skipped ``` **Example: hide everything except the DONE line** ``` gotestsum --hide-summary=skipped,failed,errors,output # or gotestsum --hide-summary=all ``` **Example: hide test output in the summary, only print names of failed and skipped tests and errors** ``` gotestsum --hide-summary=output ``` ### JUnit XML output When the `--junitfile` flag or `GOTESTSUM_JUNITFILE` environment variable are set to a file path, `gotestsum` will write a test report, in JUnit XML format, to the file. This file can be used to integrate with CI systems. ``` gotestsum --junitfile unit-tests.xml ``` If the package names in the `testsuite.name` or `testcase.classname` fields do not work with your CI system these values can be customized using the `--junitfile-testsuite-name`, or `--junitfile-testcase-classname` flags. These flags accept the following values: * `short` - the base name of the package (the single term specified by the package statement). * `relative` - a package path relative to the root of the repository * `full` - the full package path (default) Note: If Go is not installed, or the `go` binary is not in `PATH`, the `GOVERSION` environment variable can be set to remove the "failed to lookup go version for junit xml" warning. ### JSON file output When the `--jsonfile` flag or `GOTESTSUM_JSONFILE` environment variable are set to a file path, `gotestsum` will write a line-delimited JSON file with all the [test2json](https://golang.org/cmd/test2json/#hdr-Output_Format) output that was written by `go test -json`. This file can be used to compare test runs, or find flaky tests. ``` gotestsum --jsonfile test-output.log ``` ### Post Run Command The `--post-run-command` flag may be used to execute a command after the test run has completed. The binary will be run with the following environment variables set: ``` GOTESTSUM_FORMAT # gotestsum format (ex: short) GOTESTSUM_JSONFILE # path to the jsonfile, empty if no file path was given GOTESTSUM_JUNITFILE # path to the junit.xml file, empty if no file path was given TESTS_ERRORS # number of errors TESTS_FAILED # number of failed tests TESTS_SKIPPED # number of skipped tests TESTS_TOTAL # number of tests run ``` To get more details about the test run, such as failure messages or the full list of failed tests, run `gotestsum` with either a `--jsonfile` or `--junitfile` and parse the file from the post-run-command. The [gotestsum/testjson](https://pkg.go.dev/gotest.tools/gotestsum/testjson?tab=doc) package may be used to parse the JSON file output. **Example: desktop notifications** First install the example notification command with `go get gotest.tools/gotestsum/contrib/notify`. The command will be downloaded to `$GOPATH/bin` as `notify`. Note that this example `notify` command only works on macOS with [terminal-notifer](https://github.com/julienXX/terminal-notifier) installed. ``` gotestsum --post-run-command notify ``` **Example: command with flags** Possitional arguments or command line flags can be passed to the `--post-run-command` by quoting the whole command. ``` gotestsum --post-run-command "notify me --date" ``` ### Re-running failed tests When the `--rerun-fails` flag is set, `gotestsum` will re-run any failed tests. The tests will be re-run until each passes once, or the number of attempts exceeds the maximum attempts. Maximum attempts defaults to 2, and can be changed with `--rerun-fails=n`. To avoid re-running tests when there are real failures, the re-run will be skipped when there are too many test failures. By default this value is 10, and can be changed with `--rerun-fails-max-failures=n`. Note that using `--rerun-fails` may require the use of other flags, depending on how you specify args to `go test`: * when used with `--raw-command` the re-run will pass additional arguments to the command. The first arg is a `-test.run` flag with a regex that matches the test to re-run, and second is the name of a go package. These additional args can be passed to `go test`, or a test binary. * when used with any `go test` args (anything after `--` on the command line), the list of packages to test must be specified as a space separated list using the `--packages` arg. **Example** ``` gotestsum --rerun-fails --packages="./..." -- -count=2 ``` * if any of the `go test` args should be passed to the test binary, instead of `go test` itself, the `-args` flag must be used to separate the two groups of arguments. `-args` is a special flag that is understood by `go test` to indicate that any following args should be passed directly to the test binary. **Example** ``` gotestsum --rerun-fails --packages="./..." -- -count=2 -args -update-golden ``` ### Custom `go test` command By default `gotestsum` runs tests using the command `go test -json ./...`. You can change the command with positional arguments after a `--`. You can change just the test directory value (which defaults to `./...`) by setting the `TEST_DIRECTORY` environment variable. You can use `--debug` to echo the command before it is run. **Example: set build tags** ``` gotestsum -- -tags=integration ./... ``` **Example: run tests in a single package** ``` gotestsum -- ./io/http ``` **Example: enable coverage** ``` gotestsum -- -coverprofile=cover.out ./... ``` **Example: run a script instead of `go test`** ``` gotestsum --raw-command -- ./scripts/run_tests.sh ``` Note: when using `--raw-command`, the script must follow a few rules about stdout and stderr output: * The stdout produced by the script must only contain the `test2json` output, or `gotestsum` will fail. If it isn't possible to change the script to avoid non-JSON output, you can use `--ignore-non-json-output-lines` (added in version 1.7.0) to ignore non-JSON lines and write them to `gotestsum`'s stderr instead. * Any stderr produced by the script will be considered an error (this behaviour is necessary because package build errors are only reported by writting to stderr, not the `test2json` stdout). Any stderr produced by tests is not considered an error (it will be in the `test2json` stdout). **Example: accept intput from stdin** ``` cat out.json | gotestsum --raw-command -- cat ``` **Example: run tests with profiling enabled** Using a `profile.sh` script like this: ```sh #!/usr/bin/env bash set -eu for pkg in $(go list "$@"); do dir="$(go list -f '{{ .Dir }}' $pkg)" go test -json -cpuprofile="$dir/cpu.profile" "$pkg" done ``` You can run: ``` gotestsum --raw-command ./profile.sh ./... ``` **Example: using `TEST_DIRECTORY`** ``` TEST_DIRECTORY=./io/http gotestsum ``` ### Executing a compiled test binary `gotestsum` supports executing a compiled test binary (created with `go test -c`) by running it as a custom command. The `-json` flag is handled by `go test` itself, it is not available when using a compiled test binary, so `go tool test2json` must be used to get the output that `gotestsum` expects. **Example: running `./binary.test`** ``` gotestsum --raw-command -- go tool test2json -t -p pkgname ./binary.test -test.v ``` `pkgname` is the name of the package being tested, it will show up in the test output. `./binary.test` is the path to the compiled test binary. The `-test.v` must be included so that `go tool test2json` receives all the output. To execute a test binary without installing Go, see [running without go](./.project/docs/running-without-go.md). ### Finding and skipping slow tests `gotestsum tool slowest` reads [test2json output][testjson], from a file or stdin, and prints the names and elapsed time of slow tests. The tests are sorted from slowest to fastest. `gotestsum tool slowest` can also rewrite the source of tests slower than the threshold, making it possible to optionally skip them. The [test2json output][testjson] can be created with `gotestsum --jsonfile` or `go test -json`. See `gotestsum tool slowest --help`. **Example: printing a list of tests slower than 500 milliseconds** ``` $ gotestsum --format dots --jsonfile json.log [.]····↷··↷· $ gotestsum tool slowest --jsonfile json.log --threshold 500ms gotest.tools/example TestSomething 1.34s gotest.tools/example TestSomethingElse 810ms ``` **Example: skipping slow tests with `go test --short`** Any test slower than 200 milliseconds will be modified to add: ```go if testing.Short() { t.Skip("too slow for testing.Short") } ``` ```sh go test -json -short ./... | gotestsum tool slowest --skip-stmt "testing.Short" --threshold 200ms ``` Use `git diff` to see the file changes. The next time tests are run using `--short` all the slow tests will be skipped. [testjson]: https://golang.org/cmd/test2json/ ### Run tests when a file is saved When the `--watch` flag is set, `gotestsum` will watch directories using [file system notifications](https://pkg.go.dev/github.com/fsnotify/fsnotify). When a Go file in one of those directories is modified, `gotestsum` will run the tests for the package which contains the changed file. By default all directories with at least one file with a `.go` extension, under the current directory will be watched. Use the `--packages` flag to specify a different list. If `--watch` is used with a command line that includes the name of one or more packages as command line arguments (ex: `gotestsum --watch -- ./...` or `gotestsum --watch -- ./extrapkg`), the tests in those packages will also be run when any file changes. While in watch mode, pressing some keys will perform an action: * `r` will run tests for the previous event. Added in version 1.6.1. * `u` will run tests for the previous event, with the `-update` flag added. Many [golden](https://gotest.tools/v3/golden) packages use this flag to automatically update expected values of tests. Added in version 1.8.1. * `d` will run tests for the previous event using `dlv test`, allowing you to debug a test failure using [delve]. A breakpoint will automatically be added at the first line of any tests which failed in the previous run. Additional breakpoints can be added with [`runtime.Breakpoint`](https://golang.org/pkg/runtime/#Breakpoint) or by using the delve command prompt. Added in version 1.6.1. * `a` will run tests for all packages, by using `./...` as the package selector. Added in version 1.7.0. * `l` will scan the directory list again, and if there are any new directories which contain a file with a `.go` extension, they will be added to the watch list. Added in version 1.7.0. Note that [delve] must be installed in order to use debug (`d`). [delve]: https://github.com/go-delve/delve **Example: run tests for a package when any file in that package is saved** ``` gotestsum --watch --format testname ``` ## Development [![Godoc](https://godoc.org/gotest.tools/gotestsum?status.svg)](https://pkg.go.dev/gotest.tools/gotestsum?tab=subdirectories) [![CircleCI](https://circleci.com/gh/gotestyourself/gotestsum/tree/main.svg?style=shield)](https://circleci.com/gh/gotestyourself/gotestsum/tree/main) [![Go Reportcard](https://goreportcard.com/badge/gotest.tools/gotestsum)](https://goreportcard.com/report/gotest.tools/gotestsum) Pull requests and bug reports are welcome! Please open an issue first for any big changes. ## Thanks This package is heavily influenced by the [pytest](https://docs.pytest.org) test runner for `python`. gotestsum-1.8.2/cmd/000077500000000000000000000000001427475276200143375ustar00rootroot00000000000000gotestsum-1.8.2/cmd/cmd.go000066400000000000000000000004001427475276200154230ustar00rootroot00000000000000package cmd // Next splits args into the next positional argument and any remaining args. func Next(args []string) (string, []string) { switch len(args) { case 0: return "", nil case 1: return args[0], nil default: return args[0], args[1:] } } gotestsum-1.8.2/cmd/flags.go000066400000000000000000000050271427475276200157660ustar00rootroot00000000000000package cmd import ( "encoding/csv" "fmt" "path" "strings" "github.com/dnephin/pflag" "github.com/google/shlex" "gotest.tools/gotestsum/internal/junitxml" "gotest.tools/gotestsum/testjson" ) type hideSummaryValue struct { value testjson.Summary } func newHideSummaryValue() *hideSummaryValue { return &hideSummaryValue{value: testjson.SummarizeAll} } func readAsCSV(val string) ([]string, error) { if val == "" { return nil, nil } return csv.NewReader(strings.NewReader(val)).Read() } func (s *hideSummaryValue) Set(val string) error { v, err := readAsCSV(val) if err != nil { return err } for _, item := range v { summary, ok := testjson.NewSummary(item) if !ok { return fmt.Errorf("value must be one or more of: %s", testjson.SummarizeAll.String()) } s.value -= summary } return nil } func (s *hideSummaryValue) Type() string { return "summary" } func (s *hideSummaryValue) String() string { // flip all the bits, since the flag value is the negative of what is stored return (testjson.SummarizeAll ^ s.value).String() } var junitFieldFormatValues = "full, relative, short" type junitFieldFormatValue struct { value junitxml.FormatFunc } func (f *junitFieldFormatValue) Set(val string) error { switch val { case "full": return nil case "relative": f.value = testjson.RelativePackagePath return nil case "short": f.value = path.Base return nil } return fmt.Errorf("invalid value: %v, must be one of: "+junitFieldFormatValues, val) } func (f *junitFieldFormatValue) Type() string { return "field-format" } func (f *junitFieldFormatValue) String() string { return "full" } func (f *junitFieldFormatValue) Value() junitxml.FormatFunc { if f == nil { return nil } return f.value } type commandValue struct { original string command []string } func (c *commandValue) String() string { return c.original } func (c *commandValue) Set(raw string) error { var err error c.command, err = shlex.Split(raw) c.original = raw return err } func (c *commandValue) Type() string { return "command" } func (c *commandValue) Value() []string { if c == nil { return nil } return c.command } var _ pflag.Value = (*stringSlice)(nil) // stringSlice is a flag.Value which populates the string slice by splitting // the raw flag value on whitespace. type stringSlice []string func (s *stringSlice) String() string { return strings.Join(*s, " ") } func (s *stringSlice) Set(raw string) error { *s = append(*s, strings.Fields(raw)...) return nil } func (s *stringSlice) Type() string { return "list" } gotestsum-1.8.2/cmd/flags_test.go000066400000000000000000000016501427475276200170230ustar00rootroot00000000000000package cmd import ( "testing" "gotest.tools/v3/assert" ) func TestNoSummaryValue_SetAndString(t *testing.T) { t.Run("none", func(t *testing.T) { assert.Equal(t, newHideSummaryValue().String(), "none") }) t.Run("one", func(t *testing.T) { value := newHideSummaryValue() assert.NilError(t, value.Set("output")) assert.Equal(t, value.String(), "output") }) t.Run("some", func(t *testing.T) { value := newHideSummaryValue() assert.NilError(t, value.Set("errors,failed")) assert.Equal(t, value.String(), "failed,errors") }) t.Run("bad value", func(t *testing.T) { value := newHideSummaryValue() assert.ErrorContains(t, value.Set("bogus"), "must be one or more of") }) } func TestStringSlice(t *testing.T) { value := "one \ntwo three\n\tfour\t five \n" var v []string ss := (*stringSlice)(&v) assert.NilError(t, ss.Set(value)) assert.DeepEqual(t, v, []string{"one", "two", "three", "four", "five"}) } gotestsum-1.8.2/cmd/handler.go000066400000000000000000000062731427475276200163130ustar00rootroot00000000000000package cmd import ( "fmt" "io" "os" "os/exec" "path/filepath" "gotest.tools/gotestsum/internal/junitxml" "gotest.tools/gotestsum/internal/log" "gotest.tools/gotestsum/testjson" ) type eventHandler struct { formatter testjson.EventFormatter err io.Writer jsonFile io.WriteCloser maxFails int } func (h *eventHandler) Err(text string) error { _, _ = h.err.Write([]byte(text + "\n")) // always return nil, no need to stop scanning if the stderr write fails return nil } func (h *eventHandler) Event(event testjson.TestEvent, execution *testjson.Execution) error { // ignore artificial events with no raw Bytes() if h.jsonFile != nil && len(event.Bytes()) > 0 { _, err := h.jsonFile.Write(append(event.Bytes(), '\n')) if err != nil { return fmt.Errorf("failed to write JSON file: %w", err) } } err := h.formatter.Format(event, execution) if err != nil { return fmt.Errorf("failed to format event: %w", err) } if h.maxFails > 0 && len(execution.Failed()) >= h.maxFails { return fmt.Errorf("ending test run because max failures was reached") } return nil } func (h *eventHandler) Close() error { if h.jsonFile != nil { if err := h.jsonFile.Close(); err != nil { log.Errorf("Failed to close JSON file: %v", err) } } return nil } var _ testjson.EventHandler = &eventHandler{} func newEventHandler(opts *options) (*eventHandler, error) { formatter := testjson.NewEventFormatter(opts.stdout, opts.format) if formatter == nil { return nil, fmt.Errorf("unknown format %s", opts.format) } handler := &eventHandler{ formatter: formatter, err: opts.stderr, maxFails: opts.maxFails, } var err error if opts.jsonFile != "" { _ = os.MkdirAll(filepath.Dir(opts.jsonFile), 0o755) handler.jsonFile, err = os.Create(opts.jsonFile) if err != nil { return handler, fmt.Errorf("failed to open JSON file: %w", err) } } return handler, nil } func writeJUnitFile(opts *options, execution *testjson.Execution) error { if opts.junitFile == "" { return nil } _ = os.MkdirAll(filepath.Dir(opts.junitFile), 0o755) junitFile, err := os.Create(opts.junitFile) if err != nil { return fmt.Errorf("failed to open JUnit file: %v", err) } defer func() { if err := junitFile.Close(); err != nil { log.Errorf("Failed to close JUnit file: %v", err) } }() return junitxml.Write(junitFile, execution, junitxml.Config{ ProjectName: opts.junitProjectName, FormatTestSuiteName: opts.junitTestSuiteNameFormat.Value(), FormatTestCaseClassname: opts.junitTestCaseClassnameFormat.Value(), }) } func postRunHook(opts *options, execution *testjson.Execution) error { command := opts.postRunHookCmd.Value() if len(command) == 0 { return nil } cmd := exec.Command(command[0], command[1:]...) cmd.Stdout = opts.stdout cmd.Stderr = opts.stderr cmd.Env = append( os.Environ(), "GOTESTSUM_JSONFILE="+opts.jsonFile, "GOTESTSUM_JUNITFILE="+opts.junitFile, fmt.Sprintf("TESTS_TOTAL=%d", execution.Total()), fmt.Sprintf("TESTS_FAILED=%d", len(execution.Failed())), fmt.Sprintf("TESTS_SKIPPED=%d", len(execution.Skipped())), fmt.Sprintf("TESTS_ERRORS=%d", len(execution.Errors())), ) // TODO: send a more detailed report to stdin? return cmd.Run() } gotestsum-1.8.2/cmd/handler_test.go000066400000000000000000000061361427475276200173500ustar00rootroot00000000000000package cmd import ( "bytes" "io/ioutil" "os" "path/filepath" "strings" "testing" "gotest.tools/gotestsum/testjson" "gotest.tools/v3/assert" "gotest.tools/v3/env" "gotest.tools/v3/fs" "gotest.tools/v3/golden" ) func TestPostRunHook(t *testing.T) { command := &commandValue{} err := command.Set("go run ./testdata/postrunhook/main.go") assert.NilError(t, err) buf := new(bytes.Buffer) opts := &options{ postRunHookCmd: command, jsonFile: "events.json", junitFile: "junit.xml", stdout: buf, } env.Patch(t, "GOTESTSUM_FORMAT", "short") exec := newExecFromTestData(t) err = postRunHook(opts, exec) assert.NilError(t, err) golden.Assert(t, buf.String(), "post-run-hook-expected") } func newExecFromTestData(t *testing.T) *testjson.Execution { t.Helper() f, err := os.Open("../testjson/testdata/input/go-test-json.out") assert.NilError(t, err) defer f.Close() // nolint: errcheck exec, err := testjson.ScanTestOutput(testjson.ScanConfig{ Stdout: f, Stderr: strings.NewReader(""), }) assert.NilError(t, err) return exec } type bufferCloser struct { bytes.Buffer } func (bufferCloser) Close() error { return nil } func TestEventHandler_Event_WithMissingActionFail(t *testing.T) { buf := new(bufferCloser) errBuf := new(bytes.Buffer) format := testjson.NewEventFormatter(errBuf, "testname") source := golden.Get(t, "../../testjson/testdata/input/go-test-json-missing-test-fail.out") cfg := testjson.ScanConfig{ Stdout: bytes.NewReader(source), Handler: &eventHandler{jsonFile: buf, formatter: format}, } _, err := testjson.ScanTestOutput(cfg) assert.NilError(t, err) assert.Equal(t, buf.String(), string(source)) // confirm the artificial event was sent to the handler by checking the output // of the formatter. golden.Assert(t, errBuf.String(), "event-handler-missing-test-fail-expected") } func TestEventHandler_Event_MaxFails(t *testing.T) { format := testjson.NewEventFormatter(ioutil.Discard, "testname") source := golden.Get(t, "../../testjson/testdata/input/go-test-json.out") cfg := testjson.ScanConfig{ Stdout: bytes.NewReader(source), Handler: &eventHandler{formatter: format, maxFails: 2}, } _, err := testjson.ScanTestOutput(cfg) assert.Error(t, err, "ending test run because max failures was reached") } func TestNewEventHandler_CreatesDirectory(t *testing.T) { dir := fs.NewDir(t, t.Name()) jsonFile := filepath.Join(dir.Path(), "new-path", "log.json") opts := &options{ stdout: new(bytes.Buffer), format: "testname", jsonFile: jsonFile, } _, err := newEventHandler(opts) assert.NilError(t, err) _, err = os.Stat(jsonFile) assert.NilError(t, err) } func TestWriteJunitFile_CreatesDirectory(t *testing.T) { dir := fs.NewDir(t, t.Name()) junitFile := filepath.Join(dir.Path(), "new-path", "junit.xml") opts := &options{ junitFile: junitFile, junitTestCaseClassnameFormat: &junitFieldFormatValue{}, junitTestSuiteNameFormat: &junitFieldFormatValue{}, } exec := &testjson.Execution{} err := writeJUnitFile(opts, exec) assert.NilError(t, err) _, err = os.Stat(junitFile) assert.NilError(t, err) } gotestsum-1.8.2/cmd/internal/000077500000000000000000000000001427475276200161535ustar00rootroot00000000000000gotestsum-1.8.2/cmd/internal/signalhandlerdriver/000077500000000000000000000000001427475276200222025ustar00rootroot00000000000000gotestsum-1.8.2/cmd/internal/signalhandlerdriver/main.go000066400000000000000000000013761427475276200234640ustar00rootroot00000000000000package main import ( "fmt" "io/ioutil" "os" "os/signal" "strconv" "syscall" "time" ) func main() { if len(os.Args) < 2 { log("missing required filename argument") os.Exit(1) } pid := []byte(strconv.Itoa(os.Getpid())) if err := ioutil.WriteFile(os.Args[1], pid, 0644); err != nil { log("failed to write file:", err.Error()) os.Exit(1) } c := make(chan os.Signal, 1) signal.Notify(c) var s os.Signal select { case s = <-c: case <-time.After(time.Minute): log("timeout waiting for signal") os.Exit(1) } log("Received signal:", s) switch n := s.(type) { case syscall.Signal: os.Exit(100 + int(n)) default: log("failed to parse signal number") os.Exit(3) } } func log(v ...interface{}) { fmt.Fprintln(os.Stderr, v...) } gotestsum-1.8.2/cmd/main.go000066400000000000000000000323061427475276200156160ustar00rootroot00000000000000package cmd import ( "context" "errors" "fmt" "io" "os" "os/exec" "os/signal" "strings" "sync/atomic" "syscall" "github.com/dnephin/pflag" "github.com/fatih/color" "gotest.tools/gotestsum/internal/log" "gotest.tools/gotestsum/testjson" ) var version = "dev" func Run(name string, args []string) error { flags, opts := setupFlags(name) switch err := flags.Parse(args); { case err == pflag.ErrHelp: return nil case err != nil: usage(os.Stderr, name, flags) return err } opts.args = flags.Args() setupLogging(opts) switch { case opts.version: fmt.Fprintf(os.Stdout, "gotestsum version %s\n", version) return nil case opts.watch: return runWatcher(opts) } return run(opts) } func setupFlags(name string) (*pflag.FlagSet, *options) { opts := &options{ hideSummary: newHideSummaryValue(), junitTestCaseClassnameFormat: &junitFieldFormatValue{}, junitTestSuiteNameFormat: &junitFieldFormatValue{}, postRunHookCmd: &commandValue{}, stdout: color.Output, stderr: color.Error, } flags := pflag.NewFlagSet(name, pflag.ContinueOnError) flags.SetInterspersed(false) flags.Usage = func() { usage(os.Stdout, name, flags) } flags.StringVarP(&opts.format, "format", "f", lookEnvWithDefault("GOTESTSUM_FORMAT", "short"), "print format of test input") flags.BoolVar(&opts.rawCommand, "raw-command", false, "don't prepend 'go test -json' to the 'go test' command") flags.BoolVar(&opts.ignoreNonJSONOutputLines, "ignore-non-json-output-lines", false, "write non-JSON 'go test' output lines to stderr instead of failing") flags.Lookup("ignore-non-json-output-lines").Hidden = true flags.StringVar(&opts.jsonFile, "jsonfile", lookEnvWithDefault("GOTESTSUM_JSONFILE", ""), "write all TestEvents to file") flags.BoolVar(&opts.noColor, "no-color", defaultNoColor, "disable color output") flags.Var(opts.hideSummary, "no-summary", "do not print summary of: "+testjson.SummarizeAll.String()) flags.Lookup("no-summary").Hidden = true flags.Var(opts.hideSummary, "hide-summary", "hide sections of the summary: "+testjson.SummarizeAll.String()) flags.Var(opts.postRunHookCmd, "post-run-command", "command to run after the tests have completed") flags.BoolVar(&opts.watch, "watch", false, "watch go files, and run tests when a file is modified") flags.IntVar(&opts.maxFails, "max-fails", 0, "end the test run after this number of failures") flags.StringVar(&opts.junitFile, "junitfile", lookEnvWithDefault("GOTESTSUM_JUNITFILE", ""), "write a JUnit XML file") flags.Var(opts.junitTestSuiteNameFormat, "junitfile-testsuite-name", "format the testsuite name field as: "+junitFieldFormatValues) flags.Var(opts.junitTestCaseClassnameFormat, "junitfile-testcase-classname", "format the testcase classname field as: "+junitFieldFormatValues) flags.StringVar(&opts.junitProjectName, "junitfile-project-name", lookEnvWithDefault("GOTESTSUM_JUNITFILE_PROJECT_NAME", ""), "name of the project used in the junit.xml file") flags.IntVar(&opts.rerunFailsMaxAttempts, "rerun-fails", 0, "rerun failed tests until they all pass, or attempts exceeds maximum. Defaults to max 2 reruns when enabled.") flags.Lookup("rerun-fails").NoOptDefVal = "2" flags.IntVar(&opts.rerunFailsMaxInitialFailures, "rerun-fails-max-failures", 10, "do not rerun any tests if the initial run has more than this number of failures") flags.Var((*stringSlice)(&opts.packages), "packages", "space separated list of package to test") flags.StringVar(&opts.rerunFailsReportFile, "rerun-fails-report", "", "write a report to the file, of the tests that were rerun") flags.BoolVar(&opts.rerunFailsOnlyRootCases, "rerun-fails-only-root-testcases", false, "rerun only root testcaes, instead of only subtests") flags.Lookup("rerun-fails-only-root-testcases").Hidden = true flags.BoolVar(&opts.debug, "debug", false, "enabled debug logging") flags.BoolVar(&opts.version, "version", false, "show version and exit") return flags, opts } func usage(out io.Writer, name string, flags *pflag.FlagSet) { fmt.Fprintf(out, `Usage: %[1]s [flags] [--] [go test flags] %[1]s [command] Flags: `, name) flags.SetOutput(out) flags.PrintDefaults() fmt.Fprint(out, ` Formats: dots print a character for each test dots-v2 experimental dots format, one package per line pkgname print a line for each package pkgname-and-test-fails print a line for each package and failed test output testname print a line for each test and package standard-quiet standard go test format standard-verbose standard go test -v format Commands: tool tools for working with test2json output help print this help next `) } func lookEnvWithDefault(key, defValue string) string { if value := os.Getenv(key); value != "" { return value } return defValue } type options struct { args []string format string debug bool rawCommand bool ignoreNonJSONOutputLines bool jsonFile string junitFile string postRunHookCmd *commandValue noColor bool hideSummary *hideSummaryValue junitTestSuiteNameFormat *junitFieldFormatValue junitTestCaseClassnameFormat *junitFieldFormatValue junitProjectName string rerunFailsMaxAttempts int rerunFailsMaxInitialFailures int rerunFailsReportFile string rerunFailsOnlyRootCases bool packages []string watch bool maxFails int version bool // shims for testing stdout io.Writer stderr io.Writer } func (o options) Validate() error { if o.rerunFailsMaxAttempts > 0 && len(o.args) > 0 && !o.rawCommand && len(o.packages) == 0 { return fmt.Errorf( "when go test args are used with --rerun-fails-max-attempts " + "the list of packages to test must be specified by the --packages flag") } return nil } var defaultNoColor = func() bool { if os.Getenv("GITHUB_ACTIONS") == "true" { return false } return color.NoColor }() func setupLogging(opts *options) { if opts.debug { log.SetLevel(log.DebugLevel) } color.NoColor = opts.noColor } func run(opts *options) error { ctx, cancel := context.WithCancel(context.Background()) defer cancel() if err := opts.Validate(); err != nil { return err } goTestProc, err := startGoTestFn(ctx, goTestCmdArgs(opts, rerunOpts{})) if err != nil { return err } handler, err := newEventHandler(opts) if err != nil { return err } defer handler.Close() // nolint: errcheck cfg := testjson.ScanConfig{ Stdout: goTestProc.stdout, Stderr: goTestProc.stderr, Handler: handler, Stop: cancel, IgnoreNonJSONOutputLines: opts.ignoreNonJSONOutputLines, } exec, err := testjson.ScanTestOutput(cfg) if err != nil { return finishRun(opts, exec, err) } exitErr := goTestProc.cmd.Wait() if signum := atomic.LoadInt32(&goTestProc.signal); signum != 0 { return finishRun(opts, exec, exitError{num: signalExitCode + int(signum)}) } if exitErr == nil || opts.rerunFailsMaxAttempts == 0 { return finishRun(opts, exec, exitErr) } if err := hasErrors(exitErr, exec); err != nil { return finishRun(opts, exec, err) } failed := len(rerunFailsFilter(opts)(exec.Failed())) if failed > opts.rerunFailsMaxInitialFailures { err := fmt.Errorf( "number of test failures (%d) exceeds maximum (%d) set by --rerun-fails-max-failures", failed, opts.rerunFailsMaxInitialFailures) return finishRun(opts, exec, err) } cfg = testjson.ScanConfig{Execution: exec, Handler: handler} exitErr = rerunFailed(ctx, opts, cfg) if err := writeRerunFailsReport(opts, exec); err != nil { return err } return finishRun(opts, exec, exitErr) } func finishRun(opts *options, exec *testjson.Execution, exitErr error) error { testjson.PrintSummary(opts.stdout, exec, opts.hideSummary.value) if err := writeJUnitFile(opts, exec); err != nil { return fmt.Errorf("failed to write junit file: %w", err) } if err := postRunHook(opts, exec); err != nil { return fmt.Errorf("post run command failed: %w", err) } return exitErr } func goTestCmdArgs(opts *options, rerunOpts rerunOpts) []string { if opts.rawCommand { var result []string result = append(result, opts.args...) result = append(result, rerunOpts.Args()...) return result } args := opts.args result := []string{"go", "test"} if len(args) == 0 { result = append(result, "-json") if rerunOpts.runFlag != "" { result = append(result, rerunOpts.runFlag) } return append(result, cmdArgPackageList(opts, rerunOpts, "./...")...) } if boolArgIndex("json", args) < 0 { result = append(result, "-json") } if rerunOpts.runFlag != "" { // Remove any existing run arg, it needs to be replaced with our new one // and duplicate args are not allowed by 'go test'. runIndex, runIndexEnd := argIndex("run", args) if runIndex >= 0 && runIndexEnd < len(args) { args = append(args[:runIndex], args[runIndexEnd+1:]...) } result = append(result, rerunOpts.runFlag) } pkgArgIndex := findPkgArgPosition(args) result = append(result, args[:pkgArgIndex]...) result = append(result, cmdArgPackageList(opts, rerunOpts)...) result = append(result, args[pkgArgIndex:]...) return result } func cmdArgPackageList(opts *options, rerunOpts rerunOpts, defPkgList ...string) []string { switch { case rerunOpts.pkg != "": return []string{rerunOpts.pkg} case len(opts.packages) > 0: return opts.packages case os.Getenv("TEST_DIRECTORY") != "": return []string{os.Getenv("TEST_DIRECTORY")} default: return defPkgList } } func boolArgIndex(flag string, args []string) int { for i, arg := range args { if arg == "-"+flag || arg == "--"+flag { return i } } return -1 } func argIndex(flag string, args []string) (start, end int) { for i, arg := range args { if arg == "-"+flag || arg == "--"+flag { return i, i + 1 } if strings.HasPrefix(arg, "-"+flag+"=") || strings.HasPrefix(arg, "--"+flag+"=") { return i, i } } return -1, -1 } // The package list is before the -args flag, or at the end of the args list // if the -args flag is not in args. // The -args flag is a 'go test' flag that indicates that all subsequent // args should be passed to the test binary. It requires that the list of // packages comes before -args, so we re-use it as a placeholder in the case // where some args must be passed to the test binary. func findPkgArgPosition(args []string) int { if i := boolArgIndex("args", args); i >= 0 { return i } return len(args) } type proc struct { cmd waiter stdout io.Reader stderr io.Reader // signal is atomically set to the signal value when a signal is received // by newSignalHandler. signal int32 } type waiter interface { Wait() error } func startGoTest(ctx context.Context, args []string) (*proc, error) { if len(args) == 0 { return nil, errors.New("missing command to run") } cmd := exec.CommandContext(ctx, args[0], args[1:]...) cmd.Stdin = os.Stdin p := proc{cmd: cmd} log.Debugf("exec: %s", cmd.Args) var err error p.stdout, err = cmd.StdoutPipe() if err != nil { return nil, err } p.stderr, err = cmd.StderrPipe() if err != nil { return nil, err } if err := cmd.Start(); err != nil { return nil, fmt.Errorf("failed to run %s: %w", strings.Join(cmd.Args, " "), err) } log.Debugf("go test pid: %d", cmd.Process.Pid) ctx, cancel := context.WithCancel(ctx) newSignalHandler(ctx, cmd.Process.Pid, &p) p.cmd = &cancelWaiter{cancel: cancel, wrapped: p.cmd} return &p, nil } // ExitCodeWithDefault returns the ExitStatus of a process from the error returned by // exec.Run(). If the exit status is not available an error is returned. func ExitCodeWithDefault(err error) int { if err == nil { return 0 } if exiterr, ok := err.(exitCoder); ok { if code := exiterr.ExitCode(); code != -1 { return code } } return 127 } type exitCoder interface { ExitCode() int } func IsExitCoder(err error) bool { _, ok := err.(exitCoder) return ok } type exitError struct { num int } func (e exitError) Error() string { return fmt.Sprintf("exit code %d", e.num) } func (e exitError) ExitCode() int { return e.num } // signalExitCode is the base value added to a signal number to produce the // exit code value. This matches the behaviour of bash. const signalExitCode = 128 func newSignalHandler(ctx context.Context, pid int, p *proc) { c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt) go func() { defer signal.Stop(c) select { case <-ctx.Done(): return case s := <-c: atomic.StoreInt32(&p.signal, int32(s.(syscall.Signal))) proc, err := os.FindProcess(pid) if err != nil { log.Errorf("failed to find pid of 'go test': %v", err) return } if err := proc.Signal(s); err != nil { log.Errorf("failed to interrupt 'go test': %v", err) return } } }() } // cancelWaiter wraps a waiter to cancel the context after the wrapped // Wait exits. type cancelWaiter struct { cancel func() wrapped waiter } func (w *cancelWaiter) Wait() error { err := w.wrapped.Wait() w.cancel() return err } gotestsum-1.8.2/cmd/main_e2e_test.go000066400000000000000000000150641427475276200174120ustar00rootroot00000000000000package cmd import ( "bytes" "io/ioutil" "os" "path/filepath" "runtime" "strings" "sync" "testing" "time" "gotest.tools/gotestsum/internal/text" "gotest.tools/v3/assert" "gotest.tools/v3/env" "gotest.tools/v3/fs" "gotest.tools/v3/golden" "gotest.tools/v3/icmd" "gotest.tools/v3/poll" "gotest.tools/v3/skip" ) func TestMain(m *testing.M) { code := m.Run() binaryFixture.Cleanup() os.Exit(code) } func TestE2E_RerunFails(t *testing.T) { if testing.Short() { t.Skip("too slow for short run") } type testCase struct { name string args []string expectedErr string } fn := func(t *testing.T, tc testCase) { tmpFile := fs.NewFile(t, t.Name()+"-seedfile", fs.WithContent("0")) defer tmpFile.Remove() envVars := osEnviron() envVars["TEST_SEEDFILE"] = tmpFile.Path() defer env.PatchAll(t, envVars)() flags, opts := setupFlags("gotestsum") assert.NilError(t, flags.Parse(tc.args)) opts.args = flags.Args() bufStdout := new(bytes.Buffer) opts.stdout = bufStdout bufStderr := new(bytes.Buffer) opts.stderr = bufStderr err := run(opts) if tc.expectedErr != "" { assert.Error(t, err, tc.expectedErr) } else { assert.NilError(t, err) } out := text.ProcessLines(t, bufStdout, text.OpRemoveSummaryLineElapsedTime, text.OpRemoveTestElapsedTime, filepath.ToSlash, // for windows ) golden.Assert(t, out, "e2e/expected/"+expectedFilename(t.Name())) } var testCases = []testCase{ { name: "reruns until success", args: []string{ "-f=testname", "--rerun-fails=4", "--packages=./testdata/e2e/flaky/", "--", "-count=1", "-tags=testdata", }, }, { name: "reruns continues to fail", args: []string{ "-f=testname", "--rerun-fails=2", "--packages=./testdata/e2e/flaky/", "--", "-count=1", "-tags=testdata", }, expectedErr: "exit status 1", }, { name: "first run has errors, abort rerun", args: []string{ "-f=testname", "--rerun-fails=2", "--packages=../testjson/internal/broken", "--", "-count=1", "-tags=stubpkg", }, expectedErr: "rerun aborted because previous run had errors", }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { fn(t, tc) }) } } // osEnviron returns os.Environ() as a map, with any GOTESTSUM_ env vars removed // so that they do not alter the test results. func osEnviron() map[string]string { e := env.ToMap(os.Environ()) for k := range e { if strings.HasPrefix(k, "GOTESTSUM_") { delete(e, k) } } return e } func expectedFilename(name string) string { ver := runtime.Version() switch { case isPreGo114(ver): return name + "-go1.13" default: return name } } // go1.14.6 changed how it prints messages from tests. go1.14.{0-5} used a format // that was different from both go1.14.6 and previous versions of Go. These tests // no longer support that format. func isPreGo114(ver string) bool { prefix := "go1.1" if !strings.HasPrefix(ver, prefix) || len(ver) < len(prefix)+1 { return false } switch ver[len(prefix)] { case '0', '1', '2', '3': return true } return false } var binaryFixture pkgFixtureFile type pkgFixtureFile struct { filename string once sync.Once cleanup func() } func (p *pkgFixtureFile) Path() string { return p.filename } func (p *pkgFixtureFile) Do(f func() string) { p.once.Do(func() { p.filename = f() p.cleanup = func() { os.RemoveAll(p.filename) // nolint: errcheck } }) } func (p *pkgFixtureFile) Cleanup() { if p.cleanup != nil { p.cleanup() } } // compileBinary once the first time this function is called. Subsequent calls // will return the path to the compiled binary. The binary is removed when all // the tests in this package have completed. func compileBinary(t *testing.T) string { t.Helper() if testing.Short() { t.Skip("too slow for short run") } binaryFixture.Do(func() string { tmpDir, err := ioutil.TempDir("", "gotestsum-binary") assert.NilError(t, err) path := filepath.Join(tmpDir, "gotestsum") result := icmd.RunCommand("go", "build", "-o", path, "..") result.Assert(t, icmd.Success) return path }) if binaryFixture.Path() == "" { t.Skip("previous attempt to compile the binary failed") } return binaryFixture.Path() } func TestE2E_SignalHandler(t *testing.T) { skip.If(t, runtime.GOOS == "windows", "test timeout waiting for pidfile") bin := compileBinary(t) tmpDir := fs.NewDir(t, t.Name()) defer tmpDir.Remove() driver := tmpDir.Join("driver") target := filepath.FromSlash("./internal/signalhandlerdriver/") icmd.RunCommand("go", "build", "-o", driver, target). Assert(t, icmd.Success) pidFile := tmpDir.Join("pidfile") args := []string{"--raw-command", "--", driver, pidFile} result := icmd.StartCmd(icmd.Command(bin, args...)) poll.WaitOn(t, poll.FileExists(pidFile), poll.WithTimeout(time.Second)) assert.NilError(t, result.Cmd.Process.Signal(os.Interrupt)) icmd.WaitOnCmd(2*time.Second, result) result.Assert(t, icmd.Expected{ExitCode: 130}) } func TestE2E_MaxFails_EndTestRun(t *testing.T) { if testing.Short() { t.Skip("too slow for short run") } tmpFile := fs.NewFile(t, t.Name()+"-seedfile", fs.WithContent("0")) defer tmpFile.Remove() envVars := osEnviron() envVars["TEST_SEEDFILE"] = tmpFile.Path() defer env.PatchAll(t, envVars)() flags, opts := setupFlags("gotestsum") args := []string{"--max-fails=2", "--packages=./testdata/e2e/flaky/", "--", "-tags=testdata"} assert.NilError(t, flags.Parse(args)) opts.args = flags.Args() bufStdout := new(bytes.Buffer) opts.stdout = bufStdout bufStderr := new(bytes.Buffer) opts.stderr = bufStderr err := run(opts) assert.Error(t, err, "ending test run because max failures was reached") out := text.ProcessLines(t, bufStdout, text.OpRemoveSummaryLineElapsedTime, text.OpRemoveTestElapsedTime, filepath.ToSlash, // for windows ) golden.Assert(t, out, "e2e/expected/"+t.Name()) } func TestE2E_IgnoresWarnings(t *testing.T) { if testing.Short() { t.Skip("too slow for short run") } flags, opts := setupFlags("gotestsum") args := []string{ "--rerun-fails=1", "--packages=./testdata/e2e/ignore_warnings/", "--format=testname", "--", "-tags=testdata", "-cover", "-coverpkg=./cmd/internal", } assert.NilError(t, flags.Parse(args)) opts.args = flags.Args() bufStdout := new(bytes.Buffer) opts.stdout = bufStdout bufStderr := new(bytes.Buffer) opts.stderr = bufStderr err := run(opts) assert.Error(t, err, "exit status 1") out := text.ProcessLines(t, bufStdout, text.OpRemoveSummaryLineElapsedTime, text.OpRemoveTestElapsedTime, filepath.ToSlash, // for windows ) golden.Assert(t, out, "e2e/expected/"+t.Name()) } gotestsum-1.8.2/cmd/main_test.go000066400000000000000000000313161427475276200166550ustar00rootroot00000000000000package cmd import ( "bytes" "encoding/json" "os" "os/exec" "strings" "testing" "gotest.tools/gotestsum/testjson" "gotest.tools/v3/assert" "gotest.tools/v3/assert/cmp" "gotest.tools/v3/env" "gotest.tools/v3/golden" ) func TestUsage_WithFlagsFromSetupFlags(t *testing.T) { defer env.PatchAll(t, nil)() name := "gotestsum" flags, _ := setupFlags(name) buf := new(bytes.Buffer) usage(buf, name, flags) golden.Assert(t, buf.String(), "gotestsum-help-text") } func TestOptions_Validate_FromFlags(t *testing.T) { type testCase struct { name string args []string expected string } fn := func(t *testing.T, tc testCase) { flags, opts := setupFlags("gotestsum") err := flags.Parse(tc.args) assert.NilError(t, err) opts.args = flags.Args() err = opts.Validate() if tc.expected == "" { assert.NilError(t, err) return } assert.ErrorContains(t, err, tc.expected, "opts: %#v", opts) } var testCases = []testCase{ { name: "no flags", }, { name: "rerun flag, raw command", args: []string{"--rerun-fails", "--raw-command", "--", "./test-all"}, }, { name: "rerun flag, no go-test args", args: []string{"--rerun-fails", "--"}, }, { name: "rerun flag, go-test args, no packages flag", args: []string{"--rerun-fails", "--", "./..."}, expected: "the list of packages to test must be specified by the --packages flag", }, { name: "rerun flag, go-test args, with packages flag", args: []string{"--rerun-fails", "--packages", "./...", "--", "--foo"}, }, { name: "rerun flag, no go-test args, with packages flag", args: []string{"--rerun-fails", "--packages", "./..."}, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { fn(t, tc) }) } } func TestGoTestCmdArgs(t *testing.T) { type testCase struct { opts *options rerunOpts rerunOpts env []string expected []string } run := func(t *testing.T, name string, tc testCase) { t.Helper() runCase(t, name, func(t *testing.T) { defer env.PatchAll(t, env.ToMap(tc.env))() actual := goTestCmdArgs(tc.opts, tc.rerunOpts) assert.DeepEqual(t, actual, tc.expected) }) } run(t, "raw command", testCase{ opts: &options{ rawCommand: true, args: []string{"./script", "-test.timeout=20m"}, }, expected: []string{"./script", "-test.timeout=20m"}, }) run(t, "no args", testCase{ opts: &options{}, expected: []string{"go", "test", "-json", "./..."}, }) run(t, "no args, with rerunPackageList arg", testCase{ opts: &options{ packages: []string{"./pkg"}, }, expected: []string{"go", "test", "-json", "./pkg"}, }) run(t, "TEST_DIRECTORY env var no args", testCase{ opts: &options{}, env: []string{"TEST_DIRECTORY=testdir"}, expected: []string{"go", "test", "-json", "testdir"}, }) run(t, "TEST_DIRECTORY env var with args", testCase{ opts: &options{ args: []string{"-tags=integration"}, }, env: []string{"TEST_DIRECTORY=testdir"}, expected: []string{"go", "test", "-json", "-tags=integration", "testdir"}, }) run(t, "no -json arg", testCase{ opts: &options{ args: []string{"-timeout=2m", "./pkg"}, }, expected: []string{"go", "test", "-json", "-timeout=2m", "./pkg"}, }) run(t, "with -json arg", testCase{ opts: &options{ args: []string{"-json", "-timeout=2m", "./pkg"}, }, expected: []string{"go", "test", "-json", "-timeout=2m", "./pkg"}, }) run(t, "raw command, with rerunOpts", testCase{ opts: &options{ rawCommand: true, args: []string{"./script", "-test.timeout=20m"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"./script", "-test.timeout=20m", "-run=TestOne|TestTwo", "./fails"}, }) run(t, "no args, with rerunOpts", testCase{ opts: &options{}, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails"}, }) run(t, "TEST_DIRECTORY env var, no args, with rerunOpts", testCase{ opts: &options{}, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, env: []string{"TEST_DIRECTORY=testdir"}, // TEST_DIRECTORY should be overridden by rerun opts expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails"}, }) run(t, "TEST_DIRECTORY env var, with args, with rerunOpts", testCase{ opts: &options{ args: []string{"-tags=integration"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, env: []string{"TEST_DIRECTORY=testdir"}, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-tags=integration", "./fails"}, }) run(t, "no -json arg, with rerunOpts", testCase{ opts: &options{ args: []string{"-timeout=2m"}, packages: []string{"./pkg"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-timeout=2m", "./fails"}, }) run(t, "with -json arg, with rerunOpts", testCase{ opts: &options{ args: []string{"-json", "-timeout=2m"}, packages: []string{"./pkg"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-run=TestOne|TestTwo", "-json", "-timeout=2m", "./fails"}, }) run(t, "with args, with reunFailsPackageList args, with rerunOpts", testCase{ opts: &options{ args: []string{"-timeout=2m"}, packages: []string{"./pkg1", "./pkg2", "./pkg3"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-timeout=2m", "./fails"}, }) run(t, "with args, with reunFailsPackageList", testCase{ opts: &options{ args: []string{"-timeout=2m"}, packages: []string{"./pkg1", "./pkg2", "./pkg3"}, }, expected: []string{"go", "test", "-json", "-timeout=2m", "./pkg1", "./pkg2", "./pkg3"}, }) run(t, "reunFailsPackageList args, with rerunOpts ", testCase{ opts: &options{ packages: []string{"./pkg1", "./pkg2", "./pkg3"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails"}, }) run(t, "reunFailsPackageList args, with rerunOpts, with -args ", testCase{ opts: &options{ args: []string{"before", "-args", "after"}, packages: []string{"./pkg1"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "before", "./fails", "-args", "after"}, }) run(t, "reunFailsPackageList args, with rerunOpts, with -args at end", testCase{ opts: &options{ args: []string{"before", "-args"}, packages: []string{"./pkg1"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "before", "./fails", "-args"}, }) run(t, "reunFailsPackageList args, with -args at start", testCase{ opts: &options{ args: []string{"-args", "after"}, packages: []string{"./pkg1"}, }, expected: []string{"go", "test", "-json", "./pkg1", "-args", "after"}, }) run(t, "-run arg at start, with rerunOpts ", testCase{ opts: &options{ args: []string{"-run=TestFoo", "-args"}, packages: []string{"./pkg"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "./fails", "-args"}, }) run(t, "-run arg in middle, with rerunOpts ", testCase{ opts: &options{ args: []string{"-count", "1", "--run", "TestFoo", "-args"}, packages: []string{"./pkg"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-count", "1", "./fails", "-args"}, }) run(t, "-run arg at end with missing value, with rerunOpts ", testCase{ opts: &options{ args: []string{"-count", "1", "-run"}, packages: []string{"./pkg"}, }, rerunOpts: rerunOpts{ runFlag: "-run=TestOne|TestTwo", pkg: "./fails", }, expected: []string{"go", "test", "-json", "-run=TestOne|TestTwo", "-count", "1", "-run", "./fails"}, }) } func runCase(t *testing.T, name string, fn func(t *testing.T)) { t.Helper() t.Run(name, func(t *testing.T) { t.Helper() t.Log("case:", name) fn(t) }) } func TestRun_RerunFails_WithTooManyInitialFailures(t *testing.T) { jsonFailed := `{"Package": "pkg", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "fail"} {"Package": "pkg", "Test": "TestTwo", "Action": "run"} {"Package": "pkg", "Test": "TestTwo", "Action": "fail"} {"Package": "pkg", "Action": "fail"} ` fn := func(args []string) *proc { return &proc{ cmd: fakeWaiter{result: newExitCode("failed", 1)}, stdout: strings.NewReader(jsonFailed), stderr: bytes.NewReader(nil), } } reset := patchStartGoTestFn(fn) defer reset() out := new(bytes.Buffer) opts := &options{ rawCommand: true, args: []string{"./test.test"}, format: "testname", rerunFailsMaxAttempts: 3, rerunFailsMaxInitialFailures: 1, stdout: out, stderr: os.Stderr, hideSummary: newHideSummaryValue(), } err := run(opts) assert.ErrorContains(t, err, "number of test failures (2) exceeds maximum (1)", out.String()) } func TestRun_RerunFails_BuildErrorPreventsRerun(t *testing.T) { jsonFailed := `{"Package": "pkg", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "fail"} {"Package": "pkg", "Test": "TestTwo", "Action": "run"} {"Package": "pkg", "Test": "TestTwo", "Action": "fail"} {"Package": "pkg", "Action": "fail"} ` fn := func(args []string) *proc { return &proc{ cmd: fakeWaiter{result: newExitCode("failed", 1)}, stdout: strings.NewReader(jsonFailed), stderr: strings.NewReader("anything here is an error\n"), } } reset := patchStartGoTestFn(fn) defer reset() out := new(bytes.Buffer) opts := &options{ rawCommand: true, args: []string{"./test.test"}, format: "testname", rerunFailsMaxAttempts: 3, rerunFailsMaxInitialFailures: 1, stdout: out, stderr: os.Stderr, hideSummary: newHideSummaryValue(), } err := run(opts) assert.ErrorContains(t, err, "rerun aborted because previous run had errors", out.String()) } // type checking of os/exec.ExitError is done in a test file so that users // installing from source can continue to use versions prior to go1.12. var _ exitCoder = &exec.ExitError{} func TestRun_RerunFails_PanicPreventsRerun(t *testing.T) { jsonFailed := `{"Package": "pkg", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "output","Output":"panic: something went wrong\n"} {"Package": "pkg", "Action": "fail"} ` fn := func(args []string) *proc { return &proc{ cmd: fakeWaiter{result: newExitCode("failed", 1)}, stdout: strings.NewReader(jsonFailed), stderr: bytes.NewReader(nil), } } reset := patchStartGoTestFn(fn) defer reset() out := new(bytes.Buffer) opts := &options{ rawCommand: true, args: []string{"./test.test"}, format: "testname", rerunFailsMaxAttempts: 3, rerunFailsMaxInitialFailures: 1, stdout: out, stderr: os.Stderr, hideSummary: newHideSummaryValue(), } err := run(opts) assert.ErrorContains(t, err, "rerun aborted because previous run had a suspected panic", out.String()) } func TestRun_InputFromStdin(t *testing.T) { stdin := os.Stdin t.Cleanup(func() { os.Stdin = stdin }) r, w, err := os.Pipe() assert.NilError(t, err) t.Cleanup(func() { _ = r.Close() }) os.Stdin = r go func() { defer func() { _ = w.Close() }() e := json.NewEncoder(w) for _, event := range []testjson.TestEvent{ {Action: "run", Package: "pkg"}, {Action: "run", Package: "pkg", Test: "TestOne"}, {Action: "fail", Package: "pkg", Test: "TestOne"}, {Action: "fail", Package: "pkg"}, } { assert.Check(t, e.Encode(event)) } }() stdout := new(bytes.Buffer) err = run(&options{ args: []string{"cat"}, format: "testname", hideSummary: newHideSummaryValue(), rawCommand: true, stdout: stdout, stderr: os.Stderr, }) assert.NilError(t, err) assert.Assert(t, cmp.Contains(stdout.String(), "DONE 1")) } gotestsum-1.8.2/cmd/rerunfails.go000066400000000000000000000110231427475276200170350ustar00rootroot00000000000000package cmd import ( "context" "fmt" "os" "sort" "gotest.tools/gotestsum/testjson" ) type rerunOpts struct { runFlag string pkg string } func (o rerunOpts) Args() []string { var result []string if o.runFlag != "" { result = append(result, o.runFlag) } if o.pkg != "" { result = append(result, o.pkg) } return result } func newRerunOptsFromTestCase(tc testjson.TestCase) rerunOpts { return rerunOpts{ runFlag: goTestRunFlagForTestCase(tc.Test), pkg: tc.Package, } } type testCaseFilter func([]testjson.TestCase) []testjson.TestCase func rerunFailsFilter(o *options) testCaseFilter { if o.rerunFailsOnlyRootCases { return func(tcs []testjson.TestCase) []testjson.TestCase { return tcs } } return testjson.FilterFailedUnique } func rerunFailed(ctx context.Context, opts *options, scanConfig testjson.ScanConfig) error { ctx, cancel := context.WithCancel(ctx) defer cancel() tcFilter := rerunFailsFilter(opts) rec := newFailureRecorderFromExecution(scanConfig.Execution) for attempts := 0; rec.count() > 0 && attempts < opts.rerunFailsMaxAttempts; attempts++ { testjson.PrintSummary(opts.stdout, scanConfig.Execution, testjson.SummarizeNone) opts.stdout.Write([]byte("\n")) // nolint: errcheck nextRec := newFailureRecorder(scanConfig.Handler) for _, tc := range tcFilter(rec.failures) { goTestProc, err := startGoTestFn(ctx, goTestCmdArgs(opts, newRerunOptsFromTestCase(tc))) if err != nil { return err } cfg := testjson.ScanConfig{ RunID: attempts + 1, Stdout: goTestProc.stdout, Stderr: goTestProc.stderr, Handler: nextRec, Execution: scanConfig.Execution, Stop: cancel, } if _, err := testjson.ScanTestOutput(cfg); err != nil { return err } exitErr := goTestProc.cmd.Wait() if exitErr != nil { nextRec.lastErr = exitErr } if err := hasErrors(exitErr, scanConfig.Execution); err != nil { return err } } rec = nextRec } return rec.lastErr } // startGoTestFn is a shim for testing var startGoTestFn = startGoTest func hasErrors(err error, exec *testjson.Execution) error { switch { case len(exec.Errors()) > 0: return fmt.Errorf("rerun aborted because previous run had errors") // Exit code 0 and 1 are expected. case ExitCodeWithDefault(err) > 1: return fmt.Errorf("unexpected go test exit code: %v", err) case exec.HasPanic(): return fmt.Errorf("rerun aborted because previous run had a suspected panic and some test may not have run") default: return nil } } type failureRecorder struct { testjson.EventHandler failures []testjson.TestCase lastErr error } func newFailureRecorder(handler testjson.EventHandler) *failureRecorder { return &failureRecorder{EventHandler: handler} } func newFailureRecorderFromExecution(exec *testjson.Execution) *failureRecorder { return &failureRecorder{failures: exec.Failed()} } func (r *failureRecorder) Event(event testjson.TestEvent, execution *testjson.Execution) error { if !event.PackageEvent() && event.Action == testjson.ActionFail { pkg := execution.Package(event.Package) tc := pkg.LastFailedByName(event.Test) r.failures = append(r.failures, tc) } return r.EventHandler.Event(event, execution) } func (r *failureRecorder) count() int { return len(r.failures) } func goTestRunFlagForTestCase(test testjson.TestName) string { if test.IsSubTest() { root, sub := test.Split() return "-test.run=^" + root + "$/^" + sub + "$" } return "-test.run=^" + test.Name() + "$" } func writeRerunFailsReport(opts *options, exec *testjson.Execution) error { if opts.rerunFailsMaxAttempts == 0 || opts.rerunFailsReportFile == "" { return nil } type testCaseCounts struct { total int failed int } names := []string{} results := map[string]testCaseCounts{} for _, failure := range exec.Failed() { name := failure.Package + "." + failure.Test.Name() if _, ok := results[name]; ok { continue } names = append(names, name) pkg := exec.Package(failure.Package) counts := testCaseCounts{} for _, tc := range pkg.Failed { if tc.Test == failure.Test { counts.total++ counts.failed++ } } for _, tc := range pkg.Passed { if tc.Test == failure.Test { counts.total++ } } // Skipped tests are not counted, but presumably skipped tests can not fail results[name] = counts } fh, err := os.Create(opts.rerunFailsReportFile) if err != nil { return err } sort.Strings(names) for _, name := range names { counts := results[name] fmt.Fprintf(fh, "%s: %d runs, %d failures\n", name, counts.total, counts.failed) } return nil } gotestsum-1.8.2/cmd/rerunfails_test.go000066400000000000000000000110051427475276200200740ustar00rootroot00000000000000package cmd import ( "bytes" "context" "fmt" "io/ioutil" "strings" "testing" "gotest.tools/gotestsum/testjson" "gotest.tools/v3/assert" "gotest.tools/v3/fs" "gotest.tools/v3/golden" ) func TestWriteRerunFailsReport(t *testing.T) { reportFile := fs.NewFile(t, t.Name()) defer reportFile.Remove() opts := &options{ rerunFailsReportFile: reportFile.Path(), rerunFailsMaxAttempts: 4, } exec, err := testjson.ScanTestOutput(testjson.ScanConfig{ Stdout: bytes.NewReader(golden.Get(t, "go-test-json-flaky-rerun.out")), }) assert.NilError(t, err) err = writeRerunFailsReport(opts, exec) assert.NilError(t, err) raw, err := ioutil.ReadFile(reportFile.Path()) assert.NilError(t, err) golden.Assert(t, string(raw), t.Name()+"-expected") } func TestWriteRerunFailsReport_HandlesMissingActionRunEvents(t *testing.T) { reportFile := fs.NewFile(t, t.Name()) defer reportFile.Remove() opts := &options{ rerunFailsReportFile: reportFile.Path(), rerunFailsMaxAttempts: 4, } exec, err := testjson.ScanTestOutput(testjson.ScanConfig{ Stdout: bytes.NewReader(golden.Get(t, "go-test-missing-run-events.out")), }) assert.NilError(t, err) err = writeRerunFailsReport(opts, exec) assert.NilError(t, err) raw, err := ioutil.ReadFile(reportFile.Path()) assert.NilError(t, err) golden.Assert(t, string(raw), t.Name()+"-expected") } func TestGoTestRunFlagFromTestCases(t *testing.T) { type testCase struct { input string expected string } fn := func(t *testing.T, tc testCase) { actual := goTestRunFlagForTestCase(testjson.TestName(tc.input)) assert.Equal(t, actual, tc.expected) } var testCases = map[string]testCase{ "root test case": { input: "TestOne", expected: "-test.run=^TestOne$", }, "sub test case": { input: "TestOne/SubtestA", expected: "-test.run=^TestOne$/^SubtestA$", }, } for name := range testCases { t.Run(name, func(t *testing.T) { fn(t, testCases[name]) }) } } func TestRerunFailed_ReturnsAnErrorWhenTheLastTestIsSuccessful(t *testing.T) { type result struct { out string err error } jsonFailed := `{"Package": "pkg", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "fail"} {"Package": "pkg", "Action": "fail"} ` events := []result{ {out: jsonFailed, err: newExitCode("run-failed-1", 1)}, {out: jsonFailed, err: newExitCode("run-failed-2", 1)}, {out: jsonFailed, err: newExitCode("run-failed-3", 1)}, { out: `{"Package": "pkg", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "pass"} {"Package": "pkg", "Action": "pass"} `, }, } fn := func(args []string) *proc { next := events[0] events = events[1:] return &proc{ cmd: fakeWaiter{result: next.err}, stdout: strings.NewReader(next.out), stderr: bytes.NewReader(nil), } } reset := patchStartGoTestFn(fn) defer reset() stdout := new(bytes.Buffer) ctx := context.Background() opts := &options{ rerunFailsMaxInitialFailures: 10, rerunFailsMaxAttempts: 2, stdout: stdout, } cfg := testjson.ScanConfig{ Execution: newExecutionWithTwoFailures(t), Handler: noopHandler{}, } err := rerunFailed(ctx, opts, cfg) assert.Error(t, err, "run-failed-3") } func patchStartGoTestFn(f func(args []string) *proc) func() { orig := startGoTestFn startGoTestFn = func(ctx context.Context, args []string) (*proc, error) { return f(args), nil } return func() { startGoTestFn = orig } } func newExecutionWithTwoFailures(t *testing.T) *testjson.Execution { t.Helper() out := `{"Package": "pkg", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "run"} {"Package": "pkg", "Test": "TestOne", "Action": "fail"} {"Package": "pkg", "Test": "TestTwo", "Action": "run"} {"Package": "pkg", "Test": "TestTwo", "Action": "fail"} {"Package": "pkg", "Action": "fail"} ` exec, err := testjson.ScanTestOutput(testjson.ScanConfig{ Stdout: strings.NewReader(out), Stderr: strings.NewReader(""), }) assert.NilError(t, err) return exec } type fakeWaiter struct { result error } func (f fakeWaiter) Wait() error { return f.result } type exitCodeError struct { error code int } func (e exitCodeError) ExitCode() int { return e.code } func newExitCode(msg string, code int) error { return exitCodeError{error: fmt.Errorf(msg), code: code} } type noopHandler struct{} func (s noopHandler) Event(testjson.TestEvent, *testjson.Execution) error { return nil } func (s noopHandler) Err(string) error { return nil } gotestsum-1.8.2/cmd/testdata/000077500000000000000000000000001427475276200161505ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/TestWriteRerunFailsReport-expected000066400000000000000000000003541427475276200250150ustar00rootroot00000000000000gotest.tools/gotestsum/testdata/e2e/flaky.TestFailsOften: 4 runs, 3 failures gotest.tools/gotestsum/testdata/e2e/flaky.TestFailsRarely: 2 runs, 1 failures gotest.tools/gotestsum/testdata/e2e/flaky.TestFailsSometimes: 3 runs, 2 failures gotestsum-1.8.2/cmd/testdata/TestWriteRerunFailsReport_HandlesMissingActionRunEvents-expected000066400000000000000000000004761427475276200330220ustar00rootroot00000000000000github.com/hashicorp/consul/test/integration/connect/envoy.TestEnvoy: 5 runs, 5 failures github.com/hashicorp/consul/test/integration/connect/envoy.TestEnvoy/case-ent-cross-namespaces: 3 runs, 3 failures github.com/hashicorp/consul/test/integration/connect/envoy.TestEnvoy/case-ent-intra-namespace: 3 runs, 3 failures gotestsum-1.8.2/cmd/testdata/e2e/000077500000000000000000000000001427475276200166235ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/e2e/expected/000077500000000000000000000000001427475276200204245ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_IgnoresWarnings000066400000000000000000000011011427475276200247520ustar00rootroot00000000000000=== RUN TestIgnoreWarnings --- FAIL: TestIgnoreWarnings FAIL cmd/testdata/e2e/ignore_warnings.TestIgnoreWarnings coverage: [no statements] FAIL cmd/testdata/e2e/ignore_warnings DONE 1 tests, 1 failure === RUN TestIgnoreWarnings --- FAIL: TestIgnoreWarnings FAIL cmd/testdata/e2e/ignore_warnings.TestIgnoreWarnings (re-run 1) coverage: [no statements] FAIL cmd/testdata/e2e/ignore_warnings === Failed === FAIL: cmd/testdata/e2e/ignore_warnings TestIgnoreWarnings === FAIL: cmd/testdata/e2e/ignore_warnings TestIgnoreWarnings (re-run 1) DONE 2 runs, 2 tests, 2 failures gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_MaxFails_EndTestRun000066400000000000000000000003461427475276200254640ustar00rootroot00000000000000 === Failed === FAIL: cmd/testdata/e2e/flaky TestFailsRarely SEED: 0 flaky_test.go:51: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsSometimes SEED: 0 flaky_test.go:58: not this time DONE 3 tests, 2 failures gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_RerunFails/000077500000000000000000000000001427475276200237715ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_RerunFails/first_run_has_errors,_abort_rerun000066400000000000000000000001461427475276200326350ustar00rootroot00000000000000 === Errors ../testjson/internal/broken/broken.go:5:21: undefined: somepackage DONE 0 tests, 1 error first_run_has_errors,_abort_rerun-go1.13000066400000000000000000000001461427475276200334640ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_RerunFails === Errors ../testjson/internal/broken/broken.go:5:21: undefined: somepackage DONE 0 tests, 1 error gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_RerunFails/reruns_continues_to_fail000066400000000000000000000051261427475276200310220ustar00rootroot00000000000000PASS cmd/testdata/e2e/flaky.TestAlwaysPasses === RUN TestFailsRarely SEED: 0 flaky_test.go:51: not this time --- FAIL: TestFailsRarely FAIL cmd/testdata/e2e/flaky.TestFailsRarely === RUN TestFailsSometimes SEED: 0 flaky_test.go:58: not this time --- FAIL: TestFailsSometimes FAIL cmd/testdata/e2e/flaky.TestFailsSometimes PASS cmd/testdata/e2e/flaky.TestFailsOften/subtest_always_passes === RUN TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail === RUN TestFailsOften SEED: 0 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften PASS cmd/testdata/e2e/flaky.TestFailsOftenDoesNotPrefixMatch PASS cmd/testdata/e2e/flaky.TestFailsSometimesDoesNotPrefixMatch FAIL cmd/testdata/e2e/flaky DONE 8 tests, 4 failures PASS cmd/testdata/e2e/flaky.TestFailsRarely (re-run 1) PASS cmd/testdata/e2e/flaky PASS cmd/testdata/e2e/flaky.TestFailsSometimes (re-run 1) PASS cmd/testdata/e2e/flaky === RUN TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 1) === RUN TestFailsOften SEED: 3 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 1) FAIL cmd/testdata/e2e/flaky DONE 2 runs, 12 tests, 6 failures === RUN TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 2) === RUN TestFailsOften SEED: 4 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 2) FAIL cmd/testdata/e2e/flaky === Failed === FAIL: cmd/testdata/e2e/flaky TestFailsRarely SEED: 0 flaky_test.go:51: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsSometimes SEED: 0 flaky_test.go:58: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail === FAIL: cmd/testdata/e2e/flaky TestFailsOften SEED: 0 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 1) flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 1) SEED: 3 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 2) flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 2) SEED: 4 DONE 3 runs, 14 tests, 8 failures gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_RerunFails/reruns_continues_to_fail-go1.13000066400000000000000000000051561427475276200317330ustar00rootroot00000000000000PASS cmd/testdata/e2e/flaky.TestAlwaysPasses === RUN TestFailsRarely SEED: 0 --- FAIL: TestFailsRarely flaky_test.go:51: not this time FAIL cmd/testdata/e2e/flaky.TestFailsRarely === RUN TestFailsSometimes SEED: 0 --- FAIL: TestFailsSometimes flaky_test.go:58: not this time FAIL cmd/testdata/e2e/flaky.TestFailsSometimes PASS cmd/testdata/e2e/flaky.TestFailsOften/subtest_always_passes === RUN TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail === RUN TestFailsOften SEED: 0 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften PASS cmd/testdata/e2e/flaky.TestFailsOftenDoesNotPrefixMatch PASS cmd/testdata/e2e/flaky.TestFailsSometimesDoesNotPrefixMatch FAIL cmd/testdata/e2e/flaky DONE 8 tests, 4 failures PASS cmd/testdata/e2e/flaky.TestFailsRarely (re-run 1) PASS cmd/testdata/e2e/flaky PASS cmd/testdata/e2e/flaky.TestFailsSometimes (re-run 1) PASS cmd/testdata/e2e/flaky === RUN TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 1) === RUN TestFailsOften SEED: 3 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 1) FAIL cmd/testdata/e2e/flaky DONE 2 runs, 12 tests, 6 failures === RUN TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 2) === RUN TestFailsOften SEED: 4 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 2) FAIL cmd/testdata/e2e/flaky === Failed === FAIL: cmd/testdata/e2e/flaky TestFailsRarely SEED: 0 flaky_test.go:51: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsSometimes SEED: 0 flaky_test.go:58: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften SEED: 0 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 1) --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 1) SEED: 3 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 2) --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 2) SEED: 4 DONE 3 runs, 14 tests, 8 failures gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_RerunFails/reruns_until_success000066400000000000000000000065551427475276200302100ustar00rootroot00000000000000PASS cmd/testdata/e2e/flaky.TestAlwaysPasses === RUN TestFailsRarely SEED: 0 flaky_test.go:51: not this time --- FAIL: TestFailsRarely FAIL cmd/testdata/e2e/flaky.TestFailsRarely === RUN TestFailsSometimes SEED: 0 flaky_test.go:58: not this time --- FAIL: TestFailsSometimes FAIL cmd/testdata/e2e/flaky.TestFailsSometimes PASS cmd/testdata/e2e/flaky.TestFailsOften/subtest_always_passes === RUN TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail === RUN TestFailsOften SEED: 0 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften PASS cmd/testdata/e2e/flaky.TestFailsOftenDoesNotPrefixMatch PASS cmd/testdata/e2e/flaky.TestFailsSometimesDoesNotPrefixMatch FAIL cmd/testdata/e2e/flaky DONE 8 tests, 4 failures PASS cmd/testdata/e2e/flaky.TestFailsRarely (re-run 1) PASS cmd/testdata/e2e/flaky PASS cmd/testdata/e2e/flaky.TestFailsSometimes (re-run 1) PASS cmd/testdata/e2e/flaky === RUN TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 1) === RUN TestFailsOften SEED: 3 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 1) FAIL cmd/testdata/e2e/flaky DONE 2 runs, 12 tests, 6 failures === RUN TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 2) === RUN TestFailsOften SEED: 4 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 2) FAIL cmd/testdata/e2e/flaky DONE 3 runs, 14 tests, 8 failures === RUN TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 3) === RUN TestFailsOften SEED: 5 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 3) FAIL cmd/testdata/e2e/flaky DONE 4 runs, 16 tests, 10 failures PASS cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 4) PASS cmd/testdata/e2e/flaky.TestFailsOften (re-run 4) PASS cmd/testdata/e2e/flaky === Failed === FAIL: cmd/testdata/e2e/flaky TestFailsRarely SEED: 0 flaky_test.go:51: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsSometimes SEED: 0 flaky_test.go:58: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail === FAIL: cmd/testdata/e2e/flaky TestFailsOften SEED: 0 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 1) flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 1) SEED: 3 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 2) flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 2) SEED: 4 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 3) flaky_test.go:68: not this time --- FAIL: TestFailsOften/subtest_may_fail === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 3) SEED: 5 DONE 5 runs, 18 tests, 10 failures gotestsum-1.8.2/cmd/testdata/e2e/expected/TestE2E_RerunFails/reruns_until_success-go1.13000066400000000000000000000066151427475276200311130ustar00rootroot00000000000000PASS cmd/testdata/e2e/flaky.TestAlwaysPasses === RUN TestFailsRarely SEED: 0 --- FAIL: TestFailsRarely flaky_test.go:51: not this time FAIL cmd/testdata/e2e/flaky.TestFailsRarely === RUN TestFailsSometimes SEED: 0 --- FAIL: TestFailsSometimes flaky_test.go:58: not this time FAIL cmd/testdata/e2e/flaky.TestFailsSometimes PASS cmd/testdata/e2e/flaky.TestFailsOften/subtest_always_passes === RUN TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail === RUN TestFailsOften SEED: 0 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften PASS cmd/testdata/e2e/flaky.TestFailsOftenDoesNotPrefixMatch PASS cmd/testdata/e2e/flaky.TestFailsSometimesDoesNotPrefixMatch FAIL cmd/testdata/e2e/flaky DONE 8 tests, 4 failures PASS cmd/testdata/e2e/flaky.TestFailsRarely (re-run 1) PASS cmd/testdata/e2e/flaky PASS cmd/testdata/e2e/flaky.TestFailsSometimes (re-run 1) PASS cmd/testdata/e2e/flaky === RUN TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 1) === RUN TestFailsOften SEED: 3 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 1) FAIL cmd/testdata/e2e/flaky DONE 2 runs, 12 tests, 6 failures === RUN TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 2) === RUN TestFailsOften SEED: 4 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 2) FAIL cmd/testdata/e2e/flaky DONE 3 runs, 14 tests, 8 failures === RUN TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time FAIL cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 3) === RUN TestFailsOften SEED: 5 --- FAIL: TestFailsOften FAIL cmd/testdata/e2e/flaky.TestFailsOften (re-run 3) FAIL cmd/testdata/e2e/flaky DONE 4 runs, 16 tests, 10 failures PASS cmd/testdata/e2e/flaky.TestFailsOften/subtest_may_fail (re-run 4) PASS cmd/testdata/e2e/flaky.TestFailsOften (re-run 4) PASS cmd/testdata/e2e/flaky === Failed === FAIL: cmd/testdata/e2e/flaky TestFailsRarely SEED: 0 flaky_test.go:51: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsSometimes SEED: 0 flaky_test.go:58: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften SEED: 0 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 1) --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 1) SEED: 3 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 2) --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 2) SEED: 4 === FAIL: cmd/testdata/e2e/flaky TestFailsOften/subtest_may_fail (re-run 3) --- FAIL: TestFailsOften/subtest_may_fail flaky_test.go:68: not this time === FAIL: cmd/testdata/e2e/flaky TestFailsOften (re-run 3) SEED: 5 DONE 5 runs, 18 tests, 10 failures gotestsum-1.8.2/cmd/testdata/e2e/flaky/000077500000000000000000000000001427475276200177315ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/e2e/flaky/flaky_test.go000066400000000000000000000024761427475276200224360ustar00rootroot00000000000000// +build testdata package flaky import ( "fmt" "io/ioutil" "os" "strconv" "sync" "testing" ) var seed int var seedfile = seedFile() var once = new(sync.Once) func setup(t *testing.T) { once.Do(func() { raw, err := ioutil.ReadFile(seedfile) if err != nil { t.Fatalf("failed to read seed: %v", err) } n, err := strconv.ParseInt(string(raw), 10, 64) if err != nil { t.Fatalf("failed to parse seed: %v", err) } seed = int(n) err = ioutil.WriteFile(seedfile, []byte(strconv.Itoa(seed+1)), 0644) if err != nil { t.Fatalf("failed to write seed: %v", err) } }) fmt.Fprintln(os.Stderr, "SEED: ", seed) } func seedFile() string { if name, ok := os.LookupEnv("TEST_SEEDFILE"); ok { return name } return "/tmp/gotestsum-flaky-seedfile" } func TestAlwaysPasses(t *testing.T) { } func TestFailsRarely(t *testing.T) { setup(t) if seed%20 != 1 { t.Fatal("not this time") } } func TestFailsSometimes(t *testing.T) { setup(t) if seed%4 != 2 { t.Fatal("not this time") } } func TestFailsOften(t *testing.T) { setup(t) t.Run("subtest always passes", func(t *testing.T) {}) t.Run("subtest may fail", func(t *testing.T) { if seed%20 != 6 { t.Fatal("not this time") } }) } func TestFailsOftenDoesNotPrefixMatch(t *testing.T) {} func TestFailsSometimesDoesNotPrefixMatch(t *testing.T) {} gotestsum-1.8.2/cmd/testdata/e2e/ignore_warnings/000077500000000000000000000000001427475276200220165ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/e2e/ignore_warnings/ignore_warnings.go000066400000000000000000000000301427475276200255310ustar00rootroot00000000000000package ignore_warnings gotestsum-1.8.2/cmd/testdata/e2e/ignore_warnings/ignore_warnings_test.go000066400000000000000000000001371427475276200266000ustar00rootroot00000000000000package ignore_warnings import "testing" func TestIgnoreWarnings(t *testing.T) { t.Fail() } gotestsum-1.8.2/cmd/testdata/event-handler-missing-test-fail-expected000066400000000000000000000024051427475276200257640ustar00rootroot00000000000000FAIL gotest.tools/v3/poll === RUN TestWaitOn_WithCompare panic: runtime error: index out of range [1] with length 1 goroutine 7 [running]: gotest.tools/v3/internal/assert.ArgsFromComparisonCall(0xc0000552a0, 0x1, 0x1, 0x1, 0x0, 0x0) /home/daniel/pers/code/gotest.tools/internal/assert/result.go:102 +0x9f gotest.tools/v3/internal/assert.runComparison(0x6bcb80, 0xc00000e180, 0x67dee8, 0xc00007a9f0, 0x0, 0x0, 0x0, 0x7f7f4fb6d108) /home/daniel/pers/code/gotest.tools/internal/assert/result.go:34 +0x2b1 gotest.tools/v3/internal/assert.Eval(0x6bcb80, 0xc00000e180, 0x67dee8, 0x627660, 0xc00007a9f0, 0x0, 0x0, 0x0, 0x642c60) /home/daniel/pers/code/gotest.tools/internal/assert/assert.go:56 +0x2e4 gotest.tools/v3/poll.Compare(0xc00007a9f0, 0x6b74a0, 0x618a60) /home/daniel/pers/code/gotest.tools/poll/poll.go:151 +0x81 gotest.tools/v3/poll.TestWaitOn_WithCompare.func1(0x6be4c0, 0xc00016c240, 0xc00016c240, 0x6be4c0) /home/daniel/pers/code/gotest.tools/poll/poll_test.go:81 +0x58 gotest.tools/v3/poll.WaitOn.func1(0xc00001e3c0, 0x67df50, 0x6c1960, 0xc00016c240) /home/daniel/pers/code/gotest.tools/poll/poll.go:125 +0x62 created by gotest.tools/v3/poll.WaitOn /home/daniel/pers/code/gotest.tools/poll/poll.go:124 +0x16f FAIL gotest.tools/v3/poll.TestWaitOn_WithCompare (-1.00s) gotestsum-1.8.2/cmd/testdata/go-test-json-flaky-rerun.out000066400000000000000000000311161427475276200234710ustar00rootroot00000000000000{"Time":"2020-06-21T21:12:10.815884042-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestAlwaysPasses"} {"Time":"2020-06-21T21:12:10.816009964-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestAlwaysPasses","Output":"=== RUN TestAlwaysPasses\n"} {"Time":"2020-06-21T21:12:10.816024167-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestAlwaysPasses","Output":"--- PASS: TestAlwaysPasses (0.00s)\n"} {"Time":"2020-06-21T21:12:10.81603019-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestAlwaysPasses","Elapsed":0} {"Time":"2020-06-21T21:12:10.81604135-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely"} {"Time":"2020-06-21T21:12:10.816045457-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Output":"=== RUN TestFailsRarely\n"} {"Time":"2020-06-21T21:12:10.816049373-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Output":"SEED: 0\n"} {"Time":"2020-06-21T21:12:10.816063218-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Output":" TestFailsRarely: flaky_test.go:51: not this time\n"} {"Time":"2020-06-21T21:12:10.816068373-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Output":"--- FAIL: TestFailsRarely (0.00s)\n"} {"Time":"2020-06-21T21:12:10.816072877-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Elapsed":0} {"Time":"2020-06-21T21:12:10.81607599-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes"} {"Time":"2020-06-21T21:12:10.81607897-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"=== RUN TestFailsSometimes\n"} {"Time":"2020-06-21T21:12:10.816082575-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"SEED: 0\n"} {"Time":"2020-06-21T21:12:10.816086165-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":" TestFailsSometimes: flaky_test.go:58: not this time\n"} {"Time":"2020-06-21T21:12:10.8160903-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"--- FAIL: TestFailsSometimes (0.00s)\n"} {"Time":"2020-06-21T21:12:10.816094667-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Elapsed":0} {"Time":"2020-06-21T21:12:10.816098149-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften"} {"Time":"2020-06-21T21:12:10.816101281-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"=== RUN TestFailsOften\n"} {"Time":"2020-06-21T21:12:10.81610482-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"SEED: 0\n"} {"Time":"2020-06-21T21:12:10.816108597-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":" TestFailsOften: flaky_test.go:65: not this time\n"} {"Time":"2020-06-21T21:12:10.816112698-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"--- FAIL: TestFailsOften (0.00s)\n"} {"Time":"2020-06-21T21:12:10.816116235-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Elapsed":0} {"Time":"2020-06-21T21:12:10.816119536-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOftenDoesNotPrefixMatch"} {"Time":"2020-06-21T21:12:10.816122935-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOftenDoesNotPrefixMatch","Output":"=== RUN TestFailsOftenDoesNotPrefixMatch\n"} {"Time":"2020-06-21T21:12:10.816127081-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOftenDoesNotPrefixMatch","Output":"--- PASS: TestFailsOftenDoesNotPrefixMatch (0.00s)\n"} {"Time":"2020-06-21T21:12:10.816131578-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOftenDoesNotPrefixMatch","Elapsed":0} {"Time":"2020-06-21T21:12:10.816135262-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimesDoesNotPrefixMatch"} {"Time":"2020-06-21T21:12:10.816139844-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimesDoesNotPrefixMatch","Output":"=== RUN TestFailsSometimesDoesNotPrefixMatch\n"} {"Time":"2020-06-21T21:12:10.816149774-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimesDoesNotPrefixMatch","Output":"--- PASS: TestFailsSometimesDoesNotPrefixMatch (0.00s)\n"} {"Time":"2020-06-21T21:12:10.816155804-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimesDoesNotPrefixMatch","Elapsed":0} {"Time":"2020-06-21T21:12:10.816159612-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"FAIL\n"} {"Time":"2020-06-21T21:12:10.816211999-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"FAIL\tgotest.tools/gotestsum/testdata/e2e/flaky\t0.001s\n"} {"Time":"2020-06-21T21:12:10.816224311-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Elapsed":0.001} {"Time":"2020-06-21T21:12:10.985779906-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely"} {"Time":"2020-06-21T21:12:10.985890459-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Output":"=== RUN TestFailsRarely\n"} {"Time":"2020-06-21T21:12:10.985902826-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Output":"SEED: 1\n"} {"Time":"2020-06-21T21:12:10.985911982-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Output":"--- PASS: TestFailsRarely (0.00s)\n"} {"Time":"2020-06-21T21:12:10.985916034-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsRarely","Elapsed":0} {"Time":"2020-06-21T21:12:10.985923087-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes"} {"Time":"2020-06-21T21:12:10.985926869-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"=== RUN TestFailsSometimes\n"} {"Time":"2020-06-21T21:12:10.985930857-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"SEED: 1\n"} {"Time":"2020-06-21T21:12:10.985934726-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":" TestFailsSometimes: flaky_test.go:58: not this time\n"} {"Time":"2020-06-21T21:12:10.985939499-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"--- FAIL: TestFailsSometimes (0.00s)\n"} {"Time":"2020-06-21T21:12:10.985943642-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Elapsed":0} {"Time":"2020-06-21T21:12:10.985945782-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften"} {"Time":"2020-06-21T21:12:10.985947733-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"=== RUN TestFailsOften\n"} {"Time":"2020-06-21T21:12:10.985949865-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"SEED: 1\n"} {"Time":"2020-06-21T21:12:10.985952001-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":" TestFailsOften: flaky_test.go:65: not this time\n"} {"Time":"2020-06-21T21:12:10.985954479-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"--- FAIL: TestFailsOften (0.00s)\n"} {"Time":"2020-06-21T21:12:10.985956607-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Elapsed":0} {"Time":"2020-06-21T21:12:10.985958719-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"FAIL\n"} {"Time":"2020-06-21T21:12:10.986048472-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"FAIL\tgotest.tools/gotestsum/testdata/e2e/flaky\t0.001s\n"} {"Time":"2020-06-21T21:12:10.986068802-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Elapsed":0.001} {"Time":"2020-06-21T21:12:11.147554767-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes"} {"Time":"2020-06-21T21:12:11.147676606-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"=== RUN TestFailsSometimes\n"} {"Time":"2020-06-21T21:12:11.14768948-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"SEED: 2\n"} {"Time":"2020-06-21T21:12:11.147700275-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Output":"--- PASS: TestFailsSometimes (0.00s)\n"} {"Time":"2020-06-21T21:12:11.147705201-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsSometimes","Elapsed":0} {"Time":"2020-06-21T21:12:11.147710442-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften"} {"Time":"2020-06-21T21:12:11.147712827-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"=== RUN TestFailsOften\n"} {"Time":"2020-06-21T21:12:11.147715318-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"SEED: 2\n"} {"Time":"2020-06-21T21:12:11.147717797-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":" TestFailsOften: flaky_test.go:65: not this time\n"} {"Time":"2020-06-21T21:12:11.147721095-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"--- FAIL: TestFailsOften (0.00s)\n"} {"Time":"2020-06-21T21:12:11.147723329-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Elapsed":0} {"Time":"2020-06-21T21:12:11.147725838-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"FAIL\n"} {"Time":"2020-06-21T21:12:11.14783256-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"FAIL\tgotest.tools/gotestsum/testdata/e2e/flaky\t0.001s\n"} {"Time":"2020-06-21T21:12:11.147849384-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Elapsed":0.001} {"Time":"2020-06-21T21:12:11.226137617-04:00","Action":"run","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften"} {"Time":"2020-06-21T21:12:11.226247164-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"=== RUN TestFailsOften\n"} {"Time":"2020-06-21T21:12:11.226256816-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"SEED: 14\n"} {"Time":"2020-06-21T21:12:11.226264297-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Output":"--- PASS: TestFailsOften (0.00s)\n"} {"Time":"2020-06-21T21:12:11.226266905-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Test":"TestFailsOften","Elapsed":0} {"Time":"2020-06-21T21:12:11.22627268-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"PASS\n"} {"Time":"2020-06-21T21:12:11.226275849-04:00","Action":"output","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Output":"ok \tgotest.tools/gotestsum/testdata/e2e/flaky\t(cached)\n"} {"Time":"2020-06-21T21:12:11.226279592-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testdata/e2e/flaky","Elapsed":0} gotestsum-1.8.2/cmd/testdata/go-test-missing-run-events.out000066400000000000000000000453441427475276200240500ustar00rootroot00000000000000{"Time":"2020-10-22T00:18:23.836961241Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy"} {"Time":"2020-10-22T00:19:07.176212704Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-basic"} {"Time":"2020-10-22T00:19:30.595333272Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-centralconf"} {"Time":"2020-10-22T00:20:00.782717543Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-dc-failover-gateways-none"} {"Time":"2020-10-22T00:21:02.358098165Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-dc-failover-gateways-remote"} {"Time":"2020-10-22T00:22:04.420054524Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-defaultsubset"} {"Time":"2020-10-22T00:22:38.212414238Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-features"} {"Time":"2020-10-22T00:23:09.301536045Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-subset-onlypassing"} {"Time":"2020-10-22T00:23:41.435709605Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-subset-redirect"} {"Time":"2020-10-22T00:24:16.86716551Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-svc-failover"} {"Time":"2020-10-22T00:25:01.571200729Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-svc-redirect-http"} {"Time":"2020-10-22T00:25:32.020127536Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-svc-redirect-tcp"} {"Time":"2020-10-22T00:26:00.566029647Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-router-features"} {"Time":"2020-10-22T00:26:34.976920948Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-splitter-features"} {"Time":"2020-10-22T00:27:09.988011217Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-consul-exec"} {"Time":"2020-10-22T00:27:36.461488754Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-dogstatsd-udp"} {"Time":"2020-10-22T00:28:03.709314906Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-cross-namespaces"} {"Time":"2020-10-22T00:28:54.659486846Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-gateways-local"} {"Time":"2020-10-22T00:29:46.702588149Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-gateways-remote"} {"Time":"2020-10-22T00:30:31.2432353Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-intra-namespace"} {"Time":"2020-10-22T00:31:23.487327584Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-namespace-discovery-chain"} {"Time":"2020-10-22T00:32:21.2756168Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-gateway-without-services"} {"Time":"2020-10-22T00:32:47.742941478Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-gateways-local"} {"Time":"2020-10-22T00:33:42.557718152Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-gateways-remote"} {"Time":"2020-10-22T00:34:23.708756405Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-grpc"} {"Time":"2020-10-22T00:34:51.466793964Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-http"} {"Time":"2020-10-22T00:35:17.958659061Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-http-badauthz"} {"Time":"2020-10-22T00:35:45.024612888Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-grpc"} {"Time":"2020-10-22T00:36:16.626166436Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-http"} {"Time":"2020-10-22T00:36:49.578681889Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-multiple-services"} {"Time":"2020-10-22T00:37:20.475516355Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-simple"} {"Time":"2020-10-22T00:37:52.651634624Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-tls"} {"Time":"2020-10-22T00:38:23.194366198Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-mesh-gateways-resolver"} {"Time":"2020-10-22T00:39:16.834144235Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-l7-intentions"} {"Time":"2020-10-22T00:39:43.921073741Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-multidc-rsa-ca"} {"Time":"2020-10-22T00:40:23.323700733Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-prometheus"} {"Time":"2020-10-22T00:40:47.546267846Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-stats-proxy"} {"Time":"2020-10-22T00:41:11.955878675Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-statsd-udp"} {"Time":"2020-10-22T00:41:40.749502998Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-hostnames"} {"Time":"2020-10-22T00:42:05.839131501Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-simple"} {"Time":"2020-10-22T00:42:33.162515422Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-subsets"} {"Time":"2020-10-22T00:43:01.841085827Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-without-services"} {"Time":"2020-10-22T00:43:24.22276926Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-upstream-config"} {"Time":"2020-10-22T00:43:49.179125398Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-wanfed-gw"} {"Time":"2020-10-22T00:44:46.641753773Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-zipkin"} {"Time":"2020-10-22T00:45:20.108579041Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-badauthz","Elapsed":38.97} {"Time":"2020-10-22T00:45:20.108606Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-basic","Elapsed":23.42} {"Time":"2020-10-22T00:45:20.108618156Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-centralconf","Elapsed":30.19} {"Time":"2020-10-22T00:45:20.108629906Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-dc-failover-gateways-none","Elapsed":61.58} {"Time":"2020-10-22T00:45:20.108640546Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-dc-failover-gateways-remote","Elapsed":62.06} {"Time":"2020-10-22T00:45:20.108652253Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-defaultsubset","Elapsed":33.79} {"Time":"2020-10-22T00:45:20.108662762Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-features","Elapsed":31.09} {"Time":"2020-10-22T00:45:20.108672795Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-subset-onlypassing","Elapsed":32.13} {"Time":"2020-10-22T00:45:20.108683532Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-subset-redirect","Elapsed":35.43} {"Time":"2020-10-22T00:45:20.108693772Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-svc-failover","Elapsed":44.7} {"Time":"2020-10-22T00:45:20.108706751Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-svc-redirect-http","Elapsed":30.45} {"Time":"2020-10-22T00:45:20.10871706Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-resolver-svc-redirect-tcp","Elapsed":28.55} {"Time":"2020-10-22T00:45:20.10872787Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-router-features","Elapsed":34.41} {"Time":"2020-10-22T00:45:20.108737871Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-cfg-splitter-features","Elapsed":35.01} {"Time":"2020-10-22T00:45:20.108748902Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-consul-exec","Elapsed":26.47} {"Time":"2020-10-22T00:45:20.108759692Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-dogstatsd-udp","Elapsed":27.25} {"Time":"2020-10-22T00:45:20.108770081Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-cross-namespaces","Elapsed":50.95} {"Time":"2020-10-22T00:45:20.108780941Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-gateways-local","Elapsed":52.04} {"Time":"2020-10-22T00:45:20.108791687Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-gateways-remote","Elapsed":44.54} {"Time":"2020-10-22T00:45:20.108802026Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-intra-namespace","Elapsed":52.24} {"Time":"2020-10-22T00:45:20.108812518Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-namespace-discovery-chain","Elapsed":57.79} {"Time":"2020-10-22T00:45:20.108823218Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-gateway-without-services","Elapsed":26.47} {"Time":"2020-10-22T00:45:20.108834724Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-gateways-local","Elapsed":54.81} {"Time":"2020-10-22T00:45:20.108845012Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-gateways-remote","Elapsed":41.15} {"Time":"2020-10-22T00:45:20.108856989Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-grpc","Elapsed":27.76} {"Time":"2020-10-22T00:45:20.108867426Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-http","Elapsed":26.49} {"Time":"2020-10-22T00:45:20.108878346Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-http-badauthz","Elapsed":27.07} {"Time":"2020-10-22T00:45:20.108888697Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-grpc","Elapsed":31.6} {"Time":"2020-10-22T00:45:20.108898988Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-http","Elapsed":32.95} {"Time":"2020-10-22T00:45:20.108910108Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-multiple-services","Elapsed":30.9} {"Time":"2020-10-22T00:45:20.108920326Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-simple","Elapsed":32.18} {"Time":"2020-10-22T00:45:20.10893017Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-gateway-tls","Elapsed":30.54} {"Time":"2020-10-22T00:45:20.108940126Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ingress-mesh-gateways-resolver","Elapsed":53.64} {"Time":"2020-10-22T00:45:20.108949868Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-l7-intentions","Elapsed":27.09} {"Time":"2020-10-22T00:45:20.108959852Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-multidc-rsa-ca","Elapsed":39.4} {"Time":"2020-10-22T00:45:20.108969973Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-prometheus","Elapsed":24.22} {"Time":"2020-10-22T00:45:20.108979797Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-stats-proxy","Elapsed":24.41} {"Time":"2020-10-22T00:45:20.108991334Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-statsd-udp","Elapsed":28.79} {"Time":"2020-10-22T00:45:20.109001312Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-hostnames","Elapsed":25.09} {"Time":"2020-10-22T00:45:20.109011226Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-simple","Elapsed":27.32} {"Time":"2020-10-22T00:45:20.109021026Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-subsets","Elapsed":28.68} {"Time":"2020-10-22T00:45:20.109031199Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-terminating-gateway-without-services","Elapsed":22.38} {"Time":"2020-10-22T00:45:20.109041152Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-upstream-config","Elapsed":24.96} {"Time":"2020-10-22T00:45:20.109050975Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-wanfed-gw","Elapsed":57.46} {"Time":"2020-10-22T00:45:20.109060353Z","Action":"pass","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-zipkin","Elapsed":31.09} {"Time":"2020-10-22T00:45:20.109064921Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy","Elapsed":1616.27} {"Time":"2020-10-22T00:45:20.109148885Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Elapsed":1616.276} {"Time":"2020-10-22T00:45:20.673179245Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy"} {"Time":"2020-10-22T00:46:10.218981797Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-cross-namespaces","Elapsed":44.32} {"Time":"2020-10-22T00:46:10.218989964Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy","Elapsed":49.55} {"Time":"2020-10-22T00:46:10.219542662Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Elapsed":49.549} {"Time":"2020-10-22T00:46:10.784497983Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy"} {"Time":"2020-10-22T00:47:14.789854054Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-intra-namespace","Elapsed":58.85} {"Time":"2020-10-22T00:47:14.789862576Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy","Elapsed":64.01} {"Time":"2020-10-22T00:47:14.790364204Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Elapsed":64.009} {"Time":"2020-10-22T00:47:15.354865459Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy"} {"Time":"2020-10-22T00:48:04.07040834Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-cross-namespaces","Elapsed":43.64} {"Time":"2020-10-22T00:48:04.070414141Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy","Elapsed":48.72} {"Time":"2020-10-22T00:48:04.071038715Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Elapsed":48.719} {"Time":"2020-10-22T00:48:04.708139615Z","Action":"run","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy"} {"Time":"2020-10-22T00:48:58.010967512Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy/case-ent-intra-namespace","Elapsed":48.1} {"Time":"2020-10-22T00:48:58.010973222Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Test":"TestEnvoy","Elapsed":53.3} {"Time":"2020-10-22T00:48:58.011515541Z","Action":"fail","Package":"github.com/hashicorp/consul/test/integration/connect/envoy","Elapsed":53.306} gotestsum-1.8.2/cmd/testdata/gotestsum-help-text000066400000000000000000000047701427475276200220450ustar00rootroot00000000000000Usage: gotestsum [flags] [--] [go test flags] gotestsum [command] Flags: --debug enabled debug logging -f, --format string print format of test input (default "short") --hide-summary summary hide sections of the summary: skipped,failed,errors,output (default none) --jsonfile string write all TestEvents to file --junitfile string write a JUnit XML file --junitfile-project-name string name of the project used in the junit.xml file --junitfile-testcase-classname field-format format the testcase classname field as: full, relative, short (default full) --junitfile-testsuite-name field-format format the testsuite name field as: full, relative, short (default full) --max-fails int end the test run after this number of failures --no-color disable color output (default true) --packages list space separated list of package to test --post-run-command command command to run after the tests have completed --raw-command don't prepend 'go test -json' to the 'go test' command --rerun-fails int[=2] rerun failed tests until they all pass, or attempts exceeds maximum. Defaults to max 2 reruns when enabled. --rerun-fails-max-failures int do not rerun any tests if the initial run has more than this number of failures (default 10) --rerun-fails-report string write a report to the file, of the tests that were rerun --version show version and exit --watch watch go files, and run tests when a file is modified Formats: dots print a character for each test dots-v2 experimental dots format, one package per line pkgname print a line for each package pkgname-and-test-fails print a line for each package and failed test output testname print a line for each test and package standard-quiet standard go test format standard-verbose standard go test -v format Commands: tool tools for working with test2json output help print this help next gotestsum-1.8.2/cmd/testdata/post-run-hook-expected000066400000000000000000000002221427475276200224130ustar00rootroot00000000000000GOTESTSUM_FORMAT=short GOTESTSUM_JSONFILE=events.json GOTESTSUM_JUNITFILE=junit.xml TESTS_ERRORS=0 TESTS_FAILED=13 TESTS_SKIPPED=5 TESTS_TOTAL=59 gotestsum-1.8.2/cmd/testdata/postrunhook/000077500000000000000000000000001427475276200205435ustar00rootroot00000000000000gotestsum-1.8.2/cmd/testdata/postrunhook/main.go000066400000000000000000000007531427475276200220230ustar00rootroot00000000000000package main import ( "errors" "fmt" "os" "sort" "strings" ) func main() { if err := run(); err != nil { fmt.Fprintln(os.Stderr, err.Error()) os.Exit(1) } } func run() error { environ := os.Environ() sort.Strings(environ) for _, v := range environ { for _, prefix := range []string{"TESTS_", "GOTESTSUM_"} { if strings.HasPrefix(v, prefix) { fmt.Println(v) } } } err := os.Getenv("TEST_STUB_ERROR") if err != "" { return errors.New(err) } return nil } gotestsum-1.8.2/cmd/tool/000077500000000000000000000000001427475276200153145ustar00rootroot00000000000000gotestsum-1.8.2/cmd/tool/cmd.go000066400000000000000000000011621427475276200164060ustar00rootroot00000000000000package tool import ( "fmt" "os" "gotest.tools/gotestsum/cmd" "gotest.tools/gotestsum/cmd/tool/slowest" ) // Run one of the tool commands. func Run(name string, args []string) error { next, rest := cmd.Next(args) switch next { case "": fmt.Println(usage(name)) return nil case "slowest": return slowest.Run(name+" "+next, rest) default: fmt.Fprintln(os.Stderr, usage(name)) return fmt.Errorf("invalid command: %v %v", name, next) } } func usage(name string) string { return fmt.Sprintf(`Usage: %s COMMAND [flags] Commands: slowest Use '%s COMMAND --help' for command specific help. `, name, name) } gotestsum-1.8.2/cmd/tool/slowest/000077500000000000000000000000001427475276200170145ustar00rootroot00000000000000gotestsum-1.8.2/cmd/tool/slowest/ast.go000066400000000000000000000111151427475276200201310ustar00rootroot00000000000000package slowest import ( "fmt" "go/ast" "go/format" "go/parser" "go/token" "os" "strings" "golang.org/x/tools/go/packages" "gotest.tools/gotestsum/internal/log" "gotest.tools/gotestsum/testjson" ) func writeTestSkip(tcs []testjson.TestCase, skipStmt ast.Stmt) error { fset := token.NewFileSet() cfg := packages.Config{ Mode: modeAll(), Tests: true, Fset: fset, BuildFlags: buildFlags(), } pkgNames, index := testNamesByPkgName(tcs) pkgs, err := packages.Load(&cfg, pkgNames...) if err != nil { return fmt.Errorf("failed to load packages: %v", err) } for _, pkg := range pkgs { if len(pkg.Errors) > 0 { return errPkgLoad(pkg) } tcs, ok := index[normalizePkgName(pkg.PkgPath)] if !ok { log.Debugf("skipping %v, no slow tests", pkg.PkgPath) continue } log.Debugf("rewriting %v for %d test cases", pkg.PkgPath, len(tcs)) for _, file := range pkg.Syntax { path := fset.File(file.Pos()).Name() log.Debugf("looking for test cases in: %v", path) if !rewriteAST(file, tcs, skipStmt) { continue } if err := writeFile(path, file, fset); err != nil { return fmt.Errorf("failed to write ast to file %v: %v", path, err) } } } return errTestCasesNotFound(index) } // normalizePkgName removes the _test suffix from a package name. External test // packages (those named package_test) may contain tests, but the test2json output // always uses the non-external package name. The _test suffix must be removed // so that any slow tests in an external test package can be found. func normalizePkgName(name string) string { return strings.TrimSuffix(name, "_test") } func writeFile(path string, file *ast.File, fset *token.FileSet) error { fh, err := os.Create(path) if err != nil { return err } defer func() { if err := fh.Close(); err != nil { log.Errorf("Failed to close file %v: %v", path, err) } }() return format.Node(fh, fset, file) } func parseSkipStatement(text string) (ast.Stmt, error) { switch text { case "default", "testing.Short": text = ` if testing.Short() { t.Skip("too slow for testing.Short") } ` } // Add some required boilerplate around the statement to make it a valid file text = "package stub\nfunc Stub() {\n" + text + "\n}\n" file, err := parser.ParseFile(token.NewFileSet(), "fragment", text, 0) if err != nil { return nil, err } stmt := file.Decls[0].(*ast.FuncDecl).Body.List[0] return stmt, nil } func rewriteAST(file *ast.File, testNames set, skipStmt ast.Stmt) bool { var modified bool for _, decl := range file.Decls { fd, ok := decl.(*ast.FuncDecl) if !ok { continue } name := fd.Name.Name // TODO: can this be nil? if _, ok := testNames[name]; !ok { continue } fd.Body.List = append([]ast.Stmt{skipStmt}, fd.Body.List...) modified = true delete(testNames, name) } return modified } type set map[string]struct{} // testNamesByPkgName strips subtest names from test names, then builds // and returns a slice of all the packages names, and a mapping of package name // to set of failed tests in that package. // // subtests are removed because the AST lookup currently only works for top-level // functions, not t.Run subtests. func testNamesByPkgName(tcs []testjson.TestCase) ([]string, map[string]set) { var pkgs []string index := make(map[string]set) for _, tc := range tcs { testName := tc.Test.Name() if tc.Test.IsSubTest() { root, _ := tc.Test.Split() testName = root } if len(index[tc.Package]) == 0 { pkgs = append(pkgs, tc.Package) index[tc.Package] = make(map[string]struct{}) } index[tc.Package][testName] = struct{}{} } return pkgs, index } func errPkgLoad(pkg *packages.Package) error { buf := new(strings.Builder) for _, err := range pkg.Errors { buf.WriteString("\n" + err.Error()) } return fmt.Errorf("failed to load package %v %v", pkg.PkgPath, buf.String()) } func errTestCasesNotFound(index map[string]set) error { var missed []string for pkg, tcs := range index { for tc := range tcs { missed = append(missed, fmt.Sprintf("%v.%v", pkg, tc)) } } if len(missed) == 0 { return nil } return fmt.Errorf("failed to find source for test cases:\n%v", strings.Join(missed, "\n")) } func modeAll() packages.LoadMode { mode := packages.NeedName | packages.NeedFiles | packages.NeedCompiledGoFiles mode = mode | packages.NeedImports | packages.NeedDeps mode = mode | packages.NeedTypes | packages.NeedTypesSizes mode = mode | packages.NeedSyntax | packages.NeedTypesInfo return mode } func buildFlags() []string { flags := os.Getenv("GOFLAGS") if len(flags) == 0 { return nil } return strings.Split(os.Getenv("GOFLAGS"), " ") } gotestsum-1.8.2/cmd/tool/slowest/ast_test.go000066400000000000000000000007201427475276200211700ustar00rootroot00000000000000package slowest import ( "bytes" "go/format" "go/token" "testing" "gotest.tools/v3/assert" ) func TestParseSkipStatement_Preset_testingShort(t *testing.T) { stmt, err := parseSkipStatement("testing.Short") assert.NilError(t, err) expected := `if testing.Short() { t.Skip("too slow for testing.Short") }` buf := new(bytes.Buffer) err = format.Node(buf, token.NewFileSet(), stmt) assert.NilError(t, err) assert.DeepEqual(t, buf.String(), expected) } gotestsum-1.8.2/cmd/tool/slowest/slowest.go000066400000000000000000000077761427475276200210640ustar00rootroot00000000000000package slowest import ( "fmt" "io" "io/ioutil" "os" "time" "github.com/dnephin/pflag" "gotest.tools/gotestsum/internal/aggregate" "gotest.tools/gotestsum/internal/log" "gotest.tools/gotestsum/testjson" ) // Run the command func Run(name string, args []string) error { flags, opts := setupFlags(name) switch err := flags.Parse(args); { case err == pflag.ErrHelp: return nil case err != nil: usage(os.Stderr, name, flags) return err } return run(opts) } func setupFlags(name string) (*pflag.FlagSet, *options) { opts := &options{} flags := pflag.NewFlagSet(name, pflag.ContinueOnError) flags.SetInterspersed(false) flags.Usage = func() { usage(os.Stdout, name, flags) } flags.StringVar(&opts.jsonfile, "jsonfile", os.Getenv("GOTESTSUM_JSONFILE"), "path to test2json output, defaults to stdin") flags.DurationVar(&opts.threshold, "threshold", 100*time.Millisecond, "test cases with elapsed time greater than threshold are slow tests") flags.StringVar(&opts.skipStatement, "skip-stmt", "", "add this go statement to slow tests, instead of printing the list of slow tests") flags.BoolVar(&opts.debug, "debug", false, "enable debug logging.") return flags, opts } func usage(out io.Writer, name string, flags *pflag.FlagSet) { fmt.Fprintf(out, `Usage: %[1]s [flags] Read a json file and print or update tests which are slower than threshold. The json file may be created with 'gotestsum --jsonfile' or 'go test -json'. If a TestCase appears more than once in the json file, it will only appear once in the output, and the median value of all the elapsed times will be used. By default this command will print the list of tests slower than threshold to stdout. The list will be sorted from slowest to fastest. If --skip-stmt is set, instead of printing the list to stdout, the AST for the Go source code in the working directory tree will be modified. The value of --skip-stmt will be added to Go test files as the first statement in all the test functions which are slower than threshold. The --skip-stmt flag may be set to the name of a predefined statement, or to Go source code which will be parsed as a go/ast.Stmt. Currently there is only one predefined statement, --skip-stmt=testing.Short, which uses this Go statement: if testing.Short() { t.Skip("too slow for testing.Short") } Alternatively, a custom --skip-stmt may be provided as a string: skip_stmt=' if os.GetEnv("TEST_FAST") != "" { t.Skip("too slow for TEST_FAST") } ' go test -json -short ./... | %[1]s --skip-stmt "$skip_stmt" Note that this tool does not add imports, so using a custom statement may require you to add imports to the file. Go build flags, such as build tags, may be set using the GOFLAGS environment variable, following the same rules as the go toolchain. See https://golang.org/cmd/go/#hdr-Environment_variables. Flags: `, name) flags.SetOutput(out) flags.PrintDefaults() } type options struct { threshold time.Duration jsonfile string skipStatement string debug bool } func run(opts *options) error { if opts.debug { log.SetLevel(log.DebugLevel) } in, err := jsonfileReader(opts.jsonfile) if err != nil { return fmt.Errorf("failed to read jsonfile: %v", err) } defer func() { if err := in.Close(); err != nil { log.Errorf("Failed to close file %v: %v", opts.jsonfile, err) } }() exec, err := testjson.ScanTestOutput(testjson.ScanConfig{Stdout: in}) if err != nil { return fmt.Errorf("failed to scan testjson: %v", err) } tcs := aggregate.Slowest(exec, opts.threshold) if opts.skipStatement != "" { skipStmt, err := parseSkipStatement(opts.skipStatement) if err != nil { return fmt.Errorf("failed to parse skip expr: %v", err) } return writeTestSkip(tcs, skipStmt) } for _, tc := range tcs { fmt.Printf("%s %s %v\n", tc.Package, tc.Test, tc.Elapsed) } return nil } func jsonfileReader(v string) (io.ReadCloser, error) { switch v { case "", "-": return ioutil.NopCloser(os.Stdin), nil default: return os.Open(v) } } gotestsum-1.8.2/cmd/tool/slowest/slowest_test.go000066400000000000000000000005461427475276200221070ustar00rootroot00000000000000package slowest import ( "bytes" "testing" "gotest.tools/v3/env" "gotest.tools/v3/golden" ) func TestUsage_WithFlagsFromSetupFlags(t *testing.T) { defer env.PatchAll(t, nil)() name := "gotestsum tool slowest" flags, _ := setupFlags(name) buf := new(bytes.Buffer) usage(buf, name, flags) golden.Assert(t, buf.String(), "cmd-flags-help-text") } gotestsum-1.8.2/cmd/tool/slowest/testdata/000077500000000000000000000000001427475276200206255ustar00rootroot00000000000000gotestsum-1.8.2/cmd/tool/slowest/testdata/cmd-flags-help-text000066400000000000000000000037341427475276200243240ustar00rootroot00000000000000Usage: gotestsum tool slowest [flags] Read a json file and print or update tests which are slower than threshold. The json file may be created with 'gotestsum --jsonfile' or 'go test -json'. If a TestCase appears more than once in the json file, it will only appear once in the output, and the median value of all the elapsed times will be used. By default this command will print the list of tests slower than threshold to stdout. The list will be sorted from slowest to fastest. If --skip-stmt is set, instead of printing the list to stdout, the AST for the Go source code in the working directory tree will be modified. The value of --skip-stmt will be added to Go test files as the first statement in all the test functions which are slower than threshold. The --skip-stmt flag may be set to the name of a predefined statement, or to Go source code which will be parsed as a go/ast.Stmt. Currently there is only one predefined statement, --skip-stmt=testing.Short, which uses this Go statement: if testing.Short() { t.Skip("too slow for testing.Short") } Alternatively, a custom --skip-stmt may be provided as a string: skip_stmt=' if os.GetEnv("TEST_FAST") != "" { t.Skip("too slow for TEST_FAST") } ' go test -json -short ./... | gotestsum tool slowest --skip-stmt "$skip_stmt" Note that this tool does not add imports, so using a custom statement may require you to add imports to the file. Go build flags, such as build tags, may be set using the GOFLAGS environment variable, following the same rules as the go toolchain. See https://golang.org/cmd/go/#hdr-Environment_variables. Flags: --debug enable debug logging. --jsonfile string path to test2json output, defaults to stdin --skip-stmt string add this go statement to slow tests, instead of printing the list of slow tests --threshold duration test cases with elapsed time greater than threshold are slow tests (default 100ms) gotestsum-1.8.2/cmd/watch.go000066400000000000000000000061211427475276200157740ustar00rootroot00000000000000package cmd import ( "bufio" "context" "fmt" "io/ioutil" "os" "os/exec" "gotest.tools/gotestsum/internal/filewatcher" "gotest.tools/gotestsum/testjson" ) func runWatcher(opts *options) error { ctx, cancel := context.WithCancel(context.Background()) defer cancel() w := &watchRuns{opts: *opts} return filewatcher.Watch(ctx, opts.packages, w.run) } type watchRuns struct { opts options prevExec *testjson.Execution } func (w *watchRuns) run(event filewatcher.Event) error { if event.Debug { path, cleanup, err := delveInitFile(w.prevExec) if err != nil { return fmt.Errorf("failed to write delve init file: %w", err) } defer cleanup() o := delveOpts{ pkgPath: event.PkgPath, args: w.opts.args, initFilePath: path, } if err := runDelve(o); !IsExitCoder(err) { return fmt.Errorf("delve failed: %w", err) } return nil } opts := w.opts // shallow copy opts opts.packages = append([]string{}, opts.packages...) opts.packages = append(opts.packages, event.PkgPath) opts.packages = append(opts.packages, event.Args...) var err error if w.prevExec, err = runSingle(&opts); !IsExitCoder(err) { return err } return nil } // runSingle is similar to run. It doesn't support rerun-fails. It may be // possible to share runSingle with run, but the defer close on the handler // would require at least 3 return values, so for now it is a copy. func runSingle(opts *options) (*testjson.Execution, error) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() if err := opts.Validate(); err != nil { return nil, err } goTestProc, err := startGoTestFn(ctx, goTestCmdArgs(opts, rerunOpts{})) if err != nil { return nil, err } handler, err := newEventHandler(opts) if err != nil { return nil, err } defer handler.Close() // nolint: errcheck cfg := testjson.ScanConfig{ Stdout: goTestProc.stdout, Stderr: goTestProc.stderr, Handler: handler, Stop: cancel, } exec, err := testjson.ScanTestOutput(cfg) if err != nil { return exec, finishRun(opts, exec, err) } err = goTestProc.cmd.Wait() return exec, finishRun(opts, exec, err) } func delveInitFile(exec *testjson.Execution) (string, func(), error) { fh, err := ioutil.TempFile("", "gotestsum-delve-init") if err != nil { return "", nil, err } remove := func() { os.Remove(fh.Name()) // nolint: errcheck } buf := bufio.NewWriter(fh) for _, tc := range exec.Failed() { fmt.Fprintf(buf, "break %s\n", tc.Test.Name()) } buf.WriteString("continue\n") if err := buf.Flush(); err != nil { remove() return "", nil, err } return fh.Name(), remove, nil } type delveOpts struct { pkgPath string args []string initFilePath string } func runDelve(opts delveOpts) error { pkg := opts.pkgPath args := []string{"dlv", "test", "--wd", pkg} args = append(args, "--output", "gotestsum-watch-debug.test") args = append(args, "--init", opts.initFilePath) args = append(args, pkg, "--") args = append(args, opts.args...) cmd := exec.Command(args[0], args[1:]...) cmd.Stdin = os.Stdin cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr return cmd.Run() } gotestsum-1.8.2/contrib/000077500000000000000000000000001427475276200152345ustar00rootroot00000000000000gotestsum-1.8.2/contrib/notify/000077500000000000000000000000001427475276200165445ustar00rootroot00000000000000gotestsum-1.8.2/contrib/notify/notify-macos.go000066400000000000000000000020571427475276200215070ustar00rootroot00000000000000package main import ( "fmt" "log" "os" "os/exec" "strconv" ) func main() { total := envInt("TOTAL") skipped := envInt("SKIPPED") failed := envInt("FAILED") errors := envInt("ERRORS") emoji := "✅" title := "Passed" switch { case errors > 0: emoji = "⚠️" title = "Errored" case failed > 0: emoji = "❌" title = "Failed" case skipped > 0: title = "Passed with skipped" } subtitle := fmt.Sprintf("%d Tests Run", total) if errors > 0 { subtitle += fmt.Sprintf(", %d Errored", errors) } if failed > 0 { subtitle += fmt.Sprintf(", %d Failed", failed) } if skipped > 0 { subtitle += fmt.Sprintf(", %d Skipped", skipped) } args := []string{ "-title", emoji + " " + title, "-group", "gotestsum", "-subtitle", subtitle, } log.Printf("terminal-notifier %#v", args) err := exec.Command("terminal-notifier", args...).Run() if err != nil { log.Fatalf("Failed to exec: %v", err) } } func envInt(name string) int { val := os.Getenv("TESTS_" + name) n, err := strconv.Atoi(val) if err != nil { return 0 } return n } gotestsum-1.8.2/do000077500000000000000000000045471427475276200141360ustar00rootroot00000000000000#!/usr/bin/env bash set -o errexit -o nounset -o pipefail declare -A help binary() { mkdir -p dist go build -o dist/gotestsum . } binary-static() { echo "building static binary: dist/gotestsum" CGO_ENABLED=0 binary } update-golden() { gotestsum -- ./... -update } lint() { golangci-lint run -v --config .project/golangci-lint.yml } go-mod-tidy() { go mod tidy git diff --stat --exit-code go.mod go.sum } help[shell]='Run a shell in a golang docker container. Env vars: GOLANG_VERSION - the docker image tag used to build the image. ' shell() { local image; image="$(_docker-build-dev)" docker run \ --tty --interactive --rm \ -v "$PWD:/work" \ -v ~/.cache/go-build:/root/.cache/go-build \ -v ~/go/pkg/mod:/go/pkg/mod \ -w /work \ "$image" \ "${@-bash}" } _docker-build-dev() { set -e local idfile=".plsdo/docker-build-dev-image-id-${GOLANG_VERSION-default}" local dockerfile=.project/Dockerfile local tag=gotest.tools/gotestsum/builder if [ -f "$idfile" ] && [ "$dockerfile" -ot "$idfile" ]; then cat "$idfile" return 0 fi mkdir -p .plsdo >&2 docker build \ --iidfile "$idfile" \ --file "$dockerfile" \ --build-arg "UID=$UID" \ --build-arg GOLANG_VERSION \ --target "dev" \ .plsdo cat "$idfile" } help[godoc]="Run godoc locally to preview package documentation." godoc() { local url; url="http://localhost:6060/pkg/$(go list)/" command -v xdg-open && xdg-open "$url" & command -v open && open "$url" & command godoc -http=:6060 } help[list]="Print the list of tasks" list() { declare -F | awk '{print $3}' | grep -v '^_' } _plsdo_help() { local topic="${1-}" # print help for the topic if [ -n "$topic" ]; then if ! command -v "$topic" > /dev/null ; then >&2 echo "No such task: $topic" return 1 fi printf "\nUsage:\n %s %s\n\n%s\n" "$0" "$topic" "${help[$topic]-}" return 0 fi # print list of tasks and their help line. [ -n "${banner-}" ] && echo "$banner" && echo for i in $(list); do printf "%-12s\t%s\n" "$i" "${help[$i]-}" | head -1 done } _plsdo_run() { case "${1-}" in ""|help) _plsdo_help "${2-}" ;; *) "$@" ;; esac } _plsdo_run "$@" gotestsum-1.8.2/go.mod000066400000000000000000000007771427475276200147150ustar00rootroot00000000000000module gotest.tools/gotestsum require ( github.com/dnephin/pflag v1.0.7 github.com/fatih/color v1.13.0 github.com/fsnotify/fsnotify v1.5.4 github.com/google/go-cmp v0.5.8 github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 github.com/mattn/go-colorable v0.1.12 // indirect golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 golang.org/x/tools v0.1.11 gotest.tools/v3 v3.3.0 ) go 1.13 gotestsum-1.8.2/go.sum000066400000000000000000000153211427475276200147310ustar00rootroot00000000000000github.com/dnephin/pflag v1.0.7 h1:oxONGlWxhmUct0YzKTgrpQv9AUA1wtPBn7zuSjJqptk= github.com/dnephin/pflag v1.0.7/go.mod h1:uxE91IoWURlOiTUIA8Mq5ZZkAv3dPUfZNaT80Zm7OQE= github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w= github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= github.com/fsnotify/fsnotify v1.5.4 h1:jRbGcIw6P2Meqdwuo0H1p6JVLbL5DHKAKlYndzMwVZI= github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg= github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510 h1:El6M4kTTCOh6aBiKaUGG7oYTSPP8MxqL4YI3kZKwcP4= github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= github.com/mattn/go-colorable v0.1.12 h1:jF+Du6AlPIjs2BiUiQlKOX0rt3SujHxPnksPKZbaA40= github.com/mattn/go-colorable v0.1.12/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.4.1/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 h1:6zppjxzCulZykYSLyVDYbneBfbaBIQPYMevg0bEwv2s= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f h1:Ax0t5p6N38Ga0dThY21weqDEyz2oklo4IvDkpigvkD8= golang.org/x/sync v0.0.0-20220601150217-0de741cfad7f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 h1:0A+M6Uqn+Eje4kHMK80dtF3JCXC4ykBgQG4Fe06QRhQ= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20220526004731-065cf7ba2467 h1:CBpWXWQpIRjzmkkA+M7q9Fqnwd2mZr3AFqexg8YTfoM= golang.org/x/term v0.0.0-20220526004731-065cf7ba2467/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0= golang.org/x/tools v0.1.11 h1:loJ25fNOEhSXfHrpoGj91eCUThwdNX6u24rO1xnNteY= golang.org/x/tools v0.1.11/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gotest.tools/v3 v3.3.0 h1:MfDY1b1/0xN1CyMlQDac0ziEy9zJQd9CXBRRDHw2jJo= gotest.tools/v3 v3.3.0/go.mod h1:Mcr9QNxkg0uMvy/YElmo4SpXgJKWgQvYrT7Kw5RzJ1A= gotestsum-1.8.2/internal/000077500000000000000000000000001427475276200154105ustar00rootroot00000000000000gotestsum-1.8.2/internal/aggregate/000077500000000000000000000000001427475276200173365ustar00rootroot00000000000000gotestsum-1.8.2/internal/aggregate/slowest.go000066400000000000000000000036211427475276200213670ustar00rootroot00000000000000package aggregate import ( "sort" "time" "gotest.tools/gotestsum/testjson" ) // Slowest returns a slice of all tests with an elapsed time greater than // threshold. The slice is sorted by Elapsed time in descending order (slowest // test first). // // If there are multiple runs of a TestCase, all of them will be represented // by a single TestCase with the median elapsed time in the returned slice. func Slowest(exec *testjson.Execution, threshold time.Duration) []testjson.TestCase { if threshold == 0 { return nil } pkgs := exec.Packages() tests := make([]testjson.TestCase, 0, len(pkgs)) for _, pkg := range pkgs { pkgTests := ByElapsed(exec.Package(pkg).TestCases(), median) tests = append(tests, pkgTests...) } sort.Slice(tests, func(i, j int) bool { return tests[i].Elapsed > tests[j].Elapsed }) end := sort.Search(len(tests), func(i int) bool { return tests[i].Elapsed < threshold }) return tests[:end] } // ByElapsed maps all test cases by name, and if there is more than one // instance of a TestCase, uses fn to select the elapsed time for the group. // // All cases are assumed to be part of the same package. func ByElapsed(cases []testjson.TestCase, fn func(times []time.Duration) time.Duration) []testjson.TestCase { if len(cases) <= 1 { return cases } pkg := cases[0].Package // nolint: prealloc // size is not predictable m := make(map[testjson.TestName][]time.Duration) for _, tc := range cases { m[tc.Test] = append(m[tc.Test], tc.Elapsed) } result := make([]testjson.TestCase, 0, len(m)) for name, timing := range m { result = append(result, testjson.TestCase{ Package: pkg, Test: name, Elapsed: fn(timing), }) } return result } func median(times []time.Duration) time.Duration { switch len(times) { case 0: return 0 case 1: return times[0] } sort.Slice(times, func(i, j int) bool { return times[i] < times[j] }) return times[len(times)/2] } gotestsum-1.8.2/internal/aggregate/slowest_test.go000066400000000000000000000033061427475276200224260ustar00rootroot00000000000000package aggregate import ( "strings" "testing" "time" "github.com/google/go-cmp/cmp/cmpopts" "gotest.tools/gotestsum/testjson" "gotest.tools/v3/assert" ) func TestByElapsed_WithMedian(t *testing.T) { cases := []testjson.TestCase{ {Test: "TestOne", Package: "pkg", Elapsed: time.Second}, {Test: "TestTwo", Package: "pkg", Elapsed: 2 * time.Second}, {Test: "TestOne", Package: "pkg", Elapsed: 3 * time.Second}, {Test: "TestTwo", Package: "pkg", Elapsed: 4 * time.Second}, {Test: "TestOne", Package: "pkg", Elapsed: 5 * time.Second}, {Test: "TestTwo", Package: "pkg", Elapsed: 6 * time.Second}, } actual := ByElapsed(cases, median) expected := []testjson.TestCase{ {Test: "TestOne", Package: "pkg", Elapsed: 3 * time.Second}, {Test: "TestTwo", Package: "pkg", Elapsed: 4 * time.Second}, } assert.DeepEqual(t, actual, expected, cmpopts.SortSlices(func(x, y testjson.TestCase) bool { return strings.Compare(x.Test.Name(), y.Test.Name()) == -1 }), cmpopts.IgnoreUnexported(testjson.TestCase{})) } func TestMedian(t *testing.T) { var testcases = []struct { name string times []time.Duration expected time.Duration }{ { name: "one item slice", times: []time.Duration{time.Minute}, expected: time.Minute, }, { name: "odd number of items", times: []time.Duration{time.Millisecond, time.Hour, time.Second}, expected: time.Second, }, { name: "even number of items", times: []time.Duration{time.Second, time.Millisecond, time.Microsecond, time.Hour}, expected: time.Second, }, } for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { actual := median(tc.times) assert.Equal(t, actual, tc.expected) }) } } gotestsum-1.8.2/internal/dotwriter/000077500000000000000000000000001427475276200174335ustar00rootroot00000000000000gotestsum-1.8.2/internal/dotwriter/LICENSE000066400000000000000000000020701427475276200204370ustar00rootroot00000000000000MIT License =========== Copyright (c) 2015, Greg Osuri Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. gotestsum-1.8.2/internal/dotwriter/README000066400000000000000000000003161427475276200203130ustar00rootroot00000000000000This package contains a striped down and modified version of https://github.com/gosuri/uilive. The original package did not work with terminal colors, and had some bits that were unnecessary for gotestsum. gotestsum-1.8.2/internal/dotwriter/writer.go000066400000000000000000000015741427475276200213050ustar00rootroot00000000000000/* Package dotwriter implements a buffered Writer for updating progress on the terminal. */ package dotwriter import ( "bytes" "io" ) // ESC is the ASCII code for escape character const ESC = 27 // Writer buffers writes until Flush is called. Flush clears previously written // lines before writing new lines from the buffer. type Writer struct { out io.Writer buf bytes.Buffer lineCount int } // New returns a new Writer func New(out io.Writer) *Writer { return &Writer{out: out} } // Flush the buffer, writing all buffered lines to out func (w *Writer) Flush() error { if w.buf.Len() == 0 { return nil } w.clearLines(w.lineCount) w.lineCount = bytes.Count(w.buf.Bytes(), []byte{'\n'}) _, err := w.out.Write(w.buf.Bytes()) w.buf.Reset() return err } // Write saves buf to a buffer func (w *Writer) Write(buf []byte) (int, error) { return w.buf.Write(buf) } gotestsum-1.8.2/internal/dotwriter/writer_posix.go000066400000000000000000000004321427475276200225170ustar00rootroot00000000000000//go:build !windows // +build !windows package dotwriter import ( "fmt" "strings" ) // clear the line and move the cursor up var clear = fmt.Sprintf("%c[%dA%c[2K", ESC, 1, ESC) func (w *Writer) clearLines(count int) { _, _ = fmt.Fprint(w.out, strings.Repeat(clear, count)) } gotestsum-1.8.2/internal/dotwriter/writer_windows.go000066400000000000000000000030071427475276200230500ustar00rootroot00000000000000// +build windows package dotwriter import ( "fmt" "io" "strings" "syscall" "unsafe" "golang.org/x/sys/windows" ) var kernel32 = syscall.NewLazyDLL("kernel32.dll") var ( procSetConsoleCursorPosition = kernel32.NewProc("SetConsoleCursorPosition") procFillConsoleOutputCharacter = kernel32.NewProc("FillConsoleOutputCharacterW") ) // clear the line and move the cursor up var clear = fmt.Sprintf("%c[%dA%c[2K\r", ESC, 0, ESC) type dword uint32 type coord struct { x int16 y int16 } type fdWriter interface { io.Writer Fd() uintptr } func (w *Writer) clearLines(count int) { f, ok := w.out.(fdWriter) if ok && !isConsole(f.Fd()) { ok = false } if !ok { _, _ = fmt.Fprint(w.out, strings.Repeat(clear, count)) return } fd := f.Fd() var csbi windows.ConsoleScreenBufferInfo if err := windows.GetConsoleScreenBufferInfo(windows.Handle(fd), &csbi); err != nil { return } for i := 0; i < count; i++ { // move the cursor up csbi.CursorPosition.Y-- _, _, _ = procSetConsoleCursorPosition.Call(fd, uintptr(*(*int32)(unsafe.Pointer(&csbi.CursorPosition)))) // clear the line cursor := coord{ x: csbi.Window.Left, y: csbi.Window.Top + csbi.CursorPosition.Y, } var count, w dword count = dword(csbi.Size.X) _, _, _ = procFillConsoleOutputCharacter.Call(fd, uintptr(' '), uintptr(count), *(*uintptr)(unsafe.Pointer(&cursor)), uintptr(unsafe.Pointer(&w))) } } func isConsole(fd uintptr) bool { var mode uint32 err := windows.GetConsoleMode(windows.Handle(fd), &mode) return err == nil } gotestsum-1.8.2/internal/filewatcher/000077500000000000000000000000001427475276200177055ustar00rootroot00000000000000gotestsum-1.8.2/internal/filewatcher/term_aix.go000066400000000000000000000002071427475276200220430ustar00rootroot00000000000000//go:build aix // +build aix package filewatcher import "golang.org/x/sys/unix" const tcGet = unix.TCGETA const tcSet = unix.TCSETA gotestsum-1.8.2/internal/filewatcher/term_bsd.go000066400000000000000000000003371427475276200220360ustar00rootroot00000000000000//go:build darwin || dragonfly || freebsd || netbsd || openbsd // +build darwin dragonfly freebsd netbsd openbsd package filewatcher import "golang.org/x/sys/unix" const tcGet = unix.TIOCGETA const tcSet = unix.TIOCSETA gotestsum-1.8.2/internal/filewatcher/term_linux.go000066400000000000000000000001511427475276200224170ustar00rootroot00000000000000package filewatcher import "golang.org/x/sys/unix" const tcGet = unix.TCGETS const tcSet = unix.TCSETS gotestsum-1.8.2/internal/filewatcher/term_unix.go000066400000000000000000000050121427475276200222440ustar00rootroot00000000000000//go:build !windows && !aix // +build !windows,!aix package filewatcher import ( "bufio" "context" "fmt" "io" "os" "golang.org/x/sys/unix" "gotest.tools/gotestsum/internal/log" ) type terminal struct { ch chan Event reset func() } func newTerminal() *terminal { h := &terminal{ch: make(chan Event)} h.Start() return h } // Start the terminal is non-blocking read mode. The terminal can be reset to // normal mode by calling Reset. func (r *terminal) Start() { if r == nil { return } fd := int(os.Stdin.Fd()) reset, err := enableNonBlockingRead(fd) if err != nil { log.Warnf("failed to put terminal (fd %d) into raw mode: %v", fd, err) return } r.reset = reset } func enableNonBlockingRead(fd int) (func(), error) { term, err := unix.IoctlGetTermios(fd, tcGet) if err != nil { return nil, err } state := *term reset := func() { if err := unix.IoctlSetTermios(fd, tcSet, &state); err != nil { log.Debugf("failed to reset fd %d: %v", fd, err) } } term.Lflag &^= unix.ECHO | unix.ICANON term.Cc[unix.VMIN] = 1 term.Cc[unix.VTIME] = 0 if err := unix.IoctlSetTermios(fd, tcSet, term); err != nil { reset() return nil, err } return reset, nil } var stdin io.Reader = os.Stdin // Monitor the terminal for key presses. If the key press is associated with an // action, an event will be sent to channel returned by Events. func (r *terminal) Monitor(ctx context.Context) { if r == nil { return } in := bufio.NewReader(stdin) for { char, err := in.ReadByte() if err != nil { log.Warnf("failed to read input: %v", err) return } log.Debugf("received byte %v (%v)", char, string(char)) chResume := make(chan struct{}) switch char { case 'r': r.ch <- Event{resume: chResume, useLastPath: true} case 'd': r.ch <- Event{resume: chResume, useLastPath: true, Debug: true} case 'a': r.ch <- Event{resume: chResume, PkgPath: "./..."} case 'l': r.ch <- Event{resume: chResume, reloadPaths: true} case 'u': r.ch <- Event{resume: chResume, useLastPath: true, Args: []string{"-update"}} case '\n': fmt.Println() continue default: continue } select { case <-ctx.Done(): return case <-chResume: } } } // Events returns a channel which will receive events when keys are pressed. // When an event is received, the caller must close the resume channel to // resume monitoring for events. func (r *terminal) Events() <-chan Event { if r == nil { return nil } return r.ch } func (r *terminal) Reset() { if r != nil && r.reset != nil { r.reset() } } gotestsum-1.8.2/internal/filewatcher/term_windows.go000066400000000000000000000004241427475276200227550ustar00rootroot00000000000000package filewatcher import "context" type terminal struct{} func newTerminal() *terminal { return nil } func (r *terminal) Monitor(context.Context) {} func (r *terminal) Events() <-chan Event { return nil } func (r *terminal) Start() {} func (r *terminal) Reset() {} gotestsum-1.8.2/internal/filewatcher/watch.go000066400000000000000000000137731427475276200213550ustar00rootroot00000000000000//go:build !aix // +build !aix package filewatcher import ( "context" "fmt" "io" "os" "path/filepath" "strings" "time" "github.com/fsnotify/fsnotify" "gotest.tools/gotestsum/internal/log" ) const maxDepth = 7 type Event struct { // PkgPath of the package that triggered the event. PkgPath string // Args will be appended to the command line args for 'go test'. Args []string // Debug runs the tests with delve. Debug bool // resume the Watch goroutine when this channel is closed. Used to block // the Watch goroutine while tests are running. resume chan struct{} // reloadPaths will cause the watched path list to be reloaded, to watch // new directories. reloadPaths bool // useLastPath when true will use the PkgPath from the previous run. useLastPath bool } // Watch dirs for filesystem events, and run tests when .go files are saved. // nolint: gocyclo func Watch(ctx context.Context, dirs []string, run func(Event) error) error { watcher, err := fsnotify.NewWatcher() if err != nil { return fmt.Errorf("failed to create file watcher: %w", err) } defer watcher.Close() // nolint: errcheck // always returns nil error if err := loadPaths(watcher, dirs); err != nil { return err } timer := time.NewTimer(maxIdleTime) defer timer.Stop() term := newTerminal() defer term.Reset() go term.Monitor(ctx) h := &fsEventHandler{last: time.Now(), fn: run} for { select { case <-ctx.Done(): return nil case <-timer.C: return fmt.Errorf("exceeded idle timeout while watching files") case event := <-term.Events(): resetTimer(timer) if event.reloadPaths { if err := loadPaths(watcher, dirs); err != nil { return err } close(event.resume) continue } term.Reset() if err := h.runTests(event); err != nil { return fmt.Errorf("failed to rerun tests for %v: %v", event.PkgPath, err) } term.Start() close(event.resume) case event := <-watcher.Events: resetTimer(timer) log.Debugf("handling event %v", event) if handleDirCreated(watcher, event) { continue } if err := h.handleEvent(event); err != nil { return fmt.Errorf("failed to run tests for %v: %v", event.Name, err) } case err := <-watcher.Errors: return fmt.Errorf("failed while watching files: %v", err) } } } const maxIdleTime = time.Hour func resetTimer(timer *time.Timer) { if !timer.Stop() { <-timer.C } timer.Reset(maxIdleTime) } func loadPaths(watcher *fsnotify.Watcher, dirs []string) error { toWatch := findAllDirs(dirs, maxDepth) fmt.Printf("Watching %v directories. Use Ctrl-c to to stop a run or exit.\n", len(toWatch)) for _, dir := range toWatch { if err := watcher.Add(dir); err != nil { return fmt.Errorf("failed to watch directory %v: %w", dir, err) } } return nil } func findAllDirs(dirs []string, maxDepth int) []string { if len(dirs) == 0 { dirs = []string{"./..."} } var output []string // nolint: prealloc for _, dir := range dirs { const recur = "/..." if strings.HasSuffix(dir, recur) { dir = strings.TrimSuffix(dir, recur) output = append(output, findSubDirs(dir, maxDepth)...) continue } output = append(output, dir) } return output } func findSubDirs(rootDir string, maxDepth int) []string { var output []string // add root dir depth so that maxDepth is relative to the root dir maxDepth += pathDepth(rootDir) walker := func(path string, info os.FileInfo, err error) error { if err != nil { log.Warnf("failed to watch %v: %v", path, err) return nil } if !info.IsDir() { return nil } if pathDepth(path) > maxDepth || exclude(path) { log.Debugf("Ignoring %v because of max depth or exclude list", path) return filepath.SkipDir } if !hasGoFiles(path) { log.Debugf("Ignoring %v because it has no .go files", path) return nil } output = append(output, path) return nil } // nolint: errcheck // error is handled by walker func filepath.Walk(rootDir, walker) return output } func pathDepth(path string) int { return strings.Count(filepath.Clean(path), string(filepath.Separator)) } // return true if path is vendor, testdata, or starts with a dot func exclude(path string) bool { base := filepath.Base(path) switch { case strings.HasPrefix(base, ".") && len(base) > 1: return true case base == "vendor" || base == "testdata": return true } return false } func hasGoFiles(path string) bool { fh, err := os.Open(path) if err != nil { return false } defer fh.Close() // nolint: errcheck // fh is opened read-only for { names, err := fh.Readdirnames(20) switch { case err == io.EOF: return false case err != nil: log.Warnf("failed to read directory %v: %v", path, err) return false } for _, name := range names { if strings.HasSuffix(name, ".go") { return true } } } } func handleDirCreated(watcher *fsnotify.Watcher, event fsnotify.Event) (handled bool) { if event.Op&fsnotify.Create != fsnotify.Create { return false } fileInfo, err := os.Stat(event.Name) if err != nil { log.Warnf("failed to stat %s: %s", event.Name, err) return false } if !fileInfo.IsDir() { return false } if err := watcher.Add(event.Name); err != nil { log.Warnf("failed to watch new directory %v: %v", event.Name, err) } return true } type fsEventHandler struct { last time.Time lastPath string fn func(opts Event) error } var floodThreshold = 250 * time.Millisecond func (h *fsEventHandler) handleEvent(event fsnotify.Event) error { if event.Op&(fsnotify.Write|fsnotify.Create) == 0 { return nil } if !strings.HasSuffix(event.Name, ".go") { return nil } if time.Since(h.last) < floodThreshold { log.Debugf("skipping event received less than %v after the previous", floodThreshold) return nil } return h.runTests(Event{PkgPath: "./" + filepath.Dir(event.Name)}) } func (h *fsEventHandler) runTests(opts Event) error { if opts.useLastPath { opts.PkgPath = h.lastPath } fmt.Printf("\nRunning tests in %v\n", opts.PkgPath) if err := h.fn(opts); err != nil { return err } h.last = time.Now() h.lastPath = opts.PkgPath return nil } gotestsum-1.8.2/internal/filewatcher/watch_test.go000066400000000000000000000075221427475276200224070ustar00rootroot00000000000000package filewatcher import ( "fmt" "path/filepath" "testing" "time" "github.com/fsnotify/fsnotify" "gotest.tools/v3/assert" "gotest.tools/v3/env" "gotest.tools/v3/fs" ) func TestFSEventHandler_HandleEvent(t *testing.T) { type testCase struct { name string last time.Time expectedRun bool event fsnotify.Event } fn := func(t *testing.T, tc testCase) { var ran bool run := func(opts Event) error { ran = true return nil } h := fsEventHandler{last: tc.last, fn: run} err := h.handleEvent(tc.event) assert.NilError(t, err) assert.Equal(t, ran, tc.expectedRun) if tc.expectedRun { assert.Assert(t, !h.last.IsZero()) } } var testCases = []testCase{ { name: "Op is rename", event: fsnotify.Event{Op: fsnotify.Rename, Name: "file_test.go"}, }, { name: "Op is remove", event: fsnotify.Event{Op: fsnotify.Remove, Name: "file_test.go"}, }, { name: "Op is chmod", event: fsnotify.Event{Op: fsnotify.Chmod, Name: "file_test.go"}, }, { name: "Op is write+chmod", event: fsnotify.Event{Op: fsnotify.Write | fsnotify.Chmod, Name: "file_test.go"}, expectedRun: true, }, { name: "Op is write", event: fsnotify.Event{Op: fsnotify.Write, Name: "file_test.go"}, expectedRun: true, }, { name: "Op is create", event: fsnotify.Event{Op: fsnotify.Create, Name: "file_test.go"}, expectedRun: true, }, { name: "file is not a go file", event: fsnotify.Event{Op: fsnotify.Write, Name: "readme.md"}, }, { name: "under flood threshold", event: fsnotify.Event{Op: fsnotify.Create, Name: "file_test.go"}, last: time.Now(), }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { fn(t, tc) }) } } func TestHasGoFiles(t *testing.T) { t.Run("none", func(t *testing.T) { tmpDir := fs.NewDir(t, t.Name(), fs.WithFile("readme.md", "")) defer tmpDir.Remove() assert.Assert(t, !hasGoFiles(tmpDir.Path())) }) t.Run("empty", func(t *testing.T) { tmpDir := fs.NewDir(t, t.Name()) defer tmpDir.Remove() assert.Assert(t, !hasGoFiles(tmpDir.Path())) }) t.Run("some go files", func(t *testing.T) { tmpDir := fs.NewDir(t, t.Name(), fs.WithFile("main.go", "")) defer tmpDir.Remove() assert.Assert(t, hasGoFiles(tmpDir.Path())) }) t.Run("many go files", func(t *testing.T) { tmpDir := fs.NewDir(t, t.Name()) for i := 0; i < 47; i++ { fs.Apply(t, tmpDir, fs.WithFile(fmt.Sprintf("file%d.go", i), "")) } defer tmpDir.Remove() assert.Assert(t, hasGoFiles(tmpDir.Path())) }) } func TestFindAllDirs(t *testing.T) { goFile := fs.WithFile("file.go", "") dirOne := fs.NewDir(t, t.Name(), goFile, fs.WithFile("not-a-dir", ""), fs.WithDir("no-go-files"), fs.WithDir(".starts-with-dot", goFile)) defer dirOne.Remove() var path string for i := 1; i <= 10; i++ { path = filepath.Join(path, fmt.Sprintf("%d", i)) var ops []fs.PathOp if i != 4 && i != 5 { ops = []fs.PathOp{goFile} } fs.Apply(t, dirOne, fs.WithDir(path, ops...)) } dirTwo := fs.NewDir(t, t.Name(), goFile, // subdir should be ignored, dirTwo is used without /... suffix fs.WithDir("subdir", goFile)) defer dirTwo.Remove() dirs := findAllDirs([]string{dirOne.Path() + "/...", dirTwo.Path()}, maxDepth) expected := []string{ dirOne.Path(), dirOne.Join("1"), dirOne.Join("1/2"), dirOne.Join("1/2/3"), dirOne.Join("1/2/3/4/5/6"), dirOne.Join("1/2/3/4/5/6/7"), dirTwo.Path(), } assert.DeepEqual(t, dirs, expected) } func TestFindAllDirs_DefaultPath(t *testing.T) { goFile := fs.WithFile("file.go", "") dirOne := fs.NewDir(t, t.Name(), goFile, fs.WithDir("a", goFile), fs.WithDir("b", goFile)) defer dirOne.Remove() defer env.ChangeWorkingDir(t, dirOne.Path())() dirs := findAllDirs([]string{}, maxDepth) expected := []string{".", "a", "b"} assert.DeepEqual(t, dirs, expected) } gotestsum-1.8.2/internal/filewatcher/watch_unix_test.go000066400000000000000000000044201427475276200234440ustar00rootroot00000000000000//go:build !windows && !aix // +build !windows,!aix package filewatcher import ( "context" "io" "testing" "time" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "gotest.tools/v3/assert" "gotest.tools/v3/fs" ) func TestWatch(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) t.Cleanup(cancel) dir := fs.NewDir(t, t.Name()) r, w := io.Pipe() patchStdin(t, r) patchFloodThreshold(t, 0) chEvents := make(chan Event, 1) capture := func(event Event) error { chEvents <- event return nil } go func() { err := Watch(ctx, []string{dir.Path()}, capture) assert.Check(t, err) }() t.Run("run all tests", func(t *testing.T) { _, err := w.Write([]byte("a")) assert.NilError(t, err) event := <-chEvents expected := Event{PkgPath: "./..."} assert.DeepEqual(t, event, expected, cmpEvent) }) t.Run("run tests on file change", func(t *testing.T) { fs.Apply(t, dir, fs.WithFile("file.go", "")) event := <-chEvents expected := Event{PkgPath: "./" + dir.Path()} assert.DeepEqual(t, event, expected, cmpEvent) t.Run("and rerun", func(t *testing.T) { _, err := w.Write([]byte("r")) assert.NilError(t, err) event := <-chEvents expected := Event{PkgPath: "./" + dir.Path(), useLastPath: true} assert.DeepEqual(t, event, expected, cmpEvent) }) t.Run("and debug", func(t *testing.T) { _, err := w.Write([]byte("d")) assert.NilError(t, err) event := <-chEvents expected := Event{ PkgPath: "./" + dir.Path(), useLastPath: true, Debug: true, } assert.DeepEqual(t, event, expected, cmpEvent) }) t.Run("and update", func(t *testing.T) { _, err := w.Write([]byte("u")) assert.NilError(t, err) event := <-chEvents expected := Event{ PkgPath: "./" + dir.Path(), Args: []string{"-update"}, useLastPath: true, } assert.DeepEqual(t, event, expected, cmpEvent) }) }) } var cmpEvent = cmp.Options{ cmp.AllowUnexported(Event{}), cmpopts.IgnoreTypes(make(chan struct{})), } func patchStdin(t *testing.T, in io.Reader) { orig := stdin stdin = in t.Cleanup(func() { stdin = orig }) } func patchFloodThreshold(t *testing.T, d time.Duration) { orig := floodThreshold floodThreshold = d t.Cleanup(func() { floodThreshold = orig }) } gotestsum-1.8.2/internal/filewatcher/watch_unsupported.go000066400000000000000000000004351427475276200240140ustar00rootroot00000000000000//go:build aix // +build aix package filewatcher import ( "fmt" "runtime" ) type Event struct { PkgPath string Debug bool } func Watch(dirs []string, run func(Event) error) error { return fmt.Errorf("file watching is not supported on %v/%v", runtime.GOOS, runtime.GOARCH) } gotestsum-1.8.2/internal/junitxml/000077500000000000000000000000001427475276200172625ustar00rootroot00000000000000gotestsum-1.8.2/internal/junitxml/report.go000066400000000000000000000140451427475276200211300ustar00rootroot00000000000000/*Package junitxml creates a JUnit XML report from a testjson.Execution. */ package junitxml import ( "encoding/xml" "fmt" "io" "os" "os/exec" "strings" "time" "gotest.tools/gotestsum/internal/log" "gotest.tools/gotestsum/testjson" ) // JUnitTestSuites is a collection of JUnit test suites. type JUnitTestSuites struct { XMLName xml.Name `xml:"testsuites"` Name string `xml:"name,attr,omitempty"` Tests int `xml:"tests,attr"` Failures int `xml:"failures,attr"` Errors int `xml:"errors,attr"` Time string `xml:"time,attr"` Suites []JUnitTestSuite } // JUnitTestSuite is a single JUnit test suite which may contain many // testcases. type JUnitTestSuite struct { XMLName xml.Name `xml:"testsuite"` Tests int `xml:"tests,attr"` Failures int `xml:"failures,attr"` Time string `xml:"time,attr"` Name string `xml:"name,attr"` Properties []JUnitProperty `xml:"properties>property,omitempty"` TestCases []JUnitTestCase Timestamp string `xml:"timestamp,attr"` } // JUnitTestCase is a single test case with its result. type JUnitTestCase struct { XMLName xml.Name `xml:"testcase"` Classname string `xml:"classname,attr"` Name string `xml:"name,attr"` Time string `xml:"time,attr"` SkipMessage *JUnitSkipMessage `xml:"skipped,omitempty"` Failure *JUnitFailure `xml:"failure,omitempty"` } // JUnitSkipMessage contains the reason why a testcase was skipped. type JUnitSkipMessage struct { Message string `xml:"message,attr"` } // JUnitProperty represents a key/value pair used to define properties. type JUnitProperty struct { Name string `xml:"name,attr"` Value string `xml:"value,attr"` } // JUnitFailure contains data related to a failed test. type JUnitFailure struct { Message string `xml:"message,attr"` Type string `xml:"type,attr"` Contents string `xml:",chardata"` } // Config used to write a junit XML document. type Config struct { ProjectName string FormatTestSuiteName FormatFunc FormatTestCaseClassname FormatFunc // This is used for tests to have a consistent timestamp customTimestamp string customElapsed string } // FormatFunc converts a string from one format into another. type FormatFunc func(string) string // Write creates an XML document and writes it to out. func Write(out io.Writer, exec *testjson.Execution, cfg Config) error { if err := write(out, generate(exec, cfg)); err != nil { return fmt.Errorf("failed to write JUnit XML: %v", err) } return nil } func generate(exec *testjson.Execution, cfg Config) JUnitTestSuites { cfg = configWithDefaults(cfg) version := goVersion() suites := JUnitTestSuites{ Name: cfg.ProjectName, Tests: exec.Total(), Failures: len(exec.Failed()), Errors: len(exec.Errors()), Time: formatDurationAsSeconds(time.Since(exec.Started())), } if cfg.customElapsed != "" { suites.Time = cfg.customElapsed } for _, pkgname := range exec.Packages() { pkg := exec.Package(pkgname) junitpkg := JUnitTestSuite{ Name: cfg.FormatTestSuiteName(pkgname), Tests: pkg.Total, Time: formatDurationAsSeconds(pkg.Elapsed()), Properties: packageProperties(version), TestCases: packageTestCases(pkg, cfg.FormatTestCaseClassname), Failures: len(pkg.Failed), Timestamp: cfg.customTimestamp, } if cfg.customTimestamp == "" { junitpkg.Timestamp = exec.Started().Format(time.RFC3339) } suites.Suites = append(suites.Suites, junitpkg) } return suites } func configWithDefaults(cfg Config) Config { noop := func(v string) string { return v } if cfg.FormatTestSuiteName == nil { cfg.FormatTestSuiteName = noop } if cfg.FormatTestCaseClassname == nil { cfg.FormatTestCaseClassname = noop } return cfg } func formatDurationAsSeconds(d time.Duration) string { return fmt.Sprintf("%f", d.Seconds()) } func packageProperties(goVersion string) []JUnitProperty { return []JUnitProperty{ {Name: "go.version", Value: goVersion}, } } // goVersion returns the version as reported by the go binary in PATH. This // version will not be the same as runtime.Version, which is always the version // of go used to build the gotestsum binary. // // To skip the os/exec call set the GOVERSION environment variable to the // desired value. func goVersion() string { if version, ok := os.LookupEnv("GOVERSION"); ok { return version } log.Debugf("exec: go version") cmd := exec.Command("go", "version") out, err := cmd.Output() if err != nil { log.Warnf("Failed to lookup go version for junit xml: %v", err) return "unknown" } return strings.TrimPrefix(strings.TrimSpace(string(out)), "go version ") } func packageTestCases(pkg *testjson.Package, formatClassname FormatFunc) []JUnitTestCase { cases := []JUnitTestCase{} if pkg.TestMainFailed() { jtc := newJUnitTestCase(testjson.TestCase{Test: "TestMain"}, formatClassname) jtc.Failure = &JUnitFailure{ Message: "Failed", Contents: pkg.Output(0), } cases = append(cases, jtc) } for _, tc := range pkg.Failed { jtc := newJUnitTestCase(tc, formatClassname) jtc.Failure = &JUnitFailure{ Message: "Failed", Contents: strings.Join(pkg.OutputLines(tc), ""), } cases = append(cases, jtc) } for _, tc := range pkg.Skipped { jtc := newJUnitTestCase(tc, formatClassname) jtc.SkipMessage = &JUnitSkipMessage{ Message: strings.Join(pkg.OutputLines(tc), ""), } cases = append(cases, jtc) } for _, tc := range pkg.Passed { jtc := newJUnitTestCase(tc, formatClassname) cases = append(cases, jtc) } return cases } func newJUnitTestCase(tc testjson.TestCase, formatClassname FormatFunc) JUnitTestCase { return JUnitTestCase{ Classname: formatClassname(tc.Package), Name: tc.Test.Name(), Time: formatDurationAsSeconds(tc.Elapsed), } } func write(out io.Writer, suites JUnitTestSuites) error { doc, err := xml.MarshalIndent(suites, "", "\t") if err != nil { return err } _, err = out.Write([]byte(xml.Header)) if err != nil { return err } _, err = out.Write(doc) return err } gotestsum-1.8.2/internal/junitxml/report_test.go000066400000000000000000000024571427475276200221730ustar00rootroot00000000000000package junitxml import ( "bytes" "fmt" "io" "io/ioutil" "runtime" "testing" "time" "gotest.tools/gotestsum/testjson" "gotest.tools/v3/assert" "gotest.tools/v3/env" "gotest.tools/v3/golden" ) func TestWrite(t *testing.T) { out := new(bytes.Buffer) exec := createExecution(t) env.Patch(t, "GOVERSION", "go7.7.7") err := Write(out, exec, Config{ ProjectName: "test", customTimestamp: new(time.Time).Format(time.RFC3339), customElapsed: "2.1", }) assert.NilError(t, err) golden.Assert(t, out.String(), "junitxml-report.golden") } func createExecution(t *testing.T) *testjson.Execution { exec, err := testjson.ScanTestOutput(testjson.ScanConfig{ Stdout: readTestData(t, "out"), Stderr: readTestData(t, "err"), }) assert.NilError(t, err) return exec } func readTestData(t *testing.T, stream string) io.Reader { raw, err := ioutil.ReadFile("../../testjson/testdata/input/go-test-json." + stream) assert.NilError(t, err) return bytes.NewReader(raw) } func TestGoVersion(t *testing.T) { t.Run("unknown", func(t *testing.T) { env.Patch(t, "PATH", "/bogus") assert.Equal(t, goVersion(), "unknown") }) t.Run("current version", func(t *testing.T) { expected := fmt.Sprintf("%s %s/%s", runtime.Version(), runtime.GOOS, runtime.GOARCH) assert.Equal(t, goVersion(), expected) }) } gotestsum-1.8.2/internal/junitxml/testdata/000077500000000000000000000000001427475276200210735ustar00rootroot00000000000000gotestsum-1.8.2/internal/junitxml/testdata/junitxml-report.golden000066400000000000000000000304041427475276200254510ustar00rootroot00000000000000 sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s === RUN TestNestedParallelFailures/a === PAUSE TestNestedParallelFailures/a === CONT TestNestedParallelFailures/a fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) === RUN TestNestedParallelFailures/d === PAUSE TestNestedParallelFailures/d === CONT TestNestedParallelFailures/d fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) === RUN TestNestedParallelFailures/c === PAUSE TestNestedParallelFailures/c === CONT TestNestedParallelFailures/c fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) === RUN TestNestedParallelFailures/b === PAUSE TestNestedParallelFailures/b === CONT TestNestedParallelFailures/b fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) === RUN TestNestedParallelFailures --- FAIL: TestNestedParallelFailures (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === CONT TestParallelTheFirst fails_test.go:29: failed the first --- FAIL: TestParallelTheFirst (0.01s) === RUN TestParallelTheThird === PAUSE TestParallelTheThird === CONT TestParallelTheThird fails_test.go:41: failed the third --- FAIL: TestParallelTheThird (0.00s) === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === CONT TestParallelTheSecond fails_test.go:35: failed the second --- FAIL: TestParallelTheSecond (0.01s) === RUN TestFailed fails_test.go:34: this failed --- FAIL: TestFailed (0.00s) === RUN TestFailedWithStderr this is stderr fails_test.go:43: also failed --- FAIL: TestFailedWithStderr (0.00s) === RUN TestNestedWithFailure/c fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) === RUN TestNestedWithFailure --- FAIL: TestNestedWithFailure (0.00s) gotestsum-1.8.2/internal/log/000077500000000000000000000000001427475276200161715ustar00rootroot00000000000000gotestsum-1.8.2/internal/log/log.go000066400000000000000000000022261427475276200173030ustar00rootroot00000000000000package log import ( "fmt" "github.com/fatih/color" ) type Level uint8 const ( ErrorLevel Level = iota WarnLevel DebugLevel ) var ( level = WarnLevel out = color.Error ) // SetLevel for the global logger. func SetLevel(l Level) { level = l } // Warnf prints the message to stderr, with a yellow WARN prefix. func Warnf(format string, args ...interface{}) { if level < WarnLevel { return } fmt.Fprint(out, color.YellowString("WARN ")) fmt.Fprintf(out, format, args...) fmt.Fprint(out, "\n") } // Debugf prints the message to stderr, with no prefix. func Debugf(format string, args ...interface{}) { if level < DebugLevel { return } fmt.Fprintf(out, format, args...) fmt.Fprint(out, "\n") } // Errorf prints the message to stderr, with a red ERROR prefix. func Errorf(format string, args ...interface{}) { if level < ErrorLevel { return } fmt.Fprint(out, color.RedString("ERROR ")) fmt.Fprintf(out, format, args...) fmt.Fprint(out, "\n") } // Error prints the message to stderr, with a red ERROR prefix. func Error(msg string) { if level < ErrorLevel { return } fmt.Fprint(out, color.RedString("ERROR ")) fmt.Fprintln(out, msg) } gotestsum-1.8.2/internal/text/000077500000000000000000000000001427475276200163745ustar00rootroot00000000000000gotestsum-1.8.2/internal/text/testing.go000066400000000000000000000015731427475276200204060ustar00rootroot00000000000000package text import ( "bufio" "io" "strings" "testing" "gotest.tools/v3/assert" ) // ProcessLines from the Reader by passing each one to ops. The output of each // op is passed to the next. Returns the string created by joining all the // processed lines. func ProcessLines(t *testing.T, r io.Reader, ops ...func(string) string) string { t.Helper() out := new(strings.Builder) scan := bufio.NewScanner(r) for scan.Scan() { line := scan.Text() for _, op := range ops { line = op(line) } out.WriteString(line + "\n") } assert.NilError(t, scan.Err()) return out.String() } func OpRemoveSummaryLineElapsedTime(line string) string { if i := strings.Index(line, " in "); i > 0 { return line[:i] } return line } func OpRemoveTestElapsedTime(line string) string { if i := strings.Index(line, " (0."); i > 0 && i+8 == len(line) { return line[:i] } return line } gotestsum-1.8.2/main.go000066400000000000000000000012601427475276200150460ustar00rootroot00000000000000package main import ( "os" "gotest.tools/gotestsum/cmd" "gotest.tools/gotestsum/cmd/tool" "gotest.tools/gotestsum/internal/log" ) func main() { err := route(os.Args) switch { case err == nil: return case cmd.IsExitCoder(err): // go test should already report the error to stderr, exit with // the same status code os.Exit(cmd.ExitCodeWithDefault(err)) default: log.Error(err.Error()) os.Exit(3) } } func route(args []string) error { name := args[0] next, rest := cmd.Next(args[1:]) switch next { case "help", "?": return cmd.Run(name, []string{"--help"}) case "tool": return tool.Run(name+" "+next, rest) default: return cmd.Run(name, args[1:]) } } gotestsum-1.8.2/testjson/000077500000000000000000000000001427475276200154455ustar00rootroot00000000000000gotestsum-1.8.2/testjson/doc.go000066400000000000000000000013341427475276200165420ustar00rootroot00000000000000/* Package testjson scans test2json output and builds up a summary of the events. Events are passed to a formatter for output. # Example This example reads the test2json output from os.Stdin. It sends every event to the handler, builds an Execution from the output, then it prints the number of tests run. exec, err := testjson.ScanTestOutput(testjson.ScanConfig{ // Stdout is a reader that provides the test2json output stream. Stdout: os.Stdin, // Handler receives TestEvents and error lines. Handler: eventHandler, }) if err != nil { return fmt.Errorf("failed to scan testjson: %w", err) } fmt.Println("Ran %d tests", exec.Total()) */ package testjson // import "gotest.tools/gotestsum/testjson" gotestsum-1.8.2/testjson/dotformat.go000066400000000000000000000066621427475276200200050ustar00rootroot00000000000000package testjson import ( "fmt" "io" "os" "sort" "strings" "time" "golang.org/x/term" "gotest.tools/gotestsum/internal/dotwriter" "gotest.tools/gotestsum/internal/log" ) func dotsFormatV1(event TestEvent, exec *Execution) string { pkg := exec.Package(event.Package) switch { case event.PackageEvent(): return "" case event.Action == ActionRun && pkg.Total == 1: return "[" + RelativePackagePath(event.Package) + "]" } return fmtDot(event) } func fmtDot(event TestEvent) string { withColor := colorEvent(event) switch event.Action { case ActionPass: return withColor("·") case ActionFail: return withColor("✖") case ActionSkip: return withColor("↷") } return "" } type dotFormatter struct { pkgs map[string]*dotLine order []string writer *dotwriter.Writer termWidth int } type dotLine struct { runes int builder *strings.Builder lastUpdate time.Time } func (l *dotLine) update(dot string) { if dot == "" { return } l.builder.WriteString(dot) l.runes++ } // checkWidth marks the line as full when the width of the line hits the // terminal width. func (l *dotLine) checkWidth(prefix, terminal int) { if prefix+l.runes >= terminal { l.builder.WriteString("\n" + strings.Repeat(" ", prefix)) l.runes = 0 } } func newDotFormatter(out io.Writer) EventFormatter { w, _, err := term.GetSize(int(os.Stdout.Fd())) if err != nil || w == 0 { log.Warnf("Failed to detect terminal width for dots format, error: %v", err) return &formatAdapter{format: dotsFormatV1, out: out} } return &dotFormatter{ pkgs: make(map[string]*dotLine), writer: dotwriter.New(out), termWidth: w, } } func (d *dotFormatter) Format(event TestEvent, exec *Execution) error { if d.pkgs[event.Package] == nil { d.pkgs[event.Package] = &dotLine{builder: new(strings.Builder)} d.order = append(d.order, event.Package) } line := d.pkgs[event.Package] line.lastUpdate = event.Time if !event.PackageEvent() { line.update(fmtDot(event)) } switch event.Action { case ActionOutput, ActionBench: return nil } // Add an empty header to work around incorrect line counting fmt.Fprint(d.writer, "\n\n") sort.Slice(d.order, d.orderByLastUpdated) for _, pkg := range d.order { line := d.pkgs[pkg] pkgname := RelativePackagePath(pkg) + " " prefix := fmtDotElapsed(exec.Package(pkg)) line.checkWidth(len(prefix+pkgname), d.termWidth) fmt.Fprintf(d.writer, prefix+pkgname+line.builder.String()+"\n") } PrintSummary(d.writer, exec, SummarizeNone) return d.writer.Flush() } // orderByLastUpdated so that the most recently updated packages move to the // bottom of the list, leaving completed package in the same order at the top. func (d *dotFormatter) orderByLastUpdated(i, j int) bool { return d.pkgs[d.order[i]].lastUpdate.Before(d.pkgs[d.order[j]].lastUpdate) } func fmtDotElapsed(p *Package) string { f := func(v string) string { return fmt.Sprintf(" %5s ", v) } elapsed := p.Elapsed() switch { case p.cached: return f("🖴 ") case elapsed <= 0: return f("") case elapsed >= time.Hour: return f("⏳ ") case elapsed < time.Second: return f(elapsed.String()) } const maxWidth = 7 var steps = []time.Duration{ time.Millisecond, 10 * time.Millisecond, 100 * time.Millisecond, time.Second, 10 * time.Second, time.Minute, 10 * time.Minute, } for _, trunc := range steps { r := f(elapsed.Truncate(trunc).String()) if len(r) <= maxWidth { return r } } return f("") } gotestsum-1.8.2/testjson/dotformat_test.go000066400000000000000000000054641427475276200210430ustar00rootroot00000000000000package testjson import ( "bytes" "math/rand" "runtime" "testing" "testing/quick" "time" "unicode/utf8" "gotest.tools/gotestsum/internal/dotwriter" "gotest.tools/gotestsum/internal/text" "gotest.tools/v3/assert" "gotest.tools/v3/assert/cmp" "gotest.tools/v3/golden" "gotest.tools/v3/skip" ) func TestScanTestOutput_WithDotsFormatter(t *testing.T) { skip.If(t, runtime.GOOS == "windows") out := new(bytes.Buffer) dotfmt := &dotFormatter{ pkgs: make(map[string]*dotLine), writer: dotwriter.New(out), termWidth: 80, } shim := newFakeHandler(dotfmt, "input/go-test-json") _, err := ScanTestOutput(shim.Config(t)) assert.NilError(t, err) actual := text.ProcessLines(t, out, text.OpRemoveSummaryLineElapsedTime) golden.Assert(t, actual, "format/dots-v2.out") golden.Assert(t, shim.err.String(), "input/go-test-json.err") } func TestFmtDotElapsed(t *testing.T) { var testcases = []struct { cached bool elapsed time.Duration expected string }{ { elapsed: 999 * time.Microsecond, expected: " 999µs ", }, { elapsed: 7 * time.Millisecond, expected: " 7ms ", }, { cached: true, elapsed: time.Millisecond, expected: " 🖴 ", }, { elapsed: 3 * time.Hour, expected: " ⏳ ", }, { elapsed: 14 * time.Millisecond, expected: " 14ms ", }, { elapsed: 333 * time.Millisecond, expected: " 333ms ", }, { elapsed: 1337 * time.Millisecond, expected: " 1.33s ", }, { elapsed: 14821 * time.Millisecond, expected: " 14.8s ", }, { elapsed: time.Minute + 59*time.Second, expected: " 1m59s ", }, { elapsed: 59*time.Minute + 59*time.Second, expected: " 59m0s ", }, { elapsed: 148213 * time.Millisecond, expected: " 2m28s ", }, { elapsed: 1482137 * time.Millisecond, expected: " 24m0s ", }, } for _, tc := range testcases { t.Run(tc.expected, func(t *testing.T) { pkg := &Package{ cached: tc.cached, elapsed: tc.elapsed, } actual := fmtDotElapsed(pkg) assert.Check(t, cmp.Equal(utf8.RuneCountInString(actual), 7)) assert.Equal(t, actual, tc.expected) }) } } func TestFmtDotElapsed_RuneCountProperty(t *testing.T) { f := func(d time.Duration) bool { pkg := &Package{ Passed: []TestCase{{Elapsed: d}}, } actual := fmtDotElapsed(pkg) width := utf8.RuneCountInString(actual) if width == 7 { return true } t.Logf("actual %v (width %d)", actual, width) return false } seed := time.Now().Unix() t.Log("seed", seed) assert.Assert(t, quick.Check(f, &quick.Config{ MaxCountScale: 2000, Rand: rand.New(rand.NewSource(seed)), })) } func TestNewDotFormatter(t *testing.T) { buf := new(bytes.Buffer) ef := newDotFormatter(buf) d, ok := ef.(*dotFormatter) skip.If(t, !ok, "no terminal width") assert.Assert(t, d.termWidth != 0) } gotestsum-1.8.2/testjson/execution.go000066400000000000000000000501361427475276200200040ustar00rootroot00000000000000package testjson import ( "bufio" "bytes" "encoding/json" "errors" "fmt" "io" "sort" "strings" "sync" "time" "golang.org/x/sync/errgroup" "gotest.tools/gotestsum/internal/log" ) // Action of TestEvent type Action string // nolint: unused const ( ActionRun Action = "run" ActionPause Action = "pause" ActionCont Action = "cont" ActionPass Action = "pass" ActionBench Action = "bench" ActionFail Action = "fail" ActionOutput Action = "output" ActionSkip Action = "skip" ) // IsTerminal returns true if the Action is one of: pass, fail, skip. func (a Action) IsTerminal() bool { switch a { case ActionPass, ActionFail, ActionSkip: return true default: return false } } // TestEvent is a structure output by go tool test2json and go test -json. type TestEvent struct { // Time encoded as an RFC3339-format string Time time.Time Action Action Package string Test string // Elapsed time in seconds Elapsed float64 // Output of test or benchmark Output string // raw is the raw JSON bytes of the event raw []byte // RunID from the ScanConfig which produced this test event. RunID int } // PackageEvent returns true if the event is a package start or end event func (e TestEvent) PackageEvent() bool { return e.Test == "" } // ElapsedFormatted returns Elapsed formatted in the go test format, ex (0.00s). func (e TestEvent) ElapsedFormatted() string { return fmt.Sprintf("(%.2fs)", e.Elapsed) } // Bytes returns the serialized JSON bytes that were parsed to create the event. func (e TestEvent) Bytes() []byte { return e.raw } // Package is the set of TestEvents for a single go package type Package struct { Total int running map[string]TestCase Failed []TestCase Skipped []TestCase Passed []TestCase // elapsed time reported by the pass or fail event for the package. elapsed time.Duration // mapping of root TestCase ID to all sub test IDs. Used to mitigate // github.com/golang/go/issues/29755, and github.com/golang/go/issues/40771. // In the future when those bug are fixed this mapping can likely be removed. subTests map[int][]int // output printed by test cases, indexed by TestCase.ID. Package output is // saved with key 0. output map[int][]string // coverage stores the code coverage output for the package without the // trailing newline (ex: coverage: 91.1% of statements). coverage string // action identifies if the package passed or failed. A package may fail // with no test failures if an init() or TestMain exits non-zero. // skip indicates there were no tests. action Action // cached is true if the package was marked as (cached) cached bool // panicked is true if the package, or one of the tests in the package, // contained output that looked like a panic. This is used to mitigate // github.com/golang/go/issues/45508. This field may be removed in the future // if the issue is fixed in Go. panicked bool // shuffleSeed is the seed used to shuffle the tests. The value is set when // tests are run with -shuffle shuffleSeed string } // Result returns if the package passed, failed, or was skipped because there // were no tests. func (p *Package) Result() Action { return p.action } // Elapsed returns the elapsed time of the package, as reported by the // pass or fail event for the package. func (p *Package) Elapsed() time.Duration { return p.elapsed } // TestCases returns all the test cases. func (p *Package) TestCases() []TestCase { tc := append([]TestCase{}, p.Passed...) tc = append(tc, p.Failed...) tc = append(tc, p.Skipped...) return tc } // LastFailedByName returns the most recent test with name in the list of Failed // tests. If no TestCase is found with that name, an empty TestCase is returned. // // LastFailedByName may be used by formatters to find the TestCase.ID for the current // failing TestEvent. It is very likely the last TestCase in Failed, but this method // provides a little more safety if that ever changes. func (p *Package) LastFailedByName(name string) TestCase { for i := len(p.Failed) - 1; i >= 0; i-- { if p.Failed[i].Test.Name() == name { return p.Failed[i] } } return TestCase{} } // Output returns the full test output for a test. // // Unlike OutputLines() it does not return lines from subtests in some cases. func (p *Package) Output(id int) string { return strings.Join(p.output[id], "") } // OutputLines returns the full test output for a test as a slice of strings. // // As a workaround for test output being attributed to the wrong subtest, if: // - the TestCase is a root TestCase (not a subtest), and // - the TestCase has no subtest failures; // // then all output for every subtest under the root test is returned. // See https://github.com/golang/go/issues/29755. func (p *Package) OutputLines(tc TestCase) []string { lines := p.output[tc.ID] // If this is a subtest, or a root test case with subtest failures the // subtest failure output should contain the relevant lines, so we don't need // extra lines. if tc.Test.IsSubTest() || tc.hasSubTestFailed { return lines } result := make([]string, 0, len(lines)+1) result = append(result, lines...) for _, sub := range p.subTests[tc.ID] { result = append(result, p.output[sub]...) } return result } func (p *Package) addOutput(id int, output string) { if strings.HasPrefix(output, "panic: ") { p.panicked = true } // TODO: limit size of buffered test output p.output[id] = append(p.output[id], output) } type TestName string func (n TestName) Split() (root string, sub string) { parts := strings.SplitN(string(n), "/", 2) if len(parts) < 2 { return string(n), "" } return parts[0], parts[1] } // IsSubTest returns true if the name indicates the test is a subtest run using // t.Run(). func (n TestName) IsSubTest() bool { return strings.Contains(string(n), "/") } func (n TestName) Name() string { return string(n) } func (p *Package) removeOutput(id int) { delete(p.output, id) skipped := tcIDSet(p.Skipped) for _, sub := range p.subTests[id] { if _, isSkipped := skipped[sub]; !isSkipped { delete(p.output, sub) } } } func tcIDSet(skipped []TestCase) map[int]struct{} { result := make(map[int]struct{}) for _, tc := range skipped { result[tc.ID] = struct{}{} } return result } // TestMainFailed returns true if the package failed, but there were no tests. // This may occur if the package init() or TestMain exited non-zero. func (p *Package) TestMainFailed() bool { return p.action == ActionFail && len(p.Failed) == 0 } const neverFinished time.Duration = -1 // end adds any tests that were missing an ActionFail TestEvent to the list of // Failed, and returns a slice of artificial TestEvent for the missing ones. // // This is done to work around 'go test' not sending the ActionFail TestEvents // in some cases, when a test panics. func (p *Package) end() []TestEvent { result := make([]TestEvent, 0, len(p.running)) for k, tc := range p.running { if tc.Test.IsSubTest() && rootTestPassed(p, tc) { // mitigate github.com/golang/go/issues/40771 (gotestsum/issues/141) // by skipping missing subtest end events when the root test passed. continue } tc.Elapsed = neverFinished p.Failed = append(p.Failed, tc) result = append(result, TestEvent{ Action: ActionFail, Package: tc.Package, Test: tc.Test.Name(), Elapsed: float64(neverFinished), }) delete(p.running, k) } return result } // rootTestPassed looks for the root test associated with subtest and returns // true if the root test passed. This is used to mitigate // github.com/golang/go/issues/40771 (gotestsum/issues/141) and may be removed // in the future since that issue was patched in go1.16. // // This function is slightly expensive because it has to scan every test in the // package, but it should only run in the rare case where a subtest was missing // an end event. Spending a little more time in that rare case is probably better // than keeping extra mapping of tests in all cases. func rootTestPassed(p *Package, subtest TestCase) bool { root, _ := subtest.Test.Split() for _, tc := range p.Passed { if tc.Test.Name() != root { continue } for _, subID := range p.subTests[tc.ID] { if subID == subtest.ID { return true } } } return false } // TestCase stores the name and elapsed time for a test case. type TestCase struct { // ID is unique ID for each test case. A test run may include multiple instances // of the same Package and Name if -count is used, or if the input comes from // multiple runs. The ID can be used to uniquely reference an instance of a // test case. ID int Package string Test TestName Elapsed time.Duration // RunID from the ScanConfig which produced this test case. RunID int // hasSubTestFailed is true when a subtest of this TestCase has failed. It is // used to find root TestCases which have no failing subtests. hasSubTestFailed bool // Time when the test was run. Time time.Time } func newPackage() *Package { return &Package{ output: make(map[int][]string), running: make(map[string]TestCase), subTests: make(map[int][]int), } } // Execution of one or more test packages type Execution struct { started time.Time packages map[string]*Package errorsLock sync.RWMutex errors []string done bool lastRunID int } func (e *Execution) add(event TestEvent) { pkg, ok := e.packages[event.Package] if !ok { pkg = newPackage() e.packages[event.Package] = pkg } if event.PackageEvent() { pkg.addEvent(event) return } pkg.addTestEvent(event) } func (p *Package) addEvent(event TestEvent) { switch event.Action { case ActionPass, ActionFail: p.action = event.Action p.elapsed = elapsedDuration(event.Elapsed) case ActionOutput: if isCoverageOutput(event.Output) { p.coverage = strings.TrimRight(event.Output, "\n") } if strings.Contains(event.Output, "\t(cached)") { p.cached = true } if isShuffleSeedOutput(event.Output) { p.shuffleSeed = strings.TrimRight(event.Output, "\n") } p.addOutput(0, event.Output) } } func (p *Package) newTestCaseFromEvent(event TestEvent) TestCase { // Incremental total before using it as the ID, because ID 0 is used for // the package output p.Total++ return TestCase{ Package: event.Package, Test: TestName(event.Test), ID: p.Total, RunID: event.RunID, Time: event.Time, } } func (p *Package) addTestEvent(event TestEvent) { if event.Action == ActionRun { tc := p.newTestCaseFromEvent(event) p.running[event.Test] = tc if tc.Test.IsSubTest() { root, _ := TestName(event.Test).Split() rootID := p.running[root].ID p.subTests[rootID] = append(p.subTests[rootID], tc.ID) } return } tc := p.running[event.Test] // This appears to be a bug in 'go test' or test2json. This test is missing // an Action=run event. Create one on the first event received from the test. if tc.ID == 0 { tc = p.newTestCaseFromEvent(event) p.running[event.Test] = tc } switch event.Action { case ActionOutput, ActionBench: tc := p.running[event.Test] p.addOutput(tc.ID, event.Output) return case ActionPause, ActionCont: return } // the event.Action must be one of the three "test end" events delete(p.running, event.Test) tc.Elapsed = elapsedDuration(event.Elapsed) switch event.Action { case ActionFail: p.Failed = append(p.Failed, tc) // If this is a subtest, mark the root test as having a failed subtest if tc.Test.IsSubTest() { root, _ := TestName(event.Test).Split() rootTestCase := p.running[root] rootTestCase.hasSubTestFailed = true p.running[root] = rootTestCase } case ActionSkip: p.Skipped = append(p.Skipped, tc) case ActionPass: p.Passed = append(p.Passed, tc) // Do not immediately remove output for subtests, to work around a bug // in 'go test' where output is attributed to the wrong sub test. // github.com/golang/go/issues/29755. if tc.Test.IsSubTest() { return } // Remove test output once a test passes, it wont be used. p.removeOutput(tc.ID) } } func elapsedDuration(elapsed float64) time.Duration { return time.Duration(elapsed*1000) * time.Millisecond } func isCoverageOutput(output string) bool { return all( strings.HasPrefix(output, "coverage:"), strings.Contains(output, "% of statements")) } func isShuffleSeedOutput(output string) bool { return strings.HasPrefix(output, "-test.shuffle ") } func isWarningNoTestsToRunOutput(output string) bool { return output == "testing: warning: no tests to run\n" } // OutputLines returns the full test output for a test as an slice of lines. // This function is a convenient wrapper around Package.OutputLines() to // support the hiding of output in the summary. // // See Package.OutLines() for more details. func (e *Execution) OutputLines(tc TestCase) []string { return e.packages[tc.Package].OutputLines(tc) } // Package returns the Package by name. func (e *Execution) Package(name string) *Package { return e.packages[name] } // Packages returns a sorted list of all package names. func (e *Execution) Packages() []string { return sortedKeys(e.packages) } var timeNow = time.Now // Elapsed returns the time elapsed since the execution started. func (e *Execution) Elapsed() time.Duration { return timeNow().Sub(e.started) } // Failed returns a list of all the failed test cases. func (e *Execution) Failed() []TestCase { if e == nil { return nil } var failed []TestCase //nolint:prealloc for _, name := range sortedKeys(e.packages) { pkg := e.packages[name] // Add package-level failure output if there were no failed tests. if pkg.TestMainFailed() { failed = append(failed, TestCase{Package: name}) } failed = append(failed, pkg.Failed...) } return failed } // FilterFailedUnique filters a slice of failed TestCases by removing root test // case that have failed subtests. func FilterFailedUnique(tcs []TestCase) []TestCase { var result []TestCase for _, tc := range tcs { if !tc.hasSubTestFailed { result = append(result, tc) } } return result } func sortedKeys(pkgs map[string]*Package) []string { keys := make([]string, 0, len(pkgs)) for key := range pkgs { keys = append(keys, key) } sort.Strings(keys) return keys } // Skipped returns a list of all the skipped test cases. func (e *Execution) Skipped() []TestCase { skipped := make([]TestCase, 0, len(e.packages)) for _, pkg := range sortedKeys(e.packages) { skipped = append(skipped, e.packages[pkg].Skipped...) } return skipped } // Total returns a count of all test cases. func (e *Execution) Total() int { total := 0 for _, pkg := range e.packages { total += pkg.Total } return total } func (e *Execution) addError(err string) { // Build errors start with a header if strings.HasPrefix(err, "# ") { return } e.errorsLock.Lock() e.errors = append(e.errors, err) e.errorsLock.Unlock() } // Errors returns a list of all the errors. func (e *Execution) Errors() []string { e.errorsLock.RLock() defer e.errorsLock.RUnlock() return e.errors } // HasPanic returns true if at least one package had output that looked like a // panic. func (e *Execution) HasPanic() bool { for _, pkg := range e.packages { if pkg.panicked { return true } } return false } func (e *Execution) end() []TestEvent { e.done = true var result []TestEvent // nolint: prealloc for _, pkg := range e.packages { result = append(result, pkg.end()...) } return result } func (e *Execution) Started() time.Time { return e.started } // newExecution returns a new Execution and records the current time as the // time the test execution started. func newExecution() *Execution { return &Execution{ started: timeNow(), packages: make(map[string]*Package), } } // ScanConfig used by ScanTestOutput. type ScanConfig struct { // RunID is a unique identifier for the run. It may be set to the pid of the // process, or some other identifier. It will stored as the TestCase.RunID. RunID int // Stdout is a reader that yields the test2json output stream. Stdout io.Reader // Stderr is a reader that yields stderr from the 'go test' process. Often // it contains build errors, or panics. Stderr may be nil. Stderr io.Reader // Handler is a set of callbacks for receiving TestEvents and stderr text. Handler EventHandler // Execution to populate while scanning. If nil a new one will be created // and returned from ScanTestOutput. Execution *Execution // Stop is called when ScanTestOutput fails during a scan. Stop func() // IgnoreNonJSONOutputLines causes ScanTestOutput to ignore non-JSON lines received from // the Stdout reader. Instead of causing an error, the lines will be sent to Handler.Err. IgnoreNonJSONOutputLines bool } // EventHandler is called by ScanTestOutput for each event and write to stderr. type EventHandler interface { // Event is called for every TestEvent, with the current value of Execution. // It may return an error to stop scanning. Event(event TestEvent, execution *Execution) error // Err is called for every line from the Stderr reader and may return an // error to stop scanning. Err(text string) error } // ScanTestOutput reads lines from config.Stdout and config.Stderr, populates an // Execution, calls the Handler for each event, and returns the Execution. // // If config.Handler is nil, a default no-op handler will be used. func ScanTestOutput(config ScanConfig) (*Execution, error) { if config.Stdout == nil { return nil, fmt.Errorf("stdout reader must be non-nil") } if config.Handler == nil { config.Handler = noopHandler{} } if config.Stderr == nil { config.Stderr = new(bytes.Reader) } if config.Stop == nil { config.Stop = func() {} } execution := config.Execution if execution == nil { execution = newExecution() } execution.done = false execution.lastRunID = config.RunID var group errgroup.Group group.Go(func() error { return stopOnError(config.Stop, readStdout(config, execution)) }) group.Go(func() error { return stopOnError(config.Stop, readStderr(config, execution)) }) err := group.Wait() for _, event := range execution.end() { if err := config.Handler.Event(event, execution); err != nil { return execution, err } } return execution, err } func stopOnError(stop func(), err error) error { if err != nil { stop() return err } return nil } func readStdout(config ScanConfig, execution *Execution) error { scanner := bufio.NewScanner(config.Stdout) for scanner.Scan() { raw := scanner.Bytes() event, err := parseEvent(raw) switch { case err == errBadEvent: // nolint: errcheck config.Handler.Err(errBadEvent.Error() + ": " + scanner.Text()) continue case err != nil: if config.IgnoreNonJSONOutputLines { // nolint: errcheck config.Handler.Err(string(raw)) continue } return fmt.Errorf("failed to parse test output: %s: %w", string(raw), err) } event.RunID = config.RunID execution.add(event) if err := config.Handler.Event(event, execution); err != nil { return err } } if err := scanner.Err(); err != nil { return fmt.Errorf("failed to scan test output: %w", err) } return nil } func readStderr(config ScanConfig, execution *Execution) error { scanner := bufio.NewScanner(config.Stderr) for scanner.Scan() { line := scanner.Text() if err := config.Handler.Err(line); err != nil { return fmt.Errorf("failed to handle stderr: %v", err) } if isGoModuleOutput(line) { continue } if strings.HasPrefix(line, "warning:") { continue } execution.addError(line) } if err := scanner.Err(); err != nil { return fmt.Errorf("failed to scan stderr: %v", err) } return nil } func isGoModuleOutput(scannerText string) bool { prefixes := []string{ "go: copying", "go: creating", "go: downloading", "go: extracting", "go: finding", } for _, prefix := range prefixes { if strings.HasPrefix(scannerText, prefix) { return true } } return false } func parseEvent(raw []byte) (TestEvent, error) { // TODO: this seems to be a bug in the `go test -json` output if bytes.HasPrefix(raw, []byte("FAIL")) { log.Warnf("invalid TestEvent: %v", string(raw)) return TestEvent{}, errBadEvent } event := TestEvent{} err := json.Unmarshal(raw, &event) event.raw = raw return event, err } var errBadEvent = errors.New("bad output from test2json") type noopHandler struct{} func (s noopHandler) Event(TestEvent, *Execution) error { return nil } func (s noopHandler) Err(string) error { return nil } gotestsum-1.8.2/testjson/execution_test.go000066400000000000000000000145541427475276200210470ustar00rootroot00000000000000package testjson import ( "bytes" "fmt" "testing" "time" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "gotest.tools/v3/assert" "gotest.tools/v3/golden" ) func TestExecution_Add_PackageCoverage(t *testing.T) { exec := newExecution() exec.add(TestEvent{ Package: "mytestpkg", Action: ActionOutput, Output: "coverage: 33.1% of statements\n", }) pkg := exec.Package("mytestpkg") expected := &Package{ coverage: "coverage: 33.1% of statements", output: map[int][]string{ 0: {"coverage: 33.1% of statements\n"}, }, running: map[string]TestCase{}, } assert.DeepEqual(t, pkg, expected, cmpPackage) } var cmpPackage = cmp.Options{ cmp.AllowUnexported(Package{}), cmpopts.EquateEmpty(), } func TestScanTestOutput_MinimalConfig(t *testing.T) { in := bytes.NewReader(golden.Get(t, "input/go-test-json.out")) exec, err := ScanTestOutput(ScanConfig{Stdout: in}) assert.NilError(t, err) // a weak check to show that all the stdout was scanned assert.Equal(t, exec.Total(), 59) } func TestScanTestOutput_CallsStopOnError(t *testing.T) { var called bool stop := func() { called = true } cfg := ScanConfig{ Stdout: bytes.NewReader(golden.Get(t, "input/go-test-json.out")), Handler: &handlerFails{}, Stop: stop, } _, err := ScanTestOutput(cfg) assert.Error(t, err, "something failed") assert.Assert(t, called) } type handlerFails struct { count int } func (s *handlerFails) Event(_ TestEvent, _ *Execution) error { if s.count > 1 { return fmt.Errorf("something failed") } s.count++ return nil } func (s *handlerFails) Err(_ string) error { return nil } func TestParseEvent(t *testing.T) { // nolint: lll raw := `{"Time":"2018-03-22T22:33:35.168308334Z","Action":"output","Package":"example.com/good","Test": "TestOk","Output":"PASS\n"}` event, err := parseEvent([]byte(raw)) assert.NilError(t, err) expected := TestEvent{ Time: time.Date(2018, 3, 22, 22, 33, 35, 168308334, time.UTC), Action: "output", Package: "example.com/good", Test: "TestOk", Output: "PASS\n", raw: []byte(raw), } cmpTestEvent := cmp.AllowUnexported(TestEvent{}) assert.DeepEqual(t, event, expected, cmpTestEvent) } func TestPackage_AddEvent(t *testing.T) { type testCase struct { name string event string expected Package } run := func(t *testing.T, tc testCase) { te, err := parseEvent([]byte(tc.event)) assert.NilError(t, err) p := newPackage() p.addEvent(te) assert.DeepEqual(t, p, &tc.expected, cmpPackage) } var testCases = []testCase{ { name: "coverage with -cover", event: `{"Action":"output","Package":"gotest.tools/testing","Output":"coverage: 4.2% of statements\n"}`, expected: Package{ coverage: "coverage: 4.2% of statements", output: pkgOutput(0, "coverage: 4.2% of statements\n"), }, }, { name: "coverage with -coverpkg", event: `{"Action":"output","Package":"gotest.tools/testing","Output":"coverage: 7.5% of statements in ./testing\n"}`, expected: Package{ coverage: "coverage: 7.5% of statements in ./testing", output: pkgOutput(0, "coverage: 7.5% of statements in ./testing\n"), }, }, { name: "package failed", event: `{"Action":"fail","Package":"gotest.tools/testing","Elapsed":0.012}`, expected: Package{action: ActionFail, elapsed: 12 * time.Millisecond}, }, { name: "package is cached", event: `{"Action":"output","Package":"gotest.tools/testing","Output":"ok \tgotest.tools/testing\t(cached)\n"}`, expected: Package{ cached: true, output: pkgOutput(0, "ok \tgotest.tools/testing\t(cached)\n"), }, }, { name: "package pass", event: `{"Action":"pass","Package":"gotest.tools/testing","Elapsed":0.012}`, expected: Package{action: ActionPass, elapsed: 12 * time.Millisecond}, }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { run(t, tc) }) } } func pkgOutput(id int, line string) map[int][]string { return map[int][]string{id: {line}} } func TestScanOutput_WithMissingEvents(t *testing.T) { source := golden.Get(t, "go-test-json-missing-test-events.out") handler := &captureHandler{} cfg := ScanConfig{ Stdout: bytes.NewReader(source), Handler: handler, } _, err := ScanTestOutput(cfg) assert.NilError(t, err) var cmpTestEventShallow = cmp.Options{ cmp.Comparer(func(x, y TestEvent) bool { return x.Test == y.Test && x.Action == y.Action && x.Elapsed == y.Elapsed }), cmpopts.SortSlices(func(x, y TestEvent) bool { return x.Test < y.Test }), } // the package end event should come immediately before the artificial events expected := []TestEvent{ {Action: ActionPass}, {Action: ActionFail, Test: "TestMissing", Elapsed: -1}, {Action: ActionFail, Test: "TestMissing/a", Elapsed: -1}, {Action: ActionFail, Test: "TestMissingEvent", Elapsed: -1}, {Action: ActionFail, Test: "TestFailed/a", Elapsed: -1}, {Action: ActionFail, Test: "TestFailed/a/sub", Elapsed: -1}, } assert.Assert(t, len(handler.events) > len(expected)) start := len(handler.events) - len(expected) assert.DeepEqual(t, expected, handler.events[start:], cmpTestEventShallow) } func TestScanOutput_WithNonJSONLines(t *testing.T) { source := golden.Get(t, "go-test-json-with-nonjson-stdout.out") nonJSONLine := "|||This line is not valid test2json output.|||" // Test that when we ignore non-JSON lines, scanning completes, and test // that when we don't ignore non-JSON lines, scanning fails. for _, ignore := range []bool{true, false} { t.Run(fmt.Sprintf("ignore-non-json=%v", ignore), func(t *testing.T) { handler := &captureHandler{} cfg := ScanConfig{ Stdout: bytes.NewReader(source), Handler: handler, IgnoreNonJSONOutputLines: ignore, } _, err := ScanTestOutput(cfg) if ignore { assert.DeepEqual(t, handler.errs, []string{nonJSONLine}) assert.NilError(t, err) return } assert.DeepEqual(t, handler.errs, []string{}, cmpopts.EquateEmpty()) expected := "failed to parse test output: " + nonJSONLine + ": invalid character '|' looking for beginning of value" assert.Error(t, err, expected) }) } } type captureHandler struct { events []TestEvent errs []string } func (s *captureHandler) Event(event TestEvent, _ *Execution) error { s.events = append(s.events, event) return nil } func (s *captureHandler) Err(text string) error { s.errs = append(s.errs, text) return fmt.Errorf(text) } gotestsum-1.8.2/testjson/format.go000066400000000000000000000137301427475276200172700ustar00rootroot00000000000000package testjson import ( "fmt" "io" "strings" "github.com/fatih/color" ) func debugFormat(event TestEvent, _ *Execution) string { return fmt.Sprintf("%s %s %s (%.3f) [%d] %s\n", event.Package, event.Test, event.Action, event.Elapsed, event.Time.Unix(), event.Output) } // go test -v func standardVerboseFormat(event TestEvent, _ *Execution) string { if event.Action == ActionOutput { return event.Output } return "" } // go test func standardQuietFormat(event TestEvent, _ *Execution) string { if !event.PackageEvent() { return "" } if event.Output == "PASS\n" || isCoverageOutput(event.Output) { return "" } if isWarningNoTestsToRunOutput(event.Output) { return "" } return event.Output } func testNameFormat(event TestEvent, exec *Execution) string { result := colorEvent(event)(strings.ToUpper(string(event.Action))) formatTest := func() string { pkgPath := RelativePackagePath(event.Package) return fmt.Sprintf("%s %s%s %s\n", result, joinPkgToTestName(pkgPath, event.Test), formatRunID(event.RunID), event.ElapsedFormatted()) } switch { case isPkgFailureOutput(event): return event.Output case event.PackageEvent(): if !event.Action.IsTerminal() { return "" } pkg := exec.Package(event.Package) if event.Action == ActionSkip || (event.Action == ActionPass && pkg.Total == 0) { result = colorEvent(event)("EMPTY") } event.Elapsed = 0 // hide elapsed for now, for backwards compat return result + " " + packageLine(event, exec) case event.Action == ActionFail: pkg := exec.Package(event.Package) tc := pkg.LastFailedByName(event.Test) return pkg.Output(tc.ID) + formatTest() case event.Action == ActionPass: return formatTest() } return "" } // joinPkgToTestName for formatting. // If the package path isn't the current directory, we add a period to separate // the test name and the package path. If it is the current directory, we don't // show it at all. This prevents output like ..MyTest when the test is in the // current directory. func joinPkgToTestName(pkg string, test string) string { if pkg == "." { return test } return pkg + "." + test } // formatRunID returns a formatted string of the runID. func formatRunID(runID int) string { if runID <= 0 { return "" } return fmt.Sprintf(" (re-run %d)", runID) } // isPkgFailureOutput returns true if the event is package output, and the output // doesn't match any of the expected framing messages. Events which match this // pattern should be package-level failures (ex: exit(1) or panic in an init() or // TestMain). func isPkgFailureOutput(event TestEvent) bool { out := event.Output return all( event.PackageEvent(), event.Action == ActionOutput, out != "PASS\n", out != "FAIL\n", !isWarningNoTestsToRunOutput(out), !strings.HasPrefix(out, "FAIL\t"+event.Package), !strings.HasPrefix(out, "ok \t"+event.Package), !strings.HasPrefix(out, "? \t"+event.Package), !isShuffleSeedOutput(out), ) } func all(cond ...bool) bool { for _, c := range cond { if !c { return false } } return true } func pkgNameFormat(event TestEvent, exec *Execution) string { if !event.PackageEvent() { return "" } return shortFormatPackageEvent(event, exec) } func shortFormatPackageEvent(event TestEvent, exec *Execution) string { pkg := exec.Package(event.Package) fmtEvent := func(action string) string { return action + " " + packageLine(event, exec) } withColor := colorEvent(event) switch event.Action { case ActionSkip: return fmtEvent(withColor("∅")) case ActionPass: if pkg.Total == 0 { return fmtEvent(withColor("∅")) } return fmtEvent(withColor("✓")) case ActionFail: return fmtEvent(withColor("✖")) } return "" } func packageLine(event TestEvent, exec *Execution) string { pkg := exec.Package(event.Package) var buf strings.Builder buf.WriteString(RelativePackagePath(event.Package)) switch { case pkg.cached: buf.WriteString(" (cached)") case event.Elapsed != 0: d := elapsedDuration(event.Elapsed) buf.WriteString(fmt.Sprintf(" (%s)", d)) } if pkg.coverage != "" { buf.WriteString(" (" + pkg.coverage + ")") } if event.Action == ActionFail && pkg.shuffleSeed != "" { buf.WriteString(" (" + pkg.shuffleSeed + ")") } buf.WriteString("\n") return buf.String() } func pkgNameWithFailuresFormat(event TestEvent, exec *Execution) string { if !event.PackageEvent() { if event.Action == ActionFail { pkg := exec.Package(event.Package) tc := pkg.LastFailedByName(event.Test) return pkg.Output(tc.ID) } return "" } return shortFormatPackageEvent(event, exec) } func colorEvent(event TestEvent) func(format string, a ...interface{}) string { switch event.Action { case ActionPass: return color.GreenString case ActionFail: return color.RedString case ActionSkip: return color.YellowString } return color.WhiteString } // EventFormatter is a function which handles an event and returns a string to // output for the event. type EventFormatter interface { Format(event TestEvent, output *Execution) error } // NewEventFormatter returns a formatter for printing events. func NewEventFormatter(out io.Writer, format string) EventFormatter { switch format { case "debug": return &formatAdapter{out, debugFormat} case "standard-verbose": return &formatAdapter{out, standardVerboseFormat} case "standard-quiet": return &formatAdapter{out, standardQuietFormat} case "dots", "dots-v1": return &formatAdapter{out, dotsFormatV1} case "dots-v2": return newDotFormatter(out) case "testname", "short-verbose": return &formatAdapter{out, testNameFormat} case "pkgname", "short": return &formatAdapter{out, pkgNameFormat} case "pkgname-and-test-fails", "short-with-failures": return &formatAdapter{out, pkgNameWithFailuresFormat} default: return nil } } type formatAdapter struct { out io.Writer format func(TestEvent, *Execution) string } func (f *formatAdapter) Format(event TestEvent, exec *Execution) error { o := f.format(event, exec) _, err := f.out.Write([]byte(o)) return err } gotestsum-1.8.2/testjson/format_test.go000066400000000000000000000127341427475276200203320ustar00rootroot00000000000000package testjson import ( "bytes" "testing" "gotest.tools/v3/assert" "gotest.tools/v3/golden" ) // go-test-json files are generated using the following command: // // go test -p=1 -parallel=1 -json -tags=stubpkg ./testjson/internal/... // // Additional flags (ex: -cover, -shuffle) may be added to test different // scenarios. // // There are also special package scenarios: // // -tags="stubpkg timeout" // -tags="stubpkg panic" // // Expected output for the standard-quiet and standard-verbose formats can be // generated with the same command by removing the -json flag. type fakeHandler struct { inputName string formatter EventFormatter out *bytes.Buffer err *bytes.Buffer } func (s *fakeHandler) Config(t *testing.T) ScanConfig { return ScanConfig{ Stdout: bytes.NewReader(golden.Get(t, s.inputName+".out")), Stderr: bytes.NewReader(golden.Get(t, s.inputName+".err")), Handler: s, } } func newFakeHandlerWithAdapter( format func(event TestEvent, output *Execution) string, inputName string, ) *fakeHandler { out := new(bytes.Buffer) return &fakeHandler{ inputName: inputName, formatter: &formatAdapter{out: out, format: format}, out: out, err: new(bytes.Buffer), } } func newFakeHandler(formatter EventFormatter, inputName string) *fakeHandler { return &fakeHandler{ inputName: inputName, formatter: formatter, out: new(bytes.Buffer), err: new(bytes.Buffer), } } func (s *fakeHandler) Event(event TestEvent, execution *Execution) error { return s.formatter.Format(event, execution) } func (s *fakeHandler) Err(text string) error { s.err.WriteString(text + "\n") return nil } func patchPkgPathPrefix(t *testing.T, val string) { var oldVal string oldVal, pkgPathPrefix = pkgPathPrefix, val t.Cleanup(func() { pkgPathPrefix = oldVal }) } func TestFormats_DefaultGoTestJson(t *testing.T) { type testCase struct { name string format func(event TestEvent, exec *Execution) string expectedOut string expected func(t *testing.T, exec *Execution) } run := func(t *testing.T, tc testCase) { shim := newFakeHandlerWithAdapter(tc.format, "input/go-test-json") exec, err := ScanTestOutput(shim.Config(t)) assert.NilError(t, err) golden.Assert(t, shim.out.String(), tc.expectedOut) golden.Assert(t, shim.err.String(), "input/go-test-json.err") if tc.expected != nil { tc.expected(t, exec) } } testCases := []testCase{ { name: "testname", format: testNameFormat, expectedOut: "format/testname.out", }, { name: "dots-v1", format: dotsFormatV1, expectedOut: "format/dots-v1.out", }, { name: "pkgname", format: pkgNameFormat, expectedOut: "format/pkgname.out", }, { name: "standard-verbose", format: standardVerboseFormat, expectedOut: "format/standard-verbose.out", }, { name: "standard-quiet", format: standardQuietFormat, expectedOut: "format/standard-quiet.out", }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { run(t, tc) }) } } func TestFormats_Coverage(t *testing.T) { type testCase struct { name string format func(event TestEvent, exec *Execution) string expectedOut string expected func(t *testing.T, exec *Execution) } run := func(t *testing.T, tc testCase) { patchPkgPathPrefix(t, "gotest.tools") shim := newFakeHandlerWithAdapter(tc.format, "input/go-test-json-with-cover") exec, err := ScanTestOutput(shim.Config(t)) assert.NilError(t, err) golden.Assert(t, shim.out.String(), tc.expectedOut) golden.Assert(t, shim.err.String(), "go-test.err") if tc.expected != nil { tc.expected(t, exec) } } testCases := []testCase{ { name: "testname", format: testNameFormat, expectedOut: "format/testname-coverage.out", }, { name: "pkgname", format: pkgNameFormat, expectedOut: "format/pkgname-coverage.out", }, { name: "standard-verbose", format: standardVerboseFormat, expectedOut: "format/standard-verbose-coverage.out", }, { name: "standard-quiet", format: standardQuietFormat, expectedOut: "format/standard-quiet-coverage.out", }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { run(t, tc) }) } } func TestFormats_Shuffle(t *testing.T) { type testCase struct { name string format func(event TestEvent, exec *Execution) string expectedOut string expected func(t *testing.T, exec *Execution) } run := func(t *testing.T, tc testCase) { shim := newFakeHandlerWithAdapter(tc.format, "input/go-test-json-with-shuffle") exec, err := ScanTestOutput(shim.Config(t)) assert.NilError(t, err) golden.Assert(t, shim.out.String(), tc.expectedOut) golden.Assert(t, shim.err.String(), "go-test.err") if tc.expected != nil { tc.expected(t, exec) } } testCases := []testCase{ { name: "testname", format: testNameFormat, expectedOut: "format/testname-shuffle.out", }, { name: "pkgname", format: pkgNameFormat, expectedOut: "format/pkgname-shuffle.out", }, { name: "standard-verbose", format: standardVerboseFormat, expectedOut: "format/standard-verbose-shuffle.out", }, { name: "standard-quiet", format: standardQuietFormat, expectedOut: "format/standard-quiet-shuffle.out", }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { run(t, tc) }) } } gotestsum-1.8.2/testjson/internal/000077500000000000000000000000001427475276200172615ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/badmain/000077500000000000000000000000001427475276200206545ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/badmain/main_test.go000066400000000000000000000003221427475276200231630ustar00rootroot00000000000000// +build stubpkg /*Package badmain fails in TestMain */ package badmain import ( "fmt" "os" "testing" ) func TestMain(m *testing.M) { fmt.Fprintln(os.Stderr, "sometimes main can exit 2") os.Exit(2) } gotestsum-1.8.2/testjson/internal/broken/000077500000000000000000000000001427475276200205415ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/broken/broken.go000066400000000000000000000001231427475276200223440ustar00rootroot00000000000000// +build stubpkg package broken var missingImport = somepackage.Foo() // nolint gotestsum-1.8.2/testjson/internal/empty/000077500000000000000000000000001427475276200204175ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/empty/empty.go000066400000000000000000000000641427475276200221040ustar00rootroot00000000000000//go:build stubpkg // +build stubpkg package empty gotestsum-1.8.2/testjson/internal/empty/empty_test.go000066400000000000000000000000641427475276200231430ustar00rootroot00000000000000//go:build stubpkg // +build stubpkg package empty gotestsum-1.8.2/testjson/internal/frenzy/000077500000000000000000000000001427475276200205765ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/frenzy/frenzy_test.go000066400000000000000000000004641427475276200235050ustar00rootroot00000000000000// +build stubpkg,panic package frenzy import ( "fmt" "testing" ) func TestPassed(t *testing.T) {} func TestPassedWithLog(t *testing.T) { t.Log("this is a log") } func TestPassedWithStdout(t *testing.T) { fmt.Println("this is a Print") } func TestPanics(t *testing.T) { panic("this is a panic") } gotestsum-1.8.2/testjson/internal/good/000077500000000000000000000000001427475276200202115ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/good/good_test.go000066400000000000000000000016151427475276200225320ustar00rootroot00000000000000// +build stubpkg package good import ( "fmt" "os" "testing" "time" ) func TestPassed(t *testing.T) {} func TestPassedWithLog(t *testing.T) { t.Log("this is a log") } func TestPassedWithStdout(t *testing.T) { fmt.Println("this is a Print") } func TestSkipped(t *testing.T) { t.Skip() } func TestSkippedWitLog(t *testing.T) { t.Skip("the skip message") } func TestWithStderr(t *testing.T) { fmt.Fprintln(os.Stderr, "this is stderr") } func TestParallelTheFirst(t *testing.T) { t.Parallel() time.Sleep(10 * time.Millisecond) } func TestParallelTheSecond(t *testing.T) { t.Parallel() time.Sleep(6 * time.Millisecond) } func TestParallelTheThird(t *testing.T) { t.Parallel() time.Sleep(2 * time.Millisecond) } func TestNestedSuccess(t *testing.T) { for _, name := range []string{"a", "b", "c", "d"} { t.Run(name, func(t *testing.T) { t.Run("sub", func(t *testing.T) {}) }) } } gotestsum-1.8.2/testjson/internal/parallelfails/000077500000000000000000000000001427475276200220745ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/parallelfails/fails_test.go000066400000000000000000000016251427475276200245640ustar00rootroot00000000000000// +build stubpkg package fails import ( "fmt" "os" "testing" "time" ) func TestPassed(t *testing.T) {} func TestPassedWithLog(t *testing.T) { t.Log("this is a log") } func TestPassedWithStdout(t *testing.T) { fmt.Println("this is a Print") } func TestWithStderr(t *testing.T) { fmt.Fprintln(os.Stderr, "this is stderr") } func TestParallelTheFirst(t *testing.T) { t.Parallel() time.Sleep(10 * time.Millisecond) t.Fatal("failed the first") } func TestParallelTheSecond(t *testing.T) { t.Parallel() time.Sleep(6 * time.Millisecond) t.Fatal("failed the second") } func TestParallelTheThird(t *testing.T) { t.Parallel() time.Sleep(2 * time.Millisecond) t.Fatal("failed the third") } func TestNestedParallelFailures(t *testing.T) { for _, name := range []string{"a", "b", "c", "d"} { name := name t.Run(name, func(t *testing.T) { t.Parallel() t.Fatal("failed sub " + name) }) } } gotestsum-1.8.2/testjson/internal/withfails/000077500000000000000000000000001427475276200212535ustar00rootroot00000000000000gotestsum-1.8.2/testjson/internal/withfails/fails_test.go000066400000000000000000000026201427475276200237370ustar00rootroot00000000000000// +build stubpkg /*Package withfails is used to generate testdata for the testjson package. */ package withfails import ( "fmt" "os" "strings" "testing" "time" ) func TestPassed(t *testing.T) {} func TestPassedWithLog(t *testing.T) { t.Log("this is a log") } func TestPassedWithStdout(t *testing.T) { fmt.Println("this is a Print") } func TestSkipped(t *testing.T) { t.Skip() } func TestSkippedWitLog(t *testing.T) { t.Skip("the skip message") } func TestFailed(t *testing.T) { t.Fatal("this failed") } func TestWithStderr(t *testing.T) { fmt.Fprintln(os.Stderr, "this is stderr") } func TestFailedWithStderr(t *testing.T) { fmt.Fprintln(os.Stderr, "this is stderr") t.Fatal("also failed") } func TestParallelTheFirst(t *testing.T) { t.Parallel() time.Sleep(10 * time.Millisecond) } func TestParallelTheSecond(t *testing.T) { t.Parallel() time.Sleep(6 * time.Millisecond) } func TestParallelTheThird(t *testing.T) { t.Parallel() time.Sleep(2 * time.Millisecond) } func TestNestedWithFailure(t *testing.T) { for _, name := range []string{"a", "b", "c", "d"} { t.Run(name, func(t *testing.T) { if strings.HasSuffix(t.Name(), "c") { t.Fatal("failed") } t.Run("sub", func(t *testing.T) {}) }) } } func TestNestedSuccess(t *testing.T) { for _, name := range []string{"a", "b", "c", "d"} { t.Run(name, func(t *testing.T) { t.Run("sub", func(t *testing.T) {}) }) } } gotestsum-1.8.2/testjson/internal/withfails/timeout_test.go000066400000000000000000000003171427475276200243300ustar00rootroot00000000000000// +build stubpkg package withfails import ( "os" "testing" "time" ) func TestTimeout(t *testing.T) { if os.Getenv("TEST_ALL") != "true" { t.Skip("skipping slow test") } time.Sleep(time.Minute) } gotestsum-1.8.2/testjson/pkgpathprefix.go000066400000000000000000000057641427475276200206640ustar00rootroot00000000000000package testjson import ( "bytes" "go/build" "io/ioutil" "os" "path/filepath" "runtime" "strconv" "strings" ) // RelativePackagePath attempts to remove a common prefix from a package path. // The common prefix is determined either by looking at the GOPATH or reading // the package value from go.mod file. // If the pkgpath does not match the common prefix it will be returned // unmodified. // If the pkgpath matches the common prefix exactly then '.' will be returned. func RelativePackagePath(pkgpath string) string { if pkgpath == pkgPathPrefix { return "." } return strings.TrimPrefix(pkgpath, pkgPathPrefix+"/") } func getPkgPathPrefix() string { cwd, _ := os.Getwd() if isGoModuleEnabled() { prefix := getPkgPathPrefixFromGoModule(cwd) if prefix != "" { return prefix } } return getPkgPathPrefixGoPath(cwd) } func isGoModuleEnabled() bool { version := runtime.Version() if strings.HasPrefix(version, "go1.10") { return false } // Go modules may not be enabled if env var is unset, or set to auto, however // we can always fall back to using GOPATH as the prefix if a go.mod is not // found. return os.Getenv("GO111MODULE") != "off" } // TODO: might not work on windows func getPkgPathPrefixGoPath(cwd string) string { gopaths := strings.Split(build.Default.GOPATH, string(filepath.ListSeparator)) for _, gopath := range gopaths { gosrcpath := gopath + "/src/" if strings.HasPrefix(cwd, gosrcpath) { return strings.TrimPrefix(cwd, gosrcpath) } } return "" } func getPkgPathPrefixFromGoModule(cwd string) string { filename := goModuleFilePath(cwd) if filename == "" { return "" } raw, err := ioutil.ReadFile(filename) if err != nil { // TODO: log.Warn return "" } return pkgPathFromGoModuleFile(raw) } var ( slashSlash = []byte("//") moduleStr = []byte("module") ) // Copy of ModulePath from golang.org/src/cmd/go/internal/modfile/read.go func pkgPathFromGoModuleFile(mod []byte) string { for len(mod) > 0 { line := mod mod = nil if i := bytes.IndexByte(line, '\n'); i >= 0 { line, mod = line[:i], line[i+1:] } if i := bytes.Index(line, slashSlash); i >= 0 { line = line[:i] } line = bytes.TrimSpace(line) if !bytes.HasPrefix(line, moduleStr) { continue } line = line[len(moduleStr):] n := len(line) line = bytes.TrimSpace(line) if len(line) == n || len(line) == 0 { continue } if line[0] == '"' || line[0] == '`' { p, err := strconv.Unquote(string(line)) if err != nil { return "" // malformed quoted string or multi-line module path } return p } return string(line) } return "" // missing module path } // A rough re-implementation of FindModuleRoot from // golang.org/src/cmd/go/internal/modload/init.go func goModuleFilePath(cwd string) string { dir := filepath.Clean(cwd) for { path := filepath.Join(dir, "go.mod") if _, err := os.Stat(path); err == nil { return path } parent := filepath.Dir(dir) if parent == dir { return "" } dir = parent } } var pkgPathPrefix = getPkgPathPrefix() gotestsum-1.8.2/testjson/pkgpathprefix_test.go000066400000000000000000000013421427475276200217070ustar00rootroot00000000000000package testjson import ( "testing" "gotest.tools/v3/assert" "gotest.tools/v3/skip" ) func TestRelativePackagePath(t *testing.T) { prefix := "gotest.tools/gotestsum/testjson" patchPkgPathPrefix(t, prefix) relPath := RelativePackagePath(prefix + "/extra/relpath") assert.Equal(t, relPath, "extra/relpath") relPath = RelativePackagePath(prefix) assert.Equal(t, relPath, ".") } func TestGetPkgPathPrefix(t *testing.T) { t.Run("with go path", func(t *testing.T) { skip.If(t, isGoModuleEnabled()) assert.Equal(t, getPkgPathPrefix(), "gotest.tools/gotestsum/testjson") }) t.Run("with go modules", func(t *testing.T) { skip.If(t, !isGoModuleEnabled()) assert.Equal(t, getPkgPathPrefix(), "gotest.tools/gotestsum") }) } gotestsum-1.8.2/testjson/summary.go000066400000000000000000000132511427475276200174730ustar00rootroot00000000000000package testjson import ( "fmt" "io" "strings" "time" "unicode" "unicode/utf8" "github.com/fatih/color" ) // Summary enumerates the sections which can be printed by PrintSummary type Summary int // nolint: golint const ( SummarizeNone Summary = 0 SummarizeSkipped Summary = (1 << iota) / 2 SummarizeFailed SummarizeErrors SummarizeOutput SummarizeAll = SummarizeSkipped | SummarizeFailed | SummarizeErrors | SummarizeOutput ) var summaryValues = map[Summary]string{ SummarizeSkipped: "skipped", SummarizeFailed: "failed", SummarizeErrors: "errors", SummarizeOutput: "output", } var summaryFromValue = map[string]Summary{ "none": SummarizeNone, "skipped": SummarizeSkipped, "failed": SummarizeFailed, "errors": SummarizeErrors, "output": SummarizeOutput, "all": SummarizeAll, } func (s Summary) String() string { if s == SummarizeNone { return "none" } var result []string for v := Summary(1); v <= s; v <<= 1 { if s.Includes(v) { result = append(result, summaryValues[v]) } } return strings.Join(result, ",") } // Includes returns true if Summary includes all the values set by other. func (s Summary) Includes(other Summary) bool { return s&other == other } // NewSummary returns a new Summary from a string value. If the string does not // match any known values returns false for the second value. func NewSummary(value string) (Summary, bool) { s, ok := summaryFromValue[value] return s, ok } // PrintSummary of a test Execution. Prints a section for each summary type // followed by a DONE line to out. func PrintSummary(out io.Writer, execution *Execution, opts Summary) { execSummary := newExecSummary(execution, opts) if opts.Includes(SummarizeSkipped) { writeTestCaseSummary(out, execSummary, formatSkipped()) } if opts.Includes(SummarizeFailed) { writeTestCaseSummary(out, execSummary, formatFailed()) } errors := execution.Errors() if opts.Includes(SummarizeErrors) { writeErrorSummary(out, errors) } fmt.Fprintf(out, "\n%s %d tests%s%s%s in %s\n", formatExecStatus(execution), execution.Total(), formatTestCount(len(execution.Skipped()), "skipped", ""), formatTestCount(len(execution.Failed()), "failure", "s"), formatTestCount(countErrors(errors), "error", "s"), FormatDurationAsSeconds(execution.Elapsed(), 3)) } func formatTestCount(count int, category string, pluralize string) string { switch count { case 0: return "" case 1: default: category += pluralize } return fmt.Sprintf(", %d %s", count, category) } func formatExecStatus(exec *Execution) string { if !exec.done { return "" } var runs string if exec.lastRunID > 0 { runs = fmt.Sprintf(" %d runs,", exec.lastRunID+1) } return "DONE" + runs } // FormatDurationAsSeconds formats a time.Duration as a float with an s suffix. func FormatDurationAsSeconds(d time.Duration, precision int) string { if d == neverFinished { return "unknown" } return fmt.Sprintf("%.[2]*[1]fs", d.Seconds(), precision) } func writeErrorSummary(out io.Writer, errors []string) { if len(errors) > 0 { fmt.Fprintln(out, color.MagentaString("\n=== Errors")) } for _, err := range errors { fmt.Fprintln(out, err) } } // countErrors in stderr lines. Build errors may include multiple lines where // subsequent lines are indented. // FIXME: Panics will include multiple lines, and are still overcounted. func countErrors(errors []string) int { var count int for _, line := range errors { r, _ := utf8.DecodeRuneInString(line) if !unicode.IsSpace(r) { count++ } } return count } type executionSummary interface { Failed() []TestCase Skipped() []TestCase OutputLines(TestCase) []string } type noOutputSummary struct { *Execution } func (s *noOutputSummary) OutputLines(_ TestCase) []string { return nil } func newExecSummary(execution *Execution, opts Summary) executionSummary { if opts.Includes(SummarizeOutput) { return execution } return &noOutputSummary{Execution: execution} } func writeTestCaseSummary(out io.Writer, execution executionSummary, conf testCaseFormatConfig) { testCases := conf.getter(execution) if len(testCases) == 0 { return } fmt.Fprintln(out, "\n=== "+conf.header) for idx, tc := range testCases { fmt.Fprintf(out, "=== %s: %s %s%s (%s)\n", conf.prefix, RelativePackagePath(tc.Package), tc.Test, formatRunID(tc.RunID), FormatDurationAsSeconds(tc.Elapsed, 2)) for _, line := range execution.OutputLines(tc) { if isFramingLine(line) || conf.filter(tc.Test.Name(), line) { continue } fmt.Fprint(out, line) } if _, isNoOutput := execution.(*noOutputSummary); !isNoOutput && idx+1 != len(testCases) { fmt.Fprintln(out) } } } type testCaseFormatConfig struct { header string prefix string filter func(testName string, line string) bool getter func(executionSummary) []TestCase } func formatFailed() testCaseFormatConfig { withColor := color.RedString return testCaseFormatConfig{ header: withColor("Failed"), prefix: withColor("FAIL"), filter: func(testName string, line string) bool { return strings.HasPrefix(line, "--- FAIL: "+testName+" ") }, getter: func(execution executionSummary) []TestCase { return execution.Failed() }, } } func formatSkipped() testCaseFormatConfig { withColor := color.YellowString return testCaseFormatConfig{ header: withColor("Skipped"), prefix: withColor("SKIP"), filter: func(testName string, line string) bool { return strings.HasPrefix(line, "--- SKIP: "+testName+" ") }, getter: func(execution executionSummary) []TestCase { return execution.Skipped() }, } } func isFramingLine(line string) bool { return strings.HasPrefix(line, "=== RUN Test") || strings.HasPrefix(line, "=== PAUSE Test") || strings.HasPrefix(line, "=== CONT Test") } gotestsum-1.8.2/testjson/summary_test.go000066400000000000000000000165421427475276200205400ustar00rootroot00000000000000package testjson import ( "bytes" "io" "strings" "testing" "time" "gotest.tools/v3/assert" "gotest.tools/v3/golden" ) func TestSummary_String(t *testing.T) { var testcases = []struct { name string summary Summary expected string }{ { name: "none", summary: SummarizeNone, expected: "none", }, { name: "all", summary: SummarizeAll, expected: "skipped,failed,errors,output", }, { name: "one value", summary: SummarizeErrors, expected: "errors", }, { name: "a few values", summary: SummarizeOutput | SummarizeSkipped | SummarizeErrors, expected: "skipped,errors,output", }, } for _, tc := range testcases { t.Run(tc.name, func(t *testing.T) { assert.Equal(t, tc.summary.String(), tc.expected) }) } } func TestPrintSummary_NoFailures(t *testing.T) { patchTimeNow(t) out := new(bytes.Buffer) start := time.Now() exec := &Execution{ started: start, done: true, packages: map[string]*Package{ "foo": {Total: 12}, "other": {Total: 1}, }, } timeNow = func() time.Time { return start.Add(34123111 * time.Microsecond) } PrintSummary(out, exec, SummarizeAll) expected := "\nDONE 13 tests in 34.123s\n" assert.Equal(t, out.String(), expected) } func TestPrintSummary_WithFailures(t *testing.T) { patchPkgPathPrefix(t, "example.com") patchTimeNow(t) start := time.Now() exec := &Execution{ started: start, done: true, packages: map[string]*Package{ "example.com/project/fs": { Total: 12, Failed: []TestCase{ { Package: "example.com/project/fs", Test: "TestFileDo", Elapsed: 1411 * time.Millisecond, ID: 1, }, { Package: "example.com/project/fs", Test: "TestFileDoError", Elapsed: 12 * time.Millisecond, ID: 2, }, }, output: map[int][]string{ 1: multiLine(`=== RUN TestFileDo Some stdout/stderr here --- FAIL: TestFileDo (1.41s) do_test.go:33 assertion failed `), 2: multiLine(`=== RUN TestFileDoError --- FAIL: TestFileDoError (0.01s) do_test.go:50 assertion failed: expected nil error, got WHAT! `), 0: multiLine("FAIL\n"), }, action: ActionFail, }, "example.com/project/pkg/more": { Total: 1, Failed: []TestCase{ { Package: "example.com/project/pkg/more", Test: "TestAlbatross", Elapsed: 40 * time.Millisecond, ID: 1, }, }, Skipped: []TestCase{ { Package: "example.com/project/pkg/more", Test: "TestOnlySometimes", Elapsed: 0, ID: 2, }, }, output: map[int][]string{ 1: multiLine(`=== RUN TestAlbatross --- FAIL: TestAlbatross (0.04s) `), 2: multiLine(`=== RUN TestOnlySometimes --- SKIP: TestOnlySometimes (0.00s) good_test.go:27: the skip message `), }, }, "example.com/project/badmain": { action: ActionFail, output: map[int][]string{ 0: multiLine("sometimes main can exit 2\n"), }, }, }, errors: []string{ "pkg/file.go:99:12: missing ',' before newline", }, } timeNow = func() time.Time { return start.Add(34123111 * time.Microsecond) } t.Run("summarize all", func(t *testing.T) { out := new(bytes.Buffer) PrintSummary(out, exec, SummarizeAll) expected := ` === Skipped === SKIP: project/pkg/more TestOnlySometimes (0.00s) good_test.go:27: the skip message === Failed === FAIL: project/badmain (0.00s) sometimes main can exit 2 === FAIL: project/fs TestFileDo (1.41s) Some stdout/stderr here do_test.go:33 assertion failed === FAIL: project/fs TestFileDoError (0.01s) do_test.go:50 assertion failed: expected nil error, got WHAT! === FAIL: project/pkg/more TestAlbatross (0.04s) === Errors pkg/file.go:99:12: missing ',' before newline DONE 13 tests, 1 skipped, 4 failures, 1 error in 34.123s ` assert.Equal(t, out.String(), expected) }) t.Run("summarize no output", func(t *testing.T) { out := new(bytes.Buffer) PrintSummary(out, exec, SummarizeAll-SummarizeOutput) expected := ` === Skipped === SKIP: project/pkg/more TestOnlySometimes (0.00s) === Failed === FAIL: project/badmain (0.00s) === FAIL: project/fs TestFileDo (1.41s) === FAIL: project/fs TestFileDoError (0.01s) === FAIL: project/pkg/more TestAlbatross (0.04s) === Errors pkg/file.go:99:12: missing ',' before newline DONE 13 tests, 1 skipped, 4 failures, 1 error in 34.123s ` assert.Equal(t, out.String(), expected) }) t.Run("summarize only errors", func(t *testing.T) { out := new(bytes.Buffer) PrintSummary(out, exec, SummarizeErrors) expected := ` === Errors pkg/file.go:99:12: missing ',' before newline DONE 13 tests, 1 skipped, 4 failures, 1 error in 34.123s ` assert.Equal(t, out.String(), expected) }) } func patchTimeNow(t *testing.T) { timeNow = func() time.Time { return time.Date(2022, 1, 2, 3, 4, 5, 600, time.UTC) } t.Cleanup(func() { timeNow = time.Now }) } func multiLine(s string) []string { return strings.SplitAfter(s, "\n") } func TestPrintSummary(t *testing.T) { patchTimeNow(t) type testCase struct { name string config func(t *testing.T) ScanConfig expectedOut string expected func(t *testing.T, exec *Execution) } run := func(t *testing.T, tc testCase) { exec, err := ScanTestOutput(tc.config(t)) assert.NilError(t, err) buf := new(bytes.Buffer) PrintSummary(buf, exec, SummarizeAll) golden.Assert(t, buf.String(), tc.expectedOut) if tc.expected != nil { tc.expected(t, exec) } } testCases := []testCase{ { name: "missing test fail event", config: scanConfigFromGolden("input/go-test-json-missing-test-fail.out"), expectedOut: "summary/missing-test-fail-event", expected: func(t *testing.T, exec *Execution) { for name, pkg := range exec.packages { assert.Equal(t, len(pkg.running), 0, "package %v still had tests in running", name) } }, }, { name: "output attributed to wrong test", config: scanConfigFromGolden("input/go-test-json-misattributed.out"), expectedOut: "summary/misattributed-output", }, { name: "with subtest failures", config: scanConfigFromGolden("input/go-test-json.out"), expectedOut: "summary/root-test-has-subtest-failures", }, { name: "with parallel failures", config: scanConfigFromGolden("input/go-test-json-with-parallel-fails.out"), expectedOut: "summary/parallel-failures", }, { name: "missing skip message", config: scanConfigFromGolden("input/go-test-json-missing-skip-msg.out"), expectedOut: "summary/bug-missing-skip-message", }, { name: "repeated test case", config: func(t *testing.T) ScanConfig { in := golden.Get(t, "input/go-test-json.out") return ScanConfig{ Stdout: io.MultiReader( bytes.NewReader(in), bytes.NewReader(in), bytes.NewReader(in)), } }, expectedOut: "summary/bug-repeated-test-case-output", }, { name: "with rerun id", config: func(t *testing.T) ScanConfig { return ScanConfig{ Stdout: bytes.NewReader(golden.Get(t, "input/go-test-json.out")), RunID: 7, } }, expectedOut: "summary/with-run-id", }, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { run(t, tc) }) } } func scanConfigFromGolden(filename string) func(t *testing.T) ScanConfig { return func(t *testing.T) ScanConfig { return ScanConfig{Stdout: bytes.NewReader(golden.Get(t, filename))} } } gotestsum-1.8.2/testjson/testdata/000077500000000000000000000000001427475276200172565ustar00rootroot00000000000000gotestsum-1.8.2/testjson/testdata/format/000077500000000000000000000000001427475276200205465ustar00rootroot00000000000000gotestsum-1.8.2/testjson/testdata/format/dots-v1.out000066400000000000000000000003351427475276200225750ustar00rootroot00000000000000[testjson/internal/good]···↷↷·············[testjson/internal/parallelfails]····✖✖✖✖✖✖✖✖[testjson/internal/withfails]···↷↷✖·✖····✖··✖·········↷···gotestsum-1.8.2/testjson/testdata/format/dots-v2.out000066400000000000000000001336651427475276200226130ustar00rootroot00000000000000 1ms testjson/internal/badmain 0 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 0 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good 1 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good · 1 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good · 2 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ·· 2 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ·· 3 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ··· 3 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ··· 4 tests, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷ 4 tests, 1 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷ 5 tests, 1 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷ 5 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷ 6 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 6 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 7 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 7 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 8 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 8 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 9 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 9 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 10 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 11 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 12 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 13 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 14 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 15 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 16 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 17 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷·· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷··· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷···· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷····· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷······ 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷······· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷········ 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷········· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷·········· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷·········· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷··········· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷··········· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷··········· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷············ 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty testjson/internal/good ···↷↷············· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 18 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails 19 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails · 19 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails · 20 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ·· 20 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ·· 21 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ··· 21 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ··· 22 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 22 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 23 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 23 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 24 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 24 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 25 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 25 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 26 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 27 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 27 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 28 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 28 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 29 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 29 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 30 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 30 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 30 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 30 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 30 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ···· 30 tests, 2 skipped, 1 failure, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖ 30 tests, 2 skipped, 2 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖ 30 tests, 2 skipped, 3 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖ 30 tests, 2 skipped, 4 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖ 30 tests, 2 skipped, 5 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖✖ 30 tests, 2 skipped, 6 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖✖ 30 tests, 2 skipped, 6 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖✖✖ 30 tests, 2 skipped, 7 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖✖✖ 30 tests, 2 skipped, 7 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖✖✖✖ 30 tests, 2 skipped, 8 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖✖✖✖ 30 tests, 2 skipped, 8 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ 30 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ 30 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails 31 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails · 31 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails · 32 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ·· 32 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ·· 33 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ··· 33 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ··· 34 tests, 2 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷ 34 tests, 3 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷ 35 tests, 3 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷ 35 tests, 4 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷ 36 tests, 4 skipped, 9 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖ 36 tests, 4 skipped, 10 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖ 37 tests, 4 skipped, 10 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖· 37 tests, 4 skipped, 10 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖· 38 tests, 4 skipped, 10 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 38 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 39 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 39 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 40 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 40 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 41 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 41 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 42 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 43 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 44 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 45 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 46 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 47 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 48 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖ 49 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖· 49 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖·· 49 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖··· 49 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖···· 49 tests, 4 skipped, 11 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖ 49 tests, 4 skipped, 12 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖· 49 tests, 4 skipped, 12 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖·· 49 tests, 4 skipped, 12 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 49 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 50 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 51 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 52 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 53 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 54 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 55 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 56 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 57 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖ 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖· 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·· 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖··· 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖···· 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖····· 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖······ 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖······· 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖········ 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖········· 58 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖········· 59 tests, 4 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷ 59 tests, 5 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷ 59 tests, 5 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷· 59 tests, 5 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷· 59 tests, 5 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷·· 59 tests, 5 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷·· 59 tests, 5 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷··· 59 tests, 5 skipped, 13 failures, 1 error  1ms testjson/internal/badmain 🖴 testjson/internal/empty 🖴 testjson/internal/good ···↷↷············· 20ms testjson/internal/parallelfails ····✖✖✖✖✖✖✖✖ 20ms testjson/internal/withfails ···↷↷✖·✖····✖··✖·········↷··· 59 tests, 5 skipped, 13 failures, 1 error gotestsum-1.8.2/testjson/testdata/format/pkgname-coverage.out000066400000000000000000000003071427475276200245120ustar00rootroot00000000000000✖ gotestsum/testjson/internal/badmain (1ms) ✓ gotestsum/testjson/internal/good (12ms) (coverage: 0.0% of statements) ✖ gotestsum/testjson/internal/stub (11ms) (coverage: 0.0% of statements) gotestsum-1.8.2/testjson/testdata/format/pkgname-shuffle.out000066400000000000000000000003121427475276200243470ustar00rootroot00000000000000✖ testjson/internal/badmain (1ms) ✓ testjson/internal/good (20ms) ✖ testjson/internal/parallelfails (21ms) (-test.shuffle 123456) ✖ testjson/internal/withfails (20ms) (-test.shuffle 123456) gotestsum-1.8.2/testjson/testdata/format/pkgname.out000066400000000000000000000003041427475276200227160ustar00rootroot00000000000000✖ testjson/internal/badmain (1ms) ∅ testjson/internal/empty (cached) ✓ testjson/internal/good (cached) ✖ testjson/internal/parallelfails (20ms) ✖ testjson/internal/withfails (20ms) gotestsum-1.8.2/testjson/testdata/format/standard-quiet-coverage.out000066400000000000000000000003551427475276200260200ustar00rootroot00000000000000sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s ok gotest.tools/gotestsum/testjson/internal/good 0.011s coverage: 0.0% of statements FAIL FAIL gotest.tools/gotestsum/testjson/internal/stub 0.011s gotestsum-1.8.2/testjson/testdata/format/standard-quiet-shuffle.out000066400000000000000000000005341427475276200256600ustar00rootroot00000000000000sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s -test.shuffle 123456 ok gotest.tools/gotestsum/testjson/internal/good 0.020s -test.shuffle 123456 FAIL FAIL gotest.tools/gotestsum/testjson/internal/parallelfails 0.020s -test.shuffle 123456 FAIL FAIL gotest.tools/gotestsum/testjson/internal/withfails 0.020s gotestsum-1.8.2/testjson/testdata/format/standard-quiet.out000066400000000000000000000005561427475276200242320ustar00rootroot00000000000000sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s ok gotest.tools/gotestsum/testjson/internal/empty (cached) [no tests to run] ok gotest.tools/gotestsum/testjson/internal/good (cached) FAIL FAIL gotest.tools/gotestsum/testjson/internal/parallelfails 0.020s FAIL FAIL gotest.tools/gotestsum/testjson/internal/withfails 0.020s gotestsum-1.8.2/testjson/testdata/format/standard-verbose-coverage.out000066400000000000000000000103711427475276200263350ustar00rootroot00000000000000sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestPassedWithLog --- PASS: TestPassedWithLog (0.00s) good_test.go:15: this is a log === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestSkipped --- SKIP: TestSkipped (0.00s) good_test.go:23: === RUN TestSkippedWitLog --- SKIP: TestSkippedWitLog (0.00s) good_test.go:27: the skip message === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestNestedSuccess === RUN TestNestedSuccess/a === RUN TestNestedSuccess/a/sub === RUN TestNestedSuccess/b === RUN TestNestedSuccess/b/sub === RUN TestNestedSuccess/c === RUN TestNestedSuccess/c/sub === RUN TestNestedSuccess/d === RUN TestNestedSuccess/d/sub --- PASS: TestNestedSuccess (0.00s) --- PASS: TestNestedSuccess/a (0.00s) --- PASS: TestNestedSuccess/a/sub (0.00s) --- PASS: TestNestedSuccess/b (0.00s) --- PASS: TestNestedSuccess/b/sub (0.00s) --- PASS: TestNestedSuccess/c (0.00s) --- PASS: TestNestedSuccess/c/sub (0.00s) --- PASS: TestNestedSuccess/d (0.00s) --- PASS: TestNestedSuccess/d/sub (0.00s) === CONT TestParallelTheFirst === CONT TestParallelTheThird === CONT TestParallelTheSecond --- PASS: TestParallelTheThird (0.00s) --- PASS: TestParallelTheSecond (0.01s) --- PASS: TestParallelTheFirst (0.01s) PASS coverage: 0.0% of statements ok gotest.tools/gotestsum/testjson/internal/good 0.011s coverage: 0.0% of statements === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestPassedWithLog --- PASS: TestPassedWithLog (0.00s) stub_test.go:18: this is a log === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestSkipped --- SKIP: TestSkipped (0.00s) stub_test.go:26: === RUN TestSkippedWitLog --- SKIP: TestSkippedWitLog (0.00s) stub_test.go:30: the skip message === RUN TestFailed --- FAIL: TestFailed (0.00s) stub_test.go:34: this failed === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === RUN TestFailedWithStderr this is stderr --- FAIL: TestFailedWithStderr (0.00s) stub_test.go:43: also failed === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestNestedWithFailure === RUN TestNestedWithFailure/a === RUN TestNestedWithFailure/a/sub === RUN TestNestedWithFailure/b === RUN TestNestedWithFailure/b/sub === RUN TestNestedWithFailure/c === RUN TestNestedWithFailure/d === RUN TestNestedWithFailure/d/sub --- FAIL: TestNestedWithFailure (0.00s) --- PASS: TestNestedWithFailure/a (0.00s) --- PASS: TestNestedWithFailure/a/sub (0.00s) --- PASS: TestNestedWithFailure/b (0.00s) --- PASS: TestNestedWithFailure/b/sub (0.00s) --- FAIL: TestNestedWithFailure/c (0.00s) stub_test.go:65: failed --- PASS: TestNestedWithFailure/d (0.00s) --- PASS: TestNestedWithFailure/d/sub (0.00s) === RUN TestNestedSuccess === RUN TestNestedSuccess/a === RUN TestNestedSuccess/a/sub === RUN TestNestedSuccess/b === RUN TestNestedSuccess/b/sub === RUN TestNestedSuccess/c === RUN TestNestedSuccess/c/sub === RUN TestNestedSuccess/d === RUN TestNestedSuccess/d/sub --- PASS: TestNestedSuccess (0.00s) --- PASS: TestNestedSuccess/a (0.00s) --- PASS: TestNestedSuccess/a/sub (0.00s) --- PASS: TestNestedSuccess/b (0.00s) --- PASS: TestNestedSuccess/b/sub (0.00s) --- PASS: TestNestedSuccess/c (0.00s) --- PASS: TestNestedSuccess/c/sub (0.00s) --- PASS: TestNestedSuccess/d (0.00s) --- PASS: TestNestedSuccess/d/sub (0.00s) === CONT TestParallelTheFirst === CONT TestParallelTheThird === CONT TestParallelTheSecond --- PASS: TestParallelTheThird (0.00s) --- PASS: TestParallelTheSecond (0.01s) --- PASS: TestParallelTheFirst (0.01s) FAIL coverage: 0.0% of statements FAIL gotest.tools/gotestsum/testjson/internal/stub 0.011s gotestsum-1.8.2/testjson/testdata/format/standard-verbose-shuffle.out000066400000000000000000000141101427475276200261710ustar00rootroot00000000000000sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s -test.shuffle 123456 === RUN TestPassedWithLog good_test.go:15: this is a log --- PASS: TestPassedWithLog (0.00s) === RUN TestSkippedWitLog good_test.go:27: the skip message --- SKIP: TestSkippedWitLog (0.00s) === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestNestedSuccess === RUN TestNestedSuccess/a === RUN TestNestedSuccess/a/sub === RUN TestNestedSuccess/b === RUN TestNestedSuccess/b/sub === RUN TestNestedSuccess/c === RUN TestNestedSuccess/c/sub === RUN TestNestedSuccess/d === RUN TestNestedSuccess/d/sub --- PASS: TestNestedSuccess (0.00s) --- PASS: TestNestedSuccess/a (0.00s) --- PASS: TestNestedSuccess/a/sub (0.00s) --- PASS: TestNestedSuccess/b (0.00s) --- PASS: TestNestedSuccess/b/sub (0.00s) --- PASS: TestNestedSuccess/c (0.00s) --- PASS: TestNestedSuccess/c/sub (0.00s) --- PASS: TestNestedSuccess/d (0.00s) --- PASS: TestNestedSuccess/d/sub (0.00s) === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === RUN TestSkipped good_test.go:23: --- SKIP: TestSkipped (0.00s) === CONT TestParallelTheSecond --- PASS: TestParallelTheSecond (0.01s) === CONT TestParallelTheFirst --- PASS: TestParallelTheFirst (0.01s) === CONT TestParallelTheThird --- PASS: TestParallelTheThird (0.00s) PASS ok gotest.tools/gotestsum/testjson/internal/good 0.020s -test.shuffle 123456 === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestPassedWithLog fails_test.go:15: this is a log --- PASS: TestPassedWithLog (0.00s) === RUN TestNestedParallelFailures === RUN TestNestedParallelFailures/a === PAUSE TestNestedParallelFailures/a === RUN TestNestedParallelFailures/b === PAUSE TestNestedParallelFailures/b === RUN TestNestedParallelFailures/c === PAUSE TestNestedParallelFailures/c === RUN TestNestedParallelFailures/d === PAUSE TestNestedParallelFailures/d === CONT TestNestedParallelFailures/a fails_test.go:50: failed sub a === CONT TestNestedParallelFailures/d fails_test.go:50: failed sub d === CONT TestNestedParallelFailures/c fails_test.go:50: failed sub c === CONT TestNestedParallelFailures/b fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures (0.00s) --- FAIL: TestNestedParallelFailures/a (0.00s) --- FAIL: TestNestedParallelFailures/d (0.00s) --- FAIL: TestNestedParallelFailures/c (0.00s) --- FAIL: TestNestedParallelFailures/b (0.00s) === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === CONT TestParallelTheSecond fails_test.go:35: failed the second --- FAIL: TestParallelTheSecond (0.01s) === CONT TestParallelTheFirst fails_test.go:29: failed the first --- FAIL: TestParallelTheFirst (0.01s) === CONT TestParallelTheThird fails_test.go:41: failed the third --- FAIL: TestParallelTheThird (0.00s) FAIL FAIL gotest.tools/gotestsum/testjson/internal/parallelfails 0.020s -test.shuffle 123456 === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestSkipped fails_test.go:26: --- SKIP: TestSkipped (0.00s) === RUN TestNestedWithFailure === RUN TestNestedWithFailure/a === RUN TestNestedWithFailure/a/sub === RUN TestNestedWithFailure/b === RUN TestNestedWithFailure/b/sub === RUN TestNestedWithFailure/c fails_test.go:65: failed === RUN TestNestedWithFailure/d === RUN TestNestedWithFailure/d/sub --- FAIL: TestNestedWithFailure (0.00s) --- PASS: TestNestedWithFailure/a (0.00s) --- PASS: TestNestedWithFailure/a/sub (0.00s) --- PASS: TestNestedWithFailure/b (0.00s) --- PASS: TestNestedWithFailure/b/sub (0.00s) --- FAIL: TestNestedWithFailure/c (0.00s) --- PASS: TestNestedWithFailure/d (0.00s) --- PASS: TestNestedWithFailure/d/sub (0.00s) === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestSkippedWitLog fails_test.go:30: the skip message --- SKIP: TestSkippedWitLog (0.00s) === RUN TestNestedSuccess === RUN TestNestedSuccess/a === RUN TestNestedSuccess/a/sub === RUN TestNestedSuccess/b === RUN TestNestedSuccess/b/sub === RUN TestNestedSuccess/c === RUN TestNestedSuccess/c/sub === RUN TestNestedSuccess/d === RUN TestNestedSuccess/d/sub --- PASS: TestNestedSuccess (0.00s) --- PASS: TestNestedSuccess/a (0.00s) --- PASS: TestNestedSuccess/a/sub (0.00s) --- PASS: TestNestedSuccess/b (0.00s) --- PASS: TestNestedSuccess/b/sub (0.00s) --- PASS: TestNestedSuccess/c (0.00s) --- PASS: TestNestedSuccess/c/sub (0.00s) --- PASS: TestNestedSuccess/d (0.00s) --- PASS: TestNestedSuccess/d/sub (0.00s) === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestPassedWithLog fails_test.go:18: this is a log --- PASS: TestPassedWithLog (0.00s) === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestTimeout timeout_test.go:13: skipping slow test --- SKIP: TestTimeout (0.00s) === RUN TestFailedWithStderr this is stderr fails_test.go:43: also failed --- FAIL: TestFailedWithStderr (0.00s) === RUN TestFailed fails_test.go:34: this failed --- FAIL: TestFailed (0.00s) === CONT TestParallelTheFirst --- PASS: TestParallelTheFirst (0.01s) === CONT TestParallelTheThird --- PASS: TestParallelTheThird (0.00s) === CONT TestParallelTheSecond --- PASS: TestParallelTheSecond (0.01s) FAIL FAIL gotest.tools/gotestsum/testjson/internal/withfails 0.020s gotestsum-1.8.2/testjson/testdata/format/standard-verbose.out000066400000000000000000000142011427475276200245400ustar00rootroot00000000000000sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s testing: warning: no tests to run PASS ok gotest.tools/gotestsum/testjson/internal/empty (cached) [no tests to run] === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestPassedWithLog good_test.go:15: this is a log --- PASS: TestPassedWithLog (0.00s) === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestSkipped good_test.go:23: --- SKIP: TestSkipped (0.00s) === RUN TestSkippedWitLog good_test.go:27: the skip message --- SKIP: TestSkippedWitLog (0.00s) === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestNestedSuccess === RUN TestNestedSuccess/a === RUN TestNestedSuccess/a/sub === RUN TestNestedSuccess/b === RUN TestNestedSuccess/b/sub === RUN TestNestedSuccess/c === RUN TestNestedSuccess/c/sub === RUN TestNestedSuccess/d === RUN TestNestedSuccess/d/sub --- PASS: TestNestedSuccess (0.00s) --- PASS: TestNestedSuccess/a (0.00s) --- PASS: TestNestedSuccess/a/sub (0.00s) --- PASS: TestNestedSuccess/b (0.00s) --- PASS: TestNestedSuccess/b/sub (0.00s) --- PASS: TestNestedSuccess/c (0.00s) --- PASS: TestNestedSuccess/c/sub (0.00s) --- PASS: TestNestedSuccess/d (0.00s) --- PASS: TestNestedSuccess/d/sub (0.00s) === CONT TestParallelTheFirst --- PASS: TestParallelTheFirst (0.01s) === CONT TestParallelTheThird === CONT TestParallelTheSecond --- PASS: TestParallelTheThird (0.00s) --- PASS: TestParallelTheSecond (0.01s) PASS ok gotest.tools/gotestsum/testjson/internal/good (cached) === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestPassedWithLog fails_test.go:15: this is a log --- PASS: TestPassedWithLog (0.00s) === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestNestedParallelFailures === RUN TestNestedParallelFailures/a === PAUSE TestNestedParallelFailures/a === RUN TestNestedParallelFailures/b === PAUSE TestNestedParallelFailures/b === RUN TestNestedParallelFailures/c === PAUSE TestNestedParallelFailures/c === RUN TestNestedParallelFailures/d === PAUSE TestNestedParallelFailures/d === CONT TestNestedParallelFailures/a fails_test.go:50: failed sub a === CONT TestNestedParallelFailures/d fails_test.go:50: failed sub d === CONT TestNestedParallelFailures/c fails_test.go:50: failed sub c === CONT TestNestedParallelFailures/b fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures (0.00s) --- FAIL: TestNestedParallelFailures/a (0.00s) --- FAIL: TestNestedParallelFailures/d (0.00s) --- FAIL: TestNestedParallelFailures/c (0.00s) --- FAIL: TestNestedParallelFailures/b (0.00s) === CONT TestParallelTheFirst fails_test.go:29: failed the first --- FAIL: TestParallelTheFirst (0.01s) === CONT TestParallelTheThird fails_test.go:41: failed the third --- FAIL: TestParallelTheThird (0.00s) === CONT TestParallelTheSecond fails_test.go:35: failed the second --- FAIL: TestParallelTheSecond (0.01s) FAIL FAIL gotest.tools/gotestsum/testjson/internal/parallelfails 0.020s === RUN TestPassed --- PASS: TestPassed (0.00s) === RUN TestPassedWithLog fails_test.go:18: this is a log --- PASS: TestPassedWithLog (0.00s) === RUN TestPassedWithStdout this is a Print --- PASS: TestPassedWithStdout (0.00s) === RUN TestSkipped fails_test.go:26: --- SKIP: TestSkipped (0.00s) === RUN TestSkippedWitLog fails_test.go:30: the skip message --- SKIP: TestSkippedWitLog (0.00s) === RUN TestFailed fails_test.go:34: this failed --- FAIL: TestFailed (0.00s) === RUN TestWithStderr this is stderr --- PASS: TestWithStderr (0.00s) === RUN TestFailedWithStderr this is stderr fails_test.go:43: also failed --- FAIL: TestFailedWithStderr (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === RUN TestParallelTheThird === PAUSE TestParallelTheThird === RUN TestNestedWithFailure === RUN TestNestedWithFailure/a === RUN TestNestedWithFailure/a/sub === RUN TestNestedWithFailure/b === RUN TestNestedWithFailure/b/sub === RUN TestNestedWithFailure/c fails_test.go:65: failed === RUN TestNestedWithFailure/d === RUN TestNestedWithFailure/d/sub --- FAIL: TestNestedWithFailure (0.00s) --- PASS: TestNestedWithFailure/a (0.00s) --- PASS: TestNestedWithFailure/a/sub (0.00s) --- PASS: TestNestedWithFailure/b (0.00s) --- PASS: TestNestedWithFailure/b/sub (0.00s) --- FAIL: TestNestedWithFailure/c (0.00s) --- PASS: TestNestedWithFailure/d (0.00s) --- PASS: TestNestedWithFailure/d/sub (0.00s) === RUN TestNestedSuccess === RUN TestNestedSuccess/a === RUN TestNestedSuccess/a/sub === RUN TestNestedSuccess/b === RUN TestNestedSuccess/b/sub === RUN TestNestedSuccess/c === RUN TestNestedSuccess/c/sub === RUN TestNestedSuccess/d === RUN TestNestedSuccess/d/sub --- PASS: TestNestedSuccess (0.00s) --- PASS: TestNestedSuccess/a (0.00s) --- PASS: TestNestedSuccess/a/sub (0.00s) --- PASS: TestNestedSuccess/b (0.00s) --- PASS: TestNestedSuccess/b/sub (0.00s) --- PASS: TestNestedSuccess/c (0.00s) --- PASS: TestNestedSuccess/c/sub (0.00s) --- PASS: TestNestedSuccess/d (0.00s) --- PASS: TestNestedSuccess/d/sub (0.00s) === RUN TestTimeout timeout_test.go:13: skipping slow test --- SKIP: TestTimeout (0.00s) === CONT TestParallelTheFirst --- PASS: TestParallelTheFirst (0.01s) === CONT TestParallelTheThird --- PASS: TestParallelTheThird (0.00s) === CONT TestParallelTheSecond --- PASS: TestParallelTheSecond (0.01s) FAIL FAIL gotest.tools/gotestsum/testjson/internal/withfails 0.020s gotestsum-1.8.2/testjson/testdata/format/testname-coverage.out000066400000000000000000000066041427475276200247160ustar00rootroot00000000000000sometimes main can exit 2 FAIL gotestsum/testjson/internal/badmain PASS gotestsum/testjson/internal/good.TestPassed (0.00s) PASS gotestsum/testjson/internal/good.TestPassedWithLog (0.00s) PASS gotestsum/testjson/internal/good.TestPassedWithStdout (0.00s) PASS gotestsum/testjson/internal/good.TestWithStderr (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/a/sub (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/a (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/b/sub (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/b (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/c/sub (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/c (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/d/sub (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess/d (0.00s) PASS gotestsum/testjson/internal/good.TestNestedSuccess (0.00s) PASS gotestsum/testjson/internal/good.TestParallelTheThird (0.00s) PASS gotestsum/testjson/internal/good.TestParallelTheSecond (0.01s) PASS gotestsum/testjson/internal/good.TestParallelTheFirst (0.01s) coverage: 0.0% of statements PASS gotestsum/testjson/internal/good (coverage: 0.0% of statements) PASS gotestsum/testjson/internal/stub.TestPassed (0.00s) PASS gotestsum/testjson/internal/stub.TestPassedWithLog (0.00s) PASS gotestsum/testjson/internal/stub.TestPassedWithStdout (0.00s) === RUN TestFailed --- FAIL: TestFailed (0.00s) stub_test.go:34: this failed FAIL gotestsum/testjson/internal/stub.TestFailed (0.00s) PASS gotestsum/testjson/internal/stub.TestWithStderr (0.00s) === RUN TestFailedWithStderr this is stderr --- FAIL: TestFailedWithStderr (0.00s) stub_test.go:43: also failed FAIL gotestsum/testjson/internal/stub.TestFailedWithStderr (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedWithFailure/a/sub (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedWithFailure/a (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedWithFailure/b/sub (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedWithFailure/b (0.00s) === RUN TestNestedWithFailure/c --- FAIL: TestNestedWithFailure/c (0.00s) stub_test.go:65: failed FAIL gotestsum/testjson/internal/stub.TestNestedWithFailure/c (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedWithFailure/d/sub (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedWithFailure/d (0.00s) === RUN TestNestedWithFailure --- FAIL: TestNestedWithFailure (0.00s) FAIL gotestsum/testjson/internal/stub.TestNestedWithFailure (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/a/sub (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/a (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/b/sub (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/b (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/c/sub (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/c (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/d/sub (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess/d (0.00s) PASS gotestsum/testjson/internal/stub.TestNestedSuccess (0.00s) PASS gotestsum/testjson/internal/stub.TestParallelTheThird (0.00s) PASS gotestsum/testjson/internal/stub.TestParallelTheSecond (0.01s) PASS gotestsum/testjson/internal/stub.TestParallelTheFirst (0.01s) coverage: 0.0% of statements FAIL gotestsum/testjson/internal/stub (coverage: 0.0% of statements) gotestsum-1.8.2/testjson/testdata/format/testname-shuffle.out000066400000000000000000000123231427475276200245520ustar00rootroot00000000000000sometimes main can exit 2 FAIL testjson/internal/badmain PASS testjson/internal/good.TestPassedWithLog (0.00s) PASS testjson/internal/good.TestPassedWithStdout (0.00s) PASS testjson/internal/good.TestPassed (0.00s) PASS testjson/internal/good.TestNestedSuccess/a/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/a (0.00s) PASS testjson/internal/good.TestNestedSuccess/b/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/b (0.00s) PASS testjson/internal/good.TestNestedSuccess/c/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/c (0.00s) PASS testjson/internal/good.TestNestedSuccess/d/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/d (0.00s) PASS testjson/internal/good.TestNestedSuccess (0.00s) PASS testjson/internal/good.TestWithStderr (0.00s) PASS testjson/internal/good.TestParallelTheSecond (0.01s) PASS testjson/internal/good.TestParallelTheFirst (0.01s) PASS testjson/internal/good.TestParallelTheThird (0.00s) PASS testjson/internal/good PASS testjson/internal/parallelfails.TestPassedWithLog (0.00s) === RUN TestNestedParallelFailures/a === PAUSE TestNestedParallelFailures/a === CONT TestNestedParallelFailures/a fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/a (0.00s) === RUN TestNestedParallelFailures/d === PAUSE TestNestedParallelFailures/d === CONT TestNestedParallelFailures/d fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/d (0.00s) === RUN TestNestedParallelFailures/c === PAUSE TestNestedParallelFailures/c === CONT TestNestedParallelFailures/c fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/c (0.00s) === RUN TestNestedParallelFailures/b === PAUSE TestNestedParallelFailures/b === CONT TestNestedParallelFailures/b fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/b (0.00s) === RUN TestNestedParallelFailures --- FAIL: TestNestedParallelFailures (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures (0.00s) PASS testjson/internal/parallelfails.TestPassed (0.00s) PASS testjson/internal/parallelfails.TestPassedWithStdout (0.00s) PASS testjson/internal/parallelfails.TestWithStderr (0.00s) === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === CONT TestParallelTheSecond fails_test.go:35: failed the second --- FAIL: TestParallelTheSecond (0.01s) FAIL testjson/internal/parallelfails.TestParallelTheSecond (0.01s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === CONT TestParallelTheFirst fails_test.go:29: failed the first --- FAIL: TestParallelTheFirst (0.01s) FAIL testjson/internal/parallelfails.TestParallelTheFirst (0.01s) === RUN TestParallelTheThird === PAUSE TestParallelTheThird === CONT TestParallelTheThird fails_test.go:41: failed the third --- FAIL: TestParallelTheThird (0.00s) FAIL testjson/internal/parallelfails.TestParallelTheThird (0.00s) FAIL testjson/internal/parallelfails (-test.shuffle 123456) PASS testjson/internal/withfails.TestPassedWithStdout (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/a/sub (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/a (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/b/sub (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/b (0.00s) === RUN TestNestedWithFailure/c fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) FAIL testjson/internal/withfails.TestNestedWithFailure/c (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/d/sub (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/d (0.00s) === RUN TestNestedWithFailure --- FAIL: TestNestedWithFailure (0.00s) FAIL testjson/internal/withfails.TestNestedWithFailure (0.00s) PASS testjson/internal/withfails.TestWithStderr (0.00s) PASS testjson/internal/withfails.TestPassed (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/a/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/a (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/b/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/b (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/c/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/c (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/d/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/d (0.00s) PASS testjson/internal/withfails.TestNestedSuccess (0.00s) PASS testjson/internal/withfails.TestPassedWithLog (0.00s) === RUN TestFailedWithStderr this is stderr fails_test.go:43: also failed --- FAIL: TestFailedWithStderr (0.00s) FAIL testjson/internal/withfails.TestFailedWithStderr (0.00s) === RUN TestFailed fails_test.go:34: this failed --- FAIL: TestFailed (0.00s) FAIL testjson/internal/withfails.TestFailed (0.00s) PASS testjson/internal/withfails.TestParallelTheFirst (0.01s) PASS testjson/internal/withfails.TestParallelTheThird (0.00s) PASS testjson/internal/withfails.TestParallelTheSecond (0.01s) FAIL testjson/internal/withfails (-test.shuffle 123456) gotestsum-1.8.2/testjson/testdata/format/testname.out000066400000000000000000000123251427475276200231220ustar00rootroot00000000000000sometimes main can exit 2 FAIL testjson/internal/badmain EMPTY testjson/internal/empty (cached) PASS testjson/internal/good.TestPassed (0.00s) PASS testjson/internal/good.TestPassedWithLog (0.00s) PASS testjson/internal/good.TestPassedWithStdout (0.00s) PASS testjson/internal/good.TestWithStderr (0.00s) PASS testjson/internal/good.TestNestedSuccess/a/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/a (0.00s) PASS testjson/internal/good.TestNestedSuccess/b/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/b (0.00s) PASS testjson/internal/good.TestNestedSuccess/c/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/c (0.00s) PASS testjson/internal/good.TestNestedSuccess/d/sub (0.00s) PASS testjson/internal/good.TestNestedSuccess/d (0.00s) PASS testjson/internal/good.TestNestedSuccess (0.00s) PASS testjson/internal/good.TestParallelTheFirst (0.01s) PASS testjson/internal/good.TestParallelTheThird (0.00s) PASS testjson/internal/good.TestParallelTheSecond (0.01s) PASS testjson/internal/good (cached) PASS testjson/internal/parallelfails.TestPassed (0.00s) PASS testjson/internal/parallelfails.TestPassedWithLog (0.00s) PASS testjson/internal/parallelfails.TestPassedWithStdout (0.00s) PASS testjson/internal/parallelfails.TestWithStderr (0.00s) === RUN TestNestedParallelFailures/a === PAUSE TestNestedParallelFailures/a === CONT TestNestedParallelFailures/a fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/a (0.00s) === RUN TestNestedParallelFailures/d === PAUSE TestNestedParallelFailures/d === CONT TestNestedParallelFailures/d fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/d (0.00s) === RUN TestNestedParallelFailures/c === PAUSE TestNestedParallelFailures/c === CONT TestNestedParallelFailures/c fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/c (0.00s) === RUN TestNestedParallelFailures/b === PAUSE TestNestedParallelFailures/b === CONT TestNestedParallelFailures/b fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures/b (0.00s) === RUN TestNestedParallelFailures --- FAIL: TestNestedParallelFailures (0.00s) FAIL testjson/internal/parallelfails.TestNestedParallelFailures (0.00s) === RUN TestParallelTheFirst === PAUSE TestParallelTheFirst === CONT TestParallelTheFirst fails_test.go:29: failed the first --- FAIL: TestParallelTheFirst (0.01s) FAIL testjson/internal/parallelfails.TestParallelTheFirst (0.01s) === RUN TestParallelTheThird === PAUSE TestParallelTheThird === CONT TestParallelTheThird fails_test.go:41: failed the third --- FAIL: TestParallelTheThird (0.00s) FAIL testjson/internal/parallelfails.TestParallelTheThird (0.00s) === RUN TestParallelTheSecond === PAUSE TestParallelTheSecond === CONT TestParallelTheSecond fails_test.go:35: failed the second --- FAIL: TestParallelTheSecond (0.01s) FAIL testjson/internal/parallelfails.TestParallelTheSecond (0.01s) FAIL testjson/internal/parallelfails PASS testjson/internal/withfails.TestPassed (0.00s) PASS testjson/internal/withfails.TestPassedWithLog (0.00s) PASS testjson/internal/withfails.TestPassedWithStdout (0.00s) === RUN TestFailed fails_test.go:34: this failed --- FAIL: TestFailed (0.00s) FAIL testjson/internal/withfails.TestFailed (0.00s) PASS testjson/internal/withfails.TestWithStderr (0.00s) === RUN TestFailedWithStderr this is stderr fails_test.go:43: also failed --- FAIL: TestFailedWithStderr (0.00s) FAIL testjson/internal/withfails.TestFailedWithStderr (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/a/sub (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/a (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/b/sub (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/b (0.00s) === RUN TestNestedWithFailure/c fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) FAIL testjson/internal/withfails.TestNestedWithFailure/c (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/d/sub (0.00s) PASS testjson/internal/withfails.TestNestedWithFailure/d (0.00s) === RUN TestNestedWithFailure --- FAIL: TestNestedWithFailure (0.00s) FAIL testjson/internal/withfails.TestNestedWithFailure (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/a/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/a (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/b/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/b (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/c/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/c (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/d/sub (0.00s) PASS testjson/internal/withfails.TestNestedSuccess/d (0.00s) PASS testjson/internal/withfails.TestNestedSuccess (0.00s) PASS testjson/internal/withfails.TestParallelTheFirst (0.01s) PASS testjson/internal/withfails.TestParallelTheThird (0.00s) PASS testjson/internal/withfails.TestParallelTheSecond (0.01s) FAIL testjson/internal/withfails gotestsum-1.8.2/testjson/testdata/go-test-json-missing-test-events.out000066400000000000000000000120301427475276200262620ustar00rootroot00000000000000{"Time":"2021-04-17T14:33:35.167978423Z","Action":"run","Package":"gotest.tools/testing","Test":"TestPassed"} {"Time":"2021-04-17T14:33:35.167999152Z","Action":"output","Package":"gotest.tools/testing","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2021-04-17T14:33:35.168007043Z","Action":"output","Package":"gotest.tools/testing","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2021-04-17T14:33:35.16801113Z","Action":"pass","Package":"gotest.tools/testing","Test":"TestPassed","Elapsed":0} {"Time":"2021-04-17T14:33:35.167978423Z","Action":"run","Package":"gotest.tools/testing","Test":"TestMissingEvent"} {"Time":"2021-04-17T14:33:35.167999152Z","Action":"output","Package":"gotest.tools/testing","Test":"TestMissingEvent","Output":"=== RUN TestMissingEvent\n"} {"Time":"2021-04-17T14:33:35.168007043Z","Action":"output","Package":"gotest.tools/testing","Test":"TestMissingEvent","Output":"--- PASS: TestMissingEvent (0.00s)\n"} {"Time":"2021-04-17T14:33:35.168147969Z","Action":"run","Package":"gotest.tools/testing","Test":"TestNestedSuccess"} {"Time":"2021-04-17T14:33:35.168150995Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess","Output":"=== RUN TestNestedSuccess\n"} {"Time":"2021-04-17T14:33:35.168155447Z","Action":"run","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a"} {"Time":"2021-04-17T14:33:35.168158403Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a","Output":"=== RUN TestNestedSuccess/a\n"} {"Time":"2021-04-17T14:33:35.168161668Z","Action":"run","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a/sub"} {"Time":"2021-04-17T14:33:35.168164766Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a/sub","Output":"=== RUN TestNestedSuccess/a/sub\n"} {"Time":"2021-04-17T14:33:35.168168123Z","Action":"run","Package":"gotest.tools/testing","Test":"TestNestedSuccess/b"} {"Time":"2021-04-17T14:33:35.168170964Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess/b","Output":"=== RUN TestNestedSuccess/b\n"} {"Time":"2021-04-17T14:33:35.168174253Z","Action":"run","Package":"gotest.tools/testing","Test":"TestNestedSuccess/b/sub"} {"Time":"2021-04-17T14:33:35.168177104Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess/b/sub","Output":"=== RUN TestNestedSuccess/b/sub\n"} {"Time":"2021-04-17T14:33:35.16820637Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess","Output":"--- PASS: TestNestedSuccess (0.00s)\n"} {"Time":"2021-04-17T14:33:35.168210256Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a","Output":" --- PASS: TestNestedSuccess/a (0.00s)\n"} {"Time":"2021-04-17T14:33:35.168213987Z","Action":"output","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a/sub","Output":" --- PASS: TestNestedSuccess/a/sub (0.00s)\n"} {"Time":"2021-04-17T14:33:35.168217438Z","Action":"pass","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a/sub","Elapsed":0} {"Time":"2021-04-17T14:33:35.168222153Z","Action":"pass","Package":"gotest.tools/testing","Test":"TestNestedSuccess/a","Elapsed":0} {"Time":"2021-04-17T14:33:35.16826478Z","Action":"pass","Package":"gotest.tools/testing","Test":"TestNestedSuccess","Elapsed":0} {"Time":"2021-04-17T14:33:35.168147969Z","Action":"run","Package":"gotest.tools/testing","Test":"TestFailed"} {"Time":"2021-04-17T14:33:35.168150995Z","Action":"output","Package":"gotest.tools/testing","Test":"TestFailed","Output":"=== RUN TestFailed\n"} {"Time":"2021-04-17T14:33:35.168155447Z","Action":"run","Package":"gotest.tools/testing","Test":"TestFailed/a"} {"Time":"2021-04-17T14:33:35.168158403Z","Action":"output","Package":"gotest.tools/testing","Test":"TestFailed/a","Output":"=== RUN TestFailed/a\n"} {"Time":"2021-04-17T14:33:35.168161668Z","Action":"run","Package":"gotest.tools/testing","Test":"TestFailed/a/sub"} {"Time":"2021-04-17T14:33:35.168164766Z","Action":"output","Package":"gotest.tools/testing","Test":"TestFailed/a/sub","Output":"=== RUN TestFailed/a/sub\n"} {"Time":"2021-04-17T14:33:35.16826478Z","Action":"fail","Package":"gotest.tools/testing","Test":"TestFailed","Elapsed":0} {"Time":"2021-04-17T14:33:35.168147969Z","Action":"run","Package":"gotest.tools/testing","Test":"TestMissing"} {"Time":"2021-04-17T14:33:35.168150995Z","Action":"output","Package":"gotest.tools/testing","Test":"TestMissing","Output":"=== RUN TestMissing\n"} {"Time":"2021-04-17T14:33:35.168155447Z","Action":"run","Package":"gotest.tools/testing","Test":"TestMissing/a"} {"Time":"2021-04-17T14:33:35.168158403Z","Action":"output","Package":"gotest.tools/testing","Test":"TestMissing/a","Output":"=== RUN TestMissing/a\n"} {"Time":"2021-04-17T14:33:35.168308334Z","Action":"output","Package":"gotest.tools/testing","Output":"PASS\n"} {"Time":"2021-04-17T14:33:35.168311492Z","Action":"output","Package":"gotest.tools/testing","Output":"ok \tgotest.tools/testing\t(cached)\n"} {"Time":"2021-04-17T14:33:35.168316085Z","Action":"pass","Package":"gotest.tools/testing","Elapsed":0}gotestsum-1.8.2/testjson/testdata/go-test-json-with-nonjson-stdout.out000066400000000000000000000022261427475276200263150ustar00rootroot00000000000000{"Time":"2021-05-12T13:53:07.462687619-05:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed"} |||This line is not valid test2json output.||| {"Time":"2021-05-12T13:53:07.46279664-05:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2021-05-12T13:53:07.462812837-05:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2021-05-12T13:53:07.462819251-05:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Elapsed":0} {"Time":"2021-05-12T13:53:07.462825108-05:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"PASS\n"} {"Time":"2021-05-12T13:53:07.462848483-05:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"ok \tgotest.tools/gotestsum/testjson/internal/good\t0.001s\n"} {"Time":"2021-05-12T13:53:07.46309146-05:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Elapsed":0.001} gotestsum-1.8.2/testjson/testdata/go-test.err000066400000000000000000000001511427475276200213470ustar00rootroot00000000000000# gotest.tools/gotestsum/testjson/internal/broken internal/broken/broken.go:5:21: undefined: somepackage gotestsum-1.8.2/testjson/testdata/input/000077500000000000000000000000001427475276200204155ustar00rootroot00000000000000gotestsum-1.8.2/testjson/testdata/input/go-test-json-misattributed.out000066400000000000000000000063641427475276200263660ustar00rootroot00000000000000{"Action":"run","Test":"TestOutputWithSubtest"} {"Action":"output","Test":"TestOutputWithSubtest","Output":"=== RUN TestOutputWithSubtest\n"} {"Action":"run","Test":"TestOutputWithSubtest/sub_test"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test","Output":"=== RUN TestOutputWithSubtest/sub_test\n"} {"Action":"run","Test":"TestOutputWithSubtest/sub_test/sub2"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test/sub2","Output":"=== RUN TestOutputWithSubtest/sub_test/sub2\n"} {"Action":"run","Test":"TestOutputWithSubtest/sub_test2"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2","Output":"=== RUN TestOutputWithSubtest/sub_test2\n"} {"Action":"run","Test":"TestOutputWithSubtest/sub_test2/sub2"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2/sub2","Output":"=== RUN TestOutputWithSubtest/sub_test2/sub2\n"} {"Action":"output","Test":"TestOutputWithSubtest","Output":"--- FAIL: TestOutputWithSubtest (0.00s)\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test","Output":" --- PASS: TestOutputWithSubtest/sub_test (0.00s)\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test","Output":" foo_test.go:9: output from sub test\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test","Output":" foo_test.go:11: more output from sub test\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test","Output":" foo_test.go:16: more output from sub test\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test/sub2","Output":" --- PASS: TestOutputWithSubtest/sub_test/sub2 (0.00s)\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test/sub2","Output":" foo_test.go:14: output from sub2 test\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test/sub2","Output":" foo_test.go:22: output from root test\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test/sub2","Output":" foo_test.go:27: output from root test\n"} {"Action":"pass","Test":"TestOutputWithSubtest/sub_test/sub2"} {"Action":"pass","Test":"TestOutputWithSubtest/sub_test"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2","Output":" --- PASS: TestOutputWithSubtest/sub_test2 (0.00s)\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2","Output":" foo_test.go:21: output from sub test2\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2","Output":" foo_test.go:23: more output from sub test2\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2","Output":" foo_test.go:28: more output from sub test2\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2/sub2","Output":" --- PASS: TestOutputWithSubtest/sub_test2/sub2 (0.00s)\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2/sub2","Output":" foo_test.go:26: output from sub2 test\n"} {"Action":"output","Test":"TestOutputWithSubtest/sub_test2/sub2","Output":" foo_test.go:32: output after sub test\n"} {"Action":"pass","Test":"TestOutputWithSubtest/sub_test2/sub2"} {"Action":"pass","Test":"TestOutputWithSubtest/sub_test2"} {"Action":"fail","Test":"TestOutputWithSubtest"} {"Action":"output","Output":"FAIL\n"} {"Action":"output","Output":"FAIL\tgotest.tools/gotestsum/foo\t0.001s\n"} {"Action":"output","Output":"FAIL\n"} {"Action":"fail"} gotestsum-1.8.2/testjson/testdata/input/go-test-json-missing-skip-msg.out000066400000000000000000000762421427475276200267110ustar00rootroot00000000000000{"Time":"2020-05-17T21:06:45.371590661-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutput_WithDotsFormatter"} {"Time":"2020-05-17T21:06:45.371755428-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutput_WithDotsFormatter","Output":"=== RUN TestScanTestOutput_WithDotsFormatter\n"} {"Time":"2020-05-17T21:06:45.426093306-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutput_WithDotsFormatter","Output":"--- PASS: TestScanTestOutput_WithDotsFormatter (0.05s)\n"} {"Time":"2020-05-17T21:06:45.426124191-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutput_WithDotsFormatter","Elapsed":0.05} {"Time":"2020-05-17T21:06:45.426131287-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed"} {"Time":"2020-05-17T21:06:45.426134719-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed","Output":"=== RUN TestFmtDotElapsed\n"} {"Time":"2020-05-17T21:06:45.42613898-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_999µs_"} {"Time":"2020-05-17T21:06:45.426144034-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_999µs_","Output":"=== RUN TestFmtDotElapsed/_999µs_\n"} {"Time":"2020-05-17T21:06:45.426155975-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/___7ms_"} {"Time":"2020-05-17T21:06:45.426160373-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/___7ms_","Output":"=== RUN TestFmtDotElapsed/___7ms_\n"} {"Time":"2020-05-17T21:06:45.426166742-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____🖴__"} {"Time":"2020-05-17T21:06:45.426170156-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____🖴__","Output":"=== RUN TestFmtDotElapsed/____🖴__\n"} {"Time":"2020-05-17T21:06:45.426189174-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____⏳__"} {"Time":"2020-05-17T21:06:45.426212792-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____⏳__","Output":"=== RUN TestFmtDotElapsed/____⏳__\n"} {"Time":"2020-05-17T21:06:45.426227048-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/__14ms_"} {"Time":"2020-05-17T21:06:45.426234018-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/__14ms_","Output":"=== RUN TestFmtDotElapsed/__14ms_\n"} {"Time":"2020-05-17T21:06:45.426243766-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_333ms_"} {"Time":"2020-05-17T21:06:45.42624722-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_333ms_","Output":"=== RUN TestFmtDotElapsed/_333ms_\n"} {"Time":"2020-05-17T21:06:45.426260359-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1.33s_"} {"Time":"2020-05-17T21:06:45.426267551-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1.33s_","Output":"=== RUN TestFmtDotElapsed/_1.33s_\n"} {"Time":"2020-05-17T21:06:45.426298022-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_14.8s_"} {"Time":"2020-05-17T21:06:45.426312244-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_14.8s_","Output":"=== RUN TestFmtDotElapsed/_14.8s_\n"} {"Time":"2020-05-17T21:06:45.426321045-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1m59s_"} {"Time":"2020-05-17T21:06:45.426326396-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1m59s_","Output":"=== RUN TestFmtDotElapsed/_1m59s_\n"} {"Time":"2020-05-17T21:06:45.426350409-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_59m0s_"} {"Time":"2020-05-17T21:06:45.426362648-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_59m0s_","Output":"=== RUN TestFmtDotElapsed/_59m0s_\n"} {"Time":"2020-05-17T21:06:45.426377077-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_2m28s_"} {"Time":"2020-05-17T21:06:45.42638404-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_2m28s_","Output":"=== RUN TestFmtDotElapsed/_2m28s_\n"} {"Time":"2020-05-17T21:06:45.426411764-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_24m0s_"} {"Time":"2020-05-17T21:06:45.426420961-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_24m0s_","Output":"=== RUN TestFmtDotElapsed/_24m0s_\n"} {"Time":"2020-05-17T21:06:45.426438769-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed","Output":"--- PASS: TestFmtDotElapsed (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426449379-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_999µs_","Output":" --- PASS: TestFmtDotElapsed/_999µs_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426454125-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_999µs_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426458284-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/___7ms_","Output":" --- PASS: TestFmtDotElapsed/___7ms_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426461846-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/___7ms_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426464826-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____🖴__","Output":" --- PASS: TestFmtDotElapsed/____🖴__ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.42647425-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____🖴__","Elapsed":0} {"Time":"2020-05-17T21:06:45.426480557-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____⏳__","Output":" --- PASS: TestFmtDotElapsed/____⏳__ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426488798-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/____⏳__","Elapsed":0} {"Time":"2020-05-17T21:06:45.426495202-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/__14ms_","Output":" --- PASS: TestFmtDotElapsed/__14ms_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426500985-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/__14ms_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426506198-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_333ms_","Output":" --- PASS: TestFmtDotElapsed/_333ms_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.42651225-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_333ms_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426518337-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1.33s_","Output":" --- PASS: TestFmtDotElapsed/_1.33s_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426525447-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1.33s_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426529931-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_14.8s_","Output":" --- PASS: TestFmtDotElapsed/_14.8s_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426535502-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_14.8s_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426538826-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1m59s_","Output":" --- PASS: TestFmtDotElapsed/_1m59s_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426548603-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_1m59s_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426552043-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_59m0s_","Output":" --- PASS: TestFmtDotElapsed/_59m0s_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426555165-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_59m0s_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426558054-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_2m28s_","Output":" --- PASS: TestFmtDotElapsed/_2m28s_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426562065-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_2m28s_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426565127-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_24m0s_","Output":" --- PASS: TestFmtDotElapsed/_24m0s_ (0.00s)\n"} {"Time":"2020-05-17T21:06:45.426571505-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed/_24m0s_","Elapsed":0} {"Time":"2020-05-17T21:06:45.426574497-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed","Elapsed":0} {"Time":"2020-05-17T21:06:45.426577198-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed_RuneCountProperty"} {"Time":"2020-05-17T21:06:45.426579938-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed_RuneCountProperty","Output":"=== RUN TestFmtDotElapsed_RuneCountProperty\n"} {"Time":"2020-05-17T21:06:45.42658341-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed_RuneCountProperty","Output":" TestFmtDotElapsed_RuneCountProperty: dotformat_test.go:149: seed 1589764005\n"} {"Time":"2020-05-17T21:06:45.561329225-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed_RuneCountProperty","Output":"--- PASS: TestFmtDotElapsed_RuneCountProperty (0.13s)\n"} {"Time":"2020-05-17T21:06:45.561369929-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestFmtDotElapsed_RuneCountProperty","Elapsed":0.13} {"Time":"2020-05-17T21:06:45.561379872-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestNewDotFormatter"} {"Time":"2020-05-17T21:06:45.561384356-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestNewDotFormatter","Output":"=== RUN TestNewDotFormatter\n"} {"Time":"2020-05-17T21:06:45.561388744-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestNewDotFormatter","Output":"WARN Failed to detect terminal width for dots format, error: inappropriate ioctl for device\n"} {"Time":"2020-05-17T21:06:45.561702233-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestNewDotFormatter","Output":" TestNewDotFormatter: dotformat_test.go:161: !ok: no terminal width\n"} {"Time":"2020-05-17T21:06:45.561719682-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestNewDotFormatter","Output":"--- SKIP: TestNewDotFormatter (0.00s)\n"} {"Time":"2020-05-17T21:06:45.561724743-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson","Test":"TestNewDotFormatter","Elapsed":0} {"Time":"2020-05-17T21:06:45.561728367-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPackage_Elapsed"} {"Time":"2020-05-17T21:06:45.56173296-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPackage_Elapsed","Output":"=== RUN TestPackage_Elapsed\n"} {"Time":"2020-05-17T21:06:45.561737792-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPackage_Elapsed","Output":"--- PASS: TestPackage_Elapsed (0.00s)\n"} {"Time":"2020-05-17T21:06:45.56175039-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPackage_Elapsed","Elapsed":0} {"Time":"2020-05-17T21:06:45.561754009-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestExecution_Add_PackageCoverage"} {"Time":"2020-05-17T21:06:45.561757327-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestExecution_Add_PackageCoverage","Output":"=== RUN TestExecution_Add_PackageCoverage\n"} {"Time":"2020-05-17T21:06:45.561813733-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestExecution_Add_PackageCoverage","Output":"--- PASS: TestExecution_Add_PackageCoverage (0.00s)\n"} {"Time":"2020-05-17T21:06:45.561823792-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestExecution_Add_PackageCoverage","Elapsed":0} {"Time":"2020-05-17T21:06:45.561827819-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortVerboseFormat"} {"Time":"2020-05-17T21:06:45.561830844-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortVerboseFormat","Output":"=== RUN TestScanTestOutputWithShortVerboseFormat\n"} {"Time":"2020-05-17T21:06:45.601170618-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortVerboseFormat","Output":"--- PASS: TestScanTestOutputWithShortVerboseFormat (0.04s)\n"} {"Time":"2020-05-17T21:06:45.601216224-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortVerboseFormat","Elapsed":0.04} {"Time":"2020-05-17T21:06:45.601229736-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithDotsFormatV1"} {"Time":"2020-05-17T21:06:45.601237404-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithDotsFormatV1","Output":"=== RUN TestScanTestOutputWithDotsFormatV1\n"} {"Time":"2020-05-17T21:06:45.603375104-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithDotsFormatV1","Output":"--- PASS: TestScanTestOutputWithDotsFormatV1 (0.00s)\n"} {"Time":"2020-05-17T21:06:45.603410002-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithDotsFormatV1","Elapsed":0} {"Time":"2020-05-17T21:06:45.603419866-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat"} {"Time":"2020-05-17T21:06:45.60342642-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat","Output":"=== RUN TestScanTestOutputWithShortFormat\n"} {"Time":"2020-05-17T21:06:45.604830164-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat","Output":"--- PASS: TestScanTestOutputWithShortFormat (0.00s)\n"} {"Time":"2020-05-17T21:06:45.604846658-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat","Elapsed":0} {"Time":"2020-05-17T21:06:45.604855068-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat_WithCoverage"} {"Time":"2020-05-17T21:06:45.60486112-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat_WithCoverage","Output":"=== RUN TestScanTestOutputWithShortFormat_WithCoverage\n"} {"Time":"2020-05-17T21:06:45.607016671-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat_WithCoverage","Output":"--- PASS: TestScanTestOutputWithShortFormat_WithCoverage (0.00s)\n"} {"Time":"2020-05-17T21:06:45.607042817-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithShortFormat_WithCoverage","Elapsed":0} {"Time":"2020-05-17T21:06:45.607054403-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardVerboseFormat"} {"Time":"2020-05-17T21:06:45.607069956-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardVerboseFormat","Output":"=== RUN TestScanTestOutputWithStandardVerboseFormat\n"} {"Time":"2020-05-17T21:06:45.608906022-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardVerboseFormat","Output":"--- PASS: TestScanTestOutputWithStandardVerboseFormat (0.00s)\n"} {"Time":"2020-05-17T21:06:45.608930307-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardVerboseFormat","Elapsed":0} {"Time":"2020-05-17T21:06:45.608941847-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat"} {"Time":"2020-05-17T21:06:45.608948827-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat","Output":"=== RUN TestScanTestOutputWithStandardQuietFormat\n"} {"Time":"2020-05-17T21:06:45.610294664-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat","Output":"--- PASS: TestScanTestOutputWithStandardQuietFormat (0.00s)\n"} {"Time":"2020-05-17T21:06:45.610311949-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat","Elapsed":0} {"Time":"2020-05-17T21:06:45.610317541-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat_WithCoverage"} {"Time":"2020-05-17T21:06:45.610320721-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat_WithCoverage","Output":"=== RUN TestScanTestOutputWithStandardQuietFormat_WithCoverage\n"} {"Time":"2020-05-17T21:06:45.693697524-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat_WithCoverage","Output":"--- PASS: TestScanTestOutputWithStandardQuietFormat_WithCoverage (0.08s)\n"} {"Time":"2020-05-17T21:06:45.693787837-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestScanTestOutputWithStandardQuietFormat_WithCoverage","Elapsed":0.08} {"Time":"2020-05-17T21:06:45.693824555-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestRelativePackagePath"} {"Time":"2020-05-17T21:06:45.693841809-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestRelativePackagePath","Output":"=== RUN TestRelativePackagePath\n"} {"Time":"2020-05-17T21:06:45.693859328-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestRelativePackagePath","Output":"--- PASS: TestRelativePackagePath (0.00s)\n"} {"Time":"2020-05-17T21:06:45.693872368-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestRelativePackagePath","Elapsed":0} {"Time":"2020-05-17T21:06:45.693888465-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix"} {"Time":"2020-05-17T21:06:45.693907566-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix","Output":"=== RUN TestGetPkgPathPrefix\n"} {"Time":"2020-05-17T21:06:45.693929153-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_path"} {"Time":"2020-05-17T21:06:45.693940574-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_path","Output":"=== RUN TestGetPkgPathPrefix/with_go_path\n"} {"Time":"2020-05-17T21:06:45.694298339-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_path","Output":" TestGetPkgPathPrefix/with_go_path: pkgpathprefix_test.go:22: isGoModuleEnabled()\n"} {"Time":"2020-05-17T21:06:45.6943652-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_modules"} {"Time":"2020-05-17T21:06:45.694413291-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_modules","Output":"=== RUN TestGetPkgPathPrefix/with_go_modules\n"} {"Time":"2020-05-17T21:06:45.694569635-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix","Output":"--- PASS: TestGetPkgPathPrefix (0.00s)\n"} {"Time":"2020-05-17T21:06:45.694612647-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_path","Output":" --- SKIP: TestGetPkgPathPrefix/with_go_path (0.00s)\n"} {"Time":"2020-05-17T21:06:45.694639191-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_path","Elapsed":0} {"Time":"2020-05-17T21:06:45.694664109-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_modules","Output":" --- PASS: TestGetPkgPathPrefix/with_go_modules (0.00s)\n"} {"Time":"2020-05-17T21:06:45.694689546-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix/with_go_modules","Elapsed":0} {"Time":"2020-05-17T21:06:45.69470311-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestGetPkgPathPrefix","Elapsed":0} {"Time":"2020-05-17T21:06:45.694715971-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String"} {"Time":"2020-05-17T21:06:45.694730714-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String","Output":"=== RUN TestSummary_String\n"} {"Time":"2020-05-17T21:06:45.694752392-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/none"} {"Time":"2020-05-17T21:06:45.694769485-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/none","Output":"=== RUN TestSummary_String/none\n"} {"Time":"2020-05-17T21:06:45.694785705-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/all"} {"Time":"2020-05-17T21:06:45.694796767-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/all","Output":"=== RUN TestSummary_String/all\n"} {"Time":"2020-05-17T21:06:45.694807987-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/one_value"} {"Time":"2020-05-17T21:06:45.694822381-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/one_value","Output":"=== RUN TestSummary_String/one_value\n"} {"Time":"2020-05-17T21:06:45.694895269-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/a_few_values"} {"Time":"2020-05-17T21:06:45.694934921-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/a_few_values","Output":"=== RUN TestSummary_String/a_few_values\n"} {"Time":"2020-05-17T21:06:45.695006022-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String","Output":"--- PASS: TestSummary_String (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695052861-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/none","Output":" --- PASS: TestSummary_String/none (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695081352-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/none","Elapsed":0} {"Time":"2020-05-17T21:06:45.695105034-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/all","Output":" --- PASS: TestSummary_String/all (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695128571-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/all","Elapsed":0} {"Time":"2020-05-17T21:06:45.695150363-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/one_value","Output":" --- PASS: TestSummary_String/one_value (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695189799-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/one_value","Elapsed":0} {"Time":"2020-05-17T21:06:45.695209356-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/a_few_values","Output":" --- PASS: TestSummary_String/a_few_values (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695237549-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String/a_few_values","Elapsed":0} {"Time":"2020-05-17T21:06:45.695257433-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestSummary_String","Elapsed":0} {"Time":"2020-05-17T21:06:45.695269567-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_NoFailures"} {"Time":"2020-05-17T21:06:45.6952803-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_NoFailures","Output":"=== RUN TestPrintSummary_NoFailures\n"} {"Time":"2020-05-17T21:06:45.69529853-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_NoFailures","Output":"--- PASS: TestPrintSummary_NoFailures (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695319891-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_NoFailures","Elapsed":0} {"Time":"2020-05-17T21:06:45.695340098-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures"} {"Time":"2020-05-17T21:06:45.695360601-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures","Output":"=== RUN TestPrintSummary_WithFailures\n"} {"Time":"2020-05-17T21:06:45.695387925-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_all"} {"Time":"2020-05-17T21:06:45.695408199-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_all","Output":"=== RUN TestPrintSummary_WithFailures/summarize_all\n"} {"Time":"2020-05-17T21:06:45.695548542-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_no_output"} {"Time":"2020-05-17T21:06:45.695577885-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_no_output","Output":"=== RUN TestPrintSummary_WithFailures/summarize_no_output\n"} {"Time":"2020-05-17T21:06:45.695740373-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_only_errors"} {"Time":"2020-05-17T21:06:45.695766268-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_only_errors","Output":"=== RUN TestPrintSummary_WithFailures/summarize_only_errors\n"} {"Time":"2020-05-17T21:06:45.695875272-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures","Output":"--- PASS: TestPrintSummary_WithFailures (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695894246-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_all","Output":" --- PASS: TestPrintSummary_WithFailures/summarize_all (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695908276-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_all","Elapsed":0} {"Time":"2020-05-17T21:06:45.695921682-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_no_output","Output":" --- PASS: TestPrintSummary_WithFailures/summarize_no_output (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695933945-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_no_output","Elapsed":0} {"Time":"2020-05-17T21:06:45.695944263-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_only_errors","Output":" --- PASS: TestPrintSummary_WithFailures/summarize_only_errors (0.00s)\n"} {"Time":"2020-05-17T21:06:45.695973669-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures/summarize_only_errors","Elapsed":0} {"Time":"2020-05-17T21:06:45.695987799-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithFailures","Elapsed":0} {"Time":"2020-05-17T21:06:45.695996109-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_MissingTestFailEvent"} {"Time":"2020-05-17T21:06:45.69600455-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_MissingTestFailEvent","Output":"=== RUN TestPrintSummary_MissingTestFailEvent\n"} {"Time":"2020-05-17T21:06:45.696433387-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_MissingTestFailEvent","Output":"--- PASS: TestPrintSummary_MissingTestFailEvent (0.00s)\n"} {"Time":"2020-05-17T21:06:45.696453447-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_MissingTestFailEvent","Elapsed":0} {"Time":"2020-05-17T21:06:45.696460708-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithMisattributedOutput"} {"Time":"2020-05-17T21:06:45.696473682-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithMisattributedOutput","Output":"=== RUN TestPrintSummary_WithMisattributedOutput\n"} {"Time":"2020-05-17T21:06:45.696868368-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithMisattributedOutput","Output":"--- PASS: TestPrintSummary_WithMisattributedOutput (0.00s)\n"} {"Time":"2020-05-17T21:06:45.69688868-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithMisattributedOutput","Elapsed":0} {"Time":"2020-05-17T21:06:45.69689641-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithSubtestFailures"} {"Time":"2020-05-17T21:06:45.696901733-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithSubtestFailures","Output":"=== RUN TestPrintSummary_WithSubtestFailures\n"} {"Time":"2020-05-17T21:06:45.698494542-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithSubtestFailures","Output":"--- PASS: TestPrintSummary_WithSubtestFailures (0.00s)\n"} {"Time":"2020-05-17T21:06:45.698518242-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Test":"TestPrintSummary_WithSubtestFailures","Elapsed":0} {"Time":"2020-05-17T21:06:45.698531164-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Output":"PASS\n"} {"Time":"2020-05-17T21:06:45.69935265-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson","Output":"ok \tgotest.tools/gotestsum/testjson\t0.329s\n"} {"Time":"2020-05-17T21:06:45.699390055-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson","Elapsed":0.329} gotestsum-1.8.2/testjson/testdata/input/go-test-json-missing-test-fail.out000066400000000000000000000101041427475276200270300ustar00rootroot00000000000000{"Time":"2020-04-10T14:52:44.192693974-04:00","Action":"run","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare"} {"Time":"2020-04-10T14:52:44.192822137-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"=== RUN TestWaitOn_WithCompare\n"} {"Time":"2020-04-10T14:52:44.1950981-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"panic: runtime error: index out of range [1] with length 1\n"} {"Time":"2020-04-10T14:52:44.195110282-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\n"} {"Time":"2020-04-10T14:52:44.195116665-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"goroutine 7 [running]:\n"} {"Time":"2020-04-10T14:52:44.195120587-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"gotest.tools/v3/internal/assert.ArgsFromComparisonCall(0xc0000552a0, 0x1, 0x1, 0x1, 0x0, 0x0)\n"} {"Time":"2020-04-10T14:52:44.195301254-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\t/home/daniel/pers/code/gotest.tools/internal/assert/result.go:102 +0x9f\n"} {"Time":"2020-04-10T14:52:44.195332206-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"gotest.tools/v3/internal/assert.runComparison(0x6bcb80, 0xc00000e180, 0x67dee8, 0xc00007a9f0, 0x0, 0x0, 0x0, 0x7f7f4fb6d108)\n"} {"Time":"2020-04-10T14:52:44.19533807-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\t/home/daniel/pers/code/gotest.tools/internal/assert/result.go:34 +0x2b1\n"} {"Time":"2020-04-10T14:52:44.195342341-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"gotest.tools/v3/internal/assert.Eval(0x6bcb80, 0xc00000e180, 0x67dee8, 0x627660, 0xc00007a9f0, 0x0, 0x0, 0x0, 0x642c60)\n"} {"Time":"2020-04-10T14:52:44.195346449-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\t/home/daniel/pers/code/gotest.tools/internal/assert/assert.go:56 +0x2e4\n"} {"Time":"2020-04-10T14:52:44.195350377-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"gotest.tools/v3/poll.Compare(0xc00007a9f0, 0x6b74a0, 0x618a60)\n"} {"Time":"2020-04-10T14:52:44.195356946-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\t/home/daniel/pers/code/gotest.tools/poll/poll.go:151 +0x81\n"} {"Time":"2020-04-10T14:52:44.195360761-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"gotest.tools/v3/poll.TestWaitOn_WithCompare.func1(0x6be4c0, 0xc00016c240, 0xc00016c240, 0x6be4c0)\n"} {"Time":"2020-04-10T14:52:44.195367482-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\t/home/daniel/pers/code/gotest.tools/poll/poll_test.go:81 +0x58\n"} {"Time":"2020-04-10T14:52:44.195371319-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"gotest.tools/v3/poll.WaitOn.func1(0xc00001e3c0, 0x67df50, 0x6c1960, 0xc00016c240)\n"} {"Time":"2020-04-10T14:52:44.195375766-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\t/home/daniel/pers/code/gotest.tools/poll/poll.go:125 +0x62\n"} {"Time":"2020-04-10T14:52:44.195379421-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"created by gotest.tools/v3/poll.WaitOn\n"} {"Time":"2020-04-10T14:52:44.195384493-04:00","Action":"output","Package":"gotest.tools/v3/poll","Test":"TestWaitOn_WithCompare","Output":"\t/home/daniel/pers/code/gotest.tools/poll/poll.go:124 +0x16f\n"} {"Time":"2020-04-10T14:52:44.195785223-04:00","Action":"output","Package":"gotest.tools/v3/poll","Output":"FAIL\tgotest.tools/v3/poll\t0.005s\n"} {"Time":"2020-04-10T14:52:44.195796081-04:00","Action":"fail","Package":"gotest.tools/v3/poll","Elapsed":0.005} gotestsum-1.8.2/testjson/testdata/input/go-test-json-with-cover.err000066400000000000000000000001511427475276200255420ustar00rootroot00000000000000# gotest.tools/gotestsum/testjson/internal/broken internal/broken/broken.go:5:21: undefined: somepackage gotestsum-1.8.2/testjson/testdata/input/go-test-json-with-cover.out000066400000000000000000001210351427475276200255660ustar00rootroot00000000000000{"Time":"2019-06-26T19:28:47.238149257-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Output":"sometimes main can exit 2\n"} {"Time":"2019-06-26T19:28:47.238279925-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/badmain\t0.001s\n"} {"Time":"2019-06-26T19:28:47.238295101-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Elapsed":0.001} {"Time":"2019-06-26T19:28:47.458747463-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed"} {"Time":"2019-06-26T19:28:47.458782622-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2019-06-26T19:28:47.458799449-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2019-06-26T19:28:47.458806961-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Elapsed":0} {"Time":"2019-06-26T19:28:47.458813231-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog"} {"Time":"2019-06-26T19:28:47.458817456-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2019-06-26T19:28:47.458823547-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2019-06-26T19:28:47.458829353-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":" good_test.go:15: this is a log\n"} {"Time":"2019-06-26T19:28:47.458833761-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2019-06-26T19:28:47.458837672-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout"} {"Time":"2019-06-26T19:28:47.458841435-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2019-06-26T19:28:47.458845644-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2019-06-26T19:28:47.458850344-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2019-06-26T19:28:47.458855053-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2019-06-26T19:28:47.458858851-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped"} {"Time":"2019-06-26T19:28:47.458862526-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":"=== RUN TestSkipped\n"} {"Time":"2019-06-26T19:28:47.458870529-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":"--- SKIP: TestSkipped (0.00s)\n"} {"Time":"2019-06-26T19:28:47.458876671-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":" good_test.go:23: \n"} {"Time":"2019-06-26T19:28:47.45888138-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Elapsed":0} {"Time":"2019-06-26T19:28:47.458885294-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog"} {"Time":"2019-06-26T19:28:47.458889-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":"=== RUN TestSkippedWitLog\n"} {"Time":"2019-06-26T19:28:47.458900865-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":"--- SKIP: TestSkippedWitLog (0.00s)\n"} {"Time":"2019-06-26T19:28:47.458906593-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":" good_test.go:27: the skip message\n"} {"Time":"2019-06-26T19:28:47.458914409-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Elapsed":0} {"Time":"2019-06-26T19:28:47.45892158-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr"} {"Time":"2019-06-26T19:28:47.458927969-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2019-06-26T19:28:47.458932512-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2019-06-26T19:28:47.458937403-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2019-06-26T19:28:47.458941827-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Elapsed":0} {"Time":"2019-06-26T19:28:47.45894569-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2019-06-26T19:28:47.458949397-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2019-06-26T19:28:47.458955255-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2019-06-26T19:28:47.458959476-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2019-06-26T19:28:47.458963459-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2019-06-26T19:28:47.458967038-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2019-06-26T19:28:47.458971275-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2019-06-26T19:28:47.458976317-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2019-06-26T19:28:47.458983631-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2019-06-26T19:28:47.458990606-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2019-06-26T19:28:47.459003982-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2019-06-26T19:28:47.459011662-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2019-06-26T19:28:47.459019071-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess"} {"Time":"2019-06-26T19:28:47.459025415-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Output":"=== RUN TestNestedSuccess\n"} {"Time":"2019-06-26T19:28:47.459032888-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a"} {"Time":"2019-06-26T19:28:47.45903963-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Output":"=== RUN TestNestedSuccess/a\n"} {"Time":"2019-06-26T19:28:47.459053477-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub"} {"Time":"2019-06-26T19:28:47.459061016-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Output":"=== RUN TestNestedSuccess/a/sub\n"} {"Time":"2019-06-26T19:28:47.459068324-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b"} {"Time":"2019-06-26T19:28:47.459074849-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Output":"=== RUN TestNestedSuccess/b\n"} {"Time":"2019-06-26T19:28:47.459082791-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub"} {"Time":"2019-06-26T19:28:47.459089945-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Output":"=== RUN TestNestedSuccess/b/sub\n"} {"Time":"2019-06-26T19:28:47.459097795-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c"} {"Time":"2019-06-26T19:28:47.459105018-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Output":"=== RUN TestNestedSuccess/c\n"} {"Time":"2019-06-26T19:28:47.459110103-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub"} {"Time":"2019-06-26T19:28:47.459113836-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Output":"=== RUN TestNestedSuccess/c/sub\n"} {"Time":"2019-06-26T19:28:47.459123681-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d"} {"Time":"2019-06-26T19:28:47.459129671-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Output":"=== RUN TestNestedSuccess/d\n"} {"Time":"2019-06-26T19:28:47.459134441-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub"} {"Time":"2019-06-26T19:28:47.459138104-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Output":"=== RUN TestNestedSuccess/d/sub\n"} {"Time":"2019-06-26T19:28:47.459144627-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Output":"--- PASS: TestNestedSuccess (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459151692-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Output":" --- PASS: TestNestedSuccess/a (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459161703-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Output":" --- PASS: TestNestedSuccess/a/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459169885-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.45917454-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Elapsed":0} {"Time":"2019-06-26T19:28:47.459180719-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Output":" --- PASS: TestNestedSuccess/b (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459185674-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Output":" --- PASS: TestNestedSuccess/b/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459190244-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.459197899-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Elapsed":0} {"Time":"2019-06-26T19:28:47.459203616-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Output":" --- PASS: TestNestedSuccess/c (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459208678-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Output":" --- PASS: TestNestedSuccess/c/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459213207-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.459217065-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Elapsed":0} {"Time":"2019-06-26T19:28:47.459223713-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Output":" --- PASS: TestNestedSuccess/d (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459232135-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Output":" --- PASS: TestNestedSuccess/d/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.459240595-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.459247791-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Elapsed":0} {"Time":"2019-06-26T19:28:47.459252463-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Elapsed":0} {"Time":"2019-06-26T19:28:47.459258769-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2019-06-26T19:28:47.459262909-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2019-06-26T19:28:47.459267293-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2019-06-26T19:28:47.459271273-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2019-06-26T19:28:47.459275497-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2019-06-26T19:28:47.459279162-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2019-06-26T19:28:47.46114001-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"--- PASS: TestParallelTheThird (0.00s)\n"} {"Time":"2019-06-26T19:28:47.46514413-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2019-06-26T19:28:47.465163676-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"--- PASS: TestParallelTheSecond (0.01s)\n"} {"Time":"2019-06-26T19:28:47.469149033-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2019-06-26T19:28:47.469167786-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"--- PASS: TestParallelTheFirst (0.01s)\n"} {"Time":"2019-06-26T19:28:47.469179349-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2019-06-26T19:28:47.46918812-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"PASS\n"} {"Time":"2019-06-26T19:28:47.469212191-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"coverage: 0.0% of statements\n"} {"Time":"2019-06-26T19:28:47.469354607-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"ok \tgotest.tools/gotestsum/testjson/internal/good\t0.011s\tcoverage: 0.0% of statements\n"} {"Time":"2019-06-26T19:28:47.469649009-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Elapsed":0.012} {"Time":"2019-06-26T19:28:47.613455232-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassed"} {"Time":"2019-06-26T19:28:47.613489941-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2019-06-26T19:28:47.613501844-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613511031-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassed","Elapsed":0} {"Time":"2019-06-26T19:28:47.613518853-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithLog"} {"Time":"2019-06-26T19:28:47.61352445-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2019-06-26T19:28:47.613530776-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613538567-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithLog","Output":" stub_test.go:18: this is a log\n"} {"Time":"2019-06-26T19:28:47.61354478-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2019-06-26T19:28:47.613548354-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithStdout"} {"Time":"2019-06-26T19:28:47.613551518-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2019-06-26T19:28:47.613559269-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2019-06-26T19:28:47.613566884-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613573134-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2019-06-26T19:28:47.613578456-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkipped"} {"Time":"2019-06-26T19:28:47.613584276-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkipped","Output":"=== RUN TestSkipped\n"} {"Time":"2019-06-26T19:28:47.613591296-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkipped","Output":"--- SKIP: TestSkipped (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613598946-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkipped","Output":" stub_test.go:26: \n"} {"Time":"2019-06-26T19:28:47.613605417-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkipped","Elapsed":0} {"Time":"2019-06-26T19:28:47.613611099-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkippedWitLog"} {"Time":"2019-06-26T19:28:47.613616389-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkippedWitLog","Output":"=== RUN TestSkippedWitLog\n"} {"Time":"2019-06-26T19:28:47.613630786-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkippedWitLog","Output":"--- SKIP: TestSkippedWitLog (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613638067-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkippedWitLog","Output":" stub_test.go:30: the skip message\n"} {"Time":"2019-06-26T19:28:47.613644539-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestSkippedWitLog","Elapsed":0} {"Time":"2019-06-26T19:28:47.613650915-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailed"} {"Time":"2019-06-26T19:28:47.613656057-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailed","Output":"=== RUN TestFailed\n"} {"Time":"2019-06-26T19:28:47.613660804-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailed","Output":"--- FAIL: TestFailed (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613666458-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailed","Output":" stub_test.go:34: this failed\n"} {"Time":"2019-06-26T19:28:47.61367398-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailed","Elapsed":0} {"Time":"2019-06-26T19:28:47.613677924-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestWithStderr"} {"Time":"2019-06-26T19:28:47.613680917-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2019-06-26T19:28:47.613684329-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2019-06-26T19:28:47.613689561-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613698172-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestWithStderr","Elapsed":0} {"Time":"2019-06-26T19:28:47.613701738-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailedWithStderr"} {"Time":"2019-06-26T19:28:47.613704935-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailedWithStderr","Output":"=== RUN TestFailedWithStderr\n"} {"Time":"2019-06-26T19:28:47.613708452-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailedWithStderr","Output":"this is stderr\n"} {"Time":"2019-06-26T19:28:47.613712122-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailedWithStderr","Output":"--- FAIL: TestFailedWithStderr (0.00s)\n"} {"Time":"2019-06-26T19:28:47.61371559-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailedWithStderr","Output":" stub_test.go:43: also failed\n"} {"Time":"2019-06-26T19:28:47.613719048-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestFailedWithStderr","Elapsed":0} {"Time":"2019-06-26T19:28:47.613722888-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst"} {"Time":"2019-06-26T19:28:47.613728376-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2019-06-26T19:28:47.613733754-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2019-06-26T19:28:47.613737105-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst"} {"Time":"2019-06-26T19:28:47.613743446-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond"} {"Time":"2019-06-26T19:28:47.613746934-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2019-06-26T19:28:47.613750637-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2019-06-26T19:28:47.613776438-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond"} {"Time":"2019-06-26T19:28:47.613781739-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird"} {"Time":"2019-06-26T19:28:47.613785885-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2019-06-26T19:28:47.613790704-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2019-06-26T19:28:47.613794776-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird"} {"Time":"2019-06-26T19:28:47.61379922-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure"} {"Time":"2019-06-26T19:28:47.613803368-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure","Output":"=== RUN TestNestedWithFailure\n"} {"Time":"2019-06-26T19:28:47.613807955-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a"} {"Time":"2019-06-26T19:28:47.613812031-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a","Output":"=== RUN TestNestedWithFailure/a\n"} {"Time":"2019-06-26T19:28:47.61381662-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a/sub"} {"Time":"2019-06-26T19:28:47.613820714-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a/sub","Output":"=== RUN TestNestedWithFailure/a/sub\n"} {"Time":"2019-06-26T19:28:47.61382569-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b"} {"Time":"2019-06-26T19:28:47.61382997-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b","Output":"=== RUN TestNestedWithFailure/b\n"} {"Time":"2019-06-26T19:28:47.613834604-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b/sub"} {"Time":"2019-06-26T19:28:47.613838711-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b/sub","Output":"=== RUN TestNestedWithFailure/b/sub\n"} {"Time":"2019-06-26T19:28:47.61384326-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/c"} {"Time":"2019-06-26T19:28:47.613847279-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/c","Output":"=== RUN TestNestedWithFailure/c\n"} {"Time":"2019-06-26T19:28:47.613851721-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d"} {"Time":"2019-06-26T19:28:47.613856183-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d","Output":"=== RUN TestNestedWithFailure/d\n"} {"Time":"2019-06-26T19:28:47.613860835-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d/sub"} {"Time":"2019-06-26T19:28:47.613868445-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d/sub","Output":"=== RUN TestNestedWithFailure/d/sub\n"} {"Time":"2019-06-26T19:28:47.613874256-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure","Output":"--- FAIL: TestNestedWithFailure (0.00s)\n"} {"Time":"2019-06-26T19:28:47.61387999-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a","Output":" --- PASS: TestNestedWithFailure/a (0.00s)\n"} {"Time":"2019-06-26T19:28:47.61388535-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a/sub","Output":" --- PASS: TestNestedWithFailure/a/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613892244-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.61389948-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/a","Elapsed":0} {"Time":"2019-06-26T19:28:47.613904207-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b","Output":" --- PASS: TestNestedWithFailure/b (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613909201-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b/sub","Output":" --- PASS: TestNestedWithFailure/b/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613914432-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.613918715-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/b","Elapsed":0} {"Time":"2019-06-26T19:28:47.613923018-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/c","Output":" --- FAIL: TestNestedWithFailure/c (0.00s)\n"} {"Time":"2019-06-26T19:28:47.61392748-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/c","Output":" stub_test.go:65: failed\n"} {"Time":"2019-06-26T19:28:47.613932152-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/c","Elapsed":0} {"Time":"2019-06-26T19:28:47.613936537-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d","Output":" --- PASS: TestNestedWithFailure/d (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613941691-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d/sub","Output":" --- PASS: TestNestedWithFailure/d/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.613946328-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.613950391-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure/d","Elapsed":0} {"Time":"2019-06-26T19:28:47.61395449-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedWithFailure","Elapsed":0} {"Time":"2019-06-26T19:28:47.61395872-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess"} {"Time":"2019-06-26T19:28:47.613962881-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess","Output":"=== RUN TestNestedSuccess\n"} {"Time":"2019-06-26T19:28:47.613967468-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a"} {"Time":"2019-06-26T19:28:47.613971517-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a","Output":"=== RUN TestNestedSuccess/a\n"} {"Time":"2019-06-26T19:28:47.613978979-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a/sub"} {"Time":"2019-06-26T19:28:47.613984807-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a/sub","Output":"=== RUN TestNestedSuccess/a/sub\n"} {"Time":"2019-06-26T19:28:47.613989747-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b"} {"Time":"2019-06-26T19:28:47.613994192-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b","Output":"=== RUN TestNestedSuccess/b\n"} {"Time":"2019-06-26T19:28:47.613998627-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b/sub"} {"Time":"2019-06-26T19:28:47.614002677-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b/sub","Output":"=== RUN TestNestedSuccess/b/sub\n"} {"Time":"2019-06-26T19:28:47.614007557-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c"} {"Time":"2019-06-26T19:28:47.614011782-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c","Output":"=== RUN TestNestedSuccess/c\n"} {"Time":"2019-06-26T19:28:47.614016469-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c/sub"} {"Time":"2019-06-26T19:28:47.614020531-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c/sub","Output":"=== RUN TestNestedSuccess/c/sub\n"} {"Time":"2019-06-26T19:28:47.614025042-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d"} {"Time":"2019-06-26T19:28:47.614029111-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d","Output":"=== RUN TestNestedSuccess/d\n"} {"Time":"2019-06-26T19:28:47.614033552-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d/sub"} {"Time":"2019-06-26T19:28:47.614038027-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d/sub","Output":"=== RUN TestNestedSuccess/d/sub\n"} {"Time":"2019-06-26T19:28:47.614047195-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess","Output":"--- PASS: TestNestedSuccess (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614052718-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a","Output":" --- PASS: TestNestedSuccess/a (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614059105-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a/sub","Output":" --- PASS: TestNestedSuccess/a/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614064422-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.614068694-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/a","Elapsed":0} {"Time":"2019-06-26T19:28:47.614072803-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b","Output":" --- PASS: TestNestedSuccess/b (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614077732-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b/sub","Output":" --- PASS: TestNestedSuccess/b/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614082472-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.614090817-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/b","Elapsed":0} {"Time":"2019-06-26T19:28:47.614095867-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c","Output":" --- PASS: TestNestedSuccess/c (0.00s)\n"} {"Time":"2019-06-26T19:28:47.61410088-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c/sub","Output":" --- PASS: TestNestedSuccess/c/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614105594-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.614109835-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/c","Elapsed":0} {"Time":"2019-06-26T19:28:47.614114046-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d","Output":" --- PASS: TestNestedSuccess/d (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614118785-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d/sub","Output":" --- PASS: TestNestedSuccess/d/sub (0.00s)\n"} {"Time":"2019-06-26T19:28:47.614123463-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d/sub","Elapsed":0} {"Time":"2019-06-26T19:28:47.614127465-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess/d","Elapsed":0} {"Time":"2019-06-26T19:28:47.614131655-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestNestedSuccess","Elapsed":0} {"Time":"2019-06-26T19:28:47.614135791-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst"} {"Time":"2019-06-26T19:28:47.614139853-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2019-06-26T19:28:47.614144429-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird"} {"Time":"2019-06-26T19:28:47.614148541-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2019-06-26T19:28:47.614154363-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond"} {"Time":"2019-06-26T19:28:47.614158811-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2019-06-26T19:28:47.61583309-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird","Output":"--- PASS: TestParallelTheThird (0.00s)\n"} {"Time":"2019-06-26T19:28:47.619887526-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2019-06-26T19:28:47.619903436-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond","Output":"--- PASS: TestParallelTheSecond (0.01s)\n"} {"Time":"2019-06-26T19:28:47.62383803-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2019-06-26T19:28:47.62385879-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst","Output":"--- PASS: TestParallelTheFirst (0.01s)\n"} {"Time":"2019-06-26T19:28:47.623867697-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/stub","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2019-06-26T19:28:47.623872233-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Output":"FAIL\n"} {"Time":"2019-06-26T19:28:47.623881112-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Output":"coverage: 0.0% of statements\n"} {"Time":"2019-06-26T19:28:47.623967813-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/stub","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/stub\t0.011s\n"} {"Time":"2019-06-26T19:28:47.623982468-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/stub","Elapsed":0.011} gotestsum-1.8.2/testjson/testdata/input/go-test-json-with-parallel-fails.out000066400000000000000000000416111427475276200273410ustar00rootroot00000000000000{"Time":"2020-06-20T20:03:14.189062291-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed"} {"Time":"2020-06-20T20:03:14.189181845-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2020-06-20T20:03:14.189196791-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189204529-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Elapsed":0} {"Time":"2020-06-20T20:03:14.189209795-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog"} {"Time":"2020-06-20T20:03:14.189212884-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2020-06-20T20:03:14.189216281-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":" TestPassedWithLog: fails_test.go:15: this is a log\n"} {"Time":"2020-06-20T20:03:14.18922143-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189224935-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2020-06-20T20:03:14.189228284-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout"} {"Time":"2020-06-20T20:03:14.189231421-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2020-06-20T20:03:14.189242048-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2020-06-20T20:03:14.189248882-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2020-06-20T20:03:14.1892537-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2020-06-20T20:03:14.18925685-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr"} {"Time":"2020-06-20T20:03:14.189259838-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2020-06-20T20:03:14.189263114-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2020-06-20T20:03:14.189266603-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189269864-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Elapsed":0} {"Time":"2020-06-20T20:03:14.189272811-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2020-06-20T20:03:14.189275739-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2020-06-20T20:03:14.189279428-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2020-06-20T20:03:14.189282411-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2020-06-20T20:03:14.189291743-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2020-06-20T20:03:14.189295261-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2020-06-20T20:03:14.189298613-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2020-06-20T20:03:14.189301547-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2020-06-20T20:03:14.189304528-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2020-06-20T20:03:14.189307722-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2020-06-20T20:03:14.189316868-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2020-06-20T20:03:14.189321008-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2020-06-20T20:03:14.189324205-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures"} {"Time":"2020-06-20T20:03:14.189327134-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Output":"=== RUN TestNestedParallelFailures\n"} {"Time":"2020-06-20T20:03:14.189330311-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2020-06-20T20:03:14.189333211-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== RUN TestNestedParallelFailures/a\n"} {"Time":"2020-06-20T20:03:14.189336566-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== PAUSE TestNestedParallelFailures/a\n"} {"Time":"2020-06-20T20:03:14.189339616-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2020-06-20T20:03:14.189342795-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2020-06-20T20:03:14.189345726-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== RUN TestNestedParallelFailures/b\n"} {"Time":"2020-06-20T20:03:14.189348991-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== PAUSE TestNestedParallelFailures/b\n"} {"Time":"2020-06-20T20:03:14.189351895-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2020-06-20T20:03:14.18935492-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2020-06-20T20:03:14.189357786-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== RUN TestNestedParallelFailures/c\n"} {"Time":"2020-06-20T20:03:14.18936103-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== PAUSE TestNestedParallelFailures/c\n"} {"Time":"2020-06-20T20:03:14.189366866-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2020-06-20T20:03:14.189370301-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2020-06-20T20:03:14.189373227-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== RUN TestNestedParallelFailures/d\n"} {"Time":"2020-06-20T20:03:14.189376526-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== PAUSE TestNestedParallelFailures/d\n"} {"Time":"2020-06-20T20:03:14.189379535-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2020-06-20T20:03:14.189382945-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2020-06-20T20:03:14.189388341-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== CONT TestNestedParallelFailures/a\n"} {"Time":"2020-06-20T20:03:14.18939265-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":" TestNestedParallelFailures/a: fails_test.go:50: failed sub a\n"} {"Time":"2020-06-20T20:03:14.189396424-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2020-06-20T20:03:14.189399761-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== CONT TestNestedParallelFailures/d\n"} {"Time":"2020-06-20T20:03:14.189403259-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":" TestNestedParallelFailures/d: fails_test.go:50: failed sub d\n"} {"Time":"2020-06-20T20:03:14.189406517-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2020-06-20T20:03:14.189409434-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== CONT TestNestedParallelFailures/c\n"} {"Time":"2020-06-20T20:03:14.189412522-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":" TestNestedParallelFailures/c: fails_test.go:50: failed sub c\n"} {"Time":"2020-06-20T20:03:14.189415748-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2020-06-20T20:03:14.189418676-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== CONT TestNestedParallelFailures/b\n"} {"Time":"2020-06-20T20:03:14.189421937-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":" TestNestedParallelFailures/b: fails_test.go:50: failed sub b\n"} {"Time":"2020-06-20T20:03:14.189430766-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Output":"--- FAIL: TestNestedParallelFailures (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189435217-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":" --- FAIL: TestNestedParallelFailures/a (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189438729-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Elapsed":0} {"Time":"2020-06-20T20:03:14.189446566-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":" --- FAIL: TestNestedParallelFailures/d (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189451208-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Elapsed":0} {"Time":"2020-06-20T20:03:14.189454398-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":" --- FAIL: TestNestedParallelFailures/c (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189458705-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Elapsed":0} {"Time":"2020-06-20T20:03:14.189464323-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":" --- FAIL: TestNestedParallelFailures/b (0.00s)\n"} {"Time":"2020-06-20T20:03:14.189468081-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Elapsed":0} {"Time":"2020-06-20T20:03:14.18947115-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Elapsed":0} {"Time":"2020-06-20T20:03:14.189475585-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2020-06-20T20:03:14.189478551-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2020-06-20T20:03:14.199340121-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":" TestParallelTheFirst: fails_test.go:29: failed the first\n"} {"Time":"2020-06-20T20:03:14.199385908-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"--- FAIL: TestParallelTheFirst (0.01s)\n"} {"Time":"2020-06-20T20:03:14.199396994-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2020-06-20T20:03:14.199406397-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2020-06-20T20:03:14.19941412-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2020-06-20T20:03:14.201560705-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":" TestParallelTheThird: fails_test.go:41: failed the third\n"} {"Time":"2020-06-20T20:03:14.201602937-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"--- FAIL: TestParallelTheThird (0.00s)\n"} {"Time":"2020-06-20T20:03:14.201615644-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2020-06-20T20:03:14.201630909-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2020-06-20T20:03:14.201640015-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2020-06-20T20:03:14.207765102-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":" TestParallelTheSecond: fails_test.go:35: failed the second\n"} {"Time":"2020-06-20T20:03:14.207820447-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"--- FAIL: TestParallelTheSecond (0.01s)\n"} {"Time":"2020-06-20T20:03:14.207829881-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2020-06-20T20:03:14.207838745-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Output":"FAIL\n"} {"Time":"2020-06-20T20:03:14.214087937-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/parallelfails\t0.026s\n"} {"Time":"2020-06-20T20:03:14.214125492-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Elapsed":0.026} gotestsum-1.8.2/testjson/testdata/input/go-test-json-with-shuffle.err000066400000000000000000000001511427475276200260600ustar00rootroot00000000000000# gotest.tools/gotestsum/testjson/internal/broken internal/broken/broken.go:5:21: undefined: somepackage gotestsum-1.8.2/testjson/testdata/input/go-test-json-with-shuffle.out000066400000000000000000001655671427475276200261260ustar00rootroot00000000000000{"Time":"2022-06-18T15:11:13.719272566-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Output":"sometimes main can exit 2\n"} {"Time":"2022-06-18T15:11:13.719382289-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/badmain\t0.001s\n"} {"Time":"2022-06-18T15:11:13.719390039-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Elapsed":0.001} {"Time":"2022-06-18T15:11:13.777704512-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"-test.shuffle 123456\n"} {"Time":"2022-06-18T15:11:13.777734483-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog"} {"Time":"2022-06-18T15:11:13.777740216-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2022-06-18T15:11:13.777748282-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":" good_test.go:15: this is a log\n"} {"Time":"2022-06-18T15:11:13.77775809-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777763923-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2022-06-18T15:11:13.777767625-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog"} {"Time":"2022-06-18T15:11:13.77776999-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":"=== RUN TestSkippedWitLog\n"} {"Time":"2022-06-18T15:11:13.777773479-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":" good_test.go:27: the skip message\n"} {"Time":"2022-06-18T15:11:13.777780786-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":"--- SKIP: TestSkippedWitLog (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777786682-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Elapsed":0} {"Time":"2022-06-18T15:11:13.777790402-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout"} {"Time":"2022-06-18T15:11:13.777792719-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2022-06-18T15:11:13.777795382-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2022-06-18T15:11:13.777798646-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777801558-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2022-06-18T15:11:13.777804473-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.777807157-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.777814099-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.777817138-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.777819749-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.7778274-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.777832237-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.777834773-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.777837166-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed"} {"Time":"2022-06-18T15:11:13.777839375-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2022-06-18T15:11:13.777843018-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777845671-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Elapsed":0} {"Time":"2022-06-18T15:11:13.777848092-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.777850305-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.777852842-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.777855023-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.777857268-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess"} {"Time":"2022-06-18T15:11:13.777859457-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Output":"=== RUN TestNestedSuccess\n"} {"Time":"2022-06-18T15:11:13.777861948-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a"} {"Time":"2022-06-18T15:11:13.77786423-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Output":"=== RUN TestNestedSuccess/a\n"} {"Time":"2022-06-18T15:11:13.777867527-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub"} {"Time":"2022-06-18T15:11:13.777873732-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Output":"=== RUN TestNestedSuccess/a/sub\n"} {"Time":"2022-06-18T15:11:13.77787943-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b"} {"Time":"2022-06-18T15:11:13.777883395-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Output":"=== RUN TestNestedSuccess/b\n"} {"Time":"2022-06-18T15:11:13.777886722-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub"} {"Time":"2022-06-18T15:11:13.777889003-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Output":"=== RUN TestNestedSuccess/b/sub\n"} {"Time":"2022-06-18T15:11:13.777891516-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c"} {"Time":"2022-06-18T15:11:13.777893858-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Output":"=== RUN TestNestedSuccess/c\n"} {"Time":"2022-06-18T15:11:13.777896256-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub"} {"Time":"2022-06-18T15:11:13.777904401-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Output":"=== RUN TestNestedSuccess/c/sub\n"} {"Time":"2022-06-18T15:11:13.777911807-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d"} {"Time":"2022-06-18T15:11:13.777917663-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Output":"=== RUN TestNestedSuccess/d\n"} {"Time":"2022-06-18T15:11:13.777923445-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub"} {"Time":"2022-06-18T15:11:13.777926034-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Output":"=== RUN TestNestedSuccess/d/sub\n"} {"Time":"2022-06-18T15:11:13.777931209-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Output":"--- PASS: TestNestedSuccess (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777935682-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Output":" --- PASS: TestNestedSuccess/a (0.00s)\n"} {"Time":"2022-06-18T15:11:13.77794361-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Output":" --- PASS: TestNestedSuccess/a/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777950636-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.777953523-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Elapsed":0} {"Time":"2022-06-18T15:11:13.777957232-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Output":" --- PASS: TestNestedSuccess/b (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777960384-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Output":" --- PASS: TestNestedSuccess/b/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777963169-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.777965542-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Elapsed":0} {"Time":"2022-06-18T15:11:13.777967934-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Output":" --- PASS: TestNestedSuccess/c (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777970566-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Output":" --- PASS: TestNestedSuccess/c/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777973142-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.777975497-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Elapsed":0} {"Time":"2022-06-18T15:11:13.777977959-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Output":" --- PASS: TestNestedSuccess/d (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777980757-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Output":" --- PASS: TestNestedSuccess/d/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.777983383-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.7779858-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Elapsed":0} {"Time":"2022-06-18T15:11:13.777990486-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Elapsed":0} {"Time":"2022-06-18T15:11:13.777992924-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr"} {"Time":"2022-06-18T15:11:13.777995182-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2022-06-18T15:11:13.777997748-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-18T15:11:13.778000554-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2022-06-18T15:11:13.778003879-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Elapsed":0} {"Time":"2022-06-18T15:11:13.778006329-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped"} {"Time":"2022-06-18T15:11:13.778008605-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":"=== RUN TestSkipped\n"} {"Time":"2022-06-18T15:11:13.778011126-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":" good_test.go:23: \n"} {"Time":"2022-06-18T15:11:13.778013795-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":"--- SKIP: TestSkipped (0.00s)\n"} {"Time":"2022-06-18T15:11:13.778016334-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Elapsed":0} {"Time":"2022-06-18T15:11:13.778018613-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.778020899-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.784156177-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"--- PASS: TestParallelTheSecond (0.01s)\n"} {"Time":"2022-06-18T15:11:13.784166672-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2022-06-18T15:11:13.78417064-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.784173244-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.794547049-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"--- PASS: TestParallelTheFirst (0.01s)\n"} {"Time":"2022-06-18T15:11:13.794615339-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2022-06-18T15:11:13.794638491-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.794654142-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.796697407-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"--- PASS: TestParallelTheThird (0.00s)\n"} {"Time":"2022-06-18T15:11:13.796752537-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2022-06-18T15:11:13.796796596-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"PASS\n"} {"Time":"2022-06-18T15:11:13.797234684-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"ok \tgotest.tools/gotestsum/testjson/internal/good\t0.020s\n"} {"Time":"2022-06-18T15:11:13.797314439-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Elapsed":0.02} {"Time":"2022-06-18T15:11:13.853032441-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Output":"-test.shuffle 123456\n"} {"Time":"2022-06-18T15:11:13.853049121-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.853070451-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.853074361-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.853076627-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.853078943-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog"} {"Time":"2022-06-18T15:11:13.853081117-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2022-06-18T15:11:13.853089915-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":" fails_test.go:15: this is a log\n"} {"Time":"2022-06-18T15:11:13.853094124-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853096659-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2022-06-18T15:11:13.853099731-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures"} {"Time":"2022-06-18T15:11:13.853101897-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Output":"=== RUN TestNestedParallelFailures\n"} {"Time":"2022-06-18T15:11:13.853104493-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2022-06-18T15:11:13.853106728-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== RUN TestNestedParallelFailures/a\n"} {"Time":"2022-06-18T15:11:13.853109394-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== PAUSE TestNestedParallelFailures/a\n"} {"Time":"2022-06-18T15:11:13.85311161-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2022-06-18T15:11:13.853113962-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2022-06-18T15:11:13.853134185-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== RUN TestNestedParallelFailures/b\n"} {"Time":"2022-06-18T15:11:13.853136704-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== PAUSE TestNestedParallelFailures/b\n"} {"Time":"2022-06-18T15:11:13.853143459-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2022-06-18T15:11:13.8531463-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2022-06-18T15:11:13.853148539-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== RUN TestNestedParallelFailures/c\n"} {"Time":"2022-06-18T15:11:13.85315178-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== PAUSE TestNestedParallelFailures/c\n"} {"Time":"2022-06-18T15:11:13.853154154-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2022-06-18T15:11:13.853156524-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2022-06-18T15:11:13.853174405-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== RUN TestNestedParallelFailures/d\n"} {"Time":"2022-06-18T15:11:13.853176816-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== PAUSE TestNestedParallelFailures/d\n"} {"Time":"2022-06-18T15:11:13.853178986-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2022-06-18T15:11:13.853181247-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2022-06-18T15:11:13.853183399-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== CONT TestNestedParallelFailures/a\n"} {"Time":"2022-06-18T15:11:13.85318578-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":" fails_test.go:50: failed sub a\n"} {"Time":"2022-06-18T15:11:13.853189251-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2022-06-18T15:11:13.85319159-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== CONT TestNestedParallelFailures/d\n"} {"Time":"2022-06-18T15:11:13.853195426-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":" fails_test.go:50: failed sub d\n"} {"Time":"2022-06-18T15:11:13.853197997-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2022-06-18T15:11:13.853200252-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== CONT TestNestedParallelFailures/c\n"} {"Time":"2022-06-18T15:11:13.853202644-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":" fails_test.go:50: failed sub c\n"} {"Time":"2022-06-18T15:11:13.853205081-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2022-06-18T15:11:13.853207147-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== CONT TestNestedParallelFailures/b\n"} {"Time":"2022-06-18T15:11:13.853209403-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":" fails_test.go:50: failed sub b\n"} {"Time":"2022-06-18T15:11:13.853214144-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Output":"--- FAIL: TestNestedParallelFailures (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853217368-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":" --- FAIL: TestNestedParallelFailures/a (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853219877-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Elapsed":0} {"Time":"2022-06-18T15:11:13.853222427-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":" --- FAIL: TestNestedParallelFailures/d (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853224976-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Elapsed":0} {"Time":"2022-06-18T15:11:13.853227376-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":" --- FAIL: TestNestedParallelFailures/c (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853229944-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Elapsed":0} {"Time":"2022-06-18T15:11:13.853232199-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":" --- FAIL: TestNestedParallelFailures/b (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853235581-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Elapsed":0} {"Time":"2022-06-18T15:11:13.853238036-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Elapsed":0} {"Time":"2022-06-18T15:11:13.853240285-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed"} {"Time":"2022-06-18T15:11:13.85326097-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2022-06-18T15:11:13.853263837-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853266342-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Elapsed":0} {"Time":"2022-06-18T15:11:13.853268579-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.853270715-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.853273158-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.853275333-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.853277767-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout"} {"Time":"2022-06-18T15:11:13.85327998-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2022-06-18T15:11:13.85328244-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2022-06-18T15:11:13.85328762-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853290402-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2022-06-18T15:11:13.853292638-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.853294785-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.853300913-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.853303423-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.853305871-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr"} {"Time":"2022-06-18T15:11:13.853307986-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2022-06-18T15:11:13.853310336-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-18T15:11:13.853313024-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2022-06-18T15:11:13.853316221-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Elapsed":0} {"Time":"2022-06-18T15:11:13.853318669-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.853320888-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.859479577-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":" fails_test.go:35: failed the second\n"} {"Time":"2022-06-18T15:11:13.859491761-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"--- FAIL: TestParallelTheSecond (0.01s)\n"} {"Time":"2022-06-18T15:11:13.859495479-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2022-06-18T15:11:13.859498602-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.859500849-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.869798818-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":" fails_test.go:29: failed the first\n"} {"Time":"2022-06-18T15:11:13.869884891-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"--- FAIL: TestParallelTheFirst (0.01s)\n"} {"Time":"2022-06-18T15:11:13.869909031-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2022-06-18T15:11:13.869927536-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.869962898-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.872195116-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":" fails_test.go:41: failed the third\n"} {"Time":"2022-06-18T15:11:13.87226097-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"--- FAIL: TestParallelTheThird (0.00s)\n"} {"Time":"2022-06-18T15:11:13.872286473-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2022-06-18T15:11:13.872304241-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Output":"FAIL\n"} {"Time":"2022-06-18T15:11:13.872881488-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/parallelfails\t0.020s\n"} {"Time":"2022-06-18T15:11:13.87294329-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Elapsed":0.021} {"Time":"2022-06-18T15:11:13.928278718-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Output":"-test.shuffle 123456\n"} {"Time":"2022-06-18T15:11:13.928295492-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout"} {"Time":"2022-06-18T15:11:13.928298929-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2022-06-18T15:11:13.928303582-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2022-06-18T15:11:13.928307745-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928310472-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2022-06-18T15:11:13.928313768-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.92831587-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.92831847-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.928320622-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.92832302-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped"} {"Time":"2022-06-18T15:11:13.928325837-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Output":"=== RUN TestSkipped\n"} {"Time":"2022-06-18T15:11:13.928328227-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Output":" fails_test.go:26: \n"} {"Time":"2022-06-18T15:11:13.928330912-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Output":"--- SKIP: TestSkipped (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928333245-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Elapsed":0} {"Time":"2022-06-18T15:11:13.928335429-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure"} {"Time":"2022-06-18T15:11:13.928341958-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure","Output":"=== RUN TestNestedWithFailure\n"} {"Time":"2022-06-18T15:11:13.928345542-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a"} {"Time":"2022-06-18T15:11:13.928347818-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a","Output":"=== RUN TestNestedWithFailure/a\n"} {"Time":"2022-06-18T15:11:13.928350231-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub"} {"Time":"2022-06-18T15:11:13.928357324-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub","Output":"=== RUN TestNestedWithFailure/a/sub\n"} {"Time":"2022-06-18T15:11:13.92836008-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b"} {"Time":"2022-06-18T15:11:13.928362229-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b","Output":"=== RUN TestNestedWithFailure/b\n"} {"Time":"2022-06-18T15:11:13.928364489-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub"} {"Time":"2022-06-18T15:11:13.92836653-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub","Output":"=== RUN TestNestedWithFailure/b/sub\n"} {"Time":"2022-06-18T15:11:13.928368796-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c"} {"Time":"2022-06-18T15:11:13.928370919-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Output":"=== RUN TestNestedWithFailure/c\n"} {"Time":"2022-06-18T15:11:13.928373267-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Output":" fails_test.go:65: failed\n"} {"Time":"2022-06-18T15:11:13.928375621-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d"} {"Time":"2022-06-18T15:11:13.928377772-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d","Output":"=== RUN TestNestedWithFailure/d\n"} {"Time":"2022-06-18T15:11:13.928382204-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub"} {"Time":"2022-06-18T15:11:13.928384866-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub","Output":"=== RUN TestNestedWithFailure/d/sub\n"} {"Time":"2022-06-18T15:11:13.928387788-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure","Output":"--- FAIL: TestNestedWithFailure (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928390679-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a","Output":" --- PASS: TestNestedWithFailure/a (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928393553-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub","Output":" --- PASS: TestNestedWithFailure/a/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928396315-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.928398649-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a","Elapsed":0} {"Time":"2022-06-18T15:11:13.928403333-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b","Output":" --- PASS: TestNestedWithFailure/b (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928406279-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub","Output":" --- PASS: TestNestedWithFailure/b/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.92840889-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.928411091-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b","Elapsed":0} {"Time":"2022-06-18T15:11:13.928413234-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Output":" --- FAIL: TestNestedWithFailure/c (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928415771-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Elapsed":0} {"Time":"2022-06-18T15:11:13.928418171-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d","Output":" --- PASS: TestNestedWithFailure/d (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928423431-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub","Output":" --- PASS: TestNestedWithFailure/d/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928426295-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.928428568-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d","Elapsed":0} {"Time":"2022-06-18T15:11:13.928430636-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure","Elapsed":0} {"Time":"2022-06-18T15:11:13.928432744-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr"} {"Time":"2022-06-18T15:11:13.928434883-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2022-06-18T15:11:13.928437253-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-18T15:11:13.928439884-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928442324-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Elapsed":0} {"Time":"2022-06-18T15:11:13.928444468-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed"} {"Time":"2022-06-18T15:11:13.928446568-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2022-06-18T15:11:13.928449047-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928451687-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed","Elapsed":0} {"Time":"2022-06-18T15:11:13.928453907-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog"} {"Time":"2022-06-18T15:11:13.928461252-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Output":"=== RUN TestSkippedWitLog\n"} {"Time":"2022-06-18T15:11:13.928466-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Output":" fails_test.go:30: the skip message\n"} {"Time":"2022-06-18T15:11:13.928468999-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Output":"--- SKIP: TestSkippedWitLog (0.00s)\n"} {"Time":"2022-06-18T15:11:13.92847153-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Elapsed":0} {"Time":"2022-06-18T15:11:13.928473695-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess"} {"Time":"2022-06-18T15:11:13.928475702-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess","Output":"=== RUN TestNestedSuccess\n"} {"Time":"2022-06-18T15:11:13.928480593-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a"} {"Time":"2022-06-18T15:11:13.928482967-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a","Output":"=== RUN TestNestedSuccess/a\n"} {"Time":"2022-06-18T15:11:13.928485289-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub"} {"Time":"2022-06-18T15:11:13.928489131-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub","Output":"=== RUN TestNestedSuccess/a/sub\n"} {"Time":"2022-06-18T15:11:13.92849172-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b"} {"Time":"2022-06-18T15:11:13.928493869-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b","Output":"=== RUN TestNestedSuccess/b\n"} {"Time":"2022-06-18T15:11:13.928496182-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub"} {"Time":"2022-06-18T15:11:13.92849827-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub","Output":"=== RUN TestNestedSuccess/b/sub\n"} {"Time":"2022-06-18T15:11:13.928500516-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c"} {"Time":"2022-06-18T15:11:13.928502549-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c","Output":"=== RUN TestNestedSuccess/c\n"} {"Time":"2022-06-18T15:11:13.928504955-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub"} {"Time":"2022-06-18T15:11:13.928507101-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub","Output":"=== RUN TestNestedSuccess/c/sub\n"} {"Time":"2022-06-18T15:11:13.928509394-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d"} {"Time":"2022-06-18T15:11:13.928511479-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d","Output":"=== RUN TestNestedSuccess/d\n"} {"Time":"2022-06-18T15:11:13.928513732-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub"} {"Time":"2022-06-18T15:11:13.928515777-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub","Output":"=== RUN TestNestedSuccess/d/sub\n"} {"Time":"2022-06-18T15:11:13.928518375-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess","Output":"--- PASS: TestNestedSuccess (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928520993-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a","Output":" --- PASS: TestNestedSuccess/a (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928525695-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub","Output":" --- PASS: TestNestedSuccess/a/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928528577-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.928530858-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a","Elapsed":0} {"Time":"2022-06-18T15:11:13.928533111-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b","Output":" --- PASS: TestNestedSuccess/b (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928535655-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub","Output":" --- PASS: TestNestedSuccess/b/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.92853806-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.928540205-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b","Elapsed":0} {"Time":"2022-06-18T15:11:13.928542378-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c","Output":" --- PASS: TestNestedSuccess/c (0.00s)\n"} {"Time":"2022-06-18T15:11:13.92854501-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub","Output":" --- PASS: TestNestedSuccess/c/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928547567-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.928549814-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c","Elapsed":0} {"Time":"2022-06-18T15:11:13.928552106-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d","Output":" --- PASS: TestNestedSuccess/d (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928554632-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub","Output":" --- PASS: TestNestedSuccess/d/sub (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928557014-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub","Elapsed":0} {"Time":"2022-06-18T15:11:13.928559157-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d","Elapsed":0} {"Time":"2022-06-18T15:11:13.928561272-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess","Elapsed":0} {"Time":"2022-06-18T15:11:13.928563471-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.928565611-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.928568151-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.928570378-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.928572578-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog"} {"Time":"2022-06-18T15:11:13.928575669-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2022-06-18T15:11:13.928580163-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Output":" fails_test.go:18: this is a log\n"} {"Time":"2022-06-18T15:11:13.928583227-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928585761-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2022-06-18T15:11:13.928588011-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.928590129-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.928592558-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.928594675-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.928596883-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout"} {"Time":"2022-06-18T15:11:13.928598963-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Output":"=== RUN TestTimeout\n"} {"Time":"2022-06-18T15:11:13.928601386-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Output":" timeout_test.go:13: skipping slow test\n"} {"Time":"2022-06-18T15:11:13.928604118-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Output":"--- SKIP: TestTimeout (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928606618-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Elapsed":0} {"Time":"2022-06-18T15:11:13.928608826-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr"} {"Time":"2022-06-18T15:11:13.928610893-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":"=== RUN TestFailedWithStderr\n"} {"Time":"2022-06-18T15:11:13.928613237-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-18T15:11:13.928615542-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":" fails_test.go:43: also failed\n"} {"Time":"2022-06-18T15:11:13.928618738-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":"--- FAIL: TestFailedWithStderr (0.00s)\n"} {"Time":"2022-06-18T15:11:13.92862131-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Elapsed":0} {"Time":"2022-06-18T15:11:13.928624809-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed"} {"Time":"2022-06-18T15:11:13.928627223-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Output":"=== RUN TestFailed\n"} {"Time":"2022-06-18T15:11:13.928629688-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Output":" fails_test.go:34: this failed\n"} {"Time":"2022-06-18T15:11:13.928633879-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Output":"--- FAIL: TestFailed (0.00s)\n"} {"Time":"2022-06-18T15:11:13.928638465-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Elapsed":0} {"Time":"2022-06-18T15:11:13.928640917-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-18T15:11:13.928642977-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2022-06-18T15:11:13.9387892-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"--- PASS: TestParallelTheFirst (0.01s)\n"} {"Time":"2022-06-18T15:11:13.938798979-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2022-06-18T15:11:13.938802726-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird"} {"Time":"2022-06-18T15:11:13.938805129-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2022-06-18T15:11:13.940931357-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"--- PASS: TestParallelTheThird (0.00s)\n"} {"Time":"2022-06-18T15:11:13.940941604-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2022-06-18T15:11:13.940945121-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-18T15:11:13.940947665-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2022-06-18T15:11:13.94718988-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"--- PASS: TestParallelTheSecond (0.01s)\n"} {"Time":"2022-06-18T15:11:13.947287289-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2022-06-18T15:11:13.947322143-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Output":"FAIL\n"} {"Time":"2022-06-18T15:11:13.947830871-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/withfails\t0.020s\n"} {"Time":"2022-06-18T15:11:13.947895848-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Elapsed":0.02} gotestsum-1.8.2/testjson/testdata/input/go-test-json.err000066400000000000000000000001621427475276200234570ustar00rootroot00000000000000# gotest.tools/gotestsum/testjson/internal/broken testjson/internal/broken/broken.go:5:21: undefined: somepackage gotestsum-1.8.2/testjson/testdata/input/go-test-json.out000066400000000000000000001660711427475276200235120ustar00rootroot00000000000000{"Time":"2022-06-19T13:44:44.850960153-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Output":"sometimes main can exit 2\n"} {"Time":"2022-06-19T13:44:44.851078953-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/badmain\t0.001s\n"} {"Time":"2022-06-19T13:44:44.851087257-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/badmain","Elapsed":0.001} {"Time":"2022-06-19T13:44:44.855135812-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/empty","Output":"testing: warning: no tests to run\n"} {"Time":"2022-06-19T13:44:44.855143976-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/empty","Output":"PASS\n"} {"Time":"2022-06-19T13:44:44.855147691-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/empty","Output":"ok \tgotest.tools/gotestsum/testjson/internal/empty\t(cached) [no tests to run]\n"} {"Time":"2022-06-19T13:44:44.855151131-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/empty","Elapsed":0} {"Time":"2022-06-19T13:44:44.859682146-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed"} {"Time":"2022-06-19T13:44:44.859690198-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2022-06-19T13:44:44.859696077-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859699224-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassed","Elapsed":0} {"Time":"2022-06-19T13:44:44.859701901-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog"} {"Time":"2022-06-19T13:44:44.859704199-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2022-06-19T13:44:44.859706845-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":" good_test.go:15: this is a log\n"} {"Time":"2022-06-19T13:44:44.859709737-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859712195-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2022-06-19T13:44:44.859714391-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout"} {"Time":"2022-06-19T13:44:44.859716575-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2022-06-19T13:44:44.859719038-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2022-06-19T13:44:44.859721732-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859724262-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2022-06-19T13:44:44.859726506-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped"} {"Time":"2022-06-19T13:44:44.859728601-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":"=== RUN TestSkipped\n"} {"Time":"2022-06-19T13:44:44.859730999-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":" good_test.go:23: \n"} {"Time":"2022-06-19T13:44:44.859738124-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Output":"--- SKIP: TestSkipped (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859741082-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkipped","Elapsed":0} {"Time":"2022-06-19T13:44:44.859743399-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog"} {"Time":"2022-06-19T13:44:44.859745575-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":"=== RUN TestSkippedWitLog\n"} {"Time":"2022-06-19T13:44:44.859747962-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":" good_test.go:27: the skip message\n"} {"Time":"2022-06-19T13:44:44.859750682-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Output":"--- SKIP: TestSkippedWitLog (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859753158-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestSkippedWitLog","Elapsed":0} {"Time":"2022-06-19T13:44:44.859755305-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr"} {"Time":"2022-06-19T13:44:44.859757397-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2022-06-19T13:44:44.859759841-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-19T13:44:44.859762418-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859765298-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestWithStderr","Elapsed":0} {"Time":"2022-06-19T13:44:44.859767584-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.859769797-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.859772324-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.859774461-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.859776697-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.859778932-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.85978148-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.859783707-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.859786009-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.859788165-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.859790551-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.859792663-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.859797122-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess"} {"Time":"2022-06-19T13:44:44.859799552-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Output":"=== RUN TestNestedSuccess\n"} {"Time":"2022-06-19T13:44:44.859802001-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a"} {"Time":"2022-06-19T13:44:44.859804221-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Output":"=== RUN TestNestedSuccess/a\n"} {"Time":"2022-06-19T13:44:44.859807062-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub"} {"Time":"2022-06-19T13:44:44.859809331-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Output":"=== RUN TestNestedSuccess/a/sub\n"} {"Time":"2022-06-19T13:44:44.859811712-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b"} {"Time":"2022-06-19T13:44:44.859813776-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Output":"=== RUN TestNestedSuccess/b\n"} {"Time":"2022-06-19T13:44:44.859816106-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub"} {"Time":"2022-06-19T13:44:44.859818297-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Output":"=== RUN TestNestedSuccess/b/sub\n"} {"Time":"2022-06-19T13:44:44.859820689-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c"} {"Time":"2022-06-19T13:44:44.85982284-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Output":"=== RUN TestNestedSuccess/c\n"} {"Time":"2022-06-19T13:44:44.859825214-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub"} {"Time":"2022-06-19T13:44:44.859829069-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Output":"=== RUN TestNestedSuccess/c/sub\n"} {"Time":"2022-06-19T13:44:44.859832685-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d"} {"Time":"2022-06-19T13:44:44.859834876-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Output":"=== RUN TestNestedSuccess/d\n"} {"Time":"2022-06-19T13:44:44.859837245-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub"} {"Time":"2022-06-19T13:44:44.859839467-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Output":"=== RUN TestNestedSuccess/d/sub\n"} {"Time":"2022-06-19T13:44:44.859842632-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Output":"--- PASS: TestNestedSuccess (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859845452-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Output":" --- PASS: TestNestedSuccess/a (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859848379-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Output":" --- PASS: TestNestedSuccess/a/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859850991-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.859853265-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/a","Elapsed":0} {"Time":"2022-06-19T13:44:44.859857313-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Output":" --- PASS: TestNestedSuccess/b (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859860205-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Output":" --- PASS: TestNestedSuccess/b/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859862788-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.85986508-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/b","Elapsed":0} {"Time":"2022-06-19T13:44:44.859867507-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Output":" --- PASS: TestNestedSuccess/c (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859870066-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Output":" --- PASS: TestNestedSuccess/c/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859872517-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.859874632-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/c","Elapsed":0} {"Time":"2022-06-19T13:44:44.859876814-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Output":" --- PASS: TestNestedSuccess/d (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859879455-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Output":" --- PASS: TestNestedSuccess/d/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859881961-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.859884191-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess/d","Elapsed":0} {"Time":"2022-06-19T13:44:44.859886372-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestNestedSuccess","Elapsed":0} {"Time":"2022-06-19T13:44:44.859888513-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.859890567-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.8598932-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Output":"--- PASS: TestParallelTheFirst (0.01s)\n"} {"Time":"2022-06-19T13:44:44.859895611-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2022-06-19T13:44:44.85989839-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.859900572-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.859902923-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.859905116-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.859907803-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Output":"--- PASS: TestParallelTheThird (0.00s)\n"} {"Time":"2022-06-19T13:44:44.859913525-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2022-06-19T13:44:44.859916116-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Output":"--- PASS: TestParallelTheSecond (0.01s)\n"} {"Time":"2022-06-19T13:44:44.859918336-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2022-06-19T13:44:44.859920892-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"PASS\n"} {"Time":"2022-06-19T13:44:44.859923345-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/good","Output":"ok \tgotest.tools/gotestsum/testjson/internal/good\t(cached)\n"} {"Time":"2022-06-19T13:44:44.859926497-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/good","Elapsed":0} {"Time":"2022-06-19T13:44:44.914299027-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed"} {"Time":"2022-06-19T13:44:44.914322345-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2022-06-19T13:44:44.914332487-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914336528-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassed","Elapsed":0} {"Time":"2022-06-19T13:44:44.914340657-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog"} {"Time":"2022-06-19T13:44:44.914343018-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2022-06-19T13:44:44.914345542-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":" fails_test.go:15: this is a log\n"} {"Time":"2022-06-19T13:44:44.914348788-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914351368-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2022-06-19T13:44:44.91435378-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout"} {"Time":"2022-06-19T13:44:44.914356071-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2022-06-19T13:44:44.914358557-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2022-06-19T13:44:44.914361316-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914364274-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2022-06-19T13:44:44.914366514-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr"} {"Time":"2022-06-19T13:44:44.914368785-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2022-06-19T13:44:44.914371203-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-19T13:44:44.914379591-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914382623-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestWithStderr","Elapsed":0} {"Time":"2022-06-19T13:44:44.914384983-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.914387195-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.914389844-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.914391974-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.914396245-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.914398768-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.914401349-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.914403593-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.914405943-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.914408079-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.914410513-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.91441271-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.914414995-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures"} {"Time":"2022-06-19T13:44:44.914419031-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Output":"=== RUN TestNestedParallelFailures\n"} {"Time":"2022-06-19T13:44:44.914422001-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2022-06-19T13:44:44.914424349-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== RUN TestNestedParallelFailures/a\n"} {"Time":"2022-06-19T13:44:44.914426897-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== PAUSE TestNestedParallelFailures/a\n"} {"Time":"2022-06-19T13:44:44.914429136-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2022-06-19T13:44:44.914431319-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2022-06-19T13:44:44.914433488-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== RUN TestNestedParallelFailures/b\n"} {"Time":"2022-06-19T13:44:44.914438246-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== PAUSE TestNestedParallelFailures/b\n"} {"Time":"2022-06-19T13:44:44.914440864-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2022-06-19T13:44:44.914443168-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2022-06-19T13:44:44.914445351-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== RUN TestNestedParallelFailures/c\n"} {"Time":"2022-06-19T13:44:44.91444796-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== PAUSE TestNestedParallelFailures/c\n"} {"Time":"2022-06-19T13:44:44.914450169-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2022-06-19T13:44:44.914452457-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2022-06-19T13:44:44.914454603-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== RUN TestNestedParallelFailures/d\n"} {"Time":"2022-06-19T13:44:44.914457163-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== PAUSE TestNestedParallelFailures/d\n"} {"Time":"2022-06-19T13:44:44.914459404-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2022-06-19T13:44:44.914461734-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a"} {"Time":"2022-06-19T13:44:44.914463919-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":"=== CONT TestNestedParallelFailures/a\n"} {"Time":"2022-06-19T13:44:44.91446636-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":" fails_test.go:50: failed sub a\n"} {"Time":"2022-06-19T13:44:44.914468803-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d"} {"Time":"2022-06-19T13:44:44.914470889-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":"=== CONT TestNestedParallelFailures/d\n"} {"Time":"2022-06-19T13:44:44.914473333-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":" fails_test.go:50: failed sub d\n"} {"Time":"2022-06-19T13:44:44.914475904-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c"} {"Time":"2022-06-19T13:44:44.914478123-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":"=== CONT TestNestedParallelFailures/c\n"} {"Time":"2022-06-19T13:44:44.914483755-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":" fails_test.go:50: failed sub c\n"} {"Time":"2022-06-19T13:44:44.914486923-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b"} {"Time":"2022-06-19T13:44:44.914489165-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":"=== CONT TestNestedParallelFailures/b\n"} {"Time":"2022-06-19T13:44:44.914493631-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":" fails_test.go:50: failed sub b\n"} {"Time":"2022-06-19T13:44:44.914496817-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Output":"--- FAIL: TestNestedParallelFailures (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914500835-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Output":" --- FAIL: TestNestedParallelFailures/a (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914503606-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/a","Elapsed":0} {"Time":"2022-06-19T13:44:44.914506103-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Output":" --- FAIL: TestNestedParallelFailures/d (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914508601-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/d","Elapsed":0} {"Time":"2022-06-19T13:44:44.914510945-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Output":" --- FAIL: TestNestedParallelFailures/c (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914513457-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/c","Elapsed":0} {"Time":"2022-06-19T13:44:44.914515814-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Output":" --- FAIL: TestNestedParallelFailures/b (0.00s)\n"} {"Time":"2022-06-19T13:44:44.914518402-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures/b","Elapsed":0} {"Time":"2022-06-19T13:44:44.914520636-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestNestedParallelFailures","Elapsed":0} {"Time":"2022-06-19T13:44:44.914522794-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.914524941-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.92468079-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":" fails_test.go:29: failed the first\n"} {"Time":"2022-06-19T13:44:44.924695036-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Output":"--- FAIL: TestParallelTheFirst (0.01s)\n"} {"Time":"2022-06-19T13:44:44.924699091-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2022-06-19T13:44:44.924702442-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.924704814-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.926875975-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":" fails_test.go:41: failed the third\n"} {"Time":"2022-06-19T13:44:44.926887145-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Output":"--- FAIL: TestParallelTheThird (0.00s)\n"} {"Time":"2022-06-19T13:44:44.926895283-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2022-06-19T13:44:44.926900965-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.926903673-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.933091105-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":" fails_test.go:35: failed the second\n"} {"Time":"2022-06-19T13:44:44.933104623-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Output":"--- FAIL: TestParallelTheSecond (0.01s)\n"} {"Time":"2022-06-19T13:44:44.933108555-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2022-06-19T13:44:44.933117874-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Output":"FAIL\n"} {"Time":"2022-06-19T13:44:44.933266292-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/parallelfails\t0.020s\n"} {"Time":"2022-06-19T13:44:44.933277617-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/parallelfails","Elapsed":0.02} {"Time":"2022-06-19T13:44:44.988286791-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed"} {"Time":"2022-06-19T13:44:44.988309483-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed","Output":"=== RUN TestPassed\n"} {"Time":"2022-06-19T13:44:44.988318625-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed","Output":"--- PASS: TestPassed (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988321998-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassed","Elapsed":0} {"Time":"2022-06-19T13:44:44.988327026-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog"} {"Time":"2022-06-19T13:44:44.988329525-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Output":"=== RUN TestPassedWithLog\n"} {"Time":"2022-06-19T13:44:44.988333414-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Output":" fails_test.go:18: this is a log\n"} {"Time":"2022-06-19T13:44:44.988336781-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Output":"--- PASS: TestPassedWithLog (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988339579-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithLog","Elapsed":0} {"Time":"2022-06-19T13:44:44.988343267-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout"} {"Time":"2022-06-19T13:44:44.988345671-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Output":"=== RUN TestPassedWithStdout\n"} {"Time":"2022-06-19T13:44:44.988348122-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Output":"this is a Print\n"} {"Time":"2022-06-19T13:44:44.988352011-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Output":"--- PASS: TestPassedWithStdout (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988360671-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestPassedWithStdout","Elapsed":0} {"Time":"2022-06-19T13:44:44.988363604-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped"} {"Time":"2022-06-19T13:44:44.988365906-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Output":"=== RUN TestSkipped\n"} {"Time":"2022-06-19T13:44:44.988368362-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Output":" fails_test.go:26: \n"} {"Time":"2022-06-19T13:44:44.988371175-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Output":"--- SKIP: TestSkipped (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988373636-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkipped","Elapsed":0} {"Time":"2022-06-19T13:44:44.988375885-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog"} {"Time":"2022-06-19T13:44:44.988378012-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Output":"=== RUN TestSkippedWitLog\n"} {"Time":"2022-06-19T13:44:44.988380515-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Output":" fails_test.go:30: the skip message\n"} {"Time":"2022-06-19T13:44:44.988383329-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Output":"--- SKIP: TestSkippedWitLog (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988385879-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestSkippedWitLog","Elapsed":0} {"Time":"2022-06-19T13:44:44.988388139-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed"} {"Time":"2022-06-19T13:44:44.988390375-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Output":"=== RUN TestFailed\n"} {"Time":"2022-06-19T13:44:44.9883928-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Output":" fails_test.go:34: this failed\n"} {"Time":"2022-06-19T13:44:44.988397411-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Output":"--- FAIL: TestFailed (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988400233-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailed","Elapsed":0} {"Time":"2022-06-19T13:44:44.988402503-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr"} {"Time":"2022-06-19T13:44:44.98840471-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Output":"=== RUN TestWithStderr\n"} {"Time":"2022-06-19T13:44:44.988407249-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-19T13:44:44.988409861-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Output":"--- PASS: TestWithStderr (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988412375-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestWithStderr","Elapsed":0} {"Time":"2022-06-19T13:44:44.988414596-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr"} {"Time":"2022-06-19T13:44:44.988416673-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":"=== RUN TestFailedWithStderr\n"} {"Time":"2022-06-19T13:44:44.988419171-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":"this is stderr\n"} {"Time":"2022-06-19T13:44:44.988423763-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":" fails_test.go:43: also failed\n"} {"Time":"2022-06-19T13:44:44.988426857-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Output":"--- FAIL: TestFailedWithStderr (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988429392-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestFailedWithStderr","Elapsed":0} {"Time":"2022-06-19T13:44:44.988431656-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.988433767-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"=== RUN TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.988436368-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"=== PAUSE TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.988439303-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.988444219-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.988446969-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"=== RUN TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.988449626-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"=== PAUSE TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:44.98845187-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:44.988454283-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.988456446-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"=== RUN TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.988459099-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"=== PAUSE TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:44.988461303-04:00","Action":"pause","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.988463656-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure"} {"Time":"2022-06-19T13:44:44.988465773-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure","Output":"=== RUN TestNestedWithFailure\n"} {"Time":"2022-06-19T13:44:44.988468505-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a"} {"Time":"2022-06-19T13:44:44.988470734-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a","Output":"=== RUN TestNestedWithFailure/a\n"} {"Time":"2022-06-19T13:44:44.98847318-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub"} {"Time":"2022-06-19T13:44:44.988476992-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub","Output":"=== RUN TestNestedWithFailure/a/sub\n"} {"Time":"2022-06-19T13:44:44.988479651-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b"} {"Time":"2022-06-19T13:44:44.988483849-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b","Output":"=== RUN TestNestedWithFailure/b\n"} {"Time":"2022-06-19T13:44:44.988487591-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub"} {"Time":"2022-06-19T13:44:44.988489875-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub","Output":"=== RUN TestNestedWithFailure/b/sub\n"} {"Time":"2022-06-19T13:44:44.988492281-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c"} {"Time":"2022-06-19T13:44:44.988496036-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Output":"=== RUN TestNestedWithFailure/c\n"} {"Time":"2022-06-19T13:44:44.988498593-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Output":" fails_test.go:65: failed\n"} {"Time":"2022-06-19T13:44:44.988501248-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d"} {"Time":"2022-06-19T13:44:44.988503447-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d","Output":"=== RUN TestNestedWithFailure/d\n"} {"Time":"2022-06-19T13:44:44.988505839-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub"} {"Time":"2022-06-19T13:44:44.988507989-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub","Output":"=== RUN TestNestedWithFailure/d/sub\n"} {"Time":"2022-06-19T13:44:44.988511055-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure","Output":"--- FAIL: TestNestedWithFailure (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988514438-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a","Output":" --- PASS: TestNestedWithFailure/a (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988517904-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub","Output":" --- PASS: TestNestedWithFailure/a/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988523195-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.988525729-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/a","Elapsed":0} {"Time":"2022-06-19T13:44:44.98852807-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b","Output":" --- PASS: TestNestedWithFailure/b (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988530709-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub","Output":" --- PASS: TestNestedWithFailure/b/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988533344-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.988535616-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/b","Elapsed":0} {"Time":"2022-06-19T13:44:44.988538003-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Output":" --- FAIL: TestNestedWithFailure/c (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988540575-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/c","Elapsed":0} {"Time":"2022-06-19T13:44:44.98854506-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d","Output":" --- PASS: TestNestedWithFailure/d (0.00s)\n"} {"Time":"2022-06-19T13:44:44.98854805-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub","Output":" --- PASS: TestNestedWithFailure/d/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.98855307-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.988555926-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure/d","Elapsed":0} {"Time":"2022-06-19T13:44:44.988558303-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedWithFailure","Elapsed":0} {"Time":"2022-06-19T13:44:44.988560552-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess"} {"Time":"2022-06-19T13:44:44.988562729-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess","Output":"=== RUN TestNestedSuccess\n"} {"Time":"2022-06-19T13:44:44.988565175-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a"} {"Time":"2022-06-19T13:44:44.988567397-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a","Output":"=== RUN TestNestedSuccess/a\n"} {"Time":"2022-06-19T13:44:44.988569785-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub"} {"Time":"2022-06-19T13:44:44.988571867-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub","Output":"=== RUN TestNestedSuccess/a/sub\n"} {"Time":"2022-06-19T13:44:44.988574229-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b"} {"Time":"2022-06-19T13:44:44.988576451-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b","Output":"=== RUN TestNestedSuccess/b\n"} {"Time":"2022-06-19T13:44:44.988578815-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub"} {"Time":"2022-06-19T13:44:44.988582115-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub","Output":"=== RUN TestNestedSuccess/b/sub\n"} {"Time":"2022-06-19T13:44:44.988584739-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c"} {"Time":"2022-06-19T13:44:44.988586907-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c","Output":"=== RUN TestNestedSuccess/c\n"} {"Time":"2022-06-19T13:44:44.988589239-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub"} {"Time":"2022-06-19T13:44:44.988591329-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub","Output":"=== RUN TestNestedSuccess/c/sub\n"} {"Time":"2022-06-19T13:44:44.98859374-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d"} {"Time":"2022-06-19T13:44:44.988595912-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d","Output":"=== RUN TestNestedSuccess/d\n"} {"Time":"2022-06-19T13:44:44.988598349-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub"} {"Time":"2022-06-19T13:44:44.988600634-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub","Output":"=== RUN TestNestedSuccess/d/sub\n"} {"Time":"2022-06-19T13:44:44.988605352-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess","Output":"--- PASS: TestNestedSuccess (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988608372-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a","Output":" --- PASS: TestNestedSuccess/a (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988611012-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub","Output":" --- PASS: TestNestedSuccess/a/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988613572-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.98861593-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/a","Elapsed":0} {"Time":"2022-06-19T13:44:44.988618293-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b","Output":" --- PASS: TestNestedSuccess/b (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988620939-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub","Output":" --- PASS: TestNestedSuccess/b/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988623564-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.988625803-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/b","Elapsed":0} {"Time":"2022-06-19T13:44:44.988628103-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c","Output":" --- PASS: TestNestedSuccess/c (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988630639-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub","Output":" --- PASS: TestNestedSuccess/c/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.98863313-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.988635513-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/c","Elapsed":0} {"Time":"2022-06-19T13:44:44.988637857-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d","Output":" --- PASS: TestNestedSuccess/d (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988640843-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub","Output":" --- PASS: TestNestedSuccess/d/sub (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988643545-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d/sub","Elapsed":0} {"Time":"2022-06-19T13:44:44.988645759-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess/d","Elapsed":0} {"Time":"2022-06-19T13:44:44.988647935-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestNestedSuccess","Elapsed":0} {"Time":"2022-06-19T13:44:44.988651152-04:00","Action":"run","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout"} {"Time":"2022-06-19T13:44:44.988653488-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Output":"=== RUN TestTimeout\n"} {"Time":"2022-06-19T13:44:44.988655954-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Output":" timeout_test.go:13: skipping slow test\n"} {"Time":"2022-06-19T13:44:44.988661116-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Output":"--- SKIP: TestTimeout (0.00s)\n"} {"Time":"2022-06-19T13:44:44.988663887-04:00","Action":"skip","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestTimeout","Elapsed":0} {"Time":"2022-06-19T13:44:44.988666175-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst"} {"Time":"2022-06-19T13:44:44.988668308-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"=== CONT TestParallelTheFirst\n"} {"Time":"2022-06-19T13:44:44.998837463-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Output":"--- PASS: TestParallelTheFirst (0.01s)\n"} {"Time":"2022-06-19T13:44:44.998850256-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheFirst","Elapsed":0.01} {"Time":"2022-06-19T13:44:44.998854422-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird"} {"Time":"2022-06-19T13:44:44.998856909-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"=== CONT TestParallelTheThird\n"} {"Time":"2022-06-19T13:44:45.000973652-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Output":"--- PASS: TestParallelTheThird (0.00s)\n"} {"Time":"2022-06-19T13:44:45.000983481-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheThird","Elapsed":0} {"Time":"2022-06-19T13:44:45.000986998-04:00","Action":"cont","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond"} {"Time":"2022-06-19T13:44:45.000989406-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"=== CONT TestParallelTheSecond\n"} {"Time":"2022-06-19T13:44:45.007312431-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Output":"--- PASS: TestParallelTheSecond (0.01s)\n"} {"Time":"2022-06-19T13:44:45.007374647-04:00","Action":"pass","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Test":"TestParallelTheSecond","Elapsed":0.01} {"Time":"2022-06-19T13:44:45.007398746-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Output":"FAIL\n"} {"Time":"2022-06-19T13:44:45.007878468-04:00","Action":"output","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Output":"FAIL\tgotest.tools/gotestsum/testjson/internal/withfails\t0.020s\n"} {"Time":"2022-06-19T13:44:45.00795073-04:00","Action":"fail","Package":"gotest.tools/gotestsum/testjson/internal/withfails","Elapsed":0.02} gotestsum-1.8.2/testjson/testdata/summary/000077500000000000000000000000001427475276200207535ustar00rootroot00000000000000gotestsum-1.8.2/testjson/testdata/summary/bug-missing-skip-message000066400000000000000000000007161427475276200255140ustar00rootroot00000000000000 === Skipped === SKIP: testjson TestNewDotFormatter (0.00s) WARN Failed to detect terminal width for dots format, error: inappropriate ioctl for device TestNewDotFormatter: dotformat_test.go:161: !ok: no terminal width === SKIP: testjson TestGetPkgPathPrefix/with_go_path (0.00s) TestGetPkgPathPrefix/with_go_path: pkgpathprefix_test.go:22: isGoModuleEnabled() --- SKIP: TestGetPkgPathPrefix/with_go_path (0.00s) DONE 42 tests, 2 skipped in 0.000s gotestsum-1.8.2/testjson/testdata/summary/bug-repeated-test-case-output000066400000000000000000000141761427475276200264770ustar00rootroot00000000000000 === Skipped === SKIP: testjson/internal/good TestSkipped (0.00s) good_test.go:23: === SKIP: testjson/internal/good TestSkippedWitLog (0.00s) good_test.go:27: the skip message === SKIP: testjson/internal/good TestSkipped (0.00s) good_test.go:23: === SKIP: testjson/internal/good TestSkippedWitLog (0.00s) good_test.go:27: the skip message === SKIP: testjson/internal/good TestSkipped (0.00s) good_test.go:23: === SKIP: testjson/internal/good TestSkippedWitLog (0.00s) good_test.go:27: the skip message === SKIP: testjson/internal/withfails TestSkipped (0.00s) fails_test.go:26: === SKIP: testjson/internal/withfails TestSkippedWitLog (0.00s) fails_test.go:30: the skip message === SKIP: testjson/internal/withfails TestTimeout (0.00s) timeout_test.go:13: skipping slow test === SKIP: testjson/internal/withfails TestSkipped (0.00s) fails_test.go:26: === SKIP: testjson/internal/withfails TestSkippedWitLog (0.00s) fails_test.go:30: the skip message === SKIP: testjson/internal/withfails TestTimeout (0.00s) timeout_test.go:13: skipping slow test === SKIP: testjson/internal/withfails TestSkipped (0.00s) fails_test.go:26: === SKIP: testjson/internal/withfails TestSkippedWitLog (0.00s) fails_test.go:30: the skip message === SKIP: testjson/internal/withfails TestTimeout (0.00s) timeout_test.go:13: skipping slow test === Failed === FAIL: testjson/internal/badmain (0.00s) sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/a (0.00s) fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/d (0.00s) fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/c (0.00s) fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/b (0.00s) fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures (0.00s) === FAIL: testjson/internal/parallelfails TestParallelTheFirst (0.01s) fails_test.go:29: failed the first === FAIL: testjson/internal/parallelfails TestParallelTheThird (0.00s) fails_test.go:41: failed the third === FAIL: testjson/internal/parallelfails TestParallelTheSecond (0.01s) fails_test.go:35: failed the second === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/a (0.00s) fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/d (0.00s) fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/c (0.00s) fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/b (0.00s) fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures (0.00s) === FAIL: testjson/internal/parallelfails TestParallelTheFirst (0.01s) fails_test.go:29: failed the first === FAIL: testjson/internal/parallelfails TestParallelTheThird (0.00s) fails_test.go:41: failed the third === FAIL: testjson/internal/parallelfails TestParallelTheSecond (0.01s) fails_test.go:35: failed the second === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/a (0.00s) fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/d (0.00s) fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/c (0.00s) fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/b (0.00s) fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures (0.00s) === FAIL: testjson/internal/parallelfails TestParallelTheFirst (0.01s) fails_test.go:29: failed the first === FAIL: testjson/internal/parallelfails TestParallelTheThird (0.00s) fails_test.go:41: failed the third === FAIL: testjson/internal/parallelfails TestParallelTheSecond (0.01s) fails_test.go:35: failed the second === FAIL: testjson/internal/withfails TestFailed (0.00s) fails_test.go:34: this failed === FAIL: testjson/internal/withfails TestFailedWithStderr (0.00s) this is stderr fails_test.go:43: also failed === FAIL: testjson/internal/withfails TestNestedWithFailure/c (0.00s) fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) === FAIL: testjson/internal/withfails TestNestedWithFailure (0.00s) === FAIL: testjson/internal/withfails TestFailed (0.00s) fails_test.go:34: this failed === FAIL: testjson/internal/withfails TestFailedWithStderr (0.00s) this is stderr fails_test.go:43: also failed === FAIL: testjson/internal/withfails TestNestedWithFailure/c (0.00s) fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) === FAIL: testjson/internal/withfails TestNestedWithFailure (0.00s) === FAIL: testjson/internal/withfails TestFailed (0.00s) fails_test.go:34: this failed === FAIL: testjson/internal/withfails TestFailedWithStderr (0.00s) this is stderr fails_test.go:43: also failed === FAIL: testjson/internal/withfails TestNestedWithFailure/c (0.00s) fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) === FAIL: testjson/internal/withfails TestNestedWithFailure (0.00s) DONE 177 tests, 15 skipped, 37 failures in 0.000s gotestsum-1.8.2/testjson/testdata/summary/misattributed-output000066400000000000000000000015061427475276200251160ustar00rootroot00000000000000 === Failed === FAIL: TestOutputWithSubtest (0.00s) --- PASS: TestOutputWithSubtest/sub_test (0.00s) foo_test.go:9: output from sub test foo_test.go:11: more output from sub test foo_test.go:16: more output from sub test --- PASS: TestOutputWithSubtest/sub_test/sub2 (0.00s) foo_test.go:14: output from sub2 test foo_test.go:22: output from root test foo_test.go:27: output from root test --- PASS: TestOutputWithSubtest/sub_test2 (0.00s) foo_test.go:21: output from sub test2 foo_test.go:23: more output from sub test2 foo_test.go:28: more output from sub test2 --- PASS: TestOutputWithSubtest/sub_test2/sub2 (0.00s) foo_test.go:26: output from sub2 test foo_test.go:32: output after sub test DONE 5 tests, 1 failure in 0.000s gotestsum-1.8.2/testjson/testdata/summary/missing-test-fail-event000066400000000000000000000023771427475276200253650ustar00rootroot00000000000000 === Failed === FAIL: gotest.tools/v3/poll TestWaitOn_WithCompare (unknown) panic: runtime error: index out of range [1] with length 1 goroutine 7 [running]: gotest.tools/v3/internal/assert.ArgsFromComparisonCall(0xc0000552a0, 0x1, 0x1, 0x1, 0x0, 0x0) /home/daniel/pers/code/gotest.tools/internal/assert/result.go:102 +0x9f gotest.tools/v3/internal/assert.runComparison(0x6bcb80, 0xc00000e180, 0x67dee8, 0xc00007a9f0, 0x0, 0x0, 0x0, 0x7f7f4fb6d108) /home/daniel/pers/code/gotest.tools/internal/assert/result.go:34 +0x2b1 gotest.tools/v3/internal/assert.Eval(0x6bcb80, 0xc00000e180, 0x67dee8, 0x627660, 0xc00007a9f0, 0x0, 0x0, 0x0, 0x642c60) /home/daniel/pers/code/gotest.tools/internal/assert/assert.go:56 +0x2e4 gotest.tools/v3/poll.Compare(0xc00007a9f0, 0x6b74a0, 0x618a60) /home/daniel/pers/code/gotest.tools/poll/poll.go:151 +0x81 gotest.tools/v3/poll.TestWaitOn_WithCompare.func1(0x6be4c0, 0xc00016c240, 0xc00016c240, 0x6be4c0) /home/daniel/pers/code/gotest.tools/poll/poll_test.go:81 +0x58 gotest.tools/v3/poll.WaitOn.func1(0xc00001e3c0, 0x67df50, 0x6c1960, 0xc00016c240) /home/daniel/pers/code/gotest.tools/poll/poll.go:125 +0x62 created by gotest.tools/v3/poll.WaitOn /home/daniel/pers/code/gotest.tools/poll/poll.go:124 +0x16f DONE 1 tests, 1 failure in 0.000s gotestsum-1.8.2/testjson/testdata/summary/parallel-failures000066400000000000000000000024401427475276200243020ustar00rootroot00000000000000 === Failed === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/a (0.00s) TestNestedParallelFailures/a: fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/d (0.00s) TestNestedParallelFailures/d: fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/c (0.00s) TestNestedParallelFailures/c: fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/b (0.00s) TestNestedParallelFailures/b: fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures (0.00s) === FAIL: testjson/internal/parallelfails TestParallelTheFirst (0.01s) TestParallelTheFirst: fails_test.go:29: failed the first === FAIL: testjson/internal/parallelfails TestParallelTheThird (0.00s) TestParallelTheThird: fails_test.go:41: failed the third === FAIL: testjson/internal/parallelfails TestParallelTheSecond (0.01s) TestParallelTheSecond: fails_test.go:35: failed the second DONE 12 tests, 8 failures in 0.000s gotestsum-1.8.2/testjson/testdata/summary/root-test-has-subtest-failures000066400000000000000000000041701427475276200267100ustar00rootroot00000000000000 === Skipped === SKIP: testjson/internal/good TestSkipped (0.00s) good_test.go:23: === SKIP: testjson/internal/good TestSkippedWitLog (0.00s) good_test.go:27: the skip message === SKIP: testjson/internal/withfails TestSkipped (0.00s) fails_test.go:26: === SKIP: testjson/internal/withfails TestSkippedWitLog (0.00s) fails_test.go:30: the skip message === SKIP: testjson/internal/withfails TestTimeout (0.00s) timeout_test.go:13: skipping slow test === Failed === FAIL: testjson/internal/badmain (0.00s) sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/a (0.00s) fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/d (0.00s) fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/c (0.00s) fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/b (0.00s) fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures (0.00s) === FAIL: testjson/internal/parallelfails TestParallelTheFirst (0.01s) fails_test.go:29: failed the first === FAIL: testjson/internal/parallelfails TestParallelTheThird (0.00s) fails_test.go:41: failed the third === FAIL: testjson/internal/parallelfails TestParallelTheSecond (0.01s) fails_test.go:35: failed the second === FAIL: testjson/internal/withfails TestFailed (0.00s) fails_test.go:34: this failed === FAIL: testjson/internal/withfails TestFailedWithStderr (0.00s) this is stderr fails_test.go:43: also failed === FAIL: testjson/internal/withfails TestNestedWithFailure/c (0.00s) fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) === FAIL: testjson/internal/withfails TestNestedWithFailure (0.00s) DONE 59 tests, 5 skipped, 13 failures in 0.000s gotestsum-1.8.2/testjson/testdata/summary/with-run-id000066400000000000000000000044731427475276200230550ustar00rootroot00000000000000 === Skipped === SKIP: testjson/internal/good TestSkipped (re-run 7) (0.00s) good_test.go:23: === SKIP: testjson/internal/good TestSkippedWitLog (re-run 7) (0.00s) good_test.go:27: the skip message === SKIP: testjson/internal/withfails TestSkipped (re-run 7) (0.00s) fails_test.go:26: === SKIP: testjson/internal/withfails TestSkippedWitLog (re-run 7) (0.00s) fails_test.go:30: the skip message === SKIP: testjson/internal/withfails TestTimeout (re-run 7) (0.00s) timeout_test.go:13: skipping slow test === Failed === FAIL: testjson/internal/badmain (0.00s) sometimes main can exit 2 FAIL gotest.tools/gotestsum/testjson/internal/badmain 0.001s === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/a (re-run 7) (0.00s) fails_test.go:50: failed sub a --- FAIL: TestNestedParallelFailures/a (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/d (re-run 7) (0.00s) fails_test.go:50: failed sub d --- FAIL: TestNestedParallelFailures/d (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/c (re-run 7) (0.00s) fails_test.go:50: failed sub c --- FAIL: TestNestedParallelFailures/c (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures/b (re-run 7) (0.00s) fails_test.go:50: failed sub b --- FAIL: TestNestedParallelFailures/b (0.00s) === FAIL: testjson/internal/parallelfails TestNestedParallelFailures (re-run 7) (0.00s) === FAIL: testjson/internal/parallelfails TestParallelTheFirst (re-run 7) (0.01s) fails_test.go:29: failed the first === FAIL: testjson/internal/parallelfails TestParallelTheThird (re-run 7) (0.00s) fails_test.go:41: failed the third === FAIL: testjson/internal/parallelfails TestParallelTheSecond (re-run 7) (0.01s) fails_test.go:35: failed the second === FAIL: testjson/internal/withfails TestFailed (re-run 7) (0.00s) fails_test.go:34: this failed === FAIL: testjson/internal/withfails TestFailedWithStderr (re-run 7) (0.00s) this is stderr fails_test.go:43: also failed === FAIL: testjson/internal/withfails TestNestedWithFailure/c (re-run 7) (0.00s) fails_test.go:65: failed --- FAIL: TestNestedWithFailure/c (0.00s) === FAIL: testjson/internal/withfails TestNestedWithFailure (re-run 7) (0.00s) DONE 8 runs, 59 tests, 5 skipped, 13 failures in 0.000s