src/samplepack.cpp

# testing

set(ENABLE_TESTS false CACHE BOOL "Build tests.")

if (ENABLE_TESTS)

  enable_testing()

  add_subdirectory(tests)

endif ()

/*

  Copyright © 2017 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#include <QtGlobal>

#include "samplepack.h"

SamplePack::SamplePack(unsigned ns, unsigned nc, bool x)

{

    Q_ASSERT(ns > 0 && nc > 0);

    _numSamples = ns;

    _numChannels = nc;

    _yData = new double[_numSamples * _numChannels]();

    if (x)

    {

        _xData = new double[_numSamples]();

    }

    else

    {

        _xData = nullptr;

    }

}

SamplePack::~SamplePack()

{

    delete[] _yData;

    if (_xData != nullptr)

    {

        delete[] _xData;

    }

}

bool SamplePack::hasX() const

{

    return _xData != nullptr;

}

unsigned SamplePack::numChannels() const

{

    return _numChannels;

}

unsigned SamplePack::numSamples() const

{

    return _numSamples;

}

double* SamplePack::xData() const

{

    Q_ASSERT(_xData != nullptr);

    return _xData;

}

double* SamplePack::data(unsigned channel) const

{

    Q_ASSERT(channel < _numChannels);

    return &_yData[channel * _numSamples];

}

/*

  Copyright © 2017 Hasan Yavuz Özderya

  This file is part of serialplot.

  serialplot is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.

  serialplot is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef SAMPLEPACK_H

#define SAMPLEPACK_H

class SamplePack

{

public:

    SamplePack(unsigned ns, unsigned nc, bool x = false);

    ~SamplePack();

    bool hasX() const;

    unsigned numChannels() const;

    unsigned numSamples() const;

    double* xData() const;

    double* data(unsigned channel) const;

private:

    unsigned _numSamples, _numChannels;

    double* _xData;

    double* _yData;

};

#endif // SAMPLEPACK_H

#

# Copyright © 2017 Hasan Yavuz Özderya

#

# This file is part of serialplot.

#

# serialplot is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# serialplot is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

#

# Find the QtWidgets library

find_package(Qt5Widgets)

include_directories("../src")

add_executable(Test EXCLUDE_FROM_ALL

  test.cpp ../src/samplepack.cpp)

add_test(NAME test1 COMMAND Test)

qt5_use_modules(Test Widgets)

set(CMAKE_CTEST_COMMAND ctest -V)

add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND})

add_dependencies(check Test)

/*

 *  Catch v1.9.6

 *  Generated: 2017-06-27 12:19:54.557875

 *  ----------------------------------------------------------

 *  This file has been merged from multiple headers. Please don't edit it directly

 *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.

 *

 *  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)

 */

#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED

#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED

#define TWOBLUECUBES_CATCH_HPP_INCLUDED

#ifdef __clang__

#    pragma clang system_header

#elif defined __GNUC__

#    pragma GCC system_header

#endif

// #included from: internal/catch_suppress_warnings.h

#ifdef __clang__

#   ifdef __ICC // icpc defines the __clang__ macro

#       pragma warning(push)

#       pragma warning(disable: 161 1682)

#   else // __ICC

#       pragma clang diagnostic ignored "-Wglobal-constructors"

#       pragma clang diagnostic ignored "-Wvariadic-macros"

#       pragma clang diagnostic ignored "-Wc99-extensions"

#       pragma clang diagnostic ignored "-Wunused-variable"

#       pragma clang diagnostic push

#       pragma clang diagnostic ignored "-Wpadded"

#       pragma clang diagnostic ignored "-Wc++98-compat"

#       pragma clang diagnostic ignored "-Wc++98-compat-pedantic"

#       pragma clang diagnostic ignored "-Wswitch-enum"

#       pragma clang diagnostic ignored "-Wcovered-switch-default"

#    endif

#elif defined __GNUC__

#    pragma GCC diagnostic ignored "-Wvariadic-macros"

#    pragma GCC diagnostic ignored "-Wunused-variable"

#    pragma GCC diagnostic ignored "-Wparentheses"

#    pragma GCC diagnostic push

#    pragma GCC diagnostic ignored "-Wpadded"

#endif

#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)

#  define CATCH_IMPL

#endif

#ifdef CATCH_IMPL

#  ifndef CLARA_CONFIG_MAIN

#    define CLARA_CONFIG_MAIN_NOT_DEFINED

#    define CLARA_CONFIG_MAIN

#  endif

#endif

