ulib/3party/rxcpp/Ix/CPP/unittest/testbench.cpp

// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.

#include <iostream>
#include <iomanip>
#include <vector>
#include <functional>
#include <algorithm>
#include <numeric>
#include <iterator>
#include <string>
#include <complex>

#include <ctime>
#include <cstddef>

#include <boost/lambda/core.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/iterator.hpp>

#include "cpplinq/linq.hpp"

#include "testbench.hpp"

using namespace std;
using namespace cpplinq;

struct int_iter
    : std::iterator<std::random_access_iterator_tag, int, std::ptrdiff_t, int*, int>
{
    int_iter(value_type i = 0, value_type step = 1) : value(i), step(step)
    {}

    value_type operator*() const { 
        return value; 
    }
    int_iter& operator++() { 
        value+=step; return *this; 
    }
    int_iter& operator--() {
        value-=step; return *this;
    }
    int_iter& operator+=(std::ptrdiff_t offset) {
        value += step*offset; return *this;
    }
    int_iter& operator-=(std::ptrdiff_t offset) {
        value -= step*offset; return *this;
    }
    std::ptrdiff_t operator-(int_iter rhs) const {
        return std::ptrdiff_t((value - rhs.value)/step);
    }
    bool operator==(int_iter other) const {
        return value == other.value; 
    }
    bool operator!=(int_iter other) const {
        return !(*this == other);
    }
    bool operator<(int_iter other) const { return (*this - other) < 0; }
    bool operator>(int_iter other) const { return (*this - other) > 0; }
    bool operator<=(int_iter other) const { return (*this - other) <= 0; }
    bool operator>=(int_iter other) const { return (*this - other) >= 0; }

    value_type value;
    value_type step;
};
int_iter operator+(int_iter lhs, std::ptrdiff_t rhs) {
    return lhs+=rhs;
}
int_iter operator+(std::ptrdiff_t lhs, int_iter rhs) {
    return rhs+=lhs;
}
int_iter operator-(int_iter lhs, std::ptrdiff_t rhs) {
    return lhs-=rhs;
}
struct int_range
{
    typedef int_iter iterator;
    typedef int_iter::value_type value_type;
    int_range(value_type begin, value_type end, value_type step = 1) 
        : b(begin, step), e(end, step)
    {
        if (step == 0) {
            throw std::logic_error("bad step");
        }
        if (abs(end - begin) % abs(step) != 0) {
            end -= (end-begin)%abs(step);
        }
    }
    int_iter begin() const { return int_iter(b);}
    int_iter end() const { return int_iter(e); }

    iterator b, e;
};

vector<int> vector_range(int start, int end)
{
    vector<int> v;
    for (int i = start; i < end; ++i)
        v.push_back(i);
    return v;
}

TEST(test_selection)
{
    vector<int> v = vector_range(0, 10);

    auto v2 = from(v)
             .select([](int x) { return x*2; });

    auto result = accumulate(begin(v2), end(v2), int(0));

    VERIFY_EQ(90, result);
}

TEST(test_where)
{
    vector<int> v = vector_range(0, 10);
    auto v2 = from(v)
             .where([](int x) { return x % 2;});

    VERIFY_EQ(1, *v2.begin());

    auto result = accumulate(begin(v2), end(v2), int(0));

    VERIFY_EQ(25, result);
}


bool is_prime(int x) {
    if (x < 2) {return false;}
    if (x == 2) {return true;}
    for (int i = x/2; i >= 2; --i) {
        if (x % i == 0) { return false;}
    }
    return true;
};

template <class It>
void display(It start, It end)
{
    int i = 0;
    for_each(start, end, [&](typename iterator_traits<It>::value_type x){
        if (++i % 10 == 0) {
            cout << endl;
        }
        cout << x << " ";
    });
    cout << endl;
}

TEST(test_whereselect)
{
    auto xs = int_range(0,100);
    auto ys = from(xs)
             .where(is_prime)
             .select([](int x){ return x*x; });
    auto result = accumulate(begin(ys), end(ys), int(0));

    //display(begin(ys), end(ys));

    // primes < 100
    VERIFY_EQ(65796, result);
}
TEST(test_where_modification)
{
    vector<int> xs = vector_range(0, 100);

    auto ys = from(xs)
             .where(is_prime);
    std::fill(begin(ys), end(ys), int(0));

    auto result = accumulate(begin(xs), end(xs), int(0));

    //display(begin(ys), end(ys));

    // non-primes < 100
    VERIFY_EQ(3890, result);
}

