diff --git a/src/tests/kits/interface/InterfaceKitTestAddon.cpp b/src/tests/kits/interface/InterfaceKitTestAddon.cpp index 4189215979..39d376ef6d 100644 --- a/src/tests/kits/interface/InterfaceKitTestAddon.cpp +++ b/src/tests/kits/interface/InterfaceKitTestAddon.cpp @@ -5,6 +5,7 @@ #include "bbitmap/BitmapTest.h" #include "bdeskbar/DeskbarTest.h" #include "bpolygon/PolygonTest.h" +#include "bregion/RegionTest.h" BTestSuite* getTestSuite() { BTestSuite *suite = new BTestSuite("Interface"); @@ -13,6 +14,7 @@ BTestSuite* getTestSuite() { suite->addTest("BBitmap", BitmapTestSuite()); suite->addTest("BDeskbar", DeskbarTestSuite()); suite->addTest("BPolygon", PolygonTestSuite()); + suite->addTest("BRegion", RegionTestSuite()); return suite; } diff --git a/src/tests/kits/interface/Jamfile b/src/tests/kits/interface/Jamfile index a09f286751..d3ed3101d2 100644 --- a/src/tests/kits/interface/Jamfile +++ b/src/tests/kits/interface/Jamfile @@ -4,6 +4,7 @@ SubDir OBOS_TOP src tests kits interface ; SEARCH_SOURCE += [ FDirName $(SUBDIR) bbitmap ] ; SEARCH_SOURCE += [ FDirName $(SUBDIR) bdeskbar ] ; SEARCH_SOURCE += [ FDirName $(SUBDIR) bpolygon ] ; +SEARCH_SOURCE += [ FDirName $(SUBDIR) bregion ] ; SEARCH_SOURCE += [ FDirName $(TOP) src kits interface ] ; @@ -27,6 +28,15 @@ CommonTestLib libinterfacetest.so CreatePolygonTest.cpp MapPolygonTest.cpp + # BRegion + RegionTest.cpp + RegionTestcase.cpp + RegionConstruction.cpp + RegionExclude.cpp + RegionInclude.cpp + RegionIntersect.cpp + RegionOffsetBy.cpp + : libopenbeos.so be stdc++.r4 : be stdc++.r4 diff --git a/src/tests/kits/interface/bregion/RegionConstruction.cpp b/src/tests/kits/interface/bregion/RegionConstruction.cpp new file mode 100644 index 0000000000..414554df88 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionConstruction.cpp @@ -0,0 +1,124 @@ +/* + $Id: RegionConstruction.cpp,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file implements the construction test for the OpenBeOS BRegion + code. + + */ + + +#include "RegionConstruction.h" +#include +#include + + +/* + * Method: RegionConstruction::RegionConstruction() + * Descr: This is the constructor for this class. + */ + +RegionConstruction::RegionConstruction(std::string name) : + RegionTestcase(name) +{ + } + + +/* + * Method: RegionConstruction::~RegionConstruction() + * Descr: This is the destructor for this class. + */ + +RegionConstruction::~RegionConstruction() +{ + } + + +/* + * Method: RegionConstruction::testOneRegion() + * Descr: This member function performs a test on a single passed in + * region. + */ + +void RegionConstruction::testOneRegion(BRegion *testRegion) +{ + assert(!testRegion->RectAt(-1).IsValid()); + assert(!testRegion->RectAt(testRegion->CountRects()).IsValid()); + + BRegion tempRegion1(*testRegion); + assert(RegionsAreEqual(&tempRegion1, testRegion)); + CheckFrame(&tempRegion1); + + tempRegion1.MakeEmpty(); + assert(RegionIsEmpty(&tempRegion1)); + CheckFrame(&tempRegion1); + + if (!RegionIsEmpty(testRegion)) { + assert(!RegionsAreEqual(&tempRegion1, testRegion)); + for(int i = testRegion->CountRects() - 1; i >= 0; i--) { + tempRegion1.Include(testRegion->RectAt(i)); + CheckFrame(&tempRegion1); + } + } + assert(RegionsAreEqual(&tempRegion1, testRegion)); + + if (!RegionIsEmpty(testRegion)) { + BRegion tempRegion2(testRegion->RectAt(0)); + CheckFrame(&tempRegion2); + assert(!RegionIsEmpty(&tempRegion2)); + + BRegion tempRegion3; + CheckFrame(&tempRegion3); + assert(RegionIsEmpty(&tempRegion3)); + tempRegion3.Set(testRegion->RectAt(0)); + CheckFrame(&tempRegion3); + assert(!RegionIsEmpty(&tempRegion3)); + + tempRegion1.Set(testRegion->RectAt(0)); + CheckFrame(&tempRegion1); + assert(!RegionIsEmpty(&tempRegion1)); + + assert(RegionsAreEqual(&tempRegion1, &tempRegion2)); + assert(RegionsAreEqual(&tempRegion1, &tempRegion3)); + assert(RegionsAreEqual(&tempRegion2, &tempRegion3)); + } +} + + +/* + * Method: RegionConstruction::testTwoRegions() + * Descr: This member function performs a test on two regions passed in. + */ + +void RegionConstruction::testTwoRegions(BRegion *testRegionA, BRegion *testRegionB) +{ + BRegion tempRegion1; + CheckFrame(&tempRegion1); + assert(RegionIsEmpty(&tempRegion1)); + + tempRegion1 = *testRegionA; + CheckFrame(&tempRegion1); + assert(RegionsAreEqual(&tempRegion1, testRegionA)); + + tempRegion1 = *testRegionB; + CheckFrame(&tempRegion1); + assert(RegionsAreEqual(&tempRegion1, testRegionB)); + + tempRegion1.MakeEmpty(); + CheckFrame(&tempRegion1); + assert(RegionIsEmpty(&tempRegion1)); +} + + +/* + * Method: RegionConstruction::suite() + * Descr: This static member function returns a test caller for performing + * all combinations of "RegionConstruction". + */ + + Test *RegionConstruction::suite(void) +{ + typedef CppUnit::TestCaller + RegionConstructionCaller; + + return(new RegionConstructionCaller("BRegion::Construction Test", &RegionConstruction::PerformTest)); + } diff --git a/src/tests/kits/interface/bregion/RegionConstruction.h b/src/tests/kits/interface/bregion/RegionConstruction.h new file mode 100644 index 0000000000..ee1f715793 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionConstruction.h @@ -0,0 +1,33 @@ +/* + $Id: RegionConstruction.h,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file defines a class for performing one test of BRegion + functionality. + + */ + + +#ifndef RegionConstruction_H +#define RegionConstruction_H + + +#include "RegionTestcase.h" + + +class RegionConstruction : + public RegionTestcase { + +private: + + +protected: + virtual void testOneRegion(BRegion *); + virtual void testTwoRegions(BRegion *, BRegion *); + +public: + static Test *suite(void); + RegionConstruction(std::string name = ""); + virtual ~RegionConstruction(); + }; + +#endif diff --git a/src/tests/kits/interface/bregion/RegionExclude.cpp b/src/tests/kits/interface/bregion/RegionExclude.cpp new file mode 100644 index 0000000000..a6a4c07c19 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionExclude.cpp @@ -0,0 +1,197 @@ +/* + $Id: RegionExclude.cpp,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file implements the exclude test for the OpenBeOS BRegion + code. + + */ + + +#include "RegionExclude.h" +#include +#include + + +/* + * Method: RegionExclude::RegionExclude() + * Descr: This is the constructor for this class. + */ + +RegionExclude::RegionExclude(std::string name) : + RegionTestcase(name) +{ + } + + +/* + * Method: RegionExclude::~RegionExclude() + * Descr: This is the destructor for this class. + */ + +RegionExclude::~RegionExclude() +{ + } + + +/* + * Method: RegionExclude::CheckExclude() + * Descr: This member function checks that the result region is in fact + * region A with region B excluded. + */ + +void RegionExclude::CheckExclude(BRegion *resultRegion, BRegion *testRegionA, + BRegion *testRegionB) +{ + bool resultRegionEmpty = RegionIsEmpty(resultRegion); + bool testRegionAEmpty = RegionIsEmpty(testRegionA); + bool testRegionBEmpty = RegionIsEmpty(testRegionB); + + if (RegionsAreEqual(testRegionA, testRegionB)) { + assert(resultRegionEmpty); + } + + if (RegionsAreEqual(resultRegion, testRegionA)) { + BRegion tempRegion(*testRegionA); + tempRegion.IntersectWith(testRegionB); + assert(RegionIsEmpty(&tempRegion)); + } + + if (RegionsAreEqual(resultRegion, testRegionB)) { + assert(resultRegionEmpty); + assert(testRegionAEmpty); + assert(testRegionBEmpty); + } + + if ((!resultRegionEmpty) && (!testRegionAEmpty) && (!testRegionBEmpty)) { + BRect resultRegionFrame(resultRegion->Frame()); + BRect testRegionAFrame(testRegionA->Frame()); + BRect testRegionBFrame(testRegionB->Frame()); + + if (!testRegionAFrame.Intersects(testRegionBFrame)) { + assert(testRegionAFrame == resultRegionFrame); + assert(RegionsAreEqual(resultRegion, testRegionA)); + } else { + assert(testRegionAFrame.Contains(resultRegionFrame)); + } + } + + if (testRegionBEmpty) { + assert(RegionsAreEqual(resultRegion, testRegionA)); + } else { + assert(!RegionsAreEqual(resultRegion, testRegionB)); + for(int i = 0; i < testRegionB->CountRects(); i++) { + BRect tempRect = testRegionB->RectAt(i); + + assert(testRegionB->Intersects(tempRect)); + assert(!resultRegion->Intersects(tempRect)); + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(testRegionB->Contains(pointArray[j])); + assert(!resultRegion->Contains(pointArray[j])); + } + } + } + + if (testRegionAEmpty) { + assert(resultRegionEmpty); + } else { + for(int i = 0; i < testRegionA->CountRects(); i++) { + BRect tempRect = testRegionA->RectAt(i); + + assert(testRegionA->Intersects(tempRect)); + if (!testRegionB->Intersects(tempRect)) { + assert(resultRegion->Intersects(tempRect)); + } + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(testRegionA->Contains(pointArray[j])); + if (testRegionB->Contains(pointArray[j])) { + assert(!resultRegion->Contains(pointArray[j])); + } else { + assert(resultRegion->Contains(pointArray[j])); + } + } + } + } + + if (resultRegionEmpty) { + BRegion tempRegion(*testRegionA); + tempRegion.IntersectWith(testRegionB); + assert(RegionsAreEqual(&tempRegion, testRegionA)); + } else { + assert(!RegionsAreEqual(resultRegion, testRegionB)); + for(int i = 0; i < resultRegion->CountRects(); i++) { + BRect tempRect = resultRegion->RectAt(i); + + assert(resultRegion->Intersects(tempRect)); + assert(testRegionA->Intersects(tempRect)); + assert(!testRegionB->Intersects(tempRect)); + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(resultRegion->Contains(pointArray[j])); + assert(testRegionA->Contains(pointArray[j])); + assert(!testRegionB->Contains(pointArray[j])); + } + } + } +} + + +/* + * Method: RegionExclude::testOneRegion() + * Descr: This member function performs a test on a single passed in + * region. + */ + +void RegionExclude::testOneRegion(BRegion *testRegion) +{ + +} + + +/* + * Method: RegionExclude::testTwoRegions() + * Descr: This member function performs a test on two regions passed in. + */ + +void RegionExclude::testTwoRegions(BRegion *testRegionA, BRegion *testRegionB) +{ + BRegion tempRegion1(*testRegionA); + CheckFrame(&tempRegion1); + assert(RegionsAreEqual(&tempRegion1, testRegionA)); + + tempRegion1.Exclude(testRegionB); + CheckFrame(&tempRegion1); + CheckExclude(&tempRegion1, testRegionA, testRegionB); + + tempRegion1 = *testRegionA; + CheckFrame(&tempRegion1); + assert(RegionsAreEqual(&tempRegion1, testRegionA)); + + for(int i = 0; i < testRegionB->CountRects(); i++) { + tempRegion1.Exclude(testRegionB->RectAt(i)); + CheckFrame(&tempRegion1); + } + CheckExclude(&tempRegion1, testRegionA, testRegionB); +} + + +/* + * Method: RegionExclude::suite() + * Descr: This static member function returns a test caller for performing + * all combinations of "RegionExclude". + */ + + Test *RegionExclude::suite(void) +{ + typedef CppUnit::TestCaller + RegionExcludeCaller; + + return(new RegionExcludeCaller("BRegion::Exclude Test", &RegionExclude::PerformTest)); + } diff --git a/src/tests/kits/interface/bregion/RegionExclude.h b/src/tests/kits/interface/bregion/RegionExclude.h new file mode 100644 index 0000000000..2f8cbed531 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionExclude.h @@ -0,0 +1,33 @@ +/* + $Id: RegionExclude.h,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file defines a class for performing one test of BRegion + functionality. + + */ + + +#ifndef RegionExclude_H +#define RegionExclude_H + + +#include "RegionTestcase.h" + + +class RegionExclude : + public RegionTestcase { + +private: + void CheckExclude(BRegion *, BRegion *, BRegion *); + +protected: + virtual void testOneRegion(BRegion *); + virtual void testTwoRegions(BRegion *, BRegion *); + +public: + static Test *suite(void); + RegionExclude(std::string name = ""); + virtual ~RegionExclude(); + }; + +#endif diff --git a/src/tests/kits/interface/bregion/RegionInclude.cpp b/src/tests/kits/interface/bregion/RegionInclude.cpp new file mode 100644 index 0000000000..8788ee2640 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionInclude.cpp @@ -0,0 +1,183 @@ +/* + $Id: RegionInclude.cpp,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file implements the include test for the OpenBeOS BRegion + code. + + */ + + +#include "RegionInclude.h" +#include +#include + + +/* + * Method: RegionInclude::RegionInclude() + * Descr: This is the constructor for this class. + */ + +RegionInclude::RegionInclude(std::string name) : + RegionTestcase(name) +{ + } + + +/* + * Method: RegionInclude::~RegionInclude() + * Descr: This is the destructor for this class. + */ + +RegionInclude::~RegionInclude() +{ + } + + +/* + * Method: RegionExclude::CheckInclude() + * Descr: This member function checks that the result region is in fact + * region A with region B included. + */ + +void RegionInclude::CheckInclude(BRegion *resultRegion, BRegion *testRegionA, + BRegion *testRegionB) +{ + bool resultRegionEmpty = RegionIsEmpty(resultRegion); + bool testRegionAEmpty = RegionIsEmpty(testRegionA); + bool testRegionBEmpty = RegionIsEmpty(testRegionB); + + if (RegionsAreEqual(testRegionA, testRegionB)) { + assert(RegionsAreEqual(resultRegion, testRegionA)); + } + + if (RegionsAreEqual(resultRegion, testRegionA)) { + BRegion tempRegion(*testRegionA); + tempRegion.IntersectWith(testRegionB); + assert(RegionsAreEqual(&tempRegion, testRegionB)); + } + + if (RegionsAreEqual(resultRegion, testRegionB)) { + BRegion tempRegion(*testRegionA); + tempRegion.IntersectWith(testRegionB); + assert(RegionsAreEqual(&tempRegion, testRegionA)); + } + + if ((!resultRegionEmpty) && (!testRegionAEmpty) && (!testRegionBEmpty)) { + BRect resultRegionFrame(resultRegion->Frame()); + BRect testRegionAFrame(testRegionA->Frame()); + BRect testRegionBFrame(testRegionB->Frame()); + + assert(resultRegionFrame == (testRegionAFrame | testRegionBFrame)); + } + + if (testRegionBEmpty) { + assert(RegionsAreEqual(resultRegion, testRegionA)); + } else { + for(int i = 0; i < testRegionB->CountRects(); i++) { + BRect tempRect = testRegionB->RectAt(i); + + assert(testRegionB->Intersects(tempRect)); + assert(resultRegion->Intersects(tempRect)); + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(testRegionB->Contains(pointArray[j])); + assert(resultRegion->Contains(pointArray[j])); + } + } + } + + if (testRegionAEmpty) { + assert(RegionsAreEqual(resultRegion, testRegionB)); + } else { + for(int i = 0; i < testRegionA->CountRects(); i++) { + BRect tempRect = testRegionA->RectAt(i); + + assert(testRegionA->Intersects(tempRect)); + assert(resultRegion->Intersects(tempRect)); + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(testRegionA->Contains(pointArray[j])); + assert(resultRegion->Contains(pointArray[j])); + } + } + } + + if (resultRegionEmpty) { + assert(testRegionAEmpty); + assert(testRegionBEmpty); + } else { + for(int i = 0; i < resultRegion->CountRects(); i++) { + BRect tempRect = resultRegion->RectAt(i); + + assert(resultRegion->Intersects(tempRect)); + assert((testRegionA->Intersects(tempRect)) || + (testRegionB->Intersects(tempRect))); + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(resultRegion->Contains(pointArray[j])); + assert((testRegionA->Contains(pointArray[j])) || + (testRegionB->Contains(pointArray[j]))); + } + } + } +} + + +/* + * Method: RegionInclude::testOneRegion() + * Descr: This member function performs a test on a single passed in + * region. + */ + +void RegionInclude::testOneRegion(BRegion *testRegion) +{ + +} + + +/* + * Method: RegionInclude::testTwoRegions() + * Descr: This member function performs a test on two regions passed in. + */ + +void RegionInclude::testTwoRegions(BRegion *testRegionA, BRegion *testRegionB) +{ + BRegion tempRegion1(*testRegionA); + CheckFrame(&tempRegion1); + assert(RegionsAreEqual(&tempRegion1, testRegionA)); + + tempRegion1.Include(testRegionB); + CheckFrame(&tempRegion1); + CheckInclude(&tempRegion1, testRegionA, testRegionB); + + tempRegion1 = *testRegionA; + CheckFrame(&tempRegion1); + assert(RegionsAreEqual(&tempRegion1, testRegionA)); + + for(int i = 0; i < testRegionB->CountRects(); i++) { + tempRegion1.Include(testRegionB->RectAt(i)); + CheckFrame(&tempRegion1); + } + CheckInclude(&tempRegion1, testRegionA, testRegionB); +} + + +/* + * Method: RegionInclude::suite() + * Descr: This static member function returns a test caller for performing + * all combinations of "RegionInclude". + */ + + Test *RegionInclude::suite(void) +{ + typedef CppUnit::TestCaller + RegionIncludeCaller; + + return(new RegionIncludeCaller("BRegion::Include Test", &RegionInclude::PerformTest)); + } diff --git a/src/tests/kits/interface/bregion/RegionInclude.h b/src/tests/kits/interface/bregion/RegionInclude.h new file mode 100644 index 0000000000..2c0930ecc8 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionInclude.h @@ -0,0 +1,33 @@ +/* + $Id: RegionInclude.h,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file defines a class for performing one test of BRegion + functionality. + + */ + + +#ifndef RegionInclude_H +#define RegionInclude_H + + +#include "RegionTestcase.h" + + +class RegionInclude : + public RegionTestcase { + +private: + void CheckInclude(BRegion *, BRegion *, BRegion *); + +protected: + virtual void testOneRegion(BRegion *); + virtual void testTwoRegions(BRegion *, BRegion *); + +public: + static Test *suite(void); + RegionInclude(std::string name = ""); + virtual ~RegionInclude(); + }; + +#endif diff --git a/src/tests/kits/interface/bregion/RegionIntersect.cpp b/src/tests/kits/interface/bregion/RegionIntersect.cpp new file mode 100644 index 0000000000..4c796c98ec --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionIntersect.cpp @@ -0,0 +1,195 @@ +/* + $Id: RegionIntersect.cpp,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file implements the intersect test for the OpenBeOS BRegion + code. + + */ + + +#include "RegionIntersect.h" +#include +#include + + +/* + * Method: RegionIntersect::RegionIntersect() + * Descr: This is the constructor for this class. + */ + +RegionIntersect::RegionIntersect(std::string name) : + RegionTestcase(name) +{ + } + + +/* + * Method: RegionIntersect::~RegionIntersect() + * Descr: This is the destructor for this class. + */ + +RegionIntersect::~RegionIntersect() +{ + } + + +/* + * Method: RegionExclude::CheckIntersect() + * Descr: This member function checks that the result region is in fact + * region A with region B intersected. + */ + +void RegionIntersect::CheckIntersect(BRegion *resultRegion, BRegion *testRegionA, + BRegion *testRegionB) +{ + bool resultRegionEmpty = RegionIsEmpty(resultRegion); + bool testRegionAEmpty = RegionIsEmpty(testRegionA); + bool testRegionBEmpty = RegionIsEmpty(testRegionB); + + if (RegionsAreEqual(testRegionA, testRegionB)) { + assert(RegionsAreEqual(resultRegion, testRegionA)); + } + + if (RegionsAreEqual(resultRegion, testRegionA)) { + BRegion tempRegion(*testRegionA); + tempRegion.Include(testRegionB); + assert(RegionsAreEqual(&tempRegion, testRegionB)); + } + + if (RegionsAreEqual(resultRegion, testRegionB)) { + BRegion tempRegion(*testRegionA); + tempRegion.Include(testRegionB); + assert(RegionsAreEqual(&tempRegion, testRegionA)); + } + + if ((!resultRegionEmpty) && (!testRegionAEmpty) && (!testRegionBEmpty)) { + BRect resultRegionFrame(resultRegion->Frame()); + BRect testRegionAFrame(testRegionA->Frame()); + BRect testRegionBFrame(testRegionB->Frame()); + BRect tempRect = (testRegionAFrame & testRegionBFrame); + + assert(tempRect.Contains(resultRegionFrame)); + } + + if (testRegionBEmpty) { + assert(resultRegionEmpty); + } else { + for(int i = 0; i < testRegionB->CountRects(); i++) { + BRect tempRect = testRegionB->RectAt(i); + + assert(testRegionB->Intersects(tempRect)); + if (testRegionA->Intersects(tempRect)) { + assert(resultRegion->Intersects(tempRect)); + } else { + assert(!resultRegion->Intersects(tempRect)); + } + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(testRegionB->Contains(pointArray[j])); + if (testRegionA->Contains(pointArray[j])) { + assert(resultRegion->Contains(pointArray[j])); + } else { + assert(!resultRegion->Contains(pointArray[j])); + } + } + } + } + + if (testRegionAEmpty) { + assert(resultRegionEmpty); + } else { + for(int i = 0; i < testRegionA->CountRects(); i++) { + BRect tempRect = testRegionA->RectAt(i); + + assert(testRegionA->Intersects(tempRect)); + if (testRegionB->Intersects(tempRect)) { + assert(resultRegion->Intersects(tempRect)); + } else { + assert(!resultRegion->Intersects(tempRect)); + } + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(testRegionA->Contains(pointArray[j])); + if (testRegionB->Contains(pointArray[j])) { + assert(resultRegion->Contains(pointArray[j])); + } else { + assert(!resultRegion->Contains(pointArray[j])); + } + } + } + } + + if (resultRegionEmpty) { + BRegion tempRegion(*testRegionA); + tempRegion.Exclude(testRegionB); + assert(RegionsAreEqual(&tempRegion, testRegionA)); + + tempRegion = *testRegionB; + tempRegion.Exclude(testRegionA); + assert(RegionsAreEqual(&tempRegion, testRegionB)); + } else { + for(int i = 0; i < resultRegion->CountRects(); i++) { + BRect tempRect = resultRegion->RectAt(i); + + assert(resultRegion->Intersects(tempRect)); + assert(testRegionA->Intersects(tempRect)); + assert(testRegionB->Intersects(tempRect)); + + BPoint *pointArray; + int numPoints = GetPointsInRect(tempRect, &pointArray); + for (int j = 0; j < numPoints; j++) { + assert(resultRegion->Contains(pointArray[j])); + assert(testRegionA->Contains(pointArray[j])); + assert(testRegionB->Contains(pointArray[j])); + } + } + } +} + + +/* + * Method: RegionIntersect::testOneRegion() + * Descr: This member function performs a test on a single passed in + * region. + */ + +void RegionIntersect::testOneRegion(BRegion *testRegion) +{ + +} + + +/* + * Method: RegionIntersect::testTwoRegions() + * Descr: This member function performs a test on two regions passed in. + */ + +void RegionIntersect::testTwoRegions(BRegion *testRegionA, BRegion *testRegionB) +{ + BRegion tempRegion1(*testRegionA); + CheckFrame(&tempRegion1); + assert(RegionsAreEqual(&tempRegion1, testRegionA)); + + tempRegion1.IntersectWith(testRegionB); + CheckFrame(&tempRegion1); + CheckIntersect(&tempRegion1, testRegionA, testRegionB); +} + + +/* + * Method: RegionIntersect::suite() + * Descr: This static member function returns a test caller for performing + * all combinations of "RegionIntersect". + */ + + Test *RegionIntersect::suite(void) +{ + typedef CppUnit::TestCaller + RegionIntersectCaller; + + return(new RegionIntersectCaller("BRegion::Intersect Test", &RegionIntersect::PerformTest)); + } diff --git a/src/tests/kits/interface/bregion/RegionIntersect.h b/src/tests/kits/interface/bregion/RegionIntersect.h new file mode 100644 index 0000000000..7e4473b787 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionIntersect.h @@ -0,0 +1,33 @@ +/* + $Id: RegionIntersect.h,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file defines a class for performing one test of BRegion + functionality. + + */ + + +#ifndef RegionIntersect_H +#define RegionIntersect_H + + +#include "RegionTestcase.h" + + +class RegionIntersect : + public RegionTestcase { + +private: + void CheckIntersect(BRegion *, BRegion *, BRegion *); + +protected: + virtual void testOneRegion(BRegion *); + virtual void testTwoRegions(BRegion *, BRegion *); + +public: + static Test *suite(void); + RegionIntersect(std::string name = ""); + virtual ~RegionIntersect(); + }; + +#endif diff --git a/src/tests/kits/interface/bregion/RegionOffsetBy.cpp b/src/tests/kits/interface/bregion/RegionOffsetBy.cpp new file mode 100644 index 0000000000..d3612f61b2 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionOffsetBy.cpp @@ -0,0 +1,113 @@ +/* + $Id: RegionOffsetBy.cpp,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file implements the OffsetBy test for the OpenBeOS BRegion + code. + + */ + + +#include "RegionOffsetBy.h" +#include +#include + + +/* + * Method: RegionOffsetBy::RegionOffsetBy() + * Descr: This is the constructor for this class. + */ + +RegionOffsetBy::RegionOffsetBy(std::string name) : + RegionTestcase(name) +{ + } + + +/* + * Method: RegionOffsetBy::~RegionOffsetBy() + * Descr: This is the destructor for this class. + */ + +RegionOffsetBy::~RegionOffsetBy() +{ + } + + +/* + * Method: RegionOffsetBy::testOneRegion() + * Descr: This member function performs a test on a single passed in + * region. + */ + +void RegionOffsetBy::testOneRegion(BRegion *testRegion) +{ + BRegion tempRegion1(*testRegion); + CheckFrame(&tempRegion1); + + tempRegion1.OffsetBy(10.0, 20.0); + if (RegionIsEmpty(testRegion)) { + assert(RegionsAreEqual(&tempRegion1, testRegion)); + } else { + assert(!RegionsAreEqual(&tempRegion1, testRegion)); + } + + BRegion tempRegion2; + CheckFrame(&tempRegion2); + assert(RegionIsEmpty(&tempRegion2)); + + for(int i = testRegion->CountRects() - 1; i >= 0; i--) { + BRect tempRect = testRegion->RectAt(i); + tempRect.OffsetBy(10.0, 20.0); + tempRegion2.Include(tempRect); + CheckFrame(&tempRegion2); + assert(!RegionIsEmpty(&tempRegion2)); + } + assert(RegionsAreEqual(&tempRegion1, &tempRegion2)); + if (RegionIsEmpty(testRegion)) { + assert(RegionsAreEqual(&tempRegion2, testRegion)); + } else { + assert(!RegionsAreEqual(&tempRegion2, testRegion)); + } + + tempRegion1.OffsetBy(-10.0, -20.0); + CheckFrame(&tempRegion1); + if (RegionIsEmpty(testRegion)) { + assert(RegionsAreEqual(&tempRegion1, testRegion)); + assert(RegionsAreEqual(&tempRegion1, &tempRegion2)); + } else { + assert(RegionsAreEqual(&tempRegion1, testRegion)); + assert(!RegionsAreEqual(&tempRegion1, &tempRegion2)); + } + + tempRegion2.OffsetBy(-10.0, -20.0); + CheckFrame(&tempRegion2); + assert(RegionsAreEqual(&tempRegion1, testRegion)); + assert(RegionsAreEqual(&tempRegion2, testRegion)); + assert(RegionsAreEqual(&tempRegion1, &tempRegion2)); +} + + +/* + * Method: RegionOffsetBy::testTwoRegions() + * Descr: This member function performs a test on two regions passed in. + */ + +void RegionOffsetBy::testTwoRegions(BRegion *testRegionA, BRegion *testRegionB) +{ + +} + + +/* + * Method: RegionOffsetBy::suite() + * Descr: This static member function returns a test caller for performing + * all combinations of "RegionOffsetBy". + */ + + Test *RegionOffsetBy::suite(void) +{ + typedef CppUnit::TestCaller + RegionOffsetByCaller; + + return(new RegionOffsetByCaller("BRegion::OffsetBy Test", &RegionOffsetBy::PerformTest)); + } diff --git a/src/tests/kits/interface/bregion/RegionOffsetBy.h b/src/tests/kits/interface/bregion/RegionOffsetBy.h new file mode 100644 index 0000000000..e5014aebe5 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionOffsetBy.h @@ -0,0 +1,33 @@ +/* + $Id: RegionOffsetBy.h,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file defines a class for performing one test of BRegion + functionality. + + */ + + +#ifndef RegionOffsetBy_H +#define RegionOffsetBy_H + + +#include "RegionTestcase.h" + + +class RegionOffsetBy : + public RegionTestcase { + +private: + + +protected: + virtual void testOneRegion(BRegion *); + virtual void testTwoRegions(BRegion *, BRegion *); + +public: + static Test *suite(void); + RegionOffsetBy(std::string name = ""); + virtual ~RegionOffsetBy(); + }; + +#endif diff --git a/src/tests/kits/interface/bregion/RegionTest.cpp b/src/tests/kits/interface/bregion/RegionTest.cpp new file mode 100644 index 0000000000..2b3340339f --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionTest.cpp @@ -0,0 +1,26 @@ +#include "../common.h" +#include "RegionConstruction.h" +#include "RegionExclude.h" +#include "RegionInclude.h" +#include "RegionIntersect.h" +#include "RegionOffsetBy.h" + +Test *RegionTestSuite() +{ + TestSuite *testSuite = new TestSuite(); + + testSuite->addTest(RegionConstruction::suite()); + testSuite->addTest(RegionExclude::suite()); + testSuite->addTest(RegionInclude::suite()); + testSuite->addTest(RegionIntersect::suite()); + testSuite->addTest(RegionOffsetBy::suite()); + + return(testSuite); +} + + + + + + + diff --git a/src/tests/kits/interface/bregion/RegionTest.h b/src/tests/kits/interface/bregion/RegionTest.h new file mode 100644 index 0000000000..b820aa1ca0 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionTest.h @@ -0,0 +1,10 @@ +#ifndef _region_test_h_ +#define _region_test_h_ + +class CppUnit::Test; + +CppUnit::Test *RegionTestSuite(); + +#endif // _region_test_h_ + + diff --git a/src/tests/kits/interface/bregion/RegionTestcase.cpp b/src/tests/kits/interface/bregion/RegionTestcase.cpp new file mode 100644 index 0000000000..1608e1b7eb --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionTestcase.cpp @@ -0,0 +1,245 @@ +/* + $Id: RegionTestcase.cpp,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file implements a base class for all tests of the OpenBeOS + BRegion code. + + */ + + +#include "RegionTestcase.h" +#include +#include +#include + + +/* + * Method: RegionTestcase::RegionTestcase() + * Descr: This is the constructor for this class. + */ + +RegionTestcase::RegionTestcase(std::string name) : + TestCase(name) +{ + const int numTestRegions = 5; + const int numRectsPerRegion = 3; + + float theRegions[numTestRegions][numRectsPerRegion][4] = + { + { + {10.0, 10.0, 50.0, 50.0}, + {25.0, 10.0, 75.0, 40.0}, + {70.0, 100.0, 90.0, 120.0} + }, + { + {15.0, 15.0, 45.0, 45.0}, + {30.0, 15.0, 70.0, 35.0}, + {75.0, 105.0, 85.0, 115.0} + }, + { + {15.0, 15.0, 55.0, 55.0}, + {30.0, 15.0, 80.0, 45.0}, + {75.0, 105.0, 95.0, 125.0} + }, + { + {210.0, 210.0, 250.0, 250.0}, + {225.0, 210.0, 275.0, 240.0}, + {270.0, 300.0, 290.0, 320.0} + }, + { + {-50.0, -50.0, -10.0, -10.0}, + {-75.0, -40.0, -25.0, -10.0}, + {-90.0, -120.0, -70.0, -100.0} + } + }; + + listOfRegions.AddItem(new BRegion); + for(int regionNum = 0; regionNum < numTestRegions; regionNum++) { + BRegion *tempRegion = new BRegion; + for(int rectNum = 0; rectNum < numRectsPerRegion; rectNum++) { + tempRegion->Include(BRect(theRegions[regionNum][rectNum][0], + theRegions[regionNum][rectNum][1], + theRegions[regionNum][rectNum][2], + theRegions[regionNum][rectNum][3])); + } + listOfRegions.AddItem(tempRegion); + } +} + + +/* + * Method: RegionTestcase::~RegionTestcase() + * Descr: This is the destructor for this class. + */ + +RegionTestcase::~RegionTestcase() +{ + while(!listOfRegions.IsEmpty()) { + delete static_cast(listOfRegions.RemoveItem((long int)0)); + } +} + + +/* + * Method: RegionTestcase::GetPointsInRect() + * Descr: This member function returns an array of BPoints on the edge and + * inside the passed in BRect. It also returns the number of points + * in the array. + */ + +int RegionTestcase::GetPointsInRect(BRect theRect, BPoint **pointArrayPtr) +{ + *pointArrayPtr = pointArray; + if (!theRect.IsValid()) { + return(0); + } + + float xIncrement = (theRect.Width() + 1.0) / (numPointsPerSide - 1); + float yIncrement = (theRect.Height() + 1.0) / (numPointsPerSide - 1); + + int numPoints = 0; + + for(int i = 0; i < numPointsPerSide; i++) { + float xCoord = theRect.left + (i * xIncrement); + if (i == numPointsPerSide - 1) { + xCoord = theRect.right; + } + for(int j = 0; j < numPointsPerSide; j++) { + float yCoord = theRect.top + (j * yIncrement); + if (j == numPointsPerSide - 1) { + yCoord = theRect.bottom; + } + pointArray[numPoints].Set(floor(xCoord), floor(yCoord)); + assert(theRect.Contains(pointArray[numPoints])); + numPoints++; + } + } + return(numPoints); +} + + +/* + * Method: RegionTestcase::CheckFrame() + * Descr: This member function checks that the BRegion's frame matches + * the regions contents. + */ + +void RegionTestcase::CheckFrame(BRegion *theRegion) +{ + BRect theFrame = theRegion->Frame(); + if (theFrame.IsValid()) { + assert(!RegionIsEmpty(theRegion)); + + BRect testFrame = theRegion->RectAt(0); + assert(theFrame.Contains(testFrame)); + + for(int i = 1; i < theRegion->CountRects(); i++) { + BRect tempRect = theRegion->RectAt(i); + assert(theFrame.Contains(tempRect)); + testFrame = testFrame | tempRect; + } + assert(testFrame == theFrame); + } else { + assert(RegionIsEmpty(theRegion)); + } +} + + +/* + * Method: RegionTestcase::RegionsAreEqual() + * Descr: This member function returns true if the two BRegion's passed + * in are the same, otherwise it returns false. + */ + +bool RegionTestcase::RegionsAreEqual(BRegion *regionA, BRegion *regionB) +{ + bool result = false; + + if (regionA->CountRects() == regionB->CountRects()) { + bool gotAMatch = true; + for(int i = 0; i < regionA->CountRects(); i++) { + gotAMatch = false; + for(int j = 0; j < regionB->CountRects(); j++) { + if (regionA->RectAt(i) == regionB->RectAt(j)) { + gotAMatch = true; + break; + } + } + if (!gotAMatch) { + break; + } + } + if (gotAMatch) { + result = true; + } + } + + if (!result) { + BRegion tempRegion(*regionA); + + tempRegion.Exclude(regionB); + if (RegionIsEmpty(&tempRegion)) { + tempRegion = *regionB; + tempRegion.Exclude(regionA); + if (RegionIsEmpty(&tempRegion)) { + result = true; + } + } + } + + if (result) { + assert(regionA->Frame() == regionB->Frame()); + if (regionA->CountRects() == 0) { + assert(RegionIsEmpty(regionA)); + assert(RegionIsEmpty(regionB)); + } + } + return(result); +} + + +/* + * Method: RegionTestcase::RegionsIsEmpty() + * Descr: This member function returns true if the BRegion passed + * in is an empty region, otherwise it returns false. + */ + +bool RegionTestcase::RegionIsEmpty(BRegion *theRegion) +{ + if (theRegion->CountRects() == 0) { + assert(!theRegion->Frame().IsValid()); + return(true); + } + assert(theRegion->Frame().IsValid()); + return(false); +} + + +/* + * Method: RegionTestcase::PerformTest() + * Descr: This member function iterates over the set of BRegion's for + * testing and calls testOneRegion() for each region. Then it + * calls testTwoRegions() for each pair of regions (including + * when the two regions are the same). + */ + +void RegionTestcase::PerformTest(void) +{ + int numItems = listOfRegions.CountItems(); + + for(int i = 0; i < numItems; i++) { + BRegion *testRegion = static_cast(listOfRegions.ItemAt(i)); + + CheckFrame(testRegion); + testOneRegion(testRegion); + } + for(int i = 0; i < numItems; i++) { + BRegion *testRegionA = static_cast(listOfRegions.ItemAt(i)); + + for(int j = 0; j < numItems; j++) { + BRegion *testRegionB = static_cast(listOfRegions.ItemAt(j)); + + testTwoRegions(testRegionA, testRegionB); + } + } +} diff --git a/src/tests/kits/interface/bregion/RegionTestcase.h b/src/tests/kits/interface/bregion/RegionTestcase.h new file mode 100644 index 0000000000..26661917e3 --- /dev/null +++ b/src/tests/kits/interface/bregion/RegionTestcase.h @@ -0,0 +1,47 @@ +/* + $Id: RegionTestcase.h,v 1.1 2003/08/06 06:46:06 jackburton Exp $ + + This file defines a base class for performing all tests of BRegion + functionality. + + */ + + +#ifndef RegionTestcase_H +#define RegionTestcase_H + + +#include "../common.h" +#include +#include +#include + + +class BRegion; + + +class RegionTestcase : + public TestCase { + +private: + BList listOfRegions; + +#define numPointsPerSide 17 + BPoint pointArray[numPointsPerSide * numPointsPerSide]; + +protected: + int GetPointsInRect(BRect, BPoint **); + void CheckFrame(BRegion *); + bool RegionsAreEqual(BRegion *, BRegion *); + bool RegionIsEmpty(BRegion *); + + virtual void testOneRegion(BRegion *) = 0; + virtual void testTwoRegions(BRegion *, BRegion *) = 0; + +public: + void PerformTest(void); + RegionTestcase(std::string name = ""); + virtual ~RegionTestcase(); + }; + +#endif