RetroAchievements/RAIntegration
1
0
Fork 0
mirror of https://github.com/RetroAchievements/RAIntegration.git synced 2026-10-12 02:09:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
RAIntegration/tests/RA_MemValue_Tests.cpp
T

305 lines
14 KiB
C++
Raw Permalink Blame History

#include "RA_MemValue.h"
#include "RA_UnitTestHelpers.h"
using namespace Microsoft::VisualStudio::CppUnitTestFramework;
namespace ra {
namespace data {
namespace tests {
class MemValueHarness : public MemValue
{
public:
size_t NumValues() const { return m_vClauses.size(); }
const Clause& GetMemValue(size_t index) const { return m_vClauses[index]; }
bool IsAddition(size_t index) const { return m_vClauses[index].GetOperation() == ClauseOperation::Addition; }
bool IsMaximum(size_t index) const { return m_vClauses[index].GetOperation() == ClauseOperation::Maximum; }
class ClauseHarness : public Clause
{
public:
ClauseHarness() : Clause(ClauseOperation::None) {}
unsigned int GetAddress() const { return m_nAddress; }
MemSize GetVarSize() const { return m_nVarSize; }
double GetModifier() const { return m_fModifier; }
bool GetBcdParse() const { return m_bBCDParse; }
bool GetParseVal() const { return m_bParseVal; }
bool GetInvertBit() const { return m_bInvertBit; }
unsigned int GetSecondAddress() const { return m_nSecondAddress; }
MemSize GetSecondVarSize() const { return m_nSecondVarSize; }
};
};
TEST_CLASS(RA_MemValue_Tests)
{
void AssertParseFromString(const char* sSerialized, MemSize nExpectedVarSize, unsigned int nExpectedAddress, bool bExpectedBcdParse = false, bool bExpectedParseVal = false)
{
std::wstring wsSerialized = Widen(sSerialized);
MemValueHarness::ClauseHarness value;
Assert::AreEqual("", value.ParseFromString(sSerialized));
Assert::AreEqual(nExpectedVarSize, value.GetVarSize(), wsSerialized.c_str());
Assert::AreEqual(nExpectedAddress, value.GetAddress(), wsSerialized.c_str());
Assert::AreEqual(bExpectedBcdParse, value.GetBcdParse(), wsSerialized.c_str());
Assert::AreEqual(bExpectedParseVal, value.GetParseVal(), wsSerialized.c_str());
Assert::AreEqual(false, value.GetInvertBit(), wsSerialized.c_str());
Assert::AreEqual(1.0, value.GetModifier(), wsSerialized.c_str());
Assert::AreEqual(0U, value.GetSecondAddress(), wsSerialized.c_str());
Assert::AreEqual(MemSize::EightBit, value.GetSecondVarSize(), wsSerialized.c_str());
}
void AssertParseFromString(const char* sSerialized, MemSize nExpectedVarSize, unsigned int nExpectedAddress, double fExpectedModifier)
{
std::wstring wsSerialized = Widen(sSerialized);
MemValueHarness::ClauseHarness value;
Assert::AreEqual("", value.ParseFromString(sSerialized));
Assert::AreEqual(nExpectedVarSize, value.GetVarSize(), wsSerialized.c_str());
Assert::AreEqual(nExpectedAddress, value.GetAddress(), wsSerialized.c_str());
Assert::AreEqual(false, value.GetBcdParse(), wsSerialized.c_str());
Assert::AreEqual(false, value.GetParseVal(), wsSerialized.c_str());
Assert::AreEqual(false, value.GetInvertBit(), wsSerialized.c_str());
Assert::AreEqual(fExpectedModifier, value.GetModifier(), wsSerialized.c_str());
Assert::AreEqual(0U, value.GetSecondAddress(), wsSerialized.c_str());
Assert::AreEqual(MemSize::EightBit, value.GetSecondVarSize(), wsSerialized.c_str());
}
void AssertParseFromString(const char* sSerialized, MemSize nExpectedVarSize, unsigned int nExpectedAddress, MemSize nExpectedSecondVarSize, unsigned int nExpectedSecondAddress)
{
std::wstring wsSerialized = Widen(sSerialized);
MemValueHarness::ClauseHarness value;
Assert::AreEqual("", value.ParseFromString(sSerialized));
Assert::AreEqual(nExpectedVarSize, value.GetVarSize(), wsSerialized.c_str());
Assert::AreEqual(nExpectedAddress, value.GetAddress(), wsSerialized.c_str());
Assert::AreEqual(false, value.GetBcdParse(), wsSerialized.c_str());
Assert::AreEqual(false, value.GetParseVal(), wsSerialized.c_str());
Assert::AreEqual(false, value.GetInvertBit(), wsSerialized.c_str());
Assert::AreEqual(1.0, value.GetModifier(), wsSerialized.c_str());
Assert::AreEqual(nExpectedSecondAddress, value.GetSecondAddress(), wsSerialized.c_str());
Assert::AreEqual(nExpectedSecondVarSize, value.GetSecondVarSize(), wsSerialized.c_str());
}
void AssertGetValue(const char* sSerialized, double dExpectedValue)
{
std::wstring wsSerialized = Widen(sSerialized);
MemValueHarness::ClauseHarness value;
Assert::AreEqual("", value.ParseFromString(sSerialized));
Assert::AreEqual(dExpectedValue, value.GetValue(), wsSerialized.c_str());
}
public:
TEST_METHOD(TestClauseParseFromString)
{
// sizes
AssertParseFromString("0xH1234", MemSize::EightBit, 0x1234U);
AssertParseFromString("0x 1234", MemSize::SixteenBit, 0x1234U);
AssertParseFromString("0x1234", MemSize::SixteenBit, 0x1234U);
AssertParseFromString("0xX1234", MemSize::ThirtyTwoBit, 0x1234U);
AssertParseFromString("0xL1234", MemSize::Nibble_Lower, 0x1234U);
AssertParseFromString("0xU1234", MemSize::Nibble_Upper, 0x1234U);
AssertParseFromString("0xM1234", MemSize::Bit_0, 0x1234U);
AssertParseFromString("0xN1234", MemSize::Bit_1, 0x1234U);
AssertParseFromString("0xO1234", MemSize::Bit_2, 0x1234U);
AssertParseFromString("0xP1234", MemSize::Bit_3, 0x1234U);
AssertParseFromString("0xQ1234", MemSize::Bit_4, 0x1234U);
AssertParseFromString("0xR1234", MemSize::Bit_5, 0x1234U);
AssertParseFromString("0xS1234", MemSize::Bit_6, 0x1234U);
AssertParseFromString("0xT1234", MemSize::Bit_7, 0x1234U);
// BCD
AssertParseFromString("B0xH1234", MemSize::EightBit, 0x1234U, true);
AssertParseFromString("B0xX1234", MemSize::ThirtyTwoBit, 0x1234U, true);
AssertParseFromString("b0xH1234", MemSize::EightBit, 0x1234U, true);
// Value (values don't actually have size, EightBit is the default)
AssertParseFromString("V0x1234", MemSize::SixteenBit, 0x1234, false, true); // hex is indirectly supported through using CompVariable to parse the value/address
AssertParseFromString("V1234", MemSize::EightBit, 1234, false, true);
AssertParseFromString("V+1", MemSize::EightBit, 1, false, true);
AssertParseFromString("V-1", MemSize::EightBit, 0xFFFFFFFFU, false, true);
AssertParseFromString("V-2", MemSize::EightBit, 0xFFFFFFFEU, false, true); // twos compliment still works for addition
}
TEST_METHOD(TestClauseParseFromStringMultiply)
{
AssertParseFromString("0xH1234", MemSize::EightBit, 0x1234U, 1.0);
AssertParseFromString("0xH1234*1", MemSize::EightBit, 0x1234U, 1.0);
AssertParseFromString("0xH1234*3", MemSize::EightBit, 0x1234U, 3.0);
AssertParseFromString("0xH1234*0.5", MemSize::EightBit, 0x1234U, 0.5);
AssertParseFromString("0xH1234*-1", MemSize::EightBit, 0x1234U, -1.0);
}
TEST_METHOD(TestClauseParseFromStringMultiplyAddress)
{
AssertParseFromString("0xH1234", MemSize::EightBit, 0x1234U, MemSize::EightBit, 0U);
AssertParseFromString("0xH1234*0xH3456", MemSize::EightBit, 0x1234U, MemSize::EightBit, 0x3456U);
AssertParseFromString("0xH1234*0xL2222", MemSize::EightBit, 0x1234U, MemSize::Nibble_Lower, 0x2222U);
AssertParseFromString("0xH1234*0x1111", MemSize::EightBit, 0x1234U, MemSize::SixteenBit, 0x1111U);
}
TEST_METHOD(TestClauseGetValue)
{
unsigned char memory[] = { 0x00, 0x12, 0x34, 0xAB, 0x56 };
InitializeMemory(memory, 5);
// value
AssertGetValue("V0x1234", 0x1234);
AssertGetValue("V6", 6);
AssertGetValue("V6*2", 12);
AssertGetValue("V6*0.5", 3);
// memory
AssertGetValue("0xH01", 0x12);
AssertGetValue("0x0001", 0x3412);
// BCD encoding
AssertGetValue("B0xH01", 12);
AssertGetValue("B0x0001", 12); // BCD only applies to EightBit values
// multiplication
AssertGetValue("0xH01*4", 0x12 * 4); // multiply by constant
AssertGetValue("0xH01*0.5", 0x12 / 2); // multiply by fraction
AssertGetValue("0xH01*0xH02", 0x12 * 0x34); // multiply by second address
AssertGetValue("0xH01*0xT02", 0); // multiply by bit
AssertGetValue("0xH01*~0xT02", 0x12); // multiply by inverse bit
AssertGetValue("0xH01*~0xH02", 0x12 * 0x34); // ~ only applies to bit sized secondary memory addresses
}
TEST_METHOD(TestAdditionSimple)
{
unsigned char memory[] = { 0x00, 0x12, 0x34, 0xAB, 0x56 };
InitializeMemory(memory, 5);
MemValueHarness set;
Assert::AreEqual("", set.ParseFromString("0xH0001_0xH0002"));
Assert::AreEqual(2U, set.NumValues());
Assert::AreEqual(false, set.IsAddition(0));
Assert::AreEqual(false, set.IsMaximum(0));
Assert::AreEqual(true, set.IsAddition(1));
Assert::AreEqual(false, set.IsMaximum(1));
Assert::AreEqual(0x12U + 0x34U, set.GetValue());
}
TEST_METHOD(TestAdditionComplex)
{
unsigned char memory[] = { 0x00, 0x12, 0x34, 0xAB, 0x56 };
InitializeMemory(memory, 5);
MemValueHarness set;
Assert::AreEqual("", set.ParseFromString("0xH0001*100_0xH0002*0.5_0xL0003"));
Assert::AreEqual(3U, set.NumValues());
Assert::AreEqual(false, set.IsAddition(0));
Assert::AreEqual(false, set.IsMaximum(0));
Assert::AreEqual(true, set.IsAddition(1));
Assert::AreEqual(false, set.IsMaximum(1));
Assert::AreEqual(true, set.IsAddition(2));
Assert::AreEqual(false, set.IsMaximum(2));
Assert::AreEqual(0x12U * 100 + 0x34U / 2 + 0x0B, set.GetValue());
}
TEST_METHOD(TestAdditionValue)
{
unsigned char memory[] = { 0x00, 0x12, 0x34, 0xAB, 0x56 };
InitializeMemory(memory, 5);
MemValueHarness set;
Assert::AreEqual("", set.ParseFromString("0xH0001_v1"));
Assert::AreEqual(2U, set.NumValues());
Assert::AreEqual(false, set.IsAddition(0));
Assert::AreEqual(false, set.IsMaximum(0));
Assert::AreEqual(true, set.IsAddition(1));
Assert::AreEqual(false, set.IsMaximum(1));
Assert::AreEqual(0x12U + 1U, set.GetValue());
MemValueHarness set2;
Assert::AreEqual("", set2.ParseFromString("0xH0001_v-1"));
Assert::AreEqual(2U, set2.NumValues());
Assert::AreEqual(false, set2.IsAddition(0));
Assert::AreEqual(false, set2.IsMaximum(0));
Assert::AreEqual(true, set2.IsAddition(1));
Assert::AreEqual(false, set2.IsMaximum(1));
Assert::AreEqual(0x12U - 1U, set2.GetValue());
}
TEST_METHOD(TestMaximumSimple)
{
unsigned char memory[] = { 0x00, 0x12, 0x34, 0xAB, 0x56 };
InitializeMemory(memory, 5);
MemValueHarness set;
Assert::AreEqual("", set.ParseFromString("0xH0001$0xH0002"));
Assert::AreEqual(2U, set.NumValues());
Assert::AreEqual(false, set.IsAddition(0));
Assert::AreEqual(false, set.IsMaximum(0));
Assert::AreEqual(false, set.IsAddition(1));
Assert::AreEqual(true, set.IsMaximum(1));
Assert::AreEqual(0x34U, set.GetValue());
}
TEST_METHOD(TestMaximumComplex)
{
unsigned char memory[] = { 0x00, 0x12, 0x34, 0xAB, 0x56 };
InitializeMemory(memory, 5);
MemValueHarness set;
Assert::AreEqual("", set.ParseFromString("0xH0001_0xH0004*3$0xH0002*0xL0003"));
Assert::AreEqual(3U, set.NumValues());
Assert::AreEqual(false, set.IsAddition(0));
Assert::AreEqual(false, set.IsMaximum(0));
Assert::AreEqual(true, set.IsAddition(1));
Assert::AreEqual(false, set.IsMaximum(1));
Assert::AreEqual(false, set.IsAddition(2));
Assert::AreEqual(true, set.IsMaximum(2));
// 0x12 + 0x56 * 3 <> 0x34 * 0xB (0x114 <> 0x23C)
Assert::AreEqual(0x34U * 0xBU, set.GetValue());
}
TEST_METHOD(TestFormatValue)
{
Assert::AreEqual("12345", MemValue::FormatValue(12345, MemValue::Format::Value).c_str());
Assert::AreEqual("012345", MemValue::FormatValue(12345, MemValue::Format::Other).c_str());
Assert::AreEqual("012345 Points", MemValue::FormatValue(12345, MemValue::Format::Score).c_str());
Assert::AreEqual("205:45", MemValue::FormatValue(12345, MemValue::Format::TimeSecs).c_str());
Assert::AreEqual("02:03.45", MemValue::FormatValue(12345, MemValue::Format::TimeMillisecs).c_str());
Assert::AreEqual("03:25.75", MemValue::FormatValue(12345, MemValue::Format::TimeFrames).c_str());
Assert::AreEqual("05:45", MemValue::FormatValue(345, MemValue::Format::TimeSecs).c_str());
Assert::AreEqual("00:03.45", MemValue::FormatValue(345, MemValue::Format::TimeMillisecs).c_str());
Assert::AreEqual("00:05.75", MemValue::FormatValue(345, MemValue::Format::TimeFrames).c_str());
}
TEST_METHOD(TestParseMemValueFormat)
{
Assert::AreEqual(MemValue::Format::Value, MemValue::ParseFormat("VALUE"));
Assert::AreEqual(MemValue::Format::TimeSecs, MemValue::ParseFormat("SECS"));
Assert::AreEqual(MemValue::Format::TimeSecs, MemValue::ParseFormat("TIMESECS"));
Assert::AreEqual(MemValue::Format::TimeFrames, MemValue::ParseFormat("TIME"));
Assert::AreEqual(MemValue::Format::TimeFrames, MemValue::ParseFormat("FRAMES"));
Assert::AreEqual(MemValue::Format::Score, MemValue::ParseFormat("SCORE"));
Assert::AreEqual(MemValue::Format::Score, MemValue::ParseFormat("POINTS"));
Assert::AreEqual(MemValue::Format::TimeMillisecs, MemValue::ParseFormat("MILLISECS"));
Assert::AreEqual(MemValue::Format::Other, MemValue::ParseFormat("OTHER"));
Assert::AreEqual(MemValue::Format::Value, MemValue::ParseFormat("INVALID"));
}
TEST_METHOD(TestGetMemValueFormatString)
{
Assert::AreEqual("OTHER", MemValue::GetFormatString(MemValue::Format::Other));
Assert::AreEqual("POINTS", MemValue::GetFormatString(MemValue::Format::Score));
Assert::AreEqual("FRAMES", MemValue::GetFormatString(MemValue::Format::TimeFrames));
Assert::AreEqual("MILLISECS", MemValue::GetFormatString(MemValue::Format::TimeMillisecs));
Assert::AreEqual("SECS", MemValue::GetFormatString(MemValue::Format::TimeSecs));
Assert::AreEqual("VALUE", MemValue::GetFormatString(MemValue::Format::Value));
}
};
} // namespace tests
} // namespace data
} // namespace ra
Reference in New Issue View Git Blame Copy Permalink