Showing preview only (2,542K chars total). Download the full file or copy to clipboard to get everything.
Repository: onsi/ginkgo
Branch: master
Commit: c1021613df43
Files: 498
Total size: 2.3 MB
Directory structure:
gitextract__qud01z3/
├── .github/
│ ├── FUNDING.yml
│ ├── dependabot.yml
│ └── workflows/
│ ├── codeql-analysis.yml
│ └── test.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── RELEASING.md
├── config/
│ └── deprecated.go
├── core_dsl.go
├── decorator_dsl.go
├── deprecated_dsl.go
├── docs/
│ ├── .gitignore
│ ├── Gemfile
│ ├── MIGRATING_TO_V2.md
│ ├── _config.yml
│ ├── _layouts/
│ │ └── default.html
│ ├── css/
│ │ ├── layout.css
│ │ └── primer-minimal.css
│ ├── docs_suite_test.go
│ ├── index.md
│ └── js/
│ └── docs.js
├── dsl/
│ ├── core/
│ │ └── core_dsl.go
│ ├── decorators/
│ │ └── decorators_dsl.go
│ ├── dsl_suite_test.go
│ ├── reporting/
│ │ └── reporting_dsl.go
│ └── table/
│ └── table_dsl.go
├── extensions/
│ ├── globals/
│ │ ├── globals.go
│ │ └── globals_test.go
│ └── table/
│ └── deprecated.go
├── formatter/
│ ├── colorable_others.go
│ ├── colorable_windows.go
│ ├── formatter.go
│ ├── formatter_suite_test.go
│ └── formatter_test.go
├── ginkgo/
│ ├── automaxprocs/
│ │ ├── README.md
│ │ ├── automaxprocs.go
│ │ ├── cgroup.go
│ │ ├── cgroups.go
│ │ ├── cgroups2.go
│ │ ├── cpu_quota_linux.go
│ │ ├── cpu_quota_unsupported.go
│ │ ├── errors.go
│ │ ├── mountpoint.go
│ │ ├── runtime.go
│ │ └── subsys.go
│ ├── automaxprocs.go
│ ├── build/
│ │ └── build_command.go
│ ├── command/
│ │ ├── abort.go
│ │ ├── abort_test.go
│ │ ├── command.go
│ │ ├── command_suite_test.go
│ │ ├── command_test.go
│ │ ├── program.go
│ │ └── program_test.go
│ ├── generators/
│ │ ├── boostrap_templates.go
│ │ ├── bootstrap_command.go
│ │ ├── generate_command.go
│ │ ├── generate_templates.go
│ │ └── generators_common.go
│ ├── ginkgo_cli_suite_test.go
│ ├── ginkgo_cli_test.go
│ ├── internal/
│ │ ├── cli_internal_suite_test.go
│ │ ├── compile.go
│ │ ├── gocovmerge.go
│ │ ├── profiles_and_reports.go
│ │ ├── run.go
│ │ ├── test_suite.go
│ │ ├── testsuite_test.go
│ │ ├── utils.go
│ │ ├── utils_test.go
│ │ └── verify_version.go
│ ├── labels/
│ │ └── labels_command.go
│ ├── main.go
│ ├── outline/
│ │ ├── _testdata/
│ │ │ ├── alias_test.go
│ │ │ ├── alias_test.go.csv
│ │ │ ├── alias_test.go.json
│ │ │ ├── create_result.sh
│ │ │ ├── csv_proper_escaping_test.go
│ │ │ ├── csv_proper_escaping_test.go.csv
│ │ │ ├── csv_proper_escaping_test.go.json
│ │ │ ├── dsl_core_test.go
│ │ │ ├── dsl_core_test.go.csv
│ │ │ ├── dsl_core_test.go.json
│ │ │ ├── focused_test.go
│ │ │ ├── focused_test.go.csv
│ │ │ ├── focused_test.go.json
│ │ │ ├── labels_test.go
│ │ │ ├── labels_test.go.csv
│ │ │ ├── labels_test.go.json
│ │ │ ├── mixed_test.go
│ │ │ ├── mixed_test.go.csv
│ │ │ ├── mixed_test.go.json
│ │ │ ├── nestedfocused_test.go
│ │ │ ├── nestedfocused_test.go.csv
│ │ │ ├── nestedfocused_test.go.json
│ │ │ ├── nodot_test.go
│ │ │ ├── nodot_test.go.csv
│ │ │ ├── nodot_test.go.json
│ │ │ ├── normal_test.go
│ │ │ ├── normal_test.go.csv
│ │ │ ├── normal_test.go.json
│ │ │ ├── pending_decorator_test.go
│ │ │ ├── pending_decorator_test.go.csv
│ │ │ ├── pending_decorator_test.go.json
│ │ │ ├── pending_test.go
│ │ │ ├── pending_test.go.csv
│ │ │ ├── pending_test.go.json
│ │ │ ├── position_test.go
│ │ │ ├── position_test.go.csv
│ │ │ ├── position_test.go.json
│ │ │ ├── suite_test.go
│ │ │ ├── suite_test.go.csv
│ │ │ └── suite_test.go.json
│ │ ├── ginkgo.go
│ │ ├── import.go
│ │ ├── outline.go
│ │ ├── outline_command.go
│ │ ├── outline_suite_test.go
│ │ └── outline_test.go
│ ├── performance/
│ │ ├── _fixtures/
│ │ │ ├── large_suite_fixture/
│ │ │ │ └── large_suite_suite_test.go
│ │ │ └── performance_fixture/
│ │ │ ├── go.mod
│ │ │ ├── go.sum
│ │ │ ├── performance.go
│ │ │ ├── performance_suite_test.go
│ │ │ ├── pkg1/
│ │ │ │ └── pkg1_suite_test.go
│ │ │ ├── pkg2/
│ │ │ │ └── pkg2_suite_test.go
│ │ │ ├── pkg3/
│ │ │ │ └── pkg3_suite_test.go
│ │ │ └── pkg4/
│ │ │ └── pkg4_suite_test.go
│ │ ├── compiling-and-running-multiple-cache/
│ │ │ ├── 096fe2f06efcf59513adb6cb0275d32a.gmeasure-cache
│ │ │ ├── 1baac032c37c6eddc8381c02f73bab9c.gmeasure-cache
│ │ │ ├── 2daaa9348ce35e03f3fb34ec83ffc542.gmeasure-cache
│ │ │ ├── 34fa32127a8597d465872129ed999b27.gmeasure-cache
│ │ │ ├── 585dde06f8799aa0686577e4c76eee50.gmeasure-cache
│ │ │ ├── 5dde0a74da03182e70d258dbc7f9da5e.gmeasure-cache
│ │ │ ├── 63f93d6849139270a9cf6c7562b5c5c2.gmeasure-cache
│ │ │ ├── 7e079ed53f27697e0ae7f18ed2eef571.gmeasure-cache
│ │ │ ├── 952f6c671d14a219922ff81d601950dc.gmeasure-cache
│ │ │ ├── cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache
│ │ │ ├── d913553546dde110d20fd36aa954b145.gmeasure-cache
│ │ │ ├── e8c3ef1eebd492c875763c75066b201d.gmeasure-cache
│ │ │ ├── f63d60f305dbd4ac27febbc09ca9d000.gmeasure-cache
│ │ │ ├── f871828d82f74ed614c36d8f8d27f7f5.gmeasure-cache
│ │ │ └── ff4e55f973b442272532f4ac2daa0b13.gmeasure-cache
│ │ ├── compiling-and-running-single-cache/
│ │ │ ├── 2daaa9348ce35e03f3fb34ec83ffc542.gmeasure-cache
│ │ │ ├── cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache
│ │ │ └── d913553546dde110d20fd36aa954b145.gmeasure-cache
│ │ ├── compiling_and_running_test.go
│ │ ├── fetching-dependencies-cache/
│ │ │ ├── 1baac032c37c6eddc8381c02f73bab9c.gmeasure-cache
│ │ │ ├── 23a884dc38ea0cf973e24d00d94dd6ed.gmeasure-cache
│ │ │ ├── 55354cfa01f77f2c0d502c798e2b8262.gmeasure-cache
│ │ │ ├── 5eb5d96af3c34f61a070c450dddbf894.gmeasure-cache
│ │ │ ├── 63f93d6849139270a9cf6c7562b5c5c2.gmeasure-cache
│ │ │ ├── 952f6c671d14a219922ff81d601950dc.gmeasure-cache
│ │ │ ├── cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache
│ │ │ └── e8c3ef1eebd492c875763c75066b201d.gmeasure-cache
│ │ ├── fetching_dependencies_test.go
│ │ ├── large-suite-cache/
│ │ │ ├── 29caa3726740f30e27035121724c5be5.gmeasure-cache
│ │ │ ├── 483027456d601caec33292dbf280ca13.gmeasure-cache
│ │ │ ├── 54b26463f7c006bbf018993ad3bb66fc.gmeasure-cache
│ │ │ ├── 6f1839af2f330e23013bdb24a846760c.gmeasure-cache
│ │ │ ├── e3c9c7bf7ee9b54d714975dcc0babed2.gmeasure-cache
│ │ │ ├── e6de2fca259bb2567b057a5ec1929134.gmeasure-cache
│ │ │ └── f9eea3525ae1eb0c1aea29bb32267883.gmeasure-cache
│ │ ├── large_suite_test.go
│ │ └── performance_suite_test.go
│ ├── run/
│ │ └── run_command.go
│ ├── unfocus/
│ │ └── unfocus_command.go
│ └── watch/
│ ├── delta.go
│ ├── delta_tracker.go
│ ├── dependencies.go
│ ├── package_hash.go
│ ├── package_hashes.go
│ ├── suite.go
│ └── watch_command.go
├── ginkgo_cli_dependencies.go
├── ginkgo_t_dsl.go
├── go.mod
├── go.sum
├── integration/
│ ├── _fixtures/
│ │ ├── abort_fixture/
│ │ │ └── abort_fixture_suite_test.go
│ │ ├── after_run_hook_fixture/
│ │ │ ├── after_run_hook.go
│ │ │ ├── after_run_hook_suite_test.go
│ │ │ └── after_run_hook_test.go
│ │ ├── build_reporting_fixture/
│ │ │ ├── suite1/
│ │ │ │ ├── build_reporting_1_suite_test.go
│ │ │ │ └── build_reporting_1_test.go
│ │ │ └── suite2/
│ │ │ ├── build_reporting_2_suite_test.go
│ │ │ └── build_reporting_2_test.go
│ │ ├── combined_coverage_fixture/
│ │ │ ├── first_package/
│ │ │ │ ├── coverage.go
│ │ │ │ ├── coverage_fixture_suite_test.go
│ │ │ │ ├── coverage_fixture_test.go
│ │ │ │ └── external_coverage/
│ │ │ │ └── external_coverage.go
│ │ │ ├── second_package/
│ │ │ │ ├── coverage.go
│ │ │ │ ├── coverage_fixture_suite_test.go
│ │ │ │ └── coverage_fixture_test.go
│ │ │ └── third_package/
│ │ │ └── third_package_suite_test.go
│ │ ├── config_override_label_filter_fixture/
│ │ │ └── config_override_fixture_suite_test.go
│ │ ├── config_override_must_pass_repeatedly_fixture/
│ │ │ └── config_override_fixture_suite_test.go
│ │ ├── coverage_fixture/
│ │ │ ├── additional_spec/
│ │ │ │ └── additional_spec_suite_test.go
│ │ │ ├── coverage.go
│ │ │ ├── coverage_fixture_suite_test.go
│ │ │ ├── coverage_fixture_test.go
│ │ │ └── external_coverage/
│ │ │ └── external_coverage.go
│ │ ├── decorations_fixture/
│ │ │ ├── flaky_repeated/
│ │ │ │ └── flaky_repeated_fixture_suite_test.go
│ │ │ ├── invalid_decorations_flakeattempts_mustpassrepeatedly/
│ │ │ │ └── invalid_decorations_flakeattempts_mustpassrepeatedly_suite_test.go
│ │ │ ├── invalid_decorations_focused_pending/
│ │ │ │ └── invalid_decorations_focused_pending_suite_test.go
│ │ │ └── offset_focus_pending/
│ │ │ ├── never_see_this_file_test.go
│ │ │ └── offset_focus_pending_fixture_suite_test.go
│ │ ├── deprecated_features_fixture/
│ │ │ └── deprecated_features_fixture_suite_test.go
│ │ ├── does_not_compile_fixture/
│ │ │ ├── does_not_compile_suite_test.go
│ │ │ └── does_not_compile_test.go
│ │ ├── eventually_failing_fixture/
│ │ │ ├── eventually_failing_suite_test.go
│ │ │ └── eventually_failing_test.go
│ │ ├── exiting_synchronized_setup_fixture/
│ │ │ └── exiting_synchronized_setup_suite_test.go
│ │ ├── fail_fixture/
│ │ │ ├── fail_fixture_ginkgo_t_test.go
│ │ │ ├── fail_fixture_ginkgo_tb_test.go
│ │ │ ├── fail_fixture_suite_test.go
│ │ │ └── fail_fixture_test.go
│ │ ├── fail_then_hang_fixture/
│ │ │ └── fail_then_hang_fixture_suite_test.go
│ │ ├── failing_ginkgo_tests_fixture/
│ │ │ ├── failing_ginkgo_tests.go
│ │ │ ├── failing_ginkgo_tests_suite_test.go
│ │ │ └── failing_ginkgo_tests_test.go
│ │ ├── filter_fixture/
│ │ │ ├── filter_suite_test.go
│ │ │ ├── nugget_a_test.go
│ │ │ ├── nugget_b_test.go
│ │ │ ├── sprocket_a_test.go
│ │ │ ├── sprocket_b_test.go
│ │ │ ├── sprocket_c_test.go
│ │ │ ├── widget_a_test.go
│ │ │ └── widget_b_test.go
│ │ ├── flags_fixture/
│ │ │ ├── flags.go
│ │ │ ├── flags_suite_test.go
│ │ │ └── flags_test.go
│ │ ├── focused_fixture/
│ │ │ ├── README.md
│ │ │ ├── focused_fixture_suite_test.go
│ │ │ ├── focused_fixture_test.go
│ │ │ └── internal/
│ │ │ ├── focused_fixture_suite_test.go
│ │ │ └── focused_fixture_test.go
│ │ ├── focused_with_vendor_fixture/
│ │ │ ├── focused_fixture_suite_test.go
│ │ │ ├── focused_fixture_test.go
│ │ │ └── vendor/
│ │ │ ├── foo/
│ │ │ │ ├── bar/
│ │ │ │ │ └── bar.go
│ │ │ │ └── foo.go
│ │ │ └── vendored.go
│ │ ├── hanging_fixture/
│ │ │ ├── hanging_suite_test.go
│ │ │ └── hanging_test.go
│ │ ├── interceptor_fixture/
│ │ │ ├── interceptor_fixture_suite_test.go
│ │ │ └── main.go
│ │ ├── interceptor_sleep_fixture/
│ │ │ └── interceptor_fixture_suite_test.go
│ │ ├── labels_fixture/
│ │ │ ├── labels.go
│ │ │ ├── labels_fixture_suite_test.go
│ │ │ ├── labels_fixture_test.go
│ │ │ ├── nolabels/
│ │ │ │ ├── nolabels_suite_test.go
│ │ │ │ └── nolabels_test.go
│ │ │ └── onepkg/
│ │ │ ├── onepkg.go
│ │ │ ├── onepkg_suite_test.go
│ │ │ └── onepkg_test.go
│ │ ├── large_fixture/
│ │ │ └── large_fixture_suite_test.go
│ │ ├── malformed_by_fixture/
│ │ │ └── malformed_by_fixture_suite_test.go
│ │ ├── malformed_fixture/
│ │ │ ├── malformed_fixture_suite_test.go
│ │ │ └── malformed_fixture_test.go
│ │ ├── more_ginkgo_tests_fixture/
│ │ │ ├── more_ginkgo_tests.go
│ │ │ ├── more_ginkgo_tests_suite_test.go
│ │ │ └── more_ginkgo_tests_test.go
│ │ ├── no_tagged_tests_fixture/
│ │ │ ├── doc.go
│ │ │ └── no_tagged_tests_fixture_suite_test.go
│ │ ├── no_test_fn_fixture/
│ │ │ ├── no_test_fn.go
│ │ │ └── no_test_fn_test.go
│ │ ├── no_tests_fixture/
│ │ │ └── no_tests.go
│ │ ├── nondeterministic_fixture/
│ │ │ ├── file_a_test.go
│ │ │ ├── file_b_test.go
│ │ │ └── nondeterministic_fixture_suite_test.go
│ │ ├── ordered_fixture/
│ │ │ └── ordered_fixture_suite_test.go
│ │ ├── passing_ginkgo_tests_fixture/
│ │ │ ├── passing_ginkgo_tests.go
│ │ │ ├── passing_ginkgo_tests_suite_test.go
│ │ │ └── passing_ginkgo_tests_test.go
│ │ ├── pause_resume_interception_fixture/
│ │ │ └── pause_resume_interception_fixture_suite_test.go
│ │ ├── preview_fixture/
│ │ │ └── preview_fixture_suite_test.go
│ │ ├── profile_fixture/
│ │ │ ├── block_contest/
│ │ │ │ ├── block_contest.go
│ │ │ │ └── block_contest_suite_test.go
│ │ │ ├── lock_contest/
│ │ │ │ ├── lock_contest.go
│ │ │ │ └── lock_contest_suite_test.go
│ │ │ └── slow_memory_hog/
│ │ │ ├── slow_memory_hog.go
│ │ │ └── slow_memory_hog_suite_test.go
│ │ ├── progress_report_fixture/
│ │ │ ├── progress_report_fixture_suite_test.go
│ │ │ └── progress_report_test.go
│ │ ├── report_entries_fixture/
│ │ │ └── report_entries_fixture_suite_test.go
│ │ ├── reporting_fixture/
│ │ │ ├── malformed_sub_package/
│ │ │ │ └── malformed_sub_package_suite_test.go
│ │ │ ├── nonginkgo_sub_package/
│ │ │ │ └── a_test.go
│ │ │ ├── reporting_fixture_suite_test.go
│ │ │ ├── reporting_fixture_test.go
│ │ │ └── reporting_sub_package/
│ │ │ ├── reporting_sub_package_suite_test.go
│ │ │ └── reporting_sub_package_test.go
│ │ ├── rerun_specs_fixture/
│ │ │ └── rerun_specs_suite_test.go
│ │ ├── seed_fixture/
│ │ │ └── seed_fixture_suite_test.go
│ │ ├── semver_fixture/
│ │ │ ├── semver_fixture_suite_test.go
│ │ │ ├── semver_test.go
│ │ │ └── spechierarchy/
│ │ │ └── spechierarchy_suite_test.go
│ │ ├── serial_fixture/
│ │ │ └── serial_fixture_suite_test.go
│ │ ├── skip_fixture/
│ │ │ ├── skip_fixture_suite_test.go
│ │ │ └── skip_fixture_test.go
│ │ ├── symbol_fixture/
│ │ │ └── symbol_fixture_suite_test.go
│ │ ├── synchronized_setup_tests_fixture/
│ │ │ └── synchronized_setup_tests_suite_test.go
│ │ ├── tags_fixture/
│ │ │ ├── ignored_test.go
│ │ │ ├── tags_tests_suite_test.go
│ │ │ └── tags_tests_test.go
│ │ ├── timeline_fixture/
│ │ │ └── timeline_fixture_suite_test.go
│ │ ├── timeout_fixture/
│ │ │ ├── timeout_A/
│ │ │ │ └── timeout_A_suite_test.go
│ │ │ ├── timeout_B/
│ │ │ │ └── timeout_B_suite_test.go
│ │ │ ├── timeout_C/
│ │ │ │ └── timeout_C_suite_test.go
│ │ │ └── timeout_D/
│ │ │ └── timeout_D_suite_test.go
│ │ ├── version_mismatch_fixture/
│ │ │ ├── go.mod
│ │ │ ├── go.sum
│ │ │ └── version_mismatch_fixture_suite_test.go
│ │ ├── watch_fixture/
│ │ │ ├── A/
│ │ │ │ ├── A.go
│ │ │ │ ├── A_suite_test.go
│ │ │ │ └── A_test.go
│ │ │ ├── B/
│ │ │ │ ├── B.go
│ │ │ │ ├── B_suite_test.go
│ │ │ │ └── B_test.go
│ │ │ ├── C/
│ │ │ │ ├── C.go
│ │ │ │ ├── C.json
│ │ │ │ ├── C_suite_test.go
│ │ │ │ └── C_test.go
│ │ │ └── D/
│ │ │ ├── D.go
│ │ │ ├── D_suite_test.go
│ │ │ └── D_test.go
│ │ └── xunit_fixture/
│ │ ├── xunit_tests.go
│ │ └── xunit_tests_test.go
│ ├── abort_test.go
│ ├── decorations_test.go
│ ├── deprecations_test.go
│ ├── fail_test.go
│ ├── filter_test.go
│ ├── flags_test.go
│ ├── integration.go
│ ├── integration_suite_test.go
│ ├── interrupt_test.go
│ ├── output_interceptor_test.go
│ ├── precompiled_test.go
│ ├── preview_test.go
│ ├── profiling_go1.21_test.go
│ ├── profiling_go1.22_test.go
│ ├── profiling_test.go
│ ├── progress_test.go
│ ├── repeat_test.go
│ ├── report_entries_test.go
│ ├── reporting_test.go
│ ├── run_test.go
│ ├── skip_test.go
│ ├── subcommand_test.go
│ ├── suite_command_test.go
│ ├── suite_setup_test.go
│ ├── tags_test.go
│ ├── timeline_test.go
│ ├── verbose_and_succinct_test.go
│ └── watch_test.go
├── internal/
│ ├── around_node.go
│ ├── counter.go
│ ├── counter_test.go
│ ├── failer.go
│ ├── failer_test.go
│ ├── focus.go
│ ├── focus_test.go
│ ├── global/
│ │ └── init.go
│ ├── group.go
│ ├── internal_integration/
│ │ ├── abort_test.go
│ │ ├── around_node_test.go
│ │ ├── cleanup_test.go
│ │ ├── config_dry_run_test.go
│ │ ├── config_fail_fast_test.go
│ │ ├── config_flake_attempts_test.go
│ │ ├── config_must_pass_repeatedly_test.go
│ │ ├── current_spec_report_test.go
│ │ ├── decorations_test.go
│ │ ├── fail_test.go
│ │ ├── focus_test.go
│ │ ├── internal_integration_suite_test.go
│ │ ├── interrupt_and_timeout_test.go
│ │ ├── labels_test.go
│ │ ├── node_spec_events_test.go
│ │ ├── ordered_test.go
│ │ ├── parallel_test.go
│ │ ├── progress_report_test.go
│ │ ├── report_each_test.go
│ │ ├── report_entries_test.go
│ │ ├── report_suite_test.go
│ │ ├── run_test.go
│ │ ├── serial_test.go
│ │ ├── shuffle_test.go
│ │ ├── skip_test.go
│ │ ├── spec_priority_test.go
│ │ ├── synchronized_suite_nodes_test.go
│ │ ├── table_test.go
│ │ └── timeline_test.go
│ ├── internal_suite_test.go
│ ├── interrupt_handler/
│ │ ├── interrupt_handler.go
│ │ ├── interrupt_handler_test.go
│ │ ├── interrupthandler_suite_test.go
│ │ ├── sigquit_swallower_unix.go
│ │ └── sigquit_swallower_windows.go
│ ├── node.go
│ ├── node_test.go
│ ├── ordering.go
│ ├── ordering_test.go
│ ├── output_interceptor.go
│ ├── output_interceptor_test.go
│ ├── output_interceptor_unix.go
│ ├── output_interceptor_wasm.go
│ ├── output_interceptor_win.go
│ ├── parallel_support/
│ │ ├── client_server.go
│ │ ├── client_server_test.go
│ │ ├── http_client.go
│ │ ├── http_server.go
│ │ ├── parallel_support_suite_test.go
│ │ ├── rpc_client.go
│ │ ├── rpc_server.go
│ │ └── server_handler.go
│ ├── progress_report.go
│ ├── progress_report_bsd.go
│ ├── progress_report_test.go
│ ├── progress_report_unix.go
│ ├── progress_report_wasm.go
│ ├── progress_report_win.go
│ ├── progress_reporter_manager.go
│ ├── progress_reporter_manager_test.go
│ ├── report_entry.go
│ ├── report_entry_test.go
│ ├── reporters/
│ │ ├── gojson.go
│ │ ├── gojson_event_writer.go
│ │ └── gojson_reporter.go
│ ├── spec.go
│ ├── spec_context.go
│ ├── spec_context_test.go
│ ├── spec_test.go
│ ├── suite.go
│ ├── suite_test.go
│ ├── test_helpers/
│ │ ├── docs.go
│ │ ├── fake_interrupt_handler.go
│ │ ├── fake_output_interceptor.go
│ │ ├── fake_reporter.go
│ │ ├── multiline_helpers.go
│ │ ├── run_tracker.go
│ │ ├── set_up_server.go
│ │ └── status_code_poller.go
│ ├── testingtproxy/
│ │ ├── testing_t_proxy.go
│ │ ├── testingtproxy_suite_test.go
│ │ └── testingtproxy_test.go
│ ├── tree.go
│ ├── tree_test.go
│ ├── writer.go
│ └── writer_test.go
├── reporters/
│ ├── __snapshots__/
│ │ ├── gojson_report_test.snap
│ │ ├── junit_report_test.snap
│ │ └── teamcity_report_test.snap
│ ├── default_reporter.go
│ ├── default_reporter_test.go
│ ├── deprecated_reporter.go
│ ├── deprecated_reporter_test.go
│ ├── gojson_report.go
│ ├── gojson_report_test.go
│ ├── json_report.go
│ ├── json_report_test.go
│ ├── junit_report.go
│ ├── junit_report_test.go
│ ├── reporter.go
│ ├── reporters_suite_test.go
│ ├── teamcity_report.go
│ └── teamcity_report_test.go
├── reporting_dsl.go
├── table_dsl.go
└── types/
├── around_node.go
├── around_node_test.go
├── code_location.go
├── code_location_test.go
├── config.go
├── config_test.go
├── deprecated_support_test.go
├── deprecated_types.go
├── deprecated_types_test.go
├── deprecation_support.go
├── enum_support.go
├── errors.go
├── errors_test.go
├── file_filter.go
├── file_filters_test.go
├── flags.go
├── flags_test.go
├── label_filter.go
├── label_filter_test.go
├── report_entry.go
├── semver_filter.go
├── semver_filter_test.go
├── types.go
├── types_suite_test.go
├── types_test.go
└── version.go
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/FUNDING.yml
================================================
github: [onsi]
================================================
FILE: .github/dependabot.yml
================================================
version: 2
updates:
- package-ecosystem: "bundler"
directory: "/docs"
schedule:
interval: daily
time: '01:00'
open-pull-requests-limit: 5
- package-ecosystem: gomod
directory: "/"
schedule:
interval: daily
time: '01:00'
open-pull-requests-limit: 5
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: daily
time: '01:00'
open-pull-requests-limit: 5
================================================
FILE: .github/workflows/codeql-analysis.yml
================================================
# For most projects, this workflow file will not need changing; you simply need
# to commit it to your repository.
#
# You may wish to alter this file to override the set of languages analyzed,
# or to provide custom queries or build logic.
#
# ******** NOTE ********
# We have attempted to detect the languages in your repository. Please check
# the `language` matrix defined below to confirm you have the correct set of
# supported CodeQL languages.
#
name: "CodeQL"
on:
push:
branches: [ master ]
pull_request:
# The branches below must be a subset of the branches above
branches: [ master ]
schedule:
- cron: '21 7 * * 0'
permissions:
contents: read
jobs:
analyze:
permissions:
actions: read # for github/codeql-action/init to get workflow details
contents: read # for actions/checkout to fetch code
security-events: write # for github/codeql-action/autobuild to send a status report
name: Analyze
runs-on: ubuntu-latest
strategy:
fail-fast: false
matrix:
language: [ 'go', 'ruby' ]
# CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
# Learn more:
# https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
steps:
- name: Checkout repository
uses: actions/checkout@v5
# Initializes the CodeQL tools for scanning.
- name: Initialize CodeQL
uses: github/codeql-action/init@v3
with:
languages: ${{ matrix.language }}
# If you wish to specify custom queries, you can do so here or in a config file.
# By default, queries listed here will override any specified in a config file.
# Prefix the list here with "+" to use these queries and those in the config file.
# queries: ./path/to/local/query, your-org/your-repo/queries@main
# Autobuild attempts to build any compiled languages (C/C++, C#, or Java).
# If this step fails, then you should remove it and run the build manually (see below)
- name: Autobuild
uses: github/codeql-action/autobuild@v3
# ℹ️ Command-line programs to run using the OS shell.
# 📚 https://git.io/JvXDl
# ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
# and modify them (or add more) to build your code if your project
# uses a compiled language
#- run: |
# make bootstrap
# make release
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v3
================================================
FILE: .github/workflows/test.yml
================================================
name: test
on: [push, pull_request]
permissions:
contents: read
jobs:
mod:
runs-on: ubuntu-latest
name: Check modules
steps:
- uses: actions/setup-go@v6
with:
go-version: 'oldstable'
- uses: actions/checkout@v5
- run: go mod tidy && git diff --exit-code go.mod go.sum
build:
runs-on: ubuntu-latest
strategy:
matrix:
version: [ 'oldstable', 'stable' ]
name: Go ${{ matrix.version }}
steps:
- uses: actions/setup-go@v6
with:
go-version: ${{ matrix.version }}
- uses: actions/checkout@v5
- run: go vet ./...
- run: go run ./ginkgo --github-output -r -randomize-all -randomize-suites -race -trace -procs=2 -poll-progress-after=10s -poll-progress-interval=10s
================================================
FILE: .gitignore
================================================
.DS_Store
TODO
tmp/**/*
*.coverprofile
.vscode
.idea/
*.log
*.test
================================================
FILE: CHANGELOG.md
================================================
## 2.28.1
Update all dependencies. This auto-updated the required version of Go to 1.24, consistent with the fact that Go 1.23 has been out of support for almost six months.
## 2.28.0
Ginkgo's SemVer filter now supports filtering multiple components by SemVer version:
```go
It("should work in a specific version range (1.0.0, 2.0.0) and third-party dependency redis in [8.0.0, ~)", SemVerConstraint(">= 3.2.0"), ComponentSemVerConstraint("redis", ">= 8.0.0") func() {
// This test will only run when version is between 1.0.0 (exclusive) and 2.0.0 (exclusive) and redis version is >= 8.0.0
})
```
can be filtered in or out with an invocation like:
```bash
ginkgo --sem-ver-filter="2.1.1, redis=8.2.0"
```
Huge thanks to @Icarus9913 for working on this!
## 2.27.5
### Fixes
Don't make a new formatter for each GinkgoT(); that's just silly and uses precious memory
## 2.27.4
### Fixes
- CurrentTreeConstructionNodeReport: fix for nested container nodes [59bc751]
## 2.27.3
### Fixes
report exit result in case of failure [1c9f356]
fix data race [ece19c8]
## 2.27.2
### Fixes
- inline automaxprocs to simplify dependencies; this will be removed when Go 1.26 comes out [a69113a]
### Maintenance
- Fix syntax errors and typo [a99c6e0]
- Fix paragraph position error [f993df5]
## 2.27.1
### Fixes
- Fix Ginkgo Reporter slice-bounds panic [606c1cb]
- Bug Fix: Add GinkoTBWrapper.Attr() and GinkoTBWrapper.Output() [a6463b3]
## 2.27.0
### Features
#### Transforming Nodes during Tree Construction
This release adds support for `NodeArgsTransformer`s that can be registered with `AddTreeConstructionNodeArgsTransformer`.
These are called during the tree construction phase as nodes are constructed and can modify the node strings and decorators. This enables frameworks built on top of Ginkgo to modify Ginkgo nodes and enforce conventions.
Learn more [here](https://onsi.github.io/ginkgo/#advanced-transforming-node-arguments-during-tree-construction).
#### Spec Prioritization
A new `SpecPriority(int)` decorator has been added. Ginkgo will honor priority when ordering specs, ensuring that higher priority specs start running before lower priority specs
Learn more [here](https://onsi.github.io/ginkgo/#prioritizing-specs).
### Maintenance
- Bump rexml from 3.4.0 to 3.4.2 in /docs (#1595) [1333dae]
- Bump github.com/gkampitakis/go-snaps from 0.5.14 to 0.5.15 (#1600) [17ae63e]
## 2.26.0
### Features
Ginkgo can now generate json-formatted reports that are compatible with the `go test` json format. Use `ginkgo --gojson-report=report.go.json`. This is not intended to be a replacement for Ginkgo's native json format which is more information rich and better models Ginkgo's test structure semantics.
## 2.25.3
### Fixes
- emit --github-output group only for progress report itself [f01aed1]
## 2.25.2
### Fixes
Add github output group for progress report content
### Maintenance
Bump Gomega
## 2.25.1
### Fixes
- fix(types): ignore nameless nodes on FullText() [10866d3]
- chore: fix some CodeQL warnings [2e42cff]
## 2.25.0
### `AroundNode`
This release introduces a new decorator to support more complex spec setup usecases.
`AroundNode` registers a function that runs before each individual node. This is considered a more advanced decorator.
Please read the [docs](https://onsi.github.io/ginkgo/#advanced-around-node) for more information and some examples.
Allowed signatures:
- `AroundNode(func())` - `func` will be called before the node is run.
- `AroundNode(func(ctx context.Context) context.Context)` - `func` can wrap the passed in context and return a new one which will be passed on to the node.
- `AroundNode(func(ctx context.Context, body func(ctx context.Context)))` - `ctx` is the context for the node and `body` is a function that must be called to run the node. This gives you complete control over what runs before and after the node.
Multiple `AroundNode` decorators can be applied to a single node and they will run in the order they are applied.
Unlike setup nodes like `BeforeEach` and `DeferCleanup`, `AroundNode` is guaranteed to run in the same goroutine as the decorated node. This is necessary when working with lower-level libraries that must run on a single thread (you can call `runtime.LockOSThread()` in the `AroundNode` to ensure that the node runs on a single thread).
Since `AroundNode` allows you to modify the context you can also use `AroundNode` to implement shared setup that attaches values to the context.
If applied to a container, `AroundNode` will run before every node in the container. Including setup nodes like `BeforeEach` and `DeferCleanup`.
`AroundNode` can also be applied to `RunSpecs` to run before every node in the suite. This opens up new mechanisms for instrumenting individual nodes across an entire suite.
## 2.24.0
### Features
Specs can now be decorated with (e.g.) `SemVerConstraint("2.1.0")` and `ginkgo --sem-ver-filter="2.1.1"` will only run constrained specs that match the requested version. Learn more in the docs [here](https://onsi.github.io/ginkgo/#spec-semantic-version-filtering)! Thanks to @Icarus9913 for the PR.
### Fixes
- remove -o from run command [3f5d379]. fixes [#1582](https://github.com/onsi/ginkgo/issues/1582)
### Maintenance
Numerous dependency bumps and documentation fixes
## 2.23.4
Prior to this release Ginkgo would compute the incorrect number of available CPUs when running with `-p` in a linux container. Thanks to @emirot for the fix!
### Features
- Add automaxprocs for using CPUQuota [2b9c428]
### Fixes
- clarify gotchas about -vet flag [1f59d07]
### Maintenance
- bump dependencies [2d134d5]
## 2.23.3
### Fixes
- allow `-` as a standalone argument [cfcc1a5]
- Bug Fix: Add GinkoTBWrapper.Chdir() and GinkoTBWrapper.Context() [feaf292]
- ignore exit code for symbol test on linux [88e2282]
## 2.23.2
🎉🎉🎉
At long last, some long-standing performance gaps between `ginkgo` and `go test` have been resolved!
Ginkgo operates by running `go test -c` to generate test binaries, and then running those binaries. It turns out that the compilation step of `go test -c` is slower than `go test`'s compilation step because `go test` strips out debug symbols (`ldflags=-w`) whereas `go test -c` does not.
Ginkgo now passes the appropriate `ldflags` to `go test -c` when running specs to strip out symbols. This is only done when it is safe to do so and symbols are preferred when profiling is enabled and when `ginkgo build` is called explicitly.
This, coupled, with the [instructions for disabling XProtect on MacOS](https://onsi.github.io/ginkgo/#if-you-are-running-on-macos) yields a much better performance experience with Ginkgo.
## 2.23.1
## 🚨 For users on MacOS 🚨
A long-standing Ginkgo performance issue on MacOS seems to be due to mac's antimalware XProtect. You can follow the instructions [here](https://onsi.github.io/ginkgo/#if-you-are-running-on-macos) to disable it in your terminal. Doing so sped up Ginkgo's own test suite from 1m8s to 47s.
### Fixes
Ginkgo's CLI is now a bit clearer if you pass flags in incorrectly:
- make it clearer that you need to pass a filename to the various profile flags, not an absolute directory [a0e52ff]
- emit an error and exit if the ginkgo invocation includes flags after positional arguments [b799d8d]
This might cause existing CI builds to fail. If so then it's likely that your CI build was misconfigured and should be corrected. Open an issue if you need help.
## 2.23.0
Ginkgo 2.23.0 adds a handful of methods to `GinkgoT()` to make it compatible with the `testing.TB` interface in Go 1.24. `GinkgoT().Context()`, in particular, is a useful shorthand for generating a new context that will clean itself up in a `DeferCleanup()`. This has subtle behavior differences from the golang implementation but should make sense in a Ginkgo... um... context.
### Features
- bump to go 1.24.0 - support new testing.TB methods and add a test to cover testing.TB regressions [37a511b]
### Fixes
- fix edge case where build -o is pointing at an explicit file, not a directory [7556a86]
- Fix binary paths when precompiling multiple suites. [4df06c6]
### Maintenance
- Fix: Correct Markdown list rendering in MIGRATING_TO_V2.md [cbcf39a]
- docs: fix test workflow badge (#1512) [9b261ff]
- Bump golang.org/x/net in /integration/_fixtures/version_mismatch_fixture (#1516) [00f19c8]
- Bump golang.org/x/tools from 0.28.0 to 0.30.0 (#1515) [e98a4df]
- Bump activesupport from 6.0.6.1 to 6.1.7.5 in /docs (#1504) [60cc4e2]
- Bump github-pages from 231 to 232 in /docs (#1447) [fea6f2d]
- Bump rexml from 3.2.8 to 3.3.9 in /docs (#1497) [31d7813]
- Bump webrick from 1.8.1 to 1.9.1 in /docs (#1501) [fc3bbd6]
- Code linting (#1500) [aee0d56]
- change interface{} to any (#1502) [809a710]
## 2.22.2
### Maintenance
- Bump github.com/onsi/gomega from 1.36.1 to 1.36.2 (#1499) [cc553ce]
- Bump golang.org/x/crypto (#1498) [2170370]
- Bump golang.org/x/net from 0.32.0 to 0.33.0 (#1496) [a96c44f]
## 2.22.1
### Fixes
Fix CSV encoding
- Update tests [aab3da6]
- Properly encode CSV rows [c09df39]
- Add test case for proper csv escaping [96a80fc]
- Add meta-test [43dad69]
### Maintenance
- ensure *.test files are gitignored so we don't accidentally commit compiled tests again [c88c634]
- remove golang.org/x/net/context in favour of stdlib context [4df44bf]
## 2.22.0
### Features
- Add label to serial nodes [0fcaa08]
This allows serial tests to be filtered using the `label-filter`
### Maintenance
Various doc fixes
## 2.21.0
### Features
- add support for GINKGO_TIME_FORMAT [a69eb39]
- add GINKGO_NO_COLOR to disable colors via environment variables [bcab9c8]
### Fixes
- increase threshold in timeline matcher [e548367]
- Fix the document by replacing `SpecsThatWillBeRun` with `SpecsThatWillRun`
[c2c4d3c]
### Maintenance
- bump various dependencies [7e65a00]
## 2.20.2
Require Go 1.22+
### Maintenance
- bump go to v1.22 [a671816]
## 2.20.1
### Fixes
- make BeSpecEvent duration matcher more forgiving [d6f9640]
## 2.20.0
### Features
- Add buildvcs flag [be5ab95]
### Maintenance
- Add update-deps to makefile [d303d14]
- bump all dependencies [7a50221]
## 2.19.1
### Fixes
- update supported platforms for race conditions [63c8c30]
- [build] Allow custom name for binaries. [ff41e27]
### Maintenance
- bump gomega [76f4e0c]
- Bump rexml from 3.2.6 to 3.2.8 in /docs (#1417) [b69c00d]
- Bump golang.org/x/sys from 0.20.0 to 0.21.0 (#1425) [f097741]
## 2.19.0
### Features
[Label Sets](https://onsi.github.io/ginkgo/#label-sets) allow for more expressive and flexible label filtering.
## 2.18.0
### Features
- Add --slience-skips and --force-newlines [f010b65]
- fail when no tests were run and --fail-on-empty was set [d80eebe]
### Fixes
- Fix table entry context edge case [42013d6]
### Maintenance
- Bump golang.org/x/tools from 0.20.0 to 0.21.0 (#1406) [fcf1fd7]
- Bump github.com/onsi/gomega from 1.33.0 to 1.33.1 (#1399) [8bb14fd]
- Bump golang.org/x/net from 0.24.0 to 0.25.0 (#1407) [04bfad7]
## 2.17.3
### Fixes
`ginkgo watch` now ignores hidden files [bde6e00]
## 2.17.2
### Fixes
- fix: close files [32259c8]
- fix github output log level for skipped specs [780e7a3]
### Maintenance
- Bump github.com/google/pprof [d91fe4e]
- Bump github.com/go-task/slim-sprig to v3 [8cb662e]
- Bump golang.org/x/net in /integration/_fixtures/version_mismatch_fixture (#1391) [3134422]
- Bump github-pages from 230 to 231 in /docs (#1384) [eca81b4]
- Bump golang.org/x/tools from 0.19.0 to 0.20.0 (#1383) [760def8]
- Bump golang.org/x/net from 0.23.0 to 0.24.0 (#1381) [4ce33f4]
- Fix test for gomega version bump [f2fcd97]
- Bump github.com/onsi/gomega from 1.30.0 to 1.33.0 (#1390) [fd622d2]
- Bump golang.org/x/tools from 0.17.0 to 0.19.0 (#1368) [5474a26]
- Bump github-pages from 229 to 230 in /docs (#1359) [e6d1170]
- Bump google.golang.org/protobuf from 1.28.0 to 1.33.0 (#1374) [7f447b2]
- Bump golang.org/x/net from 0.20.0 to 0.23.0 (#1380) [f15239a]
## 2.17.1
### Fixes
- If the user sets --seed=0, make sure all parallel nodes get the same seed [af0330d]
## 2.17.0
### Features
- add `--github-output` for nicer output in github actions [e8a2056]
### Maintenance
- fix typo in core_dsl.go [977bc6f]
- Fix typo in docs [e297e7b]
## 2.16.0
### Features
- add SpecContext to reporting nodes
### Fixes
- merge coverages instead of combining them (#1329) (#1340) [23f0cc5]
- core_dsl: disable Getwd() with environment variable (#1357) [cd418b7]
### Maintenance
- docs/index.md: Typo [2cebe8d]
- fix docs [06de431]
- chore: test with Go 1.22 (#1352) [898cba9]
- Bump golang.org/x/tools from 0.16.1 to 0.17.0 (#1336) [17ae120]
- Bump golang.org/x/sys from 0.15.0 to 0.16.0 (#1327) [5a179ed]
- Bump github.com/go-logr/logr from 1.3.0 to 1.4.1 (#1321) [a1e6b69]
- Bump github-pages and jekyll-feed in /docs (#1351) [d52951d]
- Fix docs for handling failures in goroutines (#1339) [4471b2e]
## 2.15.0
### Features
- JUnit reports now interpret Label(owner:X) and set owner to X. [8f3bd70]
- include cancellation reason when cancelling spec context [96e915c]
### Fixes
- emit output of failed go tool cover invocation so users can try to debug things for themselves [c245d09]
- fix outline when using nodot in ginkgo v2 [dca77c8]
- Document areas where GinkgoT() behaves differently from testing.T [dbaf18f]
- bugfix(docs): use Unsetenv instead of Clearenv (#1337) [6f67a14]
### Maintenance
- Bump to go 1.20 [4fcd0b3]
## 2.14.0
### Features
You can now use `GinkgoTB()` when you need an instance of `testing.TB` to pass to a library.
Prior to this release table testing only supported generating individual `It`s for each test entry. `DescribeTableSubtree` extends table testing support to entire testing subtrees - under the hood `DescrieTableSubtree` generates a new container for each entry and invokes your function to fill our the container. See the [docs](https://onsi.github.io/ginkgo/#generating-subtree-tables) to learn more.
- Introduce DescribeTableSubtree [65ec56d]
- add GinkgoTB() to docs [4a2c832]
- Add GinkgoTB() function (#1333) [92b6744]
### Fixes
- Fix typo in internal/suite.go (#1332) [beb9507]
- Fix typo in docs/index.md (#1319) [4ac3a13]
- allow wasm to compile with ginkgo present (#1311) [b2e5bc5]
### Maintenance
- Bump golang.org/x/tools from 0.16.0 to 0.16.1 (#1316) [465a8ec]
- Bump actions/setup-go from 4 to 5 (#1313) [eab0e40]
- Bump github/codeql-action from 2 to 3 (#1317) [fbf9724]
- Bump golang.org/x/crypto (#1318) [3ee80ee]
- Bump golang.org/x/tools from 0.14.0 to 0.16.0 (#1306) [123e1d5]
- Bump github.com/onsi/gomega from 1.29.0 to 1.30.0 (#1297) [558f6e0]
- Bump golang.org/x/net from 0.17.0 to 0.19.0 (#1307) [84ff7f3]
## 2.13.2
### Fixes
- Fix file handler leak (#1309) [e2e81c8]
- Avoid allocations with `(*regexp.Regexp).MatchString` (#1302) [3b2a2a7]
## 2.13.1
### Fixes
- # 1296 fix(precompiled test guite): exec bit check omitted on Windows (#1301) [26eea01]
### Maintenance
- Bump github.com/go-logr/logr from 1.2.4 to 1.3.0 (#1291) [7161a9d]
- Bump golang.org/x/sys from 0.13.0 to 0.14.0 (#1295) [7fc7b10]
- Bump golang.org/x/tools from 0.12.0 to 0.14.0 (#1282) [74bbd65]
- Bump github.com/onsi/gomega from 1.27.10 to 1.29.0 (#1290) [9373633]
- Bump golang.org/x/net in /integration/_fixtures/version_mismatch_fixture (#1286) [6e3cf65]
## 2.13.0
### Features
Add PreviewSpect() to enable programmatic preview access to the suite report (fixes #1225)
## 2.12.1
### Fixes
- Print logr prefix if it exists (#1275) [90d4846]
### Maintenance
- Bump actions/checkout from 3 to 4 (#1271) [555f543]
- Bump golang.org/x/sys from 0.11.0 to 0.12.0 (#1270) [d867b7d]
## 2.12.0
### Features
- feat: allow MustPassRepeatedly decorator to be set at suite level (#1266) [05de518]
### Fixes
- fix-errors-in-readme (#1244) [27c2f5d]
### Maintenance
Various chores/dependency bumps.
## 2.11.0
In prior versions of Ginkgo specs the CLI filter flags (e.g. `--focus`, `--label-filter`) would _override_ any programmatic focus. This behavior has proved surprising and confusing in at least the following ways:
- users cannot combine programmatic filters and CLI filters to more efficiently select subsets of tests
- CLI filters can override programmatic focus on CI systems resulting in an exit code of 0 despite the presence of (incorrectly!) committed focused specs.
Going forward Ginkgo will AND all programmatic and CLI filters. Moreover, the presence of any programmatic focused tests will always result in a non-zero exit code.
This change is technically a change in Ginkgo's external contract and may require some users to make changes to successfully adopt. Specifically: it's possible some users were intentionally using CLI filters to override programmatic focus. If this is you please open an issue so we can explore solutions to the underlying problem you are trying to solve.
### Fixes
- Programmatic focus is no longer overwrriten by CLI filters [d6bba86]
### Maintenance
- Bump github.com/onsi/gomega from 1.27.7 to 1.27.8 (#1218) [4a70a38]
- Bump golang.org/x/sys from 0.8.0 to 0.9.0 (#1219) [97eda4d]
## 2.10.0
### Features
- feat(ginkgo/generators): add --tags flag (#1216) [a782a77]
adds a new --tags flag to ginkgo generate
### Fixes
- Fix broken link of MIGRATING_TO_V2.md (#1217) [548d78e]
### Maintenance
- Bump golang.org/x/tools from 0.9.1 to 0.9.3 (#1215) [2b76a5e]
## 2.9.7
### Fixes
- fix race when multiple defercleanups are called in goroutines [07fc3a0]
## 2.9.6
### Fixes
- fix: create parent directory before report files (#1212) [0ac65de]
### Maintenance
- Bump github.com/onsi/gomega from 1.27.6 to 1.27.7 (#1202) [3e39231]
## 2.9.5
### Fixes
- ensure the correct deterministic sort order is produced when ordered specs are generated by a helper function [7fa0b6b]
### Maintenance
- fix generators link (#1200) [9f9d8b9]
- Bump golang.org/x/tools from 0.8.0 to 0.9.1 (#1196) [150e3f2]
- fix spelling err in docs (#1199) [0013b1a]
- Bump golang.org/x/sys from 0.7.0 to 0.8.0 (#1193) [9e9e3e5]
## 2.9.4
### Fixes
- fix hang with ginkgo -p (#1192) [15d4bdc] - this addresses a _long_ standing issue related to Ginkgo hanging when a child process spawned by the test does not exit.
- fix: fail fast may cause Serial spec or cleanup Node interrupted (#1178) [8dea88b] - prior to this there was a small gap in which specs on other processes might start even if one process has tried to abort the suite.
### Maintenance
- Document run order when multiple setup nodes are at the same nesting level [903be81]
## 2.9.3
### Features
- Add RenderTimeline to GinkgoT() [c0c77b6]
### Fixes
- update Measure deprecation message. fixes #1176 [227c662]
- add newlines to GinkgoLogr (#1170) (#1171) [0de0e7c]
### Maintenance
- Bump commonmarker from 0.23.8 to 0.23.9 in /docs (#1183) [8b925ab]
- Bump nokogiri from 1.14.1 to 1.14.3 in /docs (#1184) [e3795a4]
- Bump golang.org/x/tools from 0.7.0 to 0.8.0 (#1182) [b453793]
- Bump actions/setup-go from 3 to 4 (#1164) [73ed75b]
- Bump github.com/onsi/gomega from 1.27.4 to 1.27.6 (#1173) [0a2bc64]
- Bump github.com/go-logr/logr from 1.2.3 to 1.2.4 (#1174) [f41c557]
- Bump golang.org/x/sys from 0.6.0 to 0.7.0 (#1179) [8e423e5]
## 2.9.2
### Maintenance
- Bump github.com/go-task/slim-sprig (#1167) [3fcc5bf]
- Bump github.com/onsi/gomega from 1.27.3 to 1.27.4 (#1163) [6143ffe]
## 2.9.1
### Fixes
This release fixes a longstanding issue where `ginkgo -coverpkg=./...` would not work. This is now resolved and fixes [#1161](https://github.com/onsi/ginkgo/issues/1161) and [#995](https://github.com/onsi/ginkgo/issues/995)
- Support -coverpkg=./... [26ca1b5]
- document coverpkg a bit more clearly [fc44c3b]
### Maintenance
- bump various dependencies
- Improve Documentation and fix typo (#1158) [93de676]
## 2.9.0
### Features
- AttachProgressReporter is an experimental feature that allows users to provide arbitrary information when a ProgressReport is requested [28801fe]
- GinkgoT() has been expanded to include several Ginkgo-specific methods [2bd5a3b]
The intent is to enable the development of third-party libraries that integrate deeply with Ginkgo using `GinkgoT()` to access Ginkgo's functionality.
## 2.8.4
### Features
- Add OmitSuiteSetupNodes to JunitReportConfig (#1147) [979fbc2]
- Add a reference to ginkgolinter in docs.index.md (#1143) [8432589]
### Fixes
- rename tools hack to see if it fixes things for downstream users [a8bb39a]
### Maintenance
- Bump golang.org/x/text (#1144) [41b2a8a]
- Bump github.com/onsi/gomega from 1.27.0 to 1.27.1 (#1142) [7c4f583]
## 2.8.3
Released to fix security issue in golang.org/x/net dependency
### Maintenance
- Bump golang.org/x/net from 0.6.0 to 0.7.0 (#1141) [fc1a02e]
- remove tools.go hack from documentation [0718693]
## 2.8.2
Ginkgo now includes a `tools.go` file in the root directory of the `ginkgo` package. This should allow modules that simply `go get github.com/onsi/ginkgo/v2` to also pull in the CLI dependencies. This obviates the need for consumers of Ginkgo to have their own `tools.go` file and makes it simpler to ensure that the version of the `ginkgo` CLI being used matches the version of the library. You can simply run `go run github.com/onsi/ginkgo/v2/ginkgo` to run the version of the cli associated with your package go.mod.
### Maintenance
- Bump github.com/onsi/gomega from 1.26.0 to 1.27.0 (#1139) [5767b0a]
- Fix minor typos (#1138) [e1e9723]
- Fix link in V2 Migration Guide (#1137) [a588f60]
## 2.8.1
### Fixes
- lock around default report output to avoid triggering the race detector when calling By from goroutines [2d5075a]
- don't run ReportEntries through sprintf [febbe38]
### Maintenance
- Bump golang.org/x/tools from 0.5.0 to 0.6.0 (#1135) [11a4860]
- test: update matrix for Go 1.20 (#1130) [4890a62]
- Bump golang.org/x/sys from 0.4.0 to 0.5.0 (#1133) [a774638]
- Bump github.com/onsi/gomega from 1.25.0 to 1.26.0 (#1120) [3f233bd]
- Bump github-pages from 227 to 228 in /docs (#1131) [f9b8649]
- Bump activesupport from 6.0.6 to 6.0.6.1 in /docs (#1127) [6f8c042]
- Update index.md with instructions on how to upgrade Ginkgo [833a75e]
## 2.8.0
### Features
- Introduce GinkgoHelper() to track and exclude helper functions from potential CodeLocations [e19f556]
Modeled after `testing.T.Helper()`. Now, rather than write code like:
```go
func helper(model Model) {
Expect(model).WithOffset(1).To(BeValid())
Expect(model.SerialNumber).WithOffset(1).To(MatchRegexp(/[a-f0-9]*/))
}
```
you can stop tracking offsets (which makes nesting composing helpers nearly impossible) and simply write:
```go
func helper(model Model) {
GinkgoHelper()
Expect(model).To(BeValid())
Expect(model.SerialNumber).To(MatchRegexp(/[a-f0-9]*/))
}
```
- Introduce GinkgoLabelFilter() and Label().MatchesLabelFilter() to make it possible to programmatically match filters (fixes #1119) [2f6597c]
You can now write code like this:
```go
BeforeSuite(func() {
if Label("slow").MatchesLabelFilter(GinkgoLabelFilter()) {
// do slow setup
}
if Label("fast").MatchesLabelFilter(GinkgoLabelFilter()) {
// do fast setup
}
})
```
to programmatically check whether a given set of labels will match the configured `--label-filter`.
### Maintenance
- Bump webrick from 1.7.0 to 1.8.1 in /docs (#1125) [ea4966e]
- cdeql: add ruby language (#1124) [9dd275b]
- dependabot: add bundler package-ecosystem for docs (#1123) [14e7bdd]
## 2.7.1
### Fixes
- Bring back SuiteConfig.EmitSpecProgress to avoid compilation issue for consumers that set it manually [d2a1cb0]
### Maintenance
- Bump github.com/onsi/gomega from 1.24.2 to 1.25.0 (#1118) [cafece6]
- Bump golang.org/x/tools from 0.4.0 to 0.5.0 (#1111) [eda66c2]
- Bump golang.org/x/sys from 0.3.0 to 0.4.0 (#1112) [ac5ccaa]
- Bump github.com/onsi/gomega from 1.24.1 to 1.24.2 (#1097) [eee6480]
## 2.7.0
### Features
- Introduce ContinueOnFailure for Ordered containers [e0123ca] - Ordered containers that are also decorated with ContinueOnFailure will not stop running specs after the first spec fails.
- Support for bootstrap commands to use custom data for templates (#1110) [7a2b242]
- Support for labels and pending decorator in ginkgo outline output (#1113) [e6e3b98]
- Color aliases for custom color support (#1101) [49fab7a]
### Fixes
- correctly ensure deterministic spec order, even if specs are generated by iterating over a map [89dda20]
- Fix a bug where timedout specs were not correctly treated as failures when determining whether or not to run AfterAlls in an Ordered container.
- Ensure go test coverprofile outputs to the expected location (#1105) [b0bd77b]
## 2.6.1
### Features
- Override formatter colors from envvars - this is a new feature but an alternative approach involving config files might be taken in the future (#1095) [60240d1]
### Fixes
- GinkgoRecover now supports ignoring panics that match a specific, hidden, interface [301f3e2]
### Maintenance
- Bump github.com/onsi/gomega from 1.24.0 to 1.24.1 (#1077) [3643823]
- Bump golang.org/x/tools from 0.2.0 to 0.4.0 (#1090) [f9f856e]
- Bump nokogiri from 1.13.9 to 1.13.10 in /docs (#1091) [0d7087e]
## 2.6.0
### Features
- `ReportBeforeSuite` provides access to the suite report before the suite begins.
- Add junit config option for omitting leafnodetype (#1088) [956e6d2]
- Add support to customize junit report config to omit spec labels (#1087) [de44005]
### Fixes
- Fix stack trace pruning so that it has a chance of working on windows [2165648]
## 2.5.1
### Fixes
- skipped tests only show as 'S' when running with -v [3ab38ae]
- Fix typo in docs/index.md (#1082) [55fc58d]
- Fix typo in docs/index.md (#1081) [8a14f1f]
- Fix link notation in docs/index.md (#1080) [2669612]
- Fix typo in `--progress` deprecation message (#1076) [b4b7edc]
### Maintenance
- chore: Included githubactions in the dependabot config (#976) [baea341]
- Bump golang.org/x/sys from 0.1.0 to 0.2.0 (#1075) [9646297]
## 2.5.0
### Ginkgo output now includes a timeline-view of the spec
This commit changes Ginkgo's default output. Spec details are now
presented as a **timeline** that includes events that occur during the spec
lifecycle interleaved with any GinkgoWriter content. This makes is much easier
to understand the flow of a spec and where a given failure occurs.
The --progress, --slow-spec-threshold, --always-emit-ginkgo-writer flags
and the SuppressProgressReporting decorator have all been deprecated. Instead
the existing -v and -vv flags better capture the level of verbosity to display. However,
a new --show-node-events flag is added to include node `> Enter` and `< Exit` events
in the spec timeline.
In addition, JUnit reports now include the timeline (rendered with -vv) and custom JUnit
reports can be configured and generated using
`GenerateJUnitReportWithConfig(report types.Report, dst string, config JunitReportConfig)`
Code should continue to work unchanged with this version of Ginkgo - however if you have tooling that
was relying on the specific output format of Ginkgo you _may_ run into issues. Ginkgo's console output is not guaranteed to be stable for tooling and automation purposes. You should, instead, use Ginkgo's JSON format
to build tooling on top of as it has stronger guarantees to be stable from version to version.
### Features
- Provide details about which timeout expired [0f2fa27]
### Fixes
- Add Support Policy to docs [c70867a]
### Maintenance
- Bump github.com/onsi/gomega from 1.22.1 to 1.23.0 (#1070) [bb3b4e2]
## 2.4.0
### Features
- DeferCleanup supports functions with multiple-return values [5e33c75]
- Add GinkgoLogr (#1067) [bf78c28]
- Introduction of 'MustPassRepeatedly' decorator (#1051) [047c02f]
### Fixes
- correcting some typos (#1064) [1403d3c]
- fix flaky internal_integration interrupt specs [2105ba3]
- Correct busted link in README [be6b5b9]
### Maintenance
- Bump actions/checkout from 2 to 3 (#1062) [8a2f483]
- Bump golang.org/x/tools from 0.1.12 to 0.2.0 (#1065) [529c4e8]
- Bump github/codeql-action from 1 to 2 (#1061) [da09146]
- Bump actions/setup-go from 2 to 3 (#1060) [918040d]
- Bump github.com/onsi/gomega from 1.22.0 to 1.22.1 (#1053) [2098e4d]
- Bump nokogiri from 1.13.8 to 1.13.9 in /docs (#1066) [1d74122]
- Add GHA to dependabot config [4442772]
## 2.3.1
## Fixes
Several users were invoking `ginkgo` by installing the latest version of the cli via `go install github.com/onsi/ginkgo/v2/ginkgo@latest`. When 2.3.0 was released this resulted in an influx of issues as CI systems failed due to a change in the internal contract between the Ginkgo CLI and the Ginkgo library. Ginkgo only supports running the same version of the library as the cli (which is why both are packaged in the same repository).
With this patch release, the ginkgo CLI can now identify a version mismatch and emit a helpful error message.
- Ginkgo cli can identify version mismatches and emit a helpful error message [bc4ae2f]
- further emphasize that a version match is required when running Ginkgo on CI and/or locally [2691dd8]
### Maintenance
- bump gomega to v1.22.0 [822a937]
## 2.3.0
### Interruptible Nodes and Timeouts
Ginkgo now supports per-node and per-spec timeouts on interruptible nodes. Check out the [documentation for all the details](https://onsi.github.io/ginkgo/#spec-timeouts-and-interruptible-nodes) but the gist is you can now write specs like this:
```go
It("is interruptible", func(ctx SpecContext) { // or context.Context instead of SpecContext, both are valid.
// do things until `ctx.Done()` is closed, for example:
req, err := http.NewRequestWithContext(ctx, "POST", "/build-widgets", nil)
Expect(err).NotTo(HaveOccured())
_, err := http.DefaultClient.Do(req)
Expect(err).NotTo(HaveOccured())
Eventually(client.WidgetCount).WithContext(ctx).Should(Equal(17))
}, NodeTimeout(time.Second*20), GracePeriod(5*time.Second))
```
and have Ginkgo ensure that the node completes before the timeout elapses. If it does elapse, or if an external interrupt is received (e.g. `^C`) then Ginkgo will cancel the context and wait for the Grace Period for the node to exit before proceeding with any cleanup nodes associated with the spec. The `ctx` provided by Ginkgo can also be passed down to Gomega's `Eventually` to have all assertions within the node governed by a single deadline.
### Features
- Ginkgo now records any additional failures that occur during the cleanup of a failed spec. In prior versions this information was quietly discarded, but the introduction of a more rigorous approach to timeouts and interruptions allows Ginkgo to better track subsequent failures.
- `SpecContext` also provides a mechanism for third-party libraries to provide additional information when a Progress Report is generated. Gomega uses this to provide the current state of an `Eventually().WithContext()` assertion when a Progress Report is requested.
- DescribeTable now exits with an error if it is not passed any Entries [a4c9865]
## Fixes
- fixes crashes on newer Ruby 3 installations by upgrading github-pages gem dependency [92c88d5]
- Make the outline command able to use the DSL import [1be2427]
## Maintenance
- chore(docs): delete no meaning d [57c373c]
- chore(docs): Fix hyperlinks [30526d5]
- chore(docs): fix code blocks without language settings [cf611c4]
- fix intra-doc link [b541bcb]
## 2.2.0
### Generate real-time Progress Reports [f91377c]
Ginkgo can now generate Progress Reports to point users at the current running line of code (including a preview of the actual source code) and a best guess at the most relevant subroutines.
These Progress Reports allow users to debug stuck or slow tests without exiting the Ginkgo process. A Progress Report can be generated at any time by sending Ginkgo a `SIGINFO` (`^T` on MacOS/BSD) or `SIGUSR1`.
In addition, the user can specify `--poll-progress-after` and `--poll-progress-interval` to have Ginkgo start periodically emitting progress reports if a given node takes too long. These can be overriden/set on a per-node basis with the `PollProgressAfter` and `PollProgressInterval` decorators.
Progress Reports are emitted to stdout, and also stored in the machine-redable report formats that Ginkgo supports.
Ginkgo also uses this progress reporting infrastructure under the hood when handling timeouts and interrupts. This yields much more focused, useful, and informative stack traces than previously.
### Features
- `BeforeSuite`, `AfterSuite`, `SynchronizedBeforeSuite`, `SynchronizedAfterSuite`, and `ReportAfterSuite` now support (the relevant subset of) decorators. These can be passed in _after_ the callback functions that are usually passed into these nodes.
As a result the **signature of these methods has changed** and now includes a trailing `args ...any`. For most users simply using the DSL, this change is transparent. However if you were assigning one of these functions to a custom variable (or passing it around) then your code may need to change to reflect the new signature.
### Maintenance
- Modernize the invocation of Ginkgo in github actions [0ffde58]
- Update reocmmended CI settings in docs [896bbb9]
- Speed up unnecessarily slow integration test [6d3a90e]
## 2.1.6
### Fixes
- Add `SuppressProgressReporting` decorator to turn off --progress announcements for a given node [dfef62a]
- chore: remove duplicate word in comments [7373214]
## 2.1.5
### Fixes
- drop -mod=mod instructions; fixes #1026 [6ad7138]
- Ensure `CurrentSpecReport` and `AddReportEntry` are thread-safe [817c09b]
- remove stale importmap gcflags flag test [3cd8b93]
- Always emit spec summary [5cf23e2] - even when only one spec has failed
- Fix ReportAfterSuite usage in docs [b1864ad]
- fixed typo (#997) [219cc00]
- TrimRight is not designed to trim Suffix [71ebb74]
- refactor: replace strings.Replace with strings.ReplaceAll (#978) [143d208]
- fix syntax in examples (#975) [b69554f]
### Maintenance
- Bump github.com/onsi/gomega from 1.20.0 to 1.20.1 (#1027) [e5dfce4]
- Bump tzinfo from 1.2.9 to 1.2.10 in /docs (#1006) [7ae91c4]
- Bump github.com/onsi/gomega from 1.19.0 to 1.20.0 (#1005) [e87a85a]
- test: add new Go 1.19 to test matrix (#1014) [bbefe12]
- Bump golang.org/x/tools from 0.1.11 to 0.1.12 (#1012) [9327906]
- Bump golang.org/x/tools from 0.1.10 to 0.1.11 (#993) [f44af96]
- Bump nokogiri from 1.13.3 to 1.13.6 in /docs (#981) [ef336aa]
## 2.1.4
### Fixes
- Numerous documentation typos
- Prepend `when` when using `When` (this behavior was in 1.x but unintentionally lost during the 2.0 rewrite) [efce903]
- improve error message when a parallel process fails to report back [a7bd1fe]
- guard against concurrent map writes in DeprecationTracker [0976569]
- Invoke reporting nodes during dry-run (fixes #956 and #935) [aae4480]
- Fix ginkgo import circle [f779385]
## 2.1.3
See [https://onsi.github.io/ginkgo/MIGRATING_TO_V2](https://onsi.github.io/ginkgo/MIGRATING_TO_V2) for details on V2.
### Fixes
- Calling By in a container node now emits a useful error. [ff12cee]
## 2.1.2
### Fixes
- Track location of focused specs correctly in `ginkgo unfocus` [a612ff1]
- Profiling suites with focused specs no longer generates an erroneous failure message [8fbfa02]
- Several documentation typos fixed. Big thanks to everyone who helped catch them and report/fix them!
## 2.1.1
See [https://onsi.github.io/ginkgo/MIGRATING_TO_V2](https://onsi.github.io/ginkgo/MIGRATING_TO_V2) for details on V2.
### Fixes
- Suites that only import the new dsl packages are now correctly identified as Ginkgo suites [ec17e17]
## 2.1.0
See [https://onsi.github.io/ginkgo/MIGRATING_TO_V2](https://onsi.github.io/ginkgo/MIGRATING_TO_V2) for details on V2.
2.1.0 is a minor release with a few tweaks:
- Introduce new DSL packages to enable users to pick-and-choose which portions of the DSL to dot-import. [90868e2] More details [here](https://onsi.github.io/ginkgo/#alternatives-to-dot-importing-ginkgo).
- Add error check for invalid/nil parameters to DescribeTable [6f8577e]
- Myriad docs typos fixed (thanks everyone!) [718542a, ecb7098, 146654c, a8f9913, 6bdffde, 03dcd7e]
## 2.0.0
See [https://onsi.github.io/ginkgo/MIGRATING_TO_V2](https://onsi.github.io/ginkgo/MIGRATING_TO_V2)
## 1.16.5
Ginkgo 2.0 now has a Release Candidate. 1.16.5 advertises the existence of the RC.
1.16.5 deprecates GinkgoParallelNode in favor of GinkgoParallelProcess
You can silence the RC advertisement by setting an `ACK_GINKGO_RC=true` environment variable or creating a file in your home directory called `.ack-ginkgo-rc`
## 1.16.4
### Fixes
1.16.4 retracts 1.16.3. There are no code changes. The 1.16.3 tag was associated with the wrong commit and an attempt to change it after-the-fact has proven problematic. 1.16.4 retracts 1.16.3 in Ginkgo's go.mod and creates a new, correctly tagged, release.
## 1.16.3
### Features
- Measure is now deprecated and emits a deprecation warning.
## 1.16.2
### Fixes
- Deprecations can be suppressed by setting an `ACK_GINKGO_DEPRECATIONS=<semver>` environment variable.
## 1.16.1
### Fixes
- Suppress --stream deprecation warning on windows (#793)
## 1.16.0
### Features
- Advertise Ginkgo 2.0. Introduce deprecations. [9ef1913]
- Update README.md to advertise that Ginkgo 2.0 is coming.
- Backport the 2.0 DeprecationTracker and start alerting users
about upcoming deprecations.
- Add slim-sprig template functions to bootstrap/generate (#775) [9162b86]
- Fix accidental reference to 1488 (#784) [9fb7fe4]
## 1.15.2
### Fixes
- ignore blank `-focus` and `-skip` flags (#780) [e90a4a0]
## 1.15.1
### Fixes
- reporters/junit: Use `system-out` element instead of `passed` (#769) [9eda305]
## 1.15.0
### Features
- Adds 'outline' command to print the outline of specs/containers in a file (#754) [071c369] [6803cc3] [935b538] [06744e8] [0c40583]
- Add support for using template to generate tests (#752) [efb9e69]
- Add a Chinese Doc #755 (#756) [5207632]
- cli: allow multiple -focus and -skip flags (#736) [9a782fb]
### Fixes
- Add _internal to filename of tests created with internal flag (#751) [43c12da]
## 1.14.2
### Fixes
- correct handling windows backslash in import path (#721) [97f3d51]
- Add additional methods to GinkgoT() to improve compatibility with the testing.TB interface [b5fe44d]
## 1.14.1
### Fixes
- Discard exported method declaration when running ginkgo bootstrap (#558) [f4b0240]
## 1.14.0
### Features
- Defer running top-level container nodes until RunSpecs is called [d44dedf]
- [Document Ginkgo lifecycle](http://onsi.github.io/ginkgo/#understanding-ginkgos-lifecycle)
- Add `extensions/globals` package (#692) [3295c8f] - this can be helpful in contexts where you are test-driving your test-generation code (see [#692](https://github.com/onsi/ginkgo/pull/692))
- Print Skip reason in JUnit reporter if one was provided [820dfab]
## 1.13.0
### Features
- Add a version of table.Entry that allows dumping the entry parameters. (#689) [21eaef2]
### Fixes
- Ensure integration tests pass in an environment sans GOPATH [606fba2]
- Add books package (#568) [fc0e44e]
- doc(readme): installation via "tools package" (#677) [83bb20e]
- Solve the undefined: unix.Dup2 compile error on mips64le (#680) [0624f75]
- Import package without dot (#687) [6321024]
- Fix integration tests to stop require GOPATH (#686) [a912ec5]
## 1.12.3
### Fixes
- Print correct code location of failing table test (#666) [c6d7afb]
## 1.12.2
### Fixes
- Update dependencies [ea4a036]
## 1.12.1
### Fixes
- Make unfocus ("blur") much faster (#674) [8b18061]
- Fix typo (#673) [7fdcbe8]
- Test against 1.14 and remove 1.12 [d5c2ad6]
- Test if a coverprofile content is empty before checking its latest character (#670) [14d9fa2]
- replace tail package with maintained one. this fixes go get errors (#667) [4ba33d4]
- improve ginkgo performance - makes progress on #644 [a14f98e]
- fix convert integration tests [1f8ba69]
- fix typo successful -> successful (#663) [1ea49cf]
- Fix invalid link (#658) [b886136]
- convert utility : Include comments from source (#657) [1077c6d]
- Explain what BDD means [d79e7fb]
- skip race detector test on unsupported platform (#642) [f8ab89d]
- Use Dup2 from golang.org/x/sys/unix instead of syscallDup (#638) [5d53c55]
- Fix missing newline in combined coverage file (#641) [6a07ea2]
- check if a spec is run before returning SpecSummary (#645) [8850000]
## 1.12.0
### Features
- Add module definition (#630) [78916ab]
## 1.11.0
### Features
- Add syscall for riscv64 architecture [f66e896]
- teamcity reporter: output location of test failure as well as test definition (#626) [9869142]
- teamcity reporter: output newline after every service message (#625) [3cfa02d]
- Add support for go module when running `generate` command (#578) [9c89e3f]
## 1.10.3
### Fixes
- Set go_import_path in travis.yml to allow internal packages in forks (#607) [3b721db]
- Add integration test [d90e0dc]
- Fix coverage files combining [e5dde8c]
- A new CLI option: -ginkgo.reportFile <file path> (#601) [034fd25]
## 1.10.2
### Fixes
- speed up table entry generateIt() (#609) [5049dc5]
- Fix. Write errors to stderr instead of stdout (#610) [7bb3091]
## 1.10.1
### Fixes
- stack backtrace: fix skipping (#600) [2a4c0bd]
## 1.10.0
### Fixes
- stack backtrace: fix alignment and skipping [66915d6]
- fix typo in documentation [8f97b93]
## 1.9.0
### Features
- Option to print output into report, when tests have passed [0545415]
### Fixes
- Fixed typos in comments [0ecbc58]
- gofmt code [a7f8bfb]
- Simplify code [7454d00]
- Simplify concatenation, incrementation and function assignment [4825557]
- Avoid unnecessary conversions [9d9403c]
- JUnit: include more detailed information about panic [19cca4b]
- Print help to stdout when the user asks for help [4cb7441]
## 1.8.0
### New Features
- allow config of the vet flag for `go test` (#562) [3cd45fa]
- Support projects using go modules [d56ee76]
### Fixes and Minor Improvements
- chore(godoc): fixes typos in Measurement funcs [dbaca8e]
- Optimize focus to avoid allocations [f493786]
- Ensure generated test file names are underscored [505cc35]
## 1.7.0
### New Features
- Add JustAfterEach (#484) [0d4f080]
### Fixes
- Correctly round suite time in junit reporter [2445fc1]
- Avoid using -i argument to go test for Golang 1.10+ [46bbc26]
## 1.6.0
### New Features
- add --debug flag to emit node output to files (#499) [39febac]
### Fixes
- fix: for `go vet` to pass [69338ec]
- docs: fix for contributing instructions [7004cb1]
- consolidate and streamline contribution docs (#494) [d848015]
- Make generated Junit file compatible with "Maven Surefire" (#488) [e51bee6]
- all: gofmt [000d317]
- Increase eventually timeout to 30s [c73579c]
- Clarify asynchronous test behavior [294d8f4]
- Travis badge should only show master [26d2143]
## 1.5.0 5/10/2018
### New Features
- Supports go v1.10 (#443, #446, #451) [e873237, 468e89e, e37dbfe, a37f4c0, c0b857d, bca5260, 4177ca8]
- Add a When() synonym for Context() (#386) [747514b, 7484dad, 7354a07, dd826c8]
- Re-add noisySkippings flag [652e15c]
- Allow coverage to be displayed for focused specs (#367) [11459a8]
- Handle -outputdir flag (#364) [228e3a8]
- Handle -coverprofile flag (#355) [43392d5]
### Fixes
- When using custom reporters register the custom reporters *before* the default reporter. This allows users to see the output of any print statements in their customer reporters. (#365) [8382b23]
- When running a test and calculating the coverage using the `-coverprofile` and `-outputdir` flags, Ginkgo fails with an error if the directory does not exist. This is due to an [issue in go 1.10](https://github.com/golang/go/issues/24588) (#446) [b36a6e0]
- `unfocus` command ignores vendor folder (#459) [e5e551c, c556e43, a3b6351, 9a820dd]
- Ignore packages whose tests are all ignored by go (#456) [7430ca7, 6d8be98]
- Increase the threshold when checking time measurements (#455) [2f714bf, 68f622c]
- Fix race condition in coverage tests (#423) [a5a8ff7, ab9c08b]
- Add an extra new line after reporting spec run completion for test2json [874520d]
- added name name field to junit reported testsuite [ae61c63]
- Do not set the run time of a spec when the dryRun flag is used (#438) [457e2d9, ba8e856]
- Process FWhen and FSpecify when unfocusing (#434) [9008c7b, ee65bd, df87dfe]
- Synchronies the access to the state of specs to avoid race conditions (#430) [7d481bc, ae6829d]
- Added Duration on GinkgoTestDescription (#383) [5f49dad, 528417e, 0747408, 329d7ed]
- Fix Ginkgo stack trace on failure for Specify (#415) [b977ede, 65ca40e, 6c46eb8]
- Update README with Go 1.6+, Golang -> Go (#409) [17f6b97, bc14b66, 20d1598]
- Use fmt.Errorf instead of errors.New(fmt.Sprintf (#401) [a299f56, 44e2eaa]
- Imports in generated code should follow conventions (#398) [0bec0b0, e8536d8]
- Prevent data race error when Recording a benchmark value from multiple go routines (#390) [c0c4881, 7a241e9]
- Replace GOPATH in Environment [4b883f0]
## 1.4.0 7/16/2017
- `ginkgo` now provides a hint if you accidentally forget to run `ginkgo bootstrap` to generate a `*_suite_test.go` file that actually invokes the Ginkgo test runner. [#345](https://github.com/onsi/ginkgo/pull/345)
- thanks to improvements in `go test -c` `ginkgo` no longer needs to fix Go's compilation output to ensure compilation errors are expressed relative to the CWD. [#357]
- `ginkgo watch -watchRegExp=...` allows you to specify a custom regular expression to watch. Only files matching the regular expression are watched for changes (the default is `\.go$`) [#356]
- `ginkgo` now always emits compilation output. Previously, only failed compilation output was printed out. [#277]
- `ginkgo -requireSuite` now fails the test run if there are `*_test.go` files but `go test` fails to detect any tests. Typically this means you forgot to run `ginkgo bootstrap` to generate a suite file. [#344]
- `ginkgo -timeout=DURATION` allows you to adjust the timeout for the entire test suite (default is 24 hours) [#248]
## 1.3.0 3/28/2017
Improvements:
- Significantly improved parallel test distribution. Now instead of pre-sharding test cases across workers (which can result in idle workers and poor test performance) Ginkgo uses a shared queue to keep all workers busy until all tests are complete. This improves test-time performance and consistency.
- `Skip(message)` can be used to skip the current test.
- Added `extensions/table` - a Ginkgo DSL for [Table Driven Tests](http://onsi.github.io/ginkgo/#table-driven-tests)
- Add `GinkgoRandomSeed()` - shorthand for `config.GinkgoConfig.RandomSeed`
- Support for retrying flaky tests with `--flakeAttempts`
- `ginkgo ./...` now recurses as you'd expect
- Added `Specify` a synonym for `It`
- Support colorise on Windows
- Broader support for various go compilation flags in the `ginkgo` CLI
Bug Fixes:
- Ginkgo tests now fail when you `panic(nil)` (#167)
## 1.2.0 5/31/2015
Improvements
- `ginkgo -coverpkg` calls down to `go test -coverpkg` (#160)
- `ginkgo -afterSuiteHook COMMAND` invokes the passed-in `COMMAND` after a test suite completes (#152)
- Relaxed requirement for Go 1.4+. `ginkgo` now works with Go v1.3+ (#166)
## 1.2.0-beta
Ginkgo now requires Go 1.4+
Improvements:
- Call reporters in reverse order when announcing spec completion -- allows custom reporters to emit output before the default reporter does.
- Improved focus behavior. Now, this:
```golang
FDescribe("Some describe", func() {
It("A", func() {})
FIt("B", func() {})
})
```
will run `B` but *not* `A`. This tends to be a common usage pattern when in the thick of writing and debugging tests.
- When `SIGINT` is received, Ginkgo will emit the contents of the `GinkgoWriter` before running the `AfterSuite`. Useful for debugging stuck tests.
- When `--progress` is set, Ginkgo will write test progress (in particular, Ginkgo will say when it is about to run a BeforeEach, AfterEach, It, etc...) to the `GinkgoWriter`. This is useful for debugging stuck tests and tests that generate many logs.
- Improved output when an error occurs in a setup or teardown block.
- When `--dryRun` is set, Ginkgo will walk the spec tree and emit to its reporter *without* actually running anything. Best paired with `-v` to understand which specs will run in which order.
- Add `By` to help document long `It`s. `By` simply writes to the `GinkgoWriter`.
- Add support for precompiled tests:
- `ginkgo build <path-to-package>` will now compile the package, producing a file named `package.test`
- The compiled `package.test` file can be run directly. This runs the tests in series.
- To run precompiled tests in parallel, you can run: `ginkgo -p package.test`
- Support `bootstrap`ping and `generate`ing [Agouti](http://agouti.org) specs.
- `ginkgo generate` and `ginkgo bootstrap` now honor the package name already defined in a given directory
- The `ginkgo` CLI ignores `SIGQUIT`. Prevents its stack dump from interlacing with the underlying test suite's stack dump.
- The `ginkgo` CLI now compiles tests into a temporary directory instead of the package directory. This necessitates upgrading to Go v1.4+.
- `ginkgo -notify` now works on Linux
Bug Fixes:
- If --skipPackages is used and all packages are skipped, Ginkgo should exit 0.
- Fix tempfile leak when running in parallel
- Fix incorrect failure message when a panic occurs during a parallel test run
- Fixed an issue where a pending test within a focused context (or a focused test within a pending context) would skip all other tests.
- Be more consistent about handling SIGTERM as well as SIGINT
- When interrupted while concurrently compiling test suites in the background, Ginkgo now cleans up the compiled artifacts.
- Fixed a long standing bug where `ginkgo -p` would hang if a process spawned by one of the Ginkgo parallel nodes does not exit. (Hooray!)
## 1.1.0 (8/2/2014)
No changes, just dropping the beta.
## 1.1.0-beta (7/22/2014)
New Features:
- `ginkgo watch` now monitors packages *and their dependencies* for changes. The depth of the dependency tree can be modified with the `-depth` flag.
- Test suites with a programmatic focus (`FIt`, `FDescribe`, etc...) exit with non-zero status code, even when they pass. This allows CI systems to detect accidental commits of focused test suites.
- `ginkgo -p` runs the testsuite in parallel with an auto-detected number of nodes.
- `ginkgo -tags=TAG_LIST` passes a list of tags down to the `go build` command.
- `ginkgo --failFast` aborts the test suite after the first failure.
- `ginkgo generate file_1 file_2` can take multiple file arguments.
- Ginkgo now summarizes any spec failures that occurred at the end of the test run.
- `ginkgo --randomizeSuites` will run tests *suites* in random order using the generated/passed-in seed.
Improvements:
- `ginkgo -skipPackage` now takes a comma-separated list of strings. If the *relative path* to a package matches one of the entries in the comma-separated list, that package is skipped.
- `ginkgo --untilItFails` no longer recompiles between attempts.
- Ginkgo now panics when a runnable node (`It`, `BeforeEach`, `JustBeforeEach`, `AfterEach`, `Measure`) is nested within another runnable node. This is always a mistake. Any test suites that panic because of this change should be fixed.
Bug Fixes:
- `ginkgo boostrap` and `ginkgo generate` no longer fail when dealing with `hyphen-separated-packages`.
- parallel specs are now better distributed across nodes - fixed a crashing bug where (for example) distributing 11 tests across 7 nodes would panic
## 1.0.0 (5/24/2014)
New Features:
- Add `GinkgoParallelNode()` - shorthand for `config.GinkgoConfig.ParallelNode`
Improvements:
- When compilation fails, the compilation output is rewritten to present a correct *relative* path. Allows ⌘-clicking in iTerm open the file in your text editor.
- `--untilItFails` and `ginkgo watch` now generate new random seeds between test runs, unless a particular random seed is specified.
Bug Fixes:
- `-cover` now generates a correctly combined coverprofile when running with in parallel with multiple `-node`s.
- Print out the contents of the `GinkgoWriter` when `BeforeSuite` or `AfterSuite` fail.
- Fix all remaining race conditions in Ginkgo's test suite.
## 1.0.0-beta (4/14/2014)
Breaking changes:
- `thirdparty/gomocktestreporter` is gone. Use `GinkgoT()` instead
- Modified the Reporter interface
- `watch` is now a subcommand, not a flag.
DSL changes:
- `BeforeSuite` and `AfterSuite` for setting up and tearing down test suites.
- `AfterSuite` is triggered on interrupt (`^C`) as well as exit.
- `SynchronizedBeforeSuite` and `SynchronizedAfterSuite` for setting up and tearing down singleton resources across parallel nodes.
CLI changes:
- `watch` is now a subcommand, not a flag
- `--nodot` flag can be passed to `ginkgo generate` and `ginkgo bootstrap` to avoid dot imports. This explicitly imports all exported identifiers in Ginkgo and Gomega. Refreshing this list can be done by running `ginkgo nodot`
- Additional arguments can be passed to specs. Pass them after the `--` separator
- `--skipPackage` flag takes a regexp and ignores any packages with package names passing said regexp.
- `--trace` flag prints out full stack traces when errors occur, not just the line at which the error occurs.
Misc:
- Start using semantic versioning
- Start maintaining changelog
Major refactor:
- Pull out Ginkgo's internal to `internal`
- Rename `example` everywhere to `spec`
- Much more!
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to Ginkgo
Your contributions to Ginkgo are essential for its long-term maintenance and improvement.
- Please **open an issue first** - describe what problem you are trying to solve and give the community a forum for input and feedback ahead of investing time in writing code!
- Ensure adequate test coverage:
- When adding to the Ginkgo library, add unit and/or integration tests (under the `integration` folder).
- When adding to the Ginkgo CLI, note that there are very few unit tests. Please add an integration test.
- Run `make` or:
- Install ginkgo locally via `go install ./...`
- Make sure all the tests succeed via `ginkgo -r -p`
- Vet your changes via `go vet ./...`
- Update the documentation. Ginkgo uses `godoc` comments and documentation in `docs/index.md`. You can run `bundle && bundle exec jekyll serve` in the `docs` directory to preview your changes.
Thanks for supporting Ginkgo!
================================================
FILE: LICENSE
================================================
Copyright (c) 2013-2014 Onsi Fakhouri
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.
================================================
FILE: Makefile
================================================
# default task since it's first
.PHONY: all
all: vet test
.PHONY: test
test:
go run github.com/onsi/ginkgo/v2/ginkgo -r -p -randomize-all -keep-going
.PHONY: vet
vet:
go vet ./...
.PHONY: update-deps
update-deps:
go get -u ./...
go mod tidy
================================================
FILE: README.md
================================================
[](https://github.com/onsi/ginkgo/actions?query=workflow%3Atest+branch%3Amaster) | [Ginkgo Docs](https://onsi.github.io/ginkgo/)
---
# Ginkgo
Ginkgo is a mature testing framework for Go designed to help you write expressive specs. Ginkgo builds on top of Go's `testing` foundation and is complemented by the [Gomega](https://github.com/onsi/gomega) matcher library. Together, Ginkgo and Gomega let you express the intent behind your specs clearly:
```go
import (
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
...
)
var _ = Describe("Checking books out of the library", Label("library"), func() {
var library *libraries.Library
var book *books.Book
var valjean *users.User
BeforeEach(func() {
library = libraries.NewClient()
book = &books.Book{
Title: "Les Miserables",
Author: "Victor Hugo",
}
valjean = users.NewUser("Jean Valjean")
})
When("the library has the book in question", func() {
BeforeEach(func(ctx SpecContext) {
Expect(library.Store(ctx, book)).To(Succeed())
})
Context("and the book is available", func() {
It("lends it to the reader", func(ctx SpecContext) {
Expect(valjean.Checkout(ctx, library, "Les Miserables")).To(Succeed())
Expect(valjean.Books()).To(ContainElement(book))
Expect(library.UserWithBook(ctx, book)).To(Equal(valjean))
}, SpecTimeout(time.Second * 5))
})
Context("but the book has already been checked out", func() {
var javert *users.User
BeforeEach(func(ctx SpecContext) {
javert = users.NewUser("Javert")
Expect(javert.Checkout(ctx, library, "Les Miserables")).To(Succeed())
})
It("tells the user", func(ctx SpecContext) {
err := valjean.Checkout(ctx, library, "Les Miserables")
Expect(err).To(MatchError("Les Miserables is currently checked out"))
}, SpecTimeout(time.Second * 5))
It("lets the user place a hold and get notified later", func(ctx SpecContext) {
Expect(valjean.Hold(ctx, library, "Les Miserables")).To(Succeed())
Expect(valjean.Holds(ctx)).To(ContainElement(book))
By("when Javert returns the book")
Expect(javert.Return(ctx, library, book)).To(Succeed())
By("it eventually informs Valjean")
notification := "Les Miserables is ready for pick up"
Eventually(ctx, valjean.Notifications).Should(ContainElement(notification))
Expect(valjean.Checkout(ctx, library, "Les Miserables")).To(Succeed())
Expect(valjean.Books(ctx)).To(ContainElement(book))
Expect(valjean.Holds(ctx)).To(BeEmpty())
}, SpecTimeout(time.Second * 10))
})
})
When("the library does not have the book in question", func() {
It("tells the reader the book is unavailable", func(ctx SpecContext) {
err := valjean.Checkout(ctx, library, "Les Miserables")
Expect(err).To(MatchError("Les Miserables is not in the library catalog"))
}, SpecTimeout(time.Second * 5))
})
})
```
Jump to the [docs](https://onsi.github.io/ginkgo/) to learn more. It's easy to [bootstrap](https://onsi.github.io/ginkgo/#bootstrapping-a-suite) and start writing your [first specs](https://onsi.github.io/ginkgo/#adding-specs-to-a-suite).
If you have a question, comment, bug report, feature request, etc. please open a [GitHub issue](https://github.com/onsi/ginkgo/issues/new), or visit the [Ginkgo Slack channel](https://app.slack.com/client/T029RQSE6/CQQ50BBNW).
## Capabilities
Whether writing basic unit specs, complex integration specs, or even performance specs - Ginkgo gives you an expressive Domain-Specific Language (DSL) that will be familiar to users coming from frameworks such as [Quick](https://github.com/Quick/Quick), [RSpec](https://rspec.info), [Jasmine](https://jasmine.github.io), and [Busted](https://lunarmodules.github.io/busted/). This style of testing is sometimes referred to as "Behavior-Driven Development" (BDD) though Ginkgo's utility extends beyond acceptance-level testing.
With Ginkgo's DSL you can use nestable [`Describe`, `Context` and `When` container nodes](https://onsi.github.io/ginkgo/#organizing-specs-with-container-nodes) to help you organize your specs. [`BeforeEach` and `AfterEach` setup nodes](https://onsi.github.io/ginkgo/#extracting-common-setup-beforeeach) for setup and cleanup. [`It` and `Specify` subject nodes](https://onsi.github.io/ginkgo/#spec-subjects-it) that hold your assertions. [`BeforeSuite` and `AfterSuite` nodes](https://onsi.github.io/ginkgo/#suite-setup-and-cleanup-beforesuite-and-aftersuite) to prep for and cleanup after a suite... and [much more!](https://onsi.github.io/ginkgo/#writing-specs).
At runtime, Ginkgo can run your specs in reproducibly [random order](https://onsi.github.io/ginkgo/#spec-randomization) and has sophisticated support for [spec parallelization](https://onsi.github.io/ginkgo/#spec-parallelization). In fact, running specs in parallel is as easy as
```bash
ginkgo -p
```
By following [established patterns for writing parallel specs](https://onsi.github.io/ginkgo/#patterns-for-parallel-integration-specs) you can build even large, complex integration suites that parallelize cleanly and run performantly. And you don't have to worry about your spec suite hanging or leaving a mess behind - Ginkgo provides a per-node `context.Context` and the capability to interrupt the spec after a set period of time - and then clean up.
As your suites grow Ginkgo helps you keep your specs organized with [labels](https://onsi.github.io/ginkgo/#spec-labels) and lets you easily run [subsets of specs](https://onsi.github.io/ginkgo/#filtering-specs), either [programmatically](https://onsi.github.io/ginkgo/#focused-specs) or on the [command line](https://onsi.github.io/ginkgo/#combining-filters). And Ginkgo's reporting infrastructure generates machine-readable output in a [variety of formats](https://onsi.github.io/ginkgo/#generating-machine-readable-reports) _and_ allows you to build your own [custom reporting infrastructure](https://onsi.github.io/ginkgo/#generating-reports-programmatically).
Ginkgo ships with `ginkgo`, a [command line tool](https://onsi.github.io/ginkgo/#ginkgo-cli-overview) with support for generating, running, filtering, and profiling Ginkgo suites. You can even have Ginkgo automatically run your specs when it detects a change with `ginkgo watch`, enabling rapid feedback loops during test-driven development.
And that's just Ginkgo! [Gomega](https://onsi.github.io/gomega/) brings a rich, mature, family of [assertions and matchers](https://onsi.github.io/gomega/#provided-matchers) to your suites. With Gomega you can easily mix [synchronous and asynchronous assertions](https://onsi.github.io/ginkgo/#patterns-for-asynchronous-testing) in your specs. You can even build your own set of expressive domain-specific matchers quickly and easily by composing Gomega's [existing building blocks](https://onsi.github.io/ginkgo/#building-custom-matchers).
Happy Testing!
## License
Ginkgo is MIT-Licensed
## Contributing
See [CONTRIBUTING.md](CONTRIBUTING.md)
## Sponsors
Sponsors commit to a [sponsorship](https://github.com/sponsors/onsi) for a year. If you're an organization that makes use of Ginkgo please consider becoming a sponsor!
<p style="font-size:21px; color:black;">Browser testing via
<a href="https://www.testmu.ai/" target="_blank">
<img src="https://assets.testmu.ai/resources/images/logos/white-logo.png" style="vertical-align: middle;" width="250" />
</a>
</p>
================================================
FILE: RELEASING.md
================================================
A Ginkgo release is a tagged git sha and a GitHub release. To cut a release:
1. Ensure CHANGELOG.md is up to date.
- Use
```bash
LAST_VERSION=$(git tag --sort=version:refname | tail -n1)
CHANGES=$(git log --pretty=format:'- %s [%h]' HEAD...$LAST_VERSION)
echo -e "## NEXT\n\n$CHANGES\n\n### Features\n\n### Fixes\n\n### Maintenance\n\n$(cat CHANGELOG.md)" > CHANGELOG.md
```
to update the changelog
- Categorize the changes into
- Breaking Changes (requires a major version)
- New Features (minor version)
- Fixes (fix version)
- Maintenance (which in general should not be mentioned in `CHANGELOG.md` as they have no user impact)
1. Update `VERSION` in `types/version.go`
1. Commit, push, and release:
```
git commit -m "vM.m.p"
git push
gh release create "vM.m.p"
git fetch --tags origin master
```
================================================
FILE: config/deprecated.go
================================================
package config
// GinkgoConfigType has been deprecated and its equivalent now lives in
// the types package. You can no longer access Ginkgo configuration from the config
// package. Instead use the DSL's GinkgoConfiguration() function to get copies of the
// current configuration
//
// GinkgoConfigType is still here so custom V1 reporters do not result in a compilation error
// It will be removed in a future minor release of Ginkgo
type GinkgoConfigType = DeprecatedGinkgoConfigType
type DeprecatedGinkgoConfigType struct {
RandomSeed int64
RandomizeAllSpecs bool
RegexScansFilePath bool
FocusStrings []string
SkipStrings []string
SkipMeasurements bool
FailOnPending bool
FailFast bool
FlakeAttempts int
EmitSpecProgress bool
DryRun bool
DebugParallel bool
ParallelNode int
ParallelTotal int
SyncHost string
StreamHost string
}
// DefaultReporterConfigType has been deprecated and its equivalent now lives in
// the types package. You can no longer access Ginkgo configuration from the config
// package. Instead use the DSL's GinkgoConfiguration() function to get copies of the
// current configuration
//
// DefaultReporterConfigType is still here so custom V1 reporters do not result in a compilation error
// It will be removed in a future minor release of Ginkgo
type DefaultReporterConfigType = DeprecatedDefaultReporterConfigType
type DeprecatedDefaultReporterConfigType struct {
NoColor bool
SlowSpecThreshold float64
NoisyPendings bool
NoisySkippings bool
Succinct bool
Verbose bool
FullTrace bool
ReportPassed bool
ReportFile string
}
// Sadly there is no way to gracefully deprecate access to these global config variables.
// Users who need access to Ginkgo's configuration should use the DSL's GinkgoConfiguration() method
// These new unwieldy type names exist to give users a hint when they try to compile and the compilation fails
type GinkgoConfigIsNoLongerAccessibleFromTheConfigPackageUseTheDSLsGinkgoConfigurationFunctionInstead struct{}
// Sadly there is no way to gracefully deprecate access to these global config variables.
// Users who need access to Ginkgo's configuration should use the DSL's GinkgoConfiguration() method
// These new unwieldy type names exist to give users a hint when they try to compile and the compilation fails
var GinkgoConfig = GinkgoConfigIsNoLongerAccessibleFromTheConfigPackageUseTheDSLsGinkgoConfigurationFunctionInstead{}
// Sadly there is no way to gracefully deprecate access to these global config variables.
// Users who need access to Ginkgo's configuration should use the DSL's GinkgoConfiguration() method
// These new unwieldy type names exist to give users a hint when they try to compile and the compilation fails
type DefaultReporterConfigIsNoLongerAccessibleFromTheConfigPackageUseTheDSLsGinkgoConfigurationFunctionInstead struct{}
// Sadly there is no way to gracefully deprecate access to these global config variables.
// Users who need access to Ginkgo's configuration should use the DSL's GinkgoConfiguration() method
// These new unwieldy type names exist to give users a hint when they try to compile and the compilation fails
var DefaultReporterConfig = DefaultReporterConfigIsNoLongerAccessibleFromTheConfigPackageUseTheDSLsGinkgoConfigurationFunctionInstead{}
================================================
FILE: core_dsl.go
================================================
/*
Ginkgo is a testing framework for Go designed to help you write expressive tests.
https://github.com/onsi/ginkgo
MIT-Licensed
The godoc documentation outlines Ginkgo's API. Since Ginkgo is a Domain-Specific Language it is important to
build a mental model for Ginkgo - the narrative documentation at https://onsi.github.io/ginkgo/ is designed to help you do that.
You should start there - even a brief skim will be helpful. At minimum you should skim through the https://onsi.github.io/ginkgo/#getting-started chapter.
Ginkgo's is best paired with the Gomega matcher library: https://github.com/onsi/gomega
You can run Ginkgo specs with go test - however we recommend using the ginkgo cli. It enables functionality
that go test does not (especially running suites in parallel). You can learn more at https://onsi.github.io/ginkgo/#ginkgo-cli-overview
or by running 'ginkgo help'.
*/
package ginkgo
import (
"fmt"
"io"
"os"
"path/filepath"
"slices"
"strings"
"github.com/go-logr/logr"
"github.com/onsi/ginkgo/v2/formatter"
"github.com/onsi/ginkgo/v2/internal"
"github.com/onsi/ginkgo/v2/internal/global"
"github.com/onsi/ginkgo/v2/internal/interrupt_handler"
"github.com/onsi/ginkgo/v2/internal/parallel_support"
"github.com/onsi/ginkgo/v2/reporters"
"github.com/onsi/ginkgo/v2/types"
)
const GINKGO_VERSION = types.VERSION
var flagSet types.GinkgoFlagSet
var deprecationTracker = types.NewDeprecationTracker()
var suiteConfig = types.NewDefaultSuiteConfig()
var reporterConfig = types.NewDefaultReporterConfig()
var suiteDidRun = false
var outputInterceptor internal.OutputInterceptor
var client parallel_support.Client
func init() {
var err error
flagSet, err = types.BuildTestSuiteFlagSet(&suiteConfig, &reporterConfig)
exitIfErr(err)
writer := internal.NewWriter(os.Stdout)
GinkgoWriter = writer
GinkgoLogr = internal.GinkgoLogrFunc(writer)
}
func exitIfErr(err error) {
if err != nil {
if outputInterceptor != nil {
outputInterceptor.Shutdown()
}
if client != nil {
client.Close()
}
fmt.Fprintln(formatter.ColorableStdErr, err.Error())
os.Exit(1)
}
}
func exitIfErrors(errors []error) {
if len(errors) > 0 {
if outputInterceptor != nil {
outputInterceptor.Shutdown()
}
if client != nil {
client.Close()
}
for _, err := range errors {
fmt.Fprintln(formatter.ColorableStdErr, err.Error())
}
os.Exit(1)
}
}
// The interface implemented by GinkgoWriter
type GinkgoWriterInterface interface {
io.Writer
Print(a ...any)
Printf(format string, a ...any)
Println(a ...any)
TeeTo(writer io.Writer)
ClearTeeWriters()
}
/*
SpecContext is the context object passed into nodes that are subject to a timeout or need to be notified of an interrupt. It implements the standard context.Context interface but also contains additional helpers to provide an extensibility point for Ginkgo. (As an example, Gomega's Eventually can use the methods defined on SpecContext to provide deeper integration with Ginkgo).
You can do anything with SpecContext that you do with a typical context.Context including wrapping it with any of the context.With* methods.
Ginkgo will cancel the SpecContext when a node is interrupted (e.g. by the user sending an interrupt signal) or when a node has exceeded its allowed run-time. Note, however, that even in cases where a node has a deadline, SpecContext will not return a deadline via .Deadline(). This is because Ginkgo does not use a WithDeadline() context to model node deadlines as Ginkgo needs control over the precise timing of the context cancellation to ensure it can provide an accurate progress report at the moment of cancellation.
*/
type SpecContext = internal.SpecContext
/*
GinkgoWriter implements a GinkgoWriterInterface and io.Writer
When running in verbose mode (ginkgo -v) any writes to GinkgoWriter will be immediately printed
to stdout. Otherwise, GinkgoWriter will buffer any writes produced during the current test and flush them to screen
only if the current test fails.
GinkgoWriter also provides convenience Print, Printf and Println methods and allows you to tee to a custom writer via GinkgoWriter.TeeTo(writer).
Writes to GinkgoWriter are immediately sent to any registered TeeTo() writers. You can unregister all TeeTo() Writers with GinkgoWriter.ClearTeeWriters()
You can learn more at https://onsi.github.io/ginkgo/#logging-output
*/
var GinkgoWriter GinkgoWriterInterface
/*
GinkgoLogr is a logr.Logger that writes to GinkgoWriter
*/
var GinkgoLogr logr.Logger
// The interface by which Ginkgo receives *testing.T
type GinkgoTestingT interface {
Fail()
}
/*
GinkgoConfiguration returns the configuration of the current suite.
The first return value is the SuiteConfig which controls aspects of how the suite runs,
the second return value is the ReporterConfig which controls aspects of how Ginkgo's default
reporter emits output.
Mutating the returned configurations has no effect. To reconfigure Ginkgo programmatically you need
to pass in your mutated copies into RunSpecs().
You can learn more at https://onsi.github.io/ginkgo/#overriding-ginkgos-command-line-configuration-in-the-suite
*/
func GinkgoConfiguration() (types.SuiteConfig, types.ReporterConfig) {
return suiteConfig, reporterConfig
}
/*
GinkgoRandomSeed returns the seed used to randomize spec execution order. It is
useful for seeding your own pseudorandom number generators to ensure
consistent executions from run to run, where your tests contain variability (for
example, when selecting random spec data).
You can learn more at https://onsi.github.io/ginkgo/#spec-randomization
*/
func GinkgoRandomSeed() int64 {
return suiteConfig.RandomSeed
}
/*
GinkgoParallelProcess returns the parallel process number for the current ginkgo process
The process number is 1-indexed. You can use GinkgoParallelProcess() to shard access to shared
resources across your suites. You can learn more about patterns for sharding at https://onsi.github.io/ginkgo/#patterns-for-parallel-integration-specs
For more on how specs are parallelized in Ginkgo, see http://onsi.github.io/ginkgo/#spec-parallelization
*/
func GinkgoParallelProcess() int {
return suiteConfig.ParallelProcess
}
/*
GinkgoHelper marks the function it's called in as a test helper. When a failure occurs inside a helper function, Ginkgo will skip the helper when analyzing the stack trace to identify where the failure occurred.
This is an alternative, simpler, mechanism to passing in a skip offset when calling Fail or using Gomega.
*/
func GinkgoHelper() {
types.MarkAsHelper(1)
}
/*
GinkgoLabelFilter() returns the label filter configured for this suite via `--label-filter`.
You can use this to manually check if a set of labels would satisfy the filter via:
if (Label("cat", "dog").MatchesLabelFilter(GinkgoLabelFilter())) {
//...
}
*/
func GinkgoLabelFilter() string {
suiteConfig, _ := GinkgoConfiguration()
return suiteConfig.LabelFilter
}
/*
GinkgoSemVerFilter() returns the semantic version filter configured for this suite via `--sem-ver-filter`.
You can use this to manually check if a set of semantic version constraints would satisfy the filter via:
if (SemVerConstraint("> 2.6.0", "< 2.8.0").MatchesSemVerFilter(GinkgoSemVerFilter())) {
//...
}
*/
func GinkgoSemVerFilter() string {
suiteConfig, _ := GinkgoConfiguration()
return suiteConfig.SemVerFilter
}
/*
PauseOutputInterception() pauses Ginkgo's output interception. This is only relevant
when running in parallel and output to stdout/stderr is being intercepted. You generally
don't need to call this function - however there are cases when Ginkgo's output interception
mechanisms can interfere with external processes launched by the test process.
In particular, if an external process is launched that has cmd.Stdout/cmd.Stderr set to os.Stdout/os.Stderr
then Ginkgo's output interceptor will hang. To circumvent this, set cmd.Stdout/cmd.Stderr to GinkgoWriter.
If, for some reason, you aren't able to do that, you can PauseOutputInterception() before starting the process
then ResumeOutputInterception() after starting it.
Note that PauseOutputInterception() does not cause stdout writes to print to the console -
this simply stops intercepting and storing stdout writes to an internal buffer.
*/
func PauseOutputInterception() {
if outputInterceptor == nil {
return
}
outputInterceptor.PauseIntercepting()
}
// ResumeOutputInterception() - see docs for PauseOutputInterception()
func ResumeOutputInterception() {
if outputInterceptor == nil {
return
}
outputInterceptor.ResumeIntercepting()
}
/*
RunSpecs is the entry point for the Ginkgo spec runner.
You must call this within a Golang testing TestX(t *testing.T) function.
If you bootstrapped your suite with "ginkgo bootstrap" this is already
done for you.
Ginkgo is typically configured via command-line flags. This configuration
can be overridden, however, and passed into RunSpecs as optional arguments:
func TestMySuite(t *testing.T) {
RegisterFailHandler(gomega.Fail)
// fetch the current config
suiteConfig, reporterConfig := GinkgoConfiguration()
// adjust it
suiteConfig.SkipStrings = []string{"NEVER-RUN"}
reporterConfig.FullTrace = true
// pass it in to RunSpecs
RunSpecs(t, "My Suite", suiteConfig, reporterConfig)
}
Note that some configuration changes can lead to undefined behavior. For example,
you should not change ParallelProcess or ParallelTotal as the Ginkgo CLI is responsible
for setting these and orchestrating parallel specs across the parallel processes. See http://onsi.github.io/ginkgo/#spec-parallelization
for more on how specs are parallelized in Ginkgo.
You can also pass suite-level Label() decorators to RunSpecs. The passed-in labels will apply to all specs in the suite.
*/
func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
if suiteDidRun {
exitIfErr(types.GinkgoErrors.RerunningSuite())
}
suiteDidRun = true
err := global.PushClone()
if err != nil {
exitIfErr(err)
}
defer global.PopClone()
suiteLabels, suiteSemVerConstraints, suiteComponentSemVerConstraints, suiteAroundNodes := extractSuiteConfiguration(args)
var reporter reporters.Reporter
if suiteConfig.ParallelTotal == 1 {
reporter = reporters.NewDefaultReporter(reporterConfig, formatter.ColorableStdOut)
outputInterceptor = internal.NoopOutputInterceptor{}
client = nil
} else {
reporter = reporters.NoopReporter{}
switch strings.ToLower(suiteConfig.OutputInterceptorMode) {
case "swap":
outputInterceptor = internal.NewOSGlobalReassigningOutputInterceptor()
case "none":
outputInterceptor = internal.NoopOutputInterceptor{}
default:
outputInterceptor = internal.NewOutputInterceptor()
}
client = parallel_support.NewClient(suiteConfig.ParallelHost)
if !client.Connect() {
client = nil
exitIfErr(types.GinkgoErrors.UnreachableParallelHost(suiteConfig.ParallelHost))
}
defer client.Close()
}
writer := GinkgoWriter.(*internal.Writer)
if reporterConfig.Verbosity().GTE(types.VerbosityLevelVerbose) && suiteConfig.ParallelTotal == 1 {
writer.SetMode(internal.WriterModeStreamAndBuffer)
} else {
writer.SetMode(internal.WriterModeBufferOnly)
}
if reporterConfig.WillGenerateReport() {
registerReportAfterSuiteNodeForAutogeneratedReports(reporterConfig)
}
err = global.Suite.BuildTree()
exitIfErr(err)
suitePath, err := getwd()
exitIfErr(err)
suitePath, err = filepath.Abs(suitePath)
exitIfErr(err)
passed, hasFocusedTests := global.Suite.Run(description, suiteLabels, suiteSemVerConstraints, suiteComponentSemVerConstraints, suiteAroundNodes, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
outputInterceptor.Shutdown()
flagSet.ValidateDeprecations(deprecationTracker)
if deprecationTracker.DidTrackDeprecations() {
fmt.Fprintln(formatter.ColorableStdErr, deprecationTracker.DeprecationsReport())
}
if !passed {
t.Fail()
}
if passed && hasFocusedTests && strings.TrimSpace(os.Getenv("GINKGO_EDITOR_INTEGRATION")) == "" {
fmt.Println("PASS | FOCUSED")
os.Exit(types.GINKGO_FOCUS_EXIT_CODE)
}
return passed
}
func extractSuiteConfiguration(args []any) (Labels, SemVerConstraints, ComponentSemVerConstraints, types.AroundNodes) {
suiteLabels := Labels{}
suiteSemVerConstraints := SemVerConstraints{}
suiteComponentSemVerConstraints := ComponentSemVerConstraints{}
aroundNodes := types.AroundNodes{}
configErrors := []error{}
for _, arg := range args {
switch arg := arg.(type) {
case types.SuiteConfig:
suiteConfig = arg
case types.ReporterConfig:
reporterConfig = arg
case Labels:
suiteLabels = append(suiteLabels, arg...)
case SemVerConstraints:
suiteSemVerConstraints = append(suiteSemVerConstraints, arg...)
case ComponentSemVerConstraints:
for component, constraints := range arg {
suiteComponentSemVerConstraints[component] = append(suiteComponentSemVerConstraints[component], constraints...)
suiteComponentSemVerConstraints[component] = slices.Compact(suiteComponentSemVerConstraints[component])
}
case types.AroundNodeDecorator:
aroundNodes = append(aroundNodes, arg)
default:
configErrors = append(configErrors, types.GinkgoErrors.UnknownTypePassedToRunSpecs(arg))
}
}
exitIfErrors(configErrors)
configErrors = types.VetConfig(flagSet, suiteConfig, reporterConfig)
if len(configErrors) > 0 {
fmt.Fprint(formatter.ColorableStdErr, formatter.F("{{red}}Ginkgo detected configuration issues:{{/}}\n"))
for _, err := range configErrors {
fmt.Fprint(formatter.ColorableStdErr, err.Error())
}
os.Exit(1)
}
return suiteLabels, suiteSemVerConstraints, suiteComponentSemVerConstraints, aroundNodes
}
func getwd() (string, error) {
if !strings.EqualFold(os.Getenv("GINKGO_PRESERVE_CACHE"), "true") {
// Getwd calls os.Getenv("PWD"), which breaks test caching if the cache
// is shared between two different directories with the same test code.
return os.Getwd()
}
return "", nil
}
/*
PreviewSpecs walks the testing tree and produces a report without actually invoking the specs.
See http://onsi.github.io/ginkgo/#previewing-specs for more information.
*/
func PreviewSpecs(description string, args ...any) Report {
err := global.PushClone()
if err != nil {
exitIfErr(err)
}
defer global.PopClone()
suiteLabels, suiteSemVerConstraints, suiteComponentSemVerConstraints, suiteAroundNodes := extractSuiteConfiguration(args)
priorDryRun, priorParallelTotal, priorParallelProcess := suiteConfig.DryRun, suiteConfig.ParallelTotal, suiteConfig.ParallelProcess
suiteConfig.DryRun, suiteConfig.ParallelTotal, suiteConfig.ParallelProcess = true, 1, 1
defer func() {
suiteConfig.DryRun, suiteConfig.ParallelTotal, suiteConfig.ParallelProcess = priorDryRun, priorParallelTotal, priorParallelProcess
}()
reporter := reporters.NoopReporter{}
outputInterceptor = internal.NoopOutputInterceptor{}
client = nil
writer := GinkgoWriter.(*internal.Writer)
err = global.Suite.BuildTree()
exitIfErr(err)
suitePath, err := getwd()
exitIfErr(err)
suitePath, err = filepath.Abs(suitePath)
exitIfErr(err)
global.Suite.Run(description, suiteLabels, suiteSemVerConstraints, suiteComponentSemVerConstraints, suiteAroundNodes, suitePath, global.Failer, reporter, writer, outputInterceptor, interrupt_handler.NewInterruptHandler(client), client, internal.RegisterForProgressSignal, suiteConfig)
return global.Suite.GetPreviewReport()
}
/*
Skip instructs Ginkgo to skip the current spec
You can call Skip in any Setup or Subject node closure.
For more on how to filter specs in Ginkgo see https://onsi.github.io/ginkgo/#filtering-specs
*/
func Skip(message string, callerSkip ...int) {
skip := 0
if len(callerSkip) > 0 {
skip = callerSkip[0]
}
cl := types.NewCodeLocationWithStackTrace(skip + 1)
global.Failer.Skip(message, cl)
panic(types.GinkgoErrors.UncaughtGinkgoPanic(cl))
}
/*
Fail notifies Ginkgo that the current spec has failed. (Gomega will call Fail for you automatically when an assertion fails.)
Under the hood, Fail panics to end execution of the current spec. Ginkgo will catch this panic and proceed with
the subsequent spec. If you call Fail, or make an assertion, within a goroutine launched by your spec you must
add defer GinkgoRecover() to the goroutine to catch the panic emitted by Fail.
You can call Fail in any Setup or Subject node closure.
You can learn more about how Ginkgo manages failures here: https://onsi.github.io/ginkgo/#mental-model-how-ginkgo-handles-failure
*/
func Fail(message string, callerSkip ...int) {
skip := 0
if len(callerSkip) > 0 {
skip = callerSkip[0]
}
cl := types.NewCodeLocationWithStackTrace(skip + 1)
global.Failer.Fail(message, cl)
panic(types.GinkgoErrors.UncaughtGinkgoPanic(cl))
}
/*
AbortSuite instructs Ginkgo to fail the current spec and skip all subsequent specs, thereby aborting the suite.
You can call AbortSuite in any Setup or Subject node closure.
You can learn more about how Ginkgo handles suite interruptions here: https://onsi.github.io/ginkgo/#interrupting-aborting-and-timing-out-suites
*/
func AbortSuite(message string, callerSkip ...int) {
skip := 0
if len(callerSkip) > 0 {
skip = callerSkip[0]
}
cl := types.NewCodeLocationWithStackTrace(skip + 1)
global.Failer.AbortSuite(message, cl)
panic(types.GinkgoErrors.UncaughtGinkgoPanic(cl))
}
/*
ignorablePanic is used by Gomega to signal to GinkgoRecover that Goemga is handling
the error associated with this panic. It i used when Eventually/Consistently are passed a func(g Gomega) and the resulting function launches a goroutines that makes a failed assertion. That failed assertion is registered by Gomega and then panics. Ordinarily the panic is captured by Gomega. In the case of a goroutine Gomega can't capture the panic - so we piggy back on GinkgoRecover so users have a single defer GinkgoRecover() pattern to follow. To do that we need to tell Ginkgo to ignore this panic and not register it as a panic on the global Failer.
*/
type ignorablePanic interface{ GinkgoRecoverShouldIgnoreThisPanic() }
/*
GinkgoRecover should be deferred at the top of any spawned goroutine that (may) call `Fail`
Since Gomega assertions call fail, you should throw a `defer GinkgoRecover()` at the top of any goroutine that
calls out to Gomega
Here's why: Ginkgo's `Fail` method records the failure and then panics to prevent
further assertions from running. This panic must be recovered. Normally, Ginkgo recovers the panic for you,
however if a panic originates on a goroutine *launched* from one of your specs there's no
way for Ginkgo to rescue the panic. To do this, you must remember to `defer GinkgoRecover()` at the top of such a goroutine.
You can learn more about how Ginkgo manages failures here: https://onsi.github.io/ginkgo/#mental-model-how-ginkgo-handles-failure
*/
func GinkgoRecover() {
e := recover()
if e != nil {
if _, ok := e.(ignorablePanic); ok {
return
}
global.Failer.Panic(types.NewCodeLocationWithStackTrace(1), e)
}
}
// pushNode is used by the various test construction DSL methods to push nodes onto the suite
// it handles returned errors, emits a detailed error message to help the user learn what they may have done wrong, then exits
func pushNode(node internal.Node, errors []error) bool {
exitIfErrors(errors)
exitIfErr(global.Suite.PushNode(node))
return true
}
// NodeArgsTransformer is a hook which is called by the test construction DSL methods
// before creating the new node. If it returns any error, the test suite
// prints those errors and exits. The text and arguments can be modified,
// which includes directly changing the args slice that is passed in.
// Arguments have been flattened already, i.e. none of the entries in args is another []any.
// The result may be nested.
//
// The node type is provided for information and remains the same.
//
// The offset is valid for calling NewLocation directly in the
// implementation of TransformNodeArgs to find the location where
// the Ginkgo DSL function is called. An additional offset supplied
// by the caller via args is already included.
//
// A NodeArgsTransformer can be registered with AddTreeConstructionNodeArgsTransformer.
type NodeArgsTransformer func(nodeType types.NodeType, offset Offset, text string, args []any) (string, []any, []error)
// AddTreeConstructionNodeArgsTransformer registers a NodeArgsTransformer.
// Only nodes which get created after registering a NodeArgsTransformer
// are transformed by it. The returned function can be called to
// unregister the transformer.
//
// Both may only be called during the construction phase.
//
// If there is more than one registered transformer, then the most
// recently added ones get called first.
func AddTreeConstructionNodeArgsTransformer(transformer NodeArgsTransformer) func() {
// This conversion could be avoided with a type alias, but type aliases make
// developer documentation less useful.
return internal.AddTreeConstructionNodeArgsTransformer(internal.NodeArgsTransformer(transformer))
}
/*
Describe nodes are Container nodes that allow you to organize your specs. A Describe node's closure can contain any number of
Setup nodes (e.g. BeforeEach, AfterEach, JustBeforeEach), and Subject nodes (i.e. It).
Context and When nodes are aliases for Describe - use whichever gives your suite a better narrative flow. It is idomatic
to Describe the behavior of an object or function and, within that Describe, outline a number of Contexts and Whens.
You can learn more at https://onsi.github.io/ginkgo/#organizing-specs-with-container-nodes
In addition, container nodes can be decorated with a variety of decorators. You can learn more here: https://onsi.github.io/ginkgo/#decorator-reference
*/
func Describe(text string, args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeContainer, text, args...)))
}
/*
FDescribe focuses specs within the Describe block.
*/
func FDescribe(text string, args ...any) bool {
args = append(args, internal.Focus)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeContainer, text, args...)))
}
/*
PDescribe marks specs within the Describe block as pending.
*/
func PDescribe(text string, args ...any) bool {
args = append(args, internal.Pending)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeContainer, text, args...)))
}
/*
XDescribe marks specs within the Describe block as pending.
XDescribe is an alias for PDescribe
*/
var XDescribe = PDescribe
/* Context is an alias for Describe - it generates the exact same kind of Container node */
var Context, FContext, PContext, XContext = Describe, FDescribe, PDescribe, XDescribe
/* When is an alias for Describe - it generates the exact same kind of Container node with "when " as prefix for the text. */
func When(text string, args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeContainer, "when "+text, args...)))
}
/* When is an alias for Describe - it generates the exact same kind of Container node with "when " as prefix for the text. */
func FWhen(text string, args ...any) bool {
args = append(args, internal.Focus)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeContainer, "when "+text, args...)))
}
/* When is an alias for Describe - it generates the exact same kind of Container node */
func PWhen(text string, args ...any) bool {
args = append(args, internal.Pending)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeContainer, "when "+text, args...)))
}
var XWhen = PWhen
/*
It nodes are Subject nodes that contain your spec code and assertions.
Each It node corresponds to an individual Ginkgo spec. You cannot nest any other Ginkgo nodes within an It node's closure.
You can pass It nodes bare functions (func() {}) or functions that receive a SpecContext or context.Context: func(ctx SpecContext) {} and func (ctx context.Context) {}. If the function takes a context then the It is deemed interruptible and Ginkgo will cancel the context in the event of a timeout (configured via the SpecTimeout() or NodeTimeout() decorators) or of an interrupt signal.
You can learn more at https://onsi.github.io/ginkgo/#spec-subjects-it
In addition, subject nodes can be decorated with a variety of decorators. You can learn more here: https://onsi.github.io/ginkgo/#decorator-reference
*/
func It(text string, args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeIt, text, args...)))
}
/*
FIt allows you to focus an individual It.
*/
func FIt(text string, args ...any) bool {
args = append(args, internal.Focus)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeIt, text, args...)))
}
/*
PIt allows you to mark an individual It as pending.
*/
func PIt(text string, args ...any) bool {
args = append(args, internal.Pending)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeIt, text, args...)))
}
/*
XIt allows you to mark an individual It as pending.
XIt is an alias for PIt
*/
var XIt = PIt
/*
Specify is an alias for It - it can allow for more natural wording in some context.
*/
var Specify, FSpecify, PSpecify, XSpecify = It, FIt, PIt, XIt
/*
By allows you to better document complex Specs.
Generally you should try to keep your Its short and to the point. This is not always possible, however,
especially in the context of integration tests that capture complex or lengthy workflows.
By allows you to document such flows. By may be called within a Setup or Subject node (It, BeforeEach, etc...)
and will simply log the passed in text to the GinkgoWriter. If By is handed a function it will immediately run the function.
By will also generate and attach a ReportEntry to the spec. This will ensure that By annotations appear in Ginkgo's machine-readable reports.
Note that By does not generate a new Ginkgo node - rather it is simply syntactic sugar around GinkgoWriter and AddReportEntry
You can learn more about By here: https://onsi.github.io/ginkgo/#documenting-complex-specs-by
*/
func By(text string, callback ...func()) {
exitIfErr(global.Suite.By(text, callback...))
}
/*
BeforeSuite nodes are suite-level Setup nodes that run just once before any specs are run.
When running in parallel, each parallel process will call BeforeSuite.
You may only register *one* BeforeSuite handler per test suite. You typically do so in your bootstrap file at the top level.
BeforeSuite can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within a BeforeSuite node's closure.
You can learn more here: https://onsi.github.io/ginkgo/#suite-setup-and-cleanup-beforesuite-and-aftersuite
*/
func BeforeSuite(body any, args ...any) bool {
combinedArgs := []any{body}
combinedArgs = append(combinedArgs, args...)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeBeforeSuite, "", combinedArgs...)))
}
/*
AfterSuite nodes are suite-level Setup nodes run after all specs have finished - regardless of whether specs have passed or failed.
AfterSuite node closures always run, even if Ginkgo receives an interrupt signal (^C), in order to ensure cleanup occurs.
When running in parallel, each parallel process will call AfterSuite.
You may only register *one* AfterSuite handler per test suite. You typically do so in your bootstrap file at the top level.
AfterSuite can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within an AfterSuite node's closure.
You can learn more here: https://onsi.github.io/ginkgo/#suite-setup-and-cleanup-beforesuite-and-aftersuite
*/
func AfterSuite(body any, args ...any) bool {
combinedArgs := []any{body}
combinedArgs = append(combinedArgs, args...)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeAfterSuite, "", combinedArgs...)))
}
/*
SynchronizedBeforeSuite nodes allow you to perform some of the suite setup just once - on parallel process #1 - and then pass information
from that setup to the rest of the suite setup on all processes. This is useful for performing expensive or singleton setup once, then passing
information from that setup to all parallel processes.
SynchronizedBeforeSuite accomplishes this by taking *two* function arguments and passing data between them.
The first function is only run on parallel process #1. The second is run on all processes, but *only* after the first function completes successfully. The functions have the following signatures:
The first function (which only runs on process #1) can have any of the following the signatures:
func()
func(ctx context.Context)
func(ctx SpecContext)
func() []byte
func(ctx context.Context) []byte
func(ctx SpecContext) []byte
The byte array returned by the first function (if present) is then passed to the second function, which can have any of the following signature:
func()
func(ctx context.Context)
func(ctx SpecContext)
func(data []byte)
func(ctx context.Context, data []byte)
func(ctx SpecContext, data []byte)
If either function receives a context.Context/SpecContext it is considered interruptible.
You cannot nest any other Ginkgo nodes within an SynchronizedBeforeSuite node's closure.
You can learn more, and see some examples, here: https://onsi.github.io/ginkgo/#parallel-suite-setup-and-cleanup-synchronizedbeforesuite-and-synchronizedaftersuite
*/
func SynchronizedBeforeSuite(process1Body any, allProcessBody any, args ...any) bool {
combinedArgs := []any{process1Body, allProcessBody}
combinedArgs = append(combinedArgs, args...)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeSynchronizedBeforeSuite, "", combinedArgs...)))
}
/*
SynchronizedAfterSuite nodes complement the SynchronizedBeforeSuite nodes in solving the problem of splitting clean up into a piece that runs on all processes
and a piece that must only run once - on process #1.
SynchronizedAfterSuite accomplishes this by taking *two* function arguments. The first runs on all processes. The second runs only on parallel process #1
and *only* after all other processes have finished and exited. This ensures that process #1, and any resources it is managing, remain alive until
all other processes are finished. These two functions can be bare functions (func()) or interruptible (func(context.Context)/func(SpecContext))
Note that you can also use DeferCleanup() in SynchronizedBeforeSuite to accomplish similar results.
You cannot nest any other Ginkgo nodes within an SynchronizedAfterSuite node's closure.
You can learn more, and see some examples, here: https://onsi.github.io/ginkgo/#parallel-suite-setup-and-cleanup-synchronizedbeforesuite-and-synchronizedaftersuite
*/
func SynchronizedAfterSuite(allProcessBody any, process1Body any, args ...any) bool {
combinedArgs := []any{allProcessBody, process1Body}
combinedArgs = append(combinedArgs, args...)
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeSynchronizedAfterSuite, "", combinedArgs...)))
}
/*
BeforeEach nodes are Setup nodes whose closures run before It node closures. When multiple BeforeEach nodes
are defined in nested Container nodes the outermost BeforeEach node closures are run first.
BeforeEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within a BeforeEach node's closure.
You can learn more here: https://onsi.github.io/ginkgo/#extracting-common-setup-beforeeach
*/
func BeforeEach(args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeBeforeEach, "", args...)))
}
/*
JustBeforeEach nodes are similar to BeforeEach nodes, however they are guaranteed to run *after* all BeforeEach node closures - just before the It node closure.
This can allow you to separate configuration from creation of resources for a spec.
JustBeforeEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within a JustBeforeEach node's closure.
You can learn more and see some examples here: https://onsi.github.io/ginkgo/#separating-creation-and-configuration-justbeforeeach
*/
func JustBeforeEach(args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeJustBeforeEach, "", args...)))
}
/*
AfterEach nodes are Setup nodes whose closures run after It node closures. When multiple AfterEach nodes
are defined in nested Container nodes the innermost AfterEach node closures are run first.
Note that you can also use DeferCleanup() in other Setup or Subject nodes to accomplish similar results.
AfterEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within an AfterEach node's closure.
You can learn more here: https://onsi.github.io/ginkgo/#spec-cleanup-aftereach-and-defercleanup
*/
func AfterEach(args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeAfterEach, "", args...)))
}
/*
JustAfterEach nodes are similar to AfterEach nodes, however they are guaranteed to run *before* all AfterEach node closures - just after the It node closure. This can allow you to separate diagnostics collection from teardown for a spec.
JustAfterEach can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within a JustAfterEach node's closure.
You can learn more and see some examples here: https://onsi.github.io/ginkgo/#separating-diagnostics-collection-and-teardown-justaftereach
*/
func JustAfterEach(args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeJustAfterEach, "", args...)))
}
/*
BeforeAll nodes are Setup nodes that can occur inside Ordered containers. They run just once before any specs in the Ordered container run.
Multiple BeforeAll nodes can be defined in a given Ordered container however they cannot be nested inside any other container.
BeforeAll can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within a BeforeAll node's closure.
You can learn more about Ordered Containers at: https://onsi.github.io/ginkgo/#ordered-containers
And you can learn more about BeforeAll at: https://onsi.github.io/ginkgo/#setup-in-ordered-containers-beforeall-and-afterall
*/
func BeforeAll(args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeBeforeAll, "", args...)))
}
/*
AfterAll nodes are Setup nodes that can occur inside Ordered containers. They run just once after all specs in the Ordered container have run.
Multiple AfterAll nodes can be defined in a given Ordered container however they cannot be nested inside any other container.
Note that you can also use DeferCleanup() in a BeforeAll node to accomplish similar behavior.
AfterAll can take a func() body, or an interruptible func(SpecContext)/func(context.Context) body.
You cannot nest any other Ginkgo nodes within an AfterAll node's closure.
You can learn more about Ordered Containers at: https://onsi.github.io/ginkgo/#ordered-containers
And you can learn more about AfterAll at: https://onsi.github.io/ginkgo/#setup-in-ordered-containers-beforeall-and-afterall
*/
func AfterAll(args ...any) bool {
return pushNode(internal.NewNode(internal.TransformNewNodeArgs(exitIfErrors, deprecationTracker, types.NodeTypeAfterAll, "", args...)))
}
/*
DeferCleanup can be called within any Setup or Subject node to register a cleanup callback that Ginkgo will call at the appropriate time to cleanup after the spec.
DeferCleanup can be passed:
1. A function that takes no arguments and returns no values.
2. A function that returns multiple values. `DeferCleanup` will ignore all these return values except for the last one. If this last return value is a non-nil error `DeferCleanup` will fail the spec).
3. A function that takes a context.Context or SpecContext (and optionally returns multiple values). The resulting cleanup node is deemed interruptible and the passed-in context will be cancelled in the event of a timeout or interrupt.
4. A function that takes arguments (and optionally returns multiple values) followed by a list of arguments to pass to the function.
5. A function that takes SpecContext and a list of arguments (and optionally returns multiple values) followed by a list of arguments to pass to the function.
For example:
BeforeEach(func() {
DeferCleanup(os.Setenv, "FOO", os.GetEnv("FOO"))
os.Setenv("FOO", "BAR")
})
will register a cleanup handler that will set the environment variable "FOO" to its current value (obtained by os.GetEnv("FOO")) after the spec runs and then sets the environment variable "FOO" to "BAR" for the current spec.
Similarly:
BeforeEach(func() {
DeferCleanup(func(ctx SpecContext, path) {
req, err := http.NewRequestWithContext(ctx, "POST", path, nil)
Expect(err).NotTo(HaveOccured())
_, err := http.DefaultClient.Do(req)
Expect(err).NotTo(HaveOccured())
}, "example.com/cleanup", NodeTimeout(time.Second*3))
})
will register a cleanup handler that will have three seconds to successfully complete a request to the specified path. Note that we do not specify a context in the list of arguments passed to DeferCleanup - only in the signature of the function we pass in. Ginkgo will detect the requested context and supply a SpecContext when it invokes the cleanup node. If you want to pass in your own context in addition to the Ginkgo-provided SpecContext you must specify the SpecContext as the first argument (e.g. func(ctx SpecContext, otherCtx context.Context)).
When DeferCleanup is called in BeforeEach, JustBeforeEach, It, AfterEach, or JustAfterEach the registered callback will be invoked when the spec completes (i.e. it will behave like an AfterEach node)
When DeferCleanup is called in BeforeAll or AfterAll the registered callback will be invoked when the ordered container completes (i.e. it will behave like an AfterAll node)
When DeferCleanup is called in BeforeSuite, SynchronizedBeforeSuite, AfterSuite, or SynchronizedAfterSuite the registered callback will be invoked when the suite completes (i.e. it will behave like an AfterSuite node)
Note that DeferCleanup does not represent a node but rather dynamically generates the appropriate type of cleanup node based on the context in which it is called. As such you must call DeferCleanup within a Setup or Subject node, and not within a Container node.
You can learn more about DeferCleanup here: https://onsi.github.io/ginkgo/#cleaning-up-our-cleanup-code-defercleanup
*/
func DeferCleanup(args ...any) {
fail := func(message string, cl types.CodeLocation) {
global.Failer.Fail(message, cl)
}
pushNode(internal.NewCleanupNode(deprecationTracker, fail, args...))
}
/*
AttachProgressReporter allows you to register a function that will be called whenever Ginkgo generates a Progress Report. The contents returned by the function will be included in the report.
**This is an experimental feature and the public-facing interface may change in a future minor version of Ginkgo**
Progress Reports are generated:
- whenever the user explicitly requests one (via `SIGINFO` or `SIGUSR1`)
- on nodes decorated with PollProgressAfter
- on suites run with --poll-progress-after
- whenever a test times out
Ginkgo uses Progress Reports to convey the current state of the test suite, including any running goroutines. By attaching a progress reporter you are able to supplement these reports with additional information.
# AttachProgressReporter returns a function that can be called to detach the progress reporter
You can learn more about AttachProgressReporter here: https://onsi.github.io/ginkgo/#attaching-additional-information-to-progress-reports
*/
func AttachProgressReporter(reporter func() string) func() {
return global.Suite.AttachProgressReporter(reporter)
}
================================================
FILE: decorator_dsl.go
================================================
package ginkgo
import (
"github.com/onsi/ginkgo/v2/internal"
"github.com/onsi/ginkgo/v2/types"
)
/*
Offset(uint) is a decorator that allows you to change the stack-frame offset used when computing the line number of the node in question.
You can learn more here: https://onsi.github.io/ginkgo/#the-offset-decorator
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
type Offset = internal.Offset
/*
FlakeAttempts(uint N) is a decorator that allows you to mark individual specs or spec containers as flaky. Ginkgo will run them up to `N` times until they pass.
You can learn more here: https://onsi.github.io/ginkgo/#the-flakeattempts-decorator
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
type FlakeAttempts = internal.FlakeAttempts
/*
MustPassRepeatedly(uint N) is a decorator that allows you to repeat the execution of individual specs or spec containers. Ginkgo will run them up to `N` times until they fail.
You can learn more here: https://onsi.github.io/ginkgo/#the-mustpassrepeatedly-decorator
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
type MustPassRepeatedly = internal.MustPassRepeatedly
/*
Focus is a decorator that allows you to mark a spec or container as focused. Identical to FIt and FDescribe.
You can learn more here: https://onsi.github.io/ginkgo/#filtering-specs
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
const Focus = internal.Focus
/*
Pending is a decorator that allows you to mark a spec or container as pending. Identical to PIt and PDescribe.
You can learn more here: https://onsi.github.io/ginkgo/#filtering-specs
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
const Pending = internal.Pending
/*
Serial is a decorator that allows you to mark a spec or container as serial. These specs will never run in parallel with other specs.
Specs in ordered containers cannot be marked as serial - mark the ordered container instead.
You can learn more here: https://onsi.github.io/ginkgo/#serial-specs
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
const Serial = internal.Serial
/*
Ordered is a decorator that allows you to mark a container as ordered. Specs in the container will always run in the order they appear.
They will never be randomized and they will never run in parallel with one another, though they may run in parallel with other specs.
You can learn more here: https://onsi.github.io/ginkgo/#ordered-containers
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
const Ordered = internal.Ordered
/*
ContinueOnFailure is a decorator that allows you to mark an Ordered container to continue running specs even if failures occur. Ordinarily an ordered container will stop running specs after the first failure occurs. Note that if a BeforeAll or a BeforeEach/JustBeforeEach annotated with OncePerOrdered fails then no specs will run as the precondition for the Ordered container will consider to be failed.
ContinueOnFailure only applies to the outermost Ordered container. Attempting to place ContinueOnFailure in a nested container will result in an error.
You can learn more here: https://onsi.github.io/ginkgo/#ordered-containers
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
const ContinueOnFailure = internal.ContinueOnFailure
/*
OncePerOrdered is a decorator that allows you to mark outer BeforeEach, AfterEach, JustBeforeEach, and JustAfterEach setup nodes to run once
per ordered context. Normally these setup nodes run around each individual spec, with OncePerOrdered they will run once around the set of specs in an ordered container.
The behavior for non-Ordered containers/specs is unchanged.
You can learn more here: https://onsi.github.io/ginkgo/#setup-around-ordered-containers-the-onceperordered-decorator
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
const OncePerOrdered = internal.OncePerOrdered
/*
Label decorates specs with Labels. Multiple labels can be passed to Label and these can be arbitrary strings but must not include the following characters: "&|!,()/".
Labels can be applied to container and subject nodes, but not setup nodes. You can provide multiple Labels to a given node and a spec's labels is the union of all labels in its node hierarchy.
You can learn more here: https://onsi.github.io/ginkgo/#spec-labels
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
func Label(labels ...string) Labels {
return Labels(labels)
}
/*
Labels are the type for spec Label decorators. Use Label(...) to construct Labels.
You can learn more here: https://onsi.github.io/ginkgo/#spec-labels
*/
type Labels = internal.Labels
/*
SemVerConstraint decorates specs with SemVerConstraints. Multiple semantic version constraints can be passed to SemVerConstraint and these strings must follow the semantic version constraint rules.
SemVerConstraints can be applied to container and subject nodes, but not setup nodes. You can provide multiple SemVerConstraints to a given node and a spec's semantic version constraints is the union of all semantic version constraints in its node hierarchy.
You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
func SemVerConstraint(semVerConstraints ...string) SemVerConstraints {
return SemVerConstraints(semVerConstraints)
}
/*
SemVerConstraints are the type for spec SemVerConstraint decorators. Use SemVerConstraint(...) to construct SemVerConstraints.
You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
*/
type SemVerConstraints = internal.SemVerConstraints
/*
ComponentSemVerConstraint decorates specs with ComponentSemVerConstraints. Multiple components semantic version constraints can be passed to ComponentSemVerConstraint and the component can't be empy, also the version strings must follow the semantic version constraint rules.
ComponentSemVerConstraints can be applied to container and subject nodes, but not setup nodes. You can provide multiple ComponentSemVerConstraints to a given node and a spec's component semantic version constraints is the union of all component semantic version constraints in its node hierarchy.
You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
You can learn more about decorators here: https://onsi.github.io/ginkgo/#decorator-reference
*/
func ComponentSemVerConstraint(component string, semVerConstraints ...string) ComponentSemVerConstraints {
componentSemVerConstraints := ComponentSemVerConstraints{
component: semVerConstraints,
}
return componentSemVerConstraints
}
/*
ComponentSemVerConstraints are the type for spec ComponentSemVerConstraint decorators. Use ComponentSemVerConstraint(...) to construct ComponentSemVerConstraints.
You can learn more here: https://onsi.github.io/ginkgo/#spec-semantic-version-filtering
*/
type ComponentSemVerConstraints = internal.ComponentSemVerConstraints
/*
PollProgressAfter allows you to override the configured value for --poll-progress-after for a particular node.
Ginkgo will start emitting node progress if the node is still running after a duration of PollProgressAfter. This allows you to get quicker feedback about the state of a long-running spec.
*/
type PollProgressAfter = internal.PollProgressAfter
/*
PollProgressInterval allows you to override the configured value for --poll-progress-interval for a particular node.
Once a node has been running for longer than PollProgressAfter Ginkgo will emit node progress periodically at an interval of PollProgresInterval.
*/
type PollProgressInterval = internal.PollProgressInterval
/*
NodeTimeout allows you to specify a timeout for an indivdiual node. The node cannot be a container and must be interruptible (i.e. it must be passed a function that accepts a SpecContext or context.Context).
If the node does not exit within the specified NodeTimeout its context will be cancelled. The node wil then have a period of time controlled by the GracePeriod decorator (or global --grace-period command-line argument) to exit. If the node does not exit within GracePeriod Ginkgo will leak the node and proceed to any clean-up nodes associated with the current spec.
*/
type NodeTimeout = internal.NodeTimeout
/*
SpecTimeout allows you to specify a timeout for an indivdiual spec. SpecTimeout can only decorate interruptible It nodes.
All nodes associated with the It node will need to complete before the SpecTimeout has elapsed. Individual nodes (e.g. BeforeEach) may be decorated with different NodeTimeouts - but these can only serve to provide a more stringent deadline for the node in question; they cannot extend the deadline past the SpecTimeout.
If the spec does not complete within the specified SpecTimeout the currently running node will have its context cancelled. The node wil then have a period of time controlled by that node's GracePeriod decorator (or global --grace-period command-line argument) to exit. If the node does not exit within GracePeriod Ginkgo will leak the node and proceed to any clean-up nodes associated with the current spec.
*/
type SpecTimeout = internal.SpecTimeout
/*
GracePeriod denotes the period of time Ginkgo will wait for an interruptible node to exit once an interruption (whether due to a timeout or a user-invoked signal) has occurred. If both the global --grace-period cli flag and a GracePeriod decorator are specified the value in the decorator will take precedence.
Nodes that do not finish within a GracePeriod will be leaked and Ginkgo will proceed to run subsequent nodes. In the event of a timeout, such leaks will be reported to the user.
*/
type GracePeriod = internal.GracePeriod
/*
SpecPriority allows you to assign a priority to a spec or container.
Specs with higher priority will be scheduled to run before specs with lower priority. The default priority is 0 and negative priorities are allowed.
*/
type SpecPriority = internal.SpecPriority
/*
SuppressProgressReporting is a decorator that allows you to disable progress reporting of a particular node. This is useful if `ginkgo -v -progress` is generating too much noise; particularly
if you have a `ReportAfterEach` node that is running for every skipped spec and is generating lots of progress reports.
*/
const SuppressProgressReporting = internal.SuppressProgressReporting
/*
AroundNode registers a function that runs before each individual node. This is considered a more advanced decorator.
Please read the [docs](https://onsi.github.io/ginkgo/#advanced-around-node) for more information.
Allowed signatures:
- AroundNode(func()) - func will be called before the node is run.
- AroundNode(func(ctx context.Context) context.Context) - func can wrap the passed in context and return a new one which will be passed on to the node.
- AroundNode(func(ctx context.Context, body func(ctx context.Context))) - ctx is the context for the node and body is a function that must be called to run the node. This gives you complete control over what runs before and after the node.
Multiple AroundNode decorators can be applied to a single node and they will run in the order they are applied.
Unlike setup nodes like BeforeEach and DeferCleanup, AroundNode is guaranteed to run in the same goroutine as the decorated node. This is necessary when working with lower-level libraries that must run on a single thread (you can call runtime.LockOSThread() in the AroundNode to ensure that the node runs on a single thread).
Since AroundNode allows you to modify the context you can also use AroundNode to implement shared setup that attaches values to the context. You must return a context that inherits from the passed in context.
If applied to a container, AroundNode will run before every node in the container. Including setup nodes like BeforeEach and DeferCleanup.
AroundNode can also be applied to RunSpecs to run before every node in the suite.
*/
func AroundNode[F types.AroundNodeAllowedFuncs](f F) types.AroundNodeDecorator {
return types.AroundNode(f, types.NewCodeLocation(1))
}
================================================
FILE: deprecated_dsl.go
================================================
package ginkgo
import (
"time"
"github.com/onsi/ginkgo/v2/internal"
"github.com/onsi/ginkgo/v2/internal/global"
"github.com/onsi/ginkgo/v2/reporters"
"github.com/onsi/ginkgo/v2/types"
)
/*
Deprecated: Done Channel for asynchronous testing
The Done channel pattern is no longer supported in Ginkgo 2.0.
See here for better patterns for asynchronous testing: https://onsi.github.io/ginkgo/#patterns-for-asynchronous-testing
For a migration guide see: https://onsi.github.io/ginkgo/MIGRATING_TO_V2#removed-async-testing
*/
type Done = internal.Done
/*
Deprecated: Custom Ginkgo test reporters are deprecated in Ginkgo 2.0.
Use Ginkgo's reporting nodes instead and 2.0 reporting infrastructure instead. You can learn more here: https://onsi.github.io/ginkgo/#reporting-infrastructure
For a migration guide see: https://onsi.github.io/ginkgo/MIGRATING_TO_V2#removed-custom-reporters
*/
type Reporter = reporters.DeprecatedReporter
/*
Deprecated: Custom Reporters have been removed in Ginkgo 2.0. RunSpecsWithDefaultAndCustomReporters will simply call RunSpecs()
Use Ginkgo's reporting nodes instead and 2.0 reporting infrastructure instead. You can learn more here: https://onsi.github.io/ginkgo/#reporting-infrastructure
For a migration guide see: https://onsi.github.io/ginkgo/MIGRATING_TO_V2#removed-custom-reporters
*/
func RunSpecsWithDefaultAndCustomReporters(t GinkgoTestingT, description string, _ []Reporter) bool {
deprecationTracker.TrackDeprecation(types.Deprecations.CustomReporter())
return RunSpecs(t, description)
}
/*
Deprecated: Custom Reporters have been removed in Ginkgo 2.0. RunSpecsWithCustomReporters will simply call RunSpecs()
Use Ginkgo's reporting nodes instead and 2.0 reporting infrastructure instead. You can learn more here: https://onsi.github.io/ginkgo/#reporting-infrastructure
For a migration guide see: https://onsi.github.io/ginkgo/MIGRATING_TO_V2#removed-custom-reporters
*/
func RunSpecsWithCustomReporters(t GinkgoTestingT, description string, _ []Reporter) bool {
deprecationTracker.TrackDeprecation(types.Deprecations.CustomReporter())
return RunSpecs(t, description)
}
/*
Deprecated: GinkgoTestDescription has been replaced with SpecReport.
Use CurrentSpecReport() instead.
You can learn more here: https://onsi.github.io/ginkgo/#getting-a-report-for-the-current-spec
The SpecReport type is documented here: https://pkg.go.dev/github.com/onsi/ginkgo/v2/types#SpecReport
*/
type DeprecatedGinkgoTestDescription struct {
FullTestText string
ComponentTexts []string
TestText string
FileName string
LineNumber int
Failed bool
Duration time.Duration
}
type GinkgoTestDescription = DeprecatedGinkgoTestDescription
/*
Deprecated: CurrentGinkgoTestDescription has been replaced with CurrentSpecReport.
Use CurrentSpecReport() instead.
You can learn more here: https://onsi.github.io/ginkgo/#getting-a-report-for-the-current-spec
The SpecReport type is documented here: https://pkg.go.dev/github.com/onsi/ginkgo/v2/types#SpecReport
*/
func CurrentGinkgoTestDescription() DeprecatedGinkgoTestDescription {
deprecationTracker.TrackDeprecation(
types.Deprecations.CurrentGinkgoTestDescription(),
types.NewCodeLocation(1),
)
report := global.Suite.CurrentSpecReport()
if report.State == types.SpecStateInvalid {
return GinkgoTestDescription{}
}
componentTexts := []string{}
componentTexts = append(componentTexts, report.ContainerHierarchyTexts...)
componentTexts = append(componentTexts, report.LeafNodeText)
return DeprecatedGinkgoTestDescription{
ComponentTexts: componentTexts,
FullTestText: report.FullText(),
TestText: report.LeafNodeText,
FileName: report.LeafNodeLocation.FileName,
LineNumber: report.LeafNodeLocation.LineNumber,
Failed: report.State.Is(types.SpecStateFailureStates),
Duration: report.RunTime,
}
}
/*
Deprecated: GinkgoParallelNode() has been renamed to GinkgoParallelProcess()
*/
func GinkgoParallelNode() int {
deprecationTracker.TrackDeprecation(
types.Deprecations.ParallelNode(),
types.NewCodeLocation(1),
)
return GinkgoParallelProcess()
}
/*
Deprecated: Benchmarker has been removed from Ginkgo 2.0
Use Gomega's gmeasure package instead.
You can learn more here: https://onsi.github.io/ginkgo/#benchmarking-code
*/
type Benchmarker interface {
Time(name string, body func(), info ...any) (elapsedTime time.Duration)
RecordValue(name string, value float64, info ...any)
RecordValueWithPrecision(name string, value float64, units string, precision int, info ...any)
}
/*
Deprecated: Measure() has been removed from Ginkgo 2.0
Use Gomega's gmeasure package instead.
You can learn more here: https://onsi.github.io/ginkgo/#benchmarking-code
*/
func Measure(_ ...any) bool {
deprecationTracker.TrackDeprecation(types.Deprecations.Measure(), types.NewCodeLocation(1))
return true
}
================================================
FILE: docs/.gitignore
================================================
_site
.sass-cache
.jekyll-cache
.jekyll-metadata
vendor
================================================
FILE: docs/Gemfile
================================================
source "https://rubygems.org"
# Hello! This is where you manage which Jekyll version is used to run.
# When you want to use a different version, change it below, save the
# file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
#
# bundle exec jekyll serve
#
# This will help ensure the proper Jekyll version is running.
# Happy Jekylling!
# gem "jekyll", "~> 4.2.1"
# This is the default theme for new Jekyll sites. You may change this to anything you like.
gem "minima", "~> 2.5"
# If you want to use GitHub Pages, remove the "gem "jekyll"" above and
# uncomment the line below. To upgrade, run `bundle update github-pages`.
gem "github-pages", "~> 232", group: :jekyll_plugins
# If you have any plugins, put them here!
group :jekyll_plugins do
gem "jekyll-feed", "~> 0.17"
end
gem "webrick"
# Windows and JRuby does not include zoneinfo files, so bundle the tzinfo-data gem
# and associated library.
platforms :mingw, :x64_mingw, :mswin, :jruby do
gem "tzinfo", "~> 1.2"
gem "tzinfo-data"
end
# Performance-booster for watching directories on Windows
gem "wdm", "~> 0.1.1", :platforms => [:mingw, :x64_mingw, :mswin]
================================================
FILE: docs/MIGRATING_TO_V2.md
================================================
---
layout: default
title: Migrating to Ginkgo V2
---
{% raw %}
# Ginkgo 2.0 Migration Guide
[Ginkgo 2.0](https://github.com/onsi/ginkgo/issues/711) is a major release that adds substantial new functionality and removes/moves existing functionality.
This document serves as a changelog and migration guide for users migrating from Ginkgo 1.x to 2.0. The intent is that the migration will take minimal user effort - please [open an issue](https://github.com/onsi/ginkgo/issues/new) if you run into any problems.
The 2.0 work was tracked on issue [#711](https://github.com/onsi/ginkgo/issues/711) - you can refer to that issue to find the original proposal and backlog.
## Upgrading to Ginkgo 2.0
To upgrade to Ginkgo 2.0, assuming you are using `go mod`, you'll need to do the following in an existing or new project:
1. Upgrade to the v2 module:
```bash
go get github.com/onsi/ginkgo/v2
```
2. Install the V2 CLI. Running this may require you to run a few additional `go get`s - just follow the go toolchain's instructions until you successfully get ginkgo v2 compiled:
```bash
go install -mod=mod github.com/onsi/ginkgo/v2/ginkgo@latest
ginkgo version //should print out "Ginkgo Version 2.0.0"
```
3. Update all your import statements from `import github.com/onsi/ginkgo` to `import github.com/onsi/ginkgo/v2`. You can use your text editor to replace all instances of `"github.com/onsi/ginkgo` with `"github.com/onsi/ginkgo/v2`
Updating to V2 will require you to make some changes to your test suites however the intent is that this work should be relatively minimal for most users. This migration guide should answer most questions - your first step is to simply run `ginkgo` and see what sorts of deprecation messages you get. Please don't hesitate to [open an issue](https://github.com/onsi/ginkgo/issues/new) if you run into any problems.
With the release of Ginkgo 2.0 the 1.x version is formally deprecated and no longer supported. All future development will occur on version 2.
The next sections describe the [new features in Ginkgo 2.0](#major-additions-and-improvements) and the [major changes](#major-changes) along with details on how to migrate your test code to adapt to the changes. At the end of this doc is an [FAQ](#faq) with common gotchas that will be tracked as they emerge.
## Major Additions and Improvements
### Interrupt Behavior
Interrupt behavior is substantially improved, sending an interrupt signal will now:
- immediately cause the current test to unwind. Ginkgo will run any `AfterEach` blocks, then immediately skip all remaining tests, then run the `AfterSuite` block.
- emit information about which node Ginkgo was running when the interrupt signal was received.
- emit as much information as possible about the interrupted test (e.g. `GinkgoWriter` contents, `stdout` and `stderr` context).
- emit a stack trace of every running goroutine at the moment of interruption.
Previously, sending a second interrupt signal would cause Ginkgo to exit immediately. With the improved interrupt behavior this is no longer necessary and Ginkgo will not exit until the test suite has unwound and completed.
### Timeout Behavior
In Ginkgo V1.x, Ginkgo's timeout was managed by `go test`. This meant that timeouts exited the test suite abruptly with no opportunity for custom reporters or clean up code (e.g. `AfterEach`, `AfterSuite`) to run. This is fixed in V2. Ginkgo now manages its own timeout and when a timeout triggers the test winds down gracefully. In fact, a timeout is now functionally equivalent to a user-initiated interrupt.
In addition, in V1.x when running multiple test suites Ginkgo would give each suite the full timeout allotment (so `ginkgo -r -timeout=1h` would give _each_ test suite one hour to complete). In V2 the timeout now applies to the entire test suite run so that `ginkgo -r -timeout=1h` is now guaranteed to exit after (about) one hour.
**Finally, the default timeout has been reduced from `24h` down to `1h`.** Users with long-running tests may need to adjust the timeout in their CI scripts.
### Spec Decorators
Specs can now be decorated with a series of new spec decorators. These decorators enable fine-grained control over certain aspects of the spec's creation and lifecycle.
To support decorators, the signature for Ginkgo's container, setup, and It nodes have been changed to:
```go
func Describe(text string, args ...any)
func It(text string, args ...any)
func BeforeEach(args ...any)
```
Note that this change is backwards compatible with v1.X.
Ginkgo supports passing in decorators _and_ arbitrarily nested slices of decorators. Ginkgo will unroll any slices and process the flattened list of decorators. This makes it easier to pass around and combine groups of decorators. In addition, decorators can be passed into the table-related DSL: `DescribeTable` and `Entry`.
Here's a list of new decorators. They are documented in more detail in the [Node Decorator Reference](https://onsi.github.io/ginkgo/#node-decorators-overview) section of the documentation.
#### Serial Decorator
Specs can now be decorated with the `Serial` decorator. Specs decorated as `Serial` will never run in parallel with other specs. Instead, Ginkgo will run them on a single test process _after_ all the parallel tests have finished running.
#### Ordered Decorator
Spec containers (i.e. `Describe` and `Context` blocks) can now be decorated with the `Ordered` decorator. Specs within `Ordered` containers will always run in the order they appear and will never be randomized. In addition, when running in parallel, specs in an `Ordered` containers will always run on the same process to ensure spec order is preserved. When a spec in an `Ordered` container fails, all subsequent specs in the container are skipped.
`Ordered` containers also support `BeforeAll` and `AfterAll` setup nodes. These nodes will run just once - the `BeforeAll` will run before any ordered tests in the container run; the `AfterAll` will run after all the ordered tests in the container are finished.
Ordered containers are documented in more details in the [Ordered Container](https://onsi.github.io/ginkgo/#ordered-containers) section of the documentation.
#### OncePerOrdered Decorator
The `OncePerOrdered` decorator can be applied to setup nodes and causes them to run just once around ordered containers. More details in the [Setup around Ordered Containers: the OncePerOrdered Decorator](https://onsi.github.io/ginkgo/#setup-around-ordered-containers-the-onceperordered-decorator) section of the documentation.
#### Label Decorator
Specs can now be decorated with the `Label` decorator (see [Spec Labels](#spec-labels) below for details):
```go
Describe("a labelled container", Label("red", "white"), Label("blue"), func() {
It("a labelled test", Label("yellow"), func() {
})
})
```
the labels associated with a given spec is the union of the labels attached to that spec's `It` and any of the `It`'s containers. So `"a labelled test"` will have the labels `red`, `white`, `blue`, and `yellow`.
Labels can be arbitrary strings however they cannot include any of the following characters: `"&|!,()/"`.
#### Focus Decorator
In addition to `FDescribe` and `FIt`, specs can now be focused using the new `Focus` decorator:
```go
Describe("a focused container", Focus, func() {
....
})
```
#### Pending Decorator
In addition to `PDescribe` and `PIt`, specs can now be focused using the new `Pending` decorator:
```go
Describe("a focused container", Pending, func() {
....
})
```
#### Offset Decorator
The `Offset(uint)` decorator allows the user to change the stack-frame offset used to compute the location of the test node. This is useful when building shared test behaviors. For example:
```go
SharedBehaviorIt := func() {
It("does something common and complicated", Offset(1), func() {
...
})
}
Describe("thing A", func() {
SharedBehaviorIt()
})
Describe("thing B", func() {
SharedBehaviorIt()
})
```
now, if the `It` defined in `SharedBehaviorIt` the location reported by Ginkgo will point to the line where `SharedBehaviorIt` is *invoked*.
#### FlakeAttempts Decorator
The `FlakeAttempts(uint)` decorator allows the user to flag specific tests or groups of tests as potentially flaky. Ginkgo will run tests up to the number of times specified in `FlakeAttempts` until they pass. For example:
```go
Describe("flaky tests", FlakeAttempts(3), func() {
It("is flaky", func() {
...
})
It("is also flaky", func() {
...
})
It("is _really_ flaky", FlakeAttempts(5) func() {
...
})
It("is _not_ flaky", FlakeAttempts(1), func() {
...
})
})
```
With this setup, `"is flaky"` and `"is also flaky"` will run up to 3 times. `"is _really_ flaky"` will run up to 5 times. `"is _not_ flaky"` will run only once.
Note that if `ginkgo --flake-attempts=N` is set the value passed in by the CLI will override all the decorated values. Every test will now run up to `N` times.
### Spec Labels
Users can now label specs using the [`Label` decorator](#label-decorator). Labels provide more fine-grained control for organizing specs and running specific subsets of labelled specs. Labels are arbitrary strings however they cannot contain the characters `"&|!,()/"`. A given spec inherits the labels of all its containers and any labels attached to the spec's `It`, for example:
```go
Describe("Extracting widgets", Label("integration", "extracting widgets"), func() {
It("can extract widgets from the external database", Label("network", "slow"), func() {
//has labels [integration, extracting widgets, network, slow]
})
It("can delete extracted widgets", Label("network"), func() {
//has labels [integration, extracting widgets, network]
})
It("can create new widgets locally", Label("local"), func() {
//has labels [integration, extracting widgets, local]
})
})
Describe("Editing widgets", Label("integration", "editing widgets"), func() {
It("can edit widgets in the external database", Label("network", "slow"), func() {
//has labels [integration, editing widgets, network, slow]
})
It("errors if the widget does not exist", Label("network"), func() {
//has labels [integration, editing widgets, network]
})
})
```
In addition an entire suite can be decorated by passing a `Label` decorator to `RunSpecs`:
```go
RunSpecs(t, "My Suite", Label("top-level-label", "labels-all-specs"))
```
You can filter by label using the new `ginkgo --label-filter` flag. Label filter accepts a simple filter language that supports the following:
- The `&&` and `||` logical binary operators representing AND and OR operations.
- The `!` unary operator representing the NOT operation.
- The `,` binary operator equivalent to `||`.
- The `()` for grouping expressions.
- All other characters will match as label literals. Label matches are case intensive and trailing and leading whitespace is trimmed.
- Regular expressions can be provided using `/REGEXP/` notation.
For example:
- `ginkgo --label-filter=integration` will match any specs with the `integration` label.
- `ginkgo --label-filter=!slow` will avoid any tests labelled `slow`.
- `ginkgo --label-filter=(local || network) && !slow` will run any specs labelled `local` and `network` but without the `slow` label.
- `ginkgo --label-filter=/widgets/ && !slow` will run any specs with a label that matches the regular expression `widgets` but does not include the `slow` label. This would match both the `extracting widgets` and `editing widgets` labels in our example above.
### DeferCleanup
`DeferCleanup` allows users to move cleanup code out of `AfterEach/AfterAll/AfterSuite` and closer to the setup code that needs to be cleaned up. Based on the context in which it is called, `DeferCleanup` will effectively register a dynamic `AfterEach/AfterAll/AfterSuite` node to clean up after the test/test group/suite. The [docs](https://onsi.github.io/ginkgo/#spec-cleanup-aftereach-and-defercleanup) have more detailed examples.
`DeferCleanup` allows `GinkgoT()` to more fully implement the `testing.T` interface. `Cleanup`, `TempDir`, and `Setenv` are now all supported.
### Aborting the Test Suite
Users can now signal that the entire test suite should abort via `AbortSuite(message string, skip int)`. This will fail the current test and skip all subsequent tests.
### Improved: --fail-fast
`ginkgo --fail-fast` now interrupts all test processes when a failure occurs and the tests are running in parallel.
### CLI Flags
Ginkgo's CLI flags have been rewritten to provide clearer, better-organized documentation. In addition, Ginkgo v1 was mishandling several go cli flags. This is now resolved with clear distinctions between flags intended for compilation time and run-time. As a result, users can now generate `memprofile`s and `cpuprofile`s using the Ginkgo CLI. Ginkgo 2.0 will automatically merge profiles generated by running tests in parallel (i.e. across multiple processes) and will allow you to choose between having profiles stored in individual package directories, or collected in one place using the `-output-dir` flag. See [Changed: Profiling Support](#improved-profiling-support) for more details.
### Expanded GinkgoWriter Functionality
The `GinkgoWriter` is used to write output that is only made visible if a test fails, or if the user runs in verbose mode with `ginkgo -v`.
In Ginkgo 2.0 `GinkgoWriter` now has:
- Three new convenience methods `GinkgoWriter.Print(a ...any)`, `GinkgoWriter.Println(a ...any)`, `GinkgoWriter.Printf(format string, a ...any)` These are equivalent to calling the associated `fmt.Fprint*` functions and passing in `GinkgoWriter`.
- The ability to tee to additional writers. `GinkgoWriter.TeeTo(writer)` will send any future data written to `GinkgoWriter` to the passed in `writer`. You can attach multiple `io.Writer`s for `GinkgoWriter` to tee to. You can remove all attached writers with `GinkgoWriter.ClearTeeWriters()`.
Note that _all_ data written to `GinkgoWriter` is immediately forwarded to attached tee writers regardless of where a test passes or fails.
### Improved: Reporting Infrastructure
Ginkgo V2 provides an improved reporting infrastructure that [replaces and improves upon Ginkgo V1's support for custom reporters](#removed-custom-reporters). Here are a few distinct use-cases that the new reporting infrastructure supports:
#### Generating machine-readable reports
Ginkgo now natively supports generating and aggregating reports in a number of machine-readable formats - and these reports can be generated and managed by simply passing `ginkgo` command line flags.
Ginkgo V2 introduces a new JSON format that faithfully captures all available information about a Ginkgo test suite. JSON reports can be generated via `ginkgo --json-report=out.json`. The resulting JSON file encodes an array of `types.Report`. Each entry in that array lists detailed information about the test suite and includes a list of `types.SpecReport` that captures detailed information about each spec. These types are documented [here](https://github.com/onsi/ginkgo/blob/ver2/types/types.go).
Ginkgo also supports generating JUnit reports with `ginkgo --junit-report=out.xml` and Teamcity reports with `ginkgo --teamcity-report=out.teamcity`. In addition, Ginkgo V2's JUnit reporter has been improved and is now more conformant with the JUnit specification.
Ginkgo follows the following rules when generating reports using these new `--FORMAT-report` flags:
- By default, a single report file per format is generated at the passed-in file name. This single report merges all the reports generated by each individual suite.
- If `-output-dir` is set: the report files are placed in the specified `-output-dir` directory.
- If `-keep-separate-reports` is set, the individual reports generated by each test suite are not merged. Instead, individual report files will appear in each package directory. If `-output-dir` is _also_ set these individual files are copied into the `-output-dir` directory and namespaced with `PACKAGE_NAME_{REPORT}`.
#### Generating Custom Reports when a test suite completes
Ginkgo now provides a new node, `ReportAfterSuite`, with the following properties and constraints:
- `ReportAfterSuite` nodes are passed a function that takes a `types.Report`:
```go
var _ = ReportAfterSuite("custom reporter", func(report types.Report) {
// do stuff with report
})
```
- These functions are called exactly once at the end of the test suite after any `AfterSuite` nodes have run. When running in parallel the functions are called on the primary Ginkgo process after all other processes have finished and is guaranteed to have an aggregated copy of `types.Report` that includes all `SpecReport`s from all the Ginkgo parallel processes.
- If a failure occurs in `ReportAfterSuite` it is reported in reports sent to subsequent `ReportAfterSuite`s. In particular, it is reported as part of Ginkgo's default output and is in included in any reports generated by the `--FORMAT-report` flags described above.
- `ReportAfterSuite` nodes **cannot** be interrupted by the user. This is to ensure the integrity of generated reports... so be careful what kind of code you put in there!
- Multiple `ReportAfterSuite` nodes can be registered per test suite, but all must be defined at the top-level of the suite.
`ReportAfterSuite` is useful for users who want to emit a custom-formatted report or register the results of the test run with an external service.
#### Capturing report information about each spec as the test suite runs
Ginkgo also provides a new node, `ReportAfterEach`, with the following properties and constraints:
- `ReportAfterEach` nodes are passed a function that takes a `types.SpecReport`:
```go
var _ = ReportAfterEach(func(specReport types.SpecReport) {
// do stuff with specReport
})
```
- `ReportAfterEach` nodes are called after a spec completes (i.e. after any `AfterEach` nodes have run). `ReportAfterEach` nodes are **always** called - even if the test has failed, is marked pending, or is skipped. In this way, the user is guaranteed to have access to a report about every spec defined in a suite.
- If a failure occurs in `ReportAfterEach`, the spec in question is marked as failed. Any subsequently defined `ReportAfterEach` block will receive an updated report that includes the failure. In general, though, assertions about your code should go in `AfterEach` nodes.
- `ReportAfterEach` nodes **cannot** be interrupted by the user. This is to ensure the integrity of generated reports... so be careful what kind of code you put in there!
- `ReportAfterEach` nodes can be placed in any container node in the suite's hierarchy - in this way the follow the same semantics as `AfterEach` blocks.
- When running in parallel, `ReportAfterEach` nodes will run on the Ginkgo process that is running the spec being reported on. This means that multiple `ReportAfterEach` blocks can be running concurrently on independent processes.
`ReportAfterEach` is useful if you need to stream or emit up-to-date information about the test suite as it runs.
Ginkgo also provides `ReportBeforeEach` which is called before the test runs and receives a preliminary `types.SpecReport` - the state of this report will indicate whether the test will be skipped or is marked pending.
### New: Report Entries
Ginkgo V2 supports attaching arbitrary data to individual spec reports. These are called `ReportEntries` and appear in the various report-related data structures (e.g. `Report` in `ReportAfterSuite` and `SpecReport` in `ReportAfterEach`) as well as the machine-readable reports generated by `--json-report`, `--junit-report`, etc. `ReportEntries` are also emitted to the console by Ginkgo's reporter and you can specify a visibility policy to control when this output is displayed.
You attach data to a spec report via
```go
AddReportEntry(name string, args ...any)
```
`AddReportEntry` can be called from any runnable node (e.g. `It`, `BeforeEach`, `BeforeSuite`) - but not from the body of a container node (e.g. `Describe`, `Context`).
`AddReportEntry` generates `ReportEntry` and attaches it to the current running spec. `ReportEntry` includes the passed in `name` as well as the time and source location at which `AddReportEntry` was called. Users can also attach a single object of arbitrary type to the `ReportEntry` by passing it into `AddReportEntry` - this object is wrapped and stored under `ReportEntry.Value` and is always included in the suite's JSON report.
You can access the report entries attached to a spec by getting the `CurrentSpecReport()` or registering a `ReportAfterEach()` - the returned report will include the attached `ReportEntries`. You can fetch the value associated with the `ReportEntry` by calling `entry.GetRawValue()`. When called in-process this returns the object that was passed to `AddReportEntry`. When called after hydrating a report from JSON `entry.GetRawValue()` will include a parsed JSON `any` - if you want to hydrate the JSON yourself into an object of known type you can `json.Unmarshal([]byte(entry.Value.AsJSON), &object)`.
#### Supported Args
`AddReportEntry` supports the `Offset` and `CodeLocation` decorators. These will control the source code location associated with the generated `ReportEntry`. You can also pass in a `time.Time` to override the `ReportEntry`'s timestamp. It also supports passing in a `ReportEntryVisibility` enum to control the report's visibility (see below).
#### Controlling Output
By default, Ginkgo's console reporter will emit any `ReportEntry` attached to a spec. It will emit the `ReportEntry` name, location, and time. If the `ReportEntry` value is non-nil it will also emit a representation of the value. If the value implements `fmt.Stringer` or `types.ColorableStringer` then `value.String()` or `value.ColorableString()` (which takes precedence) is used to generate the representation, otherwise Ginkgo uses `fmt.Sprintf("%#v", value)`.
You can modify this default behavior by passing in one of the `ReportEntryVisibility` enum to `AddReportEntry`:
- `ReportEntryVisibilityAlways`: the default behavior - the `ReportEntry` is always emitted.
- `ReportEntryVisibilityFailureOrVerbose`: the `ReportEntry` is only emitted if the spec fails or is run with `-v` (similar to `GinkgoWriter`s behavior).
- `ReportEntryVisibilityNever`: the `ReportEntry` is never emitted though it appears in any generated machine-readable reports (e.g. by setting `--json-report`).
The console reporter passes the string representation of the `ReportEntry.Value` through Ginkgo's `formatter`. This allows you to generate colorful console output using the color codes documented in `github.com/onsi/ginkgo/formatter/formatter.go`. For example:
```go
type StringerStruct struct {
Label string
Count int
}
// ColorableString for ReportEntry to use
func (s StringerStruct) ColorableString() string {
return fmt.Sprintf("{{red}}%s {{yellow}}{{bold}}%d{{/}}", s.Label, s.Count)
}
// non-colorable String() is used by go's string formatting support but ignored by ReportEntry
func (s StringerStruct) String() string {
return fmt.Sprintf("%s %d", s.Label, s.Count)
}
It("is reported", func() {
AddReportEntry("Report", StringerStruct{Label: "Mahomes", Count: 15})
})
```
Will emit a report that has the word "Mahomes" in red and the number 15 in bold and yellow.
Lastly, it is possible to pass a pointer into `AddReportEntry`. Ginkgo will compute the string representation of the passed in pointer at the last possible moment - so any changes to the object _after_ it is reported will be captured in the final report. This is useful for building libraries on top of `AddReportEntry` - users can simply register objects when they're created and any subsequent mutations will appear in the generated report.
### New: Table-level Entry Descriptions
Table `Entry`s can now opt-into table-level descriptions. Simply pass `nil` as the first argument into `Entry`. By default, Ginkgo will generate an `Entry` description from the `Entry`s parameters. You can also provide a string-returning function to `DescribeTable` which will be used to generate the description for these entries. There's also a new `EntryDescription` decorator that can be passed in to `DescribeTable` - `EntryDescription` wraps a format string that can be used to format the parameters associated with each `Entry` to generate it's description.
For example:
```go
var _ = Describe("Math", func() {
DescribeTable("addition",
func(a, b, c int) {
Expect(a+b).To(Equal(c))
},
EntryDescription("%d + %d = %d")
Entry(nil, 1, 2, 3),
Entry(nil, -1, 2, 1),
Entry("zeros", 0, 0, 0),
Entry(EntryDescription("%[3]d = %[1]d + %[2]d"), 2, 3, 5)
Entry(func(a, b, c int) string {fmt.Sprintf("%d = %d", a + b, c)}, 4, 3, 7)
)
})
```
Will generate entries named: `1 + 2 = 3`, `-1 + 2 = 1`, `zeros`, `5 = 2 + 3`, and `7 = 7`.
### Improved: Profiling Support
Ginkgo V1 was incorrectly handling Go test's various profiling flags (e.g. -cpuprofile, -memprofile). This has been fixed in V2. In fact, V2 can capture profiles for multiple packages (e.g. ginkgo -r -cpuprofile=profile.out will work).
When generating profiles for `-cpuprofile=FILE`, `-blockprofile=FILE`, `-memprofile=FILE`, `-mutexprofile=FILE`, and `-execution-trace=FILE` (Ginkgo's alias for `go test -test.trace`) the following rules apply:
- If `-output-dir` is not set: each profile generates a file named `$FILE` in the directory of each package under test.
- If `-output-dir` is set: each profile generates a file in the specified `-output-dir` directory. named `PACKAGE_NAME_$FILE`
### Improved: Cover Support
Coverage reporting is much improved in 2.0:
- `ginkgo -cover -p` now emits code coverage after the test completes, just like `ginkgo -cover` does in series.
- When running across multiple packages (e.g. `ginkgo -r -cover`) ginkgo will now emit a composite coverage statistic that represents the total coverage across all test suites run. (Note that this is disabled if you set `-keep-separate-coverprofiles`).
In addition, Ginkgo now follows the following rules when generating cover profiles using `-cover` and/or `-coverprofile=FILE`:
- By default, a single cover profile is generated at `FILE` (or `coverprofile.out` if `-cover-profile` is not set but `-cover` is set). This includes the merged results of all the cover profiles reported by each suite.
- If `-output-dir` is set: the `FILE` is placed in the specified `-output-dir` directory.
- If `-keep-separate-coverprofiles` is set, the individual coverprofiles generated by each package are not merged and, instead, a file named `FILE` will appear in each package directory. If `-output-dir` is _also_ set these files are copied into the `-output-dir` directory and namespaced with `PACKAGE_NAME_{FILE}`.
### New: --repeat
Ginkgo can now repeat a test suite N additional times by running `ginkgo --repeat=N`. This is similar to `go test -count=N+1` and is a variant of `ginkgo --until-it-fails` that can be run in CI environments to repeat test runs to suss out flakey tests.
Ginkgo requires the tests to succeed during each repetition in order to consider the test run a success.
### New: --focus-file and --skip-file
You can now tell Ginkgo to only run specs that match (or don't match) a given file filter. You can filter by filename as well as file:line. See the [Filtering Specs](https://onsi.github.io/ginkgo/#filtering-specs) documentation for more details.
### Improved: windows support for capturing stdout and stderr
In V1 Ginkgo would run windows tests in parallel with the `--stream` option. This would result in hard-to-understand interleaved output. The reason behind this design choice was that it proved challenging to intercept all stdout and stderr output on Windows. V2 implements a best-effort output interception scheme for windows that entails reassigning the global `os.Stdout` and `os.Stderr` variables. While not as bullet-proof as the Unix `syscall.Dup2` based implementation, this is likely good enough for most usecases and allows Ginkgo support on Windows to come into parity with unix.
## Minor Additions and Improvements
- `BeforeSuite` and `AfterSuite` no longer run if all tests in a suite are skipped.
- The entire suite is skipped if `Skip()` is called in `BeforeSuite`.
- Any output generated by `SynchronizedBeforeSuite`'s proc-1 function will now be immediately streamed to stdout, even when running in parallel. This is useful to debug complex long-running `SynchronizedBeforeSuite` setups.
- Ginkgo's performance should be improved now when running multiple suites in a context where the go mod dependencies have not been fetched yet (e.g. on CI). Previously, Ginkgo would compile suites in parallel resulting in substantial slowdown when fetching the dependencies in parallel. In V2, Ginkgo compiles the first suite in series before compiling the remaining suites in parallel.
- Ginkgo can now catch several common user gotchas and emit a helpful error.
- Tables can now accept slices of []TableEntry in addition to individual entries. This allows for entries to be reused across different tables.
- Error output is clearer and consistently links to relevant sections in the documentation.
- `By` now emits a timestamp. It also registers a `ReportEntry` that appears in the suite report as structured data. If passed a callback, `By` will now time the callback and include the duration in the suite report.
- Test randomization is now more stable as tests are now sorted deterministically on file_name:line_number first (previously they were sorted on test text which could not guarantee a stable sort).
- A new "very verbose" setting is now available. Setting `-vv` implies `-v` but also causes skipped tests to be emitted.
- Ginkgo's OutputInterceptor (the component that intercepts stdout/stderr when running in parallel) should now be more performant and better handle edge cases. It can be paused and resumed with PauseOutputInterception() and ResumeOutputInterception() and disabled entirely with --output-interceptor-mode=none.
## Major Changes
These are major changes that will need user intervention to migrate successfully.
### Removed: Async Testing
As described in the [Ginkgo 2.0 Proposal](https://docs.google.com/document/d/1h28ZknXRsTLPNNiOjdHIO-F2toCzq4xoZDXbfYaBdoQ/edit#heading=h.mzgqmkg24xoo) the Ginkgo 1.x implementation of asynchronous testing using a `Done` channel was a confusing source of test-pollution. It is removed in Ginkgo 2.0.
In Ginkgo 2.0 tests of the form:
```go
It("...", func(done Done) {
// user test code to run asynchronously
close(done) //signifies the test is done
}, timeout)
```
will emit a deprecation warning and will run **synchronously**. This means the `timeout` will not be enforced and the status of the `Done` channel will be ignored - a test that hangs will hang indefinitely.
#### Migration Strategy:
We recommend users make targeted use of Gomega's [Asynchronous Assertions](https://onsi.github.io/gomega/#making-asynchronous-assertions) to better test asynchronous behavior. In addition, as of Ginkgo 2.3.0, users can [make individual nodes interruptible and reintroduce the notion of spec timeouts](https://onsi.github.io/ginkgo/#spec-timeouts-and-interruptible-nodes).
As a first migration pass that produces **equivalent behavior** users can replace asynchronous tests with:
```go
It("...", func(ctx SpecContext) {
// user test code to run asynchronously
}, NodeTimeout(timeout))
```
if your code supports it, you can use the `ctx` passed in to the `It` to signal that the spec deadline has elapsed and cause the spec to exit.
### Removed: Measure
As described in the [Ginkgo 2.0 Proposal](https://docs.google.com/document/d/1h28ZknXRsTLPNNiOjdHIO-F2toCzq4xoZDXbfYaBdoQ/edit#heading=h.2ezhpn4gmcgs) the Ginkgo 1.x implementation of benchmarking using `Measure` nodes was a source of tightly-coupled complexity. It is removed in Ginkgo 2.0.
In Ginkgo 2.0 tests of the form:
```go
Measure(..., func(b Benchmarker) {
// user benchmark code
})
```
will emit a deprecation warning and **will no longer run**.
#### Migration Strategy:
Gomega now provides a benchmarking subpackage called `gmeasure`. Users should migrate to `gmeasure` by replacing `Measure` nodes with `It` nodes that create `gmeasure.Experiment`s and record values/durations. To generate output in Ginkgo reports add the `experiment` as a `ReportEntry` via `AddReportEntry(experiment.Name, experiment)`.
### Removed: Custom Reporters
Ginkgo 2.0 removes support for Ginkgo 1.X's custom reporters - they behaved poorly when running in parallel and represented unnecessary and error-prone boiler plate for users who simply wanted to produce machine-readable reports. Instead, the reporting infrastructure has been significantly improved to enable simpler support for the most common use-cases and custom reporting needs.
Please read through the [Improved: Reporting Infrastructure](#improved-reporting-infrastructure) section to learn more. For users with custom reporters, follow the migration guide below.
#### Migration Strategy:
In Ginkgo 2.0 both `RunSpecsWithDefaultAndCustomReporters` and `RunSpecsWithCustomReporters` have been deprecated. Users must call `RunSpecs` instead.
If you were using custom reporters to generate JUnit or Teamcity reports, simply call `RunSpecs` and [invoke your tests with the new `--junit-report` and/or `--teamcity-report` flags](#generating-machine-readable-reports). Note that unlike the 1.X JUnit and Teamcity reporters, these flags generate unified reports for all test suites run (though you can adjust this with the `--keep-separate-reports` flag) and take care of aggregating reports from parallel processes for you.
If you've written your own custom reporter, [add a `ReportAfterSuite` node](#generating-custom-reports-when-a-test-suite-completes) and process the `types.Report` that it provides you. If you'd like to continue using your custom reporter you can simply call `reporters.ReportViaDeprecatedReporter(reporter, report)` in `ReportAfterSuite` - though we recommend actually changing your code's logic to use the `types.Report` object directly as `reporters.ReportViaDeprecatedReporter` will be removed in a future release of Ginkgo 2.X. Unlike 1.X custom reporters which are called concurrently by independent parallel processes when running in parallel, `ReportAFterSuite` is called exactly once per suite and is guaranteed to have aggregated information from all parallel processes.
Alternatively, you can use the new `--json-report` flag to produce a machine readable JSON-format report that you can post-process after the test completes.
Finally, if you still need the real-time reporting capabilities that 1.X's custom reporters provided you can use [`ReportBeforeEach` and `ReportAfterEach`](#capturing-report-information-about-each-spec-as-the-test-suite-runs) to get information about each spec as it completes.
### Changed: First-class Support for Table Testing
The table extension has been moved into the core Ginkgo DSL and the table functionality has been improved while maintaining backward compatibility. Users no longer need to `import "github.com/onsi/ginkgo/v2/extensions/table"`. Instead the table DSL is automatically pulled in by importing `"github.com/onsi/ginkgo/v2"`.
#### Migration Strategy:
Remove `"github.com/onsi/ginkgo/v2/extensions/table` imports. Code that was dot-importing both Ginkgo and the table extension should automatically work. If you were not dot-importing you will need to replace references to `table.DescribeTable` and `table.Entry` with `ginkgo.DescribeTable` and `ginkgo.Entry`.
### Changed: CurrentGinkgoTestDescription()
`CurrentGinkgoTestDescription()` has been deprecated and will be removed in a future release. The method was returning a processed object that included a subset of information available about the running test.
It has been replaced with `CurrentSpecReport()` which returns the full-fledge `types.SpecReport` used by Ginkgo's reporting infrastructure. To help users migrate, `types.SpecReport` now includes a number of helper methods to make it easier to extract information about the running test.
#### Migration Strategy:
Replace any calls to `CurrentGinkgoTestDescription()` with `CurrentSpecReport()` and use the struct fields or helper methods on the returned `types.SpecReport` to get the information you need about the current test.
### Changed: availability of Ginkgo's configuration
In v1 Ginkgo's configuration could be accessed by importing the `config` package and accessing the globally available `GinkgoConfig` and `DefaultReporterConfig` objects. This is no longer supported in V2.
V1 also allowed mutating the global config objects which could lead to strange behavior if done within a test. This too is no longer supported in V2.
#### Migration Strategy:
Instead, configuration can be accessed using the DSL's `GinkgoConfiguration()` function. This will return a `types.SuiteConfig` and `types.ReporterConfig`. Users generally don't need to access this configuration - the most commonly used fields by end users are already made available via `GinkgoRandomSeed()` and `GinkgoParallelProcess()`.
It is generally recommended that users use the CLI to configure Ginkgo as some aspects of configuration must apply to the CLI as well as the suite under tests - nonetheless there are contexts where it is necessary to change Ginkgo's configuration programmatically. V2 supports this by allowing users to pass updated configuration into `RunSpecs`:
```go
func TestMySuite(t *testing.T) {
RegisterFailHandler(gomega.Fail)
// fetch the current config
suiteConfig, reporterConfig := GinkgoConfiguration()
// adjust it
suiteConfig.SkipStrings = []string{"NEVER-RUN"}
reporterConfig.FullTrace = true
// pass it in to RunSpecs
RunSpecs(t, "My Suite", suiteConfig, reporterConfig)
}
```
### Renamed: GinkgoParallelNode
`GinkgoParallelNode` has been renamed to `GinkgoParallelProcess` to reduce confusion around the word `node` and better capture Ginkgo's parallelization mechanism.
#### Migration strategy:
Change all instance of `GinkgoParallelNode()` to `GinkgoParallelProcess()`
### Changed: Command Line Flags
All camel case flags (e.g. `-randomizeAllSpecs`) are replaced with kebab case flags (e.g. `-randomize-all-specs`) in Ginkgo 2.0. The camel case versions continue to work but emit a deprecation warning.
#### Migration Strategy:
Users should update any scripts they have that invoke the `ginkgo` cli from camel case to kebab case (:camel: :arrow_right: :oden:).
### Removed: -stream
`-stream` was originally introduce in Ginkgo 1.x to force parallel test processes to emit output simultaneously in order to help debug hanging test issues. With improvements to Ginkgo's interrupt handling and parallel test reporting this behavior is no longer necessary and has been removed.
### Removed: -notify
`-notify` instructed Ginkgo to emit desktop notifications on linux and MacOS. This feature was rarely used and has been removed.
### Removed: -noisyPendings and -noisySkippings
Both these flags tweaked the reporter's behavior for pending and skipped tests but never worked quite right. Now the user can specify between four verbosity levels. `--succinct`, no verbosity setting, `-v`, and `-vv`. Specifically, when run with `-vv` skipped tests will emit their titles and code locations - otherwise skipped tests are silent.
### Changed: -slowSpecThreshold
`-slowSpecThreshold` is now `-slow-spec-threshold` and takes a `time.Duration` (e.g. `5s` or `3m`) instead of a `float64` number of seconds.
### Renamed: -reportPassed
`-reportPassed` is now `--always-emit-ginkgo-writer` which better captures the intent of the flag; namely to always emit any GinkgoWriter content, even if the spec has passed.
### Removed: -debug
The `-debug` flag has been removed. It functioned primarily as a band-aid to Ginkgo V1's poor handling of stuck parallel tests. The new [interrupt behavior](#interrupt-behavior) in V2 resolves the root issues behind the `-debug` flag.
### Removed: -regexScansFilePath
`-regexScansFilePath` allowed users to have the `-focus` and `-skip` regular expressions apply to filenames. It is now removed in favor of `-focus-file` and `-skip-file` which provide more granular and explicit control over focusing/skipping files and line numbers.
#### Migration Strategy:
Users should remove -stream from any scripts they have that invoke the `ginkgo` cli.
### Removed: ginkgo nodot
The `ginkgo nodot` subcommand in V1, along with the `--nodot` flags for `ginkgo bootstrap` and `ginkgo generate` were provided to allow users to avoid a `.` import of Ginkgo and Gomega but still have access to the exported variables and types at the top-level. This was implemented by defining top-level aliases that pointed to the objects and types in the imported Ginkgo and Gomega libraries in the user's bootstrap file. In practice most users either dot-import Ginkgo and Gomega, or they don't and use the imported package name to refer to objects and types instead. V2 removes the support generating and maintaining these alias lists. `--nodot` remains for `ginkgo bootstrap` and `ginkgo generate` and it simply avoids dot-importing Ginkgo and Gomega.
As a result of this change custom bootstrap and generate templates may need to be updated:
1. `ginkgo generate` templates should no longer reference `{{.IncludeImports}}`. Instead they should `import {{.GinkgoImport}}` and `import {{.GomegaImport}}`.
2. Both `ginkgo generate` and `ginkgo boostrap` templates can use `{{.GinkgoPackage}}` and `{{.GomegaPackage}}` to correctly reference any names exported by Ginkgo or Gomega. For example:
```go
import (
{{.GinkgoImport}}
{{.GomegaImport}}
}
var _ = {{.GinkgoPackage}}It("is templated", func() {
{{.GomegaPackage}}Expect(foo).To({{.GomegaPackage}}Equal(bar))
})
```
will generate the correct output if `--nodot` is specified by the user.
### Removed: ginkgo convert
The `ginkgo convert` subcommand in V1 could convert an existing set of Go tests into a Ginkgo test suite, wrapping each `TestX` function in an `It`. This subcommand added complexity to the codebase and was infrequently used. It has been removed. Users who want to convert tests suites over to Ginkgo will need to do so by hand.
## Minor Changes
These are minor changes that will be transparent for most users.
- `"top level"` is no longer the first element in `types.SpecReport.NodeTexts`. This will only affect users who write custom reporters.
- The output format of Ginkgo's Default Reporter has changed in numerous subtle ways to improve readability and the user experience. Users who were scraping Ginkgo output programmatically may need to change their scripts or use the new JSON formatted report option.
- When running in series and verbose mode (i.e. `ginkgo -v`) GinkgoWriter output is emitted in real-time (existing behavior) but also emitted in the failure message for failed tests. This allows for consistent failure messages regardless of verbosity settings and also makes it possible for the resulting JSON report to include captured GinkgoWriter information.
- Removed `ginkgo blur` alias. Use `ginkgo unfocus` instead.
## FAQ
As users have started adopting Ginkgo v2 they've bumped into a few specific issues. This FAQ will grow as these issues are identified to help address them.
### Can I mix Ginkgo V1 and Ginkgo V2?
..._ish_.
**What you _can't_ do**
Under the hood Ginkgo V2 is effectively a rewrite of Ginkgo V1. While the external interfaces are largely compatible (modulo the differences pointed out in this doc) the internals are very different. Because of this **it is not possible** to import and use V1 _and_ V2 **in the same _package_**.
In fact, trying to do so will result in a crash as Ginkgo V1's `init` function and Ginkgo V2's `init` function will register conflicting command line flags.
That means you can't do something like:
```go
/* sprockets/widget_test.go */
import (
. "github.com/onsi/ginkgo" //v1
)
var _ = It("uses V1", func() {...})
/* sprockets/doodad_test.go */
import (
. "github.com/onsi/ginkgo/v2" //v2
)
var _ = It("uses V2", func() {...})
```
It _also_ means you can't use a _dependency_ in your test that, in turn, imports a mismatched version of Ginkgo. For example, let's say we have a test helper package:
```go
/* helpers/test_helper.go */
import (
"github.com/onsi/ginkgo" //imports v1
)
func EnsureNoSprocketRust(sprocket *Sprocket) {
if sprocket.IsRusty() {
Fail("Sprocket rust detected")
}
}
```
this test helper package imports Ginkgo V1. If we try to use it in a test package that uses Ginkgo V2:
```go
/* sprockets/widget_test.go */
import (
. "github.com/onsi/ginkgo/v2" //v2
"helpers" //imports v1 => boom
)
var _ = It("has no rusty sprockets", func() {
helpers.EnsureNoSprocketRust(sprocket)
})
```
this won't work as the two versions of Ginkgo will be imported and result in a conflict.
Lastly, you can run into this issue accidentally while upgrading to 2.0 if you update some, but not all, of the import statements in your package.
**What you _can_ do**
While you cannot import V1 and V2 in the same package you _can_ have some packages that use V1 and other packages that use V2 associated with a given module. The different test packages are compiled separately and the V1 packages will use Ginkgo V1 whereas the V2 packages will use Ginkgo V2. Go basically treats different major versions of a dependency as completely different packages.
This means that your dependencies can use a different major version of Ginkgo for _their_ test suites than your codebase (as long as you aren't importing a test-helper dependency into your test suite and running into the major version clash described above).
This _also_ means that you can, in principle, upgrade different test suites in your module at different times. For example, in a fictitious `factory` module the `sprockets` package can be upgraded to Ginkgo V2 first, and the `convery_belt` package can stay at Ginkgo V1 until later. In _practice_ however, you'll run into difficulties as the `ginkgo` cli used to invoke the tests will be at a different major version than some subset of packages under test - this basically won't work because of changes in the client/server contract between the CLI and the test library across the two major versions. So you'll need to take care to use the correct version of the cli with the correct test package. In general the migration to V2 is intended to be simple enough that you should rarely need to resort to having mixed-version numbers like this.
### A symbol in V2 now clashes with a symbol in my codebase. What do I do?
If Ginkgo 2.0 introduces a new exported symbol that now clashes with your codebase (because you are dot-importing Ginkgo). Check out the [Alternatives to Dot-Importing Ginkgo](https://onsi.github.io/ginkgo/#alternatives-to-dot-importing-ginkgo) section of the documentation for some options. You may be able to, instead, dot-import just a subset of the Ginkgo DSL using the new `github.com/onsi/ginkgo/v2/dsl` set of packages.
Specifically when upgrading from v1 to v2 if you see a dot-import clash due to a newly introduced symbol (e.g. the new `Label` decorator) you can instead choose to dot-import the core DSL and import the `decorator` dsl separately:
```go
import (
. "github.com/onsi/ginkgo/v2/dsl/core"
"github.com/onsi/ginkgo/v2/dsl/decorators"
)
var _ = It("gives you the core DSL", decorators.Label("and namespaced decorators"), func() {
...
})
```
### I've upgraded to V2 and now have race conditions in my test. What do I do?
Most likely you are launching a goroutine that outlives the spec it was launched in and calling `By` in it. You probably didn't intend to have the goroutine outlive its spec so you'll probably want to fix that. More details here: https://github.com/onsi/ginkgo/issues/844
If that isn't the cause of your race condition you may have come across a bug, Please [open an issue](https://github.com/onsi/ginkgo/issues/new)!
{% endraw %}
================================================
FILE: docs/_config.yml
================================================
baseurl: "/ginkgo" # the subpath of your site, e.g. /blog
# Build settings
name: Ginkgo
markdown: GFM
highlighter: rouge
lsi: false
exclude:
- "*.go"
================================================
FILE: docs/_layouts/default.html
================================================
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="./css/primer-minimal.css">
<link rel="stylesheet" href="./css/layout.css">
</head>
<body>
<div id="container">
<div id="left-background"></div>
<div id="right-background"></div>
<div id="header">
<a class="brand" href="#top">Ginkgo</a>
<div class="spacer"></div>
<a href="https://github.com/onsi/ginkgo"><img class="logo" src="./images/github.png"></a>
<a href="https://github.com/sponsors/onsi"><img class="logo" src="./images/sponsor.png"></a>
<a href="https://pkg.go.dev/github.com/onsi/ginkgo"><img class="logo" src="./images/go.png"></a>
<div id="disclosure">
<div class="hamburger-slice"></div>
<div class="hamburger-slice"></div>
<div class="hamburger-slice"></div>
</div>
</div>
<div id="sidebar"></div>
<div id="mask"></div>
<div id="content" class="markdown-body">
{{ content }}
</div>
</div>
<script src="https://cdnjs.cloudflare.com/ajax/libs/anchor-js/4.1.0/anchor.min.js" integrity="sha256-lZaRhKri35AyJSypXXs4o6OPFTbTmUoltBbDCbdzegg=" crossorigin="anonymous"></script>
<script>anchors.add();</script>
<script src="./js/docs.js"></script>
</body>
</html>
================================================
FILE: docs/css/layout.css
================================================
:root {
--max-width: 1024px;
--header-height: 50px;
--breakpoint: 640px;
--ginkgo-green: #2dad6c;
--ginkgo-green-darker: #0d8d5c;
--ginkgo-green-faint: #fafffa;
}
body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
font-size: 14px;
margin: 0;
}
#header {
background-color: var(--ginkgo-green);
color: #fff;
border-bottom: solid 1px var(--ginkgo-green-darker);
}
#left-background, #right-background {
height: 100vh;
background-color: var(--ginkgo-green-faint);
}
#left-background {
box-shadow: inset -2px 0 7px -5px var(--ginkgo-green-darker);
}
#right-background {
box-shadow: inset 2px 0 7px -5px var(--ginkgo-green-darker);
}
#content {
background-color: #fff;
overflow-y: scroll;
padding: 5px;
padding-right:10px;
}
#sidebar {
background-color: #fff;
overflow-y: scroll;
padding:5px;
position:relative;
font-size: 16px;
}
#mask {
display:none;
}
img[alt="Ginkgo"] {
max-width: 80%;
max-height: 200px;
display: block;
margin-left: auto;
margin-right: auto;
}
/* code styling */
.markdown-body div.highlight {
margin-left: 20px;
margin-right: 20px;
border-radius: 10px;
margin-bottom: 16px !important;
max-width: 800px;
border: solid 2px #f0f0f0;
}
.markdown-body .highlight pre, .markdown-body pre {
background-color: transparent;
}
div.highlight.invalid {
border: solid 2px #f0aaaa;
background-color: #f0dddd;
}
/* sidebar items */
.sidebar-heading, .sidebar-item {
display:block;
text-decoration: none;
color: #000;
}
.sidebar-heading {
margin:5px 5px;
padding:3px 0;
}
.sidebar-heading.active {
font-weight:bold;
color: var(--ginkgo-green);
}
.sidebar-item {
font-size: 0.8rem;
margin: 5px 0 5px 10px;
}
.sidebar-item:nth-child(2n+1) {
color:#555;
}
.sidebar-item.active {
font-weight:bold;
color: var(--ginkgo-green);
}
.sidebar-section {
overflow: hidden;
max-height: 0;
// transition: max-height 0.3s;
}
.sidebar-heading.active + .sidebar-section {
max-height: 1000px;
}
/* header */
#header {
display: flex;
align-items: center;
}
.brand {
font-size: 1.8rem;
margin-left:10px;
font-weight: bold;
text-decoration: none;
color: #fff;
}
.spacer {
flex: 1;
}
.logo {
max-height: 22px;
margin: 0 5px;
}
a:last-of-type .logo {
margin-right: 10px;
}
#disclosure {
box-sizing: border-box;
width: var(--header-height);
height: var(--header-height);
display: flex;
flex-direction: column;
align-items: center;
justify-content: space-around;
padding: 12px 0;
cursor: pointer;
}
.hamburger-slice {
width: calc(var(--header-height) - 20px);
height: 2px;
border-radius: 4px;
background-color: #fff;
}
/* content styling */
#content h2 {
border-bottom: none;
}
/* Desktop */
@media screen and (min-width: 640px) {
#container {
--sidebar-width: 200px;
display: grid;
grid-template-areas: "left-background header header right-background"
"left-background sidebar content right-background";
grid-template-columns: 1fr var(--sidebar-width) minmax(calc(var(--breakpoint) - var(--sidebar-width)), var(--max-width)) 1fr;
grid-template-rows: var(--header-height) auto;
gap: 0;
height:100vh;
}
#left-background {
grid-area: left-background;
}
#right-background {
grid-area: right-background;
}
#header {
grid-area: header;
}
#sidebar {
grid-area: sidebar;
border-right: 5px solid #fff;
}
#content {
grid-area: content;
}
#disclosure {
display: none;
}
}
/* Mobile */
@media screen and (max-width: 640px) {
#container {
--sidebar-width: 300px;
display: grid;
grid-template-areas: "header"
"content";
grid-template-columns: 1fr;
grid-template-rows: var(--header-height) auto;
gap: 0;
height:100vh;
}
#header {
grid-area: header;
}
#content {
grid-area: content;
}
#left-background {
display: none;
}
#right-background {
display: none;
}
#sidebar {
position: fixed;
width: var(--sidebar-width);
top: var(--header-height);
bottom: 0px;
right: calc(-5px - var(--sidebar-width));
z-index:2;
transition: right 0.3s;
}
#mask {
background-color: rgba(0,0,0,0);
position: fixed;
width: 100vw;
top: var(--header-height);
bottom: 0px;
left:0px;
z-index:1;
cursor: pointer;
transition: background-color 0.3s;
}
#container.reveal-sidebar #sidebar {
right: 0px;
}
#container.reveal-sidebar #mask {
display:block;
background-color: rgba(0,0,0,0.2);
}
.hamburger-slice {
transition: transform 0.3s, opacity 0.1s;
}
#container .hamburger-slice:nth-child(1) {
transform: rotate(0deg);
transform-origin: top left;
}
#container .hamburger-slice:nth-child(2) {
opacity: 100;
}
#container .hamburger-slice:nth-child(3) {
transform: rotate(0deg);
transform-origin: bottom left;
}
#container.reveal-sidebar .hamburger-slice:nth-child(1) {
transform: rotate(35deg);
}
#container.reveal-sidebar .hamburger-slice:nth-child(2) {
opacity: 0;
}
#container.reveal-sidebar .hamburger-slice:nth-child(3) {
transform: rotate(-35deg);
}
}
/* Print */
@media print {
body {
font-size: 10pt;
margin: 0.25in;
background-image: none;
}
#header {
display: none;
}
#sidebar {
display: none;
}
#left-background {
display: none;
}
#right-background {
display: none;
}
h2 {
break-before: page;
}
.highlight {
break-inside: avoid-page;
}
}
================================================
FILE: docs/css/primer-minimal.css
================================================
.markdown-body {
line-height: 1.5;
word-wrap: break-word;
}
.markdown-body > * :first-child {
margin-top: 0 !important;
}
.markdown-body > * :last-child {
margin-bottom: 0 !important;
}
.markdown-body a {
color: #000;
text-decoration: underline;
}
.markdown-body a:visited {
color: #333;
text-decoration: underline;
}
.markdown-body .anchorjs-link {
text-decoration: none;
}
.markdown-body .absent {
color: #cb2431;
}
.markdown-body .anchor {
float: left;
padding-right: 4px;
margin-left: -20px;
line-height: 1;
}
.markdown-body .anchor:focus {
outline: none;
}
.markdown-body p, .markdown-body blockquote, .markdown-body ul, .markdown-body ol, .markdown-body dl, .markdown-body table, .markdown-body pre {
margin-top: 0;
margin-bottom: 16px;
}
.markdown-body hr {
height: 0.25em;
padding: 0;
margin: 24px 0;
background-color: #e1e4e8;
border: 0;
}
.markdown-body blockquote {
padding: 0 1em;
color: #6a737d;
border-left: 0.25em solid #dfe2e5;
}
.markdown-body blockquote > :first-child {
margin-top: 0;
}
.markdown-body blockquote > :last-child {
margin-bottom: 0;
}
.markdown-body kbd {
display: inline-block;
padding: 3px 5px;
font-size: 11px;
line-height: 10px;
color: #444d56;
vertical-align: middle;
background-color: #fafbfc;
border: solid 1px #c6cbd1;
border-bottom-color: #959da5;
border-radius: 3px;
box-shadow: inset 0 -1px 0 #959da5;
}
.markdown-body h1, .markdown-body h2, .markdown-body h3, .markdown-body h4, .markdown-body h5, .markdown-body h6 {
margin-top: 24px;
margin-bottom: 16px;
font-weight: 600;
line-height: 1.25;
}
.markdown-body h1 .octicon-link, .markdown-body h2 .octicon-link, .markdown-body h3 .octicon-link, .markdown-body h4 .octicon-link, .markdown-body h5 .octicon-link, .markdown-body h6 .octicon-link {
color: #1b1f23;
vertical-align: middle;
visibility: hidden;
}
.markdown-body h1:hover .anchor, .markdown-body h2:hover .anchor, .markdown-body h3:hover .anchor, .markdown-body h4:hover .anchor, .markdown-body h5:hover .anchor, .markdown-body h6:hover .anchor {
text-decoration: none;
}
.markdown-body h1:hover .anchor .octicon-link, .markdown-body h2:hover .anchor .octicon-link, .markdown-body h3:hover .anchor .octicon-link, .markdown-body h4:hover .anchor .octicon-link, .markdown-body h5:hover .anchor .octicon-link, .markdown-body h6:hover .anchor .octicon-link {
visibility: visible;
}
.markdown-body h1 tt, .markdown-body h1 code, .markdown-body h2 tt, .markdown-body h2 code, .markdown-body h3 tt, .markdown-body h3 code, .markdown-body h4 tt, .markdown-body h4 code, .markdown-body h5 tt, .markdown-body h5 code, .markdown-body h6 tt, .markdown-body h6 code {
font-size: inherit;
}
.markdown-body h1 {
padding-bottom: 0.3em;
font-size: 2em;
border-bottom: 1px solid #eaecef;
}
.markdown-body h2 {
padding-bottom: 0.3em;
font-size: 1.5em;
border-bottom: 1px solid #eaecef;
}
.markdown-body h3 {
font-size: 1.25em;
}
.markdown-body h4 {
font-size: 1em;
}
.markdown-body h5 {
font-size: 0.875em;
}
.markdown-body h6 {
font-size: 0.85em;
color: #6a737d;
}
.markdown-body ul, .markdown-body ol {
padding-left: 2em;
}
.markdown-body ul.no-list, .markdown-body ol.no-list {
padding: 0;
list-style-type: none;
}
.markdown-body ul ul, .markdown-body ul ol, .markdown-body ol ol, .markdown-body ol ul {
margin-top: 0;
margin-bottom: 0;
}
.markdown-body li {
word-wrap: break-all;
}
.markdown-body li > p {
margin-top: 16px;
}
.markdown-body li + li {
margin-top: 0.25em;
}
.markdown-body dl {
padding: 0;
}
.markdown-body dl dt {
padding: 0;
margin-top: 16px;
font-size: 1em;
font-style: italic;
font-weight: 600;
}
.markdown-body dl dd {
padding: 0 16px;
margin-bottom: 16px;
}
.markdown-body table {
display: block;
width: 100%;
overflow: auto;
}
.markdown-body table th {
font-weight: 600;
}
.markdown-body table th, .markdown-body table td {
padding: 6px 13px;
border: 1px solid #dfe2e5;
}
.markdown-body table tr {
background-color: #fff;
border-top: 1px solid #c6cbd1;
}
.markdown-body table tr:nth-child(2n) {
background-color: #f6f8fa;
}
.markdown-body table img {
background-color: transparent;
}
.markdown-body img {
max-width: 100%;
box-sizing: content-box;
background-color: #fff;
}
.markdown-body img[align=right] {
padding-left: 20px;
}
.markdown-body img[align=left] {
padding-right: 20px;
}
.markdown-body .emoji {
max-width: none;
vertical-align: text-top;
background-color: transparent;
}
.markdown-body span.frame {
display: block;
overflow: hidden;
}
.markdown-body span.frame > span {
display: block;
float: left;
width: auto;
padding: 7px;
margin: 13px 0 0;
overflow: hidden;
border: 1px solid #dfe2e5;
}
.markdown-body span.frame span img {
display: block;
float: left;
}
.markdown-body span.frame span span {
display: block;
padding: 5px 0 0;
clear: both;
color: #24292e;
}
.markdown-body span.align-center {
display: block;
overflow: hidden;
clear: both;
}
.markdown-body span.align-center > span {
display: block;
margin: 13px auto 0;
overflow: hidden;
text-align: center;
}
.markdown-body span.align-center span img {
margin: 0 auto;
text-align: center;
}
.markdown-body span.align-right {
display: block;
overflow: hidden;
clear: both;
}
.markdown-body span.align-right > span {
display: block;
margin: 13px 0 0;
overflow: hidden;
text-align: right;
}
.markdown-body span.align-right span img {
margin: 0;
text-align: right;
}
.markdown-body span.float-left {
display: block;
float: left;
margin-right: 13px;
overflow: hidden;
}
.markdown-body span.float-left span {
margin: 13px 0 0;
}
.markdown-body span.float-right {
display: block;
float: right;
margin-left: 13px;
overflow: hidden;
}
.markdown-body span.float-right > span {
display: block;
margin: 13px auto 0;
overflow: hidden;
text-align: right;
}
.markdown-body code, .markdown-body tt {
padding: 0.2em 0.4em;
margin: 0;
font-size: 85%;
background-color: rgba(27, 31, 35, 0.05);
border-radius: 3px;
}
.markdown-body code br, .markdown-body tt br {
display: none;
}
.markdown-body del code {
text-decoration: inherit;
}
.markdown-body pre {
word-wrap: normal;
}
.markdown-body pre > code {
padding: 0;
margin: 0;
font-size: 100%;
word-break: normal;
white-space: pre;
background: transparent;
border: 0;
}
.markdown-body .highlight {
margin-bottom: 16px;
}
.markdown-body .highlight pre {
margin-bottom: 0;
word-break: normal;
}
.markdown-body .highlight pre, .markdown-body pre {
padding: 16px;
overflow: auto;
font-size: 85%;
line-height: 1.45;
background-color: #f6f8fa;
border-radius: 3px;
}
.markdown-body pre code, .markdown-body pre tt {
display: inline;
max-width: auto;
padding: 0;
margin: 0;
overflow: visible;
line-height: inherit;
word-wrap: normal;
background-color: transparent;
border: 0;
}
.markdown-body .csv-data td, .markdown-body .csv-data th {
padding: 5px;
overflow: hidden;
font-size: 12px;
line-height: 1;
text-align: left;
white-space: nowrap;
}
.markdown-body .csv-data .blob-num {
padding: 10px 8px 9px;
text-align: right;
background: #fff;
border: 0;
}
.markdown-body .csv-data tr {
border-top: 0;
}
.markdown-body .csv-data th {
font-weight: 600;
background: #f6f8fa;
border-top: 0;
}
.highlight table td {
padding: 5px;
}
.highlight table pre {
margin: 0;
}
.highlight .cm {
color: #999988;
font-style: italic;
}
.highlight .cp {
color: #999999;
font-weight: bold;
}
.highlight .c1 {
color: #999988;
font-style: italic;
}
.highlight .cs {
color: #999999;
font-weight: bold;
font-style: italic;
}
.highlight .c, .highlight .cd {
color: #999988;
font-style: italic;
}
.highlight .err {
color: #a61717;
background-color: #e3d2d2;
}
.highlight .gd {
color: #000000;
background-color: #ffdddd;
}
.highlight .ge {
color: #000000;
font-style: italic;
}
.highlight .gr {
color: #aa0000;
}
.highlight .gh {
color: #999999;
}
.highlight .gi {
color: #000000;
background-color: #ddffdd;
}
.highlight .go {
color: #888888;
}
.highlight .gp {
color: #555555;
}
.highlight .gs {
font-weight: bold;
}
.highlight .gu {
color: #aaaaaa;
}
.highlight .gt {
color: #aa0000;
}
.highlight .kc {
color: #000000;
font-weight: bold;
}
.highlight .kd {
color: #000000;
font-weight: bold;
}
.highlight .kn {
color: #000000;
font-weight: bold;
}
.highlight .kp {
color: #000000;
font-weight: bold;
}
.highlight .kr {
color: #000000;
font-weight: bold;
}
.highlight .kt {
color: #445588;
font-weight: bold;
}
.highlight .k, .highlight .kv {
color: #000000;
font-weight: bold;
}
.highlight .mf {
color: #009999;
}
.highlight .mh {
color: #009999;
}
.highlight .il {
color: #009999;
}
.highlight .mi {
color: #009999;
}
.highlight .mo {
color: #009999;
}
.highlight .m, .highlight .mb, .highlight .mx {
color: #009999;
}
.highlight .sb {
color: #d14;
}
.highlight .sc {
color: #d14;
}
.highlight .sd {
color: #d14;
}
.highlight .s2 {
color: #d14;
}
.highlight .se {
color: #d14;
}
.highlight .sh {
color: #d14;
}
.highlight .si {
color: #d14;
}
.highlight .sx {
color: #d14;
}
.highlight .sr {
color: #009926;
}
.highlight .s1 {
color: #d14;
}
.highlight .ss {
color:
gitextract__qud01z3/
├── .github/
│ ├── FUNDING.yml
│ ├── dependabot.yml
│ └── workflows/
│ ├── codeql-analysis.yml
│ └── test.yml
├── .gitignore
├── CHANGELOG.md
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── README.md
├── RELEASING.md
├── config/
│ └── deprecated.go
├── core_dsl.go
├── decorator_dsl.go
├── deprecated_dsl.go
├── docs/
│ ├── .gitignore
│ ├── Gemfile
│ ├── MIGRATING_TO_V2.md
│ ├── _config.yml
│ ├── _layouts/
│ │ └── default.html
│ ├── css/
│ │ ├── layout.css
│ │ └── primer-minimal.css
│ ├── docs_suite_test.go
│ ├── index.md
│ └── js/
│ └── docs.js
├── dsl/
│ ├── core/
│ │ └── core_dsl.go
│ ├── decorators/
│ │ └── decorators_dsl.go
│ ├── dsl_suite_test.go
│ ├── reporting/
│ │ └── reporting_dsl.go
│ └── table/
│ └── table_dsl.go
├── extensions/
│ ├── globals/
│ │ ├── globals.go
│ │ └── globals_test.go
│ └── table/
│ └── deprecated.go
├── formatter/
│ ├── colorable_others.go
│ ├── colorable_windows.go
│ ├── formatter.go
│ ├── formatter_suite_test.go
│ └── formatter_test.go
├── ginkgo/
│ ├── automaxprocs/
│ │ ├── README.md
│ │ ├── automaxprocs.go
│ │ ├── cgroup.go
│ │ ├── cgroups.go
│ │ ├── cgroups2.go
│ │ ├── cpu_quota_linux.go
│ │ ├── cpu_quota_unsupported.go
│ │ ├── errors.go
│ │ ├── mountpoint.go
│ │ ├── runtime.go
│ │ └── subsys.go
│ ├── automaxprocs.go
│ ├── build/
│ │ └── build_command.go
│ ├── command/
│ │ ├── abort.go
│ │ ├── abort_test.go
│ │ ├── command.go
│ │ ├── command_suite_test.go
│ │ ├── command_test.go
│ │ ├── program.go
│ │ └── program_test.go
│ ├── generators/
│ │ ├── boostrap_templates.go
│ │ ├── bootstrap_command.go
│ │ ├── generate_command.go
│ │ ├── generate_templates.go
│ │ └── generators_common.go
│ ├── ginkgo_cli_suite_test.go
│ ├── ginkgo_cli_test.go
│ ├── internal/
│ │ ├── cli_internal_suite_test.go
│ │ ├── compile.go
│ │ ├── gocovmerge.go
│ │ ├── profiles_and_reports.go
│ │ ├── run.go
│ │ ├── test_suite.go
│ │ ├── testsuite_test.go
│ │ ├── utils.go
│ │ ├── utils_test.go
│ │ └── verify_version.go
│ ├── labels/
│ │ └── labels_command.go
│ ├── main.go
│ ├── outline/
│ │ ├── _testdata/
│ │ │ ├── alias_test.go
│ │ │ ├── alias_test.go.csv
│ │ │ ├── alias_test.go.json
│ │ │ ├── create_result.sh
│ │ │ ├── csv_proper_escaping_test.go
│ │ │ ├── csv_proper_escaping_test.go.csv
│ │ │ ├── csv_proper_escaping_test.go.json
│ │ │ ├── dsl_core_test.go
│ │ │ ├── dsl_core_test.go.csv
│ │ │ ├── dsl_core_test.go.json
│ │ │ ├── focused_test.go
│ │ │ ├── focused_test.go.csv
│ │ │ ├── focused_test.go.json
│ │ │ ├── labels_test.go
│ │ │ ├── labels_test.go.csv
│ │ │ ├── labels_test.go.json
│ │ │ ├── mixed_test.go
│ │ │ ├── mixed_test.go.csv
│ │ │ ├── mixed_test.go.json
│ │ │ ├── nestedfocused_test.go
│ │ │ ├── nestedfocused_test.go.csv
│ │ │ ├── nestedfocused_test.go.json
│ │ │ ├── nodot_test.go
│ │ │ ├── nodot_test.go.csv
│ │ │ ├── nodot_test.go.json
│ │ │ ├── normal_test.go
│ │ │ ├── normal_test.go.csv
│ │ │ ├── normal_test.go.json
│ │ │ ├── pending_decorator_test.go
│ │ │ ├── pending_decorator_test.go.csv
│ │ │ ├── pending_decorator_test.go.json
│ │ │ ├── pending_test.go
│ │ │ ├── pending_test.go.csv
│ │ │ ├── pending_test.go.json
│ │ │ ├── position_test.go
│ │ │ ├── position_test.go.csv
│ │ │ ├── position_test.go.json
│ │ │ ├── suite_test.go
│ │ │ ├── suite_test.go.csv
│ │ │ └── suite_test.go.json
│ │ ├── ginkgo.go
│ │ ├── import.go
│ │ ├── outline.go
│ │ ├── outline_command.go
│ │ ├── outline_suite_test.go
│ │ └── outline_test.go
│ ├── performance/
│ │ ├── _fixtures/
│ │ │ ├── large_suite_fixture/
│ │ │ │ └── large_suite_suite_test.go
│ │ │ └── performance_fixture/
│ │ │ ├── go.mod
│ │ │ ├── go.sum
│ │ │ ├── performance.go
│ │ │ ├── performance_suite_test.go
│ │ │ ├── pkg1/
│ │ │ │ └── pkg1_suite_test.go
│ │ │ ├── pkg2/
│ │ │ │ └── pkg2_suite_test.go
│ │ │ ├── pkg3/
│ │ │ │ └── pkg3_suite_test.go
│ │ │ └── pkg4/
│ │ │ └── pkg4_suite_test.go
│ │ ├── compiling-and-running-multiple-cache/
│ │ │ ├── 096fe2f06efcf59513adb6cb0275d32a.gmeasure-cache
│ │ │ ├── 1baac032c37c6eddc8381c02f73bab9c.gmeasure-cache
│ │ │ ├── 2daaa9348ce35e03f3fb34ec83ffc542.gmeasure-cache
│ │ │ ├── 34fa32127a8597d465872129ed999b27.gmeasure-cache
│ │ │ ├── 585dde06f8799aa0686577e4c76eee50.gmeasure-cache
│ │ │ ├── 5dde0a74da03182e70d258dbc7f9da5e.gmeasure-cache
│ │ │ ├── 63f93d6849139270a9cf6c7562b5c5c2.gmeasure-cache
│ │ │ ├── 7e079ed53f27697e0ae7f18ed2eef571.gmeasure-cache
│ │ │ ├── 952f6c671d14a219922ff81d601950dc.gmeasure-cache
│ │ │ ├── cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache
│ │ │ ├── d913553546dde110d20fd36aa954b145.gmeasure-cache
│ │ │ ├── e8c3ef1eebd492c875763c75066b201d.gmeasure-cache
│ │ │ ├── f63d60f305dbd4ac27febbc09ca9d000.gmeasure-cache
│ │ │ ├── f871828d82f74ed614c36d8f8d27f7f5.gmeasure-cache
│ │ │ └── ff4e55f973b442272532f4ac2daa0b13.gmeasure-cache
│ │ ├── compiling-and-running-single-cache/
│ │ │ ├── 2daaa9348ce35e03f3fb34ec83ffc542.gmeasure-cache
│ │ │ ├── cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache
│ │ │ └── d913553546dde110d20fd36aa954b145.gmeasure-cache
│ │ ├── compiling_and_running_test.go
│ │ ├── fetching-dependencies-cache/
│ │ │ ├── 1baac032c37c6eddc8381c02f73bab9c.gmeasure-cache
│ │ │ ├── 23a884dc38ea0cf973e24d00d94dd6ed.gmeasure-cache
│ │ │ ├── 55354cfa01f77f2c0d502c798e2b8262.gmeasure-cache
│ │ │ ├── 5eb5d96af3c34f61a070c450dddbf894.gmeasure-cache
│ │ │ ├── 63f93d6849139270a9cf6c7562b5c5c2.gmeasure-cache
│ │ │ ├── 952f6c671d14a219922ff81d601950dc.gmeasure-cache
│ │ │ ├── cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache
│ │ │ └── e8c3ef1eebd492c875763c75066b201d.gmeasure-cache
│ │ ├── fetching_dependencies_test.go
│ │ ├── large-suite-cache/
│ │ │ ├── 29caa3726740f30e27035121724c5be5.gmeasure-cache
│ │ │ ├── 483027456d601caec33292dbf280ca13.gmeasure-cache
│ │ │ ├── 54b26463f7c006bbf018993ad3bb66fc.gmeasure-cache
│ │ │ ├── 6f1839af2f330e23013bdb24a846760c.gmeasure-cache
│ │ │ ├── e3c9c7bf7ee9b54d714975dcc0babed2.gmeasure-cache
│ │ │ ├── e6de2fca259bb2567b057a5ec1929134.gmeasure-cache
│ │ │ └── f9eea3525ae1eb0c1aea29bb32267883.gmeasure-cache
│ │ ├── large_suite_test.go
│ │ └── performance_suite_test.go
│ ├── run/
│ │ └── run_command.go
│ ├── unfocus/
│ │ └── unfocus_command.go
│ └── watch/
│ ├── delta.go
│ ├── delta_tracker.go
│ ├── dependencies.go
│ ├── package_hash.go
│ ├── package_hashes.go
│ ├── suite.go
│ └── watch_command.go
├── ginkgo_cli_dependencies.go
├── ginkgo_t_dsl.go
├── go.mod
├── go.sum
├── integration/
│ ├── _fixtures/
│ │ ├── abort_fixture/
│ │ │ └── abort_fixture_suite_test.go
│ │ ├── after_run_hook_fixture/
│ │ │ ├── after_run_hook.go
│ │ │ ├── after_run_hook_suite_test.go
│ │ │ └── after_run_hook_test.go
│ │ ├── build_reporting_fixture/
│ │ │ ├── suite1/
│ │ │ │ ├── build_reporting_1_suite_test.go
│ │ │ │ └── build_reporting_1_test.go
│ │ │ └── suite2/
│ │ │ ├── build_reporting_2_suite_test.go
│ │ │ └── build_reporting_2_test.go
│ │ ├── combined_coverage_fixture/
│ │ │ ├── first_package/
│ │ │ │ ├── coverage.go
│ │ │ │ ├── coverage_fixture_suite_test.go
│ │ │ │ ├── coverage_fixture_test.go
│ │ │ │ └── external_coverage/
│ │ │ │ └── external_coverage.go
│ │ │ ├── second_package/
│ │ │ │ ├── coverage.go
│ │ │ │ ├── coverage_fixture_suite_test.go
│ │ │ │ └── coverage_fixture_test.go
│ │ │ └── third_package/
│ │ │ └── third_package_suite_test.go
│ │ ├── config_override_label_filter_fixture/
│ │ │ └── config_override_fixture_suite_test.go
│ │ ├── config_override_must_pass_repeatedly_fixture/
│ │ │ └── config_override_fixture_suite_test.go
│ │ ├── coverage_fixture/
│ │ │ ├── additional_spec/
│ │ │ │ └── additional_spec_suite_test.go
│ │ │ ├── coverage.go
│ │ │ ├── coverage_fixture_suite_test.go
│ │ │ ├── coverage_fixture_test.go
│ │ │ └── external_coverage/
│ │ │ └── external_coverage.go
│ │ ├── decorations_fixture/
│ │ │ ├── flaky_repeated/
│ │ │ │ └── flaky_repeated_fixture_suite_test.go
│ │ │ ├── invalid_decorations_flakeattempts_mustpassrepeatedly/
│ │ │ │ └── invalid_decorations_flakeattempts_mustpassrepeatedly_suite_test.go
│ │ │ ├── invalid_decorations_focused_pending/
│ │ │ │ └── invalid_decorations_focused_pending_suite_test.go
│ │ │ └── offset_focus_pending/
│ │ │ ├── never_see_this_file_test.go
│ │ │ └── offset_focus_pending_fixture_suite_test.go
│ │ ├── deprecated_features_fixture/
│ │ │ └── deprecated_features_fixture_suite_test.go
│ │ ├── does_not_compile_fixture/
│ │ │ ├── does_not_compile_suite_test.go
│ │ │ └── does_not_compile_test.go
│ │ ├── eventually_failing_fixture/
│ │ │ ├── eventually_failing_suite_test.go
│ │ │ └── eventually_failing_test.go
│ │ ├── exiting_synchronized_setup_fixture/
│ │ │ └── exiting_synchronized_setup_suite_test.go
│ │ ├── fail_fixture/
│ │ │ ├── fail_fixture_ginkgo_t_test.go
│ │ │ ├── fail_fixture_ginkgo_tb_test.go
│ │ │ ├── fail_fixture_suite_test.go
│ │ │ └── fail_fixture_test.go
│ │ ├── fail_then_hang_fixture/
│ │ │ └── fail_then_hang_fixture_suite_test.go
│ │ ├── failing_ginkgo_tests_fixture/
│ │ │ ├── failing_ginkgo_tests.go
│ │ │ ├── failing_ginkgo_tests_suite_test.go
│ │ │ └── failing_ginkgo_tests_test.go
│ │ ├── filter_fixture/
│ │ │ ├── filter_suite_test.go
│ │ │ ├── nugget_a_test.go
│ │ │ ├── nugget_b_test.go
│ │ │ ├── sprocket_a_test.go
│ │ │ ├── sprocket_b_test.go
│ │ │ ├── sprocket_c_test.go
│ │ │ ├── widget_a_test.go
│ │ │ └── widget_b_test.go
│ │ ├── flags_fixture/
│ │ │ ├── flags.go
│ │ │ ├── flags_suite_test.go
│ │ │ └── flags_test.go
│ │ ├── focused_fixture/
│ │ │ ├── README.md
│ │ │ ├── focused_fixture_suite_test.go
│ │ │ ├── focused_fixture_test.go
│ │ │ └── internal/
│ │ │ ├── focused_fixture_suite_test.go
│ │ │ └── focused_fixture_test.go
│ │ ├── focused_with_vendor_fixture/
│ │ │ ├── focused_fixture_suite_test.go
│ │ │ ├── focused_fixture_test.go
│ │ │ └── vendor/
│ │ │ ├── foo/
│ │ │ │ ├── bar/
│ │ │ │ │ └── bar.go
│ │ │ │ └── foo.go
│ │ │ └── vendored.go
│ │ ├── hanging_fixture/
│ │ │ ├── hanging_suite_test.go
│ │ │ └── hanging_test.go
│ │ ├── interceptor_fixture/
│ │ │ ├── interceptor_fixture_suite_test.go
│ │ │ └── main.go
│ │ ├── interceptor_sleep_fixture/
│ │ │ └── interceptor_fixture_suite_test.go
│ │ ├── labels_fixture/
│ │ │ ├── labels.go
│ │ │ ├── labels_fixture_suite_test.go
│ │ │ ├── labels_fixture_test.go
│ │ │ ├── nolabels/
│ │ │ │ ├── nolabels_suite_test.go
│ │ │ │ └── nolabels_test.go
│ │ │ └── onepkg/
│ │ │ ├── onepkg.go
│ │ │ ├── onepkg_suite_test.go
│ │ │ └── onepkg_test.go
│ │ ├── large_fixture/
│ │ │ └── large_fixture_suite_test.go
│ │ ├── malformed_by_fixture/
│ │ │ └── malformed_by_fixture_suite_test.go
│ │ ├── malformed_fixture/
│ │ │ ├── malformed_fixture_suite_test.go
│ │ │ └── malformed_fixture_test.go
│ │ ├── more_ginkgo_tests_fixture/
│ │ │ ├── more_ginkgo_tests.go
│ │ │ ├── more_ginkgo_tests_suite_test.go
│ │ │ └── more_ginkgo_tests_test.go
│ │ ├── no_tagged_tests_fixture/
│ │ │ ├── doc.go
│ │ │ └── no_tagged_tests_fixture_suite_test.go
│ │ ├── no_test_fn_fixture/
│ │ │ ├── no_test_fn.go
│ │ │ └── no_test_fn_test.go
│ │ ├── no_tests_fixture/
│ │ │ └── no_tests.go
│ │ ├── nondeterministic_fixture/
│ │ │ ├── file_a_test.go
│ │ │ ├── file_b_test.go
│ │ │ └── nondeterministic_fixture_suite_test.go
│ │ ├── ordered_fixture/
│ │ │ └── ordered_fixture_suite_test.go
│ │ ├── passing_ginkgo_tests_fixture/
│ │ │ ├── passing_ginkgo_tests.go
│ │ │ ├── passing_ginkgo_tests_suite_test.go
│ │ │ └── passing_ginkgo_tests_test.go
│ │ ├── pause_resume_interception_fixture/
│ │ │ └── pause_resume_interception_fixture_suite_test.go
│ │ ├── preview_fixture/
│ │ │ └── preview_fixture_suite_test.go
│ │ ├── profile_fixture/
│ │ │ ├── block_contest/
│ │ │ │ ├── block_contest.go
│ │ │ │ └── block_contest_suite_test.go
│ │ │ ├── lock_contest/
│ │ │ │ ├── lock_contest.go
│ │ │ │ └── lock_contest_suite_test.go
│ │ │ └── slow_memory_hog/
│ │ │ ├── slow_memory_hog.go
│ │ │ └── slow_memory_hog_suite_test.go
│ │ ├── progress_report_fixture/
│ │ │ ├── progress_report_fixture_suite_test.go
│ │ │ └── progress_report_test.go
│ │ ├── report_entries_fixture/
│ │ │ └── report_entries_fixture_suite_test.go
│ │ ├── reporting_fixture/
│ │ │ ├── malformed_sub_package/
│ │ │ │ └── malformed_sub_package_suite_test.go
│ │ │ ├── nonginkgo_sub_package/
│ │ │ │ └── a_test.go
│ │ │ ├── reporting_fixture_suite_test.go
│ │ │ ├── reporting_fixture_test.go
│ │ │ └── reporting_sub_package/
│ │ │ ├── reporting_sub_package_suite_test.go
│ │ │ └── reporting_sub_package_test.go
│ │ ├── rerun_specs_fixture/
│ │ │ └── rerun_specs_suite_test.go
│ │ ├── seed_fixture/
│ │ │ └── seed_fixture_suite_test.go
│ │ ├── semver_fixture/
│ │ │ ├── semver_fixture_suite_test.go
│ │ │ ├── semver_test.go
│ │ │ └── spechierarchy/
│ │ │ └── spechierarchy_suite_test.go
│ │ ├── serial_fixture/
│ │ │ └── serial_fixture_suite_test.go
│ │ ├── skip_fixture/
│ │ │ ├── skip_fixture_suite_test.go
│ │ │ └── skip_fixture_test.go
│ │ ├── symbol_fixture/
│ │ │ └── symbol_fixture_suite_test.go
│ │ ├── synchronized_setup_tests_fixture/
│ │ │ └── synchronized_setup_tests_suite_test.go
│ │ ├── tags_fixture/
│ │ │ ├── ignored_test.go
│ │ │ ├── tags_tests_suite_test.go
│ │ │ └── tags_tests_test.go
│ │ ├── timeline_fixture/
│ │ │ └── timeline_fixture_suite_test.go
│ │ ├── timeout_fixture/
│ │ │ ├── timeout_A/
│ │ │ │ └── timeout_A_suite_test.go
│ │ │ ├── timeout_B/
│ │ │ │ └── timeout_B_suite_test.go
│ │ │ ├── timeout_C/
│ │ │ │ └── timeout_C_suite_test.go
│ │ │ └── timeout_D/
│ │ │ └── timeout_D_suite_test.go
│ │ ├── version_mismatch_fixture/
│ │ │ ├── go.mod
│ │ │ ├── go.sum
│ │ │ └── version_mismatch_fixture_suite_test.go
│ │ ├── watch_fixture/
│ │ │ ├── A/
│ │ │ │ ├── A.go
│ │ │ │ ├── A_suite_test.go
│ │ │ │ └── A_test.go
│ │ │ ├── B/
│ │ │ │ ├── B.go
│ │ │ │ ├── B_suite_test.go
│ │ │ │ └── B_test.go
│ │ │ ├── C/
│ │ │ │ ├── C.go
│ │ │ │ ├── C.json
│ │ │ │ ├── C_suite_test.go
│ │ │ │ └── C_test.go
│ │ │ └── D/
│ │ │ ├── D.go
│ │ │ ├── D_suite_test.go
│ │ │ └── D_test.go
│ │ └── xunit_fixture/
│ │ ├── xunit_tests.go
│ │ └── xunit_tests_test.go
│ ├── abort_test.go
│ ├── decorations_test.go
│ ├── deprecations_test.go
│ ├── fail_test.go
│ ├── filter_test.go
│ ├── flags_test.go
│ ├── integration.go
│ ├── integration_suite_test.go
│ ├── interrupt_test.go
│ ├── output_interceptor_test.go
│ ├── precompiled_test.go
│ ├── preview_test.go
│ ├── profiling_go1.21_test.go
│ ├── profiling_go1.22_test.go
│ ├── profiling_test.go
│ ├── progress_test.go
│ ├── repeat_test.go
│ ├── report_entries_test.go
│ ├── reporting_test.go
│ ├── run_test.go
│ ├── skip_test.go
│ ├── subcommand_test.go
│ ├── suite_command_test.go
│ ├── suite_setup_test.go
│ ├── tags_test.go
│ ├── timeline_test.go
│ ├── verbose_and_succinct_test.go
│ └── watch_test.go
├── internal/
│ ├── around_node.go
│ ├── counter.go
│ ├── counter_test.go
│ ├── failer.go
│ ├── failer_test.go
│ ├── focus.go
│ ├── focus_test.go
│ ├── global/
│ │ └── init.go
│ ├── group.go
│ ├── internal_integration/
│ │ ├── abort_test.go
│ │ ├── around_node_test.go
│ │ ├── cleanup_test.go
│ │ ├── config_dry_run_test.go
│ │ ├── config_fail_fast_test.go
│ │ ├── config_flake_attempts_test.go
│ │ ├── config_must_pass_repeatedly_test.go
│ │ ├── current_spec_report_test.go
│ │ ├── decorations_test.go
│ │ ├── fail_test.go
│ │ ├── focus_test.go
│ │ ├── internal_integration_suite_test.go
│ │ ├── interrupt_and_timeout_test.go
│ │ ├── labels_test.go
│ │ ├── node_spec_events_test.go
│ │ ├── ordered_test.go
│ │ ├── parallel_test.go
│ │ ├── progress_report_test.go
│ │ ├── report_each_test.go
│ │ ├── report_entries_test.go
│ │ ├── report_suite_test.go
│ │ ├── run_test.go
│ │ ├── serial_test.go
│ │ ├── shuffle_test.go
│ │ ├── skip_test.go
│ │ ├── spec_priority_test.go
│ │ ├── synchronized_suite_nodes_test.go
│ │ ├── table_test.go
│ │ └── timeline_test.go
│ ├── internal_suite_test.go
│ ├── interrupt_handler/
│ │ ├── interrupt_handler.go
│ │ ├── interrupt_handler_test.go
│ │ ├── interrupthandler_suite_test.go
│ │ ├── sigquit_swallower_unix.go
│ │ └── sigquit_swallower_windows.go
│ ├── node.go
│ ├── node_test.go
│ ├── ordering.go
│ ├── ordering_test.go
│ ├── output_interceptor.go
│ ├── output_interceptor_test.go
│ ├── output_interceptor_unix.go
│ ├── output_interceptor_wasm.go
│ ├── output_interceptor_win.go
│ ├── parallel_support/
│ │ ├── client_server.go
│ │ ├── client_server_test.go
│ │ ├── http_client.go
│ │ ├── http_server.go
│ │ ├── parallel_support_suite_test.go
│ │ ├── rpc_client.go
│ │ ├── rpc_server.go
│ │ └── server_handler.go
│ ├── progress_report.go
│ ├── progress_report_bsd.go
│ ├── progress_report_test.go
│ ├── progress_report_unix.go
│ ├── progress_report_wasm.go
│ ├── progress_report_win.go
│ ├── progress_reporter_manager.go
│ ├── progress_reporter_manager_test.go
│ ├── report_entry.go
│ ├── report_entry_test.go
│ ├── reporters/
│ │ ├── gojson.go
│ │ ├── gojson_event_writer.go
│ │ └── gojson_reporter.go
│ ├── spec.go
│ ├── spec_context.go
│ ├── spec_context_test.go
│ ├── spec_test.go
│ ├── suite.go
│ ├── suite_test.go
│ ├── test_helpers/
│ │ ├── docs.go
│ │ ├── fake_interrupt_handler.go
│ │ ├── fake_output_interceptor.go
│ │ ├── fake_reporter.go
│ │ ├── multiline_helpers.go
│ │ ├── run_tracker.go
│ │ ├── set_up_server.go
│ │ └── status_code_poller.go
│ ├── testingtproxy/
│ │ ├── testing_t_proxy.go
│ │ ├── testingtproxy_suite_test.go
│ │ └── testingtproxy_test.go
│ ├── tree.go
│ ├── tree_test.go
│ ├── writer.go
│ └── writer_test.go
├── reporters/
│ ├── __snapshots__/
│ │ ├── gojson_report_test.snap
│ │ ├── junit_report_test.snap
│ │ └── teamcity_report_test.snap
│ ├── default_reporter.go
│ ├── default_reporter_test.go
│ ├── deprecated_reporter.go
│ ├── deprecated_reporter_test.go
│ ├── gojson_report.go
│ ├── gojson_report_test.go
│ ├── json_report.go
│ ├── json_report_test.go
│ ├── junit_report.go
│ ├── junit_report_test.go
│ ├── reporter.go
│ ├── reporters_suite_test.go
│ ├── teamcity_report.go
│ └── teamcity_report_test.go
├── reporting_dsl.go
├── table_dsl.go
└── types/
├── around_node.go
├── around_node_test.go
├── code_location.go
├── code_location_test.go
├── config.go
├── config_test.go
├── deprecated_support_test.go
├── deprecated_types.go
├── deprecated_types_test.go
├── deprecation_support.go
├── enum_support.go
├── errors.go
├── errors_test.go
├── file_filter.go
├── file_filters_test.go
├── flags.go
├── flags_test.go
├── label_filter.go
├── label_filter_test.go
├── report_entry.go
├── semver_filter.go
├── semver_filter_test.go
├── types.go
├── types_suite_test.go
├── types_test.go
└── version.go
SYMBOL INDEX (1777 symbols across 258 files)
FILE: config/deprecated.go
type DeprecatedGinkgoConfigType (line 11) | type DeprecatedGinkgoConfigType struct
type DeprecatedDefaultReporterConfigType (line 39) | type DeprecatedDefaultReporterConfigType struct
type GinkgoConfigIsNoLongerAccessibleFromTheConfigPackageUseTheDSLsGinkgoConfigurationFunctionInstead (line 54) | type GinkgoConfigIsNoLongerAccessibleFromTheConfigPackageUseTheDSLsGinkg...
type DefaultReporterConfigIsNoLongerAccessibleFromTheConfigPackageUseTheDSLsGinkgoConfigurationFunctionInstead (line 64) | type DefaultReporterConfigIsNoLongerAccessibleFromTheConfigPackageUseThe...
FILE: core_dsl.go
constant GINKGO_VERSION (line 36) | GINKGO_VERSION = types.VERSION
function init (line 46) | func init() {
function exitIfErr (line 55) | func exitIfErr(err error) {
function exitIfErrors (line 68) | func exitIfErrors(errors []error) {
type GinkgoWriterInterface (line 84) | type GinkgoWriterInterface interface
type GinkgoTestingT (line 124) | type GinkgoTestingT interface
function GinkgoConfiguration (line 140) | func GinkgoConfiguration() (types.SuiteConfig, types.ReporterConfig) {
function GinkgoRandomSeed (line 152) | func GinkgoRandomSeed() int64 {
function GinkgoParallelProcess (line 163) | func GinkgoParallelProcess() int {
function GinkgoHelper (line 172) | func GinkgoHelper() {
function GinkgoLabelFilter (line 185) | func GinkgoLabelFilter() string {
function GinkgoSemVerFilter (line 199) | func GinkgoSemVerFilter() string {
function PauseOutputInterception (line 218) | func PauseOutputInterception() {
function ResumeOutputInterception (line 226) | func ResumeOutputInterception() {
function RunSpecs (line 261) | func RunSpecs(t GinkgoTestingT, description string, args ...any) bool {
function extractSuiteConfiguration (line 334) | func extractSuiteConfiguration(args []any) (Labels, SemVerConstraints, C...
function getwd (line 375) | func getwd() (string, error) {
function PreviewSpecs (line 388) | func PreviewSpecs(description string, args ...any) Report {
function Skip (line 425) | func Skip(message string, callerSkip ...int) {
function Fail (line 446) | func Fail(message string, callerSkip ...int) {
function AbortSuite (line 464) | func AbortSuite(message string, callerSkip ...int) {
type ignorablePanic (line 479) | type ignorablePanic interface
function GinkgoRecover (line 493) | func GinkgoRecover() {
function pushNode (line 505) | func pushNode(node internal.Node, errors []error) bool {
type NodeArgsTransformer (line 526) | type NodeArgsTransformer
function AddTreeConstructionNodeArgsTransformer (line 537) | func AddTreeConstructionNodeArgsTransformer(transformer NodeArgsTransfor...
function Describe (line 553) | func Describe(text string, args ...any) bool {
function FDescribe (line 560) | func FDescribe(text string, args ...any) bool {
function PDescribe (line 568) | func PDescribe(text string, args ...any) bool {
function When (line 584) | func When(text string, args ...any) bool {
function FWhen (line 589) | func FWhen(text string, args ...any) bool {
function PWhen (line 595) | func PWhen(text string, args ...any) bool {
function It (line 612) | func It(text string, args ...any) bool {
function FIt (line 619) | func FIt(text string, args ...any) bool {
function PIt (line 627) | func PIt(text string, args ...any) bool {
function By (line 658) | func By(text string, callback ...func()) {
function BeforeSuite (line 673) | func BeforeSuite(body any, args ...any) bool {
function AfterSuite (line 692) | func AfterSuite(body any, args ...any) bool {
function SynchronizedBeforeSuite (line 729) | func SynchronizedBeforeSuite(process1Body any, allProcessBody any, args ...
function SynchronizedAfterSuite (line 749) | func SynchronizedAfterSuite(allProcessBody any, process1Body any, args ....
function BeforeEach (line 765) | func BeforeEach(args ...any) bool {
function JustBeforeEach (line 778) | func JustBeforeEach(args ...any) bool {
function AfterEach (line 793) | func AfterEach(args ...any) bool {
function JustAfterEach (line 805) | func JustAfterEach(args ...any) bool {
function BeforeAll (line 820) | func BeforeAll(args ...any) bool {
function AfterAll (line 837) | func AfterAll(args ...any) bool {
function DeferCleanup (line 880) | func DeferCleanup(args ...any) {
function AttachProgressReporter (line 904) | func AttachProgressReporter(reporter func() string) func() {
FILE: decorator_dsl.go
constant Focus (line 38) | Focus = internal.Focus
constant Pending (line 46) | Pending = internal.Pending
constant Serial (line 55) | Serial = internal.Serial
constant Ordered (line 64) | Ordered = internal.Ordered
constant ContinueOnFailure (line 74) | ContinueOnFailure = internal.ContinueOnFailure
constant OncePerOrdered (line 84) | OncePerOrdered = internal.OncePerOrdered
function Label (line 93) | func Label(labels ...string) Labels {
function SemVerConstraint (line 110) | func SemVerConstraint(semVerConstraints ...string) SemVerConstraints {
function ComponentSemVerConstraint (line 127) | func ComponentSemVerConstraint(component string, semVerConstraints ...st...
constant SuppressProgressReporting (line 189) | SuppressProgressReporting = internal.SuppressProgressReporting
function AroundNode (line 212) | func AroundNode[F types.AroundNodeAllowedFuncs](f F) types.AroundNodeDec...
FILE: deprecated_dsl.go
function RunSpecsWithDefaultAndCustomReporters (line 36) | func RunSpecsWithDefaultAndCustomReporters(t GinkgoTestingT, description...
function RunSpecsWithCustomReporters (line 47) | func RunSpecsWithCustomReporters(t GinkgoTestingT, description string, _...
type DeprecatedGinkgoTestDescription (line 59) | type DeprecatedGinkgoTestDescription struct
function CurrentGinkgoTestDescription (line 79) | func CurrentGinkgoTestDescription() DeprecatedGinkgoTestDescription {
function GinkgoParallelNode (line 106) | func GinkgoParallelNode() int {
type Benchmarker (line 120) | type Benchmarker interface
function Measure (line 132) | func Measure(_ ...any) bool {
FILE: docs/docs_suite_test.go
function TestDocs (line 19) | func TestDocs(t *testing.T) {
FILE: dsl/core/core_dsl.go
constant GINKGO_VERSION (line 19) | GINKGO_VERSION = ginkgo.GINKGO_VERSION
FILE: dsl/decorators/decorators_dsl.go
constant Focus (line 33) | Focus = ginkgo.Focus
constant Pending (line 34) | Pending = ginkgo.Pending
constant Serial (line 35) | Serial = ginkgo.Serial
constant Ordered (line 36) | Ordered = ginkgo.Ordered
constant ContinueOnFailure (line 37) | ContinueOnFailure = ginkgo.ContinueOnFailure
constant OncePerOrdered (line 38) | OncePerOrdered = ginkgo.OncePerOrdered
constant SuppressProgressReporting (line 39) | SuppressProgressReporting = ginkgo.SuppressProgressReporting
function AroundNode (line 45) | func AroundNode[F types.AroundNodeAllowedFuncs](f F) types.AroundNodeDec...
FILE: dsl/dsl_suite_test.go
function TestDSL (line 13) | func TestDSL(t *testing.T) {
function ExtractSymbols (line 18) | func ExtractSymbols(f *ast.File) []string {
FILE: dsl/reporting/reporting_dsl.go
constant ReportEntryVisibilityAlways (line 24) | ReportEntryVisibilityAlways, ReportEntryVisibilityFailureOrVerbose, Repo...
FILE: extensions/globals/globals.go
function Reset (line 24) | func Reset() {
FILE: extensions/globals/globals_test.go
function TestGlobals (line 10) | func TestGlobals(t *testing.T) {
FILE: extensions/table/deprecated.go
type TableSupportHasBeenMovedToTheCoreGinkgoDSL (line 3) | type TableSupportHasBeenMovedToTheCoreGinkgoDSL struct
FILE: formatter/colorable_others.go
function newColorable (line 39) | func newColorable(file *os.File) io.Writer {
FILE: formatter/colorable_windows.go
function isTerminal (line 54) | func isTerminal(fd uintptr) bool {
constant foregroundBlue (line 61) | foregroundBlue = 0x1
constant foregroundGreen (line 62) | foregroundGreen = 0x2
constant foregroundRed (line 63) | foregroundRed = 0x4
constant foregroundIntensity (line 64) | foregroundIntensity = 0x8
constant foregroundMask (line 65) | foregroundMask = (foregroundRed | foregroundBlue | foregroundGreen ...
constant backgroundBlue (line 66) | backgroundBlue = 0x10
constant backgroundGreen (line 67) | backgroundGreen = 0x20
constant backgroundRed (line 68) | backgroundRed = 0x40
constant backgroundIntensity (line 69) | backgroundIntensity = 0x80
constant backgroundMask (line 70) | backgroundMask = (backgroundRed | backgroundBlue | backgroundGreen ...
type wchar (line 73) | type wchar
type short (line 74) | type short
type dword (line 75) | type dword
type word (line 76) | type word
type coord (line 78) | type coord struct
type smallRect (line 83) | type smallRect struct
type consoleScreenBufferInfo (line 90) | type consoleScreenBufferInfo struct
type writer (line 98) | type writer struct
method Write (line 379) | func (w *writer) Write(data []byte) (n int, err error) {
function newColorable (line 105) | func newColorable(file *os.File) io.Writer {
type consoleColor (line 651) | type consoleColor struct
method foregroundAttr (line 659) | func (c consoleColor) foregroundAttr() (attr word) {
method backgroundAttr (line 675) | func (c consoleColor) backgroundAttr() (attr word) {
type hsv (line 710) | type hsv struct
method dist (line 714) | func (a hsv) dist(b hsv) float32 {
function toHSV (line 727) | func toHSV(rgb int) hsv {
type hsvTable (line 754) | type hsvTable
method find (line 764) | func (t hsvTable) find(rgb int) consoleColor {
function toHSVTable (line 756) | func toHSVTable(rgbTable []consoleColor) hsvTable {
function minmax3f (line 777) | func minmax3f(a, b, c float32) (min, max float32) {
function n256setup (line 800) | func n256setup() {
FILE: formatter/formatter.go
constant COLS (line 15) | COLS = 80
type ColorMode (line 17) | type ColorMode
constant ColorModeNone (line 20) | ColorModeNone ColorMode = iota
constant ColorModeTerminal (line 21) | ColorModeTerminal
constant ColorModePassthrough (line 22) | ColorModePassthrough
function F (line 27) | func F(format string, args ...any) string {
function Fi (line 31) | func Fi(indentation uint, format string, args ...any) string {
function Fiw (line 35) | func Fiw(indentation uint, maxWidth uint, format string, args ...any) st...
type Formatter (line 39) | type Formatter struct
method F (line 118) | func (f Formatter) F(format string, args ...any) string {
method Fi (line 122) | func (f Formatter) Fi(indentation uint, format string, args ...any) st...
method Fiw (line 126) | func (f Formatter) Fiw(indentation uint, maxWidth uint, format string,...
method length (line 183) | func (f Formatter) length(styled string) uint {
method CycleJoin (line 202) | func (f Formatter) CycleJoin(elements []string, joiner string, cycle [...
method style (line 218) | func (f Formatter) style(s string) string {
function NewWithNoColorBool (line 46) | func NewWithNoColorBool(noColor bool) Formatter {
function New (line 53) | func New(colorMode ColorMode) Formatter {
FILE: formatter/formatter_suite_test.go
function TestFormatter (line 10) | func TestFormatter(t *testing.T) {
FILE: ginkgo/automaxprocs/automaxprocs.go
function init (line 31) | func init() {
constant _maxProcsKey (line 35) | _maxProcsKey = "GOMAXPROCS"
type config (line 37) | type config struct
function Set (line 48) | func Set() error {
FILE: ginkgo/automaxprocs/cgroup.go
type CGroup (line 35) | type CGroup struct
method Path (line 45) | func (cg *CGroup) Path() string {
method ParamPath (line 50) | func (cg *CGroup) ParamPath(param string) string {
method readFirstLine (line 55) | func (cg *CGroup) readFirstLine(param string) (string, error) {
method readInt (line 73) | func (cg *CGroup) readInt(param string) (int, error) {
function NewCGroup (line 40) | func NewCGroup(path string) *CGroup {
FILE: ginkgo/automaxprocs/cgroups.go
constant _cgroupFSType (line 29) | _cgroupFSType = "cgroup"
constant _cgroupSubsysCPU (line 31) | _cgroupSubsysCPU = "cpu"
constant _cgroupSubsysCPUAcct (line 33) | _cgroupSubsysCPUAcct = "cpuacct"
constant _cgroupSubsysCPUSet (line 35) | _cgroupSubsysCPUSet = "cpuset"
constant _cgroupSubsysMemory (line 37) | _cgroupSubsysMemory = "memory"
constant _cgroupCPUCFSQuotaUsParam (line 41) | _cgroupCPUCFSQuotaUsParam = "cpu.cfs_quota_us"
constant _cgroupCPUCFSPeriodUsParam (line 44) | _cgroupCPUCFSPeriodUsParam = "cpu.cfs_period_us"
constant _procPathCGroup (line 48) | _procPathCGroup = "/proc/self/cgroup"
constant _procPathMountInfo (line 49) | _procPathMountInfo = "/proc/self/mountinfo"
type CGroups (line 53) | type CGroups
method CPUQuota (line 101) | func (cg CGroups) CPUQuota() (float64, bool, error) {
function NewCGroups (line 58) | func NewCGroups(procPathMountInfo, procPathCGroup string) (CGroups, erro...
function NewCGroupsForCurrentProcess (line 94) | func NewCGroupsForCurrentProcess() (CGroups, error) {
FILE: ginkgo/automaxprocs/cgroups2.go
constant _cgroupv2CPUMax (line 40) | _cgroupv2CPUMax = "cpu.max"
constant _cgroupv2FSType (line 43) | _cgroupv2FSType = "cgroup2"
constant _cgroupv2MountPoint (line 45) | _cgroupv2MountPoint = "/sys/fs/cgroup"
constant _cgroupV2CPUMaxDefaultPeriod (line 47) | _cgroupV2CPUMaxDefaultPeriod = 100000
constant _cgroupV2CPUMaxQuotaMax (line 48) | _cgroupV2CPUMaxQuotaMax = "max"
constant _cgroupv2CPUMaxQuotaIndex (line 52) | _cgroupv2CPUMaxQuotaIndex = iota
constant _cgroupv2CPUMaxPeriodIndex (line 53) | _cgroupv2CPUMaxPeriodIndex
type CGroups2 (line 60) | type CGroups2 struct
method CPUQuota (line 128) | func (cg *CGroups2) CPUQuota() (float64, bool, error) {
function NewCGroups2ForCurrentProcess (line 69) | func NewCGroups2ForCurrentProcess() (*CGroups2, error) {
function newCGroups2From (line 73) | func newCGroups2From(mountInfoPath, procPathCGroup string) (*CGroups2, e...
function isCGroupV2 (line 108) | func isCGroupV2(procPathMountInfo string) (bool, error) {
FILE: ginkgo/automaxprocs/cpu_quota_linux.go
function CPUQuotaToGOMAXPROCS (line 33) | func CPUQuotaToGOMAXPROCS(minValue int, round func(v float64) int) (int,...
type queryer (line 54) | type queryer interface
function newQueryer (line 64) | func newQueryer() (queryer, error) {
FILE: ginkgo/automaxprocs/cpu_quota_unsupported.go
function CPUQuotaToGOMAXPROCS (line 29) | func CPUQuotaToGOMAXPROCS(_ int, _ func(v float64) int) (int, CPUQuotaSt...
FILE: ginkgo/automaxprocs/errors.go
type cgroupSubsysFormatInvalidError (line 28) | type cgroupSubsysFormatInvalidError struct
method Error (line 42) | func (err cgroupSubsysFormatInvalidError) Error() string {
type mountPointFormatInvalidError (line 32) | type mountPointFormatInvalidError struct
method Error (line 46) | func (err mountPointFormatInvalidError) Error() string {
type pathNotExposedFromMountPointError (line 36) | type pathNotExposedFromMountPointError struct
method Error (line 50) | func (err pathNotExposedFromMountPointError) Error() string {
FILE: ginkgo/automaxprocs/mountpoint.go
constant _mountInfoSep (line 35) | _mountInfoSep = " "
constant _mountInfoOptsSep (line 36) | _mountInfoOptsSep = ","
constant _mountInfoOptionalFieldsSep (line 37) | _mountInfoOptionalFieldsSep = "-"
constant _miFieldIDMountID (line 41) | _miFieldIDMountID = iota
constant _miFieldIDParentID (line 42) | _miFieldIDParentID
constant _miFieldIDDeviceID (line 43) | _miFieldIDDeviceID
constant _miFieldIDRoot (line 44) | _miFieldIDRoot
constant _miFieldIDMountPoint (line 45) | _miFieldIDMountPoint
constant _miFieldIDOptions (line 46) | _miFieldIDOptions
constant _miFieldIDOptionalFields (line 47) | _miFieldIDOptionalFields
constant _miFieldCountFirstHalf (line 49) | _miFieldCountFirstHalf
constant _miFieldOffsetFSType (line 53) | _miFieldOffsetFSType = iota
constant _miFieldOffsetMountSource (line 54) | _miFieldOffsetMountSource
constant _miFieldOffsetSuperOptions (line 55) | _miFieldOffsetSuperOptions
constant _miFieldCountSecondHalf (line 57) | _miFieldCountSecondHalf
constant _miFieldCountMin (line 60) | _miFieldCountMin = _miFieldCountFirstHalf + _miFieldCountSecondHalf
type MountPoint (line 64) | type MountPoint struct
method Translate (line 132) | func (mp *MountPoint) Translate(absPath string) (string, error) {
function NewMountPointFromLine (line 79) | func NewMountPointFromLine(line string) (*MountPoint, error) {
function parseMountInfo (line 151) | func parseMountInfo(procPathMountInfo string, newMountPoint func(*MountP...
FILE: ginkgo/automaxprocs/runtime.go
type CPUQuotaStatus (line 26) | type CPUQuotaStatus
constant CPUQuotaUndefined (line 30) | CPUQuotaUndefined CPUQuotaStatus = iota
constant CPUQuotaUsed (line 32) | CPUQuotaUsed
constant CPUQuotaMinUsed (line 34) | CPUQuotaMinUsed
function DefaultRoundFunc (line 38) | func DefaultRoundFunc(v float64) int {
FILE: ginkgo/automaxprocs/subsys.go
constant _cgroupSep (line 34) | _cgroupSep = ":"
constant _cgroupSubsysSep (line 35) | _cgroupSubsysSep = ","
constant _csFieldIDID (line 39) | _csFieldIDID = iota
constant _csFieldIDSubsystems (line 40) | _csFieldIDSubsystems
constant _csFieldIDName (line 41) | _csFieldIDName
constant _csFieldCount (line 42) | _csFieldCount
type CGroupSubsys (line 47) | type CGroupSubsys struct
function NewCGroupSubsysFromLine (line 55) | func NewCGroupSubsysFromLine(line string) (*CGroupSubsys, error) {
function parseCGroupSubsystems (line 78) | func parseCGroupSubsystems(procPathCGroup string) (map[string]*CGroupSub...
FILE: ginkgo/build/build_command.go
function BuildBuildCommand (line 13) | func BuildBuildCommand() command.Command {
function buildSpecs (line 37) | func buildSpecs(args []string, cliConfig types.CLIConfig, goFlagsConfig ...
FILE: ginkgo/command/abort.go
type AbortDetails (line 5) | type AbortDetails struct
function Abort (line 11) | func Abort(details AbortDetails) {
function AbortGracefullyWith (line 15) | func AbortGracefullyWith(format string, args ...any) {
function AbortWith (line 23) | func AbortWith(format string, args ...any) {
function AbortWithUsage (line 31) | func AbortWithUsage(format string, args ...any) {
function AbortIfError (line 39) | func AbortIfError(preamble string, err error) {
function AbortIfErrors (line 49) | func AbortIfErrors(preamble string, errors []error) {
FILE: ginkgo/command/command.go
type Command (line 12) | type Command struct
method Run (line 22) | func (c Command) Run(args []string, additionalArgs []string) {
method EmitUsage (line 35) | func (c Command) EmitUsage(writer io.Writer) {
FILE: ginkgo/command/command_suite_test.go
function TestCommand (line 10) | func TestCommand(t *testing.T) {
FILE: ginkgo/command/program.go
type Program (line 13) | type Program struct
method RunAndExit (line 31) | func (p Program) RunAndExit(osArgs []string) {
method handleHelpRequestsAndExit (line 115) | func (p Program) handleHelpRequestsAndExit(writer io.Writer, args []st...
method EmitUsage (line 161) | func (p Program) EmitUsage(writer io.Writer) {
type DeprecatedCommand (line 26) | type DeprecatedCommand struct
FILE: ginkgo/generators/bootstrap_command.go
function BuildBootstrapCommand (line 16) | func BuildBootstrapCommand() command.Command {
type bootstrapData (line 56) | type bootstrapData struct
function generateBootstrap (line 67) | func generateBootstrap(conf GeneratorsConfig) {
FILE: ginkgo/generators/generate_command.go
function BuildGenerateCommand (line 19) | func BuildGenerateCommand() command.Command {
type specData (line 64) | type specData struct
function generateTestFiles (line 78) | func generateTestFiles(conf GeneratorsConfig, args []string) {
function generateTestFileForSubject (line 88) | func generateTestFileForSubject(subject string, conf GeneratorsConfig) {
function formatSubject (line 163) | func formatSubject(name string) string {
function moduleName (line 172) | func moduleName(modRoot string) string {
function findModuleRoot (line 222) | func findModuleRoot(dir string) (root string) {
function getPackageImportPath (line 239) | func getPackageImportPath() string {
FILE: ginkgo/generators/generators_common.go
type GeneratorsConfig (line 14) | type GeneratorsConfig struct
function getPackageAndFormattedName (line 21) | func getPackageAndFormattedName() (string, string, string) {
function ensureLegalPackageName (line 38) | func ensureLegalPackageName(name string) string {
function prettifyName (line 52) | func prettifyName(name string) string {
function determinePackageName (line 60) | func determinePackageName(name string, internal bool) string {
function getBuildTags (line 71) | func getBuildTags(tags string) string {
FILE: ginkgo/ginkgo_cli_suite_test.go
function TestGinkgoCLI (line 12) | func TestGinkgoCLI(t *testing.T) {
FILE: ginkgo/internal/cli_internal_suite_test.go
function TestCLIInternalSuite (line 10) | func TestCLIInternalSuite(t *testing.T) {
FILE: ginkgo/internal/compile.go
function CompileSuite (line 14) | func CompileSuite(suite TestSuite, goFlagsConfig types.GoFlagsConfig, pr...
function Cleanup (line 90) | func Cleanup(goFlagsConfig types.GoFlagsConfig, suites ...TestSuite) {
type parallelSuiteBundle (line 101) | type parallelSuiteBundle struct
type OrderedParallelCompiler (line 106) | type OrderedParallelCompiler struct
method StartCompiling (line 123) | func (opc *OrderedParallelCompiler) StartCompiling(suites TestSuites, ...
method Next (line 157) | func (opc *OrderedParallelCompiler) Next() (int, TestSuite) {
method StopAndDrain (line 169) | func (opc *OrderedParallelCompiler) StopAndDrain() {
function NewOrderedParallelCompiler (line 116) | func NewOrderedParallelCompiler(numCompilers int) *OrderedParallelCompil...
FILE: ginkgo/internal/gocovmerge.go
function AddCoverProfile (line 39) | func AddCoverProfile(profiles []*cover.Profile, p *cover.Profile) []*cov...
function DumpCoverProfiles (line 51) | func DumpCoverProfiles(profiles []*cover.Profile, out io.Writer) error {
function MergeCoverProfiles (line 68) | func MergeCoverProfiles(into *cover.Profile, merge *cover.Profile) error {
function mergeProfileBlock (line 85) | func mergeProfileBlock(p *cover.Profile, pb cover.ProfileBlock, startInd...
FILE: ginkgo/internal/profiles_and_reports.go
function AbsPathForGeneratedAsset (line 17) | func AbsPathForGeneratedAsset(assetName string, suite TestSuite, cliConf...
function FinalizeProfilesAndReportsForSuites (line 29) | func FinalizeProfilesAndReportsForSuites(suites TestSuites, cliConfig ty...
function MergeAndCleanupCoverProfiles (line 151) | func MergeAndCleanupCoverProfiles(profiles []string, destination string)...
function GetCoverageFromCoverProfile (line 175) | func GetCoverageFromCoverProfile(profile string) (float64, error) {
function MergeProfiles (line 195) | func MergeProfiles(profilePaths []string, destination string) error {
FILE: ginkgo/internal/run.go
function RunCompiledSuite (line 23) | func RunCompiledSuite(suite TestSuite, ginkgoConfig types.SuiteConfig, r...
function buildAndStartCommand (line 42) | func buildAndStartCommand(suite TestSuite, args []string, pipeToStdout b...
function checkForNoTestsWarning (line 59) | func checkForNoTestsWarning(buf *bytes.Buffer) bool {
function runGoTest (line 67) | func runGoTest(suite TestSuite, cliConfig types.CLIConfig, goFlagsConfig...
function runSerial (line 92) | func runSerial(suite TestSuite, ginkgoConfig types.SuiteConfig, reporter...
function runParallel (line 161) | func runParallel(suite TestSuite, ginkgoConfig types.SuiteConfig, report...
function runAfterRunHook (line 346) | func runAfterRunHook(command string, noColor bool, suite TestSuite) {
FILE: ginkgo/internal/test_suite.go
constant TIMEOUT_ELAPSED_FAILURE_REASON (line 16) | TIMEOUT_ELAPSED_FAILURE_REASON = "Suite did not run because the timeout ...
constant PRIOR_FAILURES_FAILURE_REASON (line 17) | PRIOR_FAILURES_FAILURE_REASON = "Suite did not run because prior suites ...
constant EMPTY_SKIP_FAILURE_REASON (line 18) | EMPTY_SKIP_FAILURE_REASON = "Suite did not run go test reported that no ...
type TestSuiteState (line 20) | type TestSuiteState
method Is (line 41) | func (state TestSuiteState) Is(states ...TestSuiteState) bool {
constant TestSuiteStateInvalid (line 23) | TestSuiteStateInvalid TestSuiteState = iota
constant TestSuiteStateUncompiled (line 25) | TestSuiteStateUncompiled
constant TestSuiteStateCompiled (line 26) | TestSuiteStateCompiled
constant TestSuiteStatePassed (line 28) | TestSuiteStatePassed
constant TestSuiteStateSkippedDueToEmptyCompilation (line 30) | TestSuiteStateSkippedDueToEmptyCompilation
constant TestSuiteStateSkippedByFilter (line 31) | TestSuiteStateSkippedByFilter
constant TestSuiteStateSkippedDueToPriorFailures (line 32) | TestSuiteStateSkippedDueToPriorFailures
constant TestSuiteStateFailed (line 34) | TestSuiteStateFailed
constant TestSuiteStateFailedDueToTimeout (line 35) | TestSuiteStateFailedDueToTimeout
constant TestSuiteStateFailedToCompile (line 36) | TestSuiteStateFailedToCompile
type TestSuite (line 51) | type TestSuite struct
method AbsPath (line 64) | func (ts TestSuite) AbsPath() string {
method NamespacedName (line 69) | func (ts TestSuite) NamespacedName() string {
type TestSuites (line 80) | type TestSuites
method AnyHaveProgrammaticFocus (line 82) | func (ts TestSuites) AnyHaveProgrammaticFocus() bool {
method ThatAreGinkgoSuites (line 92) | func (ts TestSuites) ThatAreGinkgoSuites() TestSuites {
method CountWithState (line 102) | func (ts TestSuites) CountWithState(states ...TestSuiteState) int {
method WithState (line 113) | func (ts TestSuites) WithState(states ...TestSuiteState) TestSuites {
method WithoutState (line 124) | func (ts TestSuites) WithoutState(states ...TestSuiteState) TestSuites {
method ShuffledCopy (line 135) | func (ts TestSuites) ShuffledCopy(seed int64) TestSuites {
function FindSuites (line 144) | func FindSuites(args []string, cliConfig types.CLIConfig, allowPrecompil...
function precompiledTestSuite (line 182) | func precompiledTestSuite(path string) (TestSuite, error) {
function suitesInDir (line 219) | func suitesInDir(dir string, recurse bool) TestSuites {
function relPath (line 253) | func relPath(dir string) string {
function packageNameForSuite (line 265) | func packageNameForSuite(dir string) string {
function filesHaveGinkgoSuite (line 270) | func filesHaveGinkgoSuite(dir string, files []os.DirEntry) bool {
FILE: ginkgo/internal/testsuite_test.go
function TS (line 13) | func TS(path string, pkgName string, isGinkgo bool, state TestSuiteState...
function PTS (line 23) | func PTS(path string, pkgName string, isGinkgo bool, pathToCompiledTest ...
FILE: ginkgo/internal/utils.go
function FileExists (line 13) | func FileExists(path string) bool {
function CopyFile (line 18) | func CopyFile(src string, dest string) error {
function GoFmt (line 49) | func GoFmt(path string) {
function PluralizedWord (line 56) | func PluralizedWord(singular, plural string, count int) string {
function FailedSuitesReport (line 63) | func FailedSuitesReport(suites TestSuites, f formatter.Formatter) string {
FILE: ginkgo/internal/verify_version.go
function VerifyCLIAndFrameworkVersion (line 15) | func VerifyCLIAndFrameworkVersion(suites TestSuites) {
FILE: ginkgo/labels/labels_command.go
function BuildLabelsCommand (line 18) | func BuildLabelsCommand() command.Command {
function ListLabels (line 38) | func ListLabels(args []string, cliConfig types.CLIConfig) {
function fetchLabelsFromPackage (line 53) | func fetchLabelsFromPackage(packagePath string) []string {
function fetchLabels (line 93) | func fetchLabels(callExpr *ast.CallExpr) []string {
FILE: ginkgo/main.go
function GenerateCommands (line 19) | func GenerateCommands() []command.Command {
function main (line 32) | func main() {
function BuildVersionCommand (line 48) | func BuildVersionCommand() command.Command {
FILE: ginkgo/outline/_testdata/suite_test.go
function TestExample (line 10) | func TestExample(t *testing.T) {
FILE: ginkgo/outline/ginkgo.go
constant undefinedTextAlt (line 13) | undefinedTextAlt = "undefined"
type ginkgoMetadata (line 17) | type ginkgoMetadata struct
type ginkgoNode (line 37) | type ginkgoNode struct
method PreOrder (line 44) | func (n *ginkgoNode) PreOrder(f walkFunc) {
method PostOrder (line 51) | func (n *ginkgoNode) PostOrder(f walkFunc) {
method Walk (line 58) | func (n *ginkgoNode) Walk(pre, post walkFunc) {
method PropagateInheritedProperties (line 68) | func (n *ginkgoNode) PropagateInheritedProperties() {
method BackpropagateUnfocus (line 87) | func (n *ginkgoNode) BackpropagateUnfocus() {
type walkFunc (line 42) | type walkFunc
function packageAndIdentNamesFromCallExpr (line 107) | func packageAndIdentNamesFromCallExpr(ce *ast.CallExpr) (string, string,...
function absoluteOffsetsForNode (line 131) | func absoluteOffsetsForNode(fset *token.FileSet, n ast.Node) (start, end...
function ginkgoNodeFromCallExpr (line 137) | func ginkgoNodeFromCallExpr(fset *token.FileSet, ce *ast.CallExpr, ginkg...
function textOrAltFromCallExpr (line 199) | func textOrAltFromCallExpr(ce *ast.CallExpr, alt string) string {
function textFromCallExpr (line 209) | func textFromCallExpr(ce *ast.CallExpr) (string, bool) {
function labelFromCallExpr (line 231) | func labelFromCallExpr(ce *ast.CallExpr) []string {
function extractLabels (line 255) | func extractLabels(expr *ast.CallExpr) []string {
function pendingFromCallExpr (line 276) | func pendingFromCallExpr(ce *ast.CallExpr) bool {
FILE: ginkgo/outline/import.go
function packageNameForImport (line 24) | func packageNameForImport(f *ast.File, path string) *string {
function importSpec (line 41) | func importSpec(f *ast.File, path string) *ast.ImportSpec {
function importPath (line 52) | func importPath(s *ast.ImportSpec) string {
FILE: ginkgo/outline/outline.go
constant ginkgoImportPath (line 18) | ginkgoImportPath = "github.com/onsi/ginkgo/v2"
function FromASTFile (line 22) | func FromASTFile(fset *token.FileSet, src *ast.File) (*outline, error) {
type outline (line 73) | type outline struct
method MarshalJSON (line 77) | func (o *outline) MarshalJSON() ([]byte, error) {
method String (line 83) | func (o *outline) String() string {
method StringIndent (line 89) | func (o *outline) StringIndent(width int) string {
FILE: ginkgo/outline/outline_command.go
constant indentWidth (line 16) | indentWidth = 4
constant stdinAlias (line 19) | stdinAlias = "-"
constant usageCommand (line 20) | usageCommand = "ginkgo outline <filename>"
type outlineConfig (line 23) | type outlineConfig struct
function BuildOutlineCommand (line 27) | func BuildOutlineCommand() command.Command {
function outlineFile (line 59) | func outlineFile(args []string, format string) {
FILE: ginkgo/outline/outline_suite_test.go
function TestOutline (line 10) | func TestOutline(t *testing.T) {
FILE: ginkgo/outline/outline_test.go
function ensureRecordsAreIdentical (line 101) | func ensureRecordsAreIdentical(csvOutlineFilename, jsonOutlineFilename s...
function flattenNodes (line 183) | func flattenNodes(nodes []ginkgoNode, flatNodes *[]ginkgoMetadata) {
FILE: ginkgo/performance/_fixtures/large_suite_fixture/large_suite_suite_test.go
function TestLargeSuiteFixture (line 10) | func TestLargeSuiteFixture(t *testing.T) {
FILE: ginkgo/performance/_fixtures/performance_fixture/performance.go
function main (line 12) | func main() {
FILE: ginkgo/performance/_fixtures/performance_fixture/performance_suite_test.go
function TestPerformanceFixture (line 12) | func TestPerformanceFixture(t *testing.T) {
FILE: ginkgo/performance/_fixtures/performance_fixture/pkg1/pkg1_suite_test.go
function TestPkg1 (line 16) | func TestPkg1(t *testing.T) {
FILE: ginkgo/performance/_fixtures/performance_fixture/pkg2/pkg2_suite_test.go
function TestPkg2 (line 16) | func TestPkg2(t *testing.T) {
FILE: ginkgo/performance/_fixtures/performance_fixture/pkg3/pkg3_suite_test.go
function TestPkg3 (line 16) | func TestPkg3(t *testing.T) {
FILE: ginkgo/performance/_fixtures/performance_fixture/pkg4/pkg4_suite_test.go
function TestPkg4 (line 16) | func TestPkg4(t *testing.T) {
FILE: ginkgo/performance/large_suite_test.go
function LoadOrCreate (line 13) | func LoadOrCreate(cache gmeasure.ExperimentCache, name string, version i...
FILE: ginkgo/performance/performance_suite_test.go
function init (line 30) | func init() {
function TestPerformance (line 34) | func TestPerformance(t *testing.T) {
type GoModCacheManager (line 57) | type GoModCacheManager struct
method Clear (line 76) | func (m GoModCacheManager) Clear() {
method Cleanup (line 83) | func (m GoModCacheManager) Cleanup() {
function NewGoModCacheManager (line 62) | func NewGoModCacheManager(path string) GoModCacheManager {
type PerformanceFixtureManager (line 93) | type PerformanceFixtureManager struct
method Cleanup (line 105) | func (f PerformanceFixtureManager) Cleanup() {
method MountFixture (line 109) | func (f PerformanceFixtureManager) MountFixture(fixture string, subPac...
method copyIn (line 121) | func (f PerformanceFixtureManager) copyIn(src string, dst string) {
method PathTo (line 141) | func (f PerformanceFixtureManager) PathTo(pkg string, target ...string...
function NewPerformanceFixtureManager (line 97) | func NewPerformanceFixtureManager(tmpDir string) PerformanceFixtureManag...
function GoModDownload (line 150) | func GoModDownload(fixture string) {
type ScenarioSettings (line 159) | type ScenarioSettings struct
method Name (line 176) | func (s ScenarioSettings) Name() string {
function SampleScenarios (line 212) | func SampleScenarios(cache gmeasure.ExperimentCache, numSamples int, cac...
function AnalyzeCache (line 248) | func AnalyzeCache(cache gmeasure.ExperimentCache) {
function RunScenario (line 266) | func RunScenario(stopwatch *gmeasure.Stopwatch, settings ScenarioSetting...
function RunScenarioWithGinkgoInternals (line 284) | func RunScenarioWithGinkgoInternals(stopwatch *gmeasure.Stopwatch, setti...
function RunScenarioWithGoTest (line 352) | func RunScenarioWithGoTest(stopwatch *gmeasure.Stopwatch, settings Scena...
function ginkgoCommand (line 431) | func ginkgoCommand(dir string, args ...string) *exec.Cmd {
function startGinkgo (line 438) | func startGinkgo(dir string, args ...string) *gexec.Session {
function startGinkgoWithEnv (line 445) | func startGinkgoWithEnv(dir string, env []string, args ...string) *gexec...
FILE: ginkgo/run/run_command.go
function BuildRunCommand (line 16) | func BuildRunCommand() command.Command {
type SpecRunner (line 57) | type SpecRunner struct
method RunSpecs (line 67) | func (r *SpecRunner) RunSpecs(args []string, additionalArgs []string) {
function orcMessage (line 203) | func orcMessage(iteration int) string {
FILE: ginkgo/unfocus/unfocus_command.go
function BuildUnfocusCommand (line 18) | func BuildUnfocusCommand() command.Command {
function unfocusSpecs (line 30) | func unfocusSpecs() {
function unfocusDir (line 55) | func unfocusDir(goFiles chan string, path string) {
function shouldProcessDir (line 72) | func shouldProcessDir(basename string) bool {
function shouldProcessFile (line 76) | func shouldProcessFile(basename string) bool {
function unfocusFile (line 80) | func unfocusFile(path string) {
function writeBackup (line 113) | func writeBackup(path string, data []byte) (string, error) {
function updateFile (line 128) | func updateFile(path string, data []byte, eliminations [][]int64) error {
function scanForFocus (line 157) | func scanForFocus(file *ast.File) (eliminations [][]int64) {
function isFocus (line 179) | func isFocus(name string) bool {
FILE: ginkgo/watch/delta.go
type Delta (line 5) | type Delta struct
method ModifiedSuites (line 19) | func (d Delta) ModifiedSuites() []*Suite {
type DescendingByDelta (line 13) | type DescendingByDelta
method Len (line 15) | func (a DescendingByDelta) Len() int { return len(a) }
method Swap (line 16) | func (a DescendingByDelta) Swap(i, j int) { a[i], a[j] = a[j], a[...
method Less (line 17) | func (a DescendingByDelta) Less(i, j int) bool { return a[i].Delta() >...
FILE: ginkgo/watch/delta_tracker.go
type SuiteErrors (line 11) | type SuiteErrors
type DeltaTracker (line 13) | type DeltaTracker struct
method Delta (line 29) | func (d *DeltaTracker) Delta(suites internal.TestSuites) (delta Delta,...
method WillRun (line 68) | func (d *DeltaTracker) WillRun(suite internal.TestSuite) error {
function NewDeltaTracker (line 20) | func NewDeltaTracker(maxDepth int, watchRegExp *regexp.Regexp) *DeltaTra...
FILE: ginkgo/watch/dependencies.go
type Dependencies (line 8) | type Dependencies struct
method Dependencies (line 37) | func (d Dependencies) Dependencies() map[string]int {
method seedWithDepsForPackageAtPath (line 41) | func (d Dependencies) seedWithDepsForPackageAtPath(path string) error {
method addDepsForDepth (line 55) | func (d Dependencies) addDepsForDepth(depth int) {
method addDepsForDep (line 63) | func (d Dependencies) addDepsForDep(dep string, depth int) {
method resolveAndAdd (line 72) | func (d Dependencies) resolveAndAdd(deps []string, depth int) {
method addDepIfNotPresent (line 84) | func (d Dependencies) addDepIfNotPresent(dep string, depth int) {
function NewDependencies (line 12) | func NewDependencies(path string, maxDepth int) (Dependencies, error) {
function matchesGinkgoOrGomega (line 91) | func matchesGinkgoOrGomega(s string) bool {
function matchesGinkgoIntegration (line 95) | func matchesGinkgoIntegration(s string) bool {
FILE: ginkgo/watch/package_hash.go
type PackageHash (line 13) | type PackageHash struct
method CheckForChanges (line 35) | func (p *PackageHash) CheckForChanges() bool {
method computeHashes (line 65) | func (p *PackageHash) computeHashes() (codeHash string, codeModifiedTi...
method hashForFileInfo (line 115) | func (p *PackageHash) hashForFileInfo(info os.FileInfo) string {
function NewPackageHash (line 24) | func NewPackageHash(path string, watchRegExp *regexp.Regexp) *PackageHash {
function isHiddenFile (line 111) | func isHiddenFile(info os.FileInfo) bool {
FILE: ginkgo/watch/package_hashes.go
type PackageHashes (line 9) | type PackageHashes struct
method CheckForChanges (line 25) | func (p *PackageHashes) CheckForChanges() []string {
method Add (line 40) | func (p *PackageHashes) Add(path string) *PackageHash {
method Get (line 56) | func (p *PackageHashes) Get(path string) *PackageHash {
method StartTrackingUsage (line 67) | func (p *PackageHashes) StartTrackingUsage() {
method StopTrackingUsageAndPrune (line 74) | func (p *PackageHashes) StopTrackingUsageAndPrune() {
function NewPackageHashes (line 16) | func NewPackageHashes(watchRegExp *regexp.Regexp) *PackageHashes {
FILE: ginkgo/watch/suite.go
type Suite (line 11) | type Suite struct
method Delta (line 38) | func (s *Suite) Delta() float64 {
method MarkAsRunAndRecomputedDependencies (line 46) | func (s *Suite) MarkAsRunAndRecomputedDependencies(maxDepth int) error {
method Description (line 64) | func (s *Suite) Description() string {
method delta (line 73) | func (s *Suite) delta(packagePath string, includeTests bool, depth int...
method dt (line 77) | func (s *Suite) dt(packagePath string, includeTests bool) time.Duration {
function NewSuite (line 19) | func NewSuite(suite internal.TestSuite, maxDepth int, sharedPackageHashe...
FILE: ginkgo/watch/watch_command.go
function BuildWatchCommand (line 15) | func BuildWatchCommand() command.Command {
type SpecWatcher (line 55) | type SpecWatcher struct
method WatchSpecs (line 65) | func (w *SpecWatcher) WatchSpecs(args []string, additionalArgs []strin...
method compileAndRun (line 155) | func (w *SpecWatcher) compileAndRun(suite internal.TestSuite, addition...
method computeSuccinctMode (line 169) | func (w *SpecWatcher) computeSuccinctMode(numSuites int) {
method updateSeed (line 188) | func (w *SpecWatcher) updateSeed() {
FILE: ginkgo_t_dsl.go
function GinkgoT (line 27) | func GinkgoT(optionalOffset ...int) FullGinkgoTInterface {
type GinkgoTInterface (line 51) | type GinkgoTInterface interface
type FullGinkgoTInterface (line 80) | type FullGinkgoTInterface interface
function GinkgoTB (line 120) | func GinkgoTB(optionalOffset ...int) *GinkgoTBWrapper {
type GinkgoTBWrapper (line 128) | type GinkgoTBWrapper struct
method Cleanup (line 133) | func (g *GinkgoTBWrapper) Cleanup(f func()) {
method Chdir (line 136) | func (g *GinkgoTBWrapper) Chdir(dir string) {
method Context (line 139) | func (g *GinkgoTBWrapper) Context() context.Context {
method Error (line 142) | func (g *GinkgoTBWrapper) Error(args ...any) {
method Errorf (line 145) | func (g *GinkgoTBWrapper) Errorf(format string, args ...any) {
method Fail (line 148) | func (g *GinkgoTBWrapper) Fail() {
method FailNow (line 151) | func (g *GinkgoTBWrapper) FailNow() {
method Failed (line 154) | func (g *GinkgoTBWrapper) Failed() bool {
method Fatal (line 157) | func (g *GinkgoTBWrapper) Fatal(args ...any) {
method Fatalf (line 160) | func (g *GinkgoTBWrapper) Fatalf(format string, args ...any) {
method Helper (line 163) | func (g *GinkgoTBWrapper) Helper() {
method Log (line 166) | func (g *GinkgoTBWrapper) Log(args ...any) {
method Logf (line 169) | func (g *GinkgoTBWrapper) Logf(format string, args ...any) {
method Name (line 172) | func (g *GinkgoTBWrapper) Name() string {
method Setenv (line 175) | func (g *GinkgoTBWrapper) Setenv(key, value string) {
method Skip (line 178) | func (g *GinkgoTBWrapper) Skip(args ...any) {
method SkipNow (line 181) | func (g *GinkgoTBWrapper) SkipNow() {
method Skipf (line 184) | func (g *GinkgoTBWrapper) Skipf(format string, args ...any) {
method Skipped (line 187) | func (g *GinkgoTBWrapper) Skipped() bool {
method TempDir (line 190) | func (g *GinkgoTBWrapper) TempDir() string {
method Attr (line 193) | func (g *GinkgoTBWrapper) Attr(key, value string) {
method Output (line 196) | func (g *GinkgoTBWrapper) Output() io.Writer {
FILE: integration/_fixtures/abort_fixture/abort_fixture_suite_test.go
function TestAbortFixture (line 11) | func TestAbortFixture(t *testing.T) {
FILE: integration/_fixtures/after_run_hook_fixture/after_run_hook.go
function Tested (line 3) | func Tested() string {
function Untested (line 7) | func Untested() string {
FILE: integration/_fixtures/after_run_hook_fixture/after_run_hook_suite_test.go
function TestAfterRunHook (line 10) | func TestAfterRunHook(t *testing.T) {
FILE: integration/_fixtures/build_reporting_fixture/suite1/build_reporting_1_suite_test.go
function TestAfterRunHook (line 10) | func TestAfterRunHook(t *testing.T) {
FILE: integration/_fixtures/build_reporting_fixture/suite2/build_reporting_2_suite_test.go
function TestAfterRunHook (line 10) | func TestAfterRunHook(t *testing.T) {
FILE: integration/_fixtures/combined_coverage_fixture/first_package/coverage.go
function A (line 3) | func A() string {
function B (line 7) | func B() string {
function C (line 11) | func C() string {
function D (line 15) | func D() string {
function E (line 19) | func E() string {
FILE: integration/_fixtures/combined_coverage_fixture/first_package/coverage_fixture_suite_test.go
function TestCoverageFixture (line 10) | func TestCoverageFixture(t *testing.T) {
FILE: integration/_fixtures/combined_coverage_fixture/first_package/external_coverage/external_coverage.go
function Tested (line 3) | func Tested() string {
function Untested (line 7) | func Untested() string {
FILE: integration/_fixtures/combined_coverage_fixture/second_package/coverage.go
function A (line 3) | func A() string {
function B (line 7) | func B() string {
function C (line 11) | func C() string {
function D (line 15) | func D() string {
function E (line 19) | func E() string {
FILE: integration/_fixtures/combined_coverage_fixture/second_package/coverage_fixture_suite_test.go
function TestCoverageFixture (line 10) | func TestCoverageFixture(t *testing.T) {
FILE: integration/_fixtures/combined_coverage_fixture/third_package/third_package_suite_test.go
function TestThirdPackage (line 10) | func TestThirdPackage(t *testing.T) {
FILE: integration/_fixtures/config_override_label_filter_fixture/config_override_fixture_suite_test.go
function TestConfigOverrideFixture (line 10) | func TestConfigOverrideFixture(t *testing.T) {
FILE: integration/_fixtures/config_override_must_pass_repeatedly_fixture/config_override_fixture_suite_test.go
function TestConfigOverrideFixture (line 10) | func TestConfigOverrideFixture(t *testing.T) {
FILE: integration/_fixtures/coverage_fixture/additional_spec/additional_spec_suite_test.go
function TestAdditionalSpecSuite (line 13) | func TestAdditionalSpecSuite(t *testing.T) {
FILE: integration/_fixtures/coverage_fixture/coverage.go
function A (line 7) | func A() string {
function B (line 11) | func B() string {
function C (line 15) | func C() string {
function D (line 19) | func D() string {
function E (line 23) | func E() string {
FILE: integration/_fixtures/coverage_fixture/coverage_fixture_suite_test.go
function TestCoverageFixture (line 10) | func TestCoverageFixture(t *testing.T) {
FILE: integration/_fixtures/coverage_fixture/external_coverage/external_coverage.go
function Tested (line 3) | func Tested() string {
function TestedByAdditional (line 7) | func TestedByAdditional() string {
FILE: integration/_fixtures/decorations_fixture/flaky_repeated/flaky_repeated_fixture_suite_test.go
function TestDecorationsFixture (line 11) | func TestDecorationsFixture(t *testing.T) {
FILE: integration/_fixtures/decorations_fixture/invalid_decorations_flakeattempts_mustpassrepeatedly/invalid_decorations_flakeattempts_mustpassrepeatedly_suite_test.go
function TestInvalidDecorations (line 10) | func TestInvalidDecorations(t *testing.T) {
FILE: integration/_fixtures/decorations_fixture/invalid_decorations_focused_pending/invalid_decorations_focused_pending_suite_test.go
function TestInvalidDecorations (line 10) | func TestInvalidDecorations(t *testing.T) {
FILE: integration/_fixtures/decorations_fixture/offset_focus_pending/never_see_this_file_test.go
function OffsetIt (line 5) | func OffsetIt() {
FILE: integration/_fixtures/decorations_fixture/offset_focus_pending/offset_focus_pending_fixture_suite_test.go
function TestDecorationsFixture (line 10) | func TestDecorationsFixture(t *testing.T) {
FILE: integration/_fixtures/deprecated_features_fixture/deprecated_features_fixture_suite_test.go
function TestDeprecatedFeaturesFixture (line 10) | func TestDeprecatedFeaturesFixture(t *testing.T) {
FILE: integration/_fixtures/does_not_compile_fixture/does_not_compile_suite_test.go
function TestDoes_not_compile (line 10) | func TestDoes_not_compile(t *testing.T) {
FILE: integration/_fixtures/eventually_failing_fixture/eventually_failing_suite_test.go
function TestEventuallyFailing (line 10) | func TestEventuallyFailing(t *testing.T) {
FILE: integration/_fixtures/exiting_synchronized_setup_fixture/exiting_synchronized_setup_suite_test.go
function TestSynchronized_setup (line 12) | func TestSynchronized_setup(t *testing.T) {
FILE: integration/_fixtures/fail_fixture/fail_fixture_suite_test.go
function TestFail_fixture (line 10) | func TestFail_fixture(t *testing.T) {
FILE: integration/_fixtures/fail_then_hang_fixture/fail_then_hang_fixture_suite_test.go
function TestFailThenHangFixture (line 11) | func TestFailThenHangFixture(t *testing.T) {
FILE: integration/_fixtures/failing_ginkgo_tests_fixture/failing_ginkgo_tests.go
function AlwaysFalse (line 3) | func AlwaysFalse() bool {
FILE: integration/_fixtures/failing_ginkgo_tests_fixture/failing_ginkgo_tests_suite_test.go
function TestFailing_ginkgo_tests (line 10) | func TestFailing_ginkgo_tests(t *testing.T) {
FILE: integration/_fixtures/filter_fixture/filter_suite_test.go
function TestFilterFixture (line 10) | func TestFilterFixture(t *testing.T) {
FILE: integration/_fixtures/flags_fixture/flags.go
function Tested (line 3) | func Tested() string {
function Untested (line 7) | func Untested() string {
FILE: integration/_fixtures/flags_fixture/flags_suite_test.go
function TestFlags (line 10) | func TestFlags(t *testing.T) {
FILE: integration/_fixtures/flags_fixture/flags_test.go
function init (line 16) | func init() {
FILE: integration/_fixtures/focused_fixture/focused_fixture_suite_test.go
function TestFocused_fixture (line 10) | func TestFocused_fixture(t *testing.T) {
FILE: integration/_fixtures/focused_fixture/internal/focused_fixture_suite_test.go
function TestFocused_fixture (line 10) | func TestFocused_fixture(t *testing.T) {
FILE: integration/_fixtures/focused_with_vendor_fixture/focused_fixture_suite_test.go
function TestFocused_fixture (line 10) | func TestFocused_fixture(t *testing.T) {
FILE: integration/_fixtures/focused_with_vendor_fixture/vendor/foo/bar/bar.go
function FContext (line 3) | func FContext() {
FILE: integration/_fixtures/focused_with_vendor_fixture/vendor/foo/foo.go
function FIt (line 3) | func FIt() {
FILE: integration/_fixtures/focused_with_vendor_fixture/vendor/vendored.go
function FDescribe (line 3) | func FDescribe() int {
FILE: integration/_fixtures/hanging_fixture/hanging_suite_test.go
function TestHangingSuite (line 10) | func TestHangingSuite(t *testing.T) {
FILE: integration/_fixtures/interceptor_fixture/interceptor_fixture_suite_test.go
function TestInterceptorFixture (line 15) | func TestInterceptorFixture(t *testing.T) {
FILE: integration/_fixtures/interceptor_fixture/main.go
function main (line 9) | func main() {
FILE: integration/_fixtures/interceptor_sleep_fixture/interceptor_fixture_suite_test.go
function TestInterceptorSleepFixture (line 13) | func TestInterceptorSleepFixture(t *testing.T) {
FILE: integration/_fixtures/labels_fixture/labels.go
function Labels (line 5) | func Labels(labels ...string) []string {
FILE: integration/_fixtures/labels_fixture/labels_fixture_suite_test.go
function TestLabelsFixture (line 10) | func TestLabelsFixture(t *testing.T) {
FILE: integration/_fixtures/labels_fixture/nolabels/nolabels_suite_test.go
function TestNolabels (line 10) | func TestNolabels(t *testing.T) {
FILE: integration/_fixtures/labels_fixture/onepkg/onepkg.go
function Stuff (line 3) | func Stuff() {}
FILE: integration/_fixtures/labels_fixture/onepkg/onepkg_suite_test.go
function TestOnepkg (line 10) | func TestOnepkg(t *testing.T) {
FILE: integration/_fixtures/large_fixture/large_fixture_suite_test.go
function TestLargeFixture (line 11) | func TestLargeFixture(t *testing.T) {
FILE: integration/_fixtures/malformed_by_fixture/malformed_by_fixture_suite_test.go
function TestMalformedFixture (line 10) | func TestMalformedFixture(t *testing.T) {
FILE: integration/_fixtures/malformed_fixture/malformed_fixture_suite_test.go
function TestMalformedFixture (line 10) | func TestMalformedFixture(t *testing.T) {
FILE: integration/_fixtures/more_ginkgo_tests_fixture/more_ginkgo_tests.go
function AlwaysTrue (line 3) | func AlwaysTrue() bool {
FILE: integration/_fixtures/more_ginkgo_tests_fixture/more_ginkgo_tests_suite_test.go
function TestMore_ginkgo_tests (line 10) | func TestMore_ginkgo_tests(t *testing.T) {
FILE: integration/_fixtures/no_tagged_tests_fixture/no_tagged_tests_fixture_suite_test.go
function TestNoTaggedTestsFixture (line 12) | func TestNoTaggedTestsFixture(t *testing.T) {
FILE: integration/_fixtures/no_test_fn_fixture/no_test_fn.go
function StringIdentity (line 3) | func StringIdentity(a string) string {
FILE: integration/_fixtures/no_tests_fixture/no_tests.go
function main (line 3) | func main() {
FILE: integration/_fixtures/nondeterministic_fixture/nondeterministic_fixture_suite_test.go
function TestNondeterministicFixture (line 12) | func TestNondeterministicFixture(t *testing.T) {
FILE: integration/_fixtures/ordered_fixture/ordered_fixture_suite_test.go
function init (line 13) | func init() {
function TestOrderedFixture (line 19) | func TestOrderedFixture(t *testing.T) {
FILE: integration/_fixtures/passing_ginkgo_tests_fixture/passing_ginkgo_tests.go
function StringIdentity (line 3) | func StringIdentity(a string) string {
function IntegerIdentity (line 7) | func IntegerIdentity(a int) int {
FILE: integration/_fixtures/passing_ginkgo_tests_fixture/passing_ginkgo_tests_suite_test.go
function TestPassing_ginkgo_tests (line 10) | func TestPassing_ginkgo_tests(t *testing.T) {
FILE: integration/_fixtures/pause_resume_interception_fixture/pause_resume_interception_fixture_suite_test.go
function TestPauseResumeInterceptionFixture (line 11) | func TestPauseResumeInterceptionFixture(t *testing.T) {
FILE: integration/_fixtures/preview_fixture/preview_fixture_suite_test.go
function TestPreviewFixture (line 12) | func TestPreviewFixture(t *testing.T) {
FILE: integration/_fixtures/profile_fixture/block_contest/block_contest.go
function ReadTheChannel (line 3) | func ReadTheChannel(c chan bool) {
function SlowReadTheChannel (line 7) | func SlowReadTheChannel(c chan bool) {
FILE: integration/_fixtures/profile_fixture/block_contest/block_contest_suite_test.go
function TestBlockContest (line 13) | func TestBlockContest(t *testing.T) {
FILE: integration/_fixtures/profile_fixture/lock_contest/lock_contest.go
function WaitForLock (line 7) | func WaitForLock(l *sync.Mutex) {
function SlowWaitForLock (line 12) | func SlowWaitForLock(l *sync.Mutex) {
FILE: integration/_fixtures/profile_fixture/lock_contest/lock_contest_suite_test.go
function TestLockContest (line 14) | func TestLockContest(t *testing.T) {
FILE: integration/_fixtures/profile_fixture/slow_memory_hog/slow_memory_hog.go
function SomethingExpensive (line 5) | func SomethingExpensive(n int) string {
function doubleArrrr (line 13) | func doubleArrrr(in []string) []string {
FILE: integration/_fixtures/profile_fixture/slow_memory_hog/slow_memory_hog_suite_test.go
function TestSlowMemoryHog (line 12) | func TestSlowMemoryHog(t *testing.T) {
FILE: integration/_fixtures/progress_report_fixture/progress_report_fixture_suite_test.go
function TestProgressReportFixture (line 10) | func TestProgressReportFixture(t *testing.T) {
FILE: integration/_fixtures/report_entries_fixture/report_entries_fixture_suite_test.go
function TestReportEntriesFixture (line 12) | func TestReportEntriesFixture(t *testing.T) {
type StringerStruct (line 17) | type StringerStruct struct
method ColorableString (line 22) | func (s StringerStruct) ColorableString() string {
FILE: integration/_fixtures/reporting_fixture/malformed_sub_package/malformed_sub_package_suite_test.go
function TestMalformedSubPackage (line 10) | func TestMalformedSubPackage(t *testing.T) {
FILE: integration/_fixtures/reporting_fixture/nonginkgo_sub_package/a_test.go
function TestA (line 5) | func TestA(t *testing.T) {
FILE: integration/_fixtures/reporting_fixture/reporting_fixture_suite_test.go
function TestReportingFixture (line 13) | func TestReportingFixture(t *testing.T) {
FILE: integration/_fixtures/reporting_fixture/reporting_sub_package/reporting_sub_package_suite_test.go
function TestReportingSubPackage (line 10) | func TestReportingSubPackage(t *testing.T) {
FILE: integration/_fixtures/rerun_specs_fixture/rerun_specs_suite_test.go
function TestRerunSpecs (line 10) | func TestRerunSpecs(t *testing.T) {
FILE: integration/_fixtures/seed_fixture/seed_fixture_suite_test.go
function TestSeedFixture (line 10) | func TestSeedFixture(t *testing.T) {
FILE: integration/_fixtures/semver_fixture/semver_fixture_suite_test.go
function TestSemverFixture (line 10) | func TestSemverFixture(t *testing.T) {
FILE: integration/_fixtures/semver_fixture/spechierarchy/spechierarchy_suite_test.go
function TestSpecHierarchy (line 10) | func TestSpecHierarchy(t *testing.T) {
FILE: integration/_fixtures/serial_fixture/serial_fixture_suite_test.go
function init (line 19) | func init() {
function TestSerialFixture (line 25) | func TestSerialFixture(t *testing.T) {
FILE: integration/_fixtures/skip_fixture/skip_fixture_suite_test.go
function TestSkip_fixture (line 10) | func TestSkip_fixture(t *testing.T) {
FILE: integration/_fixtures/symbol_fixture/symbol_fixture_suite_test.go
function TestSymbolFixture (line 12) | func TestSymbolFixture(t *testing.T) {
FILE: integration/_fixtures/synchronized_setup_tests_fixture/synchronized_setup_tests_suite_test.go
function TestSynchronized_setup_tests (line 12) | func TestSynchronized_setup_tests(t *testing.T) {
FILE: integration/_fixtures/tags_fixture/tags_tests_suite_test.go
function TestTagsTests (line 10) | func TestTagsTests(t *testing.T) {
FILE: integration/_fixtures/timeline_fixture/timeline_fixture_suite_test.go
function TestTimelineFixture (line 12) | func TestTimelineFixture(t *testing.T) {
FILE: integration/_fixtures/timeout_fixture/timeout_A/timeout_A_suite_test.go
function TestTimeoutA (line 11) | func TestTimeoutA(t *testing.T) {
FILE: integration/_fixtures/timeout_fixture/timeout_B/timeout_B_suite_test.go
function TestTimeoutB (line 11) | func TestTimeoutB(t *testing.T) {
FILE: integration/_fixtures/timeout_fixture/timeout_C/timeout_C_suite_test.go
function TestTimeoutC (line 11) | func TestTimeoutC(t *testing.T) {
FILE: integration/_fixtures/timeout_fixture/timeout_D/timeout_D_suite_test.go
function TestTimeoutD (line 11) | func TestTimeoutD(t *testing.T) {
FILE: integration/_fixtures/version_mismatch_fixture/version_mismatch_fixture_suite_test.go
function TestVersionMismatchFixture (line 10) | func TestVersionMismatchFixture(t *testing.T) {
FILE: integration/_fixtures/watch_fixture/A/A.go
function DoIt (line 5) | func DoIt() string {
FILE: integration/_fixtures/watch_fixture/A/A_suite_test.go
function TestA (line 10) | func TestA(t *testing.T) {
FILE: integration/_fixtures/watch_fixture/B/B.go
function DoIt (line 5) | func DoIt() string {
FILE: integration/_fixtures/watch_fixture/B/B_suite_test.go
function TestB (line 10) | func TestB(t *testing.T) {
FILE: integration/_fixtures/watch_fixture/C/C.go
function DoIt (line 3) | func DoIt() string {
FILE: integration/_fixtures/watch_fixture/C/C_suite_test.go
function TestC (line 10) | func TestC(t *testing.T) {
FILE: integration/_fixtures/watch_fixture/D/D.go
function DoIt (line 5) | func DoIt() string {
FILE: integration/_fixtures/watch_fixture/D/D_suite_test.go
function TestD (line 10) | func TestD(t *testing.T) {
FILE: integration/_fixtures/xunit_fixture/xunit_tests.go
function AlwaysTrue (line 3) | func AlwaysTrue() bool {
FILE: integration/_fixtures/xunit_fixture/xunit_tests_test.go
function TestAlwaysTrue (line 7) | func TestAlwaysTrue(t *testing.T) {
FILE: integration/integration_suite_test.go
function init (line 31) | func init() {
function TestIntegration (line 35) | func TestIntegration(t *testing.T) {
type FixtureManager (line 66) | type FixtureManager struct
method Cleanup (line 78) | func (f FixtureManager) Cleanup() {
method MountFixture (line 82) | func (f FixtureManager) MountFixture(fixture string, subPackage ...str...
method MkEmpty (line 94) | func (f FixtureManager) MkEmpty(pkg string) {
method copyAndRewrite (line 98) | func (f FixtureManager) copyAndRewrite(src string, dst string) {
method AbsPathTo (line 121) | func (f FixtureManager) AbsPathTo(pkg string, target ...string) string {
method PathTo (line 127) | func (f FixtureManager) PathTo(pkg string, target ...string) string {
method PathToFixtureFile (line 135) | func (f FixtureManager) PathToFixtureFile(pkg string, target string) s...
method WriteFile (line 139) | func (f FixtureManager) WriteFile(pkg string, target string, content s...
method AppendToFile (line 145) | func (f FixtureManager) AppendToFile(pkg string, target string, conten...
method ContentOf (line 150) | func (f FixtureManager) ContentOf(pkg string, target string) string {
method ListDir (line 156) | func (f FixtureManager) ListDir(pkg string, target ...string) []string {
method LoadJSONReports (line 167) | func (f FixtureManager) LoadJSONReports(pkg string, target string) []t...
method LoadJUnitReport (line 174) | func (f FixtureManager) LoadJUnitReport(pkg string, target string) rep...
method ContentOfFixture (line 181) | func (f FixtureManager) ContentOfFixture(pkg string, target string) st...
method RemoveFile (line 187) | func (f FixtureManager) RemoveFile(pkg string, target string) {
method PackageRoot (line 191) | func (f FixtureManager) PackageRoot() string {
method PackageNameFor (line 195) | func (f FixtureManager) PackageNameFor(target string) string {
function NewFixtureManager (line 70) | func NewFixtureManager(tmpDir string) FixtureManager {
function sameFile (line 199) | func sameFile(filePath, otherFilePath string) bool {
function sameFolder (line 208) | func sameFolder(sourcePath, destinationPath string) bool {
function ginkgoCommand (line 223) | func ginkgoCommand(dir string, args ...string) *exec.Cmd {
function startGinkgo (line 230) | func startGinkgo(dir string, args ...string) *gexec.Session {
function raceDetectorSupported (line 237) | func raceDetectorSupported() bool {
FILE: integration/profiling_go1.21_test.go
constant lockContestPrefix (line 6) | lockContestPrefix = "lock_contest_test.glob.."
FILE: integration/profiling_go1.22_test.go
constant lockContestPrefix (line 6) | lockContestPrefix = "lock_contest_test.init."
FILE: integration/profiling_test.go
type ProfileLine (line 20) | type ProfileLine struct
type ProfileLines (line 26) | type ProfileLines
method FindCaller (line 28) | func (lines ProfileLines) FindCaller(caller string) ProfileLine {
function ParseProfile (line 41) | func ParseProfile(binary string, path string) ProfileLines {
FILE: integration/repeat_test.go
function extractRandomSeeds (line 12) | func extractRandomSeeds(content string) []string {
FILE: internal/around_node.go
function ComputeAroundNodes (line 7) | func ComputeAroundNodes(specs Specs) Specs {
FILE: internal/counter.go
function MakeIncrementingIndexCounter (line 3) | func MakeIncrementingIndexCounter() func() (int, error) {
FILE: internal/failer.go
type Failer (line 10) | type Failer struct
method GetState (line 23) | func (f *Failer) GetState() types.SpecState {
method GetFailure (line 29) | func (f *Failer) GetFailure() types.Failure {
method Panic (line 35) | func (f *Failer) Panic(location types.CodeLocation, forwardedPanic any) {
method Fail (line 49) | func (f *Failer) Fail(message string, location types.CodeLocation) {
method Skip (line 62) | func (f *Failer) Skip(message string, location types.CodeLocation) {
method AbortSuite (line 75) | func (f *Failer) AbortSuite(message string, location types.CodeLocatio...
method Drain (line 88) | func (f *Failer) Drain() (types.SpecState, types.Failure) {
function NewFailer (line 16) | func NewFailer() *Failer {
FILE: internal/focus.go
function ApplyNestedFocusPolicyToTree (line 28) | func ApplyNestedFocusPolicyToTree(tree *TreeNode) {
function ApplyFocusToSpecs (line 59) | func ApplyFocusToSpecs(specs Specs, description string, suiteLabels Labe...
FILE: internal/global/init.go
function init (line 11) | func init() {
function InitializeGlobals (line 15) | func InitializeGlobals() {
function PushClone (line 20) | func PushClone() error {
function PopClone (line 26) | func PopClone() {
FILE: internal/group.go
type runOncePair (line 10) | type runOncePair struct
method isZero (line 18) | func (pair runOncePair) isZero() bool {
function runOncePairForNode (line 22) | func runOncePairForNode(node Node, containerID uint) runOncePair {
type runOncePairs (line 30) | type runOncePairs
method runOncePairFor (line 55) | func (pairs runOncePairs) runOncePairFor(nodeID uint) runOncePair {
method hasRunOncePair (line 64) | func (pairs runOncePairs) hasRunOncePair(pair runOncePair) bool {
method withType (line 73) | func (pairs runOncePairs) withType(nodeTypes types.NodeType) runOncePa...
function runOncePairsForSpec (line 32) | func runOncePairsForSpec(spec Spec) runOncePairs {
type group (line 91) | type group struct
method initialReportForSpec (line 114) | func (g *group) initialReportForSpec(spec Spec) types.SpecReport {
method evaluateSkipStatus (line 166) | func (g *group) evaluateSkipStatus(spec Spec) (types.SpecState, types....
method isLastSpecWithPair (line 200) | func (g *group) isLastSpecWithPair(specID uint, pair runOncePair) bool {
method attemptSpec (line 214) | func (g *group) attemptSpec(isFinalAttempt bool, spec Spec) bool {
method run (line 336) | func (g *group) run(specs Specs) {
function newGroup (line 102) | func newGroup(suite *Suite) *group {
function constructionNodeReportForTreeNode (line 139) | func constructionNodeReportForTreeNode(node *TreeNode) *types.Constructi...
function addNodeToReportForNode (line 148) | func addNodeToReportForNode(report *types.ConstructionNodeReport, node *...
FILE: internal/internal_integration/around_node_test.go
function AN (line 13) | func AN(run string) types.AroundNodeDecorator {
FILE: internal/internal_integration/internal_integration_suite_test.go
function TestSuiteTests (line 22) | func TestSuiteTests(t *testing.T) {
function progressSignalRegistrar (line 46) | func progressSignalRegistrar(handler func()) context.CancelFunc {
function noopProgressSignalRegistrar (line 51) | func noopProgressSignalRegistrar(_ func()) context.CancelFunc {
function WithSuite (line 75) | func WithSuite(suite *internal.Suite, callback func()) {
function SetUpForParallel (line 84) | func SetUpForParallel(parallelTotal int) {
function RunFixture (line 91) | func RunFixture(description string, callback func(), aroundNodes ...type...
function RunFixtureInParallel (line 111) | func RunFixtureInParallel(description string, callback func(proc int)) b...
function F (line 144) | func F(options ...any) {
function Abort (line 159) | func Abort(options ...any) {
function FixtureSkip (line 174) | func FixtureSkip(options ...any) {
function HaveHighlightedStackLine (line 189) | func HaveHighlightedStackLine(cl types.CodeLocation) OmegaMatcher {
function clLine (line 201) | func clLine(offset int) types.CodeLocation {
FILE: internal/internal_integration/interrupt_and_timeout_test.go
type TimeMap (line 16) | type TimeMap struct
method Set (line 28) | func (tm *TimeMap) Set(key string, d time.Duration) {
method Get (line 34) | func (tm *TimeMap) Get(key string) time.Duration {
function NewTimeMap (line 21) | func NewTimeMap() *TimeMap {
FILE: internal/internal_integration/ordered_test.go
constant SKIP_DUE_TO_EARLIER_FAILURE (line 14) | SKIP_DUE_TO_EARLIER_FAILURE = "Spec skipped because an earlier spec in a...
constant SKIP_DUE_TO_FAILURE_IN_BEFORE_ALL (line 15) | SKIP_DUE_TO_FAILURE_IN_BEFORE_ALL = "Spec skipped because a BeforeAll no...
constant SKIP_DUE_TO_BEFORE_ALL_SKIP (line 16) | SKIP_DUE_TO_BEFORE_ALL_SKIP = "Spec skipped because Skip() was called in...
constant SKIP_DUE_TO_BEFORE_EACH_SKIP (line 17) | SKIP_DUE_TO_BEFORE_EACH_SKIP = "Spec skipped because Skip() was called i...
function OrderedRun (line 1296) | func OrderedRun(description string) {
function Sub2 (line 1311) | func Sub2(description string) {
function Sub3 (line 1317) | func Sub3(description string) {
function Sub4 (line 1323) | func Sub4(description string) {
FILE: internal/internal_suite_test.go
function TestInternal (line 15) | func TestInternal(t *testing.T) {
type NestingLevel (line 37) | type NestingLevel
function N (line 41) | func N(args ...any) Node {
function TN (line 76) | func TN(node Node, children ...*TreeNode) *TreeNode {
function S (line 85) | func S(nodes ...Node) Spec {
function CL (line 90) | func CL(options ...any) types.CodeLocation {
function mustFindNodeWithText (line 102) | func mustFindNodeWithText(tree *TreeNode, text string) Node {
function findNodeWithText (line 108) | func findNodeWithText(tree *TreeNode, text string) Node {
FILE: internal/interrupt_handler/interrupt_handler.go
type InterruptCause (line 15) | type InterruptCause
method String (line 32) | func (ic InterruptCause) String() string {
constant InterruptCauseInvalid (line 18) | InterruptCauseInvalid InterruptCause = iota
constant InterruptCauseSignal (line 19) | InterruptCauseSignal
constant InterruptCauseAbortByOtherProcess (line 20) | InterruptCauseAbortByOtherProcess
type InterruptLevel (line 23) | type InterruptLevel
constant InterruptLevelUninterrupted (line 26) | InterruptLevelUninterrupted InterruptLevel = iota
constant InterruptLevelCleanupAndReport (line 27) | InterruptLevelCleanupAndReport
constant InterruptLevelReportOnly (line 28) | InterruptLevelReportOnly
constant InterruptLevelBailOut (line 29) | InterruptLevelBailOut
type InterruptStatus (line 42) | type InterruptStatus struct
method Interrupted (line 48) | func (s InterruptStatus) Interrupted() bool {
method Message (line 52) | func (s InterruptStatus) Message() string {
method ShouldIncludeProgressReport (line 56) | func (s InterruptStatus) ShouldIncludeProgressReport() bool {
type InterruptHandlerInterface (line 60) | type InterruptHandlerInterface interface
type InterruptHandler (line 64) | type InterruptHandler struct
method Stop (line 91) | func (handler *InterruptHandler) Stop() {
method registerForInterrupts (line 95) | func (handler *InterruptHandler) registerForInterrupts() {
method Status (line 161) | func (handler *InterruptHandler) Status() InterruptStatus {
function NewInterruptHandler (line 75) | func NewInterruptHandler(client parallel_support.Client, signals ...os.S...
FILE: internal/interrupt_handler/interrupthandler_suite_test.go
function TestInterrupthandler (line 12) | func TestInterrupthandler(t *testing.T) {
FILE: internal/interrupt_handler/sigquit_swallower_unix.go
function SwallowSigQuit (line 12) | func SwallowSigQuit() {
FILE: internal/interrupt_handler/sigquit_swallower_windows.go
function SwallowSigQuit (line 6) | func SwallowSigQuit() {
FILE: internal/node.go
function UniqueNodeID (line 18) | func UniqueNodeID() uint {
type Node (line 27) | type Node struct
method IsZero (line 715) | func (n Node) IsZero() bool {
type focusType (line 74) | type focusType
type pendingType (line 75) | type pendingType
type serialType (line 76) | type serialType
type orderedType (line 77) | type orderedType
type continueOnFailureType (line 78) | type continueOnFailureType
type honorsOrderedType (line 79) | type honorsOrderedType
type suppressProgressReporting (line 80) | type suppressProgressReporting
constant Focus (line 82) | Focus = focusType(true)
constant Pending (line 83) | Pending = pendingType(true)
constant Serial (line 84) | Serial = serialType(true)
constant Ordered (line 85) | Ordered = orderedType(true)
constant ContinueOnFailure (line 86) | ContinueOnFailure = continueOnFailureType(true)
constant OncePerOrdered (line 87) | OncePerOrdered = honorsOrderedType(true)
constant SuppressProgressReporting (line 88) | SuppressProgressReporting = suppressProgressReporting(true)
type FlakeAttempts (line 90) | type FlakeAttempts
type MustPassRepeatedly (line 91) | type MustPassRepeatedly
type Offset (line 92) | type Offset
type Done (line 93) | type Done
type PollProgressInterval (line 94) | type PollProgressInterval
type PollProgressAfter (line 95) | type PollProgressAfter
type NodeTimeout (line 96) | type NodeTimeout
type SpecTimeout (line 97) | type SpecTimeout
type GracePeriod (line 98) | type GracePeriod
type SpecPriority (line 99) | type SpecPriority
type Labels (line 101) | type Labels
method MatchesLabelFilter (line 103) | func (l Labels) MatchesLabelFilter(query string) bool {
type SemVerConstraints (line 107) | type SemVerConstraints
method MatchesSemVerFilter (line 109) | func (svc SemVerConstraints) MatchesSemVerFilter(version string) bool {
type ComponentSemVerConstraints (line 113) | type ComponentSemVerConstraints
method MatchesSemVerFilter (line 115) | func (csvc ComponentSemVerConstraints) MatchesSemVerFilter(component, ...
function unionOf (line 130) | func unionOf[S ~[]E, E comparable](slices ...S) S {
function UnionOfLabels (line 144) | func UnionOfLabels(labels ...Labels) Labels {
function UnionOfSemVerConstraints (line 148) | func UnionOfSemVerConstraints(semVerConstraints ...SemVerConstraints) Se...
function UnionOfComponentSemVerConstraints (line 152) | func UnionOfComponentSemVerConstraints(componentSemVerConstraintsSlice ....
function PartitionDecorations (line 162) | func PartitionDecorations(args ...any) ([]any, []any) {
function isDecoration (line 175) | func isDecoration(arg any) bool {
function isSliceOfDecorations (line 228) | func isSliceOfDecorations(slice any) bool {
function NewNode (line 244) | func NewNode(deprecationTracker *types.DeprecationTracker, nodeType type...
function extractBodyFunction (line 564) | func extractBodyFunction(deprecationTracker *types.DeprecationTracker, c...
function extractSynchronizedBeforeSuiteProc1Body (line 590) | func extractSynchronizedBeforeSuiteProc1Body(arg any) (func(SpecContext)...
function extractSynchronizedBeforeSuiteAllProcsBody (line 618) | func extractSynchronizedBeforeSuiteAllProcsBody(arg any) (func(SpecConte...
function NewCleanupNode (line 649) | func NewCleanupNode(deprecationTracker *types.DeprecationTracker, fail f...
type Nodes (line 720) | type Nodes
method Clone (line 722) | func (n Nodes) Clone() Nodes {
method CopyAppend (line 728) | func (n Nodes) CopyAppend(nodes ...Node) Nodes {
method SplitAround (line 738) | func (n Nodes) SplitAround(pivot Node) (Nodes, Nodes) {
method FirstNodeWithType (line 755) | func (n Nodes) FirstNodeWithType(nodeTypes types.NodeType) Node {
method WithType (line 764) | func (n Nodes) WithType(nodeTypes types.NodeType) Nodes {
method WithoutType (line 782) | func (n Nodes) WithoutType(nodeTypes types.NodeType) Nodes {
method WithoutNode (line 800) | func (n Nodes) WithoutNode(nodeToExclude Node) Nodes {
method Filter (line 822) | func (n Nodes) Filter(filter func(Node) bool) Nodes {
method FirstSatisfying (line 840) | func (n Nodes) FirstSatisfying(filter func(Node) bool) Node {
method WithinNestingLevel (line 849) | func (n Nodes) WithinNestingLevel(deepestNestingLevel int) Nodes {
method SortedByDescendingNestingLevel (line 866) | func (n Nodes) SortedByDescendingNestingLevel() Nodes {
method SortedByAscendingNestingLevel (line 876) | func (n Nodes) SortedByAscendingNestingLevel() Nodes {
method FirstWithNestingLevel (line 886) | func (n Nodes) FirstWithNestingLevel(level int) Node {
method Reverse (line 895) | func (n Nodes) Reverse() Nodes {
method Texts (line 903) | func (n Nodes) Texts() []string {
method Labels (line 911) | func (n Nodes) Labels() [][]string {
method UnionOfLabels (line 923) | func (n Nodes) UnionOfLabels() []string {
method SemVerConstraints (line 937) | func (n Nodes) SemVerConstraints() [][]string {
method UnionOfSemVerConstraints (line 949) | func (n Nodes) UnionOfSemVerConstraints() []string {
method ComponentSemVerConstraints (line 963) | func (n Nodes) ComponentSemVerConstraints() []map[string][]string {
method UnionOfComponentSemVerConstraints (line 975) | func (n Nodes) UnionOfComponentSemVerConstraints() map[string][]string {
method CodeLocations (line 991) | func (n Nodes) CodeLocations() []types.CodeLocation {
method BestTextFor (line 999) | func (n Nodes) BestTextFor(node Node) string {
method ContainsNodeID (line 1013) | func (n Nodes) ContainsNodeID(id uint) bool {
method HasNodeMarkedPending (line 1022) | func (n Nodes) HasNodeMarkedPending() bool {
method HasNodeMarkedFocus (line 1031) | func (n Nodes) HasNodeMarkedFocus() bool {
method HasNodeMarkedSerial (line 1040) | func (n Nodes) HasNodeMarkedSerial() bool {
method FirstNodeMarkedOrdered (line 1049) | func (n Nodes) FirstNodeMarkedOrdered() Node {
method IndexOfFirstNodeMarkedOrdered (line 1058) | func (n Nodes) IndexOfFirstNodeMarkedOrdered() int {
method GetMaxFlakeAttempts (line 1067) | func (n Nodes) GetMaxFlakeAttempts() int {
method GetMaxMustPassRepeatedly (line 1077) | func (n Nodes) GetMaxMustPassRepeatedly() int {
method GetSpecPriority (line 1087) | func (n Nodes) GetSpecPriority() int {
function UnrollInterfaceSlice (line 1096) | func UnrollInterfaceSlice(args any) []any {
type NodeArgsTransformer (line 1113) | type NodeArgsTransformer
function AddTreeConstructionNodeArgsTransformer (line 1115) | func AddTreeConstructionNodeArgsTransformer(transformer NodeArgsTransfor...
type registeredNodeArgsTransformer (line 1131) | type registeredNodeArgsTransformer struct
function TransformNewNodeArgs (line 1142) | func TransformNewNodeArgs(exitIfErrors func([]error), deprecationTracker...
FILE: internal/node_test.go
type container (line 2271) | type container struct
function newConstructionNodeReport (line 2280) | func newConstructionNodeReport(report types.ConstructionNodeReport, cont...
FILE: internal/ordering.go
type SortableSpecs (line 10) | type SortableSpecs struct
method Len (line 25) | func (s *SortableSpecs) Len() int { return len(s.Indexes) }
method Swap (line 26) | func (s *SortableSpecs) Swap(i, j int) { s.Indexes[i], s.Indexes[j] = ...
method Less (line 27) | func (s *SortableSpecs) Less(i, j int) bool {
function NewSortableSpecs (line 15) | func NewSortableSpecs(specs Specs) *SortableSpecs {
type GroupedSpecIndices (line 69) | type GroupedSpecIndices
type SpecIndices (line 70) | type SpecIndices
function OrderSpecs (line 72) | func OrderSpecs(specs Specs, suiteConfig types.SuiteConfig) (GroupedSpec...
FILE: internal/ordering_test.go
type SpecTexts (line 14) | type SpecTexts
method Join (line 26) | func (tt SpecTexts) Join() string {
function getTexts (line 16) | func getTexts(specs Specs, groupedSpecIndices internal.GroupedSpecIndice...
FILE: internal/output_interceptor.go
constant BAILOUT_TIME (line 10) | BAILOUT_TIME = 1 * time.Second
constant BAILOUT_MESSAGE (line 11) | BAILOUT_MESSAGE = `Ginkgo detected an issue while intercepting output.
type OutputInterceptor (line 47) | type OutputInterceptor interface
type NoopOutputInterceptor (line 58) | type NoopOutputInterceptor struct
method StartInterceptingOutput (line 60) | func (interceptor NoopOutputInterceptor) StartInterceptingOutput() ...
method StartInterceptingOutputAndForwardTo (line 61) | func (interceptor NoopOutputInterceptor) StartInterceptingOutputAndFor...
method StopInterceptingAndReturnOutput (line 62) | func (interceptor NoopOutputInterceptor) StopInterceptingAndReturnOutp...
method PauseIntercepting (line 63) | func (interceptor NoopOutputInterceptor) PauseIntercepting() ...
method ResumeIntercepting (line 64) | func (interceptor NoopOutputInterceptor) ResumeIntercepting() ...
method Shutdown (line 65) | func (interceptor NoopOutputInterceptor) Shutdown() ...
type pipePair (line 67) | type pipePair struct
function startPipeFactory (line 72) | func startPipeFactory(pipeChannel chan pipePair, shutdown chan any) {
type interceptorImplementation (line 90) | type interceptorImplementation interface
type genericOutputInterceptor (line 97) | type genericOutputInterceptor struct
method StartInterceptingOutput (line 115) | func (interceptor *genericOutputInterceptor) StartInterceptingOutput() {
method StartInterceptingOutputAndForwardTo (line 119) | func (interceptor *genericOutputInterceptor) StartInterceptingOutputAn...
method StopInterceptingAndReturnOutput (line 128) | func (interceptor *genericOutputInterceptor) StopInterceptingAndReturn...
method ResumeIntercepting (line 135) | func (interceptor *genericOutputInterceptor) ResumeIntercepting() {
method PauseIntercepting (line 174) | func (interceptor *genericOutputInterceptor) PauseIntercepting() {
method Shutdown (line 211) | func (interceptor *genericOutputInterceptor) Shutdown() {
function NewOSGlobalReassigningOutputInterceptor (line 223) | func NewOSGlobalReassigningOutputInterceptor() OutputInterceptor {
type osGlobalReassigningOutputInterceptorImpl (line 232) | type osGlobalReassigningOutputInterceptorImpl struct
method CreateStdoutStderrClones (line 234) | func (impl *osGlobalReassigningOutputInterceptorImpl) CreateStdoutStde...
method ConnectPipeToStdoutStderr (line 238) | func (impl *osGlobalReassigningOutputInterceptorImpl) ConnectPipeToStd...
method RestoreStdoutStderrFromClones (line 243) | func (impl *osGlobalReassigningOutputInterceptorImpl) RestoreStdoutStd...
method ShutdownClones (line 248) | func (impl *osGlobalReassigningOutputInterceptorImpl) ShutdownClones(_...
FILE: internal/output_interceptor_unix.go
function NewOutputInterceptor (line 12) | func NewOutputInterceptor() OutputInterceptor {
type dupSyscallOutputInterceptorImpl (line 21) | type dupSyscallOutputInterceptorImpl struct
method CreateStdoutStderrClones (line 23) | func (impl *dupSyscallOutputInterceptorImpl) CreateStdoutStderrClones(...
method ConnectPipeToStdoutStderr (line 51) | func (impl *dupSyscallOutputInterceptorImpl) ConnectPipeToStdoutStderr...
method RestoreStdoutStderrFromClones (line 60) | func (impl *dupSyscallOutputInterceptorImpl) RestoreStdoutStderrFromCl...
method ShutdownClones (line 69) | func (impl *dupSyscallOutputInterceptorImpl) ShutdownClones(stdoutClon...
FILE: internal/output_interceptor_wasm.go
function NewOutputInterceptor (line 5) | func NewOutputInterceptor() OutputInterceptor {
FILE: internal/output_interceptor_win.go
function NewOutputInterceptor (line 5) | func NewOutputInterceptor() OutputInterceptor {
FILE: internal/parallel_support/client_server.go
type BeforeSuiteState (line 13) | type BeforeSuiteState struct
type ParallelIndexCounter (line 18) | type ParallelIndexCounter struct
type Server (line 28) | type Server interface
type Client (line 38) | type Client interface
function NewServer (line 58) | func NewServer(parallelTotal int, reporter reporters.Reporter) (Server, ...
function NewClient (line 66) | func NewClient(serverHost string) Client {
FILE: internal/parallel_support/client_server_test.go
type ColorableStringerStruct (line 18) | type ColorableStringerStruct struct
method String (line 23) | func (s ColorableStringerStruct) String() string {
method ColorableString (line 27) | func (s ColorableStringerStruct) ColorableString() string {
FILE: internal/parallel_support/http_client.go
type httpClient (line 14) | type httpClient struct
method Connect (line 24) | func (client *httpClient) Connect() bool {
method Close (line 33) | func (client *httpClient) Close() error {
method post (line 37) | func (client *httpClient) post(path string, data any) error {
method poll (line 57) | func (client *httpClient) poll(path string, data any) error {
method PostSuiteWillBegin (line 85) | func (client *httpClient) PostSuiteWillBegin(report types.Report) error {
method PostDidRun (line 89) | func (client *httpClient) PostDidRun(report types.SpecReport) error {
method PostSuiteDidEnd (line 93) | func (client *httpClient) PostSuiteDidEnd(report types.Report) error {
method PostEmitProgressReport (line 97) | func (client *httpClient) PostEmitProgressReport(report types.Progress...
method PostReportBeforeSuiteCompleted (line 101) | func (client *httpClient) PostReportBeforeSuiteCompleted(state types.S...
method BlockUntilReportBeforeSuiteCompleted (line 105) | func (client *httpClient) BlockUntilReportBeforeSuiteCompleted() (type...
method PostSynchronizedBeforeSuiteCompleted (line 114) | func (client *httpClient) PostSynchronizedBeforeSuiteCompleted(state t...
method BlockUntilSynchronizedBeforeSuiteData (line 122) | func (client *httpClient) BlockUntilSynchronizedBeforeSuiteData() (typ...
method BlockUntilNonprimaryProcsHaveFinished (line 131) | func (client *httpClient) BlockUntilNonprimaryProcsHaveFinished() error {
method BlockUntilAggregatedNonprimaryProcsReport (line 135) | func (client *httpClient) BlockUntilAggregatedNonprimaryProcsReport() ...
method FetchNextCounter (line 144) | func (client *httpClient) FetchNextCounter() (int, error) {
method PostAbort (line 150) | func (client *httpClient) PostAbort() error {
method ShouldAbort (line 154) | func (client *httpClient) ShouldAbort() bool {
method Write (line 159) | func (client *httpClient) Write(p []byte) (int, error) {
function newHttpClient (line 18) | func newHttpClient(serverHost string) *httpClient {
FILE: internal/parallel_support/http_server.go
type httpServer (line 24) | type httpServer struct
method Start (line 42) | func (server *httpServer) Start() {
method Close (line 69) | func (server *httpServer) Close() {
method Address (line 74) | func (server *httpServer) Address() string {
method GetSuiteDone (line 78) | func (server *httpServer) GetSuiteDone() chan any {
method GetOutputDestination (line 82) | func (server *httpServer) GetOutputDestination() io.Writer {
method SetOutputDestination (line 86) | func (server *httpServer) SetOutputDestination(w io.Writer) {
method RegisterAlive (line 90) | func (server *httpServer) RegisterAlive(node int, alive func() bool) {
method decode (line 99) | func (server *httpServer) decode(writer http.ResponseWriter, request *...
method handleError (line 108) | func (server *httpServer) handleError(err error, writer http.ResponseW...
method specSuiteWillBegin (line 125) | func (server *httpServer) specSuiteWillBegin(writer http.ResponseWrite...
method didRun (line 134) | func (server *httpServer) didRun(writer http.ResponseWriter, request *...
method specSuiteDidEnd (line 143) | func (server *httpServer) specSuiteDidEnd(writer http.ResponseWriter, ...
method emitOutput (line 151) | func (server *httpServer) emitOutput(writer http.ResponseWriter, reque...
method emitProgressReport (line 161) | func (server *httpServer) emitProgressReport(writer http.ResponseWrite...
method handleReportBeforeSuiteCompleted (line 169) | func (server *httpServer) handleReportBeforeSuiteCompleted(writer http...
method handleReportBeforeSuiteState (line 178) | func (server *httpServer) handleReportBeforeSuiteState(writer http.Res...
method handleBeforeSuiteCompleted (line 186) | func (server *httpServer) handleBeforeSuiteCompleted(writer http.Respo...
method handleBeforeSuiteState (line 195) | func (server *httpServer) handleBeforeSuiteState(writer http.ResponseW...
method handleHaveNonprimaryProcsFinished (line 203) | func (server *httpServer) handleHaveNonprimaryProcsFinished(writer htt...
method handleAggregatedNonprimaryProcsReport (line 210) | func (server *httpServer) handleAggregatedNonprimaryProcsReport(writer...
method handleCounter (line 218) | func (server *httpServer) handleCounter(writer http.ResponseWriter, re...
method handleUp (line 226) | func (server *httpServer) handleUp(writer http.ResponseWriter, request...
method handleAbort (line 230) | func (server *httpServer) handleAbort(writer http.ResponseWriter, requ...
function newHttpServer (line 30) | func newHttpServer(parallelTotal int, reporter reporters.Reporter) (*htt...
FILE: internal/parallel_support/parallel_support_suite_test.go
function TestParallelSupport (line 13) | func TestParallelSupport(t *testing.T) {
type post (line 18) | type post struct
type fakePoster (line 24) | type fakePoster struct
method Post (line 34) | func (poster *fakePoster) Post(url string, bodyType string, body io.Re...
function newFakePoster (line 28) | func newFakePoster() *fakePoster {
FILE: internal/parallel_support/rpc_client.go
type rpcClient (line 10) | type rpcClient struct
method Connect (line 21) | func (client *rpcClient) Connect() bool {
method Close (line 34) | func (client *rpcClient) Close() error {
method poll (line 38) | func (client *rpcClient) poll(method string, data any) error {
method PostSuiteWillBegin (line 57) | func (client *rpcClient) PostSuiteWillBegin(report types.Report) error {
method PostDidRun (line 61) | func (client *rpcClient) PostDidRun(report types.SpecReport) error {
method PostSuiteDidEnd (line 65) | func (client *rpcClient) PostSuiteDidEnd(report types.Report) error {
method Write (line 69) | func (client *rpcClient) Write(p []byte) (int, error) {
method PostEmitProgressReport (line 75) | func (client *rpcClient) PostEmitProgressReport(report types.ProgressR...
method PostReportBeforeSuiteCompleted (line 79) | func (client *rpcClient) PostReportBeforeSuiteCompleted(state types.Sp...
method BlockUntilReportBeforeSuiteCompleted (line 83) | func (client *rpcClient) BlockUntilReportBeforeSuiteCompleted() (types...
method PostSynchronizedBeforeSuiteCompleted (line 92) | func (client *rpcClient) PostSynchronizedBeforeSuiteCompleted(state ty...
method BlockUntilSynchronizedBeforeSuiteData (line 100) | func (client *rpcClient) BlockUntilSynchronizedBeforeSuiteData() (type...
method BlockUntilNonprimaryProcsHaveFinished (line 109) | func (client *rpcClient) BlockUntilNonprimaryProcsHaveFinished() error {
method BlockUntilAggregatedNonprimaryProcsReport (line 113) | func (client *rpcClient) BlockUntilAggregatedNonprimaryProcsReport() (...
method FetchNextCounter (line 122) | func (client *rpcClient) FetchNextCounter() (int, error) {
method PostAbort (line 128) | func (client *rpcClient) PostAbort() error {
method ShouldAbort (line 132) | func (client *rpcClient) ShouldAbort() bool {
function newRPCClient (line 15) | func newRPCClient(serverHost string) *rpcClient {
FILE: internal/parallel_support/rpc_server.go
type RPCServer (line 23) | type RPCServer struct
method Start (line 41) | func (server *RPCServer) Start() {
method Close (line 52) | func (server *RPCServer) Close() {
method Address (line 57) | func (server *RPCServer) Address() string {
method GetSuiteDone (line 61) | func (server *RPCServer) GetSuiteDone() chan any {
method GetOutputDestination (line 65) | func (server *RPCServer) GetOutputDestination() io.Writer {
method SetOutputDestination (line 69) | func (server *RPCServer) SetOutputDestination(w io.Writer) {
method RegisterAlive (line 73) | func (server *RPCServer) RegisterAlive(node int, alive func() bool) {
function newRPCServer (line 29) | func newRPCServer(parallelTotal int, reporter reporters.Reporter) (*RPCS...
FILE: internal/parallel_support/server_handler.go
type Void (line 12) | type Void struct
type ServerHandler (line 20) | type ServerHandler struct
method SpecSuiteWillBegin (line 53) | func (handler *ServerHandler) SpecSuiteWillBegin(report types.Report, ...
method DidRun (line 74) | func (handler *ServerHandler) DidRun(report types.SpecReport, _ *Void)...
method SpecSuiteDidEnd (line 88) | func (handler *ServerHandler) SpecSuiteDidEnd(report types.Report, _ *...
method EmitOutput (line 107) | func (handler *ServerHandler) EmitOutput(output []byte, n *int) error {
method EmitProgressReport (line 113) | func (handler *ServerHandler) EmitProgressReport(report types.Progress...
method registerAlive (line 120) | func (handler *ServerHandler) registerAlive(proc int, alive func() boo...
method procIsAlive (line 126) | func (handler *ServerHandler) procIsAlive(proc int) bool {
method haveNonprimaryProcsFinished (line 136) | func (handler *ServerHandler) haveNonprimaryProcsFinished() bool {
method ReportBeforeSuiteCompleted (line 145) | func (handler *ServerHandler) ReportBeforeSuiteCompleted(reportBeforeS...
method ReportBeforeSuiteState (line 153) | func (handler *ServerHandler) ReportBeforeSuiteState(_ Void, reportBef...
method BeforeSuiteCompleted (line 168) | func (handler *ServerHandler) BeforeSuiteCompleted(beforeSuiteState Be...
method BeforeSuiteState (line 176) | func (handler *ServerHandler) BeforeSuiteState(_ Void, beforeSuiteStat...
method HaveNonprimaryProcsFinished (line 191) | func (handler *ServerHandler) HaveNonprimaryProcsFinished(_ Void, _ *V...
method AggregatedNonprimaryProcsReport (line 199) | func (handler *ServerHandler) AggregatedNonprimaryProcsReport(_ Void, ...
method Counter (line 214) | func (handler *ServerHandler) Counter(_ Void, counter *int) error {
method Abort (line 222) | func (handler *ServerHandler) Abort(_ Void, _ *Void) error {
method ShouldAbort (line 229) | func (handler *ServerHandler) ShouldAbort(_ Void, shouldAbort *bool) e...
function newServerHandler (line 39) | func newServerHandler(parallelTotal int, reporter reporters.Reporter) *S...
FILE: internal/progress_report.go
type ProgressSignalRegistrar (line 22) | type ProgressSignalRegistrar
function RegisterForProgressSignal (line 24) | func RegisterForProgressSignal(handler func()) context.CancelFunc {
type ProgressStepCursor (line 45) | type ProgressStepCursor struct
function NewProgressReport (line 51) | func NewProgressReport(isRunningInParallel bool, report types.SpecReport...
function extractRunningGoroutines (line 177) | func extractRunningGoroutines() ([]types.Goroutine, error) {
function fetchSource (line 250) | func fetchSource(filename string, lineNumber int, span int, configuredSo...
FILE: internal/progress_reporter_manager.go
type ProgressReporterManager (line 12) | type ProgressReporterManager struct
method AttachProgressReporter (line 25) | func (prm *ProgressReporterManager) AttachProgressReporter(reporter fu...
method QueryProgressReporters (line 39) | func (prm *ProgressReporterManager) QueryProgressReporters(ctx context...
function NewProgressReporterManager (line 18) | func NewProgressReporterManager() *ProgressReporterManager {
FILE: internal/report_entry.go
function NewReportEntry (line 11) | func NewReportEntry(name string, cl types.CodeLocation, args ...any) (Re...
FILE: internal/report_entry_test.go
type SomeStruct (line 14) | type SomeStruct struct
type StringerStruct (line 19) | type StringerStruct struct
method String (line 24) | func (s StringerStruct) String() string {
type ColorableStringerStruct (line 28) | type ColorableStringerStruct struct
method String (line 33) | func (s ColorableStringerStruct) String() string {
method ColorableString (line 37) | func (s ColorableStringerStruct) ColorableString() string {
function reportEntryJSONRoundTrip (line 41) | func reportEntryJSONRoundTrip(reportEntry internal.ReportEntry) internal...
FILE: internal/reporters/gojson.go
function ptr (line 13) | func ptr[T any](in T) *T {
type encoder (line 17) | type encoder interface
type gojsonEvent (line 24) | type gojsonEvent struct
type GoJSONAction (line 34) | type GoJSONAction
constant GoJSONStart (line 38) | GoJSONStart GoJSONAction = "start"
constant GoJSONRun (line 40) | GoJSONRun GoJSONAction = "run"
constant GoJSONPause (line 42) | GoJSONPause GoJSONAction = "pause"
constant GoJSONCont (line 44) | GoJSONCont GoJSONAction = "cont"
constant GoJSONPass (line 46) | GoJSONPass GoJSONAction = "pass"
constant GoJSONBench (line 48) | GoJSONBench GoJSONAction = "bench"
constant GoJSONFail (line 50) | GoJSONFail GoJSONAction = "fail"
constant GoJSONOutput (line 52) | GoJSONOutput GoJSONAction = "output"
constant GoJSONSkip (line 54) | GoJSONSkip GoJSONAction = "skip"
function goJSONActionFromSpecState (line 57) | func goJSONActionFromSpecState(state types.SpecState) GoJSONAction {
type gojsonReport (line 83) | type gojsonReport struct
method Fill (line 96) | func (r *gojsonReport) Fill() error {
function newReport (line 90) | func newReport(in types.Report) *gojsonReport {
type gojsonSpecReport (line 108) | type gojsonSpecReport struct
method Fill (line 122) | func (sr *gojsonSpecReport) Fill() error {
function newSpecReport (line 116) | func newSpecReport(in types.SpecReport) *gojsonSpecReport {
function suitePathToPkg (line 129) | func suitePathToPkg(dir string) (string, error) {
function createTestName (line 143) | func createTestName(spec types.SpecReport) string {
function formatComponentSemVerConstraintsToString (line 164) | func formatComponentSemVerConstraintsToString(componentSemVerConstraints...
FILE: internal/reporters/gojson_event_writer.go
type GoJSONEventWriter (line 3) | type GoJSONEventWriter struct
method writeEvent (line 17) | func (r *GoJSONEventWriter) writeEvent(e *gojsonEvent) error {
method WriteSuiteStart (line 21) | func (r *GoJSONEventWriter) WriteSuiteStart(report *gojsonReport) error {
method WriteSuiteResult (line 32) | func (r *GoJSONEventWriter) WriteSuiteResult(report *gojsonReport) err...
method WriteSpecStart (line 53) | func (r *GoJSONEventWriter) WriteSpecStart(report *gojsonReport, specR...
method WriteSpecOut (line 65) | func (r *GoJSONEventWriter) WriteSpecOut(report *gojsonReport, specRep...
method WriteSpecResult (line 100) | func (r *GoJSONEventWriter) WriteSpecResult(report *gojsonReport, spec...
function NewGoJSONEventWriter (line 9) | func NewGoJSONEventWriter(enc encoder, errFn specSystemExtractFn, outFn ...
FILE: internal/reporters/gojson_reporter.go
type GoJSONReporter (line 7) | type GoJSONReporter struct
method Write (line 19) | func (r *GoJSONReporter) Write(originalReport types.Report) error {
type specSystemExtractFn (line 11) | type specSystemExtractFn
function NewGoJSONReporter (line 13) | func NewGoJSONReporter(enc encoder, errFn specSystemExtractFn, outFn spe...
FILE: internal/spec.go
type Spec (line 10) | type Spec struct
method SubjectID (line 15) | func (s Spec) SubjectID() uint {
method Text (line 19) | func (s Spec) Text() string {
method FirstNodeWithType (line 29) | func (s Spec) FirstNodeWithType(nodeTypes types.NodeType) Node {
method FlakeAttempts (line 33) | func (s Spec) FlakeAttempts() int {
method MustPassRepeatedly (line 44) | func (s Spec) MustPassRepeatedly() int {
method SpecTimeout (line 55) | func (s Spec) SpecTimeout() time.Duration {
type Specs (line 59) | type Specs
method HasAnySpecsMarkedPending (line 61) | func (s Specs) HasAnySpecsMarkedPending() bool {
method CountWithoutSkip (line 71) | func (s Specs) CountWithoutSkip() int {
method AtIndices (line 81) | func (s Specs) AtIndices(indices SpecIndices) Specs {
FILE: internal/spec_context.go
type SpecContext (line 10) | type SpecContext interface
type specContext (line 18) | type specContext struct
method SpecReport (line 47) | func (sc *specContext) SpecReport() types.SpecReport {
method WrappedContext (line 51) | func (sc *specContext) WrappedContext() context.Context {
function NewSpecContext (line 34) | func NewSpecContext(suite *Suite) *specContext {
function wrapContextChain (line 59) | func wrapContextChain(ctx context.Context) SpecContext {
FILE: internal/suite.go
type Phase (line 15) | type Phase
constant PhaseBuildTopLevel (line 18) | PhaseBuildTopLevel Phase = iota
constant PhaseBuildTree (line 19) | PhaseBuildTree
constant PhaseRun (line 20) | PhaseRun
constant ProgressReporterDeadline (line 23) | ProgressReporterDeadline = 5 * time.Second
type Suite (line 25) | type Suite struct
method Clone (line 83) | func (suite *Suite) Clone() (*Suite, error) {
method BuildTree (line 98) | func (suite *Suite) BuildTree() error {
method Run (line 111) | func (suite *Suite) Run(description string, suiteLabels Labels, suiteS...
method InRunPhase (line 143) | func (suite *Suite) InRunPhase() bool {
method PushNode (line 153) | func (suite *Suite) PushNode(node Node) error {
method pushSuiteNode (line 233) | func (suite *Suite) pushSuiteNode(node Node) error {
method pushCleanupNode (line 259) | func (suite *Suite) pushCleanupNode(node Node) error {
method generateTimelineLocation (line 287) | func (suite *Suite) generateTimelineLocation() types.TimelineLocation {
method handleSpecEvent (line 299) | func (suite *Suite) handleSpecEvent(event types.SpecEvent) types.SpecE...
method handleSpecEventEnd (line 308) | func (suite *Suite) handleSpecEventEnd(eventType types.SpecEventType, ...
method By (line 319) | func (suite *Suite) By(text string, callback ...func()) error {
method CurrentConstructionNodeReport (line 348) | func (suite *Suite) CurrentConstructionNodeReport() types.Construction...
method CurrentSpecReport (line 361) | func (suite *Suite) CurrentSpecReport() types.SpecReport {
method GetPreviewReport (line 377) | func (suite *Suite) GetPreviewReport() types.Report {
method AddReportEntry (line 383) | func (suite *Suite) AddReportEntry(entry ReportEntry) error {
method generateProgressReport (line 396) | func (suite *Suite) generateProgressReport(fullReport bool) types.Prog...
method handleProgressSignal (line 417) | func (suite *Suite) handleProgressSignal() {
method emitProgressReport (line 423) | func (suite *Suite) emitProgressReport(report types.ProgressReport) {
method isRunningInParallel (line 437) | func (suite *Suite) isRunningInParallel() bool {
method processCurrentSpecReport (line 441) | func (suite *Suite) processCurrentSpecReport() {
method runSpecs (line 459) | func (suite *Suite) runSpecs(description string, suiteLabels Labels, s...
method runBeforeSuite (line 558) | func (suite *Suite) runBeforeSuite(numSpecsThatWillBeRun int) {
method runAfterSuiteCleanup (line 580) | func (suite *Suite) runAfterSuiteCleanup(numSpecsThatWillBeRun int) {
method reportEach (line 616) | func (suite *Suite) reportEach(spec Spec, nodeType types.NodeType) {
method runSuiteNode (line 648) | func (suite *Suite) runSuiteNode(node Node) {
method runReportSuiteNodesIfNeedBe (line 742) | func (suite *Suite) runReportSuiteNodesIfNeedBe(nodeType types.NodeTyp...
method runReportSuiteNode (line 783) | func (suite *Suite) runReportSuiteNode(node Node, report types.Report) {
method runNode (line 809) | func (suite *Suite) runNode(node Node, specDeadline time.Time, text st...
method failureForLeafNodeWithMessage (line 1083) | func (suite *Suite) failureForLeafNodeWithMessage(node Node, message s...
function NewSuite (line 73) | func NewSuite() *Suite {
function max (line 1094) | func max(a, b int) int {
FILE: internal/test_helpers/docs.go
type Doc (line 13) | type Doc struct
method Path (line 19) | func (doc Doc) Path(root string) string {
type Docs (line 23) | type Docs
method DocWithName (line 25) | func (d Docs) DocWithName(name string) Doc {
method DocWithURL (line 34) | func (d Docs) DocWithURL(url string) Doc {
type Anchors (line 51) | type Anchors struct
method IsResolvable (line 56) | func (a Anchors) IsResolvable(docName string, link string) bool {
function LoadAnchors (line 86) | func LoadAnchors(docs Docs, rootPath string) (Anchors, error) {
function loadMarkdownHeadingAnchors (line 101) | func loadMarkdownHeadingAnchors(filename string) ([]string, error) {
function LoadMarkdownHeadings (line 118) | func LoadMarkdownHeadings(filename string) ([]string, error) {
function LoadMarkdownLinks (line 137) | func LoadMarkdownLinks(filename string) ([]string, error) {
FILE: internal/test_helpers/fake_interrupt_handler.go
type FakeInterruptHandler (line 9) | type FakeInterruptHandler struct
method Interrupt (line 27) | func (handler *FakeInterruptHandler) Interrupt(cause interrupt_handler...
method Status (line 40) | func (handler *FakeInterruptHandler) Status() interrupt_handler.Interr...
function NewFakeInterruptHandler (line 18) | func NewFakeInterruptHandler() *FakeInterruptHandler {
FILE: internal/test_helpers/fake_output_interceptor.go
type FakeOutputInterceptor (line 8) | type FakeOutputInterceptor struct
method AppendInterceptedOutput (line 22) | func (interceptor *FakeOutputInterceptor) AppendInterceptedOutput(s st...
method StartInterceptingOutput (line 29) | func (interceptor *FakeOutputInterceptor) StartInterceptingOutput() {
method StartInterceptingOutputAndForwardTo (line 33) | func (interceptor *FakeOutputInterceptor) StartInterceptingOutputAndFo...
method PauseIntercepting (line 41) | func (interceptor *FakeOutputInterceptor) PauseIntercepting() {
method ResumeIntercepting (line 47) | func (interceptor *FakeOutputInterceptor) ResumeIntercepting() {
method StopInterceptingAndReturnOutput (line 53) | func (interceptor *FakeOutputInterceptor) StopInterceptingAndReturnOut...
method Shutdown (line 60) | func (interceptor *FakeOutputInterceptor) Shutdown() {
function NewFakeOutputInterceptor (line 15) | func NewFakeOutputInterceptor() *FakeOutputInterceptor {
FILE: internal/test_helpers/fake_reporter.go
type OmegaMatcherWithDescription (line 18) | type OmegaMatcherWithDescription struct
method GomegaString (line 23) | func (o OmegaMatcherWithDescription) GomegaString() string {
type Reports (line 33) | type Reports
method FindByLeafNodeType (line 35) | func (s Reports) FindByLeafNodeType(nodeTypes types.NodeType) types.Sp...
method Find (line 45) | func (s Reports) Find(name string) types.SpecReport {
method FindByFullText (line 55) | func (s Reports) FindByFullText(text string) types.SpecReport {
method Names (line 65) | func (s Reports) Names() []string {
method WithState (line 75) | func (s Reports) WithState(state types.SpecState) Reports {
method WithLeafNodeType (line 85) | func (s Reports) WithLeafNodeType(nodeTypes types.NodeType) Reports {
type FakeReporter (line 95) | type FakeReporter struct
method SuiteWillBegin (line 113) | func (r *FakeReporter) SuiteWillBegin(report types.Report) {
method WillRun (line 119) | func (r *FakeReporter) WillRun(report types.SpecReport) {
method DidRun (line 125) | func (r *FakeReporter) DidRun(report types.SpecReport) {
method SuiteDidEnd (line 131) | func (r *FakeReporter) SuiteDidEnd(report types.Report) {
method EmitProgressReport (line 136) | func (r *FakeReporter) EmitProgressReport(progressReport types.Progres...
method EmitFailure (line 141) | func (r *FakeReporter) EmitFailure(state types.SpecState, failure type...
method EmitReportEntry (line 146) | func (r *FakeReporter) EmitReportEntry(reportEntry types.ReportEntry) {
method EmitSpecEvent (line 151) | func (r *FakeReporter) EmitSpecEvent(specEvent types.SpecEvent) {
function NewFakeReporter (line 107) | func NewFakeReporter() *FakeReporter {
type NSpecs (line 157) | type NSpecs
type NWillRun (line 158) | type NWillRun
type NPassed (line 159) | type NPassed
type NSkipped (line 160) | type NSkipped
type NFailed (line 161) | type NFailed
type NPending (line 162) | type NPending
type NFlaked (line 163) | type NFlaked
function BeASuiteSummary (line 165) | func BeASuiteSummary(options ...any) OmegaMatcher {
type CapturedGinkgoWriterOutput (line 223) | type CapturedGinkgoWriterOutput
type CapturedStdOutput (line 224) | type CapturedStdOutput
type NumAttempts (line 225) | type NumAttempts
function HavePassed (line 227) | func HavePassed(options ...any) OmegaMatcher {
function BePending (line 252) | func BePending() OmegaMatcher {
function HaveBeenSkipped (line 259) | func HaveBeenSkipped() OmegaMatcher {
function HaveBeenSkippedWithMessage (line 266) | func HaveBeenSkippedWithMessage(message string, options ...any) OmegaMat...
function HaveBeenInterrupted (line 281) | func HaveBeenInterrupted(cause interrupt_handler.InterruptCause) OmegaMa...
type FailureNodeType (line 288) | type FailureNodeType
function failureMatcherForState (line 290) | func failureMatcherForState(state types.SpecState, messageField string, ...
function HaveFailed (line 326) | func HaveFailed(options ...any) OmegaMatcher {
function HaveTimedOut (line 330) | func HaveTimedOut(options ...any) OmegaMatcher {
function HaveAborted (line 334) | func HaveAborted(options ...any) OmegaMatcher {
function HavePanicked (line 338) | func HavePanicked(options ...any) OmegaMatcher {
function TLWithOffset (line 342) | func TLWithOffset[O int | string](o O) types.TimelineLocation {
function BeSpecEvent (line 353) | func BeSpecEvent(options ...any) OmegaMatcher {
function BeProgressReport (line 388) | func BeProgressReport(options ...any) OmegaMatcher {
function BeReportEntry (line 414) | func BeReportEntry(options ...any) OmegaMatcher {
function BeTimelineContaining (line 437) | func BeTimelineContaining(matchers ...OmegaMatcher) OmegaMatcher {
function BeTimelineExactlyMatching (line 457) | func BeTimelineExactlyMatching(matchers ...OmegaMatcher) OmegaMatcher {
FILE: internal/test_helpers/multiline_helpers.go
function MultilineTextHelper (line 11) | func MultilineTextHelper(s string) string {
function MatchLines (line 21) | func MatchLines(expected ...any) gcustom.CustomGomegaMatcher {
FILE: internal/test_helpers/run_tracker.go
type RunTracker (line 20) | type RunTracker struct
method Reset (line 33) | func (rt *RunTracker) Reset() {
method Run (line 39) | func (rt *RunTracker) Run(text string) {
method RunWithData (line 45) | func (rt *RunTracker) RunWithData(text string, kv ...any) {
method TrackedRuns (line 58) | func (rt *RunTracker) TrackedRuns() []string {
method DataFor (line 66) | func (rt *RunTracker) DataFor(text string) map[string]any {
method T (line 72) | func (rt *RunTracker) T(text string, callback ...func()) func() {
method TSC (line 81) | func (rt *RunTracker) TSC(text string, callback ...func(internal.SpecC...
method C (line 90) | func (rt *RunTracker) C(text string, callback ...func()) func(args []s...
function NewRunTracker (line 26) | func NewRunTracker() *RunTracker {
function HaveRun (line 99) | func HaveRun(run string) OmegaMatcher {
function HaveRunWithData (line 105) | func HaveRunWithData(run string, kv ...any) OmegaMatcher {
function HaveTrackedNothing (line 118) | func HaveTrackedNothing() OmegaMatcher {
type HaveTrackedMatcher (line 124) | type HaveTrackedMatcher struct
method Match (line 129) | func (m *HaveTrackedMatcher) Match(actual any) (bool, error) {
method FailureMessage (line 162) | func (m *HaveTrackedMatcher) FailureMessage(actual any) string {
method NegatedFailureMessage (line 166) | func (m *HaveTrackedMatcher) NegatedFailureMessage(actual any) string {
function HaveTracked (line 170) | func HaveTracked(runs ...string) OmegaMatcher {
FILE: internal/test_helpers/set_up_server.go
function SetUpServerAndClient (line 10) | func SetUpServerAndClient(numNodes int) (parallel_support.Server, parall...
FILE: internal/test_helpers/status_code_poller.go
function StatusCodePoller (line 5) | func StatusCodePoller(url string) func() int {
FILE: internal/testingtproxy/testing_t_proxy.go
type failFunc (line 15) | type failFunc
type skipFunc (line 16) | type skipFunc
type cleanupFunc (line 17) | type cleanupFunc
type reportFunc (line 18) | type reportFunc
type addReportEntryFunc (line 19) | type addReportEntryFunc
type ginkgoWriterInterface (line 20) | type ginkgoWriterInterface interface
type ginkgoRecoverFunc (line 27) | type ginkgoRecoverFunc
type attachProgressReporterFunc (line 28) | type attachProgressReporterFunc
function New (line 35) | func New(writer ginkgoWriterInterface, fail failFunc, skip skipFunc, cle...
type ginkgoTestingTProxy (line 53) | type ginkgoTestingTProxy struct
method Cleanup (line 71) | func (t *ginkgoTestingTProxy) Cleanup(f func()) {
method Setenv (line 75) | func (t *ginkgoTestingTProxy) Setenv(key, value string) {
method Chdir (line 89) | func (t *ginkgoTestingTProxy) Chdir(dir string) {
method Context (line 103) | func (t *ginkgoTestingTProxy) Context() context.Context {
method Error (line 109) | func (t *ginkgoTestingTProxy) Error(args ...any) {
method Errorf (line 113) | func (t *ginkgoTestingTProxy) Errorf(format string, args ...any) {
method Fail (line 117) | func (t *ginkgoTestingTProxy) Fail() {
method FailNow (line 121) | func (t *ginkgoTestingTProxy) FailNow() {
method Failed (line 125) | func (t *ginkgoTestingTProxy) Failed() bool {
method Fatal (line 129) | func (t *ginkgoTestingTProxy) Fatal(args ...any) {
method Fatalf (line 133) | func (t *ginkgoTestingTProxy) Fatalf(format string, args ...any) {
method Helper (line 137) | func (t *ginkgoTestingTProxy) Helper() {
method Log (line 141) | func (t *ginkgoTestingTProxy) Log(args ...any) {
method Logf (line 145) | func (t *ginkgoTestingTProxy) Logf(format string, args ...any) {
method Name (line 149) | func (t *ginkgoTestingTProxy) Name() string {
method Parallel (line 153) | func (t *ginkgoTestingTProxy) Parallel() {
method Skip (line 157) | func (t *ginkgoTestingTProxy) Skip(args ...any) {
method SkipNow (line 161) | func (t *ginkgoTestingTProxy) SkipNow() {
method Skipf (line 165) | func (t *ginkgoTestingTProxy) Skipf(format string, args ...any) {
method Skipped (line 169) | func (t *ginkgoTestingTProxy) Skipped() bool {
method TempDir (line 173) | func (t *ginkgoTestingTProxy) TempDir() string {
method AddReportEntryVisibilityAlways (line 185) | func (t *ginkgoTestingTProxy) AddReportEntryVisibilityAlways(name stri...
method AddReportEntryVisibilityFailureOrVerbose (line 189) | func (t *ginkgoTestingTProxy) AddReportEntryVisibilityFailureOrVerbose...
method AddReportEntryVisibilityNever (line 193) | func (t *ginkgoTestingTProxy) AddReportEntryVisibilityNever(name strin...
method Print (line 197) | func (t *ginkgoTestingTProxy) Print(a ...any) {
method Printf (line 200) | func (t *ginkgoTestingTProxy) Printf(format string, a ...any) {
method Println (line 203) | func (t *ginkgoTestingTProxy) Println(a ...any) {
method F (line 206) | func (t *ginkgoTestingTProxy) F(format string, args ...any) string {
method Fi (line 209) | func (t *ginkgoTestingTProxy) Fi(indentation uint, format string, args...
method Fiw (line 212) | func (t *ginkgoTestingTProxy) Fiw(indentation uint, maxWidth uint, for...
method RenderTimeline (line 215) | func (t *ginkgoTestingTProxy) RenderTimeline() string {
method GinkgoRecover (line 218) | func (t *ginkgoTestingTProxy) GinkgoRecover() {
method DeferCleanup (line 221) | func (t *ginkgoTestingTProxy) DeferCleanup(args ...any) {
method RandomSeed (line 225) | func (t *ginkgoTestingTProxy) RandomSeed() int64 {
method ParallelProcess (line 228) | func (t *ginkgoTestingTProxy) ParallelProcess() int {
method ParallelTotal (line 231) | func (t *ginkgoTestingTProxy) ParallelTotal() int {
method AttachProgressReporter (line 234) | func (t *ginkgoTestingTProxy) AttachProgressReporter(f func() string) ...
method Output (line 237) | func (t *ginkgoTestingTProxy) Output() io.Writer {
method Attr (line 240) | func (t *ginkgoTestingTProxy) Attr(key, value string) {
FILE: internal/testingtproxy/testingtproxy_suite_test.go
function TestTestingtproxy (line 10) | func TestTestingtproxy(t *testing.T) {
FILE: internal/testingtproxy/testingtproxy_test.go
type messagedCall (line 21) | type messagedCall struct
FILE: internal/tree.go
type TreeNode (line 5) | type TreeNode struct
method AppendChild (line 11) | func (tn *TreeNode) AppendChild(child *TreeNode) {
method AncestorNodeChain (line 16) | func (tn *TreeNode) AncestorNodeChain() Nodes {
type TreeNodes (line 23) | type TreeNodes
method Nodes (line 25) | func (tn TreeNodes) Nodes() Nodes {
method WithID (line 33) | func (tn TreeNodes) WithID(id uint) *TreeNode {
function GenerateSpecsFromTreeRoot (line 43) | func GenerateSpecsFromTreeRoot(tree *TreeNode) Specs {
FILE: internal/writer.go
type WriterMode (line 13) | type WriterMode
constant WriterModeStreamAndBuffer (line 16) | WriterModeStreamAndBuffer WriterMode = iota
constant WriterModeBufferOnly (line 17) | WriterModeBufferOnly
type WriterInterface (line 20) | type WriterInterface interface
type Writer (line 29) | type Writer struct
method SetMode (line 52) | func (w *Writer) SetMode(mode WriterMode) {
method Len (line 58) | func (w *Writer) Len() int {
method Write (line 66) | func (w *Writer) Write(b []byte) (n int, err error) {
method Truncate (line 94) | func (w *Writer) Truncate() {
method Bytes (line 100) | func (w *Writer) Bytes() []byte {
method TeeTo (line 110) | func (w *Writer) TeeTo(writer io.Writer) {
method ClearTeeWriters (line 117) | func (w *Writer) ClearTeeWriters() {
method Print (line 124) | func (w *Writer) Print(a ...any) {
method Printf (line 128) | func (w *Writer) Printf(format string, a ...any) {
method Println (line 132) | func (w *Writer) Println(a ...any) {
function NewWriter (line 41) | func NewWriter(outWriter io.Writer) *Writer {
function GinkgoLogrFunc (line 136) | func GinkgoLogrFunc(writer *Writer) logr.Logger {
FILE: reporters/default_reporter.go
type DefaultReporter (line 22) | type DefaultReporter struct
method SuiteWillBegin (line 69) | func (r *DefaultReporter) SuiteWillBegin(report types.Report) {
method SuiteDidEnd (line 125) | func (r *DefaultReporter) SuiteDidEnd(report types.Report) {
method WillRun (line 195) | func (r *DefaultReporter) WillRun(report types.SpecReport) {
method wrapTextBlock (line 205) | func (r *DefaultReporter) wrapTextBlock(sectionName string, fn func()) {
method DidRun (line 221) | func (r *DefaultReporter) DidRun(report types.SpecReport) {
method highlightColorForState (line 361) | func (r *DefaultReporter) highlightColorForState(state types.SpecState...
method humanReadableState (line 384) | func (r *DefaultReporter) humanReadableState(state types.SpecState) st...
method emitTimeline (line 388) | func (r *DefaultReporter) emitTimeline(indent uint, report types.SpecR...
method EmitFailure (line 438) | func (r *DefaultReporter) EmitFailure(state types.SpecState, failure t...
method emitShortFailure (line 446) | func (r *DefaultReporter) emitShortFailure(indent uint, state types.Sp...
method emitFailure (line 455) | func (r *DefaultReporter) emitFailure(indent uint, state types.SpecSta...
method EmitProgressReport (line 489) | func (r *DefaultReporter) EmitProgressReport(report types.ProgressRepo...
method emitProgressReport (line 500) | func (r *DefaultReporter) emitProgressReport(indent uint, emitGinkgoWr...
method EmitReportEntry (line 592) | func (r *DefaultReporter) EmitReportEntry(entry types.ReportEntry) {
method emitReportEntry (line 599) | func (r *DefaultReporter) emitReportEntry(indent uint, entry types.Rep...
method EmitSpecEvent (line 606) | func (r *DefaultReporter) EmitSpecEvent(event types.SpecEvent) {
method emitSpecEvent (line 613) | func (r *DefaultReporter) emitSpecEvent(indent uint, event types.SpecE...
method emitGoroutines (line 636) | func (r *DefaultReporter) emitGoroutines(indent uint, goroutines ...ty...
method emitSource (line 660) | func (r *DefaultReporter) emitSource(indent uint, fc types.FunctionCal...
method emit (line 690) | func (r *DefaultReporter) emit(s string) {
method emitBlock (line 694) | func (r *DefaultReporter) emitBlock(s string) {
method emitDelimiter (line 698) | func (r *DefaultReporter) emitDelimiter(indent uint) {
method _emit (line 703) | func (r *DefaultReporter) _emit(s string, block bool, isDelimiter bool) {
method f (line 725) | func (r *DefaultReporter) f(format string, args ...any) string {
method fi (line 729) | func (r *DefaultReporter) fi(indentation uint, format string, args ......
method cycleJoin (line 733) | func (r *DefaultReporter) cycleJoin(elements []string, joiner string) ...
method codeLocationBlock (line 737) | func (r *DefaultReporter) codeLocationBlock(report types.SpecReport, h...
function NewDefaultReporterUnderTest (line 39) | func NewDefaultReporterUnderTest(conf types.ReporterConfig, writer io.Wr...
function NewDefaultReporter (line 46) | func NewDefaultReporter(conf types.ReporterConfig, writer io.Writer) *De...
FILE: reporters/default_reporter_test.go
constant DELIMITER (line 24) | DELIMITER = `{{gray}}------------------------------{{/}}`
constant INDENTED_DELIMITER (line 25) | INDENTED_DELIMITER = ` {{gray}}------------------------------{{/}}`
function CLS (line 36) | func CLS(cls ...types.CodeLocation) []types.CodeLocation { return cls }
function CTS (line 37) | func CTS(componentTexts ...string) []string { return compon...
function CLabels (line 38) | func CLabels(labels ...Labels) []Labels { return labels }
function CSemVerConstraints (line 39) | func CSemVerConstraints(semVerConstraints ...SemVerConstraints) []SemVer...
function CComponentSemVerConstraints (line 42) | func CComponentSemVerConstraints(compSemVerConstraints ...ComponentSemVe...
function spr (line 45) | func spr(format string, args ...any) string { return fmt.Sprintf(format,...
type FailureNodeLocation (line 47) | type FailureNodeLocation
type ForwardedPanic (line 48) | type ForwardedPanic
type StackTrace (line 49) | type StackTrace
function TL (line 56) | func TL(options ...any) types.TimelineLocation {
function F (line 76) | func F(options ...any) types.Failure {
function AF (line 105) | func AF(state types.SpecState, options ...any) types.AdditionalFailure {
type STD (line 112) | type STD
type GW (line 113) | type GW
function S (line 116) | func S(options ...any) types.SpecReport {
type ConfigFlag (line 202) | type ConfigFlag
method Has (line 218) | func (cf ConfigFlag) Has(flag ConfigFlag) bool { return cf&flag != 0 }
method String (line 219) | func (cf ConfigFlag) String() string {
constant Succinct (line 205) | Succinct ConfigFlag = 1 << iota
constant Normal (line 206) | Normal
constant Verbose (line 207) | Verbose
constant VeryVerbose (line 208) | VeryVerbose
constant FullTrace (line 209) | FullTrace
constant ShowNodeEvents (line 210) | ShowNodeEvents
constant GithubOutput (line 211) | GithubOutput
constant SilenceSkips (line 212) | SilenceSkips
constant ForceNewlines (line 213) | ForceNewlines
constant Parallel (line 215) | Parallel
function C (line 254) | func C(flags ...ConfigFlag) types.ReporterConfig {
type ConfigCase (line 279) | type ConfigCase struct
function Case (line 284) | func Case(args ...any) ConfigCase {
type CurrentNodeText (line 297) | type CurrentNodeText
type CurrentStepText (line 298) | type CurrentStepText
type LeafNodeText (line 299) | type LeafNodeText
type AdditionalReports (line 300) | type AdditionalReports
function PR (line 302) | func PR(options ...any) types.ProgressReport {
function Fn (line 349) | func Fn(f string, filename string, line int, options ...any) types.Funct...
function G (line 369) | func G(options ...any) types.Goroutine {
function RE (line 392) | func RE(name string, cl types.CodeLocation, args ...any) types.ReportEnt...
function SE (line 408) | func SE(options ...any) types.SpecEvent {
FILE: reporters/deprecated_reporter.go
type DeprecatedReporter (line 13) | type DeprecatedReporter interface
function ReportViaDeprecatedReporter (line 29) | func ReportViaDeprecatedReporter(reporter DeprecatedReporter, report typ...
function failureFor (line 123) | func failureFor(spec types.SpecReport) types.DeprecatedSpecFailure {
FILE: reporters/deprecated_reporter_test.go
type deprecatedReporter (line 13) | type deprecatedReporter struct
method SuiteWillBegin (line 23) | func (dr *deprecatedReporter) SuiteWillBegin(config config.GinkgoConfi...
method BeforeSuiteDidRun (line 27) | func (dr *deprecatedReporter) BeforeSuiteDidRun(setupSummary *types.Se...
method SpecWillRun (line 30) | func (dr *deprecatedReporter) SpecWillRun(specSummary *types.SpecSumma...
method SpecDidComplete (line 33) | func (dr *deprecatedReporter) SpecDidComplete(specSummary *types.SpecS...
method AfterSuiteDidRun (line 36) | func (dr *deprecatedReporter) AfterSuiteDidRun(setupSummary *types.Set...
method SuiteDidEnd (line 39) | func (dr *deprecatedReporter) SuiteDidEnd(summary *types.SuiteSummary) {
FILE: reporters/gojson_report.go
function GenerateGoTestJSONReport (line 14) | func GenerateGoTestJSONReport(report types.Report, destination string) e...
function MergeAndCleanupGoTestJSONReports (line 36) | func MergeAndCleanupGoTestJSONReports(sources []string, destination stri...
FILE: reporters/json_report.go
function GenerateJSONReport (line 13) | func GenerateJSONReport(report types.Report, destination string) error {
function MergeAndCleanupJSONReports (line 35) | func MergeAndCleanupJSONReports(sources []string, destination string) ([...
FILE: reporters/junit_report.go
type JunitReportConfig (line 27) | type JunitReportConfig struct
type JUnitTestSuites (line 54) | type JUnitTestSuites struct
type JUnitTestSuite (line 71) | type JUnitTestSuite struct
type JUnitProperties (line 98) | type JUnitProperties struct
method WithName (line 102) | func (jup JUnitProperties) WithName(name string) string {
type JUnitProperty (line 111) | type JUnitProperty struct
type JUnitTestCase (line 118) | type JUnitTestCase struct
type JUnitSkipped (line 141) | type JUnitSkipped struct
type JUnitError (line 146) | type JUnitError struct
type JUnitFailure (line 155) | type JUnitFailure struct
function GenerateJUnitReport (line 164) | func GenerateJUnitReport(report types.Report, dst string) error {
function GenerateJUnitReportWithConfig (line 168) | func GenerateJUnitReportWithConfig(report types.Report, dst string, conf...
function MergeAndCleanupJUnitReports (line 336) | func MergeAndCleanupJUnitReports(sources []string, dst string) ([]string...
function failureDescriptionForUnstructuredReporters (line 377) | func failureDescriptionForUnstructuredReporters(spec types.SpecReport) s...
function systemErrForUnstructuredReporters (line 386) | func systemErrForUnstructuredReporters(spec types.SpecReport) string {
function RenderTimeline (line 390) | func RenderTimeline(spec types.SpecReport, noColor bool) string {
function systemOutForUnstructuredReporters (line 396) | func systemOutForUnstructuredReporters(spec types.SpecReport) string {
function formatComponentSemVerConstraintsToString (line 400) | func formatComponentSemVerConstraintsToString(componentSemVerConstraints...
type JUnitReporter (line 411) | type JUnitReporter struct
method SuiteWillBegin (line 414) | func (reporter *JUnitReporter) SuiteWillBegin(_ config.GinkgoConfigTyp...
method BeforeSuiteDidRun (line 415) | func (reporter *JUnitReporter) BeforeSuiteDidRun(_ *types.SetupSummary...
method SpecWillRun (line 416) | func (reporter *JUnitReporter) SpecWillRun(_ *types.SpecSummary) ...
method SpecDidComplete (line 417) | func (reporter *JUnitReporter) SpecDidComplete(_ *types.SpecSummary) ...
method AfterSuiteDidRun (line 418) | func (reporter *JUnitReporter) AfterSuiteDidRun(_ *types.SetupSummary)...
method SuiteDidEnd (line 419) | func (reporter *JUnitReporter) SuiteDidEnd(_ *types.SuiteSummary) ...
function NewJUnitReporter (line 413) | func NewJUnitReporter(_ string) *JUnitReporter ...
FILE: reporters/reporter.go
type Reporter (line 7) | type Reporter interface
type NoopReporter (line 20) | type NoopReporter struct
method SuiteWillBegin (line 22) | func (n NoopReporter) SuiteWillBegin(report types.Report) ...
method WillRun (line 23) | func (n NoopReporter) WillRun(report types.SpecReport) ...
method DidRun (line 24) | func (n NoopReporter) DidRun(report types.SpecReport) ...
method SuiteDidEnd (line 25) | func (n NoopReporter) SuiteDidEnd(report types.Report) ...
method EmitFailure (line 26) | func (n NoopReporter) EmitFailure(state types.SpecState, failure types...
method EmitProgressReport (line 27) | func (n NoopReporter) EmitProgressReport(progressReport types.Progress...
method EmitReportEntry (line 28) | func (n NoopReporter) EmitReportEntry(entry types.ReportEntry) ...
method EmitSpecEvent (line 29) | func (n NoopReporter) EmitSpecEvent(event types.SpecEvent) ...
FILE: reporters/reporters_suite_test.go
function TestReporters (line 12) | func TestReporters(t *testing.T) {
function FixtureFunction (line 19) | func FixtureFunction() {
FILE: reporters/teamcity_report.go
function tcEscape (line 20) | func tcEscape(s string) string {
function GenerateTeamcityReport (line 30) | func GenerateTeamcityReport(report types.Report, dst string) error {
function MergeAndCleanupTeamcityReports (line 108) | func MergeAndCleanupTeamcityReports(sources []string, dst string) ([]str...
FILE: reporting_dsl.go
function CurrentSpecReport (line 35) | func CurrentSpecReport() SpecReport {
function CurrentTreeConstructionNodeReport (line 60) | func CurrentTreeConstructionNodeReport() ConstructionNodeReport {
constant ReportEntryVisibilityAlways (line 75) | ReportEntryVisibilityAlways, ReportEntryVisibilityFailureOrVerbose, Repo...
function AddReportEntry (line 90) | func AddReportEntry(name string, args ...any) {
function ReportBeforeEach (line 118) | func ReportBeforeEach(body any, args ...any) bool {
function ReportAfterEach (line 142) | func ReportAfterEach(body any, args ...any) bool {
function ReportBeforeSuite (line 172) | func ReportBeforeSuite(body any, args ...any) bool {
function ReportAfterSuite (line 204) | func ReportAfterSuite(text string, body any, args ...any) bool {
function registerReportAfterSuiteNodeForAutogeneratedReports (line 210) | func registerReportAfterSuiteNodeForAutogeneratedReports(reporterConfig ...
FILE: table_dsl.go
type EntryDescription (line 24) | type EntryDescription
method render (line 26) | func (ed EntryDescription) render(args ...any) string {
function DescribeTable (line 47) | func DescribeTable(description string, args ...any) bool {
function FDescribeTable (line 56) | func FDescribeTable(description string, args ...any) bool {
function PDescribeTable (line 66) | func PDescribeTable(description string, args ...any) bool {
function DescribeTableSubtree (line 112) | func DescribeTableSubtree(description string, args ...any) bool {
function FDescribeTableSubtree (line 121) | func FDescribeTableSubtree(description string, args ...any) bool {
function PDescribeTableSubtree (line 131) | func PDescribeTableSubtree(description string, args ...any) bool {
type TableEntry (line 146) | type TableEntry struct
function Entry (line 165) | func Entry(description any, args ...any) TableEntry {
function FEntry (line 174) | func FEntry(description any, args ...any) TableEntry {
function PEntry (line 184) | func PEntry(description any, args ...any) TableEntry {
function generateTable (line 199) | func generateTable(description string, isSubtree bool, args ...any) {
function invokeFunction (line 319) | func invokeFunction(function any, parameters []any) []reflect.Value {
function validateParameters (line 342) | func validateParameters(function any, parameters []any, kind string, cl ...
function computeValue (line 380) | func computeValue(parameter any, t reflect.Type) reflect.Value {
FILE: types/around_node.go
type AroundNodeAllowedFuncs (line 7) | type AroundNodeAllowedFuncs interface
type AroundNodeFunc (line 10) | type AroundNodeFunc
function AroundNode (line 12) | func AroundNode[F AroundNodeAllowedFuncs](f F, cl CodeLocation) AroundNo...
type AroundNodeDecorator (line 38) | type AroundNodeDecorator struct
type AroundNodes (line 43) | type AroundNodes
method Clone (line 45) | func (an AroundNodes) Clone() AroundNodes {
method Append (line 51) | func (an AroundNodes) Append(other ...AroundNodeDecorator) AroundNodes {
FILE: types/code_location.go
type CodeLocation (line 13) | type CodeLocation struct
method String (line 20) | func (codeLocation CodeLocation) String() string {
method ContentsOfLine (line 27) | func (codeLocation CodeLocation) ContentsOfLine() string {
type codeLocationLocator (line 42) | type codeLocationLocator struct
method addHelper (line 48) | func (c *codeLocationLocator) addHelper(pc uintptr) {
method hasHelper (line 65) | func (c *codeLocationLocator) hasHelper(name string) bool {
method getCodeLocation (line 71) | func (c *codeLocationLocator) getCodeLocation(skip int) CodeLocation {
function MarkAsHelper (line 98) | func MarkAsHelper(optionalSkip ...int) {
function NewCustomCodeLocation (line 109) | func NewCustomCodeLocation(message string) CodeLocation {
function NewCodeLocation (line 115) | func NewCodeLocation(skip int) CodeLocation {
function NewCodeLocationWithStackTrace (line 119) | func NewCodeLocationWithStackTrace(skip int) CodeLocation {
function PruneStack (line 132) | func PruneStack(fullStackTrace string, skip int) string {
FILE: types/config.go
type SuiteConfig (line 19) | type SuiteConfig struct
function NewDefaultSuiteConfig (line 47) | func NewDefaultSuiteConfig() SuiteConfig {
type VerbosityLevel (line 57) | type VerbosityLevel
method GT (line 66) | func (vl VerbosityLevel) GT(comp VerbosityLevel) bool {
method GTE (line 70) | func (vl VerbosityLevel) GTE(comp VerbosityLevel) bool {
method Is (line 74) | func (vl VerbosityLevel) Is(comp VerbosityLevel) bool {
method LTE (line 78) | func (vl VerbosityLevel) LTE(comp VerbosityLevel) bool {
method LT (line 82) | func (vl VerbosityLevel) LT(comp VerbosityLevel) bool {
constant VerbosityLevelSuccinct (line 60) | VerbosityLevelSuccinct VerbosityLevel = iota
constant VerbosityLevelNormal (line 61) | VerbosityLevelNormal
constant VerbosityLevelVerbose (line 62) | VerbosityLevelVerbose
constant VerbosityLevelVeryVerbose (line 63) | VerbosityLevelVeryVerbose
type ReporterConfig (line 87) | type ReporterConfig struct
method Verbosity (line 104) | func (rc ReporterConfig) Verbosity() VerbosityLevel {
method WillGenerateReport (line 115) | func (rc ReporterConfig) WillGenerateReport() bool {
function NewDefaultReporterConfig (line 119) | func NewDefaultReporterConfig() ReporterConfig {
type CLIConfig (line 124) | type CLIConfig struct
method ComputedProcs (line 157) | func (g CLIConfig) ComputedProcs() int {
method ComputedNumCompilers (line 172) | func (g CLIConfig) ComputedNumCompilers() int {
function NewDefaultCLIConfig (line 150) | func NewDefaultCLIConfig() CLIConfig {
type GoFlagsConfig (line 184) | type GoFlagsConfig struct
method BinaryMustBePreserved (line 232) | func (g GoFlagsConfig) BinaryMustBePreserved() bool {
method NeedsSymbols (line 236) | func (g GoFlagsConfig) NeedsSymbols() bool {
function NewDefaultGoFlagsConfig (line 228) | func NewDefaultGoFlagsConfig() GoFlagsConfig {
type deprecatedConfig (line 241) | type deprecatedConfig struct
function BuildTestSuiteFlagSet (line 379) | func BuildTestSuiteFlagSet(suiteConfig *SuiteConfig, reporterConfig *Rep...
function VetConfig (line 393) | func VetConfig(flagSet GinkgoFlagSet, suiteConfig SuiteConfig, reporterC...
function VetAndInitializeCLIAndGoConfig (line 620) | func VetAndInitializeCLIAndGoConfig(cliConfig CLIConfig, goFlagsConfig G...
function GenerateGoTestCompileArgs (line 663) | func GenerateGoTestCompileArgs(goFlagsConfig GoFlagsConfig, packageToBui...
function GenerateGinkgoTestRunArgs (line 706) | func GenerateGinkgoTestRunArgs(suiteConfig SuiteConfig, reporterConfig R...
function GenerateGoTestRunArgs (line 722) | func GenerateGoTestRunArgs(goFlagsConfig GoFlagsConfig) ([]string, error) {
function BuildRunCommandFlagSet (line 737) | func BuildRunCommandFlagSet(suiteConfig *SuiteConfig, reporterConfig *Re...
function BuildWatchCommandFlagSet (line 758) | func BuildWatchCommandFlagSet(suiteConfig *SuiteConfig, reporterConfig *...
function BuildBuildCommandFlagSet (line 779) | func BuildBuildCommandFlagSet(cliConfig *CLIConfig, goFlagsConfig *GoFla...
function BuildLabelsCommandFlagSet (line 805) | func BuildLabelsCommandFlagSet(cliConfig *CLIConfig) (GinkgoFlagSet, err...
FILE: types/deprecated_types.go
type DeprecatedSuiteSummary (line 33) | type DeprecatedSuiteSummary struct
type DeprecatedSetupSummary (line 49) | type DeprecatedSetupSummary struct
type DeprecatedSpecSummary (line 61) | type DeprecatedSpecSummary struct
method HasFailureState (line 76) | func (s DeprecatedSpecSummary) HasFailureState() bool {
method TimedOut (line 80) | func (s DeprecatedSpecSummary) TimedOut() bool {
method Panicked (line 84) | func (s DeprecatedSpecSummary) Panicked() bool {
method Failed (line 88) | func (s DeprecatedSpecSummary) Failed() bool {
method Passed (line 92) | func (s DeprecatedSpecSummary) Passed() bool {
method Skipped (line 96) | func (s DeprecatedSpecSummary) Skipped() bool {
method Pending (line 100) | func (s DeprecatedSpecSummary) Pending() bool {
type DeprecatedSpecFailure (line 104) | type DeprecatedSpecFailure struct
type DeprecatedSpecMeasurement (line 114) | type DeprecatedSpecMeasurement struct
method PrecisionFmt (line 133) | func (s DeprecatedSpecMeasurement) PrecisionFmt() string {
FILE: types/deprecation_support.go
type Deprecation (line 13) | type Deprecation struct
type deprecations (line 19) | type deprecations struct
method CustomReporter (line 23) | func (d deprecations) CustomReporter() Deprecation {
method Async (line 31) | func (d deprecations) Async() Deprecation {
method Measure (line 39) | func (d deprecations) Measure() Deprecation {
method ParallelNode (line 47) | func (d deprecations) ParallelNode() Deprecation {
method CurrentGinkgoTestDescription (line 55) | func (d deprecations) CurrentGinkgoTestDescription() Deprecation {
method Convert (line 63) | func (d deprecations) Convert() Deprecation {
method Blur (line 71) | func (d deprecations) Blur() Deprecation {
method Nodot (line 78) | func (d deprecations) Nodot() Deprecation {
method SuppressProgressReporting (line 86) | func (d deprecations) SuppressProgressReporting() Deprecation {
type DeprecationTracker (line 93) | type DeprecationTracker struct
method TrackDeprecation (line 105) | func (d *DeprecationTracker) TrackDeprecation(deprecation Deprecation,...
method DidTrackDeprecations (line 124) | func (d *DeprecationTracker) DidTrackDeprecations() bool {
method DeprecationsReport (line 130) | func (d *DeprecationTracker) DeprecationsReport() string {
function NewDeprecationTracker (line 98) | func NewDeprecationTracker() *DeprecationTracker {
type SemVer (line 149) | type SemVer struct
method GreaterThanOrEqualTo (line 155) | func (s SemVer) GreaterThanOrEqualTo(o SemVer) bool {
function ParseSemVer (line 161) | func ParseSemVer(semver string) SemVer {
FILE: types/enum_support.go
type EnumSupport (line 5) | type EnumSupport struct
method String (line 22) | func (es EnumSupport) String(e uint) string {
method UnmarshJSON (line 29) | func (es EnumSupport) UnmarshJSON(b []byte) (uint, error) {
method MarshJSON (line 38) | func (es EnumSupport) MarshJSON(e uint) ([]byte, error) {
function NewEnumSupport (line 11) | func NewEnumSupport(toString map[uint]string) EnumSupport {
FILE: types/errors.go
type GinkgoError (line 11) | type GinkgoError struct
method Error (line 18) | func (g GinkgoError) Error() string {
type ginkgoErrors (line 38) | type ginkgoErrors struct
method UncaughtGinkgoPanic (line 42) | func (g ginkgoErrors) UncaughtGinkgoPanic(cl CodeLocation) error {
method RerunningSuite (line 65) | func (g ginkgoErrors) RerunningSuite() error {
method PushingNodeInRunPhase (line 75) | func (g ginkgoErrors) PushingNodeInRunPhase(nodeType NodeType, cl Code...
method CaughtPanicDuringABuildPhase (line 91) | func (g ginkgoErrors) CaughtPanicDuringABuildPhase(caughtPanic any, cl...
method SuiteNodeInNestedContext (line 109) | func (g ginkgoErrors) SuiteNodeInNestedContext(nodeType NodeType, cl C...
method SuiteNodeDuringRunPhase (line 126) | func (g ginkgoErrors) SuiteNodeDuringRunPhase(nodeType NodeType, cl Co...
method MultipleBeforeSuiteNodes (line 143) | func (g ginkgoErrors) MultipleBeforeSuiteNodes(nodeType NodeType, cl C...
method MultipleAfterSuiteNodes (line 147) | func (g ginkgoErrors) MultipleAfterSuiteNodes(nodeType NodeType, cl Co...
method InvalidDecoratorForNodeType (line 165) | func (g ginkgoErrors) InvalidDecoratorForNodeType(cl CodeLocation, nod...
method InvalidDeclarationOfFocusedAndPending (line 174) | func (g ginkgoErrors) InvalidDeclarationOfFocusedAndPending(cl CodeLoc...
method InvalidDeclarationOfFlakeAttemptsAndMustPassRepeatedly (line 183) | func (g ginkgoErrors) InvalidDeclarationOfFlakeAttemptsAndMustPassRepe...
method UnknownDecorator (line 192) | func (g ginkgoErrors) UnknownDecorator(cl CodeLocation, nodeType NodeT...
method InvalidBodyTypeForContainer (line 201) | func (g ginkgoErrors) InvalidBodyTypeForContainer(t reflect.Type, cl C...
method InvalidBodyType (line 210) | func (g ginkgoErrors) InvalidBodyType(t reflect.Type, cl CodeLocation,...
method InvalidBodyTypeForSynchronizedBeforeSuiteProc1 (line 224) | func (g ginkgoErrors) InvalidBodyTypeForSynchronizedBeforeSuiteProc1(t...
method InvalidBodyTypeForSynchronizedBeforeSuiteAllProcs (line 235) | func (g ginkgoErrors) InvalidBodyTypeForSynchronizedBeforeSuiteAllProc...
method MultipleBodyFunctions (line 246) | func (g ginkgoErrors) MultipleBodyFunctions(cl CodeLocation, nodeType ...
method MissingBodyFunction (line 255) | func (g ginkgoErrors) MissingBodyFunction(cl CodeLocation, nodeType No...
method InvalidTimeoutOrGracePeriodForNonContextNode (line 264) | func (g ginkgoErrors) InvalidTimeoutOrGracePeriodForNonContextNode(cl ...
method InvalidTimeoutOrGracePeriodForNonContextCleanupNode (line 273) | func (g ginkgoErrors) InvalidTimeoutOrGracePeriodForNonContextCleanupN...
method InvalidSerialNodeInNonSerialOrderedContainer (line 283) | func (g ginkgoErrors) InvalidSerialNodeInNonSerialOrderedContainer(cl ...
method SetupNodeNotInOrderedContainer (line 292) | func (g ginkgoErrors) SetupNodeNotInOrderedContainer(cl CodeLocation, ...
method InvalidContinueOnFailureDecoration (line 301) | func (g ginkgoErrors) InvalidContinueOnFailureDecoration(cl CodeLocati...
method DeferCleanupInvalidFunction (line 311) | func (g ginkgoErrors) DeferCleanupInvalidFunction(cl CodeLocation) err...
method PushingCleanupNodeDuringTreeConstruction (line 320) | func (g ginkgoErrors) PushingCleanupNodeDuringTreeConstruction(cl Code...
method PushingCleanupInReportingNode (line 329) | func (g ginkgoErrors) PushingCleanupInReportingNode(cl CodeLocation, n...
method PushingCleanupInCleanupNode (line 338) | func (g ginkgoErrors) PushingCleanupInCleanupNode(cl CodeLocation) err...
method TooManyReportEntryValues (line 348) | func (g ginkgoErrors) TooManyReportEntryValues(cl CodeLocation, arg an...
method AddReportEntryNotDuringRunPhase (line 357) | func (g ginkgoErrors) AddReportEntryNotDuringRunPhase(cl CodeLocation)...
method ByNotDuringRunPhase (line 367) | func (g ginkgoErrors) ByNotDuringRunPhase(cl CodeLocation) error {
method InvalidFileFilter (line 377) | func (g ginkgoErrors) InvalidFileFilter(filter string) error {
method InvalidFileFilterRegularExpression (line 385) | func (g ginkgoErrors) InvalidFileFilterRegularExpression(filter string...
method SyntaxErrorParsingLabelFilter (line 394) | func (g ginkgoErrors) SyntaxErrorParsingLabelFilter(input string, loca...
method InvalidLabel (line 417) | func (g ginkgoErrors) InvalidLabel(label string, cl CodeLocation) error {
method InvalidEmptyLabel (line 426) | func (g ginkgoErrors) InvalidEmptyLabel(cl CodeLocation) error {
method InvalidSemVerConstraint (line 435) | func (g ginkgoErrors) InvalidSemVerConstraint(semVerConstraint, errMsg...
method InvalidEmptySemVerConstraint (line 444) | func (g ginkgoErrors) InvalidEmptySemVerConstraint(cl CodeLocation) er...
method InvalidEmptyComponentForSemVerConstraint (line 453) | func (g ginkgoErrors) InvalidEmptyComponentForSemVerConstraint(cl Code...
method MultipleEntryBodyFunctionsForTable (line 463) | func (g ginkgoErrors) MultipleEntryBodyFunctionsForTable(cl CodeLocati...
method InvalidEntryDescription (line 472) | func (g ginkgoErrors) InvalidEntryDescription(cl CodeLocation) error {
method MissingParametersForTableFunction (line 481) | func (g ginkgoErrors) MissingParametersForTableFunction(cl CodeLocatio...
method IncorrectParameterTypeForTable (line 490) | func (g ginkgoErrors) IncorrectParameterTypeForTable(i int, name strin...
method TooFewParametersToTableFunction (line 499) | func (g ginkgoErrors) TooFewParametersToTableFunction(expected, actual...
method TooManyParametersToTableFunction (line 508) | func (g ginkgoErrors) TooManyParametersToTableFunction(expected, actua...
method IncorrectParameterTypeToTableFunction (line 517) | func (g ginkgoErrors) IncorrectParameterTypeToTableFunction(i int, exp...
method IncorrectVariadicParameterTypeToTableFunction (line 526) | func (g ginkgoErrors) IncorrectVariadicParameterTypeToTableFunction(ex...
method ContextsCannotBeUsedInSubtreeTables (line 535) | func (g ginkgoErrors) ContextsCannotBeUsedInSubtreeTables(cl CodeLocat...
method AggregatedReportUnavailableDueToNodeDisappearing (line 546) | func (g ginkgoErrors) AggregatedReportUnavailableDueToNodeDisappearing...
method SynchronizedBeforeSuiteFailedOnProc1 (line 553) | func (g ginkgoErrors) SynchronizedBeforeSuiteFailedOnProc1() error {
method SynchronizedBeforeSuiteDisappearedOnProc1 (line 560) | func (g ginkgoErrors) SynchronizedBeforeSuiteDisappearedOnProc1() error {
method UnknownTypePassedToRunSpecs (line 569) | func (g ginkgoErrors) UnknownTypePassedToRunSpecs(value any) error {
method InvalidParallelTotalConfiguration (line 578) | func (g ginkgoErrors) InvalidParallelTotalConfiguration() error {
method InvalidParallelProcessConfiguration (line 586) | func (g ginkgoErrors) InvalidParallelProcessConfiguration() error {
method MissingParallelHostConfiguration (line 594) | func (g ginkgoErrors) MissingParallelHostConfiguration() error {
method UnreachableParallelHost (line 602) | func (g ginkgoErrors) UnreachableParallelHost(host string) error {
method DryRunInParallelConfiguration (line 610) | func (g ginkgoErrors) DryRunInParallelConfiguration() error {
method GracePeriodCannotBeZero (line 617) | func (g ginkgoErrors) GracePeriodCannotBeZero() error {
method ConflictingVerbosityConfiguration (line 624) | func (g ginkgoErrors) ConflictingVerbosityConfiguration() error {
method InvalidOutputInterceptorModeConfiguration (line 631) | func (g ginkgoErrors) InvalidOutputInterceptorModeConfiguration(value ...
method InvalidGoFlagCount (line 638) | func (g ginkgoErrors) InvalidGoFlagCount() error {
method InvalidGoFlagParallel (line 645) | func (g ginkgoErrors) InvalidGoFlagParallel() error {
method BothRepeatAndUntilItFails (line 652) | func (g ginkgoErrors) BothRepeatAndUntilItFails() error {
method ExpectFilenameNotPath (line 659) | func (g ginkgoErrors) ExpectFilenameNotPath(flag string, path string) ...
method FlagAfterPositionalParameter (line 666) | func (g ginkgoErrors) FlagAfterPositionalParameter() error {
method FailedToParseStackTrace (line 675) | func (g ginkgoErrors) FailedToParseStackTrace(message string) error {
function ginkgoErrorMultipleSuiteNodes (line 151) | func ginkgoErrorMultipleSuiteNodes(setupOrTeardown string, nodeType Node...
FILE: types/file_filter.go
function ParseFileFilters (line 9) | func ParseFileFilters(filters []string) (FileFilters, error) {
type FileFilter (line 56) | type FileFilter struct
method Matches (line 61) | func (f FileFilter) Matches(locations []CodeLocation) bool {
type FileFilters (line 72) | type FileFilters
method Matches (line 74) | func (ffs FileFilters) Matches(locations []CodeLocation) bool {
type LineFilter (line 84) | type LineFilter struct
method Matches (line 89) | func (lf LineFilter) Matches(line int) bool {
type LineFilters (line 93) | type LineFilters
method Matches (line 95) | func (lfs LineFilters) Matches(line int) bool {
FILE: types/flags.go
type GinkgoFlag (line 14) | type GinkgoFlag struct
type GinkgoFlags (line 31) | type GinkgoFlags
method CopyAppend (line 33) | func (f GinkgoFlags) CopyAppend(flags ...GinkgoFlag) GinkgoFlags {
method WithPrefix (line 40) | func (f GinkgoFlags) WithPrefix(prefix string) GinkgoFlags {
method SubsetWithNames (line 60) | func (f GinkgoFlags) SubsetWithNames(names ...string) GinkgoFlags {
type GinkgoFlagSection (line 73) | type GinkgoFlagSection struct
type GinkgoFlagSections (line 81) | type GinkgoFlagSections
method Lookup (line 83) | func (gfs GinkgoFlagSections) Lookup(key string) (GinkgoFlagSection, b...
type GinkgoFlagSet (line 93) | type GinkgoFlagSet struct
method IsZero (line 211) | func (f GinkgoFlagSet) IsZero() bool {
method WasSet (line 215) | func (f GinkgoFlagSet) WasSet(name string) bool {
method Lookup (line 226) | func (f GinkgoFlagSet) Lookup(name string) *flag.Flag {
method Parse (line 230) | func (f GinkgoFlagSet) Parse(args []string) ([]string, error) {
method ValidateDeprecations (line 241) | func (f GinkgoFlagSet) ValidateDeprecations(deprecationTracker *Deprec...
method Usage (line 265) | func (f GinkgoFlagSet) Usage() string {
method substituteUsage (line 334) | func (f GinkgoFlagSet) substituteUsage() {
method usageForSection (line 366) | func (f GinkgoFlagSet) usageForSection(section GinkgoFlagSection) stri...
method usageForFlag (line 374) | func (f GinkgoFlagSet) usageForFlag(flag GinkgoFlag, style string) str...
method usageForGoFlag (line 408) | func (f GinkgoFlagSet) usageForGoFlag(goFlag *flag.Flag) string {
function NewGinkgoFlagSet (line 104) | func NewGinkgoFlagSet(flags GinkgoFlags, bindings any, sections GinkgoFl...
function NewAttachedGinkgoFlagSet (line 113) | func NewAttachedGinkgoFlagSet(flagSet *flag.FlagSet, flags GinkgoFlags, ...
function bindFlagSet (line 122) | func bindFlagSet(f GinkgoFlagSet, flagSet *flag.FlagSet) (GinkgoFlagSet,...
function valueAtKeyPath (line 338) | func valueAtKeyPath(root any, keyPath string) (reflect.Value, bool) {
type stringSliceVar (line 425) | type stringSliceVar struct
method String (line 429) | func (ssv stringSliceVar) String() string { return "" }
method Set (line 430) | func (ssv stringSliceVar) Set(s string) error {
function GenerateFlagArgs (line 436) | func GenerateFlagArgs(flags GinkgoFlags, bindings any) ([]string, error) {
FILE: types/label_filter.go
type LabelFilter (line 11) | type LabelFilter
function matchLabelAction (line 13) | func matchLabelAction(label string) LabelFilter {
function matchLabelRegexAction (line 25) | func matchLabelRegexAction(regex *regexp.Regexp) LabelFilter {
function notAction (line 36) | func notAction(filter LabelFilter) LabelFilter {
function andAction (line 40) | func andAction(a, b LabelFilter) LabelFilter {
function orAction (line 44) | func orAction(a, b LabelFilter) LabelFilter {
function labelSetFor (line 48) | func labelSetFor(key string, labels []string) map[string]bool {
function isEmptyLabelSetAction (line 64) | func isEmptyLabelSetAction(key string) LabelFilter {
function containsAnyLabelSetAction (line 70) | func containsAnyLabelSetAction(key string, expectedValues []string) Labe...
function containsAllLabelSetAction (line 82) | func containsAllLabelSetAction(key string, expectedValues []string) Labe...
function consistsOfLabelSetAction (line 94) | func consistsOfLabelSetAction(key string, expectedValues []string) Label...
function isSubsetOfLabelSetAction (line 109) | func isSubsetOfLabelSetAction(key string, expectedValues []string) Label...
type lfToken (line 125) | type lfToken
method Precedence (line 144) | func (l lfToken) Precedence() int {
method String (line 160) | func (l lfToken) String() string {
constant lfTokenInvalid (line 128) | lfTokenInvalid lfToken = iota
constant lfTokenRoot (line 130) | lfTokenRoot
constant lfTokenOpenGroup (line 131) | lfTokenOpenGroup
constant lfTokenCloseGroup (line 132) | lfTokenCloseGroup
constant lfTokenNot (line 133) | lfTokenNot
constant lfTokenAnd (line 134) | lfTokenAnd
constant lfTokenOr (line 135) | lfTokenOr
constant lfTokenRegexp (line 136) | lfTokenRegexp
constant lfTokenLabel (line 137) | lfTokenLabel
constant lfTokenSetKey (line 138) | lfTokenSetKey
constant lfTokenSetOperation (line 139) | lfTokenSetOperation
constant lfTokenSetArgument (line 140) | lfTokenSetArgument
constant lfTokenEOF (line 141) | lfTokenEOF
type treeNode (line 190) | type treeNode struct
method setRightNode (line 200) | func (tn *treeNode) setRightNode(node *treeNode) {
method setLeftNode (line 205) | func (tn *treeNode) setLeftNode(node *treeNode) {
method firstAncestorWithPrecedenceLEQ (line 210) | func (tn *treeNode) firstAncestorWithPrecedenceLEQ(precedence int) *tr...
method firstUnmatchedOpenNode (line 217) | func (tn *treeNode) firstUnmatchedOpenNode() *treeNode {
method constructLabelFilter (line 227) | func (tn *treeNode) constructLabelFilter(input string) (LabelFilter, e...
method tokenString (line 303) | func (tn *treeNode) tokenString() string {
method toString (line 312) | func (tn *treeNode) toString(indent int) string {
function tokenize (line 331) | func tokenize(input string) func() (*treeNode, error) {
function MustParseLabelFilter (line 479) | func MustParseLabelFilter(input string) LabelFilter {
function ParseLabelFilter (line 487) | func ParseLabelFilter(input string) (LabelFilter, error) {
function ValidateAndCleanupLabel (line 565) | func ValidateAndCleanupLabel(label string, cl CodeLocation) (string, err...
FILE: types/report_entry.go
type ReportEntryValue (line 11) | type ReportEntryValue struct
method GetRawValue (line 23) | func (rev ReportEntryValue) GetRawValue() any {
method String (line 27) | func (rev ReportEntryValue) String() string {
method MarshalJSON (line 44) | func (rev ReportEntryValue) MarshalJSON() ([]byte, error) {
method UnmarshalJSON (line 62) | func (rev *ReportEntryValue) UnmarshalJSON(data []byte) error {
method GobEncode (line 76) | func (rev ReportEntryValue) GobEncode() ([]byte, error) {
method GobDecode (line 80) | func (rev *ReportEntryValue) GobDecode(data []byte) error {
function WrapEntryValue (line 17) | func WrapEntryValue(value any) ReportEntryValue {
type ReportEntry (line 85) | type ReportEntry struct
method StringRepresentation (line 112) | func (entry ReportEntry) StringRepresentation() string {
method GetRawValue (line 121) | func (entry ReportEntry) GetRawValue() any {
method GetTimelineLocation (line 125) | func (entry ReportEntry) GetTimelineLocation() TimelineLocation {
type ColorableStringer (line 103) | type ColorableStringer interface
type ReportEntries (line 129) | type ReportEntries
method HasVisibility (line 131) | func (re ReportEntries) HasVisibility(visibilities ...ReportEntryVisib...
method WithVisibility (line 140) | func (re ReportEntries) WithVisibility(visibilities ...ReportEntryVisi...
type ReportEntryVisibility (line 153) | type ReportEntryVisibility
method String (line 170) | func (rev ReportEntryVisibility) String() string {
method UnmarshalJSON (line 173) | func (rev *ReportEntryVisibility) UnmarshalJSON(b []byte) error {
method MarshalJSON (line 178) | func (rev ReportEntryVisibility) MarshalJSON() ([]byte, error) {
method Is (line 182) | func (v ReportEntryVisibility) Is(visibilities ...ReportEntryVisibilit...
constant ReportEntryVisibilityAlways (line 157) | ReportEntryVisibilityAlways ReportEntryVisibility = iota
constant ReportEntryVisibilityFailureOrVerbose (line 159) | ReportEntryVisibilityFailureOrVerbose
constant ReportEntryVisibilityNever (line 161) | ReportEntryVisibilityNever
FILE: types/semver_filter.go
type SemVerFilter (line 10) | type SemVerFilter
function MustParseSemVerFilter (line 12) | func MustParseSemVerFilter(input string) SemVerFilter {
function ParseSemVerFilter (line 24) | func ParseSemVerFilter(componentFilterVersions string) (SemVerFilter, er...
function ValidateAndCleanupSemVerConstraint (line 111) | func ValidateAndCleanupSemVerConstraint(semVerConstraint string, cl Code...
FILE: types/types.go
constant GINKGO_FOCUS_EXIT_CODE (line 13) | GINKGO_FOCUS_EXIT_CODE = 197
function init (line 17) | func init() {
type ConstructionNodeReport (line 24) | type ConstructionNodeReport struct
method FullText (line 53) | func (report ConstructionNodeReport) FullText() string {
method Labels (line 63) | func (report ConstructionNodeReport) Labels() []string {
type Report (line 79) | type Report struct
method Add (line 145) | func (report Report) Add(other Report) Report {
type PreRunStats (line 138) | type PreRunStats struct
type SpecReport (line 181) | type SpecReport struct
method MarshalJSON (line 273) | func (report SpecReport) MarshalJSON() ([]byte, error) {
method CombinedOutput (line 348) | func (report SpecReport) CombinedOutput() string {
method Failed (line 360) | func (report SpecReport) Failed() bool {
method FullText (line 365) | func (report SpecReport) FullText() string {
method Labels (line 378) | func (report SpecReport) Labels() []string {
method SemVerConstraints (line 400) | func (report SpecReport) SemVerConstraints() []string {
method ComponentSemVerConstraints (line 422) | func (report SpecReport) ComponentSemVerConstraints() map[string][]str...
method MatchesLabelFilter (line 450) | func (report SpecReport) MatchesLabelFilter(query string) (bool, error) {
method MatchesSemVerFilter (line 459) | func (report SpecReport) MatchesSemVerFilter(version string) (bool, er...
method FileName (line 483) | func (report SpecReport) FileName() string {
method LineNumber (line 488) | func (report SpecReport) LineNumber() int {
method FailureMessage (line 493) | func (report SpecReport) FailureMessage() string {
method FailureLocation (line 498) | func (report SpecReport) FailureLocation() CodeLocation {
method Timeline (line 503) | func (report SpecReport) Timeline() Timeline {
type SpecReports (line 527) | type SpecReports
method WithLeafNodeType (line 530) | func (reports SpecReports) WithLeafNodeType(nodeTypes NodeType) SpecRe...
method WithState (line 550) | func (reports SpecReports) WithState(states SpecState) SpecReports {
method CountWithState (line 569) | func (reports SpecReports) CountWithState(states SpecState) int {
method CountOfFlakedSpecs (line 580) | func (reports SpecReports) CountOfFlakedSpecs() int {
method CountOfRepeatedSpecs (line 591) | func (reports SpecReports) CountOfRepeatedSpecs() int {
type TimelineLocation (line 602) | type TimelineLocation struct
type TimelineEvent (line 615) | type TimelineEvent interface
type Timeline (line 619) | type Timeline
method Len (line 621) | func (t Timeline) Len() int { return len(t) }
method Less (line 622) | func (t Timeline) Less(i, j int) bool {
method Swap (line 625) | func (t Timeline) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
method WithoutHiddenReportEntries (line 626) | func (t Timeline) WithoutHiddenReportEntries() Timeline {
method WithoutVeryVerboseSpecEvents (line 637) | func (t Timeline) WithoutVeryVerboseSpecEvents() Timeline {
type Failure (line 649) | type Failure struct
method IsZero (line 689) | func (f Failure) IsZero() bool {
method GetTimelineLocation (line 693) | func (f Failure) GetTimelineLocation() TimelineLocation {
type FailureNodeContext (line 698) | type FailureNodeContext
method String (line 715) | func (fnc FailureNodeContext) String() string {
method UnmarshalJSON (line 718) | func (fnc *FailureNodeContext) UnmarshalJSON(b []byte) error {
method MarshalJSON (line 723) | func (fnc FailureNodeContext) MarshalJSON() ([]byte, error) {
constant FailureNodeContextInvalid (line 701) | FailureNodeContextInvalid FailureNodeContext = iota
constant FailureNodeIsLeafNode (line 703) | FailureNodeIsLeafNode
constant FailureNodeAtTopLevel (line 704) | FailureNodeAtTopLevel
constant FailureNodeInContainer (line 705) | FailureNodeInContainer
type AdditionalFailure (line 730) | type AdditionalFailure struct
method GetTimelineLocation (line 735) | func (f AdditionalFailure) GetTimelineLocation() TimelineLocation {
type SpecState (line 741) | type SpecState
method String (line 768) | func (ss SpecState) String() string {
method GomegaString (line 771) | func (ss SpecState) GomegaString() string {
method UnmarshalJSON (line 774) | func (ss *SpecState) UnmarshalJSON(b []byte) error {
method MarshalJSON (line 779) | func (ss SpecState) MarshalJSON() ([]byte, error) {
method Is (line 785) | func (ss SpecState) Is(states SpecState) bool {
constant SpecStateInvalid (line 744) | SpecStateInvalid SpecState = 0
constant SpecStatePending (line 746) | SpecStatePending SpecState = 1 << iota
constant SpecStateSkipped (line 747) | SpecStateSkipped
constant SpecStatePassed (line 748) | SpecStatePassed
constant SpecStateFailed (line 749) | SpecStateFailed
constant SpecStateAborted (line 750) | SpecStateAborted
constant SpecStatePanicked (line 751) | SpecStatePanicked
constant SpecStateInterrupted (line 752) | SpecStateInterrupted
constant SpecStateTimedout (line 753) | SpecStateTimedout
type ProgressReport (line 790) | type ProgressReport struct
method IsZero (line 817) | func (pr ProgressReport) IsZero() bool {
method Time (line 821) | func (pr ProgressReport) Time() time.Time {
method SpecGoroutine (line 825) | func (pr ProgressReport) SpecGoroutine() Goroutine {
method HighlightedGoroutines (line 834) | func (pr ProgressReport) HighlightedGoroutines() []Goroutine {
method OtherGoroutines (line 845) | func (pr ProgressReport) OtherGoroutines() []Goroutine {
method WithoutCapturedGinkgoWriterOutput (line 856) | func (pr ProgressReport) WithoutCapturedGinkgoWriterOutput() ProgressR...
method WithoutOtherGoroutines (line 862) | func (pr ProgressReport) WithoutOtherGoroutines() ProgressReport {
method GetTimelineLocation (line 874) | func (pr ProgressReport) GetTimelineLocation() TimelineLocation {
type Goroutine (line 878) | type Goroutine struct
method IsZero (line 885) | func (g Goroutine) IsZero() bool {
method HasHighlights (line 889) | func (g Goroutine) HasHighlights() bool {
type FunctionCall (line 899) | type FunctionCall struct
type NodeType (line 909) | type NodeType
method String (line 970) | func (nt NodeType) String() string {
method UnmarshalJSON (line 973) | func (nt *NodeType) UnmarshalJSON(b []byte) error {
method MarshalJSON (line 978) | func (nt NodeType) MarshalJSON() ([]byte, error) {
method Is (line 982) | func (nt NodeType) Is(nodeTypes NodeType) bool {
constant NodeTypeInvalid (line 912) | NodeTypeInvalid NodeType = 0
constant NodeTypeContainer (line 914) | NodeTypeContainer NodeType = 1 << iota
constant NodeTypeIt (line 915) | NodeTypeIt
constant NodeTypeBeforeEach (line 917) | NodeTypeBeforeEach
constant NodeTypeJustBeforeEach (line 918) | NodeTypeJustBeforeEach
constant NodeTypeAfterEach (line 919) | NodeTypeAfterEach
constant NodeTypeJustAfterEach (line 920) | NodeTypeJustAfterEach
constant NodeTypeBeforeAll (line 922) | NodeTypeBeforeAll
constant NodeTypeAfterAll (line 923) | NodeTypeAfterAll
constant NodeTypeBeforeSuite (line 925) | NodeTypeBeforeSuite
constant NodeTypeSynchronizedBeforeSuite (line 926) | NodeTypeSynchronizedBeforeSuite
constant NodeTypeAfterSuite (line 927) | NodeTypeAfterSuite
constant NodeTypeSynchronizedAfterSuite (line 928) | NodeTypeSynchronizedAfterSuite
constant NodeTypeReportBeforeEach (line 930) | NodeTypeReportBeforeEach
constant NodeTypeReportAfterEach (line 931) | NodeTypeReportAfterEach
constant NodeTypeReportBeforeSuite (line 932) | NodeTypeReportBeforeSuite
constant NodeTypeReportAfterSuite (line 933) | NodeTypeReportAfterSuite
constant NodeTypeCleanupInvalid (line 935) | NodeTypeCleanupInvalid
constant NodeTypeCleanupAfterEach (line 936) | NodeTypeCleanupAfterEach
constant NodeTypeCleanupAfterAll (line 937) | NodeTypeCleanupAfterAll
constant NodeTypeCleanupAfterSuite (line 938) | NodeTypeCleanupAfterSuite
type SpecEvent (line 989) | type SpecEvent struct
method GetTimelineLocation (line 1001) | func (se SpecEvent) GetTimelineLocation() TimelineLocation {
method IsOnlyVisibleAtVeryVerbose (line 1005) | func (se SpecEvent) IsOnlyVisibleAtVeryVerbose() bool {
method GomegaString (line 1009) | func (se SpecEvent) GomegaString() string {
type SpecEvents (line 1031) | type SpecEvents
method WithType (line 1033) | func (se SpecEvents) WithType(seType SpecEventType) SpecEvents {
type SpecEventType (line 1043) | type SpecEventType
method String (line 1066) | func (se SpecEventType) String() string {
method UnmarshalJSON (line 1069) | func (se *SpecEventType) UnmarshalJSON(b []byte) error {
method MarshalJSON (line 1074) | func (se SpecEventType) MarshalJSON() ([]byte, error) {
method Is (line 1078) | func (se SpecEventType) Is(specEventTypes SpecEventType) bool {
constant SpecEventInvalid (line 1046) | SpecEventInvalid SpecEventType = 0
constant SpecEventByStart (line 1048) | SpecEventByStart SpecEventType = 1 << iota
constant SpecEventByEnd (line 1049) | SpecEventByEnd
constant SpecEventNodeStart (line 1050) | SpecEventNodeStart
constant SpecEventNodeEnd (line 1051) | SpecEventNodeEnd
constant SpecEventSpecRepeat (line 1052) | SpecEventSpecRepeat
constant SpecEventSpecRetry (line 1053) | SpecEventSpecRetry
FILE: types/types_suite_test.go
function TestTypes (line 11) | func TestTypes(t *testing.T) {
FILE: types/version.go
constant VERSION (line 3) | VERSION = "2.28.1"
Condensed preview — 498 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (2,717K chars).
[
{
"path": ".github/FUNDING.yml",
"chars": 15,
"preview": "github: [onsi]\n"
},
{
"path": ".github/dependabot.yml",
"chars": 417,
"preview": "version: 2\nupdates:\n- package-ecosystem: \"bundler\"\n directory: \"/docs\"\n schedule:\n interval: daily\n time: '01:00"
},
{
"path": ".github/workflows/codeql-analysis.yml",
"chars": 2628,
"preview": "# For most projects, this workflow file will not need changing; you simply need\n# to commit it to your repository.\n#\n# Y"
},
{
"path": ".github/workflows/test.yml",
"chars": 762,
"preview": "name: test\n\non: [push, pull_request]\n\npermissions:\n contents: read\n\njobs:\n mod:\n runs-on: ubuntu-latest\n name: C"
},
{
"path": ".gitignore",
"chars": 66,
"preview": ".DS_Store\nTODO\ntmp/**/*\n*.coverprofile\n.vscode\n.idea/\n*.log\n*.test"
},
{
"path": "CHANGELOG.md",
"chars": 53757,
"preview": "## 2.28.1\n\nUpdate all dependencies. This auto-updated the required version of Go to 1.24, consistent with the fact that"
},
{
"path": "CONTRIBUTING.md",
"chars": 933,
"preview": "# Contributing to Ginkgo\n\nYour contributions to Ginkgo are essential for its long-term maintenance and improvement.\n\n- P"
},
{
"path": "LICENSE",
"chars": 1062,
"preview": "Copyright (c) 2013-2014 Onsi Fakhouri\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of t"
},
{
"path": "Makefile",
"chars": 248,
"preview": "# default task since it's first\n.PHONY: all\nall: vet test\n\n.PHONY: test\ntest:\n\tgo run github.com/onsi/ginkgo/v2/ginkgo "
},
{
"path": "README.md",
"chars": 8001,
"preview": "\n\n[![test](https://github.com/onsi/ginkgo/actions/workflows/te"
},
{
"path": "RELEASING.md",
"chars": 858,
"preview": "A Ginkgo release is a tagged git sha and a GitHub release. To cut a release:\n\n1. Ensure CHANGELOG.md is up to date.\n -"
},
{
"path": "config/deprecated.go",
"chars": 3407,
"preview": "package config\n\n// GinkgoConfigType has been deprecated and its equivalent now lives in\n// the types package. You can n"
},
{
"path": "core_dsl.go",
"chars": 41034,
"preview": "/*\nGinkgo is a testing framework for Go designed to help you write expressive tests.\nhttps://github.com/onsi/ginkgo\nMIT-"
},
{
"path": "decorator_dsl.go",
"chars": 12506,
"preview": "package ginkgo\n\nimport (\n\t\"github.com/onsi/ginkgo/v2/internal\"\n\t\"github.com/onsi/ginkgo/v2/types\"\n)\n\n/*\nOffset(uint) is "
},
{
"path": "deprecated_dsl.go",
"chars": 4861,
"preview": "package ginkgo\n\nimport (\n\t\"time\"\n\n\t\"github.com/onsi/ginkgo/v2/internal\"\n\t\"github.com/onsi/ginkgo/v2/internal/global\"\n\t\"g"
},
{
"path": "docs/.gitignore",
"chars": 61,
"preview": "_site\r\n.sass-cache\r\n.jekyll-cache\r\n.jekyll-metadata\r\nvendor\r\n"
},
{
"path": "docs/Gemfile",
"chars": 1150,
"preview": "source \"https://rubygems.org\"\n# Hello! This is where you manage which Jekyll version is used to run.\n# When you want to "
},
{
"path": "docs/MIGRATING_TO_V2.md",
"chars": 48479,
"preview": "---\nlayout: default\ntitle: Migrating to Ginkgo V2\n---\n{% raw %}\n\n# Ginkgo 2.0 Migration Guide\n\n[Ginkgo 2.0](https://git"
},
{
"path": "docs/_config.yml",
"chars": 160,
"preview": "baseurl: \"/ginkgo\" # the subpath of your site, e.g. /blog\r\n\r\n# Build settings\r\nname: Ginkgo\r\nmarkdown: GFM\r\nhighlighter:"
},
{
"path": "docs/_layouts/default.html",
"chars": 1418,
"preview": "<!doctype html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta name=\"viewport\" content=\"width=device-wid"
},
{
"path": "docs/css/layout.css",
"chars": 5461,
"preview": ":root {\n\t--max-width: 1024px;\n\t--header-height: 50px;\n\t--breakpoint: 640px;\n\t--ginkgo-green: #2dad6c;\n\t--ginkgo-green-da"
},
{
"path": "docs/css/primer-minimal.css",
"chars": 10998,
"preview": ".markdown-body {\n line-height: 1.5;\n word-wrap: break-word;\n}\n\n.markdown-body > * :first-child {\n margin-top: 0"
},
{
"path": "docs/docs_suite_test.go",
"chars": 3142,
"preview": "package docs_test\n\nimport (\n\t\"go/ast\"\n\t\"go/doc\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"strings\"\n\t\"t"
},
{
"path": "docs/index.md",
"chars": 316904,
"preview": "---\nlayout: default\ntitle: Ginkgo\n---\n{% raw %}\n\n\n[Ginkgo](https://github.com/onsi/ginkgo"
},
{
"path": "docs/js/docs.js",
"chars": 2368,
"preview": "(() => {\n let sidebar = document.getElementById(\"sidebar\")\n let headings = document.querySelectorAll(\"#content h2,h3\")"
},
{
"path": "dsl/core/core_dsl.go",
"chars": 2684,
"preview": "/*\nGinkgo is usually dot-imported via:\n\n\timport . \"github.com/onsi/ginkgo/v2\"\n\nhowever some parts of the DSL may conflic"
},
{
"path": "dsl/decorators/decorators_dsl.go",
"chars": 1616,
"preview": "/*\nGinkgo is usually dot-imported via:\n\n\timport . \"github.com/onsi/ginkgo/v2\"\n\nhowever some parts of the DSL may conflic"
},
{
"path": "dsl/dsl_suite_test.go",
"chars": 1616,
"preview": "package dsl_test\n\nimport (\n\t\"go/ast\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/"
},
{
"path": "dsl/reporting/reporting_dsl.go",
"chars": 1256,
"preview": "/*\nGinkgo is usually dot-imported via:\n\n\timport . \"github.com/onsi/ginkgo/v2\"\n\nhowever some parts of the DSL may conflic"
},
{
"path": "dsl/table/table_dsl.go",
"chars": 1056,
"preview": "/*\nGinkgo is usually dot-imported via:\n\n\timport . \"github.com/onsi/ginkgo/v2\"\n\nhowever some parts of the DSL may conflic"
},
{
"path": "extensions/globals/globals.go",
"chars": 1404,
"preview": "// Package `globals` provides an interface to alter the global state of ginkgo suite.\n//\n// ginkgo currently registers a"
},
{
"path": "extensions/globals/globals_test.go",
"chars": 490,
"preview": "package globals_test\n\nimport (\n\t\"testing\"\n\n\t\"github.com/onsi/ginkgo/v2/extensions/globals\"\n\t\"github.com/onsi/ginkgo/v2/i"
},
{
"path": "extensions/table/deprecated.go",
"chars": 72,
"preview": "package table\n\ntype TableSupportHasBeenMovedToTheCoreGinkgoDSL struct{}\n"
},
{
"path": "formatter/colorable_others.go",
"chars": 1413,
"preview": "// +build !windows\n\n/*\nThese packages are used for colorize on Windows and contributed by mattn.jp@gmail.com\n\n * go-col"
},
{
"path": "formatter/colorable_windows.go",
"chars": 19114,
"preview": "/*\nThese packages are used for colorize on Windows and contributed by mattn.jp@gmail.com\n\n * go-colorable: <https://git"
},
{
"path": "formatter/formatter.go",
"chars": 5513,
"preview": "package formatter\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"regexp\"\n\t\"strconv\"\n\t\"strings\"\n)\n\n// ColorableStdOut and ColorableStdErr enabl"
},
{
"path": "formatter/formatter_suite_test.go",
"chars": 203,
"preview": "package formatter_test\n\nimport (\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nfunc TestForm"
},
{
"path": "formatter/formatter_test.go",
"chars": 5682,
"preview": "package formatter_test\n\nimport (\n\t\"os\"\n\t\"strings\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t\"github.com/onsi/ginkgo/v2/formatter\""
},
{
"path": "ginkgo/automaxprocs/README.md",
"chars": 235,
"preview": "This entire directory is a lightly modified clone of https://github.com/uber-go/automaxprocs\n\nIt will be removed when Go"
},
{
"path": "ginkgo/automaxprocs/automaxprocs.go",
"chars": 2516,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/cgroup.go",
"chars": 2372,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/cgroups.go",
"chars": 3938,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/cgroups2.go",
"chars": 4633,
"preview": "// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/cpu_quota_linux.go",
"chars": 2282,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/cpu_quota_unsupported.go",
"chars": 1477,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/errors.go",
"chars": 1882,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/mountpoint.go",
"chars": 5140,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/runtime.go",
"chars": 1719,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs/subsys.go",
"chars": 2887,
"preview": "// Copyright (c) 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtainin"
},
{
"path": "ginkgo/automaxprocs.go",
"chars": 114,
"preview": "//go:build !go1.25\n// +build !go1.25\n\npackage main\n\nimport (\n\t_ \"github.com/onsi/ginkgo/v2/ginkgo/automaxprocs\"\n)\n"
},
{
"path": "ginkgo/build/build_command.go",
"chars": 2230,
"preview": "package build\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"path\"\n\n\t\"github.com/onsi/ginkgo/v2/ginkgo/command\"\n\t\"github.com/onsi/ginkgo/v2/gi"
},
{
"path": "ginkgo/command/abort.go",
"chars": 1091,
"preview": "package command\n\nimport \"fmt\"\n\ntype AbortDetails struct {\n\tExitCode int\n\tError error\n\tEmitUsage bool\n}\n\nfunc Abort("
},
{
"path": "ginkgo/command/abort_test.go",
"chars": 2160,
"preview": "package command_test\n\nimport (\n\t\"fmt\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"github.com/onsi/gin"
},
{
"path": "ginkgo/command/command.go",
"chars": 1459,
"preview": "package command\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"strings\"\n\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n\t\"github.com/onsi/ginkgo/v2/ty"
},
{
"path": "ginkgo/command/command_suite_test.go",
"chars": 197,
"preview": "package command_test\n\nimport (\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nfunc TestComman"
},
{
"path": "ginkgo/command/command_test.go",
"chars": 3335,
"preview": "package command_test\n\nimport (\n\t\"strings\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n\t\"githu"
},
{
"path": "ginkgo/command/program.go",
"chars": 4560,
"preview": "package command\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"strings\"\n\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n\t\"github.com/onsi/ginkgo"
},
{
"path": "ginkgo/command/program_test.go",
"chars": 11107,
"preview": "package command_test\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n"
},
{
"path": "ginkgo/generators/boostrap_templates.go",
"chars": 1042,
"preview": "package generators\n\nvar bootstrapText = `package {{.Package}}\n\nimport (\n\t\"testing\"\n\n\t{{.GinkgoImport}}\n\t{{.GomegaImport}"
},
{
"path": "ginkgo/generators/bootstrap_command.go",
"chars": 4463,
"preview": "package generators\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"os\"\n\t\"text/template\"\n\n\tsprig \"github.com/go-task/slim-sp"
},
{
"path": "ginkgo/generators/generate_command.go",
"chars": 7750,
"preview": "package generators\n\nimport (\n\t\"bytes\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strconv\"\n\t\"strings\"\n\t\"text/templa"
},
{
"path": "ginkgo/generators/generate_templates.go",
"chars": 855,
"preview": "package generators\n\nvar specText = `{{.BuildTags}}\npackage {{.Package}}\n\nimport (\n\t{{.GinkgoImport}}\n\t{{.GomegaImport}}\n"
},
{
"path": "ginkgo/generators/generators_common.go",
"chars": 1764,
"preview": "package generators\n\nimport (\n\t\"fmt\"\n\t\"go/build\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/onsi/ginkgo/v"
},
{
"path": "ginkgo/ginkgo_cli_suite_test.go",
"chars": 428,
"preview": "package main\n\nimport (\n\t\"testing\"\n\n\t\"github.com/onsi/ginkgo/v2/internal/test_helpers\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t."
},
{
"path": "ginkgo/ginkgo_cli_test.go",
"chars": 409,
"preview": "package main\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nvar _ = Describe(\"Command Documenta"
},
{
"path": "ginkgo/internal/cli_internal_suite_test.go",
"chars": 400,
"preview": "package internal_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"testing\"\n)\n\nfunc TestCLIIn"
},
{
"path": "ginkgo/internal/compile.go",
"chars": 4606,
"preview": "package internal\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"sync\"\n\n\t\"github.com/onsi/ginkgo/v2/type"
},
{
"path": "ginkgo/internal/gocovmerge.go",
"chars": 4500,
"preview": "// Copyright (c) 2015, Wade Simmons\n// All rights reserved.\n\n// Redistribution and use in source and binary forms, with "
},
{
"path": "ginkgo/internal/profiles_and_reports.go",
"chars": 8318,
"preview": "package internal\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"strconv\"\n\n\t\"github.com/google/pprof/prof"
},
{
"path": "ginkgo/internal/run.go",
"chars": 15129,
"preview": "package internal\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"strings\"\n\t\"sync/atomic\"\n\t"
},
{
"path": "ginkgo/internal/test_suite.go",
"chars": 6350,
"preview": "package internal\n\nimport (\n\t\"errors\"\n\t\"math/rand\"\n\t\"os\"\n\t\"path\"\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"runtime\"\n\t\"strings\"\n\n\t\"gith"
},
{
"path": "ginkgo/internal/testsuite_test.go",
"chars": 14544,
"preview": "package internal_test\n\nimport (\n\t\"os\"\n\t\"path/filepath\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/ginkgo/v2/gin"
},
{
"path": "ginkgo/internal/utils.go",
"chars": 2047,
"preview": "package internal\n\nimport (\n\t\"fmt\"\n\t\"io\"\n\t\"os\"\n\t\"os/exec\"\n\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n\t\"github.com/onsi/ginkg"
},
{
"path": "ginkgo/internal/utils_test.go",
"chars": 3630,
"preview": "package internal_test\n\nimport (\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t\"github.com/onsi/gink"
},
{
"path": "ginkgo/internal/verify_version.go",
"chars": 2188,
"preview": "package internal\n\nimport (\n\t\"fmt\"\n\t\"os/exec\"\n\t\"regexp\"\n\t\"strings\"\n\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n\t\"github.com/o"
},
{
"path": "ginkgo/labels/labels_command.go",
"chars": 2934,
"preview": "package labels\n\nimport (\n\t\"fmt\"\n\t\"go/ast\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"sort\"\n\t\"strconv\"\n\t\"strings\"\n\n\t\"github.com/onsi/gink"
},
{
"path": "ginkgo/main.go",
"chars": 1539,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"github.com/onsi/ginkgo/v2/ginkgo/build\"\n\t\"github.com/onsi/ginkgo/v2/ginkgo/command"
},
{
"path": "ginkgo/outline/_testdata/alias_test.go",
"chars": 671,
"preview": "package example_test\n\nimport (\n\tfooginkgo \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = fooginkgo.Describe(\"NodotFixture\", func"
},
{
"path": "ginkgo/outline/_testdata/alias_test.go.csv",
"chars": 653,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,NodotFixture,81,670,false,false,false,\nDescribe,normal,126,259,"
},
{
"path": "ginkgo/outline/_testdata/alias_test.go.json",
"chars": 1849,
"preview": "[{\"name\":\"Describe\",\"text\":\"NodotFixture\",\"start\":81,\"end\":670,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[],"
},
{
"path": "ginkgo/outline/_testdata/create_result.sh",
"chars": 381,
"preview": "#!/usr/bin/env bash\nset -o errexit\nset -o nounset\n\nGINKGO=${GINKGO:-ginkgo}\n\ninput=${1:-\"\"}\nfor format in \"csv\" \"json\"; "
},
{
"path": "ginkgo/outline/_testdata/csv_proper_escaping_test.go",
"chars": 301,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = Describe(\"Abnormal\\\"Fixture\", func() {\n\tWhen(\"f"
},
{
"path": "ginkgo/outline/_testdata/csv_proper_escaping_test.go.csv",
"chars": 352,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,\"Abnormal\"\"Fixture\",73,300,false,false,false,\nWhen,\"four random"
},
{
"path": "ginkgo/outline/_testdata/csv_proper_escaping_test.go.json",
"chars": 716,
"preview": "[{\"name\":\"Describe\",\"text\":\"Abnormal\\\"Fixture\",\"start\":73,\"end\":300,\"spec\":false,\"focused\":false,\"pending\":false,\"labels"
},
{
"path": "ginkgo/outline/_testdata/dsl_core_test.go",
"chars": 217,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2/dsl/core\"\n)\n\nvar _ = Describe(\"DslCoreFixture\", func() {\n\tD"
},
{
"path": "ginkgo/outline/_testdata/dsl_core_test.go.csv",
"chars": 253,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,DslCoreFixture,82,216,false,false,false,\nDescribe,dslcore,119,2"
},
{
"path": "ginkgo/outline/_testdata/dsl_core_test.go.json",
"chars": 623,
"preview": "[{\"name\":\"Describe\",\"text\":\"DslCoreFixture\",\"start\":82,\"end\":216,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":["
},
{
"path": "ginkgo/outline/_testdata/focused_test.go",
"chars": 530,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = Describe(\"unfocused\", func() {\n\tFDescribe(\"focu"
},
{
"path": "ginkgo/outline/_testdata/focused_test.go.csv",
"chars": 658,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,unfocused,73,529,false,false,false,\nFDescribe,focused,105,202,f"
},
{
"path": "ginkgo/outline/_testdata/focused_test.go.json",
"chars": 1854,
"preview": "[{\"name\":\"Describe\",\"text\":\"unfocused\",\"start\":73,\"end\":529,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[],\"no"
},
{
"path": "ginkgo/outline/_testdata/labels_test.go",
"chars": 572,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = Describe(\"NormalFixture\", func() {\n\tDescribe(\"n"
},
{
"path": "ginkgo/outline/_testdata/labels_test.go.csv",
"chars": 684,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,NormalFixture,73,571,false,false,false,\nDescribe,normal,109,228"
},
{
"path": "ginkgo/outline/_testdata/labels_test.go.json",
"chars": 1882,
"preview": "[{\"name\":\"Describe\",\"text\":\"NormalFixture\",\"start\":73,\"end\":571,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[]"
},
{
"path": "ginkgo/outline/_testdata/mixed_test.go",
"chars": 585,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = FDescribe(\"unfocused\", func() {\n\tFContext(\"unfo"
},
{
"path": "ginkgo/outline/_testdata/mixed_test.go.csv",
"chars": 730,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nFDescribe,unfocused,73,584,false,false,false,\nFContext,unfocused,106,205"
},
{
"path": "ginkgo/outline/_testdata/mixed_test.go.json",
"chars": 2096,
"preview": "[{\"name\":\"FDescribe\",\"text\":\"unfocused\",\"start\":73,\"end\":584,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[],\"n"
},
{
"path": "ginkgo/outline/_testdata/nestedfocused_test.go",
"chars": 477,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = FDescribe(\"unfocused\", func() {\n\tFContext(\"unfo"
},
{
"path": "ginkgo/outline/_testdata/nestedfocused_test.go.csv",
"chars": 606,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nFDescribe,unfocused,73,476,false,false,false,\nFContext,unfocused,106,275"
},
{
"path": "ginkgo/outline/_testdata/nestedfocused_test.go.json",
"chars": 1724,
"preview": "[{\"name\":\"FDescribe\",\"text\":\"unfocused\",\"start\":73,\"end\":476,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[],\"n"
},
{
"path": "ginkgo/outline/_testdata/nodot_test.go",
"chars": 615,
"preview": "package example_test\n\nimport (\n\t\"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = ginkgo.Describe(\"NodotFixture\", func() {\n\tginkgo."
},
{
"path": "ginkgo/outline/_testdata/nodot_test.go.csv",
"chars": 653,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,NodotFixture,71,614,false,false,false,\nDescribe,normal,113,233,"
},
{
"path": "ginkgo/outline/_testdata/nodot_test.go.json",
"chars": 1849,
"preview": "[{\"name\":\"Describe\",\"text\":\"NodotFixture\",\"start\":71,\"end\":614,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[],"
},
{
"path": "ginkgo/outline/_testdata/normal_test.go",
"chars": 513,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = Describe(\"NormalFixture\", func() {\n\tDescribe(\"n"
},
{
"path": "ginkgo/outline/_testdata/normal_test.go.csv",
"chars": 654,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,NormalFixture,73,512,false,false,false,\nDescribe,normal,109,201"
},
{
"path": "ginkgo/outline/_testdata/normal_test.go.json",
"chars": 1850,
"preview": "[{\"name\":\"Describe\",\"text\":\"NormalFixture\",\"start\":73,\"end\":512,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[]"
},
{
"path": "ginkgo/outline/_testdata/pending_decorator_test.go",
"chars": 592,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = Describe(\"NormalFixture\", func() {\n\tDescribe(\"n"
},
{
"path": "ginkgo/outline/_testdata/pending_decorator_test.go.csv",
"chars": 679,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,NormalFixture,73,591,false,false,false,\nDescribe,normal,109,237"
},
{
"path": "ginkgo/outline/_testdata/pending_decorator_test.go.json",
"chars": 1877,
"preview": "[{\"name\":\"Describe\",\"text\":\"NormalFixture\",\"start\":73,\"end\":591,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[]"
},
{
"path": "ginkgo/outline/_testdata/pending_test.go",
"chars": 535,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\nvar _ = Describe(\"PendingFixture\", func() {\n\tPDescribe("
},
{
"path": "ginkgo/outline/_testdata/pending_test.go.csv",
"chars": 663,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,PendingFixture,73,534,false,false,false,\nPDescribe,pending,110,"
},
{
"path": "ginkgo/outline/_testdata/pending_test.go.json",
"chars": 1859,
"preview": "[{\"name\":\"Describe\",\"text\":\"PendingFixture\",\"start\":73,\"end\":534,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":["
},
{
"path": "ginkgo/outline/_testdata/position_test.go",
"chars": 241,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n)\n\n// Describe start=104, end=240\nvar _ = Describe(\"104,24"
},
{
"path": "ginkgo/outline/_testdata/position_test.go.csv",
"chars": 133,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\nDescribe,\"104,240\",104,240,false,false,false,\nIt,\"209,236\",209,236,true,"
},
{
"path": "ginkgo/outline/_testdata/position_test.go.json",
"chars": 248,
"preview": "[{\"name\":\"Describe\",\"text\":\"104,240\",\"start\":104,\"end\":240,\"spec\":false,\"focused\":false,\"pending\":false,\"labels\":[],\"nod"
},
{
"path": "ginkgo/outline/_testdata/suite_test.go",
"chars": 197,
"preview": "package example_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"testing\"\n)\n\nfunc TestExampl"
},
{
"path": "ginkgo/outline/_testdata/suite_test.go.csv",
"chars": 48,
"preview": "Name,Text,Start,End,Spec,Focused,Pending,Labels\n"
},
{
"path": "ginkgo/outline/_testdata/suite_test.go.json",
"chars": 3,
"preview": "[]\n"
},
{
"path": "ginkgo/outline/ginkgo.go",
"chars": 8585,
"preview": "package outline\n\nimport (\n\t\"go/ast\"\n\t\"go/token\"\n\t\"strconv\"\n\n\t\"github.com/onsi/ginkgo/v2/types\"\n)\n\nconst (\n\t// undefinedT"
},
{
"path": "ginkgo/outline/import.go",
"chars": 1583,
"preview": "// Copyright 2013 The Go Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style\n// license "
},
{
"path": "ginkgo/outline/outline.go",
"chars": 3445,
"preview": "package outline\n\nimport (\n\t\"bytes\"\n\t\"encoding/csv\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"go/ast\"\n\t\"go/token\"\n\t\"strconv\"\n\t\"strings\"\n\n"
},
{
"path": "ginkgo/outline/outline_command.go",
"chars": 2273,
"preview": "package outline\n\nimport (\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"os\"\n\n\t\"github.com/onsi/ginkgo/v2/ginkgo/com"
},
{
"path": "ginkgo/outline/outline_suite_test.go",
"chars": 197,
"preview": "package outline_test\n\nimport (\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nfunc TestOutlin"
},
{
"path": "ginkgo/outline/outline_test.go",
"chars": 7929,
"preview": "package outline\n\nimport (\n\t\"encoding/csv\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"log\"\n\t\"os\"\n\t\"path/filepath\""
},
{
"path": "ginkgo/performance/_fixtures/large_suite_fixture/large_suite_suite_test.go",
"chars": 324,
"preview": "package large_fixture_test\n\nimport (\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nfunc Test"
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/go.mod",
"chars": 332,
"preview": "module example.com/dependency_fetcher\n\ngo 1.16\n\nrequire github.com/onsi/gomega v1.13.0\n\nrequire github.com/gorilla/mux v"
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/go.sum",
"chars": 14852,
"preview": "github.com/cheekybits/is v0.0.0-20150225183255-68e9c0620927 h1:SKI1/fuSdodxmNNyVBR8d7X/HuLnRpvvFO0AgyQk764=\ngithub.com/c"
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/performance.go",
"chars": 269,
"preview": "package performance\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/gorilla/mux\"\n\t\"github.com/tdewolff/minify/v2\"\n\t\"golang.org/x/crypto/b"
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/performance_suite_test.go",
"chars": 407,
"preview": "package performance_test\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\t\"time\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\""
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/pkg1/pkg1_suite_test.go",
"chars": 569,
"preview": "package pkg1_test\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/gorilla/mux\"\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"gith"
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/pkg2/pkg2_suite_test.go",
"chars": 569,
"preview": "package pkg2_test\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/gorilla/mux\"\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"gith"
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/pkg3/pkg3_suite_test.go",
"chars": 569,
"preview": "package pkg3_test\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/gorilla/mux\"\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"gith"
},
{
"path": "ginkgo/performance/_fixtures/performance_fixture/pkg4/pkg4_suite_test.go",
"chars": 569,
"preview": "package pkg4_test\n\nimport (\n\t\"fmt\"\n\t\"testing\"\n\t\"time\"\n\n\t\"github.com/gorilla/mux\"\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"gith"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/096fe2f06efcf59513adb6cb0275d32a.gmeasure-cache",
"chars": 5434,
"preview": "{\"Name\":\"performance - compile concurrently [4] - run concurrently [4] - will compile first suite serially\",\"Version\":1}"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/1baac032c37c6eddc8381c02f73bab9c.gmeasure-cache",
"chars": 5351,
"preview": "{\"Name\":\"performance - compile concurrently [2] - run serially - will compile first suite serially\",\"Version\":1}\n{\"Name\""
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/2daaa9348ce35e03f3fb34ec83ffc542.gmeasure-cache",
"chars": 4711,
"preview": "{\"Name\":\"performance - go test -c; then run (serially)\",\"Version\":1}\n{\"Name\":\"performance - go test -c; then run (serial"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/34fa32127a8597d465872129ed999b27.gmeasure-cache",
"chars": 4923,
"preview": "{\"Name\":\"performance - compile concurrently [4] - run concurrently [2]\",\"Version\":1}\n{\"Name\":\"performance - compile conc"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/585dde06f8799aa0686577e4c76eee50.gmeasure-cache",
"chars": 841,
"preview": "{\"Name\":\"performance - go test ./...\",\"Version\":1}\n{\"Name\":\"performance - go test ./...\",\"Measurements\":[{\"Type\":\"Durati"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/5dde0a74da03182e70d258dbc7f9da5e.gmeasure-cache",
"chars": 2759,
"preview": "{\"Name\":\"performance - go test - run concurrently [8]\",\"Version\":1}\n{\"Name\":\"performance - go test - run concurrently [8"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/63f93d6849139270a9cf6c7562b5c5c2.gmeasure-cache",
"chars": 4847,
"preview": "{\"Name\":\"performance - compile concurrently [2] - run serially\",\"Version\":1}\n{\"Name\":\"performance - compile concurrently"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/7e079ed53f27697e0ae7f18ed2eef571.gmeasure-cache",
"chars": 2808,
"preview": "{\"Name\":\"performance - go test - run concurrently [2]\",\"Version\":1}\n{\"Name\":\"performance - go test - run concurrently [2"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/952f6c671d14a219922ff81d601950dc.gmeasure-cache",
"chars": 4811,
"preview": "{\"Name\":\"performance - compile concurrently [4] - run serially\",\"Version\":1}\n{\"Name\":\"performance - compile concurrently"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache",
"chars": 4747,
"preview": "{\"Name\":\"performance - compile serially - run serially\",\"Version\":1}\n{\"Name\":\"performance - compile serially - run seria"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/d913553546dde110d20fd36aa954b145.gmeasure-cache",
"chars": 2707,
"preview": "{\"Name\":\"performance - go test - serially\",\"Version\":1}\n{\"Name\":\"performance - go test - serially\",\"Measurements\":[{\"Typ"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/e8c3ef1eebd492c875763c75066b201d.gmeasure-cache",
"chars": 5317,
"preview": "{\"Name\":\"performance - compile concurrently [4] - run serially - will compile first suite serially\",\"Version\":1}\n{\"Name\""
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/f63d60f305dbd4ac27febbc09ca9d000.gmeasure-cache",
"chars": 4955,
"preview": "{\"Name\":\"performance - compile concurrently [2] - run concurrently [2]\",\"Version\":1}\n{\"Name\":\"performance - compile conc"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/f871828d82f74ed614c36d8f8d27f7f5.gmeasure-cache",
"chars": 5481,
"preview": "{\"Name\":\"performance - compile concurrently [2] - run concurrently [4] - will compile first suite serially\",\"Version\":1}"
},
{
"path": "ginkgo/performance/compiling-and-running-multiple-cache/ff4e55f973b442272532f4ac2daa0b13.gmeasure-cache",
"chars": 2815,
"preview": "{\"Name\":\"performance - go test - run concurrently [4]\",\"Version\":1}\n{\"Name\":\"performance - go test - run concurrently [4"
},
{
"path": "ginkgo/performance/compiling-and-running-single-cache/2daaa9348ce35e03f3fb34ec83ffc542.gmeasure-cache",
"chars": 1667,
"preview": "{\"Name\":\"performance - go test -c; then run (serially)\",\"Version\":1}\n{\"Name\":\"performance - go test -c; then run (serial"
},
{
"path": "ginkgo/performance/compiling-and-running-single-cache/cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache",
"chars": 1683,
"preview": "{\"Name\":\"performance - compile serially - run serially\",\"Version\":1}\n{\"Name\":\"performance - compile serially - run seria"
},
{
"path": "ginkgo/performance/compiling-and-running-single-cache/d913553546dde110d20fd36aa954b145.gmeasure-cache",
"chars": 1230,
"preview": "{\"Name\":\"performance - go test - serially\",\"Version\":1}\n{\"Name\":\"performance - go test - serially\",\"Measurements\":[{\"Typ"
},
{
"path": "ginkgo/performance/compiling_and_running_test.go",
"chars": 4694,
"preview": "package performance_test\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\t\"github.com"
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/1baac032c37c6eddc8381c02f73bab9c.gmeasure-cache",
"chars": 5312,
"preview": "{\"Name\":\"performance - compile concurrently [2] - run serially - will compile first suite serially\",\"Version\":1}\n{\"Name\""
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/23a884dc38ea0cf973e24d00d94dd6ed.gmeasure-cache",
"chars": 5641,
"preview": "{\"Name\":\"performance - compile concurrently [4] - run serially - will go mod download first\",\"Version\":1}\n{\"Name\":\"perfo"
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/55354cfa01f77f2c0d502c798e2b8262.gmeasure-cache",
"chars": 5519,
"preview": "{\"Name\":\"performance - compile serially - run serially - will go mod download first\",\"Version\":1}\n{\"Name\":\"performance -"
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/5eb5d96af3c34f61a070c450dddbf894.gmeasure-cache",
"chars": 5626,
"preview": "{\"Name\":\"performance - compile concurrently [2] - run serially - will go mod download first\",\"Version\":1}\n{\"Name\":\"perfo"
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/63f93d6849139270a9cf6c7562b5c5c2.gmeasure-cache",
"chars": 4819,
"preview": "{\"Name\":\"performance - compile concurrently [2] - run serially\",\"Version\":1}\n{\"Name\":\"performance - compile concurrently"
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/952f6c671d14a219922ff81d601950dc.gmeasure-cache",
"chars": 4819,
"preview": "{\"Name\":\"performance - compile concurrently [4] - run serially\",\"Version\":1}\n{\"Name\":\"performance - compile concurrently"
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/cb799de836ba52ec5dbc8328c8cfb89a.gmeasure-cache",
"chars": 4707,
"preview": "{\"Name\":\"performance - compile serially - run serially\",\"Version\":1}\n{\"Name\":\"performance - compile serially - run seria"
},
{
"path": "ginkgo/performance/fetching-dependencies-cache/e8c3ef1eebd492c875763c75066b201d.gmeasure-cache",
"chars": 5342,
"preview": "{\"Name\":\"performance - compile concurrently [4] - run serially - will compile first suite serially\",\"Version\":1}\n{\"Name\""
},
{
"path": "ginkgo/performance/fetching_dependencies_test.go",
"chars": 2562,
"preview": "package performance_test\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\t\"github.com"
},
{
"path": "ginkgo/performance/large-suite-cache/29caa3726740f30e27035121724c5be5.gmeasure-cache",
"chars": 461,
"preview": "{\"Name\":\"parallel-RPC-DUP-benchmark\",\"Version\":2}\n{\"Name\":\"parallel-RPC-DUP-benchmark\",\"Measurements\":[{\"Type\":\"Duration"
},
{
"path": "ginkgo/performance/large-suite-cache/483027456d601caec33292dbf280ca13.gmeasure-cache",
"chars": 467,
"preview": "{\"Name\":\"parallel-HTTP-DUP-benchmark\",\"Version\":2}\n{\"Name\":\"parallel-HTTP-DUP-benchmark\",\"Measurements\":[{\"Type\":\"Durati"
},
{
"path": "ginkgo/performance/large-suite-cache/54b26463f7c006bbf018993ad3bb66fc.gmeasure-cache",
"chars": 464,
"preview": "{\"Name\":\"parallel-RPC-SWAP-benchmark\",\"Version\":2}\n{\"Name\":\"parallel-RPC-SWAP-benchmark\",\"Measurements\":[{\"Type\":\"Durati"
},
{
"path": "ginkgo/performance/large-suite-cache/6f1839af2f330e23013bdb24a846760c.gmeasure-cache",
"chars": 467,
"preview": "{\"Name\":\"parallel-HTTP-NONE-benchmark\",\"Version\":2}\n{\"Name\":\"parallel-HTTP-NONE-benchmark\",\"Measurements\":[{\"Type\":\"Dura"
},
{
"path": "ginkgo/performance/large-suite-cache/e3c9c7bf7ee9b54d714975dcc0babed2.gmeasure-cache",
"chars": 464,
"preview": "{\"Name\":\"parallel-RPC-NONE-benchmark\",\"Version\":2}\n{\"Name\":\"parallel-RPC-NONE-benchmark\",\"Measurements\":[{\"Type\":\"Durati"
},
{
"path": "ginkgo/performance/large-suite-cache/e6de2fca259bb2567b057a5ec1929134.gmeasure-cache",
"chars": 431,
"preview": "{\"Name\":\"serial-benchmark\",\"Version\":2}\n{\"Name\":\"serial-benchmark\",\"Measurements\":[{\"Type\":\"Duration\",\"ExperimentName\":\""
},
{
"path": "ginkgo/performance/large-suite-cache/f9eea3525ae1eb0c1aea29bb32267883.gmeasure-cache",
"chars": 468,
"preview": "{\"Name\":\"parallel-HTTP-SWAP-benchmark\",\"Version\":2}\n{\"Name\":\"parallel-HTTP-SWAP-benchmark\",\"Measurements\":[{\"Type\":\"Dura"
},
{
"path": "ginkgo/performance/large_suite_test.go",
"chars": 3458,
"preview": "package performance_test\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\t\"github.com"
},
{
"path": "ginkgo/performance/performance_suite_test.go",
"chars": 13567,
"preview": "package performance_test\n\nimport (\n\t\"flag\"\n\t\"fmt\"\n\t\"math/rand\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"sync\"\n\t\"te"
},
{
"path": "ginkgo/run/run_command.go",
"chars": 7382,
"preview": "package run\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"strings\"\n\t\"time\"\n\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n\t\"github.com/onsi/ginkgo/v"
},
{
"path": "ginkgo/unfocus/unfocus_command.go",
"chars": 4095,
"preview": "package unfocus\n\nimport (\n\t\"bytes\"\n\t\"fmt\"\n\t\"go/ast\"\n\t\"go/parser\"\n\t\"go/token\"\n\t\"io\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"s"
},
{
"path": "ginkgo/watch/delta.go",
"chars": 534,
"preview": "package watch\n\nimport \"sort\"\n\ntype Delta struct {\n\tModifiedPackages []string\n\n\tNewSuites []*Suite\n\tRemovedSuites ["
},
{
"path": "ginkgo/watch/delta_tracker.go",
"chars": 1686,
"preview": "package watch\n\nimport (\n\t\"fmt\"\n\n\t\"regexp\"\n\n\t\"github.com/onsi/ginkgo/v2/ginkgo/internal\"\n)\n\ntype SuiteErrors map[internal"
},
{
"path": "ginkgo/watch/dependencies.go",
"chars": 1949,
"preview": "package watch\n\nimport (\n\t\"go/build\"\n\t\"strings\"\n)\n\ntype Dependencies struct {\n\tdeps map[string]int\n}\n\nfunc NewDependencie"
},
{
"path": "ginkgo/watch/package_hash.go",
"chars": 2290,
"preview": "package watch\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"regexp\"\n\t\"strings\"\n\t\"time\"\n)\n\nvar goTestRegExp = regexp.MustCompile(`_test\\.go$`)"
},
{
"path": "ginkgo/watch/package_hashes.go",
"chars": 1597,
"preview": "package watch\n\nimport (\n\t\"path/filepath\"\n\t\"regexp\"\n\t\"sync\"\n)\n\ntype PackageHashes struct {\n\tPackageHashes map[string]*Pac"
},
{
"path": "ginkgo/watch/suite.go",
"chars": 1923,
"preview": "package watch\n\nimport (\n\t\"fmt\"\n\t\"math\"\n\t\"time\"\n\n\t\"github.com/onsi/ginkgo/v2/ginkgo/internal\"\n)\n\ntype Suite struct {\n\tSui"
},
{
"path": "ginkgo/watch/watch_command.go",
"chars": 6150,
"preview": "package watch\n\nimport (\n\t\"fmt\"\n\t\"regexp\"\n\t\"time\"\n\n\t\"github.com/onsi/ginkgo/v2/formatter\"\n\t\"github.com/onsi/ginkgo/v2/gin"
},
{
"path": "ginkgo_cli_dependencies.go",
"chars": 131,
"preview": "//go:build ginkgoclidependencies\n// +build ginkgoclidependencies\n\npackage ginkgo\n\nimport (\n\t_ \"github.com/onsi/ginkgo/v2"
},
{
"path": "ginkgo_t_dsl.go",
"chars": 5845,
"preview": "package ginkgo\n\nimport (\n\t\"context\"\n\t\"io\"\n\t\"testing\"\n\n\t\"github.com/onsi/ginkgo/v2/internal/testingtproxy\"\n\t\"github.com/o"
},
{
"path": "go.mod",
"chars": 1302,
"preview": "module github.com/onsi/ginkgo/v2\n\ngo 1.24.0\n\nrequire (\n\tgithub.com/Masterminds/semver/v3 v3.4.0\n\tgithub.com/gkampitakis/"
},
{
"path": "go.sum",
"chars": 6526,
"preview": "github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=\ngithub.com/Masterminds/semver/v3"
},
{
"path": "integration/_fixtures/abort_fixture/abort_fixture_suite_test.go",
"chars": 583,
"preview": "package abort_fixture_test\n\nimport (\n\t\"testing\"\n\t\"time\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nf"
},
{
"path": "integration/_fixtures/after_run_hook_fixture/after_run_hook.go",
"chars": 112,
"preview": "package suite_command\n\nfunc Tested() string {\n\treturn \"tested\"\n}\n\nfunc Untested() string {\n\treturn \"untested\"\n}\n"
},
{
"path": "integration/_fixtures/after_run_hook_fixture/after_run_hook_suite_test.go",
"chars": 215,
"preview": "package suite_command_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"testing\"\n)\n\nfunc Test"
},
{
"path": "integration/_fixtures/after_run_hook_fixture/after_run_hook_test.go",
"chars": 310,
"preview": "package suite_command_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nvar _ = Describe(\"Tes"
},
{
"path": "integration/_fixtures/build_reporting_fixture/suite1/build_reporting_1_suite_test.go",
"chars": 211,
"preview": "package suite1_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"testing\"\n)\n\nfunc TestAfterRu"
},
{
"path": "integration/_fixtures/build_reporting_fixture/suite1/build_reporting_1_test.go",
"chars": 303,
"preview": "package suite1_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nvar _ = Describe(\"Testing\", "
},
{
"path": "integration/_fixtures/build_reporting_fixture/suite2/build_reporting_2_suite_test.go",
"chars": 211,
"preview": "package suite2_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"testing\"\n)\n\nfunc TestAfterRu"
},
{
"path": "integration/_fixtures/build_reporting_fixture/suite2/build_reporting_2_test.go",
"chars": 303,
"preview": "package suite2_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nvar _ = Describe(\"Testing\", "
},
{
"path": "integration/_fixtures/combined_coverage_fixture/first_package/coverage.go",
"chars": 194,
"preview": "package first_package\n\nfunc A() string {\n\treturn \"A\"\n}\n\nfunc B() string {\n\treturn \"B\"\n}\n\nfunc C() string {\n\treturn \"C\"\n}"
},
{
"path": "integration/_fixtures/combined_coverage_fixture/first_package/coverage_fixture_suite_test.go",
"chars": 225,
"preview": "package first_package_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"testing\"\n)\n\nfunc Test"
},
{
"path": "integration/_fixtures/combined_coverage_fixture/first_package/coverage_fixture_test.go",
"chars": 691,
"preview": "package first_package_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2/integration/_fixtures/combined_coverage_fixture/first"
},
{
"path": "integration/_fixtures/combined_coverage_fixture/first_package/external_coverage/external_coverage.go",
"chars": 116,
"preview": "package external_coverage\n\nfunc Tested() string {\n\treturn \"tested\"\n}\n\nfunc Untested() string {\n\treturn \"untested\"\n}\n"
},
{
"path": "integration/_fixtures/combined_coverage_fixture/second_package/coverage.go",
"chars": 188,
"preview": "package second_package\n\nfunc A() string {\n\treturn \"A\"\n}\n\nfunc B() string {\n\treturn \"B\"\n}\n\nfunc C() string {\n\treturn \"C\"\n"
},
{
"path": "integration/_fixtures/combined_coverage_fixture/second_package/coverage_fixture_suite_test.go",
"chars": 227,
"preview": "package second_package_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n\n\t\"testing\"\n)\n\nfunc Tes"
},
{
"path": "integration/_fixtures/combined_coverage_fixture/second_package/coverage_fixture_test.go",
"chars": 556,
"preview": "package second_package_test\n\nimport (\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/ginkgo/v2/integration/_fixtures"
},
{
"path": "integration/_fixtures/combined_coverage_fixture/third_package/third_package_suite_test.go",
"chars": 262,
"preview": "package third_package_test\n\nimport (\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/onsi/gomega\"\n)\n\nfunc Test"
},
{
"path": "integration/_fixtures/config_override_label_filter_fixture/config_override_fixture_suite_test.go",
"chars": 540,
"preview": "package config_override_label_filter_fixture_test\n\nimport (\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/on"
},
{
"path": "integration/_fixtures/config_override_must_pass_repeatedly_fixture/config_override_fixture_suite_test.go",
"chars": 554,
"preview": "package config_override_label_filter_fixture_test\n\nimport (\n\t\"testing\"\n\n\t. \"github.com/onsi/ginkgo/v2\"\n\t. \"github.com/on"
}
]
// ... and 298 more files (download for full content)
About this extraction
This page contains the full source code of the onsi/ginkgo GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 498 files (2.3 MB), approximately 638.3k tokens, and a symbol index with 1777 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.