FoldStringA/W tests (updated)

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi,

This is the same patch as before, just updated with a todo_wine for
the Ascii 
composite char case.

Cheers,
Jon

License: X11

Changelog:

  Jon Griffiths <jon_p_griffiths@yahoo.com>
  +dlls/kernel/tests/locale.c
    Add tests for FoldStringA/W






__________________________________
Do you Yahoo!?
The New Yahoo! Shopping - with improved product search
http://shopping.yahoo.com
--- wine/dlls/kernel/tests/locale.c	2003-09-30 03:29:09.000000000 +0100
+++ wine-develop/dlls/kernel/tests/locale.c	2003-10-17 15:55:42.000000000 +0100
@@ -43,6 +43,10 @@
                                                    LGRPID, DWORD, LONG_PTR);
 static EnumLanguageGroupLocalesAFn pEnumLanguageGroupLocalesA;
 
+typedef INT (WINAPI *FoldStringAFn)(DWORD, LPCSTR, INT, LPSTR, INT);
+static FoldStringAFn pFoldStringA;
+typedef INT (WINAPI *FoldStringWFn)(DWORD, LPCWSTR, INT, LPWSTR, INT);
+static FoldStringWFn pFoldStringW;
 
 static void InitFunctionPointers(void)
 {
@@ -51,7 +55,9 @@
   if (hKernel32)
   {
     pEnumSystemLanguageGroupsA = (void*)GetProcAddress(hKernel32, "EnumSystemLanguageGroupsA");
-	pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
+    pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
+    pFoldStringA = (void*)GetProcAddress(hKernel32, "FoldStringA");
+    pFoldStringW = (void*)GetProcAddress(hKernel32, "FoldStringW");
   }
 }
 
@@ -77,14 +83,14 @@
  "Expected GetLastError() == 0, got %ld\n", GetLastError())
 
 #define STRINGSA(x,y) strcpy(input, x); strcpy(Expected, y); SetLastError(0); buffer[0] = '\0'
-#define EXPECT_LENA EXPECT_LEN(strlen(Expected)+1)
+#define EXPECT_LENA EXPECT_LEN((int)strlen(Expected)+1)
 #define EXPECT_EQA ok(strncmp(buffer, Expected, strlen(Expected)) == 0, \
   "Expected '%s', got '%s'", Expected, buffer)
 
 #define STRINGSW(x,y) MultiByteToWideChar(CP_ACP,0,x,-1,input,COUNTOF(input)); \
    MultiByteToWideChar(CP_ACP,0,y,-1,Expected,COUNTOF(Expected)); \
    SetLastError(0); buffer[0] = '\0'
-#define EXPECT_LENW EXPECT_LEN(strlenW(Expected)+1)
+#define EXPECT_LENW EXPECT_LEN((int)strlenW(Expected)+1)
 #define EXPECT_EQW  ok(strncmpW(buffer, Expected, strlenW(Expected)) == 0, "Bad conversion\n")
 
 #define NUO LOCALE_NOUSEROVERRIDE
@@ -1039,6 +1045,481 @@
     ok(!lstrcmpW(buf, symbols_stripped), "string comparison mismatch\n");
 }
 
