RxTest.cpp File Reference

#include <wangle/deprecated/rx/Observer.h>
#include <wangle/deprecated/rx/Subject.h>
#include <gtest/gtest.h>

Go to the source code of this file.

Classes
struct	CO

Typedefs
typedef std::unique_ptr< int >	MO

Functions
static std::unique_ptr< Observer< int > >	incrementer (int &counter)
	TEST (RxTest, Observe)
	TEST (RxTest, ObserveInline)
	TEST (RxTest, Subscription)
	TEST (RxTest, SubscriptionMove)
	TEST (RxTest, SubscriptionOutlivesSubject)
	TEST (RxTest, SubscribeDuringCallback)
	TEST (RxTest, ObserveDuringCallback)
	TEST (RxTest, ObserveInlineDuringCallback)
	TEST (RxTest, UnsubscribeDuringCallback)
	TEST (RxTest, SubscribeUnsubscribeDuringCallback)
static MO	makeMO ()
template<typename T >
static ObserverPtr< T >	makeMOObserver ()
	TEST (RxTest, MoveOnlyRvalue)
template<typename T >
static ObserverPtr< T >	makeCOObserver ()
	TEST (RxTest, CopyOnly)

Typedef Documentation

typedef std::unique_ptr<int> MO

Definition at line 158 of file RxTest.cpp.

Function Documentation

static std::unique_ptr<Observer<int> > incrementer ( int &  counter )

static

Definition at line 23 of file RxTest.cpp.

References wangle::Observer< T >::create().

Referenced by TEST().

                                                              {
  return Observer<int>::create([&] (int) {
    counter++;
  });
}

template<typename T >

static ObserverPtr<T> makeCOObserver ( )

static

Definition at line 186 of file RxTest.cpp.

References wangle::Observer< T >::create(), and T.

                                       {
  return Observer<T>::create([](const T&) {});
}

static MO makeMO ( )

static

Definition at line 159 of file RxTest.cpp.

Referenced by TEST().

{ return std::make_unique<int>(1); }

template<typename T >

static ObserverPtr<T> makeMOObserver ( )

static

Definition at line 161 of file RxTest.cpp.

References wangle::Observer< T >::create(), EXPECT_EQ, and T.

                                       {
  return Observer<T>::create([](const T& mo) {
    EXPECT_EQ(1, *mo);
  });
}

TEST	(	RxTest	,
		Observe
	)

Definition at line 29 of file RxTest.cpp.

References count, EXPECT_EQ, incrementer(), wangle::Observable< T >::observe(), and wangle::Subject< T >::onNext().

                      {
  Subject<int> subject;
  auto count = 0;
  subject.observe(incrementer(count));
  subject.onNext(1);
  EXPECT_EQ(1, count);
}

TEST	(	RxTest	,
		ObserveInline
	)

Definition at line 37 of file RxTest.cpp.

References count, EXPECT_EQ, incrementer(), wangle::Observable< T >::observe(), and wangle::Subject< T >::onNext().

                            {
  Subject<int> subject;
  auto count = 0;
  auto o = incrementer(count).release();
  subject.observe(o);
  subject.onNext(1);
  EXPECT_EQ(1, count);
  delete o;
}

TEST	(	RxTest	,
		Subscription
	)

Definition at line 47 of file RxTest.cpp.

References count, EXPECT_EQ, incrementer(), wangle::Subject< T >::onNext(), s, and wangle::Observable< T >::subscribe().

                           {
  Subject<int> subject;
  auto count = 0;
  {
    auto s = subject.subscribe(incrementer(count));
    subject.onNext(1);
  }
  // The subscription has gone out of scope so no one should get this.
  subject.onNext(2);
  EXPECT_EQ(1, count);
}

TEST	(	RxTest	,
		SubscriptionMove
	)

Definition at line 59 of file RxTest.cpp.

References count, EXPECT_EQ, incrementer(), folly::gen::move, wangle::Subject< T >::onNext(), s, and wangle::Observable< T >::subscribe().

                               {
  Subject<int> subject;
  auto count = 0;
  auto s = subject.subscribe(incrementer(count));
  auto s2 = subject.subscribe(incrementer(count));
  s2 = std::move(s);
  subject.onNext(1);
  Subscription<int> s3(std::move(s2));
  subject.onNext(2);
  EXPECT_EQ(2, count);
}

TEST	(	RxTest	,
		SubscriptionOutlivesSubject
	)

Definition at line 71 of file RxTest.cpp.

References s, and wangle::Observable< T >::subscribe().

                                          {
  Subscription<int> s;
  {
    Subject<int> subject;
    s = subject.subscribe(Observer<int>::create([](int){}));
  }
  // Don't explode when s is destroyed
}

TEST	(	RxTest	,
		SubscribeDuringCallback
	)

