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 */ 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 */ 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 **/ 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 **/ 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 **/ 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 **/ 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 **/ 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 **/ 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 **/ 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 **/ 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 **/ 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 **/ 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 }