namespace rxu=rxcpp::util;
namespace rxs=rxcpp::sources;
namespace rxsc=rxcpp::schedulers;
#include "rxcpp/rx-test.hpp"
#include "catch.hpp"
SCENARIO("buffer count partial window", "[buffer][operators]"){
GIVEN("1 hot observable of ints."){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
const rxsc::test::messages<std::vector<int>> v_on;
auto xs = sc.make_hot_observable({
on.next(150, 1),
on.next(210, 2),
on.next(220, 3),
on.next(230, 4),
on.next(240, 5),
on.completed(250)
});
WHEN("group each int with the next 4 ints"){
auto res = w.start(
[&]() {
return xs
.buffer(5)
// forget type to workaround lambda deduction bug on msvc 2013
.as_dynamic();
auto res = w.start(
[&]() {
return rx::observable<>::create<int>(
[&](const rx::subscriber<int>& s){
invoked++;
s.on_next(1);
s.on_next(2);
})
// forget type to workaround lambda deduction bug on msvc 2013
.as_dynamic();
}
);
THEN("the output contains all items"){
auto required = rxu::to_vector({
on.next(200, 1),
on.next(200, 2)
});
auto actual = res.get_observer().messages();
REQUIRE(required == actual);
}
THEN("create was called until completed"){
REQUIRE(1 == invoked);
}
}
}
}
SCENARIO("when observer::on_next is overridden", "[create][observer][sources]"){
GIVEN("a test cold observable of ints"){
namespace rxs=rxcpp::sources;
namespace rxsc=rxcpp::schedulers;
namespace rxn=rx::notifications;
#include "rxcpp/rx-test.hpp"
#include "catch.hpp"
SCENARIO("amb never 3", "[amb][join][operators]"){
GIVEN("1 cold observable with 3 hot observables of ints."){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
const rxsc::test::messages<rx::observable<int>> o_on;
auto ys1 = sc.make_hot_observable({
on.next(100, 1)
});
auto ys2 = sc.make_hot_observable({
on.next(110, 2)
});
auto ys3 = sc.make_hot_observable({
on.next(120, 3)
});
auto xs = sc.make_cold_observable({
o_on.next(100, ys1),
o_on.next(100, ys2),
o_on.next(100, ys3),
o_on.completed(200)
WHEN("deferred"){
auto empty = rx::observable<>::empty<long>();
auto just = rx::observable<>::just(42);
auto one = rx::observable<>::from(42);
auto error = rx::observable<>::error<long>(std::exception_ptr());
auto runtimeerror = rx::observable<>::error<long>(std::runtime_error("runtime"));
auto res = w.start(
[&]() {
return rx::observable<>::defer(
[&](){
invoked++;
xs.reset(sc.make_cold_observable({
on.next(100, sc.clock()),
on.completed(200)
}));
return xs.get();
})
// forget type to workaround lambda deduction bug on msvc 2013
.as_dynamic();
}
);
THEN("the output stops on completion"){
auto required = rxu::to_vector({
on.next(300, 200L),
on.completed(400)
});
auto actual = res.get_observer().messages();
#include "rxcpp/rx.hpp"
namespace rxu=rxcpp::util;
namespace rxsc=rxcpp::schedulers;
#include "rxcpp/rx-test.hpp"
#include "catch.hpp"
SCENARIO("zip never/never", "[zip][join][operators]"){
GIVEN("2 hot observables of ints."){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
auto n1 = sc.make_hot_observable({
on.next(150, 1)
});
auto n2 = sc.make_hot_observable({
on.next(150, 1)
});
WHEN("each int is combined with the latest from the other source"){
auto res = w.start(
[&]() {
return n1
.zip(
[](int v2, int v1){
return v2 + v1;
},
n2
#include "rxcpp/rx.hpp"
namespace rxu=rxcpp::util;
namespace rxsc=rxcpp::schedulers;
#include "rxcpp/rx-test.hpp"
#include "catch.hpp"
SCENARIO("repeat, basic test", "[repeat][operators]"){
GIVEN("cold observable of 3 ints."){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
auto xs = sc.make_cold_observable({
on.next(100, 1),
on.next(150, 2),
on.next(200, 3),
on.completed(250)
});
WHEN("infinite repeat is launched"){
auto res = w.start(
[&]() {
return xs
.repeat()
// forget type to workaround lambda deduction bug on msvc 2013
.as_dynamic();
}
);
#include "rxcpp/rx.hpp"
namespace rxu=rxcpp::util;
namespace rxsc=rxcpp::schedulers;
#include "rxcpp/rx-test.hpp"
#include "catch.hpp"
SCENARIO("combine_latest return/return", "[combine_latest][join][operators]"){
GIVEN("2 hot observables of ints."){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
auto o1 = sc.make_hot_observable({
on.next(150, 1),
on.next(215, 2),
on.completed(230)
});
auto o2 = sc.make_hot_observable({
on.next(150, 1),
on.next(220, 3),
on.completed(240)
});
WHEN("each int is combined with the latest from the other source"){
auto res = w.start(
[&]() {
return o1
.combine_latest(
namespace rx=rxcpp;
namespace rxu=rxcpp::util;
namespace rxs=rxcpp::sources;
namespace rxsc=rxcpp::schedulers;
#include "rxcpp/rx-test.hpp"
#include "catch.hpp"
SCENARIO("replay basic", "[replay][multicast][subject][operators]"){
GIVEN("a test hot observable of ints"){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
auto xs = sc.make_hot_observable({
on.next(110, 0),
on.next(220, 1),
on.next(280, 2),
on.next(290, 3),
on.next(340, 4),
on.next(360, 5),
on.next(370, 6),
on.next(390, 7),
on.next(410, 8),
on.next(430, 9),
on.next(450, 10),
on.next(520, 11),
on.next(560, 12),
on.completed(600)
});
namespace rxsc = rxcpp::schedulers;
#include "rxcpp/rx-test.hpp"
namespace rxt = rxcpp::test;
#include "catch.hpp"
SCENARIO("window count, basic", "[window][operators]"){
GIVEN("1 hot observable of ints."){
auto sc = rxsc::make_test();
auto w = sc.create_worker();
const rxsc::test::messages<int> on;
const rxsc::test::messages<rx::observable<int>> o_on;
auto xs = sc.make_hot_observable({
on.next(100, 1),
on.next(210, 2),
on.next(240, 3),
on.next(280, 4),
on.next(320, 5),
on.next(350, 6),
on.next(380, 7),
on.next(420, 8),
on.next(470, 9),
on.completed(600)
});
WHEN("group each int with the next 2 ints"){
auto res = w.start(
[&]() {
return xs
WHEN("created by scope"){
auto res = w.start(
[&]() {
return rx::observable<>::
scope(
[&](){
return resource(rxu::to_vector({1, 2, 3, 4, 5}));
},
[&](resource r){
auto msg = std::vector<rxsc::test::messages<int>::recorded_type>();
int time = 10;
auto values = r.get();
std::for_each(values.begin(), values.end(), [&](int &v){
msg.push_back(on.next(time, v));
time += 10;
});
msg.push_back(on.completed(time));
xs.reset(sc.make_cold_observable(msg));
return xs.get();
}
)
// forget type to workaround lambda deduction bug on msvc 2013
.as_dynamic();
}
);
THEN("the output stops on completion"){
auto required = rxu::to_vector({
on.next(210, 1),