determine-size-test.cc File Reference

#include <algorithm>
#include <boost/test/unit_test.hpp>
#include <scroom/gtk-helpers.hh>
#include <scroom/presentationinterface.hh>
#include <scroom/resizablepresentationinterface.hh>
#include "sizedeterminer.hh"

Include dependency graph for determine-size-test.cc:

Classes
class	anonymous_namespace{determine-size-test.cc}::PresentationInterfaceStub
class	anonymous_namespace{determine-size-test.cc}::ResizablePresentationInterfaceStub
class	anonymous_namespace{determine-size-test.cc}::ViewInterfaceDummy

Namespaces
	anonymous_namespace{determine-size-test.cc}

Functions
template<typename Iter >
std::ostream &	dumpContainer (std::ostream &os, const std::string &name, Iter const &begin, Iter const &end)
template<typename T >
std::ostream &	std::operator<< (std::ostream &os, std::list< T > const &l)
template<typename T >
bool	operator== (boost::weak_ptr< T > const &left, boost::weak_ptr< T > const &right)
	BOOST_AUTO_TEST_CASE (determine_size_of_one_regular)
	BOOST_AUTO_TEST_CASE (determine_size_of_two_regular)
	BOOST_AUTO_TEST_CASE (determine_size_of_one_regular_one_resizable)
	BOOST_AUTO_TEST_CASE (determine_size_of_two_resizable)
	BOOST_AUTO_TEST_CASE (open_a_view_then_add_presentations_one_regular_one_resizable)
	BOOST_AUTO_TEST_CASE (updates_are_sent_to_multiple_views)

Function Documentation

BOOST_AUTO_TEST_CASE() [1/6]

BOOST_AUTO_TEST_CASE

(

determine_size_of_one_regular

)

