/*
        $Id: RegionInclude.cpp 4235 2003-08-06 06:46:06Z jackburton $
        
        This file implements the include test for the Haiku BRegion
        code.
        
        */


#include "RegionInclude.h"
#include <Region.h>
#include <Rect.h>

#include <assert.h>


/*
 *  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<RegionInclude>
                RegionIncludeCaller;
                
        return(new RegionIncludeCaller("BRegion::Include Test", &RegionInclude::PerformTest));
        }