Task 1: AARectangles main.cpp

/*
    File: main.cpp

    Task: Task 1: Axis Aligned Rectangles

    Author: *REDACTED*

    Created: *REDACTED*

    Desc: File containing the main function implementing a solution to task 1 of the assessment
        dealing with Axis Aligned Rectangles. Also contains unit testing for the task
*/


#include <iostream>
#include <conio.h>
#include <assert.h>
#include "AA_Rectangle.h"

#define RUN_UNIT_TESTS 1

using namespace std;

void RunUnitTests()
{
    cout << "Running Unit tests...\n" << endl;

    /* Testing Points in Rectangle */

    // Create a AA_Rectangle at the origin with size 5, 6
    AA_Rectangle * testRectangle = new AA_Rectangle(NULL, 5.0f, 6.0f);

    // Create a test point inside the rectangle
    Point2D * insideTestPoint = new Point2D(1.0f, 1.0f);

    // Create a test point outside the rectangle
    Point2D * outsideTestPoint = new Point2D(7.0f, -3.0f);

    assert(testRectangle->isPointInRectangle(insideTestPoint));

    assert(!(testRectangle->isPointInRectangle(outsideTestPoint)));

    /* Testing AA_Rectangle intersections */

    // Create an AA_Rectangle that does not intersect with testRectangle
    AA_Rectangle * outsideTest = new AA_Rectangle(7.0f, 7.0f, 2.0f, 3.0f);

    // Create an AA_Rectangle that does intersect
    AA_Rectangle * insideTest = new AA_Rectangle(1.0f, 1.0f, 5.0f, 6.0f);

    cout << "Result of outside test: " << testRectangle->isRectangleIntersecting(outsideTest) << endl;

    cout << "Result of inside test: " << testRectangle->isRectangleIntersecting(insideTest) << endl;

    assert(!(testRectangle->isRectangleIntersecting(outsideTest)));

    assert(testRectangle->isRectangleIntersecting(insideTest));

    // Cleanup
    delete testRectangle;
    delete outsideTest;
    delete insideTest;
    delete outsideTestPoint;
    delete insideTestPoint;

    cout << "Unit Testing complete!" << endl;
}

int main()
{
    cout << "Task 1: Axis Aligned Rectangles\n" << endl;

    // Basic point test
    Point2D * origin1 = new Point2D();
    Point2D * testPoint = new Point2D(1.0f, 1.0f);
    AA_Rectangle * test1 = new AA_Rectangle(origin1, 5.0f, 5.0f);

    if (test1->isPointInRectangle(testPoint))
    {
        cout << "Test point is in rectangle\n\n";
    }
    else
    {
        cout << "Test point is not in rectangle\n\n";
    }

    // Run some unit tests (guarded by a macro) to check the AA_Rectangle class provides expected behavior
#if RUN_UNIT_TESTS
    RunUnitTests();
#endif

    // Cleanup
    delete origin1;
    delete testPoint;
    delete test1;

    // Dirty getch to see terminal output before termination
    _getch();

    return 0;
}

/* NB:
Things that can be done to improve this solution:

- Move floating point comparisons to use epsilons instead of straight comparisons, e.g. refPoint->x - mBottomLeft->x > epsilon
allowing for better control over floating point accuracy.

- Rework AA_Rectangle class to better adhere to data encapsulation (right now its all public!).
Decided to keep this simple since there is little context as to this classes overall usage. Saves having to write and test accessors.

- Could potentially extend the Point2D class to better deal with point vs point comparisons.
Instead of explicitly having to test the x, y values when comparing points, could possibly offload that to the Point2D class in the form of a public method.

- Better asserts and logging. Again, kept things simple for this task, but I am usually weary of using simple assert().
Would be ideal to use something that writes to the output log. Thought writing a logger class just for this task might be a bit overkill.

- Improve Rectangle intersection checks to return point of intersection if applicable.
Would require a rework of the algorithm being used right now. Kept things simple so as to address only what was asked in the task.
*/