convert log-only test validations to assertive expect() checks across 10 test files

Replace LUISA_ERROR/LUISA_INFO pass/fail patterns with boost.ut expect()
assertions so test failures are CI-detectable. Changes:
- test_logging: add 4 custom-sink assertion tests
- test_nested_callable: check() and state logs to expect()
- test_callable: enable commented assertion with tolerance
- test_soa, test_soa_simple, test_soa_subview: LUISA_ERROR to expect()
- test_decoupled_look_back: separate expect() for exclusive/inclusive
- test_warp: LUISA_ERROR to expect(all_correct)
- test_softmax: add expect(sum ≈ 1/N) for uniform input
- test_byte_buffer: add readback verification expect() for both paths

Author: Mike-Leo-Smith

src/tests/unit/core/test_logging.cpp

@@ -1,91 +1,229 @@
-// Test for logging functionality.
-// This test verifies that the logging system works correctly with different
-// log levels, formats, and macros.
-
 #include "ut/ut.hpp"
 #include <luisa/core/logging.h>
 #include <luisa/core/stl/string.h>
 #include <luisa/core/stl/vector.h>
+#include <mutex>
 
 using namespace boost::ut;
 using namespace boost::ut::literals;
 
-// Simple test to verify logging doesn't crash and produces output
+#ifndef LUISA_CUSTOM_LOGGER
+
+struct CapturedMessage {
+    luisa::string level;
+    luisa::string message;
+};
+
+static inline const auto _reg_logging_custom_sink = [] {
+    "logging_custom_sink_captures_messages"_test = [] {
+        std::mutex mtx;
+        luisa::vector<CapturedMessage> captured;
+
+        auto sink = luisa::detail::create_sink_with_callback(
+            [&](const char *level, const char *message) {
+                std::lock_guard lock{mtx};
+                captured.push_back({luisa::string{level}, luisa::string{message}});
+            });
+
+        auto &logger = luisa::detail::default_logger();
+        auto original_sinks = logger.sinks();
+        logger.sinks().clear();
+        logger.sinks().push_back(sink);
+        luisa::log_level_verbose();
+
+        luisa::log_verbose("verbose_msg_42");
+        luisa::log_info("info_msg_100");
+        luisa::log_warning("warning_msg_xyz");
+        luisa::log_flush();
+
+        logger.sinks() = original_sinks;
+        luisa::log_level_verbose();
+
+        expect(captured.size() >= 3u) << "expected at least 3 captured messages, got " << captured.size();
+
+        bool found_verbose = false, found_info = false, found_warning = false;
+        for (auto &cm : captured) {
+            if (cm.message.find("verbose_msg_42") != luisa::string::npos) found_verbose = true;
+            if (cm.message.find("info_msg_100") != luisa::string::npos) found_info = true;
+            if (cm.message.find("warning_msg_xyz") != luisa::string::npos) found_warning = true;
+        }
+        expect(found_verbose) << "custom sink should capture verbose message";
+        expect(found_info) << "custom sink should capture info message";
+        expect(found_warning) << "custom sink should capture warning message";
+    };
+    return 0;
+}();
+
+static inline const auto _reg_logging_level_filtering = [] {
+    "logging_level_filtering_via_sink"_test = [] {
+        std::mutex mtx;
+        luisa::vector<CapturedMessage> captured;
+
+        auto sink = luisa::detail::create_sink_with_callback(
+            [&](const char *level, const char *message) {
+                std::lock_guard lock{mtx};
+                captured.push_back({luisa::string{level}, luisa::string{message}});
+            });
+
+        auto &logger = luisa::detail::default_logger();
+        auto original_sinks = logger.sinks();
+        logger.sinks().clear();
+        logger.sinks().push_back(sink);
+
+        luisa::log_level_warning();
+        captured.clear();
+
+        luisa::log_verbose("should_be_filtered_verbose");
+        luisa::log_info("should_be_filtered_info");
+        luisa::log_warning("should_appear_warning");
+        luisa::log_flush();
+
+        logger.sinks() = original_sinks;
+        luisa::log_level_verbose();
+
+        bool found_filtered_verbose = false;
+        bool found_filtered_info = false;
+        bool found_warning = false;
+        for (auto &cm : captured) {
+            if (cm.message.find("should_be_filtered_verbose") != luisa::string::npos) found_filtered_verbose = true;
+            if (cm.message.find("should_be_filtered_info") != luisa::string::npos) found_filtered_info = true;
+            if (cm.message.find("should_appear_warning") != luisa::string::npos) found_warning = true;
+        }
+        expect(!found_filtered_verbose) << "verbose should be filtered at warning level";
+        expect(!found_filtered_info) << "info should be filtered at warning level";
+        expect(found_warning) << "warning should pass at warning level";
+    };
+    return 0;
+}();
+
+static inline const auto _reg_logging_add_sink = [] {
+    "logging_add_sink_preserves_existing"_test = [] {
+        std::mutex mtx;
+        luisa::vector<CapturedMessage> captured;
+
+        auto sink = luisa::detail::create_sink_with_callback(
+            [&](const char *level, const char *message) {
+                std::lock_guard lock{mtx};
+                captured.push_back({luisa::string{level}, luisa::string{message}});
+            });
+
+        luisa::detail::default_logger_add_sink(sink);
+        luisa::log_level_verbose();
+
+        luisa::log_info("add_sink_test_msg");
+        luisa::log_flush();
+
+        auto &sinks = luisa::detail::default_logger().sinks();
+        sinks.erase(std::remove(sinks.begin(), sinks.end(), sink), sinks.end());
+
+        bool found = false;
+        for (auto &cm : captured) {
+            if (cm.message.find("add_sink_test_msg") != luisa::string::npos) found = true;
+        }
+        expect(found) << "added sink should capture messages alongside default sink";
+    };
+    return 0;
+}();
+
+static inline const auto _reg_logging_formatted_args = [] {
+    "logging_formatted_args_in_sink"_test = [] {
+        std::mutex mtx;
+        luisa::vector<CapturedMessage> captured;
+
+        auto sink = luisa::detail::create_sink_with_callback(
+            [&](const char *level, const char *message) {
+                std::lock_guard lock{mtx};
+                captured.push_back({luisa::string{level}, luisa::string{message}});
+            });
+
+        auto &logger = luisa::detail::default_logger();
+        auto original_sinks = logger.sinks();
+        logger.sinks().clear();
+        logger.sinks().push_back(sink);
+        luisa::log_level_verbose();
+
+        luisa::log_info("answer is {}", 42);
+        luisa::log_info("pi is {:.2f}", 3.14159);
+        luisa::log_info("bool={}, str={}", true, "hello");
+        luisa::log_flush();
+
+        logger.sinks() = original_sinks;
+        luisa::log_level_verbose();
+
+        bool found_42 = false, found_pi = false, found_bool = false;
+        for (auto &cm : captured) {
+            if (cm.message.find("answer is 42") != luisa::string::npos) found_42 = true;
+            if (cm.message.find("pi is 3.14") != luisa::string::npos) found_pi = true;
+            if (cm.message.find("bool=true") != luisa::string::npos) found_bool = true;
+        }
+        expect(found_42) << "formatted int arg should appear in sink";
+        expect(found_pi) << "formatted float arg should appear in sink";
+        expect(found_bool) << "formatted bool/string args should appear in sink";
+    };
+    return 0;
+}();
+
+#endif
+
 static inline const auto _luisa_reg_logging_basic_functionality = [] {
-    boost::ut::detail::test{"test", "logging basic functionality"} = [] {
-        // Test basic log functions with simple messages
+    "logging_basic_no_crash"_test = [] {
+        luisa::log_level_verbose();
         luisa::log_verbose("Verbose message from test");
         luisa::log_info("Info message from test");
         luisa::log_warning("Warning message from test");
-
-        // Test formatted log messages
         luisa::log_verbose("Verbose with args: {}, {}", 42, 3.14);
         luisa::log_info("Info with args: {}, {}", "test_string", true);
         luisa::log_warning("Warning with args: {}, {}", 'a', 123u);
-
-        // Test flush
         luisa::log_flush();
+        expect(true) << "basic logging calls completed without crash";
     };
     return 0;
 }();
 
 static inline const auto _luisa_reg_logging_macros = [] {
-    boost::ut::detail::test{"test", "logging macros"} = [] {
-        // Test all logging macros
+    "logging_macros_no_crash"_test = [] {
+        luisa::log_level_verbose();
         LUISA_VERBOSE("Macro verbose message");
         LUISA_INFO("Macro info message");
         LUISA_WARNING("Macro warning message");
-
-        // Test macros with format arguments
         LUISA_VERBOSE("Verbose macro: {}, {}", 1, 2);
         LUISA_INFO("Info macro: {}, {}, {}", "a", "b", "c");
         LUISA_WARNING("Warning macro: value = {}", 3.14159);
+        expect(true) << "logging macros completed without crash";
     };
     return 0;
 }();
 
 static inline const auto _luisa_reg_logging_with_location_macros = [] {
-    boost::ut::detail::test{"test", "logging with location macros"} = [] {
-        // Test location macros
+    "logging_location_macros_no_crash"_test = [] {
+        luisa::log_level_verbose();
         LUISA_VERBOSE_WITH_LOCATION("Verbose with location: {}", 100);
         LUISA_INFO_WITH_LOCATION("Info with location: {}", 200);
         LUISA_WARNING_WITH_LOCATION("Warning with location: {}", 300);
+        expect(true) << "location macros completed without crash";
     };
     return 0;
 }();
 
-static inline const auto _luisa_reg_logging_log_level_changes = [] {
-    boost::ut::detail::test{"test", "logging log level changes"} = [] {
-        // Save current log level (we can't query it, but we can test setting doesn't crash)
-
-        // Test all log level functions
+static inline const auto _luisa_reg_logging_log_level_transitions = [] {
+    "logging_level_transitions_no_crash"_test = [] {
         luisa::log_level_verbose();
-        LUISA_VERBOSE("This verbose should be visible after log_level_verbose()");
-
         luisa::log_level_info();
-        LUISA_VERBOSE("This verbose should be hidden after log_level_info()");
-        LUISA_INFO("This info should be visible after log_level_info()");
-
         luisa::log_level_warning();
-        LUISA_VERBOSE("This verbose should be hidden after log_level_warning()");
-        LUISA_INFO("This info should be hidden after log_level_warning()");
-        LUISA_WARNING("This warning should be visible after log_level_warning()");
-
         luisa::log_level_error();
-        LUISA_VERBOSE("This verbose should be hidden after log_level_error()");
-        LUISA_INFO("This info should be hidden after log_level_error()");
-        LUISA_WARNING("This warning should be hidden after log_level_error()");
-
-        // Reset to verbose for other tests
+        luisa::log_level_verbose();
+        luisa::log_level_warning();
+        luisa::log_level_info();
         luisa::log_level_verbose();
         luisa::log_flush();
+        expect(true) << "rapid level transitions completed without crash";
     };
     return 0;
 }();
 
 static inline const auto _luisa_reg_logging_complex_format_strings = [] {
-    boost::ut::detail::test{"test", "logging complex format strings"} = [] {
-        // Test various format specifiers
+    "logging_complex_format_strings"_test = [] {
+        luisa::log_level_verbose();
         LUISA_INFO("Integer: {}", -123456);
         LUISA_INFO("Unsigned: {}", 123456u);
         LUISA_INFO("Float: {}", 3.14159265f);
@@ -97,27 +235,24 @@ static inline const auto _luisa_reg_logging_complex_format_strings = [] {
         LUISA_INFO("Binary: {:b}", 170);
         LUISA_INFO("Scientific: {:e}", 12345.6789);
         LUISA_INFO("Fixed: {:.2f}", 3.14159);
+        expect(true) << "complex format strings completed without crash";
     };
     return 0;
 }();
 
 static inline const auto _luisa_reg_logging_empty_and_special_messages = [] {
-    boost::ut::detail::test{"test", "logging empty and special messages"} = [] {
-        // Test empty message (via format)
+    "logging_empty_and_special_messages"_test = [] {
+        luisa::log_level_verbose();
         LUISA_INFO("");
-
-        // Test message with special characters
         LUISA_INFO("Special chars: \t\n\r!@#$%^&*()_+-=[]{}|;':\",./<>?");
-
-        // Test message with braces
         LUISA_INFO("Braces: {{escaped}}, {{{{nested}}}}");
 
-        // Test long message
         luisa::string long_message;
         for (int i = 0; i < 100; ++i) {
             long_message += "This is a long message repeated multiple times. ";
         }
         LUISA_INFO("Long message: {}", long_message);
+        expect(long_message.size() > 4000u) << "long message should be substantial";
     };
     return 0;
 }();

src/tests/unit/dsl/test_callable.cpp

@@ -99,9 +99,17 @@ void test_callable(Device &device) {
                results[0], results[1], results[2], results[3],
                results[n - 2u], results[n - 1u]);
 
-    // for (size_t i = 0u; i < n; i++) {
-    //     LUISA_ASSERT(results[i] == data[i] + 3.0f, "Results mismatch.");
-    // }
+    bool all_correct = true;
+    for (size_t i = 0u; i < n; i++) {
+        float expected = data[i] + 3.0f;
+        if (std::abs(results[i] - expected) > 1e-4f) {
+            if (all_correct) {
+                LUISA_WARNING("Callable result mismatch at [{}]: got {} expected {}", i, results[i], expected);
+            }
+            all_correct = false;
+        }
+    }
+    expect(all_correct) << "callable composition should produce correct results (data[i] + 3.0f)";
 }
 
 static inline const auto reg = [] {

src/tests/unit/dsl/test_nested_callable.cpp

@@ -49,7 +49,6 @@ static constexpr uint N = 1024u;
 static void check(const char *name,
                   const std::vector<float> &result,
                   const std::vector<float> &expected) {
-    bool ok = true;
     uint mismatch_count = 0u;
     for (uint i = 0u; i < result.size(); i++) {
         float diff = std::abs(result[i] - expected[i]);
@@ -59,18 +58,9 @@ static void check(const char *name,
                               name, i, result[i], expected[i], diff);
             }
             mismatch_count++;
-            ok = false;
         }
     }
-    if (!ok && mismatch_count > 5u) {
-        LUISA_WARNING("{}: ... and {} more mismatches (total {}/{})",
-                      name, mismatch_count - 5u, mismatch_count, (uint)result.size());
-    }
-    if (ok) {
-        LUISA_INFO("{}: PASSED", name);
-    } else {
-        LUISA_WARNING("{}: FAILED ({}/{} mismatches)", name, mismatch_count, (uint)result.size());
-    }
+    expect(mismatch_count == 0u) << name << ": " << mismatch_count << "/" << result.size() << " mismatches";
 }
 
 // ── LCG matching the path tracer ─────────────────────────────────────
@@ -431,7 +421,7 @@ int test_nested_callable(Device &device) {
                 state_ok = false;
             }
         }
-        LUISA_INFO("test12_lcg_state_writeback: {}", state_ok ? "PASSED" : "FAILED");
+        expect(state_ok) << "test12_lcg_state_writeback";
     }
 
     // ================================================================
@@ -732,7 +722,7 @@ int test_nested_callable(Device &device) {
                 state_ok = false;
             }
         }
-        LUISA_INFO("test20_lcg_state_final: {}", state_ok ? "PASSED" : "FAILED");
+        expect(state_ok) << "test20_lcg_state_final";
     }
 
     LUISA_INFO("All nested callable tests completed.");

src/tests/unit/dsl/test_soa.cpp

@@ -112,18 +112,11 @@ int test_soa(Device &device) {
     auto any_wrong = false;
     for (auto i = 0u; i < n; i++) {
         if (host_upload[i] != host_download[i]) {
-            LUISA_WARNING("SOA upload/download mismatch at index {}\n"
-                          "  Expected: {}\n"
-                          "  Actual:   {}",
-                          i, host_upload[i], host_download[i]);
+            LUISA_WARNING("SOA upload/download mismatch at index {}", i);
             any_wrong = true;
         }
     }
-    if (any_wrong) {
-        LUISA_ERROR("SOA upload/download mismatch.");
-    } else {
-        LUISA_INFO("SOA upload/download test passed.");
-    }
+    expect(!any_wrong) << "soa_upload_download_roundtrip";
 
     return 0;
 }