"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "testapp.c" between
memcached-1.6.8.tar.gz and memcached-1.6.9.tar.gz

About: memcached is a high-performance, distributed memory object caching system, generic in nature, but originally intended for use in speeding up dynamic web applications by alleviating database load.

testapp.c  (memcached-1.6.8):testapp.c  (memcached-1.6.9)
skipping to change at line 23 skipping to change at line 23
#include <stdlib.h> #include <stdlib.h>
#include <errno.h> #include <errno.h>
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <fcntl.h> #include <fcntl.h>
#include "config.h" #include "config.h"
#include "cache.h" #include "cache.h"
#include "crc32c.h"
#include "hash.h" #include "hash.h"
#include "jenkins_hash.h" #include "jenkins_hash.h"
#include "stats_prefix.h" #include "stats_prefix.h"
#include "util.h" #include "util.h"
#include "protocol_binary.h" #include "protocol_binary.h"
#ifdef TLS #ifdef TLS
#include <openssl/ssl.h> #include <openssl/ssl.h>
#endif #endif
#define TMP_TEMPLATE "/tmp/test_file.XXXXXXX" #define TMP_TEMPLATE "/tmp/test_file.XXXXXXX"
skipping to change at line 168 skipping to change at line 169
cache_destroy(cache); cache_destroy(cache);
return (ptr == destruct_data) ? TEST_PASS : TEST_FAIL; return (ptr == destruct_data) ? TEST_PASS : TEST_FAIL;
} }
static enum test_return cache_reuse_test(void) static enum test_return cache_reuse_test(void)
{ {
int ii; int ii;
cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*), cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*),
NULL, NULL); NULL, NULL);
if (cache == NULL) {
return TEST_FAIL;
}
char *ptr = cache_alloc(cache); char *ptr = cache_alloc(cache);
cache_free(cache, ptr); cache_free(cache, ptr);
for (ii = 0; ii < 100; ++ii) { for (ii = 0; ii < 100; ++ii) {
char *p = cache_alloc(cache); char *p = cache_alloc(cache);
assert(p == ptr); assert(p == ptr);
cache_free(cache, ptr); cache_free(cache, ptr);
} }
cache_destroy(cache); cache_destroy(cache);
return TEST_PASS; return TEST_PASS;
} }
static enum test_return cache_bulkalloc(size_t datasize) static enum test_return cache_bulkalloc(size_t datasize)
{ {
cache_t *cache = cache_create("test", datasize, sizeof(char*), cache_t *cache = cache_create("test", datasize, sizeof(char*),
NULL, NULL); NULL, NULL);
if (cache == NULL) {
return TEST_FAIL;
}
#define ITERATIONS 1024 #define ITERATIONS 1024
void *ptr[ITERATIONS]; void *ptr[ITERATIONS];
for (int ii = 0; ii < ITERATIONS; ++ii) { for (int ii = 0; ii < ITERATIONS; ++ii) {
ptr[ii] = cache_alloc(cache); ptr[ii] = cache_alloc(cache);
assert(ptr[ii] != 0); assert(ptr[ii] != 0);
memset(ptr[ii], 0xff, datasize); memset(ptr[ii], 0xff, datasize);
} }
for (int ii = 0; ii < ITERATIONS; ++ii) { for (int ii = 0; ii < ITERATIONS; ++ii) {
skipping to change at line 217 skipping to change at line 224
return ret; return ret;
} }
static enum test_return cache_redzone_test(void) static enum test_return cache_redzone_test(void)
{ {
#ifndef HAVE_UMEM_H #ifndef HAVE_UMEM_H
cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*), cache_t *cache = cache_create("test", sizeof(uint32_t), sizeof(char*),
NULL, NULL); NULL, NULL);
if (cache == NULL) {
return TEST_FAIL;
}
/* Ignore SIGABRT */ /* Ignore SIGABRT */
struct sigaction old_action; struct sigaction old_action;
struct sigaction action = { .sa_handler = SIG_IGN, .sa_flags = 0}; struct sigaction action = { .sa_handler = SIG_IGN, .sa_flags = 0};
sigemptyset(&action.sa_mask); sigemptyset(&action.sa_mask);
sigaction(SIGABRT, &action, &old_action); sigaction(SIGABRT, &action, &old_action);
/* check memory debug.. */ /* check memory debug.. */
char *p = cache_alloc(cache); char *p = cache_alloc(cache);
char old = *(p - 1); char old = *(p - 1);
*(p - 1) = 0; *(p - 1) = 0;
skipping to change at line 303 skipping to change at line 313
assert(pfs1 != pfs2); assert(pfs1 != pfs2);
return TEST_PASS; return TEST_PASS;
} }
static enum test_return test_stats_prefix_record_get(void) { static enum test_return test_stats_prefix_record_get(void) {
PREFIX_STATS *pfs; PREFIX_STATS *pfs;
stats_prefix_clear(); stats_prefix_clear();
stats_prefix_record_get("abc:123", 7, false); stats_prefix_record_get("abc:123", 7, false);
pfs = stats_prefix_find("abc:123", 7); pfs = stats_prefix_find("abc:123", 7);
if (pfs == NULL) {
return TEST_FAIL;
}
assert(1 == pfs->num_gets); assert(1 == pfs->num_gets);
assert(0 == pfs->num_hits); assert(0 == pfs->num_hits);
stats_prefix_record_get("abc:456", 7, false); stats_prefix_record_get("abc:456", 7, false);
assert(2 == pfs->num_gets); assert(2 == pfs->num_gets);
assert(0 == pfs->num_hits); assert(0 == pfs->num_hits);
stats_prefix_record_get("abc:456", 7, true); stats_prefix_record_get("abc:456", 7, true);
assert(3 == pfs->num_gets); assert(3 == pfs->num_gets);
assert(1 == pfs->num_hits); assert(1 == pfs->num_hits);
stats_prefix_record_get("def:", 4, true); stats_prefix_record_get("def:", 4, true);
assert(3 == pfs->num_gets); assert(3 == pfs->num_gets);
assert(1 == pfs->num_hits); assert(1 == pfs->num_hits);
return TEST_PASS; return TEST_PASS;
} }
static enum test_return test_stats_prefix_record_delete(void) { static enum test_return test_stats_prefix_record_delete(void) {
PREFIX_STATS *pfs; PREFIX_STATS *pfs;
stats_prefix_clear(); stats_prefix_clear();
stats_prefix_record_delete("abc:123", 7); stats_prefix_record_delete("abc:123", 7);
pfs = stats_prefix_find("abc:123", 7); pfs = stats_prefix_find("abc:123", 7);
if (pfs == NULL) {
return TEST_FAIL;
}
assert(0 == pfs->num_gets); assert(0 == pfs->num_gets);
assert(0 == pfs->num_hits); assert(0 == pfs->num_hits);
assert(1 == pfs->num_deletes); assert(1 == pfs->num_deletes);
assert(0 == pfs->num_sets); assert(0 == pfs->num_sets);
stats_prefix_record_delete("def:", 4); stats_prefix_record_delete("def:", 4);
assert(1 == pfs->num_deletes); assert(1 == pfs->num_deletes);
return TEST_PASS; return TEST_PASS;
} }
static enum test_return test_stats_prefix_record_set(void) { static enum test_return test_stats_prefix_record_set(void) {
PREFIX_STATS *pfs; PREFIX_STATS *pfs;
stats_prefix_clear(); stats_prefix_clear();
stats_prefix_record_set("abc:123", 7); stats_prefix_record_set("abc:123", 7);
pfs = stats_prefix_find("abc:123", 7); pfs = stats_prefix_find("abc:123", 7);
if (pfs == NULL) {
return TEST_FAIL;
}
assert(0 == pfs->num_gets); assert(0 == pfs->num_gets);
assert(0 == pfs->num_hits); assert(0 == pfs->num_hits);
assert(0 == pfs->num_deletes); assert(0 == pfs->num_deletes);
assert(1 == pfs->num_sets); assert(1 == pfs->num_sets);
stats_prefix_record_delete("def:", 4); stats_prefix_record_delete("def:", 4);
assert(1 == pfs->num_sets); assert(1 == pfs->num_sets);
return TEST_PASS; return TEST_PASS;
} }
static enum test_return test_stats_prefix_dump(void) { static enum test_return test_stats_prefix_dump(void) {
skipping to change at line 880 skipping to change at line 899
send_ascii_command("stats cachedump 200 0 0\r\n"); send_ascii_command("stats cachedump 200 0 0\r\n");
read_ascii_response(buffer, sizeof(buffer)); read_ascii_response(buffer, sizeof(buffer));
assert(strncmp(buffer, "CLIENT_ERROR", strlen("CLIENT_ERROR")) == 0); assert(strncmp(buffer, "CLIENT_ERROR", strlen("CLIENT_ERROR")) == 0);
close_conn(); close_conn();
con = connect_server("127.0.0.1", port, false, enable_ssl); con = connect_server("127.0.0.1", port, false, enable_ssl);
assert(con); assert(con);
return TEST_PASS; return TEST_PASS;
} }
static enum test_return test_crc32c(void) {
uint32_t crc_hw, crc_sw;
char buffer[256];
for (int x = 0; x < 256; x++)
buffer[x] = x;
/* Compare harware to software implementaiton */
crc_hw = crc32c(0, buffer, 256);
crc_sw = crc32c_sw(0, buffer, 256);
assert(crc_hw == 0x9c44184b);
assert(crc_sw == 0x9c44184b);
/* Test that passing a CRC in also works */
crc_hw = crc32c(crc_hw, buffer, 256);
crc_sw = crc32c_sw(crc_sw, buffer, 256);
assert(crc_hw == 0xae10ee5a);
assert(crc_sw == 0xae10ee5a);
/* Test odd offsets/sizes */
crc_hw = crc32c(crc_hw, buffer + 1, 256 - 2);
crc_sw = crc32c_sw(crc_sw, buffer + 1, 256 - 2);
assert(crc_hw == 0xed37b906);
assert(crc_sw == 0xed37b906);
return TEST_PASS;
}
static enum test_return test_issue_102(void) { static enum test_return test_issue_102(void) {
char buffer[4096]; char buffer[4096];
memset(buffer, ' ', sizeof(buffer)); memset(buffer, ' ', sizeof(buffer));
buffer[sizeof(buffer) - 1] = '\0'; buffer[sizeof(buffer) - 1] = '\0';
close_conn(); close_conn();
con = connect_server("127.0.0.1", port, false, enable_ssl); con = connect_server("127.0.0.1", port, false, enable_ssl);
assert(con); assert(con);
send_ascii_command(buffer); send_ascii_command(buffer);
skipping to change at line 2275 skipping to change at line 2322
{ "stats_prefix_record_set", test_stats_prefix_record_set }, { "stats_prefix_record_set", test_stats_prefix_record_set },
{ "stats_prefix_dump", test_stats_prefix_dump }, { "stats_prefix_dump", test_stats_prefix_dump },
{ "issue_161", test_issue_161 }, { "issue_161", test_issue_161 },
{ "strtol", test_safe_strtol }, { "strtol", test_safe_strtol },
{ "strtoll", test_safe_strtoll }, { "strtoll", test_safe_strtoll },
{ "strtoul", test_safe_strtoul }, { "strtoul", test_safe_strtoul },
{ "strtoull", test_safe_strtoull }, { "strtoull", test_safe_strtoull },
{ "issue_44", test_issue_44 }, { "issue_44", test_issue_44 },
{ "vperror", test_vperror }, { "vperror", test_vperror },
{ "issue_101", test_issue_101 }, { "issue_101", test_issue_101 },
{ "crc32c", test_crc32c },
/* The following tests all run towards the same server */ /* The following tests all run towards the same server */
{ "start_server", start_memcached_server }, { "start_server", start_memcached_server },
{ "issue_92", test_issue_92 }, { "issue_92", test_issue_92 },
{ "issue_102", test_issue_102 }, { "issue_102", test_issue_102 },
{ "binary_noop", test_binary_noop }, { "binary_noop", test_binary_noop },
{ "binary_quit", test_binary_quit }, { "binary_quit", test_binary_quit },
{ "binary_quitq", test_binary_quitq }, { "binary_quitq", test_binary_quitq },
{ "binary_set", test_binary_set }, { "binary_set", test_binary_set },
{ "binary_setq", test_binary_setq }, { "binary_setq", test_binary_setq },
{ "binary_add", test_binary_add }, { "binary_add", test_binary_add },
skipping to change at line 2341 skipping to change at line 2389
SSLeay_add_ssl_algorithms(); SSLeay_add_ssl_algorithms();
SSL_load_error_strings(); SSL_load_error_strings();
enable_ssl = true; enable_ssl = true;
} }
#endif #endif
/* Initialized directly instead of using hash_init to avoid pulling in /* Initialized directly instead of using hash_init to avoid pulling in
the definition of settings struct from memcached.h */ the definition of settings struct from memcached.h */
hash = jenkins_hash; hash = jenkins_hash;
stats_prefix_init(':'); stats_prefix_init(':');
crc32c_init();
for (num_cases = 0; testcases[num_cases].description; num_cases++) { for (num_cases = 0; testcases[num_cases].description; num_cases++) {
/* Just counting */ /* Just counting */
} }
printf("1..%d\n", num_cases); printf("1..%d\n", num_cases);
for (ii = 0; testcases[ii].description != NULL; ++ii) { for (ii = 0; testcases[ii].description != NULL; ++ii) {
fflush(stdout); fflush(stdout);
#ifndef DEBUG #ifndef DEBUG
/* the test program shouldn't run longer than 10 minutes... */ /* the test program shouldn't run longer than 10 minutes... */
 End of changes. 10 change blocks. 
0 lines changed or deleted 50 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)