| /* |
| ** Copyright 2003-2004 The Apache Software Foundation |
| ** |
| ** Licensed under the Apache License, Version 2.0 (the "License"); |
| ** you may not use this file except in compliance with the License. |
| ** You may obtain a copy of the License at |
| ** |
| ** http://www.apache.org/licenses/LICENSE-2.0 |
| ** |
| ** Unless required by applicable law or agreed to in writing, software |
| ** distributed under the License is distributed on an "AS IS" BASIS, |
| ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ** See the License for the specific language governing permissions and |
| ** limitations under the License. |
| */ |
| |
| #include "apr_time.h" |
| #include "apr_strings.h" |
| #include "apreq_env.h" |
| #include "test_apreq.h" |
| #include "apreq.h" |
| #include "apreq_tables.h" |
| #include "apr_hash.h" |
| #if APR_HAVE_STDIO_H |
| #include <stdio.h> |
| #endif |
| #if APR_HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #if APR_HAVE_STRING_H |
| #include <string.h> |
| #endif |
| |
| static apreq_table_t *t = NULL; |
| static apreq_table_t *s = NULL; |
| static apreq_table_t *h = NULL; |
| |
| #define NELTS 16 |
| #define LOOP 10000 |
| #define FAIL(MSG) \ |
| CuFail(tc, apr_psprintf(p, MSG ": APR = %.3f vs APREQ = %.3f (microseconds)", \ |
| (double)apr_delta / LOOP, (double)apreq_delta / LOOP)) |
| #define TEST_DELTAS(winner,loser,MSG) if (winner##_delta > loser##_delta) FAIL(MSG) |
| |
| #define RUN_GET(k,v) do {apr_time_t apr_delta,apreq_delta;const char *val; \ |
| int i; apreq_delta = apr_time_now(); for(i=0;i<LOOP;++i) val = \ |
| apreq_table_get(t,k); apreq_delta = apr_time_now() - apreq_delta; \ |
| if (v) { CuAssertPtrNotNull(tc,val);CuAssertStrEquals(tc,v,val);} \ |
| else CuAssertPtrEquals(tc,NULL,val); \ |
| apr_delta = apr_time_now(); for(i=0;i<LOOP;++i) val = apr_table_get(s,k); \ |
| apr_delta = apr_time_now() - apr_delta; \ |
| if (v) {CuAssertPtrNotNull(tc,val); CuAssertStrEquals(tc,v,val);} \ |
| else CuAssertPtrEquals(tc,NULL,val);\ |
| TEST_DELTAS(apreq,apr,"apr_table_get(" k ") wins"); apr_delta = apr_time_now(); \ |
| /* for(i=0;i<LOOP;++i) val = apr_hash_get(h,k,APR_HASH_KEY_STRING);\ |
| apr_delta = apr_time_now() - apr_delta; \ |
| if (v) {CuAssertPtrNotNull(tc,val);CuAssertStrEquals(tc,v,val);} \ |
| else CuAssertPtrEquals(tc,NULL,val); \ |
| TEST_DELTAS(apreq,apr,"APR hash_get(" k ") wins"); \ |
| */} while (0) |
| |
| |
| |
| #define V(k,v) apreq_make_value(p,k,strlen(k),v,strlen(v)) |
| #define VV(k) { #k, 0, 1, 0 } |
| |
| static char *headers[12] = {"Host", "User-Agent", "Accept", |
| "Accept-Language", "Accept-Encoding", |
| "Accept-Charset", "Keep-Alive", |
| "Connection", "Referer", "Cookie", |
| "Content-Type", "Content-Length"}; |
| |
| static apreq_table_t *init_apreq(int N) |
| { |
| apreq_table_t *t = apreq_table_make(p,N); |
| int j; |
| static apreq_value_t v[] = { VV(Host), VV(User-Agent), VV(Accept), |
| VV(Accept-Language), VV(Accept-Encoding), |
| VV(Accept-Charset), VV(Keep-Alive), |
| VV(Connection), VV(Referer), VV(Cookie), |
| VV(Content-Type), VV(Content-Length) }; |
| for (j = 0; j < 12; ++j) |
| apreq_table_addv(t,v + j); |
| |
| return t; |
| } |
| |
| static apr_table_t *init_apr(int N) |
| { |
| apr_table_t *t = apr_table_make(p,N); |
| int j; |
| |
| for (j=0; j < 12; ++j) |
| apr_table_addn(t, headers[j], ""); |
| |
| return t; |
| } |
| |
| |
| static apr_hash_t *init_hash(void) |
| { |
| apr_hash_t *h = apr_hash_make(p); |
| int j; |
| |
| for (j = 0; j < 12; ++j) { |
| const char *k = headers[j]; |
| int klen = strlen(k); |
| const char *v = apr_hash_get(h, k, klen); |
| if (v == NULL) |
| apr_hash_set(h, k, klen, ""); |
| else |
| apr_hash_set(h, k, klen, apr_pstrcat(p,v,", ", k, NULL)); |
| } |
| return h; |
| } |
| |
| |
| /* measures httpd server's request header initialization time */ |
| static void perf_init(CuTest *tc) |
| { |
| apr_time_t apreq_delta,apr_delta; |
| int i; |
| |
| apr_delta = apr_time_now(); |
| for (i=0; i<LOOP;++i) { |
| apr_table_t *s = init_apr(NELTS); |
| /* apr_table_t *t = apr_table_make(p,NELTS); |
| // apr_table_overlap(t,s,APR_OVERLAP_TABLES_MERGE); |
| */ apr_table_compress(s); |
| } |
| apr_delta = apr_time_now() - apr_delta; |
| |
| apreq_delta = apr_time_now(); |
| for (i=0; i<LOOP;++i) { |
| apreq_table_t *t = init_apreq(NELTS); |
| apreq_table_normalize(t); |
| } |
| apreq_delta = apr_time_now() - apreq_delta; |
| |
| |
| TEST_DELTAS(apreq,apr,"apreq should win"); |
| |
| apr_delta = apr_time_now(); |
| for (i=0; i<LOOP;++i) { |
| apr_hash_t *h = init_hash(); |
| } |
| apr_delta = apr_time_now() - apr_delta; |
| |
| TEST_DELTAS(apr,apreq,"apr_hash should win"); |
| } |
| |
| |
| #define GET_AVG(N) \ |
| apr_delta = apr_time_now(); \ |
| for (j = 0; j < LOOP; ++j) { \ |
| const char *val = apr_table_get(s, headers[j % N]); \ |
| CuAssertPtrNotNull(tc, val); \ |
| } \ |
| apr_delta = apr_time_now() - apr_delta; \ |
| apreq_delta = apr_time_now(); \ |
| for (j = 0; j < LOOP; ++j) { \ |
| const char *val = apreq_table_get(t, headers[j % N]); \ |
| CuAssertPtrNotNull(tc, val); \ |
| } \ |
| apreq_delta = apr_time_now() - apreq_delta; |
| |
| static void perf_get_avg(CuTest *tc) |
| { |
| apr_table_t *s = init_apr(NELTS); |
| apreq_table_t *t = init_apreq(NELTS); |
| apr_time_t apr_delta, apreq_delta; |
| int j; |
| |
| GET_AVG (2); TEST_DELTAS(apr,apreq,"apr_tables should win (2)"); |
| GET_AVG (4); TEST_DELTAS(apr,apreq,"apr_tables should win (4)"); |
| GET_AVG (6); TEST_DELTAS(apreq,apr,"apreq should win (6)"); |
| GET_AVG (8); TEST_DELTAS(apreq,apr,"apreq should win (8)"); |
| GET_AVG(10); TEST_DELTAS(apreq,apr,"apreq should win (10)"); |
| GET_AVG(12); TEST_DELTAS(apreq,apr,"apreq should win (12)"); |
| } |
| |
| |
| /* |
| * nontrivial trees |
| * ------------------ |
| * |
| * (4) Accept-Encoding (7) Connection |
| * / \ / \ |
| * (2) Accept Accept-Language (3) (9) Cookie Content-Type (10) |
| * \ / |
| * (5) Accept-Charset Content-Length (11) |
| * |
| * (checksum doesn't help here) (checksum is a big win except |
| * for the Content-Length path.) |
| * |
| * |
| * apr_hash: (0.5 ~ 0.6 microseconds / lookup) |
| * apreq_table: (0.3 ~ 0.4 microseconds / entry) |
| * apr_table: (0.2 ~ 0.3 microseconds / entry) |
| */ |
| |
| |
| static void perf_get(CuTest *tc) |
| { |
| apr_hash_t *h = init_hash(); |
| apr_table_t *s = init_apr(NELTS); |
| apreq_table_t *t = init_apreq(NELTS); |
| apr_time_t apr_delta, apreq_delta; |
| int j; |
| |
| /* expected apr winners: "Accept", "Connection", "Cookie" */ |
| |
| RUN_GET("Accept-Encoding",""); |
| RUN_GET("Accept-Language",""); |
| RUN_GET("Accept-Charset",""); |
| RUN_GET("Content-Length",""); |
| RUN_GET("Content-Type",""); /* apr typically wins by ~.05 microseconds, |
| or ~ 25 clock cycles on my 500Mhz CPU */ |
| } |
| |
| |
| |
| #ifdef footoo |
| |
| static void table_set(CuTest *tc) |
| { |
| const char *val; |
| apreq_table_t *t = init_apreq(APREQ_NELTS); |
| apr_table_t *s = init_apr(APREQ_NELTS); |
| apreq_table_set(t1, V("setkey","bar")); |
| |
| apreq_table_set(t1, V("setkey","2ndtry")); |
| val = apreq_table_get(t1,"setkey"); |
| CuAssertStrEquals(tc,"2ndtry",val); |
| |
| } |
| |
| static void table_getnotthere(CuTest *tc) |
| { |
| const char *val; |
| |
| val = apreq_table_get(t1, "keynotthere"); |
| CuAssertPtrEquals(tc, NULL,val); |
| } |
| |
| static void table_add(CuTest *tc) |
| { |
| const char *val; |
| |
| apreq_table_add(t1, V("add", "bar")); |
| apreq_table_add(t1, V("add", "foo")); |
| val = apreq_table_get(t1, "add"); |
| CuAssertStrEquals(tc, "bar", val); |
| |
| |
| apreq_table_add(t1, V("f", "top")); |
| apreq_table_add(t1, V("fo", "child")); |
| apreq_table_add(t1, V("fro", "child-right")); |
| apreq_table_add(t1, V("foo", "bar")); |
| |
| /* |
| * f(5) black fo(6) black |
| * fo(6) red => f(5)red fro(7)red |
| * fro(7) red |
| * |
| */ |
| |
| |
| apreq_table_add(t1, V("flo", "child-left")); |
| apreq_table_add(t1, V("flr", "child-left-right")); |
| apreq_table_add(t1, V("frr", "child-right-right")); |
| apreq_table_add(t1, V("frl", "child-right-left")); |
| apreq_table_add(t1, V("flr", "child-left-right")); |
| apreq_table_add(t1, V("fll", "child-left-left")); |
| |
| apreq_table_add(t1, V("foot", "bart")); |
| apreq_table_add(t1, V("foon", "barn")); |
| apreq_table_add(t1, V("foot", "bart")); |
| apreq_table_add(t1, V("foop", "barp")); |
| apreq_table_add(t1, V("food", "bard")); |
| apreq_table_add(t1, V("foof", "barf")); |
| apreq_table_add(t1, V("fooz", "barz")); |
| apreq_table_add(t1, V("fooq", "barq")); |
| apreq_table_add(t1, V("foot", "bart")); |
| apreq_table_add(t1, V("fooj", "barj")); |
| apreq_table_add(t1, V("fook", "bark")); |
| apreq_table_add(t1, V("fool", "barl")); |
| apreq_table_add(t1, V("foor", "barr")); |
| apreq_table_add(t1, V("foos", "bars")); |
| |
| apreq_table_add(t1, V("foot", "bart")); |
| apreq_table_add(t1, V("foon", "barn")); |
| apreq_table_add(t1, V("foot", "bart")); |
| apreq_table_add(t1, V("foop", "barp")); |
| apreq_table_add(t1, V("food", "bard")); |
| apreq_table_add(t1, V("foof", "barf")); |
| apreq_table_add(t1, V("fooz", "barz")); |
| apreq_table_add(t1, V("fooq", "barq")); |
| apreq_table_add(t1, V("foot", "bart")); |
| apreq_table_add(t1, V("fooj", "barj")); |
| apreq_table_add(t1, V("fook", "bark")); |
| apreq_table_add(t1, V("fool", "barl")); |
| apreq_table_add(t1, V("foor", "barr")); |
| apreq_table_add(t1, V("foos", "bars")); |
| |
| apreq_table_add(t1, V("quux", "quux")); |
| apreq_table_add(t1, V("quuxa", "quuxa")); |
| apreq_table_add(t1, V("quuxz", "quuxz")); |
| apreq_table_add(t1, V("quuxb", "quuxb")); |
| apreq_table_add(t1, V("quuxg", "quuxg")); |
| apreq_table_add(t1, V("quuxw", "quuxw")); |
| apreq_table_add(t1, V("quuxr", "quuxr")); |
| apreq_table_add(t1, V("alpha", "omega")); |
| |
| val = apreq_table_get(t1, "foo"); |
| CuAssertStrEquals(tc, "bar", val); |
| val = apreq_table_get(t1, "quuxb"); |
| CuAssertStrEquals(tc, "quuxb", val); |
| val = apreq_table_get(t1,"flo"); |
| CuAssertStrEquals(tc, "child-left", val); |
| } |
| |
| static void table_unset(CuTest *tc) { |
| const char *val; |
| apreq_table_unset(t1, "flo"); |
| val = apreq_table_get(t1, "flo"); |
| CuAssertPtrEquals(tc, NULL, val); |
| |
| val = apreq_table_get(t1, "fro"); |
| CuAssertStrEquals(tc, "child-right", val); |
| val = apreq_table_get(t1, "fll"); |
| CuAssertStrEquals(tc, "child-left-left", val); |
| val = apreq_table_get(t1, "frl"); |
| CuAssertStrEquals(tc, "child-right-left", val); |
| |
| } |
| |
| |
| static void table_perf(CuTest *tc) |
| { |
| CuAssertStrEquals(tc, "quuxb", apreq_table_get(t1,"quuxb")); |
| |
| RUN_GET("alpha", "omega", "APR wins worst-case scenario"); |
| RUN_GET("quuxb", "quuxb", "APR wins multi-key case 1"); |
| RUN_GET("quuxw", "quuxw", "APR wins multi-key case 2"); |
| RUN_GET("foonot", NULL, "APR wins missing-key case"); |
| } |
| |
| static void table_perf2(CuTest *tc) |
| { |
| RUN_GET("fool", "barl", "APR wins multi-key case 3"); |
| RUN_GET(APREQ_URL_ENCTYPE, "foo","APR wins triple-key case"); |
| RUN_GET(APREQ_MFD_ENCTYPE, "bar","APR wins single-key case"); |
| } |
| |
| static void table_cache(CuTest *tc) |
| { |
| apr_table_t *t2 = apreq_table_export(p,t1); |
| apr_time_t start, apr_delta, apreq_delta; |
| const char *val; |
| int i; |
| |
| start = apr_time_now(); |
| for (i = 0; i < LOOP; ++i) |
| val = apr_table_get(t2, "foo"); |
| apr_delta = apr_time_now() - start; |
| CuAssertStrEquals(tc, "bar", val); |
| start = apr_time_now(); |
| for (i = 0; i < LOOP; ++i) |
| val = apreq_table_get(t1, "foo"); |
| apreq_delta = apr_time_now() - start; |
| CuAssertStrEquals(tc, "bar", val); |
| |
| // CuAssertTrue(tc, apreq_delta > apr_delta); |
| |
| /* apr_tables should win (above), since foo is the first "f" item; |
| * but it should lose to apreq_tables when cacheing is enabled (below). |
| */ |
| CuAssertStrEquals(tc, "bar", apreq_table_cache(t1,"foo")); |
| start = apr_time_now(); |
| for (i = 0; i < LOOP; ++i) |
| val = apreq_table_get(t1, "foo"); |
| apreq_delta = apr_time_now() - start; |
| CuAssertStrEquals(tc, "bar", val); |
| |
| TEST_DELTAS("APR beats apreq's cache"); |
| } |
| |
| static void table_nelts(CuTest *tc) |
| { |
| const char *val; |
| apreq_table_t *t = apreq_table_make(p, 1); |
| |
| |
| apreq_table_set(t, V("abc", "def")); |
| apreq_table_set(t, V("def", "abc")); |
| apreq_table_set(t, V("foo", "zzz")); |
| val = apreq_table_get(t, "foo"); |
| CuAssertStrEquals(tc, val, "zzz"); |
| |
| val = apreq_table_get(t, "abc"); |
| CuAssertStrEquals(tc, val, "def"); |
| val = apreq_table_get(t, "def"); |
| CuAssertStrEquals(tc, val, "abc"); |
| CuAssertIntEquals(tc, 3, apreq_table_nelts(t)); |
| } |
| |
| static void table_clear(CuTest *tc) |
| { |
| apreq_table_clear(t1); |
| CuAssertIntEquals(tc, 0, apreq_table_nelts(t1)); |
| } |
| |
| static void table_overlap(CuTest *tc) |
| { |
| const char *val; |
| apreq_table_t *t2 = init_apreq(APREQ_NELTS); |
| apr_table_t *r1, *r2; |
| apr_status_t s; |
| apr_time_t start, apreq_delta, apr_delta; |
| t1 = apreq_table_make(p, APREQ_NELTS); |
| |
| r1 = apreq_table_export(p,t1); |
| r2 = apreq_table_export(p,t2); |
| |
| /* APR_OVERLAP_TABLES_SET had funky semantics, so we ignore it here */ |
| |
| start = apr_time_now(); |
| s = apreq_table_overlap(t1, t2, APR_OVERLAP_TABLES_MERGE); |
| apreq_delta = apr_time_now() - start; |
| CuAssertIntEquals(tc, APR_SUCCESS, s); |
| CuAssertIntEquals(tc, 12, apreq_table_nelts(t1)); |
| start = apr_time_now(); |
| apr_table_overlap(r1, r2, APR_OVERLAP_TABLES_MERGE); |
| apr_delta = apr_time_now() - start; |
| CuAssertIntEquals(tc, 12, apr_table_elts(r1)->nelts); |
| |
| if (apr_delta < apreq_delta) |
| CuFail(tc, apr_psprintf(p, "APR wins overlap contest #1: %" APR_INT64_T_FMT |
| " < %" APR_INT64_T_FMT " (microseconds)", apr_delta,apreq_delta)); |
| |
| t1 = apreq_table_make(p, 1); |
| t2 = apreq_table_make(p,1); |
| apreq_table_add(t1, V("a", "0")); |
| apreq_table_add(t1, V("g", "7")); |
| |
| apreq_table_add(t2, V("a", "1")); |
| apreq_table_add(t2, V("b", "2")); |
| apreq_table_add(t2, V("c", "3")); |
| apreq_table_add(t2, V("b", "2.0")); |
| apreq_table_add(t2, V("d", "4")); |
| apreq_table_add(t2, V("e", "5")); |
| apreq_table_add(t2, V("b", "2.")); |
| apreq_table_add(t2, V("f", "6")); |
| |
| r1 = apreq_table_export(p,t1); |
| r2 = apreq_table_export(p,t2); |
| |
| /* APR_OVERLAP_TABLES_SET had funky semantics, so we ignore it here */ |
| |
| val = apreq_table_get(t1, "a"); |
| CuAssertStrEquals(tc, "0",val); |
| |
| start = apr_time_now(); |
| s = apreq_table_overlap(t1, t2, APR_OVERLAP_TABLES_MERGE); |
| apreq_delta = apr_time_now() - start; |
| CuAssertIntEquals(tc, APR_SUCCESS, s); |
| CuAssertIntEquals(tc, 7, apreq_table_nelts(t1)); |
| start = apr_time_now(); |
| apr_table_overlap(r1, r2, APR_OVERLAP_TABLES_MERGE); |
| apr_delta = apr_time_now() - start; |
| CuAssertIntEquals(tc, 7, apr_table_elts(r1)->nelts); |
| |
| |
| if (apr_delta < apreq_delta) |
| CuFail(tc, apr_psprintf(p, "APR wins overlap contest #2: %" APR_INT64_T_FMT |
| " < %" APR_INT64_T_FMT " (microseconds)", apr_delta,apreq_delta)); |
| |
| |
| t2 = apreq_table_copy(p,t1); |
| |
| CuAssertIntEquals(tc, 3, apreq_table_ghosts(t2)); |
| CuAssertIntEquals(tc, 9, apreq_table_exorcise(t2)); |
| CuAssertIntEquals(tc, 0, apreq_table_ghosts(t2)); |
| CuAssertIntEquals(tc, 7, apreq_table_nelts(t2)); |
| |
| val = apreq_table_get(t2, "a"); |
| CuAssertStrEquals(tc, "0, 1",val); |
| val = apreq_table_get(t2, "b"); |
| CuAssertStrEquals(tc, "2, 2.0, 2.",val); |
| val = apreq_table_get(t2, "c"); |
| CuAssertStrEquals(tc, "3",val); |
| val = apreq_table_get(t2, "d"); |
| CuAssertStrEquals(tc, "4",val); |
| val = apreq_table_get(t2, "e"); |
| CuAssertStrEquals(tc, "5",val); |
| val = apreq_table_get(t2, "f"); |
| CuAssertStrEquals(tc, "6",val); |
| val = apreq_table_get(t2, "g"); |
| CuAssertStrEquals(tc, "7",val); |
| |
| } |
| |
| #define APREQ_ELT(a,i) (*(apreq_value_t **)((a)->elts + (i) * (a)->elt_size)) |
| |
| static void table_elts(CuTest *tc) |
| { |
| const char *val; |
| const apreq_value_t *v; |
| const apr_array_header_t *a; |
| |
| CuAssertIntEquals(tc, 7, apreq_table_nelts(t1)); |
| CuAssertIntEquals(tc, 3, apreq_table_ghosts(t1)); |
| |
| a = apreq_table_elts(t1); |
| |
| CuAssertIntEquals(tc, 7, apreq_table_nelts(t1)); |
| CuAssertIntEquals(tc, 0, apreq_table_ghosts(t1)); |
| |
| v = APREQ_ELT(a,0); |
| CuAssertStrEquals(tc,"0, 1", v->data); |
| v = APREQ_ELT(a,1); |
| CuAssertStrEquals(tc,"7", v->data); |
| v = APREQ_ELT(a,2); |
| CuAssertStrEquals(tc,"2, 2.0, 2.", v->data); |
| v = APREQ_ELT(a,3); |
| CuAssertStrEquals(tc,"3", v->data); |
| |
| v = APREQ_ELT(a,a->nelts-1); |
| CuAssertStrEquals(tc,"6", v->data); |
| v = APREQ_ELT(a,a->nelts-2); |
| CuAssertStrEquals(tc,"5", v->data); |
| v = APREQ_ELT(a,a->nelts-3); |
| CuAssertStrEquals(tc,"4", v->data); |
| |
| } |
| |
| static void table_overlay(CuTest *tc) |
| { |
| const char *val; |
| apreq_table_t *t2 = apreq_table_make(p, 1); |
| apr_status_t s; |
| |
| t1 = apreq_table_make(p, 1); |
| |
| apreq_table_add(t1, V("a", "0")); |
| apreq_table_add(t1, V("g", "7")); |
| |
| apreq_table_add(t2, V("a", "1")); |
| apreq_table_add(t2, V("b", "2")); |
| apreq_table_add(t2, V("c", "3")); |
| apreq_table_add(t2, V("b", "2.0")); |
| apreq_table_add(t2, V("d", "4")); |
| apreq_table_add(t2, V("e", "5")); |
| apreq_table_add(t2, V("b", "2.")); |
| apreq_table_add(t2, V("f", "6")); |
| t1 = apreq_table_overlay(p, t1, t2); |
| |
| CuAssertIntEquals(tc, 10, apreq_table_nelts(t1)); |
| |
| val = apreq_table_get(t1, "a"); |
| CuAssertStrEquals(tc, "0",val); |
| val = apreq_table_get(t1, "b"); |
| CuAssertStrEquals(tc, "2",val); |
| val = apreq_table_get(t1, "c"); |
| CuAssertStrEquals(tc, "3",val); |
| val = apreq_table_get(t1, "d"); |
| CuAssertStrEquals(tc, "4",val); |
| val = apreq_table_get(t1, "e"); |
| CuAssertStrEquals(tc, "5",val); |
| val = apreq_table_get(t1, "f"); |
| CuAssertStrEquals(tc, "6",val); |
| val = apreq_table_get(t1, "g"); |
| CuAssertStrEquals(tc, "7",val); |
| } |
| |
| static void table_keys(CuTest *tc) |
| { |
| const char *k; |
| apr_array_header_t *a = apr_array_make(p,1, sizeof k); |
| apr_status_t s = apreq_table_keys(t1,a); |
| |
| CuAssertIntEquals(tc, APR_SUCCESS, s); |
| CuAssertIntEquals(tc, 7, a->nelts); |
| k = ((const char **)a->elts)[0]; |
| CuAssertStrEquals(tc, "a", k); |
| k = ((const char **)a->elts)[1]; |
| CuAssertStrEquals(tc, "g", k); |
| k = ((const char **)a->elts)[2]; |
| CuAssertStrEquals(tc, "b", k); |
| k = ((const char **)a->elts)[3]; |
| CuAssertStrEquals(tc, "c", k); |
| k = ((const char **)a->elts)[4]; |
| CuAssertStrEquals(tc, "d", k); |
| k = ((const char **)a->elts)[5]; |
| CuAssertStrEquals(tc, "e", k); |
| k = ((const char **)a->elts)[6]; |
| CuAssertStrEquals(tc, "f", k); |
| } |
| |
| static void table_values(CuTest *tc) |
| { |
| const apreq_value_t *v; |
| apr_array_header_t *a = apr_array_make(p,1,sizeof v); |
| apr_status_t s = apreq_table_values(t1,"a",a); |
| CuAssertIntEquals(tc, APR_SUCCESS, s); |
| CuAssertIntEquals(tc, 2, a->nelts); |
| v = ((const apreq_value_t **)a->elts)[0]; |
| CuAssertStrEquals(tc, "a", v->name); |
| CuAssertStrEquals(tc, "0", v->data); |
| v = ((const apreq_value_t **)a->elts)[1]; |
| CuAssertStrEquals(tc, "a", v->name); |
| CuAssertStrEquals(tc, "1", v->data); |
| a->nelts = 0; |
| s = apreq_table_values(t1,"b",a); |
| CuAssertIntEquals(tc, APR_SUCCESS, s); |
| CuAssertIntEquals(tc, 3, a->nelts); |
| v = ((const apreq_value_t **)a->elts)[0]; |
| CuAssertStrEquals(tc, "b", v->name); |
| CuAssertStrEquals(tc, "2", v->data); |
| v = ((const apreq_value_t **)a->elts)[1]; |
| CuAssertStrEquals(tc, "b", v->name); |
| CuAssertStrEquals(tc, "2.0", v->data); |
| v = ((const apreq_value_t **)a->elts)[2]; |
| CuAssertStrEquals(tc, "b", v->name); |
| CuAssertStrEquals(tc, "2.", v->data); |
| |
| a->nelts = 0; |
| s = apreq_table_values(t1,NULL,a); |
| CuAssertIntEquals(tc, APR_SUCCESS, s); |
| CuAssertIntEquals(tc, 7, a->nelts); |
| |
| } |
| #endif |
| |
| CuSuite *testperformance(void) |
| { |
| CuSuite *suite = CuSuiteNew("Performance"); |
| |
| SUITE_ADD_TEST(suite, perf_init); |
| SUITE_ADD_TEST(suite, perf_get_avg); |
| SUITE_ADD_TEST(suite, perf_get); |
| /* |
| SUITE_ADD_TEST(suite, table_set); |
| SUITE_ADD_TEST(suite, table_getnotthere); |
| SUITE_ADD_TEST(suite, table_add); |
| SUITE_ADD_TEST(suite, table_unset); |
| SUITE_ADD_TEST(suite, table_perf); |
| SUITE_ADD_TEST(suite, table_perf2); |
| SUITE_ADD_TEST(suite, table_cache); |
| SUITE_ADD_TEST(suite, table_nelts); |
| SUITE_ADD_TEST(suite, table_clear); |
| SUITE_ADD_TEST(suite, table_overlap); |
| SUITE_ADD_TEST(suite, table_elts); |
| SUITE_ADD_TEST(suite, table_overlay); |
| SUITE_ADD_TEST(suite, table_keys); |
| SUITE_ADD_TEST(suite, table_values); |
| */ |
| return suite; |
| } |
| |
