xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

test: add unitest for sdb

This commit is contained in:
Shengliang Guan 2022-04-28 13:56:10 +08:00
parent 46af79b90c
commit 7d3dd776f1
4 changed files with 206 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/dnode/mnode/sdb/sdb.h
View File

@ -331,7 +331,6 @@ int32_t sdbGetRawSoftVer(SSdbRaw *pRaw, int8_t *sver);
int32_t sdbGetRawTotalSize(SSdbRaw *pRaw); int32_t sdbGetRawTotalSize(SSdbRaw *pRaw);
SSdbRow *sdbAllocRow(int32_t objSize); SSdbRow *sdbAllocRow(int32_t objSize);
void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow, bool callFunc);
void *sdbGetRowObj(SSdbRow *pRow); void *sdbGetRowObj(SSdbRow *pRow);
typedef struct SSdb { typedef struct SSdb {

238
source/dnode/mnode/impl/test/sdb/sdbTest.cpp
View File

@ -73,32 +73,39 @@ SSdbRaw *strEncode(SStrObj *pObj) {
dataPos += sizeof(pObj->v32); dataPos += sizeof(pObj->v32);
sdbSetRawInt64(pRaw, dataPos, pObj->v64); sdbSetRawInt64(pRaw, dataPos, pObj->v64);
dataPos += sizeof(pObj->v64); dataPos += sizeof(pObj->v64);
sdbSetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->vstr)); sdbSetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
dataPos += sizeof(pObj->key); dataPos += sizeof(pObj->vstr);
sdbSetRawDataLen(pRaw, dataPos); sdbSetRawDataLen(pRaw, dataPos);
return pRaw; return pRaw;
} }
SSdbRaw *strDecode(SStrObj *pObj) { SSdbRow *strDecode(SSdbRaw *pRaw) {
int32_t dataPos = 0; int8_t sver = 0;
SSdbRaw *pRaw = sdbAllocRaw(SDB_USER, 1, sizeof(SStrObj)); if (sdbGetRawSoftVer(pRaw, &sver) != 0) return NULL;
if (sver != 1) return NULL;
sdbSetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->key)); SSdbRow *pRow = sdbAllocRow(sizeof(SStrObj));
if (pRow == NULL) return NULL;
SStrObj *pObj = (SStrObj *)sdbGetRowObj(pRow);
if (pObj == NULL) return NULL;
int32_t dataPos = 0;
sdbGetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->key));
dataPos += sizeof(pObj->key); dataPos += sizeof(pObj->key);
sdbSetRawInt8(pRaw, dataPos, pObj->v8); sdbGetRawInt8(pRaw, dataPos, &pObj->v8);
dataPos += sizeof(pObj->v8); dataPos += sizeof(pObj->v8);
sdbSetRawInt16(pRaw, dataPos, pObj->v16); sdbGetRawInt16(pRaw, dataPos, &pObj->v16);
dataPos += sizeof(pObj->v16); dataPos += sizeof(pObj->v16);
sdbSetRawInt32(pRaw, dataPos, pObj->v32); sdbGetRawInt32(pRaw, dataPos, &pObj->v32);
dataPos += sizeof(pObj->v32); dataPos += sizeof(pObj->v32);
sdbSetRawInt64(pRaw, dataPos, pObj->v64); sdbGetRawInt64(pRaw, dataPos, &pObj->v64);
dataPos += sizeof(pObj->v64); dataPos += sizeof(pObj->v64);
sdbSetRawBinary(pRaw, dataPos, pObj->key, sizeof(pObj->vstr)); sdbGetRawBinary(pRaw, dataPos, pObj->vstr, sizeof(pObj->vstr));
dataPos += sizeof(pObj->key); dataPos += sizeof(pObj->vstr);
sdbSetRawDataLen(pRaw, dataPos);
return pRaw; return pRow;
} }
int32_t strInsert(SSdb *pSdb, SStrObj *pObj) { return 0; } int32_t strInsert(SSdb *pSdb, SStrObj *pObj) { return 0; }
@ -110,39 +117,196 @@ int32_t strUpdate(SSdb *pSdb, SStrObj *pOld, SStrObj *pNew) {
pOld->v16 = pNew->v16; pOld->v16 = pNew->v16;
pOld->v32 = pNew->v32; pOld->v32 = pNew->v32;
pOld->v64 = pNew->v64; pOld->v64 = pNew->v64;
strcpy(pOld->vstr, pNew->vstr);
return 0; return 0;
} }
int32_t strDefault(SMnode *pMnode) { void strSetDefault(SStrObj *pObj, int32_t index) {
SStrObj strObj = {0}; memset(pObj, 0, sizeof(SStrObj));
strcpy(strObj.key, "k1000"); snprintf(pObj->key, sizeof(pObj->key), "k%d", index * 1000);
strObj.v8 = 1; pObj->v8 = index;
strObj.v16 = 1; pObj->v16 = index;
strObj.v32 = 1000; pObj->v32 = index * 1000;
strObj.v64 = 1000; pObj->v64 = index * 1000;
strcpy(strObj.vstr, "v1000"); snprintf(pObj->vstr, sizeof(pObj->vstr), "v%d", index * 1000);
SSdbRaw *pRaw = strEncode(&strObj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
return sdbWrite(pMnode->pSdb, pRaw);
} }
TEST_F(MndTestSdb, 01_Basic) { int32_t strDefault(SMnode *pMnode) {
SMnode mnode; SStrObj strObj;
SSdbRaw *pRaw = NULL;
strSetDefault(&strObj, 1);
pRaw = strEncode(&strObj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
if (sdbWrite(pMnode->pSdb, pRaw) != 0) return -1;
strSetDefault(&strObj, 2);
pRaw = strEncode(&strObj);
sdbSetRawStatus(pRaw, SDB_STATUS_READY);
if (sdbWriteWithoutFree(pMnode->pSdb, pRaw) != 0) return -1;
sdbFreeRaw(pRaw);
return 0;
}
bool sdbTraverseSucc1(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
if (pObj->v8 == 1) {
*p1 = *p2 + *p3 + pObj->v8;
}
return true;
}
bool sdbTraverseSucc2(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
*p1 = *p2 + *p3 + pObj->v8;
return true;
}
bool sdbTraverseFail(SMnode *pMnode, SStrObj *pObj, int32_t *p1, int32_t *p2, int32_t *p3) {
*p1 = *p2 + *p3;
return false;
}
TEST_F(MndTestSdb, 01_Write) {
void *pIter;
int32_t num;
SStrObj *pObj;
SMnode mnode;
SSdb *pSdb;
SSdbOpt opt = {0};
int32_t p1 = 0;
int32_t p2 = 111;
int32_t p3 = 222;
mnode.v100 = 100; mnode.v100 = 100;
mnode.v200 = 200; mnode.v200 = 200;
SSdbOpt opt = {0};
opt.pMnode = &mnode; opt.pMnode = &mnode;
opt.path = "/tmp/mnode_test_sdb"; opt.path = "/tmp/mnode_test_sdb";
taosRemoveDir(opt.path);
SSdb *pSdb = sdbInit(&opt);
EXPECT_NE(pSdb, nullptr);
SSdbTable strTable = { SSdbTable strTable = {
.sdbType = SDB_USER, .sdbType = SDB_USER,
.keyType = SDB_KEY_BINARY, .keyType = SDB_KEY_BINARY,
.deployFp = (SdbDeployFp)strEncode, .deployFp = (SdbDeployFp)strDefault,
.encodeFp = (SdbEncodeFp)strEncode,
.decodeFp = (SdbDecodeFp)strDecode,
.insertFp = (SdbInsertFp)strInsert,
.updateFp = (SdbUpdateFp)strUpdate,
.deleteFp = (SdbDeleteFp)strDelete,
};
pSdb = sdbInit(&opt);
mnode.pSdb = pSdb;
ASSERT_NE(pSdb, nullptr);
ASSERT_EQ(sdbSetTable(pSdb, strTable), 0);
ASSERT_EQ(sdbDeploy(pSdb), 0);
#if 0
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k1000");
ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k1000");
EXPECT_STREQ(pObj->vstr, "v1000");
EXPECT_EQ(pObj->v8, 1);
EXPECT_EQ(pObj->v16, 1);
EXPECT_EQ(pObj->v32, 1000);
EXPECT_EQ(pObj->v64, 1000);
sdbRelease(pSdb, pObj);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k2000");
ASSERT_NE(pObj, nullptr);
EXPECT_STREQ(pObj->key, "k2000");
EXPECT_STREQ(pObj->vstr, "v2000");
EXPECT_EQ(pObj->v8, 2);
EXPECT_EQ(pObj->v16, 2);
EXPECT_EQ(pObj->v32, 2000);
EXPECT_EQ(pObj->v64, 2000);
sdbRelease(pSdb, pObj);
pObj = (SStrObj *)sdbAcquire(pSdb, SDB_USER, "k200");
ASSERT_EQ(pObj, nullptr);
pIter = NULL;
num = 0;
do {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
if (pIter == NULL) break;
ASSERT_NE(pObj, nullptr);
num++;
sdbRelease(pSdb, pObj);
} while (1);
EXPECT_EQ(num, 2);
do {
pIter = sdbFetch(pSdb, SDB_USER, pIter, (void **)&pObj);
if (pIter == NULL) break;
if (strcmp(pObj->key, "k1000") == 0) {
sdbCancelFetch(pSdb, pIter);
break;
}
} while (1);
EXPECT_STREQ(pObj->key, "k1000");
p1 = 0;
p2 = 111;
p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
EXPECT_EQ(p1, 334);
p1 = 0;
p2 = 111;
p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseSucc2, &p1, &p2, &p3);
EXPECT_EQ(p1, 669);
p1 = 0;
p2 = 111;
p3 = 222;
sdbTraverse(pSdb, SDB_USER, (sdbTraverseFp)sdbTraverseFail, &p1, &p2, &p3);
EXPECT_EQ(p1, 333);
EXPECT_EQ(sdbGetSize(pSdb, SDB_USER), 2);
EXPECT_EQ(sdbGetMaxId(pSdb, SDB_USER), -1);
EXPECT_EQ(sdbGetTableVer(pSdb, SDB_USER), 2);
EXPECT_EQ(sdbUpdateVer(pSdb, 0), 2);
EXPECT_EQ(sdbUpdateVer(pSdb, 1), 3);
EXPECT_EQ(sdbUpdateVer(pSdb, -1), 2);
// insert, call func
// update, call func
// delete, call func 2
// write version
// sdb Write ver
// sdbRead
#endif
ASSERT_EQ(sdbWriteFile(pSdb), 0);
sdbCleanup(pSdb);
}
TEST_F(MndTestSdb, 01_Read) {
void *pIter;
int32_t num;
SStrObj *pObj;
SMnode mnode;
SSdb *pSdb;
SSdbOpt opt = {0};
int32_t p1 = 0;
int32_t p2 = 111;
int32_t p3 = 222;
mnode.v100 = 100;
mnode.v200 = 200;
opt.pMnode = &mnode;
opt.path = "/tmp/mnode_test_sdb";
taosRemoveDir(opt.path);
SSdbTable strTable = {
.sdbType = SDB_USER,
.keyType = SDB_KEY_BINARY,
.deployFp = (SdbDeployFp)strDefault,
.encodeFp = (SdbEncodeFp)strEncode, .encodeFp = (SdbEncodeFp)strEncode,
.decodeFp = (SdbDecodeFp)strDecode, .decodeFp = (SdbDecodeFp)strDecode,
.insertFp = (SdbInsertFp)strInsert, .insertFp = (SdbInsertFp)strInsert,
@ -150,7 +314,9 @@ TEST_F(MndTestSdb, 01_Basic) {
.deleteFp = (SdbDeleteFp)strUpdate, .deleteFp = (SdbDeleteFp)strUpdate,
}; };
sdbSetTable(pSdb, strTable); pSdb = sdbInit(&opt);
mnode.pSdb = pSdb;
ASSERT_EQ(sdbReadFile(pSdb), 0);
sdbCleanup(pSdb); sdbCleanup(pSdb);
} }

2
source/dnode/mnode/sdb/inc/sdbInt.h
View File

@ -52,6 +52,8 @@ typedef struct SSdbRow {
const char *sdbTableName(ESdbType type); const char *sdbTableName(ESdbType type);
void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper); void sdbPrintOper(SSdb *pSdb, SSdbRow *pRow, const char *oper);
void sdbFreeRow(SSdb *pSdb, SSdbRow *pRow, bool callFunc);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

4
source/os/src/osDir.c
View File

@ -72,8 +72,8 @@ void taosRemoveDir(const char *dirname) {
while ((de = taosReadDir(pDir)) != NULL) { while ((de = taosReadDir(pDir)) != NULL) {
if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue; if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue;
char filename[1024]; char filename[1024] = {0};
snprintf(filename, sizeof(filename), "%s/%s", dirname, taosGetDirEntryName(de)); snprintf(filename, sizeof(filename), "%s%s%s", dirname, TD_DIRSEP, taosGetDirEntryName(de));
if (taosDirEntryIsDir(de)) { if (taosDirEntryIsDir(de)) {
taosRemoveDir(filename); taosRemoveDir(filename);
} else { } else {