diff --git a/source/api_c/tests/CMakeLists.txt b/source/api_c/tests/CMakeLists.txt
index ef19305004..f1a74a26a6 100644
--- a/source/api_c/tests/CMakeLists.txt
+++ b/source/api_c/tests/CMakeLists.txt
@@ -16,6 +16,10 @@ if(ENABLE_TENSORFLOW)
 endif()
 if(ENABLE_PYTORCH)
   target_compile_definitions(runUnitTests_c PRIVATE BUILD_PYTORCH)
+  # Link torch so __has_include(<torch/csrc/inductor/...>) succeeds and
+  # BUILD_PT_EXPT is set for the test binary; otherwise pt_expt tests all
+  # GTEST_SKIP() with "PyTorch support is not enabled".
+  target_link_libraries(runUnitTests_c PRIVATE "${TORCH_LIBRARIES}")
 endif()
 if(ENABLE_JAX)
   target_compile_definitions(runUnitTests_c PRIVATE BUILD_JAX)
diff --git a/source/api_c/tests/test_deeppot_a.cc b/source/api_c/tests/test_deeppot_a.cc
deleted file mode 100644
index d5e2d42bf8..0000000000
--- a/source/api_c/tests/test_deeppot_a.cc
+++ /dev/null
@@ -1,355 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <gtest/gtest.h>
-
-#include <cmath>
-#include <vector>
-
-#include "c_api.h"
-
-class TestInferDeepPotA : public ::testing::Test {
- protected:
-  double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  int atype[6] = {0, 1, 1, 0, 1, 1};
-  double box[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  float boxf[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<double> expected_e = {
-      -9.275780747115504710e+01, -1.863501786584258468e+02,
-      -1.863392472863538103e+02, -9.279281325486221021e+01,
-      -1.863671545232153903e+02, -1.863619822847602165e+02};
-  std::vector<double> expected_f = {
-      -3.034045420701179663e-01, 8.405844663871177014e-01,
-      7.696947487118485642e-02,  7.662001266663505117e-01,
-      -1.880601391333554251e-01, -6.183333871091722944e-01,
-      -5.036172391059643427e-01, -6.529525836149027151e-01,
-      5.432962643022043459e-01,  6.382357912332115024e-01,
-      -1.748518296794561167e-01, 3.457363524891907125e-01,
-      1.286482986991941552e-03,  3.757251165286925043e-01,
-      -5.972588700887541124e-01, -5.987006197104716154e-01,
-      -2.004450304880958100e-01, 2.495901655353461868e-01};
-  std::vector<double> expected_v = {
-      -2.912234126853306959e-01, -3.800610846612756388e-02,
-      2.776624987489437202e-01,  -5.053761003913598976e-02,
-      -3.152373041953385746e-01, 1.060894290092162379e-01,
-      2.826389131596073745e-01,  1.039129970665329250e-01,
-      -2.584378792325942586e-01, -3.121722367954994914e-01,
-      8.483275876786681990e-02,  2.524662342344257682e-01,
-      4.142176771106586414e-02,  -3.820285230785245428e-02,
-      -2.727311173065460545e-02, 2.668859789777112135e-01,
-      -6.448243569420382404e-02, -2.121731470426218846e-01,
-      -8.624335220278558922e-02, -1.809695356746038597e-01,
-      1.529875294531883312e-01,  -1.283658185172031341e-01,
-      -1.992682279795223999e-01, 1.409924999632362341e-01,
-      1.398322735274434292e-01,  1.804318474574856390e-01,
-      -1.470309318999652726e-01, -2.593983661598450730e-01,
-      -4.236536279233147489e-02, 3.386387920184946720e-02,
-      -4.174017537818433543e-02, -1.003500282164128260e-01,
-      1.525690815194478966e-01,  3.398976109910181037e-02,
-      1.522253908435125536e-01,  -2.349125581341701963e-01,
-      9.515545977581392825e-04,  -1.643218849228543846e-02,
-      1.993234765412972564e-02,  6.027265332209678569e-04,
-      -9.563256398907417355e-02, 1.510815124001868293e-01,
-      -7.738094816888557714e-03, 1.502832772532304295e-01,
-      -2.380965783745832010e-01, -2.309456719810296654e-01,
-      -6.666961081213038098e-02, 7.955566551234216632e-02,
-      -8.099093777937517447e-02, -3.386641099800401927e-02,
-      4.447884755740908608e-02,  1.008593228579038742e-01,
-      4.556718179228393811e-02,  -6.078081273849572641e-02};
-  int natoms;
-  double expected_tot_e;
-  std::vector<double> expected_tot_v;
-
-  DP_DeepPot* dp = nullptr;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    const char* file_name = "../../tests/infer/deeppot.pbtxt";
-    const char* model_file = "deeppot.pb";
-    DP_ConvertPbtxtToPb(file_name, model_file);
-
-    dp = DP_NewDeepPot(model_file);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {
-    remove("deeppot.pb");
-    DP_DeleteDeepPot(dp);
-  };
-};
-
-TEST_F(TestInferDeepPotA, double_infer) {
-  double* ener_ = new double;
-  double* force_ = new double[natoms * 3];
-  double* virial_ = new double[9];
-  double* atomic_ener_ = new double[natoms];
-  double* atomic_virial_ = new double[natoms * 9];
-
-  DP_DeepPotCompute(dp, natoms, coord, atype, box, ener_, force_, virial_,
-                    atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<double> force(force_, force_ + natoms * 3);
-  std::vector<double> virial(virial_, virial_ + 9);
-  std::vector<double> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<double> atomic_virial(atomic_virial_,
-                                    atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-10);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10);
-  }
-
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
-
-TEST_F(TestInferDeepPotA, float_infer) {
-  double* ener_ = new double;
-  float* force_ = new float[natoms * 3];
-  float* virial_ = new float[9];
-  float* atomic_ener_ = new float[natoms];
-  float* atomic_virial_ = new float[natoms * 9];
-
-  DP_DeepPotComputef(dp, natoms, coordf, atype, boxf, ener_, force_, virial_,
-                     atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<float> force(force_, force_ + natoms * 3);
-  std::vector<float> virial(virial_, virial_ + 9);
-  std::vector<float> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<float> atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-6);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-6);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-6);
-  }
-
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-6);
-  }
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
-
-TEST_F(TestInferDeepPotA, cutoff) {
-  double cutoff = DP_DeepPotGetCutoff(dp);
-  EXPECT_EQ(cutoff, 6.0);
-}
-
-TEST_F(TestInferDeepPotA, numb_types) {
-  int numb_types = DP_DeepPotGetNumbTypes(dp);
-  EXPECT_EQ(numb_types, 2);
-}
-
-TEST_F(TestInferDeepPotA, numb_types_spin) {
-  int numb_types_spin = DP_DeepPotGetNumbTypesSpin(dp);
-  EXPECT_EQ(numb_types_spin, 0);
-}
-
-TEST_F(TestInferDeepPotA, type_map) {
-  const char* type_map = DP_DeepPotGetTypeMap(dp);
-  char expected_type_map[] = "O H";
-  EXPECT_EQ(strcmp(type_map, expected_type_map), 0);
-  DP_DeleteChar(type_map);
-}
-
-class TestInferDeepPotANoPBC : public ::testing::Test {
- protected:
-  double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  int atype[6] = {0, 1, 1, 0, 1, 1};
-  std::vector<double> expected_e = {
-      -9.255934839310273787e+01, -1.863253376736990106e+02,
-      -1.857237299341402945e+02, -9.279308539717486326e+01,
-      -1.863708105823244239e+02, -1.863635196514972563e+02};
-  std::vector<double> expected_f = {
-      -2.161037360255332107e+00, 9.052994347015581589e-01,
-      1.635379623977007979e+00,  2.161037360255332107e+00,
-      -9.052994347015581589e-01, -1.635379623977007979e+00,
-      -1.167128117249453811e-02, 1.371975700096064992e-03,
-      -1.575265180249604477e-03, 6.226508593971802341e-01,
-      -1.816734122009256991e-01, 3.561766019664774907e-01,
-      -1.406075393906316626e-02, 3.789140061530929526e-01,
-      -6.018777878642909140e-01, -5.969188242856223736e-01,
-      -1.986125696522633155e-01, 2.472764510780630642e-01};
-  std::vector<double> expected_v = {
-      -7.042445481792056761e-01, 2.950213647777754078e-01,
-      5.329418202437231633e-01,  2.950213647777752968e-01,
-      -1.235900311906896754e-01, -2.232594111831812944e-01,
-      5.329418202437232743e-01,  -2.232594111831813499e-01,
-      -4.033073234276823849e-01, -8.949230984097404917e-01,
-      3.749002169013777030e-01,  6.772391014992630298e-01,
-      3.749002169013777586e-01,  -1.570527935667933583e-01,
-      -2.837082722496912512e-01, 6.772391014992631408e-01,
-      -2.837082722496912512e-01, -5.125052659994422388e-01,
-      4.858210330291591605e-02,  -6.902596153269104431e-03,
-      6.682612642430500391e-03,  -5.612247004554610057e-03,
-      9.767795567660207592e-04,  -9.773758942738038254e-04,
-      5.638322117219018645e-03,  -9.483806049779926932e-04,
-      8.493873281881353637e-04,  -2.941738570564985666e-01,
-      -4.482529909499673171e-02, 4.091569840186781021e-02,
-      -4.509020615859140463e-02, -1.013919988807244071e-01,
-      1.551440772665269030e-01,  4.181857726606644232e-02,
-      1.547200233064863484e-01,  -2.398213304685777592e-01,
-      -3.218625798524068354e-02, -1.012438450438508421e-02,
-      1.271639330380921855e-02,  3.072814938490859779e-03,
-      -9.556241797915024372e-02, 1.512251983492413077e-01,
-      -8.277872384009607454e-03, 1.505412040827929787e-01,
-      -2.386150620881526407e-01, -2.312295470054945568e-01,
-      -6.631490213524345034e-02, 7.932427266386249398e-02,
-      -8.053754366323923053e-02, -3.294595881137418747e-02,
-      4.342495071150231922e-02,  1.004599500126941436e-01,
-      4.450400364869536163e-02,  -5.951077548033092968e-02};
-  int natoms;
-  double expected_tot_e;
-  std::vector<double> expected_tot_v;
-
-  DP_DeepPot* dp = nullptr;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    const char* file_name = "../../tests/infer/deeppot.pbtxt";
-    const char* model_file = "deeppot.pb";
-    DP_ConvertPbtxtToPb(file_name, model_file);
-
-    dp = DP_NewDeepPot(model_file);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {
-    remove("deeppot.pb");
-
-    DP_DeleteDeepPot(dp);
-  };
-};
-
-TEST_F(TestInferDeepPotANoPBC, double_infer) {
-  double* ener_ = new double;
-  double* force_ = new double[natoms * 3];
-  double* virial_ = new double[9];
-  double* atomic_ener_ = new double[natoms];
-  double* atomic_virial_ = new double[natoms * 9];
-
-  DP_DeepPotCompute(dp, natoms, coord, atype, nullptr, ener_, force_, virial_,
-                    atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<double> force(force_, force_ + natoms * 3);
-  std::vector<double> virial(virial_, virial_ + 9);
-  std::vector<double> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<double> atomic_virial(atomic_virial_,
-                                    atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-10);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10);
-  }
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
-
-TEST_F(TestInferDeepPotANoPBC, float_infer) {
-  double* ener_ = new double;
-  float* force_ = new float[natoms * 3];
-  float* virial_ = new float[9];
-  float* atomic_ener_ = new float[natoms];
-  float* atomic_virial_ = new float[natoms * 9];
-
-  DP_DeepPotComputef(dp, natoms, coordf, atype, nullptr, ener_, force_, virial_,
-                     atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<float> force(force_, force_ + natoms * 3);
-  std::vector<float> virial(virial_, virial_ + 9);
-  std::vector<float> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<float> atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-6);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-6);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-6);
-  }
-
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-6);
-  }
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
diff --git a/source/api_c/tests/test_deeppot_a_fparam_aparam_ptexpt.cc b/source/api_c/tests/test_deeppot_a_fparam_aparam_ptexpt.cc
deleted file mode 100644
index 9b5b086092..0000000000
--- a/source/api_c/tests/test_deeppot_a_fparam_aparam_ptexpt.cc
+++ /dev/null
@@ -1,163 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C API inference for pt_expt (.pt2) backend with fparam and aparam.
-#include <gtest/gtest.h>
-
-#include <cmath>
-#include <vector>
-
-#include "c_api.h"
-
-class TestInferDeepPotAFParamAParamPtExptC : public ::testing::Test {
- protected:
-  double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  int atype[6] = {0, 0, 0, 0, 0, 0};
-  double box[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  float boxf[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  double fparam[1] = {0.25852028};
-  float fparamf[1] = {0.25852028};
-  double aparam[6] = {0.25852028, 0.25852028, 0.25852028,
-                      0.25852028, 0.25852028, 0.25852028};
-  float aparamf[6] = {0.25852028, 0.25852028, 0.25852028,
-                      0.25852028, 0.25852028, 0.25852028};
-  // Same reference values as test_deeppot_a_fparam_aparam_ptexpt.cc (C++ API)
-  // Generated from pre-committed fparam_aparam_default.pth
-  std::vector<double> expected_e = {
-      -1.038271223729636539e-01, -7.285433579124989123e-02,
-      -9.467600492266425860e-02, -1.467050207422957442e-01,
-      -7.660561676973243195e-02, -7.277296000253175023e-02};
-  std::vector<double> expected_f = {
-      6.622266941151369601e-02,  5.278739714221529489e-02,
-      2.265728009692277028e-02,  -2.606048291367509331e-02,
-      -4.538812303131847109e-02, 1.058247419681241676e-02,
-      1.679392617013223121e-01,  -2.257826240741929533e-03,
-      -4.490146347357203138e-02, -1.148364179422036724e-01,
-      -1.169790528013799069e-02, 6.140403441496700837e-02,
-      -8.078778123309421355e-02, -5.838879041789352825e-02,
-      6.773641084621376263e-02,  -1.247724902386305318e-02,
-      6.494524782787665373e-02,  -1.174787360813439457e-01};
-  std::vector<double> expected_v = {
-      -1.589185601903579381e-01, 2.586167090689088510e-03,
-      -1.575150812458056548e-04, -1.855360549216640564e-02,
-      1.949822308966445150e-02,  -1.006552178977542650e-02,
-      3.177030388421490936e-02,  1.714350280402104215e-03,
-      -1.290389705296313833e-03, -8.553511587973079699e-02,
-      -5.654638208496251539e-03, -1.286955066237439882e-02,
-      2.464156699303176462e-02,  -2.398203243424212178e-02,
-      -1.957110698882909630e-02, 2.233493653505165544e-02,
-      6.107843889444162372e-03,  1.707076397717688723e-03,
-      -1.653994136896924094e-01, 3.894358809712639147e-02,
-      -2.169596032233910010e-02, 6.819702786556020371e-03,
-      -5.018240707559744503e-03, 2.640663592968431426e-03,
-      -1.985295554050418160e-03, -3.638422207618969423e-02,
-      2.342932709960221863e-02,  -8.501331666888653493e-02,
-      -2.181253119706856591e-03, 4.311299629418858387e-03,
-      -1.910329576491436726e-03, -1.808810428459609043e-03,
-      -1.540075460017477360e-03, -1.173703527688202929e-02,
-      -2.596307050960845741e-03, 6.705026635782097323e-03,
-      -9.038454847872562370e-02, 3.011717694088476838e-02,
-      -5.083053967307901710e-02, -2.951212926932282599e-03,
-      2.342446057919112673e-02,  -4.091208178777860222e-02,
-      -1.648470670751139844e-02, -2.872262362355524484e-02,
-      4.763925761561256522e-02,  -8.300037376164930147e-02,
-      1.020429200603871836e-03,  -1.026734257188876599e-03,
-      5.678534821710372327e-02,  1.273635858276599142e-02,
-      -1.530143401888291177e-02, -1.061672032476311256e-01,
-      -2.486859787145567074e-02, 2.875323543588798395e-02};
-  int natoms;
-  double expected_tot_e;
-  std::vector<double> expected_tot_v;
-
-  DP_DeepPot* dp = nullptr;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    const char* model_file = "../../tests/infer/fparam_aparam.pt2";
-    dp = DP_NewDeepPot(model_file);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { DP_DeleteDeepPot(dp); };
-};
-
-TEST_F(TestInferDeepPotAFParamAParamPtExptC, double_infer) {
-  double* ener_ = new double;
-  double* force_ = new double[natoms * 3];
-  double* virial_ = new double[9];
-  double* atomic_ener_ = new double[natoms];
-  double* atomic_virial_ = new double[natoms * 9];
-
-  DP_DeepPotCompute2(dp, 1, natoms, coord, atype, box, fparam, aparam, ener_,
-                     force_, virial_, atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-10);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force_[ii] - expected_f[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial_[ii] - expected_tot_v[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener_[ii] - expected_e[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial_[ii] - expected_v[ii]), 1e-10);
-  }
-
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
-
-TEST_F(TestInferDeepPotAFParamAParamPtExptC, float_infer) {
-  double* ener_ = new double;
-  float* force_ = new float[natoms * 3];
-  float* virial_ = new float[9];
-  float* atomic_ener_ = new float[natoms];
-  float* atomic_virial_ = new float[natoms * 9];
-
-  DP_DeepPotComputef2(dp, 1, natoms, coordf, atype, boxf, fparamf, aparamf,
-                      ener_, force_, virial_, atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-6);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force_[ii] - expected_f[ii]), 1e-4);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial_[ii] - expected_tot_v[ii]), 1e-4);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener_[ii] - expected_e[ii]), 1e-5);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial_[ii] - expected_v[ii]), 1e-4);
-  }
-
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
diff --git a/source/api_c/tests/test_deeppot_a_ptexpt.cc b/source/api_c/tests/test_deeppot_a_ptexpt.cc
deleted file mode 100644
index 59a9832d7b..0000000000
--- a/source/api_c/tests/test_deeppot_a_ptexpt.cc
+++ /dev/null
@@ -1,313 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C API inference for pt_expt (.pt2) backend.
-// Uses the same model (converted from deeppot_sea.pth) and reference values
-// as test_deeppot_ptexpt.cc (C++ API) to verify C API works with .pt2.
-#include <gtest/gtest.h>
-
-#include <cmath>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include "c_api.h"
-
-class TestInferDeepPotAPtExptC : public ::testing::Test {
- protected:
-  double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  int atype[6] = {0, 1, 1, 0, 1, 1};
-  double box[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  float boxf[9] = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  // Same reference values as test_deeppot_ptexpt.cc
-  std::vector<double> expected_e = {-93.016873944029,  -185.923296645958,
-                                    -185.927096544970, -93.019371018039,
-                                    -185.926179995548, -185.924351901852};
-  std::vector<double> expected_f = {
-      0.006277522211,  -0.001117962774, 0.000618580445,  0.009928999655,
-      0.003026035654,  -0.006941982227, 0.000667853212,  -0.002449963843,
-      0.006506463508,  -0.007284129115, 0.000530662205,  -0.000028806821,
-      0.000068097781,  0.006121331983,  -0.009019754602, -0.009658343745,
-      -0.006110103225, 0.008865499697};
-  std::vector<double> expected_v = {
-      -0.000155238009, 0.000116605516,  -0.007869862476, 0.000465578340,
-      0.008182547185,  -0.002398713212, -0.008112887338, -0.002423738425,
-      0.007210716605,  -0.019203504012, 0.001724938709,  0.009909211091,
-      0.001153857542,  -0.001600015103, -0.000560024090, 0.010727836276,
-      -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664,
-      0.004866398692,  -0.003360038617, -0.007241406162, 0.005920941051,
-      0.004899151657,  0.006290788591,  -0.006478820311, 0.001921504710,
-      0.001313470921,  -0.000304091236, 0.001684345981,  0.004124109256,
-      -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859,
-      -0.015230664587, -0.000110244376, 0.000690319396,  0.000045953023,
-      -0.005726548770, 0.008769818495,  -0.000572380210, 0.008860603423,
-      -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696,
-      -0.005987066507, -0.002767831232, 0.003746502525,  0.007697590397,
-      0.003746130152,  -0.005172634748};
-  int natoms;
-  double expected_tot_e;
-  std::vector<double> expected_tot_v;
-
-  DP_DeepPot* dp = nullptr;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    const char* model_file = "../../tests/infer/deeppot_sea.pt2";
-    dp = DP_NewDeepPot(model_file);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { DP_DeleteDeepPot(dp); };
-};
-
-TEST_F(TestInferDeepPotAPtExptC, double_infer) {
-  double* ener_ = new double;
-  double* force_ = new double[natoms * 3];
-  double* virial_ = new double[9];
-  double* atomic_ener_ = new double[natoms];
-  double* atomic_virial_ = new double[natoms * 9];
-
-  DP_DeepPotCompute(dp, natoms, coord, atype, box, ener_, force_, virial_,
-                    atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<double> force(force_, force_ + natoms * 3);
-  std::vector<double> virial(virial_, virial_ + 9);
-  std::vector<double> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<double> atomic_virial(atomic_virial_,
-                                    atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-10);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10);
-  }
-
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
-
-TEST_F(TestInferDeepPotAPtExptC, float_infer) {
-  double* ener_ = new double;
-  float* force_ = new float[natoms * 3];
-  float* virial_ = new float[9];
-  float* atomic_ener_ = new float[natoms];
-  float* atomic_virial_ = new float[natoms * 9];
-
-  DP_DeepPotComputef(dp, natoms, coordf, atype, boxf, ener_, force_, virial_,
-                     atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<float> force(force_, force_ + natoms * 3);
-  std::vector<float> virial(virial_, virial_ + 9);
-  std::vector<float> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<float> atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-6);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-4);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-4);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-4);
-  }
-
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
-
-TEST_F(TestInferDeepPotAPtExptC, cutoff) {
-  double cutoff = DP_DeepPotGetCutoff(dp);
-  EXPECT_EQ(cutoff, 6.0);
-}
-
-TEST_F(TestInferDeepPotAPtExptC, numb_types) {
-  int numb_types = DP_DeepPotGetNumbTypes(dp);
-  EXPECT_EQ(numb_types, 2);
-}
-
-TEST_F(TestInferDeepPotAPtExptC, numb_types_spin) {
-  int numb_types_spin = DP_DeepPotGetNumbTypesSpin(dp);
-  EXPECT_EQ(numb_types_spin, 0);
-}
-
-TEST_F(TestInferDeepPotAPtExptC, type_map) {
-  const char* type_map = DP_DeepPotGetTypeMap(dp);
-  EXPECT_STREQ(type_map, "O H");
-  DP_DeleteChar(type_map);
-}
-
-class TestInferDeepPotAPtExptCNoPbc : public ::testing::Test {
- protected:
-  double coord[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  float coordf[18] = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-                      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  int atype[6] = {0, 1, 1, 0, 1, 1};
-  // Same NoPbc reference values as test_deeppot_ptexpt.cc
-  std::vector<double> expected_e = {-93.003304908874,  -185.915806542480,
-                                    -185.928116717624, -93.017934934346,
-                                    -185.924393412278, -185.923906740801};
-  std::vector<double> expected_f = {
-      0.000868182637,  -0.000363698132, -0.000657003077, -0.000868182637,
-      0.000363698132,  0.000657003077,  0.007932614680,  -0.001003609844,
-      0.000737731722,  -0.003883788858, 0.000686896282,  -0.000578400682,
-      0.004064895086,  0.006115547962,  -0.008747097814, -0.008113720908,
-      -0.005798834400, 0.008587766774};
-  std::vector<double> expected_v = {
-      0.007762485364,  -0.003251851977, -0.005874313248, -0.003251851977,
-      0.001362262315,  0.002460860955,  -0.005874313248, 0.002460860955,
-      0.004445426242,  -0.007120030212, 0.002982715359,  0.005388130971,
-      0.002982715359,  -0.001249515894, -0.002257190002, 0.005388130971,
-      -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835,
-      -0.001522876482, 0.001796574704,  -0.000358803950, 0.000369710813,
-      -0.001108943040, 0.000332585300,  -0.000395481309, 0.008873525623,
-      0.001919112114,  -0.001486235522, 0.002002929532,  0.004222469272,
-      -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295,
-      -0.006548889778, -0.000465126991, 0.001002876603,  0.000240398734,
-      -0.005794489784, 0.008940685179,  -0.000121727685, 0.008931999051,
-      -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837,
-      -0.005278283465, -0.002662692758, 0.003618275905,  0.007095320684,
-      0.003648086464,  -0.005023397513};
-  int natoms;
-  double expected_tot_e;
-  std::vector<double> expected_tot_v;
-
-  DP_DeepPot* dp = nullptr;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    const char* model_file = "../../tests/infer/deeppot_sea.pt2";
-    dp = DP_NewDeepPot(model_file);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { DP_DeleteDeepPot(dp); };
-};
-
-TEST_F(TestInferDeepPotAPtExptCNoPbc, double_infer) {
-  double* ener_ = new double;
-  double* force_ = new double[natoms * 3];
-  double* virial_ = new double[9];
-  double* atomic_ener_ = new double[natoms];
-  double* atomic_virial_ = new double[natoms * 9];
-
-  DP_DeepPotCompute(dp, natoms, coord, atype, nullptr, ener_, force_, virial_,
-                    atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<double> force(force_, force_ + natoms * 3);
-  std::vector<double> virial(virial_, virial_ + 9);
-  std::vector<double> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<double> atomic_virial(atomic_virial_,
-                                    atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-10);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-10);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-10);
-  }
-
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
-
-TEST_F(TestInferDeepPotAPtExptCNoPbc, float_infer) {
-  double* ener_ = new double;
-  float* force_ = new float[natoms * 3];
-  float* virial_ = new float[9];
-  float* atomic_ener_ = new float[natoms];
-  float* atomic_virial_ = new float[natoms * 9];
-
-  DP_DeepPotComputef(dp, natoms, coordf, atype, nullptr, ener_, force_, virial_,
-                     atomic_ener_, atomic_virial_);
-
-  double ener = *ener_;
-  std::vector<float> force(force_, force_ + natoms * 3);
-  std::vector<float> virial(virial_, virial_ + 9);
-  std::vector<float> atomic_ener(atomic_ener_, atomic_ener_ + natoms);
-  std::vector<float> atomic_virial(atomic_virial_, atomic_virial_ + natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), 1e-6);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), 1e-4);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), 1e-4);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atomic_ener[ii] - expected_e[ii]), 1e-5);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atomic_virial[ii] - expected_v[ii]), 1e-4);
-  }
-
-  delete ener_;
-  delete[] force_;
-  delete[] virial_;
-  delete[] atomic_ener_;
-  delete[] atomic_virial_;
-}
diff --git a/source/api_c/tests/test_deeppot_universal.cc b/source/api_c/tests/test_deeppot_universal.cc
new file mode 100644
index 0000000000..d79c831295
--- /dev/null
+++ b/source/api_c/tests/test_deeppot_universal.cc
@@ -0,0 +1,430 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+#include <gtest/gtest.h>
+
+#include <cmath>
+#include <cstdio>
+#include <exception>
+#include <string>
+#include <vector>
+
+#include "../../api_cc/tests/deeppot_universal_test_common.h"
+#include "c_api.h"
+
+namespace {
+
+using namespace deepmd_test::universal;
+
+::testing::AssertionResult convert_pbtxt_model(const std::string& source,
+                                               const std::string& target) {
+  try {
+    DP_ConvertPbtxtToPb(source.c_str(), target.c_str());
+  } catch (const std::exception& e) {
+    return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for "
+                                         << source << ": " << e.what();
+  } catch (...) {
+    return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for "
+                                         << source << ": unknown exception";
+  }
+
+  if (!path_exists(target)) {
+    return ::testing::AssertionFailure()
+           << "pbtxt-to-pb conversion failed for " << source
+           << ": output was not created: " << target;
+  }
+  return ::testing::AssertionSuccess();
+}
+
+class UniversalDeepPotCTest : public ::testing::TestWithParam<ModelCase> {
+ protected:
+  DP_DeepPot* dp = nullptr;
+  std::string converted_model;
+
+  void SetUp() override {
+    const auto& param = GetParam();
+    if (!backend_enabled(param.backend)) {
+      GTEST_SKIP() << backend_name(param.backend) << " support is not enabled.";
+    }
+    ASSERT_TRUE(path_exists(param.model_path))
+        << "Model artifact is not available: " << param.model_path;
+
+    std::string model_path = param.model_path;
+    if (param.convert_pbtxt) {
+      converted_model = "deeppot_c_universal_" + param.name + ".pb";
+      ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model));
+      model_path = converted_model;
+    }
+    dp = DP_NewDeepPot(model_path.c_str());
+    const char* error = DP_DeepPotCheckOK(dp);
+    const std::string error_message(error);
+    DP_DeleteChar(error);
+    ASSERT_TRUE(error_message.empty())
+        << "Model artifact cannot be loaded by this backend: " << error_message;
+  }
+
+  void TearDown() override {
+    DP_DeleteDeepPot(dp);
+    if (!converted_model.empty()) {
+      remove(converted_model.c_str());
+    }
+  }
+};
+
+class FParamAParamDeepPotCTest
+    : public ::testing::TestWithParam<FParamAParamCase> {
+ protected:
+  DP_DeepPot* dp = nullptr;
+  std::string converted_model;
+  deepmd_test::DeepPotRef loaded_ref;
+  const deepmd_test::DeepPotRef* ref = nullptr;
+
+  void SetUp() override {
+    const auto& param = GetParam();
+    if (!backend_enabled(param.backend)) {
+      GTEST_SKIP() << backend_name(param.backend) << " support is not enabled.";
+    }
+    ASSERT_TRUE(path_exists(param.model_path))
+        << "Model artifact is not available: " << param.model_path;
+    if (param.builtin_ref != nullptr) {
+      ref = param.builtin_ref;
+    } else {
+      ASSERT_TRUE(path_exists(param.ref_path))
+          << "Reference artifact is not available: " << param.ref_path;
+      loaded_ref = load_fparam_ref(param.ref_path);
+      ref = &loaded_ref;
+    }
+
+    std::string model_path = param.model_path;
+    if (param.convert_pbtxt) {
+      converted_model = "deeppot_c_fparam_aparam_" + param.name + ".pb";
+      ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model));
+      model_path = converted_model;
+    }
+    dp = DP_NewDeepPot(model_path.c_str());
+    const char* error = DP_DeepPotCheckOK(dp);
+    const std::string error_message(error);
+    DP_DeleteChar(error);
+    ASSERT_TRUE(error_message.empty())
+        << "Model artifact cannot be loaded by this backend: " << error_message;
+  }
+
+  void TearDown() override {
+    DP_DeleteDeepPot(dp);
+    if (!converted_model.empty()) {
+      remove(converted_model.c_str());
+    }
+  }
+};
+
+TEST_P(UniversalDeepPotCTest, Metadata) {
+  const auto& ref = *GetParam().ref;
+
+  EXPECT_DOUBLE_EQ(DP_DeepPotGetCutoff(dp), ref.cutoff);
+  EXPECT_EQ(DP_DeepPotGetNumbTypes(dp), ref.numb_types);
+  EXPECT_EQ(DP_DeepPotGetNumbTypesSpin(dp), ref.numb_types_spin);
+  EXPECT_EQ(DP_DeepPotGetDimFParam(dp), ref.dim_fparam);
+  EXPECT_EQ(DP_DeepPotGetDimAParam(dp), ref.dim_aparam);
+  EXPECT_EQ(DP_DeepPotIsAParamNAll(dp), ref.aparam_nall);
+  EXPECT_EQ(DP_DeepPotHasDefaultFParam(dp), ref.has_default_fparam);
+
+  const char* type_map = DP_DeepPotGetTypeMap(dp);
+  EXPECT_STREQ(type_map, ref.type_map.c_str());
+  DP_DeleteChar(type_map);
+}
+
+void check_compute_double(DP_DeepPot* dp,
+                          const deepmd_test::DeepPotRef& ref,
+                          const double tol) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<double>& coord = deepmd_test::deeppot_coord();
+  const std::vector<double>& box = deepmd_test::deeppot_box();
+  const std::vector<int>& atype = deepmd_test::deeppot_atype();
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  double energy = 0.0;
+  std::vector<double> force(natoms * 3);
+  std::vector<double> virial(9);
+  std::vector<double> atomic_energy(natoms);
+  std::vector<double> atomic_virial(natoms * 9);
+  DP_DeepPotCompute2(dp, 1, natoms, coord.data(), atype.data(), box.data(),
+                     nullptr, nullptr, &energy, force.data(), virial.data(),
+                     atomic_energy.data(), atomic_virial.data());
+
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (int ii = 0; ii < natoms * 3; ++ii) {
+    EXPECT_NEAR(force[ii], ref.force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+  for (int ii = 0; ii < natoms; ++ii) {
+    EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol);
+  }
+  for (int ii = 0; ii < natoms * 9; ++ii) {
+    EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol);
+  }
+}
+
+void check_compute_float(DP_DeepPot* dp,
+                         const deepmd_test::DeepPotRef& ref,
+                         const double tol) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<float> coord(deepmd_test::deeppot_coord().begin(),
+                                 deepmd_test::deeppot_coord().end());
+  const std::vector<float> box(deepmd_test::deeppot_box().begin(),
+                               deepmd_test::deeppot_box().end());
+  const std::vector<int>& atype = deepmd_test::deeppot_atype();
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  double energy = 0.0;
+  std::vector<float> force(natoms * 3);
+  std::vector<float> virial(9);
+  std::vector<float> atomic_energy(natoms);
+  std::vector<float> atomic_virial(natoms * 9);
+  DP_DeepPotComputef2(dp, 1, natoms, coord.data(), atype.data(), box.data(),
+                      nullptr, nullptr, &energy, force.data(), virial.data(),
+                      atomic_energy.data(), atomic_virial.data());
+
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (int ii = 0; ii < natoms * 3; ++ii) {
+    EXPECT_NEAR(force[ii], ref.force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+  for (int ii = 0; ii < natoms; ++ii) {
+    EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol);
+  }
+  for (int ii = 0; ii < natoms * 9; ++ii) {
+    EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol);
+  }
+}
+
+void check_compute_legacy_double(DP_DeepPot* dp,
+                                 const deepmd_test::DeepPotRef& ref,
+                                 const double* box,
+                                 const double tol) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<double>& coord = deepmd_test::deeppot_coord();
+  const std::vector<int>& atype = deepmd_test::deeppot_atype();
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  double energy = 0.0;
+  std::vector<double> force(natoms * 3);
+  std::vector<double> virial(9);
+  std::vector<double> atomic_energy(natoms);
+  std::vector<double> atomic_virial(natoms * 9);
+  DP_DeepPotCompute(dp, natoms, coord.data(), atype.data(), box, &energy,
+                    force.data(), virial.data(), atomic_energy.data(),
+                    atomic_virial.data());
+
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (int ii = 0; ii < natoms * 3; ++ii) {
+    EXPECT_NEAR(force[ii], ref.force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+  for (int ii = 0; ii < natoms; ++ii) {
+    EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol);
+  }
+  for (int ii = 0; ii < natoms * 9; ++ii) {
+    EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol);
+  }
+}
+
+void check_compute_legacy_float(DP_DeepPot* dp,
+                                const deepmd_test::DeepPotRef& ref,
+                                const float* box,
+                                const double tol) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<float> coord(deepmd_test::deeppot_coord().begin(),
+                                 deepmd_test::deeppot_coord().end());
+  const std::vector<int>& atype = deepmd_test::deeppot_atype();
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  double energy = 0.0;
+  std::vector<float> force(natoms * 3);
+  std::vector<float> virial(9);
+  std::vector<float> atomic_energy(natoms);
+  std::vector<float> atomic_virial(natoms * 9);
+  DP_DeepPotComputef(dp, natoms, coord.data(), atype.data(), box, &energy,
+                     force.data(), virial.data(), atomic_energy.data(),
+                     atomic_virial.data());
+
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (int ii = 0; ii < natoms * 3; ++ii) {
+    EXPECT_NEAR(force[ii], ref.force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+  for (int ii = 0; ii < natoms; ++ii) {
+    EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol);
+  }
+  for (int ii = 0; ii < natoms * 9; ++ii) {
+    EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol);
+  }
+}
+
+void check_fparam_compute_double(DP_DeepPot* dp,
+                                 const deepmd_test::DeepPotRef& ref,
+                                 const double tol) {
+  const int natoms =
+      static_cast<int>(deepmd_test::fparam_aparam_atype().size());
+  const std::vector<double>& coord = deepmd_test::deeppot_coord();
+  const std::vector<double>& box = deepmd_test::deeppot_box();
+  const std::vector<int>& atype = deepmd_test::fparam_aparam_atype();
+  const std::vector<double>& fparam = deepmd_test::fparam_value();
+  const std::vector<double>& aparam = deepmd_test::aparam_value();
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  double energy = 0.0;
+  std::vector<double> force(natoms * 3);
+  std::vector<double> virial(9);
+  std::vector<double> atomic_energy(natoms);
+  std::vector<double> atomic_virial(natoms * 9);
+  DP_DeepPotCompute2(dp, 1, natoms, coord.data(), atype.data(), box.data(),
+                     fparam.data(), aparam.data(), &energy, force.data(),
+                     virial.data(), atomic_energy.data(), atomic_virial.data());
+
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (int ii = 0; ii < natoms * 3; ++ii) {
+    EXPECT_NEAR(force[ii], ref.force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+  for (int ii = 0; ii < natoms; ++ii) {
+    EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol);
+  }
+  for (int ii = 0; ii < natoms * 9; ++ii) {
+    EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol);
+  }
+}
+
+void check_fparam_compute_float(DP_DeepPot* dp,
+                                const deepmd_test::DeepPotRef& ref,
+                                const double tol) {
+  const int natoms =
+      static_cast<int>(deepmd_test::fparam_aparam_atype().size());
+  const std::vector<float> coord(deepmd_test::deeppot_coord().begin(),
+                                 deepmd_test::deeppot_coord().end());
+  const std::vector<float> box(deepmd_test::deeppot_box().begin(),
+                               deepmd_test::deeppot_box().end());
+  const std::vector<int>& atype = deepmd_test::fparam_aparam_atype();
+  const std::vector<float> fparam(deepmd_test::fparam_value().begin(),
+                                  deepmd_test::fparam_value().end());
+  const std::vector<float> aparam(deepmd_test::aparam_value().begin(),
+                                  deepmd_test::aparam_value().end());
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  double energy = 0.0;
+  std::vector<float> force(natoms * 3);
+  std::vector<float> virial(9);
+  std::vector<float> atomic_energy(natoms);
+  std::vector<float> atomic_virial(natoms * 9);
+  DP_DeepPotComputef2(dp, 1, natoms, coord.data(), atype.data(), box.data(),
+                      fparam.data(), aparam.data(), &energy, force.data(),
+                      virial.data(), atomic_energy.data(),
+                      atomic_virial.data());
+
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (int ii = 0; ii < natoms * 3; ++ii) {
+    EXPECT_NEAR(force[ii], ref.force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+  for (int ii = 0; ii < natoms; ++ii) {
+    EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol);
+  }
+  for (int ii = 0; ii < natoms * 9; ++ii) {
+    EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol);
+  }
+}
+
+TEST_P(UniversalDeepPotCTest, ComputeDouble) {
+  check_compute_double(dp, *GetParam().ref, GetParam().double_tol);
+}
+
+TEST_P(UniversalDeepPotCTest, ComputeFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_compute_float(dp, *GetParam().ref, GetParam().float_tol);
+}
+
+TEST_P(UniversalDeepPotCTest, ComputeLegacyDouble) {
+  const std::vector<double>& box = deepmd_test::deeppot_box();
+  check_compute_legacy_double(dp, *GetParam().ref, box.data(),
+                              GetParam().double_tol);
+}
+
+TEST_P(UniversalDeepPotCTest, ComputeLegacyFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  const std::vector<double>& box_double = deepmd_test::deeppot_box();
+  const std::vector<float> box(box_double.begin(), box_double.end());
+  check_compute_legacy_float(dp, *GetParam().ref, box.data(),
+                             GetParam().float_tol);
+}
+
+TEST_P(UniversalDeepPotCTest, ComputeLegacyNoPbcDouble) {
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_legacy_double(dp, *GetParam().no_pbc_ref, nullptr,
+                              GetParam().double_tol);
+}
+
+TEST_P(UniversalDeepPotCTest, ComputeLegacyNoPbcFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_legacy_float(dp, *GetParam().no_pbc_ref, nullptr,
+                             GetParam().float_tol);
+}
+
+TEST_P(FParamAParamDeepPotCTest, Metadata) {
+  EXPECT_EQ(DP_DeepPotGetDimFParam(dp), 1);
+  EXPECT_EQ(DP_DeepPotGetDimAParam(dp), 1);
+  EXPECT_FALSE(DP_DeepPotHasDefaultFParam(dp));
+}
+
+TEST_P(FParamAParamDeepPotCTest, ComputeDouble) {
+  check_fparam_compute_double(dp, *ref, GetParam().double_tol);
+}
+
+TEST_P(FParamAParamDeepPotCTest, ComputeFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_compute_float(dp, *ref, GetParam().float_tol);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    AvailableBackends,
+    UniversalDeepPotCTest,
+    ::testing::ValuesIn(model_cases()),
+    [](const ::testing::TestParamInfo<UniversalDeepPotCTest::ParamType>& info) {
+      return info.param.name;
+    });
+
+INSTANTIATE_TEST_SUITE_P(
+    FParamAParamBackends,
+    FParamAParamDeepPotCTest,
+    ::testing::ValuesIn(fparam_aparam_cases()),
+    [](const ::testing::TestParamInfo<FParamAParamDeepPotCTest::ParamType>&
+           info) { return info.param.name; });
+
+}  // namespace
diff --git a/source/api_cc/tests/deeppot_universal_test_common.h b/source/api_cc/tests/deeppot_universal_test_common.h
new file mode 100644
index 0000000000..565a151760
--- /dev/null
+++ b/source/api_cc/tests/deeppot_universal_test_common.h
@@ -0,0 +1,165 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+#pragma once
+
+#include <sys/stat.h>
+
+#include <string>
+#include <vector>
+
+#include "../../tests/infer/deeppot_universal_data.h"
+#include "DeepPotPTExpt.h"
+#include "expected_ref.h"
+
+namespace deepmd_test {
+namespace universal {
+
+enum class Backend { TensorFlow, PyTorch, PTExpt, JAX, Paddle };
+
+struct ModelCase {
+  std::string name;
+  Backend backend;
+  std::string model_path;
+  bool convert_pbtxt;
+  const DeepPotRef* ref;
+  const DeepPotRef* no_pbc_ref;
+  double double_tol;
+  double float_tol;
+  bool supports_float;
+  bool supports_nframes;
+  bool supports_lmp_nlist_mapping;
+};
+
+struct FParamAParamCase {
+  std::string name;
+  Backend backend;
+  std::string model_path;
+  bool convert_pbtxt;
+  const DeepPotRef* builtin_ref;
+  std::string ref_path;
+  double double_tol;
+  double float_tol;
+  bool supports_float;
+};
+
+inline bool path_exists(const std::string& path) {
+  struct stat statbuf;
+  return stat(path.c_str(), &statbuf) == 0;
+}
+
+inline bool backend_enabled(Backend backend) {
+  switch (backend) {
+    case Backend::TensorFlow:
+#ifdef BUILD_TENSORFLOW
+      return true;
+#else
+      return false;
+#endif
+    case Backend::PyTorch:
+#ifdef BUILD_PYTORCH
+      return true;
+#else
+      return false;
+#endif
+    case Backend::PTExpt:
+#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
+      return true;
+#else
+      return false;
+#endif
+    case Backend::JAX:
+#ifdef BUILD_JAX
+      return true;
+#else
+      return false;
+#endif
+    case Backend::Paddle:
+#ifdef BUILD_PADDLE
+      return true;
+#else
+      return false;
+#endif
+  }
+  return false;
+}
+
+inline std::string backend_name(Backend backend) {
+  switch (backend) {
+    case Backend::TensorFlow:
+      return "TensorFlow";
+    case Backend::PyTorch:
+      return "PyTorch";
+    case Backend::PTExpt:
+      return "PTExpt";
+    case Backend::JAX:
+      return "JAX";
+    case Backend::Paddle:
+      return "Paddle";
+  }
+  return "Unknown";
+}
+
+inline std::vector<ModelCase> model_cases() {
+  return {
+      {"tensorflow_pb", Backend::TensorFlow, "../../tests/infer/deeppot.pbtxt",
+       /*convert_pbtxt=*/true, &tf_deeppot_ref(), &tf_deeppot_no_pbc_ref(),
+       1e-10, 1e-4,
+       /*supports_float=*/true,
+       /*supports_nframes=*/true,
+       /*supports_lmp_nlist_mapping=*/true},
+      {"pytorch_pth", Backend::PyTorch, "../../tests/infer/deeppot_sea.pth",
+       /*convert_pbtxt=*/false, &sea_deeppot_ref(), &sea_deeppot_no_pbc_ref(),
+       1e-10, 1e-4,
+       /*supports_float=*/true,
+       /*supports_nframes=*/false,
+       /*supports_lmp_nlist_mapping=*/true},
+      {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/deeppot_sea.pt2",
+       /*convert_pbtxt=*/false, &sea_deeppot_ref(), &sea_deeppot_no_pbc_ref(),
+       1e-10, 1e-4,
+       /*supports_float=*/true,
+       /*supports_nframes=*/false,
+       /*supports_lmp_nlist_mapping=*/true},
+      {"jax_savedmodel", Backend::JAX,
+       "../../tests/infer/deeppot_sea.savedmodel",
+       /*convert_pbtxt=*/false, &sea_deeppot_ref(), nullptr, 1e-10, 1e-4,
+       /*supports_float=*/true,
+       /*supports_nframes=*/false,
+       /*supports_lmp_nlist_mapping=*/true},
+      {"paddle_json", Backend::Paddle, "../../tests/infer/deeppot_sea.json",
+       /*convert_pbtxt=*/false, &sea_deeppot_ref(), nullptr, 1e-7, 1e-4,
+       /*supports_float=*/false,
+       /*supports_nframes=*/false,
+       /*supports_lmp_nlist_mapping=*/false}};
+}
+
+inline std::vector<FParamAParamCase> fparam_aparam_cases() {
+  return {
+      {"tensorflow_pb", Backend::TensorFlow,
+       "../../tests/infer/fparam_aparam.pbtxt",
+       /*convert_pbtxt=*/true, &tf_fparam_aparam_ref(), "", 1e-10, 1e-4,
+       /*supports_float=*/true},
+      {"pytorch_pth", Backend::PyTorch, "../../tests/infer/fparam_aparam.pth",
+       /*convert_pbtxt=*/false, nullptr,
+       "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4,
+       /*supports_float=*/true},
+      {"pytorch_pt2", Backend::PTExpt, "../../tests/infer/fparam_aparam.pt2",
+       /*convert_pbtxt=*/false, nullptr,
+       "../../tests/infer/fparam_aparam.expected", 1e-7, 1e-4,
+       /*supports_float=*/true}};
+}
+
+inline DeepPotRef load_fparam_ref(const std::string& ref_path) {
+  ExpectedRef ref_file;
+  ref_file.load(ref_path);
+  DeepPotRef ref;
+  ref.atomic_energy = ref_file.get<double>("default", "expected_e");
+  ref.force = ref_file.get<double>("default", "expected_f");
+  ref.atomic_virial = ref_file.get<double>("default", "expected_v");
+  ref.numb_types = 1;
+  ref.dim_fparam = 1;
+  ref.dim_aparam = 1;
+  ref.type_map = "O";
+  return ref;
+}
+
+}  // namespace universal
+}  // namespace deepmd_test
diff --git a/source/api_cc/tests/test_deepdipole_pt.cc b/source/api_cc/tests/test_deepdipole_pt.cc
index 473f697188..cfb82bf721 100644
--- a/source/api_cc/tests/test_deepdipole_pt.cc
+++ b/source/api_cc/tests/test_deepdipole_pt.cc
@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <cmath>
 #include <fstream>
