noham/archived-Reclass
1
0
Fork 0
mirror of https://github.com/NohamR/Reclass.git synced 2026-05-10 19:59:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix 7 data bugs: hex endian, signed hex, array span, UTF-8 positions, array undo, offset sign

Browse Source
This commit is contained in:
sysadmin
2026-02-05 07:15:51 -07:00
parent 4d35db224e
commit a0d6b769b6
7 changed files with 226 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
tests/test_core.cpp
View File

@@ -330,13 +330,13 @@ private slots:
auto ns = rcx::nameSpanFor(lm);
QVERIFY(ns.valid);
QCOMPARE(ns.start, 22); // 6 + 14 + 2
QCOMPARE(ns.end, 44); // 22 + 22 (kColName)
QCOMPARE(ns.start, 21); // 6 + 14 + 1 (kSepWidth)
QCOMPARE(ns.end, 43); // 21 + 22 (kColName)
auto vs = rcx::valueSpanFor(lm, 100);
QVERIFY(vs.valid);
QCOMPARE(vs.start, 46); // 22 + 22 + 2
QCOMPARE(vs.end, 78); // 46 + 32 (kColValue)
QCOMPARE(vs.start, 44); // 21 + 22 + 1 (kSepWidth)
QCOMPARE(vs.end, 76); // 44 + 32 (kColValue)
}
void testColumnSpan_continuation() {
@@ -351,8 +351,8 @@ private slots:
auto vs = rcx::valueSpanFor(lm, 100);
QVERIFY(vs.valid);
QCOMPARE(vs.start, 6 + 14 + 22 + 4); // kFoldCol+indent + kColType(14) + kColName(22) + 4
QCOMPARE(vs.end, 46 + 32); // start + kColValue
QCOMPARE(vs.start, 6 + 14 + 22 + 2); // kFoldCol+indent + kColType(14) + kColName(22) + 2*kSepWidth
QCOMPARE(vs.end, 44 + 32); // start + kColValue
}
void testColumnSpan_headerFooter() {
@@ -386,13 +386,13 @@ private slots:
auto ns = rcx::nameSpanFor(lm);
QVERIFY(ns.valid);
QCOMPARE(ns.start, 19); // 3 + 14 + 2
QCOMPARE(ns.end, 41); // 19 + 22 (kColName)
QCOMPARE(ns.start, 18); // 3 + 14 + 1 (kSepWidth)
QCOMPARE(ns.end, 40); // 18 + 22 (kColName)
auto vs = rcx::valueSpanFor(lm, 100);
QVERIFY(vs.valid);
QCOMPARE(vs.start, 43); // 19 + 22 + 2
QCOMPARE(vs.end, 75); // 43 + 32 (kColValue)
QCOMPARE(vs.start, 41); // 18 + 22 + 1 (kSepWidth)
QCOMPARE(vs.end, 73); // 41 + 32 (kColValue)
}
void testNodeIdJsonRoundTrip() {
@@ -474,6 +474,38 @@ private slots:
empty.parentId = 0;
int ei = tree3.addNode(empty);
QCOMPARE(tree3.structSpan(tree3.nodes[ei].id), 0);
// Primitive array (no children) should return its declared size
NodeTree tree4;
Node arr;
arr.kind = NodeKind::Array;
arr.name = "data";
arr.parentId = 0;
arr.arrayLen = 16;
arr.elementKind = NodeKind::UInt32; // 16 * 4 = 64 bytes
int ai = tree4.addNode(arr);
QCOMPARE(tree4.structSpan(tree4.nodes[ai].id), 64);
// Struct containing primitive array - span includes array size
NodeTree tree5;
Node container;
container.kind = NodeKind::Struct;
container.name = "Container";
container.parentId = 0;
int ci = tree5.addNode(container);
uint64_t containerId = tree5.nodes[ci].id;
Node arr2;
arr2.kind = NodeKind::Array;
arr2.name = "items";
arr2.parentId = containerId;
arr2.offset = 8;
arr2.arrayLen = 10;
arr2.elementKind = NodeKind::UInt64; // 10 * 8 = 80 bytes
tree5.addNode(arr2);
// Container span = array offset (8) + array size (80) = 88
QCOMPARE(tree5.structSpan(containerId), 88);
}
void testNormalizePreferAncestors() {
using namespace rcx;

57
tests/test_format.cpp
View File

@@ -94,14 +94,14 @@ private slots:
void testParseValueHex32() {
bool ok;
// Hex parsing produces raw bytes (no endian conversion)
// Hex parsing produces native-endian bytes (matches display which reads native-endian)
QByteArray b = fmt::parseValue(NodeKind::Hex32, "DEADBEEF", &ok);
QVERIFY(ok);
QCOMPARE(b.size(), 4);
QCOMPARE((uint8_t)b[0], (uint8_t)0xDE);
QCOMPARE((uint8_t)b[1], (uint8_t)0xAD);
QCOMPARE((uint8_t)b[2], (uint8_t)0xBE);
QCOMPARE((uint8_t)b[3], (uint8_t)0xEF);
// Value 0xDEADBEEF stored as native-endian (little-endian on x86)
uint32_t v;
memcpy(&v, b.data(), 4);
QCOMPARE(v, (uint32_t)0xDEADBEEF);
}
void testParseValueBool() {
@@ -122,13 +122,12 @@ private slots:
void testParseValueHex0xPrefix() {
bool ok;
// Hex32 with 0x prefix should work (raw bytes, no endian conversion)
// Hex32 with 0x prefix should work (native-endian, matches display)
QByteArray b = fmt::parseValue(NodeKind::Hex32, "0xDEADBEEF", &ok);
QVERIFY(ok);
QCOMPARE((uint8_t)b[0], (uint8_t)0xDE);
QCOMPARE((uint8_t)b[1], (uint8_t)0xAD);
QCOMPARE((uint8_t)b[2], (uint8_t)0xBE);
QCOMPARE((uint8_t)b[3], (uint8_t)0xEF);
uint32_t v32;
memcpy(&v32, b.data(), 4);
QCOMPARE(v32, (uint32_t)0xDEADBEEF);
// Pointer64 with 0x prefix
b = fmt::parseValue(NodeKind::Pointer64, "0x0000000000400000", &ok);
@@ -177,6 +176,44 @@ private slots:
QVERIFY(!ok);
}
void testSignedHexRoundTrip() {
bool ok;
// Int8: 0xFF should parse as -1 (two's complement)
QByteArray b = fmt::parseValue(NodeKind::Int8, "0xFF", &ok);
QVERIFY(ok);
int8_t sv8;
memcpy(&sv8, b.data(), 1);
QCOMPARE(sv8, (int8_t)-1);
// Int8: 0x80 should parse as -128
b = fmt::parseValue(NodeKind::Int8, "0x80", &ok);
QVERIFY(ok);
memcpy(&sv8, b.data(), 1);
QCOMPARE(sv8, (int8_t)-128);
// Int16: 0xFFFF should parse as -1
b = fmt::parseValue(NodeKind::Int16, "0xFFFF", &ok);
QVERIFY(ok);
int16_t sv16;
memcpy(&sv16, b.data(), 2);
QCOMPARE(sv16, (int16_t)-1);
// Int32: 0xFFFFFFFF should parse as -1
b = fmt::parseValue(NodeKind::Int32, "0xFFFFFFFF", &ok);
QVERIFY(ok);
int32_t sv32;
memcpy(&sv32, b.data(), 4);
QCOMPARE(sv32, (int32_t)-1);
// Int8: 0x1FF should fail (exceeds byte range)
fmt::parseValue(NodeKind::Int8, "0x1FF", &ok);
QVERIFY(!ok);
// Int16: 0x1FFFF should fail (exceeds 16-bit range)
fmt::parseValue(NodeKind::Int16, "0x1FFFF", &ok);
QVERIFY(!ok);
}
void testReadValueBoundsCheck() {
// Vec2 subLine=2 (out of bounds) should return "?"
QByteArray data(16, '\0');