1 /*
2 * Copyright (c) 2021 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 <stdio.h>
17 #include <stdlib.h>
18 #include <unistd.h>
19 #include <math.h>
20 #include <limits.h>
21 #include "log.h"
22 #include "gtest/gtest.h"
23
24 using namespace testing::ext;
25
26 class MathApiTest : public testing::Test {
27 };
28
29 /**
30 * @tc.number SUB_KERNEL_MATH_MATH_CEIL_0100
31 * @tc.name ceil basic function test
32 * @tc.desc [C- SOFTWARE -0100]
33 */
HWTEST_F(MathApiTest, testCeil, Function | MediumTest | Level1)34 HWTEST_F(MathApiTest, testCeil, Function | MediumTest | Level1) {
35 const int testCount = 3;
36 double testValues[] = {-5.9, 0, 123.45};
37 double expected[] = {-5, 0, 124};
38 double ret;
39 for (int i = 0; i < testCount; ++i) {
40 ret = ceil(testValues[i]);
41 EXPECT_EQ(ret, expected[i]) << " ceil failed";
42 }
43 }
44
45 /**
46 * @tc.number SUB_KERNEL_MATH_MATH_CEILF_0100
47 * @tc.name ceilf basic function test
48 * @tc.desc [C- SOFTWARE -0100]
49 */
HWTEST_F(MathApiTest, testCeilf, Function | MediumTest | Level1)50 HWTEST_F(MathApiTest, testCeilf, Function | MediumTest | Level1) {
51 const int testCount = 3;
52 float testValues[] = {-5.9, 0, 123.45};
53 float expected[] = {-5, 0, 124};
54 float ret;
55 for (int i = 0; i < testCount; ++i) {
56 ret = ceilf(testValues[i]);
57 EXPECT_EQ(ret, expected[i]) << " ceilf failed";
58 }
59 }
60
61 /**
62 * @tc.number SUB_KERNEL_MATH_MATH_FINITE_0100
63 * @tc.name test finite api
64 * @tc.desc [C- SOFTWARE -0100]
65 **/
HWTEST_F(MathApiTest, testfinite, Function | MediumTest | Level1)66 HWTEST_F(MathApiTest, testfinite, Function | MediumTest | Level1) {
67 const int testCount = 7;
68 double testValues[7] = {1.0000001, 0.0/0.0, 1.0000001/0.0, 1.79769e+308, NAN};
69 testValues[5] = sqrt(-1.0000001);
70 testValues[6] = log(0);
71 double expected[] = {1, 0, 0, 1, 0, 0, 0};
72 double ret;
73 for (int i = 0; i < testCount; ++i) {
74 ret = finite(testValues[i]);
75 EXPECT_EQ(ret, expected[i]) << " finite failed";
76 }
77 }
78
79 /**
80 * @tc.number SUB_KERNEL_MATH_MATH_FINITEF_0100
81 * @tc.name test finitef api
82 * @tc.desc [C- SOFTWARE -0100]
83 **/
HWTEST_F(MathApiTest, testfinitef, Function | MediumTest | Level1)84 HWTEST_F(MathApiTest, testfinitef, Function | MediumTest | Level1) {
85 const int testCount = 6;
86 float testValues[6] = {1, -1, 3.40282e+038, NAN};
87 testValues[4] = sqrt(-1.0);
88 testValues[5] = log(0);
89 float expected[] = {1, 1, 1, 0, 0, 0};
90 float ret;
91 for (int i = 0; i < testCount; ++i) {
92 ret = finitef(testValues[i]);
93 EXPECT_EQ(ret, expected[i]) << " finitef failed";
94 }
95 }
96
97 /**
98 * @tc.number SUB_KERNEL_MATH_MATH_NAN_0100
99 * @tc.name test nan api
100 * @tc.desc [C- SOFTWARE -0100]
101 **/
HWTEST_F(MathApiTest, testnan, Function | MediumTest | Level1)102 HWTEST_F(MathApiTest, testnan, Function | MediumTest | Level1) {
103 const int testCount = 3;
104 const char *testValues[] = {"1", "99", "abc"};
105 double ret;
106 for (int i = 0; i < testCount; ++i) {
107 ret = nan(testValues[i]);
108 ASSERT_TRUE(ret != 0) << " nan failed";
109 }
110 }
111
112 /**
113 * @tc.number SUB_KERNEL_MATH_MATH_NANF_0100
114 * @tc.name test nanf api
115 * @tc.desc [C- SOFTWARE -0100]
116 **/
HWTEST_F(MathApiTest, testnanf, Function | MediumTest | Level1)117 HWTEST_F(MathApiTest, testnanf, Function | MediumTest | Level1) {
118 const int testCount = 3;
119 const char *testValues[] = {"abc", "99", " "};
120 float ret;
121 for (int i = 0; i < testCount; ++i) {
122 ret = nanf(testValues[i]);
123 ASSERT_TRUE(ret != 0) << " nanf failed";
124 }
125 }
126
127 /**
128 * @tc.number SUB_KERNEL_MATH_MATH_NANL_0100
129 * @tc.name test nanl api
130 * @tc.desc [C- SOFTWARE -0100]
131 **/
HWTEST_F(MathApiTest, testnanl, Function | MediumTest | Level1)132 HWTEST_F(MathApiTest, testnanl, Function | MediumTest | Level1) {
133 const int testCount = 3;
134 const char *testValues[] = {"abc", "99", " "};
135 long double ret;
136 for (int i = 0; i < testCount; ++i) {
137 ret = nanl(testValues[i]);
138 ASSERT_TRUE(ret != 0) << " nanl failed";
139 }
140 }
141
142 /**
143 * @tc.number SUB_KERNEL_MATH_MATH_POW10F_0100
144 * @tc.name test pow10f api
145 * @tc.desc [C- SOFTWARE -0100]
146 **/
HWTEST_F(MathApiTest, testpowf10, Function | MediumTest | Level1)147 HWTEST_F(MathApiTest, testpowf10, Function | MediumTest | Level1) {
148 const int testCount = 3;
149 float testValues[] = {0.0, 1.111111, -1.111111, 3.40282e+038};
150 float expected[] = {1, 12.915494918823242, 0.077426381409168243};
151 float ret;
152 for (int i = 0; i < testCount; ++i) {
153 ret = pow10f(testValues[i]);
154 EXPECT_EQ(ret, expected[i]) << " pow10f failed";
155 }
156 }
157
158 /**
159 * @tc.number SUB_KERNEL_MATH_MATH_POW10L_0100
160 * @tc.name test pow10l api
161 * @tc.desc [C- SOFTWARE -0100]
162 **/
HWTEST_F(MathApiTest, testpowl10, Function | MediumTest | Level1)163 HWTEST_F(MathApiTest, testpowl10, Function | MediumTest | Level1) {
164 const int testCount = 3;
165 long double testValues[] = {0.0000000000000000, 1.1111111111111111111, -1.1111111111111111111};
166 long double expected[] = {1, 12.91549665014884, 0.077426368268112708};
167 long double ret;
168 for (int i = 0; i < testCount; ++i) {
169 ret = pow10l(testValues[i]);
170 EXPECT_EQ(ret, expected[i]) << " pow10l failed";
171 }
172 }
173
174 /**
175 * @tc.number SUB_KERNEL_MATH_MATH_SIGNBIT_0100
176 * @tc.name test signbit api
177 * @tc.desc [C- SOFTWARE -0100]
178 **/
HWTEST_F(MathApiTest, testsignbit, Function | MediumTest | Level1)179 HWTEST_F(MathApiTest, testsignbit, Function | MediumTest | Level1) {
180 const int testCount = 3;
181 float testValues[] = {3.000001, -3.000001, 0.0};
182 float expected[] = {0, 1, 0};
183 float ret;
184 for (int i = 0; i < testCount; ++i) {
185 ret = signbit(testValues[i]);
186 EXPECT_EQ(ret, expected[i]) << " signbit failed";
187 }
188 }
189
190 /**
191 * @tc.number SUB_KERNEL_MATH_MATH_SIGNIFICAND_0100
192 * @tc.name test significand api
193 * @tc.desc [C- SOFTWARE -0100]
194 **/
HWTEST_F(MathApiTest, testsignificand, Function | MediumTest | Level1)195 HWTEST_F(MathApiTest, testsignificand, Function | MediumTest | Level1) {
196 const int testCount = 4;
197 double testValues[] = {3.0000001, -3.0000001, 0.0000000, 3.40282e+038};
198 double expected[] = {1.5000000499999999, -1.5000000499999999, 0.0000000, 1.9999978434325483};
199 double ret;
200 for (int i = 0; i < testCount; ++i) {
201 ret = significand(testValues[i]);
202 EXPECT_EQ(ret, expected[i]) << " significand failed";
203 }
204 }
205
206 /**
207 * @tc.number SUB_KERNEL_MATH_MATH_SIGNIFICANDF_0100
208 * @tc.name test significandf api
209 * @tc.desc [C- SOFTWARE -0100]
210 **/
HWTEST_F(MathApiTest, testsignificandf, Function | MediumTest | Level1)211 HWTEST_F(MathApiTest, testsignificandf, Function | MediumTest | Level1) {
212 const int testCount = 4;
213 float testValues[] = {3.000001, -3.000001, 0.000000, 3.40282e+038};
214 float expected[] = {1.5000004768371582, -1.5000004768371582, 0.000000, 1.9999978542327881};
215 float ret;
216 for (int i = 0; i < testCount; ++i) {
217 ret = significandf(testValues[i]);
218 EXPECT_EQ(ret, expected[i]) << " significandf failed";
219 }
220 }