1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 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 16 * distribution. 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. 20 * 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. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "spdk_cunit.h" 37 38 #include "util/base64.c" 39 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"; 55 56 static void 57 test_base64_get_encoded_strlen(void) 58 { 59 uint32_t raw_lens[4] = {8, 9, 10, 11}; 60 uint32_t text_strlens[4] = {12, 12, 16, 16}; 61 uint32_t text_strlen; 62 int i; 63 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]); 67 } 68 } 69 70 static void 71 test_base64_get_decoded_len(void) 72 { 73 uint32_t text_strlens[4] = {8, 10, 11, 12}; 74 uint32_t raw_lens[4] = {6, 7, 8, 9}; 75 uint32_t bin_len; 76 int i; 77 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]); 81 } 82 } 83 84 static void 85 test_base64_encode(void) 86 { 87 char text[100]; 88 int ret; 89 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)); 94 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)); 99 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); 103 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); 107 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); 114 } 115 116 static void 117 test_base64_decode(void) 118 { 119 char raw_buf[100]; 120 void *raw = (void *)raw_buf; 121 size_t raw_len; 122 int ret; 123 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); 128 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); 133 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); 138 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); 143 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); 156 } 157 158 static void 159 test_base64_urlsafe_encode(void) 160 { 161 char text[100]; 162 int ret; 163 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)); 168 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)); 173 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); 177 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); 181 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); 188 } 189 190 static void 191 test_base64_urlsafe_decode(void) 192 { 193 char raw_buf[100]; 194 void *raw = (void *)raw_buf; 195 size_t raw_len = 0; 196 int ret; 197 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); 202 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); 207 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); 212 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); 217 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); 230 } 231 232 int 233 main(int argc, char **argv) 234 { 235 CU_pSuite suite = NULL; 236 unsigned int num_failures; 237 238 if (CU_initialize_registry() != CUE_SUCCESS) { 239 return CU_get_error(); 240 } 241 242 suite = CU_add_suite("base64", NULL, NULL); 243 if (suite == NULL) { 244 CU_cleanup_registry(); 245 return CU_get_error(); 246 } 247 248 if ( 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(); 258 } 259 260 CU_basic_set_mode(CU_BRM_VERBOSE); 261 262 CU_basic_run_tests(); 263 264 num_failures = CU_get_number_of_failures(); 265 CU_cleanup_registry(); 266 267 return num_failures; 268 } 269