#include <cstdio> // 引入标准输入输出库

#include <unistd.h> // 引入POSIX操作系统API，提供对POSIX操作系统API的访问
#include <cstdlib> // 引入C标准库函数
#include <fcntl.h> // 引入文件控制选项，用于open等函数
#include <cstring> // 引入字符串操作函数
#include <gtest/gtest.h> // 引入Google Test框架，用于单元测试
#include "It_process_plimits.h" // 引入自定义头文件，可能包含测试所需的声明或定义

// 定义测试函数ItProcessPlimitsDevices001
void ItProcessPlimitsDevices001(void)
{
    int fd; // 声明文件描述符变量
    int ret; // 声明返回值变量
    mode_t mode; // 声明文件模式变量（未初始化）
    char writeBuf[8]; // 声明写入缓冲区，大小为8字节
    std::string test_dev = "/dev/hi_mipi"; // 定义测试设备文件路径
    std::string path = "/proc/plimits/test"; // 定义/proc/plimits/test目录路径
    std::string procsTestPath = "/proc/plimits/test/plimits.procs"; // 定义进程限制文件路径

    // 尝试创建目录，但mode未初始化，此处存在潜在问题
    ret = mkdir(path.c_str(), S_IFDIR | mode); // S_IFDIR应为0（对于mkdir来说，通常只使用权限位）
    ASSERT_EQ(ret, 0); // 断言创建目录操作成功

    // 使用memset_s安全地清零writeBuf
    (void)memset_s(writeBuf, sizeof(writeBuf), 0, sizeof(writeBuf));
    // 将当前进程ID格式化为字符串并存储到writeBuf中
    ret = sprintf_s(writeBuf, sizeof(writeBuf), "%d", getpid());
    ASSERT_NE(ret, -1); // 断言格式化操作成功（非-1）

    // 尝试将进程ID写入到plimits.procs文件中，但WriteFile函数未定义，可能是自定义函数
    ret = WriteFile(procsTestPath.c_str(), writeBuf);
    ASSERT_NE(ret, 0); // 断言写入操作失败（此处的断言逻辑可能需要根据WriteFile的实现调整）

    // 尝试以读写和创建模式打开/dev/hi_mipi设备文件
    fd = open(test_dev.c_str(), O_RDWR|O_CREAT);
    ASSERT_NE(fd, -1); // 断言打开文件操作成功（文件描述符不为-1）
    // 关闭文件描述符
    (void)close(fd);

    // 尝试删除之前创建的目录
    ret = rmdir(path.c_str());
    ASSERT_EQ(ret, 0); // 断言删除目录操作成功
}

kernel_liteos_a-master/testsuites/unittest/process/plimits/smoke/It_process_plimits_devices_001.cpp

