Refactor: update unit tests

Author: YuLiu98

source/module_elecstate/test/charge_mixing_test.cpp

@@ -1,21 +1,18 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #define private public
-#include "module_parameter/parameter.h"
-#undef private
-#include "module_base/module_mixing/broyden_mixing.h"
-#define private public
-#include "module_parameter/parameter.h"
 #include "../module_charge/charge_mixing.h"
+#include "module_base/module_mixing/broyden_mixing.h"
 #include "module_basis/module_pw/pw_basis.h"
 #include "module_hamilt_general/module_xc/xc_functional.h"
-#undef private
+#include "module_parameter/parameter.h"
 
 #ifdef _OPENMP
 #include <omp.h>
 #endif
 
-int FUNC_TYPE = 1;
+int XC_Functional::func_type = 1;
+bool XC_Functional::has_kedf = false;
 
 // mock function
 Magnetism::~Magnetism()
@@ -35,10 +32,6 @@ void Charge::set_rhopw(ModulePW::PW_Basis* rhopw_in)
 {
     this->rhopw = rhopw_in;
 }
-int XC_Functional::get_func_type()
-{
-    return FUNC_TYPE;
-}
 #ifdef __LCAO
 InfoNonlocal::InfoNonlocal()
 {
@@ -232,7 +225,8 @@ TEST_F(ChargeMixingTest, InitMixingTest)
     omp_set_num_threads(1);
 #endif
     PARAM.input.nspin = 1;
-    FUNC_TYPE = 1;
+    XC_Functional::func_type = 1;
+    XC_Functional::has_kedf = false;
     Charge_Mixing CMtest;
     CMtest.set_rhopw(&pw_basis, &pw_basis);
 
@@ -275,7 +269,8 @@ TEST_F(ChargeMixingTest, InitMixingTest)
                     PARAM.input.mixing_dmr,
                     ucell.omega,
                     ucell.tpiba);
-    FUNC_TYPE = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     CMtest.init_mixing();
     EXPECT_EQ(CMtest.tau_mdata.length, pw_basis.nrxx);
 
@@ -826,7 +821,8 @@ TEST_F(ChargeMixingTest, MixRhoTest)
     charge.set_rhopw(&pw_basis);
     const int nspin = PARAM.input.nspin = 1;
     PARAM.sys.domag_z = false;
-    FUNC_TYPE = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     PARAM.input.mixing_beta = 0.7;
     PARAM.input.mixing_ndim = 1;
     PARAM.input.mixing_gg0 = 0.0;
@@ -964,7 +960,8 @@ TEST_F(ChargeMixingTest, MixDoubleGridRhoTest)
     charge.set_rhopw(&pw_dbasis);
     const int nspin = PARAM.input.nspin = 1;
     PARAM.sys.domag_z = false;
-    FUNC_TYPE = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     PARAM.input.mixing_beta = 0.7;
     PARAM.input.mixing_ndim = 1;
     PARAM.input.mixing_gg0 = 0.0;

source/module_elecstate/test/charge_test.cpp

@@ -3,13 +3,11 @@
 
 #define private public
 #define protected public
-#include "module_parameter/parameter.h"
 #include "module_cell/unitcell.h"
 #include "module_elecstate/module_charge/charge.h"
+#include "module_hamilt_general/module_xc/xc_functional.h"
+#include "module_parameter/parameter.h"
 #include "prepare_unitcell.h"
-#undef protected
-#undef private
-
 // mock functions for UnitCell
 #ifdef __LCAO
 InfoNonlocal::InfoNonlocal()
@@ -31,13 +29,10 @@ Magnetism::~Magnetism()
 }
 
 // mock functions for Charge
+int XC_Functional::func_type = 1;
+bool XC_Functional::has_kedf = false;
 namespace elecstate
 {
-int tmp_xc_func_type = 1;
-int XC_Functional::get_func_type()
-{
-    return tmp_xc_func_type;
-}
 double tmp_ucell_omega = 500.0;
 double tmp_gridecut = 80.0;
 void Set_GlobalV_Default()
@@ -118,7 +113,8 @@ TEST_F(ChargeTest, Allocate)
     EXPECT_EQ(rhopw->npwtot, 3143);
     // call Charge::allocate()
     PARAM.input.test_charge = 2;
-    elecstate::tmp_xc_func_type = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     charge->set_rhopw(rhopw);
     EXPECT_FALSE(charge->allocate_rho);
     charge->allocate(PARAM.input.nspin);
@@ -202,7 +198,8 @@ TEST_F(ChargeTest, SaveRhoBeforeSumBand)
         }
     }
     EXPECT_EQ(PARAM.input.nelec, 8);
-    elecstate::tmp_xc_func_type = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     charge->set_omega(&ucell->omega);;
     charge->renormalize_rho();
     charge->save_rho_before_sum_band();
