1 /* 2 * Copyright (c) 2021-2022 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 "utils/type_converter.h" 17 18 #include <sstream> 19 #include <random> 20 #include <gtest/gtest.h> 21 22 #ifndef PANDA_NIGHTLY_TEST_ON 23 constexpr size_t ITERATION = 64; 24 #else 25 constexpr size_t ITERATION = 1024; 26 #endif 27 28 namespace panda::helpers::test { 29 30 HWTEST(TimeTest, RandomTimeConverterTest, testing::ext::TestSize.Level0) 31 { 32 std::mt19937 gen; 33 std::uniform_int_distribution<time_t> distrib_nanos_right(0, 1e3 - 1); 34 std::uniform_int_distribution<time_t> distrib_nanos_left(1, 23); 35 for (size_t i = 0; i < ITERATION; i++) { 36 uint64_t left_part_time = distrib_nanos_left(gen); 37 uint64_t right_part_time = distrib_nanos_right(gen); 38 ASSERT_NE(TimeConverter(left_part_time), ValueUnit(left_part_time, "ns")); 39 ASSERT_NE(TimeConverter(right_part_time), ValueUnit(right_part_time, "ns")); 40 41 ASSERT_EQ(TimeConverter(left_part_time), ValueUnit(static_cast<double>(left_part_time), "ns")); 42 ASSERT_EQ(TimeConverter(right_part_time), ValueUnit(static_cast<double>(right_part_time), "ns")); 43 44 double expected = left_part_time + right_part_time * 1e-3; 45 uint64_t nanos = left_part_time * 1e3 + right_part_time; 46 ASSERT_EQ(TimeConverter(nanos), ValueUnit(expected, "us")); 47 ASSERT_EQ(TimeConverter(nanos * 1e3), ValueUnit(expected, "ms")); 48 ASSERT_EQ(TimeConverter(nanos * 1e6), ValueUnit(expected, "s")); 49 ASSERT_EQ(TimeConverter(nanos * 1e6 * 60), ValueUnit(expected, "m")); 50 ASSERT_EQ(TimeConverter(nanos * 1e6 * 60 * 60), ValueUnit(expected, "h")); 51 ASSERT_EQ(TimeConverter(nanos * 1e6 * 60 * 60 * 24), ValueUnit(expected, "day")); 52 } 53 } 54 55 HWTEST(TimeTest, RoundTimeConverterTest, testing::ext::TestSize.Level0) 56 { 57 ASSERT_EQ(TimeConverter(11'119'272), ValueUnit(11.119, "ms")); 58 ASSERT_EQ(TimeConverter(11'119'472), ValueUnit(11.119, "ms")); 59 ASSERT_EQ(TimeConverter(11'119'499), ValueUnit(11.119, "ms")); 60 ASSERT_EQ(TimeConverter(11'119'500), ValueUnit(11.120, "ms")); 61 ASSERT_EQ(TimeConverter(11'119'572), ValueUnit(11.120, "ms")); 62 ASSERT_EQ(TimeConverter(11'119'999), ValueUnit(11.120, "ms")); 63 } 64 65 HWTEST(MemoryTest, RandomMemoryConverterTest, testing::ext::TestSize.Level0) 66 { 67 std::mt19937 gen; 68 std::uniform_int_distribution<uint64_t> distrib_bytes(1, 1023); 69 for (size_t i = 0; i < ITERATION; i++) { 70 uint64_t left_part_bytes = distrib_bytes(gen); 71 uint64_t right_part_bytes = distrib_bytes(gen); 72 ASSERT_NE(MemoryConverter(left_part_bytes), ValueUnit(left_part_bytes, "B")); 73 ASSERT_NE(MemoryConverter(right_part_bytes), ValueUnit(right_part_bytes, "B")); 74 75 ASSERT_EQ(MemoryConverter(left_part_bytes), ValueUnit(static_cast<double>(left_part_bytes), "B")); 76 ASSERT_EQ(MemoryConverter(right_part_bytes), ValueUnit(static_cast<double>(right_part_bytes), "B")); 77 78 double expected = left_part_bytes + right_part_bytes * 1e-3; 79 uint64_t bytes = left_part_bytes * 1024 + right_part_bytes; 80 ASSERT_EQ(MemoryConverter(bytes), ValueUnit(expected, "KB")); 81 ASSERT_EQ(MemoryConverter(bytes * (1UL << 10)), ValueUnit(expected, "MB")); 82 ASSERT_EQ(MemoryConverter(bytes * (1UL << 20)), ValueUnit(expected, "GB")); 83 ASSERT_EQ(MemoryConverter(bytes * (1UL << 30)), ValueUnit(expected, "TB")); 84 } 85 } 86 87 HWTEST(MemoryTest, RoundMemoryConverterTest, testing::ext::TestSize.Level0) 88 { 89 ASSERT_EQ(MemoryConverter(11'119'272), ValueUnit(10.604, "MB")); 90 ASSERT_EQ(MemoryConverter(11'120'149), ValueUnit(10.605, "MB")); 91 ASSERT_EQ(MemoryConverter(11'121'092), ValueUnit(10.606, "MB")); 92 } 93 94 HWTEST(TypeConverterTest, OperatorEqualTest, testing::ext::TestSize.Level0) 95 { 96 const uint64_t number_zero = 0UL; 97 const uint64_t number_one = 1UL; 98 ASSERT_TRUE(ValueUnit(10.27, "MB") == ValueUnit(10.27, "MB")); 99 ASSERT_FALSE(ValueUnit(10.27, "MB") == ValueUnit(10.27, "KB")); 100 ASSERT_TRUE(ValueUnit(number_zero, "MB") == ValueUnit(number_zero, "MB")); 101 ASSERT_FALSE(ValueUnit(number_zero, "MB") == ValueUnit(number_zero, "GB")); 102 ASSERT_FALSE(ValueUnit(number_one, "MB") == ValueUnit(number_one, "KB")); 103 } 104 105 HWTEST(TypeConverterTest, ValueConverterTest, testing::ext::TestSize.Level0) 106 { 107 const uint64_t number = 10UL; 108 ASSERT_EQ(ValueConverter(11'119'272, ValueType::VALUE_TYPE_TIME), ValueUnit(11.119, "ms")); 109 ASSERT_EQ(ValueConverter(11'119'272, ValueType::VALUE_TYPE_MEMORY), ValueUnit(10.604, "MB")); 110 ASSERT_EQ(ValueConverter(number, ValueType::VALUE_TYPE_OBJECT), ValueUnit(number, "")); 111 } 112 113 } // namespace panda::helpers::test 114