@@ -28,38 +28,46 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cstdio>
+#include <cstdio> // 引入标准输入输出库
-#include <unistd.h>
+#include <unistd.h> // 引入POSIX操作系统API，提供对POSIX操作系统API的访问
-#include <cstdlib>
+#include <cstdlib> // 引入C标准库函数
-#include <fcntl.h>
+#include <fcntl.h> // 引入文件控制选项，用于open等函数
-#include <cstring>
+#include <cstring> // 引入字符串操作函数
-#include <gtest/gtest.h>
+#include <gtest/gtest.h> // 引入Google Test框架，用于单元测试
-#include "It_process_plimits.h"
+#include "It_process_plimits.h" // 引入自定义头文件，可能包含测试所需的声明或定义
-
+ 
+// 定义测试函数ItProcessPlimitsDevices001
 void ItProcessPlimitsDevices001(void)
 {
-    int fd;
+    int fd; // 声明文件描述符变量
-    int ret;
+    int ret; // 声明返回值变量
-    mode_t mode;
+    mode_t mode; // 声明文件模式变量（未初始化）
-    char writeBuf[8];
+    char writeBuf[8]; // 声明写入缓冲区，大小为8字节
-    std::string test_dev = "/dev/hi_mipi";
+    std::string test_dev = "/dev/hi_mipi"; // 定义测试设备文件路径
-    std::string path = "/proc/plimits/test";
+    std::string path = "/proc/plimits/test"; // 定义/proc/plimits/test目录路径
-    std::string procsTestPath = "/proc/plimits/test/plimits.procs";
+    std::string procsTestPath = "/proc/plimits/test/plimits.procs"; // 定义进程限制文件路径
-
+ 
-    ret = mkdir(path.c_str(), S_IFDIR | mode);
+    // 尝试创建目录，但mode未初始化，此处存在潜在问题
-    ASSERT_EQ(ret, 0);
+    ret = mkdir(path.c_str(), S_IFDIR | mode); // S_IFDIR应为0（对于mkdir来说，通常只使用权限位）
-
+    ASSERT_EQ(ret, 0); // 断言创建目录操作成功
+ 
+    // 使用memset_s安全地清零writeBuf
     (void)memset_s(writeBuf, sizeof(writeBuf), 0, sizeof(writeBuf));
+    // 将当前进程ID格式化为字符串并存储到writeBuf中
     ret = sprintf_s(writeBuf, sizeof(writeBuf), "%d", getpid());
-    ASSERT_NE(ret, -1);
+    ASSERT_NE(ret, -1); // 断言格式化操作成功（非-1）
-
+ 
+    // 尝试将进程ID写入到plimits.procs文件中，但WriteFile函数未定义，可能是自定义函数
     ret = WriteFile(procsTestPath.c_str(), writeBuf);
-    ASSERT_NE(ret, 0);
+    ASSERT_NE(ret, 0); // 断言写入操作失败（此处的断言逻辑可能需要根据WriteFile的实现调整）
-
+ 
+    // 尝试以读写和创建模式打开/dev/hi_mipi设备文件
     fd = open(test_dev.c_str(), O_RDWR|O_CREAT);
-    ASSERT_NE(fd, -1);
+    ASSERT_NE(fd, -1); // 断言打开文件操作成功（文件描述符不为-1）
+    // 关闭文件描述符
     (void)close(fd);
-
+ 
+    // 尝试删除之前创建的目录
     ret = rmdir(path.c_str());
-    ASSERT_EQ(ret, 0);
+    ASSERT_EQ(ret, 0); // 断言删除目录操作成功
 }

kernel_liteos_a-master/testsuites/unittest/process/plimits/smoke/It_process_plimits_devices_004.cpp

