cppFriendsSample2.cpp

// プログラマたんbot(やめるのだフェネックで学ぶC++)の実証コード(ライブラリの使い方)
#include <cassert>
#include <cctype>
#include <ctime>
#include <cstdlib>
#include <codecvt>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <locale>
#include <map>
#include <random>
#include <regex>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>
#include <boost/any.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/variance.hpp>
#include <boost/icl/interval_set.hpp>
#include <boost/date_time/gregorian/gregorian_types.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/local_time/local_time.hpp>
#include <boost/date_time/time_facet.hpp>
#include <boost/filesystem.hpp>
#include <boost/fusion/algorithm/transformation/zip.hpp>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/include/zip.hpp>
#include <boost/fusion/include/make_vector.hpp>
#include <boost/iterator/zip_iterator.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/locale.hpp>
#include <boost/logic/tribool.hpp>
#include <boost/math/constants/constants.hpp>
#include <boost/math/distributions/poisson.hpp>
#include <boost/math/tools/minima.hpp>
#include <boost/multi_array.hpp>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/miller_rabin.hpp>
#include <boost/optional.hpp>
#include <boost/optional/optional_io.hpp>
#include <boost/random.hpp>
#include <boost/random/random_device.hpp>
#include <boost/regex.hpp>
#include <boost/type_traits/function_traits.hpp>
#include <gtest/gtest.h>
#include "cFriendsCommon.h"
#include "cppFriends.hpp"
// 自動生成されるヘッダファイル
#include "cppFriendsAutoGenerated.hpp"

// C++98では違う型、C++11は同じ型
static_assert(std::is_same<boost::fusion::vector<int,int>, boost::fusion::vector2<int,int>>::value, "Different");

class TestRegex : public ::testing::Test {
protected:
    static const std::string pattern_;
    static const std::string input_;
    static const std::string expected_;

    void createStdRegex(std::regex_constants::syntax_option_type t) {
        // 再帰正規表現はサポートしていない
        std::regex expr(pattern_, t);
    }
};

// ()の入れ子を、最も外側の()で分ける、再帰正規表現
const std::string TestRegex::pattern_  {"((?>[^\\s(]+|(\\((?>[^()]+|(?-1))*\\))))"};
const std::string TestRegex::input_    {" (a) ((b)) (((c))) (d) "};
const std::string TestRegex::expected_ {"(a)::((b))::(((c)))::(d)::"};

TEST_F(TestRegex, StdTypes1) {
    const auto typeSet = {std::regex_constants::ECMAScript, std::regex_constants::extended,
                          std::regex_constants::awk, std::regex_constants::egrep};

    for(auto t : typeSet) {
        ASSERT_ANY_THROW(createStdRegex(t));
    }
}

TEST_F(TestRegex, StdTypes2) {
    const auto typeSet = {std::regex_constants::basic, std::regex_constants::grep};

    for(auto t : typeSet) {
        using Iter = std::string::const_iterator;
        Iter startI = input_.begin();
        Iter endI = input_.end();
        std::match_results<Iter> results;
        std::regex expr(pattern_, t);
        std::regex_constants::match_flag_type flags = std::regex_constants::match_default;

        std::ostringstream os;
        while(std::regex_search(startI, endI, results, expr, flags)) {
            auto& head = results[0];
            const std::string substr(head.first, head.second);
            os << substr << "::";
            startI = head.second;
            flags |= std::regex_constants::match_prev_avail;
        }
        EXPECT_TRUE(os.str().empty());
    }
}

TEST_F(TestRegex, Boost) {
    using Iter = std::string::const_iterator;
    Iter startI = input_.begin();
    Iter endI = input_.end();
    boost::match_results<Iter> results;
    boost::regex expr(pattern_);
    boost::match_flag_type flags = boost::match_default;

    std::ostringstream osSearch;
    while(boost::regex_search(startI, endI, results, expr, flags)) {
        auto& head = results[0];
        const std::string substr(head.first, head.second);
        osSearch << substr << "::";
        startI = head.second;
        flags |= boost::match_prev_avail;
        flags |= boost::match_not_bob;
    }
    EXPECT_EQ(expected_, osSearch.str());

    std::ostringstream osIter;
    boost::sregex_token_iterator i {input_.begin(), input_.end(), expr, 1};
    boost::sregex_token_iterator e;
    while(i != e) {
        osIter << *i << "::";
        ++i;
    }
    EXPECT_EQ(expected_, osIter.str());
}

// MinGW 64だと処理が終わらなくなるが、最近のCygwinでも処理が終わらない
#if 0
namespace {
    void parseComplexRegex(void) {
        // https://www.checkmarx.com/wp-content/uploads/2015/03/ReDoS-Attacks.pdf
        std::regex expr("^[a-zA-Z]+(([\\'\\,\\.\\- ][a-zA-Z ])?[a-zA-Z]*)*$");
        std::smatch match;
        std::string str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaa!";
        ASSERT_TRUE(std::regex_match(str, match, expr));
    }
}

TEST_F(TestRegex, ReDos) {
    ASSERT_ANY_THROW(parseComplexRegex());
}
#endif

namespace {
    static_assert(sizeof(char) == 1, "Expect sizeof(char) == 1");
    static_assert(sizeof('a') == 1, "Expect sizeof(char) == 1");
    static_assert(sizeof(g_arrayForTestingSize) == 1, "g_arrayForTestingSize must have one element");
    static_assert(sizeof(TestingOuterStruct1) > sizeof(TestingOuterStruct1::member), "Unexpected struct size");
    static_assert(sizeof(TestingEmptyStruct) == 1, "Expect sizeof(empty struct) == 1");
    __attribute__((unused)) void funcTakesByte(uint8_t e) {}

    /* これら上とを同時には定義できない
    using BYTETYPE = uint8_t;
    void funcTakesByte(unsigned char e) {}
    void funcTakesByte(BYTETYPE e) {}
    */

    using Paragraph = std::vector<std::string>;
    const std::string MyJoinStrings(const Paragraph& paragraph) {
        std::ostringstream os;
        auto size = paragraph.size();

        for(decltype(size) i=0; i<size; ++i) {
            const auto& str = paragraph.at(i);
            os << str;
            if (((i + 1) < size) && !str.empty()) {
#if defined(__MINGW32__) || defined(__MINGW64__)
                auto isAsciiChar = __isascii(*(str.rbegin()));
#else
                auto isAsciiChar = ::isascii(*(str.rbegin()));
#endif
                if (isAsciiChar) {
                    // 正規のUTF-8を仮定し、MSBが1でなければUS-ASCIIとみなす
                    os << " ";
                }
            }
        }

        const std::string result = os.str();
        return result;
    }
}

// 行を結合して一行にする
class TestJoinStrings : public ::testing::Test {
protected:
    static const Paragraph sentence1_;
    static const Paragraph sentence2_;
    static const std::string expectedNoSpaces_;
    static const std::string expectedWithSpaces1_;
    static const std::string expectedWithSpaces2_;

    static const Paragraph sentenceJ1_;
    static const Paragraph sentenceJ2_;
    static const std::string expectedJapanese_;
    static const std::string expectedWithSpacesJ1_;
    static const std::string expectedWithSpacesJ2_;
};

// https://www.rain.org/~mkummel/stumpers/15feb02a.html
const Paragraph TestJoinStrings::sentence1_ {"Now", "here", "is", "water"};
const Paragraph TestJoinStrings::sentence2_ {"Nowhere", "is", "water"};
const std::string TestJoinStrings::expectedNoSpaces_ = "Nowhereiswater";
const std::string TestJoinStrings::expectedWithSpaces1_ = "Now here is water";
const std::string TestJoinStrings::expectedWithSpaces2_ = "Nowhere is water";

const Paragraph TestJoinStrings::sentenceJ1_ {"弁慶が", "なぎなたを振り回し"};
const Paragraph TestJoinStrings::sentenceJ2_ {"弁慶がな", "ぎなたを振り回し"};
const std::string TestJoinStrings::expectedJapanese_ = "弁慶がなぎなたを振り回し";
const std::string TestJoinStrings::expectedWithSpacesJ1_ = "弁慶が なぎなたを振り回し";
const std::string TestJoinStrings::expectedWithSpacesJ2_ = "弁慶がな ぎなたを振り回し";

TEST_F(TestJoinStrings, English) {
    const auto actualNoSpaces1 = boost::algorithm::join(sentence1_, "");
    const auto actualNoSpaces2 = boost::algorithm::join(sentence2_, "");
    const auto actualWithSpaces1 = boost::algorithm::join(sentence1_, " ");
    const auto actualWithSpaces2 = boost::algorithm::join(sentence2_, " ");
    EXPECT_EQ(expectedNoSpaces_, actualNoSpaces1);
    EXPECT_EQ(expectedNoSpaces_, actualNoSpaces2);
    EXPECT_EQ(expectedWithSpaces1_, actualWithSpaces1);
    EXPECT_EQ(expectedWithSpaces2_, actualWithSpaces2);

    const auto actual1 = MyJoinStrings(sentence1_);
    const auto actual2 = MyJoinStrings(sentence2_);
    EXPECT_EQ(expectedWithSpaces1_, actual1);
    EXPECT_EQ(expectedWithSpaces2_, actual2);
}

TEST_F(TestJoinStrings, NonAlpha) {
    const Paragraph vec {"1", "2 ", "", "3!", "$"};
    const std::string expected = "1 2  3! $";
    const auto actual = MyJoinStrings(vec);
    EXPECT_EQ(expected, actual);
}

