aws-crt 0.1.5 → 0.1.6

data/aws-crt-ffi/crt/aws-c-common/source/file.c

@@ -12,6 +12,11 @@
 #include <errno.h>
 
 FILE *aws_fopen(const char *file_path, const char *mode) {
+    if (!file_path || strlen(file_path) == 0) {
+        AWS_LOGF_ERROR(AWS_LS_COMMON_IO, "static: Failed to open file %s", file_path);
+        return NULL;
+    }
+
     struct aws_string *file_path_str = aws_string_new_from_c_str(aws_default_allocator(), file_path);
     struct aws_string *mode_str = aws_string_new_from_c_str(aws_default_allocator(), mode);
 
@@ -23,6 +28,7 @@ FILE *aws_fopen(const char *file_path, const char *mode) {
 }
 
 int aws_byte_buf_init_from_file(struct aws_byte_buf *out_buf, struct aws_allocator *alloc, const char *filename) {
+
     AWS_ZERO_STRUCT(*out_buf);
     FILE *fp = aws_fopen(filename, "rb");
 
@@ -66,6 +72,9 @@ int aws_byte_buf_init_from_file(struct aws_byte_buf *out_buf, struct aws_allocat
 
     AWS_LOGF_ERROR(AWS_LS_COMMON_IO, "static: Failed to open file %s with errno %d", filename, errno);
 
+    if (errno == 0) {
+        return aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+    }
     return aws_translate_and_raise_io_error(errno);
 }
 

data/aws-crt-ffi/crt/aws-c-common/source/json.c

@@ -0,0 +1,348 @@
+/**
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0.
+ */
+
+#include <aws/common/byte_buf.h>
+#include <aws/common/string.h>
+
+#include <aws/common/json.h>
+#include <aws/common/private/json_impl.h>
+
+#include <aws/common/external/cJSON.h>
+
+static struct aws_allocator *s_aws_json_module_allocator = NULL;
+static bool s_aws_json_module_initialized = false;
+
+struct aws_json_value *aws_json_value_new_string(struct aws_allocator *allocator, struct aws_byte_cursor string) {
+    struct aws_string *tmp = aws_string_new_from_cursor((struct aws_allocator *)allocator, &string);
+    void *ret_val = cJSON_CreateString(aws_string_c_str(tmp));
+    aws_string_destroy_secure(tmp);
+    return ret_val;
+}
+
+struct aws_json_value *aws_json_value_new_number(struct aws_allocator *allocator, double number) {
+    (void)allocator; // prevent warnings over unused parameter
+    return (void *)cJSON_CreateNumber(number);
+}
+
+struct aws_json_value *aws_json_value_new_array(struct aws_allocator *allocator) {
+    (void)allocator; // prevent warnings over unused parameter
+    return (void *)cJSON_CreateArray();
+}
+
+struct aws_json_value *aws_json_value_new_boolean(struct aws_allocator *allocator, bool boolean) {
+    (void)allocator; // prevent warnings over unused parameter
+    return (void *)cJSON_CreateBool(boolean);
+}
+
+struct aws_json_value *aws_json_value_new_null(struct aws_allocator *allocator) {
+    (void)allocator; // prevent warnings over unused parameter
+    return (void *)cJSON_CreateNull();
+}
+
+struct aws_json_value *aws_json_value_new_object(struct aws_allocator *allocator) {
+    (void)allocator; // prevent warnings over unused parameter
+    return (void *)cJSON_CreateObject();
+}
+
+int aws_json_value_get_string(const struct aws_json_value *value, struct aws_byte_cursor *output) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (!cJSON_IsString(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+    *output = aws_byte_cursor_from_c_str(cJSON_GetStringValue(cjson));
+    return AWS_OP_SUCCESS;
+}
+
+int aws_json_value_get_number(const struct aws_json_value *value, double *output) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (!cJSON_IsNumber(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+    *output = cjson->valuedouble;
+    return AWS_OP_SUCCESS;
+}
+
+int aws_json_value_get_boolean(const struct aws_json_value *value, bool *output) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (!cJSON_IsBool(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+    *output = cjson->type == cJSON_True;
+    return AWS_OP_SUCCESS;
+}
+
+int aws_json_value_add_to_object(
+    struct aws_json_value *object,
+    struct aws_byte_cursor key,
+    struct aws_json_value *value) {
+
+    int result = AWS_OP_ERR;
+    struct aws_string *tmp = aws_string_new_from_cursor(s_aws_json_module_allocator, &key);
+
+    struct cJSON *cjson = (struct cJSON *)object;
+    if (!cJSON_IsObject(cjson)) {
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        goto done;
+    }
+
+    struct cJSON *cjson_value = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson_value)) {
+        result = aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        goto done;
+    }
+    if (cJSON_HasObjectItem(cjson, aws_string_c_str(tmp))) {
+        goto done;
+    }
+
+    cJSON_AddItemToObject(cjson, aws_string_c_str(tmp), cjson_value);
+    result = AWS_OP_SUCCESS;
+
+done:
+    aws_string_destroy_secure(tmp);
+    return result;
+}
+
+struct aws_json_value *aws_json_value_get_from_object(const struct aws_json_value *object, struct aws_byte_cursor key) {
+
+    void *return_value = NULL;
+    struct aws_string *tmp = aws_string_new_from_cursor(s_aws_json_module_allocator, &key);
+
+    struct cJSON *cjson = (struct cJSON *)object;
+    if (!cJSON_IsObject(cjson)) {
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        goto done;
+    }
+    if (!cJSON_HasObjectItem(cjson, aws_string_c_str(tmp))) {
+        goto done;
+    }
+
+    return_value = (void *)cJSON_GetObjectItem(cjson, aws_string_c_str(tmp));
+
+done:
+    aws_string_destroy_secure(tmp);
+    return return_value;
+}
+
+bool aws_json_value_has_key(const struct aws_json_value *object, struct aws_byte_cursor key) {
+
+    struct aws_string *tmp = aws_string_new_from_cursor(s_aws_json_module_allocator, &key);
+    bool result = false;
+
+    struct cJSON *cjson = (struct cJSON *)object;
+    if (!cJSON_IsObject(cjson)) {
+        goto done;
+    }
+    if (!cJSON_HasObjectItem(cjson, aws_string_c_str(tmp))) {
+        goto done;
+    }
+    result = true;
+
+done:
+    aws_string_destroy_secure(tmp);
+    return result;
+}
+
+int aws_json_value_remove_from_object(struct aws_json_value *object, struct aws_byte_cursor key) {
+
+    int result = AWS_OP_ERR;
+    struct aws_string *tmp = aws_string_new_from_cursor(s_aws_json_module_allocator, &key);
+
+    struct cJSON *cjson = (struct cJSON *)object;
+    if (!cJSON_IsObject(cjson)) {
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        goto done;
+    }
+    if (!cJSON_HasObjectItem(cjson, aws_string_c_str(tmp))) {
+        goto done;
+    }
+
+    cJSON_DeleteItemFromObject(cjson, aws_string_c_str(tmp));
+    result = AWS_OP_SUCCESS;
+
+done:
+    aws_string_destroy_secure(tmp);
+    return result;
+}
+
+int aws_json_value_add_array_element(struct aws_json_value *array, const struct aws_json_value *value) {
+
+    struct cJSON *cjson = (struct cJSON *)array;
+    if (!cJSON_IsArray(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+
+    struct cJSON *cjson_value = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson_value)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+
+    cJSON_AddItemToArray(cjson, cjson_value);
+    return AWS_OP_SUCCESS;
+}
+
+struct aws_json_value *aws_json_get_array_element(const struct aws_json_value *array, size_t index) {
+
+    struct cJSON *cjson = (struct cJSON *)array;
+    if (!cJSON_IsArray(cjson)) {
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        return NULL;
+    }
+
+    if (index > (size_t)cJSON_GetArraySize(cjson)) {
+        aws_raise_error(AWS_ERROR_INVALID_INDEX);
+        return NULL;
+    }
+
+    return (void *)cJSON_GetArrayItem(cjson, (int)index);
+}
+
+size_t aws_json_get_array_size(const struct aws_json_value *array) {
+    struct cJSON *cjson = (struct cJSON *)array;
+    if (!cJSON_IsArray(cjson)) {
+        aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+        return 0;
+    }
+    return cJSON_GetArraySize(cjson);
+}
+
+int aws_json_value_remove_array_element(struct aws_json_value *array, size_t index) {
+
+    struct cJSON *cjson = (struct cJSON *)array;
+    if (!cJSON_IsArray(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+
+    if (index > (size_t)cJSON_GetArraySize(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_INDEX);
+    }
+
+    cJSON_DeleteItemFromArray(cjson, (int)index);
+    return AWS_OP_SUCCESS;
+}
+
+bool aws_json_value_is_string(const struct aws_json_value *value) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return false;
+    }
+    return cJSON_IsString(cjson);
+}
+
+bool aws_json_value_is_number(const struct aws_json_value *value) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return false;
+    }
+    return cJSON_IsNumber(cjson);
+}
+
+bool aws_json_value_is_array(const struct aws_json_value *value) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return false;
+    }
+    return cJSON_IsArray(cjson);
+}
+
+bool aws_json_value_is_boolean(const struct aws_json_value *value) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return false;
+    }
+    return cJSON_IsBool(cjson);
+}
+
+bool aws_json_value_is_null(const struct aws_json_value *value) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return false;
+    }
+    return cJSON_IsNull(cjson);
+}
+
+bool aws_json_value_is_object(const struct aws_json_value *value) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return false;
+    }
+    return cJSON_IsObject(cjson);
+}
+
+static void *s_aws_cJSON_alloc(size_t sz) {
+    return aws_mem_acquire(s_aws_json_module_allocator, sz);
+}
+
+static void s_aws_cJSON_free(void *ptr) {
+    aws_mem_release(s_aws_json_module_allocator, ptr);
+}
+
+void aws_json_module_init(struct aws_allocator *allocator) {
+    if (!s_aws_json_module_initialized) {
+        s_aws_json_module_allocator = allocator;
+        struct cJSON_Hooks allocation_hooks = {
+            .malloc_fn = s_aws_cJSON_alloc,
+            .free_fn = s_aws_cJSON_free,
+        };
+        cJSON_InitHooks(&allocation_hooks);
+        s_aws_json_module_initialized = true;
+    }
+}
+
+void aws_json_module_cleanup(void) {
+    if (s_aws_json_module_initialized) {
+        s_aws_json_module_allocator = NULL;
+        s_aws_json_module_initialized = false;
+    }
+}
+
+void aws_json_value_destroy(struct aws_json_value *value) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (!cJSON_IsInvalid(cjson)) {
+        cJSON_Delete(cjson);
+    }
+}
+
+int aws_byte_buf_append_json_string(const struct aws_json_value *value, struct aws_byte_buf *output) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+
+    char *tmp = cJSON_PrintUnformatted(cjson);
+    if (tmp == NULL) {
+        return AWS_OP_ERR;
+    }
+
+    // Append the text to the byte buffer
+    struct aws_byte_cursor tmp_cursor = aws_byte_cursor_from_c_str(tmp);
+    int return_val = aws_byte_buf_append_dynamic_secure(output, &tmp_cursor);
+    s_aws_cJSON_free(tmp); // free the char* now that we do not need it
+    return return_val;
+}
+
+int aws_byte_buf_append_json_string_formatted(const struct aws_json_value *value, struct aws_byte_buf *output) {
+    struct cJSON *cjson = (struct cJSON *)value;
+    if (cJSON_IsInvalid(cjson)) {
+        return aws_raise_error(AWS_ERROR_INVALID_ARGUMENT);
+    }
+
+    char *tmp = cJSON_Print(cjson);
+    if (tmp == NULL) {
+        return AWS_OP_ERR;
+    }
+
+    // Append the text to the byte buffer
+    struct aws_byte_cursor tmp_cursor = aws_byte_cursor_from_c_str(tmp);
+    int return_val = aws_byte_buf_append_dynamic_secure(output, &tmp_cursor);
+    s_aws_cJSON_free(tmp); // free the char* now that we do not need it
+    return return_val;
+}
+
+struct aws_json_value *aws_json_value_new_from_string(struct aws_allocator *allocator, struct aws_byte_cursor string) {
+    struct aws_string *tmp = aws_string_new_from_cursor((struct aws_allocator *)allocator, &string);
+    struct cJSON *cjson = cJSON_Parse(aws_string_c_str(tmp));
+    aws_string_destroy_secure(tmp);
+    return (void *)cjson;
+}