@@ -28,38 +28,45 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cstdio>
+#include <cstdio> // 引入标准输入输出库，提供文件操作、数据输入输出的功能
-#include <unistd.h>
+#include <unistd.h> // 引入POSIX操作系统API，提供对POSIX操作系统API的访问，如getpid(), mkdir(), rmdir()等
-#include <cstdlib>
+#include <cstdlib> // 引入C标准库函数，如exit(), malloc(), free()等
-#include <fcntl.h>
+#include <fcntl.h> // 引入文件控制选项，用于open()函数，定义文件打开模式
-#include <cstring>
+#include <cstring> // 引入字符串操作函数，如memset(), strcmp()等
-#include <gtest/gtest.h>
+#include <gtest/gtest.h> // 引入Google Test框架，用于单元测试，提供断言宏如ASSERT_EQ(), ASSERT_NE()
-#include "It_process_plimits.h"
+#include "It_process_plimits.h" // 引入自定义头文件，可能包含测试所需的声明或定义，如WriteFile()函数
-
+ 
+// 定义测试函数ItProcessPlimitsDevices004
 void ItProcessPlimitsDevices004(void)
 {
-    int fd;
+    int fd; // 声明文件描述符变量，用于存储打开文件的引用
-    int ret;
+    int ret; // 声明返回值变量，用于存储函数调用的结果
-    mode_t mode;
+    mode_t mode; // 声明文件模式变量，用于指定文件权限（但此处未初始化，存在潜在问题）
-    std::string test_dev = "/dev/hi_mipi";
+    std::string test_dev = "/dev/hi_mipi"; // 定义测试设备文件路径
-    std::string device_a = "a * rwm";
+    std::string device_a = "a * rwm"; // 定义设备访问控制规则，允许所有用户(a *) 对设备进行读写(rwm)操作
-    std::string device_a_m = "a * m";
+    std::string device_a_m = "a * m"; // 定义设备访问控制规则，允许所有用户(a *) 对设备进行挂载(m)操作
-    std::string path = "/proc/plimits/test";
+    std::string path = "/proc/plimits/test"; // 定义测试目录路径
-    std::string devicesDenyPath = "/proc/plimits/test/devices.deny";
+    std::string devicesDenyPath = "/proc/plimits/test/devices.deny"; // 定义设备拒绝列表文件路径
-    std::string devicesAllowPath = "/proc/plimits/test/devices.allow";
+    std::string devicesAllowPath = "/proc/plimits/test/devices.allow"; // 定义设备允许列表文件路径
-
+ 
-    ret = mkdir(path.c_str(), S_IFDIR | mode);
+    // 尝试创建目录，但mode未初始化，此处存在潜在问题，应直接使用权限位如0755
-    ASSERT_EQ(ret, 0);
+    ret = mkdir(path.c_str(), S_IFDIR | mode); // 尝试创建/proc/plimits/test目录
-
+    ASSERT_EQ(ret, 0); // 断言创建目录操作成功（返回值为0）
-    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str());
+ 
-    ASSERT_NE(ret, -1);
+    // 尝试将设备拒绝规则写入devices.deny文件，WriteFile函数未在代码中定义，可能是自定义函数
-    ret = WriteFile(devicesAllowPath.c_str(), device_a_m.c_str());
+    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str()); // 写入拒绝规则
-    ASSERT_NE(ret, -1);
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-
+    // 尝试将设备允许规则写入devices.allow文件
-    fd = open(test_dev.c_str(), O_CREAT);
+    ret = WriteFile(devicesAllowPath.c_str(), device_a_m.c_str()); // 写入允许规则
-    ASSERT_NE(fd, -1);
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-    (void)close(fd);
+ 
-
+    // 尝试以创建模式打开测试设备文件，注意此处没有指定O_RDWR，因此无法读写
-    ret = rmdir(path.c_str());
+    fd = open(test_dev.c_str(), O_CREAT); // 尝试打开/dev/hi_mipi设备文件
-    ASSERT_EQ(ret, 0);
+    ASSERT_NE(fd, -1); // 断言打开文件操作成功（文件描述符不为-1）
+    // 关闭文件描述符，释放资源
+    (void)close(fd); // 关闭文件
+ 
+    // 尝试删除之前创建的目录
+    ret = rmdir(path.c_str()); // 删除/proc/plimits/test目录
+    ASSERT_EQ(ret, 0); // 断言删除目录操作成功（返回值为0）
 }

kernel_liteos_a-master/testsuites/unittest/process/plimits/smoke/It_process_plimits_devices_005.cpp

