ppapi/tests/test_char_set.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/tests/test_char_set.h"
   6
   7 #include "ppapi/c/dev/ppb_char_set_dev.h"
   8 #include "ppapi/c/trusted/ppb_char_set_trusted.h"
   9 #include "ppapi/cpp/dev/memory_dev.h"
  10 #include "ppapi/cpp/module.h"
  11 #include "ppapi/tests/testing_instance.h"
  12
  13 REGISTER_TEST_CASE(CharSet);
  14
  15 TestCharSet::TestCharSet(TestingInstance* instance)
  16     : TestCase(instance),
  17       char_set_interface_(NULL) {
  18 }
  19
  20 bool TestCharSet::Init() {
  21   char_set_interface_ = static_cast<const PPB_CharSet_Dev*>(
  22       pp::Module::Get()->GetBrowserInterface(PPB_CHAR_SET_DEV_INTERFACE));
  23   char_set_trusted_interface_ = static_cast<const PPB_CharSet_Trusted*>(
  24       pp::Module::Get()->GetBrowserInterface(PPB_CHARSET_TRUSTED_INTERFACE));
  25   return char_set_interface_ && char_set_trusted_interface_;
  26 }
  27
  28 void TestCharSet::RunTests(const std::string& filter) {
  29   RUN_TEST(UTF16ToCharSetDeprecated, filter);
  30   RUN_TEST(UTF16ToCharSet, filter);
  31   RUN_TEST(CharSetToUTF16Deprecated, filter);
  32   RUN_TEST(CharSetToUTF16, filter);
  33   RUN_TEST(GetDefaultCharSet, filter);
  34 }
  35
  36 // TODO(brettw) remove this when the old interface is removed.
  37 std::string TestCharSet::TestUTF16ToCharSetDeprecated() {
  38   // Empty string.
  39   std::vector<uint16_t> utf16;
  40   utf16.push_back(0);
  41   uint32_t utf8result_len = 0;
  42   pp::Memory_Dev memory;
  43   char* utf8result = char_set_interface_->UTF16ToCharSet(
  44       instance_->pp_instance(), &utf16[0], 0, "latin1",
  45       PP_CHARSET_CONVERSIONERROR_SUBSTITUTE, &utf8result_len);
  46   ASSERT_TRUE(utf8result);
  47   ASSERT_TRUE(utf8result[0] == 0);
  48   ASSERT_TRUE(utf8result_len == 0);
  49   memory.MemFree(utf8result);
  50
  51   // Try round-tripping some English & Chinese from UTF-8 through UTF-16
  52   std::string utf8source("Hello, world. \xe4\xbd\xa0\xe5\xa5\xbd");
  53   utf16 = UTF8ToUTF16(utf8source);
  54   utf8result = char_set_interface_->UTF16ToCharSet(
  55       instance_->pp_instance(), &utf16[0], static_cast<uint32_t>(utf16.size()),
  56       "Utf-8", PP_CHARSET_CONVERSIONERROR_FAIL, &utf8result_len);
  57   ASSERT_TRUE(utf8source == std::string(utf8result, utf8result_len));
  58   memory.MemFree(utf8result);
  59
  60   // Test an un-encodable character with various modes.
  61   utf16 = UTF8ToUTF16("h\xe4\xbd\xa0i");
  62
  63   // Fail mode.
  64   utf8result_len = 1234;  // Test that this gets 0'ed on failure.
  65   utf8result = char_set_interface_->UTF16ToCharSet(
  66       instance_->pp_instance(), &utf16[0], static_cast<uint32_t>(utf16.size()),
  67       "latin1", PP_CHARSET_CONVERSIONERROR_FAIL, &utf8result_len);
  68   ASSERT_TRUE(utf8result_len == 0);
  69   ASSERT_TRUE(utf8result == NULL);
  70
  71   // Skip mode.
  72   utf8result = char_set_interface_->UTF16ToCharSet(
  73       instance_->pp_instance(), &utf16[0], static_cast<uint32_t>(utf16.size()),
  74       "latin1", PP_CHARSET_CONVERSIONERROR_SKIP, &utf8result_len);
  75   ASSERT_TRUE(utf8result_len == 2);
  76   ASSERT_TRUE(utf8result[0] == 'h' && utf8result[1] == 'i' &&
  77               utf8result[2] == 0);
  78   memory.MemFree(utf8result);
  79
  80   // Substitute mode.
  81   utf8result = char_set_interface_->UTF16ToCharSet(
  82       instance_->pp_instance(), &utf16[0], static_cast<uint32_t>(utf16.size()),
  83       "latin1", PP_CHARSET_CONVERSIONERROR_SUBSTITUTE, &utf8result_len);
  84   ASSERT_TRUE(utf8result_len == 3);
  85   ASSERT_TRUE(utf8result[0] == 'h' && utf8result[1] == '?' &&
  86               utf8result[2] == 'i' && utf8result[3] == 0);
  87   memory.MemFree(utf8result);
  88
  89   // Try some invalid input encoding.
  90   utf16.clear();
  91   utf16.push_back(0xD800);  // High surrogate.
  92   utf16.push_back('A');  // Not a low surrogate.
  93   utf8result = char_set_interface_->UTF16ToCharSet(
  94       instance_->pp_instance(), &utf16[0], static_cast<uint32_t>(utf16.size()),
  95       "latin1", PP_CHARSET_CONVERSIONERROR_SUBSTITUTE, &utf8result_len);
  96   ASSERT_TRUE(utf8result_len == 2);
  97   ASSERT_TRUE(utf8result[0] == '?' && utf8result[1] == 'A' &&
  98               utf8result[2] == 0);
  99   memory.MemFree(utf8result);
 100
 101   // Invalid encoding name.
 102   utf8result = char_set_interface_->UTF16ToCharSet(
 103       instance_->pp_instance(), &utf16[0], static_cast<uint32_t>(utf16.size()),
 104       "poopiepants", PP_CHARSET_CONVERSIONERROR_SUBSTITUTE, &utf8result_len);
 105   ASSERT_TRUE(!utf8result);
 106   ASSERT_TRUE(utf8result_len == 0);
 107
 108   PASS();
 109 }
 110
 111 std::string TestCharSet::TestUTF16ToCharSet() {
 112   // Empty string.
 113   std::vector<uint16_t> utf16;
 114   utf16.push_back(0);
 115   std::string output_buffer;
 116   uint32_t utf8result_len = static_cast<uint32_t>(output_buffer.size());
 117   PP_Bool result = char_set_trusted_interface_->UTF16ToCharSet(
 118       &utf16[0], 0, "latin1", PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE,
 119       &output_buffer[0], &utf8result_len);
 120   ASSERT_TRUE(result == PP_TRUE);
 121   ASSERT_TRUE(utf8result_len == 0);
 122
 123   // No output buffer returns length of string.
 124   utf16 = UTF8ToUTF16("hello");
 125   utf8result_len = 0;
 126   result = char_set_trusted_interface_->UTF16ToCharSet(
 127       &utf16[0], static_cast<uint32_t>(utf16.size()), "latin1",
 128       PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE, NULL, &utf8result_len);
 129   ASSERT_TRUE(result == PP_TRUE);
 130   ASSERT_TRUE(utf8result_len == 5);
 131
 132   // Giving too small of a buffer just fills in that many items and gives us
 133   // the desired size.
 134   output_buffer.resize(100);
 135   utf8result_len = 2;
 136   output_buffer[utf8result_len] = '$';  // Barrier character.
 137   result = char_set_trusted_interface_->UTF16ToCharSet(
 138       &utf16[0], static_cast<uint32_t>(utf16.size()), "latin1",
 139       PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE,
 140       &output_buffer[0], &utf8result_len);
 141   ASSERT_TRUE(result == PP_TRUE);
 142   ASSERT_TRUE(utf8result_len == 5);
 143   ASSERT_TRUE(output_buffer[0] == 'h' && output_buffer[1] == 'e' &&
 144               output_buffer[2] == '$');
 145
 146   // Try round-tripping some English & Chinese from UTF-8 through UTF-16
 147   std::string utf8source("Hello, world. \xe4\xbd\xa0\xe5\xa5\xbd");
 148   utf16 = UTF8ToUTF16(utf8source);
 149   output_buffer.resize(100);
 150   utf8result_len = static_cast<uint32_t>(output_buffer.size());
 151   result = char_set_trusted_interface_->UTF16ToCharSet(
 152       &utf16[0], static_cast<uint32_t>(utf16.size()),
 153       "Utf-8", PP_CHARSET_TRUSTED_CONVERSIONERROR_FAIL,
 154       &output_buffer[0], &utf8result_len);
 155   ASSERT_TRUE(result == PP_TRUE);
 156   output_buffer.resize(utf8result_len);
 157   ASSERT_TRUE(utf8source == output_buffer);
 158
 159   // Test an un-encodable character with various modes.
 160   utf16 = UTF8ToUTF16("h\xe4\xbd\xa0i");
 161
 162   // Fail mode, size should get 0'ed on failure.
 163   output_buffer.resize(100);
 164   utf8result_len = static_cast<uint32_t>(output_buffer.size());
 165   result = char_set_trusted_interface_->UTF16ToCharSet(
 166       &utf16[0], static_cast<uint32_t>(utf16.size()),
 167       "latin1", PP_CHARSET_TRUSTED_CONVERSIONERROR_FAIL,
 168       &output_buffer[0], &utf8result_len);
 169   ASSERT_TRUE(result == PP_FALSE);
 170   ASSERT_TRUE(utf8result_len == 0);
 171
 172   // Skip mode.
 173   output_buffer.resize(100);
 174   utf8result_len = static_cast<uint32_t>(output_buffer.size());
 175   result = char_set_trusted_interface_->UTF16ToCharSet(
 176       &utf16[0], static_cast<uint32_t>(utf16.size()),
 177       "latin1", PP_CHARSET_TRUSTED_CONVERSIONERROR_SKIP,
 178       &output_buffer[0], &utf8result_len);
 179   ASSERT_TRUE(result == PP_TRUE);
 180   ASSERT_TRUE(utf8result_len == 2);
 181   ASSERT_TRUE(output_buffer[0] == 'h' && output_buffer[1] == 'i');
 182
 183   // Substitute mode.
 184   output_buffer.resize(100);
 185   utf8result_len = static_cast<uint32_t>(output_buffer.size());
 186   result = char_set_trusted_interface_->UTF16ToCharSet(
 187       &utf16[0], static_cast<uint32_t>(utf16.size()),
 188       "latin1", PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE,
 189       &output_buffer[0], &utf8result_len);
 190   ASSERT_TRUE(utf8result_len == 3);
 191   output_buffer.resize(utf8result_len);
 192   ASSERT_TRUE(output_buffer == "h?i");
 193
 194   // Try some invalid input encoding.
 195   output_buffer.resize(100);
 196   utf8result_len = static_cast<uint32_t>(output_buffer.size());
 197   utf16.clear();
 198   utf16.push_back(0xD800);  // High surrogate.
 199   utf16.push_back('A');  // Not a low surrogate.
 200   result = char_set_trusted_interface_->UTF16ToCharSet(
 201       &utf16[0], static_cast<uint32_t>(utf16.size()),
 202       "latin1", PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE,
 203       &output_buffer[0], &utf8result_len);
 204   ASSERT_TRUE(utf8result_len == 2);
 205   ASSERT_TRUE(output_buffer[0] == '?' && output_buffer[1] == 'A');
 206
 207   // Invalid encoding name.
 208   output_buffer.resize(100);
 209   utf8result_len = static_cast<uint32_t>(output_buffer.size());
 210   result = char_set_trusted_interface_->UTF16ToCharSet(
 211       &utf16[0], static_cast<uint32_t>(utf16.size()),
 212       "poopiepants", PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE,
 213       &output_buffer[0], &utf8result_len);
 214   ASSERT_TRUE(result == PP_FALSE);
 215   ASSERT_TRUE(utf8result_len == 0);
 216
 217   PASS();
 218 }
 219
 220 // TODO(brettw) remove this when the old interface is removed.
 221 std::string TestCharSet::TestCharSetToUTF16Deprecated() {
 222   pp::Memory_Dev memory;
 223
 224   // Empty string.
 225   uint32_t utf16result_len;
 226   uint16_t* utf16result = char_set_interface_->CharSetToUTF16(
 227       instance_->pp_instance(), "", 0, "latin1",
 228       PP_CHARSET_CONVERSIONERROR_FAIL, &utf16result_len);
 229   ASSERT_TRUE(utf16result);
 230   ASSERT_TRUE(utf16result_len == 0);
 231   ASSERT_TRUE(utf16result[0] == 0);
 232   memory.MemFree(utf16result);
 233
 234   // Basic Latin1.
 235   char latin1[] = "H\xef";
 236   utf16result = char_set_interface_->CharSetToUTF16(
 237       instance_->pp_instance(), latin1, 2, "latin1",
 238       PP_CHARSET_CONVERSIONERROR_FAIL, &utf16result_len);
 239   ASSERT_TRUE(utf16result);
 240   ASSERT_TRUE(utf16result_len == 2);
 241   ASSERT_TRUE(utf16result[0] == 'H' && utf16result[1] == 0xef &&
 242               utf16result[2] == 0);
 243   memory.MemFree(utf16result);
 244
 245   // Invalid input encoding with FAIL.
 246   char badutf8[] = "A\xe4Z";
 247   utf16result = char_set_interface_->CharSetToUTF16(
 248       instance_->pp_instance(), badutf8, 3, "utf8",
 249       PP_CHARSET_CONVERSIONERROR_FAIL, &utf16result_len);
 250   ASSERT_TRUE(!utf16result);
 251   ASSERT_TRUE(utf16result_len == 0);
 252   memory.MemFree(utf16result);
 253
 254   // Invalid input with SKIP.
 255   utf16result = char_set_interface_->CharSetToUTF16(
 256       instance_->pp_instance(), badutf8, 3, "utf8",
 257       PP_CHARSET_CONVERSIONERROR_SKIP, &utf16result_len);
 258   ASSERT_TRUE(utf16result);
 259   ASSERT_TRUE(utf16result_len == 2);
 260   ASSERT_TRUE(utf16result[0] == 'A' && utf16result[1] == 'Z' &&
 261               utf16result[2] == 0);
 262   memory.MemFree(utf16result);
 263
 264   // Invalid input with SUBSTITUTE.
 265   utf16result = char_set_interface_->CharSetToUTF16(
 266       instance_->pp_instance(), badutf8, 3, "utf8",
 267       PP_CHARSET_CONVERSIONERROR_SUBSTITUTE, &utf16result_len);
 268   ASSERT_TRUE(utf16result);
 269   ASSERT_TRUE(utf16result_len == 3);
 270   ASSERT_TRUE(utf16result[0] == 'A' && utf16result[1] == 0xFFFD &&
 271               utf16result[2] == 'Z' && utf16result[3] == 0);
 272   memory.MemFree(utf16result);
 273
 274   // Invalid encoding name.
 275   utf16result = char_set_interface_->CharSetToUTF16(
 276       instance_->pp_instance(), badutf8, 3, "poopiepants",
 277       PP_CHARSET_CONVERSIONERROR_SUBSTITUTE, &utf16result_len);
 278   ASSERT_TRUE(!utf16result);
 279   ASSERT_TRUE(utf16result_len == 0);
 280   memory.MemFree(utf16result);
 281
 282   PASS();
 283 }
 284
 285 std::string TestCharSet::TestCharSetToUTF16() {
 286   std::vector<uint16_t> output_buffer;
 287   output_buffer.resize(100);
 288
 289   // Empty string.
 290   output_buffer.resize(100);
 291   uint32_t utf16result_len = static_cast<uint32_t>(output_buffer.size());
 292   PP_Bool result = char_set_trusted_interface_->CharSetToUTF16(
 293       "", 0, "latin1", PP_CHARSET_TRUSTED_CONVERSIONERROR_FAIL,
 294       &output_buffer[0], &utf16result_len);
 295   ASSERT_TRUE(result);
 296   ASSERT_TRUE(utf16result_len == 0);
 297   ASSERT_TRUE(output_buffer[0] == 0);
 298
 299   // Basic Latin1.
 300   output_buffer.resize(100);
 301   utf16result_len = static_cast<uint32_t>(output_buffer.size());
 302   char latin1[] = "H\xef";
 303   result = char_set_trusted_interface_->CharSetToUTF16(
 304       latin1, 2, "latin1", PP_CHARSET_TRUSTED_CONVERSIONERROR_FAIL,
 305       &output_buffer[0], &utf16result_len);
 306   ASSERT_TRUE(result);
 307   ASSERT_TRUE(utf16result_len == 2);
 308   ASSERT_TRUE(output_buffer[0] == 'H' && output_buffer[1] == 0xef);
 309
 310   // Invalid input encoding with FAIL.
 311   output_buffer.resize(100);
 312   utf16result_len = static_cast<uint32_t>(output_buffer.size());
 313   char badutf8[] = "A\xe4Z";
 314   result = char_set_trusted_interface_->CharSetToUTF16(
 315       badutf8, 3, "utf8", PP_CHARSET_TRUSTED_CONVERSIONERROR_FAIL,
 316       &output_buffer[0], &utf16result_len);
 317   ASSERT_TRUE(!result);
 318   ASSERT_TRUE(utf16result_len == 0);
 319
 320   // Invalid input with SKIP.
 321   output_buffer.resize(100);
 322   utf16result_len = static_cast<uint32_t>(output_buffer.size());
 323   result = char_set_trusted_interface_->CharSetToUTF16(
 324       badutf8, 3, "utf8", PP_CHARSET_TRUSTED_CONVERSIONERROR_SKIP,
 325       &output_buffer[0], &utf16result_len);
 326   ASSERT_TRUE(result);
 327   ASSERT_TRUE(utf16result_len == 2);
 328   ASSERT_TRUE(output_buffer[0] == 'A' && output_buffer[1] == 'Z');
 329
 330   // Invalid input with SUBSTITUTE.
 331   output_buffer.resize(100);
 332   utf16result_len = static_cast<uint32_t>(output_buffer.size());
 333   result = char_set_trusted_interface_->CharSetToUTF16(
 334       badutf8, 3, "utf8", PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE,
 335       &output_buffer[0], &utf16result_len);
 336   ASSERT_TRUE(result);
 337   ASSERT_TRUE(utf16result_len == 3);
 338   ASSERT_TRUE(output_buffer[0] == 'A' && output_buffer[1] == 0xFFFD &&
 339               output_buffer[2] == 'Z');
 340
 341   // Invalid encoding name.
 342   output_buffer.resize(100);
 343   utf16result_len = static_cast<uint32_t>(output_buffer.size());
 344   result = char_set_trusted_interface_->CharSetToUTF16(
 345       badutf8, 3, "poopiepants", PP_CHARSET_TRUSTED_CONVERSIONERROR_SUBSTITUTE,
 346       &output_buffer[0], &utf16result_len);
 347   ASSERT_TRUE(!result);
 348   ASSERT_TRUE(utf16result_len == 0);
 349
 350   PASS();
 351 }
 352
 353 std::string TestCharSet::TestGetDefaultCharSet() {
 354   // Test invalid instance.
 355   pp::Var result(pp::PASS_REF, char_set_interface_->GetDefaultCharSet(0));
 356   ASSERT_TRUE(result.is_undefined());
 357
 358   // Just make sure the default char set is a nonempty string.
 359   result = pp::Var(pp::PASS_REF,
 360       char_set_interface_->GetDefaultCharSet(instance_->pp_instance()));
 361   ASSERT_TRUE(result.is_string());
 362   ASSERT_FALSE(result.AsString().empty());
 363
 364   PASS();
 365 }
 366
 367 std::vector<uint16_t> TestCharSet::UTF8ToUTF16(const std::string& utf8) {
 368   uint32_t result_len = 0;
 369   uint16_t* result = char_set_interface_->CharSetToUTF16(
 370       instance_->pp_instance(), utf8.c_str(),
 371       static_cast<uint32_t>(utf8.size()),
 372       "utf-8", PP_CHARSET_CONVERSIONERROR_FAIL, &result_len);
 373
 374   std::vector<uint16_t> result_vector;
 375   if (!result)
 376     return result_vector;
 377
 378   result_vector.assign(result, &result[result_len]);
 379   pp::Memory_Dev memory;
 380   memory.MemFree(result);
 381   return result_vector;
 382 }