src/mojo/common/common_type_converters_unittest.cc

   1 // Copyright 2013 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 "mojo/common/common_type_converters.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9 #include "url/gurl.h"
  10
  11 namespace mojo {
  12 namespace common {
  13 namespace test {
  14 namespace {
  15
  16 void ExpectEqualsStringPiece(const std::string& expected,
  17                              const base::StringPiece& str) {
  18   EXPECT_EQ(expected, str.as_string());
  19 }
  20
  21 void ExpectEqualsMojoString(const std::string& expected,
  22                             const String& str) {
  23   EXPECT_EQ(expected, str.get());
  24 }
  25
  26 void ExpectEqualsString16(const base::string16& expected,
  27                           const base::string16& actual) {
  28   EXPECT_EQ(expected, actual);
  29 }
  30
  31 void ExpectEqualsMojoString(const base::string16& expected,
  32                             const String& str) {
  33   EXPECT_EQ(expected, str.To<base::string16>());
  34 }
  35
  36 }  // namespace
  37
  38 TEST(CommonTypeConvertersTest, StringPiece) {
  39   std::string kText("hello world");
  40
  41   base::StringPiece string_piece(kText);
  42   String mojo_string(String::From(string_piece));
  43
  44   ExpectEqualsMojoString(kText, mojo_string);
  45   ExpectEqualsStringPiece(kText, mojo_string.To<base::StringPiece>());
  46
  47   // Test implicit construction and conversion:
  48   ExpectEqualsMojoString(kText, String::From(string_piece));
  49   ExpectEqualsStringPiece(kText, mojo_string.To<base::StringPiece>());
  50
  51   // Test null String:
  52   base::StringPiece empty_string_piece = String().To<base::StringPiece>();
  53   EXPECT_TRUE(empty_string_piece.empty());
  54 }
  55
  56 TEST(CommonTypeConvertersTest, String16) {
  57   const base::string16 string16(base::ASCIIToUTF16("hello world"));
  58   const String mojo_string(String::From(string16));
  59
  60   ExpectEqualsMojoString(string16, mojo_string);
  61   EXPECT_EQ(string16, mojo_string.To<base::string16>());
  62
  63   // Test implicit construction and conversion:
  64   ExpectEqualsMojoString(string16, String::From(string16));
  65   ExpectEqualsString16(string16, mojo_string.To<base::string16>());
  66
  67   // Test empty string conversion.
  68   ExpectEqualsMojoString(base::string16(), String::From(base::string16()));
  69 }
  70
  71 TEST(CommonTypeConvertersTest, URL) {
  72   GURL url("mojo:foo");
  73   String mojo_string(String::From(url));
  74
  75   ASSERT_EQ(url.spec(), mojo_string);
  76   EXPECT_EQ(url.spec(), mojo_string.To<GURL>().spec());
  77   EXPECT_EQ(url.spec(), String::From(url));
  78
  79   GURL invalid = String().To<GURL>();
  80   ASSERT_TRUE(invalid.spec().empty());
  81
  82   String string_from_invalid = String::From(invalid);
  83   EXPECT_FALSE(string_from_invalid.is_null());
  84   ASSERT_EQ(0U, string_from_invalid.size());
  85 }
  86
  87 TEST(CommonTypeConvertersTest, ArrayUint8ToStdString) {
  88   Array<uint8_t> data(4);
  89   data[0] = 'd';
  90   data[1] = 'a';
  91   data[2] = 't';
  92   data[3] = 'a';
  93
  94   EXPECT_EQ("data", data.To<std::string>());
  95 }
  96
  97 TEST(CommonTypeConvertersTest, StdStringToArrayUint8) {
  98   std::string input("data");
  99   Array<uint8_t> data = Array<uint8_t>::From(input);
 100
 101   ASSERT_EQ(4ul, data.size());
 102   EXPECT_EQ('d', data[0]);
 103   EXPECT_EQ('a', data[1]);
 104   EXPECT_EQ('t', data[2]);
 105   EXPECT_EQ('a', data[3]);
 106 }
 107
 108 }  // namespace test
 109 }  // namespace common
 110 }  // namespace mojo