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); } } } } } }