test(rhog_io): add write_rhog tests and remove GlobalV from test file

- Add 3 new tests: WriteRoundTrip, WriteFileFail, WriteRoundTripNspin2
  (write_rhog was previously 0% covered by tests)
- Add OsNullptrSilent test for nullptr warning stream safety
- Remove GlobalV::ofs_warning usage, use local std::ofstream + fixture helpers
- Extract setup_pw_basis() fixture method to avoid duplication

Author: abacus_fixer

source/source_estate/test/test_rhog_io.cpp

@@ -8,10 +8,13 @@
 #include "source_basis/module_pw/test/test_tool.h"
 #include "mpi.h"
 #endif
+#include <fstream>
+#include <sstream>
 
 /**
  * - Tested Functions:
  *  - read_rhog()
+ *  - write_rhog()
  */
 
 class ReadRhogTest : public ::testing::Test
@@ -21,27 +24,60 @@ class ReadRhogTest : public ::testing::Test
     std::vector<std::vector<std::complex<double>>> rhog_data;
     std::vector<std::complex<double>*> rhog;
     Parallel::ParaWorld pw_world = Parallel::make_pw_world();
+    std::ofstream warning_stream;
+
+    void setup_pw_basis()
+    {
+#ifdef __MPI
+        rhopw.initmpi(pw_world.size(), pw_world.rank(), pw_world.comm());
+#endif
+        rhopw.initgrids(6.5, ModuleBase::Matrix3(-0.5, 0.0, 0.5, 0.0, 0.5, 0.5, -0.5, 0.5, 0.0), 120);
+        rhopw.initparameters(false, 120);
+        rhopw.setuptransform();
+        rhopw.collect_local_pw();
+    }
+
+    void open_warning(const std::string& path)
+    {
+        warning_stream.open(path);
+    }
+
+    void close_warning()
+    {
+        if (warning_stream.is_open())
+        {
+            warning_stream.close();
+        }
+    }
+
+    std::string read_warning_file(const std::string& path)
+    {
+        std::ifstream ifs(path);
+        std::stringstream ss;
+        ss << ifs.rdbuf();
+        ifs.close();
+        return ss.str();
+    }
 
     virtual void SetUp()
     {
         rhog_data.resize(1, std::vector<std::complex<double>>(1471));
         rhog.push_back(rhog_data[0].data());
     }
+
+    virtual void TearDown()
+    {
+        close_warning();
+    }
 };
 