// #included from: internal/catch_notimplemented_exception.h

#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED

// #included from: catch_common.h

#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED

// #included from: catch_compiler_capabilities.h

#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED

// Detect a number of compiler features - mostly C++11/14 conformance - by compiler

// The following features are defined:

//

// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported?

// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported?

// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods

// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported?

// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported

// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported?

// CATCH_CONFIG_CPP11_OVERRIDE : is override supported?

// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)

// CATCH_CONFIG_CPP11_SHUFFLE : is std::shuffle supported?

// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if supported?

// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported?

// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?

// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?

// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?

// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?

// ****************

// Note to maintainers: if new toggles are added please document them

// in configuration.md, too

// ****************

// In general each macro has a _NO_<feature name> form

// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature.

// Many features, at point of detection, define an _INTERNAL_ macro, so they

// can be combined, en-mass, with the _NO_ forms later.

// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11

#ifdef __cplusplus

#  if __cplusplus >= 201103L

#    define CATCH_CPP11_OR_GREATER

#  endif

#  if __cplusplus >= 201402L

#    define CATCH_CPP14_OR_GREATER

#  endif

#endif

#ifdef __clang__

#  if __has_feature(cxx_nullptr)

#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

#  endif

#  if __has_feature(cxx_noexcept)

#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

#  endif

#   if defined(CATCH_CPP11_OR_GREATER)

#       define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \

            _Pragma( "clang diagnostic push" ) \

            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" )

#       define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \

            _Pragma( "clang diagnostic pop" )

#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \

            _Pragma( "clang diagnostic push" ) \

            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )

#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \

            _Pragma( "clang diagnostic pop" )

#   endif

#endif // __clang__

////////////////////////////////////////////////////////////////////////////////

// We know some environments not to support full POSIX signals

#if defined(__CYGWIN__) || defined(__QNX__)

#   if !defined(CATCH_CONFIG_POSIX_SIGNALS)

#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS

#   endif

#endif

////////////////////////////////////////////////////////////////////////////////

// Cygwin

#ifdef __CYGWIN__

// Required for some versions of Cygwin to declare gettimeofday

// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin

#   define _BSD_SOURCE

#endif // __CYGWIN__

////////////////////////////////////////////////////////////////////////////////

// Borland

#ifdef __BORLANDC__

#endif // __BORLANDC__

////////////////////////////////////////////////////////////////////////////////

// EDG

#ifdef __EDG_VERSION__

#endif // __EDG_VERSION__

////////////////////////////////////////////////////////////////////////////////

// Digital Mars

#ifdef __DMC__

#endif // __DMC__

////////////////////////////////////////////////////////////////////////////////

// GCC

#ifdef __GNUC__

#   if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)

#       define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

#   endif

// - otherwise more recent versions define __cplusplus >= 201103L

// and will get picked up below

#endif // __GNUC__

////////////////////////////////////////////////////////////////////////////////

// Visual C++

#ifdef _MSC_VER

#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH

#if (_MSC_VER >= 1600)

#   define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

#   define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR

#endif

#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))

#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS

#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE

#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS

#endif

#endif // _MSC_VER

////////////////////////////////////////////////////////////////////////////////

// Use variadic macros if the compiler supports them

#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \

    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \

    ( defined __GNUC__ && __GNUC__ >= 3 ) || \

    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )

#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS

#endif

// Use __COUNTER__ if the compiler supports it

#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \

    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \

    ( defined __clang__ && __clang_major__ >= 3 )

#define CATCH_INTERNAL_CONFIG_COUNTER

#endif

////////////////////////////////////////////////////////////////////////////////

// C++ language feature support

// catch all support for C++11

#if defined(CATCH_CPP11_OR_GREATER)

#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR)

#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR

#  endif

#  ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT

#  endif

#  ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS

#    define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS

#  endif

#  ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM

#    define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM

#  endif

#  ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE

#    define CATCH_INTERNAL_CONFIG_CPP11_TUPLE

#  endif

#  ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS

#    define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS

#  endif

#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG)

#    define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG

#  endif

#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE)

#    define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE

#  endif

#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)

#    define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR

#  endif

# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE)

#   define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE

#  endif

# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS)

#  define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS

# endif

#endif // __cplusplus >= 201103L

// Now set the actual defines based on the above + anything the user has configured

#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_NULLPTR

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_NOEXCEPT

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_GENERATED_METHODS

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_IS_ENUM

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_TUPLE

#endif

#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS)

