Create a new version of paste:

/*
	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.
*/