Merge pull request #1182 from smackers/fix-undef-aws

dbeyer · web-flow · commit 3e240289a109 · 2020-10-27T18:30:09.000+01:00
Fix undefined behaviors in AWS
diff --git a/c/aws-c-common/aws_array_eq_c_str_harness.i b/c/aws-c-common/aws_array_eq_c_str_harness.i
@@ -9112,7 +9112,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 void aws_array_eq_c_str_harness() {
 
     void *array;
-    size_t array_len;
+    size_t array_len = __VERIFIER_nondet_ulong();
     assume_abort_if_not(array_len <= 10);
     array = can_fail_malloc(array_len);
     const char *c_str = nondet_bool() ? 
diff --git a/c/aws-c-common/aws_array_eq_c_str_ignore_case_harness.i b/c/aws-c-common/aws_array_eq_c_str_ignore_case_harness.i
@@ -9111,7 +9111,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_eq_c_str_ignore_case_harness() {
 
-    size_t array_len;
+    size_t array_len = __VERIFIER_nondet_ulong();
     assume_abort_if_not(array_len <= 10);
     void *array = can_fail_malloc(array_len);
     const char *c_str = nondet_bool() ? 
diff --git a/c/aws-c-common/aws_array_eq_harness.i b/c/aws-c-common/aws_array_eq_harness.i
@@ -9111,12 +9111,12 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_eq_harness() {
 
-    size_t lhs_len;
+    size_t lhs_len = __VERIFIER_nondet_ulong();
     assume_abort_if_not(lhs_len <= 10);
     void *lhs = can_fail_malloc(lhs_len);
 
     void *rhs;
-    size_t rhs_len;
+    size_t rhs_len = __VERIFIER_nondet_ulong();
     if (nondet_bool()) {
         rhs_len = lhs_len;
         rhs = lhs;
diff --git a/c/aws-c-common/aws_array_eq_ignore_case_harness.i b/c/aws-c-common/aws_array_eq_ignore_case_harness.i
@@ -9111,12 +9111,12 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_eq_ignore_case_harness() {
 
-    size_t lhs_len;
+    size_t lhs_len = __VERIFIER_nondet_ulong();
     assume_abort_if_not(lhs_len <= 10);
     void *lhs = can_fail_malloc(lhs_len);
 
     void *rhs;
-    size_t rhs_len;
+    size_t rhs_len = __VERIFIER_nondet_ulong();
     if (nondet_bool()) {
         rhs_len = lhs_len;
         rhs = lhs;
diff --git a/c/aws-c-common/aws_array_list_back_harness.i b/c/aws-c-common/aws_array_list_back_harness.i
@@ -8014,7 +8014,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 void aws_array_list_back_harness() {
 
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_capacity_harness.i b/c/aws-c-common/aws_array_list_capacity_harness.i
@@ -7991,7 +7991,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_capacity_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_clean_up_harness.i b/c/aws-c-common/aws_array_list_clean_up_harness.i
@@ -7772,7 +7772,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_clean_up_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_clear_harness.i b/c/aws-c-common/aws_array_list_clear_harness.i
@@ -7772,7 +7772,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_clear_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_comparator_string_harness.i b/c/aws-c-common/aws_array_list_comparator_string_harness.i
@@ -9881,10 +9881,10 @@ void aws_array_list_comparator_string_harness() {
     struct aws_string *str_b = nondet_bool() ? str_a : ensure_string_is_allocated_bounded_length(16);
     
    _Bool 
-        nondet_parameter_a;
+        nondet_parameter_a = nondet_bool();
     
    _Bool 
-        nondet_parameter_b;
+        nondet_parameter_b = nondet_bool();
     if (aws_array_list_comparator_string(nondet_parameter_a ? &str_a : 
                                                                       ((void *)0)
                                                                           , nondet_parameter_b ? &str_b : 
diff --git a/c/aws-c-common/aws_array_list_ensure_capacity_harness.i b/c/aws-c-common/aws_array_list_ensure_capacity_harness.i
@@ -8019,7 +8019,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_ensure_capacity_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_erase_harness.i b/c/aws-c-common/aws_array_list_erase_harness.i
@@ -8069,7 +8069,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_erase_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
     size_t index;
 
 
diff --git a/c/aws-c-common/aws_array_list_front_harness.i b/c/aws-c-common/aws_array_list_front_harness.i
@@ -8011,7 +8011,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_front_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_get_at_harness.i b/c/aws-c-common/aws_array_list_get_at_harness.i
@@ -8013,7 +8013,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_get_at_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_get_at_ptr_harness.i b/c/aws-c-common/aws_array_list_get_at_ptr_harness.i
@@ -8013,7 +8013,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_get_at_ptr_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_init_dynamic_harness.i b/c/aws-c-common/aws_array_list_init_dynamic_harness.i
@@ -7772,7 +7772,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_init_dynamic_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     struct aws_allocator *allocator = can_fail_allocator();
diff --git a/c/aws-c-common/aws_array_list_init_static_harness.i b/c/aws-c-common/aws_array_list_init_static_harness.i
@@ -7602,7 +7602,7 @@ void aws_array_list_swap(struct aws_array_list *restrict list, size_t a, size_t
 }
 void aws_array_list_init_static_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     size_t item_size;
diff --git a/c/aws-c-common/aws_array_list_length_harness.i b/c/aws-c-common/aws_array_list_length_harness.i
@@ -7991,7 +7991,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_length_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_pop_back_harness.i b/c/aws-c-common/aws_array_list_pop_back_harness.i
@@ -8013,7 +8013,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_pop_back_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_pop_front_harness.i b/c/aws-c-common/aws_array_list_pop_front_harness.i
@@ -8009,7 +8009,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_pop_front_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_pop_front_n_harness.i b/c/aws-c-common/aws_array_list_pop_front_n_harness.i
@@ -8009,7 +8009,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_pop_front_n_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
@@ -8022,7 +8022,7 @@ void aws_array_list_pop_front_n_harness() {
     save_byte_from_array((uint8_t *)list.data, list.current_size, &old_byte);
 
 
-    size_t n;
+    size_t n = __VERIFIER_nondet_ulong();
     aws_array_list_pop_front_n(&list, n);
 
 
diff --git a/c/aws-c-common/aws_array_list_push_back_harness.i b/c/aws-c-common/aws_array_list_push_back_harness.i
@@ -8014,7 +8014,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_push_back_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_set_at_harness.i b/c/aws-c-common/aws_array_list_set_at_harness.i
@@ -8014,7 +8014,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_set_at_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_shrink_to_fit_harness.i b/c/aws-c-common/aws_array_list_shrink_to_fit_harness.i
@@ -8055,15 +8055,15 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_shrink_to_fit_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
     ensure_array_list_has_allocated_data_member(&list);
     assume_abort_if_not(aws_array_list_is_valid(&list));
 
 
-    size_t n;
+    size_t n = __VERIFIER_nondet_ulong();
     aws_array_list_pop_front_n(&list, n);
 
 
diff --git a/c/aws-c-common/aws_array_list_sort_harness.i b/c/aws-c-common/aws_array_list_sort_harness.i
@@ -8011,7 +8011,7 @@ int compare(const void *a, const void *b, size_t item_size) {
 
 void aws_array_list_sort_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_array_list_swap_harness.i b/c/aws-c-common/aws_array_list_swap_harness.i
@@ -8019,11 +8019,11 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_array_list_swap_harness() {
 
-    struct aws_array_list list;
+    struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};
 
 
-    size_t index_a;
-    size_t index_b;
+    size_t index_a = __VERIFIER_nondet_ulong();
+    size_t index_b = __VERIFIER_nondet_ulong();
 
 
     assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));
diff --git a/c/aws-c-common/aws_byte_buf_advance_harness.i b/c/aws-c-common/aws_byte_buf_advance_harness.i
@@ -9112,9 +9112,9 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_buf_advance_harness() {
 
-    struct aws_byte_buf buf;
-    struct aws_byte_buf output;
-    size_t len;
+    struct aws_byte_buf buf = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
+    struct aws_byte_buf output = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
+    size_t len = __VERIFIER_nondet_ulong();
 
 
     assume_abort_if_not(aws_byte_buf_is_bounded(&buf, 40));
diff --git a/c/aws-c-common/aws_byte_buf_cat_harness.i b/c/aws-c-common/aws_byte_buf_cat_harness.i
@@ -9111,10 +9111,10 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_buf_cat_harness() {
 
-    struct aws_byte_buf buffer1;
-    struct aws_byte_buf buffer2;
-    struct aws_byte_buf buffer3;
-    struct aws_byte_buf dest;
+    struct aws_byte_buf buffer1 = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
+    struct aws_byte_buf buffer2 = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
+    struct aws_byte_buf buffer3 = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
+    struct aws_byte_buf dest = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
     size_t number_of_args = 3;
 
 
diff --git a/c/aws-c-common/aws_byte_buf_eq_c_str_harness.i b/c/aws-c-common/aws_byte_buf_eq_c_str_harness.i
@@ -9111,7 +9111,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_buf_eq_c_str_harness() {
 
-    struct aws_byte_buf buf;
+    struct aws_byte_buf buf = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
     const char *c_str = ensure_c_str_is_allocated(10);
 
 
diff --git a/c/aws-c-common/aws_byte_buf_eq_c_str_ignore_case_harness.i b/c/aws-c-common/aws_byte_buf_eq_c_str_ignore_case_harness.i
@@ -9111,7 +9111,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_buf_eq_c_str_ignore_case_harness() {
 
-    struct aws_byte_buf buf;
+    struct aws_byte_buf buf = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
     const char *c_str = ensure_c_str_is_allocated(10);
 
 
diff --git a/c/aws-c-common/aws_byte_buf_write_from_whole_string_harness.i b/c/aws-c-common/aws_byte_buf_write_from_whole_string_harness.i
@@ -9880,7 +9880,7 @@ void aws_byte_buf_write_from_whole_string_harness() {
     struct aws_string *str = nondet_bool() ? ensure_string_is_allocated_bounded_length(16) : 
                                                                                                         ((void *)0)
                                                                                                             ;
-    struct aws_byte_buf buf;
+    struct aws_byte_buf buf = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
 
     ensure_byte_buf_has_allocated_buffer_member(&buf);
     assume_abort_if_not(aws_byte_buf_is_valid(&buf));
diff --git a/c/aws-c-common/aws_byte_buf_write_harness.i b/c/aws-c-common/aws_byte_buf_write_harness.i
@@ -9090,8 +9090,8 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_buf_write_harness() {
 
-    struct aws_byte_buf buf;
-    size_t len;
+    struct aws_byte_buf buf = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
+    size_t len = __VERIFIER_nondet_ulong();
     uint8_t *array = bounded_malloc(len);
 
 
diff --git a/c/aws-c-common/aws_byte_cursor_advance_harness.i b/c/aws-c-common/aws_byte_cursor_advance_harness.i
@@ -9090,8 +9090,8 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_cursor_advance_harness() {
 
-    struct aws_byte_cursor cursor;
-    size_t len;
+    struct aws_byte_cursor cursor = {__VERIFIER_nondet_ulong(), 0};
+    size_t len = __VERIFIER_nondet_ulong();
 
 
     ensure_byte_cursor_has_allocated_buffer_member(&cursor);
diff --git a/c/aws-c-common/aws_byte_cursor_advance_nospec_harness.i b/c/aws-c-common/aws_byte_cursor_advance_nospec_harness.i
@@ -9090,8 +9090,8 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_cursor_advance_nospec_harness() {
 
-    struct aws_byte_cursor cursor;
-    size_t len;
+    struct aws_byte_cursor cursor = {__VERIFIER_nondet_ulong(), 0};
+    size_t len = __VERIFIER_nondet_ulong();
 
 
     ensure_byte_cursor_has_allocated_buffer_member(&cursor);
diff --git a/c/aws-c-common/aws_byte_cursor_from_buf_harness.i b/c/aws-c-common/aws_byte_cursor_from_buf_harness.i
@@ -9090,7 +9090,7 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_cursor_from_buf_harness() {
 
-    struct aws_byte_buf buf;
+    struct aws_byte_buf buf = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
 
 
     assume_abort_if_not(aws_byte_buf_is_bounded(&buf, 10));
diff --git a/c/aws-c-common/aws_byte_cursor_read_and_fill_buffer_harness.i b/c/aws-c-common/aws_byte_cursor_read_and_fill_buffer_harness.i
@@ -9090,8 +9090,8 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_cursor_read_and_fill_buffer_harness() {
 
-    struct aws_byte_cursor cur;
-    struct aws_byte_buf buf;
+    struct aws_byte_cursor cur = {__VERIFIER_nondet_ulong(), 0};
+    struct aws_byte_buf buf = {__VERIFIER_nondet_ulong(), 0, __VERIFIER_nondet_ulong(), 0};
 
 
     ensure_byte_cursor_has_allocated_buffer_member(&cur);
diff --git a/c/aws-c-common/aws_byte_cursor_read_be16_harness.i b/c/aws-c-common/aws_byte_cursor_read_be16_harness.i
@@ -9090,8 +9090,8 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_cursor_read_common_harness() {
 
-    struct aws_byte_cursor cur;
-    size_t length;
+    struct aws_byte_cursor cur = {__VERIFIER_nondet_ulong(), 0};
+    size_t length = __VERIFIER_nondet_ulong();
     uint16_t *dest = can_fail_malloc(length);
 
 
diff --git a/c/aws-c-common/aws_byte_cursor_read_be32_harness.i b/c/aws-c-common/aws_byte_cursor_read_be32_harness.i
@@ -9090,8 +9090,8 @@ void aws_common_fatal_assert_library_initialized(void) {
 }
 void aws_byte_cursor_read_common_harness() {
 
-    struct aws_byte_cursor cur;
-    size_t length;
+    struct aws_byte_cursor cur = {__VERIFIER_nondet_ulong(), 0};
+    size_t length = __VERIFIER_nondet_ulong();
     uint32_t *dest = can_fail_malloc(length);
 
 
diff --git a/c/aws-c-common/aws_byte_cursor_read_be64_harness.i b/c/aws-c-common/aws_byte_cursor_read_be64_harness.i
diff --git a/c/aws-c-common/aws_byte_cursor_read_harness.i b/c/aws-c-common/aws_byte_cursor_read_harness.i
diff --git a/c/aws-c-common/aws_byte_cursor_read_u8_harness.i b/c/aws-c-common/aws_byte_cursor_read_u8_harness.i
diff --git a/c/aws-c-common/aws_hash_iter_delete_harness.i b/c/aws-c-common/aws_hash_iter_delete_harness.i
diff --git a/c/aws-c-common/aws_hash_iter_done_harness.i b/c/aws-c-common/aws_hash_iter_done_harness.i
diff --git a/c/aws-c-common/aws_hash_iter_next_harness.i b/c/aws-c-common/aws_hash_iter_next_harness.i
diff --git a/c/aws-c-common/aws_is_power_of_two_harness.i b/c/aws-c-common/aws_is_power_of_two_harness.i
diff --git a/c/aws-c-common/aws_nospec_mask_harness.i b/c/aws-c-common/aws_nospec_mask_harness.i
diff --git a/c/aws-c-common/aws_round_up_to_power_of_two_harness.i b/c/aws-c-common/aws_round_up_to_power_of_two_harness.i
diff --git a/c/aws-c-common/aws_string_eq_byte_buf_harness.i b/c/aws-c-common/aws_string_eq_byte_buf_harness.i
diff --git a/c/aws-c-common/aws_string_eq_byte_cursor_harness.i b/c/aws-c-common/aws_string_eq_byte_cursor_harness.i

Original file line number	Diff line number	Diff line change
`@@ -9111,7 +9111,7 @@ void aws_common_fatal_assert_library_initialized(void) {`
`9111`	`9111`	`}`
`9112`	`9112`	`void aws_array_eq_c_str_ignore_case_harness() {`
`9113`	`9113`
`9114`		`- size_t array_len;`
	`9114`	`+ size_t array_len = __VERIFIER_nondet_ulong();`
`9115`	`9115`	`assume_abort_if_not(array_len <= 10);`
`9116`	`9116`	`void *array = can_fail_malloc(array_len);`
`9117`	`9117`	`const char *c_str = nondet_bool() ?`
Original file line number	Diff line number	Diff line change
`@@ -7991,7 +7991,7 @@ void aws_common_fatal_assert_library_initialized(void) {`
`7991`	`7991`	`}`
`7992`	`7992`	`void aws_array_list_capacity_harness() {`
`7993`	`7993`
`7994`		`- struct aws_array_list list;`
	`7994`	`+ struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};`
`7995`	`7995`
`7996`	`7996`
`7997`	`7997`	`assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));`
Original file line number	Diff line number	Diff line change
`@@ -7772,7 +7772,7 @@ void aws_common_fatal_assert_library_initialized(void) {`
`7772`	`7772`	`}`
`7773`	`7773`	`void aws_array_list_clean_up_harness() {`
`7774`	`7774`
`7775`		`- struct aws_array_list list;`
	`7775`	`+ struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};`
`7776`	`7776`
`7777`	`7777`
`7778`	`7778`	`assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));`
Original file line number	Diff line number	Diff line change
`@@ -8019,7 +8019,7 @@ void aws_common_fatal_assert_library_initialized(void) {`
`8019`	`8019`	`}`
`8020`	`8020`	`void aws_array_list_ensure_capacity_harness() {`
`8021`	`8021`
`8022`		`- struct aws_array_list list;`
	`8022`	`+ struct aws_array_list list = {0, __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), __VERIFIER_nondet_ulong(), 0};`
`8023`	`8023`
`8024`	`8024`
`8025`	`8025`	`assume_abort_if_not(aws_array_list_is_bounded(&list, 9223372036854775808U, 2));`