Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package aws-c-sdkutils for openSUSE:Factory checked in at 2024-08-09 16:14:49 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/aws-c-sdkutils (Old) and /work/SRC/openSUSE:Factory/.aws-c-sdkutils.new.7232 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "aws-c-sdkutils" Fri Aug 9 16:14:49 2024 rev:5 rq:1192593 version:0.1.19 Changes: -------- --- /work/SRC/openSUSE:Factory/aws-c-sdkutils/aws-c-sdkutils.changes 2024-06-06 12:32:20.247859423 +0200 +++ /work/SRC/openSUSE:Factory/.aws-c-sdkutils.new.7232/aws-c-sdkutils.changes 2024-08-09 16:15:21.544672329 +0200 @@ -1,0 +2,14 @@ +Wed Aug 7 13:37:56 UTC 2024 - John Paul Adrian Glaubitz <adrian.glaubitz@suse.com> + +- Update to version 0.1.19 + * Lets make string array const input by @DmitriyMusatkin in (#44) +- from version 0.1.18 + * Switch to more efficient functions for json parsing + by @DmitriyMusatkin in (#43) +- from version 0.1.17 + * clang-format 18 by @graebm in (#40) + * Update MacOS to arm64 by @waahm7 in (#41) + * Add support for string array request parameter to + endpoint resolution by @DmitriyMusatkin in (#42) + +------------------------------------------------------------------- Old: ---- v0.1.16.tar.gz New: ---- v0.1.19.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ aws-c-sdkutils.spec ++++++ --- /var/tmp/diff_new_pack.HGIlRk/_old 2024-08-09 16:15:23.292745293 +0200 +++ /var/tmp/diff_new_pack.HGIlRk/_new 2024-08-09 16:15:23.296745460 +0200 @@ -20,7 +20,7 @@ %define library_pkg 1_0_0 %define library_soversion 1 Name: aws-c-sdkutils -Version: 0.1.16 +Version: 0.1.19 Release: 0 Summary: AWS C SDK Utils License: Apache-2.0 ++++++ v0.1.16.tar.gz -> v0.1.19.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/.github/workflows/ci.yml new/aws-c-sdkutils-0.1.19/.github/workflows/ci.yml --- old/aws-c-sdkutils-0.1.16/.github/workflows/ci.yml 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/.github/workflows/ci.yml 2024-08-03 00:36:14.000000000 +0200 @@ -6,7 +6,7 @@ - 'main' env: - BUILDER_VERSION: v0.9.55 + BUILDER_VERSION: v0.9.62 BUILDER_SOURCE: releases BUILDER_HOST: https://d19elf31gohf1l.cloudfront.net PACKAGE_NAME: aws-c-sdkutils @@ -119,8 +119,17 @@ run: | python .\aws-c-sdkutils\build\deps\aws-c-common\scripts\appverifier_ctest.py --build_directory .\aws-c-sdkutils\build\aws-c-sdkutils - osx: - runs-on: macos-12 # latest + macos: + runs-on: macos-14 # latest + steps: + - name: Build ${{ env.PACKAGE_NAME }} + consumers + run: | + python3 -c "from urllib.request import urlretrieve; urlretrieve('${{ env.BUILDER_HOST }}/${{ env.BUILDER_SOURCE }}/${{ env.BUILDER_VERSION }}/builder.pyz', 'builder')" + chmod a+x builder + ./builder build -p ${{ env.PACKAGE_NAME }} + + macos-x64: + runs-on: macos-14-large # latest steps: - name: Build ${{ env.PACKAGE_NAME }} + consumers run: | diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/.github/workflows/clang-format.yml new/aws-c-sdkutils-0.1.19/.github/workflows/clang-format.yml --- old/aws-c-sdkutils-0.1.16/.github/workflows/clang-format.yml 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/.github/workflows/clang-format.yml 2024-08-03 00:36:14.000000000 +0200 @@ -5,14 +5,12 @@ jobs: clang-format: - runs-on: ubuntu-20.04 # latest + runs-on: ubuntu-24.04 # latest steps: - name: Checkout Sources - uses: actions/checkout@v1 + uses: actions/checkout@v4 - name: clang-format lint - uses: DoozyX/clang-format-lint-action@v0.3.1 - with: - # List of extensions to check - extensions: c,h + run: | + ./format-check.py diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/format-check.py new/aws-c-sdkutils-0.1.19/format-check.py --- old/aws-c-sdkutils-0.1.16/format-check.py 1970-01-01 01:00:00.000000000 +0100 +++ new/aws-c-sdkutils-0.1.19/format-check.py 2024-08-03 00:36:14.000000000 +0200 @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +import argparse +import os +from pathlib import Path +import re +from subprocess import list2cmdline, run +from tempfile import NamedTemporaryFile + +CLANG_FORMAT_VERSION = '18.1.6' + +INCLUDE_REGEX = re.compile( + r'^(include|source|tests|verification)/.*\.(c|h|inl)$') +EXCLUDE_REGEX = re.compile(r'^$') + +arg_parser = argparse.ArgumentParser(description="Check with clang-format") +arg_parser.add_argument('-i', '--inplace-edit', action='store_true', + help="Edit files inplace") +args = arg_parser.parse_args() + +os.chdir(Path(__file__).parent) + +# create file containing list of all files to format +filepaths_file = NamedTemporaryFile(delete=False) +for dirpath, dirnames, filenames in os.walk('.'): + for filename in filenames: + # our regexes expect filepath to use forward slash + filepath = Path(dirpath, filename).as_posix() + if not INCLUDE_REGEX.match(filepath): + continue + if EXCLUDE_REGEX.match(filepath): + continue + + filepaths_file.write(f"{filepath}\n".encode()) +filepaths_file.close() + +# use pipx to run clang-format from PyPI +# this is a simple way to run the same clang-format version regardless of OS +cmd = ['pipx', 'run', f'clang-format=={CLANG_FORMAT_VERSION}', + f'--files={filepaths_file.name}'] +if args.inplace_edit: + cmd += ['-i'] +else: + cmd += ['--Werror', '--dry-run'] + +print(f"{Path.cwd()}$ {list2cmdline(cmd)}") +if run(cmd).returncode: + exit(1) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/format-check.sh new/aws-c-sdkutils-0.1.19/format-check.sh --- old/aws-c-sdkutils-0.1.16/format-check.sh 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/format-check.sh 1970-01-01 01:00:00.000000000 +0100 @@ -1,24 +0,0 @@ -#!/usr/bin/env bash - -if [[ -z $CLANG_FORMAT ]] ; then - CLANG_FORMAT=clang-format -fi - -if NOT type $CLANG_FORMAT 2> /dev/null ; then - echo "No appropriate clang-format found." - exit 1 -fi - -FAIL=0 -SOURCE_FILES=`find source include tests -type f \( -name '*.h' -o -name '*.c' \)` -for i in $SOURCE_FILES -do - $CLANG_FORMAT -output-replacements-xml $i | grep -c "<replacement " > /dev/null - if [ $? -ne 1 ] - then - echo "$i failed clang-format check." - FAIL=1 - fi -done - -exit $FAIL diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/include/aws/sdkutils/endpoints_rule_engine.h new/aws-c-sdkutils-0.1.19/include/aws/sdkutils/endpoints_rule_engine.h --- old/aws-c-sdkutils-0.1.16/include/aws/sdkutils/endpoints_rule_engine.h 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/include/aws/sdkutils/endpoints_rule_engine.h 2024-08-03 00:36:14.000000000 +0200 @@ -19,7 +19,11 @@ struct aws_endpoints_request_context; struct aws_hash_table; -enum aws_endpoints_parameter_type { AWS_ENDPOINTS_PARAMETER_STRING, AWS_ENDPOINTS_PARAMETER_BOOLEAN }; +enum aws_endpoints_parameter_type { + AWS_ENDPOINTS_PARAMETER_STRING, + AWS_ENDPOINTS_PARAMETER_BOOLEAN, + AWS_ENDPOINTS_PARAMETER_STRING_ARRAY, +}; enum aws_endpoints_resolved_endpoint_type { AWS_ENDPOINTS_RESOLVED_ENDPOINT, AWS_ENDPOINTS_RESOLVED_ERROR }; AWS_EXTERN_C_BEGIN @@ -221,7 +225,6 @@ /* * Add boolean value to request context. - * Note: this function will make a copy of the memory backing the cursors. * The function will override any previous value stored in the context with the * same name. */ @@ -232,6 +235,19 @@ bool value); /* + * Add string array value to request context. + * Note: this function will make a copy of the memory backing the cursors. + * The function will override any previous value stored in the context with the + * same name. + */ +AWS_SDKUTILS_API int aws_endpoints_request_context_add_string_array( + struct aws_allocator *allocator, + struct aws_endpoints_request_context *context, + struct aws_byte_cursor name, + const struct aws_byte_cursor *value_array, + size_t len); + +/* * Resolve an endpoint given request context. * Resolved endpoint is returned through out_resolved_endpoint. * In cases of error out_resolved_endpoint is set to NULL and error is returned. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/include/aws/sdkutils/private/endpoints_types_impl.h new/aws-c-sdkutils-0.1.19/include/aws/sdkutils/private/endpoints_types_impl.h --- old/aws-c-sdkutils-0.1.16/include/aws/sdkutils/private/endpoints_types_impl.h 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/include/aws/sdkutils/private/endpoints_types_impl.h 2024-08-03 00:36:14.000000000 +0200 @@ -71,6 +71,35 @@ AWS_ENDPOINTS_FN_LAST, }; +enum aws_endpoints_value_type { + /* Special value to represent that any value type is expected from resolving an expresion. + Not a valid value for a value type. */ + AWS_ENDPOINTS_VALUE_ANY, + + AWS_ENDPOINTS_VALUE_NONE, + AWS_ENDPOINTS_VALUE_STRING, + AWS_ENDPOINTS_VALUE_BOOLEAN, + AWS_ENDPOINTS_VALUE_OBJECT, /* Generic type returned by some functions. json string under the covers. */ + AWS_ENDPOINTS_VALUE_NUMBER, + AWS_ENDPOINTS_VALUE_ARRAY, + + AWS_ENDPOINTS_VALUE_SIZE +}; + +/* concrete type value */ +struct aws_endpoints_value { + enum aws_endpoints_value_type type; + union { + struct aws_owning_cursor owning_cursor_string; + bool boolean; + struct aws_owning_cursor owning_cursor_object; + double number; + struct aws_array_list array; + } v; + /* Value is a reference to another value, no need to clean it up. */ + bool is_ref; +}; + struct aws_endpoints_parameter { struct aws_allocator *allocator; @@ -80,10 +109,7 @@ struct aws_byte_cursor built_in; bool has_default_value; - union { - struct aws_byte_cursor string; - bool boolean; - } default_value; + struct aws_endpoints_value default_value; bool is_required; struct aws_byte_cursor documentation; @@ -210,21 +236,6 @@ ****************************** */ -enum aws_endpoints_value_type { - /* Special value to represent that any value type is expected from resolving an expresion. - Note a valid value for a value type. */ - AWS_ENDPOINTS_VALUE_ANY, - - AWS_ENDPOINTS_VALUE_NONE, - AWS_ENDPOINTS_VALUE_STRING, - AWS_ENDPOINTS_VALUE_BOOLEAN, - AWS_ENDPOINTS_VALUE_OBJECT, /* Generic type returned by some functions. json string under the covers. */ - AWS_ENDPOINTS_VALUE_NUMBER, - AWS_ENDPOINTS_VALUE_ARRAY, - - AWS_ENDPOINTS_VALUE_SIZE -}; - struct aws_endpoints_request_context { struct aws_allocator *allocator; struct aws_ref_count ref_count; @@ -232,18 +243,6 @@ struct aws_hash_table values; }; -/* concrete type value */ -struct aws_endpoints_value { - enum aws_endpoints_value_type type; - union { - struct aws_owning_cursor owning_cursor_string; - bool boolean; - struct aws_owning_cursor owning_cursor_object; - double number; - struct aws_array_list array; - } v; -}; - /* wrapper around aws_endpoints_value to store it more easily in hash table*/ struct aws_endpoints_scope_value { struct aws_allocator *allocator; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/source/endpoints_rule_engine.c new/aws-c-sdkutils-0.1.19/source/endpoints_rule_engine.c --- old/aws-c-sdkutils-0.1.16/source/endpoints_rule_engine.c 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/source/endpoints_rule_engine.c 2024-08-03 00:36:14.000000000 +0200 @@ -186,13 +186,10 @@ switch (value->type) { case AWS_ENDPOINTS_PARAMETER_STRING: - val->value.type = AWS_ENDPOINTS_VALUE_STRING; - val->value.v.owning_cursor_string = - aws_endpoints_non_owning_cursor_create(value->default_value.string); - break; case AWS_ENDPOINTS_PARAMETER_BOOLEAN: - val->value.type = AWS_ENDPOINTS_VALUE_BOOLEAN; - val->value.v.boolean = value->default_value.boolean; + case AWS_ENDPOINTS_PARAMETER_STRING_ARRAY: + val->value = value->default_value; + val->value.is_ref = true; break; default: AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Unexpected parameter type."); @@ -310,8 +307,21 @@ } case AWS_ENDPOINTS_EXPR_ARRAY: { out_value->type = AWS_ENDPOINTS_VALUE_ARRAY; - /* TODO: deep copy */ - out_value->v.array = expr->e.array; + { + size_t len = aws_array_list_length(&expr->e.array); + aws_array_list_init_dynamic(&out_value->v.array, allocator, len, sizeof(struct aws_endpoints_value)); + for (size_t i = 0; i < len; ++i) { + struct aws_endpoints_expr expr_elem; + aws_array_list_get_at(&expr->e.array, &expr_elem, i); + struct aws_endpoints_value val; + if (s_resolve_expr(allocator, &expr_elem, scope, &val)) { + AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Failed to resolve array element."); + aws_endpoints_value_clean_up(out_value); + goto on_error; + } + aws_array_list_set_at(&out_value->v.array, &val, i); + } + } break; } case AWS_ENDPOINTS_EXPR_REFERENCE: { @@ -325,14 +335,9 @@ out_value->type = AWS_ENDPOINTS_VALUE_NONE; } else { struct aws_endpoints_scope_value *aws_endpoints_scope_value = element->value; + *out_value = aws_endpoints_scope_value->value; - if (aws_endpoints_scope_value->value.type == AWS_ENDPOINTS_VALUE_STRING) { - /* Value will not own underlying mem and instead its owned - by the scope, so set it to NULL. */ - out_value->v.owning_cursor_string.string = NULL; - } else if (aws_endpoints_scope_value->value.type == AWS_ENDPOINTS_VALUE_OBJECT) { - out_value->v.owning_cursor_object.string = NULL; - } + out_value->is_ref = true; } break; } @@ -450,6 +455,8 @@ struct aws_endpoints_value *value, struct aws_byte_cursor path_cur, struct aws_endpoints_value *out_value) { + (void)allocator; + (void)scope; AWS_PRECONDITION(value->type == AWS_ENDPOINTS_VALUE_ARRAY); @@ -461,25 +468,20 @@ goto on_error; } - if (index < aws_array_list_length(&value->v.array)) { + if (index >= aws_array_list_length(&value->v.array)) { out_value->type = AWS_ENDPOINTS_VALUE_NONE; return AWS_OP_SUCCESS; } - struct aws_endpoints_expr *expr = NULL; - if (aws_array_list_get_at_ptr(&value->v.array, (void **)&expr, (size_t)index)) { + struct aws_endpoints_value *val = NULL; + if (aws_array_list_get_at_ptr(&value->v.array, (void **)&val, (size_t)index)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Failed to index into resolved value"); goto on_error; } - struct aws_endpoints_value val; - if (s_resolve_expr(allocator, expr, scope, &val)) { - AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Failed to resolve val."); - aws_endpoints_value_clean_up(&val); - goto on_error; - } + *out_value = *val; + out_value->is_ref = true; - *out_value = val; return AWS_OP_SUCCESS; on_error: @@ -597,7 +599,10 @@ goto on_error; } } else { - AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Invalid value type for pathing through."); + AWS_LOGF_ERROR( + AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, + "Invalid value type for pathing through. type %d", + scope_value->value.type); goto on_error; } @@ -737,6 +742,34 @@ return AWS_OP_SUCCESS; } +int aws_endpoints_request_context_add_string_array( + struct aws_allocator *allocator, + struct aws_endpoints_request_context *context, + struct aws_byte_cursor name, + const struct aws_byte_cursor *values, + size_t len) { + + struct aws_endpoints_scope_value *val = aws_endpoints_scope_value_new(allocator, name); + val->value.type = AWS_ENDPOINTS_VALUE_ARRAY; + aws_array_list_init_dynamic(&val->value.v.array, allocator, len, sizeof(struct aws_endpoints_value)); + + for (size_t i = 0; i < len; ++i) { + struct aws_endpoints_value elem = { + .is_ref = false, + .type = AWS_ENDPOINTS_VALUE_STRING, + .v.owning_cursor_object = aws_endpoints_owning_cursor_from_cursor(allocator, values[i])}; + + aws_array_list_set_at(&val->value.v.array, &elem, i); + } + + if (aws_hash_table_put(&context->values, &val->name.cur, val, NULL)) { + aws_endpoints_scope_value_destroy(val); + return aws_raise_error(AWS_ERROR_SDKUTILS_ENDPOINTS_RESOLVE_INIT_FAILED); + }; + + return AWS_OP_SUCCESS; +} + /* ****************************** * Rule engine. @@ -1126,7 +1159,6 @@ result = aws_raise_error(AWS_ERROR_SDKUTILS_ENDPOINTS_RULESET_EXHAUSTED); on_done: - AWS_LOGF_DEBUG(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Resolved endpoint with status %d", result); s_scope_clean_up(&scope); return result; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/source/endpoints_ruleset.c new/aws-c-sdkutils-0.1.19/source/endpoints_ruleset.c --- old/aws-c-sdkutils-0.1.16/source/endpoints_ruleset.c 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/source/endpoints_ruleset.c 2024-08-03 00:36:14.000000000 +0200 @@ -14,6 +14,7 @@ /* parameter types */ static struct aws_byte_cursor s_string_type_cur = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("string"); static struct aws_byte_cursor s_boolean_type_cur = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("boolean"); +static struct aws_byte_cursor s_string_array_type_cur = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("stringArray"); /* rule types */ static struct aws_byte_cursor s_endpoint_type_cur = AWS_BYTE_CUR_INIT_FROM_STRING_LITERAL("endpoint"); @@ -52,7 +53,7 @@ AWS_PRECONDITION(out_cursor); if (parameter->type == AWS_ENDPOINTS_PARAMETER_STRING) { - *out_cursor = parameter->default_value.string; + *out_cursor = parameter->default_value.v.owning_cursor_string.cur; return AWS_OP_SUCCESS; }; @@ -67,7 +68,7 @@ AWS_PRECONDITION(out_bool); if (parameter->type == AWS_ENDPOINTS_PARAMETER_BOOLEAN) { - *out_bool = ¶meter->default_value.boolean; + *out_bool = ¶meter->default_value.v.boolean; return AWS_OP_SUCCESS; }; @@ -225,7 +226,7 @@ AWS_ZERO_STRUCT(*out_reference); - struct aws_json_value *ref_node = aws_json_value_get_from_object(node, aws_byte_cursor_from_c_str("ref")); + struct aws_json_value *ref_node = aws_json_value_get_from_object_c_str(node, "ref"); if (ref_node != NULL && aws_json_value_get_string(ref_node, out_reference)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to parse ref."); AWS_ZERO_STRUCT(*out_reference); @@ -328,7 +329,7 @@ AWS_ZERO_STRUCT(*function); - struct aws_json_value *fn_node = aws_json_value_get_from_object(node, aws_byte_cursor_from_c_str("fn")); + struct aws_json_value *fn_node = aws_json_value_get_from_object_c_str(node, "fn"); if (fn_node == NULL) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Node is not a function."); goto on_error; @@ -357,7 +358,7 @@ goto on_error; } - struct aws_json_value *argv_node = aws_json_value_get_from_object(node, aws_byte_cursor_from_c_str("argv")); + struct aws_json_value *argv_node = aws_json_value_get_from_object_c_str(node, "argv"); if (argv_node == NULL || !aws_json_value_is_array(argv_node)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "No argv or unexpected type."); goto on_error; @@ -394,7 +395,7 @@ /* required fields */ struct aws_byte_cursor type_cur; - struct aws_json_value *type_node = aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("type")); + struct aws_json_value *type_node = aws_json_value_get_from_object_c_str(value, "type"); if (type_node == NULL || aws_json_value_get_string(type_node, &type_cur)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract parameter type."); goto on_error; @@ -405,6 +406,8 @@ type = AWS_ENDPOINTS_PARAMETER_STRING; } else if (aws_byte_cursor_eq_ignore_case(&type_cur, &s_boolean_type_cur)) { type = AWS_ENDPOINTS_PARAMETER_BOOLEAN; + } else if (aws_byte_cursor_eq_ignore_case(&type_cur, &s_string_array_type_cur)) { + type = AWS_ENDPOINTS_PARAMETER_STRING_ARRAY; } else { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected type for parameter."); goto on_error; @@ -412,8 +415,7 @@ parameter->type = type; - struct aws_json_value *documentation_node = - aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("documentation")); + struct aws_json_value *documentation_node = aws_json_value_get_from_object_c_str(value, "documentation"); /* TODO: spec calls for documentation to be required, but several test-cases are missing docs on parameters */ @@ -425,7 +427,7 @@ } /* optional fields */ - struct aws_json_value *built_in_node = aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("builtIn")); + struct aws_json_value *built_in_node = aws_json_value_get_from_object_c_str(value, "builtIn"); if (built_in_node != NULL) { if (aws_json_value_get_string(built_in_node, ¶meter->built_in)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected type for built-in parameter field."); @@ -433,8 +435,7 @@ } } - struct aws_json_value *required_node = - aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("required")); + struct aws_json_value *required_node = aws_json_value_get_from_object_c_str(value, "required"); if (required_node != NULL) { if (!aws_json_value_is_boolean(required_node)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected type for required parameter field."); @@ -443,34 +444,59 @@ aws_json_value_get_boolean(required_node, ¶meter->is_required); } - struct aws_json_value *default_node = aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("default")); + struct aws_json_value *default_node = aws_json_value_get_from_object_c_str(value, "default"); parameter->has_default_value = default_node != NULL; if (default_node != NULL) { - if (type == AWS_ENDPOINTS_PARAMETER_STRING && - aws_json_value_get_string(default_node, ¶meter->default_value.string)) { - AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected type for default parameter value."); - goto on_error; - } else if ( - type == AWS_ENDPOINTS_PARAMETER_BOOLEAN && - aws_json_value_get_boolean(default_node, ¶meter->default_value.boolean)) { + if (type == AWS_ENDPOINTS_PARAMETER_STRING && aws_json_value_is_string(default_node)) { + struct aws_byte_cursor cur; + aws_json_value_get_string(default_node, &cur); + parameter->default_value.type = AWS_ENDPOINTS_VALUE_STRING; + parameter->default_value.v.owning_cursor_string = aws_endpoints_non_owning_cursor_create(cur); + } else if (type == AWS_ENDPOINTS_PARAMETER_BOOLEAN && aws_json_value_is_boolean(default_node)) { + parameter->default_value.type = AWS_ENDPOINTS_VALUE_BOOLEAN; + aws_json_value_get_boolean(default_node, ¶meter->default_value.v.boolean); + } else if (type == AWS_ENDPOINTS_PARAMETER_STRING_ARRAY && aws_json_value_is_array(default_node)) { + parameter->default_value.type = AWS_ENDPOINTS_VALUE_ARRAY; + size_t len = aws_json_get_array_size(default_node); + aws_array_list_init_dynamic( + ¶meter->default_value.v.array, wrapper->allocator, len, sizeof(struct aws_endpoints_value)); + for (size_t i = 0; i < len; ++i) { + struct aws_json_value *element = aws_json_get_array_element(default_node, i); + if (!aws_json_value_is_string(element)) { + AWS_LOGF_ERROR( + AWS_LS_SDKUTILS_ENDPOINTS_PARSING, + "Unexpected type for default parameter value. String array parameter must have string " + "elements"); + goto on_error; + } + + struct aws_byte_cursor cur; + aws_json_value_get_string(element, &cur); + + struct aws_endpoints_value val = { + .is_ref = false, + .type = AWS_ENDPOINTS_VALUE_STRING, + .v.owning_cursor_string = aws_endpoints_non_owning_cursor_create(cur)}; + + aws_array_list_set_at(¶meter->default_value.v.array, &val, i); + } + } else { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected type for default parameter value."); goto on_error; } } - struct aws_json_value *deprecated_node = - aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("deprecated")); + struct aws_json_value *deprecated_node = aws_json_value_get_from_object_c_str(value, "deprecated"); if (deprecated_node != NULL) { struct aws_json_value *deprecated_message_node = - aws_json_value_get_from_object(deprecated_node, aws_byte_cursor_from_c_str("message")); + aws_json_value_get_from_object_c_str(deprecated_node, "message"); if (deprecated_message_node != NULL && aws_json_value_get_string(deprecated_message_node, ¶meter->deprecated_message)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected value for deprecated message."); goto on_error; } - struct aws_json_value *deprecated_since_node = - aws_json_value_get_from_object(deprecated_node, aws_byte_cursor_from_c_str("since")); + struct aws_json_value *deprecated_since_node = aws_json_value_get_from_object_c_str(deprecated_node, "since"); if (deprecated_since_node != NULL && aws_json_value_get_string(deprecated_since_node, ¶meter->deprecated_since)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected value for deprecated since."); @@ -510,8 +536,7 @@ goto on_error; } - struct aws_json_value *assign_node = - aws_json_value_get_from_object(condition_node, aws_byte_cursor_from_c_str("assign")); + struct aws_json_value *assign_node = aws_json_value_get_from_object_c_str(condition_node, "assign"); if (assign_node != NULL && aws_json_value_get_string(assign_node, &condition.assign)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected value for assign."); goto on_error; @@ -589,7 +614,7 @@ AWS_PRECONDITION(data_rule); data_rule->allocator = allocator; - struct aws_json_value *url_node = aws_json_value_get_from_object(rule_node, aws_byte_cursor_from_c_str("url")); + struct aws_json_value *url_node = aws_json_value_get_from_object_c_str(rule_node, "url"); if (url_node == NULL || aws_json_value_is_string(url_node)) { data_rule->url.type = AWS_ENDPOINTS_EXPR_STRING; aws_json_value_get_string(url_node, &data_rule->url.e.string); @@ -612,8 +637,7 @@ } } - struct aws_json_value *properties_node = - aws_json_value_get_from_object(rule_node, aws_byte_cursor_from_c_str("properties")); + struct aws_json_value *properties_node = aws_json_value_get_from_object_c_str(rule_node, "properties"); if (properties_node != NULL) { aws_byte_buf_init(&data_rule->properties, allocator, 0); @@ -638,12 +662,11 @@ aws_hash_callback_string_destroy, s_callback_headers_destroy); - struct aws_json_value *headers_node = - aws_json_value_get_from_object(rule_node, aws_byte_cursor_from_c_str("headers")); + struct aws_json_value *headers_node = aws_json_value_get_from_object_c_str(rule_node, "headers"); if (headers_node != NULL) { if (s_init_members_from_json(allocator, headers_node, &data_rule->headers, s_on_headers_key)) { - AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract parameters."); + AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract headers."); goto on_error; } } @@ -708,7 +731,7 @@ AWS_PRECONDITION(rule_node); AWS_PRECONDITION(rule_data); - struct aws_json_value *rules_node = aws_json_value_get_from_object(rule_node, aws_byte_cursor_from_c_str("rules")); + struct aws_json_value *rules_node = aws_json_value_get_from_object_c_str(rule_node, "rules"); if (rules_node == NULL || !aws_json_value_is_array(rules_node)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Rules node is missing or unexpected type."); return aws_raise_error(AWS_ERROR_SDKUTILS_ENDPOINTS_PARSE_FAILED); @@ -739,7 +762,7 @@ /* Required fields */ struct aws_byte_cursor type_cur; - struct aws_json_value *type_node = aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("type")); + struct aws_json_value *type_node = aws_json_value_get_from_object_c_str(value, "type"); if (type_node == NULL || aws_json_value_get_string(type_node, &type_cur)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract rule type."); return aws_raise_error(AWS_ERROR_SDKUTILS_ENDPOINTS_PARSE_FAILED); @@ -761,8 +784,7 @@ AWS_ZERO_STRUCT(rule); rule.type = type; - struct aws_json_value *conditions_node = - aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("conditions")); + struct aws_json_value *conditions_node = aws_json_value_get_from_object_c_str(value, "conditions"); if (conditions_node == NULL || !aws_json_value_is_array(conditions_node)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Conditions node missing."); goto on_error; @@ -779,8 +801,7 @@ switch (type) { case AWS_ENDPOINTS_RULE_ENDPOINT: { - struct aws_json_value *endpoint_node = - aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("endpoint")); + struct aws_json_value *endpoint_node = aws_json_value_get_from_object_c_str(value, "endpoint"); if (endpoint_node == NULL || s_parse_endpoints_rule_data_endpoint(wrapper->allocator, endpoint_node, &rule.rule_data.endpoint)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract endpoint rule data."); @@ -789,8 +810,7 @@ break; } case AWS_ENDPOINTS_RULE_ERROR: { - struct aws_json_value *error_node = - aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("error")); + struct aws_json_value *error_node = aws_json_value_get_from_object_c_str(value, "error"); if (error_node == NULL || s_parse_endpoints_rule_data_error(wrapper->allocator, error_node, &rule.rule_data.error)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract error rule data."); @@ -810,8 +830,7 @@ } /* Optional fields */ - struct aws_json_value *documentation_node = - aws_json_value_get_from_object(value, aws_byte_cursor_from_c_str("documentation")); + struct aws_json_value *documentation_node = aws_json_value_get_from_object_c_str(value, "documentation"); if (documentation_node != NULL) { if (aws_json_value_get_string(documentation_node, &rule.documentation)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract parameter documentation."); @@ -845,7 +864,7 @@ ruleset->json_root = root; - struct aws_json_value *version_node = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("version")); + struct aws_json_value *version_node = aws_json_value_get_from_object_c_str(root, "version"); if (version_node == NULL || aws_json_value_get_string(version_node, &ruleset->version)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract version."); aws_raise_error(AWS_ERROR_SDKUTILS_ENDPOINTS_UNSUPPORTED_RULESET); @@ -860,8 +879,7 @@ } #endif - struct aws_json_value *service_id_node = - aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("serviceId")); + struct aws_json_value *service_id_node = aws_json_value_get_from_object_c_str(root, "serviceId"); if (service_id_node != NULL && aws_json_value_get_string(service_id_node, &ruleset->service_id)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract serviceId."); @@ -878,8 +896,7 @@ NULL, s_callback_endpoints_parameter_destroy); - struct aws_json_value *parameters_node = - aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("parameters")); + struct aws_json_value *parameters_node = aws_json_value_get_from_object_c_str(root, "parameters"); if (parameters_node == NULL || s_init_members_from_json(allocator, parameters_node, &ruleset->parameters, s_on_parameter_key)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Failed to extract parameters."); @@ -887,7 +904,7 @@ goto on_error; } - struct aws_json_value *rules_node = aws_json_value_get_from_object(root, aws_byte_cursor_from_c_str("rules")); + struct aws_json_value *rules_node = aws_json_value_get_from_object_c_str(root, "rules"); if (rules_node == NULL || !aws_json_value_is_array(rules_node)) { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_PARSING, "Unexpected type for rules node."); aws_raise_error(AWS_ERROR_SDKUTILS_ENDPOINTS_PARSE_FAILED); @@ -914,12 +931,12 @@ struct aws_endpoints_ruleset *ruleset = data; - aws_json_value_destroy(ruleset->json_root); - aws_hash_table_clean_up(&ruleset->parameters); aws_array_list_deep_clean_up(&ruleset->rules, s_on_rule_array_element_clean_up); + aws_json_value_destroy(ruleset->json_root); + aws_mem_release(ruleset->allocator, ruleset); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/source/endpoints_standard_lib.c new/aws-c-sdkutils-0.1.19/source/endpoints_standard_lib.c --- old/aws-c-sdkutils-0.1.16/source/endpoints_standard_lib.c 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/source/endpoints_standard_lib.c 2024-08-03 00:36:14.000000000 +0200 @@ -94,7 +94,8 @@ goto on_done; } } else { - AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Invalid value type for pathing through."); + AWS_LOGF_ERROR( + AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Invalid value type for pathing through. type: %d", argv_value.type); result = aws_raise_error(AWS_ERROR_SDKUTILS_ENDPOINTS_RESOLVE_FAILED); goto on_done; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/source/endpoints_types_impl.c new/aws-c-sdkutils-0.1.19/source/endpoints_types_impl.c --- old/aws-c-sdkutils-0.1.16/source/endpoints_types_impl.c 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/source/endpoints_types_impl.c 2024-08-03 00:36:14.000000000 +0200 @@ -11,6 +11,8 @@ #include <aws/sdkutils/private/endpoints_types_impl.h> #include <aws/sdkutils/private/endpoints_util.h> +void s_endpoints_value_clean_up_cb(void *value); + uint64_t aws_endpoints_fn_name_hash[AWS_ENDPOINTS_FN_LAST]; void aws_endpoints_rule_engine_init(void) { @@ -85,6 +87,10 @@ return; } + if (parameter->has_default_value && parameter->type == AWS_ENDPOINTS_PARAMETER_STRING_ARRAY) { + aws_array_list_deep_clean_up(¶meter->default_value.v.array, s_endpoints_value_clean_up_cb); + } + aws_mem_release(parameter->allocator, parameter); } @@ -189,6 +195,7 @@ return; } aws_string_destroy(scope_value->name.string); + aws_endpoints_value_clean_up(&scope_value->value); aws_mem_release(scope_value->allocator, scope_value); } @@ -198,6 +205,10 @@ void aws_endpoints_value_clean_up(struct aws_endpoints_value *aws_endpoints_value) { AWS_PRECONDITION(aws_endpoints_value); + if (aws_endpoints_value->is_ref) { + goto on_done; + } + if (aws_endpoints_value->type == AWS_ENDPOINTS_VALUE_STRING) { aws_string_destroy(aws_endpoints_value->v.owning_cursor_string.string); } @@ -207,13 +218,14 @@ } if (aws_endpoints_value->type == AWS_ENDPOINTS_VALUE_ARRAY) { - aws_array_list_deep_clean_up(&aws_endpoints_value->v.array, aws_endpoints_value_clean_up_cb); + aws_array_list_deep_clean_up(&aws_endpoints_value->v.array, s_endpoints_value_clean_up_cb); } +on_done: AWS_ZERO_STRUCT(*aws_endpoints_value); } -void aws_endpoints_value_clean_up_cb(void *value) { +void s_endpoints_value_clean_up_cb(void *value) { struct aws_endpoints_value *aws_endpoints_value = value; aws_endpoints_value_clean_up(aws_endpoints_value); } @@ -224,15 +236,35 @@ struct aws_endpoints_value *to) { to->type = from->type; + to->is_ref = false; if (to->type == AWS_ENDPOINTS_VALUE_STRING) { - to->v.owning_cursor_string = aws_endpoints_owning_cursor_create(allocator, from->v.owning_cursor_string.string); + to->v.owning_cursor_string = + aws_endpoints_owning_cursor_from_cursor(allocator, from->v.owning_cursor_string.cur); } else if (to->type == AWS_ENDPOINTS_VALUE_BOOLEAN) { to->v.boolean = from->v.boolean; + } else if (to->type == AWS_ENDPOINTS_VALUE_ARRAY) { + size_t len = aws_array_list_length(&from->v.array); + aws_array_list_init_dynamic(&to->v.array, allocator, len, sizeof(struct aws_endpoints_value)); + for (size_t i = 0; i < len; ++i) { + struct aws_endpoints_value val; + aws_array_list_get_at(&from->v.array, &val, i); + + struct aws_endpoints_value to_val; + if (aws_endpoints_deep_copy_parameter_value(allocator, &val, &to_val)) { + AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Unexpected array element type."); + goto on_error; + } + + aws_array_list_set_at(&to->v.array, &to_val, i); + } } else { AWS_LOGF_ERROR(AWS_LS_SDKUTILS_ENDPOINTS_RESOLVE, "Unexpected value type."); return aws_raise_error(AWS_ERROR_INVALID_STATE); } - return AWS_OP_SUCCESS; + +on_error: + aws_endpoints_value_clean_up(to); + return AWS_OP_ERR; } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/tests/CMakeLists.txt new/aws-c-sdkutils-0.1.19/tests/CMakeLists.txt --- old/aws-c-sdkutils-0.1.16/tests/CMakeLists.txt 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/tests/CMakeLists.txt 2024-08-03 00:36:14.000000000 +0200 @@ -87,6 +87,7 @@ add_test_case(test_endpoints_valid_hostlabel) add_test_case(test_endpoints_condition_mem_clean_up) add_test_case(test_endpoints_custom) +add_test_case(test_endpoints_string_array) add_test_case(endpoints_uri_normalize_path) add_test_case(endpoints_byte_buf_init_from_resolved_templated_string) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/tests/endpoints_rule_engine_tests.c new/aws-c-sdkutils-0.1.19/tests/endpoints_rule_engine_tests.c --- old/aws-c-sdkutils-0.1.16/tests/endpoints_rule_engine_tests.c 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/tests/endpoints_rule_engine_tests.c 2024-08-03 00:36:14.000000000 +0200 @@ -114,6 +114,11 @@ struct aws_endpoints_request_context *context; }; +enum { + /* something is really wrong if there is more than 4 elems during the test */ + MAX_STRING_ARRAY_ELEMENTS = 4 +}; + static int s_on_parameter_key( const struct aws_byte_cursor *key, const struct aws_json_value *value, @@ -125,23 +130,27 @@ if (aws_json_value_is_string(value)) { struct aws_byte_cursor cur; - if (aws_json_value_get_string(value, &cur) || - aws_endpoints_request_context_add_string(wrapper->allocator, wrapper->context, *key, cur)) { - goto on_error; - } + ASSERT_SUCCESS(aws_json_value_get_string(value, &cur)); + ASSERT_SUCCESS(aws_endpoints_request_context_add_string(wrapper->allocator, wrapper->context, *key, cur)); return AWS_OP_SUCCESS; } else if (aws_json_value_is_boolean(value)) { bool b; - if (aws_json_value_get_boolean(value, &b) || - aws_endpoints_request_context_add_boolean(wrapper->allocator, wrapper->context, *key, b)) { - goto on_error; + ASSERT_SUCCESS(aws_json_value_get_boolean(value, &b)); + ASSERT_SUCCESS(aws_endpoints_request_context_add_boolean(wrapper->allocator, wrapper->context, *key, b)); + return AWS_OP_SUCCESS; + } else if (aws_json_value_is_array(value)) { + struct aws_byte_cursor strings[MAX_STRING_ARRAY_ELEMENTS]; + size_t len = aws_json_get_array_size(value); + ASSERT_TRUE(len <= MAX_STRING_ARRAY_ELEMENTS); + for (size_t i = 0; i < len; ++i) { + struct aws_json_value *str = aws_json_get_array_element(value, i); + ASSERT_SUCCESS(aws_json_value_get_string(str, &strings[i])); } + ASSERT_SUCCESS( + aws_endpoints_request_context_add_string_array(wrapper->allocator, wrapper->context, *key, strings, len)); return AWS_OP_SUCCESS; - } else { - goto on_error; } -on_error: return AWS_OP_ERR; } @@ -274,7 +283,6 @@ aws_json_value_get_from_object(endpoint, aws_byte_cursor_from_c_str("url")); struct aws_byte_cursor expected_url; aws_json_value_get_string(expected_url_node, &expected_url); - AWS_LOGF_DEBUG(0, PRInSTR " " PRInSTR, AWS_BYTE_CURSOR_PRI(url), AWS_BYTE_CURSOR_PRI(expected_url)); ASSERT_TRUE(aws_byte_cursor_eq(&url, &expected_url)); struct aws_byte_cursor properties; @@ -485,3 +493,12 @@ return AWS_OP_SUCCESS; } + +AWS_TEST_CASE(test_endpoints_string_array, s_test_endpoints_string_array) +static int s_test_endpoints_string_array(struct aws_allocator *allocator, void *ctx) { + (void)ctx; + + ASSERT_SUCCESS(eval_expected(allocator, aws_byte_cursor_from_c_str("string_array.json"))); + + return AWS_OP_SUCCESS; +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/tests/resources/test-cases/partition-fn.json new/aws-c-sdkutils-0.1.19/tests/resources/test-cases/partition-fn.json --- old/aws-c-sdkutils-0.1.16/tests/resources/test-cases/partition-fn.json 2024-04-22 18:32:19.000000000 +0200 +++ new/aws-c-sdkutils-0.1.19/tests/resources/test-cases/partition-fn.json 2024-08-03 00:36:14.000000000 +0200 @@ -122,4 +122,4 @@ } } ] - } \ No newline at end of file + } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/tests/resources/test-cases/string_array.json new/aws-c-sdkutils-0.1.19/tests/resources/test-cases/string_array.json --- old/aws-c-sdkutils-0.1.16/tests/resources/test-cases/string_array.json 1970-01-01 01:00:00.000000000 +0100 +++ new/aws-c-sdkutils-0.1.19/tests/resources/test-cases/string_array.json 2024-08-03 00:36:14.000000000 +0200 @@ -0,0 +1,45 @@ +{ + "version": "1.0", + "testCases": [ + { + "documentation": "Default array values used", + "params": {}, + "expect": { + "endpoint": { + "url": "https://example.com/defaultValue1" + } + } + }, + { + "documentation": "Empty array", + "params": { + "stringArrayParam": [] + }, + "expect": { + "error": "no array values set" + } + }, + { + "documentation": "Static value", + "params": { + "stringArrayParam": ["staticValue1"] + }, + "expect": { + "endpoint": { + "url": "https://example.com/staticValue1" + } + } + }, + { + "documentation": "bound value from input", + "params": { + "stringArrayParam": ["key1", "key2", "key3", "key4"] + }, + "expect": { + "endpoint": { + "url": "https://example.com/key1" + } + } + } + ] +} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/aws-c-sdkutils-0.1.16/tests/resources/valid-rules/string_array.json new/aws-c-sdkutils-0.1.19/tests/resources/valid-rules/string_array.json --- old/aws-c-sdkutils-0.1.16/tests/resources/valid-rules/string_array.json 1970-01-01 01:00:00.000000000 +0100 +++ new/aws-c-sdkutils-0.1.19/tests/resources/valid-rules/string_array.json 2024-08-03 00:36:14.000000000 +0200 @@ -0,0 +1,38 @@ +{ + "version": "1.0", + "parameters": { + "stringArrayParam": { + "type": "stringArray", + "required": true, + "default": ["defaultValue1", "defaultValue2"], + "documentation": "docs" + } + }, + "rules": [ + { + "documentation": "Template first array value into URI if set", + "conditions": [ + { + "fn": "getAttr", + "argv": [ + { + "ref": "stringArrayParam" + }, + "[0]" + ], + "assign": "arrayValue" + } + ], + "endpoint": { + "url": "https://example.com/{arrayValue}" + }, + "type": "endpoint" + }, + { + "conditions": [], + "documentation": "error fallthrough", + "error": "no array values set", + "type": "error" + } + ] +}