Cool_Tools/ImHex
1
0
Fork 0
mirror of synced 2024-09-24 03:28:24 +02:00
Code Releases Wiki Activity

tests: Added bitfield test

Browse Source
This commit is contained in:
WerWolv 2021-09-12 20:28:32 +02:00
parent 82cc528c49
commit bed5361879
10 changed files with 69 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
tests/CMakeLists.txt
View File

@ -13,6 +13,7 @@ set(AVAILABLE_TESTS
Padding
SucceedingAssert
FailingAssert
Bitfields
)

4
tests/include/test_patterns/test_pattern.hpp
View File

@ -28,8 +28,8 @@ namespace hex::test {
}
template<typename T>
static T* create(u64 offset, size_t size, const std::string &typeName, const std::string &varName) {
auto pattern = new T(offset, size);
static T* create(const std::string &typeName, const std::string &varName, auto ... args) {
auto pattern = new T(args...);
pattern->setTypeName(typeName);
pattern->setVariableName(varName);

44
tests/include/test_patterns/test_pattern_bitfields.hpp Normal file
View File

@ -0,0 +1,44 @@
#pragma once
#include "test_pattern.hpp"
namespace hex::test {
class TestPatternBitfields : public TestPattern {
public:
TestPatternBitfields() : TestPattern("Bitfields") {
auto testBitfield = create<PatternDataBitfield>("TestBitfield", "testBitfield", 0x12, (4 * 4) / 8);
testBitfield->setEndian(std::endian::big);
testBitfield->setFields({
create<PatternDataBitfieldField>("", "a", 0x12, 0, 4),
create<PatternDataBitfieldField>("", "b", 0x12, 4, 4),
create<PatternDataBitfieldField>("", "c", 0x12, 8, 4),
create<PatternDataBitfieldField>("", "d", 0x12, 12, 4)
});
addPattern(testBitfield);
}
~TestPatternBitfields() override = default;
[[nodiscard]]
std::string getSourceCode() const override {
return R"(
bitfield TestBitfield {
a : 4;
b : 4;
c : 4;
d : 4;
};
be TestBitfield testBitfield @ 0x12;
std::assert(testBitfield.a == 0x0A, "Field A invalid");
std::assert(testBitfield.b == 0x00, "Field B invalid");
std::assert(testBitfield.c == 0x04, "Field C invalid");
std::assert(testBitfield.d == 0x03, "Field D invalid");
)";
}
};
}

2
tests/include/test_patterns/test_pattern_enums.hpp
View File

@ -7,7 +7,7 @@ namespace hex::test {
class TestPatternEnums : public TestPattern {
public:
TestPatternEnums() : TestPattern("Enums"){
auto testEnum = create<PatternDataEnum>(0x120, sizeof(u32), "TestEnum", "testEnum");
auto testEnum = create<PatternDataEnum>("TestEnum", "testEnum", 0x120, sizeof(u32));
testEnum->setEnumValues({
{ s32(0x0000), "A" },
{ s32(0x1234), "B" },

10
tests/include/test_patterns/test_pattern_padding.hpp
View File

@ -7,12 +7,12 @@ namespace hex::test {
class TestPatternPadding : public TestPattern {
public:
TestPatternPadding() : TestPattern("Padding") {
auto testStruct = create<PatternDataStruct>(0x100, sizeof(s32) + 20 + sizeof(u8[0x10]), "TestStruct", "testStruct");
auto testStruct = create<PatternDataStruct>("TestStruct", "testStruct", 0x100, sizeof(s32) + 20 + sizeof(u8[0x10]));
auto variable = create<PatternDataSigned>(0x100, sizeof(s32), "s32", "variable");
auto padding = create<PatternDataPadding>(0x100 + sizeof(s32), 20, "", "");
auto array = create<PatternDataStaticArray>(0x100 + sizeof(s32) + 20, sizeof(u8[0x10]), "u8", "array");
array->setEntries(create<PatternDataUnsigned>(0x100 + sizeof(s32) + 20, sizeof(u8), "u8", ""), 0x10);
auto variable = create<PatternDataSigned>("s32", "variable", 0x100, sizeof(s32));
auto padding = create<PatternDataPadding>("", "", 0x100 + sizeof(s32), 20);
auto array = create<PatternDataStaticArray>("u8", "array", 0x100 + sizeof(s32) + 20, sizeof(u8[0x10]));
array->setEntries(create<PatternDataUnsigned>("u8", "", 0x100 + sizeof(s32) + 20, sizeof(u8)), 0x10);
testStruct->setMembers({ variable, padding, array });

6
tests/include/test_patterns/test_pattern_placement.hpp
View File

@ -9,13 +9,13 @@ namespace hex::test {
TestPatternPlacement() : TestPattern("Placement") {
// placementVar
{
addPattern(create<PatternDataUnsigned>(0x00, sizeof(u32), "u32", "placementVar"));
addPattern(create<PatternDataUnsigned>("u32", "placementVar", 0x00, sizeof(u32)));
}
// placementArray
{
auto placementArray = create<PatternDataStaticArray>(0x10, sizeof(u8) * 10, "u8", "placementArray");
placementArray->setEntries(create<PatternDataUnsigned>(0x10, sizeof(u8), "u8", ""), 10);
auto placementArray = create<PatternDataStaticArray>("u8", "placementArray", 0x10, sizeof(u8) * 10);
placementArray->setEntries(create<PatternDataUnsigned>("u8", "", 0x10, sizeof(u8)), 10);
addPattern(placementArray);
}

8
tests/include/test_patterns/test_pattern_structs.hpp
View File

@ -7,11 +7,11 @@ namespace hex::test {
class TestPatternStructs : public TestPattern {
public:
TestPatternStructs() : TestPattern("Structs") {
auto testStruct = create<PatternDataStruct>(0x100, sizeof(s32) + sizeof(u8[0x10]), "TestStruct", "testStruct");
auto testStruct = create<PatternDataStruct>("TestStruct", "testStruct", 0x100, sizeof(s32) + sizeof(u8[0x10]));
auto variable = create<PatternDataSigned>(0x100, sizeof(s32), "s32", "variable");
auto array = create<PatternDataStaticArray>(0x100 + sizeof(s32), sizeof(u8[0x10]), "u8", "array");
array->setEntries(create<PatternDataUnsigned>(0x100 + sizeof(s32), sizeof(u8), "u8", ""), 0x10);
auto variable = create<PatternDataSigned>("s32", "variable", 0x100, sizeof(s32));
auto array = create<PatternDataStaticArray>("u8", "array", 0x100 + sizeof(s32), sizeof(u8[0x10]));
array->setEntries(create<PatternDataUnsigned>("u8", "", 0x100 + sizeof(s32), sizeof(u8)), 0x10);
testStruct->setMembers({ variable, array });

8
tests/include/test_patterns/test_pattern_unions.hpp
View File

@ -7,11 +7,11 @@ namespace hex::test {
class TestPatternUnions : public TestPattern {
public:
TestPatternUnions() : TestPattern("Unions") {
auto testUnion = create<PatternDataUnion>(0x200, sizeof(u128), "TestUnion", "testUnion");
auto testUnion = create<PatternDataUnion>("TestUnion", "testUnion", 0x200, sizeof(u128));
auto array = create<PatternDataStaticArray>(0x200, sizeof(s32[2]), "s32", "array");
array->setEntries(create<PatternDataSigned>(0x200, sizeof(s32), "s32", ""), 2);
auto variable = create<PatternDataUnsigned>(0x200, sizeof(u128), "u128", "variable");
auto array = create<PatternDataStaticArray>("s32", "array", 0x200, sizeof(s32[2]));
array->setEntries(create<PatternDataSigned>("s32", "", 0x200, sizeof(s32)), 2);
auto variable = create<PatternDataUnsigned>("u128", "variable", 0x200, sizeof(u128));
testUnion->setMembers({ array, variable });

5
tests/include/test_provider.hpp
View File

@ -9,9 +9,8 @@ namespace hex::test {
class TestProvider : public prv::Provider {
public:
TestProvider() : Provider() {
this->m_testFile = File("test_data", File::Mode::Read);
if (!this->m_testFile.isValid()) {
TestProvider() : Provider(), m_testFile(File("test_data", File::Mode::Read)) {
if (!this->m_testFile.isValid() || this->m_testFile.getSize() == 0) {
hex::log::fatal("Failed to open test data!");
throw std::runtime_error("");
}

4
tests/source/tests.cpp
View File

@ -8,6 +8,7 @@
#include "test_patterns/test_pattern_padding.hpp"
#include "test_patterns/test_pattern_succeeding_assert.hpp"
#include "test_patterns/test_pattern_failing_assert.hpp"
#include "test_patterns/test_pattern_bitfields.hpp"
std::array Tests = {
TEST(Placement),
@ -17,5 +18,6 @@ std::array Tests = {
TEST(Literals),
TEST(Padding),
TEST(SucceedingAssert),
TEST(FailingAssert)
TEST(FailingAssert),
TEST(Bitfields)
};