wehub-resource-sync
481 lines
14 KiB
C++
481 lines
14 KiB
C++
// Copyright 2025-present the zvec project
|
|
//
|
|
// 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 <cmath>
|
|
#include <limits>
|
|
#include <gtest/gtest.h>
|
|
#include <zvec/ailego/internal/platform.h>
|
|
#include <zvec/ailego/utility/string_helper.h>
|
|
|
|
using namespace zvec;
|
|
|
|
TEST(StringHelper, Split) {
|
|
std::vector<std::string> out;
|
|
|
|
ailego::StringHelper::Split("", ",", &out);
|
|
EXPECT_EQ(1u, out.size());
|
|
EXPECT_EQ("", out[0]);
|
|
|
|
ailego::StringHelper::Split("", ';', &out);
|
|
EXPECT_EQ(1u, out.size());
|
|
EXPECT_EQ("", out[0]);
|
|
|
|
ailego::StringHelper::Split("Hello, world!", "", &out);
|
|
EXPECT_EQ(1u, out.size());
|
|
EXPECT_EQ("Hello, world!", out[0]);
|
|
|
|
ailego::StringHelper::Split("Hello, world!", '!', &out);
|
|
EXPECT_EQ(2u, out.size());
|
|
EXPECT_EQ("Hello, world", out[0]);
|
|
EXPECT_EQ("", out[1]);
|
|
|
|
ailego::StringHelper::Split("abxycdxyxydefxya", "xyz", &out);
|
|
EXPECT_EQ(1u, out.size());
|
|
EXPECT_EQ("abxycdxyxydefxya", out[0]);
|
|
|
|
ailego::StringHelper::Split("abxycdxyxydefxya", 'a', &out);
|
|
EXPECT_EQ(3u, out.size());
|
|
EXPECT_EQ("", out[0]);
|
|
EXPECT_EQ("bxycdxyxydefxy", out[1]);
|
|
EXPECT_EQ("", out[2]);
|
|
|
|
ailego::StringHelper::Split("abxycdxy!!xydefxya", "xy", &out);
|
|
EXPECT_EQ(5u, out.size());
|
|
EXPECT_EQ("ab", out[0]);
|
|
EXPECT_EQ("cd", out[1]);
|
|
EXPECT_EQ("!!", out[2]);
|
|
EXPECT_EQ("def", out[3]);
|
|
EXPECT_EQ("a", out[4]);
|
|
|
|
ailego::StringHelper::Split("abxycdxy!!xydefxya", '!', &out);
|
|
EXPECT_EQ(3u, out.size());
|
|
EXPECT_EQ("abxycdxy", out[0]);
|
|
EXPECT_EQ("", out[1]);
|
|
EXPECT_EQ("xydefxya", out[2]);
|
|
|
|
ailego::StringHelper::Split("abxycdxyxydefxya", "xy", &out);
|
|
EXPECT_EQ(5u, out.size());
|
|
EXPECT_EQ("ab", out[0]);
|
|
EXPECT_EQ("cd", out[1]);
|
|
EXPECT_EQ("", out[2]);
|
|
EXPECT_EQ("def", out[3]);
|
|
EXPECT_EQ("a", out[4]);
|
|
|
|
ailego::StringHelper::Split("abxycdxyxydefxya", 'y', &out);
|
|
EXPECT_EQ(5u, out.size());
|
|
EXPECT_EQ("abx", out[0]);
|
|
EXPECT_EQ("cdx", out[1]);
|
|
EXPECT_EQ("x", out[2]);
|
|
EXPECT_EQ("defx", out[3]);
|
|
EXPECT_EQ("a", out[4]);
|
|
|
|
ailego::StringHelper::Split("abxycdxyxydefxy", "xy", &out);
|
|
EXPECT_EQ(5u, out.size());
|
|
EXPECT_EQ("ab", out[0]);
|
|
EXPECT_EQ("cd", out[1]);
|
|
EXPECT_EQ("", out[2]);
|
|
EXPECT_EQ("def", out[3]);
|
|
EXPECT_EQ("", out[4]);
|
|
|
|
ailego::StringHelper::Split("abxycdxyxydefxy", 'y', &out);
|
|
EXPECT_EQ(5u, out.size());
|
|
EXPECT_EQ("abx", out[0]);
|
|
EXPECT_EQ("cdx", out[1]);
|
|
EXPECT_EQ("x", out[2]);
|
|
EXPECT_EQ("defx", out[3]);
|
|
EXPECT_EQ("", out[4]);
|
|
|
|
ailego::StringHelper::Split("xy", "xy", &out);
|
|
EXPECT_EQ(2u, out.size());
|
|
EXPECT_EQ("", out[0]);
|
|
EXPECT_EQ("", out[1]);
|
|
|
|
ailego::StringHelper::Split("x", 'x', &out);
|
|
EXPECT_EQ(2u, out.size());
|
|
EXPECT_EQ("", out[0]);
|
|
EXPECT_EQ("", out[1]);
|
|
}
|
|
|
|
TEST(StringHelper, SplitFloat) {
|
|
std::vector<float> out1;
|
|
ailego::StringHelper::Split("1.0, tt, 2,", ',', &out1);
|
|
EXPECT_EQ(4u, out1.size());
|
|
EXPECT_FLOAT_EQ(1.0f, out1[0]);
|
|
EXPECT_FLOAT_EQ(0.0f, out1[1]);
|
|
EXPECT_FLOAT_EQ(2.0f, out1[2]);
|
|
EXPECT_FLOAT_EQ(0.0f, out1[3]);
|
|
|
|
std::vector<double> out2;
|
|
ailego::StringHelper::Split("1.0, tt, 2,", ',', &out2);
|
|
EXPECT_EQ(4u, out2.size());
|
|
EXPECT_DOUBLE_EQ(1.0f, out2[0]);
|
|
EXPECT_DOUBLE_EQ(0.0f, out2[1]);
|
|
EXPECT_DOUBLE_EQ(2.0f, out2[2]);
|
|
EXPECT_DOUBLE_EQ(0.0f, out2[3]);
|
|
}
|
|
|
|
TEST(StringHelper, SplitInteger) {
|
|
std::vector<int32_t> out1;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", ',', &out1);
|
|
EXPECT_EQ(4u, out1.size());
|
|
EXPECT_EQ(-1, out1[0]);
|
|
EXPECT_EQ(0, out1[1]);
|
|
EXPECT_EQ(2, out1[2]);
|
|
EXPECT_EQ(0, out1[3]);
|
|
|
|
std::vector<uint32_t> out2;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", ',', &out2);
|
|
EXPECT_EQ(4u, out2.size());
|
|
EXPECT_EQ(0xffffffffu, out2[0]);
|
|
EXPECT_EQ(0u, out2[1]);
|
|
EXPECT_EQ(2u, out2[2]);
|
|
EXPECT_EQ(0u, out2[3]);
|
|
|
|
std::vector<int64_t> out3;
|
|
ailego::StringHelper::Split("-1.0, tt, 2.3,", ',', &out3);
|
|
EXPECT_EQ(4u, out3.size());
|
|
EXPECT_EQ(-1, out3[0]);
|
|
EXPECT_EQ(0, out3[1]);
|
|
EXPECT_EQ(2, out3[2]);
|
|
EXPECT_EQ(0, out3[3]);
|
|
|
|
std::vector<uint64_t> out4;
|
|
ailego::StringHelper::Split("-1.0, tt, 2.3,", ',', &out4);
|
|
EXPECT_EQ(4u, out4.size());
|
|
EXPECT_EQ((uint64_t)-1, out4[0]);
|
|
EXPECT_EQ(0u, out4[1]);
|
|
EXPECT_EQ(2u, out4[2]);
|
|
EXPECT_EQ(0u, out4[3]);
|
|
|
|
std::vector<int8_t> out5;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", ',', &out5);
|
|
EXPECT_EQ(4u, out5.size());
|
|
EXPECT_EQ(-1, out5[0]);
|
|
EXPECT_EQ(0, out5[1]);
|
|
EXPECT_EQ(2, out5[2]);
|
|
EXPECT_EQ(0, out5[3]);
|
|
|
|
std::vector<uint8_t> out6;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", ',', &out6);
|
|
EXPECT_EQ(4u, out6.size());
|
|
EXPECT_EQ(255u, out6[0]);
|
|
EXPECT_EQ(0u, out6[1]);
|
|
EXPECT_EQ(2u, out6[2]);
|
|
EXPECT_EQ(0u, out6[3]);
|
|
|
|
std::vector<int16_t> out7;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", ',', &out7);
|
|
EXPECT_EQ(4u, out7.size());
|
|
EXPECT_EQ(-1, out7[0]);
|
|
EXPECT_EQ(0, out7[1]);
|
|
EXPECT_EQ(2, out7[2]);
|
|
EXPECT_EQ(0, out7[3]);
|
|
|
|
std::vector<uint16_t> out8;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", ',', &out8);
|
|
EXPECT_EQ(4u, out8.size());
|
|
EXPECT_EQ(65535u, out8[0]);
|
|
EXPECT_EQ(0u, out8[1]);
|
|
EXPECT_EQ(2u, out8[2]);
|
|
EXPECT_EQ(0u, out8[3]);
|
|
}
|
|
|
|
TEST(StringHelper, SplitWithTValidDelimeter) {
|
|
std::vector<int32_t> out1;
|
|
ailego::StringHelper::Split("12321", '2', &out1);
|
|
EXPECT_EQ(3u, out1.size());
|
|
EXPECT_EQ(1, out1[0]);
|
|
EXPECT_EQ(3, out1[1]);
|
|
EXPECT_EQ(1, out1[2]);
|
|
|
|
std::vector<double> out2;
|
|
ailego::StringHelper::Split("300e30e3", 'e', &out2);
|
|
EXPECT_EQ(3u, out2.size());
|
|
EXPECT_DOUBLE_EQ(300.0f, out2[0]);
|
|
EXPECT_DOUBLE_EQ(30.0f, out2[1]);
|
|
EXPECT_DOUBLE_EQ(3.0f, out2[2]);
|
|
}
|
|
|
|
TEST(StringHelper, SplitByString) {
|
|
std::string sep = ",";
|
|
std::vector<int32_t> out1;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", sep, &out1);
|
|
EXPECT_EQ(4u, out1.size());
|
|
EXPECT_EQ(-1, out1[0]);
|
|
EXPECT_EQ(0, out1[1]);
|
|
EXPECT_EQ(2, out1[2]);
|
|
EXPECT_EQ(0, out1[3]);
|
|
|
|
std::vector<uint32_t> out2;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", sep, &out2);
|
|
EXPECT_EQ(4u, out2.size());
|
|
EXPECT_EQ(0xffffffffu, out2[0]);
|
|
EXPECT_EQ(0u, out2[1]);
|
|
EXPECT_EQ(2u, out2[2]);
|
|
EXPECT_EQ(0u, out2[3]);
|
|
|
|
std::vector<int64_t> out3;
|
|
ailego::StringHelper::Split("-1.0, tt, 2.3,", sep, &out3);
|
|
EXPECT_EQ(4u, out3.size());
|
|
EXPECT_EQ(-1, out3[0]);
|
|
EXPECT_EQ(0, out3[1]);
|
|
EXPECT_EQ(2, out3[2]);
|
|
EXPECT_EQ(0, out3[3]);
|
|
|
|
std::vector<uint64_t> out4;
|
|
ailego::StringHelper::Split("-1.0, tt, 2.3,", sep, &out4);
|
|
EXPECT_EQ(4u, out4.size());
|
|
EXPECT_EQ((uint64_t)-1, out4[0]);
|
|
EXPECT_EQ(0u, out4[1]);
|
|
EXPECT_EQ(2u, out4[2]);
|
|
EXPECT_EQ(0u, out4[3]);
|
|
|
|
std::vector<int8_t> out5;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", sep, &out5);
|
|
EXPECT_EQ(4u, out5.size());
|
|
EXPECT_EQ(-1, out5[0]);
|
|
EXPECT_EQ(0, out5[1]);
|
|
EXPECT_EQ(2, out5[2]);
|
|
EXPECT_EQ(0, out5[3]);
|
|
|
|
std::vector<uint8_t> out6;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", sep, &out6);
|
|
EXPECT_EQ(4u, out6.size());
|
|
EXPECT_EQ(255u, out6[0]);
|
|
EXPECT_EQ(0u, out6[1]);
|
|
EXPECT_EQ(2u, out6[2]);
|
|
EXPECT_EQ(0u, out6[3]);
|
|
|
|
std::vector<int16_t> out7;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", sep, &out7);
|
|
EXPECT_EQ(4u, out7.size());
|
|
EXPECT_EQ(-1, out7[0]);
|
|
EXPECT_EQ(0, out7[1]);
|
|
EXPECT_EQ(2, out7[2]);
|
|
EXPECT_EQ(0, out7[3]);
|
|
|
|
std::vector<uint16_t> out8;
|
|
ailego::StringHelper::Split("-1.0, tt, 2,", sep, &out8);
|
|
EXPECT_EQ(4u, out8.size());
|
|
EXPECT_EQ(65535u, out8[0]);
|
|
EXPECT_EQ(0u, out8[1]);
|
|
EXPECT_EQ(2u, out8[2]);
|
|
EXPECT_EQ(0u, out8[3]);
|
|
}
|
|
|
|
TEST(StringHelper, Trim) {
|
|
std::string aaa = " \t123 45 67\t\n8\r \n";
|
|
EXPECT_EQ("123 45 67\t\n8\r \n", ailego::StringHelper::CopyLeftTrim(aaa));
|
|
EXPECT_EQ(" \t123 45 67\t\n8", ailego::StringHelper::CopyRightTrim(aaa));
|
|
EXPECT_EQ("123 45 67\t\n8", ailego::StringHelper::CopyTrim(aaa));
|
|
|
|
std::string bbb = " \t123 45 67\t\n8\r \n";
|
|
ailego::StringHelper::LeftTrim(bbb);
|
|
EXPECT_EQ("123 45 67\t\n8\r \n", bbb);
|
|
|
|
std::string ccc = " \t123 45 67\t\n8\r \n";
|
|
ailego::StringHelper::RightTrim(ccc);
|
|
EXPECT_EQ(" \t123 45 67\t\n8", ccc);
|
|
|
|
std::string ddd = " \t123 45 67\t\n8\r \n";
|
|
ailego::StringHelper::Trim(ddd);
|
|
EXPECT_EQ("123 45 67\t\n8", ddd);
|
|
}
|
|
|
|
TEST(StringHelper, CompareIgnoreCase) {
|
|
{
|
|
std::string a = "a b\tc\nd";
|
|
std::string b = "A B\tC\nd";
|
|
EXPECT_TRUE(ailego::StringHelper::CompareIgnoreCase(a, b));
|
|
}
|
|
{
|
|
std::string a = "a d\tc\nd";
|
|
std::string b = "A B\tC\nd";
|
|
EXPECT_FALSE(ailego::StringHelper::CompareIgnoreCase(a, b));
|
|
}
|
|
{
|
|
std::string a = "a d\tc\n";
|
|
std::string b = "A B\tC\nd";
|
|
EXPECT_FALSE(ailego::StringHelper::CompareIgnoreCase(a, b));
|
|
}
|
|
{
|
|
std::string a = "A D\tc\n123456";
|
|
std::string b = "A d\tC\n123456";
|
|
EXPECT_TRUE(ailego::StringHelper::CompareIgnoreCase(a, b));
|
|
}
|
|
{
|
|
std::string a = "A D\tc\n123456";
|
|
std::string b = "";
|
|
EXPECT_FALSE(ailego::StringHelper::CompareIgnoreCase(a, b));
|
|
}
|
|
}
|
|
|
|
namespace zvec::ailego {
|
|
namespace testing {
|
|
|
|
TEST(StringHelperJoinAppend, Integer) {
|
|
short a = -1;
|
|
unsigned short b = 2;
|
|
long c = -3;
|
|
unsigned long d = 4;
|
|
long long e = -5;
|
|
unsigned long long f = 6;
|
|
ssize_t g = -7;
|
|
size_t h = 8;
|
|
auto res = StringHelper::Concat(a, b, c, d, e, f, g, h);
|
|
EXPECT_EQ(res, "-12-34-56-78");
|
|
std::string str = "TEST";
|
|
StringHelper::Append(&str, a, b, c, d, e, f, g, h);
|
|
EXPECT_EQ(str, "TEST-12-34-56-78");
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, SizedInteger) {
|
|
int8_t a = -1;
|
|
uint8_t b = 2;
|
|
int16_t c = -3;
|
|
uint16_t d = 4;
|
|
int32_t e = -5;
|
|
uint32_t f = 6;
|
|
int64_t g = -7;
|
|
uint64_t h = 8;
|
|
EXPECT_EQ("-12", StringHelper::Concat(a, b));
|
|
EXPECT_EQ("-12-3", StringHelper::Concat(a, b, c));
|
|
EXPECT_EQ("4-5", StringHelper::Concat(d, e));
|
|
EXPECT_EQ("-78", StringHelper::Concat(g, h));
|
|
|
|
auto res = StringHelper::Concat(a, b, c, d, e, f, g, h);
|
|
EXPECT_EQ(res, "-12-34-56-78");
|
|
std::string str = "TEST";
|
|
StringHelper::Append(&str, a, b, c, d, e, f, g, h);
|
|
EXPECT_EQ(str, "TEST-12-34-56-78");
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, MinMax) {
|
|
auto a = StringHelper::Concat(
|
|
std::numeric_limits<int8_t>::min(), std::numeric_limits<int8_t>::max(),
|
|
std::numeric_limits<int16_t>::min(), std::numeric_limits<int16_t>::max(),
|
|
std::numeric_limits<int32_t>::min(), std::numeric_limits<int32_t>::max(),
|
|
std::numeric_limits<int64_t>::min(), std::numeric_limits<int64_t>::max());
|
|
EXPECT_EQ(a,
|
|
"-128127-3276832767-21474836482147483647-"
|
|
"92233720368547758089223372036854775807");
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, Float) {
|
|
float f = 3.14f;
|
|
double d = 6.28;
|
|
long double ld = 9.42;
|
|
auto a = StringHelper::Concat(
|
|
f, d, ld, NAN, INFINITY, std::numeric_limits<float>::min(),
|
|
std::numeric_limits<float>::max(), std::numeric_limits<double>::min(),
|
|
std::numeric_limits<double>::max());
|
|
EXPECT_EQ(a,
|
|
"3.146.289.42naninf1.17549e-383.40282e+382.22507e-3081.79769e+308");
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, Enums) {
|
|
enum { kOne = 1, kTen = 10 };
|
|
enum class A : int64_t { kFirst = 100, kLast = 10000 };
|
|
auto a = StringHelper::Concat(kOne, kTen, A::kFirst, A::kLast);
|
|
EXPECT_EQ(a, "11010010000");
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, String) {
|
|
auto a = StringHelper::Concat("a", std::string{"b"}, "c", std::string{"d"});
|
|
EXPECT_EQ(a, "abcd");
|
|
auto b = StringHelper::Concat("aaaa", std::string{"bbbb"}, "cccc",
|
|
std::string{"dddd"});
|
|
EXPECT_EQ(b, "aaaabbbbccccdddd");
|
|
auto c = StringHelper::Concat("aaaaaaaa", std::string{"bbbbbbbb"}, "cccccccc",
|
|
std::string{"dddddddd"});
|
|
EXPECT_EQ(c, "aaaaaaaabbbbbbbbccccccccdddddddd");
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, ArbitaryNumberOfArguments) {
|
|
auto a = StringHelper::Concat(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c",
|
|
"d", "e", "f", "g", "h", "i", "j", "k", "l",
|
|
"m", "n", "o", "p", "q", "r", "s", "t", "u",
|
|
"v", "w", "x", "y", "z");
|
|
EXPECT_EQ(a, "0123456789abcdefghijklmnopqrstuvwxyz");
|
|
|
|
std::string str = "TEST";
|
|
StringHelper::Append(&str, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d",
|
|
"e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
|
|
"p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z");
|
|
EXPECT_EQ(str, "TEST0123456789abcdefghijklmnopqrstuvwxyz");
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, Empty) {
|
|
for (const char *t :
|
|
{"", "short string", "a very very very very very long string"}) {
|
|
EXPECT_EQ(t, StringHelper::Concat(t));
|
|
EXPECT_EQ(t, StringHelper::Concat(t, ""));
|
|
EXPECT_EQ(t, StringHelper::Concat(t, "", ""));
|
|
EXPECT_EQ(t, StringHelper::Concat(t, "", "", ""));
|
|
EXPECT_EQ(t, StringHelper::Concat(t, "", "", "", ""));
|
|
EXPECT_EQ(t, StringHelper::Concat(t, "", std::string{}, "", "", ""));
|
|
EXPECT_EQ(t, StringHelper::Concat(t, "", std::string{}, "", std::string{},
|
|
"", ""));
|
|
|
|
std::string str = t;
|
|
StringHelper::Append(&str);
|
|
EXPECT_EQ(str, t);
|
|
StringHelper::Append(&str, "");
|
|
EXPECT_EQ(str, t);
|
|
StringHelper::Append(&str, "", "");
|
|
EXPECT_EQ(str, t);
|
|
StringHelper::Append(&str, "", "", "");
|
|
EXPECT_EQ(str, t);
|
|
StringHelper::Append(&str, "", "", "", "");
|
|
EXPECT_EQ(str, t);
|
|
StringHelper::Append(&str, "", std::string{}, "", "", "");
|
|
EXPECT_EQ(str, t);
|
|
StringHelper::Append(&str, "", std::string{}, "", std::string{}, "", "");
|
|
EXPECT_EQ(str, t);
|
|
}
|
|
}
|
|
|
|
TEST(StringHelperJoinAppend, StringView) {
|
|
StringView v1 = "hello";
|
|
StringView v2 = v1;
|
|
StringView v3 = nullptr;
|
|
std::string foo = "foo";
|
|
StringView v4 = foo;
|
|
StringView v5 = "bar";
|
|
StringView v6{v1.data() + 2, 2};
|
|
auto s = StringHelper::Concat(v1, v2, v3, v4, v5, v6);
|
|
EXPECT_EQ(s, "hellohellofoobarll");
|
|
}
|
|
|
|
TEST(StringHelper, SplitWithEmptySkipped) {
|
|
std::vector<std::string> out;
|
|
|
|
ailego::StringHelper::Split("", ",", &out, true);
|
|
EXPECT_EQ(0u, out.size());
|
|
|
|
ailego::StringHelper::Split(";1;", ';', &out, true);
|
|
EXPECT_EQ(1u, out.size());
|
|
EXPECT_EQ("1", out[0]);
|
|
|
|
ailego::StringHelper::Split(";;;", ";", &out, true);
|
|
EXPECT_EQ(0u, out.size());
|
|
|
|
ailego::StringHelper::Split(";;;1", ';', &out, true);
|
|
EXPECT_EQ(1u, out.size());
|
|
EXPECT_EQ("1", out[0]);
|
|
}
|
|
|
|
} // namespace testing
|
|
} // namespace zvec::ailego
|