UnitTests: Add tests for BitField.

1 files changed, 127 insertions, 0 deletions

diff --git a/Source/UnitTests/Common/BitFieldTest.cpp b/Source/UnitTests/Common/BitFieldTest.cpp
new file mode 100644
index 0000000000..16efd29d19
--- /dev/null
+++ b/Source/UnitTests/Common/BitFieldTest.cpp
@@ -0,0 +1,127 @@
+// Copyright 2014 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include <gtest/gtest.h>
+
+#include "Common/BitField.h"
+#include "Common/CommonTypes.h"
+
+union TestUnion
+{
+	u64 hex;
+
+	BitField< 0,64,u64> full_u64;   // spans whole storage
+	BitField< 0,64,s64> full_s64;   // spans whole storage
+
+	BitField< 9, 3,u64> regular_field_unsigned;  // a plain bitfield
+	BitField< 9, 3,u64> regular_field_unsigned2; // Just the very same bitfield again
+	BitField< 9, 3,s64> regular_field_signed;    // Same bitfield, but different sign
+
+	BitField<30, 4,s64> at_dword_boundary;  // goes over the boundary of two u32 values
+
+	BitField<15, 1,s64> signed_1bit;  // allowed values: -1 and 0
+};
+
+// table of raw numbers to test with
+u64 table[] =
+{
+	0x0000000000000000ull, // all zero
+	0xffffffffffffffffull, // all one
+	0x7fffffffffffffffull, // all one apart from the sign bit
+	0x8000000000000000ull, // all zero apart from the sign bit
+	0x8000000000000048ull, // regular_field = 0b1001
+
+	// "random" numbers
+	0x0F7B8B1ABD9B8D3Full,
+	0xA8B86F73FDAADD2Dull,
+	0x1B17A557BFEB351Dull,
+	0xE3354268B0C2395Bull,
+};
+
+// Verify that bitfields in a union have the same underlying data
+TEST(BitField, Storage)
+{
+	TestUnion object;
+
+	EXPECT_EQ((void*)&object.hex, (void*)&object.regular_field_unsigned);
+	EXPECT_EQ(sizeof(TestUnion), sizeof(object.hex));
+	EXPECT_EQ(sizeof(TestUnion), sizeof(object.full_u64));
+	EXPECT_EQ(sizeof(TestUnion), sizeof(object.full_s64));
+	EXPECT_EQ(sizeof(TestUnion), sizeof(object.regular_field_unsigned));
+	EXPECT_EQ(sizeof(TestUnion), sizeof(object.regular_field_signed));
+	EXPECT_EQ(sizeof(TestUnion), sizeof(object.at_dword_boundary));
+	EXPECT_EQ(sizeof(TestUnion), sizeof(object.signed_1bit));
+
+	// Now write some values to one field and check if this reflects properly
+	// in the others.
+	for (u64 val : table)
+	{
+		object.hex = val;
+		EXPECT_EQ(object.hex, object.full_u64);
+		EXPECT_EQ(object.regular_field_unsigned, object.regular_field_unsigned2);
+
+		object.regular_field_unsigned = val & 0x3;
+		EXPECT_EQ(object.hex, object.full_u64);
+		EXPECT_EQ(object.regular_field_unsigned, object.regular_field_unsigned2);
+	}
+}
+
+TEST(BitField, Read)
+{
+	TestUnion object;
+
+	for (u64 val : table)
+	{
+		object.hex = val;
+
+		// Make sure reading/casting does not behave completely idiotic
+		EXPECT_EQ(object.full_u64, (u64)object.full_u64);
+		EXPECT_EQ(object.full_s64, (s64)object.full_s64);
+		EXPECT_EQ(object.regular_field_unsigned, (u64)object.regular_field_unsigned);
+		EXPECT_EQ(object.regular_field_unsigned2, (u64)object.regular_field_unsigned2);
+		EXPECT_EQ(object.regular_field_signed, (s64)object.regular_field_signed);
+		EXPECT_EQ(object.at_dword_boundary, (s64)object.at_dword_boundary);
+		EXPECT_EQ(object.signed_1bit, (s64)object.signed_1bit);
+
+		// Now make sure the value is indeed correct
+		EXPECT_EQ(val, object.full_u64);
+		EXPECT_EQ(*(s64*)&val, object.full_s64);
+		EXPECT_EQ((val >> 9) & 0x7, object.regular_field_unsigned);
+		EXPECT_EQ((val >> 9) & 0x7, object.regular_field_unsigned2);
+		EXPECT_EQ(((s64)(object.hex << 52)) >> 61, object.regular_field_signed);
+		EXPECT_EQ(((s64)(object.hex << 30)) >> 60, object.at_dword_boundary);
+		EXPECT_EQ(((object.hex >> 15) & 1) ? -1 : 0, object.signed_1bit);
+	}
+}
+
+TEST(BitField, Assignment)
+{
+	TestUnion object;
+
+	for (u64 val : table)
+	{
+		// Assignments with fixed values
+		object.full_u64 = val;
+		EXPECT_EQ(val, object.full_u64);
+
+		object.full_s64 = (s64)val;
+		EXPECT_EQ((s64)val, object.full_u64);
+
+		object.regular_field_unsigned = val;
+		EXPECT_EQ(val & 0x7, object.regular_field_unsigned);
+
+		object.at_dword_boundary = val;
+		EXPECT_EQ(((s64)(val << 60)) >> 60, object.at_dword_boundary);
+
+		object.signed_1bit = val;
+		EXPECT_EQ((val & 1) ? -1 : 0, object.signed_1bit);
+
+		object.regular_field_signed = val;
+		EXPECT_EQ(((s64)(object.hex << 61)) >> 61, object.regular_field_signed);
+
+		// Assignment from other BitField
+		object.at_dword_boundary = object.regular_field_unsigned;
+		EXPECT_EQ(object.regular_field_unsigned, object.at_dword_boundary);
+	}
+}