void gpgdo() { if (*cgi("delpub")) delkey(cgi("pubkeyname"), 0); else if (*cgi("delsec") && *cgi("really")) delkey(cgi("seckeyname"), 1); else if (*cgi("sign")) signkey(cgi("pubkeyname"), cgi("seckeyname"), cgi("signlevel")); else if (*cgi("setdefault")) setdefault(cgi("seckeyname")); }
//test bucket_find_entry and bucket_overflow_remove static void test_bucket_find_entry(struct lruhash *table) { testkey *k1 = newkey(12); testkey *k2 = newkey(12 + 1024); testkey *k3 = newkey(14); testkey *k4 = newkey(12 + 1024*2); hashvalue_t h = simplehash(12); struct lruhash_bucket bucket; memset(&bucket, 0, sizeof(bucket)); //remove from empty list bucket_overflow_remove(&bucket, &k1->entry); //find in empty list unit_assert(bucket_find_entry(table, &bucket, h, k1) == NULL); //insert bucket.overflow_list = &k1->entry; unit_assert(bucket_find_entry(table, &bucket, simplehash(13), k1) == NULL); unit_assert(k1->entry.hash == k2->entry.hash); unit_assert(bucket_find_entry(table, &bucket, h, k2) == NULL); unit_assert(bucket_find_entry(table, &bucket, h, k1) == &k1->entry); //remove bucket_overflow_remove(&bucket, &k1->entry); unit_assert(bucket_find_entry(table, &bucket, h, k1) == NULL); //insert multi unit_assert(k1->entry.hash == k4->entry.hash); k4->entry.overflow_next = &k1->entry; k3->entry.overflow_next = &k4->entry; bucket.overflow_list = &k3->entry; unit_assert(bucket_find_entry(table, &bucket, simplehash(13), k1) == NULL); unit_assert(k1->entry.hash == k2->entry.hash); unit_assert(bucket_find_entry(table, &bucket, h, k2) == NULL); unit_assert(bucket_find_entry(table, &bucket, h, k1) == &k1->entry); //remove mid unit_assert(bucket_find_entry(table, &bucket, k4->entry.hash, k4) == &k4->entry); bucket_overflow_remove(&bucket, &k4->entry); unit_assert(bucket_find_entry(table, &bucket, k4->entry.hash, k4) == NULL); //remove last bucket_overflow_remove(&bucket, &k1->entry); unit_assert(bucket_find_entry(table, &bucket, h, k1) == NULL); delkey(k1); delkey(k2); delkey(k3); delkey(k4); }
//test lru_front and lru_remove static void test_lru(struct lruhash *table) { testkey *k1 = newkey(12); testkey *k2 = newkey(14); lock_basic_lock(&table->lock); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); lru_remove(table, &k1->entry); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); //add one lru_front(table, &k1->entry); unit_assert( table->lru_head == &k1->entry && table->lru_tail == &k1->entry); //remove lru_remove(table, &k1->entry); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); //add two lru_front(table, &k1->entry); unit_assert(table->lru_head == &k1->entry && table->lru_tail == &k1->entry); lru_front(table, &k2->entry); unit_assert(table->lru_head == &k2->entry && table->lru_tail == &k1->entry); //remove first lru_remove(table, &k2->entry); unit_assert(table->lru_head == &k1->entry && table->lru_tail == &k1->entry); lru_front(table, &k2->entry); unit_assert(table->lru_head == &k2->entry && table->lru_tail == &k1->entry); //remove last lru_remove(table, &k1->entry); unit_assert(table->lru_head == &k2->entry && table->lru_tail == &k2->entry); //empty lru_remove(table, &k2->entry); unit_assert(table->lru_head == NULL && table->lru_tail == NULL); lock_basic_unlock(&table->lock); delkey(k1); delkey(k2); }
/** test adding a random element */ static void testremove(struct lruhash* table, testdata_t* ref[]) { int num = random() % HASHTESTMAX; testkey_t* key = newkey(num); lruhash_remove(table, myhash(num), key); ref[num] = NULL; delkey(key); }
//test remove a random element static void testremove(struct lruhash *table, testdata *ref[]) { int num = random() % MAXHASH; testkey *key = newkey(num); lruhash_remove(table, simplehash(num), key); if (ref) ref[num] = NULL; delkey(key); }
/** test lru_front lru_remove */ static void test_lru(struct lruhash* table) { testkey_t* k = newkey(12); testkey_t* k2 = newkey(14); lock_quick_lock(&table->lock); unit_assert( table->lru_start == NULL && table->lru_end == NULL); lru_remove(table, &k->entry); unit_assert( table->lru_start == NULL && table->lru_end == NULL); /* add one */ lru_front(table, &k->entry); unit_assert( table->lru_start == &k->entry && table->lru_end == &k->entry); /* remove it */ lru_remove(table, &k->entry); unit_assert( table->lru_start == NULL && table->lru_end == NULL); /* add two */ lru_front(table, &k->entry); unit_assert( table->lru_start == &k->entry && table->lru_end == &k->entry); lru_front(table, &k2->entry); unit_assert( table->lru_start == &k2->entry && table->lru_end == &k->entry); /* remove first in list */ lru_remove(table, &k2->entry); unit_assert( table->lru_start == &k->entry && table->lru_end == &k->entry); lru_front(table, &k2->entry); unit_assert( table->lru_start == &k2->entry && table->lru_end == &k->entry); /* remove last in list */ lru_remove(table, &k->entry); unit_assert( table->lru_start == &k2->entry && table->lru_end == &k2->entry); /* empty the list */ lru_remove(table, &k2->entry); unit_assert( table->lru_start == NULL && table->lru_end == NULL); lock_quick_unlock(&table->lock); delkey(k); delkey(k2); }
/** test adding a random element (unlimited range) */ static void testremove_unlim(struct lruhash* table, testdata_t** ref) { int num = random() % (HASHTESTMAX*10); testkey_t* key = newkey(num); lruhash_remove(table, myhash(num), key); if(ref) ref[num] = NULL; delkey(key); }
/** test adding a random element */ static void testlookup(struct lruhash* table, testdata_t* ref[]) { int num = random() % HASHTESTMAX; testkey_t* key = newkey(num); struct lruhash_entry* en = lruhash_lookup(table, myhash(num), key, 0); testdata_t* data = en? (testdata_t*)en->data : NULL; if(en) { unit_assert(en->key); unit_assert(en->data); } if(0) log_info("lookup %d got %d, expect %d", num, en? data->data :-1, ref[num]? ref[num]->data : -1); unit_assert( data == ref[num] ); if(en) { lock_rw_unlock(&en->lock); } delkey(key); }
//test lookup a random element static void testlookup(struct lruhash *table, testdata *ref[]) { int num = random() % MAXHASH; testkey *key = newkey(num); struct lruhash_entry *e = lruhash_lookup(table, simplehash(num), key); testdata *data = e ? (testdata *)e->data : NULL; if(e) { unit_assert(e->key); unit_assert(e->data); lock_basic_unlock(&e->lock); } if (ref) unit_assert(data == ref[num]); delkey(key); }
/** test adding a random element (unlimited range) */ static void testlookup_unlim(struct lruhash* table, testdata_t** ref) { int num = random() % (HASHTESTMAX*10); testkey_t* key = newkey(num); struct lruhash_entry* en = lruhash_lookup(table, myhash(num), key, 0); testdata_t* data = en? (testdata_t*)en->data : NULL; if(en) { unit_assert(en->key); unit_assert(en->data); } if(0 && ref) log_info("lookup unlim %d got %d, expect %d", num, en ? data->data :-1, ref[num] ? ref[num]->data : -1); if(data && ref) { /* its okay for !data, it fell off the lru */ unit_assert( data == ref[num] ); } if(en) { lock_rw_unlock(&en->lock); } delkey(key); }
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { TCHAR cap[16]=TEXT(""); static HWND hCalcButton=0; switch (msg) { case WM_CLOSE: DestroyWindow(hWnd); break; case WM_DESTROY: PostQuitMessage(0); break; case WM_KEYDOWN: if (wParam==VK_RETURN){ hCalc=FindWindow(TEXT("CalcFrame"),TEXT(" алькул¤тор")); //hCalcButton=FindWindowEx(hCalc,hCalcButton,TEXT("Button"),TEXT("")); //SetClassLong(hCalcButton,GCL_STYLE,CS_ if (button_list.empty()){ EnumChildWindows((HWND)hCalc, EnumChildProc, (LPARAM)hWnd); button_list.sort(); } //ShowWindow(button_list.back(), SW_HIDE); SetTimer(hWnd,1,1000,NULL); } if (wParam==VK_ESCAPE) KillTimer(hWnd,1); break; case WM_TIMER: delkey(hCalc); break; default: return DefWindowProc(hWnd, msg, wParam, lParam); } return 0; }
void test_slabhash_delkey(void* key, void* ATTR_UNUSED(arg)) { delkey((struct slabhash_testkey*)key); }
/** test bin_find_entry function and bin_overflow_remove */ static void test_bin_find_entry(struct lruhash* table) { testkey_t* k = newkey(12); testdata_t* d = newdata(128); testkey_t* k2 = newkey(12 + 1024); testkey_t* k3 = newkey(14); testkey_t* k4 = newkey(12 + 1024*2); hashvalue_t h = myhash(12); struct lruhash_bin bin; memset(&bin, 0, sizeof(bin)); bin_init(&bin, 1); /* remove from empty list */ bin_overflow_remove(&bin, &k->entry); /* find in empty list */ unit_assert( bin_find_entry(table, &bin, h, k) == NULL ); /* insert */ lock_quick_lock(&bin.lock); bin.overflow_list = &k->entry; lock_quick_unlock(&bin.lock); /* find, hash not OK. */ unit_assert( bin_find_entry(table, &bin, myhash(13), k) == NULL ); /* find, hash OK, but cmp not */ unit_assert( k->entry.hash == k2->entry.hash ); unit_assert( bin_find_entry(table, &bin, h, k2) == NULL ); /* find, hash OK, and cmp too */ unit_assert( bin_find_entry(table, &bin, h, k) == &k->entry ); /* remove the element */ lock_quick_lock(&bin.lock); bin_overflow_remove(&bin, &k->entry); lock_quick_unlock(&bin.lock); unit_assert( bin_find_entry(table, &bin, h, k) == NULL ); /* prepend two different elements; so the list is long */ /* one has the same hash, but different cmp */ lock_quick_lock(&bin.lock); unit_assert( k->entry.hash == k4->entry.hash ); k4->entry.overflow_next = &k->entry; k3->entry.overflow_next = &k4->entry; bin.overflow_list = &k3->entry; lock_quick_unlock(&bin.lock); /* find, hash not OK. */ unit_assert( bin_find_entry(table, &bin, myhash(13), k) == NULL ); /* find, hash OK, but cmp not */ unit_assert( k->entry.hash == k2->entry.hash ); unit_assert( bin_find_entry(table, &bin, h, k2) == NULL ); /* find, hash OK, and cmp too */ unit_assert( bin_find_entry(table, &bin, h, k) == &k->entry ); /* remove middle element */ unit_assert( bin_find_entry(table, &bin, k4->entry.hash, k4) == &k4->entry ); lock_quick_lock(&bin.lock); bin_overflow_remove(&bin, &k4->entry); lock_quick_unlock(&bin.lock); unit_assert( bin_find_entry(table, &bin, k4->entry.hash, k4) == NULL); /* remove last element */ lock_quick_lock(&bin.lock); bin_overflow_remove(&bin, &k->entry); lock_quick_unlock(&bin.lock); unit_assert( bin_find_entry(table, &bin, h, k) == NULL ); lock_quick_destroy(&bin.lock); delkey(k); delkey(k2); delkey(k3); delkey(k4); deldata(d); }