data/aws-crt-ffi/crt/aws-c-common/source/logging.c

@@ -547,8 +547,13 @@ int aws_logger_init_noalloc(
         impl->file = options->file;
         impl->should_close = false;
     } else { /* _MSC_VER */
-        impl->file = aws_fopen(options->filename, "w");
-        impl->should_close = true;
+        if (options->filename != NULL) {
+            impl->file = aws_fopen(options->filename, "w");
+            impl->should_close = true;
+        } else {
+            impl->file = stderr;
+            impl->should_close = false;
+        }
     }
 
     aws_mutex_init(&impl->lock);

data/aws-crt-ffi/crt/aws-c-common/source/posix/system_info.c

@@ -14,6 +14,14 @@
 #    define __BSD_VISIBLE 1
 #endif
 
+#if defined(__linux__)
+#    include <sys/sysinfo.h>
+#endif
+
+#if defined(__linux__) || defined(__unix__)
+#    include <sys/types.h>
+#endif
+
 #include <unistd.h>
 
 #if defined(HAVE_SYSCONF)

data/aws-crt-ffi/crt/aws-c-common/source/ref_count.c

@@ -15,7 +15,9 @@ void aws_ref_count_init(struct aws_ref_count *ref_count, void *object, aws_simpl
 }
 
 void *aws_ref_count_acquire(struct aws_ref_count *ref_count) {
-    aws_atomic_fetch_add(&ref_count->ref_count, 1);
+    size_t old_value = aws_atomic_fetch_add(&ref_count->ref_count, 1);
+    AWS_ASSERT(old_value > 0 && "refcount has been zero, it's invalid to use it again.");
+    (void)old_value;
 
     return ref_count->object;
 }

