int ZSOpenContainer_basic_check1()
{
ZS_status_t ret = ZS_SUCCESS;
ZS_cguid_t cguid;
fprintf(fp,"test %d:\n" ,++testCount);
ret = OpenContainer("t",&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS == ret){
ret = OpenContainer("t",&p,ZS_CTNR_RO_MODE,&cguid);
}
else return -1;
if(ZS_SUCCESS == ret){
ret = OpenContainer("t",&p,ZS_CTNR_RW_MODE,&cguid);
}
CloseContainer(cguid );
if(ZS_SUCCESS != DeleteContainer(cguid))
return -2;
if(ZS_SUCCESS == ret)
return 1;
return 0;
}
int ZSOpenContainer_invalid_flags()
{
ZS_status_t ret;
ZS_cguid_t cguid;
int flag;
fprintf(fp,"test %d:\n",++testCount);
ret = OpenContainer("test10",&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS != ret)
return -1;
ret = OpenContainer("test10",&p,0,&cguid);
if(ZS_SUCCESS == ret){
fprintf(fp,"Open Created Container invalid mode SUCCESS.\n");
flag = 1;
}
else{
fprintf(fp,"Open Created Container invalid mode fail:%s.\n",ZSStrError(ret));
flag = 0;
}
CloseContainer(cguid);
if(ZS_SUCCESS != DeleteContainer(cguid))
flag = -2;
return flag;
}
int ZSOpenContainer_invalid_cguid()
{
ZS_status_t ret;
ZS_cguid_t cguid;
ZS_cguid_t cguid_invalid;
int flag;
fprintf(fp,"test %d:\n",++testCount);
ret = OpenContainer("test8",&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS != ret)
return -1;
ret = OpenContainer("test8",&p,ZS_CTNR_RW_MODE,&cguid_invalid);
if(ZS_SUCCESS != ret){
fprintf(fp,"Open created Container invalid cguid fail:%s.\n",ZSStrError(ret));
flag = 0;
}
else{
fprintf(fp,"Open created Container invalid cguid success.\n");
flag = 1;
}
CloseContainer(cguid );
if(ZS_SUCCESS != DeleteContainer(cguid))
flag = -2;
return flag;
}
int ZSOpenContainer_openMore(int count)
{
ZS_status_t ret;
ZS_cguid_t cguid;
int flag;
uint32_t flags[2]={ZS_CTNR_RO_MODE,ZS_CTNR_RW_MODE};
fprintf(fp,"test %d:\n",++testCount);
ret = OpenContainer("test7",&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS != ret)
return -1;
for(int i = 0;i < count; i++){
ret = OpenContainer("test7",&p,flags[i%2],&cguid);
if(ZS_SUCCESS != ret)
break;
}
if(ZS_SUCCESS == ret){
fprintf(fp,"OpenContainer OpenMore success.\n");
flag = 1;
}
else{
fprintf(fp,"OpenContainer OpenMore fail:%s.\n",ZSStrError(ret));
flag = 0;
}
CloseContainer(cguid);
if(ZS_SUCCESS != DeleteContainer(cguid))
flag = -2;
return flag;
}
int ZSNextEnumeratedObject_Open_CreateObj_close(int count)
{
ZS_status_t ret = ZS_SUCCESS;
int flag;
struct ZS_iterator *iterator;
char key[6] = "key_a";
char data[7] = "data_a";
char key_in[MAX_OBJECT_COUNT][10]={""};
char data_in[MAX_OBJECT_COUNT][10]={""};
int num_in = 0;
int flags[] = {ZS_CTNR_RO_MODE,ZS_CTNR_RW_MODE};
ZS_cguid_t cguid;
fprintf(fp,"test %d:\n",++testCount);
OpenContainer("x3",ZS_CTNR_CREATE,&cguid);
for(int i = 0; i < count;i++){
ret = CreateObject(cguid,key,6,data,7);
if(ZS_SUCCESS != ret){
flag = -2;
while(i>0){
key[4]--;
if(ZS_SUCCESS != DeleteObject(cguid,key,6))flag = -3;
i--;
}
if(ZS_SUCCESS != CloseContainer(cguid ))flag = -3;
if(ZS_SUCCESS != DeleteContainer(cguid))flag = -3;
return flag;
}
strcpy(key_in[num_in],key);
strcpy(data_in[num_in],data);
num_in++;
CloseContainer(cguid );
OpenContainer("x3",flags[i%2],&cguid);
key[4]++;
}
ret = EnumerateContainerObjects(cguid,&iterator);
if(ZS_SUCCESS == ret){
num_out = 0;
while(ZS_SUCCESS == (ret = NextEnumeratedObject(iterator)));
FinishEnumeration(iterator);
if(ZS_OBJECT_UNKNOWN == ret){
flag = CheckEnumeratedObject(key_in,data_in,num_in);
}
else flag = -1;
}
else flag = -2;
for(int i = count;i > 0;i--){
key[4]--;
if(ZS_SUCCESS != DeleteObject(cguid,key,6)) flag = -3;
}
if(ZS_SUCCESS != CloseContainer(cguid ))flag = -3;
if(ZS_SUCCESS != DeleteContainer(cguid))flag = -3;
return flag;
}
int ZSOpenContainer_invalid_props()
{
ZS_status_t ret;
ZS_cguid_t cguid;
int flag;
fprintf(fp,"test %d:\n",++testCount);
p.writethru = 0;
p.evicting = 0;
ret = OpenContainer("test12",&p,ZS_CTNR_CREATE,&cguid);
// We set writethru=1 and evicting=0 in create so this open will pass
if(ZS_SUCCESS == ret){
fprintf(fp,"OpenContainer invalid props fail:%s.\n",ZSStrError(ret));
CloseContainer(cguid);
DeleteContainer(cguid);
flag = 1;
}
else{
fprintf(fp,"OpenContainer invalid props success.\n");
flag = 0;
}
p.writethru = 1;
return flag;
}
int ZSNextEnumeratedObject_basic_check2()
{
ZS_status_t ret;
int flag;
struct ZS_iterator *iterator;
ZS_cguid_t cguid;
fprintf(fp,"test %d:\n",++testCount);
OpenContainer("x2",ZS_CTNR_CREATE,&cguid);
CreateObject(cguid,"key_a",6,"data_a",7);
ret = EnumerateContainerObjects(cguid,&iterator);
if(ZS_SUCCESS != ret)
flag = -2;
else{
ret = NextEnumeratedObject(iterator);
FinishEnumeration(iterator);
if(ZS_SUCCESS == ret)
flag = 1;
else flag = -1;
}
if(ZS_SUCCESS != DeleteObject(cguid,"key_a",6))flag = -3;
if(ZS_SUCCESS != CloseContainer(cguid ))flag = -3;
if(ZS_SUCCESS != DeleteContainer(cguid))flag = -3;
return flag;
}
int test_invalid_object(uint32_t aw)
{
ZS_status_t ret;
int tag = 0;
testname[1] = "#test1: flush object with invalid objects.";
fprintf(fp,"****** async write = %d ******\n",aw);
fprintf(fp,"%s\n",testname[1]);
for(int i = 0; i < 3; i++)
{
ret = OpenContainer("test1", 1, aw, i);
if(ZS_SUCCESS == ret)
{
ret = FlushObject(cguid, "xxx", 4);
if(ZS_OBJECT_UNKNOWN == ret)
{
result[aw][1][i] = 1;
tag += 1;
}
(void)CloseContainer(cguid);
(void)DeleteContainer(cguid);
}
}
return (3 == tag);
}
int ZSOpenContainer_flags_check()
{
ZS_status_t ret;
ZS_cguid_t cguid,cguid_tmp;
int flag = 1;
uint32_t flags[2]={ZS_CTNR_RO_MODE,ZS_CTNR_RW_MODE};
fprintf(fp,"test %d:\n",++testCount);
for(int i = 0;i < 2;i++){
ret = OpenContainer("test11",&p,flags[i],&cguid);
if(ZS_SUCCESS != ret){
fprintf(fp,"ZSOpenContainer create one mode=%d Fail:%s.\n",flags[i],ZSStrError(ret));
if(flag==1)flag = 1;
}
else{
flag = 0;
fprintf(fp,"ZSOpenContainer create one mode=%d success.\n",flags[i]);
CloseContainer(cguid);
DeleteContainer(cguid);
}
}
ret = OpenContainer("test11",&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS != ret)
return -1;
ret = OpenContainer("test11",&p,ZS_CTNR_CREATE,&cguid_tmp);
if(ZS_SUCCESS != ret){
fprintf(fp,"ZSOpenContainer create twice failed.\n");
if(flag==1)flag = 1;
}
else{
fprintf(fp,"ZSOpenContainer create twice succeed:%s.\n",ZSStrError(ret));
flag = 0;
CloseContainer(cguid_tmp);
if(ZS_SUCCESS != DeleteContainer(cguid_tmp))
flag = -2;
}
CloseContainer(cguid);
if(ZS_SUCCESS != DeleteContainer(cguid))
flag = -2;
return flag;
}
void CHtmlWinParser::InitParser(const wxString& source)
{
CHtmlParser::InitParser(source);
wxASSERT_MSG(m_DC != NULL, wxT("no DC assigned to CHtmlWinParser!!"));
m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
m_FontSize = 3; //default one
CreateCurrentFont(); // we're selecting default font into
m_DC->GetTextExtent( wxT("H"), &m_CharWidth, &m_CharHeight);
/* NOTE : we're not using GetCharWidth/Height() because
of differences under X and win
*/
m_UseLink = false;
m_Link = CHtmlLinkInfo( wxEmptyString );
m_LinkColor.Set(0, 0, 0xFF);
m_ActualColor.Set(0, 0, 0);
m_Align = wxHTML_ALIGN_LEFT;
m_tmpLastWasSpace = false;
m_lastWordCell = NULL;
OpenContainer();
OpenContainer();
#if !wxUSE_UNICODE
wxString charset = ExtractCharsetInformation(source);
if (!charset.empty())
{
wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charset);
if (enc != wxFONTENCODING_SYSTEM)
SetInputEncoding(enc);
}
#endif
m_Container->InsertCell(new CHtmlColourCell(m_ActualColor));
wxColour windowColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW) ;
m_Container->InsertCell(
new CHtmlColourCell(GetWindow() ?
GetWindow()->GetBackgroundColour() :
windowColour,
wxHTML_CLR_BACKGROUND));
m_Container->InsertCell(new CHtmlFontCell(CreateCurrentFont()));
}
wxObject* wxHtmlWinParser::GetProduct()
{
wxHtmlContainerCell *top;
CloseContainer();
OpenContainer();
top = m_Container;
while (top->GetParent()) top = top->GetParent();
top->RemoveExtraSpacing(true, true);
return top;
}
int ZSNextEnumeratedObject_MoreObject3(int count)
{
ZS_status_t ret = ZS_SUCCESS;
int flag;
struct ZS_iterator *iterator;
char key[6] = "key_a";
char data[1024] = "data_a";
int i;
char *key_enum;
uint32_t keylen;
char *data_enum;
uint64_t datalen;
int num_in = 0;
num_out = 0;
ZS_cguid_t cguid;
fprintf(fp,"test %d:\n",++testCount);
OpenContainer("x4",ZS_CTNR_CREATE,&cguid);
for( i=0; i < count; i++){
ret = CreateObject(cguid,key,6,data,1024);
if(ZS_SUCCESS != ret){
break;
}
num_in++;
key[4]++;
}
ret = EnumerateContainerObjects(cguid,&iterator);
while(ZS_SUCCESS == ret){
ret = ZSNextEnumeratedObject(_zs_thd_state,iterator,&key_enum,&keylen,&data_enum,&datalen);
if(ZS_SUCCESS == ret)num_out++;
}
FinishEnumeration(iterator);
fprintf(fp,"num_in=%d,num_out=%d.\n",num_in,num_out);
if(num_out == num_in){
flag = 1;
fprintf(fp,"num_in=%d,num_out=%d.\n",num_in,num_out);
}
else flag = 0;
for(int j = i;j > 0;j--){
key[4]--;
if(ZS_SUCCESS != DeleteObject(cguid,key,6)) flag = -3;
}
if(ZS_SUCCESS != CloseContainer(cguid ))flag = -3;
if(ZS_SUCCESS != DeleteContainer(cguid))flag = -3;
return flag;
}
int ZSOpenContainer_openCloseMore2(int count)
{
ZS_status_t ret;
ZS_cguid_t cguid;
int flag;
ZS_boolean_t eviction[] = {0,0};
ZS_boolean_t persistence[] = {1,1};
ZS_boolean_t fifo[] = {0,0};
int i;
uint32_t flags[2]={ZS_CTNR_RO_MODE,ZS_CTNR_RW_MODE};
fprintf(fp,"test %d:\n",++testCount);
ret = OpenContainer("test6",&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS != ret)
return -1;
for(i = 0; i < count;i++){
ret = OpenContainer("test6",&p,flags[i%2],&cguid);
SetContainerProps(cguid,eviction[i%2],persistence[i%2],fifo[i%2],i%2);
CloseContainer(cguid);
if(ZS_SUCCESS != ret)
break;
}
if(ZS_SUCCESS == ret){
fprintf(fp,"OpenContainer OpenCloseMore success.\n");
flag = 1;
}
else{
fprintf(fp,"OpenContainer OpenCloseMore fail:%s.\n",ZSStrError(ret));
flag = 0;
}
if(ZS_SUCCESS != DeleteContainer(cguid))
return -2;
return flag;
}
int test_basic_check_1(uint32_t aw)
{
ZS_status_t ret;
int tag = 0;
testname[3] = "#test3:basic check for flush object.";
fprintf(fp,"****** async write = %d ******\n",aw);
fprintf(fp,"%s\n",testname[3]);
for(int i = 0; i < 3; i++)
{
ret = OpenContainer("test3", 1, aw, i);
if(ZS_SUCCESS == ret)
{
if(ZS_SUCCESS == WriteObject(cguid, "xxx", 4, "sadf", 5, 1))
{
ret = FlushObject(cguid, "xxx", 4);
if(ZS_SUCCESS == ret)
{
result[aw][3][i] += 1;
}
if(ZS_SUCCESS == WriteObject(cguid, "xxx", 4, "yyy", 4, 2))
{
ret = FlushObject(cguid, "xxx", 4);
if(ZS_SUCCESS == ret)
{
result[aw][3][i] += 1;
}
}
(void)DeleteObject(cguid, "xxx", 4);
}
(void)CloseContainer(cguid);
(void)DeleteContainer(cguid);
}
if(2 == result[aw][3][i])
{
result[aw][3][i] = 1;
tag += 1;
} else {
result[aw][3][i] = 0;
}
}
return (3 == tag);
}
int ZSNextEnumeratedObject_basic_check1()
{
ZS_status_t ret = ZS_SUCCESS;
int flag;
struct ZS_iterator *iterator;
char key[] = "key_a";
char data[] = "data_a";
char key_in[MAX_OBJECT_COUNT][10]={""};
char data_in[MAX_OBJECT_COUNT][10]={""};
int num_in = 0;
char *r_data;
uint64_t datalen;
num_out = 0;
ZS_cguid_t cguid;
fprintf(fp,"test %d:\n",++testCount);
OpenContainer("x1",ZS_CTNR_CREATE,&cguid);
fprintf(stderr,"test read!\n");
CreateObject(cguid,key,6,data,7);
fprintf(stderr,"test read--write ok!\n");
ZSReadObject(_zs_thd_state,cguid,key,6,&r_data,&datalen);
strcpy(key_in[num_in],key);
strcpy(data_in[num_in],data);
num_in++;
ret = EnumerateContainerObjects(cguid,&iterator);
if(ZS_SUCCESS != ret)
flag = -2;
else{
while(ZS_SUCCESS ==(ret = NextEnumeratedObject(iterator)));
FinishEnumeration(iterator);
if(ZS_OBJECT_UNKNOWN == ret)
flag = CheckEnumeratedObject(key_in,data_in,num_in);
else flag = -1;
}
if(ZS_SUCCESS != DeleteObject(cguid,"key_a",6))flag = -3;
if(ZS_SUCCESS != CloseContainer(cguid ))flag = -3;
if(ZS_SUCCESS != DeleteContainer(cguid))flag = -3;
return flag;
}
int ZSOpenContainer_createDeletedMore(int count)
{
ZS_status_t ret = ZS_SUCCESS;
ZS_cguid_t cguid;
fprintf(fp,"test %d:\n",++testCount);
for(int i =0 ;i < count;i++){
ret = OpenContainer("t",&p,ZS_CTNR_CREATE,&cguid);
CloseContainer(cguid );
DeleteContainer(cguid);
if(ZS_SUCCESS != ret){
fprintf(fp,"OpenContainer %drd create deleted container failed:%s.\n",count,ZSStrError(ret));
return 0;
}
}
fprintf(fp,"OpenContainer create deleted %d times success.\n",count);
return 1;
}
static ZS_status_t
container_ops(char *cname, uint64_t flag, uint64_t dura)
{
ZS_status_t ret = ZS_SUCCESS;
ret = OpenContainer(cname, flag, dura, &cguid);
if (ZS_SUCCESS != ret) {
fprintf(fp, "Open container failed with: %s\n", ZSStrError(ret));
goto exit_container_ops;
}
ret = CloseContainer(cguid);
if (ZS_SUCCESS != ret) {
fprintf(fp, "Close container failed with: %s\n", ZSStrError(ret));
goto exit_container_ops;
}
exit_container_ops:
return ret;
}
int ZSOpenContainer_createMore(int count)
{
ZS_status_t ret = ZS_SUCCESS;
ZS_cguid_t cguid[MAX_COUNT];
char cname[13] = "cntr_test_a";
int flag;
fprintf(fp,"test %d:\n",++testCount);
for(int i = 0;i< count;i++)
{
ret = OpenContainer(cname,&p,ZS_CTNR_CREATE,&cguid[i]);
if(ZS_SUCCESS != ret){
flag = -1;
for(int j = i-1;j>=0;j--){
CloseContainer(cguid[j] );
if(ZS_SUCCESS != DeleteContainer(cguid[j]))
flag = -2;
}
return flag;
}
cname[9]++;
}
if(ZS_SUCCESS == ret){
flag = 1;
fprintf(fp,"ZSOpenContainer create %d containers success:\n",count);
}
else{
flag = 0;
fprintf(fp,"ZSOpenContainer create %d containers failed:%s\n",count,ZSStrError(ret));
}
for(int i = 0;i< count;i++){
CloseContainer(cguid[i] );
if(ZS_SUCCESS != DeleteContainer(cguid[i]))
flag = -2;
}
return flag;
}
int ZSOpenContainer_basic_check_size()
{
ZS_status_t ret = ZS_SUCCESS;
ZS_cguid_t cguid;
fprintf(fp,"test %d:\n",++testCount);
p.size_kb = 0;
ret = OpenContainer("test",&p,ZS_CTNR_CREATE,&cguid);
p.size_kb = 3;
if(ZS_SUCCESS == ret){
fprintf(fp,"set size = 0 Create container success.\n");
CloseContainer(cguid );
if(ZS_SUCCESS != DeleteContainer(cguid))
return -2;
return 1;
}
else{
fprintf(fp,"set size = 0 Create container failed.\n");
return 0;
}
}
int ZSOpenContainer_invalid_cname1()
{
ZS_status_t ret;
ZS_cguid_t cguid;
int flag;
char cname[1];
cname[0] = '\0';
fprintf(fp,"test %d:\n",++testCount);
ret = OpenContainer(cname,&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS != ret){
fprintf(fp,"OpenContainer invalid cname fail:%s.\n",ZSStrError(ret));
flag = 1;
}
else{
fprintf(fp,"OpenContainer invalid cname success.\n");
CloseContainer(cguid);
DeleteContainer(cguid);
flag = 0;
}
return flag;
}
int test_invalid_key_keylen(uint32_t aw)
{
ZS_status_t ret;
int tag = 0;
testname[2] = "#test2: open c/ write o/flush object with wrong key/keylen.";
fprintf(fp,"****** async write = %d ******\n",aw);
fprintf(fp,"%s\n",testname[2]);
for(int i = 0; i < 3; i++)
{
ret = OpenContainer("test2", 1, aw, i);
if(ZS_SUCCESS == ret)
{
ret = WriteObject(cguid, "aaa", 4, "sadf", 5, 1);
if(ZS_SUCCESS == ret)
{
/*
ret = FlushObject(cguid, NULL, 4);
if(ZS_OBJECT_UNKNOWN == ret)
{
result[aw][2][i] += 1;
}
*/
ret = FlushObject(cguid, "aa", 4);
if(ZS_OBJECT_UNKNOWN == ret)
{
result[aw][2][i] += 1;
}
ret = FlushObject(cguid, "aaaaa", 4);
if(ZS_OBJECT_UNKNOWN == ret)
{
result[aw][2][i] += 1;
}
ret = FlushObject(cguid, "aaa", 0);
if(ZS_OBJECT_UNKNOWN == ret)
{
result[aw][2][i] += 1;
}
ret = FlushObject(cguid, "aaa", 1);
if(ZS_OBJECT_UNKNOWN == ret)
{
result[aw][2][i] += 1;
}
ret = FlushObject(cguid, "aaa", 10);
if(ZS_OBJECT_UNKNOWN == ret)
{
result[aw][2][i] += 1;
}
(void)DeleteObject(cguid, "aaa", 4);
}
(void)CloseContainer(cguid);
(void)DeleteContainer(cguid);
}
if(5 == result[aw][2][i])
{
result[aw][2][i] = 1;
tag += 1;
} else {
result[aw][2][i] = 0;
}
}
return (3 == tag);
}
int test_basic_check(uint32_t aw)
{
ZS_status_t ret;
int tag = 0;
int k;
char stmp[1000];
testname[1] = "#test1: basic check.";
fprintf(stderr,"****** async write = %d ******\n",aw);
fprintf(stderr,"%s\n",testname[1]);
ZS_stats_t stats1,stats2;
for(int i = 0; i < 10; i++)
{
ret = OpenContainer("test1", 1, aw, mode[i][0], mode[i][1], mode[i][2], mode[i][3]);
// ret = OpenContainer("test1", 1, aw, mode[i][0], mode[i][1], mode[i][2], 0);
fprintf(stderr, "OpenContainer returned %s\n", ZSStrError(ret));
if(ZS_SUCCESS == ret)
{
fprintf(fp, "OpenContainer succeeded!\n");
//(void)WriteObject(cguid, "xxxx", 5, "123", 4, ZS_WRITE_MUST_NOT_EXIST);
//(void)WriteObject(cguid, "yyyy", 5, "456", 4, ZS_WRITE_MUST_NOT_EXIST);
(void)WriteObject(cguid, "xxxx", 5, "123", 4, 0);
(void)WriteObject(cguid, "yyyy", 5, "456", 4, 0);
for (k=0; k<100; k++) {
sprintf(stmp, "zzz%d", k);
(void)WriteObject(cguid, stmp, 1+strlen(stmp), DummyData, DummyDataSize, 0);
}
(void) ZSFlushContainer(zs_thrd_state, cguid);
ret = GetContainerStats(cguid, &stats1);
fprintf(stderr, "GetContainerStats returned %d for cguid=%ld\n", ret, cguid);
if (ZS_SUCCESS == ret)
{
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_WRITETHRUS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_WRITETHRUS]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_WRITEBACKS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_WRITEBACKS]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_ASYNC_DRAINS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_ASYNC_DRAINS]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_ASYNC_PUTS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_ASYNC_PUTS]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_ASYNC_PUT_FAILS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_ASYNC_PUT_FAILS]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_ASYNC_FLUSHES=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_ASYNC_FLUSHES]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_ASYNC_FLUSH_FAILS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_ASYNC_FLUSH_FAILS]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_ASYNC_WRBKS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_ASYNC_WRBKS]);
fprintf(stderr, "cguid=%ld, ZS_CACHE_STAT_ASYNC_WRBK_FAILS=%ld\n", cguid, stats1.cache_stats[ZS_CACHE_STAT_ASYNC_WRBK_FAILS]);
if (mode[i][3] == 0) {
/*
* Currently write Back with Btree is not supported, Hence write back set is reset to write through in btree layer.
* In this unit test, This Part of the test collects writeback stats and compare them, so this part is bypassed now
*/
// writeback
/*if (mode[i][2]) {
// evicting
if ((stats1.cache_stats[ZS_CACHE_STAT_WRITETHRUS] == 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_WRBKS] != 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_WRBK_FAILS] == 0))
{
result[aw][1][i] += 1;
}
} else {
// non-evicting
if ((stats1.cache_stats[ZS_CACHE_STAT_WRITETHRUS] == 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_WRBKS] != 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_WRBK_FAILS] != 0))
{
result[aw][1][i] += 1;
}
}*/
result[aw][1][i] += 1;
} else {
// writethru
if (aw) {
// async writes
if (mode[i][2]) {
// evicting
if ((stats1.cache_stats[ZS_CACHE_STAT_WRITETHRUS] != 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_PUTS] != 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_PUT_FAILS] == 0))
{
result[aw][1][i] += 1;
}
} else {
// non-evicting
if ((stats1.cache_stats[ZS_CACHE_STAT_WRITETHRUS] != 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_PUTS] != 0) &&
(stats1.cache_stats[ZS_CACHE_STAT_ASYNC_PUT_FAILS] != 0))
{
result[aw][1][i] += 1;
}
}
} else {
if (stats1.cache_stats[ZS_CACHE_STAT_WRITETHRUS] != 0) {
result[aw][1][i] += 1;
}
}
}
}
(void)DeleteObject(cguid, "yyyy", 5);
(void)DeleteObject(cguid, "xxxx", 5);
ret = GetContainerStats(cguid, &stats2);
if(ZS_SUCCESS == ret)
{
result[aw][1][i] += 1;
}
}
if(2 == result[aw][1][i])
{
tag += 1;
result[aw][1][i] = 1;
}else {
result[aw][1][i] = 0;
}
(void)CloseContainer(cguid);
(void)DeleteContainer(cguid);
}
return (10 == tag);
}
static int32_t
mgr1()
{
ZS_status_t ret = ZS_SUCCESS;
fprintf(fp, "%s", "****** Test 1 *****\n");
/*
* Init ZS
*/
ret = pre_env();
if (ZS_SUCCESS != ret) {
fprintf(fp, "pre_env failed with err=%s\n", ZSStrError(ret));
return -1;
}
/*
* Create a container
*/
uint32_t flag = ZS_CTNR_CREATE; //ZS_CTNR_RO_MODE
uint32_t dura = ZS_DURABILITY_PERIODIC;
char cname[1024] = {'\0'};
uint32_t i;
int32_t r = 0;
int32_t count = 0;
sprintf(cname, "test_%d", 0);
do {
ret = OpenContainer(cname, flag, dura, &cguid);
/*
* Start high frequency I/O
*/
for (i = 0; i < MAX_ITERATION; i++)
{
r = rand() % 16 + 1;
if (0 == (r % 7)) {
fprintf(fp, "Random failure at %d\n", r);
goto exit_mgr1;
}
ret = io();
if (ZS_SUCCESS != ret) {
fprintf(fp, "io failed with err=%s\n", ZSStrError(ret));
goto exit_mgr1;
}
}
ret = DeleteContainer(cguid);
if (ZS_SUCCESS != ret) {
fprintf(fp, "DeleteContainer failed with err=%s\n", ZSStrError(ret));
goto exit_mgr1;
}
count++;
} while (count < 5);
exit_mgr1:
/*
* Start graceful shutdown
*/
fprintf(fp, "%s", "Starting graceful shutdown\n");
ret = clear_env();
fprintf(fp, "Shutdown returned %s:\n", ZSStrError(ret));
if (ZS_SUCCESS != ret) {
fprintf(fp, "%s", "Graceful shutdown test1 failed\n");
return 1;
}
/*
* Attempt another shutdown
*/
fprintf(fp, "%s", "Attempt another shutdown\n");
ret = ZSShutdown(zs_state);
fprintf(fp, "Next shutdown returned %s:\n", ZSStrError(ret));
if (ZS_SUCCESS == ret) {
fprintf(fp, "%s", "Next shutdown test2 failed\n");
return 1;
}
/*
* Perform I/O and container ops after shutdown
* It should fail
*/
ret = io();
fprintf(fp, "Post shutdown: I/O failed with %s\n", ZSStrError(ret));
if (ZS_SUCCESS == ret) {
fprintf(fp, "%s", "Post shutdown: I/O test3 failed\n");
return 1;
}
/*
* Perform container ops: It should fail
*/
ret = container_ops(cname, flag, dura);
fprintf(fp, "Post shutdown: container ops returns %s\n", ZSStrError(ret));
if (ZS_SUCCESS == ret) {
fprintf(fp, "%s", "Post shutdown: container ops test4 failed\n");
return 1;
}
return 0;
}
int main(int argc, char *argv[])
{
int result[3][2][5] = {{{0,0}}};
ZS_boolean_t eviction[] = {0,0,0};
ZS_boolean_t persistent[] = {1,1,1};
ZS_boolean_t fifo[] = {0,0,0};
ZS_boolean_t writethru[] = {1,1,1};
ZS_boolean_t async_writes[] = {0,1};
ZS_durability_level_t durability[] = {0,1,2};
char property[] = "SDF_REFORMAT";
char value[][4] = {"1","0"};
int resultCount = 12;
int num = 0;
if((fp = fopen("ZS_SetProperty.log", "w+")) == 0){
fprintf(stderr, " open failed!.\n");
return -1;
}
if( 1 != preEnvironment())
return 0;
fprintf(fp, "************Begin to test ***************\n");
for(int j = 0 ;j < 1;j++){
for(int i = 0 ; i < 3;i++){
ZSSetProperty(property,value[i]);
testCount = 0;
SetPropMode(eviction[i],persistent[i],fifo[i],writethru[i],async_writes[j],durability[i]);
OpenContainer("x",ZS_CTNR_CREATE,&cguid);
result[j][i][0] = ZSSetProperty_basic_check();
result[j][i][1] = ZSSetProperty_Open_CreateObj_close(2);
// result[j][i][2] = ZSSetProperty_MoreObject1(6);
// result[j][i][3] = ZSSetProperty_MoreObject2(5);
CloseContainer(cguid );
DeleteContainer(cguid);
}
}
CleanEnvironment();
for(int k = 0; k < 1; k++){
for(int j = 0;j < 3;j++){
fprintf(stderr, "test mode:eviction=%d,persistent=%d,fifo=%d,writethru=%d,async_writes=%d,durability=%d.SDF_REFORMAT=%d\n",eviction[j],persistent[j],fifo[j],writethru[j],async_writes[k],durability[j],(j+1)%2);
for(int i = 0; i < 4; i++){
if(result[k][j][i] == 1){
num++;
fprintf(stderr, "ZSSetProperty %drd success.\n",i+1);
}
else if(result[k][j][i] == -2)
fprintf(stderr, "ZSSetProperty test %drd fail to test.\n",i+1);
else if(result[k][j][i] == 0)
fprintf(stderr, "ZSSetProperty test %drd failed.\n",i+1);
else if(result[k][j][i] == -1)
fprintf(stderr, "ZSSetProperty test %drd return failed.\n",i+1);
else fprintf(stderr, "ZSSetProperty test %drd hit wrong.\n",i+1);
}
}
}
if(resultCount == num){
fprintf(stderr, "************ test pass!******************\n");
fprintf(stderr, "#The related test script is ZS_SetProperty.c\n");
fprintf(stderr, "#If you want, you can check test details in ZS_SetProperty.log\n");
return 0;
}
else
fprintf(stderr, "************%d test fail!******************\n",resultCount-num);
fprintf(stderr, "#The related test script is ZS_SetProperty.c\n");
fprintf(stderr, "#If you want, you can check test details in ZS_SetProperty.log\n");
return 1;
}
int ZSSetProperty_MoreObject2(int count)
{
ZS_status_t ret1 = ZS_SUCCESS,ret2;
ZS_cguid_t cguid1;
int flag;
struct ZS_iterator *iterator1,*iterator2;
char key1[6] = "key_a";
char key2[7] = "test_1";
char data1[7] = "data_a";
char data2[7] = "data_1";
char key_in[2][MAX_OBJECT_COUNT][10];
char data_in[2][MAX_OBJECT_COUNT][10];
int num_in[2] ={ 0};
fprintf(fp,"test %d:\n",++testCount);
OpenContainer("test",ZS_CTNR_CREATE,&cguid1);
for(int i =0; i < count; i++){
ret1 = CreateObject(cguid,key1,6,data1,7);
strcpy(key_in[0][num_in[0]],key1);
strcpy(data_in[0][num_in[0]],data1);
num_in[0]++;
ret2 = CreateObject(cguid1,key2,7,data2,7);
strcpy(key_in[1][num_in[1]],key2);
strcpy(data_in[1][num_in[1]],data2);
num_in[1]++;
if(ZS_SUCCESS != ret1 || ZS_SUCCESS != ret2){
flag = -2;
if(ZS_SUCCESS == ret1)
if(ZS_SUCCESS != DeleteObject(cguid,key1,6)) flag = -3;
if(ZS_SUCCESS == ret2)
if(ZS_SUCCESS != DeleteObject(cguid1,key2,7)) flag = -3;
for(int j = i-1;j >= 0;j--){
key1[4]--;
if(ZS_SUCCESS != DeleteObject(cguid,key1,6))flag = -3;
key2[5]--;
if(ZS_SUCCESS != DeleteObject(cguid1,key2,7))flag = -3;
}
if(ZS_SUCCESS != CloseContainer(cguid1 ))flag = -3;
if(ZS_SUCCESS != DeleteContainer(cguid1))flag = -3;
return -2;
}
key1[4]++;
key2[5]++;
}
ret1 = EnumerateContainerObjects(cguid,&iterator1);
ret2 = EnumerateContainerObjects(cguid1,&iterator2);
if(ZS_SUCCESS == ret1 && ZS_SUCCESS == ret2){
num_out = 0;
while(ZS_SUCCESS == (ret1 = NextEnumeratedObject(iterator1)));
if(ZS_OBJECT_UNKNOWN == ret1 ){
flag = CheckEnumeratedObject(key_in[0],data_in[0],num_in[0]);
if(flag == 1){
num_out = 0;
while(ZS_SUCCESS == (ret2 = NextEnumeratedObject(iterator2)));
if(ZS_OBJECT_UNKNOWN == ret2)
flag = CheckEnumeratedObject(key_in[1],data_in[1],num_in[1]);
else flag = -1;
}
else flag = -2;
}
else flag = -1;
FinishEnumeration(iterator1);
FinishEnumeration(iterator2);
}
else{
if(ZS_SUCCESS == ret1){
FinishEnumeration(iterator1);
}
if(ZS_SUCCESS == ret2){
FinishEnumeration(iterator2);
}
flag = -2;
}
for(int j = count-1;j >= 0;j--){
key1[4]--;
key2[5]--;
if(ZS_SUCCESS != DeleteObject(cguid,key1,6)) flag = -3;
if(ZS_SUCCESS != DeleteObject(cguid1,key2,7)) flag = -3;
}
if(ZS_SUCCESS != CloseContainer(cguid1 ))flag = -3;
if(ZS_SUCCESS != DeleteContainer(cguid1))flag = -3;
return flag;
}
int ZSOpenContainer_openCloseMore_createObj(int count)
{
ZS_status_t ret,ret_obj;
ZS_cguid_t cguid;
int flag, i;
char key[6]="key_a";
uint32_t flags[2]={ZS_CTNR_RO_MODE,ZS_CTNR_RW_MODE};
int tmp = 0;
// ZS + btree minimum container size is 8KB.
p.size_kb = 32;
fprintf(fp,"test %d:\n",++testCount);
ret = OpenContainer("test6",&p,ZS_CTNR_CREATE,&cguid);
if(ZS_SUCCESS != ret)
return -1;
ret_obj = CreateObject(cguid,key,6,"data",5);
CloseContainer(cguid);
for(i = 0;i < count; i++){
key[4]++;
ret = OpenContainer("test6",&p,flags[i%2],&cguid);
ret_obj = CreateObject(cguid,key,6,"data",5);
CloseContainer(cguid);
#ifdef RO_MODE_SUPPORTED
if(ZS_SUCCESS != ret) {
break;
} else if ((i%2 == 0) && (ret_obj == ZS_SUCCESS)) {
tmp = 1;
break;
} else if ((i%2 != 0) && (ret_obj != ZS_SUCCESS)) {
tmp = 1;
break;
}
#else
if (ZS_SUCCESS != ret || ZS_SUCCESS != ret_obj) {
tmp = 1;
break;
}
#endif
}
if(i == count) {
fprintf(fp,"OpenContainer OpenCloseMore to create obj success.\n");
flag = 1;
}
else if(tmp == 1) {
fprintf(fp,"OpenContainer OpenCloseMore to create obj failed:%s.\n",ZSStrError(ret));
flag = -2;
}
else{
fprintf(fp,"OpenContainer OpenCloseMore_obj fail:%s.\n",ZSStrError(ret));
flag = 0;
}
ret = OpenContainer("test6",&p,flags[1],&cguid);
if(ZS_SUCCESS != ret)
return -1;
for(int i = count;i >=0; i--){
ret = DeleteObject(cguid,key,6);
#ifdef RO_MODE_SUPPORTED
if((i%2 == 0) && (ret != ZS_SUCCESS)) {
flag = -2;
} else if ((i%2 != 0) && (ret == ZS_SUCCESS)) {
flag = -2;
}
#else
if (ret != ZS_SUCCESS) {
flag = -2;
}
#endif
key[4]--;
}
CloseContainer(cguid);
if(ZS_SUCCESS != DeleteContainer(cguid))
flag = -2;
return flag;
}
void wxHtmlWinParser::InitParser(const wxString& source)
{
wxHtmlParser::InitParser(source);
wxASSERT_MSG(m_DC != NULL, wxT("no DC assigned to wxHtmlWinParser!!"));
m_FontBold = m_FontItalic = m_FontUnderlined = m_FontFixed = FALSE;
m_FontSize = 3; //default one
CreateCurrentFont(); // we're selecting default font into
// we're not using GetCharWidth/Height() because of
// differences under X and win
wxCoord w,h;
m_DC->GetTextExtent( wxT("H"), &w, &h);
m_CharWidth = w;
m_CharHeight = h;
m_UseLink = false;
m_Link = wxHtmlLinkInfo( wxEmptyString );
m_LinkColor.Set(0, 0, 0xFF);
m_ActualColor.Set(0, 0, 0);
const wxColour windowColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW) ;
m_ActualBackgroundColor = m_windowInterface
? m_windowInterface->GetHTMLBackgroundColour()
: windowColour;
m_ActualBackgroundMode = wxTRANSPARENT;
m_Align = wxHTML_ALIGN_LEFT;
m_ScriptMode = wxHTML_SCRIPT_NORMAL;
m_ScriptBaseline = 0;
m_tmpLastWasSpace = false;
m_lastWordCell = NULL;
// open the toplevel container that contains everything else and that
// is never closed (this makes parser's life easier):
OpenContainer();
// then open the first container into which page's content will go:
OpenContainer();
#if !wxUSE_UNICODE
wxString charset = ExtractCharsetInformation(source);
if (!charset.empty())
{
wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(charset);
if (enc != wxFONTENCODING_SYSTEM)
SetInputEncoding(enc);
}
#endif
m_Container->InsertCell(new wxHtmlColourCell(m_ActualColor));
m_Container->InsertCell
(
new wxHtmlColourCell
(
m_ActualBackgroundColor,
m_ActualBackgroundMode == wxTRANSPARENT ? wxHTML_CLR_TRANSPARENT_BACKGROUND : wxHTML_CLR_BACKGROUND
)
);
m_Container->InsertCell(new wxHtmlFontCell(CreateCurrentFont()));
}
void
nsTreeContentView::AttributeChanged(nsIDocument* aDocument,
dom::Element* aElement,
int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
// Lots of codepaths under here that do all sorts of stuff, so be safe.
nsCOMPtr<nsIMutationObserver> kungFuDeathGrip(this);
// Make sure this notification concerns us.
// First check the tag to see if it's one that we care about.
nsIAtom* tag = aElement->Tag();
if (mBoxObject && (aElement == mRoot || aElement == mBody)) {
mBoxObject->ClearStyleAndImageCaches();
mBoxObject->Invalidate();
}
// We don't consider non-XUL nodes.
nsIContent* parent = nullptr;
if (!aElement->IsXUL() ||
((parent = aElement->GetParent()) && !parent->IsXUL())) {
return;
}
if (tag != nsGkAtoms::treecol &&
tag != nsGkAtoms::treeitem &&
tag != nsGkAtoms::treeseparator &&
tag != nsGkAtoms::treerow &&
tag != nsGkAtoms::treecell) {
return;
}
// If we have a legal tag, go up to the tree/select and make sure
// that it's ours.
for (nsIContent* element = aElement; element != mBody; element = element->GetParent()) {
if (!element)
return; // this is not for us
nsIAtom *parentTag = element->Tag();
if (element->IsXUL() && parentTag == nsGkAtoms::tree)
return; // this is not for us
}
// Handle changes of the hidden attribute.
if (aAttribute == nsGkAtoms::hidden &&
(tag == nsGkAtoms::treeitem || tag == nsGkAtoms::treeseparator)) {
bool hidden = aElement->AttrValueIs(kNameSpaceID_None,
nsGkAtoms::hidden,
nsGkAtoms::_true, eCaseMatters);
int32_t index = FindContent(aElement);
if (hidden && index >= 0) {
// Hide this row along with its children.
int32_t count = RemoveRow(index);
if (mBoxObject)
mBoxObject->RowCountChanged(index, -count);
}
else if (!hidden && index < 0) {
// Show this row along with its children.
nsCOMPtr<nsIContent> parent = aElement->GetParent();
if (parent) {
InsertRowFor(parent, aElement);
}
}
return;
}
if (tag == nsGkAtoms::treecol) {
if (aAttribute == nsGkAtoms::properties) {
if (mBoxObject) {
nsCOMPtr<nsITreeColumns> cols;
mBoxObject->GetColumns(getter_AddRefs(cols));
if (cols) {
nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aElement);
nsCOMPtr<nsITreeColumn> col;
cols->GetColumnFor(element, getter_AddRefs(col));
mBoxObject->InvalidateColumn(col);
}
}
}
}
else if (tag == nsGkAtoms::treeitem) {
int32_t index = FindContent(aElement);
if (index >= 0) {
Row* row = mRows[index];
if (aAttribute == nsGkAtoms::container) {
bool isContainer =
aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::container,
nsGkAtoms::_true, eCaseMatters);
row->SetContainer(isContainer);
if (mBoxObject)
mBoxObject->InvalidateRow(index);
}
else if (aAttribute == nsGkAtoms::open) {
bool isOpen =
aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::open,
nsGkAtoms::_true, eCaseMatters);
bool wasOpen = row->IsOpen();
if (! isOpen && wasOpen)
CloseContainer(index);
else if (isOpen && ! wasOpen)
OpenContainer(index);
}
else if (aAttribute == nsGkAtoms::empty) {
bool isEmpty =
aElement->AttrValueIs(kNameSpaceID_None, nsGkAtoms::empty,
nsGkAtoms::_true, eCaseMatters);
row->SetEmpty(isEmpty);
if (mBoxObject)
mBoxObject->InvalidateRow(index);
}
}
}
else if (tag == nsGkAtoms::treeseparator) {
int32_t index = FindContent(aElement);
if (index >= 0) {
if (aAttribute == nsGkAtoms::properties && mBoxObject) {
mBoxObject->InvalidateRow(index);
}
}
}
else if (tag == nsGkAtoms::treerow) {
if (aAttribute == nsGkAtoms::properties) {
nsCOMPtr<nsIContent> parent = aElement->GetParent();
if (parent) {
int32_t index = FindContent(parent);
if (index >= 0 && mBoxObject) {
mBoxObject->InvalidateRow(index);
}
}
}
}
else if (tag == nsGkAtoms::treecell) {
if (aAttribute == nsGkAtoms::ref ||
aAttribute == nsGkAtoms::properties ||
aAttribute == nsGkAtoms::mode ||
aAttribute == nsGkAtoms::src ||
aAttribute == nsGkAtoms::value ||
aAttribute == nsGkAtoms::label) {
nsIContent* parent = aElement->GetParent();
if (parent) {
nsCOMPtr<nsIContent> grandParent = parent->GetParent();
if (grandParent && grandParent->IsXUL()) {
int32_t index = FindContent(grandParent);
if (index >= 0 && mBoxObject) {
// XXX Should we make an effort to invalidate only cell ?
mBoxObject->InvalidateRow(index);
}
}
}
}
}
}