TEST_F(TestJoinStrings, Japanese) {
    const auto actualWithSpaces1 = boost::algorithm::join(sentenceJ1_, " ");
    const auto actualWithSpaces2 = boost::algorithm::join(sentenceJ2_, " ");
    EXPECT_EQ(expectedWithSpacesJ1_, actualWithSpaces1);
    EXPECT_EQ(expectedWithSpacesJ2_, actualWithSpaces2);

    const auto actual1 = MyJoinStrings(sentenceJ1_);
    const auto actual2 = MyJoinStrings(sentenceJ2_);
    EXPECT_EQ(expectedJapanese_, actual1);
    EXPECT_EQ(expectedJapanese_, actual2);
}

// UTF-8を解釈する
class TestUtfCharCounter : public ::testing::Test{};

TEST_F(TestUtfCharCounter, Well) {
    // http://en.cppreference.com/w/cpp/locale/wstring_convert/from_bytes
    // の例で、utf8.data()を使っているが、utf8.data()は
    // C++11以前では null terminateされているとは限らない(C++11ではされている)
    std::string utf8jp = "かばんちゃん急に何を言い出すの";
    std::u16string utf16jp = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(utf8jp);
    EXPECT_EQ(15, utf16jp.size());

    // ラッキービーストは複数いるはず
    std::string utf8 = "I'm a lucky beast";
    std::u16string utf16 = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(utf8);
    EXPECT_EQ(17, utf16.size());

    constexpr size_t length = 5;
    std::vector<char> vec(length, ' ');
    vec.push_back(0);
    std::u16string utf16sp = std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(vec.data());
    EXPECT_EQ(length, utf16sp.size());
}

TEST_F(TestUtfCharCounter, ByteOrderMark) {
    // BOM + 半角空白
    const std::vector<uint8_t> elements {0xef, 0xbb, 0xbf, 0x20};

    std::vector<char> vec;
    for(auto e : elements) {
        vec.push_back(static_cast<char>(e));
    }
    vec.push_back(0);

    bool thrown = false;
    try {
        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(vec.data());
    } catch(std::range_error& e) {
        thrown = true;
    }
    EXPECT_FALSE(thrown);
}

TEST_F(TestUtfCharCounter, Ill) {
    // 半角空白 = 00100000 をわざと冗長なUTF-8で表現する
    // 11100000 10000000 10100000
    const std::vector<uint8_t> elements {0xe0, 0x80, 0xa0};

    constexpr size_t length = 5;
    std::vector<char> vec;
    for(size_t i=0; i<length; ++i) {
        for(auto e : elements) {
            vec.push_back(static_cast<char>(e));
        }
    }
    vec.push_back(0);

    bool thrown = false;
    try {
        std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(vec.data());
    } catch(std::range_error& e) {
        thrown = true;
    }
    EXPECT_TRUE(thrown);
}

// ファイル出力
class TestFileStream : public ::testing::Test {};

TEST_F(TestFileStream, Close) {
    EXPECT_FALSE(errno);
    {
        std::ofstream fs1;
        fs1.exceptions(std::ifstream::failbit);
        // ファイルに関連付けられていなければcloseに失敗する
        ASSERT_ANY_THROW(fs1.close());
    }
    EXPECT_FALSE(errno);

    {
        std::ofstream fs2;
        fs2.exceptions(std::ifstream::failbit);
        fs2 << "test";
        // ofstreamのデストラクタは失敗しても何も教えてくれない
    }
    EXPECT_FALSE(errno);
}

// 整数型が持てる最大桁数
static_assert(std::numeric_limits<uint64_t>::digits10 == 19, "");
static_assert(std::numeric_limits<int64_t>::digits10 == 18, "");

// 敢えて自作する
template <typename T>
constexpr int MyNumericLimitsDigits10_A(T a, int digits) {
    // 整数オーバフローを意図的に起こす
    auto n = a * 10 + 9;
    return (n > a) ? MyNumericLimitsDigits10_A(n, digits + 1) : digits;
}

template <typename T>
constexpr int MyNumericLimitsDigits10_A(void) {
    return MyNumericLimitsDigits10_A<T>(9,1);
}

static_assert(MyNumericLimitsDigits10_A<uint64_t>() == 19, "");

// Cygwin GCC 6.3.0では定数式ではないとされてコンパイルエラーになる
// GCC 5.4.0ではコンパイルエラーにならない
#if (__GNUC__ < 6)
static_assert(MyNumericLimitsDigits10_A<int64_t>() == 18, "");
#endif

template <typename T>
constexpr int MyNumericLimitsDigits10_B(T a, int digits) {
    auto n = a / 10;
    return (n) ? MyNumericLimitsDigits10_B(n, digits + 1) : digits;
}

template <typename T>
constexpr int MyNumericLimitsDigits10_B(void) {
    // std::is_signed
    using BitWidth = decltype(sizeof(T));
    constexpr T zero = 0;
    constexpr T preZero = zero - static_cast<T>(1);
    constexpr BitWidth isSigned = (zero > preZero) ? 1 : 0;

    T maxNumber = 0;
    constexpr BitWidth shift = sizeof(T) * 8 - isSigned;
    for(BitWidth i=0; i<shift; ++i) {
        // maxNumber *= 2 は -Wconversionで警告が出る
        maxNumber = static_cast<T>(maxNumber * 2);
        ++maxNumber;
    }
    return MyNumericLimitsDigits10_B<T>(maxNumber,0);
}

static_assert(MyNumericLimitsDigits10_B<uint64_t>() == 19, "");
static_assert(MyNumericLimitsDigits10_B<int64_t>()  == 18, "");
static_assert(MyNumericLimitsDigits10_B<uint64_t>() == std::numeric_limits<uint64_t>::digits10, "");
static_assert(MyNumericLimitsDigits10_B<uint32_t>() == std::numeric_limits<uint32_t>::digits10, "");
static_assert(MyNumericLimitsDigits10_B<uint16_t>() == std::numeric_limits<uint16_t>::digits10, "");
static_assert(MyNumericLimitsDigits10_B<uint8_t>()  == std::numeric_limits<uint8_t>::digits10, "");
static_assert(MyNumericLimitsDigits10_B<int64_t>() == std::numeric_limits<int64_t>::digits10, "");
static_assert(MyNumericLimitsDigits10_B<int32_t>() == std::numeric_limits<int32_t>::digits10, "");
static_assert(MyNumericLimitsDigits10_B<int16_t>() == std::numeric_limits<int16_t>::digits10, "");
static_assert(MyNumericLimitsDigits10_B<int8_t>()  == std::numeric_limits<int8_t>::digits10, "");

constexpr int MyIntMinExplicit(int l, int r) {
    return (l < r) ? l : r;
}

template <typename T>
constexpr T MyMin(T l, T r) {
    return (l < r) ? l : r;
}
// typedefは使えない
auto const MyIntMinAlias = &MyMin<int>;

// Cではこうするが、C++ではfunction traitsが使えない
#define CPPFRIENDS_MY_MACRO_MIN(l, r) ((l < r) ? l : r)

static_assert(std::is_same<int, decltype(MyIntMinExplicit(0,0))>::value, "");
static_assert(std::is_same<int, decltype(MyIntMinAlias(0,0))>::value, "");
static_assert(std::is_same<int, boost::function_traits<decltype(MyIntMinExplicit)>::arg1_type>::value, "");
static_assert(std::is_same<int, boost::function_traits<decltype(*MyIntMinExplicit)>::arg1_type>::value, "");
static_assert(std::is_same<int, boost::function_traits<decltype(*MyIntMinAlias)>::arg1_type>::value, "");
// こうは書けない
// static_assert(std::is_same<int, boost::function_traits<decltype(MyIntMinAlias)>::arg1_type>::value, "");
// static_assert(std::is_same<int, boost::function_traits<decltype(CPPFRIENDS_MY_MACRO_MIN)>::arg1_type>::value, "");

// #define MY_MACRO_POW(base, exp) ((exp) ? (base * MY_MACRO_POW(base, exp - 1)) : 1)

// 桁あふれは考慮していない
template <typename T>
constexpr T MyIntegerPow(T base, T exp) {
    return (exp) ? (base * MyIntegerPow(base, exp - 1)) : 1;
}

class TestCppMacro : public ::testing::Test {};

TEST_F(TestCppMacro, Plain) {
    EXPECT_EQ(-1, MyIntMinExplicit(-1, 0));
    EXPECT_EQ(-1, MyIntMinExplicit(0, -1));
    EXPECT_EQ(-1, MyIntMinAlias(-1, 0));
    EXPECT_EQ(-1, MyIntMinAlias(0, -1));
    EXPECT_EQ(-1, CPPFRIENDS_MY_MACRO_MIN(-1, 0));
    EXPECT_EQ(-1, CPPFRIENDS_MY_MACRO_MIN(0, -1));
}

TEST_F(TestCppMacro, Recursive) {
    using Data = unsigned int;
    Data base = 2;
    for(Data i=0; i<10; ++i) {
        EXPECT_EQ(1 << i, MyIntegerPow(base, i));
    }

    base = 3;
    Data expected = 1;
    for(Data i=0; i<5; ++i) {
        EXPECT_EQ(expected, MyIntegerPow(base, i));
        expected *= 3;
    }

    // こうは書けない
    // std::cout << MY_MACRO_POW(2,0);
}

class TestPrimalityTesting : public ::testing::Test{};