TEST(test_where_any)
{
    using namespace boost::lambda;

    vector<int> xs(200);
    fill(begin(xs), end(xs), int(0));
    auto it = xs.begin();
    *it = 2;

    for(;;) {
        auto last = *it++;
        auto primes = from(int_range(last+1, -1))
                      .where([&](int x){ 
                                 return from(begin(xs), it)
                                       //.all([&](int d){return x%d;});
                                       .all(x % boost::lambda::_1);
                             });
        *it = *primes.begin();
        if ((*it)>=100) {
            break;
        }
    };
    xs.erase(it, xs.end());

    auto result = accumulate(begin(xs), end(xs), int(0));

    //display(begin(xs), end(xs));

    // primes < 100
    VERIFY_EQ(1060, result);
}

TEST(test_take)
{
    auto zero_one = from(int_range(0, -1))
                    .take(2);

    VERIFY_EQ(0, zero_one[0]);
    VERIFY_EQ(1, zero_one[1]);

    auto ten = from(int_range(0, -1))
               .skip(10);

    VERIFY_EQ(10, ten[0]);
    VERIFY_EQ(11, ten[1]);
}

vector<int> some_primes(std::size_t howMany)
{
    auto xs = from(int_range(0, -1))
             .where(is_prime)
             .take(howMany);
    auto v = vector<int>(begin(xs), end(xs));
    return v;
}

TEST(test_groupby)
{
    auto xs = some_primes(40);
    //display(begin(xs), end(xs));

    auto grouped = 
        from(xs)
        .groupby([](int i){return i % 10; });

    VERIFY_EQ(6, from(grouped).count());
    for(auto group = begin(grouped); group != end(grouped); ++group) {
        //cout << "key = " << group->key << endl 
        //     << "| ";
        for (auto elem = group->begin(); elem != group->end(); ++elem) {
            //cout << *elem << "  ";
        }
        //cout << endl;

        switch(group->key) {
        case 2: VERIFY_EQ(1, from(*group).count()); break;
        case 3: VERIFY_EQ(11, from(*group).count()); break;
        case 5: VERIFY_EQ(1, from(*group).count()); break;
        case 7: VERIFY_EQ(11, from(*group).count()); break;
        case 1: VERIFY_EQ(8, from(*group).count()); break;
        case 9: VERIFY_EQ(8, from(*group).count()); break;
        }
    }
}

TEST(test_symbolname)
{
    auto complexQuery = 
        from(int_range(0,100000))
        .select([](int x){ return x*2;})
        .where([](int x){ return x%7; })
        .skip(20);

    //cout << " type name: " << typeid(complexQuery1).name() << endl;

    
    //auto complexQuery =
    //    complexQuery1.groupby([](int x) { return x%5; })
    //    .take(3)
    //    ;
    
    
    cout << "type name: " << typeid(complexQuery).name() << endl;
    cout << "type name length: " << strlen(typeid(complexQuery).name()) << endl;

    auto iter = complexQuery.begin();
    cout << "iterator name: " << typeid(iter).name() << endl;
    cout << "iterator name length: " << strlen(typeid(iter).name()) << endl;
}

TEST(test_cast)
{
    auto q = from(int_range(0,10))
             .cast<bool>();
    VERIFY_EQ(false, q[0]);
    VERIFY_EQ(true, q[1]);
    VERIFY_EQ(true, q[2]);
    VERIFY((std::is_same<decltype(q[0]), bool>::value));
}

TEST(test_contains)
{
    auto q = from(int_range(0,10))
             .select([](int x){return x*2;});
    VERIFY(q.contains(4));
    VERIFY(!q.contains(5));
}

TEST(test_element_accessors)
{
    vector<int> v(int_iter(0), int_iter(10));
    auto q = from(v)
             .where([](int x){return x%2==0;});

    VERIFY_EQ(0, q.first());
    VERIFY_EQ(8, q.last());
    VERIFY_EQ(6, q.element_at(3));

    bool thrown = false;
    try { q.element_at(5); } catch (std::logic_error&) { thrown = true; }
    VERIFY(thrown);

    q.first() = 1;
    q.last() = 42;

    // note: because the vector now contains { 1, 1, 2, 3, ... 7, 8, 42 }, the first
    //  even number is now '2'
    VERIFY_EQ(2, q.first());
    VERIFY_EQ(42, q.last());
}

