Chiebot-Mirror
/
grpc
mirror of https://github.com/grpc/grpc.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
The C based gRPC (C++, Python, Ruby, Objective-C, PHP, C#) https://grpc.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
30588 Commits
276 Branches
377 Tags
1.2 GiB
 
 
 
 
 
 
Tag: Branch: Tree: e0adbb6c2e
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'e0adbb6c2e'
${ noResults }
grpc/test/core/gpr/string_test.cc

312 lines
8.3 KiB
Raw Blame History

/*
*
* 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/gpr/string.h"
#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <grpc/support/alloc.h>
#include <grpc/support/log.h>
#include <grpc/support/string_util.h>
#include <grpc/support/useful.h>
#include "test/core/util/test_config.h"
#define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
static void test_strdup(void) {
static const char* src1 = "hello world";
char* dst1;
LOG_TEST_NAME("test_strdup");
dst1 = gpr_strdup(src1);
GPR_ASSERT(0 == strcmp(src1, dst1));
gpr_free(dst1);
GPR_ASSERT(nullptr == gpr_strdup(nullptr));
}
static void expect_dump(const char* buf, size_t len, uint32_t flags,
const char* result) {
char* got = gpr_dump(buf, len, flags);
GPR_ASSERT(0 == strcmp(got, result));
gpr_free(got);
}
static void test_dump(void) {
LOG_TEST_NAME("test_dump");
expect_dump("\x01", 1, GPR_DUMP_HEX, "01");
expect_dump("\x01", 1, GPR_DUMP_HEX | GPR_DUMP_ASCII, "01 '.'");
expect_dump("\x01\x02", 2, GPR_DUMP_HEX, "01 02");
expect_dump("\x01\x23\x45\x67\x89\xab\xcd\xef", 8, GPR_DUMP_HEX,
"01 23 45 67 89 ab cd ef");
expect_dump("ab", 2, GPR_DUMP_HEX | GPR_DUMP_ASCII, "61 62 'ab'");
}
static void test_pu32_fail(const char* s) {
uint32_t out;
GPR_ASSERT(!gpr_parse_bytes_to_uint32(s, strlen(s), &out));
}
static void test_pu32_succeed(const char* s, uint32_t want) {
uint32_t out;
GPR_ASSERT(gpr_parse_bytes_to_uint32(s, strlen(s), &out));
GPR_ASSERT(out == want);
}
static void test_parse_uint32(void) {
LOG_TEST_NAME("test_parse_uint32");
test_pu32_fail("-1");
test_pu32_fail("a");
test_pu32_fail("");
test_pu32_succeed("0", 0);
test_pu32_succeed("1", 1);
test_pu32_succeed("2", 2);
test_pu32_succeed("3", 3);
test_pu32_succeed("4", 4);
test_pu32_succeed("5", 5);
test_pu32_succeed("6", 6);
test_pu32_succeed("7", 7);
test_pu32_succeed("8", 8);
test_pu32_succeed("9", 9);
test_pu32_succeed("10", 10);
test_pu32_succeed("11", 11);
test_pu32_succeed("12", 12);
test_pu32_succeed("13", 13);
test_pu32_succeed("14", 14);
test_pu32_succeed("15", 15);
test_pu32_succeed("16", 16);
test_pu32_succeed("17", 17);
test_pu32_succeed("18", 18);
test_pu32_succeed("19", 19);
test_pu32_succeed("1234567890", 1234567890);
test_pu32_succeed("4294967295", 4294967295u);
test_pu32_fail("4294967296");
test_pu32_fail("4294967297");
test_pu32_fail("4294967298");
test_pu32_fail("4294967299");
}
static void test_asprintf(void) {
char* buf;
int i, j;
LOG_TEST_NAME("test_asprintf");
/* Print an empty string. */
GPR_ASSERT(gpr_asprintf(&buf, "%s", "") == 0);
GPR_ASSERT(buf[0] == '\0');
gpr_free(buf);
/* Print strings of various lengths. */
for (i = 1; i < 100; i++) {
GPR_ASSERT(gpr_asprintf(&buf, "%0*d", i, 1) == i);
/* The buffer should resemble "000001\0". */
for (j = 0; j < i - 2; j++) {
GPR_ASSERT(buf[j] == '0');
}
GPR_ASSERT(buf[i - 1] == '1');
GPR_ASSERT(buf[i] == '\0');
gpr_free(buf);
}
}
static void test_strjoin(void) {
const char* parts[4] = {"one", "two", "three", "four"};
size_t joined_len;
char* joined;
LOG_TEST_NAME("test_strjoin");
joined = gpr_strjoin(parts, 4, &joined_len);
GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
gpr_free(joined);
joined = gpr_strjoin(parts, 0, &joined_len);
GPR_ASSERT(0 == strcmp("", joined));
gpr_free(joined);
joined = gpr_strjoin(parts, 1, &joined_len);
GPR_ASSERT(0 == strcmp("one", joined));
gpr_free(joined);
}
static void test_strjoin_sep(void) {
const char* parts[4] = {"one", "two", "three", "four"};
size_t joined_len;
char* joined;
LOG_TEST_NAME("test_strjoin_sep");
joined = gpr_strjoin_sep(parts, 4, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("one, two, three, four", joined));
gpr_free(joined);
/* empty separator */
joined = gpr_strjoin_sep(parts, 4, "", &joined_len);
GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
gpr_free(joined);
/* degenerated case specifying zero input parts */
joined = gpr_strjoin_sep(parts, 0, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("", joined));
gpr_free(joined);
/* single part should have no separator */
joined = gpr_strjoin_sep(parts, 1, ", ", &joined_len);
GPR_ASSERT(0 == strcmp("one", joined));
gpr_free(joined);
}
static void test_ltoa() {
char* str;
char buf[GPR_LTOA_MIN_BUFSIZE];
LOG_TEST_NAME("test_ltoa");
/* zero */
GPR_ASSERT(1 == gpr_ltoa(0, buf));
GPR_ASSERT(0 == strcmp("0", buf));
/* positive number */
GPR_ASSERT(3 == gpr_ltoa(123, buf));
GPR_ASSERT(0 == strcmp("123", buf));
/* negative number */
GPR_ASSERT(6 == gpr_ltoa(-12345, buf));
GPR_ASSERT(0 == strcmp("-12345", buf));
/* large negative - we don't know the size of long in advance */
GPR_ASSERT(gpr_asprintf(&str, "%lld", (long long)LONG_MIN));
GPR_ASSERT(strlen(str) == (size_t)gpr_ltoa(LONG_MIN, buf));
GPR_ASSERT(0 == strcmp(str, buf));
gpr_free(str);
}
static void test_int64toa() {
char buf[GPR_INT64TOA_MIN_BUFSIZE];
LOG_TEST_NAME("test_int64toa");
/* zero */
GPR_ASSERT(1 == int64_ttoa(0, buf));
GPR_ASSERT(0 == strcmp("0", buf));
/* positive */
GPR_ASSERT(3 == int64_ttoa(123, buf));
GPR_ASSERT(0 == strcmp("123", buf));
/* large positive */
GPR_ASSERT(19 == int64_ttoa(9223372036854775807LL, buf));
GPR_ASSERT(0 == strcmp("9223372036854775807", buf));
/* large negative */
GPR_ASSERT(20 == int64_ttoa(-9223372036854775807LL - 1, buf));
GPR_ASSERT(0 == strcmp("-9223372036854775808", buf));
}
static void test_leftpad() {
char* padded;
LOG_TEST_NAME("test_leftpad");
padded = gpr_leftpad("foo", ' ', 5);
GPR_ASSERT(0 == strcmp(" foo", padded));
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 4);
GPR_ASSERT(0 == strcmp(" foo", padded));
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 3);
GPR_ASSERT(0 == strcmp("foo", padded));
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 2);
GPR_ASSERT(0 == strcmp("foo", padded));
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 1);
GPR_ASSERT(0 == strcmp("foo", padded));
gpr_free(padded);
padded = gpr_leftpad("foo", ' ', 0);
GPR_ASSERT(0 == strcmp("foo", padded));
gpr_free(padded);
padded = gpr_leftpad("foo", '0', 5);
GPR_ASSERT(0 == strcmp("00foo", padded));
gpr_free(padded);
}
static void test_stricmp(void) {
LOG_TEST_NAME("test_stricmp");
GPR_ASSERT(0 == gpr_stricmp("hello", "hello"));
GPR_ASSERT(0 == gpr_stricmp("HELLO", "hello"));
GPR_ASSERT(gpr_stricmp("a", "b") < 0);
GPR_ASSERT(gpr_stricmp("b", "a") > 0);
}
static void test_memrchr(void) {
LOG_TEST_NAME("test_memrchr");
GPR_ASSERT(nullptr == gpr_memrchr(nullptr, 'a', 0));
GPR_ASSERT(nullptr == gpr_memrchr("", 'a', 0));
GPR_ASSERT(nullptr == gpr_memrchr("hello", 'b', 5));
GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'h', 5), "hello"));
GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'o', 5), "o"));
GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'l', 5), "lo"));
}
static void test_is_true(void) {
LOG_TEST_NAME("test_is_true");
GPR_ASSERT(true == gpr_is_true("True"));
GPR_ASSERT(true == gpr_is_true("true"));
GPR_ASSERT(true == gpr_is_true("TRUE"));
GPR_ASSERT(true == gpr_is_true("Yes"));
GPR_ASSERT(true == gpr_is_true("yes"));
GPR_ASSERT(true == gpr_is_true("YES"));
GPR_ASSERT(true == gpr_is_true("1"));
GPR_ASSERT(false == gpr_is_true(nullptr));
GPR_ASSERT(false == gpr_is_true(""));
GPR_ASSERT(false == gpr_is_true("0"));
}
int main(int argc, char** argv) {
grpc_test_init(argc, argv);
test_strdup();
test_dump();
test_parse_uint32();
test_asprintf();
test_strjoin();
test_strjoin_sep();
test_ltoa();
test_int64toa();
test_leftpad();
test_stricmp();
test_memrchr();
test_is_true();
return 0;
}