1 /*
2  * Copyright (c) 2024 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 #define LOG_TAG "RdbResultSetStubTest"
16 
17 #include "gtest/gtest.h"
18 #include "log_print.h"
19 #include "message_parcel.h"
20 #include "rdb_result_set_impl.h"
21 #include "rdb_result_set_stub.h"
22 #include "store/cursor.h"
23 #include "securec.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS;
27 using namespace OHOS::DistributedRdb;
28 using namespace OHOS::DistributedData;
29 const std::u16string INTERFACE_TOKEN = u"OHOS::NativeRdb.IResultSet";
30 namespace OHOS::Test {
31 namespace DistributedRDBTest {
32 class RdbResultSetStubTest : public testing::Test {
33 public:
SetUpTestCase(void)34     static void SetUpTestCase(void){};
TearDownTestCase(void)35     static void TearDownTestCase(void){};
SetUp()36     void SetUp(){};
TearDown()37     void TearDown(){};
38 protected:
39 };
40 
41 /**
42 * @tc.name: OnRemoteRequest001
43 * @tc.desc: RdbResultSetStub OnRemoteRequest function error test.
44 * @tc.type: FUNC
45 * @tc.require:
46 * @tc.author: SQL
47 */
48 HWTEST_F(RdbResultSetStubTest, OnRemoteRequest001, TestSize.Level1)
49 {
50     std::shared_ptr<DistributedData::Cursor> dbResultSet;
51     auto result = std::make_shared<RdbResultSetImpl>(dbResultSet);
52     MessageParcel request1;
53     MessageParcel reply1;
54     MessageOption option1;
55     std::shared_ptr<RdbResultSetStub> rdbResultSetStub1 = std::make_shared<RdbResultSetStub>(result);
56     auto ret = rdbResultSetStub1->OnRemoteRequest(RdbResultSetStub::Code::CMD_GET_ALL_COLUMN_NAMES,
57         request1, reply1, option1);
58     EXPECT_EQ(ret, -1);
59 
60     result = nullptr;
61     uint8_t value = 1;
62     uint8_t *data = &value;
63     size_t size = 1;
64     MessageParcel request2;
65     request2.WriteInterfaceToken(INTERFACE_TOKEN);
66     request2.WriteBuffer(data, size);
67     request2.RewindRead(0);
68     MessageParcel reply2;
69     MessageOption option2;
70     std::shared_ptr<RdbResultSetStub> rdbResultSetStub2 = std::make_shared<RdbResultSetStub>(result);
71     ret = rdbResultSetStub2->OnRemoteRequest(RdbResultSetStub::Code::CMD_GET_ALL_COLUMN_NAMES,
72         request2, reply2, option2);
73     EXPECT_EQ(ret, -1);
74 
75     MessageParcel request3;
76     MessageParcel reply3;
77     MessageOption option3;
78     std::shared_ptr<RdbResultSetStub> rdbResultSetStub3 = std::make_shared<RdbResultSetStub>(result);
79     ret = rdbResultSetStub3->OnRemoteRequest(RdbResultSetStub::Code::CMD_GET_ALL_COLUMN_NAMES,
80         request3, reply3, option3);
81     EXPECT_EQ(ret, -1);
82 }
83 
84 /**
85 * @tc.name: OnRemoteRequest002
86 * @tc.desc: RdbResultSetStub OnRemoteRequest function error test.
87 * @tc.type: FUNC
88 * @tc.require:
89 * @tc.author: SQL
90 */
91 HWTEST_F(RdbResultSetStubTest, OnRemoteRequest002, TestSize.Level1)
92 {
93     std::shared_ptr<DistributedData::Cursor> dbResultSet;
94     auto result = std::make_shared<RdbResultSetImpl>(dbResultSet);
95     std::shared_ptr<RdbResultSetStub> rdbResultSetStub = std::make_shared<RdbResultSetStub>(result);
96     uint8_t value = 1;
97     uint8_t *data = &value;
98     size_t size = 1;
99     MessageParcel request1;
100     request1.WriteInterfaceToken(INTERFACE_TOKEN);
101     request1.WriteBuffer(data, size);
102     request1.RewindRead(0);
103     MessageParcel reply1;
104     MessageOption option1;
105     uint32_t code = -1;
106     auto ret = rdbResultSetStub->OnRemoteRequest(code, request1, reply1, option1);
107     EXPECT_GT(ret, 0);
108 
109     code = 20; // invalid code > Code::CMD_MAX
110     MessageParcel request2;
111     request2.WriteInterfaceToken(INTERFACE_TOKEN);
112     request2.WriteBuffer(data, size);
113     request2.RewindRead(0);
114     MessageParcel reply2;
115     MessageOption option2;
116     ret = rdbResultSetStub->OnRemoteRequest(code, request2, reply2, option2);
117     EXPECT_GT(ret, 0);
118 }
119 
120 /**
121 * @tc.name: RdbResultSetStub
122 * @tc.desc: RdbResultSetStub function test.
123 * @tc.type: FUNC
124 * @tc.require:
125 * @tc.author: SQL
126 */
127 HWTEST_F(RdbResultSetStubTest, RdbResultSetStub, TestSize.Level1)
128 {
129     std::shared_ptr<DistributedData::Cursor> dbResultSet;
130     auto result = std::make_shared<RdbResultSetImpl>(dbResultSet);
131     std::shared_ptr<RdbResultSetStub> rdbResultSetStub = std::make_shared<RdbResultSetStub>(result);
132     for (uint32_t i = RdbResultSetStub::Code::CMD_GET_ALL_COLUMN_NAMES; i < RdbResultSetStub::Code::CMD_MAX; ++i)
133     {
134         RdbResultSetStub::Code code = static_cast<RdbResultSetStub::Code>(i);
135         uint8_t value = 1;
136         uint8_t *data = &value;
137         size_t size = 1;
138         MessageParcel request;
139         request.WriteInterfaceToken(INTERFACE_TOKEN);
140         request.WriteBuffer(data, size);
141         request.RewindRead(0);
142         MessageParcel reply;
143         MessageOption option;
144         auto ret = rdbResultSetStub->OnRemoteRequest(code, request, reply, option);
145         EXPECT_EQ(ret, 0);
146     }
147 }
148 } // namespace DistributedRDBTest
149 } // namespace OHOS::Test