test/core/surface/byte_buffer_reader_test.cc

   1 /*
   2  *
   3  * Copyright 2015 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <string.h>
  20
  21 #include <grpc/byte_buffer.h>
  22 #include <grpc/byte_buffer_reader.h>
  23 #include <grpc/grpc.h>
  24 #include <grpc/slice.h>
  25 #include <grpc/support/alloc.h>
  26 #include <grpc/support/log.h>
  27 #include <grpc/support/time.h>
  28
  29 #include "src/core/lib/gprpp/thd.h"
  30 #include "src/core/lib/iomgr/exec_ctx.h"
  31 #include "test/core/util/test_config.h"
  32
  33 #define LOG_TEST(x) gpr_log(GPR_INFO, "%s", x)
  34
  35 static void test_read_one_slice(void) {
  36   grpc_slice slice;
  37   grpc_byte_buffer* buffer;
  38   grpc_byte_buffer_reader reader;
  39   grpc_slice first_slice, second_slice;
  40   int first_code, second_code;
  41
  42   LOG_TEST("test_read_one_slice");
  43   slice = grpc_slice_from_copied_string("test");
  44   buffer = grpc_raw_byte_buffer_create(&slice, 1);
  45   grpc_slice_unref(slice);
  46   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
  47              "Couldn't init byte buffer reader");
  48   first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
  49   GPR_ASSERT(first_code != 0);
  50   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(first_slice), "test", 4) == 0);
  51   grpc_slice_unref(first_slice);
  52   second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
  53   GPR_ASSERT(second_code == 0);
  54   grpc_byte_buffer_destroy(buffer);
  55 }
  56
  57 static void test_read_one_slice_malloc(void) {
  58   grpc_slice slice;
  59   grpc_byte_buffer* buffer;
  60   grpc_byte_buffer_reader reader;
  61   grpc_slice first_slice, second_slice;
  62   int first_code, second_code;
  63
  64   LOG_TEST("test_read_one_slice_malloc");
  65   slice = grpc_slice_malloc(4);
  66   memcpy(GRPC_SLICE_START_PTR(slice), "test", 4);
  67   buffer = grpc_raw_byte_buffer_create(&slice, 1);
  68   grpc_slice_unref(slice);
  69   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
  70              "Couldn't init byte buffer reader");
  71   first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
  72   GPR_ASSERT(first_code != 0);
  73   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(first_slice), "test", 4) == 0);
  74   grpc_slice_unref(first_slice);
  75   second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
  76   GPR_ASSERT(second_code == 0);
  77   grpc_byte_buffer_destroy(buffer);
  78 }
  79
  80 static void test_read_none_compressed_slice(void) {
  81   grpc_slice slice;
  82   grpc_byte_buffer* buffer;
  83   grpc_byte_buffer_reader reader;
  84   grpc_slice first_slice, second_slice;
  85   int first_code, second_code;
  86
  87   LOG_TEST("test_read_none_compressed_slice");
  88   slice = grpc_slice_from_copied_string("test");
  89   buffer = grpc_raw_byte_buffer_create(&slice, 1);
  90   grpc_slice_unref(slice);
  91   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
  92              "Couldn't init byte buffer reader");
  93   first_code = grpc_byte_buffer_reader_next(&reader, &first_slice);
  94   GPR_ASSERT(first_code != 0);
  95   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(first_slice), "test", 4) == 0);
  96   grpc_slice_unref(first_slice);
  97   second_code = grpc_byte_buffer_reader_next(&reader, &second_slice);
  98   GPR_ASSERT(second_code == 0);
  99   grpc_byte_buffer_destroy(buffer);
 100 }
 101
 102 static void test_peek_one_slice(void) {
 103   grpc_slice slice;
 104   grpc_byte_buffer* buffer;
 105   grpc_byte_buffer_reader reader;
 106   grpc_slice* first_slice;
 107   grpc_slice* second_slice;
 108   int first_code, second_code;
 109
 110   LOG_TEST("test_peek_one_slice");
 111   slice = grpc_slice_from_copied_string("test");
 112   buffer = grpc_raw_byte_buffer_create(&slice, 1);
 113   grpc_slice_unref(slice);
 114   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
 115              "Couldn't init byte buffer reader");
 116   first_code = grpc_byte_buffer_reader_peek(&reader, &first_slice);
 117   GPR_ASSERT(first_code != 0);
 118   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4) == 0);
 119   second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
 120   GPR_ASSERT(second_code == 0);
 121   grpc_byte_buffer_destroy(buffer);
 122 }
 123
 124 static void test_peek_one_slice_malloc(void) {
 125   grpc_slice slice;
 126   grpc_byte_buffer* buffer;
 127   grpc_byte_buffer_reader reader;
 128   grpc_slice* first_slice;
 129   grpc_slice* second_slice;
 130   int first_code, second_code;
 131
 132   LOG_TEST("test_peek_one_slice_malloc");
 133   slice = grpc_slice_malloc(4);
 134   memcpy(GRPC_SLICE_START_PTR(slice), "test", 4);
 135   buffer = grpc_raw_byte_buffer_create(&slice, 1);
 136   grpc_slice_unref(slice);
 137   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
 138              "Couldn't init byte buffer reader");
 139   first_code = grpc_byte_buffer_reader_peek(&reader, &first_slice);
 140   GPR_ASSERT(first_code != 0);
 141   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4) == 0);
 142   second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
 143   GPR_ASSERT(second_code == 0);
 144   grpc_byte_buffer_destroy(buffer);
 145 }
 146
 147 static void test_peek_none_compressed_slice(void) {
 148   grpc_slice slice;
 149   grpc_byte_buffer* buffer;
 150   grpc_byte_buffer_reader reader;
 151   grpc_slice* first_slice;
 152   grpc_slice* second_slice;
 153   int first_code, second_code;
 154
 155   LOG_TEST("test_peek_none_compressed_slice");
 156   slice = grpc_slice_from_copied_string("test");
 157   buffer = grpc_raw_byte_buffer_create(&slice, 1);
 158   grpc_slice_unref(slice);
 159   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
 160              "Couldn't init byte buffer reader");
 161   first_code = grpc_byte_buffer_reader_peek(&reader, &first_slice);
 162   GPR_ASSERT(first_code != 0);
 163   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(*first_slice), "test", 4) == 0);
 164   second_code = grpc_byte_buffer_reader_peek(&reader, &second_slice);
 165   GPR_ASSERT(second_code == 0);
 166   grpc_byte_buffer_destroy(buffer);
 167 }
 168
 169 static void test_byte_buffer_from_reader(void) {
 170   grpc_slice slice;
 171   grpc_byte_buffer *buffer, *buffer_from_reader;
 172   grpc_byte_buffer_reader reader;
 173
 174   LOG_TEST("test_byte_buffer_from_reader");
 175   slice = grpc_slice_malloc(4);
 176   memcpy(GRPC_SLICE_START_PTR(slice), "test", 4);
 177   buffer = grpc_raw_byte_buffer_create(&slice, 1);
 178   grpc_slice_unref(slice);
 179   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
 180              "Couldn't init byte buffer reader");
 181
 182   buffer_from_reader = grpc_raw_byte_buffer_from_reader(&reader);
 183   GPR_ASSERT(buffer->type == buffer_from_reader->type);
 184   GPR_ASSERT(buffer_from_reader->data.raw.compression == GRPC_COMPRESS_NONE);
 185   GPR_ASSERT(buffer_from_reader->data.raw.slice_buffer.count == 1);
 186   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(
 187                         buffer_from_reader->data.raw.slice_buffer.slices[0]),
 188                     "test", 4) == 0);
 189
 190   grpc_byte_buffer_destroy(buffer);
 191   grpc_byte_buffer_destroy(buffer_from_reader);
 192 }
 193
 194 static void test_readall(void) {
 195   char* lotsa_as[512];
 196   char* lotsa_bs[1024];
 197   grpc_slice slices[2];
 198   grpc_byte_buffer* buffer;
 199   grpc_byte_buffer_reader reader;
 200   grpc_slice slice_out;
 201
 202   LOG_TEST("test_readall");
 203
 204   memset(lotsa_as, 'a', 512 * sizeof(lotsa_as[0]));
 205   memset(lotsa_bs, 'b', 1024 * sizeof(lotsa_bs[0]));
 206   /* use slices large enough to overflow inlining */
 207   slices[0] = grpc_slice_malloc(512);
 208   memcpy(GRPC_SLICE_START_PTR(slices[0]), lotsa_as, 512);
 209   slices[1] = grpc_slice_malloc(1024);
 210   memcpy(GRPC_SLICE_START_PTR(slices[1]), lotsa_bs, 1024);
 211
 212   buffer = grpc_raw_byte_buffer_create(slices, 2);
 213   grpc_slice_unref(slices[0]);
 214   grpc_slice_unref(slices[1]);
 215
 216   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
 217              "Couldn't init byte buffer reader");
 218   slice_out = grpc_byte_buffer_reader_readall(&reader);
 219
 220   GPR_ASSERT(GRPC_SLICE_LENGTH(slice_out) == 512 + 1024);
 221   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(slice_out), lotsa_as, 512) == 0);
 222   GPR_ASSERT(memcmp(&(GRPC_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024) ==
 223              0);
 224   grpc_slice_unref(slice_out);
 225   grpc_byte_buffer_destroy(buffer);
 226 }
 227
 228 static void test_byte_buffer_copy(void) {
 229   char* lotsa_as[512];
 230   char* lotsa_bs[1024];
 231   grpc_slice slices[2];
 232   grpc_byte_buffer* buffer;
 233   grpc_byte_buffer* copied_buffer;
 234   grpc_byte_buffer_reader reader;
 235   grpc_slice slice_out;
 236
 237   LOG_TEST("test_byte_buffer_copy");
 238
 239   memset(lotsa_as, 'a', 512 * sizeof(lotsa_as[0]));
 240   memset(lotsa_bs, 'b', 1024 * sizeof(lotsa_bs[0]));
 241   /* use slices large enough to overflow inlining */
 242   slices[0] = grpc_slice_malloc(512);
 243   memcpy(GRPC_SLICE_START_PTR(slices[0]), lotsa_as, 512);
 244   slices[1] = grpc_slice_malloc(1024);
 245   memcpy(GRPC_SLICE_START_PTR(slices[1]), lotsa_bs, 1024);
 246
 247   buffer = grpc_raw_byte_buffer_create(slices, 2);
 248   grpc_slice_unref(slices[0]);
 249   grpc_slice_unref(slices[1]);
 250   copied_buffer = grpc_byte_buffer_copy(buffer);
 251
 252   GPR_ASSERT(grpc_byte_buffer_reader_init(&reader, buffer) &&
 253              "Couldn't init byte buffer reader");
 254   slice_out = grpc_byte_buffer_reader_readall(&reader);
 255
 256   GPR_ASSERT(GRPC_SLICE_LENGTH(slice_out) == 512 + 1024);
 257   GPR_ASSERT(memcmp(GRPC_SLICE_START_PTR(slice_out), lotsa_as, 512) == 0);
 258   GPR_ASSERT(memcmp(&(GRPC_SLICE_START_PTR(slice_out)[512]), lotsa_bs, 1024) ==
 259              0);
 260   grpc_slice_unref(slice_out);
 261   grpc_byte_buffer_destroy(buffer);
 262   grpc_byte_buffer_destroy(copied_buffer);
 263 }
 264
 265 int main(int argc, char** argv) {
 266   grpc_init();
 267   grpc::testing::TestEnvironment env(argc, argv);
 268   test_read_one_slice();
 269   test_read_one_slice_malloc();
 270   test_read_none_compressed_slice();
 271   test_peek_one_slice();
 272   test_peek_one_slice_malloc();
 273   test_peek_none_compressed_slice();
 274   test_byte_buffer_from_reader();
 275   test_byte_buffer_copy();
 276   test_readall();
 277   grpc_shutdown();
 278   return 0;
 279 }