blob: 1b4402902fdbdefd39d5716a5287ea25a0236f3a [file] [log] [blame]
// Copyright (C) 2011 The Libphonenumber Authors
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
// Author: Philippe Liard
#include "phonenumbers/stringutil.h"
#include <string>
#include <vector>
#include <gtest/gtest.h>
using std::string;
using std::vector;
namespace i18n {
namespace phonenumbers {
// Test operator+(const string&, int).
TEST(StringUtilTest, OperatorPlus) {
EXPECT_EQ("hello10", string("hello") + 10);
// Test SimpleItoa implementation.
TEST(StringUtilTest, SimpleItoa) {
EXPECT_EQ("10", SimpleItoa(10));
TEST(StringUtilTest, HasPrefixString) {
EXPECT_TRUE(HasPrefixString("hello world", "hello"));
EXPECT_FALSE(HasPrefixString("hello world", "hellO"));
TEST(StringUtilTest, FindNthWithEmptyString) {
EXPECT_EQ(string::npos, FindNth("", 'a', 1));
TEST(StringUtilTest, FindNthWithNNegative) {
EXPECT_EQ(string::npos, FindNth("hello world", 'o', -1));
TEST(StringUtilTest, FindNthWithNTooHigh) {
EXPECT_EQ(string::npos, FindNth("hello world", 'o', 3));
TEST(StringUtilTest, FindNth) {
EXPECT_EQ(7U, FindNth("hello world", 'o', 2));
TEST(StringUtilTest, SplitStringUsingWithEmptyString) {
vector<string> result;
SplitStringUsing("", ":", &result);
EXPECT_EQ(0U, result.size());
TEST(StringUtilTest, SplitStringUsingWithEmptyDelimiter) {
vector<string> result;
SplitStringUsing("hello", "", &result);
EXPECT_EQ(0U, result.size());
TEST(StringUtilTest, SplitStringUsing) {
vector<string> result;
SplitStringUsing(":hello:world:", ":", &result);
EXPECT_EQ(2U, result.size());
EXPECT_EQ("hello", result[0]);
EXPECT_EQ("world", result[1]);
TEST(StringUtilTest, SplitStringUsingIgnoresEmptyToken) {
vector<string> result;
SplitStringUsing("hello::world", ":", &result);
EXPECT_EQ(2U, result.size());
EXPECT_EQ("hello", result[0]);
EXPECT_EQ("world", result[1]);
// Test TryStripPrefixString.
TEST(StringUtilTest, TryStripPrefixString) {
string s;
EXPECT_TRUE(TryStripPrefixString("hello world", "hello", &s));
EXPECT_EQ(" world", s);
EXPECT_FALSE(TryStripPrefixString("hello world", "helloa", &s));
EXPECT_TRUE(TryStripPrefixString("hello world", "", &s));
EXPECT_EQ("hello world", s);
EXPECT_FALSE(TryStripPrefixString("", "hello", &s));
// Test HasSuffixString.
TEST(StringUtilTest, HasSuffixString) {
EXPECT_TRUE(HasSuffixString("hello world", "hello world"));
EXPECT_TRUE(HasSuffixString("hello world", "world"));
EXPECT_FALSE(HasSuffixString("hello world", "world!"));
EXPECT_TRUE(HasSuffixString("hello world", ""));
EXPECT_FALSE(HasSuffixString("", "hello"));
// Test safe_strto32.
TEST(StringUtilTest, safe_strto32) {
int32 n;
safe_strto32("0", &n);
EXPECT_EQ(0, n);
safe_strto32("16", &n);
EXPECT_EQ(16, n);
safe_strto32("2147483647", &n);
EXPECT_EQ(2147483647, n);
safe_strto32("-2147483648", &n);
EXPECT_EQ(-2147483648LL, n);
// Test safe_strtou64.
TEST(StringUtilTest, safe_strtou64) {
uint64 n;
safe_strtou64("0", &n);
safe_strtou64("16", &n);
EXPECT_EQ(16U, n);
safe_strtou64("18446744073709551615UL", &n);
EXPECT_EQ(18446744073709551615ULL, n);
// Test strrmm.
TEST(StringUtilTest, strrmm) {
string input("hello");
strrmm(&input, "");
EXPECT_EQ(input, input);
string empty;
strrmm(&empty, "");
EXPECT_EQ("", empty);
strrmm(&empty, "aa");
EXPECT_EQ("", empty);
strrmm(&input, "h");
EXPECT_EQ("ello", input);
strrmm(&input, "el");
EXPECT_EQ("o", input);
// Test GlobalReplaceSubstring.
TEST(StringUtilTest, GlobalReplaceSubstring) {
string input("hello");
EXPECT_EQ(0, GlobalReplaceSubstring("aaa", "", &input));
EXPECT_EQ("hello", input);
EXPECT_EQ(0, GlobalReplaceSubstring("", "aaa", &input));
EXPECT_EQ("hello", input);
EXPECT_EQ(0, GlobalReplaceSubstring("", "", &input));
EXPECT_EQ("hello", input);
EXPECT_EQ(0, GlobalReplaceSubstring("aaa", "bbb", &input));
EXPECT_EQ("hello", input);
EXPECT_EQ(1, GlobalReplaceSubstring("o", "o world", &input));
ASSERT_EQ("hello world", input);
EXPECT_EQ(2, GlobalReplaceSubstring("o", "O", &input));
EXPECT_EQ("hellO wOrld", input);
// Test the StringHolder class.
TEST(StringUtilTest, StringHolder) {
// Test with C string.
static const char cstring[] = "aaa";
StringHolder sh1(cstring);
EXPECT_EQ(cstring, sh1.GetCString());
EXPECT_EQ(NULL, sh1.GetString());
// Test with std::string.
string s = "bbb";
StringHolder sh2(s);
EXPECT_EQ(NULL, sh2.GetCString());
EXPECT_EQ(&s, sh2.GetString());
// Test GetLength().
string s2 = "hello";
StringHolder sh3(s2);
EXPECT_EQ(5U, sh3.Length());
// Test with uint64.
StringHolder sh4(42);
EXPECT_TRUE(sh4.GetCString() == NULL);
EXPECT_EQ(2U, sh4.Length());
EXPECT_EQ("42", *sh4.GetString());
// Test the operator+=(string& lhs, const StringHolder& rhs) implementation.
TEST(StringUtilTest, OperatorPlusEquals) {
// Test with a const char* string to append.
string s = "h";
static const char append1[] = "ello";
s += StringHolder(append1); // force StringHolder usage
EXPECT_EQ("hello", s);
// Test with a std::string to append.
s = "h";
string append2 = "ello";
s += StringHolder(append2); // force StringHolder usage
EXPECT_EQ("hello", s);
// Test the StrCat implementations
TEST(StringUtilTest, StrCat) {
string s;
// Test with 2 arguments.
s = StrCat("a", "b");
EXPECT_EQ("ab", s);
// Test with 3 arguments.
s = StrCat("a", "b", "c");
EXPECT_EQ("abc", s);
// Test with 4 arguments.
s = StrCat("a", "b", "c", "d");
EXPECT_EQ("abcd", s);
// Test with 5 arguments.
s = StrCat("a", "b", "c", "d", "e");
EXPECT_EQ("abcde", s);
// Test with 6 arguments.
s = StrCat("a", "b", "c", "d", "e", "f");
EXPECT_EQ("abcdef", s);
// Test with 7 arguments.
s = StrCat("a", "b", "c", "d", "e", "f", "g");
EXPECT_EQ("abcdefg", s);
// Test with 8 arguments.
s = StrCat("a", "b", "c", "d", "e", "f", "g", "h");
EXPECT_EQ("abcdefgh", s);
// Test with 9 arguments.
s = StrCat("a", "b", "c", "d", "e", "f", "g", "h", "i");
EXPECT_EQ("abcdefghi", s);
// Test with 11 arguments.
s = StrCat("a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k");
EXPECT_EQ("abcdefghijk", s);
// Test the StrAppend implementations.
TEST(StringUtilTest, StrAppend) {
string s;
// Test with 1 argument.
StrAppend(&s, "a");
ASSERT_EQ("a", s);
// Test with 2 arguments.
StrAppend(&s, "b", "c");
ASSERT_EQ("abc", s);
// Test with 3 arguments.
StrAppend(&s, "d", "e", "f");
ASSERT_EQ("abcdef", s);
// Test with 4 arguments.
StrAppend(&s, "g", "h", "i", "j");
ASSERT_EQ("abcdefghij", s);
// Test with 5 arguments.
StrAppend(&s, "k", "l", "m", "n", "o");
ASSERT_EQ("abcdefghijklmno", s);
// Test with int argument.
StrAppend(&s, 42);
ASSERT_EQ("abcdefghijklmno42", s);
} // namespace phonenumbers
} // namespace i18n