1 /* 2 * Copyright (c) 2025 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <gtest/gtest.h> 17 #include "close_core.h" 18 #include "open_core.h" 19 20 #define FILE_PATH "/data/test/CloseCoreTest.txt" 21 22 namespace OHOS { 23 namespace FileManagement { 24 namespace ModuleFileIO { 25 using namespace std; 26 class CloseCoreTest : public testing::Test { 27 public: SetUpTestCase(void)28 static void SetUpTestCase(void) 29 { 30 int32_t fd = open(FILE_PATH, CREATE | O_RDWR, 0644); 31 close(fd); 32 }; TearDownTestCase()33 static void TearDownTestCase() 34 { 35 rmdir(FILE_PATH); 36 }; SetUp()37 void SetUp() {}; TearDown()38 void TearDown() {}; 39 }; 40 41 /** 42 * @tc.name: DoCloseTestFd_0001 43 * @tc.desc: Test function of DoClose() interface for invalid arguments. 44 * @tc.size: MEDIUM 45 * @tc.type: FUNC 46 * @tc.level Level 1 47 */ 48 HWTEST_F(CloseCoreTest, DoCloseTestFd_0001, testing::ext::TestSize.Level1) 49 { 50 GTEST_LOG_(INFO) << "CloseCoreTest-begin DoCloseTestFd_0001"; 51 auto ret = CloseCore::DoClose(-1); 52 EXPECT_FALSE(ret.IsSuccess()); 53 54 auto err = ret.GetError(); 55 EXPECT_EQ(err.GetErrNo(), 13900020); 56 57 58 GTEST_LOG_(INFO) << "CloseCoreTest-end DoCloseTestFd_0001"; 59 } 60 61 /** 62 * @tc.name: DoCloseTestFd_0002 63 * @tc.desc: Test function of DoClose() interface for sucess. 64 * @tc.size: MEDIUM 65 * @tc.type: FUNC 66 * @tc.level Level 1 67 */ 68 HWTEST_F(CloseCoreTest, DoCloseTestFd_0002, testing::ext::TestSize.Level1) 69 { 70 GTEST_LOG_(INFO) << "CloseCoreTest-begin DoCloseTestFd_0002"; 71 int32_t fd = open(FILE_PATH, O_RDWR); 72 if (fd <= 0) { 73 close(fd); 74 ASSERT_TRUE(false); 75 } 76 77 auto ret = CloseCore::DoClose(fd); 78 EXPECT_TRUE(ret.IsSuccess()); 79 80 int32_t fdEnd = open(FILE_PATH, O_RDWR); 81 if (fdEnd <= 0) { 82 close(fdEnd); 83 ASSERT_TRUE(false); 84 } 85 EXPECT_EQ(fdEnd, fd); 86 87 ret = CloseCore::DoClose(fd); 88 EXPECT_TRUE(ret.IsSuccess()); 89 90 GTEST_LOG_(INFO) << "CloseCoreTest-end DoCloseTestFd_0002"; 91 } 92 93 /** 94 * @tc.name: DoCloseTestFd_0003 95 * @tc.desc: Test function of DoClose() interface for failed. 96 * @tc.size: MEDIUM 97 * @tc.type: FUNC 98 * @tc.level Level 1 99 */ 100 HWTEST_F(CloseCoreTest, DoCloseTestFd_0003, testing::ext::TestSize.Level1) 101 { 102 GTEST_LOG_(INFO) << "CloseCoreTest-begin DoCloseTestFd_0003"; 103 int32_t fd = open(FILE_PATH, O_RDWR); 104 if (fd <= 0) { 105 close(fd); 106 ASSERT_TRUE(false); 107 } 108 auto ret = CloseCore::DoClose(fd); 109 EXPECT_TRUE(ret.IsSuccess()); 110 111 ret = CloseCore::DoClose(fd); 112 EXPECT_FALSE(ret.IsSuccess()); 113 auto err = ret.GetError(); 114 EXPECT_EQ(err.GetErrNo(), 13900008); 115 116 GTEST_LOG_(INFO) << "CloseCoreTest-end DoCloseTestFd_0003"; 117 } 118 119 /** 120 * @tc.name: DoCloseTestFile_0001 121 * @tc.desc: Test function of DoClose() interface for success. 122 * @tc.size: MEDIUM 123 * @tc.type: FUNC 124 * @tc.level Level 1 125 */ 126 HWTEST_F(CloseCoreTest, DoCloseTestFile_0001, testing::ext::TestSize.Level1) 127 { 128 GTEST_LOG_(INFO) << "CloseCoreTest-begin DoCloseTestFile_0001"; 129 auto fileRes = OpenCore::DoOpen(FILE_PATH); 130 if (!fileRes.IsSuccess()) { 131 ASSERT_TRUE(false); 132 } 133 FsFile *file = fileRes.GetData().value(); 134 auto ret = CloseCore::DoClose(file); 135 EXPECT_TRUE(ret.IsSuccess()); 136 137 GTEST_LOG_(INFO) << "CloseCoreTest-end DoCloseTestFile_0001"; 138 } 139 140 /** 141 * @tc.name: DoCloseTestFile_0002 142 * @tc.desc: Test function of DoClose() interface for failed get fd. 143 * @tc.size: MEDIUM 144 * @tc.type: FUNC 145 * @tc.level Level 1 146 */ 147 HWTEST_F(CloseCoreTest, DoCloseTestFile_0002, testing::ext::TestSize.Level1) 148 { 149 GTEST_LOG_(INFO) << "CloseCoreTest-begin DoCloseTestFile_0002"; 150 auto fileRes = OpenCore::DoOpen(FILE_PATH); 151 if (!fileRes.IsSuccess()) { 152 ASSERT_TRUE(false); 153 } 154 FsFile *file = fileRes.GetData().value(); 155 auto ret = CloseCore::DoClose(file); 156 EXPECT_TRUE(ret.IsSuccess()); 157 158 ret = CloseCore::DoClose(file); 159 EXPECT_FALSE(ret.IsSuccess()); 160 auto err = ret.GetError(); 161 EXPECT_EQ(err.GetErrNo(), 13900020); 162 163 GTEST_LOG_(INFO) << "CloseCoreTest-end DoCloseTestFile_0002"; 164 } 165 166 } 167 } 168 }