//////////////////// New style cursors ////////////////////

TEST(test_cursor_dynamic)
{
    dynamic_cursor<int> dc(int_iter(0), int_iter(2));

    VERIFY(!dc.empty());
    VERIFY_EQ(0, dc.get());
    dc.inc();
    VERIFY_EQ(1, dc.get());
    dc.inc();
    VERIFY(dc.empty());
}

TEST(test_selectmany)
{
    int_range range1(0, 3);
    auto range2 = 

        from(range1)
        .select_many( 
        [](int x)
        {
            return int_range(0, x+1);
        });

    auto cur = range2.get_cursor();

    // expected: 0, 0, 1, 0, 1, 2.
    VERIFY(!cur.empty());

    VERIFY_EQ(0, cur.get()); 
    cur.inc();
    VERIFY(!cur.empty());

    VERIFY_EQ(0, cur.get()); 
    cur.inc();
    VERIFY(!cur.empty());
    
    VERIFY_EQ(1, cur.get()); 
    cur.inc();
    VERIFY(!cur.empty());

    VERIFY_EQ(0, cur.get()); 
    cur.inc();
    VERIFY(!cur.empty());

    VERIFY_EQ(1, cur.get()); 
    cur.inc();
    VERIFY(!cur.empty());

    VERIFY_EQ(2, cur.get()); 
    cur.inc();
    VERIFY(cur.empty());
}

TEST(test_cursor_selectmany2)
{
    int_range range1(0, 3);
    auto range2 = from(range1)
        .select_many(
        [](int x) 
        {
            return int_range(0, x+1);
        });

    // expected: 0, 0, 1, 0, 1, 2.
    int expect[] = { 0, 0, 1, 0, 1, 2 };

    VERIFY_EQ(_countof(expect), std::distance(range2.begin(), range2.end()));
    VERIFY_EQ(_countof(expect), std::distance(range2.begin(), range2.end()));

    auto result = std::mismatch(expect, expect + _countof(expect), range2.begin());
    if (result.second != range2.end()) {
        cout << "mismatch: " << *result.first << " != " << *result.second << endl;
    }
    VERIFY( result.second == range2.end());
}

TEST(test_late_bind)
{
    int_range range1(0, 100);
    linq_driver<dynamic_collection<int>> range2 = from(range1).late_bind();

    VERIFY_EQ(1, range2.element_at(1));

    auto q1 = from(range1).select([](int x){ return x*2; }).where([](int x){ return x%10!=0; });

    cout << "typeof q1 ==> " << typeid(q1).name() << endl;
    cout << "typeof q1.late_bind() ==> " << typeid(q1.late_bind()).name() << endl;
}

struct stopwatch
{
    time_t t0, t1;
    void start() {
        t1 = t0 = clock();
    }
    void stop() {
        t1 = clock();
    }
    double value() const {
        return double(t1-t0)/CLOCKS_PER_SEC;
    }
};

template <class Fn>
void test_perf(Fn fn)
{
    // warmup
    fn(10);
    
    int n = 100;
    stopwatch sw;
    for(;;) 
    {
        cout << "trying n=" << n << endl;
        sw.start();
        fn(n);
        sw.stop();
        if (sw.value() > 2.0) {
            break;
        }
        n *= 2;
    }
    cout << "time   = " << sw.value() << " s\n";
    cout << "steps  = " << n << "\n";
    cout << "t/step = " << (sw.value() * 1e9 / n) << " ns\n";
    cout << "step/t = " << (n / sw.value()) << " Hz\n";
}

