better PositionTest

Author: ItchyTrack

src/backend/position/position.h

@@ -78,6 +78,20 @@ class Vector::Iterator {
 		yNeg = 1 - 2 * (vector.dy < 0);
 		end = (yNeg * vector.dy + 1) * width - 1;
 	}
+	inline bool operator==(const Iterator& other) const {
+		return (
+			xNeg == other.xNeg && yNeg == other.yNeg &&
+			end == other.end && cur == other.cur &&
+			width == other.width && notDone == other.notDone
+		);
+	}
+	inline bool operator!=(const Iterator& other) const {
+		return (
+			xNeg != other.xNeg || yNeg != other.yNeg ||
+			end != other.end || cur != other.cur ||
+			width != other.width || notDone != other.notDone
+		);
+	}
 	inline Iterator& operator++() {
 		next();
 		return *this;
@@ -106,8 +120,8 @@ class Vector::Iterator {
 		cur += notDone;
 	}
 	inline void prev() {
+		cur -= notDone && (cur != 0);
 		notDone = true;
-		cur -= cur != 0;
 	}
 	std::uint8_t xNeg;
 	std::uint8_t yNeg;
@@ -254,6 +268,18 @@ class Position::Iterator {
 			this->start.y = start.y;
 		}
 	}
+	inline bool operator==(const Iterator& other) const {
+		return (
+			end == other.end && cur == other.cur &&
+			width == other.width && notDone == other.notDone
+		);
+	}
+	inline bool operator!=(const Iterator& other) const {
+		return (
+			end != other.end || cur != other.cur ||
+			width != other.width || notDone != other.notDone
+		);
+	}
 	inline Iterator& operator++() noexcept {
 		next();
 		return *this;
@@ -282,7 +308,7 @@ class Position::Iterator {
 		cur += notDone;
 	}
 	inline void prev() {
-		cur -= notDone && cur != 0;
+		cur -= notDone && (cur != 0);
 		notDone = true;
 	}
 	Position start;
@@ -436,6 +462,18 @@ class Size::Iterator {
 		width = size.w;
 		end = size.area() - 1;
 	}
+	inline bool operator==(const Iterator& other) const {
+		return (
+			end == other.end && cur == other.cur &&
+			width == other.width && notDone == other.notDone
+		);
+	}
+	inline bool operator!=(const Iterator& other) const {
+		return (
+			end != other.end || cur != other.cur ||
+			width != other.width || notDone != other.notDone
+		);
+	}
 	inline Iterator& operator++() {
 		next();
 		return *this;
@@ -466,13 +504,12 @@ class Size::Iterator {
 	// inline Vector operator->() const { return *(*this); }
 
 private:
-
 	inline void next() {
 		notDone = cur != end;
 		cur += notDone;
 	}
 	inline void prev() {
-		cur -= cur != 0;
+		cur -= notDone && (cur != 0);
 		notDone = (bool)end;
 	}
 	unsigned int end;

tests/circuitTest.cpp

@@ -1,9 +1,6 @@
 #include "circuitTest.h"
 
-Position randPos() {
-	return Position(rand() % 100000, rand() % 100000);
-}
-
+#include "randomGens.h"
 const int loopsPerTest = 100; // upped
 
 void CircuitTest::SetUp() {

tests/positionTest.cpp

@@ -1,11 +1,6 @@
 #include "positionTest.h"
-#include "util/uuid.h"
 
-void PositionTest::SetUp() { }
-
-void PositionTest::TearDown() {
-
-}
+#include "randomGens.h"
 
 TEST_F(PositionTest, VectorBasicOperations) {
 	Vector a(5, 5);
@@ -162,3 +157,164 @@ TEST_F(PositionTest, FPositionComparisons) {
 	ASSERT_TRUE(a2 == FPosition(3.2, 6.1));
 	ASSERT_TRUE(a * 3.1 == FPosition(19.84, 28.52));
 }
+
+TEST_F(PositionTest, ZeroConstructor) {
+	Position zeroPos;
+	ASSERT_EQ(zeroPos.x, 0);
+	ASSERT_EQ(zeroPos.y, 0);
+
+	FPosition zeroFPos;
+	ASSERT_EQ(zeroFPos.x, 0);
+	ASSERT_EQ(zeroFPos.y, 0);
+	ASSERT_TRUE(zeroFPos.isValid());
+
+	Vector zeroVec;
+	ASSERT_EQ(zeroVec.dx, 0);
+	ASSERT_EQ(zeroVec.dy, 0);
+
+	FVector zeroFVec;
+	ASSERT_EQ(zeroFVec.dx, 0);
+	ASSERT_EQ(zeroFVec.dy, 0);
+
+	Size zeroSize;
+	ASSERT_EQ(zeroSize.w, 0);
+	ASSERT_EQ(zeroSize.h, 0);
+
+	FSize zeroFSize;
+	ASSERT_EQ(zeroFSize.w, 0);
+	ASSERT_EQ(zeroFSize.h, 0);
+	ASSERT_TRUE(zeroFSize.isValid());
+
+	Orientation zeroOrientation;
+	ASSERT_EQ(zeroOrientation.rotation, Rotation::ZERO);
+	ASSERT_EQ(zeroOrientation.flipped, false);
+}
+
+TEST_F(PositionTest, FPositionInvalid) {
+	FPosition zeroVec = FPosition::getInvalid();
+	ASSERT_TRUE(zeroVec.isInvalid());
+	ASSERT_FALSE(zeroVec.isValid());
+	zeroVec = FPosition(1, 2);
+	ASSERT_EQ(zeroVec.x, 1);
+	ASSERT_EQ(zeroVec.y, 2);
+	ASSERT_FALSE(zeroVec.isInvalid());
+	ASSERT_TRUE(zeroVec.isValid());
+	zeroVec.setInvalid();
+	ASSERT_TRUE(zeroVec.isInvalid());
+	ASSERT_FALSE(zeroVec.isValid());
+	zeroVec.x = 0;
+	ASSERT_TRUE(zeroVec.isInvalid());
+	ASSERT_FALSE(zeroVec.isValid());
+	zeroVec.y = 0;
+	ASSERT_EQ(zeroVec.x, 0);
+	ASSERT_EQ(zeroVec.y, 0);
+	ASSERT_FALSE(zeroVec.isInvalid());
+	ASSERT_TRUE(zeroVec.isValid());
+	zeroVec.setInvalid();
+	ASSERT_TRUE(zeroVec.isInvalid());
+	ASSERT_FALSE(zeroVec.isValid());
+	zeroVec.y = 0;
+	ASSERT_TRUE(zeroVec.isInvalid());
+	ASSERT_FALSE(zeroVec.isValid());
+}
+
+TEST_F(PositionTest, toString) {
+	Position pos;
+	ASSERT_EQ(pos.toString(), "(0, 0)");
+	pos.x = 10;
+	ASSERT_EQ(pos.toString(), "(10, 0)");
+	pos.y = -51;
+	ASSERT_EQ(pos.toString(), "(10, -51)");
+	pos.x = -1161231;
+	ASSERT_EQ(pos.toString(), "(-1161231, -51)");
+
+	Vector vec;
+	ASSERT_EQ(vec.toString(), "<0, 0>");
+	vec.dx = 10;
+	ASSERT_EQ(vec.toString(), "<10, 0>");
+	vec.dy = -51;
+	ASSERT_EQ(vec.toString(), "<10, -51>");
+	vec.dx = -1161231;
+	ASSERT_EQ(vec.toString(), "<-1161231, -51>");
+
+	Size size;
+	ASSERT_EQ(size.toString(), "0x0");
+	size.w = 10;
+	ASSERT_EQ(size.toString(), "10x0");
+	size.h = 14371;
+	ASSERT_EQ(size.toString(), "10x14371");
+	size.h = -51;
+	ASSERT_EQ(size.toString(), "10x-51");
+	size.w = -1161231;
+	ASSERT_EQ(size.toString(), "-1161231x-51");
+
+	Orientation orientation;
+
+	ASSERT_EQ(orientation.toString(), "(r:0, f:0)");
+}
+
+TEST_F(PositionTest, vectorIter) {
+	for (unsigned int i = 0; i < 50; i++) {
+		Vector v = randVec();
+		v.dx %= 1000; // takes too long otherwise
+		v.dy %= 1000;
+
+		unsigned long long area = 0;
+		for (Vector::Iterator iter = v.iter(); iter; iter++) {
+			Vector::Iterator curIter = iter;
+			Vector::Iterator nextIter = (++iter)--;
+			ASSERT_EQ(iter++, curIter);
+			ASSERT_EQ(iter--, nextIter);
+			ASSERT_EQ(++iter, nextIter);
+			ASSERT_EQ(--iter, curIter);
+			area++;
+		}
+		ASSERT_EQ(area, (v.dx+1)*(v.dy+1));
+	}
+}
+
+TEST_F(PositionTest, sizeIter) {
+	for (unsigned int i = 0; i < 50; i++) {
+		Size s = randSize();
+		s.w = abs(s.w) % 1000 + 1; // takes too long otherwise, move than 1 w&h
+		s.h = abs(s.h) % 1000 + 1;
+		ASSERT_TRUE(s.isValid());
+
+		unsigned long long area = 0;
+		for (Size::Iterator iter = s.iter(); iter; iter++) {
+			Size::Iterator curIter = iter;
+			Size::Iterator nextIter = (++iter)--;
+			ASSERT_EQ(iter++, curIter);
+			ASSERT_EQ(iter--, nextIter);
+			ASSERT_EQ(++iter, nextIter);
+			ASSERT_EQ(--iter, curIter);
+			area++;
+		}
+		ASSERT_EQ(area, s.w*s.h);
+		ASSERT_EQ(area, s.area());
+	}
+}
+
+TEST_F(PositionTest, positionIter) {
+	for (unsigned int i = 0; i < 50; i++) {
+		Position p1 = randPos();
+		Position p2 = randPos();
+		p1.x %= 1000; // takes too long otherwise
+		p1.y %= 1000; // takes too long otherwise
+		p2.x %= 1000; // takes too long otherwise
+		p2.y %= 1000; // takes too long otherwise
+
+		unsigned long long area = 0;
+		// ASSERT_EQ(*(p1.iterTo(p2)), p1); // not guaranteed. Should it be?
+		for (Position::Iterator iter = p1.iterTo(p2); iter; iter++) {
+			Position::Iterator curIter = iter;
+			Position::Iterator nextIter = (++iter)--;
+			ASSERT_EQ(iter++, curIter);
+			ASSERT_EQ(iter--, nextIter);
+			ASSERT_EQ(++iter, nextIter);
+			ASSERT_EQ(--iter, curIter);
+			area++;
+		}
+		ASSERT_EQ(area, (abs(p1.x - p2.x)+1) * (abs(p1.y - p2.y)+1));
+	}
+}

tests/positionTest.h

@@ -2,12 +2,7 @@
 #define positionTests_h
 
 #include <gtest/gtest.h>
-#include "backend/position/position.h"
 
-class PositionTest : public ::testing::Test {
-protected:
-	void SetUp() override;
-	void TearDown() override;
-};
+class PositionTest : public ::testing::Test {};
 
 #endif /* PositionTests_h */

tests/randomGens.cpp

@@ -0,0 +1,5 @@
+#include "randomGens.h"
+
+Position randPos() { return Position(rand() % 100000, rand() % 100000); }
+Vector randVec() { return Vector(rand() % 100000, rand() % 100000); }
+Size randSize() { return Size(rand() % 100000, rand() % 100000); }

tests/randomGens.h

@@ -0,0 +1,5 @@
+#include "backend/position/position.h"
+
+Position randPos();
+Vector randVec();
+Size randSize();