rectangletests.cc File Reference

#include <boost/mpl/list.hpp>
#include <boost/test/unit_test.hpp>
#include <scroom/gtk-helpers.hh>
#include <scroom/linearsegment.hh>
#include <scroom/rectangle.hh>

Include dependency graph for rectangletests.cc:

Classes
class	RectangleHorizontalTestScaffold
class	RectangleVerticalTestScaffold

Typedefs
using	test_types = boost::mpl::list< Segment< int >, RectangleHorizontalTestScaffold, RectangleVerticalTestScaffold >

Functions
template<class Scaffold >
void	containedSegmentEqualsIntersection (const Scaffold &container, const Scaffold &contained)
template<class Scaffold >
void	intersectsImpliesNonEmptyIntersection (const Scaffold &a, const Scaffold &b)
	BOOST_AUTO_TEST_CASE_TEMPLATE (testCreateSegment, Scaffold, test_types)
	BOOST_AUTO_TEST_CASE_TEMPLATE (testMoveTo, Scaffold, test_types)
	BOOST_AUTO_TEST_CASE_TEMPLATE (testReduceSizeToMultipleOf, Scaffold, test_types)
	BOOST_AUTO_TEST_CASE_TEMPLATE (testContainsPoint, Scaffold, test_types)
	BOOST_AUTO_TEST_CASE_TEMPLATE (testContainsSegment, Scaffold, test_types)
	BOOST_AUTO_TEST_CASE_TEMPLATE (testIntersects, Scaffold, test_types)
	BOOST_AUTO_TEST_CASE_TEMPLATE (testIntersection, Scaffold, test_types)
	BOOST_AUTO_TEST_CASE (testRetrievingHorizontallyAndVertically)
	BOOST_AUTO_TEST_CASE (testConversionToAndFromGdkRectangle)
	BOOST_AUTO_TEST_CASE (testCorners)
	BOOST_AUTO_TEST_CASE (testMath)
	BOOST_AUTO_TEST_CASE (testCuts)
	BOOST_AUTO_TEST_CASE (testPlus)
	BOOST_AUTO_TEST_CASE (testMinus)
	BOOST_AUTO_TEST_CASE (testMultiply)
	BOOST_AUTO_TEST_CASE (testAnd)

Typedef Documentation

test_types

using test_types = boost::mpl::list<Segment<int>, RectangleHorizontalTestScaffold, RectangleVerticalTestScaffold>

Function Documentation

BOOST_AUTO_TEST_CASE() [1/9]

BOOST_AUTO_TEST_CASE

(

testAnd

)