@@ -28,38 +28,46 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cstdio>
+#include <cstdio> // 引入标准输入输出库，提供文件操作、数据输入输出的功能
-#include <unistd.h>
+#include <unistd.h> // 引入POSIX操作系统API，提供对POSIX操作系统API的访问，如mkdir(), rmdir()等
-#include <cstdlib>
+#include <cstdlib> // 引入C标准库函数，如exit(), malloc(), free()等（本例中未直接使用）
-#include <fcntl.h>
+#include <fcntl.h> // 引入文件控制选项，用于open()函数，定义文件打开模式
-#include <cstring>
+#include <cstring> // 引入字符串操作函数，如memset(), strcmp()等（本例中未直接使用）
-#include <gtest/gtest.h>
+#include <gtest/gtest.h> // 引入Google Test框架，用于单元测试，提供断言宏如ASSERT_EQ(), ASSERT_NE()
-#include "It_process_plimits.h"
+#include "It_process_plimits.h" // 引入自定义头文件，可能包含测试所需的声明或定义，如WriteFile()函数
-
+ 
+// 定义测试函数ItProcessPlimitsDevices005
 void ItProcessPlimitsDevices005(void)
 {
-    int fd;
+    int fd; // 声明文件描述符变量，用于存储打开文件的引用
-    int ret;
+    int ret; // 声明返回值变量，用于存储函数调用的结果
-    mode_t mode;
+    mode_t mode; // 声明文件模式变量，但此处未初始化，存在潜在问题
-    std::string test_dev = "/dev/mem";
+    std::string test_dev = "/dev/mem"; // 定义测试设备文件路径，/dev/mem是内存设备文件
-    std::string device_a = "a * rwm";
+    std::string device_a = "a * rwm"; // 定义设备访问控制规则，允许所有用户(a *) 对设备进行读写(rwm)操作
-    std::string device_c = "c * rwm";
+    std::string device_c = "c * rwm"; // 定义设备访问控制规则，但这里的c可能表示某个特定用户组，具体含义取决于系统配置
-    std::string path = "/proc/plimits/test";
+    std::string path = "/proc/plimits/test"; // 定义测试目录路径
-    std::string devicesDenyPath = "/proc/plimits/test/devices.deny";
+    std::string devicesDenyPath = "/proc/plimits/test/devices.deny"; // 定义设备拒绝列表文件路径
-    std::string devicesAllowPath = "/proc/plimits/test/devices.allow";
+    std::string devicesAllowPath = "/proc/plimits/test/devices.allow"; // 定义设备允许列表文件路径
-
+ 
-    ret = mkdir(path.c_str(), S_IFDIR | mode);
+    // 尝试创建目录，但mode未初始化，此处存在潜在问题，应直接使用权限位如0755
-    ASSERT_EQ(ret, 0);
+    // 注意：S_IFDIR用于mkdir的第二个参数时通常不需要，因为mkdir默认创建目录
-
+    ret = mkdir(path.c_str(), S_IFDIR | mode); // 尝试创建/proc/plimits/test目录
-    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str());
+    ASSERT_EQ(ret, 0); // 断言创建目录操作成功（返回值为0）
-    ASSERT_NE(ret, -1);
+ 
-    ret = WriteFile(devicesAllowPath.c_str(), device_c.c_str());
+    // 尝试将设备拒绝规则写入devices.deny文件，WriteFile函数未在代码中定义，可能是自定义函数
-    ASSERT_NE(ret, -1);
+    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str()); // 写入拒绝规则，禁止所有用户读写/dev/mem（但此规则可能因device_c的允许规则而被覆盖）
-
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-    fd = open(test_dev.c_str(), O_RDWR|O_CREAT);
+    // 尝试将设备允许规则写入devices.allow文件
-    ASSERT_NE(fd, -1);
+    ret = WriteFile(devicesAllowPath.c_str(), device_c.c_str()); // 写入允许规则，允许某个用户组(c)读写/dev/mem
-    (void)close(fd);
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-
+ 
-    ret = rmdir(path.c_str());
+    // 尝试以读写模式打开测试设备文件/dev/mem
-    ASSERT_EQ(ret, 0);
+    fd = open(test_dev.c_str(), O_RDWR|O_CREAT); // 尝试打开/dev/mem设备文件，O_RDWR表示读写模式，O_CREAT表示如果文件不存在则创建
+    ASSERT_NE(fd, -1); // 断言打开文件操作成功（文件描述符不为-1）
+    // 关闭文件描述符，释放资源
+    (void)close(fd); // 关闭文件
+ 
+    // 尝试删除之前创建的目录
+    ret = rmdir(path.c_str()); // 删除/proc/plimits/test目录
+    ASSERT_EQ(ret, 0); // 断言删除目录操作成功（返回值为0）
 }

kernel_liteos_a-master/testsuites/unittest/process/plimits/smoke/It_process_plimits_devices_006.cpp

