1 // Protocol Buffers - Google's data interchange format
2 // Copyright 2023 Google LLC. All rights reserved.
3 //
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file or at
6 // https://developers.google.com/open-source/licenses/bsd
7
8 #include "upb/lex/atoi.h"
9
10 #include <string.h>
11
12 #include <gtest/gtest.h>
13 #include "absl/strings/str_cat.h"
14
TEST(AtoiTest,Uint64)15 TEST(AtoiTest, Uint64) {
16 uint64_t val;
17
18 const char* s = "1234z";
19 EXPECT_EQ(s + 1, upb_BufToUint64(s, s + 1, &val));
20 EXPECT_EQ(val, 1);
21 EXPECT_EQ(s + 4, upb_BufToUint64(s, s + 4, &val));
22 EXPECT_EQ(val, 1234);
23 EXPECT_EQ(s + 4, upb_BufToUint64(s, s + 5, &val));
24 EXPECT_EQ(val, 1234);
25
26 const char* t = "42.6";
27 EXPECT_EQ(t + 1, upb_BufToUint64(t, t + 1, &val));
28 EXPECT_EQ(val, 4);
29 EXPECT_EQ(t + 2, upb_BufToUint64(t, t + 2, &val));
30 EXPECT_EQ(val, 42);
31 EXPECT_EQ(t + 2, upb_BufToUint64(t, t + 3, &val));
32 EXPECT_EQ(val, 42);
33
34 // Integer overflow
35 const char* u = "1000000000000000000000000000000";
36 EXPECT_EQ(nullptr, upb_BufToUint64(u, u + strlen(u), &val));
37
38 // Not an integer
39 const char* v = "foobar";
40 EXPECT_EQ(v, upb_BufToUint64(v, v + strlen(v), &val));
41
42 const uint64_t values[] = {
43 std::numeric_limits<uint64_t>::max(),
44 std::numeric_limits<uint64_t>::min(),
45 };
46 for (size_t i = 0; i < ABSL_ARRAYSIZE(values); i++) {
47 std::string v = absl::StrCat(values[i]);
48 const char* ptr = v.c_str();
49 const char* end = ptr + strlen(ptr);
50 EXPECT_EQ(end, upb_BufToUint64(ptr, end, &val));
51 EXPECT_EQ(val, values[i]);
52 }
53 }
54
TEST(AtoiTest,Int64)55 TEST(AtoiTest, Int64) {
56 int64_t val;
57 bool neg;
58
59 const char* s = "1234z";
60 EXPECT_EQ(s + 1, upb_BufToInt64(s, s + 1, &val, &neg));
61 EXPECT_EQ(val, 1);
62 EXPECT_EQ(neg, false);
63 EXPECT_EQ(s + 4, upb_BufToInt64(s, s + 4, &val, nullptr));
64 EXPECT_EQ(val, 1234);
65 EXPECT_EQ(s + 4, upb_BufToInt64(s, s + 5, &val, nullptr));
66 EXPECT_EQ(val, 1234);
67
68 const char* t = "-42.6";
69 EXPECT_EQ(t + 2, upb_BufToInt64(t, t + 2, &val, &neg));
70 EXPECT_EQ(val, -4);
71 EXPECT_EQ(neg, true);
72 EXPECT_EQ(t + 3, upb_BufToInt64(t, t + 3, &val, nullptr));
73 EXPECT_EQ(val, -42);
74 EXPECT_EQ(neg, true);
75 EXPECT_EQ(t + 3, upb_BufToInt64(t, t + 5, &val, nullptr));
76 EXPECT_EQ(val, -42);
77
78 const int64_t values[] = {
79 std::numeric_limits<int32_t>::max(),
80 std::numeric_limits<int32_t>::min(),
81 std::numeric_limits<int64_t>::max(),
82 std::numeric_limits<int64_t>::min(),
83 };
84 for (size_t i = 0; i < ABSL_ARRAYSIZE(values); i++) {
85 std::string v = absl::StrCat(values[i]);
86 const char* ptr = v.c_str();
87 const char* end = ptr + strlen(ptr);
88 EXPECT_EQ(end, upb_BufToInt64(ptr, end, &val, nullptr));
89 EXPECT_EQ(val, values[i]);
90 }
91 }
92