test: complete backend engine gmock

test/gtest/mocks/gmock_engine.cpp

@@ -19,13 +19,22 @@
 
 namespace mocks {
 
-nixl_b_params_t custom_params;
+nixl_b_params_t custom_params{};
 const nixlBackendInitParams init_params{.customParams = &custom_params};
 const std::string gmock_engine_key = "gmock_engine_key";
 char gmock_dummy_mvh;
 
-GMockBackendEngine::GMockBackendEngine() : nixlBackendEngine(&init_params) {
+GMockBackendEngine::GMockBackendEngine() : GMockBackendEngine(&init_params) {}
+
+GMockBackendEngine::GMockBackendEngine(const nixlBackendInitParams *init_params)
+    : nixlBackendEngine(init_params) {
+    setDefaults();
+}
+
+void
+GMockBackendEngine::setDefaults() {
     using testing::Return;
+    using testing::A;
     using testing::_;
 
     ON_CALL(*this, supportsRemote()).WillByDefault(Return(true));
@@ -41,7 +50,7 @@ GMockBackendEngine::GMockBackendEngine() : nixlBackendEngine(&init_params) {
     ON_CALL(*this, postXfer(_, _, _, _, _, _)).WillByDefault(Return(NIXL_SUCCESS));
     ON_CALL(*this, checkXfer(_)).WillByDefault(Return(NIXL_SUCCESS));
     ON_CALL(*this, releaseReqH(_)).WillByDefault(Return(NIXL_SUCCESS));
-    ON_CALL(*this, prepMemView(_, _, _))
+    ON_CALL(*this, prepMemView(A<const nixl_remote_meta_dlist_t &>(), _, _))
         .WillByDefault(
             [](const nixl_remote_meta_dlist_t &, nixlMemViewH &mvh, const nixl_opt_b_args_t *) {
                 mvh = &gmock_dummy_mvh;
@@ -57,6 +66,20 @@ GMockBackendEngine::GMockBackendEngine() : nixlBackendEngine(&init_params) {
     ON_CALL(*this, loadLocalMD(_, _)).WillByDefault(Return(NIXL_SUCCESS));
     ON_CALL(*this, getNotifs(_)).WillByDefault(Return(NIXL_SUCCESS));
     ON_CALL(*this, genNotif(_, _)).WillByDefault(Return(NIXL_SUCCESS));
+    setOptionalDefaults();
+}
+
+void
+GMockBackendEngine::setOptionalDefaults() {
+    using testing::A;
+    using testing::Return;
+    using testing::_;
+
+    ON_CALL(*this, prepMemView(A<const nixl_meta_dlist_t &>(), _, _))
+        .WillByDefault(Return(NIXL_ERR_NOT_SUPPORTED));
+    ON_CALL(*this, queryMem(_, _)).WillByDefault(Return(NIXL_ERR_NOT_SUPPORTED));
+    ON_CALL(*this, estimateXferCost(_, _, _, _, _, _, _, _, _))
+        .WillByDefault(Return(NIXL_ERR_NOT_SUPPORTED));
 }
 
 void

test/gtest/mocks/gmock_engine.h

@@ -17,6 +17,8 @@
 #ifndef TEST_GTEST_GMOCK_ENGINE_H
 #define TEST_GTEST_GMOCK_ENGINE_H
 
+#include <chrono>
+
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
@@ -56,8 +58,7 @@ class GMockBackendEngine : public nixlBackendEngine {
 public:
     GMockBackendEngine();
 
-    GMockBackendEngine(const nixlBackendInitParams *init_params) : nixlBackendEngine(init_params) {}
-
+    explicit GMockBackendEngine(const nixlBackendInitParams *init_params);
 
     void
     SetToParams(nixl_b_params_t &params) const;
@@ -102,6 +103,13 @@ class GMockBackendEngine : public nixlBackendEngine {
                  nixlMemViewH &mvh,
                  const nixl_opt_b_args_t *opt_args),
                 (const, override));
+    MOCK_METHOD(nixl_status_t,
+                prepMemView,
+                (const nixl_meta_dlist_t &dlist,
+                 nixlMemViewH &mvh,
+                 const nixl_opt_b_args_t *opt_args),
+                (const, override));
+    MOCK_METHOD(void, releaseMemView, (nixlMemViewH mvh), (const, override));
     MOCK_METHOD(nixl_status_t,
                 getPublicData,
                 (const nixlBackendMD *input, std::string &str),
@@ -127,6 +135,28 @@ class GMockBackendEngine : public nixlBackendEngine {
                 genNotif,
                 (const std::string &remote_agent, const std::string &msg),
                 (const, override));
+    MOCK_METHOD(nixl_status_t,
+                queryMem,
+                (const nixl_reg_dlist_t &descs, std::vector<nixl_query_resp_t> &resp),
+                (const, override));
+    MOCK_METHOD(nixl_status_t,
+                estimateXferCost,
+                (const nixl_xfer_op_t &operation,
+                 const nixl_meta_dlist_t &local,
+                 const nixl_meta_dlist_t &remote,
+                 const std::string &remote_agent,
+                 nixlBackendReqH *const &handle,
+                 std::chrono::microseconds &duration,
+                 std::chrono::microseconds &err_margin,
+                 nixl_cost_t &method,
+                 const nixl_opt_args_t *extra_params),
+                (const, override));
+
+private:
+    void
+    setDefaults();
+    void
+    setOptionalDefaults();
 };
 
 } // namespace mocks

test/gtest/mocks/mock_backend_engine.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -90,6 +90,20 @@ MockBackendEngine::releaseReqH(nixlBackendReqH *handle) const {
     return gmock_backend_engine->releaseReqH(handle);
 }
 
+nixl_status_t
+MockBackendEngine::prepMemView(const nixl_meta_dlist_t &dlist,
+                               nixlMemViewH &mvh,
+                               const nixl_opt_b_args_t *opt_args) const {
+    assert(sharedState > 0);
+    return gmock_backend_engine->prepMemView(dlist, mvh, opt_args);
+}
+
+void
+MockBackendEngine::releaseMemView(nixlMemViewH mvh) const {
+    assert(sharedState > 0);
+    gmock_backend_engine->releaseMemView(mvh);
+}
+
 nixl_status_t
 MockBackendEngine::loadRemoteConnInfo(const std::string &remote_agent,
                                       const std::string &remote_conn_info) {
@@ -124,4 +138,26 @@ MockBackendEngine::genNotif(const std::string &remote_agent, const std::string &
     return gmock_backend_engine->genNotif(remote_agent, msg);
 }
 
+nixl_status_t
+MockBackendEngine::queryMem(const nixl_reg_dlist_t &descs,
+                            std::vector<nixl_query_resp_t> &resp) const {
+    assert(sharedState > 0);
+    return gmock_backend_engine->queryMem(descs, resp);
+}
+
+nixl_status_t
+MockBackendEngine::estimateXferCost(const nixl_xfer_op_t &operation,
+                                    const nixl_meta_dlist_t &local,
+                                    const nixl_meta_dlist_t &remote,
+                                    const std::string &remote_agent,
+                                    nixlBackendReqH *const &handle,
+                                    std::chrono::microseconds &duration,
+                                    std::chrono::microseconds &err_margin,
+                                    nixl_cost_t &method,
+                                    const nixl_opt_args_t *extra_params) const {
+    assert(sharedState > 0);
+    return gmock_backend_engine->estimateXferCost(
+        operation, local, remote, remote_agent, handle, duration, err_margin, method, extra_params);
+}
+
 } // namespace mocks

test/gtest/mocks/mock_backend_engine.h

@@ -20,6 +20,7 @@
 #include "backend/backend_engine.h"
 #include "backend/backend_plugin.h"
 #include <cassert>
+#include <chrono>
 
 namespace mocks {
 
@@ -77,6 +78,25 @@ class MockBackendEngine : public nixlBackendEngine {
       assert(sharedState > 0);
       return gmock_backend_engine->prepMemView(dlist, mvh, opt_args);
   }
+
+  nixl_status_t
+  prepMemView(const nixl_meta_dlist_t &dlist,
+              nixlMemViewH &mvh,
+              const nixl_opt_b_args_t *opt_args) const override;
+  void
+  releaseMemView(nixlMemViewH mvh) const override;
+  nixl_status_t
+  queryMem(const nixl_reg_dlist_t &descs, std::vector<nixl_query_resp_t> &resp) const override;
+  nixl_status_t
+  estimateXferCost(const nixl_xfer_op_t &operation,
+                   const nixl_meta_dlist_t &local,
+                   const nixl_meta_dlist_t &remote,
+                   const std::string &remote_agent,
+                   nixlBackendReqH *const &handle,
+                   std::chrono::microseconds &duration,
+                   std::chrono::microseconds &err_margin,
+                   nixl_cost_t &method,
+                   const nixl_opt_args_t *extra_params) const override;
   nixl_status_t getPublicData(const nixlBackendMD *meta, std::string &str) const override {
     assert(sharedState > 0);
     return gmock_backend_engine->getPublicData(meta, str);