Enable program_test in CI and fix flaky LoadFromMutableSegment test (#16709)

Enable program_test target in CMakeLists.txt which was previously
disabled (TODO T191569140).

Fix the LoadFromMutableSegment test which was fragile due to checking
for a hardcoded byte value (232) that varies across platforms and
PyTorch versions. The test now:

1. Loads the full 36-byte weight tensor instead of a single byte
2. Verifies data consistency by comparing two loads with memcmp
3. Checks that loaded data is non-trivial (contains non-zero bytes)
4. Validates source immutability by mutating local buffer and
   reloading to verify original data is preserved

This maintains the test's purpose of validating mutable segment
loading while being robust across different environments.

Author: mergennachin

runtime/executor/test/CMakeLists.txt

@@ -133,12 +133,17 @@ set_property(TEST method_test PROPERTY ENVIRONMENT ${test_env})
 # TODO(T191569140): Enable this test. et_cxx_test(method_meta_test SOURCES
 # method_meta_test.cpp EXTRA_LIBS extension_data_loader)
 
-# TODO(T191569140): Enable this test. et_cxx_test( program_test SOURCES
-# program_test.cpp EXTRA_LIBS extension_data_loader )
+et_cxx_test(
+  program_test SOURCES program_test.cpp EXTRA_LIBS extension_data_loader
+  program_schema
+)
+add_dependencies(program_test generated_pte_files)
+set_property(TEST program_test PROPERTY ENVIRONMENT ${test_env})
 
-# target_include_directories( program_test PRIVATE
-# "${CMAKE_INSTALL_PREFIX}/schema/include"
-# "${EXECUTORCH_ROOT}/third-party/flatbuffers/include" )
+target_include_directories(
+  program_test PRIVATE "${CMAKE_INSTALL_PREFIX}/schema/include"
+                       "${EXECUTORCH_ROOT}/third-party/flatbuffers/include"
+)
 
 et_cxx_test(
   kernel_resolution_test SOURCES kernel_resolution_test.cpp EXTRA_LIBS

runtime/executor/test/program_test.cpp

@@ -187,6 +187,14 @@ TEST_F(ProgramTest, BadMagicFailsToLoad) {
   }
 }
 
+// These tests require ET_ENABLE_PROGRAM_VERIFICATION to be enabled.
+// In Release builds, verification is disabled by default to save binary size.
+#ifndef ET_ENABLE_PROGRAM_VERIFICATION
+#define ET_ENABLE_PROGRAM_VERIFICATION 1
+#endif
+
+#if ET_ENABLE_PROGRAM_VERIFICATION
+
 TEST_F(ProgramTest, VerificationCatchesTruncation) {
   // Get the program data.
   size_t full_data_len = add_loader_->size().get();
@@ -234,6 +242,8 @@ TEST_F(ProgramTest, VerificationCatchesCorruption) {
   ASSERT_EQ(program.error(), Error::InvalidProgram);
 }
 
+#endif // ET_ENABLE_PROGRAM_VERIFICATION
+
 TEST_F(ProgramTest, UnalignedProgramDataFails) {
   // Make a local copy of the data, on an odd alignment.
   size_t data_len = add_loader_->size().get();
@@ -508,32 +518,47 @@ TEST_F(ProgramTest, LoadFromMutableSegment) {
   Result<Program> program = Program::load(&training_loader.get());
   ASSERT_EQ(program.error(), Error::Ok);
 
-  // dummy buffers to load into
-  uint8_t buffer[1] = {0};
-  uint8_t buffer2[1] = {0};
+  // The linear layer weight tensor is 3x3 floats = 36 bytes.
+  // Load the full weight data to verify the loading mechanism works correctly.
+  constexpr size_t kWeightSize = 36;
+  uint8_t buffer[kWeightSize] = {0};
+  uint8_t buffer2[kWeightSize] = {0};
 
-  // Load some mutable segment data
+  // Load the mutable segment data (linear.weight at offset_index 1)
   Error err = ProgramTestFriend::load_mutable_subsegment_into(
-      &program.get(), 0, 1, 1, buffer);
+      &program.get(), 0, 1, kWeightSize, buffer);
   EXPECT_EQ(err, Error::Ok);
 
-  // Check that the data loaded correctly, and then mutate it
-  EXPECT_EQ(buffer[0], 232); // 232 comes from inspecting the file itself. The
-                             // file is seeded so this value should be stable.
-  buffer[0] = 0;
+  // Load the same data into a second buffer
+  err = ProgramTestFriend::load_mutable_subsegment_into(
+      &program.get(), 0, 1, kWeightSize, buffer2);
+  EXPECT_EQ(err, Error::Ok);
+
+  // Verify both loads return identical data
+  EXPECT_EQ(std::memcmp(buffer, buffer2, kWeightSize), 0)
+      << "Loading the same segment twice should return identical data";
+
+  // Verify that the loaded data is non-trivial (not all zeros).
+  bool has_nonzero = false;
+  for (size_t i = 0; i < kWeightSize; ++i) {
+    if (buffer[i] != 0) {
+      has_nonzero = true;
+      break;
+    }
+  }
+  EXPECT_TRUE(has_nonzero)
+      << "Loaded mutable segment data should not be all zeros";
 
-  // Load the same mutable segment data from file into a different buffer.
+  // Mutate the local buffer and reload to verify source immutability
+  std::memset(buffer, 0xFF, kWeightSize);
   err = ProgramTestFriend::load_mutable_subsegment_into(
-      &program.get(),
-      0, // mutable_data_segments_index
-      1, // offset_index
-      1, // size
-      buffer2);
+      &program.get(), 0, 1, kWeightSize, buffer);
   EXPECT_EQ(err, Error::Ok);
 
-  // Check that new data loaded from the file does not reflect the change to
-  // buffer.
-  EXPECT_EQ(buffer2[0], 232);
+  // Verify the reloaded data matches the original (local mutation didn't
+  // affect the file source)
+  EXPECT_EQ(std::memcmp(buffer, buffer2, kWeightSize), 0)
+      << "Reloading after local mutation should return original data";
 
   const executorch_flatbuffer::Program* flatbuffer_program =
       ProgramTestFriend::GetInternalProgram(&program.get());