data/aws-crt-ffi/crt/aws-c-common/source/windows/file.c

@@ -13,7 +13,19 @@
 #include <stdio.h>
 #include <windows.h>
 
+static bool s_is_string_empty(const struct aws_string *str) {
+    return str == NULL || str->len == 0;
+}
+
+static bool s_is_wstring_empty(const struct aws_wstring *str) {
+    return str == NULL || str->len == 0;
+}
+
 FILE *aws_fopen_safe(const struct aws_string *file_path, const struct aws_string *mode) {
+    if (s_is_string_empty(file_path) || s_is_string_empty(mode)) {
+        return NULL;
+    }
+
     struct aws_wstring *w_file_path = aws_string_convert_to_wstring(aws_default_allocator(), file_path);
     struct aws_wstring *w_mode = aws_string_convert_to_wstring(aws_default_allocator(), mode);
 
@@ -31,6 +43,9 @@ FILE *aws_fopen_safe(const struct aws_string *file_path, const struct aws_string
 }
 
 struct aws_wstring *s_to_long_path(struct aws_allocator *allocator, const struct aws_wstring *path) {
+    if (s_is_wstring_empty(path)) {
+        return NULL;
+    }
 
     wchar_t prefix[] = L"\\\\?\\";
     size_t prefix_size = sizeof(prefix);
@@ -56,6 +71,10 @@ struct aws_wstring *s_to_long_path(struct aws_allocator *allocator, const struct
 }
 
 int aws_directory_create(const struct aws_string *dir_path) {
+    if (s_is_string_empty(dir_path)) {
+        return aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+    }
+
     struct aws_wstring *w_dir_path = aws_string_convert_to_wstring(aws_default_allocator(), dir_path);
     struct aws_wstring *long_dir_path = s_to_long_path(aws_default_allocator(), w_dir_path);
     aws_wstring_destroy(w_dir_path);
@@ -84,6 +103,10 @@ int aws_directory_create(const struct aws_string *dir_path) {
 }
 
 bool aws_directory_exists(const struct aws_string *dir_path) {
+    if (s_is_string_empty(dir_path)) {
+        return false;
+    }
+
     struct aws_wstring *w_dir_path = aws_string_convert_to_wstring(aws_default_allocator(), dir_path);
     struct aws_wstring *long_dir_path = s_to_long_path(aws_default_allocator(), w_dir_path);
     aws_wstring_destroy(w_dir_path);
@@ -115,6 +138,9 @@ static bool s_delete_file_or_directory(const struct aws_directory_entry *entry,
 }
 
 int aws_directory_delete(const struct aws_string *dir_path, bool recursive) {
+    if (s_is_string_empty(dir_path)) {
+        return aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+    }
     if (!aws_directory_exists(dir_path)) {
         return AWS_OP_SUCCESS;
     }
@@ -158,6 +184,10 @@ int aws_directory_delete(const struct aws_string *dir_path, bool recursive) {
 }
 
 int aws_file_delete(const struct aws_string *file_path) {
+    if (s_is_string_empty(file_path)) {
+        return aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+    }
+
     struct aws_wstring *w_file_path = aws_string_convert_to_wstring(aws_default_allocator(), file_path);
     struct aws_wstring *long_file_path = s_to_long_path(aws_default_allocator(), w_file_path);
     aws_wstring_destroy(w_file_path);
@@ -182,6 +212,10 @@ int aws_file_delete(const struct aws_string *file_path) {
 }
 
 int aws_directory_or_file_move(const struct aws_string *from, const struct aws_string *to) {
+    if (s_is_string_empty(from) || s_is_string_empty(to)) {
+        return aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+    }
+
     struct aws_wstring *w_from_path = aws_string_convert_to_wstring(aws_default_allocator(), from);
     struct aws_wstring *long_from_path = s_to_long_path(aws_default_allocator(), w_from_path);
     aws_wstring_destroy(w_from_path);
@@ -216,6 +250,11 @@ int aws_directory_traverse(
     bool recursive,
     aws_on_directory_entry *on_entry,
     void *user_data) {
+
+    if (s_is_string_empty(path)) {
+        return aws_raise_error(AWS_ERROR_FILE_INVALID_PATH);
+    }
+
     struct aws_wstring *w_path_wchar = aws_string_convert_to_wstring(allocator, path);
     struct aws_wstring *long_path_wchar = s_to_long_path(allocator, w_path_wchar);
     aws_wstring_destroy(w_path_wchar);
@@ -440,6 +479,10 @@ struct aws_string *aws_get_home_directory(struct aws_allocator *allocator) {
 }
 
 bool aws_path_exists(const struct aws_string *path) {
+    if (s_is_string_empty(path)) {
+        return false;
+    }
+
     struct aws_wstring *wchar_path = aws_string_convert_to_wstring(aws_default_allocator(), path);
     bool ret_val = PathFileExistsW(aws_wstring_c_str(wchar_path)) == TRUE;
     aws_wstring_destroy(wchar_path);
@@ -455,6 +498,10 @@ int aws_fseek(FILE *file, int64_t offset, int whence) {
 }
 
 int aws_file_get_length(FILE *file, int64_t *length) {
+    if (file == NULL) {
+        return aws_raise_error(AWS_ERROR_INVALID_FILE_HANDLE);
+    }
+
     int fd = _fileno(file);
     if (fd == -1) {
         return aws_raise_error(AWS_ERROR_INVALID_FILE_HANDLE);

data/aws-crt-ffi/crt/aws-c-common/source/windows/system_info.c

@@ -272,7 +272,7 @@ void aws_backtrace_log(int log_level) {
     }
     aws_mem_release(aws_default_allocator(), symbols);
 }
-#else  /* !AWS_OS_WINDOWS_DESKTOP */
+#else /* !AWS_OS_WINDOWS_DESKTOP */
 size_t aws_backtrace(void **stack_frames, size_t size) {
     (void)stack_frames;
     (void)size;
@@ -299,4 +299,5 @@ void aws_backtrace_log() {
     AWS_LOGF_TRACE(
         AWS_LS_COMMON_GENERAL, "aws_backtrace_log: backtrace requested, but logging is unsupported on this platform");
 }
+
 #endif /* AWS_OS_WINDOWS_DESKTOP */

data/aws-crt-ffi/crt/aws-c-common/tests/CMakeLists.txt

@@ -277,6 +277,8 @@ add_test_case(test_byte_buf_reserve_relative)
 add_test_case(test_byte_buf_reset)
 add_test_case(test_byte_cursor_compare_lexical)
 add_test_case(test_byte_cursor_compare_lookup)
+add_test_case(test_byte_cursor_starts_with)
+add_test_case(test_byte_cursor_starts_with_ignore_case)
 add_test_case(test_isalnum)
 add_test_case(test_isalpha)
 add_test_case(test_isdigit)
@@ -474,6 +476,9 @@ add_test_case(promise_test_finish_immediately)
 add_test_case(promise_test_finish_before_wait)
 add_test_case(promise_test_multiple_waiters)
 
+add_test_case(test_json_parse_from_string)
+add_test_case(test_json_parse_to_string)
+
 generate_test_driver(${PROJECT_NAME}-tests)
 
 if (NOT MSVC AND NOT LEGACY_COMPILER_SUPPORT)

data/aws-crt-ffi/crt/aws-c-common/tests/byte_buf_test.c

@@ -798,6 +798,75 @@ static int s_test_byte_buf_reserve_relative(struct aws_allocator *allocator, voi
 }
 AWS_TEST_CASE(test_byte_buf_reserve_relative, s_test_byte_buf_reserve_relative)
 
+static int s_test_byte_cursor_starts_with(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    (void)allocator;
+
+    struct aws_byte_cursor a = aws_byte_cursor_from_c_str("a");
+    struct aws_byte_cursor abcd = aws_byte_cursor_from_c_str("abcd");
+    struct aws_byte_cursor ab = aws_byte_cursor_from_c_str("ab");
+    struct aws_byte_cursor abcde = aws_byte_cursor_from_c_str("abcde");
+    struct aws_byte_cursor ABCD = aws_byte_cursor_from_c_str("ABCD");
+    struct aws_byte_cursor AB = aws_byte_cursor_from_c_str("AB");
+    struct aws_byte_cursor empty_string = aws_byte_cursor_from_c_str("");
+    struct aws_byte_cursor null_char_string = aws_byte_cursor_from_array("\0", 1);
+
+    /* TRUE */
+    ASSERT_TRUE(aws_byte_cursor_starts_with(&a, &a));
+    ASSERT_TRUE(aws_byte_cursor_starts_with(&abcd, &ab));
+    ASSERT_TRUE(aws_byte_cursor_starts_with(&abcd, &abcd));
+    ASSERT_TRUE(aws_byte_cursor_starts_with(&abcd, &empty_string));
+    ASSERT_TRUE(aws_byte_cursor_starts_with(&empty_string, &empty_string));
+
+    /* FALSE */
+    ASSERT_FALSE(aws_byte_cursor_starts_with(&abcd, &abcde));
+    ASSERT_FALSE(aws_byte_cursor_starts_with(&abcd, &ABCD));
+    ASSERT_FALSE(aws_byte_cursor_starts_with(&abcd, &AB));
+    ASSERT_FALSE(aws_byte_cursor_starts_with(&empty_string, &a));
+    ASSERT_FALSE(aws_byte_cursor_starts_with(&empty_string, &null_char_string));
+    ASSERT_FALSE(aws_byte_cursor_starts_with(&abcd, &null_char_string));
+
+    return 0;
+}
+AWS_TEST_CASE(test_byte_cursor_starts_with, s_test_byte_cursor_starts_with)
+
+static int s_test_byte_cursor_starts_with_ignore_case(struct aws_allocator *allocator, void *ctx) {
+    (void)ctx;
+    (void)allocator;
+
+    struct aws_byte_cursor a = aws_byte_cursor_from_c_str("a");
+    struct aws_byte_cursor A = aws_byte_cursor_from_c_str("A");
+    struct aws_byte_cursor abcd = aws_byte_cursor_from_c_str("abcd");
+    struct aws_byte_cursor ABCD = aws_byte_cursor_from_c_str("ABCD");
+    struct aws_byte_cursor abcde = aws_byte_cursor_from_c_str("abcde");
+    struct aws_byte_cursor azcd = aws_byte_cursor_from_c_str("azcd");
+    struct aws_byte_cursor empty_string = aws_byte_cursor_from_c_str("");
+    struct aws_byte_cursor null_char_string = aws_byte_cursor_from_array("\0", 1);
+
+    /* TRUE */
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&abcd, &abcd));
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&abcd, &ABCD));
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&ABCD, &abcd));
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&ABCD, &ABCD));
+
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&abcd, &a));
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&abcd, &A));
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&ABCD, &a));
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&ABCD, &A));
+
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&abcd, &empty_string));
+    ASSERT_TRUE(aws_byte_cursor_starts_with_ignore_case(&empty_string, &empty_string));
+
+    /* FALSE */
+    ASSERT_FALSE(aws_byte_cursor_starts_with_ignore_case(&abcd, &abcde));
+    ASSERT_FALSE(aws_byte_cursor_starts_with_ignore_case(&abcd, &azcd));
+    ASSERT_FALSE(aws_byte_cursor_starts_with_ignore_case(&empty_string, &a));
+    ASSERT_FALSE(aws_byte_cursor_starts_with_ignore_case(&empty_string, &null_char_string));
+
+    return 0;
+}
+AWS_TEST_CASE(test_byte_cursor_starts_with_ignore_case, s_test_byte_cursor_starts_with_ignore_case)
+
 static int s_test_byte_cursor_compare_lexical(struct aws_allocator *allocator, void *ctx) {
     (void)ctx;
     (void)allocator;