Remove error test cases from test-backend-ops.cpp

These tests trigger GGML_ASSERT which aborts on WebGPU/Vulkan/CUDA backends.
The backend-ops framework isn't designed for tests that intentionally cause
assertion failures. The standalone test files (test-memory-exhaustion.cpp and
test-invalid-inputs.cpp) provide error testing coverage.

Co-Authored-By: Alex Peng <[email protected]>

Author: devin-ai-integration[bot]

tests/test-backend-ops.cpp

@@ -5433,185 +5433,6 @@ struct test_falcon : public test_llm {
     }
 };
 
-// ###############################################
-// ## Section 2.5: Error Scenario Test Cases  ###
-// ###############################################
-
-struct test_error_null_tensor : public test_case {
-    ggml_type type;
-    std::array<int64_t, 4> ne;
-
-    std::string vars() override {
-        return VARS_TO_STR2(type, ne);
-    }
-
-    test_error_null_tensor(ggml_type type = GGML_TYPE_F32, std::array<int64_t, 4> ne = {10, 10, 1, 1})
-        : type(type), ne(ne) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne.data());
-        ggml_tensor * out = a;  // Just return a valid tensor for the test framework
-        return out;
-    }
-};
-
-struct test_error_alloc_failure : public test_case {
-    ggml_type type;
-    std::array<int64_t, 4> ne;
-
-    std::string vars() override {
-        return VARS_TO_STR2(type, ne);
-    }
-
-    test_error_alloc_failure(ggml_type type = GGML_TYPE_F32, std::array<int64_t, 4> ne = {32, 32, 1, 1})
-        : type(type), ne(ne) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        // Create multiple tensors to stress memory allocation
-        ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne.data());
-        ggml_tensor * b = ggml_new_tensor(ctx, type, 4, ne.data());
-        ggml_tensor * c = ggml_add(ctx, a, b);
-        return c;
-    }
-};
-
-// Test operations with mismatched tensor dimensions
-struct test_error_dim_mismatch : public test_case {
-    ggml_type type;
-    std::array<int64_t, 4> ne_a;
-    std::array<int64_t, 4> ne_b;
-
-    std::string vars() override {
-        return VARS_TO_STR3(type, ne_a, ne_b);
-    }
-
-    test_error_dim_mismatch(
-        ggml_type type = GGML_TYPE_F32,
-        std::array<int64_t, 4> ne_a = {10, 20, 1, 1},
-        std::array<int64_t, 4> ne_b = {15, 25, 1, 1})
-        : type(type), ne_a(ne_a), ne_b(ne_b) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne_a.data());
-        ggml_tensor * b = ggml_new_tensor(ctx, type, 4, ne_b.data());
-        ggml_tensor * out = ggml_add(ctx, a, b);
-        return out;
-    }
-};
-
-struct test_error_zero_size : public test_case {
-    ggml_type type;
-
-    std::string vars() override {
-        return VARS_TO_STR1(type);
-    }
-
-    test_error_zero_size(ggml_type type = GGML_TYPE_F32)
-        : type(type) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        // Create a zero-sized tensor
-        std::array<int64_t, 4> ne = {0, 10, 1, 1};
-        ggml_tensor * a = ggml_new_tensor(ctx, type, 4, ne.data());
-        return a;
-    }
-};
-
-struct test_error_type_conversion : public test_case {
-    ggml_type type_src;
-    ggml_type type_dst;
-    std::array<int64_t, 4> ne;
-
-    std::string vars() override {
-        return VARS_TO_STR3(type_src, type_dst, ne);
-    }
-
-    test_error_type_conversion(
-        ggml_type type_src = GGML_TYPE_F32,
-        ggml_type type_dst = GGML_TYPE_Q4_0,
-        std::array<int64_t, 4> ne = {32, 1, 1, 1})  // Must be multiple of block size
-        : type_src(type_src), type_dst(type_dst), ne(ne) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        ggml_tensor * src = ggml_new_tensor(ctx, type_src, 4, ne.data());
-        ggml_tensor * dst = ggml_new_tensor(ctx, type_dst, 4, ne.data());
-        ggml_tensor * out = ggml_cpy(ctx, src, dst);
-        return out;
-    }
-};
-
-struct test_error_invalid_view : public test_case {
-    ggml_type type;
-    std::array<int64_t, 2> ne_src;
-    std::array<int64_t, 2> ne_view;
-    size_t offset;
-
-    std::string vars() override {
-        return VARS_TO_STR4(type, ne_src, ne_view, offset);
-    }
-
-    test_error_invalid_view(
-        ggml_type type = GGML_TYPE_F32,
-        std::array<int64_t, 2> ne_src = {100, 100},
-        std::array<int64_t, 2> ne_view = {50, 50},
-        size_t offset = 0)
-        : type(type), ne_src(ne_src), ne_view(ne_view), offset(offset) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        ggml_tensor * src = ggml_new_tensor_2d(ctx, type, ne_src[0], ne_src[1]);
-        ggml_tensor * view = ggml_view_2d(ctx, src, ne_view[0], ne_view[1],
-                                         ne_src[0] * ggml_type_size(type), offset);
-        return view;
-    }
-};
-
-// Test matrix multiplication with incompatible dimensions
-struct test_error_matmul_incompatible : public test_case {
-    ggml_type type;
-    std::array<int64_t, 2> ne_a;
-    std::array<int64_t, 2> ne_b;
-
-    std::string vars() override {
-        return VARS_TO_STR3(type, ne_a, ne_b);
-    }
-
-    test_error_matmul_incompatible(
-        ggml_type type = GGML_TYPE_F32,
-        std::array<int64_t, 2> ne_a = {10, 20},  // 20x10 matrix
-        std::array<int64_t, 2> ne_b = {30, 40})  // 40x30 matrix (incompatible)
-        : type(type), ne_a(ne_a), ne_b(ne_b) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        ggml_tensor * a = ggml_new_tensor_2d(ctx, type, ne_a[0], ne_a[1]);
-        ggml_tensor * b = ggml_new_tensor_2d(ctx, type, ne_b[0], ne_b[1]);
-        ggml_tensor * out = ggml_mul_mat(ctx, a, b);
-        return out;
-    }
-
-    double max_nmse_err() override {
-        return 1.0;  // Allow higher error for invalid operations
-    }
-};
-
-struct test_error_extreme_size : public test_case {
-    ggml_type type;
-    int64_t size;
-
-    std::string vars() override {
-        return VARS_TO_STR2(type, size);
-    }
-
-    test_error_extreme_size(ggml_type type = GGML_TYPE_F32, int64_t size = 1024*1024)
-        : type(type), size(size) {}
-
-    ggml_tensor * build_graph(ggml_context * ctx) override {
-        // Create a very large tensor to test memory limits
-        ggml_tensor * a = ggml_new_tensor_1d(ctx, type, size);
-        return a;
-    }
-};
-
-
 // ###########################################
 // ## Section 3: GGML Op Test Instantiation ##
 // ###########################################
@@ -6585,14 +6406,6 @@ static std::vector<std::unique_ptr<test_case>> make_test_cases_eval() {
     test_cases.emplace_back(new test_falcon(2));
 #endif
 
-    test_cases.emplace_back(new test_error_null_tensor(GGML_TYPE_F32, {16, 16, 1, 1}));
-    test_cases.emplace_back(new test_error_alloc_failure(GGML_TYPE_F32, {64, 64, 1, 1}));
-    test_cases.emplace_back(new test_error_dim_mismatch(GGML_TYPE_F32, {10, 20, 1, 1}, {15, 25, 1, 1}));
-    test_cases.emplace_back(new test_error_zero_size(GGML_TYPE_F32));
-    test_cases.emplace_back(new test_error_type_conversion(GGML_TYPE_F32, GGML_TYPE_Q4_0, {64, 1, 1, 1}));
-    test_cases.emplace_back(new test_error_invalid_view(GGML_TYPE_F32, {100, 100}, {50, 50}, 0));
-    test_cases.emplace_back(new test_error_matmul_incompatible(GGML_TYPE_F32, {10, 20}, {30, 40}));
-
     return test_cases;
 }