Navigation

← Previous Change
Next Change →

Changeset 877 for tests

Timestamp:

08/06/07 18:40:58 (1 year ago)

Author:

cesar

Message:

--

Files:

tests/cache/cherokee/cache_obj.c (modified) (1 diff)
tests/cache/cherokee/cache_obj.h (modified) (2 diffs)
tests/cache/cherokee/cache_obj_http.c (modified) (4 diffs)
tests/cache/cherokee/cache_table.c (modified) (9 diffs)
tests/cache/cherokee/cache_table.h (modified) (1 diff)
tests/cache/cherokee/test.c (modified) (5 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

tests/cache/cherokee/cache_obj.c

r691	r877
32	32	obj->usage = 0;
33	33	obj->last_access = 0;
	34	obj->clean_up_func = NULL;
	35
	36	return ret_ok;
	37	}
	38
	39
	40	ret_t
	41	cherokee_cache_obj_mrproper (cherokee_cache_obj_t *obj)
	42	{
	43	obj->usage = 0;
	44	obj->last_access = 0;
	45	obj->clean_up_func = NULL;
34	46
35	47	return ret_ok;
36	48	}
37	49
	50	ret_t
	51	cherokee_cache_obj_clean_up (cherokee_cache_obj_t *obj)
	52	{
	53	ret_t ret;
	54
	55	/* Sanity check
	56	*/
	57	if (obj->clean_up_func == NULL)
	58	return ret_error;
	59	/* Clean up func by concrete obj
	60	*/
	61	ret = obj->clean_up_func(obj);
	62	return ret;
	63	}
38	64
39		~~ret_t~~
40		~~cherokee_cache_obj_mrproper (cherokee_cache_obj_t *obj)~~
41		{
42		~~return ret_ok;~~
43		}

tests/cache/cherokee/cache_obj.h

r694	r877
32	32
33	33	#include <cherokee/common.h>
34		~~#include <cherokee/buffer.h>~~
35	34
36	35	CHEROKEE_BEGIN_DECLS
	36
	37	struct cherokee_cache_obj;
	38
	39	typedef ret_t (* cherokee_obj_clean_up_func_t) (struct cherokee_cache_obj *cache_obj);
37	40
38	41	struct cherokee_cache_obj {
39	42	/* Accessing data
40	43	*/
41		cuint_t usage;
42		time_t last_access;
	44	cuint_t usage;
	45	time_t last_access;
	46	cherokee_obj_clean_up_func_t clean_up_func;
43	47	};
44	48	typedef struct cherokee_cache_obj cherokee_cache_obj_t;
…	…
49	53	ret_t cherokee_cache_obj_init (cherokee_cache_obj_t *obj);
50	54	ret_t cherokee_cache_obj_mrproper (cherokee_cache_obj_t *obj);
	55	ret_t cherokee_cache_obj_clean_up (cherokee_cache_obj_t *obj);
51	56
52	57	CHEROKEE_END_DECLS

tests/cache/cherokee/cache_obj_http.c

r694	r877
26	26	#include "cache_obj_http.h"
27	27
28
29	28	/* Implements _new and _free methods
30	29	*/
…	…
32	31	CHEROKEE_ADD_FUNC_FREE (cache_obj_http);
33	32
	33
	34	ret_t
	35	cherokee_cache_obj_http_mrproper (cherokee_cache_obj_http_t *obj)
	36	{
	37	ret_t ret;
	38
	39	/* First, destroy parent
	40	*/
	41	cherokee_cache_obj_mrproper (CACHE_OBJ(obj));
	42	CACHE_OBJ(obj)->clean_up_func = NULL;
	43
	44	ret = cherokee_buffer_mrproper (&obj->id);
	45	if (unlikely (ret != ret_ok)) return ret_error;
	46
	47	ret = cherokee_buffer_mrproper (&obj->body);
	48	if (unlikely (ret != ret_ok)) return ret_error;
	49
	50	return ret_ok;
	51	}
34	52
35	53	ret_t
…	…
41	59	*/
42	60	cherokee_cache_obj_init (CACHE_OBJ(obj));
	61	CACHE_OBJ(obj)->clean_up_func = (cherokee_obj_clean_up_func_t *) cherokee_cache_obj_http_free;
