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