From 948c0a54f14085b1edb76afe39ee985424ea4474 Mon Sep 17 00:00:00 2001 From: Tony Wasserka Date: Tue, 11 Mar 2014 00:43:29 +0100 Subject: [PATCH] UnitTests: Add tests for BitField. --- Source/UnitTests/Common/BitFieldTest.cpp | 127 +++++++++++++++++++++++ Source/UnitTests/Common/CMakeLists.txt | 1 + 2 files changed, 128 insertions(+) create mode 100644 Source/UnitTests/Common/BitFieldTest.cpp 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 + +#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); + } +} diff --git a/Source/UnitTests/Common/CMakeLists.txt b/Source/UnitTests/Common/CMakeLists.txt index 80d4943c2e..78f9938e1c 100644 --- a/Source/UnitTests/Common/CMakeLists.txt +++ b/Source/UnitTests/Common/CMakeLists.txt @@ -1,3 +1,4 @@ +add_dolphin_test(BitFieldTest BitFieldTest.cpp common) add_dolphin_test(CommonFuncsTest CommonFuncsTest.cpp common) add_dolphin_test(FifoQueueTest FifoQueueTest.cpp common) add_dolphin_test(FixedSizeQueueTest FixedSizeQueueTest.cpp common)