#170-Test CppStringT::startswith() with char and wchar_t

schmouk · schmouk · commit a11502e8bc75 · 2025-07-10T17:39:45.000+02:00
Completed. Validated.
Led to the fixing of code.
diff --git a/cpp-strings-tests/cpp-strings-tests.cpp b/cpp-strings-tests/cpp-strings-tests.cpp
@@ -3317,8 +3317,8 @@ namespace cppstringstests
 #pragma warning(push)
 #pragma warning(disable: 4566)  // to get no warning when current page code is not compatible with next unicode points
 			{
-				CppString text{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r" };
-				std::vector<CppString> lines{ text.splitlines() };
+				CppString wtext{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r" };
+				std::vector<CppString> lines{ wtext.splitlines() };
 				std::vector<CppString> expected{ "", "abc", "cde", "efg", "ghi", "ijk", "klm", "mno", "", "opq", "qrs", "stu", "uvw", "wxy", "zzz", "." };
 				auto exp_it{ expected.cbegin() };
 				auto lin_it{ lines.cbegin() };
@@ -3330,8 +3330,8 @@ namespace cppstringstests
 			}
 
 			{
-				CppString text{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r\n" };
-				std::vector<CppString> lines{ text.splitlines() };
+				CppString wtext{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r\n" };
+				std::vector<CppString> lines{ wtext.splitlines() };
 				std::vector<CppString> expected{ "", "abc", "cde", "efg", "ghi", "ijk", "klm", "mno", "", "opq", "qrs", "stu", "uvw", "wxy", "zzz", "." };
 				auto exp_it{ expected.cbegin() };
 				auto lin_it{ lines.cbegin() };
@@ -3343,8 +3343,8 @@ namespace cppstringstests
 			}
 
 			{
-				CppString text{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\n\r" };
-				std::vector<CppString> lines{ text.splitlines() };
+				CppString wtext{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\n\r" };
+				std::vector<CppString> lines{ wtext.splitlines() };
 				std::vector<CppString> expected{ "", "abc", "cde", "efg", "ghi", "ijk", "klm", "mno", "", "opq", "qrs", "stu", "uvw", "wxy", "zzz", ".", "" };
 				auto exp_it{ expected.cbegin() };
 				auto lin_it{ lines.cbegin() };
@@ -3356,8 +3356,8 @@ namespace cppstringstests
 			}
 
 			{
-				CppString text{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r" };
-				std::vector<CppString> lines{ text.splitlines(true) };
+				CppString wtext{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r" };
+				std::vector<CppString> lines{ wtext.splitlines(true) };
 				std::vector<CppString> expected{
 					"\v", "abc\013", "cde\f", "efg\x0c", "ghi\x1c", "ijk\x1d", "klm\x1d", "mno\r\n",
 					"\n", "opq\r", "qrs\v", "stu\r", "uvw\n", "wxy\r\n", "zzz\x0c", ".\r"
@@ -3372,8 +3372,8 @@ namespace cppstringstests
 			}
 
 			{
-				CppString text{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r\n" };
-				std::vector<CppString> lines{ text.splitlines(true) };
+				CppString wtext{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\r\n" };
+				std::vector<CppString> lines{ wtext.splitlines(true) };
 				std::vector<CppString> expected{
 					"\v", "abc\013", "cde\f", "efg\x0c", "ghi\x1c", "ijk\x1d", "klm\x1d", "mno\r\n",
 					"\n", "opq\r", "qrs\v", "stu\r", "uvw\n", "wxy\r\n", "zzz\x0c", ".\r\n"
@@ -3388,8 +3388,8 @@ namespace cppstringstests
 			}
 
 			{
-				CppString text{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\n\r" };
-				std::vector<CppString> lines{ text.splitlines(true) };
+				CppString wtext{ "\vabc\013cde\fefg\x0cghi\x1cijk\x1dklm\x1dmno\r\n\nopq\rqrs\vstu\ruvw\nwxy\r\nzzz\x0c.\n\r" };
+				std::vector<CppString> lines{ wtext.splitlines(true) };
 				std::vector<CppString> expected{
 					"\v", "abc\013", "cde\f", "efg\x0c", "ghi\x1c", "ijk\x1d", "klm\x1d", "mno\r\n",
 					"\n", "opq\r", "qrs\v", "stu\r", "uvw\n", "wxy\r\n", "zzz\x0c", ".\n", "\r"
@@ -3495,5 +3495,126 @@ namespace cppstringstests
 
 		}
 
+		TEST_METHOD(startswith)
+		{
+			CppString text("Abcdef");
+			const size_t len{ text.size() };
+
+			Assert::IsTrue(text.startswith("A"));
+			Assert::IsTrue(text.startswith("Ab"));
+			Assert::IsTrue(text.startswith("Abc"));
+			Assert::IsTrue(text.startswith("Abcd"));
+			Assert::IsTrue(text.startswith("Abcde"));
+			Assert::IsTrue(text.startswith("Abcdef"));
+			Assert::IsFalse(text.startswith("Abcdefg"));
+			Assert::IsFalse(text.startswith("a"));
+			Assert::IsFalse(text.startswith("def"));
+
+			Assert::IsTrue(text.startswith("b", 1));
+			Assert::IsTrue(text.startswith("bc", 1));
+			Assert::IsTrue(text.startswith("bcd", 1));
+			Assert::IsFalse(text.startswith("bcdefg", 1));
+			Assert::IsFalse(text.startswith("A", 1));
+			Assert::IsFalse(text.startswith("def", 1));
+
+			Assert::IsTrue(text.startswith("c", 2));
+			Assert::IsTrue(text.startswith("cd", 2));
+			Assert::IsTrue(text.startswith("cde", 2));
+			Assert::IsFalse(text.startswith("cdefg", 2));
+			Assert::IsFalse(text.startswith("Ab", 2));
+			Assert::IsFalse(text.startswith("def", 2));
+
+			Assert::IsTrue(text.startswith("d", 3));
+			Assert::IsTrue(text.startswith("de", 3));
+			Assert::IsTrue(text.startswith("def", 3));
+			Assert::IsFalse(text.startswith("defg", 3));
+			Assert::IsFalse(text.startswith("Abc", 3));
+			Assert::IsFalse(text.startswith("ef", 3));
+
+			Assert::IsTrue(text.startswith("e", 4));
+			Assert::IsTrue(text.startswith("ef", 4));
+			Assert::IsFalse(text.startswith("efg", 4));
+			Assert::IsFalse(text.startswith("Abcd", 4));
+			Assert::IsFalse(text.startswith("f", 4));
+
+			Assert::IsTrue(text.startswith("f", 5));
+			Assert::IsFalse(text.startswith("fg", 5));
+			Assert::IsFalse(text.startswith("Abcde", 5));
+			Assert::IsFalse(text.startswith("g", 5));
+
+			Assert::IsTrue(text.startswith("A", 0, 0));
+			Assert::IsFalse(text.startswith("b", 0, 0));
+			Assert::IsTrue(text.startswith("b", 1, 3));
+			Assert::IsTrue(text.startswith("bc", 1, 3));
+			Assert::IsTrue(text.startswith("bcd", 1, 3));
+			Assert::IsFalse(text.startswith("bcde", 1, 3));
+
+			Assert::IsTrue(text.startswith("", 5, 2));
+			Assert::IsTrue(text.startswith("", 15, 16));
+
+			Assert::IsTrue(text.startswith({ "ghi", "abca", "Abcd" }, 0, len - 2));
+			Assert::IsFalse(text.startswith({ "def", "ghi" }, 0, len - 4));
+			Assert::IsFalse(text.startswith({ "def", "ghi", "Abcd" }, 0, len - 4));
+
+
+			CppWString wtext(L"Abcdef");
+
+			Assert::IsTrue(wtext.startswith(L"A"));
+			Assert::IsTrue(wtext.startswith(L"Ab"));
+			Assert::IsTrue(wtext.startswith(L"Abc"));
+			Assert::IsTrue(wtext.startswith(L"Abcd"));
+			Assert::IsTrue(wtext.startswith(L"Abcde"));
+			Assert::IsTrue(wtext.startswith(L"Abcdef"));
+			Assert::IsFalse(wtext.startswith(L"Abcdefg"));
+			Assert::IsFalse(wtext.startswith(L"a"));
+			Assert::IsFalse(wtext.startswith(L"def"));
+
+			Assert::IsTrue(wtext.startswith(L"b", 1));
+			Assert::IsTrue(wtext.startswith(L"bc", 1));
+			Assert::IsTrue(wtext.startswith(L"bcd", 1));
+			Assert::IsFalse(wtext.startswith(L"bcdefg", 1));
+			Assert::IsFalse(wtext.startswith(L"A", 1));
+			Assert::IsFalse(wtext.startswith(L"def", 1));
+
+			Assert::IsTrue(wtext.startswith(L"c", 2));
+			Assert::IsTrue(wtext.startswith(L"cd", 2));
+			Assert::IsTrue(wtext.startswith(L"cde", 2));
+			Assert::IsFalse(wtext.startswith(L"cdefg", 2));
+			Assert::IsFalse(wtext.startswith(L"Ab", 2));
+			Assert::IsFalse(wtext.startswith(L"def", 2));
+
+			Assert::IsTrue(wtext.startswith(L"d", 3));
+			Assert::IsTrue(wtext.startswith(L"de", 3));
+			Assert::IsTrue(wtext.startswith(L"def", 3));
+			Assert::IsFalse(wtext.startswith(L"defg", 3));
+			Assert::IsFalse(wtext.startswith(L"Abc", 3));
+			Assert::IsFalse(wtext.startswith(L"ef", 3));
+
+			Assert::IsTrue(wtext.startswith(L"e", 4));
+			Assert::IsTrue(wtext.startswith(L"ef", 4));
+			Assert::IsFalse(wtext.startswith(L"efg", 4));
+			Assert::IsFalse(wtext.startswith(L"Abcd", 4));
+			Assert::IsFalse(wtext.startswith(L"f", 4));
+
+			Assert::IsTrue(wtext.startswith(L"f", 5));
+			Assert::IsFalse(wtext.startswith(L"fg", 5));
+			Assert::IsFalse(wtext.startswith(L"Abcde", 5));
+			Assert::IsFalse(wtext.startswith(L"g", 5));
+
+			Assert::IsTrue(wtext.startswith(L"A", 0, 0));
+			Assert::IsFalse(wtext.startswith(L"b", 0, 0));
+			Assert::IsTrue(wtext.startswith(L"b", 1, 3));
+			Assert::IsTrue(wtext.startswith(L"bc", 1, 3));
+			Assert::IsTrue(wtext.startswith(L"bcd", 1, 3));
+			Assert::IsFalse(wtext.startswith(L"bcde", 1, 3));
+
+			Assert::IsTrue(wtext.startswith(L"", 5, 2));
+			Assert::IsTrue(wtext.startswith(L"", 15, 16));
+
+			Assert::IsTrue(wtext.startswith({  L"ghi", L"abca", L"Abcd" }, 0, len - 2));
+			Assert::IsFalse(wtext.startswith({ L"def", L"ghi" }, 0, len - 4));
+			Assert::IsFalse(wtext.startswith({ L"def", L"ghi", L"Abcd" }, 0, len - 4));
+		}
+
 	};
 }
diff --git a/cpp-strings/cppstrings.h b/cpp-strings/cppstrings.h
@@ -1652,47 +1652,48 @@ namespace pcs // i.e. "pythonic c++ strings"
 
 
         //---   startswith()   ------------------------------------
-        /** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at start position and stops at end position. */
-        inline const bool startswith(const CppStringT& suffix, const size_type start, const size_type end) const noexcept
+        /** Returns true if the string starts with the specified prefix, otherwise returns false. Test begins at start position and stops at end position. */
+        inline const bool startswith(const CppStringT& prefix, const size_type start, const size_type end) const noexcept
         {
-            return startswith(std::span{ suffix }, start, end);
+            return this->substr(start, end - start + 1).MyBaseClass::starts_with(prefix);
         }
 
-        /** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at start position and stops at end of string. */
-        inline const bool startswith(const CppStringT& suffix, const size_type start) const noexcept
+        /** Returns true if the string starts with the specified prefix, otherwise returns false. Test begins at start position and stops at end of string. */
+        inline const bool startswith(const CppStringT& prefix, const size_type start) const noexcept
         {
-            return startswith(std::span{ suffix }, start, this->size() - 1);
+            return startswith(prefix, start, this->size() - 1);
         }
 
-        /** Returns true if the string starts with the specified suffix, otherwise returns false. Test runs on the whole string. */
-        inline const bool startswith(const CppStringT& suffix) const noexcept
+        /** Returns true if the string starts with the specified prefix, otherwise returns false. Test runs on the whole string. */
+        inline const bool startswith(const CppStringT& prefix) const noexcept
         {
-            return this->starts_with(suffix);
+            return this->starts_with(prefix);
         }
 
-        /** Returns true if the string starts with any of the specified suffixes, otherwise returns false. Test begins at start position and stops at end of string. */
-        inline const bool startswith(const std::span<CppStringT>& suffixes, const size_type start, const size_type end) const noexcept
+        /** Returns true if the string starts with any of the specified prefixes, otherwise returns false. Test begins at start position and stops at end of string. */
+        inline const bool startswith(const std::initializer_list<CppStringT>& prefixes, const size_type start, const size_type end) const noexcept
         {
             if (start > end)
                 return false;
-            else
-                return std::any_of(suffixes.cbegin(), suffixes.cend(), this->substr(start, end).starts_with);
-            /*
-            for (auto& suffix : suffixes) {
-                if (this->substr(start, end).starts_with(suffix))
+
+            CppStringT tmp(this->substr(start, end));
+            for (auto& prefix : prefixes) {
+                if (tmp.starts_with(prefix))
                     return true;
             }
-
             return false;
-            */
+
+            //else
+            //    return std::any_of(prefixes.cbegin(), prefixes.cend(), this->substr(start, end).starts_with);
         }
 
 
         //---   startswith_n()   ----------------------------------
         /** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at start position and stops after count positions. */
         inline const bool startswith_n(const CppStringT& suffix, const size_type start, const size_type count) const noexcept
         {
-            return startswith(std::span{ suffix }, start, start + count - 1);
+            //return startswith(std::span{ suffix }, start, start + count - 1);
+            return startswith(std::initializer_list<CppStringT>(suffix), start, start + count - 1);
         }
 
         /** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at position 0 and stops after count positions. */
@@ -1732,8 +1733,8 @@ namespace pcs // i.e. "pythonic c++ strings"
         inline CppStringT substr(const size_type start, const size_type count=-1) const noexcept
         {
             if (start > this->size())
-                return *this;
-            const size_type width = std::min(count, this->size() - start + 1);
+                return CppStringT();
+            const size_type width{ std::min(count, this->size() - start + 1) };
             return CppStringT(MyBaseClass::substr(start, width));
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1652,47 +1652,48 @@ namespace pcs // i.e. "pythonic c++ strings"`
`1652`	`1652`
`1653`	`1653`
`1654`	`1654`	`//--- startswith() ------------------------------------`
`1655`		`- /** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at start position and stops at end position. */`
`1656`		`- inline const bool startswith(const CppStringT& suffix, const size_type start, const size_type end) const noexcept`
	`1655`	`+ /** Returns true if the string starts with the specified prefix, otherwise returns false. Test begins at start position and stops at end position. */`
	`1656`	`+ inline const bool startswith(const CppStringT& prefix, const size_type start, const size_type end) const noexcept`
`1657`	`1657`	`{`
`1658`		`- return startswith(std::span{ suffix }, start, end);`
	`1658`	`+ return this->substr(start, end - start + 1).MyBaseClass::starts_with(prefix);`
`1659`	`1659`	`}`
`1660`	`1660`
`1661`		`- /** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at start position and stops at end of string. */`
`1662`		`- inline const bool startswith(const CppStringT& suffix, const size_type start) const noexcept`
	`1661`	`+ /** Returns true if the string starts with the specified prefix, otherwise returns false. Test begins at start position and stops at end of string. */`
	`1662`	`+ inline const bool startswith(const CppStringT& prefix, const size_type start) const noexcept`
`1663`	`1663`	`{`
`1664`		`- return startswith(std::span{ suffix }, start, this->size() - 1);`
	`1664`	`+ return startswith(prefix, start, this->size() - 1);`
`1665`	`1665`	`}`
`1666`	`1666`
`1667`		`- /** Returns true if the string starts with the specified suffix, otherwise returns false. Test runs on the whole string. */`
`1668`		`- inline const bool startswith(const CppStringT& suffix) const noexcept`
	`1667`	`+ /** Returns true if the string starts with the specified prefix, otherwise returns false. Test runs on the whole string. */`
	`1668`	`+ inline const bool startswith(const CppStringT& prefix) const noexcept`
`1669`	`1669`	`{`
`1670`		`- return this->starts_with(suffix);`
	`1670`	`+ return this->starts_with(prefix);`
`1671`	`1671`	`}`
`1672`	`1672`
`1673`		`- /** Returns true if the string starts with any of the specified suffixes, otherwise returns false. Test begins at start position and stops at end of string. */`
`1674`		`- inline const bool startswith(const std::span<CppStringT>& suffixes, const size_type start, const size_type end) const noexcept`
	`1673`	`+ /** Returns true if the string starts with any of the specified prefixes, otherwise returns false. Test begins at start position and stops at end of string. */`
	`1674`	`+ inline const bool startswith(const std::initializer_list<CppStringT>& prefixes, const size_type start, const size_type end) const noexcept`
`1675`	`1675`	`{`
`1676`	`1676`	`if (start > end)`
`1677`	`1677`	`return false;`
`1678`		`- else`
`1679`		`- return std::any_of(suffixes.cbegin(), suffixes.cend(), this->substr(start, end).starts_with);`
`1680`		`- /*`
`1681`		`- for (auto& suffix : suffixes) {`
`1682`		`- if (this->substr(start, end).starts_with(suffix))`
	`1678`	`+`
	`1679`	`+ CppStringT tmp(this->substr(start, end));`
	`1680`	`+ for (auto& prefix : prefixes) {`
	`1681`	`+ if (tmp.starts_with(prefix))`
`1683`	`1682`	`return true;`
`1684`	`1683`	`}`
`1685`		`-`
`1686`	`1684`	`return false;`
`1687`		`- */`
	`1685`	`+`
	`1686`	`+ //else`
	`1687`	`+ // return std::any_of(prefixes.cbegin(), prefixes.cend(), this->substr(start, end).starts_with);`
`1688`	`1688`	`}`
`1689`	`1689`
`1690`	`1690`
`1691`	`1691`	`//--- startswith_n() ----------------------------------`
`1692`	`1692`	`/** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at start position and stops after count positions. */`
`1693`	`1693`	`inline const bool startswith_n(const CppStringT& suffix, const size_type start, const size_type count) const noexcept`
`1694`	`1694`	`{`
`1695`		`- return startswith(std::span{ suffix }, start, start + count - 1);`
	`1695`	`+ //return startswith(std::span{ suffix }, start, start + count - 1);`
	`1696`	`+ return startswith(std::initializer_list<CppStringT>(suffix), start, start + count - 1);`
`1696`	`1697`	`}`
`1697`	`1698`
`1698`	`1699`	`/** Returns true if the string starts with the specified suffix, otherwise returns false. Test begins at position 0 and stops after count positions. */`
`@@ -1732,8 +1733,8 @@ namespace pcs // i.e. "pythonic c++ strings"`
`1732`	`1733`	`inline CppStringT substr(const size_type start, const size_type count=-1) const noexcept`
`1733`	`1734`	`{`
`1734`	`1735`	`if (start > this->size())`
`1735`		`- return *this;`
`1736`		`- const size_type width = std::min(count, this->size() - start + 1);`
	`1736`	`+ return CppStringT();`
	`1737`	`+ const size_type width{ std::min(count, this->size() - start + 1) };`
`1737`	`1738`	`return CppStringT(MyBaseClass::substr(start, width));`
`1738`	`1739`	`}`
`1739`	`1740`