43	62
44	63	/* Init object properties
…	…
52	71	return ret_ok;
53	72	}
54
55
56		~~ret_t~~
57		~~cherokee_cache_obj_http_mrproper (cherokee_cache_obj_http_t *obj)~~
58		{
59		~~ret_t ret;~~
60
61		~~/* Destroy the objecj properties~~
62		*/
63		~~ret = cherokee_buffer_mrproper (&obj->id);~~
64		~~if (unlikely (ret != ret_ok)) return ret_error;~~
65
66		~~ret = cherokee_buffer_mrproper (&obj->body);~~
67		~~if (unlikely (ret != ret_ok)) return ret_error;~~
68
69		~~/* Call its parent destructor~~
70		*/
71		~~cherokee_cache_obj_mrproper (CACHE_OBJ(obj));~~
72		~~return ret_ok;~~
73		}

tests/cache/cherokee/cache_table.c

r695	r877
25	25	#include <cherokee/common.h>
26	26	#include <cherokee/buffer.h>
27		#include ~~"common-internal.h"~~
	27	#include <cherokee/common-internal.h>
28	28	#include "cache_table.h"
29	29	#include "cache_obj.h"
	30
	31	#define ENTRIES "cache_table"
30	32
31	33	static ret_t
…	…
33	35	{
34	36	ret_t ret;
	37
	38	CHEROKEE_RWLOCK_WRITER(&CACHE_TABLE(cache)->lock_table);
	39	ret = cherokee_avl_add (&CACHE_TABLE(cache)->objs, key, (void **)item);
	40	CHEROKEE_RWLOCK_UNLOCK(&CACHE_TABLE(cache)->lock_table);
	41
	42	TRACE(ENTRIES, "%d:%i\n", key->buf, ret);
	43
	44	return ret;
	45	}
35	46
36		~~ret = cherokee_table_add (&CACHE_TABLE(cache)->objs, key->buf, (void **)item);~~
37		~~if (unlikely (ret != ret_ok)) return ret;~~
38
39		~~return ret_ok;~~
40		}
41	47
42	48	static ret_t
…	…
45	51	ret_t ret;
46	52
47		ret = cherokee_table_get (&CACHE_TABLE(cache)->objs, key->buf, (void **)item);
48		if (unlikely (ret != ret_ok)) return ret;
	53	CHEROKEE_RWLOCK_READER(&CACHE_TABLE(cache)->lock_table);
	54	ret = cherokee_avl_get (&CACHE_TABLE(cache)->objs, key, (void **)item);
	55	CHEROKEE_RWLOCK_UNLOCK(&CACHE_TABLE(cache)->lock_table);
	56
	57	return ret;
	58	}
49	59
50		~~return ret_ok;~~
51		}
52	60
53	61	static ret_t
…	…
56	64	ret_t ret;
57	65
58		ret = cherokee_table_del (&CACHE_TABLE(cache)->objs, key->buf, (void **)item);
59		if (unlikely (ret != ret_ok)) return ret;
	66	CHEROKEE_RWLOCK_WRITER(&CACHE_TABLE(cache)->lock_table);
	67	ret = cherokee_avl_del (&CACHE_TABLE(cache)->objs, key, (void **)item);
	68	CHEROKEE_RWLOCK_UNLOCK(&CACHE_TABLE(cache)->lock_table);
60	69
61		return ret~~_ok~~;
	70	return ret;
