summaryrefslogtreecommitdiffstats
path: root/test/internal
diff options
context:
space:
mode:
Diffstat (limited to 'test/internal')
-rw-r--r--test/internal/Makefile.in37
-rw-r--r--test/internal/Makefile.win109
-rw-r--r--test/internal/testregex.c91
-rw-r--r--test/internal/testucs.c348
4 files changed, 585 insertions, 0 deletions
diff --git a/test/internal/Makefile.in b/test/internal/Makefile.in
new file mode 100644
index 0000000..b1f6c6a
--- /dev/null
+++ b/test/internal/Makefile.in
@@ -0,0 +1,37 @@
+srcdir = @srcdir@
+VPATH = @srcdir@
+
+NONPORTABLE = \
+ testregex@EXEEXT@
+
+PROGRAMS = \
+
+TARGETS = $(PROGRAMS) $(NONPORTABLE)
+
+# bring in rules.mk for standard functionality
+@INCLUDE_RULES@
+
+LOCAL_LIBS=../../lib@APR_LIBNAME@.la
+
+CLEAN_TARGETS = testregex@EXEEXT@
+
+INCDIR=../../include
+INCLUDES=-I$(INCDIR)
+
+CFLAGS=$(MY_CFLAGS)
+
+all: $(PROGRAMS) $(NONPORTABLE)
+
+check: $(PROGRAMS) $(NONPORTABLE)
+ for prog in $(PROGRAMS) $(NONPORTABLE); do \
+ ./$$prog; \
+ if test $$i = 255; then \
+ echo "$$prog failed"; \
+ break; \
+ fi \
+ done
+
+testregex@EXEEXT@: testregex.lo $(LOCAL_LIBS)
+ $(LINK) testregex.lo $(LOCAL_LIBS) $(ALL_LIBS)
+
+# DO NOT REMOVE
diff --git a/test/internal/Makefile.win b/test/internal/Makefile.win
new file mode 100644
index 0000000..a881f07
--- /dev/null
+++ b/test/internal/Makefile.win
@@ -0,0 +1,109 @@
+# PROGRAMS includes all test programs built on this platform.
+# STDTEST_PORTABLE
+# test programs invoked via standard user interface, run on all platforms
+# STDTEST_NONPORTABLE
+# test programs invoked via standard user interface, not portable
+# OTHER_PROGRAMS
+# programs such as sendfile, that have to be invoked in a special sequence
+# or with special parameters
+
+!IFNDEF MODEL
+MODEL=dynamic
+!ENDIF
+
+INCDIR=../../include
+
+!IFNDEF OUTDIR
+!IF "$(MODEL)" == "static"
+OUTDIR=LibR
+!ELSE
+OUTDIR=Release
+!ENDIF
+
+!IF [$(COMSPEC) /c cl /nologo /? | find "x64" >NUL ] == 0
+OUTDIR=x64\$(OUTDIR)
+!ENDIF
+!ENDIF
+
+!IF !EXIST("$(OUTDIR)\.")
+!IF ([$(COMSPEC) /C mkdir $(OUTDIR)] == 0)
+!ENDIF
+!ENDIF
+
+!IFNDEF INTDIR
+INTDIR=$(OUTDIR)
+!ELSE
+!IF !EXIST("$(INTDIR)\.")
+!IF ([$(COMSPEC) /C mkdir $(INTDIR)] == 0)
+!ENDIF
+!ENDIF
+!ENDIF
+
+!MESSAGE Building tests into $(OUTDIR) for $(MODEL)
+
+NONPORTABLE = \
+ $(OUTDIR)\testucs.exe
+
+CLEAN_BUILDDIRS = Release Debug 9x x64
+
+PROGRAMS =
+
+TARGETS = $(PROGRAMS) $(NONPORTABLE)
+
+# bring in rules.mk for standard functionality
+ALL: $(TARGETS)
+
+CL = cl.exe
+LD = link.exe
+
+!IF "$(MODEL)" == "static"
+LOCAL_LIB= ..\..\$(OUTDIR)\apr-1.lib
+STATIC_CFLAGS = /D APR_DECLARE_STATIC
+!ELSE
+LOCAL_LIB= ..\..\$(OUTDIR)\libapr-1.lib
+STATIC_CFLAGS =
+!ENDIF
+
+!IFDEF _DEBUG
+DEBUG_CFLAGS = /MDd
+!ELSE
+DEBUG_CFLAGS = /MD
+!ENDIF
+
+INCLUDES=/I "$(INCDIR)"
+
+CFLAGS = /nologo /c /W3 /Gm /EHsc /Zi /Od $(INCLUDES) \
+ $(STATIC_CFLAGS) $(DEBUG_CFLAGS) /D "BINPATH=$(OUTDIR:\=/)" \
+ /D _DEBUG /D WIN32 /Fo"$(INTDIR)/" /FD
+
+LD_LIBS = kernel32.lib advapi32.lib ws2_32.lib wsock32.lib \
+ ole32.lib shell32.lib rpcrt4.lib
+
+LDFLAGS = /nologo /debug /subsystem:console /incremental:no
+SHLDFLAGS = /nologo /dll /debug /subsystem:windows /incremental:no
+
+.c{$(INTDIR)}.obj:
+ $(CL) $(CFLAGS) -c $< -Fd$(INTDIR)\ $(INCLUDES)
+
+$(OUTDIR)\testucs.exe: $(INTDIR)\testucs.obj $(LOCAL_LIB)
+ $(LD) $(LDFLAGS) /out:"$@" $** $(LD_LIBS)
+ @if exist "$@.manifest" \
+ mt.exe -manifest "$@.manifest" -outputresource:$@;1
+
+
+clean:
+ @if EXIST $(INTDIR)\. rmdir /s /q $(INTDIR)
+ @if EXIST $(OUTDIR)\. rmdir /s /q $(OUTDIR)
+
+cleanall:
+ @for %d in ($(CLEAN_BUILDDIRS)) do @if EXIST %d\. rmdir /s /q %d
+
+
+PATH=$(OUTDIR);..\..\$(OUTDIR);$(PATH)
+
+check: $(NONPORTABLE)
+ @for %p in ($(NONPORTABLE)) do @( \
+ echo Testing %p && %p || echo %p failed \
+ )
+
+# DO NOT REMOVE
diff --git a/test/internal/testregex.c b/test/internal/testregex.c
new file mode 100644
index 0000000..20dcfde
--- /dev/null
+++ b/test/internal/testregex.c
@@ -0,0 +1,91 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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_strings.h"
+#include "apr_pools.h"
+#include "apr_general.h"
+#include "apr_hash.h"
+#include "apr_lib.h"
+#include "apr_time.h"
+#include <regex.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main( int argc, char** argv) {
+ apr_pool_t *context;
+ regex_t regex;
+ int rc;
+ int i;
+ int iters;
+ apr_time_t now;
+ apr_time_t end;
+ apr_hash_t *h;
+
+
+ if (argc !=4 ) {
+ fprintf(stderr, "Usage %s match string #iterations\n",argv[0]);
+ return -1;
+ }
+ iters = atoi( argv[3]);
+
+ apr_initialize() ;
+ atexit(apr_terminate);
+ if (apr_pool_create(&context, NULL) != APR_SUCCESS) {
+ fprintf(stderr, "Something went wrong\n");
+ exit(-1);
+ }
+ rc = regcomp( &regex, argv[1], REG_EXTENDED|REG_NOSUB);
+
+
+ if (rc) {
+ char errbuf[2000];
+ regerror(rc, &regex,errbuf,2000);
+ fprintf(stderr,"Couldn't compile regex ;(\n%s\n ",errbuf);
+ return -1;
+ }
+ if ( regexec( &regex, argv[2], 0, NULL,0) == 0 ) {
+ fprintf(stderr,"Match\n");
+ }
+ else {
+ fprintf(stderr,"No Match\n");
+ }
+ now = apr_time_now();
+ for (i=0;i<iters;i++) {
+ regexec( &regex, argv[2], 0, NULL,0) ;
+ }
+ end=apr_time_now();
+ puts(apr_psprintf( context, "Time to run %d regex's %8lld\n",iters,end-now));
+ h = apr_hash_make( context);
+ for (i=0;i<70;i++) {
+ apr_hash_set(h,apr_psprintf(context, "%dkey",i),APR_HASH_KEY_STRING,"1");
+ }
+ now = apr_time_now();
+ for (i=0;i<iters;i++) {
+ apr_hash_get( h, argv[2], APR_HASH_KEY_STRING);
+ }
+ end=apr_time_now();
+ puts(apr_psprintf( context, "Time to run %d hash (no find)'s %8lld\n",iters,end-now));
+ apr_hash_set(h, argv[2],APR_HASH_KEY_STRING,"1");
+ now = apr_time_now();
+ for (i=0;i<iters;i++) {
+ apr_hash_get( h, argv[2], APR_HASH_KEY_STRING);
+ }
+ end=apr_time_now();
+ puts(apr_psprintf( context, "Time to run %d hash (find)'s %8lld\n",iters,end-now));
+
+ return 0;
+}
diff --git a/test/internal/testucs.c b/test/internal/testucs.c
new file mode 100644
index 0000000..bf8874e
--- /dev/null
+++ b/test/internal/testucs.c
@@ -0,0 +1,348 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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.h"
+#include "arch/win32/apr_arch_utf8.h"
+#include <wchar.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+struct testval {
+ unsigned char n[8];
+ apr_size_t nl;
+ wchar_t w[4];
+ apr_size_t wl;
+};
+
+#ifdef FOR_REFERENCE
+/* For reference; a table of invalid utf-8 encoded ucs-2/ucs-4 sequences.
+ * The table consists of start, end pairs for all invalid ranges.
+ * NO_UCS2_PAIRS will pass the reservered D800-DFFF values, halting at FFFF
+ * FULL_UCS4_MAPPER represents all 31 bit values to 7FFF FFFF
+ *
+ * We already tested these, because we ensure there is a 1:1 mapping across
+ * the entire range of byte values in each position of 1 to 6 byte sequences.
+ */
+struct testval malformed[] = [
+ [[0x80,], 1,], /* 10000000 64 invalid leading continuation values */
+ [[0xBF,], 1,], /* 10111111 64 invalid leading continuation values */
+ [[0xC0,0x80], 2,], /* overshort mapping of 0000 */
+ [[0xC1,0xBF], 2,], /* overshort mapping of 007F */
+ [[0xE0,0x80,0x80,], 3,], /* overshort mapping of 0000 */
+ [[0xE0,0x9F,0xBF,], 3,], /* overshort mapping of 07FF */
+#ifndef NO_UCS2_PAIRS
+ [[0xED,0xA0,0x80,], 3,], /* unexpected mapping of UCS-2 literal D800 */
+ [[0xED,0xBF,0xBF,], 3,], /* unexpected mapping of UCS-2 literal DFFF */
+#endif
+ [[0xF0,0x80,0x80,0x80,], 4,], /* overshort mapping of 0000 */
+ [[0xF0,0x8F,0xBF,0xBF,], 4,], /* overshort mapping of FFFF */
+#ifdef NO_UCS2_PAIRS
+ [[0xF0,0x90,0x80,0x80,], 4,], /* invalid too large value 0001 0000 */
+ [[0xF4,0x8F,0xBF,0xBF,], 4,], /* invalid too large value 0010 FFFF */
+#endif
+#ifndef FULL_UCS4_MAPPER
+ [[0xF4,0x90,0x80,0x80,], 4,], /* invalid too large value 0011 0000 */
+ [[0xF7,0xBF,0xBF,0xBF,], 4,], /* invalid too large value 001F FFFF */
+#endif
+ [[0xF8,0x80,0x80,0x80,0x80,], 5,], /* overshort mapping of 0000 0000 */
+ [[0xF8,0x87,0xBF,0xBF,0xBF,], 5,], /* overshort mapping of 001F FFFF */
+#ifndef FULL_UCS4_MAPPER
+ [[0xF8,0x88,0x80,0x80,0x80,], 5,], /* invalid too large value 0020 0000 */
+ [[0xFB,0xBF,0xBF,0xBF,0xBF,], 5,], /* invalid too large value 03FF FFFF */
+#endif
+ [[0xFC,0x80,0x80,0x80,0x80,0x80,], 6,], /* overshort mapping 0000 0000 */
+ [[0xFC,0x83,0xBF,0xBF,0xBF,0xBF,], 6,], /* overshort mapping 03FF FFFF */
+#ifndef FULL_UCS4_MAPPER
+ [[0xFC,0x84,0x80,0x80,0x80,0x80,], 6,], /* overshort mapping 0400 0000 */
+ [[0xFD,0xBF,0xBF,0xBF,0xBF,0xBF,], 6,], /* overshort mapping 7FFF FFFF */
+#endif
+ [[0xFE,], 1,], /* 11111110 invalid "too large" value, no 7 byte seq */
+ [[0xFF,], 1,], /* 11111111 invalid "too large" value, no 8 byte seq */
+];
+#endif /* FOR_REFERENCE */
+
+void displaynw(struct testval *f, struct testval *l)
+{
+ char x[80], *t = x;
+ int i;
+ for (i = 0; i < f->nl; ++i)
+ t += sprintf(t, "%02X ", f->n[i]);
+ *(t++) = '-';
+ for (i = 0; i < l->nl; ++i)
+ t += sprintf(t, " %02X", l->n[i]);
+ *(t++) = ' ';
+ *(t++) = '=';
+ *(t++) = ' ';
+ for (i = 0; i < f->wl; ++i)
+ t += sprintf(t, "%04X ", f->w[i]);
+ *(t++) = '-';
+ for (i = 0; i < l->wl; ++i)
+ t += sprintf(t, " %04X", l->w[i]);
+ *t = '\0';
+ puts(x);
+}
+
+/*
+ * Test every possible byte value.
+ * If the test passes or fails at this byte value we are done.
+ * Otherwise iterate test_nrange again, appending another byte.
+ */
+void test_nrange(struct testval *p)
+{
+ struct testval f, l, s;
+ apr_status_t rc;
+ int success = 0;
+
+ memcpy (&s, p, sizeof(s));
+ ++s.nl;
+
+ do {
+ apr_size_t nl = s.nl, wl = sizeof(s.w) / 2;
+ rc = apr_conv_utf8_to_ucs2(s.n, &nl, s.w, &wl);
+ s.wl = (sizeof(s.w) / 2) - wl;
+ if (!nl && rc == APR_SUCCESS) {
+ if (!success) {
+ memcpy(&f, &s, sizeof(s));
+ success = -1;
+ }
+ else {
+ if (s.wl != l.wl
+ || memcmp(s.w, l.w, (s.wl - 1) * 2) != 0
+ || s.w[s.wl - 1] != l.w[l.wl - 1] + 1) {
+ displaynw(&f, &l);
+ memcpy(&f, &s, sizeof(s));
+ }
+ }
+ memcpy(&l, &s, sizeof(s));
+ }
+ else {
+ if (success) {
+ displaynw(&f, &l);
+ success = 0;
+ }
+ if (rc == APR_INCOMPLETE) {
+ test_nrange(&s);
+ }
+ }
+ } while (++s.n[s.nl - 1]);
+
+ if (success) {
+ displaynw(&f, &l);
+ success = 0;
+ }
+}
+
+/*
+ * Test every possible word value.
+ * Once we are finished, retest every possible word value.
+ * if the test fails on the following null word, iterate test_nrange
+ * again, appending another word.
+ * This assures the output order of the two tests are in sync.
+ */
+void test_wrange(struct testval *p)
+{
+ struct testval f, l, s;
+ apr_status_t rc;
+ int success = 0;
+
+ memcpy (&s, p, sizeof(s));
+ ++s.wl;
+
+ do {
+ apr_size_t nl = sizeof(s.n), wl = s.wl;
+ rc = apr_conv_ucs2_to_utf8(s.w, &wl, s.n, &nl);
+ s.nl = sizeof(s.n) - nl;
+ if (!wl && rc == APR_SUCCESS) {
+ if (!success) {
+ memcpy(&f, &s, sizeof(s));
+ success = -1;
+ }
+ else {
+ if (s.nl != l.nl
+ || memcmp(s.n, l.n, s.nl - 1) != 0
+ || s.n[s.nl - 1] != l.n[l.nl - 1] + 1) {
+ displaynw(&f, &l);
+ memcpy(&f, &s, sizeof(s));
+ }
+ }
+ memcpy(&l, &s, sizeof(s));
+ }
+ else {
+ if (success) {
+ displaynw(&f, &l);
+ success = 0;
+ }
+ }
+ } while (++s.w[s.wl - 1]);
+
+ if (success) {
+ displaynw(&f, &l);
+ success = 0;
+ }
+
+ do {
+ apr_size_t wl = s.wl, nl = sizeof(s.n);
+ rc = apr_conv_ucs2_to_utf8(s.w, &wl, s.n, &nl);
+ s.nl = sizeof(s.n) - s.nl;
+ if (rc == APR_INCOMPLETE) {
+ test_wrange(&s);
+ }
+ } while (++s.w[s.wl - 1]);
+}
+
+/*
+ * Test every possible byte value.
+ * If the test passes or fails at this byte value we are done.
+ * Otherwise iterate test_nrange again, appending another byte.
+ */
+void test_ranges()
+{
+ struct testval ntest, wtest;
+ apr_status_t nrc, wrc;
+ apr_size_t inlen;
+ unsigned long matches = 0;
+
+ memset(&ntest, 0, sizeof(ntest));
+ ++ntest.nl;
+
+ memset(&wtest, 0, sizeof(wtest));
+ ++wtest.wl;
+
+ do {
+ do {
+ inlen = ntest.nl;
+ ntest.wl = sizeof(ntest.w) / 2;
+ nrc = apr_conv_utf8_to_ucs2(ntest.n, &inlen, ntest.w, &ntest.wl);
+ if (nrc == APR_SUCCESS) {
+ ntest.wl = (sizeof(ntest.w) / 2) - ntest.wl;
+ break;
+ }
+ if (nrc == APR_INCOMPLETE) {
+ ++ntest.nl;
+ if (ntest.nl > 6) {
+ printf ("\n\nUnexpected utf8 sequence of >6 bytes;\n");
+ exit(255);
+ }
+ continue;
+ }
+ else {
+ while (!(++ntest.n[ntest.nl - 1])) {
+ if (!(--ntest.nl))
+ break;
+ }
+ }
+ } while (ntest.nl);
+
+ do {
+ inlen = wtest.wl;
+ wtest.nl = sizeof(wtest.n);
+ wrc = apr_conv_ucs2_to_utf8(wtest.w, &inlen, wtest.n, &wtest.nl);
+ if (wrc == APR_SUCCESS) {
+ wtest.nl = sizeof(wtest.n) - wtest.nl;
+ break;
+ }
+ else {
+ if (!(++wtest.w[wtest.wl - 1])) {
+ if (wtest.wl == 1)
+ ++wtest.wl;
+ else
+ ++wtest.w[0];
+
+ /* On the second pass, ensure lead word is incomplete */
+ do {
+ inlen = 1;
+ wtest.nl = sizeof(wtest.n);
+ if (apr_conv_ucs2_to_utf8(wtest.w, &inlen, wtest.n, &wtest.nl)
+ == APR_INCOMPLETE)
+ break;
+ if (!(++wtest.w[0])) {
+ wtest.wl = 0;
+ break;
+ }
+ } while (1);
+ }
+ }
+ } while (wtest.wl);
+
+ if (!ntest.nl && !wtest.wl)
+ break;
+
+ /* Identical? */
+ if ((wtest.nl != ntest.nl)
+ || (memcmp(wtest.n, ntest.n, ntest.nl) != 0)
+ || (wtest.wl != ntest.wl)
+ || (memcmp(ntest.w, wtest.w, wtest.wl * 2) != 0)) {
+ printf ("\n\nMismatch of w/n conversion at;\n");
+ displaynw(&ntest, &wtest);
+ exit(255);
+ }
+ ++matches;
+
+ while (!(++ntest.n[ntest.nl - 1])) {
+ if (!(--ntest.nl))
+ break;
+ }
+
+ if (!(++wtest.w[wtest.wl - 1])) {
+ if (wtest.wl == 1)
+ ++wtest.wl;
+ else
+ ++wtest.w[0];
+
+ /* On the second pass, ensure lead word is incomplete */
+ do {
+ inlen = 1;
+ wtest.nl = sizeof(wtest.n);
+ if (apr_conv_ucs2_to_utf8(wtest.w, &inlen, wtest.n, &wtest.nl)
+ == APR_INCOMPLETE)
+ break;
+ if (!(++wtest.w[0])) {
+ wtest.wl = 0;
+ break;
+ }
+ } while (1);
+ }
+ } while (wtest.wl || ntest.nl);
+
+ printf ("\n\nutf8 and ucs2 sequences of %lu transformations matched OK.\n",
+ matches);
+}
+
+/*
+ * Syntax: testucs [w|n]
+ *
+ * If no arg or arg is not recognized, run equality sequence test.
+ */
+int main(int argc, char **argv)
+{
+ struct testval s;
+ memset (&s, 0, sizeof(s));
+
+ if (argc >= 2 && apr_tolower(*argv[1]) != 'w') {
+ printf ("\n\nTesting Narrow Char Ranges\n");
+ test_nrange(&s);
+ }
+ else if (argc >= 2 && apr_tolower(*argv[1]) != 'n') {
+ printf ("\n\nTesting Wide Char Ranges\n");
+ test_wrange(&s);
+ }
+ else {
+ test_ranges();
+ }
+ return 0;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-16 03:45:39 +0000