1 //
2 //
3 // Copyright 2018 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/tsi/alts/handshaker/transport_security_common_api.h"
20
21 #include <stdbool.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24
25 #include <gtest/gtest.h>
26
27 const size_t kMaxRpcVersionMajor = 3;
28 const size_t kMaxRpcVersionMinor = 2;
29 const size_t kMinRpcVersionMajor = 2;
30 const size_t kMinRpcVersionMinor = 1;
31
grpc_gcp_rpc_protocol_versions_equal(grpc_gcp_rpc_protocol_versions * l_versions,grpc_gcp_rpc_protocol_versions * r_versions)32 static bool grpc_gcp_rpc_protocol_versions_equal(
33 grpc_gcp_rpc_protocol_versions* l_versions,
34 grpc_gcp_rpc_protocol_versions* r_versions) {
35 EXPECT_TRUE(l_versions != nullptr && r_versions != nullptr);
36 if ((l_versions->max_rpc_version.major !=
37 r_versions->max_rpc_version.major) ||
38 (l_versions->max_rpc_version.minor !=
39 r_versions->max_rpc_version.minor)) {
40 return false;
41 }
42 if ((l_versions->min_rpc_version.major !=
43 r_versions->min_rpc_version.major) ||
44 (l_versions->min_rpc_version.minor !=
45 r_versions->min_rpc_version.minor)) {
46 return false;
47 }
48 return true;
49 }
50
TEST(TransportSecurityCommonApiTest,TestSuccess)51 TEST(TransportSecurityCommonApiTest, TestSuccess) {
52 grpc_gcp_rpc_protocol_versions version;
53 grpc_gcp_rpc_protocol_versions decoded_version;
54 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(
55 &version, kMaxRpcVersionMajor, kMaxRpcVersionMinor));
56 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(
57 &version, kMinRpcVersionMajor, kMinRpcVersionMinor));
58 // Serializes to grpc slice.
59 grpc_slice encoded_slice;
60 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_encode(&version, &encoded_slice));
61 // Deserializes and compares with the original version.
62 ASSERT_TRUE(
63 grpc_gcp_rpc_protocol_versions_decode(encoded_slice, &decoded_version));
64 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_equal(&version, &decoded_version));
65 grpc_slice_unref(encoded_slice);
66 }
67
TEST(TransportSecurityCommonApiTest,TestFailure)68 TEST(TransportSecurityCommonApiTest, TestFailure) {
69 grpc_gcp_rpc_protocol_versions version, decoded_version;
70 grpc_slice encoded_slice;
71 // Test for invalid arguments.
72 ASSERT_FALSE(grpc_gcp_rpc_protocol_versions_set_max(
73 nullptr, kMaxRpcVersionMajor, kMaxRpcVersionMinor));
74 ASSERT_FALSE(grpc_gcp_rpc_protocol_versions_set_min(
75 nullptr, kMinRpcVersionMajor, kMinRpcVersionMinor));
76 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(
77 &version, kMaxRpcVersionMajor, kMaxRpcVersionMinor));
78 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(
79 &version, kMinRpcVersionMajor, kMinRpcVersionMinor));
80 ASSERT_FALSE(grpc_gcp_rpc_protocol_versions_encode(nullptr, &encoded_slice));
81 ASSERT_FALSE(grpc_gcp_rpc_protocol_versions_encode(&version, nullptr));
82 ASSERT_FALSE(grpc_gcp_rpc_protocol_versions_decode(encoded_slice, nullptr));
83 // Test for upb decode.
84 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_encode(&version, &encoded_slice));
85 grpc_slice bad_slice = grpc_slice_split_head(
86 &encoded_slice, GRPC_SLICE_LENGTH(encoded_slice) - 1);
87 grpc_slice_unref(encoded_slice);
88 ASSERT_TRUE(
89 !grpc_gcp_rpc_protocol_versions_decode(bad_slice, &decoded_version));
90 grpc_slice_unref(bad_slice);
91 }
92
TEST(TransportSecurityCommonApiTest,TestCopy)93 TEST(TransportSecurityCommonApiTest, TestCopy) {
94 grpc_gcp_rpc_protocol_versions src;
95 grpc_gcp_rpc_protocol_versions des;
96 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(&src, kMaxRpcVersionMajor,
97 kMaxRpcVersionMinor));
98 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(&src, kMinRpcVersionMajor,
99 kMinRpcVersionMinor));
100 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_copy(&src, &des));
101 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_equal(&src, &des));
102 }
103
TEST(TransportSecurityCommonApiTest,TestCheckSuccess)104 TEST(TransportSecurityCommonApiTest, TestCheckSuccess) {
105 grpc_gcp_rpc_protocol_versions v1;
106 grpc_gcp_rpc_protocol_versions v2;
107 grpc_gcp_rpc_protocol_versions_version highest_common_version;
108 // test equality.
109 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(&v1, kMaxRpcVersionMajor,
110 kMaxRpcVersionMinor));
111 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(&v1, kMaxRpcVersionMajor,
112 kMaxRpcVersionMinor));
113 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(&v2, kMaxRpcVersionMajor,
114 kMaxRpcVersionMinor));
115 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(&v2, kMaxRpcVersionMajor,
116 kMaxRpcVersionMinor));
117 ASSERT_EQ(
118 grpc_gcp_rpc_protocol_versions_check(
119 (const grpc_gcp_rpc_protocol_versions*)&v1,
120 (const grpc_gcp_rpc_protocol_versions*)&v2, &highest_common_version),
121 1);
122 ASSERT_EQ(grpc_core::internal::grpc_gcp_rpc_protocol_version_compare(
123 &highest_common_version, &v1.max_rpc_version),
124 0);
125
126 // test inequality.
127 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(&v1, kMaxRpcVersionMajor,
128 kMaxRpcVersionMinor));
129 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(&v1, kMinRpcVersionMinor,
130 kMinRpcVersionMinor));
131 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(&v2, kMaxRpcVersionMajor,
132 kMinRpcVersionMinor));
133 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(&v2, kMinRpcVersionMajor,
134 kMaxRpcVersionMinor));
135 ASSERT_EQ(
136 grpc_gcp_rpc_protocol_versions_check(
137 (const grpc_gcp_rpc_protocol_versions*)&v1,
138 (const grpc_gcp_rpc_protocol_versions*)&v2, &highest_common_version),
139 1);
140 ASSERT_EQ(grpc_core::internal::grpc_gcp_rpc_protocol_version_compare(
141 &highest_common_version, &v2.max_rpc_version),
142 0);
143 }
144
TEST(TransportSecurityCommonApiTest,TestCheckFailure)145 TEST(TransportSecurityCommonApiTest, TestCheckFailure) {
146 grpc_gcp_rpc_protocol_versions v1;
147 grpc_gcp_rpc_protocol_versions v2;
148 grpc_gcp_rpc_protocol_versions_version highest_common_version;
149
150 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(&v1, kMinRpcVersionMajor,
151 kMinRpcVersionMinor));
152 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(&v1, kMinRpcVersionMajor,
153 kMinRpcVersionMinor));
154 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_max(&v2, kMaxRpcVersionMajor,
155 kMaxRpcVersionMinor));
156 ASSERT_TRUE(grpc_gcp_rpc_protocol_versions_set_min(&v2, kMaxRpcVersionMajor,
157 kMaxRpcVersionMinor));
158 ASSERT_EQ(
159 grpc_gcp_rpc_protocol_versions_check(
160 (const grpc_gcp_rpc_protocol_versions*)&v1,
161 (const grpc_gcp_rpc_protocol_versions*)&v2, &highest_common_version),
162 0);
163 }
164
main(int argc,char ** argv)165 int main(int argc, char** argv) {
166 ::testing::InitGoogleTest(&argc, argv);
167 return RUN_ALL_TESTS();
168 }
169