#   define CATCH_CONFIG_VARIADIC_MACROS

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_LONG_LONG

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_OVERRIDE

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_UNIQUE_PTR

#endif

// Use of __COUNTER__ is suppressed if __JETBRAINS_IDE__ is #defined (meaning we're being parsed by a JetBrains IDE for

// analytics) because, at time of writing, __COUNTER__ is not properly handled by it.

// This does not affect compilation

#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER) && !defined(__JETBRAINS_IDE__)

#   define CATCH_CONFIG_COUNTER

#endif

#if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)

#   define CATCH_CONFIG_CPP11_SHUFFLE

#endif

# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11)

#  define CATCH_CONFIG_CPP11_TYPE_TRAITS

# endif

#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)

#   define CATCH_CONFIG_WINDOWS_SEH

#endif

// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.

#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)

#   define CATCH_CONFIG_POSIX_SIGNALS

#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)

#   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS

#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS

#endif

#if !defined(CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS)

#   define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS

#   define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS

#endif

// noexcept support:

#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)

#  define CATCH_NOEXCEPT noexcept

#  define CATCH_NOEXCEPT_IS(x) noexcept(x)

#else

#  define CATCH_NOEXCEPT throw()

#  define CATCH_NOEXCEPT_IS(x)

#endif

// nullptr support

#ifdef CATCH_CONFIG_CPP11_NULLPTR

#   define CATCH_NULL nullptr

#else

#   define CATCH_NULL NULL

#endif

// override support

#ifdef CATCH_CONFIG_CPP11_OVERRIDE

#   define CATCH_OVERRIDE override

#else

#   define CATCH_OVERRIDE

#endif

// unique_ptr support

#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR

#   define CATCH_AUTO_PTR( T ) std::unique_ptr<T>

#else

#   define CATCH_AUTO_PTR( T ) std::auto_ptr<T>

#endif

#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line

#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )

#ifdef CATCH_CONFIG_COUNTER

#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )

#else

#  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )

#endif

#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr

#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )

#include <sstream>

#include <algorithm>

namespace Catch {

    struct IConfig;

    struct CaseSensitive { enum Choice {

        Yes,

        No

    }; };

    class NonCopyable {

#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS

        NonCopyable( NonCopyable const& )              = delete;

        NonCopyable( NonCopyable && )                  = delete;

        NonCopyable& operator = ( NonCopyable const& ) = delete;

        NonCopyable& operator = ( NonCopyable && )     = delete;

#else

        NonCopyable( NonCopyable const& info );

        NonCopyable& operator = ( NonCopyable const& );

#endif

    protected:

        NonCopyable() {}

        virtual ~NonCopyable();

    };

    class SafeBool {

    public:

        typedef void (SafeBool::*type)() const;

        static type makeSafe( bool value ) {

            return value ? &SafeBool::trueValue : 0;

        }

    private:

        void trueValue() const {}

    };

    template<typename ContainerT>

    inline void deleteAll( ContainerT& container ) {

        typename ContainerT::const_iterator it = container.begin();

        typename ContainerT::const_iterator itEnd = container.end();

        for(; it != itEnd; ++it )

            delete *it;

    }

    template<typename AssociativeContainerT>

    inline void deleteAllValues( AssociativeContainerT& container ) {

        typename AssociativeContainerT::const_iterator it = container.begin();

        typename AssociativeContainerT::const_iterator itEnd = container.end();

        for(; it != itEnd; ++it )

            delete it->second;

    }

    bool startsWith( std::string const& s, std::string const& prefix );

    bool startsWith( std::string const& s, char prefix );

    bool endsWith( std::string const& s, std::string const& suffix );

    bool endsWith( std::string const& s, char suffix );

    bool contains( std::string const& s, std::string const& infix );

    void toLowerInPlace( std::string& s );

    std::string toLower( std::string const& s );

    std::string trim( std::string const& str );

    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );

    struct pluralise {

        pluralise( std::size_t count, std::string const& label );

        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );

        std::size_t m_count;

        std::string m_label;

    };

    struct SourceLineInfo {

        SourceLineInfo();

        SourceLineInfo( char const* _file, std::size_t _line );

#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS

        SourceLineInfo(SourceLineInfo const& other)          = default;

        SourceLineInfo( SourceLineInfo && )                  = default;

        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;

        SourceLineInfo& operator = ( SourceLineInfo && )     = default;

#  endif

        bool empty() const;

        bool operator == ( SourceLineInfo const& other ) const;

        bool operator < ( SourceLineInfo const& other ) const;

        char const* file;

        std::size_t line;

    };

    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );

    // This is just here to avoid compiler warnings with macro constants and boolean literals

    inline bool isTrue( bool value ){ return value; }

    inline bool alwaysTrue() { return true; }

    inline bool alwaysFalse() { return false; }

    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );

    void seedRng( IConfig const& config );

    unsigned int rngSeed();

    // Use this in variadic streaming macros to allow

    //    >> +StreamEndStop

    // as well as

    //    >> stuff +StreamEndStop

    struct StreamEndStop {

        std::string operator+() {

            return std::string();

        }

    };

    template<typename T>

    T const& operator + ( T const& value, StreamEndStop ) {

        return value;

    }

}

