1 //
2 //
3 // Copyright 2015 gRPC authors.
4 //
5 // Licensed under the Apache License, Version 2.0 (the "License");
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
8 //
9 // http://www.apache.org/licenses/LICENSE-2.0
10 //
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an "AS IS" BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
16 //
17 //
18
19 #include "src/core/lib/transport/timeout_encoding.h"
20
21 #include <string>
22
23 #include "absl/strings/str_format.h"
24 #include "absl/strings/string_view.h"
25 #include "gtest/gtest.h"
26 #include "src/core/util/time.h"
27 #include "src/core/util/useful.h"
28
29 namespace grpc_core {
30 namespace {
31
assert_encodes_as(Duration ts,const char * s)32 void assert_encodes_as(Duration ts, const char* s) {
33 EXPECT_EQ(absl::string_view(s),
34 Timeout::FromDuration(ts).Encode().as_string_view())
35 << " ts=" << ts.ToString();
36 }
37
TEST(TimeoutTest,Encoding)38 TEST(TimeoutTest, Encoding) {
39 assert_encodes_as(Duration::Milliseconds(-1), "1n");
40 assert_encodes_as(Duration::Milliseconds(-10), "1n");
41 assert_encodes_as(Duration::Milliseconds(1), "1m");
42 assert_encodes_as(Duration::Milliseconds(10), "10m");
43 assert_encodes_as(Duration::Milliseconds(100), "100m");
44 assert_encodes_as(Duration::Milliseconds(890), "890m");
45 assert_encodes_as(Duration::Milliseconds(900), "900m");
46 assert_encodes_as(Duration::Milliseconds(901), "901m");
47 assert_encodes_as(Duration::Milliseconds(1000), "1S");
48 assert_encodes_as(Duration::Milliseconds(2000), "2S");
49 assert_encodes_as(Duration::Milliseconds(2500), "2500m");
50 assert_encodes_as(Duration::Milliseconds(59900), "59900m");
51 assert_encodes_as(Duration::Seconds(50), "50S");
52 assert_encodes_as(Duration::Seconds(59), "59S");
53 assert_encodes_as(Duration::Seconds(60), "1M");
54 assert_encodes_as(Duration::Seconds(80), "80S");
55 assert_encodes_as(Duration::Seconds(90), "90S");
56 assert_encodes_as(Duration::Seconds(120), "2M");
57 assert_encodes_as(Duration::Minutes(20), "20M");
58 assert_encodes_as(Duration::Hours(1), "1H");
59 assert_encodes_as(Duration::Hours(10), "10H");
60 assert_encodes_as(Duration::Hours(1) - Duration::Milliseconds(100), "1H");
61 assert_encodes_as(Duration::Hours(100), "100H");
62 assert_encodes_as(Duration::Hours(100000), "27000H");
63 }
64
assert_decodes_as(const char * buffer,Duration expected)65 void assert_decodes_as(const char* buffer, Duration expected) {
66 EXPECT_EQ(expected, ParseTimeout(Slice::FromCopiedString(buffer)));
67 }
68
decode_suite(char ext,Duration (* answer)(int64_t x))69 void decode_suite(char ext, Duration (*answer)(int64_t x)) {
70 long test_vals[] = {1, 12, 123, 1234, 12345, 123456,
71 1234567, 12345678, 123456789, 98765432, 9876543, 987654,
72 98765, 9876, 987, 98, 9};
73 for (unsigned i = 0; i < GPR_ARRAY_SIZE(test_vals); i++) {
74 std::string input = absl::StrFormat("%ld%c", test_vals[i], ext);
75 assert_decodes_as(input.c_str(), answer(test_vals[i]));
76
77 input = absl::StrFormat(" %ld%c", test_vals[i], ext);
78 assert_decodes_as(input.c_str(), answer(test_vals[i]));
79
80 input = absl::StrFormat("%ld %c", test_vals[i], ext);
81 assert_decodes_as(input.c_str(), answer(test_vals[i]));
82
83 input = absl::StrFormat("%ld %c ", test_vals[i], ext);
84 assert_decodes_as(input.c_str(), answer(test_vals[i]));
85 }
86 }
87
TEST(TimeoutTest,DecodingSucceeds)88 TEST(TimeoutTest, DecodingSucceeds) {
89 decode_suite('n', Duration::NanosecondsRoundUp);
90 decode_suite('u', Duration::MicrosecondsRoundUp);
91 decode_suite('m', Duration::Milliseconds);
92 decode_suite('S', Duration::Seconds);
93 decode_suite('M', Duration::Minutes);
94 decode_suite('H', Duration::Hours);
95 assert_decodes_as("1000000000S", Duration::Seconds(1000 * 1000 * 1000));
96 assert_decodes_as("1000000000000000000000u", Duration::Infinity());
97 assert_decodes_as("1000000001S", Duration::Infinity());
98 assert_decodes_as("2000000001S", Duration::Infinity());
99 assert_decodes_as("9999999999S", Duration::Infinity());
100 }
101
assert_decoding_fails(const char * s)102 void assert_decoding_fails(const char* s) {
103 EXPECT_EQ(absl::nullopt, ParseTimeout(Slice::FromCopiedString(s)))
104 << " s=" << s;
105 }
106
TEST(TimeoutTest,DecodingFails)107 TEST(TimeoutTest, DecodingFails) {
108 assert_decoding_fails("");
109 assert_decoding_fails(" ");
110 assert_decoding_fails("x");
111 assert_decoding_fails("1");
112 assert_decoding_fails("1x");
113 assert_decoding_fails("1ux");
114 assert_decoding_fails("!");
115 assert_decoding_fails("n1");
116 assert_decoding_fails("-1u");
117 }
118
119 } // namespace
120 } // namespace grpc_core
121
main(int argc,char ** argv)122 int main(int argc, char** argv) {
123 ::testing::InitGoogleTest(&argc, argv);
124 return RUN_ALL_TESTS();
125 }
126