Silly - better test runner for the D programming language

### Simple

###### Easy to install and use

It's just a test runner, how can it not be simple?
Add it as a dependency and run `dub test`.

### Fast

###### Compile tests fast, run tests faster

Running tests in parallel is a pretty common feature most of the test runners have.
Silly brings you this as well as lightning fast compilation times.

### Nonintrusive

###### Your code, your rules

You don't have to change a single line of your code (as long as it meets requirements).
Silly is just an another dependency. No more, no less.

## Requirements #

To be able to use silly in your project it has to satisfy the following requirements:

- It should be written in D and use latest DMD or LDC compiler (silly might work with older versions, but it's not guaranteed)
- It should use DUB
- It should not define `main` function when built in `unittest` mode (conditional compilation will help you here)
- Make sure there's no `targetType: executable` in `unittest` configuration in dub.json/dub.sdl. See #12 for more info

## Installation #

If your projects meets requirements, add the following to your `dub.json` or `dub.json` (depending on which one you're using)

#### dub.json

    {
    	<...>
    	"dependencies": {
    		<...>
    		"silly": "*"
    	}
    }

#### dub.sdl

    <...>
    dependency "silly" version="*"

## Usage #

As soon as you added silly to dependencies of your project, you can run tests with `dub test`

## Command-line options #

There are some command-line options you can use to change silly's behaviour

--no-colours
  Disable colours
-t `<n>`
--threads `<n>`
  Number of worker threads. `0` to auto-detect (default)
-i `<regexp>`
--include `<regexp>`
  Run tests if their name matches specified regular expression. See Choosing tests
-e `<regexp>`
--exclude `<regexp>`
  Skip tests if their name matches specified regular expression. See Choosing tests
-v
--verbose
  Show verbose output (full stack traces and durations)
-h
--help
  Help information

## Choosing tests to be run #

With `--include` and `--exclude` options it's possible to control which tests will be run. These options take regular expression in std.regex' format

`--include` option will tell silly to run tests which match specified regular expression. Other tests will be skipped
`--exclude` option will tell silly to skip tests which match specified regular expression. Other tests will be run

Note: these options match `<full test name (example.one.__unittest_L1_C1)> <pretty name | __unittest_L\d+_C\d+>` against specified regex. Because of that `^` assertions won't match beginning of the test name but beginning of the module name. Use `.*\s` to skip module part.
Using both options at the same can produce unexpected results and therefore is not advised

## In action #