{
  Segment<int> const left(1, 4);
  Segment<int> const right(3, 7);
  Segment<int> const result = left & right;
  Segment<int> const expected(3, 2);
  BOOST_CHECK_EQUAL(expected, result);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [2/9]

BOOST_AUTO_TEST_CASE

(

testConversionToAndFromGdkRectangle

)

{
  const cairo_rectangle_int_t original = Scroom::GtkHelpers::createCairoIntRectangle(1, 2, 3, 4);
  const auto                  rect     = Rectangle<int>(original);
  BOOST_CHECK_EQUAL(make_rect(1, 2, 3, 4), rect);
 
  const GdkRectangle grect = rect.toGdkRectangle();
  BOOST_CHECK_EQUAL(original, grect);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [3/9]

BOOST_AUTO_TEST_CASE

(

testCorners

)

{
  const Rectangle<int> rect(1, 2, 3, 4);
  BOOST_CHECK_EQUAL(make_point(1, 2), rect.getTopLeft());
  BOOST_CHECK_EQUAL(make_point(4, 2), rect.getTopRight());
  BOOST_CHECK_EQUAL(make_point(1, 6), rect.getBottomLeft());
  BOOST_CHECK_EQUAL(make_point(4, 6), rect.getBottomRight());
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [4/9]

BOOST_AUTO_TEST_CASE

(

testCuts

)

{
  const Rectangle<int> original(10, 20, 30, 40);
 
  BOOST_CHECK(original.leftOf(5).isEmpty());
  BOOST_CHECK_EQUAL(original, original.leftOf(40));
  BOOST_CHECK_EQUAL(Rectangle<int>(10, 20, 10, 40), original.leftOf(20));
 
  BOOST_CHECK(original.rightOf(40).isEmpty());
  BOOST_CHECK_EQUAL(original, original.rightOf(5));
  BOOST_CHECK_EQUAL(Rectangle<int>(20, 20, 20, 40), original.rightOf(20));
 
  BOOST_CHECK(original.above(5).isEmpty());
  BOOST_CHECK_EQUAL(original, original.above(60));
  BOOST_CHECK_EQUAL(Rectangle<int>(10, 20, 30, 20), original.above(40));
 
  BOOST_CHECK(original.below(60).isEmpty());
  BOOST_CHECK_EQUAL(original, original.below(20));
  BOOST_CHECK_EQUAL(Rectangle<int>(10, 40, 30, 20), original.below(40));
 
  BOOST_CHECK_EQUAL(Rectangle<int>(10, 30, 5, 5), original.leftOf(Rectangle<int>(15, 30, 10, 5)));
  BOOST_CHECK_EQUAL(Rectangle<int>(10, 20, 10, 40), original.above(Rectangle<int>(0, 100, 20, 10)));
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [5/9]

BOOST_AUTO_TEST_CASE

(

testMath

)

{
  BOOST_CHECK_EQUAL(make_point(4, 6), make_point(1, 2) + make_point(3, 4));
  BOOST_CHECK_EQUAL(make_point(4, 6) - make_point(1, 2), make_point(3, 4));
  BOOST_CHECK_EQUAL(make_point(2, 4), make_point(1, 2) * 2);
 
  BOOST_CHECK_EQUAL(make_rect(6, 8, 3, 4), make_point(5, 6) + make_rect(1, 2, 3, 4));
  BOOST_CHECK_EQUAL(make_rect(6, 8, 3, 4) - make_point(5, 6), make_rect(1, 2, 3, 4));
 
  auto result = 0.5 * make_rect(1, 3, 5, 7);
  BOOST_CHECK_CLOSE(0.5, result.getLeft(), 1e-6);
  BOOST_CHECK_CLOSE(2.5, result.getWidth(), 1e-6);
  BOOST_CHECK_CLOSE(1.5, result.getTop(), 1e-6);
  BOOST_CHECK_CLOSE(3.5, result.getHeight(), 1e-6);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [6/9]

BOOST_AUTO_TEST_CASE

(

testMinus

)

{
  Segment<int> const result = make_segment(7, 3) - 10;
  Segment<int> const expected(-3, 3);
  BOOST_CHECK_EQUAL(expected, result);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [7/9]

BOOST_AUTO_TEST_CASE

(

testMultiply

)

{
  Segment<int> const result = make_segment(7, 3) * 5;
  Segment<int> const expected(35, 15);
  BOOST_CHECK_EQUAL(expected, result);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [8/9]

BOOST_AUTO_TEST_CASE

(

testPlus

)

{
  Segment<int> const result = 5 + make_segment(7, 3);
  Segment<int> const expected(12, 3);
  BOOST_CHECK_EQUAL(expected, result);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE() [9/9]

BOOST_AUTO_TEST_CASE

(

testRetrievingHorizontallyAndVertically

)

{
  const Rectangle<int> r(1, 2, 3, 4);
 
  BOOST_CHECK_EQUAL(make_segment(1, 3), r.getHorizontally());
  BOOST_CHECK_EQUAL(make_segment(2, 4), r.getVertically());
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE_TEMPLATE() [1/7]

BOOST_AUTO_TEST_CASE_TEMPLATE	(	testContainsPoint	,
		Scaffold	,
		test_types
	)

{
  Scaffold s1;
  Scaffold s2(2, 5);
 
  BOOST_CHECK(!s1.contains(0));
  BOOST_CHECK(!s2.contains(0));
  BOOST_CHECK(s2.contains(2));
  BOOST_CHECK(s2.contains(6));
  BOOST_CHECK(!s2.contains(7));
  BOOST_CHECK(!s2.contains(8));
}

BOOST_AUTO_TEST_CASE_TEMPLATE() [2/7]

BOOST_AUTO_TEST_CASE_TEMPLATE	(	testContainsSegment	,
		Scaffold	,
		test_types
	)

{
  Scaffold s1;
  Scaffold s2(-1, 3);
  Scaffold s3(-3, 2);
  Scaffold s4(-2, 2);
  Scaffold s5(-1, 2);
  Scaffold s6(0, 2);
  Scaffold s7(1, 2);
  Scaffold s8(2, 2);
 
  BOOST_CHECK(!s1.contains(s2));
  containedSegmentEqualsIntersection(s1, s2);
  BOOST_CHECK(!s1.contains(s3));
  containedSegmentEqualsIntersection(s1, s3);
  BOOST_CHECK(!s1.contains(s4));
  containedSegmentEqualsIntersection(s1, s4);
  BOOST_CHECK(!s1.contains(s5));
  containedSegmentEqualsIntersection(s1, s5);
  BOOST_CHECK(!s1.contains(s6));
  containedSegmentEqualsIntersection(s1, s6);
  BOOST_CHECK(!s1.contains(s7));
  containedSegmentEqualsIntersection(s1, s7);
  BOOST_CHECK(!s1.contains(s8));
  containedSegmentEqualsIntersection(s1, s8);
 
  BOOST_CHECK(s2.contains(s1));
  containedSegmentEqualsIntersection(s2, s1);
  BOOST_CHECK(!s2.contains(s3));
  containedSegmentEqualsIntersection(s2, s3);
  BOOST_CHECK(!s2.contains(s4));
  containedSegmentEqualsIntersection(s2, s4);
  BOOST_CHECK(s2.contains(s5));
  containedSegmentEqualsIntersection(s2, s5);
  BOOST_CHECK(s2.contains(s6));
  containedSegmentEqualsIntersection(s2, s6);
  BOOST_CHECK(!s2.contains(s7));
  containedSegmentEqualsIntersection(s2, s7);
  BOOST_CHECK(!s2.contains(s8));
  containedSegmentEqualsIntersection(s2, s8);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE_TEMPLATE() [3/7]

BOOST_AUTO_TEST_CASE_TEMPLATE	(	testCreateSegment	,
		Scaffold	,
		test_types
	)

{
  Scaffold s1;
  Scaffold s2(2, 5);
  Scaffold s3;
  Scaffold s4(2, 5);
  Scaffold s5(3, 5);
  Scaffold s6(2, 6);
  Scaffold s7(7, -5);
 
  BOOST_CHECK(s1.isEmpty());
  BOOST_CHECK_EQUAL(0, s1.getSize());
 
  BOOST_CHECK(!s2.isEmpty());
  BOOST_CHECK(s3.isEmpty());
  BOOST_CHECK(!s4.isEmpty());
  BOOST_CHECK(!s5.isEmpty());
  BOOST_CHECK(!s6.isEmpty());
 
  BOOST_CHECK_EQUAL(2, s2.getStart());
  BOOST_CHECK_EQUAL(5, s2.getSize());
  BOOST_CHECK_EQUAL(7, s2.getEnd());
  BOOST_CHECK(s1 == s3);
  BOOST_CHECK(s2 == s4);
  BOOST_CHECK(s1 != s2);
  BOOST_CHECK(s2 != s5);
  BOOST_CHECK(s2 != s6);
 
  BOOST_CHECK_EQUAL(2, s7.getStart());
  BOOST_CHECK_EQUAL(5, s7.getSize());
  BOOST_CHECK_EQUAL(7, s7.getEnd());
  BOOST_CHECK_EQUAL(s2, s7);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE_TEMPLATE() [4/7]

BOOST_AUTO_TEST_CASE_TEMPLATE	(	testIntersection	,
		Scaffold	,
		test_types
	)

{
  Scaffold s1;
  Scaffold s2(-1, 3);
  Scaffold s3(-3, 2);
  Scaffold s4(-2, 2);
  Scaffold s5(-1, 2);
  Scaffold s6(0, 2);
  Scaffold s7(1, 2);
  Scaffold s8(2, 2);
 
  BOOST_CHECK(s1.intersection(s2).isEmpty());
  BOOST_CHECK(s1.intersection(s3).isEmpty());
  BOOST_CHECK(s1.intersection(s4).isEmpty());
  BOOST_CHECK(s1.intersection(s5).isEmpty());
  BOOST_CHECK(s1.intersection(s6).isEmpty());
  BOOST_CHECK(s1.intersection(s7).isEmpty());
  BOOST_CHECK(s1.intersection(s8).isEmpty());
 
  BOOST_CHECK(s2.intersection(s1).isEmpty());
  BOOST_CHECK(s2.intersection(s3).isEmpty());
  BOOST_CHECK_EQUAL(Scaffold(-1, 1), s2.intersection(s4));
  BOOST_CHECK_EQUAL(s5, s2.intersection(s5));
  BOOST_CHECK_EQUAL(s6, s2.intersection(s6));
  BOOST_CHECK_EQUAL(Scaffold(1, 1), s2.intersection(s7));
  BOOST_CHECK(s2.intersection(s8).isEmpty());
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE_TEMPLATE() [5/7]

BOOST_AUTO_TEST_CASE_TEMPLATE	(	testIntersects	,
		Scaffold	,
		test_types
	)

{
  Scaffold s1;
  Scaffold s2(-1, 3);
  Scaffold s3(-3, 2);
  Scaffold s4(-2, 2);
  Scaffold s5(-1, 2);
  Scaffold s6(0, 2);
  Scaffold s7(1, 2);
  Scaffold s8(2, 2);
 
  BOOST_CHECK(!s1.intersects(s2));
  intersectsImpliesNonEmptyIntersection(s1, s2);
  BOOST_CHECK(!s1.intersects(s3));
  intersectsImpliesNonEmptyIntersection(s1, s3);
  BOOST_CHECK(!s1.intersects(s4));
  intersectsImpliesNonEmptyIntersection(s1, s4);
  BOOST_CHECK(!s1.intersects(s5));
  intersectsImpliesNonEmptyIntersection(s1, s5);
  BOOST_CHECK(!s1.intersects(s6));
  intersectsImpliesNonEmptyIntersection(s1, s6);
  BOOST_CHECK(!s1.intersects(s7));
  intersectsImpliesNonEmptyIntersection(s1, s7);
  BOOST_CHECK(!s1.intersects(s8));
  intersectsImpliesNonEmptyIntersection(s1, s8);
 
  BOOST_CHECK(!s2.intersects(s1));
  intersectsImpliesNonEmptyIntersection(s2, s1);
  BOOST_CHECK(!s2.intersects(s3));
  intersectsImpliesNonEmptyIntersection(s2, s3);
  BOOST_CHECK(s2.intersects(s4));
  intersectsImpliesNonEmptyIntersection(s2, s4);
  BOOST_CHECK(s2.intersects(s5));
  intersectsImpliesNonEmptyIntersection(s2, s5);
  BOOST_CHECK(s2.intersects(s6));
  intersectsImpliesNonEmptyIntersection(s2, s6);
  BOOST_CHECK(s2.intersects(s7));
  intersectsImpliesNonEmptyIntersection(s2, s7);
  BOOST_CHECK(!s2.intersects(s8));
  intersectsImpliesNonEmptyIntersection(s2, s8);
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE_TEMPLATE() [6/7]

BOOST_AUTO_TEST_CASE_TEMPLATE	(	testMoveTo	,
		Scaffold	,
		test_types
	)

{
  Scaffold orig(2, 5);
  Scaffold s = orig.moveTo(5);
 
  BOOST_CHECK(!s.isEmpty());
 
  BOOST_CHECK_EQUAL(5, s.getStart());
  BOOST_CHECK_EQUAL(5, s.getSize());
  BOOST_CHECK_EQUAL(10, s.getEnd());
}

Here is the call graph for this function:

BOOST_AUTO_TEST_CASE_TEMPLATE() [7/7]

BOOST_AUTO_TEST_CASE_TEMPLATE	(	testReduceSizeToMultipleOf	,
		Scaffold	,
		test_types
	)

{
  Scaffold s(2, 10);
 
  s.reduceSizeToMultipleOf(5);
  BOOST_CHECK_EQUAL(2, s.getStart());
  BOOST_CHECK_EQUAL(10, s.getSize());
 
  s.reduceSizeToMultipleOf(3);
  BOOST_CHECK_EQUAL(2, s.getStart());
  BOOST_CHECK_EQUAL(9, s.getSize());
}

Here is the call graph for this function:

containedSegmentEqualsIntersection()

template<class Scaffold >

void containedSegmentEqualsIntersection	(	const Scaffold &	container,
		const Scaffold &	contained
	)

{
  if(container.contains(contained))
  {
    BOOST_CHECK_EQUAL(contained, container.intersection(contained));
    BOOST_CHECK_EQUAL(contained, contained.intersection(container));
  }
}

Referenced by BOOST_AUTO_TEST_CASE_TEMPLATE().

Here is the call graph for this function:

Here is the caller graph for this function:

intersectsImpliesNonEmptyIntersection()

template<class Scaffold >

void intersectsImpliesNonEmptyIntersection	(	const Scaffold &	a,
		const Scaffold &	b
	)

{
  BOOST_CHECK_EQUAL(a.intersects(b), b.intersects(a));
  BOOST_CHECK_EQUAL(a.intersects(b), !a.intersection(b).isEmpty());
  BOOST_CHECK_EQUAL(b.intersects(a), !b.intersection(a).isEmpty());
  BOOST_CHECK_EQUAL(a.intersection(b), b.intersection(a));
}

Referenced by BOOST_AUTO_TEST_CASE_TEMPLATE().

Here is the call graph for this function:

Here is the caller graph for this function: