summaryrefslogtreecommitdiff
path: root/Build/source/libs/icu/icu-4.6/test/intltest/nptrans.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/icu/icu-4.6/test/intltest/nptrans.cpp')
-rw-r--r--Build/source/libs/icu/icu-4.6/test/intltest/nptrans.cpp284
1 files changed, 284 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-4.6/test/intltest/nptrans.cpp b/Build/source/libs/icu/icu-4.6/test/intltest/nptrans.cpp
new file mode 100644
index 00000000000..a4a591ba2a2
--- /dev/null
+++ b/Build/source/libs/icu/icu-4.6/test/intltest/nptrans.cpp
@@ -0,0 +1,284 @@
+/*
+ *******************************************************************************
+ *
+ * Copyright (C) 2003-2010, International Business Machines
+ * Corporation and others. All Rights Reserved.
+ *
+ *******************************************************************************
+ * file name: nptrans.h
+ * encoding: US-ASCII
+ * tab size: 8 (not used)
+ * indentation:4
+ *
+ * created on: 2003feb1
+ * created by: Ram Viswanadha
+ */
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_TRANSLITERATION
+#if !UCONFIG_NO_IDNA
+
+#include "nptrans.h"
+#include "unicode/resbund.h"
+#include "unicode/uniset.h"
+#include "sprpimpl.h"
+#include "cmemory.h"
+#include "ustr_imp.h"
+#include "intltest.h"
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+const char NamePrepTransform::fgClassID=0;
+
+//Factory method
+NamePrepTransform* NamePrepTransform::createInstance(UParseError& parseError, UErrorCode& status){
+ NamePrepTransform* transform = new NamePrepTransform(parseError, status);
+ if(U_FAILURE(status)){
+ delete transform;
+ return NULL;
+ }
+ return transform;
+}
+
+//constructor
+NamePrepTransform::NamePrepTransform(UParseError& parseError, UErrorCode& status)
+: unassigned(), prohibited(), labelSeparatorSet(){
+
+ mapping = NULL;
+ bundle = NULL;
+
+
+ const char* testDataName = IntlTest::loadTestData(status);
+
+ if(U_FAILURE(status)){
+ return;
+ }
+
+ bundle = ures_openDirect(testDataName,"idna_rules",&status);
+
+ if(bundle != NULL && U_SUCCESS(status)){
+ // create the mapping transliterator
+ int32_t ruleLen = 0;
+ const UChar* ruleUChar = ures_getStringByKey(bundle, "MapNFKC",&ruleLen, &status);
+ int32_t mapRuleLen = 0;
+ const UChar *mapRuleUChar = ures_getStringByKey(bundle, "MapNoNormalization", &mapRuleLen, &status);
+ UnicodeString rule(mapRuleUChar, mapRuleLen);
+ rule.append(ruleUChar, ruleLen);
+
+ mapping = Transliterator::createFromRules(UnicodeString("NamePrepTransform", ""), rule,
+ UTRANS_FORWARD, parseError,status);
+ if(U_FAILURE(status)) {
+ return;
+ }
+
+ //create the unassigned set
+ int32_t patternLen =0;
+ const UChar* pattern = ures_getStringByKey(bundle,"UnassignedSet",&patternLen, &status);
+ unassigned.applyPattern(UnicodeString(pattern, patternLen), status);
+
+ //create prohibited set
+ patternLen=0;
+ pattern = ures_getStringByKey(bundle,"ProhibitedSet",&patternLen, &status);
+ UnicodeString test(pattern,patternLen);
+ prohibited.applyPattern(test,status);
+#ifdef DEBUG
+ if(U_FAILURE(status)){
+ printf("Construction of Unicode set failed\n");
+ }
+
+ if(U_SUCCESS(status)){
+ if(prohibited.contains((UChar) 0x644)){
+ printf("The string contains 0x644 ... damn !!\n");
+ }
+ UnicodeString temp;
+ prohibited.toPattern(temp,TRUE);
+
+ for(int32_t i=0;i<temp.length();i++){
+ printf("%c", (char)temp.charAt(i));
+ }
+ printf("\n");
+ }
+#endif
+
+ //create label separator set
+ patternLen=0;
+ pattern = ures_getStringByKey(bundle,"LabelSeparatorSet",&patternLen, &status);
+ labelSeparatorSet.applyPattern(UnicodeString(pattern,patternLen),status);
+ }
+
+ if(U_SUCCESS(status) &&
+ (mapping == NULL)
+ ){
+ status = U_MEMORY_ALLOCATION_ERROR;
+ delete mapping;
+ ures_close(bundle);
+ mapping = NULL;
+ bundle = NULL;
+ }
+
+}
+
+
+UBool NamePrepTransform::isProhibited(UChar32 ch){
+ return (UBool)(ch != ASCII_SPACE);
+}
+
+NamePrepTransform::~NamePrepTransform(){
+ delete mapping;
+ mapping = NULL;
+
+ //close the bundle
+ ures_close(bundle);
+ bundle = NULL;
+}
+
+
+int32_t NamePrepTransform::map(const UChar* src, int32_t srcLength,
+ UChar* dest, int32_t destCapacity,
+ UBool allowUnassigned,
+ UParseError* /*parseError*/,
+ UErrorCode& status ){
+
+ if(U_FAILURE(status)){
+ return 0;
+ }
+ //check arguments
+ if(src==NULL || srcLength<-1 || (dest==NULL && destCapacity!=0)) {
+ status=U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ UnicodeString rsource(src,srcLength);
+ // map the code points
+ // transliteration also performs NFKC
+ mapping->transliterate(rsource);
+
+ const UChar* buffer = rsource.getBuffer();
+ int32_t bufLen = rsource.length();
+ // check if unassigned
+ if(allowUnassigned == FALSE){
+ int32_t bufIndex=0;
+ UChar32 ch =0 ;
+ for(;bufIndex<bufLen;){
+ U16_NEXT(buffer, bufIndex, bufLen, ch);
+ if(unassigned.contains(ch)){
+ status = U_IDNA_UNASSIGNED_ERROR;
+ return 0;
+ }
+ }
+ }
+ // check if there is enough room in the output
+ if(bufLen < destCapacity){
+ uprv_memcpy(dest,buffer,bufLen*U_SIZEOF_UCHAR);
+ }
+
+ return u_terminateUChars(dest, destCapacity, bufLen, &status);
+}
+
+
+#define MAX_BUFFER_SIZE 300
+
+int32_t NamePrepTransform::process( const UChar* src, int32_t srcLength,
+ UChar* dest, int32_t destCapacity,
+ UBool allowUnassigned,
+ UParseError* parseError,
+ UErrorCode& status ){
+ // check error status
+ if(U_FAILURE(status)){
+ return 0;
+ }
+
+ //check arguments
+ if(src==NULL || srcLength<-1 || (dest==NULL && destCapacity!=0)) {
+ status=U_ILLEGAL_ARGUMENT_ERROR;
+ return 0;
+ }
+
+ UnicodeString b1String;
+ UChar *b1 = b1String.getBuffer(MAX_BUFFER_SIZE);
+ int32_t b1Len;
+
+ int32_t b1Index = 0;
+ UCharDirection direction=U_CHAR_DIRECTION_COUNT, firstCharDir=U_CHAR_DIRECTION_COUNT;
+ UBool leftToRight=FALSE, rightToLeft=FALSE;
+
+ b1Len = map(src, srcLength, b1, b1String.getCapacity(), allowUnassigned, parseError, status);
+ b1String.releaseBuffer(b1Len);
+
+ if(status == U_BUFFER_OVERFLOW_ERROR){
+ // redo processing of string
+ /* we do not have enough room so grow the buffer*/
+ b1 = b1String.getBuffer(b1Len);
+ status = U_ZERO_ERROR; // reset error
+ b1Len = map(src, srcLength, b1, b1String.getCapacity(), allowUnassigned, parseError, status);
+ b1String.releaseBuffer(b1Len);
+ }
+
+ if(U_FAILURE(status)){
+ b1Len = 0;
+ goto CLEANUP;
+ }
+
+
+ for(; b1Index<b1Len; ){
+
+ UChar32 ch = 0;
+
+ U16_NEXT(b1, b1Index, b1Len, ch);
+
+ if(prohibited.contains(ch) && ch!=0x0020){
+ status = U_IDNA_PROHIBITED_ERROR;
+ b1Len = 0;
+ goto CLEANUP;
+ }
+
+ direction = u_charDirection(ch);
+ if(firstCharDir==U_CHAR_DIRECTION_COUNT){
+ firstCharDir = direction;
+ }
+ if(direction == U_LEFT_TO_RIGHT){
+ leftToRight = TRUE;
+ }
+ if(direction == U_RIGHT_TO_LEFT || direction == U_RIGHT_TO_LEFT_ARABIC){
+ rightToLeft = TRUE;
+ }
+ }
+
+ // satisfy 2
+ if( leftToRight == TRUE && rightToLeft == TRUE){
+ status = U_IDNA_CHECK_BIDI_ERROR;
+ b1Len = 0;
+ goto CLEANUP;
+ }
+
+ //satisfy 3
+ if( rightToLeft == TRUE &&
+ !((firstCharDir == U_RIGHT_TO_LEFT || firstCharDir == U_RIGHT_TO_LEFT_ARABIC) &&
+ (direction == U_RIGHT_TO_LEFT || direction == U_RIGHT_TO_LEFT_ARABIC))
+ ){
+ status = U_IDNA_CHECK_BIDI_ERROR;
+ return FALSE;
+ }
+
+ if(b1Len <= destCapacity){
+ uprv_memmove(dest,b1, b1Len*U_SIZEOF_UCHAR);
+ }
+
+CLEANUP:
+ return u_terminateUChars(dest, destCapacity, b1Len, &status);
+}
+
+UBool NamePrepTransform::isLabelSeparator(UChar32 ch, UErrorCode& status){
+ // check error status
+ if(U_FAILURE(status)){
+ return FALSE;
+ }
+
+ return labelSeparatorSet.contains(ch);
+}
+
+#endif /* #if !UCONFIG_NO_IDNA */
+#endif /* #if !UCONFIG_NO_TRANSLITERATION */