TEST(test_performance)
{
    // http://projecteuler.net/problem=8
    // 
    // Find the greatest product of five consecutive digits in the 1000-digit number.
    //

    static const char num[] = 
         "73167176531330624919225119674426574742355349194934"
         "96983520312774506326239578318016984801869478851843"
         "85861560789112949495459501737958331952853208805511"
         "12540698747158523863050715693290963295227443043557"
         "66896648950445244523161731856403098711121722383113"
         "62229893423380308135336276614282806444486645238749"
         "30358907296290491560440772390713810515859307960866"
         "70172427121883998797908792274921901699720888093776"
         "65727333001053367881220235421809751254540594752243"
         "52584907711670556013604839586446706324415722155397"
         "53697817977846174064955149290862569321978468622482"
         "83972241375657056057490261407972968652414535100474"
         "82166370484403199890008895243450658541227588666881"
         "16427171479924442928230863465674813919123162824586"
         "17866458359124566529476545682848912883142607690042"
         "24219022671055626321111109370544217506941658960408"
         "07198403850962455444362981230987879927244284909188"
         "84580156166097919133875499200524063689912560717606"
         "05886116467109405077541002256983155200055935729725"
         "71636269561882670428252483600823257530420752963450";

    auto task = [&](int n){
        for (int i = 0; i < n; ++i) {
            auto range1 = int_range(0, _countof(num)-5); // 5 digit numbers, plus null terminator

            auto products = from(range1)
                .select([&](int i){ return num+i;})
                .where([&](const char* s){ return !from(s, s+5).contains('0'); })
                .select([&](const char* s) { return from(s, s+5).select([](char c){ return c - '0'; })
                                                                .aggregate(std::multiplies<int>()); });
            
            auto result = products.max();
            if (n == 1) {
                cout << "result = " << result << endl;
            }
        }
    };
    cout << "length of input: " << (_countof(num)-1) << endl;

    task(1);
    cout << endl;

#ifdef PERF
    test_perf(task);
    cout << endl;
#endif
}

// SUM TESTS

TEST(test_sum_ints)
{
    vector<int> numbers{1, 2, 3, 4, 5};

	auto result = cpplinq::from(numbers);
    auto r2 = result.sum();

	VERIFY_EQ(15, r2);
}

TEST(test_sum_ints_with_seed)
{
    vector<int> numbers{1, 2, 3, 4, 5};

	auto result = cpplinq::from(numbers).sum(10);

	VERIFY_EQ(25, result);
}

TEST(test_sum_floats) {
	vector<float> numbers{ 1.0f,2.0f,3.0f,4.0f,5.0f };

	auto result = cpplinq::from(numbers).sum();

	VERIFY_EQ(15.0f, result);
}

TEST(test_sum_doubles) {
	vector<double> numbers { 1.0,2.0,3.0,4.0,5.0 };

	auto result = cpplinq::from(numbers).sum();

	VERIFY_EQ(15.0, result);
}

TEST(test_sum_complex) {
	using namespace std::complex_literals;

	vector<complex<double>> numbers{ 1i, 1.0 + 2i, 2.0 + 3i };

	auto sum = cpplinq::from(numbers).sum();

	VERIFY_EQ(3.0, sum.real());
	VERIFY_EQ(6.0, sum.imag());
}

TEST(test_sum_with_projection_lambda) {
	vector<tuple<int>> numbers { std::tuple<int>(0), std::tuple<int>(1), std::tuple<int>(2) };

	auto result = cpplinq::from(numbers).sum([](std::tuple<int>& x){
                return std::get<0>(x);
        });

	VERIFY_EQ(3.0, result);
}

TEST(test_sum_with_projection_lambda_and_seed) {
	vector<tuple<int>> numbers { std::tuple<int>(0), std::tuple<int>(1), std::tuple<int>(2) };

	auto result = cpplinq::from(numbers).sum([](std::tuple<int>& x){
                return std::get<0>(x);
        }, 10);

	VERIFY_EQ(13.0, result);
}

int getValue(std::tuple<int> x)
{
    return std::get<0>(x);
}

TEST(test_sum_with_projection_function_pointer) {
	vector<tuple<int>> numbers { std::tuple<int>(0), std::tuple<int>(1), std::tuple<int>(2) };

	auto result = cpplinq::from(numbers).sum(getValue);

	VERIFY_EQ(3.0, result);
}

int main(int argc, char** argv)
{
    std::size_t pass = 0, fail = 0;
    testrange<0,__LINE__>().run(pass, fail);


    cout << "pass: " << pass << ", fail: " << fail << endl;
    if (fail){
        cerr << "ERRORS PRESENT." << endl;
    } else if (!pass) {
        cerr << "ERROR, no tests run" << endl;
    }
}