1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * KUnit test for struct string_stream. 4 * 5 * Copyright (C) 2019, Google LLC. 6 * Author: Brendan Higgins <brendanhiggins@google.com> 7 */ 8 9 #include <kunit/static_stub.h> 10 #include <kunit/test.h> 11 #include <linux/ktime.h> 12 #include <linux/slab.h> 13 #include <linux/timekeeping.h> 14 15 #include "string-stream.h" 16 17 struct string_stream_test_priv { 18 /* For testing resource-managed free. */ 19 struct string_stream *expected_free_stream; 20 bool stream_was_freed; 21 bool stream_free_again; 22 }; 23 24 /* Avoids a cast warning if kfree() is passed direct to kunit_add_action(). */ 25 static void kfree_wrapper(void *p) 26 { 27 kfree(p); 28 } 29 30 /* Avoids a cast warning if string_stream_destroy() is passed direct to kunit_add_action(). */ 31 static void cleanup_raw_stream(void *p) 32 { 33 struct string_stream *stream = p; 34 35 string_stream_destroy(stream); 36 } 37 38 static char *get_concatenated_string(struct kunit *test, struct string_stream *stream) 39 { 40 char *str = string_stream_get_string(stream); 41 42 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, str); 43 kunit_add_action(test, kfree_wrapper, (void *)str); 44 45 return str; 46 } 47 48 /* Managed string_stream object is initialized correctly. */ 49 static void string_stream_managed_init_test(struct kunit *test) 50 { 51 struct string_stream *stream; 52 53 /* Resource-managed initialization. */ 54 stream = kunit_alloc_string_stream(test, GFP_KERNEL); 55 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 56 57 KUNIT_EXPECT_EQ(test, stream->length, 0); 58 KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); 59 KUNIT_EXPECT_TRUE(test, (stream->gfp == GFP_KERNEL)); 60 KUNIT_EXPECT_FALSE(test, stream->append_newlines); 61 KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); 62 } 63 64 /* Unmanaged string_stream object is initialized correctly. */ 65 static void string_stream_unmanaged_init_test(struct kunit *test) 66 { 67 struct string_stream *stream; 68 69 stream = alloc_string_stream(GFP_KERNEL); 70 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 71 kunit_add_action(test, cleanup_raw_stream, stream); 72 73 KUNIT_EXPECT_EQ(test, stream->length, 0); 74 KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); 75 KUNIT_EXPECT_EQ(test, stream->gfp, GFP_KERNEL); 76 KUNIT_EXPECT_FALSE(test, stream->append_newlines); 77 78 KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); 79 } 80 81 static void string_stream_destroy_stub(struct string_stream *stream) 82 { 83 struct kunit *fake_test = kunit_get_current_test(); 84 struct string_stream_test_priv *priv = fake_test->priv; 85 86 /* The kunit could own string_streams other than the one we are testing. */ 87 if (stream == priv->expected_free_stream) { 88 if (priv->stream_was_freed) 89 priv->stream_free_again = true; 90 else 91 priv->stream_was_freed = true; 92 } 93 94 /* 95 * Calling string_stream_destroy() will only call this function again 96 * because the redirection stub is still active. 97 * Avoid calling deactivate_static_stub() or changing current->kunit_test 98 * during cleanup. 99 */ 100 string_stream_clear(stream); 101 kfree(stream); 102 } 103 104 /* kunit_free_string_stream() calls string_stream_desrtoy() */ 105 static void string_stream_managed_free_test(struct kunit *test) 106 { 107 struct string_stream_test_priv *priv = test->priv; 108 109 priv->expected_free_stream = NULL; 110 priv->stream_was_freed = false; 111 priv->stream_free_again = false; 112 113 kunit_activate_static_stub(test, 114 string_stream_destroy, 115 string_stream_destroy_stub); 116 117 priv->expected_free_stream = kunit_alloc_string_stream(test, GFP_KERNEL); 118 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->expected_free_stream); 119 120 /* This should call the stub function. */ 121 kunit_free_string_stream(test, priv->expected_free_stream); 122 123 KUNIT_EXPECT_TRUE(test, priv->stream_was_freed); 124 KUNIT_EXPECT_FALSE(test, priv->stream_free_again); 125 } 126 127 /* string_stream object is freed when test is cleaned up. */ 128 static void string_stream_resource_free_test(struct kunit *test) 129 { 130 struct string_stream_test_priv *priv = test->priv; 131 struct kunit *fake_test; 132 133 fake_test = kunit_kzalloc(test, sizeof(*fake_test), GFP_KERNEL); 134 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, fake_test); 135 136 kunit_init_test(fake_test, "string_stream_fake_test", NULL); 137 fake_test->priv = priv; 138 139 /* 140 * Activate stub before creating string_stream so the 141 * string_stream will be cleaned up first. 142 */ 143 priv->expected_free_stream = NULL; 144 priv->stream_was_freed = false; 145 priv->stream_free_again = false; 146 147 kunit_activate_static_stub(fake_test, 148 string_stream_destroy, 149 string_stream_destroy_stub); 150 151 priv->expected_free_stream = kunit_alloc_string_stream(fake_test, GFP_KERNEL); 152 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->expected_free_stream); 153 154 /* Set current->kunit_test to fake_test so the static stub will be called. */ 155 current->kunit_test = fake_test; 156 157 /* Cleanup test - the stub function should be called */ 158 kunit_cleanup(fake_test); 159 160 /* Set current->kunit_test back to current test. */ 161 current->kunit_test = test; 162 163 KUNIT_EXPECT_TRUE(test, priv->stream_was_freed); 164 KUNIT_EXPECT_FALSE(test, priv->stream_free_again); 165 } 166 167 /* 168 * Add a series of lines to a string_stream. Check that all lines 169 * appear in the correct order and no characters are dropped. 170 */ 171 static void string_stream_line_add_test(struct kunit *test) 172 { 173 struct string_stream *stream; 174 char line[60]; 175 char *concat_string, *pos, *string_end; 176 size_t len, total_len; 177 int num_lines, i; 178 179 stream = kunit_alloc_string_stream(test, GFP_KERNEL); 180 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 181 182 /* Add series of sequence numbered lines */ 183 total_len = 0; 184 for (i = 0; i < 100; ++i) { 185 len = snprintf(line, sizeof(line), 186 "The quick brown fox jumps over the lazy penguin %d\n", i); 187 188 /* Sanity-check that our test string isn't truncated */ 189 KUNIT_ASSERT_LT(test, len, sizeof(line)); 190 191 string_stream_add(stream, line); 192 total_len += len; 193 } 194 num_lines = i; 195 196 concat_string = get_concatenated_string(test, stream); 197 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, concat_string); 198 KUNIT_EXPECT_EQ(test, strlen(concat_string), total_len); 199 200 /* 201 * Split the concatenated string at the newlines and check that 202 * all the original added strings are present. 203 */ 204 pos = concat_string; 205 for (i = 0; i < num_lines; ++i) { 206 string_end = strchr(pos, '\n'); 207 KUNIT_EXPECT_NOT_NULL(test, string_end); 208 209 /* Convert to NULL-terminated string */ 210 *string_end = '\0'; 211 212 snprintf(line, sizeof(line), 213 "The quick brown fox jumps over the lazy penguin %d", i); 214 KUNIT_EXPECT_STREQ(test, pos, line); 215 216 pos = string_end + 1; 217 } 218 219 /* There shouldn't be any more data after this */ 220 KUNIT_EXPECT_EQ(test, strlen(pos), 0); 221 } 222 223 /* Add a series of lines of variable length to a string_stream. */ 224 static void string_stream_variable_length_line_test(struct kunit *test) 225 { 226 static const char line[] = 227 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 228 " 0123456789!$%^&*()_-+={}[]:;@'~#<>,.?/|"; 229 struct string_stream *stream; 230 struct rnd_state rnd; 231 char *concat_string, *pos, *string_end; 232 size_t offset, total_len; 233 int num_lines, i; 234 235 stream = kunit_alloc_string_stream(test, GFP_KERNEL); 236 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 237 238 /* 239 * Log many lines of varying lengths until we have created 240 * many fragments. 241 * The "randomness" must be repeatable. 242 */ 243 prandom_seed_state(&rnd, 3141592653589793238ULL); 244 total_len = 0; 245 for (i = 0; i < 100; ++i) { 246 offset = prandom_u32_state(&rnd) % (sizeof(line) - 1); 247 string_stream_add(stream, "%s\n", &line[offset]); 248 total_len += sizeof(line) - offset; 249 } 250 num_lines = i; 251 252 concat_string = get_concatenated_string(test, stream); 253 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, concat_string); 254 KUNIT_EXPECT_EQ(test, strlen(concat_string), total_len); 255 256 /* 257 * Split the concatenated string at the newlines and check that 258 * all the original added strings are present. 259 */ 260 prandom_seed_state(&rnd, 3141592653589793238ULL); 261 pos = concat_string; 262 for (i = 0; i < num_lines; ++i) { 263 string_end = strchr(pos, '\n'); 264 KUNIT_EXPECT_NOT_NULL(test, string_end); 265 266 /* Convert to NULL-terminated string */ 267 *string_end = '\0'; 268 269 offset = prandom_u32_state(&rnd) % (sizeof(line) - 1); 270 KUNIT_EXPECT_STREQ(test, pos, &line[offset]); 271 272 pos = string_end + 1; 273 } 274 275 /* There shouldn't be any more data after this */ 276 KUNIT_EXPECT_EQ(test, strlen(pos), 0); 277 } 278 279 /* Appending the content of one string stream to another. */ 280 static void string_stream_append_test(struct kunit *test) 281 { 282 static const char * const strings_1[] = { 283 "one", "two", "three", "four", "five", "six", 284 "seven", "eight", "nine", "ten", 285 }; 286 static const char * const strings_2[] = { 287 "Apple", "Pear", "Orange", "Banana", "Grape", "Apricot", 288 }; 289 struct string_stream *stream_1, *stream_2; 290 const char *stream1_content_before_append, *stream_2_content; 291 char *combined_content; 292 size_t combined_length; 293 int i; 294 295 stream_1 = kunit_alloc_string_stream(test, GFP_KERNEL); 296 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); 297 298 stream_2 = kunit_alloc_string_stream(test, GFP_KERNEL); 299 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); 300 301 /* Append content of empty stream to empty stream */ 302 string_stream_append(stream_1, stream_2); 303 KUNIT_EXPECT_EQ(test, strlen(get_concatenated_string(test, stream_1)), 0); 304 305 /* Add some data to stream_1 */ 306 for (i = 0; i < ARRAY_SIZE(strings_1); ++i) 307 string_stream_add(stream_1, "%s\n", strings_1[i]); 308 309 stream1_content_before_append = get_concatenated_string(test, stream_1); 310 311 /* Append content of empty stream to non-empty stream */ 312 string_stream_append(stream_1, stream_2); 313 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), 314 stream1_content_before_append); 315 316 /* Add some data to stream_2 */ 317 for (i = 0; i < ARRAY_SIZE(strings_2); ++i) 318 string_stream_add(stream_2, "%s\n", strings_2[i]); 319 320 /* Append content of non-empty stream to non-empty stream */ 321 string_stream_append(stream_1, stream_2); 322 323 /* 324 * End result should be the original content of stream_1 plus 325 * the content of stream_2. 326 */ 327 stream_2_content = get_concatenated_string(test, stream_2); 328 combined_length = strlen(stream1_content_before_append) + strlen(stream_2_content); 329 combined_length++; /* for terminating \0 */ 330 combined_content = kunit_kmalloc(test, combined_length, GFP_KERNEL); 331 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, combined_content); 332 snprintf(combined_content, combined_length, "%s%s", 333 stream1_content_before_append, stream_2_content); 334 335 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), combined_content); 336 337 /* Append content of non-empty stream to empty stream */ 338 kunit_free_string_stream(test, stream_1); 339 340 stream_1 = kunit_alloc_string_stream(test, GFP_KERNEL); 341 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); 342 343 string_stream_append(stream_1, stream_2); 344 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), stream_2_content); 345 } 346 347 /* Appending the content of one string stream to one with auto-newlining. */ 348 static void string_stream_append_auto_newline_test(struct kunit *test) 349 { 350 struct string_stream *stream_1, *stream_2; 351 352 /* Stream 1 has newline appending enabled */ 353 stream_1 = kunit_alloc_string_stream(test, GFP_KERNEL); 354 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_1); 355 string_stream_set_append_newlines(stream_1, true); 356 KUNIT_EXPECT_TRUE(test, stream_1->append_newlines); 357 358 /* Stream 2 does not append newlines */ 359 stream_2 = kunit_alloc_string_stream(test, GFP_KERNEL); 360 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); 361 362 /* Appending a stream with a newline should not add another newline */ 363 string_stream_add(stream_1, "Original string\n"); 364 string_stream_add(stream_2, "Appended content\n"); 365 string_stream_add(stream_2, "More stuff\n"); 366 string_stream_append(stream_1, stream_2); 367 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), 368 "Original string\nAppended content\nMore stuff\n"); 369 370 kunit_free_string_stream(test, stream_2); 371 stream_2 = kunit_alloc_string_stream(test, GFP_KERNEL); 372 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream_2); 373 374 /* 375 * Appending a stream without newline should add a final newline. 376 * The appended string_stream is treated as a single string so newlines 377 * should not be inserted between fragments. 378 */ 379 string_stream_add(stream_2, "Another"); 380 string_stream_add(stream_2, "And again"); 381 string_stream_append(stream_1, stream_2); 382 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream_1), 383 "Original string\nAppended content\nMore stuff\nAnotherAnd again\n"); 384 } 385 386 /* Adding an empty string should not create a fragment. */ 387 static void string_stream_append_empty_string_test(struct kunit *test) 388 { 389 struct string_stream *stream; 390 int original_frag_count; 391 392 stream = kunit_alloc_string_stream(test, GFP_KERNEL); 393 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 394 395 /* Formatted empty string */ 396 string_stream_add(stream, "%s", ""); 397 KUNIT_EXPECT_TRUE(test, string_stream_is_empty(stream)); 398 KUNIT_EXPECT_TRUE(test, list_empty(&stream->fragments)); 399 400 /* Adding an empty string to a non-empty stream */ 401 string_stream_add(stream, "Add this line"); 402 original_frag_count = list_count_nodes(&stream->fragments); 403 404 string_stream_add(stream, "%s", ""); 405 KUNIT_EXPECT_EQ(test, list_count_nodes(&stream->fragments), original_frag_count); 406 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream), "Add this line"); 407 } 408 409 /* Adding strings without automatic newline appending */ 410 static void string_stream_no_auto_newline_test(struct kunit *test) 411 { 412 struct string_stream *stream; 413 414 stream = kunit_alloc_string_stream(test, GFP_KERNEL); 415 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 416 417 /* 418 * Add some strings with and without newlines. All formatted newlines 419 * should be preserved. It should not add any extra newlines. 420 */ 421 string_stream_add(stream, "One"); 422 string_stream_add(stream, "Two\n"); 423 string_stream_add(stream, "%s\n", "Three"); 424 string_stream_add(stream, "%s", "Four\n"); 425 string_stream_add(stream, "Five\n%s", "Six"); 426 string_stream_add(stream, "Seven\n\n"); 427 string_stream_add(stream, "Eight"); 428 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream), 429 "OneTwo\nThree\nFour\nFive\nSixSeven\n\nEight"); 430 } 431 432 /* Adding strings with automatic newline appending */ 433 static void string_stream_auto_newline_test(struct kunit *test) 434 { 435 struct string_stream *stream; 436 437 stream = kunit_alloc_string_stream(test, GFP_KERNEL); 438 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 439 440 string_stream_set_append_newlines(stream, true); 441 KUNIT_EXPECT_TRUE(test, stream->append_newlines); 442 443 /* 444 * Add some strings with and without newlines. Newlines should 445 * be appended to lines that do not end with \n, but newlines 446 * resulting from the formatting should not be changed. 447 */ 448 string_stream_add(stream, "One"); 449 string_stream_add(stream, "Two\n"); 450 string_stream_add(stream, "%s\n", "Three"); 451 string_stream_add(stream, "%s", "Four\n"); 452 string_stream_add(stream, "Five\n%s", "Six"); 453 string_stream_add(stream, "Seven\n\n"); 454 string_stream_add(stream, "Eight"); 455 KUNIT_EXPECT_STREQ(test, get_concatenated_string(test, stream), 456 "One\nTwo\nThree\nFour\nFive\nSix\nSeven\n\nEight\n"); 457 } 458 459 /* 460 * This doesn't actually "test" anything. It reports time taken 461 * and memory used for logging a large number of lines. 462 */ 463 static void string_stream_performance_test(struct kunit *test) 464 { 465 struct string_stream_fragment *frag_container; 466 struct string_stream *stream; 467 char test_line[101]; 468 ktime_t start_time, end_time; 469 size_t len, bytes_requested, actual_bytes_used, total_string_length; 470 int offset, i; 471 472 stream = kunit_alloc_string_stream(test, GFP_KERNEL); 473 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, stream); 474 475 memset(test_line, 'x', sizeof(test_line) - 1); 476 test_line[sizeof(test_line) - 1] = '\0'; 477 478 start_time = ktime_get(); 479 for (i = 0; i < 10000; i++) { 480 offset = i % (sizeof(test_line) - 1); 481 string_stream_add(stream, "%s: %d\n", &test_line[offset], i); 482 } 483 end_time = ktime_get(); 484 485 /* 486 * Calculate memory used. This doesn't include invisible 487 * overhead due to kernel allocator fragment size rounding. 488 */ 489 bytes_requested = sizeof(*stream); 490 actual_bytes_used = ksize(stream); 491 total_string_length = 0; 492 493 list_for_each_entry(frag_container, &stream->fragments, node) { 494 bytes_requested += sizeof(*frag_container); 495 actual_bytes_used += ksize(frag_container); 496 497 len = strlen(frag_container->fragment); 498 total_string_length += len; 499 bytes_requested += len + 1; /* +1 for '\0' */ 500 actual_bytes_used += ksize(frag_container->fragment); 501 } 502 503 kunit_info(test, "Time elapsed: %lld us\n", 504 ktime_us_delta(end_time, start_time)); 505 kunit_info(test, "Total string length: %zu\n", total_string_length); 506 kunit_info(test, "Bytes requested: %zu\n", bytes_requested); 507 kunit_info(test, "Actual bytes allocated: %zu\n", actual_bytes_used); 508 } 509 510 static int string_stream_test_init(struct kunit *test) 511 { 512 struct string_stream_test_priv *priv; 513 514 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL); 515 if (!priv) 516 return -ENOMEM; 517 518 test->priv = priv; 519 520 return 0; 521 } 522 523 static struct kunit_case string_stream_test_cases[] = { 524 KUNIT_CASE(string_stream_managed_init_test), 525 KUNIT_CASE(string_stream_unmanaged_init_test), 526 KUNIT_CASE(string_stream_managed_free_test), 527 KUNIT_CASE(string_stream_resource_free_test), 528 KUNIT_CASE(string_stream_line_add_test), 529 KUNIT_CASE(string_stream_variable_length_line_test), 530 KUNIT_CASE(string_stream_append_test), 531 KUNIT_CASE(string_stream_append_auto_newline_test), 532 KUNIT_CASE(string_stream_append_empty_string_test), 533 KUNIT_CASE(string_stream_no_auto_newline_test), 534 KUNIT_CASE(string_stream_auto_newline_test), 535 KUNIT_CASE(string_stream_performance_test), 536 {} 537 }; 538 539 static struct kunit_suite string_stream_test_suite = { 540 .name = "string-stream-test", 541 .test_cases = string_stream_test_cases, 542 .init = string_stream_test_init, 543 }; 544 kunit_test_suites(&string_stream_test_suite); 545