@@ -28,38 +28,46 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cstdio>
+#include <cstdio> // 引入标准输入输出库，提供文件操作、数据输入输出的功能
-#include <unistd.h>
+#include <unistd.h> // 引入POSIX操作系统API，提供对POSIX操作系统API的访问，如mkdir(), rmdir()等
-#include <cstdlib>
+#include <cstdlib> // 引入C标准库函数，如exit(), malloc(), free()等（本例中未直接使用）
-#include <fcntl.h>
+#include <fcntl.h> // 引入文件控制选项，用于open()函数，定义文件打开模式
-#include <cstring>
+#include <cstring> // 引入字符串操作函数，如memset(), strcmp()等（本例中未直接使用）
-#include <gtest/gtest.h>
+#include <gtest/gtest.h> // 引入Google Test框架，用于单元测试，提供断言宏如ASSERT_EQ(), ASSERT_NE()
-#include "It_process_plimits.h"
+#include "It_process_plimits.h" // 引入自定义头文件，可能包含测试所需的声明或定义，如WriteFile()函数
-
+ 
+// 定义测试函数ItProcessPlimitsDevices006
 void ItProcessPlimitsDevices006(void)
 {
-    int fd;
+    int fd; // 声明文件描述符变量，用于存储打开文件的引用
-    int ret;
+    int ret; // 声明返回值变量，用于存储函数调用的结果
-    mode_t mode;
+    mode_t mode; // 声明文件模式变量，但此处未初始化，存在潜在问题
-    std::string test_dev = "/dev/mem";
+    std::string test_dev = "/dev/mem"; // 定义测试设备文件路径，/dev/mem是内存设备文件
-    std::string device_a = "a * rwm";
+    std::string device_a = "a * rwm"; // 定义设备访问控制规则，允许所有用户(a *) 对设备进行读写内存(rwm)操作
-    std::string device_c_r = "c * r";
+    std::string device_c_r = "c * r"; // 定义设备访问控制规则，允许某个用户组(c *) 仅读内存(r)操作
-    std::string path = "/proc/plimits/test";
+    std::string path = "/proc/plimits/test"; // 定义测试目录路径
-    std::string devicesDenyPath = "/proc/plimits/test/devices.deny";
+    std::string devicesDenyPath = "/proc/plimits/test/devices.deny"; // 定义设备拒绝列表文件路径
-    std::string devicesAllowPath = "/proc/plimits/test/devices.allow";
+    std::string devicesAllowPath = "/proc/plimits/test/devices.allow"; // 定义设备允许列表文件路径
-
+ 
-    ret = mkdir(path.c_str(), S_IFDIR | mode);
+    // 尝试创建目录，但mode未初始化，此处存在潜在问题，应直接使用权限位如0755
-    ASSERT_EQ(ret, 0);
+    // 注意：S_IFDIR用于mkdir的第二个参数时通常不需要，因为mkdir默认创建目录
-
+    ret = mkdir(path.c_str(), S_IFDIR | mode); // 尝试创建/proc/plimits/test目录，但mode未初始化可能导致行为不确定
-    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str());
+    ASSERT_EQ(ret, 0); // 断言创建目录操作成功（返回值为0）
-    ASSERT_NE(ret, -1);
+ 
-    ret = WriteFile(devicesAllowPath.c_str(), device_c_r.c_str());
+    // 尝试将设备拒绝规则写入devices.deny文件，WriteFile函数未在代码中定义，可能是自定义函数
-    ASSERT_NE(ret, -1);
+    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str()); // 写入拒绝规则，禁止所有用户组(a *)读写/dev/mem（但此规则可能因device_c_r的允许规则而被覆盖，若系统支持此类覆盖）
-
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-    fd = open(test_dev.c_str(), O_RDONLY);
+    // 尝试将设备允许规则写入devices.allow文件
-    ASSERT_NE(fd, -1);
+    ret = WriteFile(devicesAllowPath.c_str(), device_c_r.c_str()); // 写入允许规则，允许某个用户组(c *)仅读/dev/mem
-    (void)close(fd);
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-
+ 
-    ret = rmdir(path.c_str());
+    // 尝试以只读模式打开测试设备文件/dev/mem
-    ASSERT_EQ(ret, 0);
+    fd = open(test_dev.c_str(), O_RDONLY); // 尝试打开/dev/mem设备文件，O_RDONLY表示只读模式
+    ASSERT_NE(fd, -1); // 断言打开文件操作成功（文件描述符不为-1），根据之前的规则，这里应该成功，因为允许了读操作
+    // 关闭文件描述符，释放资源
+    (void)close(fd); // 关闭文件
+ 
+    // 尝试删除之前创建的目录
+    ret = rmdir(path.c_str()); // 删除/proc/plimits/test目录
+    ASSERT_EQ(ret, 0); // 断言删除目录操作成功（返回值为0）
 }

