gecko/security/nss/cmd/libpkix/pkix_pl/system/test_string.c

480 lines
16 KiB
C
Raw Normal View History

2008-06-06 05:40:11 -07:00
/* ***** 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&#x000A;newlines and&#x0009;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,
"&#x003k;",
7,
&testString,
plContext));
/* &#x must be followed by 4 hexadecimal digits */
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
PKIX_ESCASCII,
"abc&#x00",
8,
&testString,
plContext));
/* &#x must be between 00010000-0010FFFF */
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
PKIX_ESCASCII,
"&#x00200101;",
11,
&testString,
plContext));
/* &#x must be followed by 8 hexadecimal digits */
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
PKIX_ESCASCII,
"&#x001000",
10,
&testString,
plContext));
/* &#x must be followed by 8 hexadecimal digits */
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
PKIX_ESCASCII,
"&#x0010m00;",
10,
&testString,
plContext));
/* Byte values D800-DFFF are reserved */
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
PKIX_ESCASCII,
"&#xD800;",
7,
&testString,
plContext));
/* Can't use &#x for regular characters */
PKIX_TEST_EXPECT_ERROR(PKIX_PL_String_Create(
PKIX_ESCASCII,
"&#x0032;",
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: &amp;#x0012;",
"Encode &amp; with &amp;amp; in ASCII",
"&#x00A1;",
"&amp;",
"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,
&ampString,
&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);
}