+void test_FoldStringA(void)
+{
+  int ret, i;
+  char src[256], dst[256];
+  static const char digits_src[] = { 0xB9,0xB2,0xB3,'\0'  };
+  static const char digits_dst[] = { '1','2','3','\0'  };
+  static const char composite_src[] =
+  {
+    0x8a,0x8e,0x9a,0x9e,0x9f,0xc0,0xc1,0xc2,
+    0xc3,0xc4,0xc5,0xc7,0xc8,0xc9,0xca,0xcb,
+    0xcc,0xcd,0xce,0xcf,0xd1,0xd2,0xd3,0xd4,
+    0xd5,0xd6,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,
+    0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe7,0xe8,
+    0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,0xf1,
+    0xf2,0xf3,0xf4,0xf5,0xf6,0xf8,0xf9,0xfa,
+    0xfb,0xfc,0xfd,0xff,'\0'
+  };
+  static const char composite_dst[] =
+  {
+    0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
+    0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
+    0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
+    0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
+    0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
+    0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
+    0x4f,0x7e,0x4f,0xa8,0x4f,0x3f,0x55,0x60,
+    0x55,0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,
+    0x61,0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,
+    0x61,0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,
+    0x65,0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,
+    0x69,0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,
+    0x6f,0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,
+    0x6f,0xa8,0x6f,0x3f,0x75,0x60,0x75,0xb4,
+    0x75,0x5e,0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
+  };
+  static const char ligatures_src[] =
+  {
+    0x8C,0x9C,0xC6,0xDE,0xDF,0xE6,0xFE,'\0'
+  };
+  static const char ligatures_dst[] =
+  {
+    'O','E','o','e','A','E','T','H','s','s','a','e','t','h','\0'
+  };
+
+  if (!pFoldStringA)
+    return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
+
+  /* MAP_FOLDDIGITS */
+  SetLastError(0);
+  ret = pFoldStringA(MAP_FOLDDIGITS, digits_src, -1, dst, 256);
+  EXPECT_LEN(4); EXPECT_VALID;
+  ok(strcmp(dst, digits_dst) == 0,
+     "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", digits_dst, dst);
+  for (i = 1; i < 256; i++)
+  {
+    if (!strchr(digits_src, i))
+    {
+      src[0] = i;
+      src[1] = '\0';
+      SetLastError(0);
+      ret = pFoldStringA(MAP_FOLDDIGITS, src, -1, dst, 256);
+      EXPECT_LEN(2); EXPECT_VALID;
+      ok(dst[0] == src[0],
+         "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", src, dst);
+    }
+  }
+
+  /* MAP_EXPAND_LIGATURES */
+  SetLastError(0);
+  ret = pFoldStringA(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
+  EXPECT_LEN(15); EXPECT_VALID;
+  ok(strcmp(dst, ligatures_dst) == 0,
+     "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", ligatures_dst, dst);
+  for (i = 1; i < 256; i++)
+  {
+    if (!strchr(ligatures_src, i))
+    {
+      src[0] = i;
+      src[1] = '\0';
+      SetLastError(0);
+      ret = pFoldStringA(MAP_EXPAND_LIGATURES, src, -1, dst, 256);
+      EXPECT_LEN(2); EXPECT_VALID;
+      ok(dst[0] == src[0],
+         "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", src, dst);
+    }
+  }
+
+  /* MAP_COMPOSITE */
+  SetLastError(0);
+  ret = pFoldStringA(MAP_COMPOSITE, composite_src, -1, dst, 256);
+  EXPECT_VALID;
+  todo_wine
+  {
+    /* Wine gets close, but doesn't produce quite the same result as native */
+    EXPECT_LEN(121);
+    ok(strcmp(dst, composite_dst) == 0,
+       "MAP_COMPOSITE: Expected '%s', got '%s'\n", composite_dst, dst);
+  }
+
+  for (i = 1; i < 256; i++)
+  {
+    if (!strchr(composite_src, i))
+    {
+      src[0] = i;
+      src[1] = '\0';
+      SetLastError(0);
+      ret = pFoldStringA(MAP_COMPOSITE, src, -1, dst, 256);
+      EXPECT_LEN(2); EXPECT_VALID;
+      ok(dst[0] == src[0],
+         "0x%02x, 0x%02x,0x%02x,0x%02x,\n", (unsigned char)src[0],
+         (unsigned char)dst[0],(unsigned char)dst[1],(unsigned char)dst[2]);
+    }
+  }
+
+  /* MAP_FOLDCZONE */
+  for (i = 1; i < 256; i++)
+  {
+    src[0] = i;
+    src[1] = '\0';
+    SetLastError(0);
+    ret = FoldStringA(MAP_FOLDCZONE, src, -1, dst, 256);
+    EXPECT_LEN(2); EXPECT_VALID;
+    ok(src[0] == dst[0],
+       "MAP_FOLDCZONE: Expected 0x%02x, got 0x%02x\n",
+       (unsigned char)src[0], (unsigned char)dst[0]);
+  }
+
+  /* MAP_PRECOMPOSED */
+  for (i = 1; i < 256; i++)
+  {
+    src[0] = i;
+    src[1] = '\0';
+    SetLastError(0);
+    ret = FoldStringA(MAP_PRECOMPOSED, src, -1, dst, 256);
+    EXPECT_LEN(2); EXPECT_VALID;
+    ok(src[0] == dst[0],
+       "MAP_PRECOMPOSED: Expected 0x%02x, got 0x%02x\n",
+       (unsigned char)src[0], (unsigned char)dst[0]);
+  }
+}
+
+void test_FoldStringW(void)
+{
+  int ret;
+  size_t i, j;
+  WCHAR src[256], dst[256], ch, prev_ch = 1;
+  static const DWORD badFlags[] =
+  {
+    0,
+    MAP_PRECOMPOSED|MAP_COMPOSITE,
+    MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES,
+    MAP_COMPOSITE|MAP_EXPAND_LIGATURES
+  };
+  /* Ranges of digits 0-9 : Must be sorted! */
+  static const WCHAR digitRanges[] =
+  {
+    0x0030, /* '0'-'9' */
+    0x0660, /* Eastern Arabic */
+    0x06F0, /* Arabic - Hindu */
+    0x0966, /* Devengari */
+    0x09E6, /* Bengalii */
+    0x0A66, /* Gurmukhi */
+    0x0AE6, /* Gujarati */
+    0x0B66, /* Oriya */
+    0x0BE6, /* Tamil - No 0 */
+    0x0C66, /* Telugu */
+    0x0CE6, /* Kannada */
+    0x0D66, /* Maylayalam */
+    0x0E50, /* Thai */
+    0x0ED0, /* Laos */
+    0x2070, /* Superscript - 1, 2, 3 are out of sequence */
+    0x2080, /* Subscript */
+    0x245F, /* Circled - 0 is out of sequence */
+    0x2473, /* Bracketed */
+    0x2487, /* Full stop */
+    0x2775, /* Inverted circled - No 0 */
+    0x277F, /* Patterned circled - No 0 */
+    0x2789, /* Inverted Patterned circled - No 0 */
+    0xff10, /* Pliene chasse (?) */
+    0xffff  /* Terminator */
+  };
+  /* Digits which are represented, but out of sequence */
+  static const WCHAR outOfSequenceDigits[] =
+  {
+      0xB9,   /* Superscript 1 */
+      0xB2,   /* Superscript 2 */
+      0xB3,   /* Superscript 3 */
+      0x24EA, /* Circled 0 */
+      '\0'    /* Terminator */
+  };
+  /* Digits in digitRanges for which no representation is available */
+  static const WCHAR noDigitAvailable[] =
+  {
+      0x0BE6, /* No Tamil 0 */
+      0x2473, /* No Bracketed 0 */
+      0x2487, /* No 0 Full stop */
+      0x2775, /* No inverted circled 0 */
+      0x277F, /* No patterned circled */
+      0x2789, /* No inverted Patterned circled */
+      '\0'    /* Terminator */
+  };
+  /* Compatability conversion results */
+  static const WCHAR compat_F900_FA2F[256+48] =
+  {
+      0x8c48, 0x66f4, 0x8eca, 0x8cc8, 0x6ed1, 0x4e32, 0x53e5, 0x9f9c,
+      0x9f9c, 0x5951, 0x91d1, 0x5587, 0x5948, 0x61f6, 0x7669, 0x7f85,
+      0x863f, 0x87ba, 0x88f8, 0x908f, 0x6a02, 0x6d1b, 0x70d9, 0x73de,
+      0x843d, 0x916a, 0x99f1, 0x4e82, 0x5375, 0x6b04, 0x721b, 0x862d,
+      0x9e1e, 0x5d50, 0x6feb, 0x85cd, 0x8964, 0x62c9, 0x81d8, 0x881f,
+      0x5eca, 0x6717, 0x6d6a, 0x72fc, 0x0000, 0x4f86, 0x51b7, 0x52de,
+      0x64c4, 0x6ad3, 0x7210, 0x76e7, 0x8001, 0x8606, 0x865c, 0x8def,
+      0x9732, 0x9b6f, 0x9dfa, 0x788c, 0x797f, 0x7da0, 0x83c9, 0x9304,
+      0x9e7f, 0x8ad6, 0x58df, 0x5f04, 0x7c60, 0x807e, 0x7262, 0x78ca,
+      0x8cc2, 0x96f7, 0x58d8, 0x5c62, 0x6a13, 0x6dda, 0x6f0f, 0x7d2f,
+      0x7e37, 0x964b, 0x52d2, 0x808b, 0x51dc, 0x51cc, 0x7a1c, 0x7dbe,
+      0x83f1, 0x9675, 0x8b80, 0x62cf, 0x6a02, 0x8afe, 0x4e39, 0x5be7,
+      0x6012, 0x7387, 0x7570, 0x5317, 0x78fb, 0x4fbf, 0x5fa9, 0x4e0d,
+      0x6ccc, 0x6578, 0x7d22, 0x53c3, 0x585e, 0x7701, 0x8449, 0x8aaa,
+      0x6bba, 0x8fb0, 0x6c88, 0x62fe, 0x82e5, 0x63a0, 0x7565, 0x4eae,
+      0x5169, 0x0000, 0x6881, 0x7ce7, 0x826f, 0x8ad2, 0x91cf, 0x52f5,
+      0x5442, 0x5973, 0x5eec, 0x65c5, 0x6ffe, 0x792a, 0x95ad, 0x9a6a,
+      0x9e97, 0x9ece, 0x529b, 0x66c6, 0x6b77, 0x8f62, 0x5e74, 0x6190,
+      0x6200, 0x649a, 0x6f23, 0x7149, 0x7489, 0x0000, 0x7df4, 0x806f,
+      0x8f26, 0x84ee, 0x9023, 0x934a, 0x5217, 0x52a3, 0x54bd, 0x70c8,
+      0x88c2, 0x8aaa, 0x5ec9, 0x5ff5, 0x637b, 0x6bae, 0x7c3e, 0x7375,
+      0x4ee4, 0x56f9, 0x5be7, 0x5dba, 0x601c, 0x73b2, 0x7469, 0x7f9a,
+      0x8046, 0x9234, 0x96f6, 0x9748, 0x9818, 0x4f8b, 0x79ae, 0x91b4,
+      0x96b8, 0x60e1, 0x4e86, 0x50da, 0x5bee, 0x5c3f, 0x6599, 0x6a02,
+      0x71ce, 0x7642, 0x84fc, 0x907c, 0x9f8d, 0x6688, 0x962e, 0x5289,
+      0x677b, 0x67f3, 0x6d41, 0x6e9c, 0x7409, 0x7559, 0x786b, 0x7d10,
+      0x985e, 0x516d, 0x622e, 0x9678, 0x502b, 0x5d19, 0x6dea, 0x8f2a,
+      0x5f8b, 0x6144, 0x6817, 0x7387, 0x9686, 0x5229, 0x540f, 0x5c65,
+      0x6613, 0x674e, 0x68a8, 0x6ce5, 0x7406, 0x75e2, 0x7f79, 0x0000,
+      0x88e1, 0x91cc, 0x96e2, 0x533f, 0x6eba, 0x541d, 0x71d0, 0x7498,
+      0x85fa, 0x0000, 0x9c57, 0x9e9f, 0x6797, 0x6dcb, 0x81e8, 0x7acb,
+      0x7b20, 0x7c92, 0x72c0, 0x7099, 0x8b58, 0x4ec0, 0x8336, 0x523a,
+      0x5207, 0x5ea6, 0x62d3, 0x7cd6, 0x5b85, 0x6d1e, 0x66b4, 0x8f3b,
+      0x884c, 0x964d, 0x898b, 0x5ed3, 0x0000, 0x0000, 0x0000, 0x0000,
+      0x585a, 0x0000, 0x6674, 0x0000, 0x0000, 0x51de, 0x8c6c, 0x76ca,
+      0x0000, 0x795e, 0x7965, 0x798f, 0x9756, 0x7cbe, 0x7fbd, 0x0000,
+      0x0000, 0x0000, 0x8af8, 0x0000, 0x0000, 0x9038, 0x90fd, 0x0000,
+      0x0000, 0x0000, 0x98ef, 0x98fc, 0x9928, 0x9db4, 0x0000, 0x0000
+  };
+  static const WCHAR compat_FE30_FEF7[200] =
+  {
+      0x2025, 0x2014, 0x2013, 0x005f, 0x005f, 0x0028, 0x0029, 0x007b,
+      0x007d, 0x3014, 0x3015, 0x3010, 0x3011, 0x300a, 0x300b, 0x3008,
+      0x3009, 0x300c, 0x300d, 0x300e, 0x300f, 0x0000, 0x0000, 0x0000,
+      0x0000, 0x203e, 0x203e, 0x203e, 0x203e, 0x005f, 0x005f, 0x005f,
+      0x002c, 0x3001, 0x002e, 0x0000, 0x003b, 0x003a, 0x003f, 0x0021,
+      0x2014, 0x0028, 0x0029, 0x007b, 0x007d, 0x3014, 0x3015, 0x0023,
+      0x0026, 0x002a, 0x002b, 0x002d, 0x003c, 0x003e, 0x003d, 0x0000,
+      0x0000, 0x0024, 0x0025, 0x0040, 0x0000, 0x0000, 0x0000, 0x0000,
+      0x064b, 0x064b, 0x064c, 0x0000, 0x064d, 0x0000, 0x064e, 0x064e,
+      0x064f, 0x064f, 0x0650, 0x0650, 0x0651, 0x0651, 0x0652, 0x0652,
+      0x0621, 0x0622, 0x0622, 0x0623, 0x0623, 0x0624, 0x0624, 0x0625,
+      0x0625, 0x0626, 0x0626, 0x0626, 0x0626, 0x0627, 0x0627, 0x0628,
+      0x0628, 0x0628, 0x0628, 0x0629, 0x0629, 0x062a, 0x062a, 0x062a,
+      0x062a, 0x062b, 0x062b, 0x062b, 0x062b, 0x062c, 0x062c, 0x062c,
+      0x062c, 0x062d, 0x062d, 0x062d, 0x062d, 0x062e, 0x062e, 0x062e,
+      0x062e, 0x062f, 0x062f, 0x0630, 0x0630, 0x0631, 0x0631, 0x0632,
+      0x0632, 0x0633, 0x0633, 0x0633, 0x0633, 0x0634, 0x0634, 0x0634,
+      0x0634, 0x0635, 0x0635, 0x0635, 0x0635, 0x0636, 0x0636, 0x0636,
+      0x0636, 0x0637, 0x0637, 0x0637, 0x0637, 0x0638, 0x0638, 0x0638,
+      0x0638, 0x0639, 0x0639, 0x0639, 0x0639, 0x063a, 0x063a, 0x063a,
+      0x063a, 0x0641, 0x0641, 0x0641, 0x0641, 0x0642, 0x0642, 0x0642,
+      0x0642, 0x0643, 0x0643, 0x0643, 0x0643, 0x0644, 0x0644, 0x0644,
+      0x0644, 0x0645, 0x0645, 0x0645, 0x0645, 0x0646, 0x0646, 0x0646,
+      0x0646, 0x0647, 0x0647, 0x0647, 0x0647, 0x0648, 0x0648, 0x0649,
+      0x0649, 0x064a, 0x064a, 0x064a, 0x064a, 0x0000, 0x0000, 0x0000
+  };
+  static const WCHAR compat_FF00_FFEF[240] =
+  {
+      0x0000, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
+      0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
+      0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
+      0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
+      0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
+      0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
+      0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
+      0x0058, 0x0059, 0x005a, 0x005b, 0x0000, 0x005d, 0x005e, 0x005f,
+      0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
+      0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
+      0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
+      0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x0000,
+      0x0000, 0x3002, 0x300c, 0x300d, 0x3001, 0x30fb, 0x30f2, 0x30a1,
+      0x30a3, 0x30a5, 0x30a7, 0x30a9, 0x30e3, 0x30e5, 0x30e7, 0x30c3,
+      0x30fc, 0x30a2, 0x30a4, 0x30a6, 0x30a8, 0x30aa, 0x30ab, 0x30ad,
+      0x30af, 0x30b1, 0x30b3, 0x30b5, 0x30b7, 0x30b9, 0x30bb, 0x30bd,
+      0x30bf, 0x30c1, 0x30c4, 0x30c6, 0x30c8, 0x30ca, 0x30cb, 0x30cc,
+      0x30cd, 0x30ce, 0x30cf, 0x30d2, 0x30d5, 0x30d8, 0x30db, 0x30de,
+      0x30df, 0x30e0, 0x30e1, 0x30e2, 0x30e4, 0x30e6, 0x30e8, 0x30e9,
+      0x30ea, 0x30eb, 0x30ec, 0x30ed, 0x30ef, 0x30f3, 0x309b, 0x309c,
+      0x3164, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136, 0x3137,
+      0x3138, 0x3139, 0x313a, 0x313b, 0x313c, 0x313d, 0x313e, 0x313f,
+      0x3140, 0x3141, 0x3142, 0x3143, 0x3144, 0x3145, 0x3146, 0x3147,
+      0x3148, 0x3149, 0x314a, 0x314b, 0x314c, 0x314d, 0x314e, 0x0000,
+      0x0000, 0x0000, 0x314f, 0x3150, 0x3151, 0x3152, 0x3153, 0x3154,
+      0x0000, 0x0000, 0x3155, 0x3156, 0x3157, 0x3158, 0x3159, 0x315a,
+      0x0000, 0x0000, 0x315b, 0x315c, 0x315d, 0x315e, 0x315f, 0x3160,
+      0x0000, 0x0000, 0x3161, 0x3162, 0x3163, 0x0000, 0x0000, 0x0000,
+      0x00a2, 0x00a3, 0x00ac, 0x00af, 0x00a6, 0x00a5, 0x20a9, 0x0000,
+      0x2502, 0x2190, 0x2191, 0x2192, 0x2193, 0x25a0, 0x25cb, 0x0000
+  };
+  static const WCHAR ligatures_src[] =
+  {
+    0x00c6, 0x00de, 0x00df, 0x00e6, 0x00fe, 0x0132, 0x0133, 0x0152,
+    0x0153, 0x01c4, 0x01c5, 0x01c6, 0x01c7, 0x01c8, 0x01c9, 0x01ca,
+    0x01cb, 0x01cc, 0x01e2, 0x01e3, 0x01f1, 0x01f2, 0x01f3, 0x01fc,
+    0x01fd, 0x05f0, 0x05f1, 0x05f2, 0xfb00, 0xfb01, 0xfb02, 0xfb03,
+    0xfb04, 0xfb05, 0xfb06, '\0'
+  };
+  static const WCHAR ligatures_dst[] =
+  {
+    'A','E','T','H','s','s','a','e','t','h','I','J','i','j','O','E','o','e',
+    'D',0x017d,'D',0x017e,'d',0x017e,'L','J','L','j','l','j','N','J','N','j',
+    'n','j',0x0100,0x0112,0x0101,0x0113,'D','Z','D','z','d','z',0x00c1,0x00c9,
+    0x00e1,0x00e9,0x05d5,0x05d5,0x05d5,0x05d9,0x05d9,0x05d9,'f','f','f','i',
+    'f','l','f','f','i','f','f','l',0x017f,'t','s','t','\0'
+  };
+
+  if (!pFoldStringW)
+    return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
+
+  /* Invalid flag combinations */
+  for (i = 0; i < sizeof(badFlags)/sizeof(badFlags[0]); i++)
+  {
+    src[0] = dst[0] = '\0';
+    SetLastError(0);
+    ret = pFoldStringW(badFlags[i], src, 256, dst, 256);
+    EXPECT_LEN(0); EXPECT_FLAGS;
+  }
+
+  /* src & dst cannot be the same */
+  SetLastError(0);
+  ret = pFoldStringW(MAP_FOLDCZONE, src, -1, src, 256);
+  EXPECT_LEN(0); EXPECT_INVALID;
+
+  /* src can't be NULL */
+  SetLastError(0);
+  ret = pFoldStringW(MAP_FOLDCZONE, NULL, -1, dst, 256);
+  EXPECT_LEN(0); EXPECT_INVALID;
+
+  /* srclen can't be 0 */
+  SetLastError(0);
+  ret = pFoldStringW(MAP_FOLDCZONE, src, 0, dst, 256);
+  EXPECT_LEN(0); EXPECT_INVALID;
+
+  /* dstlen can't be < 0 */
+  SetLastError(0);
+  ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, -1);
+  EXPECT_LEN(0); EXPECT_INVALID;
+
+  /* Ret includes terminating NUL which is appended if srclen = -1 */
+  SetLastError(0);
+  src[0] = 'A';
+  src[1] = '\0';
+  dst[0] = '\0';
+  ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, 256);
+  EXPECT_LEN(2); EXPECT_VALID;
+  ok(dst[0] == 'A' && dst[1] == '\0',
+     "srclen=-1: Expected ret=2 [%d,%d], got ret=%d [%d,%d], err=%ld\n",
+     'A', '\0', ret, dst[0], dst[1], GetLastError());
+
+  /* If size is given, result is not NUL terminated */
+  SetLastError(0);
+  src[0] = 'A';
+  src[1] = 'A';
+  dst[0] = 'X';
+  dst[1] = 'X';
+  ret = pFoldStringW(MAP_FOLDCZONE, src, 1, dst, 256);
+  EXPECT_LEN(1); EXPECT_VALID;
+  ok(dst[0] == 'A' && dst[1] == 'X',
+     "srclen=1: Expected ret=1, [%d,%d], got ret=%d,[%d,%d], err=%ld\n",
+     'A','X', ret, dst[0], dst[1], GetLastError());
+
+  /* MAP_FOLDDIGITS */
+  for (j = 0; j < sizeof(digitRanges)/sizeof(digitRanges[0]); j++)
+  {
+    /* Check everything before this range */
+    for (ch = prev_ch; ch < digitRanges[j]; ch++)
+    {
+      SetLastError(0);
+      src[0] = ch;
+      src[1] = dst[0] = '\0';
+      ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
+      EXPECT_LEN(2); EXPECT_VALID;
+
+      ok(dst[0] == ch || strchrW(outOfSequenceDigits, ch) ||
+         /* Wine (correctly) maps all Unicode 4.0+ digits */
+         isdigitW(ch) || (ch >= 0x24F5 && ch <= 0x24FD) || ch == 0x24FF,
+         "MAP_FOLDDIGITS: ch %d 0x%04x Expected unchanged got %d\n", ch, ch, dst[0]);
+    }
+
+    if (digitRanges[j] == 0xffff)
+      break; /* Finished the whole code point space */
+
+    for (ch = digitRanges[j]; ch < digitRanges[j] + 10; ch++)
+    {
+      WCHAR c;
+
+      /* Map out of sequence characters */
+      if      (ch == 0x2071) c = 0x00B9; /* Superscript 1 */
+      else if (ch == 0x2072) c = 0x00B2; /* Superscript 2 */
+      else if (ch == 0x2073) c = 0x00B3; /* Superscript 3 */
+      else if (ch == 0x245F) c = 0x24EA; /* Circled 0     */
+      else                   c = ch;
+      SetLastError(0);
+      src[0] = c;
+      src[1] = dst[0] = '\0';
+      ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
+      EXPECT_LEN(2); EXPECT_VALID;
+
+      ok((dst[0] == '0' + ch - digitRanges[j] && dst[1] == '\0') ||
+         strchrW(noDigitAvailable, c),
+         "MAP_FOLDDIGITS: ch %d Expected %d got %d\n",
+         ch, '0' + digitRanges[j] - ch, dst[0]);
+    }
+    prev_ch = ch;
+  }
+
+  /* MAP_FOLDCZONE */
+  for (ch = 1; ch <0xffff; ch++)
+  {
+    WCHAR expected = 0;
+
+    if (ch >= 0xF900 && ch <= 0xFA2F)
+      expected = compat_F900_FA2F[ch - 0xF900];
+    else if (ch >= 0xFE30 && ch <= 0xFEF7)
+      expected = compat_FE30_FEF7[ch - 0xFE30];
+    else if (ch >= 0xFF00 && ch <= 0xFFEF)
+      expected = compat_FF00_FFEF[ch - 0xFF00];
+
+    if (!expected)
+      expected = ch;
+
+    SetLastError(0);
+    src[0] = ch;
+    src[1] = dst[0] = '\0';
+    ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, 256);
+    EXPECT_LEN(2); EXPECT_VALID;
+    ok(dst[0] == expected ||
+       /* Wine (correctly) uses updated mappings for some Unicode 4.0 chars */
+       (ch >= 0xFA0D && ch <= 0xFA47) ||
+       0xf92c || ch == 0xf979 || ch == 0xf995 || ch == 0xf9e7 || ch == 0xf9f1,
+       "MAP_FOLDCZONE: ch %d 0x%04x Expected 0x%04x got 0x%04x\n",
+       ch, ch, expected, dst[0]);
+  }
+
+  /* MAP_EXPAND_LIGATURES */
+  SetLastError(0);
+  ret = pFoldStringW(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
+  EXPECT_LEN(73); EXPECT_VALID;
+  ok(!memcmp(dst, ligatures_dst, 71 * sizeof(WCHAR)),
+     "MAP_EXPAND_LIGATURES: Expanded incorrrectly\n");
+  for (i = 1; i <= 0xffff; i++)
+  {
+    if (!strchrW(ligatures_src, i))
+    {
+      src[0] = i;
+      src[1] = '\0';
+      SetLastError(0);
+      ret = pFoldStringW(MAP_EXPAND_LIGATURES, src, -1, dst, 256);
+      EXPECT_LEN(2); EXPECT_VALID;
+      ok(dst[0] == src[0],
+         "MAP_EXPAND_LIGATURES: 0x%02x : Expected 0x%02x, got 0x%02x\n",
+         i, src[0], dst[0]);
+    }
+  }
+
+  /* FIXME: MAP_PRECOMPOSED : MAP_COMPOSITE */
+}
+
+
+
 #define LCID_OK(l) \
   ok(lcid == l, "Expected lcid = %08lx, got %08lx\n", l, lcid)
 #define MKLCID(x,y,z) MAKELCID(MAKELANGID(x, y), z)
@@ -1197,6 +1678,8 @@
   test_CompareStringA();
   test_LCMapStringA();
   test_LCMapStringW();
+  test_FoldStringA();
+  test_FoldStringW();
   test_ConvertDefaultLocale();
   test_EnumSystemLanguageGroupsA();
   test_EnumLanguageGroupLocalesA();

[Index of Archives]     [Gimp for Windows]     [Red Hat]     [Samba]     [Yosemite Camping]     [Graphics Cards]     [Wine Home]

  Powered by Linux