{
  Scroom::Utils::Rectangle<double> const expected(1, 2, 3, 4);
  PresentationInterfaceStub::Ptr const   p  = PresentationInterfaceStub::create(expected);
  SizeDeterminer::Ptr const              sd = SizeDeterminer::create();
  sd->add(p);
 
  BOOST_CHECK_EQUAL(expected, sd->getRect());
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [2/6]

BOOST_AUTO_TEST_CASE

(

determine_size_of_one_regular_one_resizable

)

{
  Scroom::Utils::Rectangle<double> const        expected(2, 1, 4, 3);
  ResizablePresentationInterfaceStub::Ptr const p1 = ResizablePresentationInterfaceStub::create({1, 2, 3, 4});
  PresentationInterfaceStub::Ptr const          p2 = PresentationInterfaceStub::create({2, 1, 4, 3});
  SizeDeterminer::Ptr const                     sd = SizeDeterminer::create();
  sd->add(p1);
  sd->add(p2);
 
  BOOST_CHECK_EQUAL(expected, sd->getRect());
  BOOST_CHECK(p1->receivedVi.empty());
  BOOST_CHECK(p1->receivedRect.empty());
  ViewInterface::Ptr const v1 = ViewInterfaceDummy::create();
  sd->open(p1, v1);
  p1->CheckAllEqual(expected);
  BOOST_CHECK(p1->Contains(v1));
 
  p1->Clear();
  ViewInterface::Ptr const v2 = ViewInterfaceDummy::create();
  sd->open(p2, v2);
  p1->CheckEmpty();
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [3/6]

BOOST_AUTO_TEST_CASE

(

determine_size_of_two_regular

)

{
  Scroom::Utils::Rectangle<double> const expected(1, 1, 5, 5);
  PresentationInterfaceStub::Ptr const   p1 = PresentationInterfaceStub::create({1, 2, 3, 4});
  PresentationInterfaceStub::Ptr const   p2 = PresentationInterfaceStub::create({2, 1, 4, 3});
  SizeDeterminer::Ptr const              sd = SizeDeterminer::create();
  sd->add(p1);
  sd->add(p2);
 
  BOOST_CHECK_EQUAL(expected, sd->getRect());
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [4/6]

BOOST_AUTO_TEST_CASE

(

determine_size_of_two_resizable

)

{
  Scroom::Utils::Rectangle<double> const        expected(1, 1, 5, 5);
  ResizablePresentationInterfaceStub::Ptr const p1 = ResizablePresentationInterfaceStub::create({1, 2, 3, 4});
  ResizablePresentationInterfaceStub::Ptr const p2 = ResizablePresentationInterfaceStub::create({2, 1, 4, 3});
  SizeDeterminer::Ptr const                     sd = SizeDeterminer::create();
  sd->add(p1);
  sd->add(p2);
 
  BOOST_CHECK_EQUAL(expected, sd->getRect());
 
  p1->CheckEmpty();
  ViewInterface::Ptr const v1 = ViewInterfaceDummy::create();
  sd->open(p1, v1);
  p1->CheckAllEqual(expected);
  BOOST_CHECK(p1->Contains(v1));
  p2->CheckEmpty();
 
  p1->Clear();
  ViewInterface::Ptr const v2 = ViewInterfaceDummy::create();
  sd->open(p2, v2);
  p2->CheckAllEqual(expected);
  BOOST_CHECK(p2->Contains(v2));
  p1->CheckEmpty();
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [5/6]

BOOST_AUTO_TEST_CASE

(

open_a_view_then_add_presentations_one_regular_one_resizable

)

{
  SizeDeterminer::Ptr const sd = SizeDeterminer::create();
 
  Scroom::Utils::Rectangle<double> const        r1(1, 2, 3, 4);
  ResizablePresentationInterfaceStub::Ptr const p1 = ResizablePresentationInterfaceStub::create(r1);
  sd->add(p1);
  ViewInterface::Ptr const v1 = ViewInterfaceDummy::create();
  sd->open(p1, v1);
  BOOST_CHECK_EQUAL(r1, sd->getRect());
  p1->CheckAllEqual(r1);
  BOOST_CHECK(p1->Contains(v1));
  p1->Clear();
 
  Scroom::Utils::Rectangle<double> const r2(2, 1, 4, 3);
  PresentationInterfaceStub::Ptr const   p2 = PresentationInterfaceStub::create(r2);
  sd->add(p2);
  BOOST_CHECK_EQUAL(r2, sd->getRect());
  p1->CheckAllEqual(r2);
  BOOST_CHECK(p1->Contains(v1));
  p1->Clear();
  ViewInterface::Ptr const v2 = ViewInterfaceDummy::create();
  sd->open(p2, v2);
  p1->CheckEmpty();
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [6/6]

BOOST_AUTO_TEST_CASE

(

updates_are_sent_to_multiple_views

)

{
  SizeDeterminer::Ptr const sd = SizeDeterminer::create();
 
  Scroom::Utils::Rectangle<double> const        r1(1, 2, 3, 4);
  ResizablePresentationInterfaceStub::Ptr const p1 = ResizablePresentationInterfaceStub::create(r1);
  sd->add(p1);
  ViewInterface::Ptr const vi1 = ViewInterfaceDummy::create();
  sd->open(p1, vi1);
  ViewInterface::Ptr const vi2 = ViewInterfaceDummy::create();
  sd->open(p1, vi2);
  ViewInterface::Ptr const vi3 = ViewInterfaceDummy::create();
  sd->open(p1, vi3);
 
  BOOST_CHECK_EQUAL(r1, sd->getRect());
  p1->CheckAllEqual(r1);
  BOOST_CHECK(p1->Contains(vi1));
  BOOST_CHECK(p1->Contains(vi2));
  BOOST_CHECK(p1->Contains(vi3));
  p1->Clear();
 
  sd->close(p1, vi3);
  Scroom::Utils::Rectangle<double> const r2(2, 1, 4, 3);
  PresentationInterfaceStub::Ptr const   p2 = PresentationInterfaceStub::create(r2);
  sd->add(p2);
  BOOST_CHECK_EQUAL(r2, sd->getRect());
  p1->CheckAllEqual(r2);
  BOOST_CHECK(p1->Contains(vi1));
  BOOST_CHECK(p1->Contains(vi2));
  BOOST_CHECK(!p1->Contains(vi3));
}

Here is the call graph for this function:

dumpContainer()

template<typename Iter >

std::ostream& dumpContainer	(	std::ostream &	os,
		const std::string &	name,
		Iter const &	begin,
		Iter const &	end
	)

{
  os << name << "(";
  Iter cur = begin;
  if(cur != end)
  {
    os << *cur++;
  }
 
  while(cur != end)
  {
    os << ", " << *cur++;
  }
 
  os << ")";
  return os;
}

Referenced by std::operator<<().

Here is the caller graph for this function:

operator<<()

template<typename T >

std::ostream& std::operator<<	(	std::ostream &	os,
		std::list< T > const &	l
	)

  {
    return dumpContainer(os, "std::list", l.begin(), l.end());
  }

Here is the call graph for this function:

operator==()

template<typename T >

bool operator==	(	boost::weak_ptr< T > const &	left,
		boost::weak_ptr< T > const &	right
	)

{
  return !(left < right) && !(right < left);
}