Check in the pristine copy of ICU 4.6...

icu46/source/test/cintltst/spreptst.c

+/*
+ *******************************************************************************
+ *
+ *   Copyright (C) 2003-2010, International Business Machines
+ *   Corporation and others.  All Rights Reserved.
+ *
+ *******************************************************************************
+ *   file name:  spreptst.c
+ *   encoding:   US-ASCII
+ *   tab size:   8 (not used)
+ *   indentation:4
+ *
+ *   created on: 2003jul11
+ *   created by: Ram Viswanadha
+ */
+#include <stdlib.h>
+#include <string.h>
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_IDNA
+
+#include "unicode/ustring.h"
+#include "unicode/usprep.h"
+#include "cstring.h"
+#include "cintltst.h"
+#include "nfsprep.h"
+
+
+#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
+
+void addUStringPrepTest(TestNode** root);
+void doStringPrepTest(const char* binFileName, const char* txtFileName, 
+                 int32_t options, UErrorCode* errorCode);
+
+static void Test_nfs4_cs_prep_data(void);
+static void Test_nfs4_cis_prep_data(void);
+static void Test_nfs4_mixed_prep_data(void);
+static void Test_nfs4_cs_prep(void);
+static void Test_nfs4_cis_prep(void);
+static void Test_nfs4_mixed_prep(void);
+static void TestBEAMWarning(void);
+static void TestCoverage(void);
+static void TestStringPrepProfiles(void);
+
+UStringPrepProfileType getTypeFromProfileName(const char* profileName);
+
+void 
+addUStringPrepTest(TestNode** root)
+{
+#if !UCONFIG_NO_FILE_IO && !UCONFIG_NO_LEGACY_CONVERSION
+   addTest(root, &Test_nfs4_cs_prep_data,    "spreptst/Test_nfs4_cs_prep_data");
+   addTest(root, &Test_nfs4_cis_prep_data,   "spreptst/Test_nfs4_cis_prep_data");
+   addTest(root, &Test_nfs4_mixed_prep_data, "spreptst/Test_nfs4_mixed_prep_data");
+   addTest(root, &Test_nfs4_cs_prep,         "spreptst/Test_nfs4_cs_prep");
+   addTest(root, &Test_nfs4_cis_prep,        "spreptst/Test_nfs4_cis_prep");
+   addTest(root, &Test_nfs4_mixed_prep,      "spreptst/Test_nfs4_mixed_prep");
+   addTest(root, &TestBEAMWarning,           "spreptst/TestBEAMWarning");
+#endif
+   addTest(root, &TestCoverage,              "spreptst/TestCoverage");
+   addTest(root, &TestStringPrepProfiles,              "spreptst/TestStringPrepProfiles");
+}
+
+static void 
+Test_nfs4_cs_prep_data(void){
+    UErrorCode errorCode = U_ZERO_ERROR;
+    loadTestData(&errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(errorCode));
+        return;
+    }
+
+    log_verbose("Testing nfs4_cs_prep_ci.txt\n");
+    doStringPrepTest("nfscsi","nfs4_cs_prep_ci.txt", USPREP_DEFAULT, &errorCode);
+
+    log_verbose("Testing nfs4_cs_prep_cs.txt\n");
+    errorCode = U_ZERO_ERROR;
+    doStringPrepTest("nfscss","nfs4_cs_prep_cs.txt", USPREP_DEFAULT, &errorCode);
+    
+
+}
+static void 
+Test_nfs4_cis_prep_data(void){
+    UErrorCode errorCode = U_ZERO_ERROR;
+    log_verbose("Testing nfs4_cis_prep.txt\n");
+    doStringPrepTest("nfscis","nfs4_cis_prep.txt", USPREP_DEFAULT, &errorCode);
+}
+static void 
+Test_nfs4_mixed_prep_data(void){
+    UErrorCode errorCode = U_ZERO_ERROR;
+    loadTestData(&errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(errorCode));
+        return;
+    }
+
+    log_verbose("Testing nfs4_mixed_prep_s.txt\n");
+    doStringPrepTest("nfsmxs","nfs4_mixed_prep_s.txt", USPREP_DEFAULT, &errorCode);
+
+    errorCode = U_ZERO_ERROR;
+    log_verbose("Testing nfs4_mixed_prep_p.txt\n");
+    doStringPrepTest("nfsmxp","nfs4_mixed_prep_p.txt", USPREP_DEFAULT, &errorCode);
+
+}
+
+static const struct ConformanceTestCases
+   {
+     const char *comment;
+     const char *in;
+     const char *out;
+     const char *profile;
+     UErrorCode expectedStatus;
+   }
+   conformanceTestCases[] =
+   {
+  
+     {/*0*/
+       "Case folding ASCII U+0043 U+0041 U+0046 U+0045",
+       "\x43\x41\x46\x45", "\x63\x61\x66\x65",
+       "nfs4_cis_prep", 
+       U_ZERO_ERROR
+
+     },
+     {/*1*/
+       "Case folding 8bit U+00DF (german sharp s)",
+       "\xC3\x9F", "\x73\x73", 
+       "nfs4_cis_prep", 
+       U_ZERO_ERROR  
+     },
+     {/*2*/
+       "Non-ASCII multibyte space character U+1680",
+       "\xE1\x9A\x80", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*3*/
+       "Non-ASCII 8bit control character U+0085",
+       "\xC2\x85", NULL, 
+       "nfs4_cis_prep",
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*4*/
+       "Non-ASCII multibyte control character U+180E",
+       "\xE1\xA0\x8E", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*5*/
+       "Non-ASCII control character U+1D175",
+       "\xF0\x9D\x85\xB5", NULL, 
+       "nfs4_cis_prep",
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*6*/
+       "Plane 0 private use character U+F123",
+       "\xEF\x84\xA3", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*7*/
+       "Plane 15 private use character U+F1234",
+       "\xF3\xB1\x88\xB4", NULL, 
+       "nfs4_cis_prep",
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*8*/
+       "Plane 16 private use character U+10F234",
+       "\xF4\x8F\x88\xB4", NULL, 
+       "nfs4_cis_prep",
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*9*/
+       "Non-character code point U+8FFFE",
+       "\xF2\x8F\xBF\xBE", NULL, 
+       "nfs4_cis_prep",
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*10*/
+       "Non-character code point U+10FFFF",
+       "\xF4\x8F\xBF\xBF", NULL,
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR 
+     },
+ /* 
+     {
+       "Surrogate code U+DF42",
+       "\xED\xBD\x82", NULL, "nfs4_cis_prep", UIDNA_DEFAULT,
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+*/
+     {/*11*/
+       "Non-plain text character U+FFFD",
+       "\xEF\xBF\xBD", NULL, 
+       "nfs4_cis_prep",
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*12*/
+       "Ideographic description character U+2FF5",
+       "\xE2\xBF\xB5", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*13*/
+       "Display property character U+0341",
+       "\xCD\x81", "\xCC\x81",
+       "nfs4_cis_prep", U_ZERO_ERROR
+
+     },
+
+     {/*14*/
+       "Left-to-right mark U+200E",
+       "\xE2\x80\x8E", "\xCC\x81", 
+       "nfs4_cis_prep",
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*15*/
+
+       "Deprecated U+202A",
+       "\xE2\x80\xAA", "\xCC\x81", 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*16*/
+       "Language tagging character U+E0001",
+       "\xF3\xA0\x80\x81", "\xCC\x81", 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*17*/
+       "Language tagging character U+E0042",
+       "\xF3\xA0\x81\x82", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_PROHIBITED_ERROR
+     },
+     {/*18*/
+       "Bidi: RandALCat character U+05BE and LCat characters",
+       "\x66\x6F\x6F\xD6\xBE\x62\x61\x72", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_CHECK_BIDI_ERROR
+     },
+     {/*19*/
+       "Bidi: RandALCat character U+FD50 and LCat characters",
+       "\x66\x6F\x6F\xEF\xB5\x90\x62\x61\x72", NULL,
+       "nfs4_cis_prep",
+       U_STRINGPREP_CHECK_BIDI_ERROR
+     },
+     {/*20*/
+       "Bidi: RandALCat character U+FB38 and LCat characters",
+       "\x66\x6F\x6F\xEF\xB9\xB6\x62\x61\x72", "\x66\x6F\x6F\x20\xd9\x8e\x62\x61\x72",
+       "nfs4_cis_prep", 
+       U_ZERO_ERROR
+     },
+     {/*21*/
+       "Bidi: RandALCat without trailing RandALCat U+0627 U+0031",
+       "\xD8\xA7\x31", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_CHECK_BIDI_ERROR
+     },
+     {/*22*/
+       "Bidi: RandALCat character U+0627 U+0031 U+0628",
+       "\xD8\xA7\x31\xD8\xA8", "\xD8\xA7\x31\xD8\xA8",
+       "nfs4_cis_prep", 
+       U_ZERO_ERROR
+     },
+     {/*23*/
+       "Unassigned code point U+E0002",
+       "\xF3\xA0\x80\x82", NULL, 
+       "nfs4_cis_prep", 
+       U_STRINGPREP_UNASSIGNED_ERROR
+     },
+
+/*  // Invalid UTF-8
+     {
+       "Larger test (shrinking)",
+       "X\xC2\xAD\xC3\xDF\xC4\xB0\xE2\x84\xA1\x6a\xcc\x8c\xc2\xa0\xc2"
+       "\xaa\xce\xb0\xe2\x80\x80", "xssi\xcc\x87""tel\xc7\xb0 a\xce\xb0 ",
+       "nfs4_cis_prep",
+        U_ZERO_ERROR
+     },
+    {
+
+       "Larger test (expanding)",
+       "X\xC3\xDF\xe3\x8c\x96\xC4\xB0\xE2\x84\xA1\xE2\x92\x9F\xE3\x8c\x80",
+       "xss\xe3\x82\xad\xe3\x83\xad\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\x88"
+       "\xe3\x83\xab""i\xcc\x87""tel\x28""d\x29\xe3\x82\xa2\xe3\x83\x91"
+       "\xe3\x83\xbc\xe3\x83\x88"
+       "nfs4_cis_prep",
+        U_ZERO_ERROR
+     },
+  */
+};
+
+#define MAX_BUFFER_SIZE  1000
+
+static int32_t 
+unescapeData(const char* src, int32_t srcLen, 
+             char* dest, int32_t destCapacity, 
+             UErrorCode* status){
+
+    UChar b1Stack[MAX_BUFFER_SIZE];
+    int32_t b1Capacity = MAX_BUFFER_SIZE,
+            b1Len      = 0,
+            destLen    = 0;
+
+    UChar* b1 = b1Stack;
+
+    b1Len = u_unescape(src,b1,b1Capacity);
+
+    u_strToUTF8(dest, destCapacity, &destLen, b1, b1Len, status);
+
+    return destLen;
+}
+
+
+static void Test_nfs4_cis_prep(void){
+    int32_t i=0;
+    UErrorCode loadStatus = U_ZERO_ERROR;
+    loadTestData(&loadStatus);
+    if (U_FAILURE(loadStatus)) {
+        log_data_err("Test could not initialize. Got %s\n", u_errorName(loadStatus));
+        return;
+    }
+
+    for(i=0;i< (int32_t)(sizeof(conformanceTestCases)/sizeof(conformanceTestCases[0]));i++){
+        const char* src = conformanceTestCases[i].in;
+        UErrorCode status = U_ZERO_ERROR;
+        UParseError parseError;
+        UErrorCode expectedStatus = conformanceTestCases[i].expectedStatus;
+        const char* expectedDest = conformanceTestCases[i].out;
+        char* dest = NULL;
+        int32_t destLen = 0;
+
+        destLen = nfs4_cis_prepare(src , (int32_t)strlen(src), dest, destLen, &parseError, &status); 
+        if(status == U_BUFFER_OVERFLOW_ERROR){
+            status = U_ZERO_ERROR;
+            dest = (char*) malloc(++destLen);
+            destLen = nfs4_cis_prepare( src , (int32_t)strlen(src), dest, destLen, &parseError, &status); 
+        }
+
+        if(expectedStatus != status){
+            log_data_err("Did not get the expected status for nfs4_cis_prep at index %i. Expected: %s Got: %s - (Are you missing data?)\n",i, u_errorName(expectedStatus), u_errorName(status));
+        }
+        if(U_SUCCESS(status) && (strcmp(expectedDest,dest) !=0)){
+              log_err("Did not get the expected output for nfs4_cis_prep at index %i.\n", i);
+        }
+        free(dest);
+    }
+}
+
+
+
+/*
+   There are several special identifiers ("who") which need to be
+   understood universally, rather than in the context of a particular
+   DNS domain.  Some of these identifiers cannot be understood when an
+   NFS client accesses the server, but have meaning when a local process
+   accesses the file.  The ability to display and modify these
+   permissions is permitted over NFS, even if none of the access methods
+   on the server understands the identifiers.
+
+    Who                    Description
+   _______________________________________________________________
+
+   "OWNER"                The owner of the file.
+   "GROUP"                The group associated with the file.
+   "EVERYONE"             The world.
+   "INTERACTIVE"          Accessed from an interactive terminal.
+   "NETWORK"              Accessed via the network.
+   "DIALUP"               Accessed as a dialup user to the server.
+   "BATCH"                Accessed from a batch job.
+   "ANONYMOUS"            Accessed without any authentication.
+   "AUTHENTICATED"        Any authenticated user (opposite of
+                          ANONYMOUS)
+   "SERVICE"              Access from a system service.
+
+   To avoid conflict, these special identifiers are distinguish by an
+   appended "@" and should appear in the form "xxxx@" (note: no domain
+   name after the "@").  For example: ANONYMOUS@.
+*/
+static const char* mixed_prep_data[] ={
+    "OWNER@",
+    "GROUP@",        
+    "EVERYONE@",     
+    "INTERACTIVE@",  
+    "NETWORK@",      
+    "DIALUP@",       
+    "BATCH@",        
+    "ANONYMOUS@",    
+    "AUTHENTICATED@",
+    "\\u0930\\u094D\\u092E\\u094D\\u0915\\u094D\\u0937\\u0947\\u0924\\u094D@slip129-37-118-146.nc.us.ibm.net",
+    "\\u0936\\u094d\\u0930\\u0940\\u092e\\u0926\\u094d@saratoga.pe.utexas.edu",
+    "\\u092d\\u0917\\u0935\\u0926\\u094d\\u0917\\u0940\\u0924\\u093e@dial-120-45.ots.utexas.edu",
+    "\\u0905\\u0927\\u094d\\u092f\\u093e\\u092f@woo-085.dorms.waller.net",
+    "\\u0905\\u0930\\u094d\\u091c\\u0941\\u0928@hd30-049.hil.compuserve.com",
+    "\\u0935\\u093f\\u0937\\u093e\\u0926@pem203-31.pe.ttu.edu",
+    "\\u092f\\u094b\\u0917@56K-227.MaxTNT3.pdq.net",
+    "\\u0927\\u0943\\u0924\\u0930\\u093e\\u0937\\u094d\\u091f\\u094d\\u0930@dial-36-2.ots.utexas.edu",
+    "\\u0909\\u0935\\u093E\\u091A\\u0943@slip129-37-23-152.ga.us.ibm.net",
+    "\\u0927\\u0930\\u094d\\u092e\\u0915\\u094d\\u0937\\u0947\\u0924\\u094d\\u0930\\u0947@ts45ip119.cadvision.com",
+    "\\u0915\\u0941\\u0930\\u0941\\u0915\\u094d\\u0937\\u0947\\u0924\\u094d\\u0930\\u0947@sdn-ts-004txaustP05.dialsprint.net",
+    "\\u0938\\u092e\\u0935\\u0947\\u0924\\u093e@bar-tnt1s66.erols.com",
+    "\\u092f\\u0941\\u092f\\u0941\\u0924\\u094d\\u0938\\u0935\\u0903@101.st-louis-15.mo.dial-access.att.net",
+    "\\u092e\\u093e\\u092e\\u0915\\u093e\\u0903@h92-245.Arco.COM",
+    "\\u092a\\u093e\\u0923\\u094d\\u0921\\u0935\\u093e\\u0936\\u094d\\u091a\\u0948\\u0935@dial-13-2.ots.utexas.edu",
+    "\\u0915\\u093f\\u092e\\u0915\\u0941\\u0930\\u094d\\u0935\\u0924@net-redynet29.datamarkets.com.ar",
+    "\\u0938\\u0902\\u091c\\u0935@ccs-shiva28.reacciun.net.ve",
+    "\\u0c30\\u0c18\\u0c41\\u0c30\\u0c3e\\u0c2e\\u0c4d@7.houston-11.tx.dial-access.att.net",
+    "\\u0c35\\u0c3f\\u0c36\\u0c4d\\u0c35\\u0c28\\u0c3e\\u0c27@ingw129-37-120-26.mo.us.ibm.net",
+    "\\u0c06\\u0c28\\u0c02\\u0c26\\u0c4d@dialup6.austintx.com",
+    "\\u0C35\\u0C26\\u0C4D\\u0C26\\u0C3F\\u0C30\\u0C3E\\u0C1C\\u0C41@dns2.tpao.gov.tr",
+    "\\u0c30\\u0c3e\\u0c1c\\u0c40\\u0c35\\u0c4d@slip129-37-119-194.nc.us.ibm.net",
+    "\\u0c15\\u0c36\\u0c30\\u0c2c\\u0c3e\\u0c26@cs7.dillons.co.uk.203.119.193.in-addr.arpa",
+    "\\u0c38\\u0c02\\u0c1c\\u0c40\\u0c35\\u0c4d@swprd1.innovplace.saskatoon.sk.ca",
+    "\\u0c15\\u0c36\\u0c30\\u0c2c\\u0c3e\\u0c26@bikini.bologna.maraut.it",
+    "\\u0c38\\u0c02\\u0c1c\\u0c40\\u0c2c\\u0c4d@node91.subnet159-198-79.baxter.com",
+    "\\u0c38\\u0c46\\u0c28\\u0c4d\\u0c17\\u0c41\\u0c2a\\u0c4d\\u0c24@cust19.max5.new-york.ny.ms.uu.net",
+    "\\u0c05\\u0c2e\\u0c30\\u0c47\\u0c02\\u0c26\\u0c4d\\u0c30@balexander.slip.andrew.cmu.edu",
+    "\\u0c39\\u0c28\\u0c41\\u0c2e\\u0c3e\\u0c28\\u0c41\\u0c32@pool029.max2.denver.co.dynip.alter.net",
+    "\\u0c30\\u0c35\\u0c3f@cust49.max9.new-york.ny.ms.uu.net",
+    "\\u0c15\\u0c41\\u0c2e\\u0c3e\\u0c30\\u0c4d@s61.abq-dialin2.hollyberry.com",
+    "\\u0c35\\u0c3f\\u0c36\\u0c4d\\u0c35\\u0c28\\u0c3e\\u0c27@\\u0917\\u0928\\u0947\\u0936.sanjose.ibm.com",
+    "\\u0c06\\u0c26\\u0c3f\\u0c24\\u0c4d\\u0c2f@www.\\u00E0\\u00B3\\u00AF.com",
+    "\\u0C15\\u0C02\\u0C26\\u0C4D\\u0C30\\u0C47\\u0C17\\u0C41\\u0c32@www.\\u00C2\\u00A4.com",
+    "\\u0c36\\u0c4d\\u0c30\\u0c40\\u0C27\\u0C30\\u0C4D@www.\\u00C2\\u00A3.com",
+    "\\u0c15\\u0c02\\u0c1f\\u0c2e\\u0c36\\u0c46\\u0c1f\\u0c4d\\u0c1f\\u0c3f@\\u0025",
+    "\\u0c2e\\u0c3e\\u0c27\\u0c35\\u0c4d@\\u005C\\u005C",
+    "\\u0c26\\u0c46\\u0c36\\u0c46\\u0c1f\\u0c4d\\u0c1f\\u0c3f@www.\\u0021.com",
+    "test@www.\\u0024.com",
+    "help@\\u00C3\\u00BC.com",
+
+};
+
+
+static void 
+Test_nfs4_mixed_prep(void){
+    UErrorCode loadStatus = U_ZERO_ERROR;
+    loadTestData(&loadStatus);
+    if (U_FAILURE(loadStatus)) {
+        log_data_err("Test could not initialize. Got %s\n", u_errorName(loadStatus));
+        return;
+    }
+
+    {
+        int32_t i=0;
+        char src[MAX_BUFFER_SIZE];
+        int32_t srcLen;
+
+        for(i=0; i< LENGTHOF(mixed_prep_data); i++){
+            int32_t destLen=0;
+            char* dest = NULL;
+            UErrorCode status = U_ZERO_ERROR;
+            UParseError parseError;
+            srcLen = unescapeData(mixed_prep_data[i], (int32_t)strlen(mixed_prep_data[i]), src, MAX_BUFFER_SIZE, &status);
+            if(U_FAILURE(status)){
+                log_err("Conversion of data at index %i failed. Error: %s\n", i, u_errorName(status));
+                continue;
+            }
+            destLen = nfs4_mixed_prepare(src, srcLen, NULL, 0, &parseError, &status);
+            if(status == U_BUFFER_OVERFLOW_ERROR){
+                status = U_ZERO_ERROR;
+                dest = (char*)malloc(++destLen);
+                destLen = nfs4_mixed_prepare(src, srcLen, dest, destLen, &parseError, &status);
+            }
+            free(dest);
+            if(U_FAILURE(status)){
+                log_data_err("Preparation of string at index %i failed. Error: %s - (Are you missing data?)\n", i, u_errorName(status));
+                continue;
+            }
+        } 
+    }
+    /* test the error condition */
+    {
+        const char* source = "OWNER@oss.software.ibm.com";
+        char dest[MAX_BUFFER_SIZE];
+        char src[MAX_BUFFER_SIZE] = {0};
+        UErrorCode status = U_ZERO_ERROR;
+        UParseError parseError;
+        
+        int32_t srcLen = unescapeData(source, (int32_t)strlen(source), src, MAX_BUFFER_SIZE, &status);
+
+        nfs4_mixed_prepare(src, srcLen, dest, MAX_BUFFER_SIZE, &parseError, &status);
+
+        if(status != U_PARSE_ERROR){
+            log_err("Did not get the expected error.Expected: %s Got: %s\n", u_errorName(U_PARSE_ERROR), u_errorName(status));
+        }
+    }
+
+
+}
+
+static void 
+Test_nfs4_cs_prep(void){
+    UErrorCode errorCode = U_ZERO_ERROR;
+    loadTestData(&errorCode);
+    if(U_FAILURE(errorCode)) {
+        log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(errorCode));
+        return;
+    }
+
+    {
+        /* BiDi checking is turned off */
+        const char *source = "\\uC138\\uACC4\\uC758\\uBAA8\\uB4E0\\uC0AC\\uB78C\\uB4E4\\uC774\\u0644\\u064A\\u0647\\uD55C\\uAD6D\\uC5B4\\uB97C\\uC774\\uD574\\uD55C\\uB2E4\\uBA74";
+        UErrorCode status = U_ZERO_ERROR;
+        char src[MAX_BUFFER_SIZE]={'\0'};
+        UParseError parseError;
+        int32_t srcLen = unescapeData(source, (int32_t)strlen(source), src, MAX_BUFFER_SIZE, &status);
+        if(U_SUCCESS(status)){
+            char dest[MAX_BUFFER_SIZE] = {'\0'};
+            int32_t destLen = nfs4_cs_prepare(src, srcLen, dest, MAX_BUFFER_SIZE, FALSE, &parseError, &status);
+            if(U_FAILURE(status)){
+                log_err("StringPrep failed for case: BiDi Checking Turned OFF with error: %s\n", u_errorName(status));
+            }
+            if(strcmp(dest,src)!=0){
+                log_err("Did not get the expected output for case: BiDi Checking Turned OFF\n");
+            }
+            if(destLen != srcLen){
+                log_err("Did not get the expected length for the output for case: BiDi Checking Turned OFF. Expected: %i Got: %i\n", srcLen, destLen);
+            }
+        }else{
+            log_err("Conversion failed for case: BiDi Checking Turned OFF with error: %s\n", u_errorName(status));
+        }
+    }
+    {
+        /* Normalization turned off */
+        const char *source = "www.\\u00E0\\u00B3\\u00AF.com";
+        UErrorCode status = U_ZERO_ERROR;
+        char src[MAX_BUFFER_SIZE]={'\0'};
+        UParseError parseError;
+        int32_t srcLen = unescapeData(source, (int32_t)strlen(source), src, MAX_BUFFER_SIZE, &status);
+        if(U_SUCCESS(status)){
+            char dest[MAX_BUFFER_SIZE] = {'\0'};
+            int32_t destLen = nfs4_cs_prepare(src, srcLen, dest, MAX_BUFFER_SIZE, FALSE, &parseError, &status);
+            if(U_FAILURE(status)){
+                log_err("StringPrep failed for case: Normalization Turned OFF with error: %s\n", u_errorName(status));
+            }
+            if(strcmp(dest,src)!=0){
+                log_err("Did not get the expected output for case: Normalization Turned OFF\n");
+            }
+            if(destLen != srcLen){
+                log_err("Did not get the expected length for the output for case: Normalization Turned OFF. Expected: %i Got: %i\n", srcLen, destLen);
+            }
+        }else{
+            log_err("Conversion failed for case: Normalization Turned OFF with error: %s\n", u_errorName(status));
+        }
+    }
+    {
+        /* case mapping turned off */
+        const char *source = "THISISATEST";
+        UErrorCode status = U_ZERO_ERROR;
+        char src[MAX_BUFFER_SIZE]={'\0'};
+        UParseError parseError;
+        int32_t srcLen = unescapeData(source, (int32_t)strlen(source), src, MAX_BUFFER_SIZE, &status);
+        if(U_SUCCESS(status)){
+            char dest[MAX_BUFFER_SIZE] = {'\0'};
+            int32_t destLen = nfs4_cs_prepare(src, srcLen, dest, MAX_BUFFER_SIZE, TRUE, &parseError, &status);
+            if(U_FAILURE(status)){
+                log_err("StringPrep failed for case: Case Mapping Turned OFF with error: %s\n", u_errorName(status));
+            }
+            if(strcmp(dest,src)!=0){
+                log_err("Did not get the expected output for case: Case Mapping Turned OFF\n");
+            }
+            if(destLen != srcLen){
+                log_err("Did not get the expected length for the output for case: Case Mapping Turned OFF. Expected: %i Got: %i\n", srcLen, destLen);
+            }
+        }else{
+            log_err("Conversion failed for case: Case Mapping Turned OFF with error: %s\n", u_errorName(status));
+        }
+    }
+    {
+        /* case mapping turned on */
+        const char *source = "THISISATEST";
+        const char *expected = "thisisatest";
+        UErrorCode status = U_ZERO_ERROR;
+        char src[MAX_BUFFER_SIZE]={'\0'};
+        char exp[MAX_BUFFER_SIZE]={'\0'};
+        UParseError parseError;
+        int32_t srcLen = unescapeData(source, (int32_t)strlen(source), src, MAX_BUFFER_SIZE, &status);
+        int32_t expLen = unescapeData(expected, (int32_t)strlen(expected), exp, MAX_BUFFER_SIZE, &status);
+        if(U_SUCCESS(status)){
+            char dest[MAX_BUFFER_SIZE] = {'\0'};
+            int32_t destLen = nfs4_cs_prepare(src, srcLen, dest, MAX_BUFFER_SIZE, FALSE, &parseError, &status);
+            if(U_FAILURE(status)){
+                log_err("StringPrep failed for case: Case Mapping Turned On with error: %s\n", u_errorName(status));
+            }
+            if(strcmp(exp, dest)!=0){
+                log_err("Did not get the expected output for case: Case Mapping Turned On!\n");
+            }
+            if(destLen != expLen){
+                log_err("Did not get the expected length for the outputfor case: Case Mapping Turned On. Expected: %i Got: %i\n", strlen(expected), destLen);
+            }
+        }else{
+            log_err("Conversion failed for case: Case Mapping Turned ON with error: %s\n", u_errorName(status));
+        }
+    }
+}
+
+
+
+static void TestBEAMWarning(){
+    UErrorCode status = U_ZERO_ERROR;
+    UParseError parseError;
+    UStringPrepProfile* profile = NULL;
+    /* get the test data path */
+    const char *testdatapath = NULL;
+    UChar src =0x0000;
+    testdatapath = loadTestData(&status);
+    if(U_FAILURE(status)) {
+        log_data_err("Could not load testdata.dat, status = %s\n", u_errorName(status));
+        return;
+    }
+    /* open the profile */
+    profile = usprep_open(testdatapath, "nfscis",  &status);
+    usprep_prepare(profile,&src , 0, NULL, 0, USPREP_DEFAULT, &parseError, &status);
+
+    usprep_close(profile);
+}
+
+static void TestCoverage(void) {
+    UErrorCode status = U_USELESS_COLLATOR_ERROR;
+    UParseError parseError;
+    
+    usprep_open(NULL, NULL, &status);
+    if (status != U_USELESS_COLLATOR_ERROR) {
+        log_err("usprep_open didn't react correctly to a bad UErrorCode\n");
+    }
+    usprep_prepare(NULL, NULL, 0, NULL, 0, USPREP_DEFAULT, &parseError, &status);
+    if (status != U_USELESS_COLLATOR_ERROR) {
+        log_err("usprep_prepare didn't react correctly to a bad UErrorCode\n");
+    }
+    status = U_ZERO_ERROR;
+    usprep_prepare(NULL, NULL, 0, NULL, 0, USPREP_DEFAULT, &parseError, &status);
+    if (status != U_ILLEGAL_ARGUMENT_ERROR) {
+        log_err("usprep_prepare didn't check its arguments\n");
+    }
+
+    /* Don't crash */
+    usprep_close(NULL);
+}
+
+/**** Profile Test ****/
+
+#define SPREP_PROFILE_TEST_MAX_LENGTH 64
+/* The format of the test cases should be the following:
+* {
+*     Profile name
+*     src string1
+*     expected result1
+*     src string2
+*     expected result2
+*     ...
+* } 
+* 
+* *Note: For expected failures add FAIL to beginning of the source string and for expected result use "FAIL".
+*/
+static const char *profile_test_case[] = {
+/**** RFC4013_SASLPREP ****/
+    "RFC4013_SASLPREP",
+    "user:\\u00A0\\u0AC6\\u1680\\u00ADpassword1",
+    "user: \\u0AC6 password1",
+    
+/**** RFC4011_MIB ****/
+    "RFC4011_MIB",
+    "Policy\\u034F\\u200DBase\\u0020d\\u1806\\u200C",
+    "PolicyBase d",
+    
+/**** RFC4505_TRACE ****/
+    "RFC4505_TRACE",
+    "Anony\\u0020\\u00A0mous\\u3000\\u0B9D\\u034F\\u00AD",
+    "Anony\\u0020\\u00A0mous\\u3000\\u0B9D\\u034F\\u00AD",
+    
+/**** RFC4518_LDAP ****/
+    "RFC4518_LDAP",
+    "Ldap\\uFB01\\u00ADTest\\u0020\\u00A0\\u2062ing",
+    "LdapfiTest  ing",
+    
+/**** RFC4518_LDAP_CI ****/
+    "RFC4518_LDAP_CI",
+    "Ldap\\uFB01\\u00ADTest\\u0020\\u00A0\\u2062ing12345",
+    "ldapfitest  ing12345",
+    
+/**** RFC3920_RESOURCEPREP ****/
+    "RFC3920_RESOURCEPREP",
+    "ServerXM\\u2060\\uFE00\\uFE09PP s p ",
+    "ServerXMPP s p ",
+    
+/**** RFC3920_NODEPREP ****/
+    "RFC3920_NODEPREP",
+    "Server\\u200DXMPPGreEK\\u03D0",
+    "serverxmppgreek\\u03B2",
+    
+/**** RFC3722_ISCI ****/
+    "RFC3722_ISCSI",
+    "InternetSmallComputer\\uFB01\\u0032\\u2075Interface",
+    "internetsmallcomputerfi25interface",
+    "FAILThisShouldFailBecauseOfThis\\u002F",
+    "FAIL",
+    
+/**** RFC3530_NFS4_CS_PREP ****/
+    "RFC3530_NFS4_CS_PREP",
+    "\\u00ADUser\\u2060Name@ \\u06DDDOMAIN.com",
+    "UserName@ \\u06DDDOMAIN.com",
+    
+/**** RFC3530_NFS4_CS_PREP_CI ****/
+    "RFC3530_NFS4_CS_PREP_CI",
+    "\\u00ADUser\\u2060Name@ \\u06DDDOMAIN.com",
+    "username@ \\u06DDdomain.com",
+    
+/**** RFC3530_NFS4_CIS_PREP ****/
+    "RFC3530_NFS4_CIS_PREP",
+    "AA\\u200C\\u200D @@DomAin.org",
+    "aa @@domain.org",
+    
+/**** RFC3530_NFS4_MIXED_PREP_PREFIX ****/
+    "RFC3530_NFS4_MIXED_PREP_PREFIX",
+    "PrefixUser \\u007F\\uFB01End",
+    "PrefixUser \\u007FfiEnd",
+    
+/**** RFC3530_NFS4_MIXED_PREP_SUFFIX ****/
+    "RFC3530_NFS4_MIXED_PREP_SUFFIX",
+    "SuffixDomain \\u007F\\uFB01EnD",
+    "suffixdomain \\u007Ffiend",
+};
+
+UStringPrepProfileType getTypeFromProfileName(const char* profileName) {
+    if (uprv_strcmp(profileName, "RFC4013_SASLPREP") == 0) {
+        return USPREP_RFC4013_SASLPREP;
+    } else if (uprv_strcmp(profileName, "RFC4011_MIB") == 0) {
+        return USPREP_RFC4011_MIB;
+    } else if (uprv_strcmp(profileName, "RFC4505_TRACE") == 0) {
+        return USPREP_RFC4505_TRACE;
+    } else if (uprv_strcmp(profileName, "RFC4518_LDAP") == 0) {
+        return USPREP_RFC4518_LDAP;
+    } else if (uprv_strcmp(profileName, "RFC4518_LDAP_CI") == 0) {
+        return USPREP_RFC4518_LDAP_CI;
+    } else if (uprv_strcmp(profileName, "RFC3920_RESOURCEPREP") == 0) {
+        return USPREP_RFC3920_RESOURCEPREP;
+    } else if (uprv_strcmp(profileName, "RFC3920_NODEPREP") == 0) {
+        return USPREP_RFC3920_NODEPREP;
+    } else if (uprv_strcmp(profileName, "RFC3722_ISCSI") == 0) {
+        return USPREP_RFC3722_ISCSI;
+    } else if (uprv_strcmp(profileName, "RFC3530_NFS4_CS_PREP") == 0) {
+        return USPREP_RFC3530_NFS4_CS_PREP;
+    } else if (uprv_strcmp(profileName, "RFC3530_NFS4_CS_PREP_CI") == 0) {
+        return USPREP_RFC3530_NFS4_CS_PREP_CI;
+    } else if (uprv_strcmp(profileName, "RFC3530_NFS4_CIS_PREP") == 0) {
+        return USPREP_RFC3530_NFS4_CIS_PREP;
+    } else if (uprv_strcmp(profileName, "RFC3530_NFS4_MIXED_PREP_PREFIX") == 0) {
+        return USPREP_RFC3530_NFS4_MIXED_PREP_PREFIX;
+    } else if (uprv_strcmp(profileName, "RFC3530_NFS4_MIXED_PREP_SUFFIX") == 0) {
+        return USPREP_RFC3530_NFS4_MIXED_PREP_SUFFIX;
+    }
+    /* Should not happen. */
+    return USPREP_RFC3491_NAMEPREP;
+}
+static void TestStringPrepProfiles(void) {
+    UErrorCode status = U_ZERO_ERROR;
+    const char *profileName = NULL;
+    UChar src[SPREP_PROFILE_TEST_MAX_LENGTH];
+    UChar expected[SPREP_PROFILE_TEST_MAX_LENGTH];
+    UChar result[SPREP_PROFILE_TEST_MAX_LENGTH];
+    int32_t srcLength, resultLength, expectedLength;
+    int32_t i, testNum = 0;
+    UStringPrepProfile *sprep = NULL;
+    
+    for (i = 0; i < LENGTHOF(profile_test_case); i++) {
+        if (uprv_strstr(profile_test_case[i], "RFC")) {
+            if (sprep != NULL) {
+                usprep_close(sprep);
+                sprep = NULL;
+            }
+            profileName = profile_test_case[i];
+            sprep = usprep_openByType(getTypeFromProfileName(profileName), &status);
+            if (U_FAILURE(status)) {
+                log_data_err("Unable to open String Prep Profile with: %s\n", profileName);
+                break;
+            }
+            
+            testNum = 0;
+            continue;
+        }
+        srcLength = resultLength = expectedLength = SPREP_PROFILE_TEST_MAX_LENGTH;
+        
+        testNum++;
+        
+        srcLength = u_unescape(profile_test_case[i], src, srcLength);
+        expectedLength = u_unescape(profile_test_case[++i], expected, expectedLength);
+        
+        resultLength = usprep_prepare(sprep, src, srcLength, result, resultLength, USPREP_ALLOW_UNASSIGNED, NULL, &status);
+        if (U_FAILURE(status)) {
+            if (uprv_strstr(profile_test_case[i], "FAIL") == NULL) {
+                log_err("Error occurred on test[%d] for profile: %s\n", testNum, profileName);
+            } else {
+                /* Error is expected so reset the status. */
+                status = U_ZERO_ERROR;
+            }
+        } else {
+            if (uprv_strstr(profile_test_case[i], "FAIL") != NULL) {
+                log_err("Error expected on test[%d] for profile: %s\n", testNum, profileName);
+            }
+            
+            if (resultLength != expectedLength || u_strcmp(result, expected) != 0) {
+                log_err("Results do not match expected on test[%d] for profile: %s\n", testNum, profileName);
+            }
+        }
+    }
+    
+    if (sprep != NULL) {
+        usprep_close(sprep);
+    }
+}
+
+#endif
+
+/*
+ * Hey, Emacs, please set the following:
+ *
+ * Local Variables:
+ * indent-tabs-mode: nil
+ * End:
+ *
+ */