This also adds two test utilities from dune-functions
that are both used in this test.

* TestSuite: A helper class to organize checks in tests
  in a unified way and more readable way.
* CollectorStream: A simple stream that allows to collect
  data and forward it to its creator using a callback.
  Used by testsuite.hh

Since can also be used for tests in other modules they
are installed in dune/common/test. However, CollectorStream
is not strictly related to tests and may also be moved directly
to dune/common/.

This removed the recently added prioritytag.hh
header again. Having a separate header for each
of these trivial helpers will only clutter the
directory and make people lookup the correct
header more often.

This header should be used to collect all utilities for
type computations, constraining overloads, and similar
purposes, that are not type-traits.

The main feature of this header is the constexpr function
models(). The result of

  models<C, T1, ..., TN>()

indicated if the concept C is modeled by the collection
(T1, ..., TN) of types. A concept is a list of valid
expressions that a type must support. Concepts can refine
other concepts to inherit all requirements from those
base concepts.

Besides the concept check function itself, the header contains
some helper functions of the form require requireFoo for additional
checks. The purpose of those functions is to transform a non-satisfied
condition Foo to a substitution failure, such that the corresponding
expression is not valid. E.g.,

  requireConvertible<R>(t.f())

is not valid unless the result of t.f() is convertible to R.

We should always export ::Type and ::type to follow
the dune convention and the std pattern for type traits.

This can be used to 'store' an argument pack and access
its members. In contrast to a std::tuple<T...> which is
a container of objects of types T... a TypeList<T...>
only captures the types T... . Hence one can easily
create TypeList objects and use them to pass types around
or. e.g., in overload resolution where they can be used for
tag-dispatch.

This class is e.g. used in the concept checking facility
I'll add soon.

Notice that adding a template packer<T...> doing exactly
the same has been proposed for the standard in N4115

  http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4115.html

This is intended to contain everything related to type
computations, like, e.g., type traits, helpers for
overload resolution, ...

GitLab readable contribution guide, license and README

Adding the `.md` extension enables rendering of the files, which is much nicer.

Also ported the contribution guide from the User Wiki.

Renamed COPYING to LICENSE.md because that is the name that GitLab looks for to display it nicely on the project starting page.

If this one is accepted, I will do the same for the other core modules.

See merge request !5

Conans ancient compiler has problems since the latest
changes to the Dune Exceptions. We switch the dune-common
check to a more easy header...

Implement some new features for dune_add_test

* `COMMANDS` was requested by @tkoch on the mailing list
* `COMPILE_ONLY` is useful for my latest YaspGrid tests, that check the code with and without deprecated interface features.
* `TIMEOUT` sets the timeout for ctest and is need in parallel testing

See merge request !1

This reverts commit 8bd9ff56.

The commit did not apply the correct fix, as MPI_RANKS is not a number
but a list of ranks instead. Also, I doubt the existence of ">".

ADDTEST_MPI_RANKS is set two lines above if it has been emtpy.

This allows to give priorities to otherwise ambiguous
overloads. It's main use is to make multiple overloads
work, when only some are ruled out via SFINAE. This is
e.g. used in the concepts check that I'll move to
dune-common soon.

The implemention is trivial but makes such applications
more readable and idiomatic compared to other approaches
where, e.g., null pointers are passed to overloads
have T* and void* dummy arguments.

Due to it's simplicity a separate header may not be justified,
but none of the existing seems to fit.

It needs to be specified when using MPI_RANKS. IT otherwise
defaults to 5 minutes. No test should ever run that long, I
guess, but the default keeps automated systems from entirely
hanging up.

It does not work the other way round, because gitlab is stupid.

Some whitespace changes included to make the more strict
whitespace hook happy (tabs removed).

Mostly C&P from the User wiki, with adjustments
to the new workflow.

Feature/dune exception derived from std exception

I almost missed Christian's last commit. It was poor luck  that I had a look into the commit history before replacing the old remote URL by the new, Gitlab-based one. I manually transferred his commit and saved myself the work of programming what Christian already did.

See merge request !2

Set if the given test should only be compiled during `make build_tests`,
but not run during `make test`. This is useful if you compile the same
executable twice, but with different compile flags, where you want to assue that
it compiles with both sets of flags, but you already know they will produce the
same result.

It allows to specify an arbitrary command to be executed
when running the test. This may for example be used to wrap
a script around a C++ executable.

Previously, the script that splits the in-module documentation
into parts exited with cryptic error messages that gave no hint
on where the typo happened. It now prints the offending line.

In dune-testtools we built a sphinx cmake documentation which is customized
quite a bit. With the core functionality being in dune-common, it is hard
to maintain it twice. I have therefore added some options to the dune-common
doc infrastructure, that are beneficial downstream.

You can now:
* provide custom rst sources
* provide a custom sphinx-build conf file
* limit the documentation to the current module, instead of adding all requirements automatically

The defaults of all those parameters result in an unchanged behaviour
(compared to before this commit).

As talked about on the developer meeting, a configure
switch should allow to build the tests during make all.
You can either set it through your opts file or activate
it on a per module level. If not active, you have to run

make build_tests && make test

to run the test suite.

We should always use the DUNE_ prefix for our cmake
variables, to avoid scoping clashes and to stay consistent.

Sorry for not doing this immediately, it was an oversight.