4 * Copyright (c) Intel Corporation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 #include "spdk/stdinc.h"
36 #include "spdk_cunit.h"
38 #include "util/base64.c"
40 char text_A
[] = "FZB3";
41 uint8_t raw_A
[] = {0x15, 0x90, 0x77};
42 char text_B
[] = "AbC/1+c=";
43 char text_urlsafe_B
[] = "AbC_1-c=";
44 uint8_t raw_B
[] = {0x01, 0xB0, 0xBF, 0xD7, 0xE7};
45 char text_C
[] = "AbC/1+cC";
46 char text_urlsafe_C
[] = "AbC_1-cC";
47 uint8_t raw_C
[] = {0x01, 0xB0, 0xBF, 0xD7, 0xE7, 0x02};
48 char text_D
[] = "AbC/1w==";
49 char text_urlsafe_D
[] = "AbC_1w==";
50 uint8_t raw_D
[] = {0x01, 0xB0, 0xBF, 0xD7};
51 char text_E
[] = "AbC12===";
52 char text_F
[] = "AbCd112";
53 char text_G
[] = "AbCd12";
54 char text_H
[] = "AbC12";
57 test_base64_get_encoded_strlen(void)
59 uint32_t raw_lens
[4] = {8, 9, 10, 11};
60 uint32_t text_strlens
[4] = {12, 12, 16, 16};
64 for (i
= 0; i
< 4; i
++) {
65 text_strlen
= spdk_base64_get_encoded_strlen(raw_lens
[i
]);
66 CU_ASSERT_EQUAL(text_strlen
, text_strlens
[i
]);
71 test_base64_get_decoded_len(void)
73 uint32_t text_strlens
[4] = {8, 10, 11, 12};
74 uint32_t raw_lens
[4] = {6, 7, 8, 9};
78 for (i
= 0; i
< 4; i
++) {
79 bin_len
= spdk_base64_get_decoded_len(text_strlens
[i
]);
80 CU_ASSERT_EQUAL(bin_len
, raw_lens
[i
]);
85 test_base64_encode(void)
90 ret
= spdk_base64_encode(text
, raw_A
, sizeof(raw_A
));
91 CU_ASSERT_EQUAL(ret
, 0);
92 CU_ASSERT(strcmp(text
, text_A
) == 0);
93 CU_ASSERT_EQUAL(strlen(text
), strlen(text_A
));
95 ret
= spdk_base64_encode(text
, raw_B
, sizeof(raw_B
));
96 CU_ASSERT_EQUAL(ret
, 0);
97 CU_ASSERT(strcmp(text
, text_B
) == 0);
98 CU_ASSERT_EQUAL(strlen(text
), strlen(text_B
));
100 ret
= spdk_base64_encode(text
, raw_C
, sizeof(raw_C
));
101 CU_ASSERT_EQUAL(ret
, 0);
102 CU_ASSERT(strcmp(text
, text_C
) == 0);
104 ret
= spdk_base64_encode(text
, raw_D
, sizeof(raw_D
));
105 CU_ASSERT_EQUAL(ret
, 0);
106 CU_ASSERT(strcmp(text
, text_D
) == 0);
108 ret
= spdk_base64_encode(NULL
, raw_A
, sizeof(raw_A
));
109 CU_ASSERT_EQUAL(ret
, -EINVAL
);
110 ret
= spdk_base64_encode(text
, NULL
, sizeof(raw_A
));
111 CU_ASSERT_EQUAL(ret
, -EINVAL
);
112 ret
= spdk_base64_encode(text
, raw_A
, 0);
113 CU_ASSERT_EQUAL(ret
, -EINVAL
);
117 test_base64_decode(void)
120 void *raw
= (void *)raw_buf
;
124 ret
= spdk_base64_decode(raw
, &raw_len
, text_A
);
125 CU_ASSERT_EQUAL(ret
, 0);
126 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_A
));
127 CU_ASSERT(memcmp(raw
, raw_A
, sizeof(raw_A
)) == 0);
129 ret
= spdk_base64_decode(raw
, &raw_len
, text_B
);
130 CU_ASSERT_EQUAL(ret
, 0);
131 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_B
));
132 CU_ASSERT(memcmp(raw
, raw_B
, sizeof(raw_B
)) == 0);
134 ret
= spdk_base64_decode(raw
, &raw_len
, text_C
);
135 CU_ASSERT_EQUAL(ret
, 0);
136 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_C
));
137 CU_ASSERT(memcmp(raw
, raw_C
, sizeof(raw_C
)) == 0);
139 ret
= spdk_base64_decode(raw
, &raw_len
, text_D
);
140 CU_ASSERT_EQUAL(ret
, 0);
141 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_D
));
142 CU_ASSERT(memcmp(raw
, raw_D
, sizeof(raw_D
)) == 0);
144 ret
= spdk_base64_decode(raw
, &raw_len
, text_E
);
145 CU_ASSERT_EQUAL(ret
, -EINVAL
);
146 ret
= spdk_base64_decode(raw
, &raw_len
, text_F
);
147 CU_ASSERT_EQUAL(ret
, -EINVAL
);
148 ret
= spdk_base64_decode(raw
, &raw_len
, text_G
);
149 CU_ASSERT_EQUAL(ret
, -EINVAL
);
150 ret
= spdk_base64_decode(raw
, &raw_len
, text_H
);
151 CU_ASSERT_EQUAL(ret
, -EINVAL
);
152 ret
= spdk_base64_decode(NULL
, &raw_len
, text_H
);
153 CU_ASSERT_EQUAL(ret
, -EINVAL
);
154 ret
= spdk_base64_decode(raw
, &raw_len
, NULL
);
155 CU_ASSERT_EQUAL(ret
, -EINVAL
);
159 test_base64_urlsafe_encode(void)
164 ret
= spdk_base64_urlsafe_encode(text
, raw_A
, sizeof(raw_A
));
165 CU_ASSERT_EQUAL(ret
, 0);
166 CU_ASSERT(strcmp(text
, text_A
) == 0);
167 CU_ASSERT_EQUAL(strlen(text
), strlen(text_A
));
169 ret
= spdk_base64_urlsafe_encode(text
, raw_B
, sizeof(raw_B
));
170 CU_ASSERT_EQUAL(ret
, 0);
171 CU_ASSERT(strcmp(text
, text_urlsafe_B
) == 0);
172 CU_ASSERT_EQUAL(strlen(text
), strlen(text_urlsafe_B
));
174 ret
= spdk_base64_urlsafe_encode(text
, raw_C
, sizeof(raw_C
));
175 CU_ASSERT_EQUAL(ret
, 0);
176 CU_ASSERT(strcmp(text
, text_urlsafe_C
) == 0);
178 ret
= spdk_base64_urlsafe_encode(text
, raw_D
, sizeof(raw_D
));
179 CU_ASSERT_EQUAL(ret
, 0);
180 CU_ASSERT(strcmp(text
, text_urlsafe_D
) == 0);
182 ret
= spdk_base64_urlsafe_encode(NULL
, raw_A
, sizeof(raw_A
));
183 CU_ASSERT_EQUAL(ret
, -EINVAL
);
184 ret
= spdk_base64_urlsafe_encode(text
, NULL
, sizeof(raw_A
));
185 CU_ASSERT_EQUAL(ret
, -EINVAL
);
186 ret
= spdk_base64_urlsafe_encode(text
, raw_A
, 0);
187 CU_ASSERT_EQUAL(ret
, -EINVAL
);
191 test_base64_urlsafe_decode(void)
194 void *raw
= (void *)raw_buf
;
198 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_A
);
199 CU_ASSERT_EQUAL(ret
, 0);
200 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_A
));
201 CU_ASSERT(memcmp(raw
, raw_A
, sizeof(raw_A
)) == 0);
203 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_urlsafe_B
);
204 CU_ASSERT_EQUAL(ret
, 0);
205 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_B
));
206 CU_ASSERT(memcmp(raw
, raw_B
, sizeof(raw_B
)) == 0);
208 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_urlsafe_C
);
209 CU_ASSERT_EQUAL(ret
, 0);
210 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_C
));
211 CU_ASSERT(memcmp(raw
, raw_C
, sizeof(raw_C
)) == 0);
213 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_urlsafe_D
);
214 CU_ASSERT_EQUAL(ret
, 0);
215 CU_ASSERT_EQUAL(raw_len
, sizeof(raw_D
));
216 CU_ASSERT(memcmp(raw
, raw_D
, sizeof(raw_D
)) == 0);
218 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_E
);
219 CU_ASSERT_EQUAL(ret
, -EINVAL
);
220 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_F
);
221 CU_ASSERT_EQUAL(ret
, -EINVAL
);
222 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_G
);
223 CU_ASSERT_EQUAL(ret
, -EINVAL
);
224 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, text_H
);
225 CU_ASSERT_EQUAL(ret
, -EINVAL
);
226 ret
= spdk_base64_urlsafe_decode(NULL
, &raw_len
, text_H
);
227 CU_ASSERT_EQUAL(ret
, -EINVAL
);
228 ret
= spdk_base64_urlsafe_decode(raw
, &raw_len
, NULL
);
229 CU_ASSERT_EQUAL(ret
, -EINVAL
);
233 main(int argc
, char **argv
)
235 CU_pSuite suite
= NULL
;
236 unsigned int num_failures
;
238 if (CU_initialize_registry() != CUE_SUCCESS
) {
239 return CU_get_error();
242 suite
= CU_add_suite("base64", NULL
, NULL
);
244 CU_cleanup_registry();
245 return CU_get_error();
249 CU_add_test(suite
, "test_base64_get_encoded_strlen", test_base64_get_encoded_strlen
) == NULL
||
250 CU_add_test(suite
, "test_base64_get_decoded_len",
251 test_base64_get_decoded_len
) == NULL
||
252 CU_add_test(suite
, "test_base64_encode", test_base64_encode
) == NULL
||
253 CU_add_test(suite
, "test_base64_decode", test_base64_decode
) == NULL
||
254 CU_add_test(suite
, "test_base64_urlsafe_encode", test_base64_urlsafe_encode
) == NULL
||
255 CU_add_test(suite
, "test_base64_urlsafe_decode", test_base64_urlsafe_decode
) == NULL
) {
256 CU_cleanup_registry();
257 return CU_get_error();
260 CU_basic_set_mode(CU_BRM_VERBOSE
);
262 CU_basic_run_tests();
264 num_failures
= CU_get_number_of_failures();
265 CU_cleanup_registry();