-#include <sstream>
 #include <vector>
 
 #include "DeepTensor.h"
@@ -147,18 +146,9 @@ TYPED_TEST(TestInferDeepTensorPt, print_summary) {
 
 TYPED_TEST(TestInferDeepTensorPt, get_type_map) {
   deepmd::DeepTensor& dt = this->dt;
-  std::string type_map_str;
-  dt.get_type_map(type_map_str);
-  // Parse the type map string manually
-  std::vector<std::string> type_map;
-  std::istringstream iss(type_map_str);
-  std::string token;
-  while (iss >> token) {
-    type_map.push_back(token);
-  }
-  EXPECT_EQ(type_map.size(), 2);
-  EXPECT_EQ(type_map[0], "O");
-  EXPECT_EQ(type_map[1], "H");
+  std::string type_map;
+  dt.get_type_map(type_map);
+  EXPECT_EQ(type_map, "O H");
 }
 
 TYPED_TEST(TestInferDeepTensorPt, get_properties) {
diff --git a/source/api_cc/tests/test_deeppot_a.cc b/source/api_cc/tests/test_deeppot_a.cc
deleted file mode 100644
index ffd2a25a5d..0000000000
--- a/source/api_cc/tests/test_deeppot_a.cc
+++ /dev/null
@@ -1,668 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-template <class VALUETYPE>
-class TestInferDeepPotA : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e = {
-      -9.275780747115504710e+01, -1.863501786584258468e+02,
-      -1.863392472863538103e+02, -9.279281325486221021e+01,
-      -1.863671545232153903e+02, -1.863619822847602165e+02};
-  std::vector<VALUETYPE> expected_f = {
-      -3.034045420701179663e-01, 8.405844663871177014e-01,
-      7.696947487118485642e-02,  7.662001266663505117e-01,
-      -1.880601391333554251e-01, -6.183333871091722944e-01,
-      -5.036172391059643427e-01, -6.529525836149027151e-01,
-      5.432962643022043459e-01,  6.382357912332115024e-01,
-      -1.748518296794561167e-01, 3.457363524891907125e-01,
-      1.286482986991941552e-03,  3.757251165286925043e-01,
-      -5.972588700887541124e-01, -5.987006197104716154e-01,
-      -2.004450304880958100e-01, 2.495901655353461868e-01};
-  std::vector<VALUETYPE> expected_v = {
-      -2.912234126853306959e-01, -3.800610846612756388e-02,
-      2.776624987489437202e-01,  -5.053761003913598976e-02,
-      -3.152373041953385746e-01, 1.060894290092162379e-01,
-      2.826389131596073745e-01,  1.039129970665329250e-01,
-      -2.584378792325942586e-01, -3.121722367954994914e-01,
-      8.483275876786681990e-02,  2.524662342344257682e-01,
-      4.142176771106586414e-02,  -3.820285230785245428e-02,
-      -2.727311173065460545e-02, 2.668859789777112135e-01,
-      -6.448243569420382404e-02, -2.121731470426218846e-01,
-      -8.624335220278558922e-02, -1.809695356746038597e-01,
-      1.529875294531883312e-01,  -1.283658185172031341e-01,
-      -1.992682279795223999e-01, 1.409924999632362341e-01,
-      1.398322735274434292e-01,  1.804318474574856390e-01,
-      -1.470309318999652726e-01, -2.593983661598450730e-01,
-      -4.236536279233147489e-02, 3.386387920184946720e-02,
-      -4.174017537818433543e-02, -1.003500282164128260e-01,
-      1.525690815194478966e-01,  3.398976109910181037e-02,
-      1.522253908435125536e-01,  -2.349125581341701963e-01,
-      9.515545977581392825e-04,  -1.643218849228543846e-02,
-      1.993234765412972564e-02,  6.027265332209678569e-04,
-      -9.563256398907417355e-02, 1.510815124001868293e-01,
-      -7.738094816888557714e-03, 1.502832772532304295e-01,
-      -2.380965783745832010e-01, -2.309456719810296654e-01,
-      -6.666961081213038098e-02, 7.955566551234216632e-02,
-      -8.099093777937517447e-02, -3.386641099800401927e-02,
-      4.447884755740908608e-02,  1.008593228579038742e-01,
-      4.556718179228393811e-02,  -6.078081273849572641e-02};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot.pbtxt";
-    deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot.pbtxt",
-                                "deeppot.pb");
-
-    dp.init("deeppot.pb");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotA, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotA, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotA, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {};
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotA, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotA, cpu_lmp_nlist_type_sel_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy,
-      atomic_virial;
-  dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy,
-             atype_cpy, box, nall - nloc, inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotA, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotANoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e = {
-      -9.255934839310273787e+01, -1.863253376736990106e+02,
-      -1.857237299341402945e+02, -9.279308539717486326e+01,
-      -1.863708105823244239e+02, -1.863635196514972563e+02};
-  std::vector<VALUETYPE> expected_f = {
-      -2.161037360255332107e+00, 9.052994347015581589e-01,
-      1.635379623977007979e+00,  2.161037360255332107e+00,
-      -9.052994347015581589e-01, -1.635379623977007979e+00,
-      -1.167128117249453811e-02, 1.371975700096064992e-03,
-      -1.575265180249604477e-03, 6.226508593971802341e-01,
-      -1.816734122009256991e-01, 3.561766019664774907e-01,
-      -1.406075393906316626e-02, 3.789140061530929526e-01,
-      -6.018777878642909140e-01, -5.969188242856223736e-01,
-      -1.986125696522633155e-01, 2.472764510780630642e-01};
-  std::vector<VALUETYPE> expected_v = {
-      -7.042445481792056761e-01, 2.950213647777754078e-01,
-      5.329418202437231633e-01,  2.950213647777752968e-01,
-      -1.235900311906896754e-01, -2.232594111831812944e-01,
-      5.329418202437232743e-01,  -2.232594111831813499e-01,
-      -4.033073234276823849e-01, -8.949230984097404917e-01,
-      3.749002169013777030e-01,  6.772391014992630298e-01,
-      3.749002169013777586e-01,  -1.570527935667933583e-01,
-      -2.837082722496912512e-01, 6.772391014992631408e-01,
-      -2.837082722496912512e-01, -5.125052659994422388e-01,
-      4.858210330291591605e-02,  -6.902596153269104431e-03,
-      6.682612642430500391e-03,  -5.612247004554610057e-03,
-      9.767795567660207592e-04,  -9.773758942738038254e-04,
-      5.638322117219018645e-03,  -9.483806049779926932e-04,
-      8.493873281881353637e-04,  -2.941738570564985666e-01,
-      -4.482529909499673171e-02, 4.091569840186781021e-02,
-      -4.509020615859140463e-02, -1.013919988807244071e-01,
-      1.551440772665269030e-01,  4.181857726606644232e-02,
-      1.547200233064863484e-01,  -2.398213304685777592e-01,
-      -3.218625798524068354e-02, -1.012438450438508421e-02,
-      1.271639330380921855e-02,  3.072814938490859779e-03,
-      -9.556241797915024372e-02, 1.512251983492413077e-01,
-      -8.277872384009607454e-03, 1.505412040827929787e-01,
-      -2.386150620881526407e-01, -2.312295470054945568e-01,
-      -6.631490213524345034e-02, 7.932427266386249398e-02,
-      -8.053754366323923053e-02, -3.294595881137418747e-02,
-      4.342495071150231922e-02,  1.004599500126941436e-01,
-      4.450400364869536163e-02,  -5.951077548033092968e-02};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot.pbtxt";
-    deepmd::convert_pbtxt_to_pb(file_name, "deeppot.pb");
-
-    dp.init("deeppot.pb");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotANoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotANoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_a_fparam_aparam.cc b/source/api_cc/tests/test_deeppot_a_fparam_aparam.cc
deleted file mode 100644
index 93efee28fe..0000000000
--- a/source/api_cc/tests/test_deeppot_a_fparam_aparam.cc
+++ /dev/null
@@ -1,386 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-template <class VALUETYPE>
-class TestInferDeepPotAFParamAParam : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 0, 0, 0, 0, 0};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> fparam = {0.25852028};
-  std::vector<VALUETYPE> aparam = {0.25852028, 0.25852028, 0.25852028,
-                                   0.25852028, 0.25852028, 0.25852028};
-  std::vector<VALUETYPE> expected_e = {
-      -1.038271183039953804e-01, -7.285433575272914908e-02,
-      -9.467600174099155552e-02, -1.467050086239614082e-01,
-      -7.660561620618722145e-02, -7.277295998502930630e-02};
-  std::vector<VALUETYPE> expected_f = {
-      6.622266817497907132e-02,  5.278739055693523058e-02,
-      2.265727495541422845e-02,  -2.606047850915838363e-02,
-      -4.538811686410718776e-02, 1.058247569147072187e-02,
-      1.679392490937766935e-01,  -2.257828022687320690e-03,
-      -4.490145670355452645e-02, -1.148364103573685929e-01,
-      -1.169790466695089237e-02, 6.140402504113953025e-02,
-      -8.078778132132799494e-02, -5.838878056243369807e-02,
-      6.773639989682191109e-02,  -1.247724708090079161e-02,
-      6.494523955924384750e-02,  -1.174787188812918687e-01};
-  std::vector<VALUETYPE> expected_v = {
-      -1.589185553287162656e-01, 2.586163333170100279e-03,
-      -1.575127933809472624e-04, -1.855360380105876630e-02,
-      1.949822090859933826e-02,  -1.006552056166355388e-02,
-      3.177029853276916449e-02,  1.714349636720383010e-03,
-      -1.290389175187874483e-03, -8.553510339477603253e-02,
-      -5.654637257232508415e-03, -1.286954833787038420e-02,
-      2.464156457499515687e-02,  -2.398202886026797043e-02,
-      -1.957110465239037672e-02, 2.233492928605742764e-02,
-      6.107843207824020099e-03,  1.707078295947736047e-03,
-      -1.653994088976195043e-01, 3.894358678172111371e-02,
-      -2.169595969759342477e-02, 6.819704294738503786e-03,
-      -5.018242039618424008e-03, 2.640664428663210429e-03,
-      -1.985298275686078057e-03, -3.638421609610945767e-02,
-      2.342932331075030239e-02,  -8.501331914753691710e-02,
-      -2.181253413538992297e-03, 4.311300069651782287e-03,
-      -1.910329328333908129e-03, -1.808810159508548836e-03,
-      -1.540075281450827612e-03, -1.173703213175551763e-02,
-      -2.596306629910121507e-03, 6.705025662372287101e-03,
-      -9.038455005073858795e-02, 3.011717773578577451e-02,
-      -5.083054073419784880e-02, -2.951210292616929069e-03,
-      2.342445652898489383e-02,  -4.091207474993674431e-02,
-      -1.648470649301832236e-02, -2.872261885460645689e-02,
-      4.763924972552112391e-02,  -8.300036532764677732e-02,
-      1.020429228955421243e-03,  -1.026734151199098881e-03,
-      5.678534096113684732e-02,  1.273635718045938205e-02,
-      -1.530143225195957322e-02, -1.061671865629566225e-01,
-      -2.486859433265622629e-02, 2.875323131744185121e-02};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/fparam_aparam.pbtxt";
-    deepmd::convert_pbtxt_to_pb(file_name, "fparam_aparam.pb");
-
-    dp.init("fparam_aparam.pb");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { remove("fparam_aparam.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotAFParamAParam, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box, fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box,
-             fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0, fparam, aparam);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParam, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0, fparam, aparam);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_a_fparam_aparam_pt.cc b/source/api_cc/tests/test_deeppot_a_fparam_aparam_pt.cc
deleted file mode 100644
index 442a2c1b6d..0000000000
--- a/source/api_cc/tests/test_deeppot_a_fparam_aparam_pt.cc
+++ /dev/null
@@ -1,359 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// 1e-10 cannot pass; unclear bug or not
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-7 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath = "../../tests/infer/fparam_aparam.expected";
-constexpr const char* kModelPath = "../../tests/infer/fparam_aparam.pth";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotAFParamAParamPt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 0, 0, 0, 0, 0};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> fparam = {0.25852028};
-  std::vector<VALUETYPE> aparam = {0.25852028, 0.25852028, 0.25852028,
-                                   0.25852028, 0.25852028, 0.25852028};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("default", "expected_e");
-    expected_f = ref.get<VALUETYPE>("default", "expected_f");
-    expected_v = ref.get<VALUETYPE>("default", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotAFParamAParamPt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box, fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box,
-             fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0, fparam, aparam);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPt, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0, fparam, aparam);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_a_fparam_aparam_ptexpt.cc b/source/api_cc/tests/test_deeppot_a_fparam_aparam_ptexpt.cc
deleted file mode 100644
index 8b07cbd90e..0000000000
--- a/source/api_cc/tests/test_deeppot_a_fparam_aparam_ptexpt.cc
+++ /dev/null
@@ -1,341 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for pt_expt (.pt2) backend with fparam and aparam.
-// Uses a model created with type_one_side=True (required for make_fx tracing).
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "DeepPotPTExpt.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// 1e-10 cannot pass; unclear bug or not
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-7 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath = "../../tests/infer/fparam_aparam.expected";
-constexpr const char* kModelPath = "../../tests/infer/fparam_aparam.pt2";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotAFParamAParamPtExpt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 0, 0, 0, 0, 0};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> fparam = {0.25852028};
-  std::vector<VALUETYPE> aparam = {0.25852028, 0.25852028, 0.25852028,
-                                   0.25852028, 0.25852028, 0.25852028};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("default", "expected_e");
-    expected_f = ref.get<VALUETYPE>("default", "expected_f");
-    expected_v = ref.get<VALUETYPE>("default", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotAFParamAParamPtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotAFParamAParamPtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box, fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box,
-             fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0, fparam, aparam);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAFParamAParamPtExpt, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1, fparam, aparam);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-// Test that a .pt2 model without default_fparam reports false
-template <class VALUETYPE>
-class TestInferDeepPotNoDefaultFParamPtExpt : public ::testing::Test {
- protected:
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init("../../tests/infer/fparam_aparam.pt2");
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotNoDefaultFParamPtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotNoDefaultFParamPtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotNoDefaultFParamPtExpt, no_default_fparam) {
-  using VALUETYPE = TypeParam;
-  deepmd::DeepPot& dp = this->dp;
-  EXPECT_EQ(dp.dim_fparam(), 1);
-  EXPECT_FALSE(dp.has_default_fparam());
-}
-// DefaultFParam tests with expected values are in
-// test_deeppot_default_fparam_ptexpt.cc (from upstream #5343).
diff --git a/source/api_cc/tests/test_deeppot_a_nframes.cc b/source/api_cc/tests/test_deeppot_a_nframes.cc
deleted file mode 100644
index 1e7c160437..0000000000
--- a/source/api_cc/tests/test_deeppot_a_nframes.cc
+++ /dev/null
@@ -1,792 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-template <class VALUETYPE>
-class TestInferDeepPotANFrames : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {
-      12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56,
-      12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.,
-                                13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e = {
-      -9.275780747115504710e+01, -1.863501786584258468e+02,
-      -1.863392472863538103e+02, -9.279281325486221021e+01,
-      -1.863671545232153903e+02, -1.863619822847602165e+02,
-      -9.275780747115504710e+01, -1.863501786584258468e+02,
-      -1.863392472863538103e+02, -9.279281325486221021e+01,
-      -1.863671545232153903e+02, -1.863619822847602165e+02};
-  std::vector<VALUETYPE> expected_f = {
-      -3.034045420701179663e-01, 8.405844663871177014e-01,
-      7.696947487118485642e-02,  7.662001266663505117e-01,
-      -1.880601391333554251e-01, -6.183333871091722944e-01,
-      -5.036172391059643427e-01, -6.529525836149027151e-01,
-      5.432962643022043459e-01,  6.382357912332115024e-01,
-      -1.748518296794561167e-01, 3.457363524891907125e-01,
-      1.286482986991941552e-03,  3.757251165286925043e-01,
-      -5.972588700887541124e-01, -5.987006197104716154e-01,
-      -2.004450304880958100e-01, 2.495901655353461868e-01,
-      -3.034045420701179663e-01, 8.405844663871177014e-01,
-      7.696947487118485642e-02,  7.662001266663505117e-01,
-      -1.880601391333554251e-01, -6.183333871091722944e-01,
-      -5.036172391059643427e-01, -6.529525836149027151e-01,
-      5.432962643022043459e-01,  6.382357912332115024e-01,
-      -1.748518296794561167e-01, 3.457363524891907125e-01,
-      1.286482986991941552e-03,  3.757251165286925043e-01,
-      -5.972588700887541124e-01, -5.987006197104716154e-01,
-      -2.004450304880958100e-01, 2.495901655353461868e-01};
-  std::vector<VALUETYPE> expected_v = {
-      -2.912234126853306959e-01, -3.800610846612756388e-02,
-      2.776624987489437202e-01,  -5.053761003913598976e-02,
-      -3.152373041953385746e-01, 1.060894290092162379e-01,
-      2.826389131596073745e-01,  1.039129970665329250e-01,
-      -2.584378792325942586e-01, -3.121722367954994914e-01,
-      8.483275876786681990e-02,  2.524662342344257682e-01,
-      4.142176771106586414e-02,  -3.820285230785245428e-02,
-      -2.727311173065460545e-02, 2.668859789777112135e-01,
-      -6.448243569420382404e-02, -2.121731470426218846e-01,
-      -8.624335220278558922e-02, -1.809695356746038597e-01,
-      1.529875294531883312e-01,  -1.283658185172031341e-01,
-      -1.992682279795223999e-01, 1.409924999632362341e-01,
-      1.398322735274434292e-01,  1.804318474574856390e-01,
-      -1.470309318999652726e-01, -2.593983661598450730e-01,
-      -4.236536279233147489e-02, 3.386387920184946720e-02,
-      -4.174017537818433543e-02, -1.003500282164128260e-01,
-      1.525690815194478966e-01,  3.398976109910181037e-02,
-      1.522253908435125536e-01,  -2.349125581341701963e-01,
-      9.515545977581392825e-04,  -1.643218849228543846e-02,
-      1.993234765412972564e-02,  6.027265332209678569e-04,
-      -9.563256398907417355e-02, 1.510815124001868293e-01,
-      -7.738094816888557714e-03, 1.502832772532304295e-01,
-      -2.380965783745832010e-01, -2.309456719810296654e-01,
-      -6.666961081213038098e-02, 7.955566551234216632e-02,
-      -8.099093777937517447e-02, -3.386641099800401927e-02,
-      4.447884755740908608e-02,  1.008593228579038742e-01,
-      4.556718179228393811e-02,  -6.078081273849572641e-02,
-      -2.912234126853306959e-01, -3.800610846612756388e-02,
-      2.776624987489437202e-01,  -5.053761003913598976e-02,
-      -3.152373041953385746e-01, 1.060894290092162379e-01,
-      2.826389131596073745e-01,  1.039129970665329250e-01,
-      -2.584378792325942586e-01, -3.121722367954994914e-01,
-      8.483275876786681990e-02,  2.524662342344257682e-01,
-      4.142176771106586414e-02,  -3.820285230785245428e-02,
-      -2.727311173065460545e-02, 2.668859789777112135e-01,
-      -6.448243569420382404e-02, -2.121731470426218846e-01,
-      -8.624335220278558922e-02, -1.809695356746038597e-01,
-      1.529875294531883312e-01,  -1.283658185172031341e-01,
-      -1.992682279795223999e-01, 1.409924999632362341e-01,
-      1.398322735274434292e-01,  1.804318474574856390e-01,
-      -1.470309318999652726e-01, -2.593983661598450730e-01,
-      -4.236536279233147489e-02, 3.386387920184946720e-02,
-      -4.174017537818433543e-02, -1.003500282164128260e-01,
-      1.525690815194478966e-01,  3.398976109910181037e-02,
-      1.522253908435125536e-01,  -2.349125581341701963e-01,
-      9.515545977581392825e-04,  -1.643218849228543846e-02,
-      1.993234765412972564e-02,  6.027265332209678569e-04,
-      -9.563256398907417355e-02, 1.510815124001868293e-01,
-      -7.738094816888557714e-03, 1.502832772532304295e-01,
-      -2.380965783745832010e-01, -2.309456719810296654e-01,
-      -6.666961081213038098e-02, 7.955566551234216632e-02,
-      -8.099093777937517447e-02, -3.386641099800401927e-02,
-      4.447884755740908608e-02,  1.008593228579038742e-01,
-      4.556718179228393811e-02,  -6.078081273849572641e-02};
-  int natoms;
-  int nframes = 2;
-  std::vector<double> expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot.pbtxt";
-    deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot.pbtxt",
-                                "deeppot.pb");
-
-    dp.init("deeppot.pb");
-
-    natoms = expected_e.size() / nframes;
-    EXPECT_EQ(nframes * natoms * 3, expected_f.size());
-    EXPECT_EQ(nframes * natoms * 9, expected_v.size());
-    expected_tot_e.resize(nframes);
-    expected_tot_v.resize(static_cast<size_t>(nframes) * 9);
-    std::fill(expected_tot_e.begin(), expected_tot_e.end(), 0.);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int kk = 0; kk < nframes; ++kk) {
-      for (int ii = 0; ii < natoms; ++ii) {
-        expected_tot_e[kk] += expected_e[kk * natoms + ii];
-      }
-      for (int ii = 0; ii < natoms; ++ii) {
-        for (int dd = 0; dd < 9; ++dd) {
-          expected_tot_v[kk * 9 + dd] +=
-              expected_v[kk * natoms * 9 + ii * 9 + dd];
-        }
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotANFrames, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotANFrames, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotANFrames, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-  EXPECT_EQ(atom_ener.size(), nframes * natoms);
-  EXPECT_EQ(atom_vir.size(), nframes * natoms * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  std::vector<VALUETYPE> coord_first(coord.begin(), coord.begin() + 3 * natoms);
-  std::vector<VALUETYPE> box_first(box.begin(), box.begin() + 9);
-  int nloc = coord_first.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping,
-                          coord_first, atype, box_first, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  std::vector<VALUETYPE> coord_cpy2(nframes * nall * 3);
-  for (int ii = 0; ii < nframes; ++ii) {
-    for (int jj = 0; jj < nall * 3; ++jj) {
-      coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj];
-    }
-  }
-
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  std::fill(ener.begin(), ener.end(), 0.0);
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  std::vector<VALUETYPE> coord_first(coord.begin(), coord.begin() + 3 * natoms);
-  std::vector<VALUETYPE> box_first(box.begin(), box.begin() + 9);
-  int nloc = coord_first.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping,
-                          coord_first, atype, box_first, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  std::vector<VALUETYPE> coord_cpy2(nframes * nall * 3);
-  for (int ii = 0; ii < nframes; ++ii) {
-    for (int jj = 0; jj < nall * 3; ++jj) {
-      coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj];
-    }
-  }
-
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy2, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1, nframes);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-  EXPECT_EQ(atom_ener.size(), nframes * natoms);
-  EXPECT_EQ(atom_vir.size(), nframes * natoms * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  std::fill(ener.begin(), ener.end(), 0.0);
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy2, atype_cpy,
-             box, nall - nloc, inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1, nframes);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-  EXPECT_EQ(atom_ener.size(), nframes * natoms);
-  EXPECT_EQ(atom_vir.size(), nframes * natoms * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  std::vector<VALUETYPE> coord_first(coord.begin(), coord.begin() + 3 * natoms);
-  std::vector<VALUETYPE> box_first(box.begin(), box.begin() + 9);
-  int nloc = coord_first.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping,
-                          coord_first, atype, box_first, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  std::vector<VALUETYPE> coord_cpy2(nframes * nall * 3);
-  for (int ii = 0; ii < nframes; ++ii) {
-    for (int jj = 0; jj < nall * 3; ++jj) {
-      coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj];
-    }
-  }
-
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(nframes * 9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  std::fill(ener.begin(), ener.end(), 0.0);
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  // two frames
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-  expected_f.insert(expected_f.begin() + natoms * 3, expected_f_vir.begin(),
-                    expected_f_vir.end());
-  std::vector<VALUETYPE> coord_first(coord.begin(), coord.begin() + 3 * natoms);
-  std::vector<VALUETYPE> box_first(box.begin(), box.begin() + 9);
-
-  // build nlist
-  int nloc = coord_first.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping,
-                          coord_first, atype, box_first, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  std::vector<VALUETYPE> coord_cpy2(nframes * nall * 3);
-  for (int ii = 0; ii < nframes; ++ii) {
-    for (int jj = 0; jj < nall * 3; ++jj) {
-      coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj];
-    }
-  }
-
-  // dp compute
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(nframes * 9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy2, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotANFrames, cpu_lmp_nlist_type_sel_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  // two frames
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-  expected_f.insert(expected_f.begin() + natoms * 3, expected_f_vir.begin(),
-                    expected_f_vir.end());
-  std::vector<VALUETYPE> coord_first(coord.begin(), coord.begin() + 3 * natoms);
-  std::vector<VALUETYPE> box_first(box.begin(), box.begin() + 9);
-
-  // build nlist
-  int nloc = coord_first.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping,
-                          coord_first, atype, box_first, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  std::vector<VALUETYPE> coord_cpy2(nframes * nall * 3);
-  for (int ii = 0; ii < nframes; ++ii) {
-    for (int jj = 0; jj < nall * 3; ++jj) {
-      coord_cpy2[ii * nall * 3 + jj] = coord_cpy[jj];
-    }
-  }
-
-  // dp compute
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(nframes * 9, 0.0),
-      atomic_energy, atomic_virial;
-  dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy2,
-             atype_cpy, box, nall - nloc, inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3, nframes);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotANFramesNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {
-      12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56,
-      12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
-      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e = {
-      -9.255934839310273787e+01, -1.863253376736990106e+02,
-      -1.857237299341402945e+02, -9.279308539717486326e+01,
-      -1.863708105823244239e+02, -1.863635196514972563e+02,
-      -9.255934839310273787e+01, -1.863253376736990106e+02,
-      -1.857237299341402945e+02, -9.279308539717486326e+01,
-      -1.863708105823244239e+02, -1.863635196514972563e+02};
-  std::vector<VALUETYPE> expected_f = {
-      -2.161037360255332107e+00, 9.052994347015581589e-01,
-      1.635379623977007979e+00,  2.161037360255332107e+00,
-      -9.052994347015581589e-01, -1.635379623977007979e+00,
-      -1.167128117249453811e-02, 1.371975700096064992e-03,
-      -1.575265180249604477e-03, 6.226508593971802341e-01,
-      -1.816734122009256991e-01, 3.561766019664774907e-01,
-      -1.406075393906316626e-02, 3.789140061530929526e-01,
-      -6.018777878642909140e-01, -5.969188242856223736e-01,
-      -1.986125696522633155e-01, 2.472764510780630642e-01,
-      -2.161037360255332107e+00, 9.052994347015581589e-01,
-      1.635379623977007979e+00,  2.161037360255332107e+00,
-      -9.052994347015581589e-01, -1.635379623977007979e+00,
-      -1.167128117249453811e-02, 1.371975700096064992e-03,
-      -1.575265180249604477e-03, 6.226508593971802341e-01,
-      -1.816734122009256991e-01, 3.561766019664774907e-01,
-      -1.406075393906316626e-02, 3.789140061530929526e-01,
-      -6.018777878642909140e-01, -5.969188242856223736e-01,
-      -1.986125696522633155e-01, 2.472764510780630642e-01};
-  std::vector<VALUETYPE> expected_v = {
-      -7.042445481792056761e-01, 2.950213647777754078e-01,
-      5.329418202437231633e-01,  2.950213647777752968e-01,
-      -1.235900311906896754e-01, -2.232594111831812944e-01,
-      5.329418202437232743e-01,  -2.232594111831813499e-01,
-      -4.033073234276823849e-01, -8.949230984097404917e-01,
-      3.749002169013777030e-01,  6.772391014992630298e-01,
-      3.749002169013777586e-01,  -1.570527935667933583e-01,
-      -2.837082722496912512e-01, 6.772391014992631408e-01,
-      -2.837082722496912512e-01, -5.125052659994422388e-01,
-      4.858210330291591605e-02,  -6.902596153269104431e-03,
-      6.682612642430500391e-03,  -5.612247004554610057e-03,
-      9.767795567660207592e-04,  -9.773758942738038254e-04,
-      5.638322117219018645e-03,  -9.483806049779926932e-04,
-      8.493873281881353637e-04,  -2.941738570564985666e-01,
-      -4.482529909499673171e-02, 4.091569840186781021e-02,
-      -4.509020615859140463e-02, -1.013919988807244071e-01,
-      1.551440772665269030e-01,  4.181857726606644232e-02,
-      1.547200233064863484e-01,  -2.398213304685777592e-01,
-      -3.218625798524068354e-02, -1.012438450438508421e-02,
-      1.271639330380921855e-02,  3.072814938490859779e-03,
-      -9.556241797915024372e-02, 1.512251983492413077e-01,
-      -8.277872384009607454e-03, 1.505412040827929787e-01,
-      -2.386150620881526407e-01, -2.312295470054945568e-01,
-      -6.631490213524345034e-02, 7.932427266386249398e-02,
-      -8.053754366323923053e-02, -3.294595881137418747e-02,
-      4.342495071150231922e-02,  1.004599500126941436e-01,
-      4.450400364869536163e-02,  -5.951077548033092968e-02,
-      -7.042445481792056761e-01, 2.950213647777754078e-01,
-      5.329418202437231633e-01,  2.950213647777752968e-01,
-      -1.235900311906896754e-01, -2.232594111831812944e-01,
-      5.329418202437232743e-01,  -2.232594111831813499e-01,
-      -4.033073234276823849e-01, -8.949230984097404917e-01,
-      3.749002169013777030e-01,  6.772391014992630298e-01,
-      3.749002169013777586e-01,  -1.570527935667933583e-01,
-      -2.837082722496912512e-01, 6.772391014992631408e-01,
-      -2.837082722496912512e-01, -5.125052659994422388e-01,
-      4.858210330291591605e-02,  -6.902596153269104431e-03,
-      6.682612642430500391e-03,  -5.612247004554610057e-03,
-      9.767795567660207592e-04,  -9.773758942738038254e-04,
-      5.638322117219018645e-03,  -9.483806049779926932e-04,
-      8.493873281881353637e-04,  -2.941738570564985666e-01,
-      -4.482529909499673171e-02, 4.091569840186781021e-02,
-      -4.509020615859140463e-02, -1.013919988807244071e-01,
-      1.551440772665269030e-01,  4.181857726606644232e-02,
-      1.547200233064863484e-01,  -2.398213304685777592e-01,
-      -3.218625798524068354e-02, -1.012438450438508421e-02,
-      1.271639330380921855e-02,  3.072814938490859779e-03,
-      -9.556241797915024372e-02, 1.512251983492413077e-01,
-      -8.277872384009607454e-03, 1.505412040827929787e-01,
-      -2.386150620881526407e-01, -2.312295470054945568e-01,
-      -6.631490213524345034e-02, 7.932427266386249398e-02,
-      -8.053754366323923053e-02, -3.294595881137418747e-02,
-      4.342495071150231922e-02,  1.004599500126941436e-01,
-      4.450400364869536163e-02,  -5.951077548033092968e-02};
-  int natoms;
-  int nframes = 2;
-  std::vector<double> expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot.pbtxt";
-    deepmd::convert_pbtxt_to_pb(file_name, "deeppot.pb");
-
-    dp.init("deeppot.pb");
-
-    natoms = expected_e.size() / nframes;
-    EXPECT_EQ(nframes * natoms * 3, expected_f.size());
-    EXPECT_EQ(nframes * natoms * 9, expected_v.size());
-    expected_tot_e.resize(nframes);
-    expected_tot_v.resize(static_cast<size_t>(nframes) * 9);
-    std::fill(expected_tot_e.begin(), expected_tot_e.end(), 0.);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int kk = 0; kk < nframes; ++kk) {
-      for (int ii = 0; ii < natoms; ++ii) {
-        expected_tot_e[kk] += expected_e[kk * natoms + ii];
-      }
-      for (int ii = 0; ii < natoms; ++ii) {
-        for (int dd = 0; dd < 9; ++dd) {
-          expected_tot_v[kk * 9 + dd] +=
-              expected_v[kk * natoms * 9 + ii * 9 + dd];
-        }
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotANFramesNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotANFramesNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  int& nframes = this->nframes;
-  std::vector<double>& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  std::vector<double> ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(ener.size(), nframes);
-  EXPECT_EQ(force.size(), nframes * natoms * 3);
-  EXPECT_EQ(virial.size(), nframes * 9);
-
-  for (int ii = 0; ii < nframes; ++ii) {
-    EXPECT_LT(fabs(ener[ii] - expected_tot_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < nframes * 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_default_fparam_pt.cc b/source/api_cc/tests/test_deeppot_default_fparam_pt.cc
deleted file mode 100644
index fb83151ef5..0000000000
--- a/source/api_cc/tests/test_deeppot_default_fparam_pt.cc
+++ /dev/null
@@ -1,217 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// 1e-10 cannot pass; unclear bug or not
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-7 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath =
-    "../../tests/infer/fparam_aparam_default.expected";
-constexpr const char* kModelPath =
-    "../../tests/infer/fparam_aparam_default.pth";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDefaultFParamPt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 0, 0, 0, 0, 0};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  // aparam is still provided explicitly
-  std::vector<VALUETYPE> aparam = {0.25852028, 0.25852028, 0.25852028,
-                                   0.25852028, 0.25852028, 0.25852028};
-  // explicit fparam for backward compat test
-  std::vector<VALUETYPE> fparam = {0.25852028};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("default", "expected_e");
-    expected_f = ref.get<VALUETYPE>("default", "expected_f");
-    expected_v = ref.get<VALUETYPE>("default", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDefaultFParamPt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPt, attrs) {
-  using VALUETYPE = TypeParam;
-  deepmd::DeepPot& dp = this->dp;
-  EXPECT_EQ(dp.dim_fparam(), 1);
-  EXPECT_EQ(dp.dim_aparam(), 1);
-  EXPECT_TRUE(dp.has_default_fparam());
-}
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPt, cpu_build_nlist_empty_fparam) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  // Empty fparam — model should use default
-  std::vector<VALUETYPE> empty_fparam;
-  dp.compute(ener, force, virial, coord, atype, box, empty_fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPt, cpu_build_nlist_explicit_fparam) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  // Explicit fparam — backward compat
-  dp.compute(ener, force, virial, coord, atype, box, fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPt, cpu_lmp_nlist_empty_fparam) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  std::vector<VALUETYPE> empty_fparam;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0, empty_fparam, aparam);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-// Test that a model without default_fparam reports false
-template <class VALUETYPE>
-class TestInferDeepPotNoDefaultFParamPt : public ::testing::Test {
- protected:
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    dp.init("../../tests/infer/fparam_aparam.pth");
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotNoDefaultFParamPt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotNoDefaultFParamPt, no_default_fparam) {
-  using VALUETYPE = TypeParam;
-  deepmd::DeepPot& dp = this->dp;
-  EXPECT_EQ(dp.dim_fparam(), 1);
-  EXPECT_FALSE(dp.has_default_fparam());
-}
diff --git a/source/api_cc/tests/test_deeppot_default_fparam_ptexpt.cc b/source/api_cc/tests/test_deeppot_default_fparam_ptexpt.cc
deleted file mode 100644
index 72ac55c2c3..0000000000
--- a/source/api_cc/tests/test_deeppot_default_fparam_ptexpt.cc
+++ /dev/null
@@ -1,203 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for pt_expt (.pt2) backend with default_fparam.
-// Uses fparam_aparam_default.pt2: has_default_fparam=true,
-// default=[0.25852028].
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "DeepPotPTExpt.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// 1e-10 cannot pass; unclear bug or not
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-7 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath =
-    "../../tests/infer/fparam_aparam_default.expected";
-constexpr const char* kModelPath =
-    "../../tests/infer/fparam_aparam_default.pt2";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDefaultFParamPtExpt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 0, 0, 0, 0, 0};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  // aparam is still provided explicitly
-  std::vector<VALUETYPE> aparam = {0.25852028, 0.25852028, 0.25852028,
-                                   0.25852028, 0.25852028, 0.25852028};
-  // explicit fparam for backward compat test
-  std::vector<VALUETYPE> fparam = {0.25852028};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("default", "expected_e");
-    expected_f = ref.get<VALUETYPE>("default", "expected_f");
-    expected_v = ref.get<VALUETYPE>("default", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDefaultFParamPtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDefaultFParamPtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt, attrs) {
-  using VALUETYPE = TypeParam;
-  deepmd::DeepPot& dp = this->dp;
-  EXPECT_EQ(dp.dim_fparam(), 1);
-  EXPECT_EQ(dp.dim_aparam(), 1);
-  EXPECT_TRUE(dp.has_default_fparam());
-}
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt, cpu_build_nlist_empty_fparam) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  // Empty fparam — model should use default
-  std::vector<VALUETYPE> empty_fparam;
-  dp.compute(ener, force, virial, coord, atype, box, empty_fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt,
-           cpu_build_nlist_explicit_fparam) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& fparam = this->fparam;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  // Explicit fparam — backward compat
-  dp.compute(ener, force, virial, coord, atype, box, fparam, aparam);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDefaultFParamPtExpt, cpu_lmp_nlist_empty_fparam) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& aparam = this->aparam;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  std::vector<VALUETYPE> empty_fparam;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0, empty_fparam, aparam);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa1_pt.cc b/source/api_cc/tests/test_deeppot_dpa1_pt.cc
deleted file mode 100644
index 6fd24451e0..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa1_pt.cc
+++ /dev/null
@@ -1,245 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for PT (.pth) backend with DPA1 (mixed-type) model.
-// Uses the same model weights as test_deeppot_dpa_ptexpt.cc (generated from
-// dpmodel with type_one_side=True via gen_dpa1.py).
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-// Reference values come from source/tests/infer/deeppot_dpa1.expected, which
-// gen_dpa1.py regenerates at CI time alongside the .pth/.pt2 model files.
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa1.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa1.pth";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa1Pt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa1Pt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa1Pt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa1Pt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa1PtNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa1PtNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa1PtNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa1PtNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa1_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa1_ptexpt.cc
deleted file mode 100644
index d42f56b9d0..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa1_ptexpt.cc
+++ /dev/null
@@ -1,262 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for pt_expt (.pt2) backend with DPA1 (mixed-type) model.
-// Uses the same model weights as test_deeppot_dpa1_pt.cc (generated from
-// dpmodel with type_one_side=True via gen_dpa1.py).
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "DeepPotPTExpt.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa1.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa1.pt2";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa1PtExpt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa1PtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa1PtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa1PtExpt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa1PtExpt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa1PtExptNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa1PtExptNoPbc<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa1PtExptNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa1PtExptNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa1PtExptNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa2_pt.cc b/source/api_cc/tests/test_deeppot_dpa2_pt.cc
deleted file mode 100644
index 951d88e018..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa2_pt.cc
+++ /dev/null
@@ -1,325 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for PT (.pth) backend with DPA2 (mixed-type) model.
-// Reference values generated by source/tests/infer/gen_dpa2.py.
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-// Reference values come from source/tests/infer/deeppot_dpa2.expected, which
-// gen_dpa2.py regenerates at CI time alongside the .pth/.pt2 model files.
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa2.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa2.pth";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa2Pt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa2Pt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa2Pt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2Pt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa2PtNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa2PtNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtNoPbc, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box, 0,
-             inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa2_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa2_ptexpt.cc
deleted file mode 100644
index 5814f65f1b..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa2_ptexpt.cc
+++ /dev/null
@@ -1,537 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for pt_expt (.pt2) backend with DPA2 (mixed-type) model.
-// Reference values generated by source/tests/infer/gen_dpa2.py.
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "DeepPotPTExpt.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// DPA2 models need relaxed epsilon (same as test_deeppot_dpa2_pt.cc)
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa2.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa2.pt2";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa2PtExpt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa2PtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa2PtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {
-      // DPA2 needs relaxed numfv tolerance (consistent with Python places=5)
-      this->level = std::is_same<VALUETYPE, double>::value ? 1e-3 : 1e-1;
-    };
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  // DPA2 repformer uses mapping; pass it so the C++ backend can
-  // correctly map ghost atoms back to local atoms.
-  inlist.mapping = mapping.data();
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExpt, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-// ---- NoPbc fixture (box = {}) ----
-template <class VALUETYPE>
-class TestInferDeepPotDpa2PtExptNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa2PtExptNoPbc<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa2PtExptNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa2PtExptNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa2PtExptNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa3_pt.cc b/source/api_cc/tests/test_deeppot_dpa3_pt.cc
deleted file mode 100644
index 4457c5e1fb..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa3_pt.cc
+++ /dev/null
@@ -1,244 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for PT (.pth) backend with DPA3 (mixed-type) model.
-// Reference values generated by source/tests/infer/gen_dpa3.py.
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-// Reference values come from source/tests/infer/deeppot_dpa3.expected, which
-// gen_dpa3.py regenerates at CI time alongside the .pth/.pt2 model files.
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa3.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa3.pth";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa3Pt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa3Pt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa3Pt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3Pt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa3PtNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    dp.init(kModelPath);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa3PtNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa3PtNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa3_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa3_ptexpt.cc
deleted file mode 100644
index 66c9235613..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa3_ptexpt.cc
+++ /dev/null
@@ -1,537 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for pt_expt (.pt2) backend with DPA3 (mixed-type) model.
-// Reference values generated by source/tests/infer/gen_dpa3.py.
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "DeepPotPTExpt.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// DPA3 models need relaxed epsilon (same as test_deeppot_dpa3_pt.cc)
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa3.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa3.pt2";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa3PtExpt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa3PtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa3PtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {
-      // DPA3 needs relaxed numfv tolerance (consistent with Python places=5)
-      this->level = std::is_same<VALUETYPE, double>::value ? 1e-3 : 1e-1;
-    };
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  // DPA3 repflows uses mapping; pass it so the C++ backend can
-  // correctly map ghost atoms back to local atoms.
-  inlist.mapping = mapping.data();
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir * 3; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExpt, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-// ---- NoPbc fixture (box = {}) ----
-template <class VALUETYPE>
-class TestInferDeepPotDpa3PtExptNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa3PtExptNoPbc<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa3PtExptNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa3PtExptNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa3PtExptNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa4_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa4_ptexpt.cc
deleted file mode 100644
index 77200c9508..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa4_ptexpt.cc
+++ /dev/null
@@ -1,537 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for pt_expt (.pt2) backend with DPA4 (mixed-type) model.
-// Reference values generated by source/tests/infer/gen_dpa4.py.
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "DeepPotPTExpt.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// DPA4 models need relaxed epsilon (same as test_deeppot_dpa3_ptexpt.cc)
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa4.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa4.pt2";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpa4PtExpt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa4PtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa4PtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {
-      // DPA4 needs relaxed numfv tolerance (consistent with Python places=5)
-      this->level = std::is_same<VALUETYPE, double>::value ? 1e-3 : 1e-1;
-    };
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  // DPA4 is a message-passing descriptor; pass mapping so the C++ backend can
-  // correctly map ghost atoms back to local atoms.
-  inlist.mapping = mapping.data();
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir * 3; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  inlist.mapping = mapping.data();
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExpt, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-// ---- NoPbc fixture (box = {}) ----
-template <class VALUETYPE>
-class TestInferDeepPotDpa4PtExptNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpa4PtExptNoPbc<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpa4PtExptNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpa4PtExptNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpa4PtExptNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa_jax.cc b/source/api_cc/tests/test_deeppot_dpa_jax.cc
deleted file mode 100644
index 2e857450b7..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa_jax.cc
+++ /dev/null
@@ -1,399 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// 1e-10 cannot pass; unclear bug or not
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-7 : 1e-1)
-
-template <class VALUETYPE>
-class TestInferDeepPotDpaJAX : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  // Generated by the following Python code:
-  // import numpy as np
-  // from deepmd.infer import DeepPot
-  // coord = np.array([
-  //     12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-  //     00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-  //     3.51,  2.51, 2.60, 4.27,  3.22, 1.56
-  // ]).reshape(1, -1)
-  // atype = np.array([0, 1, 1, 0, 1, 1])
-  // box = np.array([13., 0., 0., 0., 13., 0., 0., 0., 13.]).reshape(1, -1)
-  // dp = DeepPot("deeppot_dpa.savedmodel")
-  // e, f, v, ae, av = dp.eval(coord, box, atype, atomic=True)
-  // np.set_printoptions(precision=16)
-  // print(f"{e.ravel()=} {v.ravel()=} {f.ravel()=} {ae.ravel()=}
-  // {av.ravel()=}")
-
-  std::vector<VALUETYPE> expected_e = {-94.24098099691867,  -187.8049502787117,
-                                       -187.80486052083617, -94.24059525229518,
-                                       -187.80366985846246, -187.8042377490619};
-  std::vector<VALUETYPE> expected_f = {
-      -0.0020150115442053, -0.0133389255924977, -0.0014347177433057,
-      -0.0140757358179293, 0.0031373814221557,  0.0098594354314677,
-      0.004755683505073,   0.0099471082374397,  -0.0080868184532793,
-      -0.0086166721574536, 0.0037803939137322,  -0.0075733131286482,
-      0.0037437603038209,  -0.008452527996008,  0.0134837461840424,
-      0.0162079757106944,  0.0049265700151781,  -0.0062483322902769};
-  std::vector<VALUETYPE> expected_v = {
-      0.0133534319524089,  0.0013445914938337,  -0.0029370551651952,
-      0.0002611806151294,  0.004662662211533,   -0.0002717443796319,
-      -0.0027779798869954, -0.0003277976466339, 0.0018284972283065,
-      0.0085710118978246,  0.0003865036653608,  -0.0057964032875089,
-      -0.0014358330222619, 0.0002912625128908,  0.001212630641674,
-      -0.0050582608957046, -0.0001087907763249, 0.0040068757134429,
-      0.0116736349373084,  0.0007055477968445,  -0.0019544933708784,
-      0.0032997459258512,  0.0037887116116712,  -0.0043140890650835,
-      -0.0034418738401156, -0.0029420616852742, 0.0038219676716965,
-      0.0147134944025738,  0.0005214313829998,  -0.0006524136175906,
-      0.0003656980996363,  0.0010046161607714,  -0.0017279359476254,
-      0.000111127036911,   -0.0017063190420654, 0.0030174567965904,
-      0.0104435705455107,  -0.0008704394438241, 0.0012354202650812,
-      0.0009397615830053,  0.0029105236407293,  -0.0044188897903449,
-      -0.0011461513500477, -0.0045759080125852, 0.0070310883421107,
-      0.0089818851995049,  0.0038819466696704,  -0.005443705549253,
-      0.0025390283635246,  0.0012121502955869,  -0.0016998728971157,
-      -0.0032355117893925, -0.0015590242752438, 0.0021980725909838};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_JAX
-    GTEST_SKIP() << "Skip because JAX support is not enabled.";
-#endif
-    dp.init("../../tests/infer/deeppot_dpa.savedmodel");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpaJAX, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpaJAX, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaJAX, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotDpaJAXNopbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  // Generated by the following Python code:
-  // import numpy as np
-  // from deepmd.infer import DeepPot
-  // coord = np.array([
-  //     12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-  //     00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-  //     3.51,  2.51, 2.60, 4.27,  3.22, 1.56
-  // ]).reshape(1, -1)
-  // atype = np.array([0, 1, 1, 0, 1, 1])
-  // box = None
-  // dp = DeepPot("deeppot_dpa.savedmodel")
-  // e, f, v, ae, av = dp.eval(coord, box, atype, atomic=True)
-  // np.set_printoptions(precision=16)
-  // print(f"{e.ravel()=} {v.ravel()=} {f.ravel()=} {ae.ravel()=}
-  // {av.ravel()=}")
-
-  std::vector<VALUETYPE> expected_e = {
-      -94.24457967995595, -187.81100287606412, -187.81417300904738,
-      -94.24110552426328, -187.80431436838532, -187.80457222464983};
-  std::vector<VALUETYPE> expected_f = {
-      0.0051417559595313,  -0.0021539788479118, -0.0038910585639696,
-      -0.0051417559595313, 0.0021539788479118,  0.0038910585639696,
-      -0.0035470615733886, 0.0003602503965239,  -0.0001895679272905,
-      -0.0117361352793328, 0.0034252835112125,  -0.0071824017939095,
-      0.0005398894945495,  -0.0084330745423862, 0.013284532676939,
-      0.0147433073581718,  0.0046475406346498,  -0.005912562955739};
-  std::vector<VALUETYPE> expected_v = {
-      1.8756488030620411e-03,  -7.8574476885035112e-04, -1.4194099050199721e-03,
-      -7.8574476885031816e-04, 3.2916334911298369e-04,  5.9461766291377029e-04,
-      -1.4194099050199305e-03, 5.9461766291377637e-04,  1.0741480362313257e-03,
-      1.9292506069911106e-03,  -8.0819957860435269e-04, -1.4599734323175548e-03,
-      -8.0819957860438912e-04, 3.3857009373966171e-04,  6.1161049191681572e-04,
-      -1.4599734323175878e-03, 6.1161049191681138e-04,  1.1048447595916697e-03,
-      7.6085550162737362e-03,  -9.6772620145935649e-04, 8.3466357433496438e-04,
-      -6.0870001592646837e-04, 7.8216372819095133e-05,  -6.6454748650881927e-05,
-      1.6484218595781155e-04,  -1.4860654308892986e-05, 9.1346879754941710e-06,
-      7.3496442591020616e-03,  -4.4351638231197171e-04, 1.0048648094020743e-03,
-      -6.7678341212752506e-04, 1.0347359647873023e-03,  -1.6645682233463639e-03,
-      1.4376416549492857e-03,  -1.7116654329527997e-03, 2.8516307661164836e-03,
-      1.7683913600324828e-03,  -2.6945055858769765e-04, 3.0381043714224000e-04,
-      9.9317892494769217e-04,  2.9343081937224687e-03,  -4.4381349285303948e-03,
-      -1.6684804850477311e-03, -4.5760063242183471e-03, 6.9407432349694147e-03,
-      7.8021639779489171e-03,  3.5246152053432442e-03,  -4.9415349551876243e-03,
-      2.1362265660905197e-03,  1.2226850609509659e-03,  -1.7016886981679963e-03,
-      -2.7321994901677166e-03, -1.5683141872155984e-03, 2.1960566952029213e-03};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_JAX
-    GTEST_SKIP() << "Skip because JAX support is not enabled.";
-#endif
-    dp.init("../../tests/infer/deeppot_dpa.savedmodel");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotDpaJAXNopbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaJAXNopbc, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box, 0,
-             inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa_ptexpt.cc b/source/api_cc/tests/test_deeppot_dpa_ptexpt.cc
deleted file mode 100644
index 4a1b0d45df..0000000000
--- a/source/api_cc/tests/test_deeppot_dpa_ptexpt.cc
+++ /dev/null
@@ -1,527 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-// Test C++ inference for pt_expt (.pt2) backend with DPA1 (mixed-type) model.
-#include <gtest/gtest.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "DeepPotPTExpt.h"
-#include "expected_ref.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-// DPA1 models need relaxed epsilon (same as test_deeppot_dpa_pt.cc)
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-10 : 1e-4)
-
-namespace {
-constexpr const char* kRefPath = "../../tests/infer/deeppot_dpa1.expected";
-constexpr const char* kModelPath = "../../tests/infer/deeppot_dpa1.pt2";
-}  // namespace
-
-template <class VALUETYPE>
-class TestInferDeepPotDpaPtExpt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("pbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("pbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("pbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpaPtExpt<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpaPtExpt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {};
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir * 3; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExpt, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-// ---- NoPbc fixture (box = {}) ----
-template <class VALUETYPE>
-class TestInferDeepPotDpaPtExptNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e;
-  std::vector<VALUETYPE> expected_f;
-  std::vector<VALUETYPE> expected_v;
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  static deepmd::DeepPot dp;
-
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init(kModelPath);
-#endif
-  }
-
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    deepmd_test::ExpectedRef ref;
-    ref.load(kRefPath);
-    expected_e = ref.get<VALUETYPE>("nopbc", "expected_e");
-    expected_f = ref.get<VALUETYPE>("nopbc", "expected_f");
-    expected_v = ref.get<VALUETYPE>("nopbc", "expected_v");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.assign(9, 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestInferDeepPotDpaPtExptNoPbc<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestInferDeepPotDpaPtExptNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotDpaPtExptNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotDpaPtExptNoPbc, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-
-  std::vector<std::vector<int> > nlist_data = {
-      {1, 2, 3, 4, 5}, {0, 2, 3, 4, 5}, {0, 1, 3, 4, 5},
-      {0, 1, 2, 4, 5}, {0, 1, 2, 3, 5}, {0, 1, 2, 3, 4}};
-  std::vector<int> ilist(natoms), numneigh(natoms);
-  std::vector<int*> firstneigh(natoms);
-  deepmd::InputNlist inlist(natoms, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  dp.compute(ener, force, virial, coord, atype, box, 0, inlist, 0);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc b/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc
index a356151c76..dc43cb3719 100644
--- a/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc
+++ b/source/api_cc/tests/test_deeppot_dpa_ptexpt_spin.cc
@@ -51,17 +51,12 @@ class TestInferDeepSpinDpaPtExpt : public ::testing::Test {
   deepmd::DeepSpin dp;
 
   void SetUp() override {
-    // The .pt2 spin model requires the BUILD_PT_EXPT guard from the header.
-    // If AOTInductor headers are missing, skip.
-    {
-      std::ifstream f(kModelPath);
-      if (!f.good()) {
-        GTEST_SKIP() << "Skipping: " << kModelPath << " not found.";
-      }
-    }
 #if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN
     GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
 #endif
+    std::ifstream model_file(kModelPath);
+    ASSERT_TRUE(model_file.good())
+        << "Model artifact is not available: " << kModelPath;
     dp.init(kModelPath);
 
     deepmd_test::ExpectedRef ref;
@@ -205,15 +200,12 @@ class TestInferDeepSpinDpaPtExptNopbc : public ::testing::Test {
   deepmd::DeepSpin dp;
 
   void SetUp() override {
-    {
-      std::ifstream f(kModelPath);
-      if (!f.good()) {
-        GTEST_SKIP() << "Skipping: " << kModelPath << " not found.";
-      }
-    }
 #if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN
     GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
 #endif
+    std::ifstream model_file(kModelPath);
+    ASSERT_TRUE(model_file.good())
+        << "Model artifact is not available: " << kModelPath;
     dp.init(kModelPath);
 
     deepmd_test::ExpectedRef ref;
diff --git a/source/api_cc/tests/test_deeppot_jax.cc b/source/api_cc/tests/test_deeppot_jax.cc
deleted file mode 100644
index 80ddf00860..0000000000
--- a/source/api_cc/tests/test_deeppot_jax.cc
+++ /dev/null
@@ -1,557 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-template <class VALUETYPE>
-class TestInferDeepPotAJAX : public ::testing::Test {
- protected:
-  // import numpy as np
-  // from deepmd.infer import DeepPot
-  // coord = np.array([
-  //     12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-  //     00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-  //     3.51,  2.51, 2.60, 4.27,  3.22, 1.56
-  // ]).reshape(1, -1)
-  // atype = np.array([0, 1, 1, 0, 1, 1])
-  // box = np.array([13., 0., 0., 0., 13., 0., 0., 0., 13.]).reshape(1, -1)
-  // dp = DeepPot("deeppot_sea.savedmodel")
-  // e, f, v, ae, av = dp.eval(coord, box, atype, atomic=True)
-  // np.set_printoptions(precision=16)
-  // print(f"{e.ravel()=} {v.ravel()=} {f.ravel()=} {ae.ravel()=}
-  // {av.ravel()=}")
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  // the data in this file is just copied from PT
-  std::vector<VALUETYPE> expected_e = {
-
-      -93.016873944029, -185.923296645958, -185.927096544970,
-      -93.019371018039, -185.926179995548, -185.924351901852};
-  std::vector<VALUETYPE> expected_f = {
-
-      0.006277522211,  -0.001117962774, 0.000618580445,  0.009928999655,
-      0.003026035654,  -0.006941982227, 0.000667853212,  -0.002449963843,
-      0.006506463508,  -0.007284129115, 0.000530662205,  -0.000028806821,
-      0.000068097781,  0.006121331983,  -0.009019754602, -0.009658343745,
-      -0.006110103225, 0.008865499697};
-  std::vector<VALUETYPE> expected_v = {
-      -0.000155238009, 0.000116605516,  -0.007869862476, 0.000465578340,
-      0.008182547185,  -0.002398713212, -0.008112887338, -0.002423738425,
-      0.007210716605,  -0.019203504012, 0.001724938709,  0.009909211091,
-      0.001153857542,  -0.001600015103, -0.000560024090, 0.010727836276,
-      -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664,
-      0.004866398692,  -0.003360038617, -0.007241406162, 0.005920941051,
-      0.004899151657,  0.006290788591,  -0.006478820311, 0.001921504710,
-      0.001313470921,  -0.000304091236, 0.001684345981,  0.004124109256,
-      -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859,
-      -0.015230664587, -0.000110244376, 0.000690319396,  0.000045953023,
-      -0.005726548770, 0.008769818495,  -0.000572380210, 0.008860603423,
-      -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696,
-      -0.005987066507, -0.002767831232, 0.003746502525,  0.007697590397,
-      0.003746130152,  -0.005172634748};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_JAX
-    GTEST_SKIP() << "Skip because JAX support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot_sea.savedmodel";
-
-    dp.init(file_name);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  }
-
-  void TearDown() override {}
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotAJAX, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {};
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, cpu_lmp_nlist_type_sel_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy,
-      atomic_virial;
-  dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy,
-             atype_cpy, box, nall - nloc, inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-TYPED_TEST(TestInferDeepPotAJAX, get_type_map) {
-  deepmd::DeepPot& dp = this->dp;
-  std::string type_map;
-  dp.get_type_map(type_map);
-  EXPECT_EQ(type_map, "O H");
-}
diff --git a/source/api_cc/tests/test_deeppot_pd.cc b/source/api_cc/tests/test_deeppot_pd.cc
deleted file mode 100644
index bede9b11aa..0000000000
--- a/source/api_cc/tests/test_deeppot_pd.cc
+++ /dev/null
@@ -1,648 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <string>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-#ifdef EPSILON
-#undef EPSILON
-#define EPSILON (std::is_same<VALUETYPE, double>::value ? 1e-7 : 1e-4)
-#endif
-
-typedef testing::Types<double> PDValueTypes;
-
-template <class VALUETYPE>
-class TestInferDeepPotAPd : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e = {
-
-      -93.016873944029, -185.923296645958, -185.927096544970,
-      -93.019371018039, -185.926179995548, -185.924351901852};
-  std::vector<VALUETYPE> expected_f = {
-
-      0.006277522211,  -0.001117962774, 0.000618580445,  0.009928999655,
-      0.003026035654,  -0.006941982227, 0.000667853212,  -0.002449963843,
-      0.006506463508,  -0.007284129115, 0.000530662205,  -0.000028806821,
-      0.000068097781,  0.006121331983,  -0.009019754602, -0.009658343745,
-      -0.006110103225, 0.008865499697};
-  std::vector<VALUETYPE> expected_v = {
-      -0.000155238009, 0.000116605516,  -0.007869862476, 0.000465578340,
-      0.008182547185,  -0.002398713212, -0.008112887338, -0.002423738425,
-      0.007210716605,  -0.019203504012, 0.001724938709,  0.009909211091,
-      0.001153857542,  -0.001600015103, -0.000560024090, 0.010727836276,
-      -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664,
-      0.004866398692,  -0.003360038617, -0.007241406162, 0.005920941051,
-      0.004899151657,  0.006290788591,  -0.006478820311, 0.001921504710,
-      0.001313470921,  -0.000304091236, 0.001684345981,  0.004124109256,
-      -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859,
-      -0.015230664587, -0.000110244376, 0.000690319396,  0.000045953023,
-      -0.005726548770, 0.008769818495,  -0.000572380210, 0.008860603423,
-      -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696,
-      -0.005987066507, -0.002767831232, 0.003746502525,  0.007697590397,
-      0.003746130152,  -0.005172634748};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PADDLE
-    GTEST_SKIP() << "Skip because Paddle support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot_sea.json";
-
-    dp.init(file_name);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotAPd, PDValueTypes);
-
-TYPED_TEST(TestInferDeepPotAPd, type_map) {
-  std::string type_map = "stale";
-  this->dp.get_type_map(type_map);
-  EXPECT_EQ(type_map, "O H");
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {};
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPd, cpu_lmp_nlist_type_sel_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy,
-      atomic_virial;
-  dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy,
-             atype_cpy, box, nall - nloc, inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPd, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotAPdNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box =
-      {};  // 0-size input will be supported in the future
-  std::vector<VALUETYPE> expected_e = {-93.003304908874,  -185.915806542480,
-                                       -185.928116717624, -93.017934934346,
-                                       -185.924393412278, -185.923906740801};
-  std::vector<VALUETYPE> expected_f = {
-      0.000868182637,  -0.000363698132, -0.000657003077, -0.000868182637,
-      0.000363698132,  0.000657003077,  0.007932614680,  -0.001003609844,
-      0.000737731722,  -0.003883788858, 0.000686896282,  -0.000578400682,
-      0.004064895086,  0.006115547962,  -0.008747097814, -0.008113720908,
-      -0.005798834400, 0.008587766774};
-  std::vector<VALUETYPE> expected_v = {
-      0.007762485364,  -0.003251851977, -0.005874313248, -0.003251851977,
-      0.001362262315,  0.002460860955,  -0.005874313248, 0.002460860955,
-      0.004445426242,  -0.007120030212, 0.002982715359,  0.005388130971,
-      0.002982715359,  -0.001249515894, -0.002257190002, 0.005388130971,
-      -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835,
-      -0.001522876482, 0.001796574704,  -0.000358803950, 0.000369710813,
-      -0.001108943040, 0.000332585300,  -0.000395481309, 0.008873525623,
-      0.001919112114,  -0.001486235522, 0.002002929532,  0.004222469272,
-      -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295,
-      -0.006548889778, -0.000465126991, 0.001002876603,  0.000240398734,
-      -0.005794489784, 0.008940685179,  -0.000121727685, 0.008931999051,
-      -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837,
-      -0.005278283465, -0.002662692758, 0.003618275905,  0.007095320684,
-      0.003648086464,  -0.005023397513};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PADDLE
-    GTEST_SKIP() << "Skip because Paddle support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot_sea.json";
-    dp.init(file_name);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-/*
-NOTE: Disable TestInferDeepPotAPdNoPbc cuerrently for box is a 0-size Tensor,
-which is not fully supported in paddle yet
-*/
-// TYPED_TEST_SUITE(TestInferDeepPotAPdNoPbc, PDValueTypes);
-
-// TYPED_TEST(TestInferDeepPotAPdNoPbc, cpu_build_nlist) {
-//   using VALUETYPE = TypeParam;
-//   std::vector<VALUETYPE>& coord = this->coord;
-//   std::vector<int>& atype = this->atype;
-//   std::vector<VALUETYPE>& box = this->box;
-//   std::vector<VALUETYPE>& expected_e = this->expected_e;
-//   std::vector<VALUETYPE>& expected_f = this->expected_f;
-//   std::vector<VALUETYPE>& expected_v = this->expected_v;
-//   int& natoms = this->natoms;
-//   double& expected_tot_e = this->expected_tot_e;
-//   std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-//   deepmd::DeepPot& dp = this->dp;
-//   double ener;
-//   std::vector<VALUETYPE> force, virial;
-//   dp.compute(ener, force, virial, coord, atype, box);
-
-//   EXPECT_EQ(force.size(), natoms * 3);
-//   EXPECT_EQ(virial.size(), 9);
-
-//   EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-//   for (int ii = 0; ii < natoms * 3; ++ii) {
-//     EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-//   }
-//   for (int ii = 0; ii < 3 * 3; ++ii) {
-//     EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-//   }
-// }
diff --git a/source/api_cc/tests/test_deeppot_pt.cc b/source/api_cc/tests/test_deeppot_pt.cc
deleted file mode 100644
index 0560e976dd..0000000000
--- a/source/api_cc/tests/test_deeppot_pt.cc
+++ /dev/null
@@ -1,718 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <string>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-template <class VALUETYPE>
-class TestInferDeepPotAPt : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e = {
-
-      -93.016873944029, -185.923296645958, -185.927096544970,
-      -93.019371018039, -185.926179995548, -185.924351901852};
-  std::vector<VALUETYPE> expected_f = {
-
-      0.006277522211,  -0.001117962774, 0.000618580445,  0.009928999655,
-      0.003026035654,  -0.006941982227, 0.000667853212,  -0.002449963843,
-      0.006506463508,  -0.007284129115, 0.000530662205,  -0.000028806821,
-      0.000068097781,  0.006121331983,  -0.009019754602, -0.009658343745,
-      -0.006110103225, 0.008865499697};
-  std::vector<VALUETYPE> expected_v = {
-      -0.000155238009, 0.000116605516,  -0.007869862476, 0.000465578340,
-      0.008182547185,  -0.002398713212, -0.008112887338, -0.002423738425,
-      0.007210716605,  -0.019203504012, 0.001724938709,  0.009909211091,
-      0.001153857542,  -0.001600015103, -0.000560024090, 0.010727836276,
-      -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664,
-      0.004866398692,  -0.003360038617, -0.007241406162, 0.005920941051,
-      0.004899151657,  0.006290788591,  -0.006478820311, 0.001921504710,
-      0.001313470921,  -0.000304091236, 0.001684345981,  0.004124109256,
-      -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859,
-      -0.015230664587, -0.000110244376, 0.000690319396,  0.000045953023,
-      -0.005726548770, 0.008769818495,  -0.000572380210, 0.008860603423,
-      -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696,
-      -0.005987066507, -0.002767831232, 0.003746502525,  0.007697590397,
-      0.003746130152,  -0.005172634748};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot_sea.pth";
-
-    dp.init(file_name);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override {};
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotAPt, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotAPt, type_map) {
-  std::string type_map;
-  this->dp.get_type_map(type_map);
-  EXPECT_EQ(type_map, "O H");
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int> atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {};
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_skin_below_model_width) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_wide;
-  _build_nlist<VALUETYPE>(nlist_wide, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-
-  const double rc2 = static_cast<double>(rc) * static_cast<double>(rc);
-  bool has_skin_neighbor = false;
-  std::vector<std::vector<int> > nlist_skin(nlist_wide.size());
-  for (size_t ii = 0; ii < nlist_wide.size(); ++ii) {
-    bool added_skin_neighbor = false;
-    for (const int jj : nlist_wide[ii]) {
-      const double dx = static_cast<double>(coord_cpy[jj * 3]) -
-                        static_cast<double>(coord_cpy[ii * 3]);
-      const double dy = static_cast<double>(coord_cpy[jj * 3 + 1]) -
-                        static_cast<double>(coord_cpy[ii * 3 + 1]);
-      const double dz = static_cast<double>(coord_cpy[jj * 3 + 2]) -
-                        static_cast<double>(coord_cpy[ii * 3 + 2]);
-      const double rr = dx * dx + dy * dy + dz * dz;
-      if (rr <= rc2) {
-        nlist_skin[ii].push_back(jj);
-      } else if (!added_skin_neighbor) {
-        nlist_skin[ii].push_back(jj);
-        added_skin_neighbor = true;
-        has_skin_neighbor = true;
-      }
-    }
-  }
-  ASSERT_TRUE(has_skin_neighbor);
-
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_skin);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, cpu_lmp_nlist_type_sel_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0), atomic_energy,
-      atomic_virial;
-  dp.compute(ener, force_, virial, atomic_energy, atomic_virial, coord_cpy,
-             atype_cpy, box, nall - nloc, inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotAPt, print_summary) {
-  deepmd::DeepPot& dp = this->dp;
-  dp.print_summary("");
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotAPtNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e = {-93.003304908874,  -185.915806542480,
-                                       -185.928116717624, -93.017934934346,
-                                       -185.924393412278, -185.923906740801};
-  std::vector<VALUETYPE> expected_f = {
-      0.000868182637,  -0.000363698132, -0.000657003077, -0.000868182637,
-      0.000363698132,  0.000657003077,  0.007932614680,  -0.001003609844,
-      0.000737731722,  -0.003883788858, 0.000686896282,  -0.000578400682,
-      0.004064895086,  0.006115547962,  -0.008747097814, -0.008113720908,
-      -0.005798834400, 0.008587766774};
-  std::vector<VALUETYPE> expected_v = {
-      0.007762485364,  -0.003251851977, -0.005874313248, -0.003251851977,
-      0.001362262315,  0.002460860955,  -0.005874313248, 0.002460860955,
-      0.004445426242,  -0.007120030212, 0.002982715359,  0.005388130971,
-      0.002982715359,  -0.001249515894, -0.002257190002, 0.005388130971,
-      -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835,
-      -0.001522876482, 0.001796574704,  -0.000358803950, 0.000369710813,
-      -0.001108943040, 0.000332585300,  -0.000395481309, 0.008873525623,
-      0.001919112114,  -0.001486235522, 0.002002929532,  0.004222469272,
-      -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295,
-      -0.006548889778, -0.000465126991, 0.001002876603,  0.000240398734,
-      -0.005794489784, 0.008940685179,  -0.000121727685, 0.008931999051,
-      -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837,
-      -0.005278283465, -0.002662692758, 0.003618275905,  0.007095320684,
-      0.003648086464,  -0.005023397513};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_PYTORCH
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot_sea.pth";
-    dp.init(file_name);
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotAPtNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotAPtNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_ptexpt.cc b/source/api_cc/tests/test_deeppot_ptexpt.cc
index a4b925849c..530e1ed9f8 100644
--- a/source/api_cc/tests/test_deeppot_ptexpt.cc
+++ b/source/api_cc/tests/test_deeppot_ptexpt.cc
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // Test C++ inference for pt_expt (.pt2) backend.
-// Uses the same model (converted from deeppot_sea.pth) and reference values
-// as test_deeppot_pt.cc to verify cross-backend consistency.
+// Uses the same model (converted from deeppot_sea.pth) and shared universal
+// DeepPot reference values to verify PTExpt-specific behavior.
 #include <gtest/gtest.h>
 
 #include <algorithm>
@@ -29,7 +29,7 @@ class TestInferDeepPotAPtExpt : public ::testing::Test {
                                       8.37,  10.70, 5.76,  2.95, 7.21, 0.83};
   std::vector<int> atype = {0, 1, 1, 0, 1, 1};
   std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  // Same reference values as test_deeppot_pt.cc (model converted from .pth)
+  // Same reference values as deeppot_universal_data.h.
   std::vector<VALUETYPE> expected_e = {-93.016873944029,  -185.923296645958,
                                        -185.927096544970, -93.019371018039,
                                        -185.926179995548, -185.924351901852};
@@ -197,42 +197,6 @@ TYPED_TEST(TestInferDeepPotAPtExpt, cpu_build_nlist_numfv) {
   model.test_v(coord, box_);
 }
 
-TYPED_TEST(TestInferDeepPotAPtExpt, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
 TYPED_TEST(TestInferDeepPotAPtExpt, cpu_lmp_nlist) {
   using VALUETYPE = TypeParam;
   std::vector<VALUETYPE>& coord = this->coord;
@@ -737,7 +701,7 @@ class TestInferDeepPotAPtExptNoPbc : public ::testing::Test {
                                       8.37,  10.70, 5.76,  2.95, 7.21, 0.83};
   std::vector<int> atype = {0, 1, 1, 0, 1, 1};
   std::vector<VALUETYPE> box = {};
-  // Same reference values as TestInferDeepPotAPtNoPbc in test_deeppot_pt.cc
+  // Same NoPBC reference values as deeppot_universal_data.h.
   std::vector<VALUETYPE> expected_e = {-93.003304908874,  -185.915806542480,
                                        -185.928116717624, -93.017934934346,
                                        -185.924393412278, -185.923906740801};
@@ -831,42 +795,6 @@ TYPED_TEST(TestInferDeepPotAPtExptNoPbc, cpu_build_nlist) {
   }
 }
 
-TYPED_TEST(TestInferDeepPotAPtExptNoPbc, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
 // Multi-frame PBC test via compute_mixed_type
 TYPED_TEST(TestInferDeepPotAPtExpt, cpu_build_nlist_nframes) {
   using VALUETYPE = TypeParam;
@@ -983,57 +911,6 @@ TEST(TestDeepPotPTExptParser, load_tiny_file) {
   std::remove(tmpfile.c_str());
 }
 
-// Metadata accessor tests — exercise JSON parser on a real model
-template <class VALUETYPE>
-class TestDeepPotPTExptMetadata : public ::testing::Test {
- protected:
-  static deepmd::DeepPot dp;
-  static void SetUpTestSuite() {
-#if defined(BUILD_PYTORCH) && BUILD_PT_EXPT
-    dp.init("../../tests/infer/deeppot_sea.pt2");
-#endif
-  }
-  void SetUp() override {
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
-  };
-  void TearDown() override {};
-
-  static void TearDownTestSuite() { dp = deepmd::DeepPot(); }
-};
-
-template <class VALUETYPE>
-deepmd::DeepPot TestDeepPotPTExptMetadata<VALUETYPE>::dp;
-
-TYPED_TEST_SUITE(TestDeepPotPTExptMetadata, ValueTypes);
-
-TYPED_TEST(TestDeepPotPTExptMetadata, type_map) {
-  std::string type_map;
-  this->dp.get_type_map(type_map);
-  EXPECT_EQ(type_map, "O H");
-}
-
-TYPED_TEST(TestDeepPotPTExptMetadata, cutoff) {
-  EXPECT_GT(this->dp.cutoff(), 0.0);
-}
-
-TYPED_TEST(TestDeepPotPTExptMetadata, ntypes) {
-  EXPECT_EQ(this->dp.numb_types(), 2);
-}
-
-TYPED_TEST(TestDeepPotPTExptMetadata, dim_fparam_zero) {
-  EXPECT_EQ(this->dp.dim_fparam(), 0);
-}
-
-TYPED_TEST(TestDeepPotPTExptMetadata, dim_aparam_zero) {
-  EXPECT_EQ(this->dp.dim_aparam(), 0);
-}
-
-TYPED_TEST(TestDeepPotPTExptMetadata, no_default_fparam) {
-  EXPECT_FALSE(this->dp.has_default_fparam());
-}
-
 // JSON parser type-coverage via fparam model
 template <class VALUETYPE>
 class TestDeepPotPTExptJsonTypes : public ::testing::Test {
diff --git a/source/api_cc/tests/test_deeppot_r.cc b/source/api_cc/tests/test_deeppot_r.cc
deleted file mode 100644
index 99c5eca6e5..0000000000
--- a/source/api_cc/tests/test_deeppot_r.cc
+++ /dev/null
@@ -1,601 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-#include <fcntl.h>
-#include <gtest/gtest.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-
-#include <algorithm>
-#include <cmath>
-#include <fstream>
-#include <vector>
-
-#include "DeepPot.h"
-#include "neighbor_list.h"
-#include "test_utils.h"
-
-template <class VALUETYPE>
-class TestInferDeepPotR : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {13., 0., 0., 0., 13., 0., 0., 0., 13.};
-  std::vector<VALUETYPE> expected_e = {
-      -9.320909762801588272e+01, -1.868020345400987878e+02,
-      -1.868011172371355997e+02, -9.320868430396934912e+01,
-      -1.868010398844378415e+02, -1.868016706555875999e+02};
-  std::vector<VALUETYPE> expected_f = {
-      6.385312846474267391e-04,  -6.460452911141417731e-03,
-      -5.652405655332678417e-04, -7.516468794343579736e-03,
-      1.128804614240160216e-03,  5.531937784564192051e-03,
-      1.914138124904981664e-03,  5.601819906021693503e-03,
-      -5.131359585752605541e-03, -4.847104424804288617e-03,
-      1.992071550328819614e-03,  -4.028159855157302516e-03,
-      1.236340684486603517e-03,  -5.373955841338794344e-03,
-      8.312829460571366513e-03,  8.574563125108854156e-03,
-      3.111712681889538742e-03,  -4.120007238692381148e-03};
-  std::vector<VALUETYPE> expected_v = {
-      5.844056241889131371e-03,  4.663973497239899614e-04,
-      -2.268382127762904633e-03, 4.663973497239897988e-04,
-      2.349338784202595950e-03,  -6.908546513234039253e-04,
-      -2.268382127762904633e-03, -6.908546513234039253e-04,
-      2.040499248150800561e-03,  4.238130266437327605e-03,
-      -1.539867187443782223e-04, -2.393101333240631613e-03,
-      -1.539867187443782223e-04, 4.410341945447907377e-04,
-      9.544239698119633068e-06,  -2.393101333240631613e-03,
-      9.544239698119578858e-06,  1.877785959095269654e-03,
-      5.798992562057291543e-03,  6.943392552230453693e-04,
-      -1.180376879311998773e-03, 6.943392552230453693e-04,
-      1.686725132156275536e-03,  -1.461632060145726542e-03,
-      -1.180376879311998556e-03, -1.461632060145726325e-03,
-      1.749543733794208444e-03,  7.173915604192910439e-03,
-      3.903218041111061569e-04,  -5.747400467123527524e-04,
-      3.903218041111061569e-04,  1.208289706621179949e-03,
-      -1.826828914132010932e-03, -5.747400467123527524e-04,
-      -1.826828914132011148e-03, 2.856960586657185906e-03,
-      4.067553030177322240e-03,  -3.267469855253819430e-05,
-      -6.980667859103454904e-05, -3.267469855253830272e-05,
-      1.387653029234650918e-03,  -2.096820720698671855e-03,
-      -6.980667859103444062e-05, -2.096820720698671855e-03,
-      3.218305506720191278e-03,  4.753992590355240674e-03,
-      1.224911338353675992e-03,  -1.683421934571502484e-03,
-      1.224911338353676209e-03,  7.332113564901583539e-04,
-      -1.025577052190138451e-03, -1.683421934571502484e-03,
-      -1.025577052190138234e-03, 1.456681925652047018e-03};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot-r.pbtxt";
-    deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot-r.pbtxt",
-                                "deeppot.pb");
-
-    dp.init("deeppot.pb");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotR, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotR, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotR, cpu_build_nlist_numfv) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  class MyModel : public EnergyModelTest<VALUETYPE> {
-    deepmd::DeepPot& mydp;
-    const std::vector<int>& atype;
-
-   public:
-    MyModel(deepmd::DeepPot& dp_, const std::vector<int>& atype_)
-        : mydp(dp_), atype(atype_) {};
-    virtual void compute(double& ener,
-                         std::vector<VALUETYPE>& force,
-                         std::vector<VALUETYPE>& virial,
-                         const std::vector<VALUETYPE>& coord,
-                         const std::vector<VALUETYPE>& box) {
-      mydp.compute(ener, force, virial, coord, atype, box);
-    }
-  };
-  MyModel model(dp, atype);
-  model.test_f(coord, box);
-  model.test_v(coord, box);
-  std::vector<VALUETYPE> box_(box);
-  box_[1] -= 0.4;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[2] += 0.5;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[4] += 0.2;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[3] -= 0.3;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[6] -= 0.7;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-  box_[7] += 0.6;
-  model.test_f(coord, box_);
-  model.test_v(coord, box_);
-}
-
-TYPED_TEST(TestInferDeepPotR, cpu_build_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial, atom_ener, atom_vir;
-  dp.compute(ener, force, virial, atom_ener, atom_vir, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, virial;
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist_atomic) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_, atom_ener_, atom_vir_, virial;
-  std::vector<VALUETYPE> force, atom_ener, atom_vir;
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 0);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  std::fill(atom_ener_.begin(), atom_ener_.end(), 0.0);
-  std::fill(atom_vir_.begin(), atom_vir_.end(), 0.0);
-  dp.compute(ener, force_, virial, atom_ener_, atom_vir_, coord_cpy, atype_cpy,
-             box, nall - nloc, inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-  _fold_back<VALUETYPE>(atom_ener, atom_ener_, mapping, nloc, nall, 1);
-  _fold_back<VALUETYPE>(atom_vir, atom_vir_, mapping, nloc, nall, 9);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-  EXPECT_EQ(atom_ener.size(), natoms);
-  EXPECT_EQ(atom_vir.size(), natoms * 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms; ++ii) {
-    EXPECT_LT(fabs(atom_ener[ii] - expected_e[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < natoms * 9; ++ii) {
-    EXPECT_LT(fabs(atom_vir[ii] - expected_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist_2rc) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc * 2);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-
-  ener = 0.;
-  std::fill(force_.begin(), force_.end(), 0.0);
-  std::fill(virial.begin(), virial.end(), 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 1);
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-TYPED_TEST(TestInferDeepPotR, cpu_lmp_nlist_type_sel) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  float rc = dp.cutoff();
-
-  // add vir atoms
-  int nvir = 2;
-  std::vector<VALUETYPE> coord_vir(nvir * 3);
-  std::vector<int> atype_vir(nvir, 2);
-  for (int ii = 0; ii < nvir; ++ii) {
-    coord_vir[ii] = coord[ii];
-  }
-  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
-  atype.insert(atype.begin(), atype_vir.begin(), atype_vir.end());
-  natoms += nvir;
-  std::vector<VALUETYPE> expected_f_vir(nvir * 3, 0.0);
-  expected_f.insert(expected_f.begin(), expected_f_vir.begin(),
-                    expected_f_vir.end());
-
-  // build nlist
-  int nloc = coord.size() / 3;
-  std::vector<VALUETYPE> coord_cpy;
-  std::vector<int> atype_cpy, mapping;
-  std::vector<std::vector<int> > nlist_data;
-  _build_nlist<VALUETYPE>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
-                          atype, box, rc);
-  int nall = coord_cpy.size() / 3;
-  std::vector<int> ilist(nloc), numneigh(nloc);
-  std::vector<int*> firstneigh(nloc);
-  deepmd::InputNlist inlist(nloc, &ilist[0], &numneigh[0], &firstneigh[0]);
-  convert_nlist(inlist, nlist_data);
-
-  // dp compute
-  double ener;
-  std::vector<VALUETYPE> force_(nall * 3, 0.0), virial(9, 0.0);
-  dp.compute(ener, force_, virial, coord_cpy, atype_cpy, box, nall - nloc,
-             inlist, 0);
-  // fold back
-  std::vector<VALUETYPE> force;
-  _fold_back<VALUETYPE>(force, force_, mapping, nloc, nall, 3);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
-
-template <class VALUETYPE>
-class TestInferDeepPotRNoPbc : public ::testing::Test {
- protected:
-  std::vector<VALUETYPE> coord = {12.83, 2.56, 2.18, 12.09, 2.87, 2.74,
-                                  00.25, 3.32, 1.68, 3.36,  3.00, 1.81,
-                                  3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
-  std::vector<int> atype = {0, 1, 1, 0, 1, 1};
-  std::vector<VALUETYPE> box = {};
-  std::vector<VALUETYPE> expected_e = {
-      -9.321213823508108476e+01, -1.868044102481340758e+02,
-      -1.868067983858651075e+02, -9.320899631301440991e+01,
-      -1.868014559732615112e+02, -1.868017660713088617e+02};
-  std::vector<VALUETYPE> expected_f = {
-      4.578151103701261042e-03,  -1.917874111009987628e-03,
-      -3.464546781179331930e-03, -4.578151103701261042e-03,
-      1.917874111009987628e-03,  3.464546781179331930e-03,
-      -2.624402581721222913e-03, 3.566275128489623933e-04,
-      -2.859315986763691776e-04, -5.767787273464367384e-03,
-      1.907053583551196647e-03,  -3.889064429673861831e-03,
-      1.786820066350549132e-04,  -5.327197473636275694e-03,
-      8.236236182834734409e-03,  8.213507848550535492e-03,
-      3.063516377236116545e-03,  -4.061240154484504865e-03};
-  std::vector<VALUETYPE> expected_v = {
-      1.984979026299632174e-03,  -8.315452677741701822e-04,
-      -1.502146290172694243e-03, -8.315452677741700738e-04,
-      3.483500446080982317e-04,  6.292774999372096039e-04,
-      -1.502146290172694243e-03, 6.292774999372097123e-04,
-      1.136759354725281907e-03,  1.402852790439301908e-03,
-      -5.876815743732210226e-04, -1.061618327900012114e-03,
-      -5.876815743732211311e-04, 2.461909298049979960e-04,
-      4.447320022283834766e-04,  -1.061618327900012331e-03,
-      4.447320022283834766e-04,  8.033868427351443728e-04,
-      4.143606961846296385e-03,  -5.511382161123719835e-04,
-      4.465413399437045397e-04,  -5.511382161123719835e-04,
-      1.082271054025323839e-04,  -1.097918001262628728e-04,
-      4.465413399437046481e-04,  -1.097918001262628728e-04,
-      1.220966982358671871e-04,  5.263952004497593831e-03,
-      2.395243710938091842e-04,  -2.830378939414603329e-04,
-      2.395243710938094010e-04,  1.189969706598244898e-03,
-      -1.805627331015851201e-03, -2.830378939414602245e-04,
-      -1.805627331015851635e-03, 2.801996513751836820e-03,
-      2.208413501170402270e-03,  5.331756287635716889e-05,
-      -1.664423506603235218e-04, 5.331756287635695205e-05,
-      1.379626072862918072e-03,  -2.094132943741625064e-03,
-      -1.664423506603234133e-04, -2.094132943741625064e-03,
-      3.199787996743366607e-03,  4.047014004814953811e-03,
-      1.137904999421357000e-03,  -1.568106936614101698e-03,
-      1.137904999421357217e-03,  7.205982843216952307e-04,
-      -1.011174600268313238e-03, -1.568106936614101698e-03,
-      -1.011174600268313238e-03, 1.435226522157425754e-03};
-  int natoms;
-  double expected_tot_e;
-  std::vector<VALUETYPE> expected_tot_v;
-
-  deepmd::DeepPot dp;
-
-  void SetUp() override {
-#ifndef BUILD_TENSORFLOW
-    GTEST_SKIP() << "Skip because TensorFlow support is not enabled.";
-#endif
-    std::string file_name = "../../tests/infer/deeppot-r.pbtxt";
-    deepmd::convert_pbtxt_to_pb("../../tests/infer/deeppot-r.pbtxt",
-                                "deeppot.pb");
-
-    dp.init("deeppot.pb");
-
-    natoms = expected_e.size();
-    EXPECT_EQ(natoms * 3, expected_f.size());
-    EXPECT_EQ(natoms * 9, expected_v.size());
-    expected_tot_e = 0.;
-    expected_tot_v.resize(9);
-    std::fill(expected_tot_v.begin(), expected_tot_v.end(), 0.);
-    for (int ii = 0; ii < natoms; ++ii) {
-      expected_tot_e += expected_e[ii];
-    }
-    for (int ii = 0; ii < natoms; ++ii) {
-      for (int dd = 0; dd < 9; ++dd) {
-        expected_tot_v[dd] += expected_v[ii * 9 + dd];
-      }
-    }
-  };
-
-  void TearDown() override { remove("deeppot.pb"); };
-};
-
-TYPED_TEST_SUITE(TestInferDeepPotRNoPbc, ValueTypes);
-
-TYPED_TEST(TestInferDeepPotRNoPbc, cpu_build_nlist) {
-  using VALUETYPE = TypeParam;
-  std::vector<VALUETYPE>& coord = this->coord;
-  std::vector<int>& atype = this->atype;
-  std::vector<VALUETYPE>& box = this->box;
-  std::vector<VALUETYPE>& expected_e = this->expected_e;
-  std::vector<VALUETYPE>& expected_f = this->expected_f;
-  std::vector<VALUETYPE>& expected_v = this->expected_v;
-  int& natoms = this->natoms;
-  double& expected_tot_e = this->expected_tot_e;
-  std::vector<VALUETYPE>& expected_tot_v = this->expected_tot_v;
-  deepmd::DeepPot& dp = this->dp;
-  double ener;
-  std::vector<VALUETYPE> force, virial;
-  dp.compute(ener, force, virial, coord, atype, box);
-
-  EXPECT_EQ(force.size(), natoms * 3);
-  EXPECT_EQ(virial.size(), 9);
-
-  EXPECT_LT(fabs(ener - expected_tot_e), EPSILON);
-  for (int ii = 0; ii < natoms * 3; ++ii) {
-    EXPECT_LT(fabs(force[ii] - expected_f[ii]), EPSILON);
-  }
-  for (int ii = 0; ii < 3 * 3; ++ii) {
-    EXPECT_LT(fabs(virial[ii] - expected_tot_v[ii]), EPSILON);
-  }
-}
diff --git a/source/api_cc/tests/test_deeppot_universal.cc b/source/api_cc/tests/test_deeppot_universal.cc
new file mode 100644
index 0000000000..e0ee6fc8f4
--- /dev/null
+++ b/source/api_cc/tests/test_deeppot_universal.cc
@@ -0,0 +1,1958 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+#include <gtest/gtest.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <exception>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "DeepPot.h"
+#include "DeepPotPTExpt.h"
+#include "deeppot_universal_test_common.h"
+#include "expected_ref.h"
+#include "test_utils.h"
+
+namespace {
+
+using namespace deepmd_test::universal;
+
+struct VariantDeepPotCase {
+  std::string name;
+  Backend backend;
+  std::string model_path;
+  bool convert_pbtxt;
+  const deepmd_test::DeepPotRef* builtin_ref;
+  const deepmd_test::DeepPotRef* builtin_no_pbc_ref;
+  std::string ref_path;
+  std::string ref_section;
+  std::string no_pbc_ref_section;
+  double double_tol;
+  double float_tol;
+  bool supports_float;
+  bool supports_finite_difference;
+  bool supports_lmp_nlist;
+  bool supports_lmp_nlist_atomic;
+  bool supports_lmp_nlist_cutoff_twice;
+  bool supports_lmp_nlist_type_sel;
+  bool supports_print_summary;
+  bool supports_no_pbc_simple;
+  bool supports_no_pbc_atomic;
+  bool supports_no_pbc_lmp_nlist;
+  bool supports_no_pbc_lmp_nlist_atomic;
+};
+
+struct DefaultFParamCase {
+  std::string name;
+  Backend backend;
+  std::string model_path;
+  std::string ref_path;
+  double double_tol;
+  double float_tol;
+  bool supports_float;
+};
+
+std::vector<VariantDeepPotCase> variant_deeppot_cases() {
+  return {{"tensorflow_r",
+           Backend::TensorFlow,
+           "../../tests/infer/deeppot-r.pbtxt",
+           /*convert_pbtxt=*/true,
+           &deepmd_test::tf_deeppot_r_ref(),
+           &deepmd_test::tf_deeppot_r_no_pbc_ref(),
+           "",
+           "",
+           "",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/true,
+           /*supports_lmp_nlist=*/true,
+           /*supports_lmp_nlist_atomic=*/true,
+           /*supports_lmp_nlist_cutoff_twice=*/true,
+           /*supports_lmp_nlist_type_sel=*/true,
+           /*supports_print_summary=*/false,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/false,
+           /*supports_no_pbc_lmp_nlist=*/false,
+           /*supports_no_pbc_lmp_nlist_atomic=*/false},
+          {"dpa_jax_savedmodel",
+           Backend::JAX,
+           "../../tests/infer/deeppot_dpa.savedmodel",
+           /*convert_pbtxt=*/false,
+           &deepmd_test::jax_dpa_deeppot_ref(),
+           &deepmd_test::jax_dpa_deeppot_no_pbc_ref(),
+           "",
+           "",
+           "",
+           1e-7,
+           1e-1,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/false,
+           /*supports_lmp_nlist=*/false,
+           /*supports_lmp_nlist_atomic=*/false,
+           /*supports_lmp_nlist_cutoff_twice=*/false,
+           /*supports_lmp_nlist_type_sel=*/false,
+           /*supports_print_summary=*/false,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/true,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/true},
+          {"dpa1_pytorch_pth",
+           Backend::PyTorch,
+           "../../tests/infer/deeppot_dpa1.pth",
+           /*convert_pbtxt=*/false,
+           nullptr,
+           nullptr,
+           "../../tests/infer/deeppot_dpa1.expected",
+           "pbc",
+           "nopbc",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/false,
+           /*supports_lmp_nlist=*/false,
+           /*supports_lmp_nlist_atomic=*/false,
+           /*supports_lmp_nlist_cutoff_twice=*/false,
+           /*supports_lmp_nlist_type_sel=*/false,
+           /*supports_print_summary=*/false,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/false,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/false},
+          {"dpa1_pytorch_pt2",
+           Backend::PTExpt,
+           "../../tests/infer/deeppot_dpa1.pt2",
+           /*convert_pbtxt=*/false,
+           nullptr,
+           nullptr,
+           "../../tests/infer/deeppot_dpa1.expected",
+           "pbc",
+           "nopbc",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/true,
+           /*supports_lmp_nlist=*/true,
+           /*supports_lmp_nlist_atomic=*/true,
+           /*supports_lmp_nlist_cutoff_twice=*/true,
+           /*supports_lmp_nlist_type_sel=*/true,
+           /*supports_print_summary=*/true,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/false,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/false},
+          {"dpa2_pytorch_pth",
+           Backend::PyTorch,
+           "../../tests/infer/deeppot_dpa2.pth",
+           /*convert_pbtxt=*/false,
+           nullptr,
+           nullptr,
+           "../../tests/infer/deeppot_dpa2.expected",
+           "pbc",
+           "nopbc",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/false,
+           /*supports_lmp_nlist=*/false,
+           /*supports_lmp_nlist_atomic=*/false,
+           /*supports_lmp_nlist_cutoff_twice=*/false,
+           /*supports_lmp_nlist_type_sel=*/false,
+           /*supports_print_summary=*/false,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/true,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/true},
+          {"dpa2_pytorch_pt2",
+           Backend::PTExpt,
+           "../../tests/infer/deeppot_dpa2.pt2",
+           /*convert_pbtxt=*/false,
+           nullptr,
+           nullptr,
+           "../../tests/infer/deeppot_dpa2.expected",
+           "pbc",
+           "nopbc",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/true,
+           /*supports_lmp_nlist=*/true,
+           /*supports_lmp_nlist_atomic=*/true,
+           /*supports_lmp_nlist_cutoff_twice=*/true,
+           /*supports_lmp_nlist_type_sel=*/true,
+           /*supports_print_summary=*/true,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/false,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/false},
+          {"dpa3_pytorch_pth",
+           Backend::PyTorch,
+           "../../tests/infer/deeppot_dpa3.pth",
+           /*convert_pbtxt=*/false,
+           nullptr,
+           nullptr,
+           "../../tests/infer/deeppot_dpa3.expected",
+           "pbc",
+           "nopbc",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/false,
+           /*supports_lmp_nlist=*/false,
+           /*supports_lmp_nlist_atomic=*/false,
+           /*supports_lmp_nlist_cutoff_twice=*/false,
+           /*supports_lmp_nlist_type_sel=*/false,
+           /*supports_print_summary=*/false,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/false,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/false},
+          {"dpa3_pytorch_pt2",
+           Backend::PTExpt,
+           "../../tests/infer/deeppot_dpa3.pt2",
+           /*convert_pbtxt=*/false,
+           nullptr,
+           nullptr,
+           "../../tests/infer/deeppot_dpa3.expected",
+           "pbc",
+           "nopbc",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/true,
+           /*supports_lmp_nlist=*/true,
+           /*supports_lmp_nlist_atomic=*/true,
+           /*supports_lmp_nlist_cutoff_twice=*/true,
+           /*supports_lmp_nlist_type_sel=*/true,
+           /*supports_print_summary=*/true,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/false,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/false},
+          {"dpa4_pytorch_pt2",
+           Backend::PTExpt,
+           "../../tests/infer/deeppot_dpa4.pt2",
+           /*convert_pbtxt=*/false,
+           nullptr,
+           nullptr,
+           "../../tests/infer/deeppot_dpa4.expected",
+           "pbc",
+           "nopbc",
+           1e-10,
+           1e-4,
+           /*supports_float=*/true,
+           /*supports_finite_difference=*/true,
+           /*supports_lmp_nlist=*/true,
+           /*supports_lmp_nlist_atomic=*/true,
+           /*supports_lmp_nlist_cutoff_twice=*/true,
+           /*supports_lmp_nlist_type_sel=*/true,
+           /*supports_print_summary=*/true,
+           /*supports_no_pbc_simple=*/true,
+           /*supports_no_pbc_atomic=*/false,
+           /*supports_no_pbc_lmp_nlist=*/true,
+           /*supports_no_pbc_lmp_nlist_atomic=*/false}};
+}
+
+std::vector<DefaultFParamCase> default_fparam_cases() {
+  return {{"pytorch_pth", Backend::PyTorch,
+           "../../tests/infer/fparam_aparam_default.pth",
+           "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4,
+           /*supports_float=*/true},
+          {"pytorch_pt2", Backend::PTExpt,
+           "../../tests/infer/fparam_aparam_default.pt2",
+           "../../tests/infer/fparam_aparam_default.expected", 1e-7, 1e-4,
+           /*supports_float=*/true}};
+}
+
+deepmd_test::DeepPotRef load_expected_ref(const std::string& ref_path,
+                                          const std::string& section) {
+  deepmd_test::ExpectedRef ref_file;
+  ref_file.load(ref_path);
+  deepmd_test::DeepPotRef ref;
+  ref.atomic_energy = ref_file.get<double>(section, "expected_e");
+  ref.force = ref_file.get<double>(section, "expected_f");
+  ref.atomic_virial = ref_file.get<double>(section, "expected_v");
+  return ref;
+}
+
+::testing::AssertionResult convert_pbtxt_model(const std::string& source,
+                                               const std::string& target) {
+  try {
+    deepmd::convert_pbtxt_to_pb(source, target);
+  } catch (const std::exception& e) {
+    return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for "
+                                         << source << ": " << e.what();
+  } catch (...) {
+    return ::testing::AssertionFailure() << "pbtxt-to-pb conversion failed for "
+                                         << source << ": unknown exception";
+  }
+
+  if (!path_exists(target)) {
+    return ::testing::AssertionFailure()
+           << "pbtxt-to-pb conversion failed for " << source
+           << ": output was not created: " << target;
+  }
+  return ::testing::AssertionSuccess();
+}
+
+class UniversalDeepPotTest : public ::testing::TestWithParam<ModelCase> {
+ protected:
+  deepmd::DeepPot dp;
+  std::string converted_model;
+
+  void SetUp() override {
+    const auto& param = GetParam();
+    if (!backend_enabled(param.backend)) {
+      GTEST_SKIP() << backend_name(param.backend) << " support is not enabled.";
+    }
+    ASSERT_TRUE(path_exists(param.model_path))
+        << "Model artifact is not available: " << param.model_path;
+
+    std::string model_path = param.model_path;
+    if (param.convert_pbtxt) {
+      converted_model = "deeppot_universal_" + param.name + ".pb";
+      ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model));
+      model_path = converted_model;
+    }
+    dp.init(model_path);
+  }
+
+  void TearDown() override {
+    if (!converted_model.empty()) {
+      remove(converted_model.c_str());
+    }
+  }
+};
+
+class VariantDeepPotTest : public ::testing::TestWithParam<VariantDeepPotCase> {
+ protected:
+  deepmd::DeepPot dp;
+  std::string converted_model;
+  deepmd_test::DeepPotRef loaded_ref;
+  deepmd_test::DeepPotRef loaded_no_pbc_ref;
+  const deepmd_test::DeepPotRef* ref = nullptr;
+  const deepmd_test::DeepPotRef* no_pbc_ref = nullptr;
+
+  void SetUp() override {
+    const auto& param = GetParam();
+    if (!backend_enabled(param.backend)) {
+      GTEST_SKIP() << backend_name(param.backend) << " support is not enabled.";
+    }
+    ASSERT_TRUE(path_exists(param.model_path))
+        << "Model artifact is not available: " << param.model_path;
+
+    if (param.builtin_ref != nullptr) {
+      ref = param.builtin_ref;
+    } else {
+      ASSERT_TRUE(path_exists(param.ref_path))
+          << "Reference artifact is not available: " << param.ref_path;
+      loaded_ref = load_expected_ref(param.ref_path, param.ref_section);
+      ref = &loaded_ref;
+    }
+
+    const bool needs_no_pbc_ref = param.supports_no_pbc_simple ||
+                                  param.supports_no_pbc_atomic ||
+                                  param.supports_no_pbc_lmp_nlist ||
+                                  param.supports_no_pbc_lmp_nlist_atomic;
+    if (needs_no_pbc_ref) {
+      if (param.builtin_no_pbc_ref != nullptr) {
+        no_pbc_ref = param.builtin_no_pbc_ref;
+      } else {
+        ASSERT_TRUE(path_exists(param.ref_path))
+            << "Reference artifact is not available: " << param.ref_path;
+        loaded_no_pbc_ref =
+            load_expected_ref(param.ref_path, param.no_pbc_ref_section);
+        no_pbc_ref = &loaded_no_pbc_ref;
+      }
+    }
+
+    std::string model_path = param.model_path;
+    if (param.convert_pbtxt) {
+      converted_model = "deeppot_variant_" + param.name + ".pb";
+      ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model));
+      model_path = converted_model;
+    }
+    dp.init(model_path);
+  }
+
+  void TearDown() override {
+    if (!converted_model.empty()) {
+      remove(converted_model.c_str());
+    }
+  }
+};
+
+class FParamAParamDeepPotTest
+    : public ::testing::TestWithParam<FParamAParamCase> {
+ protected:
+  deepmd::DeepPot dp;
+  std::string converted_model;
+  deepmd_test::DeepPotRef loaded_ref;
+  const deepmd_test::DeepPotRef* ref = nullptr;
+
+  void SetUp() override {
+    const auto& param = GetParam();
+    if (!backend_enabled(param.backend)) {
+      GTEST_SKIP() << backend_name(param.backend) << " support is not enabled.";
+    }
+    ASSERT_TRUE(path_exists(param.model_path))
+        << "Model artifact is not available: " << param.model_path;
+    if (param.builtin_ref != nullptr) {
+      ref = param.builtin_ref;
+    } else {
+      ASSERT_TRUE(path_exists(param.ref_path))
+          << "Reference artifact is not available: " << param.ref_path;
+      loaded_ref = load_fparam_ref(param.ref_path);
+      ref = &loaded_ref;
+    }
+
+    std::string model_path = param.model_path;
+    if (param.convert_pbtxt) {
+      converted_model = "deeppot_fparam_aparam_" + param.name + ".pb";
+      ASSERT_TRUE(convert_pbtxt_model(param.model_path, converted_model));
+      model_path = converted_model;
+    }
+    dp.init(model_path);
+  }
+
+  void TearDown() override {
+    if (!converted_model.empty()) {
+      remove(converted_model.c_str());
+    }
+  }
+};
+
+class DefaultFParamDeepPotTest
+    : public ::testing::TestWithParam<DefaultFParamCase> {
+ protected:
+  deepmd::DeepPot dp;
+  deepmd_test::DeepPotRef ref;
+
+  void SetUp() override {
+    const auto& param = GetParam();
+    if (!backend_enabled(param.backend)) {
+      GTEST_SKIP() << backend_name(param.backend) << " support is not enabled.";
+    }
+    ASSERT_TRUE(path_exists(param.model_path))
+        << "Model artifact is not available: " << param.model_path;
+    ASSERT_TRUE(path_exists(param.ref_path))
+        << "Reference artifact is not available: " << param.ref_path;
+    ref = load_fparam_ref(param.ref_path);
+    ref.has_default_fparam = true;
+    dp.init(param.model_path);
+  }
+};
+
+TEST_P(UniversalDeepPotTest, Metadata) {
+  const auto& ref = *GetParam().ref;
+  std::string type_map;
+
+  EXPECT_DOUBLE_EQ(dp.cutoff(), ref.cutoff);
+  EXPECT_EQ(dp.numb_types(), ref.numb_types);
+  EXPECT_EQ(dp.numb_types_spin(), ref.numb_types_spin);
+  EXPECT_EQ(dp.dim_fparam(), ref.dim_fparam);
+  EXPECT_EQ(dp.dim_aparam(), ref.dim_aparam);
+  EXPECT_EQ(dp.is_aparam_nall(), ref.aparam_nall);
+  EXPECT_EQ(dp.has_default_fparam(), ref.has_default_fparam);
+  dp.get_type_map(type_map);
+  EXPECT_EQ(type_map, ref.type_map);
+}
+
+template <typename ValueType>
+void expect_reference(const double energy,
+                      const std::vector<ValueType>& force,
+                      const std::vector<ValueType>& virial,
+                      const deepmd_test::DeepPotRef& ref,
+                      const double tol) {
+  const int natoms = static_cast<int>(ref.atomic_energy.size());
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  ASSERT_EQ(force.size(), static_cast<size_t>(natoms * 3));
+  ASSERT_EQ(virial.size(), 9U);
+  ASSERT_EQ(ref.force.size(), static_cast<size_t>(natoms * 3));
+  ASSERT_EQ(ref.atomic_virial.size(), static_cast<size_t>(natoms * 9));
+
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (int ii = 0; ii < natoms * 3; ++ii) {
+    EXPECT_NEAR(force[ii], ref.force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+}
+
+template <typename ValueType>
+void expect_atomic_reference(const double energy,
+                             const std::vector<ValueType>& force,
+                             const std::vector<ValueType>& virial,
+                             const std::vector<ValueType>& atomic_energy,
+                             const std::vector<ValueType>& atomic_virial,
+                             const deepmd_test::DeepPotRef& ref,
+                             const double tol) {
+  const int natoms = static_cast<int>(ref.atomic_energy.size());
+
+  expect_reference(energy, force, virial, ref, tol);
+  ASSERT_EQ(atomic_energy.size(), static_cast<size_t>(natoms));
+  ASSERT_EQ(atomic_virial.size(), static_cast<size_t>(natoms * 9));
+
+  for (int ii = 0; ii < natoms; ++ii) {
+    EXPECT_NEAR(atomic_energy[ii], ref.atomic_energy[ii], tol);
+  }
+  for (int ii = 0; ii < natoms * 9; ++ii) {
+    EXPECT_NEAR(atomic_virial[ii], ref.atomic_virial[ii], tol);
+  }
+}
+
+template <typename ValueType>
+void check_compute_simple(deepmd::DeepPot& dp,
+                          const deepmd_test::DeepPotRef& ref,
+                          const double tol,
+                          const bool use_box = true) {
+  const std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                                     deepmd_test::deeppot_coord().end());
+  std::vector<ValueType> box;
+  if (use_box) {
+    box.assign(deepmd_test::deeppot_box().begin(),
+               deepmd_test::deeppot_box().end());
+  }
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+
+  double energy = 0.0;
+  std::vector<ValueType> force;
+  std::vector<ValueType> virial;
+  dp.compute(energy, force, virial, coord, atype, box);
+
+  expect_reference(energy, force, virial, ref, tol);
+}
+
+template <typename ValueType>
+void check_compute_atomic(deepmd::DeepPot& dp,
+                          const deepmd_test::DeepPotRef& ref,
+                          const double tol,
+                          const bool use_box = true) {
+  const std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                                     deepmd_test::deeppot_coord().end());
+  std::vector<ValueType> box;
+  if (use_box) {
+    box.assign(deepmd_test::deeppot_box().begin(),
+               deepmd_test::deeppot_box().end());
+  }
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+
+  double energy = 0.0;
+  std::vector<ValueType> force;
+  std::vector<ValueType> virial;
+  std::vector<ValueType> atomic_energy;
+  std::vector<ValueType> atomic_virial;
+  dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, atype,
+             box);
+
+  expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial,
+                          ref, tol);
+}
+
+template <typename ValueType>
+void check_finite_difference(deepmd::DeepPot& dp, const double level = -1.0) {
+  class Model : public EnergyModelTest<ValueType> {
+    deepmd::DeepPot& dp_;
+    const std::vector<int> atype_;
+
+   public:
+    Model(deepmd::DeepPot& dp, const std::vector<int>& atype, double level)
+        : dp_(dp), atype_(atype) {
+      if (level > 0.0) {
+        this->level = level;
+      }
+    }
+
+    void compute(double& energy,
+                 std::vector<ValueType>& force,
+                 std::vector<ValueType>& virial,
+                 const std::vector<ValueType>& coord,
+                 const std::vector<ValueType>& box) override {
+      dp_.compute(energy, force, virial, coord, atype_, box);
+    }
+  };
+
+  const std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                                     deepmd_test::deeppot_coord().end());
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+  std::vector<ValueType> box(deepmd_test::deeppot_box().begin(),
+                             deepmd_test::deeppot_box().end());
+  Model model(dp, atype, level);
+  model.test_f(coord, box);
+  model.test_v(coord, box);
+  box[1] -= 0.4;
+  model.test_f(coord, box);
+  model.test_v(coord, box);
+  box[2] += 0.5;
+  model.test_f(coord, box);
+  model.test_v(coord, box);
+  box[4] += 0.2;
+  model.test_f(coord, box);
+  model.test_v(coord, box);
+  box[3] -= 0.3;
+  model.test_f(coord, box);
+  model.test_v(coord, box);
+  box[6] -= 0.7;
+  model.test_f(coord, box);
+  model.test_v(coord, box);
+  box[7] += 0.6;
+  model.test_f(coord, box);
+  model.test_v(coord, box);
+}
+
+template <typename ValueType>
+void check_lmp_nlist(deepmd::DeepPot& dp,
+                     const deepmd_test::DeepPotRef& ref,
+                     const double tol,
+                     const double cutoff_scale = 1.0,
+                     const bool set_mapping = true) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                                     deepmd_test::deeppot_coord().end());
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+  const std::vector<ValueType> box(deepmd_test::deeppot_box().begin(),
+                                   deepmd_test::deeppot_box().end());
+  const float rc = static_cast<float>(dp.cutoff() * cutoff_scale);
+  const int nloc = natoms;
+  std::vector<ValueType> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int>> nlist_data;
+  _build_nlist<ValueType>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box, rc);
+  const int nall = static_cast<int>(coord_cpy.size() / 3);
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_data);
+  if (set_mapping) {
+    inlist.mapping = mapping.data();
+  }
+
+  for (int ago = 0; ago < 2; ++ago) {
+    double energy = 0.0;
+    std::vector<ValueType> force_all(nall * 3, 0.0);
+    std::vector<ValueType> virial(9, 0.0);
+    dp.compute(energy, force_all, virial, coord_cpy, atype_cpy, box,
+               nall - nloc, inlist, ago);
+
+    std::vector<ValueType> force;
+    _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3);
+    expect_reference(energy, force, virial, ref, tol);
+  }
+}
+
+template <typename ValueType>
+void check_lmp_nlist_skin_below_model_width(deepmd::DeepPot& dp,
+                                            const deepmd_test::DeepPotRef& ref,
+                                            const double tol,
+                                            const bool set_mapping = true) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                                     deepmd_test::deeppot_coord().end());
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+  const std::vector<ValueType> box(deepmd_test::deeppot_box().begin(),
+                                   deepmd_test::deeppot_box().end());
+  const float rc = static_cast<float>(dp.cutoff());
+  const int nloc = natoms;
+  std::vector<ValueType> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int>> nlist_wide;
+  _build_nlist<ValueType>(nlist_wide, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box, rc * 2);
+
+  const double rc2 = static_cast<double>(rc) * static_cast<double>(rc);
+  bool has_skin_neighbor = false;
+  std::vector<std::vector<int>> nlist_skin(nlist_wide.size());
+  for (size_t ii = 0; ii < nlist_wide.size(); ++ii) {
+    bool added_skin_neighbor = false;
+    for (const int jj : nlist_wide[ii]) {
+      const double dx = static_cast<double>(coord_cpy[jj * 3]) -
+                        static_cast<double>(coord_cpy[ii * 3]);
+      const double dy = static_cast<double>(coord_cpy[jj * 3 + 1]) -
+                        static_cast<double>(coord_cpy[ii * 3 + 1]);
+      const double dz = static_cast<double>(coord_cpy[jj * 3 + 2]) -
+                        static_cast<double>(coord_cpy[ii * 3 + 2]);
+      const double rr = dx * dx + dy * dy + dz * dz;
+      if (rr <= rc2) {
+        nlist_skin[ii].push_back(jj);
+      } else if (!added_skin_neighbor) {
+        nlist_skin[ii].push_back(jj);
+        added_skin_neighbor = true;
+        has_skin_neighbor = true;
+      }
+    }
+  }
+  ASSERT_TRUE(has_skin_neighbor);
+
+  const int nall = static_cast<int>(coord_cpy.size() / 3);
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_skin);
+  if (set_mapping) {
+    inlist.mapping = mapping.data();
+  }
+
+  for (int ago = 0; ago < 2; ++ago) {
+    double energy = 0.0;
+    std::vector<ValueType> force_all(nall * 3, 0.0);
+    std::vector<ValueType> virial(9, 0.0);
+    dp.compute(energy, force_all, virial, coord_cpy, atype_cpy, box,
+               nall - nloc, inlist, ago);
+
+    std::vector<ValueType> force;
+    _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3);
+    expect_reference(energy, force, virial, ref, tol);
+  }
+}
+
+template <typename ValueType>
+void check_lmp_nlist_atomic(deepmd::DeepPot& dp,
+                            const deepmd_test::DeepPotRef& ref,
+                            const double tol,
+                            const bool set_mapping = true) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                                     deepmd_test::deeppot_coord().end());
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+  const std::vector<ValueType> box(deepmd_test::deeppot_box().begin(),
+                                   deepmd_test::deeppot_box().end());
+  const float rc = static_cast<float>(dp.cutoff());
+  const int nloc = natoms;
+  std::vector<ValueType> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int>> nlist_data;
+  _build_nlist<ValueType>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box, rc);
+  const int nall = static_cast<int>(coord_cpy.size() / 3);
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_data);
+  if (set_mapping) {
+    inlist.mapping = mapping.data();
+  }
+
+  for (int ago = 0; ago < 2; ++ago) {
+    double energy = 0.0;
+    std::vector<ValueType> force_all(nall * 3, 0.0), virial(9, 0.0);
+    std::vector<ValueType> atomic_energy_all(nall, 0.0);
+    std::vector<ValueType> atomic_virial_all(nall * 9, 0.0);
+    dp.compute(energy, force_all, virial, atomic_energy_all, atomic_virial_all,
+               coord_cpy, atype_cpy, box, nall - nloc, inlist, ago);
+
+    std::vector<ValueType> force, atomic_energy, atomic_virial;
+    _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3);
+    _fold_back<ValueType>(atomic_energy, atomic_energy_all, mapping, nloc, nall,
+                          1);
+    _fold_back<ValueType>(atomic_virial, atomic_virial_all, mapping, nloc, nall,
+                          9);
+    expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial,
+                            ref, tol);
+  }
+}
+
+std::vector<std::vector<int>> make_full_nlist_data(const int natoms) {
+  std::vector<std::vector<int>> nlist_data(natoms);
+  for (int ii = 0; ii < natoms; ++ii) {
+    nlist_data[ii].reserve(natoms - 1);
+    for (int jj = 0; jj < natoms; ++jj) {
+      if (ii != jj) {
+        nlist_data[ii].push_back(jj);
+      }
+    }
+  }
+  return nlist_data;
+}
+
+template <typename ValueType>
+void check_no_pbc_lmp_nlist(deepmd::DeepPot& dp,
+                            const deepmd_test::DeepPotRef& ref,
+                            const double tol,
+                            const bool atomic) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                                     deepmd_test::deeppot_coord().end());
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+  const std::vector<ValueType> box;
+  std::vector<std::vector<int>> nlist_data = make_full_nlist_data(natoms);
+  std::vector<int> ilist(natoms), numneigh(natoms);
+  std::vector<int*> firstneigh(natoms);
+  deepmd::InputNlist inlist(natoms, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_data);
+
+  double energy = 0.0;
+  std::vector<ValueType> force;
+  std::vector<ValueType> virial;
+  if (atomic) {
+    std::vector<ValueType> atomic_energy;
+    std::vector<ValueType> atomic_virial;
+    dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord,
+               atype, box, 0, inlist, 0);
+    expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial,
+                            ref, tol);
+  } else {
+    dp.compute(energy, force, virial, coord, atype, box, 0, inlist, 0);
+    expect_reference(energy, force, virial, ref, tol);
+  }
+}
+
+template <typename ValueType>
+void check_lmp_nlist_type_sel(deepmd::DeepPot& dp,
+                              const deepmd_test::DeepPotRef& ref,
+                              const double tol,
+                              const bool atomic,
+                              const bool set_mapping = true) {
+  constexpr int nvir = 2;
+  std::vector<ValueType> coord(deepmd_test::deeppot_coord().begin(),
+                               deepmd_test::deeppot_coord().end());
+  std::vector<int> atype = deepmd_test::deeppot_atype();
+  const std::vector<ValueType> box(deepmd_test::deeppot_box().begin(),
+                                   deepmd_test::deeppot_box().end());
+  std::vector<ValueType> expected_force(ref.force.begin(), ref.force.end());
+  std::vector<ValueType> coord_vir(nvir * 3);
+  std::copy(coord.begin(), coord.begin() + nvir * 3, coord_vir.begin());
+  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
+  atype.insert(atype.begin(), nvir, 2);
+  expected_force.insert(expected_force.begin(), nvir * 3, 0.0);
+
+  const int natoms = static_cast<int>(atype.size());
+  const int nloc = natoms;
+  const float rc = static_cast<float>(dp.cutoff());
+  std::vector<ValueType> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int>> nlist_data;
+  _build_nlist<ValueType>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box, rc);
+  const int nall = static_cast<int>(coord_cpy.size() / 3);
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_data);
+  if (set_mapping) {
+    inlist.mapping = mapping.data();
+  }
+
+  double energy = 0.0;
+  std::vector<ValueType> force_all(nall * 3, 0.0), virial(9, 0.0);
+  if (atomic) {
+    std::vector<ValueType> atomic_energy, atomic_virial;
+    dp.compute(energy, force_all, virial, atomic_energy, atomic_virial,
+               coord_cpy, atype_cpy, box, nall - nloc, inlist, 0);
+  } else {
+    dp.compute(energy, force_all, virial, coord_cpy, atype_cpy, box,
+               nall - nloc, inlist, 0);
+  }
+
+  std::vector<ValueType> force;
+  _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3);
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+  ASSERT_EQ(force.size(), expected_force.size());
+  EXPECT_NEAR(energy, deepmd_test::total_energy(ref), tol);
+  for (size_t ii = 0; ii < expected_force.size(); ++ii) {
+    EXPECT_NEAR(force[ii], expected_force[ii], tol);
+  }
+  for (size_t ii = 0; ii < 9; ++ii) {
+    EXPECT_NEAR(virial[ii], expected_virial[ii], tol);
+  }
+}
+
+template <typename ValueType>
+std::vector<ValueType> cast_values(const std::vector<double>& values) {
+  return std::vector<ValueType>(values.begin(), values.end());
+}
+
+template <typename ValueType>
+std::vector<ValueType> repeat_values(const std::vector<ValueType>& values,
+                                     const int nframes) {
+  std::vector<ValueType> repeated;
+  repeated.reserve(static_cast<size_t>(nframes) * values.size());
+  for (int kk = 0; kk < nframes; ++kk) {
+    repeated.insert(repeated.end(), values.begin(), values.end());
+  }
+  return repeated;
+}
+
+template <typename ValueType>
+void expect_reference_frames(const std::vector<double>& energy,
+                             const std::vector<ValueType>& force,
+                             const std::vector<ValueType>& virial,
+                             const deepmd_test::DeepPotRef& ref,
+                             const double tol,
+                             const int nframes) {
+  const int natoms = static_cast<int>(ref.atomic_energy.size());
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+
+  ASSERT_EQ(energy.size(), static_cast<size_t>(nframes));
+  ASSERT_EQ(force.size(), static_cast<size_t>(nframes * natoms * 3));
+  ASSERT_EQ(virial.size(), static_cast<size_t>(nframes * 9));
+
+  for (int kk = 0; kk < nframes; ++kk) {
+    EXPECT_NEAR(energy[kk], deepmd_test::total_energy(ref), tol);
+    for (int ii = 0; ii < natoms * 3; ++ii) {
+      EXPECT_NEAR(force[kk * natoms * 3 + ii], ref.force[ii], tol);
+    }
+    for (int ii = 0; ii < 9; ++ii) {
+      EXPECT_NEAR(virial[kk * 9 + ii], expected_virial[ii], tol);
+    }
+  }
+}
+
+template <typename ValueType>
+void expect_atomic_reference_frames(const std::vector<double>& energy,
+                                    const std::vector<ValueType>& force,
+                                    const std::vector<ValueType>& virial,
+                                    const std::vector<ValueType>& atomic_energy,
+                                    const std::vector<ValueType>& atomic_virial,
+                                    const deepmd_test::DeepPotRef& ref,
+                                    const double tol,
+                                    const int nframes) {
+  const int natoms = static_cast<int>(ref.atomic_energy.size());
+
+  expect_reference_frames(energy, force, virial, ref, tol, nframes);
+  ASSERT_EQ(atomic_energy.size(), static_cast<size_t>(nframes * natoms));
+  ASSERT_EQ(atomic_virial.size(), static_cast<size_t>(nframes * natoms * 9));
+
+  for (int kk = 0; kk < nframes; ++kk) {
+    for (int ii = 0; ii < natoms; ++ii) {
+      EXPECT_NEAR(atomic_energy[kk * natoms + ii], ref.atomic_energy[ii], tol);
+    }
+    for (int ii = 0; ii < natoms * 9; ++ii) {
+      EXPECT_NEAR(atomic_virial[kk * natoms * 9 + ii], ref.atomic_virial[ii],
+                  tol);
+    }
+  }
+}
+
+template <typename ValueType>
+void check_compute_frames_simple(deepmd::DeepPot& dp,
+                                 const deepmd_test::DeepPotRef& ref,
+                                 const double tol,
+                                 const int nframes,
+                                 const bool use_box = true) {
+  const std::vector<ValueType> coord = repeat_values(
+      cast_values<ValueType>(deepmd_test::deeppot_coord()), nframes);
+  std::vector<ValueType> box;
+  if (use_box) {
+    box = repeat_values(cast_values<ValueType>(deepmd_test::deeppot_box()),
+                        nframes);
+  }
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+
+  std::vector<double> energy;
+  std::vector<ValueType> force;
+  std::vector<ValueType> virial;
+  dp.compute(energy, force, virial, coord, atype, box);
+
+  expect_reference_frames(energy, force, virial, ref, tol, nframes);
+}
+
+template <typename ValueType>
+void check_compute_frames_atomic(deepmd::DeepPot& dp,
+                                 const deepmd_test::DeepPotRef& ref,
+                                 const double tol,
+                                 const int nframes) {
+  const std::vector<ValueType> coord = repeat_values(
+      cast_values<ValueType>(deepmd_test::deeppot_coord()), nframes);
+  const std::vector<ValueType> box = repeat_values(
+      cast_values<ValueType>(deepmd_test::deeppot_box()), nframes);
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+
+  std::vector<double> energy;
+  std::vector<ValueType> force;
+  std::vector<ValueType> virial;
+  std::vector<ValueType> atomic_energy;
+  std::vector<ValueType> atomic_virial;
+  dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, atype,
+             box);
+
+  expect_atomic_reference_frames(energy, force, virial, atomic_energy,
+                                 atomic_virial, ref, tol, nframes);
+}
+
+template <typename ValueType>
+void check_lmp_nlist_frames(deepmd::DeepPot& dp,
+                            const deepmd_test::DeepPotRef& ref,
+                            const double tol,
+                            const int nframes,
+                            const bool atomic,
+                            const double cutoff_scale = 1.0,
+                            const bool set_mapping = true) {
+  const int natoms = static_cast<int>(deepmd_test::deeppot_atype().size());
+  const std::vector<ValueType> coord =
+      cast_values<ValueType>(deepmd_test::deeppot_coord());
+  const std::vector<int> atype = deepmd_test::deeppot_atype();
+  const std::vector<ValueType> box_frame =
+      cast_values<ValueType>(deepmd_test::deeppot_box());
+  const std::vector<ValueType> box = repeat_values(box_frame, nframes);
+  const float rc = static_cast<float>(dp.cutoff() * cutoff_scale);
+  const int nloc = natoms;
+  std::vector<ValueType> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int>> nlist_data;
+  _build_nlist<ValueType>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box_frame, rc);
+  const int nall = static_cast<int>(coord_cpy.size() / 3);
+  const std::vector<ValueType> coord_cpy_frames =
+      repeat_values(coord_cpy, nframes);
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_data);
+  if (set_mapping) {
+    inlist.mapping = mapping.data();
+  }
+
+  for (int ago = 0; ago < 2; ++ago) {
+    std::vector<double> energy;
+    std::vector<ValueType> force_all;
+    std::vector<ValueType> virial;
+    if (atomic) {
+      std::vector<ValueType> atomic_energy_all;
+      std::vector<ValueType> atomic_virial_all;
+      dp.compute(energy, force_all, virial, atomic_energy_all,
+                 atomic_virial_all, coord_cpy_frames, atype_cpy, box,
+                 nall - nloc, inlist, ago);
+
+      std::vector<ValueType> force, atomic_energy, atomic_virial;
+      _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3, nframes);
+      _fold_back<ValueType>(atomic_energy, atomic_energy_all, mapping, nloc,
+                            nall, 1, nframes);
+      _fold_back<ValueType>(atomic_virial, atomic_virial_all, mapping, nloc,
+                            nall, 9, nframes);
+      expect_atomic_reference_frames(energy, force, virial, atomic_energy,
+                                     atomic_virial, ref, tol, nframes);
+    } else {
+      dp.compute(energy, force_all, virial, coord_cpy_frames, atype_cpy, box,
+                 nall - nloc, inlist, ago);
+
+      std::vector<ValueType> force;
+      _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3, nframes);
+      expect_reference_frames(energy, force, virial, ref, tol, nframes);
+    }
+  }
+}
+
+template <typename ValueType>
+void check_lmp_nlist_type_sel_frames(deepmd::DeepPot& dp,
+                                     const deepmd_test::DeepPotRef& ref,
+                                     const double tol,
+                                     const int nframes,
+                                     const bool atomic,
+                                     const bool set_mapping = true) {
+  constexpr int nvir = 2;
+  const std::vector<ValueType> base_coord =
+      cast_values<ValueType>(deepmd_test::deeppot_coord());
+  std::vector<ValueType> coord_vir(nvir * 3);
+  std::copy(base_coord.begin(), base_coord.begin() + nvir * 3,
+            coord_vir.begin());
+
+  std::vector<ValueType> coord = base_coord;
+  coord.insert(coord.begin(), coord_vir.begin(), coord_vir.end());
+  std::vector<int> atype = deepmd_test::deeppot_atype();
+  atype.insert(atype.begin(), nvir, 2);
+  const std::vector<ValueType> box_frame =
+      cast_values<ValueType>(deepmd_test::deeppot_box());
+  const std::vector<ValueType> box = repeat_values(box_frame, nframes);
+
+  const int natoms = static_cast<int>(atype.size());
+  const int nloc = natoms;
+  const float rc = static_cast<float>(dp.cutoff());
+  std::vector<ValueType> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int>> nlist_data;
+  _build_nlist<ValueType>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box_frame, rc);
+  const int nall = static_cast<int>(coord_cpy.size() / 3);
+  const std::vector<ValueType> coord_cpy_frames =
+      repeat_values(coord_cpy, nframes);
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_data);
+  if (set_mapping) {
+    inlist.mapping = mapping.data();
+  }
+
+  std::vector<double> energy;
+  std::vector<ValueType> force_all;
+  std::vector<ValueType> virial;
+  if (atomic) {
+    std::vector<ValueType> atomic_energy, atomic_virial;
+    dp.compute(energy, force_all, virial, atomic_energy, atomic_virial,
+               coord_cpy_frames, atype_cpy, box, nall - nloc, inlist, 0);
+  } else {
+    dp.compute(energy, force_all, virial, coord_cpy_frames, atype_cpy, box,
+               nall - nloc, inlist, 0);
+  }
+
+  std::vector<ValueType> force;
+  _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3, nframes);
+
+  const std::vector<double> expected_virial = deepmd_test::total_virial(ref);
+  std::vector<ValueType> expected_force_frame(ref.force.begin(),
+                                              ref.force.end());
+  expected_force_frame.insert(expected_force_frame.begin(), nvir * 3, 0.0);
+  const std::vector<ValueType> expected_force =
+      repeat_values(expected_force_frame, nframes);
+
+  ASSERT_EQ(energy.size(), static_cast<size_t>(nframes));
+  ASSERT_EQ(force.size(), expected_force.size());
+  ASSERT_EQ(virial.size(), static_cast<size_t>(nframes * 9));
+  for (int kk = 0; kk < nframes; ++kk) {
+    EXPECT_NEAR(energy[kk], deepmd_test::total_energy(ref), tol);
+    for (size_t ii = 0; ii < expected_force_frame.size(); ++ii) {
+      EXPECT_NEAR(force[kk * expected_force_frame.size() + ii],
+                  expected_force_frame[ii], tol);
+    }
+    for (size_t ii = 0; ii < 9; ++ii) {
+      EXPECT_NEAR(virial[kk * 9 + ii], expected_virial[ii], tol);
+    }
+  }
+}
+
+template <typename ValueType>
+void check_fparam_compute_simple(deepmd::DeepPot& dp,
+                                 const deepmd_test::DeepPotRef& ref,
+                                 const double tol,
+                                 const std::vector<double>& fparam_values) {
+  const std::vector<ValueType> coord =
+      cast_values<ValueType>(deepmd_test::deeppot_coord());
+  const std::vector<int> atype = deepmd_test::fparam_aparam_atype();
+  const std::vector<ValueType> box =
+      cast_values<ValueType>(deepmd_test::deeppot_box());
+  const std::vector<ValueType> fparam = cast_values<ValueType>(fparam_values);
+  const std::vector<ValueType> aparam =
+      cast_values<ValueType>(deepmd_test::aparam_value());
+
+  double energy = 0.0;
+  std::vector<ValueType> force;
+  std::vector<ValueType> virial;
+  dp.compute(energy, force, virial, coord, atype, box, fparam, aparam);
+
+  expect_reference(energy, force, virial, ref, tol);
+}
+
+template <typename ValueType>
+void check_fparam_compute_atomic(deepmd::DeepPot& dp,
+                                 const deepmd_test::DeepPotRef& ref,
+                                 const double tol,
+                                 const std::vector<double>& fparam_values) {
+  const std::vector<ValueType> coord =
+      cast_values<ValueType>(deepmd_test::deeppot_coord());
+  const std::vector<int> atype = deepmd_test::fparam_aparam_atype();
+  const std::vector<ValueType> box =
+      cast_values<ValueType>(deepmd_test::deeppot_box());
+  const std::vector<ValueType> fparam = cast_values<ValueType>(fparam_values);
+  const std::vector<ValueType> aparam =
+      cast_values<ValueType>(deepmd_test::aparam_value());
+
+  double energy = 0.0;
+  std::vector<ValueType> force;
+  std::vector<ValueType> virial;
+  std::vector<ValueType> atomic_energy;
+  std::vector<ValueType> atomic_virial;
+  dp.compute(energy, force, virial, atomic_energy, atomic_virial, coord, atype,
+             box, fparam, aparam);
+
+  expect_atomic_reference(energy, force, virial, atomic_energy, atomic_virial,
+                          ref, tol);
+}
+
+template <typename ValueType>
+void check_fparam_lmp_nlist(deepmd::DeepPot& dp,
+                            const deepmd_test::DeepPotRef& ref,
+                            const double tol,
+                            const std::vector<double>& fparam_values,
+                            const bool atomic,
+                            const double cutoff_scale = 1.0,
+                            const int ago_count = 2) {
+  const int natoms =
+      static_cast<int>(deepmd_test::fparam_aparam_atype().size());
+  const std::vector<ValueType> coord =
+      cast_values<ValueType>(deepmd_test::deeppot_coord());
+  const std::vector<int> atype = deepmd_test::fparam_aparam_atype();
+  const std::vector<ValueType> box =
+      cast_values<ValueType>(deepmd_test::deeppot_box());
+  const std::vector<ValueType> fparam = cast_values<ValueType>(fparam_values);
+  const std::vector<ValueType> aparam =
+      cast_values<ValueType>(deepmd_test::aparam_value());
+  const float rc = static_cast<float>(dp.cutoff() * cutoff_scale);
+  const int nloc = natoms;
+  std::vector<ValueType> coord_cpy;
+  std::vector<int> atype_cpy, mapping;
+  std::vector<std::vector<int>> nlist_data;
+  _build_nlist<ValueType>(nlist_data, coord_cpy, atype_cpy, mapping, coord,
+                          atype, box, rc);
+  const int nall = static_cast<int>(coord_cpy.size() / 3);
+  std::vector<int> ilist(nloc), numneigh(nloc);
+  std::vector<int*> firstneigh(nloc);
+  deepmd::InputNlist inlist(nloc, ilist.data(), numneigh.data(),
+                            firstneigh.data());
+  convert_nlist(inlist, nlist_data);
+  inlist.mapping = mapping.data();
+
+  for (int ago = 0; ago < ago_count; ++ago) {
+    double energy = 0.0;
+    std::vector<ValueType> force_all(nall * 3, 0.0);
+    std::vector<ValueType> virial(9, 0.0);
+    if (atomic) {
+      std::vector<ValueType> atomic_energy_all(nall, 0.0);
+      std::vector<ValueType> atomic_virial_all(nall * 9, 0.0);
+      dp.compute(energy, force_all, virial, atomic_energy_all,
+                 atomic_virial_all, coord_cpy, atype_cpy, box, nall - nloc,
+                 inlist, ago, fparam, aparam);
+
+      std::vector<ValueType> force, atomic_energy, atomic_virial;
+      _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3);
+      _fold_back<ValueType>(atomic_energy, atomic_energy_all, mapping, nloc,
+                            nall, 1);
+      _fold_back<ValueType>(atomic_virial, atomic_virial_all, mapping, nloc,
+                            nall, 9);
+      expect_atomic_reference(energy, force, virial, atomic_energy,
+                              atomic_virial, ref, tol);
+    } else {
+      dp.compute(energy, force_all, virial, coord_cpy, atype_cpy, box,
+                 nall - nloc, inlist, ago, fparam, aparam);
+
+      std::vector<ValueType> force;
+      _fold_back<ValueType>(force, force_all, mapping, nloc, nall, 3);
+      expect_reference(energy, force, virial, ref, tol);
+    }
+  }
+}
+
+TEST_P(UniversalDeepPotTest, ComputeDouble) {
+  check_compute_atomic<double>(dp, *GetParam().ref, GetParam().double_tol);
+}
+
+TEST_P(UniversalDeepPotTest, ComputeFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_compute_atomic<float>(dp, *GetParam().ref, GetParam().float_tol);
+}
+
+TEST_P(UniversalDeepPotTest, ComputeSimpleDouble) {
+  check_compute_simple<double>(dp, *GetParam().ref, GetParam().double_tol);
+}
+
+TEST_P(UniversalDeepPotTest, ComputeSimpleFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_compute_simple<float>(dp, *GetParam().ref, GetParam().float_tol);
+}
+
+TEST_P(UniversalDeepPotTest, FiniteDifferenceDouble) {
+  check_finite_difference<double>(dp);
+}
+
+TEST_P(UniversalDeepPotTest, FiniteDifferenceFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_finite_difference<float>(dp);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistDouble) {
+  check_lmp_nlist<double>(dp, *GetParam().ref, GetParam().double_tol, 1.0,
+                          GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_lmp_nlist<float>(dp, *GetParam().ref, GetParam().float_tol, 1.0,
+                         GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistAtomicDouble) {
+  check_lmp_nlist_atomic<double>(dp, *GetParam().ref, GetParam().double_tol,
+                                 GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_lmp_nlist_atomic<float>(dp, *GetParam().ref, GetParam().float_tol,
+                                GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistDoubleCutoffTwice) {
+  check_lmp_nlist<double>(dp, *GetParam().ref, GetParam().double_tol, 2.0,
+                          GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistFloatCutoffTwice) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_lmp_nlist<float>(dp, *GetParam().ref, GetParam().float_tol, 2.0,
+                         GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistSkinBelowModelWidthDouble) {
+  check_lmp_nlist_skin_below_model_width<double>(
+      dp, *GetParam().ref, GetParam().double_tol,
+      GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistSkinBelowModelWidthFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_lmp_nlist_skin_below_model_width<float>(
+      dp, *GetParam().ref, GetParam().float_tol,
+      GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistTypeSelDouble) {
+  check_lmp_nlist_type_sel<double>(dp, *GetParam().ref, GetParam().double_tol,
+                                   false,
+                                   GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistTypeSelFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_lmp_nlist_type_sel<float>(dp, *GetParam().ref, GetParam().float_tol,
+                                  false, GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistTypeSelAtomicDouble) {
+  check_lmp_nlist_type_sel<double>(dp, *GetParam().ref, GetParam().double_tol,
+                                   true, GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, LmpNlistTypeSelAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_lmp_nlist_type_sel<float>(dp, *GetParam().ref, GetParam().float_tol,
+                                  true, GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, ComputeNoPbcDouble) {
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_atomic<double>(dp, *GetParam().no_pbc_ref,
+                               GetParam().double_tol, false);
+}
+
+TEST_P(UniversalDeepPotTest, ComputeNoPbcFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_atomic<float>(dp, *GetParam().no_pbc_ref, GetParam().float_tol,
+                              false);
+}
+
+TEST_P(UniversalDeepPotTest, ComputeSimpleNoPbcDouble) {
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_simple<double>(dp, *GetParam().no_pbc_ref,
+                               GetParam().double_tol, false);
+}
+
+TEST_P(UniversalDeepPotTest, ComputeSimpleNoPbcFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_simple<float>(dp, *GetParam().no_pbc_ref, GetParam().float_tol,
+                              false);
+}
+
+TEST_P(UniversalDeepPotTest, PrintSummary) { dp.print_summary(""); }
+
+TEST_P(UniversalDeepPotTest, NFramesComputeDouble) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_compute_frames_simple<double>(dp, *GetParam().ref,
+                                      GetParam().double_tol, 2);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesComputeFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_compute_frames_simple<float>(dp, *GetParam().ref, GetParam().float_tol,
+                                     2);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesComputeAtomicDouble) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_compute_frames_atomic<double>(dp, *GetParam().ref,
+                                      GetParam().double_tol, 2);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesComputeAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_compute_frames_atomic<float>(dp, *GetParam().ref, GetParam().float_tol,
+                                     2);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistDouble) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_lmp_nlist_frames<double>(dp, *GetParam().ref, GetParam().double_tol, 2,
+                                 false, 1.0,
+                                 GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_lmp_nlist_frames<float>(dp, *GetParam().ref, GetParam().float_tol, 2,
+                                false, 1.0,
+                                GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicDouble) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_lmp_nlist_frames<double>(dp, *GetParam().ref, GetParam().double_tol, 2,
+                                 true, 1.0,
+                                 GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_lmp_nlist_frames<float>(dp, *GetParam().ref, GetParam().float_tol, 2,
+                                true, 1.0,
+                                GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistDoubleCutoffTwice) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_lmp_nlist_frames<double>(dp, *GetParam().ref, GetParam().double_tol, 2,
+                                 false, 2.0,
+                                 GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistFloatCutoffTwice) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  check_lmp_nlist_frames<float>(dp, *GetParam().ref, GetParam().float_tol, 2,
+                                false, 2.0,
+                                GetParam().supports_lmp_nlist_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelDouble) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  const bool set_mapping = GetParam().supports_lmp_nlist_mapping;
+  check_lmp_nlist_type_sel_frames<double>(
+      dp, *GetParam().ref, GetParam().double_tol, 2, false, set_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  const bool set_mapping = GetParam().supports_lmp_nlist_mapping;
+  check_lmp_nlist_type_sel_frames<float>(
+      dp, *GetParam().ref, GetParam().float_tol, 2, false, set_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicDouble) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  const bool set_mapping = GetParam().supports_lmp_nlist_mapping;
+  check_lmp_nlist_type_sel_frames<double>(
+      dp, *GetParam().ref, GetParam().double_tol, 2, true, set_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesLmpNlistTypeSelAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  const bool set_mapping = GetParam().supports_lmp_nlist_mapping;
+  check_lmp_nlist_type_sel_frames<float>(
+      dp, *GetParam().ref, GetParam().float_tol, 2, true, set_mapping);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesComputeNoPbcDouble) {
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_frames_simple<double>(dp, *GetParam().no_pbc_ref,
+                                      GetParam().double_tol, 2, false);
+}
+
+TEST_P(UniversalDeepPotTest, NFramesComputeNoPbcFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_nframes) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " nframes coverage is not enabled.";
+  }
+  if (GetParam().no_pbc_ref == nullptr) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " NoPBC reference is not available.";
+  }
+  check_compute_frames_simple<float>(dp, *GetParam().no_pbc_ref,
+                                     GetParam().float_tol, 2, false);
+}
+
+TEST_P(VariantDeepPotTest, ComputeDouble) {
+  check_compute_atomic<double>(dp, *ref, GetParam().double_tol);
+}
+
+TEST_P(VariantDeepPotTest, ComputeFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_compute_atomic<float>(dp, *ref, GetParam().float_tol);
+}
+
+TEST_P(VariantDeepPotTest, ComputeSimpleDouble) {
+  check_compute_simple<double>(dp, *ref, GetParam().double_tol);
+}
+
+TEST_P(VariantDeepPotTest, ComputeSimpleFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_compute_simple<float>(dp, *ref, GetParam().float_tol);
+}
+
+TEST_P(VariantDeepPotTest, FiniteDifferenceDouble) {
+  if (!GetParam().supports_finite_difference) {
+    GTEST_SKIP() << GetParam().name
+                 << " finite-difference coverage is not enabled.";
+  }
+  check_finite_difference<double>(dp);
+}
+
+TEST_P(VariantDeepPotTest, FiniteDifferenceFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_finite_difference) {
+    GTEST_SKIP() << GetParam().name
+                 << " finite-difference coverage is not enabled.";
+  }
+  const double finite_difference_tol =
+      GetParam().name == "dpa4_pytorch_pt2" ? 3e-2 : -1.0;
+  check_finite_difference<float>(dp, finite_difference_tol);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistDouble) {
+  if (!GetParam().supports_lmp_nlist) {
+    GTEST_SKIP() << GetParam().name << " LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist<double>(dp, *ref, GetParam().double_tol);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_lmp_nlist) {
+    GTEST_SKIP() << GetParam().name << " LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist<float>(dp, *ref, GetParam().float_tol);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistAtomicDouble) {
+  if (!GetParam().supports_lmp_nlist_atomic) {
+    GTEST_SKIP() << GetParam().name
+                 << " atomic LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist_atomic<double>(dp, *ref, GetParam().double_tol);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_lmp_nlist_atomic) {
+    GTEST_SKIP() << GetParam().name
+                 << " atomic LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist_atomic<float>(dp, *ref, GetParam().float_tol);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistDoubleCutoffTwice) {
+  if (!GetParam().supports_lmp_nlist_cutoff_twice) {
+    GTEST_SKIP() << GetParam().name
+                 << " doubled-cutoff LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist<double>(dp, *ref, GetParam().double_tol, 2.0);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistFloatCutoffTwice) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_lmp_nlist_cutoff_twice) {
+    GTEST_SKIP() << GetParam().name
+                 << " doubled-cutoff LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist<float>(dp, *ref, GetParam().float_tol, 2.0);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistTypeSelDouble) {
+  if (!GetParam().supports_lmp_nlist_type_sel) {
+    GTEST_SKIP() << GetParam().name
+                 << " type-selected LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist_type_sel<double>(dp, *ref, GetParam().double_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, LmpNlistTypeSelFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_lmp_nlist_type_sel) {
+    GTEST_SKIP() << GetParam().name
+                 << " type-selected LAMMPS nlist coverage is not enabled.";
+  }
+  check_lmp_nlist_type_sel<float>(dp, *ref, GetParam().float_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, PrintSummary) {
+  if (!GetParam().supports_print_summary) {
+    GTEST_SKIP() << GetParam().name << " summary coverage is not enabled.";
+  }
+  dp.print_summary("");
+}
+
+TEST_P(VariantDeepPotTest, ComputeSimpleNoPbcDouble) {
+  if (!GetParam().supports_no_pbc_simple) {
+    GTEST_SKIP() << GetParam().name << " NoPBC coverage is not enabled.";
+  }
+  check_compute_simple<double>(dp, *no_pbc_ref, GetParam().double_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, ComputeSimpleNoPbcFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_no_pbc_simple) {
+    GTEST_SKIP() << GetParam().name << " NoPBC coverage is not enabled.";
+  }
+  check_compute_simple<float>(dp, *no_pbc_ref, GetParam().float_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, ComputeNoPbcDouble) {
+  if (!GetParam().supports_no_pbc_atomic) {
+    GTEST_SKIP() << GetParam().name << " atomic NoPBC coverage is not enabled.";
+  }
+  check_compute_atomic<double>(dp, *no_pbc_ref, GetParam().double_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, ComputeNoPbcFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_no_pbc_atomic) {
+    GTEST_SKIP() << GetParam().name << " atomic NoPBC coverage is not enabled.";
+  }
+  check_compute_atomic<float>(dp, *no_pbc_ref, GetParam().float_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, NoPbcLmpNlistDouble) {
+  if (!GetParam().supports_no_pbc_lmp_nlist) {
+    GTEST_SKIP() << GetParam().name
+                 << " NoPBC LAMMPS nlist coverage is not enabled.";
+  }
+  check_no_pbc_lmp_nlist<double>(dp, *no_pbc_ref, GetParam().double_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, NoPbcLmpNlistFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_no_pbc_lmp_nlist) {
+    GTEST_SKIP() << GetParam().name
+                 << " NoPBC LAMMPS nlist coverage is not enabled.";
+  }
+  check_no_pbc_lmp_nlist<float>(dp, *no_pbc_ref, GetParam().float_tol, false);
+}
+
+TEST_P(VariantDeepPotTest, NoPbcLmpNlistAtomicDouble) {
+  if (!GetParam().supports_no_pbc_lmp_nlist_atomic) {
+    GTEST_SKIP() << GetParam().name
+                 << " atomic NoPBC LAMMPS nlist coverage is not enabled.";
+  }
+  check_no_pbc_lmp_nlist<double>(dp, *no_pbc_ref, GetParam().double_tol, true);
+}
+
+TEST_P(VariantDeepPotTest, NoPbcLmpNlistAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  if (!GetParam().supports_no_pbc_lmp_nlist_atomic) {
+    GTEST_SKIP() << GetParam().name
+                 << " atomic NoPBC LAMMPS nlist coverage is not enabled.";
+  }
+  check_no_pbc_lmp_nlist<float>(dp, *no_pbc_ref, GetParam().float_tol, true);
+}
+
+TEST_P(FParamAParamDeepPotTest, Metadata) {
+  EXPECT_EQ(dp.dim_fparam(), 1);
+  EXPECT_EQ(dp.dim_aparam(), 1);
+  EXPECT_FALSE(dp.has_default_fparam());
+}
+
+TEST_P(FParamAParamDeepPotTest, ComputeDouble) {
+  check_fparam_compute_atomic<double>(dp, *ref, GetParam().double_tol,
+                                      deepmd_test::fparam_value());
+}
+
+TEST_P(FParamAParamDeepPotTest, ComputeFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_compute_atomic<float>(dp, *ref, GetParam().float_tol,
+                                     deepmd_test::fparam_value());
+}
+
+TEST_P(FParamAParamDeepPotTest, ComputeSimpleDouble) {
+  check_fparam_compute_simple<double>(dp, *ref, GetParam().double_tol,
+                                      deepmd_test::fparam_value());
+}
+
+TEST_P(FParamAParamDeepPotTest, ComputeSimpleFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_compute_simple<float>(dp, *ref, GetParam().float_tol,
+                                     deepmd_test::fparam_value());
+}
+
+TEST_P(FParamAParamDeepPotTest, LmpNlistDouble) {
+  check_fparam_lmp_nlist<double>(dp, *ref, GetParam().double_tol,
+                                 deepmd_test::fparam_value(), false);
+}
+
+TEST_P(FParamAParamDeepPotTest, LmpNlistFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_lmp_nlist<float>(dp, *ref, GetParam().float_tol,
+                                deepmd_test::fparam_value(), false);
+}
+
+TEST_P(FParamAParamDeepPotTest, LmpNlistAtomicDouble) {
+  check_fparam_lmp_nlist<double>(dp, *ref, GetParam().double_tol,
+                                 deepmd_test::fparam_value(), true);
+}
+
+TEST_P(FParamAParamDeepPotTest, LmpNlistAtomicFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_lmp_nlist<float>(dp, *ref, GetParam().float_tol,
+                                deepmd_test::fparam_value(), true);
+}
+
+TEST_P(FParamAParamDeepPotTest, LmpNlistDoubleCutoffTwice) {
+  check_fparam_lmp_nlist<double>(dp, *ref, GetParam().double_tol,
+                                 deepmd_test::fparam_value(), false, 2.0);
+}
+
+TEST_P(FParamAParamDeepPotTest, LmpNlistFloatCutoffTwice) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_lmp_nlist<float>(dp, *ref, GetParam().float_tol,
+                                deepmd_test::fparam_value(), false, 2.0);
+}
+
+TEST_P(DefaultFParamDeepPotTest, Metadata) {
+  EXPECT_EQ(dp.dim_fparam(), 1);
+  EXPECT_EQ(dp.dim_aparam(), 1);
+  EXPECT_TRUE(dp.has_default_fparam());
+}
+
+TEST_P(DefaultFParamDeepPotTest, ComputeWithEmptyFParamDouble) {
+  check_fparam_compute_simple<double>(dp, ref, GetParam().double_tol, {});
+}
+
+TEST_P(DefaultFParamDeepPotTest, ComputeWithEmptyFParamFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_compute_simple<float>(dp, ref, GetParam().float_tol, {});
+}
+
+TEST_P(DefaultFParamDeepPotTest, ComputeWithExplicitFParamDouble) {
+  check_fparam_compute_simple<double>(dp, ref, GetParam().double_tol,
+                                      deepmd_test::fparam_value());
+}
+
+TEST_P(DefaultFParamDeepPotTest, ComputeWithExplicitFParamFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_compute_simple<float>(dp, ref, GetParam().float_tol,
+                                     deepmd_test::fparam_value());
+}
+
+TEST_P(DefaultFParamDeepPotTest, LmpNlistWithEmptyFParamDouble) {
+  check_fparam_lmp_nlist<double>(dp, ref, GetParam().double_tol, {}, false, 1.0,
+                                 1);
+}
+
+TEST_P(DefaultFParamDeepPotTest, LmpNlistWithEmptyFParamFloat) {
+  if (!GetParam().supports_float) {
+    GTEST_SKIP() << backend_name(GetParam().backend)
+                 << " does not provide float inference coverage.";
+  }
+  check_fparam_lmp_nlist<float>(dp, ref, GetParam().float_tol, {}, false, 1.0,
+                                1);
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    AvailableBackends,
+    UniversalDeepPotTest,
+    ::testing::ValuesIn(model_cases()),
+    [](const ::testing::TestParamInfo<UniversalDeepPotTest::ParamType>& info) {
+      return info.param.name;
+    });
+
+INSTANTIATE_TEST_SUITE_P(
+    ModelVariants,
+    VariantDeepPotTest,
+    ::testing::ValuesIn(variant_deeppot_cases()),
+    [](const ::testing::TestParamInfo<VariantDeepPotTest::ParamType>& info) {
+      return info.param.name;
+    });
+
+INSTANTIATE_TEST_SUITE_P(
+    FParamAParamBackends,
+    FParamAParamDeepPotTest,
+    ::testing::ValuesIn(fparam_aparam_cases()),
+    [](const ::testing::TestParamInfo<FParamAParamDeepPotTest::ParamType>&
+           info) { return info.param.name; });
+
+INSTANTIATE_TEST_SUITE_P(
+    DefaultFParamBackends,
+    DefaultFParamDeepPotTest,
+    ::testing::ValuesIn(default_fparam_cases()),
+    [](const ::testing::TestParamInfo<DefaultFParamDeepPotTest::ParamType>&
+           info) { return info.param.name; });
+
+}  // namespace
diff --git a/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc b/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc
index ada7c2eba7..07836f4d6e 100644
--- a/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc
+++ b/source/api_cc/tests/test_deepspin_model_devi_ptexpt.cc
@@ -35,21 +35,19 @@ class TestInferDeepSpinModeDeviPtExpt : public ::testing::Test {
   void SetUp() override {
     std::string model0_path = "../../tests/infer/deeppot_dpa_spin_md0.pt2";
     std::string model1_path = "../../tests/infer/deeppot_dpa_spin_md1.pt2";
+#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN
+    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
+#endif
     {
       std::ifstream f(model0_path);
-      if (!f.good()) {
-        GTEST_SKIP() << "Skipping: " << model0_path << " not found.";
-      }
+      ASSERT_TRUE(f.good())
+          << "Model artifact is not available: " << model0_path;
     }
     {
       std::ifstream f(model1_path);
-      if (!f.good()) {
-        GTEST_SKIP() << "Skipping: " << model1_path << " not found.";
-      }
+      ASSERT_TRUE(f.good())
+          << "Model artifact is not available: " << model1_path;
     }
-#if !defined(BUILD_PYTORCH) || !BUILD_PT_EXPT_SPIN
-    GTEST_SKIP() << "Skip because PyTorch support is not enabled.";
-#endif
     dp0.init(model0_path);
     dp1.init(model1_path);
     dp_md.init({model0_path, model1_path});
diff --git a/source/lmp/tests/test_lammps_faparam.py b/source/lmp/tests/test_lammps_faparam.py
index c40fb9bdb0..857acc9f17 100644
--- a/source/lmp/tests/test_lammps_faparam.py
+++ b/source/lmp/tests/test_lammps_faparam.py
@@ -27,7 +27,7 @@
 data_file = Path(__file__).parent / "data.lmp"
 md_file = Path(__file__).parent / "md.out"
 
-# from api_cc/tests/test_deeppot_a_fparam_aparam.cc
+# Same reference values as source/tests/infer/deeppot_universal_data.h.
 expected_ae = np.array(
     [
         -1.038271183039953804e-01,
diff --git a/source/tests/infer/deeppot_universal_data.h b/source/tests/infer/deeppot_universal_data.h
new file mode 100644
index 0000000000..fdb64e2c72
--- /dev/null
+++ b/source/tests/infer/deeppot_universal_data.h
@@ -0,0 +1,422 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+#pragma once
+
+#include <numeric>
+#include <string>
+#include <vector>
+
+namespace deepmd_test {
+
+struct DeepPotRef {
+  std::vector<double> atomic_energy;
+  std::vector<double> force;
+  std::vector<double> atomic_virial;
+  double cutoff = 6.0;
+  int numb_types = 2;
+  int numb_types_spin = 0;
+  int dim_fparam = 0;
+  int dim_aparam = 0;
+  bool aparam_nall = false;
+  bool has_default_fparam = false;
+  std::string type_map = "O H";
+};
+
+inline const std::vector<double>& deeppot_coord() {
+  static const std::vector<double> coord = {
+      12.83, 2.56, 2.18, 12.09, 2.87, 2.74, 00.25, 3.32, 1.68,
+      3.36,  3.00, 1.81, 3.51,  2.51, 2.60, 4.27,  3.22, 1.56};
+  return coord;
+}
+
+inline const std::vector<int>& deeppot_atype() {
+  static const std::vector<int> atype = {0, 1, 1, 0, 1, 1};
+  return atype;
+}
+
+inline const std::vector<double>& deeppot_box() {
+  static const std::vector<double> box = {13., 0., 0., 0., 13.,
+                                          0.,  0., 0., 13.};
+  return box;
+}
+
+inline const std::vector<int>& fparam_aparam_atype() {
+  static const std::vector<int> atype = {0, 0, 0, 0, 0, 0};
+  return atype;
+}
+
+inline const std::vector<double>& fparam_value() {
+  static const std::vector<double> fparam = {0.25852028};
+  return fparam;
+}
+
+inline const std::vector<double>& aparam_value() {
+  static const std::vector<double> aparam = {
+      0.25852028, 0.25852028, 0.25852028, 0.25852028, 0.25852028, 0.25852028};
+  return aparam;
+}
+
+inline const DeepPotRef& tf_deeppot_ref() {
+  static const DeepPotRef ref = {
+      {-9.275780747115504710e+01, -1.863501786584258468e+02,
+       -1.863392472863538103e+02, -9.279281325486221021e+01,
+       -1.863671545232153903e+02, -1.863619822847602165e+02},
+      {-3.034045420701179663e-01, 8.405844663871177014e-01,
+       7.696947487118485642e-02, 7.662001266663505117e-01,
+       -1.880601391333554251e-01, -6.183333871091722944e-01,
+       -5.036172391059643427e-01, -6.529525836149027151e-01,
+       5.432962643022043459e-01, 6.382357912332115024e-01,
+       -1.748518296794561167e-01, 3.457363524891907125e-01,
+       1.286482986991941552e-03, 3.757251165286925043e-01,
+       -5.972588700887541124e-01, -5.987006197104716154e-01,
+       -2.004450304880958100e-01, 2.495901655353461868e-01},
+      {-2.912234126853306959e-01, -3.800610846612756388e-02,
+       2.776624987489437202e-01,  -5.053761003913598976e-02,
+       -3.152373041953385746e-01, 1.060894290092162379e-01,
+       2.826389131596073745e-01,  1.039129970665329250e-01,
+       -2.584378792325942586e-01, -3.121722367954994914e-01,
+       8.483275876786681990e-02,  2.524662342344257682e-01,
+       4.142176771106586414e-02,  -3.820285230785245428e-02,
+       -2.727311173065460545e-02, 2.668859789777112135e-01,
+       -6.448243569420382404e-02, -2.121731470426218846e-01,
+       -8.624335220278558922e-02, -1.809695356746038597e-01,
+       1.529875294531883312e-01,  -1.283658185172031341e-01,
+       -1.992682279795223999e-01, 1.409924999632362341e-01,
+       1.398322735274434292e-01,  1.804318474574856390e-01,
+       -1.470309318999652726e-01, -2.593983661598450730e-01,
+       -4.236536279233147489e-02, 3.386387920184946720e-02,
+       -4.174017537818433543e-02, -1.003500282164128260e-01,
+       1.525690815194478966e-01,  3.398976109910181037e-02,
+       1.522253908435125536e-01,  -2.349125581341701963e-01,
+       9.515545977581392825e-04,  -1.643218849228543846e-02,
+       1.993234765412972564e-02,  6.027265332209678569e-04,
+       -9.563256398907417355e-02, 1.510815124001868293e-01,
+       -7.738094816888557714e-03, 1.502832772532304295e-01,
+       -2.380965783745832010e-01, -2.309456719810296654e-01,
+       -6.666961081213038098e-02, 7.955566551234216632e-02,
+       -8.099093777937517447e-02, -3.386641099800401927e-02,
+       4.447884755740908608e-02,  1.008593228579038742e-01,
+       4.556718179228393811e-02,  -6.078081273849572641e-02}};
+  return ref;
+}
+
+inline const DeepPotRef& tf_deeppot_no_pbc_ref() {
+  static const DeepPotRef ref = {
+      {-9.255934839310273787e+01, -1.863253376736990106e+02,
+       -1.857237299341402945e+02, -9.279308539717486326e+01,
+       -1.863708105823244239e+02, -1.863635196514972563e+02},
+      {-2.161037360255332107e+00, 9.052994347015581589e-01,
+       1.635379623977007979e+00, 2.161037360255332107e+00,
+       -9.052994347015581589e-01, -1.635379623977007979e+00,
+       -1.167128117249453811e-02, 1.371975700096064992e-03,
+       -1.575265180249604477e-03, 6.226508593971802341e-01,
+       -1.816734122009256991e-01, 3.561766019664774907e-01,
+       -1.406075393906316626e-02, 3.789140061530929526e-01,
+       -6.018777878642909140e-01, -5.969188242856223736e-01,
+       -1.986125696522633155e-01, 2.472764510780630642e-01},
+      {-7.042445481792056761e-01, 2.950213647777754078e-01,
+       5.329418202437231633e-01,  2.950213647777752968e-01,
+       -1.235900311906896754e-01, -2.232594111831812944e-01,
+       5.329418202437232743e-01,  -2.232594111831813499e-01,
+       -4.033073234276823849e-01, -8.949230984097404917e-01,
+       3.749002169013777030e-01,  6.772391014992630298e-01,
+       3.749002169013777586e-01,  -1.570527935667933583e-01,
+       -2.837082722496912512e-01, 6.772391014992631408e-01,
+       -2.837082722496912512e-01, -5.125052659994422388e-01,
+       4.858210330291591605e-02,  -6.902596153269104431e-03,
+       6.682612642430500391e-03,  -5.612247004554610057e-03,
+       9.767795567660207592e-04,  -9.773758942738038254e-04,
+       5.638322117219018645e-03,  -9.483806049779926932e-04,
+       8.493873281881353637e-04,  -2.941738570564985666e-01,
+       -4.482529909499673171e-02, 4.091569840186781021e-02,
+       -4.509020615859140463e-02, -1.013919988807244071e-01,
+       1.551440772665269030e-01,  4.181857726606644232e-02,
+       1.547200233064863484e-01,  -2.398213304685777592e-01,
+       -3.218625798524068354e-02, -1.012438450438508421e-02,
+       1.271639330380921855e-02,  3.072814938490859779e-03,
+       -9.556241797915024372e-02, 1.512251983492413077e-01,
+       -8.277872384009607454e-03, 1.505412040827929787e-01,
+       -2.386150620881526407e-01, -2.312295470054945568e-01,
+       -6.631490213524345034e-02, 7.932427266386249398e-02,
+       -8.053754366323923053e-02, -3.294595881137418747e-02,
+       4.342495071150231922e-02,  1.004599500126941436e-01,
+       4.450400364869536163e-02,  -5.951077548033092968e-02}};
+  return ref;
+}
+
+inline const DeepPotRef& sea_deeppot_ref() {
+  static const DeepPotRef ref = {
+      {-93.016873944029, -185.923296645958, -185.927096544970, -93.019371018039,
+       -185.926179995548, -185.924351901852},
+      {0.006277522211, -0.001117962774, 0.000618580445, 0.009928999655,
+       0.003026035654, -0.006941982227, 0.000667853212, -0.002449963843,
+       0.006506463508, -0.007284129115, 0.000530662205, -0.000028806821,
+       0.000068097781, 0.006121331983, -0.009019754602, -0.009658343745,
+       -0.006110103225, 0.008865499697},
+      {-0.000155238009, 0.000116605516,  -0.007869862476, 0.000465578340,
+       0.008182547185,  -0.002398713212, -0.008112887338, -0.002423738425,
+       0.007210716605,  -0.019203504012, 0.001724938709,  0.009909211091,
+       0.001153857542,  -0.001600015103, -0.000560024090, 0.010727836276,
+       -0.001034836404, -0.007973454377, -0.021517399106, -0.004064359664,
+       0.004866398692,  -0.003360038617, -0.007241406162, 0.005920941051,
+       0.004899151657,  0.006290788591,  -0.006478820311, 0.001921504710,
+       0.001313470921,  -0.000304091236, 0.001684345981,  0.004124109256,
+       -0.006396084465, -0.000701095618, -0.006356507032, 0.009818550859,
+       -0.015230664587, -0.000110244376, 0.000690319396,  0.000045953023,
+       -0.005726548770, 0.008769818495,  -0.000572380210, 0.008860603423,
+       -0.013819348050, -0.021227082558, -0.004977781343, 0.006646239696,
+       -0.005987066507, -0.002767831232, 0.003746502525,  0.007697590397,
+       0.003746130152,  -0.005172634748}};
+  return ref;
+}
+
+inline const DeepPotRef& tf_fparam_aparam_ref() {
+  static const DeepPotRef ref = [] {
+    DeepPotRef ref = {{-1.038271183039953804e-01, -7.285433575272914908e-02,
+                       -9.467600174099155552e-02, -1.467050086239614082e-01,
+                       -7.660561620618722145e-02, -7.277295998502930630e-02},
+                      {6.622266817497907132e-02, 5.278739055693523058e-02,
+                       2.265727495541422845e-02, -2.606047850915838363e-02,
+                       -4.538811686410718776e-02, 1.058247569147072187e-02,
+                       1.679392490937766935e-01, -2.257828022687320690e-03,
+                       -4.490145670355452645e-02, -1.148364103573685929e-01,
+                       -1.169790466695089237e-02, 6.140402504113953025e-02,
+                       -8.078778132132799494e-02, -5.838878056243369807e-02,
+                       6.773639989682191109e-02, -1.247724708090079161e-02,
+                       6.494523955924384750e-02, -1.174787188812918687e-01},
+                      {-1.589185553287162656e-01, 2.586163333170100279e-03,
+                       -1.575127933809472624e-04, -1.855360380105876630e-02,
+                       1.949822090859933826e-02,  -1.006552056166355388e-02,
+                       3.177029853276916449e-02,  1.714349636720383010e-03,
+                       -1.290389175187874483e-03, -8.553510339477603253e-02,
+                       -5.654637257232508415e-03, -1.286954833787038420e-02,
+                       2.464156457499515687e-02,  -2.398202886026797043e-02,
+                       -1.957110465239037672e-02, 2.233492928605742764e-02,
+                       6.107843207824020099e-03,  1.707078295947736047e-03,
+                       -1.653994088976195043e-01, 3.894358678172111371e-02,
+                       -2.169595969759342477e-02, 6.819704294738503786e-03,
+                       -5.018242039618424008e-03, 2.640664428663210429e-03,
+                       -1.985298275686078057e-03, -3.638421609610945767e-02,
+                       2.342932331075030239e-02,  -8.501331914753691710e-02,
+                       -2.181253413538992297e-03, 4.311300069651782287e-03,
+                       -1.910329328333908129e-03, -1.808810159508548836e-03,
+                       -1.540075281450827612e-03, -1.173703213175551763e-02,
+                       -2.596306629910121507e-03, 6.705025662372287101e-03,
+                       -9.038455005073858795e-02, 3.011717773578577451e-02,
+                       -5.083054073419784880e-02, -2.951210292616929069e-03,
+                       2.342445652898489383e-02,  -4.091207474993674431e-02,
+                       -1.648470649301832236e-02, -2.872261885460645689e-02,
+                       4.763924972552112391e-02,  -8.300036532764677732e-02,
+                       1.020429228955421243e-03,  -1.026734151199098881e-03,
+                       5.678534096113684732e-02,  1.273635718045938205e-02,
+                       -1.530143225195957322e-02, -1.061671865629566225e-01,
+                       -2.486859433265622629e-02, 2.875323131744185121e-02}};
+    ref.numb_types = 1;
+    ref.dim_fparam = 1;
+    ref.dim_aparam = 1;
+    ref.type_map = "O";
+    return ref;
+  }();
+  return ref;
+}
+
+inline const DeepPotRef& sea_deeppot_no_pbc_ref() {
+  static const DeepPotRef ref = {
+      {-93.003304908874, -185.915806542480, -185.928116717624, -93.017934934346,
+       -185.924393412278, -185.923906740801},
+      {0.000868182637, -0.000363698132, -0.000657003077, -0.000868182637,
+       0.000363698132, 0.000657003077, 0.007932614680, -0.001003609844,
+       0.000737731722, -0.003883788858, 0.000686896282, -0.000578400682,
+       0.004064895086, 0.006115547962, -0.008747097814, -0.008113720908,
+       -0.005798834400, 0.008587766774},
+      {0.007762485364,  -0.003251851977, -0.005874313248, -0.003251851977,
+       0.001362262315,  0.002460860955,  -0.005874313248, 0.002460860955,
+       0.004445426242,  -0.007120030212, 0.002982715359,  0.005388130971,
+       0.002982715359,  -0.001249515894, -0.002257190002, 0.005388130971,
+       -0.002257190002, -0.004077504519, -0.015805863589, 0.001952684835,
+       -0.001522876482, 0.001796574704,  -0.000358803950, 0.000369710813,
+       -0.001108943040, 0.000332585300,  -0.000395481309, 0.008873525623,
+       0.001919112114,  -0.001486235522, 0.002002929532,  0.004222469272,
+       -0.006517211126, -0.001656192522, -0.006501210045, 0.010118622295,
+       -0.006548889778, -0.000465126991, 0.001002876603,  0.000240398734,
+       -0.005794489784, 0.008940685179,  -0.000121727685, 0.008931999051,
+       -0.013852797563, -0.017962955675, -0.004645050453, 0.006214692837,
+       -0.005278283465, -0.002662692758, 0.003618275905,  0.007095320684,
+       0.003648086464,  -0.005023397513}};
+  return ref;
+}
+
+inline const DeepPotRef& tf_deeppot_r_ref() {
+  static const DeepPotRef ref = {
+      {-9.320909762801588272e+01, -1.868020345400987878e+02,
+       -1.868011172371355997e+02, -9.320868430396934912e+01,
+       -1.868010398844378415e+02, -1.868016706555875999e+02},
+      {6.385312846474267391e-04, -6.460452911141417731e-03,
+       -5.652405655332678417e-04, -7.516468794343579736e-03,
+       1.128804614240160216e-03, 5.531937784564192051e-03,
+       1.914138124904981664e-03, 5.601819906021693503e-03,
+       -5.131359585752605541e-03, -4.847104424804288617e-03,
+       1.992071550328819614e-03, -4.028159855157302516e-03,
+       1.236340684486603517e-03, -5.373955841338794344e-03,
+       8.312829460571366513e-03, 8.574563125108854156e-03,
+       3.111712681889538742e-03, -4.120007238692381148e-03},
+      {5.844056241889131371e-03,  4.663973497239899614e-04,
+       -2.268382127762904633e-03, 4.663973497239897988e-04,
+       2.349338784202595950e-03,  -6.908546513234039253e-04,
+       -2.268382127762904633e-03, -6.908546513234039253e-04,
+       2.040499248150800561e-03,  4.238130266437327605e-03,
+       -1.539867187443782223e-04, -2.393101333240631613e-03,
+       -1.539867187443782223e-04, 4.410341945447907377e-04,
+       9.544239698119633068e-06,  -2.393101333240631613e-03,
+       9.544239698119578858e-06,  1.877785959095269654e-03,
+       5.798992562057291543e-03,  6.943392552230453693e-04,
+       -1.180376879311998773e-03, 6.943392552230453693e-04,
+       1.686725132156275536e-03,  -1.461632060145726542e-03,
+       -1.180376879311998556e-03, -1.461632060145726325e-03,
+       1.749543733794208444e-03,  7.173915604192910439e-03,
+       3.903218041111061569e-04,  -5.747400467123527524e-04,
+       3.903218041111061569e-04,  1.208289706621179949e-03,
+       -1.826828914132010932e-03, -5.747400467123527524e-04,
+       -1.826828914132011148e-03, 2.856960586657185906e-03,
+       4.067553030177322240e-03,  -3.267469855253819430e-05,
+       -6.980667859103454904e-05, -3.267469855253830272e-05,
+       1.387653029234650918e-03,  -2.096820720698671855e-03,
+       -6.980667859103444062e-05, -2.096820720698671855e-03,
+       3.218305506720191278e-03,  4.753992590355240674e-03,
+       1.224911338353675992e-03,  -1.683421934571502484e-03,
+       1.224911338353676209e-03,  7.332113564901583539e-04,
+       -1.025577052190138451e-03, -1.683421934571502484e-03,
+       -1.025577052190138234e-03, 1.456681925652047018e-03}};
+  return ref;
+}
+
+inline const DeepPotRef& tf_deeppot_r_no_pbc_ref() {
+  static const DeepPotRef ref = {
+      {-9.321213823508108476e+01, -1.868044102481340758e+02,
+       -1.868067983858651075e+02, -9.320899631301440991e+01,
+       -1.868014559732615112e+02, -1.868017660713088617e+02},
+      {4.578151103701261042e-03, -1.917874111009987628e-03,
+       -3.464546781179331930e-03, -4.578151103701261042e-03,
+       1.917874111009987628e-03, 3.464546781179331930e-03,
+       -2.624402581721222913e-03, 3.566275128489623933e-04,
+       -2.859315986763691776e-04, -5.767787273464367384e-03,
+       1.907053583551196647e-03, -3.889064429673861831e-03,
+       1.786820066350549132e-04, -5.327197473636275694e-03,
+       8.236236182834734409e-03, 8.213507848550535492e-03,
+       3.063516377236116545e-03, -4.061240154484504865e-03},
+      {1.984979026299632174e-03,  -8.315452677741701822e-04,
+       -1.502146290172694243e-03, -8.315452677741700738e-04,
+       3.483500446080982317e-04,  6.292774999372096039e-04,
+       -1.502146290172694243e-03, 6.292774999372097123e-04,
+       1.136759354725281907e-03,  1.402852790439301908e-03,
+       -5.876815743732210226e-04, -1.061618327900012114e-03,
+       -5.876815743732211311e-04, 2.461909298049979960e-04,
+       4.447320022283834766e-04,  -1.061618327900012331e-03,
+       4.447320022283834766e-04,  8.033868427351443728e-04,
+       4.143606961846296385e-03,  -5.511382161123719835e-04,
+       4.465413399437045397e-04,  -5.511382161123719835e-04,
+       1.082271054025323839e-04,  -1.097918001262628728e-04,
+       4.465413399437046481e-04,  -1.097918001262628728e-04,
+       1.220966982358671871e-04,  5.263952004497593831e-03,
+       2.395243710938091842e-04,  -2.830378939414603329e-04,
+       2.395243710938094010e-04,  1.189969706598244898e-03,
+       -1.805627331015851201e-03, -2.830378939414602245e-04,
+       -1.805627331015851635e-03, 2.801996513751836820e-03,
+       2.208413501170402270e-03,  5.331756287635716889e-05,
+       -1.664423506603235218e-04, 5.331756287635695205e-05,
+       1.379626072862918072e-03,  -2.094132943741625064e-03,
+       -1.664423506603234133e-04, -2.094132943741625064e-03,
+       3.199787996743366607e-03,  4.047014004814953811e-03,
+       1.137904999421357000e-03,  -1.568106936614101698e-03,
+       1.137904999421357217e-03,  7.205982843216952307e-04,
+       -1.011174600268313238e-03, -1.568106936614101698e-03,
+       -1.011174600268313238e-03, 1.435226522157425754e-03}};
+  return ref;
+}
+
+inline const DeepPotRef& jax_dpa_deeppot_ref() {
+  static const DeepPotRef ref = {
+      {-94.24098099691867, -187.8049502787117, -187.80486052083617,
+       -94.24059525229518, -187.80366985846246, -187.8042377490619},
+      {-0.0020150115442053, -0.0133389255924977, -0.0014347177433057,
+       -0.0140757358179293, 0.0031373814221557, 0.0098594354314677,
+       0.004755683505073, 0.0099471082374397, -0.0080868184532793,
+       -0.0086166721574536, 0.0037803939137322, -0.0075733131286482,
+       0.0037437603038209, -0.008452527996008, 0.0134837461840424,
+       0.0162079757106944, 0.0049265700151781, -0.0062483322902769},
+      {0.0133534319524089,  0.0013445914938337,  -0.0029370551651952,
+       0.0002611806151294,  0.004662662211533,   -0.0002717443796319,
+       -0.0027779798869954, -0.0003277976466339, 0.0018284972283065,
+       0.0085710118978246,  0.0003865036653608,  -0.0057964032875089,
+       -0.0014358330222619, 0.0002912625128908,  0.001212630641674,
+       -0.0050582608957046, -0.0001087907763249, 0.0040068757134429,
+       0.0116736349373084,  0.0007055477968445,  -0.0019544933708784,
+       0.0032997459258512,  0.0037887116116712,  -0.0043140890650835,
+       -0.0034418738401156, -0.0029420616852742, 0.0038219676716965,
+       0.0147134944025738,  0.0005214313829998,  -0.0006524136175906,
+       0.0003656980996363,  0.0010046161607714,  -0.0017279359476254,
+       0.000111127036911,   -0.0017063190420654, 0.0030174567965904,
+       0.0104435705455107,  -0.0008704394438241, 0.0012354202650812,
+       0.0009397615830053,  0.0029105236407293,  -0.0044188897903449,
+       -0.0011461513500477, -0.0045759080125852, 0.0070310883421107,
+       0.0089818851995049,  0.0038819466696704,  -0.005443705549253,
+       0.0025390283635246,  0.0012121502955869,  -0.0016998728971157,
+       -0.0032355117893925, -0.0015590242752438, 0.0021980725909838}};
+  return ref;
+}
+
+inline const DeepPotRef& jax_dpa_deeppot_no_pbc_ref() {
+  static const DeepPotRef ref = {
+      {-94.24457967995595, -187.81100287606412, -187.81417300904738,
+       -94.24110552426328, -187.80431436838532, -187.80457222464983},
+      {0.0051417559595313, -0.0021539788479118, -0.0038910585639696,
+       -0.0051417559595313, 0.0021539788479118, 0.0038910585639696,
+       -0.0035470615733886, 0.0003602503965239, -0.0001895679272905,
+       -0.0117361352793328, 0.0034252835112125, -0.0071824017939095,
+       0.0005398894945495, -0.0084330745423862, 0.013284532676939,
+       0.0147433073581718, 0.0046475406346498, -0.005912562955739},
+      {1.8756488030620411e-03,  -7.8574476885035112e-04,
+       -1.4194099050199721e-03, -7.8574476885031816e-04,
+       3.2916334911298369e-04,  5.9461766291377029e-04,
+       -1.4194099050199305e-03, 5.9461766291377637e-04,
+       1.0741480362313257e-03,  1.9292506069911106e-03,
+       -8.0819957860435269e-04, -1.4599734323175548e-03,
+       -8.0819957860438912e-04, 3.3857009373966171e-04,
+       6.1161049191681572e-04,  -1.4599734323175878e-03,
+       6.1161049191681138e-04,  1.1048447595916697e-03,
+       7.6085550162737362e-03,  -9.6772620145935649e-04,
+       8.3466357433496438e-04,  -6.0870001592646837e-04,
+       7.8216372819095133e-05,  -6.6454748650881927e-05,
+       1.6484218595781155e-04,  -1.4860654308892986e-05,
+       9.1346879754941710e-06,  7.3496442591020616e-03,
+       -4.4351638231197171e-04, 1.0048648094020743e-03,
+       -6.7678341212752506e-04, 1.0347359647873023e-03,
+       -1.6645682233463639e-03, 1.4376416549492857e-03,
+       -1.7116654329527997e-03, 2.8516307661164836e-03,
+       1.7683913600324828e-03,  -2.6945055858769765e-04,
+       3.0381043714224000e-04,  9.9317892494769217e-04,
+       2.9343081937224687e-03,  -4.4381349285303948e-03,
+       -1.6684804850477311e-03, -4.5760063242183471e-03,
+       6.9407432349694147e-03,  7.8021639779489171e-03,
+       3.5246152053432442e-03,  -4.9415349551876243e-03,
+       2.1362265660905197e-03,  1.2226850609509659e-03,
+       -1.7016886981679963e-03, -2.7321994901677166e-03,
+       -1.5683141872155984e-03, 2.1960566952029213e-03}};
+  return ref;
+}
+
+inline double total_energy(const DeepPotRef& ref) {
+  return std::accumulate(ref.atomic_energy.begin(), ref.atomic_energy.end(),
+                         0.0);
+}
+
+inline std::vector<double> total_virial(const DeepPotRef& ref) {
+  std::vector<double> virial(9, 0.0);
+  for (size_t atom = 0; atom < ref.atomic_energy.size(); ++atom) {
+    for (size_t dd = 0; dd < 9; ++dd) {
+      virial[dd] += ref.atomic_virial[atom * 9 + dd];
+    }
+  }
+  return virial;
+}
+
+}  // namespace deepmd_test
diff --git a/source/tests/infer/gen_fparam_aparam.py b/source/tests/infer/gen_fparam_aparam.py
index 79f165e147..2445b8b304 100644
--- a/source/tests/infer/gen_fparam_aparam.py
+++ b/source/tests/infer/gen_fparam_aparam.py
@@ -147,7 +147,8 @@ def main():
     )
 
     # ---- 4a. Write sidecar for fparam_aparam.pt2/.pth tests ----
-    # Consumers: test_deeppot_a_fparam_aparam_{pt,ptexpt,nframes_ptexpt}.cc
+    # Consumers: api_cc/api_c test_deeppot_universal.cc and
+    # api_cc test_deeppot_a_fparam_aparam_nframes_ptexpt.cc
     # Note: test_deeppot_ptexpt.cc also loads fparam_aparam.pt2 but only for
     # JSON-metadata checks; it does not consume these reference values.
     ref_path = os.path.join(base_dir, "fparam_aparam.expected")