Livox-SDK
349 lines
11 KiB
C
349 lines
11 KiB
C
/* 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;
|
|
}
|