Scroom  0.14
Classes | Functions
observable-tests.cc File Reference
#include <utility>
#include <boost/shared_ptr.hpp>
#include <boost/test/unit_test.hpp>
#include <scroom/observable.hh>
Include dependency graph for observable-tests.cc:

Classes

class  TestObserver
 
class  TestObservable
 
class  TestRecursiveObservable
 

Functions

 BOOST_AUTO_TEST_CASE (register_observer)
 
 BOOST_AUTO_TEST_CASE (register_weak_observer)
 
 BOOST_AUTO_TEST_CASE (registered_weak_observer_goes_away)
 
 BOOST_AUTO_TEST_CASE (register_multiple_observers)
 
 BOOST_AUTO_TEST_CASE (register_observer_multiple_times)
 
 BOOST_AUTO_TEST_CASE (register_weak_observer_multiple_times)
 
 BOOST_AUTO_TEST_CASE (register_observer_recursively)
 
 BOOST_AUTO_TEST_CASE (shared_from_this)
 
 BOOST_AUTO_TEST_CASE (deleting_observable_deletes_observer)
 

Function Documentation

◆ BOOST_AUTO_TEST_CASE() [1/9]

BOOST_AUTO_TEST_CASE ( deleting_observable_deletes_observer  )
311 {
312  TestObservable::Ptr observable = TestObservable::create();
313  TestObserver::Ptr observer = TestObserver::create();
314  TestObserver::WeakPtr const weakObserver = observer;
315  std::list<TestObservable::Observer> observers;
316 
317  // Registration succeeds
318  Stuff const registration = observable->registerStrongObserver(observer);
319  BOOST_CHECK(registration);
320 
321  // Observable has a reference to observer, so it doesn't go away
322  observer.reset();
323  BOOST_CHECK(!observer);
324  observers = observable->getObservers();
325  BOOST_REQUIRE(1 == observers.size());
326  observer = weakObserver.lock();
327  BOOST_CHECK_EQUAL(observer, observers.front());
328  observers.clear();
329 
330  // Destroying observable destroys observer
331  observer.reset();
332  BOOST_CHECK(!observer);
333  observable.reset();
334  BOOST_CHECK(!observable);
335  BOOST_CHECK(!weakObserver.lock());
336 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [2/9]

BOOST_AUTO_TEST_CASE ( register_multiple_observers  )
171 {
172  TestObservable::Ptr const observable = TestObservable::create();
173  TestObserver::Ptr const o1 = TestObserver::create();
174  TestObserver::Ptr const o2 = TestObserver::create();
175  TestObserver::Ptr const o3 = TestObserver::create();
176  TestObserver::WeakPtr const weakObserver = o1;
177  std::list<TestObservable::Observer> observers;
178 
179  // Registration succeeds
180  Stuff r1 = observable->registerObserver(weakObserver);
181  Stuff r2 = observable->registerObserver(o2);
182  Stuff r3 = observable->registerStrongObserver(o3);
183  BOOST_CHECK(r1);
184  BOOST_CHECK(r2);
185  BOOST_CHECK(r3);
186  observers = observable->getObservers();
187  BOOST_CHECK_EQUAL(3, observers.size());
188  observers.remove(o1);
189  BOOST_CHECK_EQUAL(2, observers.size());
190  observers.remove(o2);
191  BOOST_CHECK_EQUAL(1, observers.size());
192  observers.remove(o3);
193  BOOST_CHECK_EQUAL(0, observers.size());
194 
195  // Unregistering succeeds
196  r1.reset();
197  observers = observable->getObservers();
198  BOOST_CHECK_EQUAL(2, observers.size());
199  observers.remove(o1);
200  BOOST_CHECK_EQUAL(2, observers.size());
201  observers.remove(o2);
202  BOOST_CHECK_EQUAL(1, observers.size());
203  observers.remove(o3);
204  BOOST_CHECK_EQUAL(0, observers.size());
205 
206  r2.reset();
207  observers = observable->getObservers();
208  BOOST_CHECK_EQUAL(1, observers.size());
209  observers.remove(o1);
210  BOOST_CHECK_EQUAL(1, observers.size());
211  observers.remove(o2);
212  BOOST_CHECK_EQUAL(1, observers.size());
213  observers.remove(o3);
214  BOOST_CHECK_EQUAL(0, observers.size());
215 
216  r3.reset();
217  observers = observable->getObservers();
218  BOOST_CHECK_EQUAL(0, observers.size());
219 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [3/9]

BOOST_AUTO_TEST_CASE ( register_observer  )
91 {
92  TestObservable::Ptr const observable = TestObservable::create();
93  TestObserver::Ptr observer = TestObserver::create();
94  TestObserver::WeakPtr const weakObserver = observer;
95  std::list<TestObservable::Observer> observers;
96 
97  // Registration succeeds
98  Stuff registration = observable->registerStrongObserver(observer);
99  BOOST_CHECK(registration);
100  observers = observable->getObservers();
101  BOOST_REQUIRE(1 == observers.size());
102  BOOST_CHECK_EQUAL(observer, observers.front());
103 
104  // Observable has a reference to observer, so it doesn't go away
105  observer.reset();
106  BOOST_CHECK(!observer);
107  observers = observable->getObservers();
108  BOOST_REQUIRE(1 == observers.size());
109  observer = weakObserver.lock();
110  BOOST_CHECK_EQUAL(observer, observers.front());
111 
112  // Unregistering succeeds
113  registration.reset();
114  observers = observable->getObservers();
115  BOOST_REQUIRE(observers.empty());
116 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [4/9]

BOOST_AUTO_TEST_CASE ( register_observer_multiple_times  )
222 {
223  TestObservable::Ptr const observable = TestObservable::create();
224  TestObserver::Ptr const observer = TestObserver::create();
225  std::list<TestObservable::Observer> observers;
226 
227  // Registration succeeds
228  Stuff r1 = observable->registerStrongObserver(observer);
229  Stuff r2 = observable->registerStrongObserver(observer);
230  BOOST_CHECK(r1);
231  BOOST_CHECK(r2);
232  BOOST_CHECK_EQUAL(r1, r2);
233  observers = observable->getObservers();
234  BOOST_REQUIRE(1 == observers.size());
235  BOOST_CHECK_EQUAL(observer, observers.front());
236 
237  // Unregistering succeeds
238  r1.reset();
239  observers = observable->getObservers();
240  BOOST_REQUIRE(1 == observers.size());
241  BOOST_CHECK_EQUAL(observer, observers.front());
242  r2.reset();
243  observers = observable->getObservers();
244  BOOST_REQUIRE(observers.empty());
245 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [5/9]

BOOST_AUTO_TEST_CASE ( register_observer_recursively  )
274 {
275  TestObservable::Ptr const observable = TestObservable::create();
276  TestRecursiveObservable::Ptr const recursiveObservable = TestRecursiveObservable::create(observable);
277  TestObserver::Ptr const observer = TestObserver::create();
278  std::list<TestObservable::Observer> observers;
279 
280  // Registration succeeds
281  Stuff registration = recursiveObservable->registerObserver(observer);
282  BOOST_CHECK(registration);
283  observers = observable->getObservers();
284  BOOST_REQUIRE(1 == observers.size());
285  BOOST_CHECK_EQUAL(observer, observers.front());
286  observers = recursiveObservable->getObservers();
287  BOOST_REQUIRE(1 == observers.size());
288  BOOST_CHECK_EQUAL(observer, observers.front());
289 
290  // Unregistering succeeds
291  registration.reset();
292  observers = observable->getObservers();
293  BOOST_REQUIRE(observers.empty());
294  observers = recursiveObservable->getObservers();
295  BOOST_REQUIRE(observers.empty());
296 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [6/9]

BOOST_AUTO_TEST_CASE ( register_weak_observer  )
119 {
120  TestObservable::Ptr const observable = TestObservable::create();
121  TestObserver::Ptr observer = TestObserver::create();
122  TestObserver::WeakPtr const weakObserver = observer;
123  std::list<TestObservable::Observer> observers;
124 
125  // Registration succeeds
126  Stuff registration = observable->registerObserver(weakObserver);
127  BOOST_CHECK(registration);
128  observers = observable->getObservers();
129  BOOST_REQUIRE(1 == observers.size());
130  BOOST_CHECK_EQUAL(observer, observers.front());
131 
132  // Unregistering succeeds
133  registration.reset();
134  BOOST_CHECK(!weakObserver.expired());
135  observers = observable->getObservers();
136  BOOST_REQUIRE(observers.empty());
137  observer.reset();
138  BOOST_CHECK(weakObserver.expired());
139 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [7/9]

BOOST_AUTO_TEST_CASE ( register_weak_observer_multiple_times  )
248 {
249  TestObservable::Ptr const observable = TestObservable::create();
250  TestObserver::Ptr const observer = TestObserver::create();
251  std::list<TestObservable::Observer> observers;
252 
253  // Registration succeeds
254  Stuff r1 = observable->registerObserver(observer);
255  Stuff r2 = observable->registerObserver(observer);
256  BOOST_CHECK(r1);
257  BOOST_CHECK(r2);
258  BOOST_CHECK_EQUAL(r1, r2);
259  observers = observable->getObservers();
260  BOOST_REQUIRE(1 == observers.size());
261  BOOST_CHECK_EQUAL(observer, observers.front());
262 
263  // Unregistering succeeds
264  r1.reset();
265  observers = observable->getObservers();
266  BOOST_REQUIRE(1 == observers.size());
267  BOOST_CHECK_EQUAL(observer, observers.front());
268  r2.reset();
269  observers = observable->getObservers();
270  BOOST_REQUIRE(observers.empty());
271 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [8/9]

BOOST_AUTO_TEST_CASE ( registered_weak_observer_goes_away  )
142 {
143  TestObservable::Ptr const observable = TestObservable::create();
144  TestObserver::Ptr observer = TestObserver::create();
145  TestObserver::WeakPtr const weakObserver = observer;
146  std::list<TestObservable::Observer> observers;
147 
148  // Registration succeeds
149  Stuff registration = observable->registerObserver(observer);
150  BOOST_CHECK(registration);
151  observers = observable->getObservers();
152  BOOST_REQUIRE(1 == observers.size());
153  BOOST_CHECK_EQUAL(observer, observers.front());
154 
155  // Observable does not have a reference to observer, so it goes away
156  observers.clear(); // don't forget this reference :-)
157  observer.reset();
158  BOOST_CHECK(!observer);
159  observers = observable->getObservers();
160  BOOST_REQUIRE(observers.empty());
161  BOOST_CHECK(weakObserver.expired());
162  BOOST_CHECK(registration);
163 
164  // Unregistering succeeds
165  registration.reset();
166  observers = observable->getObservers();
167  BOOST_REQUIRE(observers.empty());
168 }
Here is the call graph for this function:

◆ BOOST_AUTO_TEST_CASE() [9/9]

BOOST_AUTO_TEST_CASE ( shared_from_this  )
299 {
300  TestObservable::Ptr const original = TestObservable::create();
301  TestObservable::Ptr const copy1 = original->shared_from_this<TestObservable>();
302  boost::shared_ptr<TestObservable const> const copy2 = original;
303  boost::shared_ptr<TestObservable const> const copy3 = copy2->shared_from_this<TestObservable>();
304 
305  BOOST_CHECK_EQUAL(original, copy1);
306  BOOST_CHECK_EQUAL(copy2, copy3);
307  BOOST_CHECK_EQUAL(original, copy2);
308 }
Here is the call graph for this function:
TestObservable::Ptr
boost::shared_ptr< TestObservable > Ptr
Definition: observable-tests.cc:35
TestObservable
Definition: observable-tests.cc:32
BOOST_CHECK_EQUAL
BOOST_CHECK_EQUAL(sample.expectedColors, originalColormap->colors.size())
TestObserver::WeakPtr
boost::weak_ptr< TestObserver > WeakPtr
Definition: observable-tests.cc:23
TestObserver::Ptr
boost::shared_ptr< TestObserver > Ptr
Definition: observable-tests.cc:22
TestObserver::create
static Ptr create()
Definition: observable-tests.cc:28
TestObservable::create
static Ptr create()
Definition: observable-tests.cc:44
BOOST_REQUIRE
BOOST_REQUIRE(originalColormap)
Scroom::Utils::Stuff
boost::shared_ptr< void > Stuff
Definition: stuff.hh:18
TestRecursiveObservable::create
static Ptr create(TestObservable::Ptr child)
Definition: observable-tests.cc:76
TestRecursiveObservable::Ptr
boost::shared_ptr< TestRecursiveObservable > Ptr
Definition: observable-tests.cc:56