1 /*
2 * Copyright 2017 The WebRTC Project Authors. All rights reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "rtc_base/string_to_number.h"
12
13 #include <stdint.h>
14
15 #include <limits>
16 #include <string>
17
18 #include "absl/strings/string_view.h"
19 #include "absl/types/optional.h"
20 #include "test/gtest.h"
21
22 namespace rtc {
23
24 namespace {
25 // clang-format off
26 using IntegerTypes =
27 ::testing::Types<char,
28 signed char, unsigned char, // NOLINT(runtime/int)
29 short, unsigned short, // NOLINT(runtime/int)
30 int, unsigned int, // NOLINT(runtime/int)
31 long, unsigned long, // NOLINT(runtime/int)
32 long long, unsigned long long, // NOLINT(runtime/int)
33 int8_t, uint8_t,
34 int16_t, uint16_t,
35 int32_t, uint32_t,
36 int64_t, uint64_t>;
37 // clang-format on
38
39 template <typename T>
40 class BasicNumberTest : public ::testing::Test {};
41
42 TYPED_TEST_SUITE_P(BasicNumberTest);
43
TYPED_TEST_P(BasicNumberTest,TestValidNumbers)44 TYPED_TEST_P(BasicNumberTest, TestValidNumbers) {
45 using T = TypeParam;
46 constexpr T min_value = std::numeric_limits<T>::lowest();
47 constexpr T max_value = std::numeric_limits<T>::max();
48 constexpr T zero_value = 0;
49 const std::string min_string = std::to_string(min_value);
50 const std::string max_string = std::to_string(max_value);
51 EXPECT_EQ(min_value, StringToNumber<T>(min_string));
52 EXPECT_EQ(min_value, StringToNumber<T>(min_string.c_str()));
53 EXPECT_EQ(max_value, StringToNumber<T>(max_string));
54 EXPECT_EQ(max_value, StringToNumber<T>(max_string.c_str()));
55 EXPECT_EQ(zero_value, StringToNumber<T>("0"));
56 EXPECT_EQ(zero_value, StringToNumber<T>("-0"));
57 EXPECT_EQ(zero_value, StringToNumber<T>(std::string("-0000000000000")));
58 }
59
TYPED_TEST_P(BasicNumberTest,TestInvalidNumbers)60 TYPED_TEST_P(BasicNumberTest, TestInvalidNumbers) {
61 using T = TypeParam;
62 // Value ranges aren't strictly enforced in this test, since that would either
63 // require doctoring specific strings for each data type, which is a hassle
64 // across platforms, or to be able to do addition of values larger than the
65 // largest type, which is another hassle.
66 constexpr T min_value = std::numeric_limits<T>::lowest();
67 constexpr T max_value = std::numeric_limits<T>::max();
68 // If the type supports negative values, make the large negative value
69 // approximately ten times larger. If the type is unsigned, just use -2.
70 const std::string too_low_string =
71 (min_value == 0) ? "-2" : (std::to_string(min_value) + "1");
72 // Make the large value approximately ten times larger than the maximum.
73 const std::string too_large_string = std::to_string(max_value) + "1";
74 EXPECT_EQ(absl::nullopt, StringToNumber<T>(too_low_string));
75 EXPECT_EQ(absl::nullopt, StringToNumber<T>(too_low_string.c_str()));
76 EXPECT_EQ(absl::nullopt, StringToNumber<T>(too_large_string));
77 EXPECT_EQ(absl::nullopt, StringToNumber<T>(too_large_string.c_str()));
78 }
79
TYPED_TEST_P(BasicNumberTest,TestInvalidInputs)80 TYPED_TEST_P(BasicNumberTest, TestInvalidInputs) {
81 using T = TypeParam;
82 const char kInvalidCharArray[] = "Invalid string containing 47";
83 const char kPlusMinusCharArray[] = "+-100";
84 const char kNumberFollowedByCruft[] = "640x480";
85 const char kEmbeddedNul[] = {'1', '2', '\0', '3', '4'};
86 const char kBeginningEmbeddedNul[] = {'\0', '1', '2', '3', '4'};
87 const char kTrailingEmbeddedNul[] = {'1', '2', '3', '4', '\0'};
88
89 EXPECT_EQ(absl::nullopt, StringToNumber<T>(kInvalidCharArray));
90 EXPECT_EQ(absl::nullopt, StringToNumber<T>(std::string(kInvalidCharArray)));
91 EXPECT_EQ(absl::nullopt, StringToNumber<T>(kPlusMinusCharArray));
92 EXPECT_EQ(absl::nullopt, StringToNumber<T>(std::string(kPlusMinusCharArray)));
93 EXPECT_EQ(absl::nullopt, StringToNumber<T>(kNumberFollowedByCruft));
94 EXPECT_EQ(absl::nullopt,
95 StringToNumber<T>(std::string(kNumberFollowedByCruft)));
96 EXPECT_EQ(absl::nullopt, StringToNumber<T>(" 5"));
97 EXPECT_EQ(absl::nullopt, StringToNumber<T>(" - 5"));
98 EXPECT_EQ(absl::nullopt, StringToNumber<T>("- 5"));
99 EXPECT_EQ(absl::nullopt, StringToNumber<T>(" -5"));
100 EXPECT_EQ(absl::nullopt, StringToNumber<T>("5 "));
101 // Test various types of empty inputs
102 EXPECT_EQ(absl::nullopt, StringToNumber<T>({nullptr, 0}));
103 EXPECT_EQ(absl::nullopt, StringToNumber<T>(""));
104 EXPECT_EQ(absl::nullopt, StringToNumber<T>(std::string()));
105 EXPECT_EQ(absl::nullopt, StringToNumber<T>(std::string("")));
106 EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view()));
107 EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view(nullptr, 0)));
108 EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view("")));
109 // Test strings with embedded nuls.
110 EXPECT_EQ(absl::nullopt, StringToNumber<T>(absl::string_view(
111 kEmbeddedNul, sizeof(kEmbeddedNul))));
112 EXPECT_EQ(absl::nullopt,
113 StringToNumber<T>(absl::string_view(
114 kBeginningEmbeddedNul, sizeof(kBeginningEmbeddedNul))));
115 EXPECT_EQ(absl::nullopt,
116 StringToNumber<T>(absl::string_view(kTrailingEmbeddedNul,
117 sizeof(kTrailingEmbeddedNul))));
118 }
119
120 REGISTER_TYPED_TEST_SUITE_P(BasicNumberTest,
121 TestValidNumbers,
122 TestInvalidNumbers,
123 TestInvalidInputs);
124
125 } // namespace
126
127 INSTANTIATE_TYPED_TEST_SUITE_P(StringToNumberTest_Integers,
128 BasicNumberTest,
129 IntegerTypes);
130
TEST(StringToNumberTest,TestSpecificValues)131 TEST(StringToNumberTest, TestSpecificValues) {
132 EXPECT_EQ(absl::nullopt, StringToNumber<uint8_t>("256"));
133 EXPECT_EQ(absl::nullopt, StringToNumber<uint8_t>("-256"));
134 EXPECT_EQ(absl::nullopt, StringToNumber<int8_t>("256"));
135 EXPECT_EQ(absl::nullopt, StringToNumber<int8_t>("-256"));
136 }
137
138 } // namespace rtc
139