TEST_F(TestPrimalityTesting, MersenneNumber) {
    boost::random::random_device seed;
    std::mt19937 gen(seed);

    const unsigned int index[] = {3,5,7,13,17,19,31,61,89,107,127,521,607};
    using BigNumber = boost::multiprecision::uint1024_t;
    BigNumber base = 2;
    for(auto i : index) {
        BigNumber n = boost::multiprecision::pow(base, i);
        n -= 1;
        EXPECT_TRUE(boost::multiprecision::miller_rabin_test(n, 25, gen));
    }
}

// Googleの看板"{first 10-digit prime found in consecutive digits of e}.com"を解く
TEST_F(TestPrimalityTesting, QuizBoard) {
    using LongFloat = boost::multiprecision::number<boost::multiprecision::cpp_dec_float<200>>;
//  std::cout << "\n\n" << typeid(boost::multiprecision::cpp_dec_float_50::str).name() << "\n\n";
    static_assert(!std::is_floating_point<LongFloat>::value);
    static_assert(std::is_floating_point<double>::value);
    static_assert(boost::multiprecision::number_category<LongFloat>::value ==
                  boost::multiprecision::number_kind_floating_point);
    static_assert(boost::multiprecision::number_category<double>::value ==
                  boost::multiprecision::number_kind_floating_point);

    // const std::string にすると、770行のエラーメッセージが出る
    // decltype(str) = const std::string なので変換できない
    // std::string str = boost::math::constants::e<LongFloat>().convert_to<decltype(str)>();
    const auto str = boost::math::constants::e<LongFloat>().convert_to<std::string>();

    boost::random::random_device seed;
    std::mt19937 gen(seed);
    long long int digits = 0;
    decltype(digits) solution = 0;
    constexpr decltype(digits) expected = 7427466391ll;
    constexpr decltype(digits) base = 10000000000ll;  // 10桁
    static_assert(std::numeric_limits<decltype(digits)>::max() > base, "Too small");

    size_t i = 0;
    char digit[] = {'\0', '\0'};
    for(auto c : str) {
        ++i;
        if (!::isdigit(c)) {
            continue;
        }

        digits *= 10;
        digit[0] = c;
        digits += boost::lexical_cast<decltype(digits)>(digit);
        digits %= base;
        if ((i >= 10) && (boost::multiprecision::miller_rabin_test(digits, 25, gen))) {
            solution = digits;
            break;
        }
    }

    EXPECT_EQ(expected, solution);
}

class TestFindYearInNapierConstant : public ::testing::Test{};

// 指定された数がeに出てくる
TEST_F(TestFindYearInNapierConstant, YearAny) {
    using namespace boost::multiprecision;
    using LongFloat = number<cpp_dec_float<13000>>;
    using LongInt = cpp_int;
    const auto str = boost::math::constants::e<LongFloat>().convert_to<std::string>();
    const std::string target("2019");

    const auto pos = str.find(target);
    ASSERT_NE(std::string::npos, pos);
    EXPECT_EQ(6264, pos);

    std::string answer = str.substr(pos, target.size());
    EXPECT_EQ(target, answer);

    auto value = boost::math::constants::e<LongFloat>();
    auto len = pos + target.size() - 2;

    LongFloat shiftDigits = 10;
    value *= pow(shiftDigits, len);
    LongInt y = LongInt(trunc(value)) % 10000;
    EXPECT_EQ("2019", y.str());
}

TEST_F(TestFindYearInNapierConstant, Year2019) {
    using namespace boost::multiprecision;
    auto value = boost::math::constants::e<number<cpp_dec_float<13000>>>();
    decltype(value) shiftDigits = 10;
    value *= pow(shiftDigits, 6266);

    cpp_int year = cpp_int(trunc(value)) % 10000;
    // とっても長いコンパイルエラーのメッセージ
    // cpp_int year = trunc(value) % 10000;
    std::cout << year.str();
    EXPECT_EQ("2019", year.str());

    // もっと短いコンパイルエラーのメッセージ
    // double v = 2.718;
    // auto y = std::trunc(v) % 10000;
}

TEST_F(TestPrimalityTesting, CompilationError) {
    using namespace boost::multiprecision;
    using T=cpp_dec_float_50;
    T v=2.75;
    // boost::multiprecision::truncの返り値はunmentionable-expression-template-typeであって、Tではない
    // auto y = trunc(v);
    T y=trunc(v); // これは可能
    EXPECT_EQ("2", y.str());
    static_assert(!std::is_same<decltype(v), decltype(trunc(v))>::value, "Different Types");
}

TEST_F(TestPrimalityTesting, NegativeZero) {
    using RealNumber = double;
    boost::random::random_device seed;
    std::mt19937 gen(seed);
    std::uniform_real_distribution<RealNumber> dist(1.0, 2.0);
    // コンパイル時に計算しない
    auto number = -1.0 * dist(gen);

    constexpr int radix = std::numeric_limits<RealNumber>::radix;
    constexpr int loop = -2 * radix * std::numeric_limits<RealNumber>::min_exponent;
    EXPECT_LT(1, radix);
    EXPECT_LT(100, loop);

    for (int i=0; i<loop; ++i) {
        number /= std::numeric_limits<RealNumber>::radix + 0.1;
        EXPECT_TRUE(number <= 0.0);
    }

    uint8_t octets[sizeof(number)] {0};
    static_assert(sizeof(octets) == sizeof(number), "Must have same size");
    std::memmove(octets, &number, sizeof(octets));

    uint8_t sum = 0;
    for (decltype(octets[0]) octet : octets) {
        sum |= octet;
    }

    // Sign for negative zero is 1 in my environment
    EXPECT_TRUE(sum);
}

#if !defined(__MINGW32__) && !defined(__MINGW64__)
TEST_F(TestPrimalityTesting, ToBigNumber) {
    using BigNumber = boost::multiprecision::int1024_t;
//  using BigNumber = boost::multiprecision::number<boost::multiprecision::cpp_int>;
    std::string partDividendStr = "123456789";
    std::string partDividerStr  = "000000001";
    std::string dividendStr = partDividendStr;
    std::string dividerStr = "1";

    constexpr size_t n = 20;
    for(size_t i=1; i<n; ++i) {
        dividendStr += partDividendStr;
        dividerStr += partDividerStr;
    }
    EXPECT_EQ(n * partDividendStr.size(), dividendStr.size());
    EXPECT_EQ((n - 1) * partDividerStr.size() + 1, dividerStr.size());

    BigNumber dividend(dividendStr);
    BigNumber divider(dividerStr);
    EXPECT_EQ(dividendStr, dividend.str());
    EXPECT_EQ(dividerStr, divider.str());

    BigNumber zero("0");
    BigNumber reminder = dividend % divider;
    EXPECT_EQ(zero, reminder);
}
#endif

// Based on
// https://stackoverflow.com/questions/45943750/calculating-log-sum-exp-function-in-c
namespace {
    template <typename T, bool FilterInf = true,
              std::enable_if_t<boost::multiprecision::number_category<typename T::value_type>::value, std::nullptr_t> = nullptr>
    typename T::value_type logSumExp(const T& logProbabilityVec) {
        using ValueType = typename T::value_type;
        if (logProbabilityVec.empty()) {
            return -std::numeric_limits<ValueType>::infinity();
        }

        const auto maxElement = *std::max_element(
            logProbabilityVec.begin(), logProbabilityVec.end());

        // これがないと Inf - Inf = NaNになってしまう
        if (FilterInf && std::isinf(maxElement)) {
            return maxElement;
        }

        typename T::value_type sum = std::accumulate(
            logProbabilityVec.begin(), logProbabilityVec.end(), ValueType{0.0},
            [&maxElement](const auto& acc, const auto& element) {
                return acc + std::exp(element - maxElement); });

        return maxElement + std::log(sum);
    }
}

TEST_F(TestPrimalityTesting, LogSumExpDouble) {
    using ValueType = double;
    const std::vector<ValueType> logProbabilityVec {std::log(1.0/2.0), std::log(1.0/8.0), std::log(1.0/32.0)};
    const auto actual = logSumExp(logProbabilityVec);
    const auto expected = std::log(1.0/2.0 + 1.0/8.0 + 1.0/32.0);
    EXPECT_DOUBLE_EQ(expected, actual);
}

TEST_F(TestPrimalityTesting, LogSumExpFloat) {
    using ValueType = float;
    const std::vector<ValueType> logProbabilityVec {std::log(1.0/4.0), std::log(1.0/16.0), std::log(1.0/64.0)};
    const auto actual = logSumExp(logProbabilityVec);
    const auto expected = std::log(1.0/4.0 + 1.0/16.0 + 1.0/64.0);
    // floatをdoubleだと思って比較すると誤差が出る
    EXPECT_NEAR(expected, actual, 1e-5);
}

TEST_F(TestPrimalityTesting, LogSumExpEmpty) {
    const auto actual = logSumExp(std::vector<double>());
    EXPECT_TRUE(std::isinf(actual));
    EXPECT_GT(0.0, actual);
}

TEST_F(TestPrimalityTesting, LogSumExpInf) {
    using ValueType = double;
    const auto InfNum = std::numeric_limits<ValueType>::infinity();

    const std::vector<ValueType> positiveInfVec {InfNum, 2.0, -1.0};
    const auto actualPositive = logSumExp(positiveInfVec);
    EXPECT_TRUE(std::isinf(actualPositive));
    EXPECT_LT(0.0, actualPositive);
    EXPECT_TRUE(std::isnan(logSumExp<decltype(positiveInfVec), false>(positiveInfVec)));

    const std::vector<ValueType> negativeInfVec {-InfNum, -InfNum, -InfNum};
    const auto actualNegative = logSumExp(negativeInfVec);
    EXPECT_TRUE(std::isinf(actualNegative));
    EXPECT_GT(0.0, actualNegative);
    EXPECT_TRUE(std::isnan(logSumExp<decltype(negativeInfVec), false>(negativeInfVec)));
}