Definition at line 80 of file RxTest.cpp.

References EXPECT_EQ, incrementer(), wangle::Subject< T >::onNext(), and wangle::Observable< T >::subscribe().

                                      {
  // A subscriber who was subscribed in the course of a callback should get
  // subsequent updates but not the current update.
  Subject<int> subject;
  int outerCount = 0, innerCount = 0;
  Subscription<int> s1, s2;
  s1 = subject.subscribe(Observer<int>::create([&] (int) {
    outerCount++;
    s2 = subject.subscribe(incrementer(innerCount));
  }));
  subject.onNext(42);
  subject.onNext(0xDEADBEEF);
  EXPECT_EQ(2, outerCount);
  EXPECT_EQ(1, innerCount);
}

TEST	(	RxTest	,
		ObserveDuringCallback
	)

Definition at line 96 of file RxTest.cpp.

References EXPECT_EQ, incrementer(), wangle::Observable< T >::observe(), and wangle::Subject< T >::onNext().

                                    {
  Subject<int> subject;
  int outerCount = 0, innerCount = 0;
  subject.observe(Observer<int>::create([&] (int) {
    outerCount++;
    subject.observe(incrementer(innerCount));
  }));
  subject.onNext(42);
  subject.onNext(0xDEADBEEF);
  EXPECT_EQ(2, outerCount);
  EXPECT_EQ(1, innerCount);
}

TEST	(	RxTest	,
		ObserveInlineDuringCallback
	)

Definition at line 109 of file RxTest.cpp.

References wangle::Observer< T >::create(), EXPECT_EQ, incrementer(), wangle::Observable< T >::observe(), and wangle::Subject< T >::onNext().

                                          {
  Subject<int> subject;
  int outerCount = 0, innerCount = 0;
  auto innerO = incrementer(innerCount).release();
  auto outerO = Observer<int>::create([&] (int) {
    outerCount++;
    subject.observe(innerO);
  }).release();
  subject.observe(outerO);
  subject.onNext(42);
  subject.onNext(0xDEADBEEF);
  EXPECT_EQ(2, outerCount);
  EXPECT_EQ(1, innerCount);
  delete innerO;
  delete outerO;
}

TEST	(	RxTest	,
		UnsubscribeDuringCallback
	)

Definition at line 126 of file RxTest.cpp.

References EXPECT_EQ, incrementer(), wangle::Subject< T >::onNext(), and wangle::Observable< T >::subscribe().

                                        {
  // A subscriber who was unsubscribed in the course of a callback should get
  // the current update but not subsequent ones
  Subject<int> subject;
  int count1 = 0, count2 = 0;
  auto s1 = subject.subscribe(incrementer(count1));
  auto s2 = subject.subscribe(Observer<int>::create([&] (int) {
    count2++;
    s1.~Subscription();
  }));
  subject.onNext(1);
  subject.onNext(2);
  EXPECT_EQ(1, count1);
  EXPECT_EQ(2, count2);
}

TEST	(	RxTest	,
		SubscribeUnsubscribeDuringCallback
	)

Definition at line 142 of file RxTest.cpp.

References EXPECT_EQ, incrementer(), wangle::Subject< T >::onNext(), and wangle::Observable< T >::subscribe().

                                                 {
  // A subscriber who was subscribed and unsubscribed in the course of a
  // callback should not get any updates
  Subject<int> subject;
  int outerCount = 0, innerCount = 0;
  auto s2 = subject.subscribe(Observer<int>::create([&] (int) {
    outerCount++;
    auto s3 = subject.subscribe(incrementer(innerCount));
  }));
  subject.onNext(1);
  subject.onNext(2);
  EXPECT_EQ(2, outerCount);
  EXPECT_EQ(0, innerCount);
}

TEST	(	RxTest	,
		MoveOnlyRvalue
	)

Definition at line 167 of file RxTest.cpp.

References makeMO(), folly::gen::move, wangle::Subject< T >::onNext(), and wangle::Observable< T >::subscribe().

                             {
  Subject<MO> subject;
  auto s1 = subject.subscribe(makeMOObserver<MO>());
  auto s2 = subject.subscribe(makeMOObserver<MO>());
  auto mo = makeMO();
  // Can't bind lvalues to rvalue references
  // subject.onNext(mo);
  subject.onNext(std::move(mo));
  subject.onNext(makeMO());
}

TEST	(	RxTest	,
		CopyOnly
	)

Definition at line 190 of file RxTest.cpp.

References GCC61971::co, wangle::Subject< T >::onNext(), and wangle::Observable< T >::subscribe().

                       {
  Subject<CO> subject;
  auto s1 = subject.subscribe(makeCOObserver<CO>());
  CO co;
  subject.onNext(co);
}