@@ -212,7 +209,8 @@ TEST_F(ChargeTest, SaveRhoBeforeSumBand)
 TEST_F(ChargeTest, InitFinalScf)
 {
     charge->set_rhopw(rhopw);
-    elecstate::tmp_xc_func_type = 1;
+    XC_Functional::func_type = 1;
+    XC_Functional::has_kedf = false;
     PARAM.input.test_charge = 2;
     charge->init_final_scf();
     EXPECT_TRUE(charge->allocate_rho_final_scf);

source/module_elecstate/test/elecstate_energy_test.cpp

@@ -2,21 +2,18 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #define private public
-#include "module_parameter/parameter.h"
-#undef private
 #include "module_elecstate/elecstate.h"
+#include "module_hamilt_general/module_xc/xc_functional.h"
+#include "module_parameter/parameter.h"
 
 #include <string>
 Parameter PARMA;
 
 // mock functions
+int XC_Functional::func_type = 1;
+bool XC_Functional::has_kedf = false;
 namespace elecstate
 {
-int tmp_xc_func_type = 1;
-int XC_Functional::get_func_type()
-{
-    return tmp_xc_func_type;
-}
 void Potential::get_vnew(Charge const*, ModuleBase::matrix&)
 {
     return;

source/module_elecstate/test/elecstate_print_test.cpp

@@ -3,13 +3,13 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #define private public
-#include "module_parameter/parameter.h"
-#undef private
 #include "module_cell/klist.h"
 #include "module_elecstate/elecstate.h"
 #include "module_elecstate/module_charge/charge.h"
 #include "module_elecstate/potentials/efield.h"
 #include "module_elecstate/potentials/gatefield.h"
+#include "module_hamilt_general/module_xc/xc_functional.h"
+#include "module_parameter/parameter.h"
 
 /***************************************************************
  *  mock functions
@@ -40,10 +40,9 @@ Charge::Charge()
 Charge::~Charge()
 {
 }
-int XC_Functional::get_func_type()
-{
-    return 0;
-}
+
+int XC_Functional::func_type = 0;
+bool XC_Functional::has_kedf = false;
 
 /***************************************************************
  *  unit test of functions in elecstate_print.cpp

source/module_elecstate/test/elecstate_pw_test.cpp

@@ -3,20 +3,15 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #define private public
-#include "module_parameter/parameter.h"
-#undef private
 #define protected public
 #include "module_elecstate/elecstate_pw.h"
+#include "module_hamilt_general/module_xc/xc_functional.h"
 #include "module_hamilt_pw/hamilt_pwdft/VL_in_pw.h"
-#undef protected
+#include "module_parameter/parameter.h"
 // mock functions for testing
+int XC_Functional::func_type = 1;
 namespace elecstate
 {
-int tmp_xc_func_type = 1;
-int XC_Functional::get_func_type()
-{
-    return tmp_xc_func_type;
-}
 void Potential::init_pot(int, Charge const*)
 {
 }
@@ -272,7 +267,7 @@ TEST_F(ElecStatePWTest, ConstructorSingle)
 
 TEST_F(ElecStatePWTest, InitRhoDataDouble)
 {
-    elecstate::tmp_xc_func_type = 3;
+    XC_Functional::func_type = 3;
     chg->nrxx = 1000;
     elecstate_pw_d = new elecstate::ElecStatePW<std::complex<double>, base_device::DEVICE_CPU>(wfcpw,
                                                                                                chg,
@@ -291,7 +286,7 @@ TEST_F(ElecStatePWTest, InitRhoDataDouble)
 TEST_F(ElecStatePWTest, InitRhoDataSingle)
 {
     PARAM.input.precision = "single";
-    elecstate::tmp_xc_func_type = 3;
+    XC_Functional::func_type = 3;
     chg->nspin = PARAM.input.nspin;
     chg->nrxx = 1000;
     elecstate_pw_s = new elecstate::ElecStatePW<std::complex<float>, base_device::DEVICE_CPU>(wfcpw,

source/module_elecstate/test/potential_new_test.cpp

@@ -2,9 +2,9 @@
 #include <vector>
 
 #define private public
-#include "module_parameter/parameter.h"
 #include "module_elecstate/potentials/potential_new.h"
-#undef private
+#include "module_hamilt_general/module_xc/xc_functional.h"
+#include "module_parameter/parameter.h"
 // mock functions
 Structure_Factor::Structure_Factor()
 {
@@ -44,14 +44,10 @@ surchem::surchem()
 surchem::~surchem()
 {
 }
-
+int XC_Functional::func_type = 1;
+bool XC_Functional::has_kedf = false;
 namespace elecstate
 {
-int tmp_xc_func_type = 1;
-int XC_Functional::get_func_type()
-{
-    return tmp_xc_func_type;
-}
 
 PotBase* Potential::get_pot_type(const std::string& pot_type)
 {
@@ -197,7 +193,8 @@ TEST_F(PotentialNewTest, ConstructorNRXX0)
 
 TEST_F(PotentialNewTest, ConstructorXC3)
 {
-    elecstate::tmp_xc_func_type = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     rhopw->nrxx = 100;
     pot = new elecstate::Potential(rhopw, rhopw, ucell, vloc, structure_factors, solvent, etxc, vtxc);
     EXPECT_TRUE(pot->fixed_mode);
@@ -463,7 +460,8 @@ TEST_F(PotentialNewTest, GetEffectiveVarrayNullptr)
 TEST_F(PotentialNewTest, GetEffectiveVofkmatrix)
 {
     // construct potential
-    elecstate::tmp_xc_func_type = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     rhopw->nrxx = 100;
     pot = new elecstate::Potential(rhopw, rhopw, ucell, vloc, structure_factors, solvent, etxc, vtxc);
     //
@@ -532,7 +530,8 @@ TEST_F(PotentialNewTest, GetVeffSmooth)
 {
     // construct potential
     rhopw->nrxx = 100;
-    elecstate::tmp_xc_func_type = 3;
+    XC_Functional::func_type = 3;
+    XC_Functional::has_kedf = true;
     pot = new elecstate::Potential(rhopw, rhopw, ucell, vloc, structure_factors, solvent, etxc, vtxc);
     //
     ModuleBase::matrix veff_smooth_tmp = pot->get_veff_smooth();
@@ -576,28 +575,29 @@ TEST_F(PotentialNewTest, GetVofkSmooth)
 TEST_F(PotentialNewTest, InterpolateVrsDoubleGrids)
 {
      PARAM.sys.double_grid = true;
-    elecstate::tmp_xc_func_type = 3;
-    // Init pw_basis
-    rhopw->initgrids(4, ModuleBase::Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1), 4);
-    rhopw->initparameters(false, 4);
-    rhopw->setuptransform();
-    rhopw->collect_local_pw();
-
-    rhodpw->initgrids(4, ModuleBase::Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1), 6);
-    rhodpw->initparameters(false, 6);
-    static_cast<ModulePW::PW_Basis_Sup*>(rhodpw)->setuptransform(rhopw);
-    rhodpw->collect_local_pw();
-
-    pot = new elecstate::Potential(rhodpw, rhopw, ucell, vloc, structure_factors, solvent, etxc, vtxc);
-
-    for (int ir = 0; ir < pot->v_effective.nr; ir++)
-    {
-        for (int ic = 0; ic < pot->v_effective.nc; ic++)
-        {
-            pot->v_effective(ir,ic) = ir+ic;
-            pot->vofk_effective(ir,ic) = ir+2*ic;
-        }
-    }
+     XC_Functional::func_type = 3;
+     XC_Functional::has_kedf = true;
+     // Init pw_basis
+     rhopw->initgrids(4, ModuleBase::Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1), 4);
+     rhopw->initparameters(false, 4);
+     rhopw->setuptransform();
+     rhopw->collect_local_pw();
+
+     rhodpw->initgrids(4, ModuleBase::Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1), 6);
+     rhodpw->initparameters(false, 6);
+     static_cast<ModulePW::PW_Basis_Sup*>(rhodpw)->setuptransform(rhopw);
+     rhodpw->collect_local_pw();
+
+     pot = new elecstate::Potential(rhodpw, rhopw, ucell, vloc, structure_factors, solvent, etxc, vtxc);
+
+     for (int ir = 0; ir < pot->v_effective.nr; ir++)
+     {
+         for (int ic = 0; ic < pot->v_effective.nc; ic++)
+         {
+             pot->v_effective(ir, ic) = ir + ic;
+             pot->vofk_effective(ir, ic) = ir + 2 * ic;
+         }
+     }
 
     pot->interpolate_vrs();
 
@@ -641,23 +641,24 @@ TEST_F(PotentialNewTest, InterpolateVrsWarningQuit)
 TEST_F(PotentialNewTest, InterpolateVrsSingleGrids)
 {
      PARAM.sys.double_grid = false;
-    elecstate::tmp_xc_func_type = 3;
-    // Init pw_basis
-    rhopw->initgrids(4, ModuleBase::Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1), 4);
-    rhopw->initparameters(false, 4);
-    rhopw->setuptransform();
-    rhopw->collect_local_pw();
-
-    pot = new elecstate::Potential(rhopw, rhopw, ucell, vloc, structure_factors, solvent, etxc, vtxc);
-
-    for (int ir = 0; ir < pot->v_effective.nr; ir++)
-    {
-        for (int ic = 0; ic < pot->v_effective.nc; ic++)
-        {
-            pot->v_effective(ir,ic) = ir+ic;
-            pot->vofk_effective(ir,ic) = ir+2*ic;
-        }
-    }
+     XC_Functional::func_type = 3;
+     XC_Functional::has_kedf = true;
+     // Init pw_basis
+     rhopw->initgrids(4, ModuleBase::Matrix3(1, 0, 0, 0, 1, 0, 0, 0, 1), 4);
+     rhopw->initparameters(false, 4);
+     rhopw->setuptransform();
+     rhopw->collect_local_pw();
+
+     pot = new elecstate::Potential(rhopw, rhopw, ucell, vloc, structure_factors, solvent, etxc, vtxc);
+
+     for (int ir = 0; ir < pot->v_effective.nr; ir++)
+     {
+         for (int ic = 0; ic < pot->v_effective.nc; ic++)
+         {
+             pot->v_effective(ir, ic) = ir + ic;
+             pot->vofk_effective(ir, ic) = ir + 2 * ic;
+         }
+     }
 
     pot->interpolate_vrs();