// これがコンパイルできるのは困る
#if 0
TEST_F(TestPrimalityTesting, Int) {
    const std::vector<int> logProbabilityVec {1, 2, 4};
    logSumExp(logProbabilityVec);
}
#endif

TEST_F(TestPrimalityTesting, Divide) {
    const double actual = std::log(1/2);
    EXPECT_TRUE(std::isinf(actual));
    EXPECT_GT(0.0, actual);
}

TEST_F(TestPrimalityTesting, BadAccumulation) {
    const std::vector<double> v {0.125, 0.25};
    const auto sumInt = std::accumulate(v.begin(), v.end(), 0,
                                        [](const auto& acc, const auto& element){
                                            return acc + element; });
    EXPECT_EQ(0, sumInt);

    const auto sumDouble = std::accumulate(v.begin(), v.end(),
                                           decltype(v)::value_type{0},
                                           [](const auto& acc, const auto& element){
                                               return acc+ element; });
    EXPECT_EQ(0.375, sumDouble);
}

// 浮動小数の誤差を適切に扱わないと何が起きるか
// https://snowtree-injune.com/2019/07/07/arange-linspace/
class TestIterateDouble : public ::testing::Test{};

namespace {
    struct IterateDoubleTestCase {
        using Value = double;
        Value stepValue;
        Value upperBound;
        int nSection = 10;
        Value expectedLast;
        std::string expectedArrange;
        std::string expectedLinspace;
    };

    const std::vector<IterateDoubleTestCase> IterateDoubleTestCaseSet {
        {0.1, 1.0, 10, 0.9, "^0.99999\\d+$", "^0.90000\\d+$"},
        {0.3, 0.9, 3, 0.6, "^0.89999\\d+$", "^0.59999\\d+$"},
    };
}

TEST_F(TestIterateDouble, PythonArangeLike) {
    using Value = IterateDoubleTestCase::Value;
    for (const auto& testCase : IterateDoubleTestCaseSet) {
        auto count = decltype(testCase.nSection){0};
        Value lastValue = 0;

        for(auto x=testCase.stepValue; x<testCase.upperBound; x+=testCase.stepValue) {
            lastValue = x;
            ++count;
        }

        std::smatch match;
        const auto s = boost::lexical_cast<std::string>(lastValue);
        EXPECT_TRUE(std::regex_match(s, match, std::regex(testCase.expectedArrange)));
        EXPECT_DOUBLE_EQ(testCase.upperBound, lastValue);
        EXPECT_EQ(testCase.nSection, count);
    }

    return;
}

TEST_F(TestIterateDouble, PythonArangeLikeFixed) {
    double lv = 0;
    for(double x=0.1; x<1.0; x+=0.1) {
        lv = x;
    }
    EXPECT_DOUBLE_EQ(1.0, lv);
    return;
}

TEST_F(TestIterateDouble, PythonLinspaceLike) {
    using Value = IterateDoubleTestCase::Value;
    for (const auto& testCase : IterateDoubleTestCaseSet) {
        auto count = decltype(testCase.nSection){0};
        Value lastValue = 0;

        for(auto i=decltype(count){1}; i<testCase.nSection; ++i) {
            lastValue = static_cast<Value>(i);
            lastValue *= testCase.upperBound;
            lastValue /= static_cast<Value>(testCase.nSection);
            ++count;
        }

        std::smatch match;
        const auto s = boost::lexical_cast<std::string>(lastValue);
        EXPECT_TRUE(std::regex_match(s, match, std::regex(testCase.expectedLinspace)));
        EXPECT_DOUBLE_EQ(testCase.expectedLast, lastValue);
        EXPECT_EQ(testCase.nSection - 1, count);
    }

    return;
}

namespace {
    template <typename Dist>
    std::string CppQpois(const std::string& title, Dist& dist) {
        const std::vector<double> quantiles {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9};
        std::vector<std::string> results;

        for (const auto& qValue : quantiles) {
            results.push_back(boost::lexical_cast<std::string>(boost::math::quantile(dist, qValue)));
        }

        std::string line = title;
        line += " : ";
        line += boost::algorithm::join(results, ",");
        return line;
    }
}

class TestDiscreteQuantilePolicies : public ::testing::Test{};

TEST_F(TestDiscreteQuantilePolicies, All) {
    using namespace boost::math;
    using namespace boost::math::policies;
    using MeanType = double;
    using PoisssonOutwards = poisson_distribution<MeanType, policy<discrete_quantile<integer_round_outwards>>>;
    using PoisssonInwards = poisson_distribution<MeanType, policy<discrete_quantile<integer_round_inwards>>>;
    using PoisssonDown = poisson_distribution<MeanType, policy<discrete_quantile<integer_round_down>>>;
    using PoisssonUp = poisson_distribution<MeanType, policy<discrete_quantile<integer_round_up>>>; // R qpois
    using PoisssonNearest = poisson_distribution<MeanType, policy<discrete_quantile<integer_round_nearest>>>;

    constexpr MeanType mean = 7;
    PoisssonOutwards distOutwards(mean);
    PoisssonInwards distInwards(mean);
    PoisssonDown distDown(mean);
    PoisssonUp distUp(mean);
    PoisssonNearest distNearest(mean);

    EXPECT_EQ("Outwards : 3,4,4,5,7,8,8,9,10", CppQpois("Outwards", distOutwards));
    EXPECT_EQ("Inwards  : 4,5,5,6,6,7,7,8,9", CppQpois("Inwards ", distInwards));
    EXPECT_EQ("Down     : 3,4,4,5,6,7,7,8,9", CppQpois("Down    ", distDown));
    EXPECT_EQ("Up       : 4,5,5,6,7,8,8,9,10", CppQpois("Up      ", distUp));
    EXPECT_EQ("Nearest  : 3,4,5,6,6,7,8,9,10", CppQpois("Nearest ", distNearest));
}

#if 0
// You will find very long error messages when you run code below.
class TestLargeErrorMessage : public ::testing::Test {};

TEST_F(TestLargeErrorMessage, StdCout) {
    constexpr int n = 0;
    std::cout << n < "\n";
}
#endif

// 時刻と時差を扱う
namespace {
    bool g_faultInStream = false;
    size_t g_facetDeleteCount = 0;

    class MyDebugFacet : public boost::posix_time::time_input_facet {
    public:
        MyDebugFacet(const string_type& str) : boost::posix_time::time_input_facet(str) {}
        virtual ~MyDebugFacet(void) { ++g_facetDeleteCount; }
    };

    std::string convertLocalTimeToUTC(const std::string& timeStr, const std::string& localeStr) {
        auto pInputFacet = std::make_unique<MyDebugFacet>("%d/%m/%Y %H:%M:%S %ZP");
        std::istringstream is(timeStr);
        boost::locale::generator gen;
        if (!localeStr.empty()) {
            is.imbue(gen(localeStr));
        }

        if (g_faultInStream) {
            throw std::runtime_error("Fail in imbue");
        }
        auto baseLoc = is.getloc();
        auto newloc = std::locale(baseLoc, pInputFacet.get());
        // 例外が投げられなかった場合は、input facetの所有権がnewlocに移ったので、
        // スマートポインタの所有権を放棄する
        pInputFacet.release();
        is.imbue(newloc);

        boost::local_time::local_date_time lt(boost::posix_time::not_a_date_time);
        is >> lt;

        std::ostringstream os;
        os << lt.utc_time();
        return os.str();
    }
}

class TestDateFormat : public ::testing::Test {
    virtual void SetUp() override {
        g_faultInStream = false;
        g_facetDeleteCount = 0;
    }
};

TEST_F(TestDateFormat, LeapSecond) {
    const char* dataDormat = "%Y-%m-%d %H:%M:%S";
    std::tm t = {};

    {
        std::istringstream is("2017-01-01 08:59:59");
        is >> std::get_time(&t, dataDormat);
        ASSERT_FALSE(is.fail());
        EXPECT_EQ(1483228799, std::mktime(&t));
    }

    {
        std::istringstream is("2017-01-01 08:59:60");
        is >> std::get_time(&t, dataDormat);
        ASSERT_FALSE(is.fail());
        EXPECT_EQ(1483228800, std::mktime(&t));

    }

    {
        std::istringstream is("2017-01-01 08:59:61");
        is >> std::get_time(&t, dataDormat);
#if defined(__MINGW32__) && !defined(__MINGW64__)
        ASSERT_FALSE(is.fail());
#else
        ASSERT_TRUE(is.fail());
#endif
    }
}

TEST_F(TestDateFormat, RepeatTime) {
    EXPECT_EQ("2017-Oct-29 00:30:00", convertLocalTimeToUTC("29/10/2017 01:30:00 BST+1", "en_GB.UTF-8"));
    EXPECT_EQ(1, g_facetDeleteCount);
    EXPECT_EQ("2017-Oct-29 01:30:00", convertLocalTimeToUTC("29/10/2017 01:30:00 GMT+0", "en_GB.UTF-8"));
    EXPECT_EQ(2, g_facetDeleteCount);
    EXPECT_EQ("2017-Oct-28 16:30:00", convertLocalTimeToUTC("29/10/2017 01:30:00 JST+9", "ja_JP.UTF-8"));
    EXPECT_EQ(3, g_facetDeleteCount);
}

