Merge pull request #5 from steinwurf/add-tests

Add tests

src/ASBeautifier.cpp

@@ -2909,12 +2909,13 @@ void ASBeautifier::parseCurrentLine(const string& line)
 			if (!inStatementIndentStack->empty())
 			{
                 bool initializerBlock =
-                    (isInStatement && (prevNonSpaceCh == ',' || prevNonSpaceCh == '('));
+                    (prevNonSpaceCh == ',' || prevNonSpaceCh == '('
+                            || prevNonSpaceCh == '{');
 
                 // Purge the inStatementIndentStack if the line begins with '{'
                 // and this is not a possible initializer block in a statement,
                 // for example: function(arg, { 1, 2, 3, 4 });
-                if (lineBeginsWithOpenBracket && !initializerBlock)
+                if (i == 0 && !initializerBlock)
                 {
 				    while (!inStatementIndentStack->empty())
 					    popLastInStatementIndent();

test/correct_style.cpp

@@ -0,0 +1,796 @@
+// Copyright comment
+
+#pragma once
+
+#include <iostream>
+#include <vector>
+#include <cstdint>
+#include <string>
+
+// Indented preprocessor statements
+#if defined(PLATFORM_WINDOWS_PHONE)
+    #if defined(PLATFORM_MSVC_ARM)
+        // NEON introduced in VS2012
+        #if (_MSC_VER >= 1700)
+            #define PLATFORM_NEON 1
+        #endif
+    #endif
+#elif defined(PLATFORM_MSVC_X86)
+    // SSSE3, SSE4.1, SSE4.2, PCLMUL introduced in VS2008
+    #if (_MSC_VER >= 1500)
+        #define PLATFORM_SSSE3 1
+        #define PLATFORM_SSE41 1
+        #define PLATFORM_SSE42 1
+        #define PLATFORM_PCLMUL 1
+    #endif
+    // AVX and AVX2 introduced in VS2012
+    #if (_MSC_VER >= 1700)
+        #define PLATFORM_AVX 1
+        #define PLATFORM_AVX2 1
+    #endif
+#endif
+
+// Namespaces
+namespace test
+{
+
+// Using expressions
+
+/// @ingroup finite_field_layers
+///
+/// @brief Template alias for the common set of finite field
+///        layers used in most stacks
+template<class Field, class SuperCoder>
+using finite_field_layers =
+    finite_field_math<typename fifi::default_field<Field>::type,
+    // Test comment
+    finite_field<Field, SuperCoder>>;
+
+/// @ingroup coefficient_generator_layers
+///
+/// @brief Generates an uniform random coefficient (from the
+///        chosen Finite Field) for every symbol. In addition
+///        using the pivot_aware_generate means that we will only
+///        generate non-zero coefficients for symbols which are
+///        available locally.
+template<class Features, class SuperCoder>
+using on_the_fly_generator =
+    kodo_core::check_partial_generator<
+    // Test comment
+    kodo_core::uniform_generator_layers::type<Features,
+    kodo_core::pivot_aware_generator<
+    SuperCoder> > >;
+
+// Expression with template disambiguator
+using type = typename std::conditional<
+             Predicate<T>::value,
+             typename conditional_append<Predicate,
+             typename TypeList::template append<T>, List...>::type,
+             typename conditional_append<Predicate,
+             TypeList, List...>::type>::type;
+
+// Template stacks
+
+template
+<
+    class MainStack,
+    class Features
+>
+class full_vector_recoding_stack : public
+    // Payload API
+    kodo_core::payload_info<
+    // Codec Header API
+    kodo_core::default_off_systematic_encoder<
+    kodo_core::symbol_id_encoder<
+    // Symbol ID API
+    recoder_symbol_id<
+    // Coefficient Generator API
+    kodo_core::uniform_generator_layers::type<Features,
+    kodo_core::pivot_aware_generator<
+    // Encoder API
+    kodo_core::write_symbol_tracker<
+    kodo_core::zero_symbol_encoder<
+    kodo_core::trace_write_symbol<kodo_core::find_enable_trace<Features>,
+    kodo_core::trace_symbol<kodo_core::find_enable_trace<Features>,
+    kodo_core::linear_block_encoder<
+    // Coefficient Storage API
+    kodo_core::coefficient_value_access<
+    // Proxy
+    kodo_core::proxy_layer<MainStack,
+    kodo_core::final_layer
+    > > > > > > > > > > > > >
+{ };
+
+template<class T>
+struct is_regular :
+    // Comment 2
+    std::integral_constant<bool,
+    // Comment 3
+    std::is_default_constructible<T>::value &&
+    // Comment 4
+    std::is_move_assignable<T>::value>
+{ };
+
+class client : public
+    links::message_handler<links::message,
+    message_printer<
+    links::link
+    >>
+{
+protected:
+
+    /// Helper struct to determine if two classes have the same field types
+    template<class T>
+    struct is_same_field
+    {
+        static const bool value =
+            std::is_same<typename T::field_type, field_type>::value;
+    };
+};
+
+}
+
+// Nested namespaces
+namespace test
+{
+
+namespace api
+{
+inline std::shared_ptr<final_interface> build(final_interface* stack)
+{
+    auto api = dynamic_cast<build_interface*>(stack);
+    assert(api);
+    return api->build();
+}
+}
+
+namespace
+{
+struct dummy_one
+{
+    template<class Factory>
+    void construct(Factory& the_factory)
+    {
+        (void) the_factory;
+        m_construct();
+    }
+
+    stub::function<void()> m_construct;
+};
+}
+
+}
+
+// Free functions
+
+/// @copydoc layer::multipy_add(uint8_t*, const uint8_t*,
+///                             value_type, uint32_t)
+void multiply_add(uint8_t* symbol_dest,
+                  const uint8_t* symbol_src,
+                  value_type coefficient, uint32_t symbol_size)
+{
+    assert(m_field);
+    assert(symbol_dest != 0);
+    assert(symbol_src != 0);
+    assert(symbol_size > 0);
+
+    coefficient = fifi::pack_constant<field_type>(coefficient);
+
+    m_field->region_multiply_add(symbol_dest, symbol_src, coefficient,
+                                 symbol_size);
+}
+
+template<typename U>
+static auto test(int) ->
+    decltype(std::declval<U>().some_function(), yes());
+
+template<class SuperCoder>
+inline auto
+vandermonde_matrix_base::config::construct_matrix(uint32_t symbols) ->
+    std::shared_ptr<generator_matrix>
+{
+    // Something
+}
+
+template<
+    class Field,
+    class TraceTag
+>
+auto coder(const std::string& name) ->
+    boost::python::class_<Coder<Field, TraceTag>, boost::noncopyable>
+{
+    // Something
+}
+
+template<std::size_t... Is, class F, class... Args>
+inline auto easy_bind(indices<Is...>, F const& f, Args&&... args) ->
+    decltype(std::bind(
+        f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...))
+{
+    return std::bind(
+        f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...);
+}
+
+template<class R, class... FArgs, class... Args>
+inline auto easy_bind(std::function<R(FArgs...)> f, Args&&... args) ->
+    decltype(detail::easy_bind(
+        detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
+        f, std::forward<Args>(args)...))
+{
+    return detail::easy_bind(
+        detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
+        f, std::forward<Args>(args)...);
+}
+
+template <typename R, typename T, typename... FArgs, typename... Args>
+inline auto easy_bind(R(T::*mf)(FArgs...), Args&&... args) ->
+    decltype(detail::easy_bind(
+        detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
+        mf, std::forward<Args>(args)...))
+{
+    // The extra argument is the object pointer (this)
+    static_assert(sizeof...(Args) <= sizeof...(FArgs) + 1,
+                  "Too many arguments to easy_bind");
+
+    return detail::easy_bind(
+        detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
+        mf, std::forward<Args>(args)...);
+}
+
+template
+<
+    class T,
+    typename std::enable_if<has_region_multiply_constant<T>::value,
+                            uint8_t>::type = 0
+>
+inline void region_multiply_constant(T& t, uint8_t* dest,
+                                     typename T::value_type constant,
+                                     uint32_t size)
+{
+    t.region_multiply_constant(dest, constant, size);
+}
+
+template
+<
+    typename... Types,
+    // Comment 1
+    typename I = std::make_index_sequence<
+        // Comment 2
+        std::tuple_size<std::tuple<Types...>>::value>
+>
+constexpr auto tuple_to_array(std::tuple<Types...>&& tuple);
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+KODOC_API
+uint8_t kodoc_has_write_payload(kodoc_coder_t coder);
+
+KODOC_API
+void kodoc_set_mutable_symbols(
+    kodoc_coder_t decoder, uint8_t* data, uint32_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+namespace fifi
+{
+#ifdef PLATFORM_AVX2
+
+namespace detail
+{
+inline void multiply_helper(__m256i& low, __m256i& high,
+                            __m256i*& table_ptr, __m256i& sum)
+{
+    __m256i table1, table2;
+    __m256i h, l, product;
+
+    // Load the 32-byte row that contains the pre-calculated
+    // multiplication results with the low-half of the constant
+    table1 = _mm256_loadu_si256(table_ptr++);
+}
+}
+
+#else
+
+avx2_binary8_full_table::avx2_binary8_full_table()
+{
+    (void) m_table_one;
+    (void) m_table_two;
+}
+
+void avx2_binary8_full_table::region_add(
+    uint8_t*, const uint8_t*, uint32_t) const
+{
+    // Not implemented
+    assert(0 && "This line should never be executed");
+}
+
+#endif
+}
+
+// Enum
+enum error_type
+{
+    failed_open_file = 1,
+    failed_open_file = 2
+};
+
+// Normal class
+class my_class
+{
+public:
+
+    // Constructors
+
+    my_class() :
+        m_first(0U),
+        m_second(1U)
+    { }
+
+    my_class() :
+        m_vector { 1, 2, 3, 4 },
+        m_second(1U)
+    { }
+
+    // Make sure that this base class cannot be instantiated
+    factory(kodoc_factory_t factory,
+            std::function<void(kodoc_factory_t)> deleter) :
+        m_factory(factory, deleter)
+    { }
+
+    decoder_factory(codec codec, field field,
+                    uint32_t max_symbols, uint32_t max_symbol_size) :
+        factory(kodoc_new_decoder_factory(
+            (int32_t)codec, (int32_t)field, max_symbols, max_symbol_size),
+            [](kodoc_factory_t factory) { kodoc_delete_factory(factory); })
+    { }
+
+    io_service() :
+        m_io_service(
+            score_new_io_service(), [](score_io_service_t io)
+        {
+            score_delete_io_service(io);
+        })
+    { }
+
+    io_service() :
+        m_io_service(
+            score_new_io_service(),
+            {
+                1, 2, 3
+            })
+    { }
+
+    template
+    <
+        class T = Value,
+        typename std::enable_if<
+            std::is_default_constructible<T>::value, uint8_t>::type = 0
+    >
+    resource_pool() :
+        m_pool(std::make_shared<impl>(
+            allocate_function(std::make_shared<value_type>)))
+    { }
+
+public:
+
+    // Function calls
+    void function_calls()
+    {
+        srand(static_cast<uint32_t>(time(0)));
+
+        assert(m_socket && "Invalid socket in queue_async_receive");
+
+        assert(cancelled == 0 &&
+               "Rate limiter send called multiple times without "
+               "waiting for callback!");
+
+        m_timer->async_wait(std::bind(&rate_limiter::timeout_handler,
+                                      this, std::placeholders::_1, callback));
+
+        namespace ph = std::placeholders;
+
+        m_socket->async_receive_from(
+            boost::asio::buffer(m_receive_buffer), *ep, std::bind(
+                &sockets::handle_async_receive_from, this,
+                ph::_1, ph::_2, ep));
+
+        m_redundancy_estimator.sample(
+            (1.0 + m_redundancy_estimator.estimate()) *
+            m_generation_size() / m_worst.get() - 1.0);
+
+        m_formatters.insert(std::make_pair(
+            "csv", std::shared_ptr<tables::format>(new tables::csv_format())),
+            third_param);
+
+        EXPECT_TRUE(main_stack->copy_from_symbols.expect_calls().with(
+            storage::storage(data))
+            .to_bool());
+
+        // Before function
+        m_socket->async_receive_from(
+            // Line 1
+            looooooooooooooooong_function_name1(m_receive_buffer),
+            // Line 2
+            { 1, 2, 3, 4 },
+            // Line 3
+            looooooooooooooooong_function_name2(
+                // Line 4
+                &sockets::handle_async_receive_from, this,
+                ph::_1, ph::_2, ep));
+
+
+        // Initializer block within a function call
+        m_output_queue.insert(m_output_queue.begin(),
+                              vector { 1, 2, 3 });
+
+        m_output_queue.insert(m_output_queue.begin(),
+                              {
+                                  1, 2, 3
+                              },
+                              more);
+
+        m_output_queue.insert(
+            {
+                1, 2, 3
+            },
+            m_output_queue.end());
+
+        std::map<uint32_t, uint32_t> generation_map(
+            { {0, 100}, {1, 100}, {2, 100}, {3, 10}, {4, 10} });
+
+        std::map<uint32_t, uint32_t> generation_map(
+            {
+                {0, 100}, {1, 100},
+                {2, 100}, {3, 10},
+                {4, 10}
+            });
+
+        // Examples for non-optimal manual layout. The lines should be broken
+        // after the '(' to get decent layout.
+        score::generation_storage_in::coder_type::factory factory(symbol_size,
+                                                                  generation_size);
+
+        boost::asio::ip::multicast::join_group option(addr,
+                                                      score::manual_sender::address_type());
+    }
+
+    // Assignments and arithmetics
+    void assignments()
+    {
+        m_pep = m_pep * std::pow(base, losses + 1.0) +
+                (1.0 - std::pow(base, losses));
+
+        m_worst =
+            (m_worst) ? std::max(*m_worst, s.m_rank) : s.m_rank;
+
+        bool binary_ext_fields =
+            std::is_same<field_type, fifi::binary4>::value ||
+            std::is_same<field_type, fifi::binary8>::value;
+
+        double time = static_cast<double>(
+            boost::chrono::duration_cast<boost::chrono::microseconds>(
+                m_total_stop-m_total_start).count());
+
+        statistics iter = calculate_statistics(iterations.cbegin(),
+                                               iterations.cend());
+
+        bool result = std::equal(input_buffer.begin(), input_buffer.end(),
+                                 output_buffer.begin());
+
+        m_socket->async_receive_from(
+            looooooooooooooooong_function_name1(alpha) <
+            looooooooooooooooong_function_name2(beta));
+
+        std::shared_ptr<endpoint_type> ep =
+            std::make_shared<endpoint_type>();
+
+        using rlnc_decoder = kodo_rlnc::full_vector_decoder<
+                             fifi::binary, fifi::binary4, fifi::binary8>;
+
+        uint8_t constant_matrix[3][3] =
+        {
+            {1, 2, 3},
+            {5, 6, 7},
+            {53, 71, 42}
+        };
+
+        expected_coefficients =
+        { 95, 203, 243, 46, 187, 199, 153, 152, 39, 114 };
+
+        EXXXXXXXXECT_EQ(1u, stack.m_send.calls()) <<
+            "Only one packet be send as " <<
+            "io service is not run yet";
+
+        out << "\t\t" << "dest = " << ((uintptr_t) std::get<0>(v))
+            << " src = " << ((uintptr_t) std::get<1>(v))
+            << " length = " << ((uint32_t) std::get<2>(v)) << std::endl;
+
+        std::cout << "This is a very looooooong line for this Hello World! " <<
+                  "string string" << num << std::endl;
+    }
+
+    // Return statements
+    void return_statements()
+    {
+        return  m_pep * std::pow(base, losses + 1.0) +
+                (1.0 - std::pow(base, losses));
+
+        return looooooooooooooooong_function_name(
+            alpha + beta);
+
+        return detail::easy_bind(
+            detail::build_indices<sizeof...(Args)>(),
+            mf, std::forward<Args>(args)...);
+    }
+
+
+    // Control flow and special blocks
+    void blocks()
+    {
+        {
+            max_value = *std::max_element(std::begin(m_container),
+                                          std::end(m_container));
+
+            m_redundancy_estimator.sample(
+                (1.0 + m_redundancy_estimator.estimate()) *
+                m_generation_size() / m_worst.get() - 1.0);
+
+            bool alpha = beta +
+                         gamma;
+
+            return beta +
+                   gamma;
+        }
+
+        if (coffee_pot == full &&
+            second_condition::value &&
+            third_condition::value)
+        {
+            continue;
+        }
+
+        while (foundAssignmentOp->length() <
+               foundNonAssignmentOp->length())
+        {
+            foundAssignmentOp = NULL;
+        }
+
+        for (const auto& item : m_snack_list)
+        {
+            item.write(writer, m_current_generation);
+        }
+
+        for (auto it = stored_snacks.lower_bound(feedback_generation - rtt);
+             it != stored_snacks.end(); ++it)
+        {
+            lowest_rank = std::min(it->second, lowest_rank);
+        }
+
+        switch (other.m_type)
+        {
+        case class_type::object:
+            m_internal.m_map =
+                new json::object_type(
+                    other.m_internal.m_map->begin(),
+                    other.m_internal.m_map->end());
+            break;
+        default:
+            // Something
+            break;
+        }
+
+        try
+        {
+            my_function();
+        }
+        catch (const std::exception& e)
+        {
+            // handles std::exception
+        }
+        catch (...)
+        {
+            // handles int or std::string or any other unrelated type
+        }
+
+        // Alignment for commas
+        int a, b, c,
+            d, e, f;
+
+        // This is a block with an arbitrary macro header
+        RUN
+        {
+            max_value = *std::max_element(std::begin(m_container),
+                                          std::end(m_container));
+
+            m_redundancy_estimator.sample(
+                (1.0 + m_redundancy_estimator.estimate()) *
+                m_generation_size() / m_worst.get() - 1.0);
+
+            bool alpha = beta +
+                         gamma;
+
+            return beta +
+                   gamma;
+        }
+    }
+
+
+    // Lambda functions
+    void lambda_functions()
+    {
+        // Standalone lambdas
+
+        auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
+        {
+            EXPECT_TRUE((bool) o);
+            ++recycled;
+        };
+
+        auto callback = [function](const std::string& zone,
+                                   const std::string& message)
+        {
+            boost::python::call<void>(function, zone, message);
+        };
+
+        auto callback = [function](
+            const std::string& zone, const std::string& message)
+        {
+            boost::python::call<void>(function, zone, message);
+        };
+
+        auto compare = [](const parameter& a, const parameter& b) -> bool
+        {
+            if (std::get<0>(a) != std::get<0>(b))
+                return false;
+        };
+
+        // Single-line lambdas
+
+        std::function<uint32_t()> m_delay_generator =
+            []() { return 0; };
+
+        m_output_queue.insert(m_output_queue.begin(),
+                              queue_item(repair, []() {}));
+
+        std::generate(data.begin(), data.end(),
+                      [&]() { return randval(engine); });
+
+        in.fetch_data_ready(
+            [&](std::vector<uint8_t>& cb) { fetch_data_ready_stub(cb); });
+
+        // Lambda blocks as function arguments
+
+        sender.flush([&io]()
+        {
+            io.stop();
+            std::cout << "IO service stopped." << std::endl;
+        });
+
+        s.write_data(buffer, [&]()
+        {
+            io.post(write_data_callback);
+        });
+
+        m_io_thread = std::make_shared<std::thread>([&]
+        {
+            m_io_service.run();
+        });
+
+        auto cmp = stub::make_compare([](const cup& c)->bool
+        {
+            return c.m_volume == 2.3;
+        });
+
+        // Lambda within a lambda
+
+        deleter = [](kodoc_factory_t factory)
+        {
+            kodoc_delete_factory(factory);
+
+            auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
+            {
+                EXPECT_TRUE((bool) o);
+                ++recycled;
+            };
+        }
+    }
+
+    // Standalone template expressions
+    void standalone_templates()
+    {
+        run_test_basic_api<
+            // Line 1
+            Encoder<fifi::binary>,
+            // Line 2
+            Decoder<fifi::binary>
+        >(symbols, symbol_size);
+
+        parser<
+            box::moov<parser<
+                box::trak<parser<
+                    box::mdia<parser<
+                        box::hdlr,
+                        box::mdhd
+                    >>
+                >>
+            >>
+        > parser;
+
+        {
+            SCOPED_TRACE(testing::Message() << "field = binary");
+            run_test_basic_api<
+                Encoder<fifi::binary>,
+                // Line 2
+                Decoder<fifi::binary>
+            >(symbols, symbol_size);
+        }
+    }
+
+
+protected:
+
+    // Member variables
+
+    std::function<void(const std::vector<uint8_t>&)> m_write_symbol_callback;
+
+    stub::function<uint32_t, const storage::const_storage> copy_into_symbol;
+
+    stub::function<
+        void(uint8_t**, const uint8_t**, uint8_t**, uint32_t, uint32_t)
+    > m_vector_dot_product;
+
+    stub::function<
+        void (uint8_t*, const uint8_t*, value_type, uint32_t)
+    > multiply_add;
+};
+
+// gtest macros
+
+INSTANTIATE_TEST_CASE_P(/* symbol_size */,
+                        test_message_serialize_parse_param,
+                        ::testing::Values(/*4u, 10U, 15U, 30U,*/
+                            150U, 300U, 500U,
+                            1500U, 3000U, 5000U));
+
+INSTANTIATE_TEST_CASE_P(
+    /* symbol_size */,
+    test_message_serialize_parse_param,
+    ::testing::Values(
+        /*4u, 10U, 15U, 30U,*/
+        150U, 300U, 500U,
+        1500U, 3000U, 5000U));
+
+// Main function body
+
+int main(int argc, const char* argv[])
+{
+    uint16_t num = 42;
+
+    auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
+    {
+        EXPECT_TRUE((bool) o);
+        ++recycled;
+    };
+
+    std::vector<int> v = {0, 1, 2, 3, 4, 5};
+
+    std::vector<uint8_t> data =
+    {
+        0x67, 0x42, 0x00, 0x0A, 0xF8, 0x41, 0xA2
+    };
+
+    // insert code here...
+    std::cout << "This is a very loooooooooong line for this Hello World! "
+              << num << std::endl;
+
+    for (int& i : v)
+        std::cout << i << ' ';
+
+    return 0;
+}

test/distorted_style.cpp

@@ -0,0 +1,779 @@
+ // Copyright comment
+
+#pragma once
+
+#include <iostream>
+    #include <vector>
+  #include <cstdint>
+#include <string>
+
+// Indented preprocessor statements
+#if defined(PLATFORM_WINDOWS_PHONE)
+#if defined(PLATFORM_MSVC_ARM)
+    // NEON introduced in VS2012
+    #if (_MSC_VER >= 1700)
+        #define PLATFORM_NEON 1
+    #endif
+#endif
+#elif defined(PLATFORM_MSVC_X86)
+    // SSSE3, SSE4.1, SSE4.2, PCLMUL introduced in VS2008
+     #if (_MSC_VER >= 1500)
+#define PLATFORM_SSSE3 1
+        #define PLATFORM_SSE41 1
+        #define PLATFORM_SSE42 1
+        #define PLATFORM_PCLMUL 1
+#endif
+     // AVX and AVX2 introduced in VS2012
+    #if (_MSC_VER >= 1700)
+#define PLATFORM_AVX 1
+        #define PLATFORM_AVX2 1
+    #endif
+#endif
+
+// Namespaces
+namespace test {
+
+// Using expressions
+
+/// @ingroup finite_field_layers
+    ///
+    /// @brief Template alias for the common set of finite field
+///        layers used in most stacks
+template<class Field, class SuperCoder>
+using finite_field_layers =
+            finite_field_math<typename fifi::default_field<Field>::type,
+        // Test comment
+    finite_field<Field, SuperCoder>>;
+
+/// @ingroup coefficient_generator_layers
+///
+/// @brief Generates an uniform random coefficient (from the
+///        chosen Finite Field) for every symbol. In addition
+///        using the pivot_aware_generate means that we will only
+///        generate non-zero coefficients for symbols which are
+///        available locally.
+template<class Features, class SuperCoder>
+using on_the_fly_generator =
+    kodo_core::check_partial_generator<
+        // Test comment
+            kodo_core::uniform_generator_layers::type<Features,
+                kodo_core::pivot_aware_generator<
+                    SuperCoder> > >;
+
+// Expression with template disambiguator
+using type = typename std::conditional<
+    Predicate<T>::value,
+        typename conditional_append<Predicate,
+      typename TypeList::template append<T>, List...>::type,
+         typename conditional_append<Predicate,
+       TypeList, List...>::type>::type;
+
+// Template stacks
+
+template
+    <
+    class MainStack,
+        class Features
+    >
+class full_vector_recoding_stack : public
+        // Payload API
+    kodo_core::payload_info<
+        // Codec Header API
+    kodo_core::default_off_systematic_encoder<
+        kodo_core::symbol_id_encoder<
+    // Symbol ID API
+    recoder_symbol_id<
+    // Coefficient Generator API
+    kodo_core::uniform_generator_layers::type<Features,
+    kodo_core::pivot_aware_generator<
+    // Encoder API
+    kodo_core::write_symbol_tracker<
+        kodo_core::zero_symbol_encoder<
+    kodo_core::trace_write_symbol<kodo_core::find_enable_trace<Features>,
+    kodo_core::trace_symbol<kodo_core::find_enable_trace<Features>,
+                kodo_core::linear_block_encoder<
+    // Coefficient Storage API
+    kodo_core::coefficient_value_access<
+    // Proxy
+        kodo_core::proxy_layer<MainStack,
+    kodo_core::final_layer
+    > > > > > > > > > > > > >
+{ };
+
+template<class T>
+struct is_regular :
+    // Comment 2
+        std::integral_constant<bool,
+        // Comment 3
+        std::is_default_constructible<T>::value &&
+    // Comment 4
+    std::is_move_assignable<T>::value>
+    { };
+
+class client : public
+    links::message_handler<links::message,
+    message_printer<
+    links::link
+    >>
+{
+protected:
+
+    /// Helper struct to determine if two classes have the same field types
+    template<class T>
+    struct is_same_field {
+        static const bool value =
+        std::is_same<typename T::field_type, field_type>::value;
+    };
+    };
+
+}
+
+// Nested namespaces
+namespace test
+{
+
+namespace api {
+inline std::shared_ptr<final_interface> build(final_interface* stack)
+{
+    auto api = dynamic_cast<build_interface*>(stack);
+        assert(api);
+    return api->build( );
+}
+}
+
+namespace
+{
+struct dummy_one
+{
+    template<class Factory>
+        void construct(Factory& the_factory)
+    {
+            (void) the_factory;
+        m_construct();
+    }
+
+    stub::function<void()> m_construct;
+};
+}
+
+}
+
+// Free functions
+
+/// @copydoc layer::multipy_add(uint8_t*, const uint8_t*,
+///                             value_type, uint32_t)
+void multiply_add(uint8_t* symbol_dest,
+                    const uint8_t* symbol_src,
+         value_type coefficient, uint32_t symbol_size)
+{
+    assert (m_field);
+        assert(symbol_dest != 0);
+    assert( symbol_src != 0);
+    assert(symbol_size > 0);
+
+    coefficient = fifi::pack_constant<field_type>(coefficient);
+
+    m_field->region_multiply_add(symbol_dest, symbol_src, coefficient,
+                                    symbol_size);
+}
+
+    template<typename U>
+static auto test(int) ->
+decltype(std::declval<U>().some_function(), yes());
+
+template<class SuperCoder>
+inline auto
+vandermonde_matrix_base::config::construct_matrix(uint32_t symbols) ->
+        std::shared_ptr<generator_matrix>
+{
+        // Something
+}
+
+template<
+    class Field,
+        class TraceTag
+    >
+auto coder(const std::string& name) ->
+    boost::python::class_<Coder<Field, TraceTag>, boost::noncopyable>
+    {
+    // Something
+    }
+
+template<std::size_t... Is, class F, class... Args>
+inline auto easy_bind(indices<Is...>, F const& f, Args&&... args) ->
+decltype(std::bind(
+        f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...))
+{
+return std::bind(
+        f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...);
+}
+
+template<class R, class... FArgs, class... Args>
+inline auto easy_bind(std::function<R(FArgs...)> f, Args&&... args) ->
+    decltype(detail::easy_bind(
+            detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
+        f, std::forward<Args>(args)...))
+{
+    return detail::easy_bind(
+            detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
+        f, std::forward<Args>(args)...);
+}
+
+    template <typename R, typename T, typename... FArgs, typename... Args>
+inline auto easy_bind(R(T::*mf)(FArgs...), Args&&... args) ->
+    decltype(detail::easy_bind(
+        detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
+            mf, std::forward<Args>(args)...))
+{
+    // The extra argument is the object pointer (this)
+    static_assert(sizeof...(Args) <= sizeof...(FArgs) + 1,
+            "Too many arguments to easy_bind");
+
+    return detail::easy_bind(
+        detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
+            mf, std::forward<Args>(args)...);
+}
+
+template
+<
+    class T,
+    typename std::enable_if<has_region_multiply_constant<T>::value,
+      uint8_t>::type = 0
+>
+inline void region_multiply_constant(T& t, uint8_t* dest,
+                       typename T::value_type constant,
+                                     uint32_t size)
+{
+t.region_multiply_constant(dest, constant, size);
+}
+
+template
+    <
+    typename... Types,
+    // Comment 1
+        typename I = std::make_index_sequence<
+        // Comment 2
+        std::tuple_size<std::tuple<Types...>>::value>
+    >
+constexpr auto tuple_to_array(std::tuple<Types...>&& tuple);
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+KODOC_API
+    uint8_t kodoc_has_write_payload(kodoc_coder_t coder);
+
+KODOC_API
+void kodoc_set_mutable_symbols(
+ kodoc_coder_t decoder, uint8_t* data, uint32_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+namespace fifi
+{
+#ifdef PLATFORM_AVX2
+
+namespace detail
+{
+inline void multiply_helper(__m256i &low, __m256i& high,
+             __m256i* &table_ptr, __m256i& sum)
+{
+    __m256i table1, table2;
+    __m256i h, l, product;
+
+    // Load the 32-byte row that contains the pre-calculated
+    // multiplication results with the low-half of the constant
+    table1 = _mm256_loadu_si256(table_ptr++);
+}
+}
+
+#else
+
+avx2_binary8_full_table::avx2_binary8_full_table()
+{
+    (void) m_table_one;
+    (void) m_table_two;
+}
+
+void avx2_binary8_full_table::region_add(
+    uint8_t*, const uint8_t*, uint32_t ) const
+    {
+    // Not implemented
+    assert(0 && "This line should never be executed");
+}
+
+#endif
+}
+
+// Enum
+enum error_type
+{
+        failed_open_file = 1,
+    failed_open_file = 2
+    };
+
+// Normal class
+class my_class {
+public:
+
+    // Constructors
+
+    my_class(): m_first(0U),
+        m_second(1U)
+    { }
+
+    my_class()
+        : m_vector { 1, 2, 3, 4 },
+            m_second(1U)
+    { }
+
+    // Make sure that this base class cannot be instantiated
+    factory(kodoc_factory_t factory,
+            std::function<void(kodoc_factory_t)> deleter)
+        : m_factory(factory, deleter)
+    { }
+
+    decoder_factory(codec codec, field field,
+                    uint32_t max_symbols, uint32_t max_symbol_size):
+        factory(kodoc_new_decoder_factory(
+            (int32_t)codec, (int32_t)field, max_symbols, max_symbol_size),
+        [](kodoc_factory_t factory) { kodoc_delete_factory(factory); })
+    { }
+
+    io_service() :
+        m_io_service(
+            score_new_io_service(), [](score_io_service_t io) {
+            score_delete_io_service(io);
+        })
+    { }
+
+    io_service() :
+        m_io_service(
+            score_new_io_service(),
+            {
+            1, 2, 3
+            })
+    { }
+
+    template
+        <
+        class T = Value,
+        typename std::enable_if<
+        std::is_default_constructible<T>::value, uint8_t>::type = 0
+    >
+    resource_pool() :
+        m_pool(std::make_shared<impl>(
+                        allocate_function(std::make_shared<value_type>)))
+    { }
+
+public:
+
+    // Function calls
+    void function_calls() {
+        srand( static_cast<uint32_t>( time(0 ) ));
+
+        assert(m_socket && "Invalid socket in queue_async_receive");
+
+        assert(cancelled == 0 &&
+           "Rate limiter send called multiple times without "
+               "waiting for callback!");
+
+        m_timer->async_wait(std::bind(&rate_limiter::timeout_handler,
+                       this, std::placeholders::_1, callback));
+
+        namespace ph = std::placeholders;
+
+        m_socket->async_receive_from(
+            boost::asio::buffer(m_receive_buffer), *ep, std::bind(
+                &sockets::handle_async_receive_from, this,
+            ph::_1, ph::_2, ep));
+
+        m_redundancy_estimator.sample(
+                (1.0 + m_redundancy_estimator.estimate()) *
+            m_generation_size() / m_worst.get() - 1.0);
+
+        m_formatters.insert(std::make_pair(
+                "csv", std::shared_ptr<tables::format>(new tables::csv_format())),
+            third_param);
+
+        EXPECT_TRUE(main_stack->copy_from_symbols.expect_calls().with(
+            storage::storage(data))
+                .to_bool());
+
+        // Before function
+        m_socket->async_receive_from(
+            // Line 1
+            looooooooooooooooong_function_name1(m_receive_buffer),
+        // Line 2
+        { 1, 2, 3, 4 },
+            // Line 3
+            looooooooooooooooong_function_name2(
+                    // Line 4
+                &sockets::handle_async_receive_from, this,
+                    ph::_1, ph::_2, ep));
+
+
+        // Initializer block within a function call
+        m_output_queue.insert(m_output_queue.begin(),
+                                            vector { 1, 2, 3 });
+
+        m_output_queue.insert(m_output_queue.begin(),
+                    {
+                        1, 2, 3
+                    },
+                              more);
+
+        m_output_queue.insert(
+            {
+            1, 2, 3
+            },
+                m_output_queue.end());
+
+        std::map<uint32_t, uint32_t> generation_map(
+        { {0, 100}, {1, 100}, {2, 100}, {3, 10}, {4, 10} });
+
+        std::map<uint32_t, uint32_t> generation_map(
+        {
+                {0, 100}, {1, 100},
+            {2, 100}, {3, 10},
+                {4, 10}
+            });
+
+        // Examples for non-optimal manual layout. The lines should be broken
+        // after the '(' to get decent layout.
+        score::generation_storage_in::coder_type::factory factory(symbol_size,
+                                       generation_size);
+
+        boost::asio::ip::multicast::join_group option(addr,
+                        score::manual_sender::address_type());
+    }
+
+    // Assignments and arithmetics
+    void assignments()
+    {
+        m_pep = m_pep * std::pow(base, losses + 1.0) +
+                        (1.0 - std::pow(base, losses));
+
+        m_worst =
+                    (m_worst) ? std::max(*m_worst, s.m_rank) : s.m_rank;
+
+        bool binary_ext_fields =
+                std::is_same<field_type, fifi::binary4>::value ||
+            std::is_same<field_type, fifi::binary8>::value;
+
+        double time = static_cast<double>(
+                    boost::chrono::duration_cast<boost::chrono::microseconds>(
+                m_total_stop-m_total_start).count());
+
+        statistics iter = calculate_statistics(iterations.cbegin(),
+                                                    iterations.cend());
+
+        bool result = std::equal(input_buffer.begin(), input_buffer.end(),
+                          output_buffer.begin());
+
+        m_socket->async_receive_from(
+                    looooooooooooooooong_function_name1(alpha) <
+            looooooooooooooooong_function_name2(beta));
+
+        std::shared_ptr<endpoint_type> ep =
+        std::make_shared<endpoint_type>();
+
+        using rlnc_decoder = kodo_rlnc::full_vector_decoder<
+                       fifi::binary, fifi::binary4, fifi::binary8>;
+
+        uint8_t constant_matrix[3][3] =
+            {
+            {1, 2, 3},
+                    {5, 6, 7},
+                {53, 71, 42}
+        };
+
+        expected_coefficients =
+            { 95, 203, 243, 46, 187, 199, 153, 152, 39, 114 };
+
+        EXXXXXXXXECT_EQ(1u, stack.m_send.calls()) <<
+                "Only one packet be send as " <<
+                "io service is not run yet";
+
+        out << "\t\t" << "dest = " << ((uintptr_t) std::get<0>(v))
+                    << " src = " << ((uintptr_t) std::get<1>(v))
+            << " length = " << ((uint32_t) std::get<2>(v)) << std::endl;
+
+        std::cout << "This is a very looooooong line for this Hello World! " <<
+            "string string" << num << std::endl;
+    }
+
+    // Return statements
+    void return_statements() {
+        return  m_pep * std::pow(base, losses + 1.0) +
+                        (1.0 - std::pow(base, losses));
+
+        return looooooooooooooooong_function_name(
+                        alpha + beta);
+
+        return detail::easy_bind(
+                    detail::build_indices<sizeof...(Args)>(),
+            mf, std::forward<Args>(args)...);
+    }
+
+
+    // Control flow and special blocks
+    void blocks()
+    {
+        {
+            max_value = *std::max_element(std::begin(m_container),
+                                  std::end(m_container));
+
+            m_redundancy_estimator.sample(
+                (1.0 + m_redundancy_estimator.estimate()) *
+                m_generation_size() / m_worst.get() - 1.0);
+
+            bool alpha = beta +
+                                gamma;
+
+            return beta +
+                gamma;
+        }
+
+        if (coffee_pot == full &&
+                second_condition::value &&
+                third_condition::value)
+        {
+                continue;
+        }
+
+        while (foundAssignmentOp->length() <
+            foundNonAssignmentOp->length())
+        {
+        foundAssignmentOp = NULL;
+        }
+
+        for (const auto & item : m_snack_list )
+        {
+            item.write(writer, m_current_generation);
+        }
+
+        for ( auto it = stored_snacks.lower_bound(feedback_generation - rtt);
+             it != stored_snacks.end();++it) {
+              lowest_rank = std::min(it->second, lowest_rank);
+        }
+
+        switch (other.m_type) {
+            case class_type::object:
+            m_internal.m_map =
+                new json::object_type(
+                    other.m_internal.m_map->begin(),
+                    other.m_internal.m_map->end());
+            break;
+        default:
+                // Something
+                break;
+            }
+
+        try {
+            my_function();
+        }
+        catch(const std::exception& e)
+        {
+                    // handles std::exception
+        }
+        catch(...)
+        {
+            // handles int or std::string or any other unrelated type
+        }
+
+        // Alignment for commas
+        int a, b, c,
+                        d, e, f;
+
+        // This is a block with an arbitrary macro header
+        RUN
+        {
+            max_value = *std::max_element(std::begin(m_container),
+                                                std::end(m_container));
+
+            m_redundancy_estimator.sample(
+                (1.0 + m_redundancy_estimator.estimate()) *
+                        m_generation_size() / m_worst.get() - 1.0);
+
+                bool alpha = beta +
+                         gamma;
+
+                return beta +
+                   gamma;
+        }
+    }
+
+
+    // Lambda functions
+    void lambda_functions()
+    {
+        // Standalone lambdas
+
+        auto recycle = [&recycled](std::shared_ptr<dummy_two> o) {
+            EXPECT_TRUE((bool) o);
+            ++recycled;
+        };
+
+        auto callback = [function](const std::string& zone,
+                              const std::string& message)
+        {
+            boost::python::call<void>(function, zone, message);
+        };
+
+        auto callback = [function](
+                    const std::string& zone, const std::string& message)
+        {
+            boost::python::call<void>(function, zone, message);
+        };
+
+        auto compare = [](const parameter& a, const parameter& b) -> bool {
+            if(std::get<0>(a) != std::get<0>(b))
+                return false;
+        };
+
+        // Single-line lambdas
+
+        std::function<uint32_t()> m_delay_generator =
+        []() { return 0; };
+
+        m_output_queue.insert(m_output_queue.begin(),
+                     queue_item(repair, []() {}));
+
+        std::generate(data.begin(), data.end(),
+                                [&]() { return randval(engine); });
+
+        in.fetch_data_ready(
+        [&](std::vector<uint8_t>& cb) { fetch_data_ready_stub(cb); });
+
+        // Lambda blocks as function arguments
+
+        sender.flush([&io]() {
+            io.stop();
+                std::cout << "IO service stopped." << std::endl;
+        });
+
+        s.write_data(buffer, [&]()
+        {
+                    io.post(write_data_callback);
+        });
+
+        m_io_thread = std::make_shared<std::thread>([&] {
+            m_io_service.run();
+        });
+
+        auto cmp = stub::make_compare( [](const cup& c)->bool
+        {
+            return c.m_volume == 2.3;
+        });
+
+        // Lambda within a lambda
+
+        deleter = []( kodoc_factory_t factory)   {
+            kodoc_delete_factory(factory);
+
+            auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
+            {
+                EXPECT_TRUE((bool) o);
+                ++recycled;
+            };
+        }
+    }
+
+    // Standalone template expressions
+    void standalone_templates()
+    {
+        run_test_basic_api<
+                    // Line 1
+                Encoder<fifi::binary>,
+            // Line 2
+                Decoder<fifi::binary>
+        >(  symbols, symbol_size);
+
+        parser<
+                    box::moov<parser<
+                box::trak<parser<
+                    box::mdia<parser<
+                                box::hdlr,
+                            box::mdhd
+                    >>
+                >>
+            >>
+        > parser;
+
+        {
+                SCOPED_TRACE(testing::Message() << "field = binary");
+            run_test_basic_api<
+                    Encoder<fifi::binary>,
+                // Line 2
+                Decoder<fifi::binary>
+                >(symbols, symbol_size);
+        }
+    }
+
+
+    protected:
+
+    // Member variables
+
+    std::function<void(const std::vector<uint8_t>&)> m_write_symbol_callback;
+
+    stub::function<uint32_t, const storage::const_storage> copy_into_symbol;
+
+    stub::function<
+        void(uint8_t**, const uint8_t**, uint8_t**, uint32_t, uint32_t)
+        > m_vector_dot_product;
+
+    stub::function<
+        void (uint8_t*, const uint8_t*, value_type, uint32_t)
+            > multiply_add;
+    };
+
+// gtest macros
+
+    INSTANTIATE_TEST_CASE_P(/* symbol_size */,
+                        test_message_serialize_parse_param,
+                                ::testing::Values(/*4u, 10U, 15U, 30U,*/
+                            150U, 300U, 500U,
+                            1500U, 3000U, 5000U));
+
+INSTANTIATE_TEST_CASE_P (
+/* symbol_size */,
+test_message_serialize_parse_param,
+::testing::Values(
+    /*4u, 10U, 15U, 30U,*/
+    150U, 300U, 500U,
+    1500U, 3000U, 5000U));
+
+// Main function body
+
+int main(int argc, const char *argv[])
+{
+    uint16_t num = 42;
+
+    auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
+        {
+            EXPECT_TRUE((bool) o);
+            ++recycled;
+        };
+
+    std::vector<int> v = {0, 1, 2, 3, 4, 5};
+
+    std::vector<uint8_t> data = {
+        0x67, 0x42, 0x00, 0x0A, 0xF8, 0x41, 0xA2
+    };
+
+    // insert code here...
+    std::cout << "This is a very loooooooooong line for this Hello World! "
+                    << num << std::endl;
+
+    for (int &i : v)
+            std::cout << i << ' ';
+
+    return 0;
+}

wscript

@@ -1,11 +1,18 @@
 #! /usr/bin/env python
 # encoding: utf-8
 
+import os
+import difflib
+import sys
+import subprocess
+import shutil
+from waflib.TaskGen import feature, after_method
+from waflib import Errors
+import waflib.extras.wurf_options
+
 APPNAME = 'astyle'
 VERSION = '0.1.0'
 
-import waflib.extras.wurf_options
-
 
 def options(opt):
 
@@ -44,8 +51,66 @@ def build(bld):
             static_libs = ['Shell32']
 
         bld.program(
-            features='cxx',
+            features='cxx test_astyle',
             source=bld.path.ant_glob('src/*.cpp'),
             lib=static_libs,
             target='astyle')
 
+
+@feature('test_astyle')
+@after_method('apply_link')
+def test_astyle(self):
+    # Only execute the tests within the current project
+    if self.path.is_child_of(self.bld.srcnode):
+        if self.bld.has_tool_option('run_tests'):
+            self.bld.add_post_fun(run_astyle_tests)
+
+
+def run_command(args):
+    print("Running: {}".format(args))
+    sys.stdout.flush()
+    subprocess.check_call(args)
+
+
+def run_astyle_tests(bld):
+    astyle = bld.get_tgen_by_name('astyle').link_task.outputs[0].abspath()
+    options = "--options={}".format(bld.path.find_node('.astylerc').abspath())
+
+    if os.path.isdir('test'):
+        test_folder = os.path.join(os.getcwd(), 'test')
+        correct_style = os.path.join(test_folder, 'correct_style.cpp')
+        # Read the input file using universal newlines (so the line endings
+        # are seen as '\n', even if git checks out the code with '\r\n')
+        correct_lines = open(correct_style, 'rU').readlines()
+
+        temp_folder = os.path.join(test_folder, 'temp')
+        # Make sure that the temp folder is deleted before copytree
+        if os.path.isdir(temp_folder):
+            shutil.rmtree(temp_folder)
+        shutil.copytree(test_folder, temp_folder)
+
+        incorrect_files = 0
+
+        # Run astyle to format each test file
+        for file in sorted(os.listdir(temp_folder)):
+            test_file = os.path.join(temp_folder, file)
+            if os.path.isfile(test_file):
+                print('Test file: '+test_file)
+                run_command([astyle, options, test_file])
+
+                # Compare the formatted file with the correct style
+                test_lines = open(test_file, 'r').readlines()
+                diff = difflib.unified_diff(correct_lines, test_lines)
+                diff_lines = ''.join(diff)
+
+                if len(diff_lines) > 0:
+                    incorrect_files += 1
+                    print('\nIncorrect formatting: {}'.format(test_file))
+                    print(diff_lines)
+
+        # Clean up the temp directory
+        shutil.rmtree(temp_folder)
+
+        if incorrect_files > 0:
+            raise Errors.WafError('Number of incorrectly formatted '
+                                   'files: {}'.format(incorrect_files))