1 /*
2 * Copyright (C) 2023 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
18 #include "memory.h"
19 #include "signature.h"
20
21 using namespace std;
22 using namespace testing::ext;
23
24 namespace {
25 class CryptoDsaVerifyTest : public testing::Test {
26 public:
27 static void SetUpTestCase();
28 static void TearDownTestCase();
29 void SetUp();
30 void TearDown();
31 };
32
SetUpTestCase()33 void CryptoDsaVerifyTest::SetUpTestCase() {}
TearDownTestCase()34 void CryptoDsaVerifyTest::TearDownTestCase() {}
SetUp()35 void CryptoDsaVerifyTest::SetUp() {}
TearDown()36 void CryptoDsaVerifyTest::TearDown() {}
37
38 static const char *g_hcfVerifyClass = "HcfVerify";
39
40 HWTEST_F(CryptoDsaVerifyTest, CryptoDsaVerifyTest001, TestSize.Level0)
41 {
42 HcfVerify *verify = nullptr;
43 HcfResult ret = HcfVerifyCreate("DSA2048|NoHash", &verify);
44
45 ASSERT_EQ(ret, HCF_SUCCESS);
46 ASSERT_NE(verify, nullptr);
47
48 const char *verifyClassName = verify->base.getClass();
49 HcfObjDestroy(verify);
50 ASSERT_STREQ(verifyClassName, g_hcfVerifyClass);
51 }
52
53 HWTEST_F(CryptoDsaVerifyTest, CryptoDsaVerifyTest002, TestSize.Level0)
54 {
55 HcfVerify *verify = nullptr;
56 HcfResult ret = HcfVerifyCreate("DSA2048|NoHash", &verify);
57
58 ASSERT_EQ(ret, HCF_SUCCESS);
59 ASSERT_NE(verify, nullptr);
60
61 verify->base.destroy(&(verify->base));
62 }
63
64 HWTEST_F(CryptoDsaVerifyTest, CryptoDsaVerifyTest003, TestSize.Level0)
65 {
66 HcfVerify *verify = nullptr;
67 HcfResult ret = HcfVerifyCreate("DSA2048|NoHash", &verify);
68
69 ASSERT_EQ(ret, HCF_SUCCESS);
70 ASSERT_NE(verify, nullptr);
71
72 const char *alg = verify->getAlgoName(verify);
73 HcfObjDestroy(verify);
74 ASSERT_STREQ(alg, "DSA2048|NoHash");
75 }
76
77 HWTEST_F(CryptoDsaVerifyTest, CryptoDsaVerifyTest004, TestSize.Level0)
78 {
79 HcfVerify *verify = nullptr;
80 HcfResult ret = HcfVerifyCreate("DSA2048|NoHash", &verify);
81
82 ASSERT_EQ(ret, HCF_SUCCESS);
83 ASSERT_NE(verify, nullptr);
84
85 ret = verify->setVerifySpecInt(verify, PSS_SALT_LEN_INT, 0);
86 HcfObjDestroy(verify);
87 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
88 }
89
90 HWTEST_F(CryptoDsaVerifyTest, CryptoDsaVerifyTest105, TestSize.Level0)
91 {
92 HcfVerify *verify = nullptr;
93 HcfResult ret = HcfVerifyCreate("DSA2048|NoHash", &verify);
94
95 ASSERT_EQ(ret, HCF_SUCCESS);
96 ASSERT_NE(verify, nullptr);
97
98 int32_t returnInt;
99 ret = verify->getVerifySpecInt(verify, PSS_SALT_LEN_INT, &returnInt);
100 HcfObjDestroy(verify);
101 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
102 }
103
104 HWTEST_F(CryptoDsaVerifyTest, CryptoDsaVerifyTest106, TestSize.Level0)
105 {
106 HcfVerify *verify = nullptr;
107 HcfResult ret = HcfVerifyCreate("DSA2048|NoHash", &verify);
108
109 ASSERT_EQ(ret, HCF_SUCCESS);
110 ASSERT_NE(verify, nullptr);
111
112 char *returnC = nullptr;
113 ret = verify->getVerifySpecString(verify, PSS_MGF_NAME_STR, &returnC);
114 HcfObjDestroy(verify);
115 ASSERT_EQ(ret, HCF_NOT_SUPPORT);
116 }
117 }