-// Test the read_rhog function
+// Test the read_rhog function with normal file
 TEST_F(ReadRhogTest, ReadRhog)
 {
     std::string filename = "./support/charge-density.dat";
-#ifdef __MPI
-    rhopw.initmpi(pw_world.size(), pw_world.rank(), pw_world.comm());
-#endif
-    rhopw.initgrids(6.5, ModuleBase::Matrix3(-0.5, 0.0, 0.5, 0.0, 0.5, 0.5, -0.5, 0.5, 0.0), 120);
-    rhopw.initparameters(false, 120);
-    rhopw.setuptransform();
-    rhopw.collect_local_pw();
+    setup_pw_basis();
 
-    bool result = ModuleIO::read_rhog(filename, &rhopw, 1, rhog.data(), pw_world, &GlobalV::ofs_warning)
+    bool result = ModuleIO::read_rhog(filename, &rhopw, 1, rhog.data(), pw_world, nullptr);
 
     EXPECT_TRUE(result);
     EXPECT_DOUBLE_EQ(rhog[0][0].real(), -1.0304462993299456e-05);
@@ -57,46 +93,33 @@ TEST_F(ReadRhogTest, NotFoundFile)
 {
     std::string filename = "notfound.txt";
 
-    GlobalV::ofs_warning.open("test_read_rhog.txt");
-    bool result = ModuleIO::read_rhog(filename, &rhopw, 1, rhog.data(), pw_world, &GlobalV::ofs_warning)
-    GlobalV::ofs_warning.close();
-
-    std::ifstream ifs_running("test_read_rhog.txt");
-    std::stringstream ss;
-    ss << ifs_running.rdbuf();
-    std::string file_content = ss.str();
-    ifs_running.close();
+    open_warning("test_read_rhog.txt");
+    bool result = ModuleIO::read_rhog(filename, &rhopw, 1, rhog.data(), pw_world, &warning_stream);
+    close_warning();
 
     std::string expected_content = " ModuleIO::read_rhog  warning : Can't open file notfound.txt\n";
-
     EXPECT_FALSE(result);
-    EXPECT_EQ(file_content, expected_content);
+    EXPECT_EQ(read_warning_file("test_read_rhog.txt"), expected_content);
     std::remove("test_read_rhog.txt");
 }
 
-// Test the read_rhog function when tgamma_only is inconsistent
+// Test the read_rhog function when gamma_only is inconsistent
 TEST_F(ReadRhogTest, InconsistentGammaOnly)
 {
     std::string filename = "./support/charge-density.dat";
     rhopw.gamma_only = true;
 
-    GlobalV::ofs_warning.open("test_read_rhog.txt");
-    bool result = ModuleIO::read_rhog(filename, &rhopw, 2, rhog.data(), pw_world, &GlobalV::ofs_warning);
-    GlobalV::ofs_warning.close();
-
-    std::ifstream ifs_running("test_read_rhog.txt");
-    std::stringstream ss;
-    ss << ifs_running.rdbuf();
-    std::string file_content = ss.str();
-    ifs_running.close();
+    open_warning("test_read_rhog.txt");
+    bool result = ModuleIO::read_rhog(filename, &rhopw, 2, rhog.data(), pw_world, &warning_stream);
+    close_warning();
 
     std::string expected_content
         = " ModuleIO::read_rhog  warning : some planewaves in file are not used\n ModuleIO::read_rhog  warning : some "
           "spin channels in file are missing\n ModuleIO::read_rhog  warning : gamma_only read from file is "
           "inconsistent with INPUT\n";
 
     EXPECT_FALSE(result);
-    EXPECT_EQ(file_content, expected_content);
+    EXPECT_EQ(read_warning_file("test_read_rhog.txt"), expected_content);
     std::remove("test_read_rhog.txt");
 }
 
@@ -106,23 +129,131 @@ TEST_F(ReadRhogTest, SomePWMissing)
     std::string filename = "./support/charge-density.dat";
     rhopw.npwtot = 2000;
 
-    GlobalV::ofs_warning.open("test_read_rhog.txt");
-    bool result = ModuleIO::read_rhog(filename, &rhopw, 1, rhog.data(), pw_world, &GlobalV::ofs_warning)
-    GlobalV::ofs_warning.close();
-
-    std::ifstream ifs_running("test_read_rhog.txt");
-    std::stringstream ss;
-    ss << ifs_running.rdbuf();
-    std::string file_content = ss.str();
-    ifs_running.close();
+    open_warning("test_read_rhog.txt");
+    bool result = ModuleIO::read_rhog(filename, &rhopw, 1, rhog.data(), pw_world, &warning_stream);
+    close_warning();
 
     std::string expected_content = " ModuleIO::read_rhog  warning : some planewaves in file are missing\n";
-
     EXPECT_TRUE(result);
-    EXPECT_EQ(file_content, expected_content);
+    EXPECT_EQ(read_warning_file("test_read_rhog.txt"), expected_content);
     std::remove("test_read_rhog.txt");
 }
 
