TestSuite

Tests/Unit/StreamReader.cpp

@@ -13,9 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <IACore/StreamReader.hpp>
-
 #include <IACore/IATest.hpp>
+#include <IACore/StreamReader.hpp>
 
 using namespace IACore;
 
@@ -24,71 +23,72 @@ IAT_BEGIN_BLOCK(Core, StreamReader)
 // -------------------------------------------------------------------------
 // 1. Basic Primitive Reading (u8)
 // -------------------------------------------------------------------------
-bool TestReadUint8() {
+auto test_read_uint8() -> bool {
   u8 data[] = {0xAA, 0xBB, 0xCC};
   StreamReader reader(data);
 
   // Read First Byte
-  auto val1 = reader.Read<u8>();
+  auto val1 = reader.read<u8>();
   IAT_CHECK(val1.has_value());
   IAT_CHECK_EQ(*val1, 0xAA);
-  IAT_CHECK_EQ(reader.Cursor(), (usize)1);
+  IAT_CHECK_EQ(reader.cursor(), static_cast<usize>(1));
 
   // Read Second Byte
-  auto val2 = reader.Read<u8>();
+  auto val2 = reader.read<u8>();
+  IAT_CHECK(val2.has_value());
   IAT_CHECK_EQ(*val2, 0xBB);
 
-  return TRUE;
+  return true;
 }
 
 // -------------------------------------------------------------------------
 // 2. Multi-byte Reading (Endianness check)
 // -------------------------------------------------------------------------
-bool TestReadMultiByte() {
+auto test_read_multi_byte() -> bool {
   // 0x04030201 in Little Endian memory layout
   // IACore always assumes a Little Endian machine
   u8 data[] = {0x01, 0x02, 0x03, 0x04};
   StreamReader reader(data);
 
-  auto val = reader.Read<u32>();
+  auto val = reader.read<u32>();
   IAT_CHECK(val.has_value());
 
-  IAT_CHECK_EQ(*val, (u32)0x04030201);
+  IAT_CHECK_EQ(*val, static_cast<u32>(0x04030201));
 
-  IAT_CHECK_EQ(reader.Cursor(), (usize)4);
-  IAT_CHECK(reader.IsEOF());
+  IAT_CHECK_EQ(reader.cursor(), static_cast<usize>(4));
+  IAT_CHECK(reader.is_eof());
 
-  return TRUE;
+  return true;
 }
 
 // -------------------------------------------------------------------------
 // 3. Floating Point (Approx check)
 // -------------------------------------------------------------------------
-bool TestReadFloat() {
-  f32 pi = 3.14159f;
+auto test_read_float() -> bool {
+  const f32 pi = 3.14159f;
   // Bit-cast float to bytes for setup
   u8 data[4];
   std::memcpy(data, &pi, 4);
 
   StreamReader reader(data);
-  auto val = reader.Read<f32>();
+  auto val = reader.read<f32>();
 
   IAT_CHECK(val.has_value());
   IAT_CHECK_APPROX(*val, pi);
 
-  return TRUE;
+  return true;
 }
 
 // -------------------------------------------------------------------------
 // 4. Batch Buffer Reading
 // -------------------------------------------------------------------------
-bool TestReadBuffer() {
+auto test_read_buffer() -> bool {
   u8 src[] = {1, 2, 3, 4, 5};
   u8 dst[3] = {0};
   StreamReader reader(src);
 
   // Read 3 bytes into dst
-  auto res = reader.Read(dst, 3);
+  const auto res = reader.read(dst, 3);
   IAT_CHECK(res.has_value());
 
   // Verify dst content
@@ -97,74 +97,74 @@ bool TestReadBuffer() {
   IAT_CHECK_EQ(dst[2], 3);
 
   // Verify cursor
-  IAT_CHECK_EQ(reader.Cursor(), (usize)3);
+  IAT_CHECK_EQ(reader.cursor(), static_cast<usize>(3));
 
-  return TRUE;
+  return true;
 }
 
 // -------------------------------------------------------------------------
 // 5. Navigation (Seek, Skip, Remaining)
 // -------------------------------------------------------------------------
-bool TestNavigation() {
+auto test_navigation() -> bool {
   u8 data[10] = {0}; // Zero init
   StreamReader reader(data);
 
-  IAT_CHECK_EQ(reader.Remaining(), (usize)10);
+  IAT_CHECK_EQ(reader.remaining(), static_cast<usize>(10));
 
   // Skip
-  reader.Skip(5);
-  IAT_CHECK_EQ(reader.Cursor(), (usize)5);
-  IAT_CHECK_EQ(reader.Remaining(), (usize)5);
+  reader.skip(5);
+  IAT_CHECK_EQ(reader.cursor(), static_cast<usize>(5));
+  IAT_CHECK_EQ(reader.remaining(), static_cast<usize>(5));
 
   // Skip clamping
-  reader.Skip(100); // Should clamp to 10
-  IAT_CHECK_EQ(reader.Cursor(), (usize)10);
-  IAT_CHECK(reader.IsEOF());
+  reader.skip(100); // Should clamp to 10
+  IAT_CHECK_EQ(reader.cursor(), static_cast<usize>(10));
+  IAT_CHECK(reader.is_eof());
 
   // Seek
-  reader.Seek(2);
-  IAT_CHECK_EQ(reader.Cursor(), (usize)2);
-  IAT_CHECK_EQ(reader.Remaining(), (usize)8);
-  IAT_CHECK_NOT(reader.IsEOF());
+  reader.seek(2);
+  IAT_CHECK_EQ(reader.cursor(), static_cast<usize>(2));
+  IAT_CHECK_EQ(reader.remaining(), static_cast<usize>(8));
+  IAT_CHECK_NOT(reader.is_eof());
 
-  return TRUE;
+  return true;
 }
 
 // -------------------------------------------------------------------------
 // 6. Error Handling (EOF Protection)
 // -------------------------------------------------------------------------
-bool TestBoundaryChecks() {
+auto test_boundary_checks() -> bool {
   u8 data[] = {0x00, 0x00};
   StreamReader reader(data);
 
   // Valid read
-  UNUSED(reader.Read<u16>());
-  IAT_CHECK(reader.IsEOF());
+  (void)reader.read<u16>();
+  IAT_CHECK(reader.is_eof());
 
   // Invalid Read Primitive
-  auto val = reader.Read<u8>();
+  auto val = reader.read<u8>();
   IAT_CHECK_NOT(val.has_value()); // Should be unexpected
 
   // Invalid Batch Read
   u8 buf[1];
-  auto batch = reader.Read(buf, 1);
+  auto batch = reader.read(buf, 1);
   IAT_CHECK_NOT(batch.has_value());
 
-  return TRUE;
+  return true;
 }
 
 // -------------------------------------------------------------------------
 // Registration
 // -------------------------------------------------------------------------
 IAT_BEGIN_TEST_LIST()
-IAT_ADD_TEST(TestReadUint8);
-IAT_ADD_TEST(TestReadMultiByte);
-IAT_ADD_TEST(TestReadFloat);
-IAT_ADD_TEST(TestReadBuffer);
-IAT_ADD_TEST(TestNavigation);
-IAT_ADD_TEST(TestBoundaryChecks);
+IAT_ADD_TEST(test_read_uint8);
+IAT_ADD_TEST(test_read_multi_byte);
+IAT_ADD_TEST(test_read_float);
+IAT_ADD_TEST(test_read_buffer);
+IAT_ADD_TEST(test_navigation);
+IAT_ADD_TEST(test_boundary_checks);
 IAT_END_TEST_LIST()
 
 IAT_END_BLOCK()
 
-IAT_REGISTER_ENTRY(Core, StreamReader)
+IAT_REGISTER_ENTRY(Core, StreamReader)