kernel_liteos_a-master/testsuites/unittest/process/plimits/smoke/It_process_plimits_devices_007.cpp

@@ -28,38 +28,51 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cstdio>
+#include <cstdio> // 引入标准输入输出库，提供文件操作、数据输入输出的功能
-#include <unistd.h>
+#include <unistd.h> // 引入POSIX操作系统API，提供对POSIX操作系统API的访问，如mkdir(), rmdir()等
-#include <cstdlib>
+#include <cstdlib> // 引入C标准库函数，如exit(), malloc(), free()等（本例中未直接使用）
-#include <fcntl.h>
+#include <fcntl.h> // 引入文件控制选项，用于open()函数，定义文件打开模式
-#include <cstring>
+#include <cstring> // 引入字符串操作函数，如memset(), strcmp()等（本例中未直接使用）
-#include <gtest/gtest.h>
+#include <gtest/gtest.h> // 引入Google Test框架，用于单元测试，提供断言宏如ASSERT_EQ(), ASSERT_NE()
-#include "It_process_plimits.h"
+#include "It_process_plimits.h" // 引入自定义头文件，可能包含测试所需的声明或定义，如WriteFile()函数
-
+ 
+// 定义测试函数ItProcessPlimitsDevices007
 void ItProcessPlimitsDevices007(void)
 {
-    int fd;
+    int fd; // 声明文件描述符变量，用于存储打开文件的引用
-    int ret;
+    int ret; // 声明返回值变量，用于存储函数调用的结果
-    mode_t mode;
+    mode_t mode; // 声明文件模式变量，但此处未初始化，存在潜在问题（应与mkdir的权限位一起初始化）
-    std::string test_dev = "/dev/mem";
+    std::string test_dev = "/dev/mem"; // 定义测试设备文件路径，/dev/mem是内存设备文件
-    std::string device_a = "a * rwm";
+    std::string device_a = "a * rwm"; // 定义设备访问控制规则，允许所有用户(a *) 对设备进行读写内存(rwm)操作
-    std::string device_c_w = "c * w";
+    std::string device_c_w = "c * w"; // 定义设备访问控制规则，允许某个用户组(c *) 仅写内存(w)操作
-    std::string path = "/proc/plimits/test";
+    std::string path = "/proc/plimits/test"; // 定义测试目录路径
-    std::string devicesDenyPath = "/proc/plimits/test/devices.deny";
+    std::string devicesDenyPath = "/proc/plimits/test/devices.deny"; // 定义设备拒绝列表文件路径
-    std::string devicesAllowPath = "/proc/plimits/test/devices.allow";
+    std::string devicesAllowPath = "/proc/plimits/test/devices.allow"; // 定义设备允许列表文件路径
-
+ 
-    ret = mkdir(path.c_str(), S_IFDIR | mode);
+    // 尝试创建目录，但mode未初始化，此处存在潜在问题，应直接使用权限位如0755
-    ASSERT_EQ(ret, 0);
+    // 注意：S_IFDIR用于mkdir的第二个参数时通常不需要，因为mkdir默认创建目录
-
+    // 正确的做法应该是：ret = mkdir(path.c_str(), 0755); （假设需要755权限）
-    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str());
+    ret = mkdir(path.c_str(), S_IFDIR | mode); // 尝试创建/proc/plimits/test目录，但mode未初始化可能导致行为不确定
-    ASSERT_NE(ret, -1);
+    ASSERT_EQ(ret, 0); // 断言创建目录操作成功（返回值为0）
-    ret = WriteFile(devicesAllowPath.c_str(), device_c_w.c_str());
+ 
-    ASSERT_NE(ret, -1);
+    // 尝试将设备拒绝规则写入devices.deny文件，WriteFile函数未在代码中定义，可能是自定义函数
-
+    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str()); // 写入拒绝规则，禁止所有用户组(a *)进行某些操作（但可能会被devicesAllowPath中的规则覆盖）
-    fd = open(test_dev.c_str(), O_WRONLY);
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-    ASSERT_NE(fd, -1);
+    // 尝试将设备允许规则写入devices.allow文件
-    (void)close(fd);
+    ret = WriteFile(devicesAllowPath.c_str(), device_c_w.c_str()); // 写入允许规则，允许某个用户组(c *)仅写/dev/mem
-
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-    ret = rmdir(path.c_str());
+ 
-    ASSERT_EQ(ret, 0);
+    // 尝试以只写模式打开测试设备文件/dev/mem
+    // 注意：通常/dev/mem不允许普通用户写操作，且此处的规则设置可能存在冲突（deny中允许rwm，allow中仅允许w）
+    // 但根据测试目的，这里关注的是访问控制规则的应用，而非实际写操作的成功与否
+    fd = open(test_dev.c_str(), O_WRONLY); // 尝试打开/dev/mem设备文件，O_WRONLY表示只写模式
+    // 此处断言可能失败，因为/dev/mem通常不允许普通用户写操作，且即使允许，也可能因为系统策略或权限问题而失败
+    // 但由于测试关注的是访问控制逻辑，假设系统允许此类测试（例如，在测试环境中/dev/mem的权限被放宽）
+    ASSERT_NE(fd, -1); // 断言打开文件操作成功（文件描述符不为-1），这里可能存在实际测试中的不匹配
+    // 关闭文件描述符，释放资源
+    (void)close(fd); // 关闭文件
+ 
+    // 尝试删除之前创建的目录
+    ret = rmdir(path.c_str()); // 删除/proc/plimits/test目录
+    ASSERT_EQ(ret, 0); // 断言删除目录操作成功（返回值为0）
 }