#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )

#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );

namespace Catch {

    class NotImplementedException : public std::exception

    {

    public:

        NotImplementedException( SourceLineInfo const& lineInfo );

        NotImplementedException( NotImplementedException const& ) {}

        virtual ~NotImplementedException() CATCH_NOEXCEPT {}

        virtual const char* what() const CATCH_NOEXCEPT;

    private:

        std::string m_what;

        SourceLineInfo m_lineInfo;

    };

} // end namespace Catch

///////////////////////////////////////////////////////////////////////////////

#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )

// #included from: internal/catch_context.h

#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED

// #included from: catch_interfaces_generators.h

#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED

#include <string>

namespace Catch {

    struct IGeneratorInfo {

        virtual ~IGeneratorInfo();

        virtual bool moveNext() = 0;

        virtual std::size_t getCurrentIndex() const = 0;

    };

    struct IGeneratorsForTest {

        virtual ~IGeneratorsForTest();

        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;

        virtual bool moveNext() = 0;

    };

    IGeneratorsForTest* createGeneratorsForTest();

} // end namespace Catch

// #included from: catch_ptr.hpp

#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wpadded"

#endif

namespace Catch {

    // An intrusive reference counting smart pointer.

    // T must implement addRef() and release() methods

    // typically implementing the IShared interface

    template<typename T>

    class Ptr {

    public:

        Ptr() : m_p( CATCH_NULL ){}

        Ptr( T* p ) : m_p( p ){

            if( m_p )

                m_p->addRef();

        }

        Ptr( Ptr const& other ) : m_p( other.m_p ){

            if( m_p )

                m_p->addRef();

        }

        ~Ptr(){

            if( m_p )

                m_p->release();

        }

        void reset() {

            if( m_p )

                m_p->release();

            m_p = CATCH_NULL;

        }

        Ptr& operator = ( T* p ){

            Ptr temp( p );

            swap( temp );

            return *this;

        }

        Ptr& operator = ( Ptr const& other ){

            Ptr temp( other );

            swap( temp );

            return *this;

        }

        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }

        T* get() const{ return m_p; }

        T& operator*() const { return *m_p; }

        T* operator->() const { return m_p; }

        bool operator !() const { return m_p == CATCH_NULL; }

        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); }

    private:

        T* m_p;

    };

    struct IShared : NonCopyable {

        virtual ~IShared();

        virtual void addRef() const = 0;

        virtual void release() const = 0;

    };

    template<typename T = IShared>

    struct SharedImpl : T {

        SharedImpl() : m_rc( 0 ){}

        virtual void addRef() const {

            ++m_rc;

        }

        virtual void release() const {

            if( --m_rc == 0 )

                delete this;

        }

        mutable unsigned int m_rc;

    };

} // end namespace Catch

#ifdef __clang__

#pragma clang diagnostic pop

#endif

namespace Catch {

    class TestCase;

    class Stream;

    struct IResultCapture;

    struct IRunner;

    struct IGeneratorsForTest;

    struct IConfig;

    struct IContext

    {

        virtual ~IContext();

        virtual IResultCapture* getResultCapture() = 0;

        virtual IRunner* getRunner() = 0;

        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;

        virtual bool advanceGeneratorsForCurrentTest() = 0;

        virtual Ptr<IConfig const> getConfig() const = 0;

    };

    struct IMutableContext : IContext

    {

        virtual ~IMutableContext();

        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;

        virtual void setRunner( IRunner* runner ) = 0;

        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;

    };

    IContext& getCurrentContext();

    IMutableContext& getCurrentMutableContext();

    void cleanUpContext();

    Stream createStream( std::string const& streamName );

}

// #included from: internal/catch_test_registry.hpp

#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED

// #included from: catch_interfaces_testcase.h

#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED

#include <vector>

namespace Catch {