TEST_F(TestDateFormat, Except) {
    g_faultInStream = true;
    ASSERT_ANY_THROW(convertLocalTimeToUTC("29/10/2017 01:30:00 JST+9", "ja_JP.UTF-8"));
    EXPECT_EQ(1, g_facetDeleteCount);
}

namespace JapariPark {
    class Animal {
    public:
        Animal(void) {
            setLine("animal");
        }
        virtual ~Animal(void) = default;

        const std::string& IntroduceSelf(void) const {
            return line_;
        }

    protected:
        Animal(const std::string& name) {
            setLine(name);
        }

    private:
        void setLine(const std::string& name) {
            line_ = "I'm ";
            // 本当はこれらの文字で始まっても母音でないこともあるし(uniqueなど)
            // これ以外の文字で始まっても母音のこともある(euroなど)
            line_ += (name.find_first_of("aeiou") == 0) ? "an" : "a";
            line_ += " ";
            line_ += name;
        }
        std::string line_;
    };

    class Cat : public Animal {
    public:
        Cat(void) : Animal("cat") {}
        virtual ~Cat(void) = default;
    protected:
        Cat(const std::string& name) : Animal(name) {}
    };

    class Serval : public Cat {
    public:
        Serval(void) : Cat("serval") {}
        virtual ~Serval(void) = default;
    };

    template <typename T>
    const std::string FindByKonoha(const T& obj) {
        std::string line;

        auto& tid = typeid(obj);
        if (tid == typeid(Animal)) {
            line = "She is an animal";
        } else if (tid == typeid(Cat)) {
            line = "She is a cat";
        } else if (tid == typeid(Serval)) {
            line = "She is a serval";
        } else {
            line = "Give me a second helping, please";
        }
        return line;
    }

    template <typename T>
    const std::string FindByKonohaHashCode(const T& obj) {
        std::string line;

        auto tcode = typeid(obj).hash_code();
        if (tcode == typeid(Animal).hash_code()) {
            line = "She is an animal.";
        } else if (tcode == typeid(Cat).hash_code()) {
            line = "She is a cat.";
        } else if (tcode == typeid(Serval).hash_code()) {
            line = "She is a serval.";
        } else {
            line = "Give me a second helping, please.";
        }
        return line;
    }

    template <typename T>
    const std::string FindByKonohaSwitchCase(const T& obj) {
        std::string line;
#if 0
        // typeid()が整数でないのでコンパイルできない
        switch(typeid(obj)) {
        case typeid(Animal):
            line = "She is an animal.";
            break;
        default:
            line = "Give me a second helping, please.";
            break;
        }

        switch(typeid(obj).hash_code()) {
        // caseがnon-constexprなのでコンパイルできない
        case typeid(Animal).hash_code():
            line = "She is an animal.";
            break;
        default:
            line = "Give me a second helping, please.";
            break;
        }
#endif
        return line;
    }

    const std::string FindByKonohaAny(const boost::any& obj) {
        std::string line;

        // constの有無はtypeidに影響しない
        if (obj.type() == typeid(Animal)) {
            line = "She is an animal!";
        } else if (obj.type() == typeid(Cat)) {
            line = "She is a cat!";
        } else if (obj.type() == typeid(Serval)) {
            line = "She is a serval!";
        } else {
            line = "Give me a second helping, please!";
        }
        return line;
    }

    time_t g_currentTimestamp;
    class ConstMemFn {
    public:
        virtual ~ConstMemFn(void) = default;
        void MakeSideEffect(void) const {
            g_currentTimestamp = ::time(nullptr);
            if (g_currentTimestamp) {
                throw std::runtime_error("Non zero timestamp");
            }
            return;
        }
    };
}

class TestSwitchCase : public ::testing::Test {};

TEST_F(TestSwitchCase, Polymorphism) {
    JapariPark::Animal animal;
    EXPECT_EQ("I'm an animal", animal.IntroduceSelf());
    JapariPark::Cat cat;
    EXPECT_EQ("I'm a cat", cat.IntroduceSelf());
    JapariPark::Serval serval;
    EXPECT_EQ("I'm a serval", serval.IntroduceSelf());
}

TEST_F(TestSwitchCase, Procedural) {
    JapariPark::Animal animal;
    EXPECT_EQ("She is an animal", JapariPark::FindByKonoha(animal));
    JapariPark::Cat cat;
    EXPECT_EQ("She is a cat", JapariPark::FindByKonoha(cat));
    JapariPark::Serval serval;
    EXPECT_EQ("She is a serval", JapariPark::FindByKonoha(serval));
    std::string str;
    EXPECT_EQ("Give me a second helping, please", JapariPark::FindByKonoha(str));
}

TEST_F(TestSwitchCase, HashCode) {
    JapariPark::Animal animal;
    EXPECT_EQ("She is an animal.", JapariPark::FindByKonohaHashCode(animal));
    JapariPark::Cat cat;
    EXPECT_EQ("She is a cat.", JapariPark::FindByKonohaHashCode(cat));
    JapariPark::Serval serval;
    EXPECT_EQ("She is a serval.", JapariPark::FindByKonohaHashCode(serval));
    std::string str;
    EXPECT_EQ("Give me a second helping, please.", JapariPark::FindByKonohaHashCode(str));
}

TEST_F(TestSwitchCase, SwitchCase) {
    std::string str;
    EXPECT_EQ("", JapariPark::FindByKonohaSwitchCase(str));
}

TEST_F(TestSwitchCase, Any) {
    JapariPark::Animal animal;
    const JapariPark::Animal animalC;

    boost::any obj = animal;
    EXPECT_EQ("She is an animal!", JapariPark::FindByKonohaAny(obj));
    obj = animalC;
    EXPECT_EQ("She is an animal!", JapariPark::FindByKonohaAny(obj));

    JapariPark::Cat cat;
    const JapariPark::Cat catC;
    obj = cat;
    EXPECT_EQ("She is a cat!", JapariPark::FindByKonohaAny(obj));
    obj = catC;
    EXPECT_EQ("She is a cat!", JapariPark::FindByKonohaAny(obj));

    JapariPark::Serval serval;
    const JapariPark::Serval servalC;
    obj = serval;
    EXPECT_EQ("She is a serval!", JapariPark::FindByKonohaAny(obj));
    obj = servalC;
    EXPECT_EQ("She is a serval!", JapariPark::FindByKonohaAny(obj));

    std::string str;
    obj = str;
    EXPECT_EQ("Give me a second helping, please!", JapariPark::FindByKonohaAny(obj));
}

TEST_F(TestSwitchCase, ConstMemFn) {
    JapariPark::g_currentTimestamp = 0;
    JapariPark::ConstMemFn obj;
    ASSERT_ANY_THROW(obj.MakeSideEffect());
    EXPECT_TRUE(JapariPark::g_currentTimestamp);
}

// ものすごくコンパイルが遅い
template <typename Result>
class BaseDelayedFunction {
public:
    virtual ~BaseDelayedFunction(void) = default;
    virtual Result Exec(void) = 0;
    virtual const std::string& GetName(void) = 0;
    virtual const std::string& GetPrettyName(void) = 0;
};

template <typename Result, typename Enable = void, typename ... ArgTypes>
class DelayedFunction;

template <typename Result, typename ... ArgTypes>
class DelayedFunction<Result,
                      typename std::enable_if_t<std::is_pod<Result>::value, void>, ArgTypes...>
    : public BaseDelayedFunction<Result> {
public:
    using Function = Result(&)(ArgTypes...);
    DelayedFunction(const Function f, ArgTypes... args) : func_(std::bind(f, args...)) {}
    virtual ~DelayedFunction(void) = default;
    virtual Result Exec(void) override { return func_(); }
    virtual const std::string& GetName(void) override {
        name_ = __FUNCTION__;
        return name_;
    }
    virtual const std::string& GetPrettyName(void) override {
        prettyName_ = __PRETTY_FUNCTION__;
        return prettyName_;
    }
private:
    std::function<Result()> func_;
    std::string name_;
    std::string prettyName_;
};

template <typename Result, typename ... ArgTypes>
class DelayedFunction<Result,
                      typename std::enable_if_t<!std::is_pod<Result>::value, void>, ArgTypes...>
    : public BaseDelayedFunction<Result> {
public:
    using Function = Result(&)(ArgTypes...);
    DelayedFunction(const Function f, ArgTypes... args) : func_(std::bind(f, args...)) {}
    virtual ~DelayedFunction(void) = default;
    virtual Result Exec(void) override { return func_(); }
    virtual const std::string& GetName(void) override {
        name_ = __FUNCTION__;
        return name_;
    }
    virtual const std::string& GetPrettyName(void) override {
        prettyName_ = __PRETTY_FUNCTION__;
        return prettyName_;
    }
private:
    std::function<Result()> func_;
    std::string name_;
    std::string prettyName_;
};

// && 対応は別途
namespace {
    template <typename Result, typename ... ArgTypes>
    auto CreateDelayedFunction(Result(&f)(ArgTypes...), ArgTypes... args) {
        auto func = std::make_unique<DelayedFunction<Result, void, ArgTypes...>>(f, args...);
        return func;
    }

    int intSum3(int a, int b, int c) {
        return a + b + c;
    }

    int intProduce5(int a, int b, int c, int d, int e) {
        return a * b * c * d * e;
    }

    using ClassInteger = boost::multiprecision::int1024_t;
    ClassInteger intNegate(ClassInteger a) {
        return -a;
    }
}

class TestFunctionName : public ::testing::Test {};

