From 34a57d0346afe95e11104462c30dc468b0cb0b89 Mon Sep 17 00:00:00 2001 From: Yash Tibrewal Date: Mon, 23 Oct 2017 15:33:21 -0700 Subject: rename all test core files to cc and a lot of C++ style conversions --- test/core/compression/algorithm_test.c | 97 ------- test/core/compression/algorithm_test.cc | 100 +++++++ test/core/compression/compression_test.c | 214 --------------- test/core/compression/compression_test.cc | 220 +++++++++++++++ test/core/compression/message_compress_test.c | 320 ---------------------- test/core/compression/message_compress_test.cc | 330 +++++++++++++++++++++++ test/core/compression/stream_compression_test.c | 297 -------------------- test/core/compression/stream_compression_test.cc | 298 ++++++++++++++++++++ 8 files changed, 948 insertions(+), 928 deletions(-) delete mode 100644 test/core/compression/algorithm_test.c create mode 100644 test/core/compression/algorithm_test.cc delete mode 100644 test/core/compression/compression_test.c create mode 100644 test/core/compression/compression_test.cc delete mode 100644 test/core/compression/message_compress_test.c create mode 100644 test/core/compression/message_compress_test.cc delete mode 100644 test/core/compression/stream_compression_test.c create mode 100644 test/core/compression/stream_compression_test.cc (limited to 'test/core/compression') diff --git a/test/core/compression/algorithm_test.c b/test/core/compression/algorithm_test.c deleted file mode 100644 index a11e6e90ac..0000000000 --- a/test/core/compression/algorithm_test.c +++ /dev/null @@ -1,97 +0,0 @@ -/* - * - * Copyright 2015 gRPC authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#include "src/core/lib/compression/algorithm_metadata.h" - -#include -#include - -#include -#include -#include - -#include "src/core/lib/slice/slice_internal.h" -#include "src/core/lib/transport/static_metadata.h" -#include "test/core/util/test_config.h" - -static void test_algorithm_mesh(void) { - int i; - - gpr_log(GPR_DEBUG, "test_algorithm_mesh"); - - for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { - const char *name; - grpc_compression_algorithm parsed; - grpc_slice mdstr; - grpc_mdelem mdelem; - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - GPR_ASSERT( - grpc_compression_algorithm_name((grpc_compression_algorithm)i, &name)); - GPR_ASSERT(grpc_compression_algorithm_parse( - grpc_slice_from_static_string(name), &parsed)); - GPR_ASSERT((int)parsed == i); - mdstr = grpc_slice_from_copied_string(name); - GPR_ASSERT(grpc_slice_eq(mdstr, grpc_compression_algorithm_slice(parsed))); - GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr)); - mdelem = grpc_compression_encoding_mdelem(parsed); - GPR_ASSERT(grpc_slice_eq(GRPC_MDVALUE(mdelem), mdstr)); - GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING)); - grpc_slice_unref_internal(&exec_ctx, mdstr); - GRPC_MDELEM_UNREF(&exec_ctx, mdelem); - grpc_exec_ctx_finish(&exec_ctx); - } - - /* test failure */ - GPR_ASSERT(GRPC_MDISNULL( - grpc_compression_encoding_mdelem(GRPC_COMPRESS_ALGORITHMS_COUNT))); -} - -static void test_algorithm_failure(void) { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - grpc_slice mdstr; - - gpr_log(GPR_DEBUG, "test_algorithm_failure"); - - GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT, - NULL) == 0); - GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT + 1, - NULL) == 0); - mdstr = grpc_slice_from_static_string("this-is-an-invalid-algorithm"); - GPR_ASSERT(grpc_compression_algorithm_from_slice(mdstr) == - GRPC_COMPRESS_ALGORITHMS_COUNT); - GPR_ASSERT(grpc_slice_eq( - grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT), - grpc_empty_slice())); - GPR_ASSERT(grpc_slice_eq( - grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT + 1), - grpc_empty_slice())); - grpc_slice_unref_internal(&exec_ctx, mdstr); - grpc_exec_ctx_finish(&exec_ctx); -} - -int main(int argc, char **argv) { - grpc_test_init(argc, argv); - grpc_init(); - - test_algorithm_mesh(); - test_algorithm_failure(); - - grpc_shutdown(); - - return 0; -} diff --git a/test/core/compression/algorithm_test.cc b/test/core/compression/algorithm_test.cc new file mode 100644 index 0000000000..4ca979e30f --- /dev/null +++ b/test/core/compression/algorithm_test.cc @@ -0,0 +1,100 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "src/core/lib/compression/algorithm_metadata.h" + +#include +#include + +#include +#include +#include + +#include "src/core/lib/slice/slice_internal.h" +#include "src/core/lib/transport/static_metadata.h" +#include "test/core/util/test_config.h" + +static void test_algorithm_mesh(void) { + int i; + + gpr_log(GPR_DEBUG, "test_algorithm_mesh"); + + for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { + const char *name; + grpc_compression_algorithm parsed; + grpc_slice mdstr; + grpc_mdelem mdelem; + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + GPR_ASSERT( + grpc_compression_algorithm_name((grpc_compression_algorithm)i, &name)); + GPR_ASSERT(grpc_compression_algorithm_parse( + grpc_slice_from_static_string(name), &parsed)); + GPR_ASSERT((int)parsed == i); + mdstr = grpc_slice_from_copied_string(name); + GPR_ASSERT(grpc_slice_eq(mdstr, grpc_compression_algorithm_slice(parsed))); + GPR_ASSERT(parsed == grpc_compression_algorithm_from_slice(mdstr)); + mdelem = grpc_compression_encoding_mdelem(parsed); + GPR_ASSERT(grpc_slice_eq(GRPC_MDVALUE(mdelem), mdstr)); + GPR_ASSERT(grpc_slice_eq(GRPC_MDKEY(mdelem), GRPC_MDSTR_GRPC_ENCODING)); + grpc_slice_unref_internal(&exec_ctx, mdstr); + GRPC_MDELEM_UNREF(&exec_ctx, mdelem); + grpc_exec_ctx_finish(&exec_ctx); + } + + /* test failure */ + GPR_ASSERT(GRPC_MDISNULL( + grpc_compression_encoding_mdelem(GRPC_COMPRESS_ALGORITHMS_COUNT))); +} + +static void test_algorithm_failure(void) { + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + grpc_slice mdstr; + + gpr_log(GPR_DEBUG, "test_algorithm_failure"); + + GPR_ASSERT(grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT, + NULL) == 0); + GPR_ASSERT( + grpc_compression_algorithm_name(static_cast( + GRPC_COMPRESS_ALGORITHMS_COUNT + 1), + NULL) == 0); + mdstr = grpc_slice_from_static_string("this-is-an-invalid-algorithm"); + GPR_ASSERT(grpc_compression_algorithm_from_slice(mdstr) == + GRPC_COMPRESS_ALGORITHMS_COUNT); + GPR_ASSERT(grpc_slice_eq( + grpc_compression_algorithm_slice(GRPC_COMPRESS_ALGORITHMS_COUNT), + grpc_empty_slice())); + GPR_ASSERT(grpc_slice_eq( + grpc_compression_algorithm_slice(static_cast( + static_cast(GRPC_COMPRESS_ALGORITHMS_COUNT) + 1)), + grpc_empty_slice())); + grpc_slice_unref_internal(&exec_ctx, mdstr); + grpc_exec_ctx_finish(&exec_ctx); +} + +int main(int argc, char **argv) { + grpc_test_init(argc, argv); + grpc_init(); + + test_algorithm_mesh(); + test_algorithm_failure(); + + grpc_shutdown(); + + return 0; +} diff --git a/test/core/compression/compression_test.c b/test/core/compression/compression_test.c deleted file mode 100644 index 326a800300..0000000000 --- a/test/core/compression/compression_test.c +++ /dev/null @@ -1,214 +0,0 @@ -/* - * - * Copyright 2015 gRPC authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#include -#include - -#include -#include -#include -#include - -#include "test/core/util/test_config.h" - -static void test_compression_algorithm_parse(void) { - size_t i; - const char *valid_names[] = {"identity", "gzip", "deflate"}; - const grpc_compression_algorithm valid_algorithms[] = { - GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE}; - const char *invalid_names[] = {"gzip2", "foo", "", "2gzip"}; - - gpr_log(GPR_DEBUG, "test_compression_algorithm_parse"); - - for (i = 0; i < GPR_ARRAY_SIZE(valid_names); i++) { - const char *valid_name = valid_names[i]; - grpc_compression_algorithm algorithm; - const int success = grpc_compression_algorithm_parse( - grpc_slice_from_static_string(valid_name), &algorithm); - GPR_ASSERT(success != 0); - GPR_ASSERT(algorithm == valid_algorithms[i]); - } - - for (i = 0; i < GPR_ARRAY_SIZE(invalid_names); i++) { - const char *invalid_name = invalid_names[i]; - grpc_compression_algorithm algorithm; - int success; - success = grpc_compression_algorithm_parse( - grpc_slice_from_static_string(invalid_name), &algorithm); - GPR_ASSERT(success == 0); - /* the value of "algorithm" is undefined upon failure */ - } -} - -static void test_compression_algorithm_name(void) { - int success; - const char *name; - size_t i; - const char *valid_names[] = {"identity", "gzip", "deflate"}; - const grpc_compression_algorithm valid_algorithms[] = { - GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE}; - - gpr_log(GPR_DEBUG, "test_compression_algorithm_name"); - - for (i = 0; i < GPR_ARRAY_SIZE(valid_algorithms); i++) { - success = grpc_compression_algorithm_name(valid_algorithms[i], &name); - GPR_ASSERT(success != 0); - GPR_ASSERT(strcmp(name, valid_names[i]) == 0); - } - - success = - grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT, &name); - GPR_ASSERT(success == 0); - /* the value of "name" is undefined upon failure */ -} - -static void test_compression_algorithm_for_level(void) { - gpr_log(GPR_DEBUG, "test_compression_algorithm_for_level"); - - { - /* accept only identity (aka none) */ - uint32_t accepted_encodings = 0; - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ - - GPR_ASSERT(GRPC_COMPRESS_NONE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_NONE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_NONE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_NONE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, - accepted_encodings)); - } - - { - /* accept only gzip */ - uint32_t accepted_encodings = 0; - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP); - - GPR_ASSERT(GRPC_COMPRESS_NONE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_GZIP == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_GZIP == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_GZIP == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, - accepted_encodings)); - } - - { - /* accept only deflate */ - uint32_t accepted_encodings = 0; - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE); - - GPR_ASSERT(GRPC_COMPRESS_NONE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_DEFLATE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_DEFLATE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_DEFLATE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, - accepted_encodings)); - } - - { - /* accept gzip and deflate */ - uint32_t accepted_encodings = 0; - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP); - GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE); - - GPR_ASSERT(GRPC_COMPRESS_NONE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_GZIP == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_DEFLATE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, - accepted_encodings)); - - GPR_ASSERT(GRPC_COMPRESS_DEFLATE == - grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, - accepted_encodings)); - } -} - -static void test_compression_enable_disable_algorithm(void) { - grpc_compression_options options; - grpc_compression_algorithm algorithm; - - gpr_log(GPR_DEBUG, "test_compression_enable_disable_algorithm"); - - grpc_compression_options_init(&options); - for (algorithm = GRPC_COMPRESS_NONE; - algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) { - /* all algorithms are enabled by default */ - GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options, - algorithm) != 0); - } - /* disable one by one */ - for (algorithm = GRPC_COMPRESS_NONE; - algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) { - grpc_compression_options_disable_algorithm(&options, algorithm); - GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options, - algorithm) == 0); - } - /* re-enable one by one */ - for (algorithm = GRPC_COMPRESS_NONE; - algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; algorithm++) { - grpc_compression_options_enable_algorithm(&options, algorithm); - GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options, - algorithm) != 0); - } -} - -int main(int argc, char **argv) { - grpc_init(); - test_compression_algorithm_parse(); - test_compression_algorithm_name(); - test_compression_algorithm_for_level(); - test_compression_enable_disable_algorithm(); - grpc_shutdown(); - - return 0; -} diff --git a/test/core/compression/compression_test.cc b/test/core/compression/compression_test.cc new file mode 100644 index 0000000000..f4fa3a8d63 --- /dev/null +++ b/test/core/compression/compression_test.cc @@ -0,0 +1,220 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include +#include + +#include +#include +#include +#include + +#include "test/core/util/test_config.h" + +static void test_compression_algorithm_parse(void) { + size_t i; + const char *valid_names[] = {"identity", "gzip", "deflate"}; + const grpc_compression_algorithm valid_algorithms[] = { + GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE}; + const char *invalid_names[] = {"gzip2", "foo", "", "2gzip"}; + + gpr_log(GPR_DEBUG, "test_compression_algorithm_parse"); + + for (i = 0; i < GPR_ARRAY_SIZE(valid_names); i++) { + const char *valid_name = valid_names[i]; + grpc_compression_algorithm algorithm; + const int success = grpc_compression_algorithm_parse( + grpc_slice_from_static_string(valid_name), &algorithm); + GPR_ASSERT(success != 0); + GPR_ASSERT(algorithm == valid_algorithms[i]); + } + + for (i = 0; i < GPR_ARRAY_SIZE(invalid_names); i++) { + const char *invalid_name = invalid_names[i]; + grpc_compression_algorithm algorithm; + int success; + success = grpc_compression_algorithm_parse( + grpc_slice_from_static_string(invalid_name), &algorithm); + GPR_ASSERT(success == 0); + /* the value of "algorithm" is undefined upon failure */ + } +} + +static void test_compression_algorithm_name(void) { + int success; + const char *name; + size_t i; + const char *valid_names[] = {"identity", "gzip", "deflate"}; + const grpc_compression_algorithm valid_algorithms[] = { + GRPC_COMPRESS_NONE, GRPC_COMPRESS_GZIP, GRPC_COMPRESS_DEFLATE}; + + gpr_log(GPR_DEBUG, "test_compression_algorithm_name"); + + for (i = 0; i < GPR_ARRAY_SIZE(valid_algorithms); i++) { + success = grpc_compression_algorithm_name(valid_algorithms[i], &name); + GPR_ASSERT(success != 0); + GPR_ASSERT(strcmp(name, valid_names[i]) == 0); + } + + success = + grpc_compression_algorithm_name(GRPC_COMPRESS_ALGORITHMS_COUNT, &name); + GPR_ASSERT(success == 0); + /* the value of "name" is undefined upon failure */ +} + +static void test_compression_algorithm_for_level(void) { + gpr_log(GPR_DEBUG, "test_compression_algorithm_for_level"); + + { + /* accept only identity (aka none) */ + uint32_t accepted_encodings = 0; + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ + + GPR_ASSERT(GRPC_COMPRESS_NONE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_NONE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_NONE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_NONE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, + accepted_encodings)); + } + + { + /* accept only gzip */ + uint32_t accepted_encodings = 0; + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP); + + GPR_ASSERT(GRPC_COMPRESS_NONE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_GZIP == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_GZIP == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_GZIP == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, + accepted_encodings)); + } + + { + /* accept only deflate */ + uint32_t accepted_encodings = 0; + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE); + + GPR_ASSERT(GRPC_COMPRESS_NONE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_DEFLATE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_DEFLATE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_DEFLATE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, + accepted_encodings)); + } + + { + /* accept gzip and deflate */ + uint32_t accepted_encodings = 0; + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_NONE); /* always */ + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_GZIP); + GPR_BITSET(&accepted_encodings, GRPC_COMPRESS_DEFLATE); + + GPR_ASSERT(GRPC_COMPRESS_NONE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_NONE, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_GZIP == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_LOW, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_DEFLATE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_MED, + accepted_encodings)); + + GPR_ASSERT(GRPC_COMPRESS_DEFLATE == + grpc_compression_algorithm_for_level(GRPC_COMPRESS_LEVEL_HIGH, + accepted_encodings)); + } +} + +static void test_compression_enable_disable_algorithm(void) { + grpc_compression_options options; + grpc_compression_algorithm algorithm; + + gpr_log(GPR_DEBUG, "test_compression_enable_disable_algorithm"); + + grpc_compression_options_init(&options); + for (algorithm = GRPC_COMPRESS_NONE; + algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; + algorithm = static_cast( + static_cast(algorithm) + 1)) { + /* all algorithms are enabled by default */ + GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options, + algorithm) != 0); + } + /* disable one by one */ + for (algorithm = GRPC_COMPRESS_NONE; + algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; + algorithm = static_cast( + static_cast(algorithm) + 1)) { + grpc_compression_options_disable_algorithm(&options, algorithm); + GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options, + algorithm) == 0); + } + /* re-enable one by one */ + for (algorithm = GRPC_COMPRESS_NONE; + algorithm < GRPC_COMPRESS_ALGORITHMS_COUNT; + algorithm = static_cast( + static_cast(algorithm) + 1)) { + grpc_compression_options_enable_algorithm(&options, algorithm); + GPR_ASSERT(grpc_compression_options_is_algorithm_enabled(&options, + algorithm) != 0); + } +} + +int main(int argc, char **argv) { + grpc_init(); + test_compression_algorithm_parse(); + test_compression_algorithm_name(); + test_compression_algorithm_for_level(); + test_compression_enable_disable_algorithm(); + grpc_shutdown(); + + return 0; +} diff --git a/test/core/compression/message_compress_test.c b/test/core/compression/message_compress_test.c deleted file mode 100644 index f7f4893dee..0000000000 --- a/test/core/compression/message_compress_test.c +++ /dev/null @@ -1,320 +0,0 @@ -/* - * - * Copyright 2015 gRPC authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#include "src/core/lib/compression/message_compress.h" - -#include -#include - -#include -#include -#include - -#include "src/core/lib/iomgr/exec_ctx.h" -#include "src/core/lib/support/murmur_hash.h" -#include "test/core/util/slice_splitter.h" -#include "test/core/util/test_config.h" - -typedef enum { ONE_A = 0, ONE_KB_A, ONE_MB_A, TEST_VALUE_COUNT } test_value; - -typedef enum { - SHOULD_NOT_COMPRESS, - SHOULD_COMPRESS, - MAYBE_COMPRESSES -} compressability; - -static void assert_passthrough(grpc_slice value, - grpc_compression_algorithm algorithm, - grpc_slice_split_mode uncompressed_split_mode, - grpc_slice_split_mode compressed_split_mode, - compressability compress_result_check) { - grpc_slice_buffer input; - grpc_slice_buffer compressed_raw; - grpc_slice_buffer compressed; - grpc_slice_buffer output; - grpc_slice final; - int was_compressed; - const char *algorithm_name; - - GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algorithm_name) != 0); - gpr_log( - GPR_INFO, "assert_passthrough: value_length=%" PRIuPTR - " value_hash=0x%08x " - "algorithm='%s' uncompressed_split='%s' compressed_split='%s'", - GRPC_SLICE_LENGTH(value), gpr_murmur_hash3(GRPC_SLICE_START_PTR(value), - GRPC_SLICE_LENGTH(value), 0), - algorithm_name, grpc_slice_split_mode_name(uncompressed_split_mode), - grpc_slice_split_mode_name(compressed_split_mode)); - - grpc_slice_buffer_init(&input); - grpc_slice_buffer_init(&compressed_raw); - grpc_slice_buffer_init(&compressed); - grpc_slice_buffer_init(&output); - - grpc_split_slices_to_buffer(uncompressed_split_mode, &value, 1, &input); - - { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - was_compressed = - grpc_msg_compress(&exec_ctx, algorithm, &input, &compressed_raw); - grpc_exec_ctx_finish(&exec_ctx); - } - GPR_ASSERT(input.count > 0); - - switch (compress_result_check) { - case SHOULD_NOT_COMPRESS: - GPR_ASSERT(was_compressed == 0); - break; - case SHOULD_COMPRESS: - GPR_ASSERT(was_compressed == 1); - break; - case MAYBE_COMPRESSES: - /* no check */ - break; - } - - grpc_split_slice_buffer(compressed_split_mode, &compressed_raw, &compressed); - - { - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - GPR_ASSERT(grpc_msg_decompress( - &exec_ctx, was_compressed ? algorithm : GRPC_COMPRESS_NONE, &compressed, - &output)); - grpc_exec_ctx_finish(&exec_ctx); - } - - final = grpc_slice_merge(output.slices, output.count); - GPR_ASSERT(grpc_slice_eq(value, final)); - - grpc_slice_buffer_destroy(&input); - grpc_slice_buffer_destroy(&compressed); - grpc_slice_buffer_destroy(&compressed_raw); - grpc_slice_buffer_destroy(&output); - grpc_slice_unref(final); -} - -static grpc_slice repeated(char c, size_t length) { - grpc_slice out = grpc_slice_malloc(length); - memset(GRPC_SLICE_START_PTR(out), c, length); - return out; -} - -static compressability get_compressability( - test_value id, grpc_compression_algorithm algorithm) { - if (algorithm == GRPC_COMPRESS_NONE) return SHOULD_NOT_COMPRESS; - switch (id) { - case ONE_A: - return SHOULD_NOT_COMPRESS; - case ONE_KB_A: - case ONE_MB_A: - return SHOULD_COMPRESS; - case TEST_VALUE_COUNT: - abort(); - break; - } - return MAYBE_COMPRESSES; -} - -static grpc_slice create_test_value(test_value id) { - switch (id) { - case ONE_A: - return grpc_slice_from_copied_string("a"); - case ONE_KB_A: - return repeated('a', 1024); - case ONE_MB_A: - return repeated('a', 1024 * 1024); - case TEST_VALUE_COUNT: - abort(); - break; - } - return grpc_slice_from_copied_string("bad value"); -} - -static void test_tiny_data_compress(void) { - grpc_slice_buffer input; - grpc_slice_buffer output; - grpc_compression_algorithm i; - - grpc_slice_buffer_init(&input); - grpc_slice_buffer_init(&output); - grpc_slice_buffer_add(&input, create_test_value(ONE_A)); - - for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { - if (i == GRPC_COMPRESS_NONE) continue; - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - GPR_ASSERT(0 == grpc_msg_compress(&exec_ctx, i, &input, &output)); - grpc_exec_ctx_finish(&exec_ctx); - GPR_ASSERT(1 == output.count); - } - - grpc_slice_buffer_destroy(&input); - grpc_slice_buffer_destroy(&output); -} - -static void test_bad_decompression_data_crc(void) { - grpc_slice_buffer input; - grpc_slice_buffer corrupted; - grpc_slice_buffer output; - size_t idx; - const uint32_t bad = 0xdeadbeef; - - grpc_slice_buffer_init(&input); - grpc_slice_buffer_init(&corrupted); - grpc_slice_buffer_init(&output); - grpc_slice_buffer_add(&input, create_test_value(ONE_MB_A)); - - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - /* compress it */ - grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_GZIP, &input, &corrupted); - /* corrupt the output by smashing the CRC */ - GPR_ASSERT(corrupted.count > 1); - GPR_ASSERT(GRPC_SLICE_LENGTH(corrupted.slices[1]) > 8); - idx = GRPC_SLICE_LENGTH(corrupted.slices[1]) - 8; - memcpy(GRPC_SLICE_START_PTR(corrupted.slices[1]) + idx, &bad, 4); - - /* try (and fail) to decompress the corrupted compresed buffer */ - GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_GZIP, &corrupted, - &output)); - grpc_exec_ctx_finish(&exec_ctx); - - grpc_slice_buffer_destroy(&input); - grpc_slice_buffer_destroy(&corrupted); - grpc_slice_buffer_destroy(&output); -} - -static void test_bad_decompression_data_trailing_garbage(void) { - grpc_slice_buffer input; - grpc_slice_buffer output; - - grpc_slice_buffer_init(&input); - grpc_slice_buffer_init(&output); - /* append 0x99 to the end of an otherwise valid stream */ - grpc_slice_buffer_add( - &input, grpc_slice_from_copied_buffer( - "\x78\xda\x63\x60\x60\x60\x00\x00\x00\x04\x00\x01\x99", 13)); - - /* try (and fail) to decompress the invalid compresed buffer */ - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input, - &output)); - grpc_exec_ctx_finish(&exec_ctx); - - grpc_slice_buffer_destroy(&input); - grpc_slice_buffer_destroy(&output); -} - -static void test_bad_decompression_data_stream(void) { - grpc_slice_buffer input; - grpc_slice_buffer output; - - grpc_slice_buffer_init(&input); - grpc_slice_buffer_init(&output); - grpc_slice_buffer_add(&input, - grpc_slice_from_copied_buffer("\x78\xda\xff\xff", 4)); - - /* try (and fail) to decompress the invalid compresed buffer */ - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input, - &output)); - grpc_exec_ctx_finish(&exec_ctx); - - grpc_slice_buffer_destroy(&input); - grpc_slice_buffer_destroy(&output); -} - -static void test_bad_compression_algorithm(void) { - grpc_slice_buffer input; - grpc_slice_buffer output; - int was_compressed; - - grpc_slice_buffer_init(&input); - grpc_slice_buffer_init(&output); - grpc_slice_buffer_add( - &input, grpc_slice_from_copied_string("Never gonna give you up")); - - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - was_compressed = grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT, - &input, &output); - GPR_ASSERT(0 == was_compressed); - - was_compressed = grpc_msg_compress( - &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output); - GPR_ASSERT(0 == was_compressed); - grpc_exec_ctx_finish(&exec_ctx); - - grpc_slice_buffer_destroy(&input); - grpc_slice_buffer_destroy(&output); -} - -static void test_bad_decompression_algorithm(void) { - grpc_slice_buffer input; - grpc_slice_buffer output; - int was_decompressed; - - grpc_slice_buffer_init(&input); - grpc_slice_buffer_init(&output); - grpc_slice_buffer_add(&input, - grpc_slice_from_copied_string( - "I'm not really compressed but it doesn't matter")); - grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; - was_decompressed = grpc_msg_decompress( - &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT, &input, &output); - GPR_ASSERT(0 == was_decompressed); - - was_decompressed = grpc_msg_decompress( - &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT + 123, &input, &output); - GPR_ASSERT(0 == was_decompressed); - grpc_exec_ctx_finish(&exec_ctx); - - grpc_slice_buffer_destroy(&input); - grpc_slice_buffer_destroy(&output); -} - -int main(int argc, char **argv) { - unsigned i, j, k, m; - grpc_slice_split_mode uncompressed_split_modes[] = { - GRPC_SLICE_SPLIT_IDENTITY, GRPC_SLICE_SPLIT_ONE_BYTE}; - grpc_slice_split_mode compressed_split_modes[] = {GRPC_SLICE_SPLIT_MERGE_ALL, - GRPC_SLICE_SPLIT_IDENTITY, - GRPC_SLICE_SPLIT_ONE_BYTE}; - - grpc_test_init(argc, argv); - grpc_init(); - - for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { - for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) { - for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) { - for (m = 0; m < TEST_VALUE_COUNT; m++) { - grpc_slice slice = create_test_value(m); - assert_passthrough(slice, i, j, k, get_compressability(m, i)); - grpc_slice_unref(slice); - } - } - } - } - - test_tiny_data_compress(); - test_bad_decompression_data_crc(); - test_bad_decompression_data_stream(); - test_bad_decompression_data_trailing_garbage(); - test_bad_compression_algorithm(); - test_bad_decompression_algorithm(); - grpc_shutdown(); - - return 0; -} diff --git a/test/core/compression/message_compress_test.cc b/test/core/compression/message_compress_test.cc new file mode 100644 index 0000000000..1395d42739 --- /dev/null +++ b/test/core/compression/message_compress_test.cc @@ -0,0 +1,330 @@ +/* + * + * Copyright 2015 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include "src/core/lib/compression/message_compress.h" + +#include +#include + +#include +#include +#include + +#include "src/core/lib/iomgr/exec_ctx.h" +#include "src/core/lib/support/murmur_hash.h" +#include "test/core/util/slice_splitter.h" +#include "test/core/util/test_config.h" + +typedef enum { ONE_A = 0, ONE_KB_A, ONE_MB_A, TEST_VALUE_COUNT } test_value; + +typedef enum { + SHOULD_NOT_COMPRESS, + SHOULD_COMPRESS, + MAYBE_COMPRESSES +} compressability; + +static void assert_passthrough(grpc_slice value, + grpc_compression_algorithm algorithm, + grpc_slice_split_mode uncompressed_split_mode, + grpc_slice_split_mode compressed_split_mode, + compressability compress_result_check) { + grpc_slice_buffer input; + grpc_slice_buffer compressed_raw; + grpc_slice_buffer compressed; + grpc_slice_buffer output; + grpc_slice final; + int was_compressed; + const char *algorithm_name; + + GPR_ASSERT(grpc_compression_algorithm_name(algorithm, &algorithm_name) != 0); + gpr_log( + GPR_INFO, "assert_passthrough: value_length=%" PRIuPTR + " value_hash=0x%08x " + "algorithm='%s' uncompressed_split='%s' compressed_split='%s'", + GRPC_SLICE_LENGTH(value), gpr_murmur_hash3(GRPC_SLICE_START_PTR(value), + GRPC_SLICE_LENGTH(value), 0), + algorithm_name, grpc_slice_split_mode_name(uncompressed_split_mode), + grpc_slice_split_mode_name(compressed_split_mode)); + + grpc_slice_buffer_init(&input); + grpc_slice_buffer_init(&compressed_raw); + grpc_slice_buffer_init(&compressed); + grpc_slice_buffer_init(&output); + + grpc_split_slices_to_buffer(uncompressed_split_mode, &value, 1, &input); + + { + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + was_compressed = + grpc_msg_compress(&exec_ctx, algorithm, &input, &compressed_raw); + grpc_exec_ctx_finish(&exec_ctx); + } + GPR_ASSERT(input.count > 0); + + switch (compress_result_check) { + case SHOULD_NOT_COMPRESS: + GPR_ASSERT(was_compressed == 0); + break; + case SHOULD_COMPRESS: + GPR_ASSERT(was_compressed == 1); + break; + case MAYBE_COMPRESSES: + /* no check */ + break; + } + + grpc_split_slice_buffer(compressed_split_mode, &compressed_raw, &compressed); + + { + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + GPR_ASSERT(grpc_msg_decompress( + &exec_ctx, was_compressed ? algorithm : GRPC_COMPRESS_NONE, &compressed, + &output)); + grpc_exec_ctx_finish(&exec_ctx); + } + + final = grpc_slice_merge(output.slices, output.count); + GPR_ASSERT(grpc_slice_eq(value, final)); + + grpc_slice_buffer_destroy(&input); + grpc_slice_buffer_destroy(&compressed); + grpc_slice_buffer_destroy(&compressed_raw); + grpc_slice_buffer_destroy(&output); + grpc_slice_unref(final); +} + +static grpc_slice repeated(char c, size_t length) { + grpc_slice out = grpc_slice_malloc(length); + memset(GRPC_SLICE_START_PTR(out), c, length); + return out; +} + +static compressability get_compressability( + test_value id, grpc_compression_algorithm algorithm) { + if (algorithm == GRPC_COMPRESS_NONE) return SHOULD_NOT_COMPRESS; + switch (id) { + case ONE_A: + return SHOULD_NOT_COMPRESS; + case ONE_KB_A: + case ONE_MB_A: + return SHOULD_COMPRESS; + case TEST_VALUE_COUNT: + abort(); + break; + } + return MAYBE_COMPRESSES; +} + +static grpc_slice create_test_value(test_value id) { + switch (id) { + case ONE_A: + return grpc_slice_from_copied_string("a"); + case ONE_KB_A: + return repeated('a', 1024); + case ONE_MB_A: + return repeated('a', 1024 * 1024); + case TEST_VALUE_COUNT: + abort(); + break; + } + return grpc_slice_from_copied_string("bad value"); +} + +static void test_tiny_data_compress(void) { + grpc_slice_buffer input; + grpc_slice_buffer output; + + grpc_slice_buffer_init(&input); + grpc_slice_buffer_init(&output); + grpc_slice_buffer_add(&input, create_test_value(ONE_A)); + + for (int i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { + if (i == GRPC_COMPRESS_NONE) continue; + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + GPR_ASSERT(0 == grpc_msg_compress( + &exec_ctx, static_cast(i), + &input, &output)); + grpc_exec_ctx_finish(&exec_ctx); + GPR_ASSERT(1 == output.count); + } + + grpc_slice_buffer_destroy(&input); + grpc_slice_buffer_destroy(&output); +} + +static void test_bad_decompression_data_crc(void) { + grpc_slice_buffer input; + grpc_slice_buffer corrupted; + grpc_slice_buffer output; + size_t idx; + const uint32_t bad = 0xdeadbeef; + + grpc_slice_buffer_init(&input); + grpc_slice_buffer_init(&corrupted); + grpc_slice_buffer_init(&output); + grpc_slice_buffer_add(&input, create_test_value(ONE_MB_A)); + + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + /* compress it */ + grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_GZIP, &input, &corrupted); + /* corrupt the output by smashing the CRC */ + GPR_ASSERT(corrupted.count > 1); + GPR_ASSERT(GRPC_SLICE_LENGTH(corrupted.slices[1]) > 8); + idx = GRPC_SLICE_LENGTH(corrupted.slices[1]) - 8; + memcpy(GRPC_SLICE_START_PTR(corrupted.slices[1]) + idx, &bad, 4); + + /* try (and fail) to decompress the corrupted compresed buffer */ + GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_GZIP, &corrupted, + &output)); + grpc_exec_ctx_finish(&exec_ctx); + + grpc_slice_buffer_destroy(&input); + grpc_slice_buffer_destroy(&corrupted); + grpc_slice_buffer_destroy(&output); +} + +static void test_bad_decompression_data_trailing_garbage(void) { + grpc_slice_buffer input; + grpc_slice_buffer output; + + grpc_slice_buffer_init(&input); + grpc_slice_buffer_init(&output); + /* append 0x99 to the end of an otherwise valid stream */ + grpc_slice_buffer_add( + &input, grpc_slice_from_copied_buffer( + "\x78\xda\x63\x60\x60\x60\x00\x00\x00\x04\x00\x01\x99", 13)); + + /* try (and fail) to decompress the invalid compresed buffer */ + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input, + &output)); + grpc_exec_ctx_finish(&exec_ctx); + + grpc_slice_buffer_destroy(&input); + grpc_slice_buffer_destroy(&output); +} + +static void test_bad_decompression_data_stream(void) { + grpc_slice_buffer input; + grpc_slice_buffer output; + + grpc_slice_buffer_init(&input); + grpc_slice_buffer_init(&output); + grpc_slice_buffer_add(&input, + grpc_slice_from_copied_buffer("\x78\xda\xff\xff", 4)); + + /* try (and fail) to decompress the invalid compresed buffer */ + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + GPR_ASSERT(0 == grpc_msg_decompress(&exec_ctx, GRPC_COMPRESS_DEFLATE, &input, + &output)); + grpc_exec_ctx_finish(&exec_ctx); + + grpc_slice_buffer_destroy(&input); + grpc_slice_buffer_destroy(&output); +} + +static void test_bad_compression_algorithm(void) { + grpc_slice_buffer input; + grpc_slice_buffer output; + int was_compressed; + + grpc_slice_buffer_init(&input); + grpc_slice_buffer_init(&output); + grpc_slice_buffer_add( + &input, grpc_slice_from_copied_string("Never gonna give you up")); + + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + was_compressed = grpc_msg_compress(&exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT, + &input, &output); + GPR_ASSERT(0 == was_compressed); + + was_compressed = + grpc_msg_compress(&exec_ctx, static_cast( + GRPC_COMPRESS_ALGORITHMS_COUNT + 123), + &input, &output); + GPR_ASSERT(0 == was_compressed); + grpc_exec_ctx_finish(&exec_ctx); + + grpc_slice_buffer_destroy(&input); + grpc_slice_buffer_destroy(&output); +} + +static void test_bad_decompression_algorithm(void) { + grpc_slice_buffer input; + grpc_slice_buffer output; + int was_decompressed; + + grpc_slice_buffer_init(&input); + grpc_slice_buffer_init(&output); + grpc_slice_buffer_add(&input, + grpc_slice_from_copied_string( + "I'm not really compressed but it doesn't matter")); + grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT; + was_decompressed = grpc_msg_decompress( + &exec_ctx, GRPC_COMPRESS_ALGORITHMS_COUNT, &input, &output); + GPR_ASSERT(0 == was_decompressed); + + was_decompressed = + grpc_msg_decompress(&exec_ctx, static_cast( + GRPC_COMPRESS_ALGORITHMS_COUNT + 123), + &input, &output); + GPR_ASSERT(0 == was_decompressed); + grpc_exec_ctx_finish(&exec_ctx); + + grpc_slice_buffer_destroy(&input); + grpc_slice_buffer_destroy(&output); +} + +int main(int argc, char **argv) { + unsigned i, j, k, m; + grpc_slice_split_mode uncompressed_split_modes[] = { + GRPC_SLICE_SPLIT_IDENTITY, GRPC_SLICE_SPLIT_ONE_BYTE}; + grpc_slice_split_mode compressed_split_modes[] = {GRPC_SLICE_SPLIT_MERGE_ALL, + GRPC_SLICE_SPLIT_IDENTITY, + GRPC_SLICE_SPLIT_ONE_BYTE}; + + grpc_test_init(argc, argv); + grpc_init(); + + for (i = 0; i < GRPC_COMPRESS_ALGORITHMS_COUNT; i++) { + for (j = 0; j < GPR_ARRAY_SIZE(uncompressed_split_modes); j++) { + for (k = 0; k < GPR_ARRAY_SIZE(compressed_split_modes); k++) { + for (m = 0; m < TEST_VALUE_COUNT; m++) { + grpc_slice slice = create_test_value(static_cast(m)); + assert_passthrough( + slice, static_cast(i), + static_cast(j), + static_cast(k), + get_compressability(static_cast(m), + static_cast(i))); + grpc_slice_unref(slice); + } + } + } + } + + test_tiny_data_compress(); + test_bad_decompression_data_crc(); + test_bad_decompression_data_stream(); + test_bad_decompression_data_trailing_garbage(); + test_bad_compression_algorithm(); + test_bad_decompression_algorithm(); + grpc_shutdown(); + + return 0; +} diff --git a/test/core/compression/stream_compression_test.c b/test/core/compression/stream_compression_test.c deleted file mode 100644 index afed6cd6b5..0000000000 --- a/test/core/compression/stream_compression_test.c +++ /dev/null @@ -1,297 +0,0 @@ -/* - * - * Copyright 2017 gRPC authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - */ - -#include - -#include -#include -#include -#include - -#include "src/core/lib/compression/stream_compression.h" - -static void generate_random_payload(char *payload, size_t size) { - size_t i; - static const char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890"; - for (i = 0; i < size - 1; ++i) { - payload[i] = chars[rand() % (int)(sizeof(chars) - 1)]; - } - payload[size - 1] = '\0'; -} - -static bool slice_buffer_equals_string(grpc_slice_buffer *buf, - const char *str) { - size_t i; - if (buf->length != strlen(str)) { - return false; - } - size_t pointer = 0; - for (i = 0; i < buf->count; i++) { - size_t slice_len = GRPC_SLICE_LENGTH(buf->slices[i]); - if (0 != strncmp(str + pointer, - (char *)GRPC_SLICE_START_PTR(buf->slices[i]), slice_len)) { - return false; - } - pointer += slice_len; - } - return true; -} - -static void test_stream_compression_simple_compress_decompress() { - const char test_str[] = "aaaaaaabbbbbbbccccccctesttesttest"; - grpc_slice_buffer source, relay, sink; - grpc_slice_buffer_init(&source); - grpc_slice_buffer_init(&relay); - grpc_slice_buffer_init(&sink); - grpc_stream_compression_context *compress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); - grpc_stream_compression_context *decompress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); - grpc_slice slice = grpc_slice_from_static_string(test_str); - grpc_slice_buffer_add(&source, slice); - GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, - ~(size_t)0, - GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); - bool end_of_context; - size_t output_size; - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - ~(size_t)0, &end_of_context)); - GPR_ASSERT(output_size == sizeof(test_str) - 1); - grpc_stream_compression_context_destroy(compress_ctx); - grpc_stream_compression_context_destroy(decompress_ctx); - - GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); - - grpc_slice_buffer_destroy(&source); - grpc_slice_buffer_destroy(&relay); - grpc_slice_buffer_destroy(&sink); -} - -static void -test_stream_compression_simple_compress_decompress_with_output_size_constraint() { - const char test_str[] = "aaaaaaabbbbbbbccccccctesttesttest"; - grpc_slice_buffer source, relay, sink; - grpc_slice_buffer_init(&source); - grpc_slice_buffer_init(&relay); - grpc_slice_buffer_init(&sink); - grpc_stream_compression_context *compress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); - grpc_stream_compression_context *decompress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); - grpc_slice slice = grpc_slice_from_static_string(test_str); - grpc_slice_buffer_add(&source, slice); - GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, - ~(size_t)0, - GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); - grpc_stream_compression_context_destroy(compress_ctx); - - bool end_of_context; - size_t output_size; - size_t max_output_size = 2; - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - max_output_size, &end_of_context)); - GPR_ASSERT(output_size == max_output_size); - GPR_ASSERT(end_of_context == false); - grpc_slice slice_recv = grpc_slice_buffer_take_first(&sink); - char *str_recv = (char *)GRPC_SLICE_START_PTR(slice_recv); - GPR_ASSERT(GRPC_SLICE_LENGTH(slice_recv) == max_output_size); - GPR_ASSERT(0 == strncmp(test_str, str_recv, max_output_size)); - grpc_slice_unref(slice_recv); - - size_t remaining_size = sizeof(test_str) - 1 - max_output_size; - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - remaining_size, &end_of_context)); - GPR_ASSERT(output_size == remaining_size); - GPR_ASSERT(end_of_context == true); - - GPR_ASSERT(slice_buffer_equals_string(&sink, test_str + max_output_size)); - - grpc_stream_compression_context_destroy(decompress_ctx); - grpc_slice_buffer_destroy(&source); - grpc_slice_buffer_destroy(&relay); - grpc_slice_buffer_destroy(&sink); -} - -#define LARGE_DATA_SIZE (1024 * 1024) -static void -test_stream_compression_simple_compress_decompress_with_large_data() { - char *test_str = gpr_malloc(LARGE_DATA_SIZE * sizeof(char)); - generate_random_payload(test_str, LARGE_DATA_SIZE); - grpc_slice_buffer source, relay, sink; - grpc_slice_buffer_init(&source); - grpc_slice_buffer_init(&relay); - grpc_slice_buffer_init(&sink); - grpc_stream_compression_context *compress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); - grpc_stream_compression_context *decompress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); - grpc_slice slice = grpc_slice_from_static_string(test_str); - grpc_slice_buffer_add(&source, slice); - GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, - ~(size_t)0, - GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); - bool end_of_context; - size_t output_size; - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - ~(size_t)0, &end_of_context)); - GPR_ASSERT(output_size == LARGE_DATA_SIZE - 1); - grpc_stream_compression_context_destroy(compress_ctx); - grpc_stream_compression_context_destroy(decompress_ctx); - - GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); - - grpc_slice_buffer_destroy(&source); - grpc_slice_buffer_destroy(&relay); - grpc_slice_buffer_destroy(&sink); - gpr_free(test_str); -} - -static void test_stream_compression_drop_context() { - const char test_str[] = "aaaaaaabbbbbbbccccccc"; - const char test_str2[] = "dddddddeeeeeeefffffffggggg"; - grpc_slice_buffer source, relay, sink; - grpc_slice_buffer_init(&source); - grpc_slice_buffer_init(&relay); - grpc_slice_buffer_init(&sink); - grpc_stream_compression_context *compress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); - grpc_slice slice = grpc_slice_from_static_string(test_str); - grpc_slice_buffer_add(&source, slice); - GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, - ~(size_t)0, - GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); - grpc_stream_compression_context_destroy(compress_ctx); - - compress_ctx = grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); - slice = grpc_slice_from_static_string(test_str2); - grpc_slice_buffer_add(&source, slice); - GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, - ~(size_t)0, - GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); - grpc_stream_compression_context_destroy(compress_ctx); - - /* Concatenate the two compressed sliced into one to test decompressing two - * contexts */ - grpc_slice slice1 = grpc_slice_buffer_take_first(&relay); - grpc_slice slice2 = grpc_slice_buffer_take_first(&relay); - grpc_slice slice3 = - grpc_slice_malloc(GRPC_SLICE_LENGTH(slice1) + GRPC_SLICE_LENGTH(slice2)); - memcpy(GRPC_SLICE_START_PTR(slice3), GRPC_SLICE_START_PTR(slice1), - GRPC_SLICE_LENGTH(slice1)); - memcpy(GRPC_SLICE_START_PTR(slice3) + GRPC_SLICE_LENGTH(slice1), - GRPC_SLICE_START_PTR(slice2), GRPC_SLICE_LENGTH(slice2)); - grpc_slice_unref(slice1); - grpc_slice_unref(slice2); - grpc_slice_buffer_add(&relay, slice3); - - grpc_stream_compression_context *decompress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); - bool end_of_context; - size_t output_size; - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - ~(size_t)0, &end_of_context)); - GPR_ASSERT(end_of_context == true); - GPR_ASSERT(output_size == sizeof(test_str) - 1); - - GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); - grpc_stream_compression_context_destroy(decompress_ctx); - grpc_slice_buffer_destroy(&sink); - - grpc_slice_buffer_init(&sink); - decompress_ctx = grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - ~(size_t)0, &end_of_context)); - GPR_ASSERT(end_of_context == true); - GPR_ASSERT(output_size == sizeof(test_str2) - 1); - GPR_ASSERT(slice_buffer_equals_string(&sink, test_str2)); - grpc_stream_compression_context_destroy(decompress_ctx); - - grpc_slice_buffer_destroy(&source); - grpc_slice_buffer_destroy(&relay); - grpc_slice_buffer_destroy(&sink); -} - -static void test_stream_compression_sync_flush() { - const char test_str[] = "aaaaaaabbbbbbbccccccc"; - const char test_str2[] = "dddddddeeeeeeefffffffggggg"; - grpc_slice_buffer source, relay, sink; - grpc_slice_buffer_init(&source); - grpc_slice_buffer_init(&relay); - grpc_slice_buffer_init(&sink); - grpc_stream_compression_context *compress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); - grpc_slice slice = grpc_slice_from_static_string(test_str); - grpc_slice_buffer_add(&source, slice); - GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, - ~(size_t)0, - GRPC_STREAM_COMPRESSION_FLUSH_SYNC)); - - grpc_stream_compression_context *decompress_ctx = - grpc_stream_compression_context_create( - GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); - bool end_of_context; - size_t output_size; - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - ~(size_t)0, &end_of_context)); - GPR_ASSERT(end_of_context == false); - GPR_ASSERT(output_size == sizeof(test_str) - 1); - GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); - grpc_slice_buffer_destroy(&sink); - - grpc_slice_buffer_init(&sink); - slice = grpc_slice_from_static_string(test_str2); - grpc_slice_buffer_add(&source, slice); - GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, - ~(size_t)0, - GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); - grpc_stream_compression_context_destroy(compress_ctx); - - GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, - ~(size_t)0, &end_of_context)); - GPR_ASSERT(end_of_context == true); - GPR_ASSERT(output_size == sizeof(test_str2) - 1); - GPR_ASSERT(slice_buffer_equals_string(&sink, test_str2)); - grpc_stream_compression_context_destroy(decompress_ctx); - - grpc_slice_buffer_destroy(&source); - grpc_slice_buffer_destroy(&relay); - grpc_slice_buffer_destroy(&sink); -} - -int main(int argc, char **argv) { - grpc_init(); - test_stream_compression_simple_compress_decompress(); - test_stream_compression_simple_compress_decompress_with_output_size_constraint(); - test_stream_compression_simple_compress_decompress_with_large_data(); - test_stream_compression_sync_flush(); - test_stream_compression_drop_context(); - grpc_shutdown(); - - return 0; -} diff --git a/test/core/compression/stream_compression_test.cc b/test/core/compression/stream_compression_test.cc new file mode 100644 index 0000000000..d136408710 --- /dev/null +++ b/test/core/compression/stream_compression_test.cc @@ -0,0 +1,298 @@ +/* + * + * Copyright 2017 gRPC authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#include + +#include +#include +#include +#include + +#include "src/core/lib/compression/stream_compression.h" + +static void generate_random_payload(char *payload, size_t size) { + size_t i; + static const char chars[] = "abcdefghijklmnopqrstuvwxyz1234567890"; + for (i = 0; i < size - 1; ++i) { + payload[i] = chars[rand() % (int)(sizeof(chars) - 1)]; + } + payload[size - 1] = '\0'; +} + +static bool slice_buffer_equals_string(grpc_slice_buffer *buf, + const char *str) { + size_t i; + if (buf->length != strlen(str)) { + return false; + } + size_t pointer = 0; + for (i = 0; i < buf->count; i++) { + size_t slice_len = GRPC_SLICE_LENGTH(buf->slices[i]); + if (0 != strncmp(str + pointer, + (char *)GRPC_SLICE_START_PTR(buf->slices[i]), slice_len)) { + return false; + } + pointer += slice_len; + } + return true; +} + +static void test_stream_compression_simple_compress_decompress() { + const char test_str[] = "aaaaaaabbbbbbbccccccctesttesttest"; + grpc_slice_buffer source, relay, sink; + grpc_slice_buffer_init(&source); + grpc_slice_buffer_init(&relay); + grpc_slice_buffer_init(&sink); + grpc_stream_compression_context *compress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); + grpc_stream_compression_context *decompress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); + grpc_slice slice = grpc_slice_from_static_string(test_str); + grpc_slice_buffer_add(&source, slice); + GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, + ~(size_t)0, + GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); + bool end_of_context; + size_t output_size; + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + ~(size_t)0, &end_of_context)); + GPR_ASSERT(output_size == sizeof(test_str) - 1); + grpc_stream_compression_context_destroy(compress_ctx); + grpc_stream_compression_context_destroy(decompress_ctx); + + GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); + + grpc_slice_buffer_destroy(&source); + grpc_slice_buffer_destroy(&relay); + grpc_slice_buffer_destroy(&sink); +} + +static void +test_stream_compression_simple_compress_decompress_with_output_size_constraint() { + const char test_str[] = "aaaaaaabbbbbbbccccccctesttesttest"; + grpc_slice_buffer source, relay, sink; + grpc_slice_buffer_init(&source); + grpc_slice_buffer_init(&relay); + grpc_slice_buffer_init(&sink); + grpc_stream_compression_context *compress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); + grpc_stream_compression_context *decompress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); + grpc_slice slice = grpc_slice_from_static_string(test_str); + grpc_slice_buffer_add(&source, slice); + GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, + ~(size_t)0, + GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); + grpc_stream_compression_context_destroy(compress_ctx); + + bool end_of_context; + size_t output_size; + size_t max_output_size = 2; + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + max_output_size, &end_of_context)); + GPR_ASSERT(output_size == max_output_size); + GPR_ASSERT(end_of_context == false); + grpc_slice slice_recv = grpc_slice_buffer_take_first(&sink); + char *str_recv = (char *)GRPC_SLICE_START_PTR(slice_recv); + GPR_ASSERT(GRPC_SLICE_LENGTH(slice_recv) == max_output_size); + GPR_ASSERT(0 == strncmp(test_str, str_recv, max_output_size)); + grpc_slice_unref(slice_recv); + + size_t remaining_size = sizeof(test_str) - 1 - max_output_size; + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + remaining_size, &end_of_context)); + GPR_ASSERT(output_size == remaining_size); + GPR_ASSERT(end_of_context == true); + + GPR_ASSERT(slice_buffer_equals_string(&sink, test_str + max_output_size)); + + grpc_stream_compression_context_destroy(decompress_ctx); + grpc_slice_buffer_destroy(&source); + grpc_slice_buffer_destroy(&relay); + grpc_slice_buffer_destroy(&sink); +} + +#define LARGE_DATA_SIZE (1024 * 1024) +static void +test_stream_compression_simple_compress_decompress_with_large_data() { + char *test_str = + static_cast(gpr_malloc(LARGE_DATA_SIZE * sizeof(char))); + generate_random_payload(test_str, LARGE_DATA_SIZE); + grpc_slice_buffer source, relay, sink; + grpc_slice_buffer_init(&source); + grpc_slice_buffer_init(&relay); + grpc_slice_buffer_init(&sink); + grpc_stream_compression_context *compress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); + grpc_stream_compression_context *decompress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); + grpc_slice slice = grpc_slice_from_static_string(test_str); + grpc_slice_buffer_add(&source, slice); + GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, + ~(size_t)0, + GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); + bool end_of_context; + size_t output_size; + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + ~(size_t)0, &end_of_context)); + GPR_ASSERT(output_size == LARGE_DATA_SIZE - 1); + grpc_stream_compression_context_destroy(compress_ctx); + grpc_stream_compression_context_destroy(decompress_ctx); + + GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); + + grpc_slice_buffer_destroy(&source); + grpc_slice_buffer_destroy(&relay); + grpc_slice_buffer_destroy(&sink); + gpr_free(test_str); +} + +static void test_stream_compression_drop_context() { + const char test_str[] = "aaaaaaabbbbbbbccccccc"; + const char test_str2[] = "dddddddeeeeeeefffffffggggg"; + grpc_slice_buffer source, relay, sink; + grpc_slice_buffer_init(&source); + grpc_slice_buffer_init(&relay); + grpc_slice_buffer_init(&sink); + grpc_stream_compression_context *compress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); + grpc_slice slice = grpc_slice_from_static_string(test_str); + grpc_slice_buffer_add(&source, slice); + GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, + ~(size_t)0, + GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); + grpc_stream_compression_context_destroy(compress_ctx); + + compress_ctx = grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); + slice = grpc_slice_from_static_string(test_str2); + grpc_slice_buffer_add(&source, slice); + GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, + ~(size_t)0, + GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); + grpc_stream_compression_context_destroy(compress_ctx); + + /* Concatenate the two compressed sliced into one to test decompressing two + * contexts */ + grpc_slice slice1 = grpc_slice_buffer_take_first(&relay); + grpc_slice slice2 = grpc_slice_buffer_take_first(&relay); + grpc_slice slice3 = + grpc_slice_malloc(GRPC_SLICE_LENGTH(slice1) + GRPC_SLICE_LENGTH(slice2)); + memcpy(GRPC_SLICE_START_PTR(slice3), GRPC_SLICE_START_PTR(slice1), + GRPC_SLICE_LENGTH(slice1)); + memcpy(GRPC_SLICE_START_PTR(slice3) + GRPC_SLICE_LENGTH(slice1), + GRPC_SLICE_START_PTR(slice2), GRPC_SLICE_LENGTH(slice2)); + grpc_slice_unref(slice1); + grpc_slice_unref(slice2); + grpc_slice_buffer_add(&relay, slice3); + + grpc_stream_compression_context *decompress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); + bool end_of_context; + size_t output_size; + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + ~(size_t)0, &end_of_context)); + GPR_ASSERT(end_of_context == true); + GPR_ASSERT(output_size == sizeof(test_str) - 1); + + GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); + grpc_stream_compression_context_destroy(decompress_ctx); + grpc_slice_buffer_destroy(&sink); + + grpc_slice_buffer_init(&sink); + decompress_ctx = grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + ~(size_t)0, &end_of_context)); + GPR_ASSERT(end_of_context == true); + GPR_ASSERT(output_size == sizeof(test_str2) - 1); + GPR_ASSERT(slice_buffer_equals_string(&sink, test_str2)); + grpc_stream_compression_context_destroy(decompress_ctx); + + grpc_slice_buffer_destroy(&source); + grpc_slice_buffer_destroy(&relay); + grpc_slice_buffer_destroy(&sink); +} + +static void test_stream_compression_sync_flush() { + const char test_str[] = "aaaaaaabbbbbbbccccccc"; + const char test_str2[] = "dddddddeeeeeeefffffffggggg"; + grpc_slice_buffer source, relay, sink; + grpc_slice_buffer_init(&source); + grpc_slice_buffer_init(&relay); + grpc_slice_buffer_init(&sink); + grpc_stream_compression_context *compress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_COMPRESS); + grpc_slice slice = grpc_slice_from_static_string(test_str); + grpc_slice_buffer_add(&source, slice); + GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, + ~(size_t)0, + GRPC_STREAM_COMPRESSION_FLUSH_SYNC)); + + grpc_stream_compression_context *decompress_ctx = + grpc_stream_compression_context_create( + GRPC_STREAM_COMPRESSION_GZIP_DECOMPRESS); + bool end_of_context; + size_t output_size; + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + ~(size_t)0, &end_of_context)); + GPR_ASSERT(end_of_context == false); + GPR_ASSERT(output_size == sizeof(test_str) - 1); + GPR_ASSERT(slice_buffer_equals_string(&sink, test_str)); + grpc_slice_buffer_destroy(&sink); + + grpc_slice_buffer_init(&sink); + slice = grpc_slice_from_static_string(test_str2); + grpc_slice_buffer_add(&source, slice); + GPR_ASSERT(grpc_stream_compress(compress_ctx, &source, &relay, NULL, + ~(size_t)0, + GRPC_STREAM_COMPRESSION_FLUSH_FINISH)); + grpc_stream_compression_context_destroy(compress_ctx); + + GPR_ASSERT(grpc_stream_decompress(decompress_ctx, &relay, &sink, &output_size, + ~(size_t)0, &end_of_context)); + GPR_ASSERT(end_of_context == true); + GPR_ASSERT(output_size == sizeof(test_str2) - 1); + GPR_ASSERT(slice_buffer_equals_string(&sink, test_str2)); + grpc_stream_compression_context_destroy(decompress_ctx); + + grpc_slice_buffer_destroy(&source); + grpc_slice_buffer_destroy(&relay); + grpc_slice_buffer_destroy(&sink); +} + +int main(int argc, char **argv) { + grpc_init(); + test_stream_compression_simple_compress_decompress(); + test_stream_compression_simple_compress_decompress_with_output_size_constraint(); + test_stream_compression_simple_compress_decompress_with_large_data(); + test_stream_compression_sync_flush(); + test_stream_compression_drop_context(); + grpc_shutdown(); + + return 0; +} -- cgit v1.2.3