+// Test read_rhog with os_warning=nullptr (silent mode, must not crash)
+TEST_F(ReadRhogTest, OsNullptrSilent)
+{
+    std::string filename = "notfound.txt";
+    bool result = ModuleIO::read_rhog(filename, &rhopw, 1, rhog.data(), pw_world, nullptr);
+    EXPECT_FALSE(result);
+}
+
+// Test write_rhog round-trip: write then read back, verify data consistency
+TEST_F(ReadRhogTest, WriteRoundTrip)
+{
+    setup_pw_basis();
+
+    // initialize some rhog data
+    rhog_data[0].assign(rhopw.npw, std::complex<double>(1.5, 2.5));
+
+    std::string tmpfile = "test_rhog_roundtrip.dat";
+
+    // write
+    bool write_result = ModuleIO::write_rhog(
+        tmpfile, rhopw.gamma_only, &rhopw, 1,
+        ModuleBase::Matrix3(-0.5, 0.0, 0.5, 0.0, 0.5, 0.5, -0.5, 0.5, 0.0),
+        rhog.data(), pw_world, nullptr);
+    EXPECT_TRUE(write_result);
+
+    // read back into a fresh buffer
+    std::vector<std::vector<std::complex<double>>> rhog_read_data(
+        1, std::vector<std::complex<double>>(rhopw.npw));
+    std::vector<std::complex<double>*> rhog_read;
+    rhog_read.push_back(rhog_read_data[0].data());
+
+    bool read_result = ModuleIO::read_rhog(tmpfile, &rhopw, 1, rhog_read.data(), pw_world, nullptr);
+    EXPECT_TRUE(read_result);
+
+    // compare: within MPI precision tolerance
+    int diff_count = 0;
+    for (int ig = 0; ig < rhopw.npw; ++ig)
+    {
+        if (std::abs(rhog[0][ig] - rhog_read[0][ig]) > 1e-10)
+        {
+            ++diff_count;
+        }
+    }
+    EXPECT_EQ(diff_count, 0) << diff_count << " planewave values differ after round-trip";
+
+    std::remove(tmpfile.c_str());
+}
+
+// Test write_rhog when the output path is not writable
+TEST_F(ReadRhogTest, WriteFileFail)
+{
+    setup_pw_basis();
+    rhog_data[0].assign(rhopw.npw, std::complex<double>(1.0, 0.0));
+
+    // try to write to a directory path (not a file) — should fail
+    bool result = ModuleIO::write_rhog(
+        "/tmp", rhopw.gamma_only, &rhopw, 1,
+        ModuleBase::Matrix3(-0.5, 0.0, 0.5, 0.0, 0.5, 0.5, -0.5, 0.5, 0.0),
+        rhog.data(), pw_world, nullptr);
+    EXPECT_FALSE(result);
+}
+
+// Test write_rhog with nspin=2, round-trip both channels
+TEST_F(ReadRhogTest, WriteRoundTripNspin2)
+{
+    setup_pw_basis();
+
+    // expand to nspin=2
+    rhog_data.resize(2, std::vector<std::complex<double>>(rhopw.npw));
+    rhog.clear();
+    rhog.push_back(rhog_data[0].data());
+    rhog.push_back(rhog_data[1].data());
+
+    // initialize distinct values for each spin channel
+    for (int ig = 0; ig < rhopw.npw; ++ig)
+    {
+        rhog_data[0][ig] = std::complex<double>(1.0 * ig, 0.1 * ig);
+        rhog_data[1][ig] = std::complex<double>(2.0 * ig, 0.2 * ig);
+    }
+
+    std::string tmpfile = "test_rhog_roundtrip_nspin2.dat";
+
+    // write nspin=2
+    bool write_result = ModuleIO::write_rhog(
+        tmpfile, rhopw.gamma_only, &rhopw, 2,
+        ModuleBase::Matrix3(-0.5, 0.0, 0.5, 0.0, 0.5, 0.5, -0.5, 0.5, 0.0),
+        rhog.data(), pw_world, nullptr);
+    EXPECT_TRUE(write_result);
+
+    // read back
+    std::vector<std::vector<std::complex<double>>> rhog_read_data(
+        2, std::vector<std::complex<double>>(rhopw.npw));
+    std::vector<std::complex<double>*> rhog_read;
+    rhog_read.push_back(rhog_read_data[0].data());
+    rhog_read.push_back(rhog_read_data[1].data());
+
+    bool read_result = ModuleIO::read_rhog(tmpfile, &rhopw, 2, rhog_read.data(), pw_world, nullptr);
+    EXPECT_TRUE(read_result);
+
+    int diff_count = 0;
+    for (int is = 0; is < 2; ++is)
+    {
+        for (int ig = 0; ig < rhopw.npw; ++ig)
+        {
+            if (std::abs(rhog[is][ig] - rhog_read[is][ig]) > 1e-10)
+            {
+                ++diff_count;
+            }
+        }
+    }
+    EXPECT_EQ(diff_count, 0) << diff_count << " planewave values differ after nspin=2 round-trip";
+
+    std::remove(tmpfile.c_str());
+}
+
 int main(int argc, char** argv)
 {
 #ifdef __MPI