TEST_F(TestFunctionName, IntSum) {
    int a = 2;
    int b = 5;
    int c = 7;
    auto f = CreateDelayedFunction(intSum3, a, b, c);
    EXPECT_EQ(14, f->Exec());
    // GetName
    // const string& DelayedFunction<Result, typename std::enable_if<std::is_pod<_Tp>::value, void>::type, ArgTypes ...>::GetPrettyName() [with Result = int; ArgTypes = {int, int, int}; typename std::enable_if<std::is_pod<_Tp>::value, void>::type = void; std::string = std::basic_string<char>]
    std::cout << f->GetName() << "\n" << f->GetPrettyName()<< "\n";
}

TEST_F(TestFunctionName, IntProduct) {
    auto f = CreateDelayedFunction(intProduce5, 2, 3, 5, 7, 11);
    EXPECT_EQ(2310, f->Exec());
    // GetName
    // const string& DelayedFunction<Result, typename std::enable_if<std::is_pod<_Tp>::value, void>::type, ArgTypes ...>::GetPrettyName() [with Result = int; ArgTypes = {int, int, int, int, int}; typename std::enable_if<std::is_pod<_Tp>::value, void>::type = void; std::string = std::basic_string<char>]
    std::cout << f->GetName() << "\n" << f->GetPrettyName()<< "\n";
}

TEST_F(TestFunctionName, CppInt) {
    ClassInteger c = -1;
    auto f = CreateDelayedFunction(intNegate, c);
    EXPECT_EQ(1, f->Exec());
    // GetName
    // const string& DelayedFunction<Result, typename std::enable_if<(! std::is_pod<_Tp>::value), void>::type, ArgTypes ...>::GetPrettyName() [with Result = boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<1024u, 1024u, (boost::multiprecision::cpp_integer_type)1u, (boost::multiprecision::cpp_int_check_type)0u, void> >; ArgTypes = {boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<1024u, 1024u, (boost::multiprecision::cpp_integer_type)1u, (boost::multiprecision::cpp_int_check_type)0u, void>, (boost::multiprecision::expression_template_option)0u>}; typename std::enable_if<(! std::is_pod<_Tp>::value), void>::type = void; std::string = std::basic_string<char>]
    std::cout << f->GetName() << "\n" << f->GetPrettyName()<< "\n";
}

namespace {
    struct MyConstBoolObject {
        constexpr MyConstBoolObject(bool b) : b_{b} {}
        operator bool() const { return b_; }
        const bool b_ {false};
    };

    bool g_assertFlag = false;

    void SetAssertFlag(void) {
        g_assertFlag = true;
    }

    bool SetAndClearAssertFlag(void) {
        bool flag = false;
        std::swap(flag, g_assertFlag);
        return flag;
    }

    void MyAssertImpl(void) {
        SetAssertFlag();
    }

    template <typename T>
    void MyAssert(T&& cond) {
        if (cond) {
            return;
        }
        MyAssertImpl();
    }
}

class TestTemplateAssert : public ::testing::Test {
    virtual void SetUp() override {
        SetAndClearAssertFlag();
    }
};

TEST_F(TestTemplateAssert, TemplateTrue) {
    // lvalue
    bool b = true;
    MyAssert(b);
    EXPECT_FALSE(SetAndClearAssertFlag());

    int c = 1;
    MyAssert(c);
    EXPECT_FALSE(SetAndClearAssertFlag());

    MyConstBoolObject obj(true);
    MyAssert(obj);
    EXPECT_FALSE(SetAndClearAssertFlag());

    auto p = &c;
    MyAssert(p);
    EXPECT_FALSE(SetAndClearAssertFlag());

    // rvalue
    MyAssert(2);
    EXPECT_FALSE(SetAndClearAssertFlag());

    MyAssert(MyConstBoolObject(true));
    EXPECT_FALSE(SetAndClearAssertFlag());

    MyAssert(&c);
    EXPECT_FALSE(SetAndClearAssertFlag());

    // 式
    MyAssert(MyConstBoolObject(c < 2));
    EXPECT_FALSE(SetAndClearAssertFlag());
}

TEST_F(TestTemplateAssert, ConstTrue) {
    const bool b = true;
    MyAssert(b);
    EXPECT_FALSE(SetAndClearAssertFlag());

    const int c = 1;
    MyAssert(c);
    EXPECT_FALSE(SetAndClearAssertFlag());

    const MyConstBoolObject obj(true);
    MyAssert(obj);
    EXPECT_FALSE(SetAndClearAssertFlag());

    std::vector<bool> vec {true, true};
    MyAssert(vec.at(0));
    EXPECT_FALSE(SetAndClearAssertFlag());
}

TEST_F(TestTemplateAssert, TemplateFalse) {
    bool b = false;
    MyAssert(b);
    EXPECT_TRUE(SetAndClearAssertFlag());

    int c = 0;
    MyAssert(c);
    EXPECT_TRUE(SetAndClearAssertFlag());

    MyConstBoolObject obj(false);
    MyAssert(obj);
    EXPECT_TRUE(SetAndClearAssertFlag());

    void* p = nullptr;
    MyAssert(p);
    EXPECT_TRUE(SetAndClearAssertFlag());

    MyAssert(0);
    EXPECT_TRUE(SetAndClearAssertFlag());

    MyAssert(MyConstBoolObject(false));
    EXPECT_TRUE(SetAndClearAssertFlag());

    MyAssert(nullptr);
    EXPECT_TRUE(SetAndClearAssertFlag());

    // 式
    MyAssert(MyConstBoolObject(c > 0));
    EXPECT_TRUE(SetAndClearAssertFlag());

    std::vector<bool> vec {false, false};
    MyAssert(vec.at(0));
    EXPECT_TRUE(SetAndClearAssertFlag());
}

TEST_F(TestTemplateAssert, ConstFalse) {
    const bool b = false;
    MyAssert(b);
    EXPECT_TRUE(SetAndClearAssertFlag());

    const int c = 0;
    MyAssert(c);
    EXPECT_TRUE(SetAndClearAssertFlag());

    const MyConstBoolObject obj(false);
    MyAssert(obj);
    EXPECT_TRUE(SetAndClearAssertFlag());
}

namespace {
    void MyAssertByBool(bool cond) {
        if (cond) {
            return;
        }
        MyAssertImpl();
    }
}

TEST_F(TestTemplateAssert, BoolTrue) {
    // lvalue
    bool b = true;
    MyAssertByBool(b);
    EXPECT_FALSE(SetAndClearAssertFlag());

    int c = 1;
    MyAssertByBool(c);
    EXPECT_FALSE(SetAndClearAssertFlag());

    MyConstBoolObject obj(true);
    MyAssertByBool(obj);
    EXPECT_FALSE(SetAndClearAssertFlag());

    auto p = &c;
    MyAssertByBool(p);
    EXPECT_FALSE(SetAndClearAssertFlag());

    // rvalue
    MyAssertByBool(2);
    EXPECT_FALSE(SetAndClearAssertFlag());

    MyAssertByBool(MyConstBoolObject(true));
    EXPECT_FALSE(SetAndClearAssertFlag());

    // &vが常にtrueと評価されると警告が出る
    // MyAssertByBool(&c);
    // EXPECT_FALSE(SetAndClearAssertFlag());

    // 式
    MyAssert(MyConstBoolObject(c < 2));
    EXPECT_FALSE(SetAndClearAssertFlag());
}

TEST_F(TestTemplateAssert, BoolFalse) {
    bool b = false;
    MyAssertByBool(b);
    EXPECT_TRUE(SetAndClearAssertFlag());

    int c = 0;
    MyAssertByBool(c);
    EXPECT_TRUE(SetAndClearAssertFlag());

    MyConstBoolObject obj(false);
    MyAssertByBool(obj);
    EXPECT_TRUE(SetAndClearAssertFlag());

    // boolに変換できる
    void* p = nullptr;
    MyAssertByBool(p);
    EXPECT_TRUE(SetAndClearAssertFlag());

    MyAssertByBool(0);
    EXPECT_TRUE(SetAndClearAssertFlag());

    MyAssertByBool(MyConstBoolObject(false));
    EXPECT_TRUE(SetAndClearAssertFlag());

    // nullptrをboolに変換できないのでエラーになる
    // MyAssertByBool(nullptr);

    // 式
    MyAssert(MyConstBoolObject(c > 0));
    EXPECT_TRUE(SetAndClearAssertFlag());
}

namespace {
    void MyAssertByInt(int cond) {
        if (cond) {
            return;
        }
        MyAssertImpl();
    }
}

TEST_F(TestTemplateAssert, Int) {
    bool b = true;
    MyAssertByInt(b);
    EXPECT_FALSE(SetAndClearAssertFlag());

    MyConstBoolObject objBool(true);
    MyAssertByInt(objBool);
    EXPECT_FALSE(SetAndClearAssertFlag());

    int c = 1;
    MyAssertByInt(c);
    EXPECT_FALSE(SetAndClearAssertFlag());
    MyAssertByInt(1);
    EXPECT_FALSE(SetAndClearAssertFlag());

    // intに変換できないのでコンパイルエラーになる
    // MyAssertByInt(&c);
    // void* p = nullptr;
    // MyAssertByInt(p);
}

class TestFileAlias : public ::testing::Test {};

