Progmasoft Git

catch3

Progmasoft Catch3: an independently maintained C++17 test framework with a parallel runner, property checks, snapshots and structured results.

Clonegit clone https://git.progmasoft.com/catch3

Add table of contents

Commit
07211cea9c5d916f590a3791e845b1c83c8db81e
Author
Martin Moene ·
Committer
Martin Hořeňovský
Parents
c5553019cc26

Files · Download .tar.gz

Changes

 docs/assertions.md    |  6 ++++++
 docs/command-line.md  | 24 ++++++++++++++++++++++++
 docs/configuration.md |  9 +++++++++
 docs/slow-compiles.md |  6 ++++++
 docs/tutorial.md      |  9 +++++++++
 5 files changed, 54 insertions(+)

diff --git a/docs/assertions.md b/docs/assertions.md
index 3150b584..66d127bb 100644
--- a/docs/assertions.md
+++ b/docs/assertions.md
@@ -1,6 +1,12 @@
 <a id="top"></a>
 # Assertion Macros
 
+**Contents**  
+[Natural Expressions](#natural-expressions)  
+[Exceptions](#exceptions)  
+[Matcher expressions](#matcher-expressions)  
+[Thread Safety](#thread-safety)  
+
 Most test frameworks have a large collection of assertion macros to capture all possible conditional forms (```_EQUALS```, ```_NOTEQUALS```, ```_GREATER_THAN``` etc).
 
 Catch is different. Because it decomposes natural C-style conditional expressions most of these forms are reduced to one or two that you will use all the time. That said there are a rich set of auxilliary macros as well. We'll describe all of these here.
diff --git a/docs/command-line.md b/docs/command-line.md
index 12517bcc..00d55852 100644
--- a/docs/command-line.md
+++ b/docs/command-line.md
@@ -1,6 +1,30 @@
 <a id="top"></a>
 # Command line
 
+**Contents**  
+[Specifying which tests to run](#specifying-which-tests-to-run)  
+[Choosing a reporter to use](#choosing-a-reporter-to-use)  
+[Breaking into the debugger](#breaking-into-the-debugger)  
+[Showing results for successful tests](#showing-results-for-successful-tests)  
+[Aborting after a certain number of failures](#aborting-after-a-certain-number-of-failures)  
+[Listing available tests, tags or reporters](#listing-available-tests-tags-or-reporters)  
+[Sending output to a file](#sending-output-to-a-file)  
+[Naming a test run](#naming-a-test-run)  
+[Eliding assertions expected to throw](#eliding-assertions-expected-to-throw)  
+[Make whitespace visible](#make-whitespace-visible)  
+[Warnings](#warnings)  
+[Reporting timings](#reporting-timings)  
+[Load test names to run from a file](#load-test-names-to-run-from-a-file)  
+[Just test names](#just-test-names)  
+[Specify the order test cases are run](#specify-the-order-test-cases-are-run)  
+[Specify a seed for the Random Number Generator](#specify-a-seed-for-the-random-number-generator)  
+[Identify framework and version according to the libIdentify standard](#identify-framework-and-version-according-to-the-libidentify-standard)  
+[Wait for key before continuing](#wait-for-key-before-continuing)  
+[Specify multiples of clock resolution to run benchmarks for](#specify-multiples-of-clock-resolution-to-run-benchmarks-for)  
+[Usage](#usage)  
+[Specify the section to run](#specify-the-section-to-run)  
+[Filenames as tags](#filenames-as-tags)  
+
 Catch works quite nicely without any command line options at all - but for those times when you want greater control the following options are available.
 Click one of the followings links to take you straight to that option - or scroll on to browse the available options.
 
diff --git a/docs/configuration.md b/docs/configuration.md
index 9685973f..937e6122 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -1,6 +1,15 @@
 <a id="top"></a>
 # Compile-time configuration
 
+**Contents**  
+[main()/ implementation](#main-implementation)  
+[Prefixing Catch macros](#prefixing-catch-macros)  
+[Terminal colour](#terminal-colour)  
+[Console width](#console-width)  
+[stdout](#stdout)  
+[Other toggles](#other-toggles)  
+[Windows header clutter](#windows-header-clutter)  
+
 Catch is designed to "just work" as much as possible. For most people the only configuration needed is telling Catch which source file should host all the implementation code (```CATCH_CONFIG_MAIN```).
 
 Nonetheless there are still some occasions where finer control is needed. For these occasions Catch exposes a set of macros for configuring how it is built.
diff --git a/docs/slow-compiles.md b/docs/slow-compiles.md
index d1806d03..9696757d 100644
--- a/docs/slow-compiles.md
+++ b/docs/slow-compiles.md
@@ -1,6 +1,12 @@
 <a id="top"></a>
 # Why do my tests take so long to compile?
 
+**Contents**  
+[Short answer](#short-answer)  
+[Long answer](#long-answer)  
+[Practical example](#practical-example)  
+[Other possible solutions](#other-possible-solutions)  
+
 Several people have reported that test code written with Catch takes much longer to compile than they would expect. Why is that?
 
 Catch is implemented entirely in headers. There is a little overhead due to this - but not as much as you might think - and you can minimise it simply by organising your test code as follows:
diff --git a/docs/tutorial.md b/docs/tutorial.md
index 80465ba2..ebc20fd2 100644
--- a/docs/tutorial.md
+++ b/docs/tutorial.md
@@ -1,6 +1,15 @@
 <a id="top"></a>
 # Tutorial
 
+**Contents**  
+[Getting Catch](#getting-catch)  
+[Where to put it?](#where-to-put-it)  
+[Writing tests](#writing-tests)  
+[Test cases and sections](#test-cases-and-sections)  
+[BDD-Style](#bdd-style)  
+[Scaling up](#scaling-up)  
+[Next steps](#next-steps)  
+
 ## Getting Catch
 
 The simplest way to get Catch is to download the latest [single header version](https://raw.githubusercontent.com/philsquared/Catch/master/single_include/catch.hpp). The single header is generated by merging a set of individual headers but it is still just normal source code in a header file.