62	71	}
63	72
…	…
65	74	static ret_t
66	75	clean_up (cherokee_cache_t *cache)
67		{
68		/* cherokee_cache_obj_mrproper doesn't know the concrete mrproper needed here,
69		* It should be available in cherokee_cache_obj_*_t
70		*/
	76	{
	77	ret_t ret;
	78
	79	CHEROKEE_RWLOCK_WRITER(&CACHE_TABLE(cache)->lock_table);
	80	ret = cherokee_avl_mrproper(&CACHE_TABLE(cache)->objs,
	81	(cherokee_func_free_t)
	82	cherokee_cache_obj_clean_up);
	83	CHEROKEE_RWLOCK_UNLOCK(&CACHE_TABLE(cache)->lock_table);
71	84
72		return ret~~_ok~~;
	85	return ret;
73	86	}
	87
74	88
75	89	static ret_t
…	…
87	101	cuint_t g;
88	102	cint_t c;
89
90		CHEROKEE_NEW(n,buffer);
91
92		cherokee_buffer_init(n);
	103
	104	cherokee_buffer_t *n;
	105	cherokee_buffer_new(&n);
93	106
94	107	for (s = buf->buf; buf->buf + buf->len >= s; s++) {
…	…
107	120
108	121	*key = n;
109
110		~~TRACE(ENTRIES, "url:%s, key: %s\n", buf->buf, BUF(n)->buf);~~
111	122	return ret_ok;
112	123
113	124	}
114
115
116	125
117	126	ret_t
…	…
133	142	CACHE(cache)->clean_up = (cherokee_cache_func_clean_up_t) clean_up;
134	143
	144	ret = cherokee_avl_init(&CACHE_TABLE(cache)->objs);
	145	if (unlikely (ret != ret_ok)) return ret_error;
	146
135	147	INIT_LIST_HEAD(&CACHE_TABLE(cache)->to_delete);
136	148
137		ret = cherokee_table_init_case(&CACHE_TABLE(cache)->objs);
138		if (unlikely (ret != ret_ok)) return ret_error;
	149	CHEROKEE_RWLOCK_INIT (&CACHE_TABLE(cache)->lock_table, NULL);
139	150
140	151	return ret_ok;
…	…
154	165	/* cache->objs already deleted by _clean_up()
155	166	*/
	167	CHEROKEE_RWLOCK_DESTROY (&CACHE_TABLE(cache)->lock_table);
	168
156	169	cherokee_list_del (&cache->to_delete);
157	170

tests/cache/cherokee/cache_table.h

r695	r877
30	30	#define CHEROKEE_CACHE_TABLE_H
31	31
	32	#include <cherokee/avl.h>
	33	#include <cherokee/list.h>
32	34	#include <cherokee/cache.h>
33		~~#include <cherokee/table.h>~~
34		~~#include <cherokee/list.h>~~
35	35
36	36	CHEROKEE_BEGIN_DECLS
37	37
38	38	typedef struct {
39		cherokee_cache_t parent;
	39	cherokee_cache_t parent;
40	40
41	41	/* Objects collection
42	42	*/
43		cherokee_~~table_t~~ objs; /* cherokee_cache_obj_ts */
	43	cherokee_avl_t objs; /* cherokee_cache_obj_ts */
44	44	cherokee_list_t to_delete;
45		}cherokee_cache_table_t;
	45	CHEROKEE_RWLOCK_T(lock_table);
	46	} cherokee_cache_table_t;
46	47
47	48	#define CACHE_TABLE(c) ((cherokee_cache_table_t *)(c))

tests/cache/cherokee/test.c