TEST_F(TestFileAlias, All) {
    const std::string NodeFilename(g_cppFriendsNodeFilename);
    const std::string SymlinkFilename(g_cppFriendsSymlinkFilename);
    const std::string HardlinkFilename(g_cppFriendsHardlinkFilename);

    EXPECT_FALSE(NodeFilename.empty());
    EXPECT_TRUE(boost::filesystem::equivalent(NodeFilename, NodeFilename));

    if (!SymlinkFilename.empty()) {
        EXPECT_TRUE(boost::filesystem::equivalent(SymlinkFilename, SymlinkFilename));
        EXPECT_TRUE(boost::filesystem::equivalent(SymlinkFilename, NodeFilename));
    }

    if (!HardlinkFilename.empty()) {
        EXPECT_TRUE(boost::filesystem::equivalent(HardlinkFilename, HardlinkFilename));
        EXPECT_TRUE(boost::filesystem::equivalent(HardlinkFilename, NodeFilename));
        if (!SymlinkFilename.empty()) {
            EXPECT_TRUE(boost::filesystem::equivalent(HardlinkFilename, SymlinkFilename));
        }
    }
}

class TestTriBool : public ::testing::Test {};

TEST_F(TestTriBool, TriBool) {
    boost::logic::tribool b = boost::logic::indeterminate;
#if 0
    EXPECT_TRUE(b);   // actual false
    EXPECT_FALSE(b);  // actual true
#endif
    EXPECT_TRUE(boost::logic::indeterminate(b));

    if (b) {
        EXPECT_TRUE(false);
    } else {
        EXPECT_TRUE(true);
    }

    if (!b) {
        EXPECT_TRUE(false);
    } else {
        EXPECT_TRUE(true);
    }

    b = false;
    EXPECT_FALSE(boost::logic::indeterminate(b));
    EXPECT_FALSE(b);
    EXPECT_TRUE(!b);

    b = true;
    EXPECT_FALSE(boost::logic::indeterminate(b));
    EXPECT_TRUE(b);
    EXPECT_FALSE(!b);
}

TEST_F(TestTriBool, Optional) {
    boost::optional<bool> tb;
    EXPECT_FALSE(tb);

    tb = false;
    ASSERT_TRUE(tb);
    EXPECT_FALSE(*tb);

    tb = true;
    ASSERT_TRUE(tb);
    EXPECT_TRUE(*tb);
}

class TestOptional : public ::testing::Test {};

TEST_F(TestOptional, Print) {
    boost::optional<int> uninitInt;
    std::ostringstream osUninitInt;
    osUninitInt << uninitInt;
    EXPECT_EQ("--", osUninitInt.str());

    boost::optional<int> initInt {-123};
    std::ostringstream osInitInt;
    osInitInt << initInt;
    EXPECT_EQ(" -123", osInitInt.str());

    std::ostringstream osInt;
    osInt << uninitInt << initInt.get();
    EXPECT_EQ("---123", osInt.str());

    boost::optional<std::string> uninitStr;
    boost::optional<std::string> initStr {"Str"};
    std::ostringstream osStr;
    osStr << uninitStr << initStr;
    EXPECT_EQ("-- Str", osStr.str());

    std::ostringstream osStrValue;
    osStrValue << uninitStr << *initStr;
    EXPECT_EQ("--Str", osStrValue.str());
}

TEST_F(TestOptional, Arrow) {
    struct MyPair {
        struct Value {
            int num;
        };
        int key {0};
        boost::optional<Value> value;
    };

    MyPair kv;
    kv.key = 1;
    kv.value = MyPair::Value {2};
    EXPECT_EQ(1, kv.key);
    ASSERT_TRUE(kv.value);
    ASSERT_EQ(2, kv.value->num);
}

namespace {
    struct Element {
        int id;
        std::string key;
        std::string value;
    };

    // http://www.boost.org/doc/libs/1_66_0/libs/multi_index/example/basic.cpp
    // には{}があるが、なくてもよい
    struct id;
    struct key;

    // 宣言は複数あってもよい
    struct id;

    using MyOrderedDic = boost::multi_index_container <
        Element,
        boost::multi_index::indexed_by <
            boost::multi_index::ordered_unique <
                boost::multi_index::tag<id>,
                BOOST_MULTI_INDEX_MEMBER(Element, decltype(Element::id), Element::id)>,
            boost::multi_index::ordered_unique <
                boost::multi_index::tag<key>,
                BOOST_MULTI_INDEX_MEMBER(Element, decltype(Element::key), Element::key)>
            >>;
}

class TestMultiIndex : public ::testing::Test {};

TEST_F(TestMultiIndex, OrderedDic) {
    MyOrderedDic dic;
    dic.insert(Element{1, "Serval Cat", "Leptailurus serval"});
    dic.insert(Element{2, "Fennec Fox", "Vulpes zerda"});
    dic.insert(Element{3, "Raccoon", "Procyon lotor"});

    std::ostringstream osId;
    for(const auto& element : dic.get<id>()) {
        osId << element.key;
    }
    EXPECT_EQ("Serval CatFennec FoxRaccoon", osId.str());

    std::ostringstream osKey;
    std::ostringstream osValue;
    for(const auto& element : dic.get<key>()) {
        osKey << element.key;
        osValue << element.value;
    }
    EXPECT_EQ("Fennec FoxRaccoonServal Cat", osKey.str());
    EXPECT_EQ("Vulpes zerdaProcyon lotorLeptailurus serval", osValue.str());
}

// 以下を元に作成
// https://stackoverflow.com/questions/28217179/iterating-boosticlinterval-set
class TestInterval : public ::testing::Test {};

TEST_F(TestInterval, SplitBySubtraction) {
    using RangeSet = boost::icl::interval_set<double>;
    using Range = RangeSet::interval_type;

    // 一区間を下記のように二区間で引き算すると、三区間に分かれる
    RangeSet ranges;
    ranges += Range::right_open(1.5, 16.5);
    ranges -= Range::right_open(2.5, 4.5);
    ranges -= Range::right_open(7.5, 11.5);

    std::ostringstream os;
    for(auto&& i = ranges.begin(); i != ranges.end(); ++i){
        os << "[" << i->lower() << "," << i->upper() << "]";
    }

    EXPECT_EQ("[1.5,2.5][4.5,7.5][11.5,16.5]", os.str());
}

namespace {
    template <typename T, typename std::enable_if_t<std::numeric_limits<T>::has_infinity, std::nullptr_t> = nullptr>
    size_t literal_sizeof(void) {
        if (std::numeric_limits<T>::has_infinity) {
            auto p = malloc(sizeof(std::numeric_limits<T>::infinity()));
            free(p);
        }
        return sizeof(T);
    }
}

class TestLiteralSizeof : public ::testing::Test {};

TEST_F(TestLiteralSizeof, Double) {
    EXPECT_EQ(sizeof(float), literal_sizeof<float>());
    EXPECT_EQ(sizeof(double), literal_sizeof<double>());
    free(malloc(sizeof(3.14)));
    free(malloc(sizeof(std::numeric_limits<double>::quiet_NaN())));
    static_assert(std::is_same<size_t, decltype(sizeof(3.14))>::value, "");
    static_assert(sizeof(double) == sizeof(3.14), "");
}

TEST_F(TestLiteralSizeof, Zero) {
    // It's safe
    free(malloc(0));
}

class TestTypeDeduction : public ::testing::Test {};

TEST_F(TestTypeDeduction, Constant) {
    size_t count = 0;
    constexpr size_t n = 0x80000000u;
#if 0
    // n>=0x80000000のときに、iがnを超えることはないので無限ループ
    for(auto i=0; i<n; ++i) {
        static_assert(std::is_same<size_t, std::remove_const_t<decltype(n)>>::value, "");
        static_assert(std::is_const<decltype(n)>::value, "");
        static_assert(std::is_same<int, decltype(i)>::value, "");
        static_assert(!std::is_const<decltype(i)>::value, "");
        static_assert(!std::is_same<decltype(i), std::remove_const_t<decltype(n)>>::value, "");
        ++count;
    }
#endif
    for(auto i=decltype(n){0}; i<n; ++i) {
        static_assert(std::is_same<size_t, decltype(i)>::value, "");
        static_assert(!std::is_const<decltype(i)>::value, "");
        static_assert(std::is_same<decltype(i), std::remove_const_t<decltype(n)>>::value, "");
        ++count;
    }

    EXPECT_EQ(n, count);
}

// #define CAUSE_COMPILATION_ERROR
namespace {
    class MyBaseClass {
    public:
        virtual ~MyBaseClass(void) = default;
        virtual int GetA(void) = 0;
        virtual int GetB(void) = 0;
    };

    class MyIntermediateClass : public MyBaseClass {
    public:
        virtual ~MyIntermediateClass(void) = default;
        virtual int GetA(void) final { return 1; };
        virtual int GetB(void) override { return 2; };
        virtual int final(void) { return 3; };
    };

    class MyFinalClass final : public MyIntermediateClass {
    public:
        constexpr MyFinalClass(int arg) { final = arg; }
        virtual ~MyFinalClass(void) = default;
#ifdef CAUSE_COMPILATION_ERROR
        virtual int GetA(void) { return 4; };
#endif
        virtual int GetB(void) override { return final; }
        virtual int override(void) { return 5; };
    private:
        int final {0};
    };

#ifdef CAUSE_COMPILATION_ERROR
    class MySuperClass : public MyFinalClass {};
#endif
}

class TestFinalKeyword : public ::testing::Test {};

TEST_F(TestFinalKeyword, All) {
    MyIntermediateClass intermediate;
    EXPECT_EQ(1, intermediate.GetA());
    EXPECT_EQ(2, intermediate.GetB());
    EXPECT_EQ(3, intermediate.final());

    constexpr int n = 6;
    MyFinalClass final(n);
    EXPECT_EQ(1, final.GetA());
    EXPECT_EQ(n, final.GetB());
    auto override = final.override();
    EXPECT_EQ(5, override);
}

class TestMultiArray : public ::testing::Test {};

