util_string_test.cpp

Go to the documentation of this file.

/*
 * Copyright 2011-2016 Blender Foundation
 *
 * 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
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#include "testing/testing.h"
 
#include "util/util_string.h"
 
CCL_NAMESPACE_BEGIN
 
/* ******** Tests for string_printf() ******** */
 
TEST(util_string_printf, no_format)
{
  string str = string_printf("foo bar");
  EXPECT_EQ("foo bar", str);
}
 
TEST(util_string_printf, int_number)
{
  string str = string_printf("foo %d bar", 314);
  EXPECT_EQ("foo 314 bar", str);
}
 
TEST(util_string_printf, float_number_default_precision)
{
  string str = string_printf("foo %f bar", 3.1415);
  EXPECT_EQ("foo 3.141500 bar", str);
}
 
TEST(util_string_printf, float_number_custom_precision)
{
  string str = string_printf("foo %.1f bar", 3.1415);
  EXPECT_EQ("foo 3.1 bar", str);
}
 
/* ******** Tests for string_printf() ******** */
 
TEST(util_string_iequals, empty_a)
{
  bool equals = string_iequals("", "foo");
  EXPECT_FALSE(equals);
}
 
TEST(util_string_iequals, empty_b)
{
  bool equals = string_iequals("foo", "");
  EXPECT_FALSE(equals);
}
 
TEST(util_string_iequals, same_register)
{
  bool equals = string_iequals("foo", "foo");
  EXPECT_TRUE(equals);
}
 
TEST(util_string_iequals, different_register)
{
  bool equals = string_iequals("XFoo", "XfoO");
  EXPECT_TRUE(equals);
}
 
/* ******** Tests for string_split() ******** */
 
TEST(util_string_split, empty)
{
  vector<string> tokens;
  string_split(tokens, "");
  EXPECT_EQ(tokens.size(), 0);
}
 
TEST(util_string_split, only_spaces)
{
  vector<string> tokens;
  string_split(tokens, "   \t\t \t");
  EXPECT_EQ(tokens.size(), 0);
}
 
TEST(util_string_split, single)
{
  vector<string> tokens;
  string_split(tokens, "foo");
  EXPECT_EQ(tokens.size(), 1);
  EXPECT_EQ(tokens[0], "foo");
}
 
TEST(util_string_split, simple)
{
  vector<string> tokens;
  string_split(tokens, "foo a bar b");
  EXPECT_EQ(tokens.size(), 4);
  EXPECT_EQ(tokens[0], "foo");
  EXPECT_EQ(tokens[1], "a");
  EXPECT_EQ(tokens[2], "bar");
  EXPECT_EQ(tokens[3], "b");
}
 
TEST(util_string_split, multiple_spaces)
{
  vector<string> tokens;
  string_split(tokens, " \t foo \ta bar b\t  ");
  EXPECT_EQ(tokens.size(), 4);
  EXPECT_EQ(tokens[0], "foo");
  EXPECT_EQ(tokens[1], "a");
  EXPECT_EQ(tokens[2], "bar");
  EXPECT_EQ(tokens[3], "b");
}
 
/* ******** Tests for string_replace() ******** */
 
TEST(util_string_replace, empty_haystack_and_other)
{
  string str = "";
  string_replace(str, "x", "");
  EXPECT_EQ(str, "");
}
 
TEST(util_string_replace, empty_haystack)
{
  string str = "";
  string_replace(str, "x", "y");
  EXPECT_EQ(str, "");
}
 
TEST(util_string_replace, empty_other)
{
  string str = "x";
  string_replace(str, "x", "");
  EXPECT_EQ(str, "");
}
 
TEST(util_string_replace, long_haystack_empty_other)
{
  string str = "a x b xxc";
  string_replace(str, "x", "");
  EXPECT_EQ(str, "a  b c");
}
 
TEST(util_string_replace, long_haystack)
{
  string str = "a x b xxc";
  string_replace(str, "x", "FOO");
  EXPECT_EQ(str, "a FOO b FOOFOOc");
}
 
/* ******** Tests for string_endswith() ******** */
 
TEST(util_string_endswith, empty_both)
{
  bool endswith = string_endswith("", "");
  EXPECT_TRUE(endswith);
}
 
TEST(util_string_endswith, empty_string)
{
  bool endswith = string_endswith("", "foo");
  EXPECT_FALSE(endswith);
}
 
TEST(util_string_endswith, empty_end)
{
  bool endswith = string_endswith("foo", "");
  EXPECT_TRUE(endswith);
}
 
TEST(util_string_endswith, simple_true)
{
  bool endswith = string_endswith("foo bar", "bar");
  EXPECT_TRUE(endswith);
}
 
TEST(util_string_endswith, simple_false)
{
  bool endswith = string_endswith("foo bar", "foo");
  EXPECT_FALSE(endswith);
}
 
/* ******** Tests for string_strip() ******** */
 
TEST(util_string_strip, empty)
{
  string str = string_strip("");
  EXPECT_EQ(str, "");
}
 
TEST(util_string_strip, only_spaces)
{
  string str = string_strip("      ");
  EXPECT_EQ(str, "");
}
 
TEST(util_string_strip, no_spaces)
{
  string str = string_strip("foo bar");
  EXPECT_EQ(str, "foo bar");
}
 
TEST(util_string_strip, with_spaces)
{
  string str = string_strip("    foo bar ");
  EXPECT_EQ(str, "foo bar");
}
 
/* ******** Tests for string_remove_trademark() ******** */
 
TEST(util_string_remove_trademark, empty)
{
  string str = string_remove_trademark("");
  EXPECT_EQ(str, "");
}
 
TEST(util_string_remove_trademark, no_trademark)
{
  string str = string_remove_trademark("foo bar");
  EXPECT_EQ(str, "foo bar");
}
 
TEST(util_string_remove_trademark, only_tm)
{
  string str = string_remove_trademark("foo bar(TM) zzz");
  EXPECT_EQ(str, "foo bar zzz");
}
 
TEST(util_string_remove_trademark, only_r)
{
  string str = string_remove_trademark("foo bar(R) zzz");
  EXPECT_EQ(str, "foo bar zzz");
}
 
TEST(util_string_remove_trademark, both)
{
  string str = string_remove_trademark("foo bar(TM)(R) zzz");
  EXPECT_EQ(str, "foo bar zzz");
}
 
TEST(util_string_remove_trademark, both_space)
{
  string str = string_remove_trademark("foo bar(TM) (R) zzz");
  EXPECT_EQ(str, "foo bar zzz");
}
 
TEST(util_string_remove_trademark, both_space_around)
{
  string str = string_remove_trademark("foo bar (TM) (R) zzz");
  EXPECT_EQ(str, "foo bar zzz");
}
 
TEST(util_string_remove_trademark, trademark_space_suffix)
{
  string str = string_remove_trademark("foo bar (TM)");
  EXPECT_EQ(str, "foo bar");
}
 
TEST(util_string_remove_trademark, trademark_space_middle)
{
  string str = string_remove_trademark("foo bar (TM) baz");
  EXPECT_EQ(str, "foo bar baz");
}
 
TEST(util_string_remove_trademark, r_space_suffix)
{
  string str = string_remove_trademark("foo bar (R)");
  EXPECT_EQ(str, "foo bar");
}
 
TEST(util_string_remove_trademark, r_space_middle)
{
  string str = string_remove_trademark("foo bar (R) baz");
  EXPECT_EQ(str, "foo bar baz");
}
 
CCL_NAMESPACE_END