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.
52357 Commits
279 Branches
380 Tags
1.3 GiB
 
 
 
 
 
 
Tag: Branch: Tree: 58ad7950a0
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '58ad7950a0'
${ noResults }
grpc/test/core/gpr/time_test.cc

266 lines
9.4 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.
*
*/
/* Test of gpr time support. */
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include "gtest/gtest.h"
#include <grpc/support/time.h>
#include "test/core/util/test_config.h"
static void to_fp(void* arg, const char* buf, size_t len) {
fwrite(buf, 1, len, static_cast<FILE*>(arg));
}
/* Convert gpr_intmax x to ascii base b (2..16), and write with
(*writer)(arg, ...), zero padding to "chars" digits). */
static void i_to_s(intmax_t x, int base, int chars,
void (*writer)(void* arg, const char* buf, size_t len),
void* arg) {
char buf[64];
char fmt[32];
ASSERT_TRUE(base == 16 || base == 10);
sprintf(fmt, "%%0%d%s", chars, base == 16 ? PRIxMAX : PRIdMAX);
sprintf(buf, fmt, x);
(*writer)(arg, buf, strlen(buf));
}
/* Convert ts to ascii, and write with (*writer)(arg, ...). */
static void ts_to_s(gpr_timespec t,
void (*writer)(void* arg, const char* buf, size_t len),
void* arg) {
if (t.tv_sec < 0 && t.tv_nsec != 0) {
t.tv_sec++;
t.tv_nsec = GPR_NS_PER_SEC - t.tv_nsec;
}
i_to_s(t.tv_sec, 10, 0, writer, arg);
(*writer)(arg, ".", 1);
i_to_s(t.tv_nsec, 10, 9, writer, arg);
}
TEST(TimeTest, Values) {
int i;
gpr_timespec x = gpr_time_0(GPR_CLOCK_REALTIME);
ASSERT_TRUE(x.tv_sec == 0 && x.tv_nsec == 0);
x = gpr_inf_future(GPR_CLOCK_REALTIME);
fprintf(stderr, "far future ");
fflush(stderr);
i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
fprintf(stderr, "\n");
ASSERT_EQ(x.tv_sec, INT64_MAX);
fprintf(stderr, "far future ");
fflush(stderr);
ts_to_s(x, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
x = gpr_inf_past(GPR_CLOCK_REALTIME);
fprintf(stderr, "far past ");
fflush(stderr);
i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
ASSERT_EQ(x.tv_sec, INT64_MIN);
fprintf(stderr, "far past ");
fflush(stderr);
ts_to_s(x, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
for (i = 1; i != 1000 * 1000 * 1000; i *= 10) {
x = gpr_time_from_micros(i, GPR_TIMESPAN);
ASSERT_TRUE(x.tv_sec == i / GPR_US_PER_SEC &&
x.tv_nsec == (i % GPR_US_PER_SEC) * GPR_NS_PER_US);
x = gpr_time_from_nanos(i, GPR_TIMESPAN);
ASSERT_TRUE(x.tv_sec == i / GPR_NS_PER_SEC &&
x.tv_nsec == (i % GPR_NS_PER_SEC));
x = gpr_time_from_millis(i, GPR_TIMESPAN);
ASSERT_TRUE(x.tv_sec == i / GPR_MS_PER_SEC &&
x.tv_nsec == (i % GPR_MS_PER_SEC) * GPR_NS_PER_MS);
}
/* Test possible overflow in conversion of -ve values. */
x = gpr_time_from_micros(-(INT64_MAX - 999997), GPR_TIMESPAN);
ASSERT_LT(x.tv_sec, 0);
ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
EXPECT_EQ((x.tv_sec * GPR_US_PER_SEC +
x.tv_nsec / (GPR_NS_PER_SEC / GPR_US_PER_SEC)),
-(INT64_MAX - 999997));
x = gpr_time_from_nanos(-(INT64_MAX - 999999997), GPR_TIMESPAN);
ASSERT_LT(x.tv_sec, 0);
ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
EXPECT_EQ((x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec), -(INT64_MAX - 999999997));
x = gpr_time_from_millis(-(INT64_MAX - 997), GPR_TIMESPAN);
ASSERT_LT(x.tv_sec, 0);
ASSERT_TRUE(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
EXPECT_EQ((x.tv_sec * GPR_MS_PER_SEC +
x.tv_nsec / (GPR_NS_PER_SEC / GPR_MS_PER_SEC)),
-(INT64_MAX - 997));
/* Test general -ve values. */
for (i = -1; i > -1000 * 1000 * 1000; i *= 7) {
x = gpr_time_from_micros(i, GPR_TIMESPAN);
ASSERT_EQ(x.tv_sec * GPR_US_PER_SEC + x.tv_nsec / GPR_NS_PER_US, i);
x = gpr_time_from_nanos(i, GPR_TIMESPAN);
ASSERT_EQ(x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec, i);
x = gpr_time_from_millis(i, GPR_TIMESPAN);
ASSERT_EQ(x.tv_sec * GPR_MS_PER_SEC + x.tv_nsec / GPR_NS_PER_MS, i);
}
}
TEST(TimeTest, AddSub) {
int i;
int j;
int k;
/* Basic addition and subtraction. */
for (i = -100; i <= 100; i++) {
for (j = -100; j <= 100; j++) {
for (k = 1; k <= 10000000; k *= 10) {
int sum = i + j;
int diff = i - j;
gpr_timespec it = gpr_time_from_micros(i * k, GPR_TIMESPAN);
gpr_timespec jt = gpr_time_from_micros(j * k, GPR_TIMESPAN);
gpr_timespec sumt = gpr_time_add(it, jt);
gpr_timespec difft = gpr_time_sub(it, jt);
if (gpr_time_cmp(gpr_time_from_micros(sum * k, GPR_TIMESPAN), sumt) !=
0) {
fprintf(stderr, "i %d j %d sum %d sumt ", i, j, sum);
fflush(stderr);
ts_to_s(sumt, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
ASSERT_TRUE(0);
}
if (gpr_time_cmp(gpr_time_from_micros(diff * k, GPR_TIMESPAN), difft) !=
0) {
fprintf(stderr, "i %d j %d diff %d diff ", i, j, diff);
fflush(stderr);
ts_to_s(sumt, &to_fp, stderr);
fprintf(stderr, "\n");
fflush(stderr);
ASSERT_TRUE(0);
}
}
}
}
}
TEST(TimeTest, Overflow) {
/* overflow */
gpr_timespec x = gpr_time_from_micros(1, GPR_TIMESPAN);
do {
x = gpr_time_add(x, x);
} while (gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)) < 0);
ASSERT_EQ(gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)), 0);
x = gpr_time_from_micros(-1, GPR_TIMESPAN);
do {
x = gpr_time_add(x, x);
} while (gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)) > 0);
ASSERT_EQ(gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)), 0);
}
TEST(TimeTest, StickyInfinities) {
int i;
int j;
int k;
gpr_timespec infinity[2];
gpr_timespec addend[3];
infinity[0] = gpr_inf_future(GPR_TIMESPAN);
infinity[1] = gpr_inf_past(GPR_TIMESPAN);
addend[0] = gpr_inf_future(GPR_TIMESPAN);
addend[1] = gpr_inf_past(GPR_TIMESPAN);
addend[2] = gpr_time_0(GPR_TIMESPAN);
/* Infinities are sticky */
for (i = 0; i != sizeof(infinity) / sizeof(infinity[0]); i++) {
for (j = 0; j != sizeof(addend) / sizeof(addend[0]); j++) {
gpr_timespec x = gpr_time_add(infinity[i], addend[j]);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
x = gpr_time_sub(infinity[i], addend[j]);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
}
for (k = -200; k <= 200; k++) {
gpr_timespec y = gpr_time_from_micros(k * 100000, GPR_TIMESPAN);
gpr_timespec x = gpr_time_add(infinity[i], y);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
x = gpr_time_sub(infinity[i], y);
ASSERT_EQ(gpr_time_cmp(x, infinity[i]), 0);
}
}
}
TEST(TimeTest, Similar) {
ASSERT_EQ(1, gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
gpr_inf_future(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
gpr_inf_past(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
gpr_inf_future(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
gpr_inf_past(GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_0(GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(15, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
ASSERT_EQ(1, gpr_time_similar(gpr_time_from_micros(15, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(25, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
ASSERT_EQ(0, gpr_time_similar(gpr_time_from_micros(25, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN),
gpr_time_from_micros(10, GPR_TIMESPAN)));
}
TEST(TimeTest, ConvertExtreme) {
gpr_timespec realtime = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
gpr_timespec monotime = gpr_convert_clock_type(realtime, GPR_CLOCK_MONOTONIC);
ASSERT_EQ(monotime.tv_sec, realtime.tv_sec);
ASSERT_EQ(monotime.clock_type, GPR_CLOCK_MONOTONIC);
}
TEST(TimeTest, CmpExtreme) {
gpr_timespec t1 = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
gpr_timespec t2 = {INT64_MAX, 2, GPR_CLOCK_REALTIME};
ASSERT_EQ(gpr_time_cmp(t1, t2), 0);
t1.tv_sec = INT64_MIN;
t2.tv_sec = INT64_MIN;
ASSERT_EQ(gpr_time_cmp(t1, t2), 0);
}
int main(int argc, char** argv) {
grpc::testing::TestEnvironment env(&argc, argv);
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}