Refactor single-program channel test to Boost.Test suites and cases

Motivation:
- state clearly what is covered with tests without reading non-trivial code
- avoid cleverness - tests should be no-brainer
- get closer to one test case targets one feature/beaviour with one check
- replace obscure `throw std::exception` with diagnostics that are actually
  useful to pin-point failure cause and location - makes CI logs useful.
- allow to select and run specific tests
- make tests maintenance easy, quick and fun

Propose new structure of tests that reflects the previous tests hierarchy,
but organizes channel tests in test/channel directory with test programs
each covering specific library feature (or set of closely related features).

The refactored tests cover 100% of checks from the old `channel.cpp`,
plus it refines or adds a bunch more.
NOTE: old test/channel.cpp has not been removed yet.

Common definitions from the single test/channel.cpp moved to
channel_test_fixtures.hpp and namespace boost::gil::test::fixture:
Classes and typedefs:
- `do_test` as `fixture::channel`
- `value_core` as `fixture::channel_value`
- `reference_core` as `fixture::channel_reference`
- `packed_reference_core` as `fixture::packed_channel_reference`
- `packed_dynamic_reference_core` as `fixture::packed_dynamic_channel_reference`
- `channel_archetype` and relatives to `channel_concepts.cpp` which is compile
   test in Jamfile
- `test_packed_channel_reference()` parts as `fixture::packed_channels565`
- `test_packed_dynamic_channel_reference()` parts as `fixture::packed_dynamic_channels565`
Test case functions called from `do_test<T>::test_all`:
- `test_channel_invert()` to `algorithm_channel_invert.cpp` suite
- `test_channel_convert()` to `algorithm_channel_convert.cpp` suite
- `test_channel_multiply()` to `algorithm_channel_multiply.cpp` suite
- `test_channel_math()` split to `algorithm_channel_relation.cpp`
   and `algorithm_channel_arithmetic.cpp`

Add test cases for each channel value type T as used to run from
`test_channel_value_impl<T>`, `test_packed_channel_reference<T>` and
`test_packed_dynamic_channel_reference<T>`.

Add list of possible T-s defined as type-lists `fixture::channel_byte_types`,
`fixture::channel_integer_types`, `channel_float_types` and
`channel_bitfield_types` which used with `BOOST_AUTO_TEST_CASE_TEMPLATE`
generate all possible combination of inputs.

Add new `channel_test_fixture.cpp` is a self-test suite verifying the fixtures.

test/channel/algorithm_channel_arithmetic.cpp

@@ -0,0 +1,112 @@
+//
+// Copyright 2005-2007 Adobe Systems Incorporated
+// Copyright 2018 Mateusz Loskot <mateusz at loskot dot net>
+//
+// Distributed under the Boost Software License, Version 1.0
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+//
+#include <boost/gil/channel_algorithm.hpp>
+#include <type_traits>
+#include <utility>
+
+#define BOOST_TEST_MODULE test_algorithm_channel_arithmetic
+#include <gil_test_common.hpp>
+#include "channel_test_fixture.hpp"
+
+namespace gil = boost::gil;
+namespace fixture = boost::gil::test::fixture;
+
+template <typename ChannelFixtureBase>
+void test_channel_arithmetic_mutable(boost::mpl::false_)  {}
+
+template <typename ChannelFixtureBase>
+void test_channel_arithmetic_mutable(boost::mpl::true_)
+{
+    using fixture_t = fixture::channel<ChannelFixtureBase>;
+    using channel_value_t = typename fixture_t::channel_value_t;
+    fixture_t f;
+    channel_value_t const v = f.min_v_;
+
+    ++f.min_v_;
+    f.min_v_++;
+    --f.min_v_;
+    f.min_v_--;
+    BOOST_TEST(v == f.min_v_);
+
+    f.min_v_ += 1;
+    f.min_v_ -= 1;
+    BOOST_TEST(v == f.min_v_);
+
+    f.min_v_ *= 1;
+    f.min_v_ /= 1;
+    BOOST_TEST(v == f.min_v_);
+
+    f.min_v_ = 1; // assignable to scalar
+    BOOST_TEST(f.min_v_ == 1);
+    f.min_v_ = v; // and to value type
+    BOOST_TEST(f.min_v_ == v);
+
+    // test swap
+    channel_value_t v1 = f.min_v_;
+    channel_value_t v2 = f.max_v_;
+    std::swap(f.min_v_, f.max_v_);
+    BOOST_TEST(f.min_v_ > f.max_v_);
+    channel_value_t v3 = f.min_v_;
+    channel_value_t v4 = f.max_v_;
+    BOOST_TEST(v1 == v4);
+    BOOST_TEST(v2 == v3);
+}
+
+template <typename ChannelFixtureBase>
+void test_channel_arithmetic()
+{
+    using fixture_t = fixture::channel<ChannelFixtureBase>;
+    fixture_t f;
+    BOOST_TEST(f.min_v_ * 1 == f.min_v_);
+    BOOST_TEST(f.min_v_ / 1 == f.min_v_);
+    BOOST_TEST((f.min_v_ + 1) + 1 == f.min_v_ + 2);
+    BOOST_TEST((f.max_v_ - 1) - 1 == f.max_v_ - 2);
+
+    using is_mutable_t = boost::mpl::bool_
+        <
+        gil::channel_traits<typename fixture_t::channel_t>::is_mutable
+        >;
+    test_channel_arithmetic_mutable<ChannelFixtureBase>(is_mutable_t());
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(channel_value, Channel, fixture::channel_byte_types)
+{
+    using fixture_t = fixture::channel_value<Channel>;
+    test_channel_arithmetic<fixture_t>();
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(channel_reference, Channel, fixture::channel_byte_types)
+{
+    using fixture_t = fixture::channel_reference<Channel&>;
+    test_channel_arithmetic<fixture_t>();
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(
+    channel_reference_const, Channel, fixture::channel_byte_types)
+{
+    using fixture_t = fixture::channel_reference<Channel const&>;
+    test_channel_arithmetic<fixture_t>();
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(
+    packed_channel_reference, BitField, fixture::channel_bitfield_types)
+{
+    using channels565_t = fixture::packed_channels565<BitField>;
+    test_channel_arithmetic<typename channels565_t::fixture_0_5_t>();
+    test_channel_arithmetic<typename channels565_t::fixture_5_6_t >();
+    test_channel_arithmetic<typename channels565_t::fixture_11_5_t>();
+}
+
+BOOST_AUTO_TEST_CASE_TEMPLATE(
+    packed_dynamic_channel_reference, BitField, fixture::channel_bitfield_types)
+{
+    using channels565_t = fixture::packed_dynamic_channels565<BitField>;
+    test_channel_arithmetic<typename channels565_t::fixture_5_t>();
+    test_channel_arithmetic<typename channels565_t::fixture_6_t>();
+}