mirror of
https://github.com/rn10950/RetroZilla.git
synced 2024-11-16 20:40:11 +01:00
480 lines
16 KiB
C
480 lines
16 KiB
C
|
/* ***** BEGIN LICENSE BLOCK *****
|
||
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
||
|
|
*
|
||
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
||
|
|
* 1.1 (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.mozilla.org/MPL/
|
||
|
|
*
|
||
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
||
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
||
|
|
* for the specific language governing rights and limitations under the
|
||
|
|
* License.
|
||
|
|
*
|
||
|
|
* The Original Code is the PKIX-C library.
|
||
|
|
*
|
||
|
|
* The Initial Developer of the Original Code is
|
||
|
|
* Sun Microsystems, Inc.
|
||
|
|
* Portions created by the Initial Developer are
|
||
|
|
* Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
|
||
|
|
*
|
||
|
|
* Contributor(s):
|
||
|
|
* Sun Microsystems, Inc.
|
||
|
|
*
|
||
|
|
* Alternatively, the contents of this file may be used under the terms of
|
||
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
||
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
||
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
||
|
|
* of those above. If you wish to allow use of your version of this file only
|
||
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
||
|
|
* use your version of this file under the terms of the MPL, indicate your
|
||
|
|
* decision by deleting the provisions above and replace them with the notice
|
||
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
||
|
|
* the provisions above, a recipient may use your version of this file under
|
||
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
||
|
|
*
|
||
|
|
* ***** END LICENSE BLOCK ***** */
|
||
|
|
/*
|
||
|
|
* test_string.c
|
||
|
|
*
|
||
|
|
* Tests Strings.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "testutil.h"
|
||
|
|
#include "testutil_nss.h"
|
||
|
|
|
||
|
|
static void *plContext = NULL;
|
||
|
|
|
||
|
|
static void
|
||
|
|
createString(
|
||
|
|
PKIX_PL_String **testString,
|
||
|
|
PKIX_UInt32 format,
|
||
|
|
char *stringAscii,
|
||
|
|
PKIX_UInt32 length)
|
||
|
|
{
|
||
|
|
PKIX_TEST_STD_VARS();
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR
|
||
|
|
(PKIX_PL_String_Create
|
||
|
|
(format, stringAscii, length, testString, plContext));
|
||
|
|
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
PKIX_TEST_RETURN();
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
createStringOther(
|
||
|
|
PKIX_PL_String **testEscAscii,
|
||
|
|
PKIX_PL_String **testUtf16,
|
||
|
|
PKIX_PL_String **ampString,
|
||
|
|
PKIX_PL_String **testDebugAscii,
|
||
|
|
PKIX_PL_String **testNullString,
|
||
|
|
PKIX_UInt32 *utf16data)
|
||
|
|
{
|
||
|
|
char *nullText = "Hi� there!";
|
||
|
|
|
||
|
|
char *escAsciiString =
|
||
|
|
"¡𐀀࿿􀀁";
|
||
|
|
|
||
|
|
char *debugAsciiString =
|
||
|
|
"string with
newlines and	tabs";
|
||
|
|
|
||
|
|
char * utfAmp = "\x00&";
|
||
|
|
|
||
|
|
PKIX_TEST_STD_VARS();
|
||
|
|
|
||
|
|
createString(testEscAscii,
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
escAsciiString,
|
||
|
|
PL_strlen(escAsciiString));
|
||
|
|
|
||
|
|
createString(testUtf16, PKIX_UTF16, (char *)utf16data, 12);
|
||
|
|
|
||
|
|
createString(ampString, PKIX_UTF16, utfAmp, 2);
|
||
|
|
|
||
|
|
createString(testDebugAscii,
|
||
|
|
PKIX_ESCASCII_DEBUG,
|
||
|
|
debugAsciiString,
|
||
|
|
PL_strlen(debugAsciiString));
|
||
|
|
|
||
|
|
createString(testNullString,
|
||
|
|
PKIX_ESCASCII_DEBUG,
|
||
|
|
nullText,
|
||
|
|
PL_strlen(nullText));
|
||
|
|
|
||
|
|
goto cleanup;
|
||
|
|
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
PKIX_TEST_RETURN();
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
testGetEncoded(
|
||
|
|
PKIX_PL_String *testEscAscii,
|
||
|
|
PKIX_PL_String *testString0,
|
||
|
|
PKIX_PL_String *testDebugAscii,
|
||
|
|
PKIX_PL_String *testNullString,
|
||
|
|
PKIX_UInt32 *utf16data)
|
||
|
|
{
|
||
|
|
char *temp = NULL;
|
||
|
|
void *dest = NULL;
|
||
|
|
void *dest2 = NULL;
|
||
|
|
char *plainText = "string with\nnewlines and\ttabs";
|
||
|
|
PKIX_UInt32 length, length2, i;
|
||
|
|
|
||
|
|
PKIX_TEST_STD_VARS();
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_GetEncoded(testEscAscii,
|
||
|
|
PKIX_UTF16,
|
||
|
|
&dest,
|
||
|
|
&length,
|
||
|
|
plContext));
|
||
|
|
for (i = 0; i < length; i++) {
|
||
|
|
if (((char*)dest)[i] != ((char*)utf16data)[i]) {
|
||
|
|
testError("UTF-16 Data Differs from Source");
|
||
|
|
printf("%d-th char is different -%c-%c-\n", i,
|
||
|
|
((char*)dest)[i], ((char*)utf16data)[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
length = 0;
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(dest, plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_GetEncoded(testNullString,
|
||
|
|
PKIX_UTF16,
|
||
|
|
&dest,
|
||
|
|
&length,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
length = 0;
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(dest, plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_GetEncoded(testString0,
|
||
|
|
PKIX_ESCASCII_DEBUG,
|
||
|
|
&dest,
|
||
|
|
&length,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_GetEncoded(testDebugAscii,
|
||
|
|
PKIX_ESCASCII_DEBUG,
|
||
|
|
&dest2,
|
||
|
|
&length2,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
for (i = 0; (i < length) && (i < length2); i++)
|
||
|
|
if (((char*)dest)[i] != ((char*)dest2)[i]) {
|
||
|
|
testError("Equivalent strings are unequal");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
length = 0;
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(dest, plContext));
|
||
|
|
length2 = 0;
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(dest2, plContext));
|
||
|
|
|
||
|
|
temp = PKIX_String2ASCII(testDebugAscii, plContext);
|
||
|
|
if (temp){
|
||
|
|
if (PL_strcmp(plainText, temp) != 0)
|
||
|
|
testError("Debugged ASCII does not match "
|
||
|
|
"equivalent EscAscii");
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext));
|
||
|
|
}
|
||
|
|
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
PKIX_TEST_RETURN();
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
testSprintf(void)
|
||
|
|
{
|
||
|
|
PKIX_Int32 x = 0xCAFE;
|
||
|
|
PKIX_Int32 y = -12345;
|
||
|
|
PKIX_PL_String *testString = NULL;
|
||
|
|
PKIX_PL_String *formatString = NULL;
|
||
|
|
PKIX_PL_String *sprintfString = NULL;
|
||
|
|
char *plainText = "Testing Sprintf";
|
||
|
|
char *format = "%s %x %u %d";
|
||
|
|
char *convertedFormat = "%s %lx %lu %ld";
|
||
|
|
char *temp = NULL;
|
||
|
|
char *temp2 = NULL;
|
||
|
|
|
||
|
|
PKIX_TEST_STD_VARS();
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
plainText,
|
||
|
|
PL_strlen(plainText),
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
format,
|
||
|
|
11,
|
||
|
|
&formatString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Sprintf(&sprintfString,
|
||
|
|
plContext,
|
||
|
|
formatString,
|
||
|
|
testString, x, y, y));
|
||
|
|
PKIX_TEST_DECREF_BC(testString);
|
||
|
|
|
||
|
|
temp = PR_smprintf(convertedFormat, plainText, x, y, y);
|
||
|
|
temp2 = PKIX_String2ASCII(sprintfString, plContext);
|
||
|
|
|
||
|
|
if (PL_strcmp(temp, temp2) != 0)
|
||
|
|
testError("Sprintf produced incorrect output");
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp, plContext));
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(PKIX_PL_Free(temp2, plContext));
|
||
|
|
|
||
|
|
|
||
|
|
PKIX_TEST_DECREF_BC(sprintfString);
|
||
|
|
|
||
|
|
|
||
|
|
PKIX_TEST_DECREF_BC(formatString);
|
||
|
|
|
||
|
|
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
PKIX_TEST_RETURN();
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
testErrorHandling(void)
|
||
|
|
{
|
||
|
|
char *debugAsciiString =
|
||
|
|
"string with
newlines and	tabs";
|
||
|
|
|
||
|
|
PKIX_PL_String *testString = NULL;
|
||
|
|
|
||
|
|
PKIX_TEST_STD_VARS();
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
NULL,
|
||
|
|
50,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(PKIX_ESCASCII,
|
||
|
|
"blah", 4, NULL, plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_Sprintf(&testString, plContext, NULL));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_ERROR
|
||
|
|
(PKIX_PL_GetString(0, NULL, &testString, plContext));
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_GetString(0, "blah", 0, plContext));
|
||
|
|
|
||
|
|
/* ---------------------------- */
|
||
|
|
subTest("Unicode Error Handling");
|
||
|
|
|
||
|
|
/* &#x must be followed by 4 hexadecimal digits */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"k;",
|
||
|
|
7,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* &#x must be followed by 4 hexadecimal digits */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"abc�",
|
||
|
|
8,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* &#x must be between 00010000-0010FFFF */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"�",
|
||
|
|
11,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* &#x must be followed by 8 hexadecimal digits */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"က",
|
||
|
|
10,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* &#x must be followed by 8 hexadecimal digits */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"m00;",
|
||
|
|
10,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* Byte values D800-DFFF are reserved */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"�",
|
||
|
|
7,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* Can't use &#x for regular characters */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"2",
|
||
|
|
7,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* Can't use non-printable characters */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"\xA1",
|
||
|
|
1,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* Only legal \\ characters are \\, u and U */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
"&blah",
|
||
|
|
5,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/* Surrogate pairs must be legal */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_UTF16,
|
||
|
|
"\xd8\x00\x0\x66",
|
||
|
|
4,
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
|
||
|
|
/* Debugged EscASCII should not be accepted as EscASCII */
|
||
|
|
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
debugAsciiString,
|
||
|
|
PL_strlen(debugAsciiString),
|
||
|
|
&testString,
|
||
|
|
plContext));
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
PKIX_TEST_RETURN();
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
testDestroy(
|
||
|
|
PKIX_PL_String *string)
|
||
|
|
{
|
||
|
|
PKIX_TEST_STD_VARS();
|
||
|
|
|
||
|
|
PKIX_TEST_DECREF_BC(string);
|
||
|
|
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
PKIX_TEST_RETURN();
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
int test_string(int argc, char *argv[]) {
|
||
|
|
|
||
|
|
PKIX_PL_String *testString[6] = {NULL};
|
||
|
|
PKIX_PL_String *testNullString = NULL;
|
||
|
|
PKIX_PL_String *testDebugAscii = NULL;
|
||
|
|
PKIX_PL_String *testEscAscii = NULL;
|
||
|
|
PKIX_PL_String *testUtf16 = NULL;
|
||
|
|
PKIX_PL_String *ampString = NULL;
|
||
|
|
unsigned char utf16Data[] = {0x00, 0xA1, 0xD8, 0x00,
|
||
|
|
0xDC, 0x00, 0x0F, 0xFF,
|
||
|
|
0xDB, 0xC0, 0xDC, 0x01};
|
||
|
|
PKIX_UInt32 i, size = 6;
|
||
|
|
|
||
|
|
char *plainText[6] = {
|
||
|
|
"string with\nnewlines and\ttabs",
|
||
|
|
"Not an escaped char: &#x0012;",
|
||
|
|
"Encode & with &amp; in ASCII",
|
||
|
|
"¡",
|
||
|
|
"&",
|
||
|
|
"string with\nnewlines and\ttabs"
|
||
|
|
};
|
||
|
|
|
||
|
|
PKIX_UInt32 actualMinorVersion;
|
||
|
|
PKIX_UInt32 j = 0;
|
||
|
|
|
||
|
|
PKIX_TEST_STD_VARS();
|
||
|
|
|
||
|
|
startTests("Strings");
|
||
|
|
|
||
|
|
PKIX_TEST_EXPECT_NO_ERROR(
|
||
|
|
PKIX_PL_NssContext_Create(0, PKIX_FALSE, NULL, &plContext));
|
||
|
|
|
||
|
|
subTest("PKIX_PL_String_Create <ascii format>");
|
||
|
|
for (i = 0; i < size; i++) {
|
||
|
|
testString[i] = NULL;
|
||
|
|
createString
|
||
|
|
(&testString[i],
|
||
|
|
PKIX_ESCASCII,
|
||
|
|
plainText[i],
|
||
|
|
PL_strlen(plainText[i]));
|
||
|
|
}
|
||
|
|
|
||
|
|
subTest("PKIX_PL_String_Create <other formats>");
|
||
|
|
createStringOther
|
||
|
|
(&testEscAscii,
|
||
|
|
&testUtf16,
|
||
|
|
&String,
|
||
|
|
&testDebugAscii,
|
||
|
|
&testNullString,
|
||
|
|
(PKIX_UInt32 *)utf16Data);
|
||
|
|
|
||
|
|
PKIX_TEST_EQ_HASH_TOSTR_DUP
|
||
|
|
(testString[0],
|
||
|
|
testString[5],
|
||
|
|
testString[1],
|
||
|
|
plainText[0],
|
||
|
|
String,
|
||
|
|
PKIX_TRUE);
|
||
|
|
|
||
|
|
subTest("PKIX_PL_String_GetEncoded");
|
||
|
|
testGetEncoded
|
||
|
|
(testEscAscii,
|
||
|
|
testString[0],
|
||
|
|
testDebugAscii,
|
||
|
|
testNullString,
|
||
|
|
(PKIX_UInt32 *)utf16Data);
|
||
|
|
|
||
|
|
subTest("PKIX_PL_Sprintf");
|
||
|
|
testSprintf();
|
||
|
|
|
||
|
|
subTest("PKIX_PL_String_Create <error_handling>");
|
||
|
|
testErrorHandling();
|
||
|
|
|
||
|
|
subTest("PKIX_PL_String_Destroy");
|
||
|
|
for (i = 0; i < size; i++) {
|
||
|
|
testDestroy(testString[i]);
|
||
|
|
}
|
||
|
|
testDestroy(testEscAscii);
|
||
|
|
testDestroy(testUtf16);
|
||
|
|
testDestroy(ampString);
|
||
|
|
testDestroy(testDebugAscii);
|
||
|
|
testDestroy(testNullString);
|
||
|
|
|
||
|
|
cleanup:
|
||
|
|
|
||
|
|
PKIX_Shutdown(plContext);
|
||
|
|
|
||
|
|
PKIX_TEST_RETURN();
|
||
|
|
|
||
|
|
endTests("String");
|
||
|
|
|
||
|
|
return (0);
|
||
|
|
|
||
|
|
}
|