TEST_F(TestMultiArray, Iteration) {
    using MyArray = boost::multi_array<int, 3>;
    constexpr int size = 3;
    MyArray mat(boost::extents[size][size][size]);

    int value = 0;
    for(int indexA = 0; indexA < size; ++indexA) {
        for(int indexB = 0; indexB < size; ++indexB) {
            for(int indexC = 0; indexC < size; ++indexC) {
                mat[indexA][indexB][indexC] = ++value;
            }
        }
    }

    MyArray::index_range full_range;
    MyArray::array_view<1>::type view = mat[boost::indices[full_range][0][0]];

    int index = 0;
    for(auto&& e : view) {
        EXPECT_EQ(index * size * size + 1, e);
        ++e;
        ++index;
    }

    index = 0;
    for(auto i = view.begin(); i != view.end(); ++i) {
        EXPECT_EQ(index * size * size + 2, *i);
        ++index;
    }
}

namespace {
    template<class T> struct RemoveKeyConst {
        using value_type = std::pair<
            typename std::remove_const_t<typename T::key_type>,
            typename T::mapped_type>;
    };
};

class TestRemoveConstFromKey : public ::testing::Test {};

TEST_F(TestRemoveConstFromKey, Iteration) {
    std::map<int, std::string> keyMap;
    const std::string expected1("one");
    const std::string expected2("two");
    keyMap[1] = expected1;
    keyMap[2] = expected2;
    EXPECT_EQ(expected1, keyMap[1]);

    decltype(keyMap)::value_type constKeyValue(2, expected2);
    // firstがconstなのでこれはできない
    // constKeyValue.first = 3;
    EXPECT_EQ(2, constKeyValue.first);
    EXPECT_EQ(expected2, constKeyValue.second);
    EXPECT_EQ(expected2, keyMap[2]);

    RemoveKeyConst<decltype(keyMap)>::value_type keyValue(3, expected2);
    keyValue.first = 2;
    EXPECT_EQ(2, keyValue.first);
    EXPECT_EQ(expected2, keyValue.second);
}

namespace {
    class MyParser {
    public:
        enum class Mode {
            PARSE_INT,
            OTHERS
        };

        MyParser(Mode mode) :
            setter_(std::bind(&MyParser::setDefault, this, std::placeholders::_1)) {
            switch(mode) {
            case Mode::PARSE_INT:
                setter_ = std::bind(&MyParser::setInt, this, std::placeholders::_1);
                break;
            default:
                break;
            }
        }

        virtual ~MyParser(void) = default;

        void Set(const std::string& s) {
            setter_(s);
            return;
        }

        int GetInt(void) const {
            return i_;
        }

        const std::string& GetString(void) const {
            return s_;
        }

    private:
        void setInt(const std::string& s) {
            i_ = boost::lexical_cast<decltype(i_)>(s);
            setDefault(s);
            return;
        }

        void setDefault(const std::string& s) {
            s_ = s;
            return;
        }

        std::function<void(const std::string& s)> setter_;
        int i_ {0};
        std::string s_;
    };
};

class TestBindMemberFunction : public ::testing::Test {};

TEST_F(TestBindMemberFunction, All) {
    MyParser parserInt(MyParser::Mode::PARSE_INT);
    parserInt.Set("123");
    EXPECT_EQ(123, parserInt.GetInt());
    EXPECT_EQ("123", parserInt.GetString());
    ASSERT_ANY_THROW(parserInt.Set("ABC"));

    MyParser parserDefault(MyParser::Mode::OTHERS);
    parserDefault.Set("abc");
    EXPECT_EQ(0, parserDefault.GetInt());
    EXPECT_EQ("abc", parserDefault.GetString());
}

#if 0
TEST_F(TestBindMemberFunction, Error) {
    // >が足りないが、template argument 2 is invalid としか言われない
    using FuncMap = std::map<int, std::function<void(int)>;
    FuncMap mp;
}
#endif

class TestOddEven : public ::testing::Test {};

TEST_F(TestOddEven, All) {
    for(int i=0; i<100; ++i) {
        const auto expected = (i % 2) == 0;
        std::smatch match;
        const auto s = boost::lexical_cast<std::string>(i);
        bool actual = std::regex_match(s, match, std::regex("^.*(0|2|4|6|8)\\s*$"));
        EXPECT_EQ(expected, actual);
    }
}

class TestBoostStat : public ::testing::Test {};

TEST_F(TestBoostStat, Sum) {
    using namespace boost::accumulators;
    using T = int;
    accumulator_set<T, stats<tag::sum>> acc;

    acc(1);
    acc(2);
    acc(4);
    const T expected = 7;
    EXPECT_EQ(expected, sum(acc));
}

TEST_F(TestBoostStat, MeanVar) {
    using namespace boost::accumulators;
    using T = double;
    accumulator_set<T, stats<tag::mean, tag::variance>> acc;
//  こう書くと、大量のエラーが出る
//  accumulator_set<T, stats<tag::mean>, stats<tag::variance>> accMeanVar;

    acc(1);
    acc(2);
    acc(3);
    const T expectedMean = 2.0;
    const T expectedVar = 2.0 / 3.0;
    EXPECT_DOUBLE_EQ(expectedMean, mean(acc));
    EXPECT_DOUBLE_EQ(expectedVar, variance(acc));
}

class TestCheckRandomSeed : public ::testing::Test {};

TEST_F(TestCheckRandomSeed, Reproduce) {
    std::random_device randDev;
    std::vector<std::random_device::result_type> seedSet;
    const auto seedSize = decltype(seedSet)::value_type{100};

    for(auto i=decltype(seedSize){0}; i<seedSize; ++i) {
        seedSet.push_back(randDev());
    }

    using RandEngine = std::mt19937;
    std::vector<RandEngine::result_type> randNumbers;

    // First
    for(const auto& seed : seedSet) {
        RandEngine gen(seed);
        randNumbers.push_back(gen());
    }
    ASSERT_FALSE(randNumbers.empty());

    // Second
    const auto numSize = randNumbers.size();
    for(auto i=decltype(numSize){0}; i<numSize; ++i) {
        RandEngine gen(seedSet.at(i));
        EXPECT_EQ(randNumbers.at(i), gen());
    }
}

class TestBrendFindMinima : public ::testing::Test {};

TEST_F(TestBrendFindMinima, All) {
    using ValueType = double;
    auto r = boost::math::tools::brent_find_minima(
        [](ValueType x) {return x * std::log(x);},
        std::numeric_limits<ValueType>::min(),
        std::numeric_limits<ValueType>::max(),
        20);

    const auto expected = std::exp(-1);
    EXPECT_NEAR(expected, r.first, 1e-6);
    EXPECT_NEAR(-expected, r.second, 1e-6);
}

class TestDayOfYear : public ::testing::Test {};

TEST_F(TestDayOfYear, All) {
    using boost::gregorian::date;
    EXPECT_LT(0, boost::gregorian::day_clock::local_day().day_of_year());
    if (boost::gregorian::day_clock::local_day().day_of_year() == 256) {
        // Prorammers' day
        EXPECT_TRUE(true);
    }

    date theFirstDay = boost::gregorian::from_string("2020/01/01");
    EXPECT_EQ(1, theFirstDay.day_of_year());

    date silvester = boost::gregorian::from_string("2020/12/31");
    EXPECT_EQ(366, silvester.day_of_year());

    date theProgrammersDay2019 = boost::gregorian::from_string("2019/09/13");
    EXPECT_EQ(256, theProgrammersDay2019.day_of_year());

    date theProgrammersDay2020 = boost::gregorian::from_string("2020/09/12");
    EXPECT_EQ(256, theProgrammersDay2020.day_of_year());
}

class TestZipIterator : public ::testing::Test {};

// http://boost.cppll.jp/HEAD//libs/iterator/doc/zip_iterator.html
TEST_F(TestZipIterator, Iter) {
    const std::vector<std::string> numStrSet {"1", "2", "3"};
    const std::vector<int> numIntSet {10, 20, 30};

    using T = boost::tuple<std::string, int>;
    auto iBegins = boost::make_zip_iterator(boost::make_tuple(numStrSet.begin(), numIntSet.begin()));
    auto iEnds = boost::make_zip_iterator(boost::make_tuple(numStrSet.end(), numIntSet.end()));
    std::for_each(iBegins, iEnds, [&](const T& t) {
//      [&](const auto& t) {
        ASSERT_EQ(t.get<1>(), 10 * boost::lexical_cast<int>(t.get<0>()));
    });
}

// https://www.boost.org/doc/libs/1_72_0/libs/fusion/doc/html/fusion/algorithm/transformation/functions/zip.html
TEST_F(TestZipIterator, Fusion) {
    boost::fusion::vector<std::string, std::string> numStrSet("1", "2");
    boost::fusion::vector<int, int> numIntSet(10, 20);

    assert(boost::fusion::zip(numStrSet, numIntSet) ==
           boost::fusion::make_vector(boost::fusion::make_vector("1", 10),
                                      boost::fusion::make_vector("2", 20)));
}

VarSample GetVoid() {
    VarSample v = std::monostate{};
    return v;
}

VarSample GetDerived1() {
    VarSample v = VarDerived1{};
    return v;
}

VarSample GetDerived2() {
    VarSample v = VarDerived2{};
    return v;
}

void VarDerived1::Print(std::ostream& os) const {
    os << "A";
}

void VarDerived2::Print(std::ostream& os) const {
    os << "b";
}

/*
Local Variables:
mode: c++
coding: utf-8-dos
tab-width: nil
c-file-style: "stroustrup"
End:
*/