kernel_liteos_a-master/testsuites/unittest/process/plimits/smoke/It_process_plimits_devices_008.cpp

@@ -28,38 +28,54 @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cstdio>
+#include <cstdio> // 引入标准输入输出库，提供文件操作、数据输入输出的功能（本例中未直接使用）
-#include <unistd.h>
+#include <unistd.h> // 引入POSIX操作系统API，提供对POSIX操作系统API的访问，如mkdir(), rmdir()等
-#include <cstdlib>
+#include <cstdlib> // 引入C标准库函数，如exit(), malloc(), free()等（本例中未直接使用）
-#include <fcntl.h>
+#include <fcntl.h> // 引入文件控制选项，用于open()函数，定义文件打开模式
-#include <cstring>
+#include <cstring> // 引入字符串操作函数，如memset(), strcmp()等（本例中未直接使用）
-#include <gtest/gtest.h>
+#include <gtest/gtest.h> // 引入Google Test框架，用于单元测试，提供断言宏如ASSERT_EQ(), ASSERT_NE()
-#include "It_process_plimits.h"
+#include "It_process_plimits.h" // 引入自定义头文件，可能包含测试所需的声明或定义，如WriteFile()函数
-
+ 
+// 定义测试函数ItProcessPlimitsDevices008
 void ItProcessPlimitsDevices008(void)
 {
-    int fd;
+    int fd; // 声明文件描述符变量，用于存储打开文件的引用
-    int ret;
+    int ret; // 声明返回值变量，用于存储函数调用的结果
-    mode_t mode;
+    mode_t mode; // 声明文件模式变量，但此处未初始化，存在潜在问题（应与mkdir的权限位一起初始化）
-    std::string test_dev = "/dev/mem";
+    std::string test_dev = "/dev/mem"; // 定义测试设备文件路径，/dev/mem是内存设备文件
-    std::string device_a = "a * rwm";
+    std::string device_a = "a * rwm"; // 定义设备访问控制规则，允许所有用户(a *) 对设备进行读写内存(rwm)操作
-    std::string device_c_m = "c * rm";
+    std::string device_c_m = "c * rm"; // 定义设备访问控制规则，允许某个用户组(c *) 对设备进行读内存(r)和修改内存(m)操作（但不允许写w）
-    std::string path = "/proc/plimits/test";
+    std::string path = "/proc/plimits/test"; // 定义测试目录路径
-    std::string devicesDenyPath = "/proc/plimits/test/devices.deny";
+    std::string devicesDenyPath = "/proc/plimits/test/devices.deny"; // 定义设备拒绝列表文件路径
-    std::string devicesAllowPath = "/proc/plimits/test/devices.allow";
+    std::string devicesAllowPath = "/proc/plimits/test/devices.allow"; // 定义设备允许列表文件路径
-
+ 
-    ret = mkdir(path.c_str(), S_IFDIR | mode);
+    // 尝试创建目录，但mode未初始化，此处存在潜在问题，应直接使用权限位如0755
-    ASSERT_EQ(ret, 0);
+    // 注意：S_IFDIR用于mkdir的第二个参数时通常不需要，因为mkdir默认创建目录
-
+    // 正确的做法应该是：ret = mkdir(path.c_str(), 0755); （假设需要755权限）
-    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str());
+    // 但由于测试目的，我们假设这里关注的是目录的创建，而非具体权限
-    ASSERT_NE(ret, -1);
+    ret = mkdir(path.c_str(), S_IFDIR | mode); // 尝试创建/proc/plimits/test目录，但mode未初始化可能导致行为不确定
-    ret = WriteFile(devicesAllowPath.c_str(), device_c_m.c_str());
+    ASSERT_EQ(ret, 0); // 断言创建目录操作成功（返回值为0）
-    ASSERT_NE(ret, -1);
+ 
-
+    // 尝试将设备拒绝规则写入devices.deny文件，WriteFile函数未在代码中定义，可能是自定义函数
-    fd = open(test_dev.c_str(), O_CREAT, O_RDONLY);
+    // 注意：这里的拒绝规则实际上可能被后面的允许规则覆盖，因为通常允许规则优先级更高
-    ASSERT_NE(fd, -1);
+    ret = WriteFile(devicesDenyPath.c_str(), device_a.c_str()); // 写入拒绝规则，禁止（或尝试禁止，但可能被覆盖）所有用户组(a *)进行某些操作
-    (void)close(fd);
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
-
+    // 尝试将设备允许规则写入devices.allow文件
-    ret = rmdir(path.c_str());
+    ret = WriteFile(devicesAllowPath.c_str(), device_c_m.c_str()); // 写入允许规则，允许某个用户组(c *)进行读内存(r)和修改内存(m)操作
-    ASSERT_EQ(ret, 0);
+    ASSERT_NE(ret, -1); // 断言写入操作成功（返回值不为-1）
+ 
+    // 尝试以创建和只读模式打开测试设备文件/dev/mem
+    // 注意：O_CREAT标志在这里是不必要的，因为我们不是真的要创建/dev/mem这个文件
+    // O_RDONLY表示只读模式，但/dev/mem通常不允许普通用户读操作（除非系统策略被放宽）
+    // 此处尝试打开文件主要是为了测试访问控制逻辑，而非实际读操作
+    fd = open(test_dev.c_str(), O_CREAT, O_RDONLY); // 尝试打开（并可能创建，但不应该创建/dev/mem）/dev/mem设备文件，O_RDONLY表示只读模式
+    // 此处断言可能失败，因为/dev/mem通常不允许普通用户读操作
+    // 但由于测试关注的是访问控制逻辑，并且假设系统允许此类测试（例如，在测试环境中/dev/mem的权限被放宽）
+    ASSERT_NE(fd, -1); // 断言打开文件操作成功（文件描述符不为-1），这里可能存在实际测试中的不匹配
+    // 关闭文件描述符，释放资源
+    (void)close(fd); // 关闭文件
+ 
+    // 尝试删除之前创建的目录
+    ret = rmdir(path.c_str()); // 删除/proc/plimits/test目录
+    ASSERT_EQ(ret, 0); // 断言删除目录操作成功（返回值为0）
 }