r695	r877
24	24
25	25	#include "common-internal.h"
26
27	26	#include "cache_file.h"
28	27	#include "cache_obj_file.h"
29
30	28	#include "cache_table.h"
31	29	#include "cache_obj_http.h"
…	…
36	34	int test_table ();
37	35
38
39	36	int
40	37	main ()
41	38	{
42	39	ret_t ret;
	40
43	41	printf("Cherokee cache_table test:\n");
44	42	ret = test_table();
45	43	if (ret != ret_ok)
46	44	fprintf(stderr, "test_file failed\n");
	45	/*
47	46
48	47	printf("Cherokee cache_file test:\n");
…	…
50	49	if (ret != ret_ok)
51	50	fprintf(stderr, "test_file failed\n");
52
	51	*/
53	52	return ret_ok;
54	53	}
…	…
57	56	int test_table()
58	57	{
59		cuint_t i;
60		ret_t ret;
	58	cuint_t i;
	59	ret_t ret;
	60
	61	cherokee_buffer_t buf;
	62	cherokee_buffer_t *key;
61	63
62		CHEROKEE_NEW_STRUCT(key, buffer);
63		~~CHEROKEE_NEW_STRUCT(buf, buffer)~~;
	64	cherokee_cache_obj_http_t *obj;
	65	cherokee_cache_table_t cache;
64	66
65		CHEROKEE_NEW_STRUCT(obj, cache_obj_http);
66		CHEROKEE_NEW_STRUCT(obj2, cache_obj_http);
	67	cherokee_cache_table_init (&cache);
67	68
68		CHEROKEE_NEW_STRUCT(cache, cache_table);
69		cherokee_cache_table_init (cache);
	69	/* Store some stuff
	70	*/
	71	for (i=0; i<NUM_OBJS; i++) {
	72
	73	cherokee_cache_obj_http_new (&obj);
70	74
71		/* Store some stuff
72		*/
73		for (i=0; i<NUM_OBJS; i++) {
	75	cherokee_buffer_add_va (&obj->id, "info-%d", i);
	76	cherokee_cache_gen_key (CACHE(&cache), &key, &obj->id);
	77	cherokee_buffer_add_va (&obj->body, "<html>%d</html>", i);
	78
	79	ret = cherokee_cache_add (CACHE(&cache), key, CACHE_OBJ(obj));
	80	if (ret != ret_ok)
	81	fprintf(stderr, "Error Writing\n");
	82
	83	cherokee_buffer_free(key);
	84	}
	85
	86	/* Read the stuff
	87	*/
	88	cherokee_cache_obj_http_init (obj);
74	89
75		cherokee_cache_obj_http_new (&obj);
76		cherokee_buffer_init(buf);
77
78		//CHEROKEE_RWLOCK_WRITER(&obj->lock);
79		cherokee_buffer_add_va (buf, "info-%d", i);
80
81		cherokee_cache_gen_key (CACHE(cache), &key, buf);
82		cherokee_buffer_swap_buffers (&obj->id, key);
83		cherokee_buffer_add_va (&obj->body, "<html>%d</html>", i);
84
85		cherokee_cache_add (CACHE(cache), &obj->id, CACHE_OBJ(obj));
86		//CHEROKEE_RWLOCK_UNLOCK(&obj->lock);
87
88		cherokee_buffer_mrproper(buf);
89		cherokee_buffer_free(key);
90		}
91
92		/* Read the stuff
93		*/
94		for (i=0; i<NUM_OBJS+3; i++) {
95		cherokee_buffer_init(buf);
96
97		cherokee_buffer_add_va (buf, "info-%d", i);
98		cherokee_cache_gen_key (CACHE(cache), &key, buf);
99		cherokee_buffer_swap_buffers(&obj->id, key);
100
101		ret = cherokee_cache_get(CACHE(cache), &obj->id, CACHE_OBJ(&obj2));
102		if (ret != ret_ok)
103		printf("%s Not found\n", obj->id.buf);
104		//else
105		// printf("found %s\n", CACHE_OBJ_HTTP(obj2)->id.buf);
106
107		cherokee_buffer_mrproper(buf);
108		}
109
110		cherokee_cache_clean_up (CACHE(cache));
111		cherokee_cache_table_mrproper (cache);
112
113		return ret_ok;
	90	for (i=0; i<NUM_OBJS+3; i++) {
	91	cherokee_buffer_init(&buf);
	92
	93	cherokee_buffer_add_va (&buf, "info-%d", i);
	94	cherokee_cache_gen_key (CACHE(&cache), &key, &buf);
	95
	96	ret = cherokee_cache_get(CACHE(&cache), key, (cherokee_cache_obj_t **)(&obj));
	97	if (ret != ret_ok)
	98	fprintf(stderr, "%s Not found\n", key->buf);
	99	//else
	100	// fprintf(stderr, "found %s\n", CACHE_OBJ_HTTP(obj)->id.buf);
	101
	102	cherokee_buffer_mrproper(&buf);
	103	cherokee_buffer_free(key);
	104	}
	105
	106	cherokee_cache_clean_up (CACHE(&cache));
	107	cherokee_cache_table_mrproper (&cache);
	108
	109	return ret_ok;
114	110	}
115	111
…	…
162	158	ret = cherokee_cache_get (CACHE(&cache), &name, (cherokee_cache_obj_t **)&obj);
163	159
164		~~printf (~~"%s -> %p (ret=%d)\n", name.buf, obj, ret);
	160	fprintf (stderr, "%s -> %p (ret=%d)\n", name.buf, obj, ret);
165	161	cherokee_buffer_mrproper (&name);
166	162	}
167
168
169	163	cherokee_cache_mrproper (CACHE(&cache));
170	164	cherokee_cache_obj_mrproper (CACHE_OBJ(&obj));