Issue 6378 - [emscripten] Make DependentString constexpr

test/compiled/String.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <string>
 #include <gtest/gtest.h>
 #include "compiled/String.h"
 
 ABP_NS_USING
 
-TEST(TestString, checkConstexprCorrectness)
-{
-  static constexpr DependentString s(u"Hello world!");
-  static_assert(s.length() == 12, "Length should be 12");
-
-  EXPECT_FALSE(s.is_writable());

[sergei, 2018/03/14 16:57:44]

I wonder whether it should be static_assert too.

[René Jeschke, 2018/03/14 17:01:00]

Yeah, was thinking about this, too. I wasn't sure if I can have a test case
without any 'tests'. And: if 's.length()' works without errors, the other
functions should, too, as the static assert makes sure, that we really have a
constexpr value.

I can, add more static_asserts, one for each 'constexpr' method, if wanted.

[sergei, 2018/03/14 17:03:09]

I think it's fine, JIC technically it's possible.
That would be very good too.

[René Jeschke, 2018/03/14 17:12:22]

Done.

+constexpr void checkConstexprTemplateCtor()
+{
+  constexpr DependentString s(u"Test string");
+}
+
+constexpr void checkConstexprInvalidCtor()
+{
+  constexpr DependentString s;
+  static_assert(s.is_invalid(), "String should be invalid");
+}
+
+constexpr void checkConstexprCtor()
+{
+  constexpr DependentString s(u"Test string", 11);
+}
+
+constexpr void checkConstexprFuncsAndOps()
+{
+  constexpr DependentString s = u"Test string"_str;
+  constexpr DependentString s2 = u"Test string"_str;
+  constexpr DependentString s3 = u"Another test string"_str;
+
+  static_assert(s.length() == s2.length(), "Length should be equal");
+  static_assert(s.equals(s2), "Strings should be equal");
+  static_assert(s == s2, "Strings should be equal");
+  static_assert(s != s3, "Strings should not be equal");
+
+  static_assert(!s.empty(), "String should not be empty");
+  static_assert(!s.is_writable(), "String should not be writable");
+  static_assert(!s.is_deleted(), "String should not be deleted");
+
+  static_assert(s.data()[0] == 'T', "First character should be 'T'");
+  static_assert(s[1] == 'e', "Second character should be 'e'");
+
+  static_assert(s.find(u'e') == 1, "'e' should be at pos 1");
+  static_assert(s.find(s2) == 0, "String should be found at pos 0");
+  static_assert(s.rfind(u'e') == 1, "'e' should be at pos 1");
 }
 
 TEST(TestString, constructInvalidDependentString)
 {
   DependentString s;
   EXPECT_TRUE(s.is_invalid());
 
   DependentString s2(s);
   EXPECT_TRUE(s2.is_invalid());
 }
 
 TEST(TestString, constructInvalidOwnedString)
 {
   OwnedString s;
   EXPECT_TRUE(s.is_invalid());
 
   // Valid string
   OwnedString s2(2);
   EXPECT_FALSE(s2.is_invalid());
 
   // Ensure we still have an invalid string.
   OwnedString s3(s);
   EXPECT_TRUE(s3.is_invalid());
 
   // Empty valid string lead to valid string.
-  OwnedString s4(u""_str);
+  OwnedString s4(ABP_TEXT(""_str));
   EXPECT_FALSE(s4.is_invalid());
 }
 
 TEST(TestStringTrimSpaces, zeroLengthString)
 {
-  EXPECT_EQ(u""_str, TrimSpaces(DependentString()));
-  EXPECT_EQ(u""_str, TrimSpaces(OwnedString()));
-  EXPECT_EQ(u""_str, TrimSpaces(u""_str));
+  EXPECT_EQ(ABP_TEXT(""_str), TrimSpaces(DependentString()));
+  EXPECT_EQ(ABP_TEXT(""_str), TrimSpaces(OwnedString()));
+  EXPECT_EQ(ABP_TEXT(""_str), TrimSpaces(ABP_TEXT(""_str)));
 }
 
 TEST(TestStringTrimSpaces, spacesAreRemoved)
 {
   for (uint16_t leftSpaces = 0; leftSpaces < 5; ++leftSpaces)
   {
     for (uint16_t rightSpaces = 0; rightSpaces < 5; ++rightSpaces)
     {
       for (uint16_t nonSpaces = 0; nonSpaces < 5; ++nonSpaces)
       {
         OwnedString str;
         std::string leftSpacesStdString(leftSpaces, ' ');
         str.append(leftSpacesStdString.c_str(), leftSpacesStdString.length());
         std::string stdString(nonSpaces, 'a');
         OwnedString trimmedString;
         trimmedString.append(stdString.c_str(), stdString.length());
         str.append(trimmedString);
         std::string rightSpacesStdString(rightSpaces, ' ');
         str.append(rightSpacesStdString.c_str(), rightSpacesStdString.length());
         EXPECT_EQ(trimmedString, TrimSpaces(str));
       }
     }
   }
 }
 
 TEST(TestStringSplitString, test)
 {
   {
-    auto str = u"123:abc"_str;
+    auto str = ABP_TEXT("123:abc"_str);
     auto split = SplitString(str, 3);
-    EXPECT_EQ(u"123"_str, split.first);
-    EXPECT_EQ(u"abc"_str, split.second);
-  }
-  {
-    auto str = u"123:abc"_str;
+    EXPECT_EQ(ABP_TEXT("123"_str), split.first);
+    EXPECT_EQ(ABP_TEXT("abc"_str), split.second);
+  }
+  {
+    auto str = ABP_TEXT("123:abc"_str);
     auto split = SplitString(str, 0);
-    EXPECT_EQ(u""_str, split.first);
-    EXPECT_EQ(u"23:abc"_str, split.second);
-  }
-  {
-    auto str = u"123:abc"_str;
+    EXPECT_EQ(ABP_TEXT(""_str), split.first);
+    EXPECT_EQ(ABP_TEXT("23:abc"_str), split.second);
+  }
+  {
+    auto str = ABP_TEXT("123:abc"_str);
     auto split = SplitString(str, 6);
-    EXPECT_EQ(u"123:ab"_str, split.first);
-    EXPECT_EQ(u""_str, split.second);
-  }
-  {
-    auto str = u"123:abc"_str;
+    EXPECT_EQ(ABP_TEXT("123:ab"_str), split.first);
+    EXPECT_EQ(ABP_TEXT(""_str), split.second);
+  }
+  {
+    auto str = ABP_TEXT("123:abc"_str);
     auto split = SplitString(str, 7);
-    EXPECT_EQ(u"123:abc"_str, split.first);
-    EXPECT_EQ(u""_str, split.second);
-  }
-  {
-    auto str = u"123:abc"_str;
+    EXPECT_EQ(ABP_TEXT("123:abc"_str), split.first);
+    EXPECT_EQ(ABP_TEXT(""_str), split.second);
+  }
+  {
+    auto str = ABP_TEXT("123:abc"_str);
     auto split = SplitString(str, 10);
-    EXPECT_EQ(u"123:abc"_str, split.first);
-    EXPECT_EQ(u""_str, split.second);
+    EXPECT_EQ(ABP_TEXT("123:abc"_str), split.first);
+    EXPECT_EQ(ABP_TEXT(""_str), split.second);
   }
 }
 
 TEST(TestStringLexicalCast, toIntegers)
 {
-  EXPECT_EQ(0, lexical_cast<int32_t>(u"0"_str));
-  EXPECT_EQ(1, lexical_cast<int32_t>(u"1"_str));
-  EXPECT_EQ(2, lexical_cast<int32_t>(u"2"_str));
-  EXPECT_EQ(10, lexical_cast<int32_t>(u"10"_str));
-  EXPECT_EQ(10, lexical_cast<int32_t>(u"010"_str));
-  EXPECT_EQ(-1, lexical_cast<int32_t>(u"-1"_str));
-  EXPECT_EQ(-2, lexical_cast<int32_t>(u"-2"_str));
-  EXPECT_EQ(-20, lexical_cast<int32_t>(u"-20"_str));
-  EXPECT_EQ(-20, lexical_cast<int32_t>(u"-020"_str));
-  EXPECT_EQ(0, lexical_cast<int32_t>(u"0-2"_str));
-  EXPECT_EQ(-2147483647, lexical_cast<int32_t>(u"-2147483647"_str));
-  EXPECT_EQ(-2147483648, lexical_cast<int32_t>(u"-2147483648"_str));
-  EXPECT_EQ(          0, lexical_cast<int32_t>(u"-2147483649"_str));
-  EXPECT_EQ(          0, lexical_cast<int32_t>(u"-2157483649"_str));
-  EXPECT_EQ(          0, lexical_cast<int32_t>(u"-3147483649"_str));
-  EXPECT_EQ(-2147483648, lexical_cast<int32_t>(u"-02147483648"_str));
-  EXPECT_EQ(-2147483648, lexical_cast<int32_t>(u"-000002147483648"_str));
-  EXPECT_EQ(          0, lexical_cast<int32_t>(u"-21474836480"_str));
-  EXPECT_EQ(2147483647, lexical_cast<int32_t>(u"2147483647"_str));
-  EXPECT_EQ(2147483647, lexical_cast<int32_t>(u"000002147483647"_str));
-  EXPECT_EQ(2147483647, lexical_cast<int32_t>(u"02147483647"_str));
-  EXPECT_EQ(         0, lexical_cast<int32_t>(u"21474836470"_str));
-  EXPECT_EQ(         0, lexical_cast<int32_t>(u"2147483648"_str));
-  EXPECT_EQ(         0, lexical_cast<int32_t>(u"2157483648"_str));
-  EXPECT_EQ(         0, lexical_cast<int32_t>(u"3147483648"_str));
-  EXPECT_EQ(0u, lexical_cast<uint32_t>(u"0"_str));
-  EXPECT_EQ(2u, lexical_cast<uint32_t>(u"2"_str));
-  EXPECT_EQ(123u, lexical_cast<uint32_t>(u"123"_str));
-  EXPECT_EQ(123u, lexical_cast<uint32_t>(u"0123"_str));
-  EXPECT_EQ(123u, lexical_cast<uint32_t>(u"0000123"_str));
-  EXPECT_EQ(4294967294u, lexical_cast<uint32_t>(u"4294967294"_str));
-  EXPECT_EQ(4294967295u, lexical_cast<uint32_t>(u"4294967295"_str));
-  EXPECT_EQ(         0u, lexical_cast<uint32_t>(u"4294967296"_str));
-  EXPECT_EQ(         0u, lexical_cast<uint32_t>(u"4594967295"_str));
-  EXPECT_EQ(         0u, lexical_cast<uint32_t>(u"5294967295"_str));
-  EXPECT_EQ(         0u, lexical_cast<uint32_t>(u"42949672950"_str));
-  EXPECT_EQ(4294967295u, lexical_cast<uint32_t>(u"04294967295"_str));
-
-  EXPECT_EQ(0, lexical_cast<int32_t>(u" 123"_str));
-  EXPECT_EQ(0u, lexical_cast<uint32_t>(u" 123"_str));
-  EXPECT_EQ(0, lexical_cast<int32_t>(u"123abc"_str));
-  EXPECT_EQ(0u, lexical_cast<uint32_t>(u"123abc"_str));
-  EXPECT_EQ(0, lexical_cast<int32_t>(u"1 23"_str));
-  EXPECT_EQ(0u, lexical_cast<uint32_t>(u"1 23"_str));
+  EXPECT_EQ(0, lexical_cast<int32_t>(ABP_TEXT("0"_str)));
+  EXPECT_EQ(1, lexical_cast<int32_t>(ABP_TEXT("1"_str)));
+  EXPECT_EQ(2, lexical_cast<int32_t>(ABP_TEXT("2"_str)));
+  EXPECT_EQ(10, lexical_cast<int32_t>(ABP_TEXT("10"_str)));
+  EXPECT_EQ(10, lexical_cast<int32_t>(ABP_TEXT("010"_str)));
+  EXPECT_EQ(-1, lexical_cast<int32_t>(ABP_TEXT("-1"_str)));
+  EXPECT_EQ(-2, lexical_cast<int32_t>(ABP_TEXT("-2"_str)));
+  EXPECT_EQ(-20, lexical_cast<int32_t>(ABP_TEXT("-20"_str)));
+  EXPECT_EQ(-20, lexical_cast<int32_t>(ABP_TEXT("-020"_str)));
+  EXPECT_EQ(0, lexical_cast<int32_t>(ABP_TEXT("0-2"_str)));
+  EXPECT_EQ(-2147483647, lexical_cast<int32_t>(ABP_TEXT("-2147483647"_str)));
+  EXPECT_EQ(-2147483648, lexical_cast<int32_t>(ABP_TEXT("-2147483648"_str)));
+  EXPECT_EQ(          0, lexical_cast<int32_t>(ABP_TEXT("-2147483649"_str)));
+  EXPECT_EQ(          0, lexical_cast<int32_t>(ABP_TEXT("-2157483649"_str)));
+  EXPECT_EQ(          0, lexical_cast<int32_t>(ABP_TEXT("-3147483649"_str)));
+  EXPECT_EQ(-2147483648, lexical_cast<int32_t>(ABP_TEXT("-02147483648"_str)));
+  EXPECT_EQ(-2147483648, lexical_cast<int32_t>(ABP_TEXT("-000002147483648"_str)));
+  EXPECT_EQ(          0, lexical_cast<int32_t>(ABP_TEXT("-21474836480"_str)));
+  EXPECT_EQ(2147483647, lexical_cast<int32_t>(ABP_TEXT("2147483647"_str)));
+  EXPECT_EQ(2147483647, lexical_cast<int32_t>(ABP_TEXT("000002147483647"_str)));
+  EXPECT_EQ(2147483647, lexical_cast<int32_t>(ABP_TEXT("02147483647"_str)));
+  EXPECT_EQ(         0, lexical_cast<int32_t>(ABP_TEXT("21474836470"_str)));
+  EXPECT_EQ(         0, lexical_cast<int32_t>(ABP_TEXT("2147483648"_str)));
+  EXPECT_EQ(         0, lexical_cast<int32_t>(ABP_TEXT("2157483648"_str)));
+  EXPECT_EQ(         0, lexical_cast<int32_t>(ABP_TEXT("3147483648"_str)));
+  EXPECT_EQ(0u, lexical_cast<uint32_t>(ABP_TEXT("0"_str)));
+  EXPECT_EQ(2u, lexical_cast<uint32_t>(ABP_TEXT("2"_str)));
+  EXPECT_EQ(123u, lexical_cast<uint32_t>(ABP_TEXT("123"_str)));
+  EXPECT_EQ(123u, lexical_cast<uint32_t>(ABP_TEXT("0123"_str)));
+  EXPECT_EQ(123u, lexical_cast<uint32_t>(ABP_TEXT("0000123"_str)));
+  EXPECT_EQ(4294967294u, lexical_cast<uint32_t>(ABP_TEXT("4294967294"_str)));
+  EXPECT_EQ(4294967295u, lexical_cast<uint32_t>(ABP_TEXT("4294967295"_str)));
+  EXPECT_EQ(         0u, lexical_cast<uint32_t>(ABP_TEXT("4294967296"_str)));
+  EXPECT_EQ(         0u, lexical_cast<uint32_t>(ABP_TEXT("4594967295"_str)));
+  EXPECT_EQ(         0u, lexical_cast<uint32_t>(ABP_TEXT("5294967295"_str)));
+  EXPECT_EQ(         0u, lexical_cast<uint32_t>(ABP_TEXT("42949672950"_str)));
+  EXPECT_EQ(4294967295u, lexical_cast<uint32_t>(ABP_TEXT("04294967295"_str)));
+
+  EXPECT_EQ(0, lexical_cast<int32_t>(ABP_TEXT(" 123"_str)));
+  EXPECT_EQ(0u, lexical_cast<uint32_t>(ABP_TEXT(" 123"_str)));
+  EXPECT_EQ(0, lexical_cast<int32_t>(ABP_TEXT("123abc"_str)));
+  EXPECT_EQ(0u, lexical_cast<uint32_t>(ABP_TEXT("123abc"_str)));
+  EXPECT_EQ(0, lexical_cast<int32_t>(ABP_TEXT("1 23"_str)));
+  EXPECT_EQ(0u, lexical_cast<uint32_t>(ABP_TEXT("1 23"_str)));
 }
 
 TEST(TestStringLexicalCast, toBoolean)
 {
-  EXPECT_TRUE(lexical_cast<bool>(u"true"_str));
-  EXPECT_FALSE(lexical_cast<bool>(u"true123"_str));
-  EXPECT_FALSE(lexical_cast<bool>(u"false"_str));
-  EXPECT_FALSE(lexical_cast<bool>(u"some-string"_str));
-  EXPECT_FALSE(lexical_cast<bool>(u""_str));
+  EXPECT_TRUE(lexical_cast<bool>(ABP_TEXT("true"_str)));
+  EXPECT_FALSE(lexical_cast<bool>(ABP_TEXT("true123"_str)));
+  EXPECT_FALSE(lexical_cast<bool>(ABP_TEXT("false"_str)));
+  EXPECT_FALSE(lexical_cast<bool>(ABP_TEXT("some-string"_str)));
+  EXPECT_FALSE(lexical_cast<bool>(ABP_TEXT(""_str)));
   EXPECT_FALSE(lexical_cast<bool>(DependentString()));
 }
 
 TEST(TestStringLexicalCast, toOwnedString)
 {
-  EXPECT_EQ(u"some-string"_str, lexical_cast<OwnedString>(u"some-string"_str));
-  EXPECT_EQ(u""_str, lexical_cast<OwnedString>(u""_str));
-}
+  EXPECT_EQ(ABP_TEXT("some-string"_str), lexical_cast<OwnedString>(ABP_TEXT("some-string"_str)));
+  EXPECT_EQ(ABP_TEXT(""_str), lexical_cast<OwnedString>(ABP_TEXT(""_str)));
+}