hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

patch 4.0

Browse Source
This commit is contained in:
wangzelin.wzl
2022-10-24 10:34:53 +08:00
parent 4ad6e00ec3
commit 93a1074b0c
10533 changed files with 2588271 additions and 2299373 deletions
Download Patch File Download Diff File Expand all files Collapse all files

231
deps/oblib/unittest/common/test_smart_var.cpp vendored
View File

@ -21,42 +21,51 @@
const int64_t s_size = 2 << 20;
using namespace std;
namespace oceanbase {
namespace common {
#ifdef S
#undef S
namespace oceanbase
{
namespace common
{
bool has_malloc = false;
bool has_free = false;
bool make_malloc_fail = false;
void* smart_alloc(const int64_t nbyte, const char* label)
void *smart_alloc(const int64_t nbyte, const char *label)
{
has_malloc = true;
return make_malloc_fail ? nullptr : ob_malloc(nbyte, label);
}
void smart_free(void* ptr)
void smart_free(void *ptr)
{
ob_free(ptr);
has_free = true;
}
template <int64_t N>
struct Buffer {
char buf[N];
};
template<int64_t N>
struct Buffer { char buf[N];};
void* test(void*)
bool in_stack(void *ptr)
{
void *stack_addr = nullptr;
size_t stack_size = 0;
abort_unless(0 == get_stackattr(stack_addr, stack_size));
return (char*)ptr > (char*)stack_addr && (char*)ptr < (char*)stack_addr + stack_size;
}
void *test(void *)
{
int ret = OB_SUCCESS;
// basic
{
int v = 0;
SMART_VAR(int, i, 100)
{
v = i;
}
EXPECT_EQ(v, 100);
int v = 0;
SMART_VAR(int, i, 100) {
v = i;
}
EXPECT_EQ(v, 100);
}
// array
@ -65,8 +74,7 @@ void* test(void*)
char buf[LEN];
char buf_cmp[LEN];
memset(buf_cmp, 'A', LEN);
SMART_VAR(char[LEN], b)
{
SMART_VAR(char[LEN], b) {
EXPECT_EQ(LEN, ARRAYSIZEOF(b));
memset(b, 'A', LEN);
memcpy(buf, b, LEN);
@ -77,11 +85,9 @@ void* test(void*)
// nested
{
int v1, v2 = 0;
SMART_VAR(int, i, 100)
{
SMART_VAR(int, i, 100) {
v1 = i;
SMART_VAR(int, i, 200)
{
SMART_VAR(int, i, 200) {
v2 = i;
}
}
@ -92,44 +98,36 @@ void* test(void*)
// construct && deconstruct
{
// scalar
class S {
class S
{
public:
S(int& k) : k_(k)
{
k_ += 1;
}
~S()
{
k_ += 2;
}
int& k_;
S(int &k)
: k_(k) { k_ += 1; }
~S() { k_ += 2; }
int &k_;
};
int k = 0;
{
SMART_VAR(S, s, k)
{
SMART_VAR(S, s, k) {
UNUSEDx(s);
}
}
EXPECT_EQ(k, 3);
// array
class V {
class V
{
public:
V() : self_k_(2), k_(nullptr)
{}
~V()
{
*k_ += self_k_;
}
V()
: self_k_(2), k_(nullptr) {}
~V() { *k_ += self_k_; }
int self_k_;
int* k_;
int *k_;
};
const int N = 10;
int ks[N] = {0};
{
SMART_VAR(V[N], v)
{
SMART_VAR(V[N], v) {
for (int i = 0; i < N; i++) {
v[i].k_ = &ks[i];
}
@ -146,10 +144,8 @@ void* test(void*)
bool from_stack = false;
has_malloc = false;
has_free = false;
SMART_VAR(Buffer<s_size / 2>, buf)
{
int v;
from_stack = abs((char*)&buf - (char*)&v) < s_size;
SMART_VAR(Buffer<s_size/2>, buf) {
from_stack = in_stack(&buf);
}
EXPECT_TRUE(from_stack);
EXPECT_FALSE(has_malloc);
@ -161,10 +157,9 @@ void* test(void*)
has_malloc = false;
has_free = false;
{
SMART_VAR(Buffer<s_size / 2>, buf)
{
SMART_VAR(Buffer<s_size/2>, buf) {
int v;
from_heap = abs((char*)&buf - (char*)&v) > s_size;
from_heap = !in_stack(&buf);
}
}
EXPECT_TRUE(from_heap);
@ -177,13 +172,10 @@ void* test(void*)
bool has_error = false;
make_malloc_fail = true;
{
SMART_VAR(Buffer<s_size / 2>, buf)
{
SMART_VAR(Buffer<s_size/2>, buf) {
UNUSEDx(buf);
EXPECT_TRUE(false);
}
else
{
} else {
has_error = true;
}
}
@ -197,55 +189,147 @@ void* test(void*)
int err = -10000;
ret = err;
int path = 0;
SMART_VAR(int, i)
{
SMART_VAR(int, i) {
UNUSEDx(i);
path = 1;
}
else
{
} else {
path = 2;
}
EXPECT_EQ(ret, OB_SUCCESS);
EXPECT_EQ(path, 1);
EXPECT_EQ(ret, err);
EXPECT_EQ(path, 2);
ret = OB_SUCCESS;
}
// direct heap
{
has_malloc = false;
int v = 0;
HEAP_VAR(int, i, 10)
{
HEAP_VAR(int, i, 10) {
v = i;
}
EXPECT_TRUE(has_malloc);
EXPECT_EQ(v, 10);
}
// check compile only
{
HEAP_VAR(char[100], c) {
}
}
// SMART_VARS && HEAP_VARS
{
bool from_stack = false;
int v = 0;
{
SMART_VARS_2((int, i, 10), (int, j, 10)) {
v = i + j;
from_stack = in_stack(&i);
from_stack = from_stack && in_stack(&j);
}
EXPECT_TRUE(from_stack);
EXPECT_EQ(20, v);
}
from_stack = false;
v = 0;
{
HEAP_VARS_2((int, i), (int, j)) {
i = j = 10;
v = i + j;
from_stack = in_stack(&i);
from_stack = from_stack && in_stack(&j);
}
EXPECT_FALSE(from_stack);
EXPECT_EQ(20, v);
}
from_stack = false;
v = 0;
{
SMART_VARS_3((int, i), (int, j), (int, k)) {
i = j = k = 10;
v = i + j + k;
from_stack = in_stack(&i);
from_stack = from_stack && in_stack(&j);
from_stack = from_stack && in_stack(&k);
}
EXPECT_TRUE(from_stack);
EXPECT_EQ(30, v);
}
from_stack = false;
v = 0;
{
HEAP_VARS_3((int, i, 10), (int, j, 10), (int, k, 10)) {
v = i + j + k;
from_stack = in_stack(&i);
from_stack = from_stack && in_stack(&j);
from_stack = from_stack && in_stack(&k);
}
EXPECT_FALSE(from_stack);
EXPECT_EQ(30, v);
}
v = 0;
{
HEAP_VARS_2((int, i, (666 + 0)), (Buffer<100>, b)) {
snprintf(b.buf, sizeof b.buf, "hello %d", i);
sscanf(b.buf, "hello %d", &v);
}
EXPECT_EQ(666, v);
}
}
// array initialization list
{
{
SMART_VAR(char[2], buf, "") {
EXPECT_EQ(strlen(buf), 0);
}
}
{
SMART_VAR(int[2], vals, 1, 2) {
EXPECT_EQ(vals[0], 1);
EXPECT_EQ(vals[1], 2);
}
}
{
using Pair = std::pair<int,int>;
SMART_VAR(Pair[2], pairs, {1,2}, {2,1}) {
EXPECT_EQ(pairs[0].first, 1);
EXPECT_EQ(pairs[0].second, 2);
EXPECT_EQ(pairs[1].first, 2);
EXPECT_EQ(pairs[1].second, 1);
}
}
}
return nullptr;
}
template <int64_t N>
template<int64_t N>
void do_alloc()
{
int ret = OB_SUCCESS;
char b[N];
cout << b[0] << endl;
has_malloc = false;
SMART_VAR(char[(8L << 10) + 1], buf)
{
SMART_VAR(char[(8L<<10)+1], buf) {
UNUSEDx(buf);
}
EXPECT_TRUE(has_malloc);
}
void* test2(void*)
void *test2(void *)
{
cout << "alloc from heap when stack used large than SMART_VAR_MAX_STACK_USE_SIZE" << endl;
int ret = OB_SUCCESS;
bool is_overflow = false;
int64_t used = 0;
if (OB_FAIL(check_stack_overflow(is_overflow, get_reserved_stack_size(), &used))) {}
if (OB_FAIL(check_stack_overflow(is_overflow,
get_reserved_stack_size(),
&used))) {
}
ASSERT_EQ(OB_SUCCESS, ret), nullptr;
constexpr static int64_t N = SMART_VAR_MAX_STACK_USE_SIZE;
@ -277,11 +361,12 @@ TEST(utility, used_size)
pthread_attr_destroy(&attr);
}
} // end namespace common
} // end namespace oceanbase
} // end namespace common
} // end namespace oceanbase
int main(int argc, char** argv)
int main(int argc, char **argv)
{
::testing::InitGoogleTest(&argc, argv);
::testing::InitGoogleTest(&argc,argv);
return RUN_ALL_TESTS();
}
#endif