Bobby R. Bruce has submitted this change. (
https://gem5-review.googlesource.com/c/public/gem5/+/22084 )
Change subject: tests: Added GTests for base/str.cc
......................................................................
tests: Added GTests for base/str.cc
Adding these tests supercedes the unittest/strnumtest.cc
and unittest/tokentest.cc tests. They have thereby been removed.
Function "to_number" in base/str.hh previously failed to cast negative
float/double numbers. This was due to the use of
std::numeric_limits<T>::min() instead of std::numeric_limits<T>::lowest()
to determine whether a string-to-float/double conversion was
"Out of range". Tests "StrTest.ToNumberFloatNegative" and
"StrTest.ToNumberDoubleNegative" exposed this bug. It has been fixed.
Methods "split_first" and "split_last" in base/str.hh have had their
documentation updated to remove abiguity in their functionality.
Change-Id: I16e0fe40d884e22dd010db4045857eb6e7f33d4a
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/22084
Reviewed-by: Daniel Carvalho <oda...@yahoo.com.br>
Maintainer: Jason Lowe-Power <ja...@lowepower.com>
Tested-by: kokoro <noreply+kok...@google.com>
---
M src/base/SConscript
M src/base/str.hh
A src/base/str.test.cc
M src/unittest/SConscript
D src/unittest/strnumtest.cc
D src/unittest/tokentest.cc
6 files changed, 470 insertions(+), 166 deletions(-)
Approvals:
Daniel Carvalho: Looks good to me, approved
Jason Lowe-Power: Looks good to me, approved
kokoro: Regressions pass
diff --git a/src/base/SConscript b/src/base/SConscript
index ca81822..d6615be 100644
--- a/src/base/SConscript
+++ b/src/base/SConscript
@@ -71,6 +71,7 @@
Source('socket.cc')
Source('statistics.cc')
Source('str.cc')
+GTest('str.test', 'str.test.cc', 'str.cc')
Source('time.cc')
Source('trace.cc')
GTest('trie.test', 'trie.test.cc')
diff --git a/src/base/str.hh b/src/base/str.hh
index 1ea18b7..48fccc8 100644
--- a/src/base/str.hh
+++ b/src/base/str.hh
@@ -85,12 +85,14 @@
}
// Split the string s into lhs and rhs on the first occurence of the
-// character c.
+// character c. Character c is not included in either lhs or rhs. If
+// character c is not contained within string s, lsh equals s.
bool
split_first(const std::string &s, std::string &lhs, std::string &rhs, char
c);
// Split the string s into lhs and rhs on the last occurence of the
-// character c.
+// character c. Character c is not included in either lhs or rhs. If
+// character c is not contained within string s, lhs equals s.
bool
split_last(const std::string &s, std::string &lhs, std::string &rhs, char
c);
@@ -115,8 +117,10 @@
{
// start big and narrow it down if needed, determine the base
dynamically
long long r = std::stoll(value, nullptr, 0);
- if (r < std::numeric_limits<T>::min() || r >
std::numeric_limits<T>::max())
+ if (r < std::numeric_limits<T>::lowest()
+ || r > std::numeric_limits<T>::max()) {
throw std::out_of_range("Out of range");
+ }
return static_cast<T>(r);
}
@@ -146,8 +150,10 @@
{
// start big and narrow it down if needed
long double r = std::stold(value);
- if (r < std::numeric_limits<T>::min() || r >
std::numeric_limits<T>::max())
+ if (r < std::numeric_limits<T>::lowest()
+ || r > std::numeric_limits<T>::max()) {
throw std::out_of_range("Out of range");
+ }
return static_cast<T>(r);
}
/** @} */
diff --git a/src/base/str.test.cc b/src/base/str.test.cc
new file mode 100644
index 0000000..05af5d7
--- /dev/null
+++ b/src/base/str.test.cc
@@ -0,0 +1,459 @@
+/*
+ * Copyright (c) 2019 The Regents of the University of California
+ * All rights reserved
+ *
+ * The license below extends only to copyright in the software and shall
+ * not be construed as granting a license to any other intellectual
+ * property including but not limited to intellectual property relating
+ * to a hardware implementation of the functionality of the software
+ * licensed hereunder. You may use the software subject to the license
+ * terms below provided that you ensure that this notice is replicated
+ * unmodified and in its entirety in all distributions of the software,
+ * modified or unmodified, in source code or in binary form.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Bobby R. Bruce
+ */
+
+#include <gtest/gtest.h>
+
+#include "base/str.hh"
+
+/*
+ * str.cc has "eat_lead_white", "eat_end_white", and "eat_white" fucntions
to
+ * remove leading and trailing whitespace. The following tests verify this
+ * behavior.
+ */
+TEST(StrTest, EatLeadWhite)
+{
+ std::string val = " hello there ";
+ eat_lead_white(val);
+ EXPECT_EQ("hello there ", val);
+}
+
+TEST(StrTest, EatLeadWhiteNoLeadingWhitespace)
+{
+ std::string val = "hello there ";
+ eat_lead_white(val);
+ EXPECT_EQ("hello there ", val);
+}
+
+TEST(StrTest, EatEndWhite)
+{
+ std::string val = " hello there ";
+ eat_end_white(val);
+ EXPECT_EQ(" hello there", val);
+}
+
+TEST(StrTest, EatEndWhiteNoTrailingWhitespace)
+{
+ std::string val = " hello there";
+ eat_end_white(val);
+ EXPECT_EQ(" hello there", val);
+}
+
+TEST(StrTest, EatWhite)
+{
+ std::string val = " hello there ";
+ eat_white(val);
+ EXPECT_EQ("hello there", val);
+}
+
+TEST(StrTest, EatWhiteNoWhitespace)
+{
+ std::string val = "hello there";
+ eat_lead_white(val);
+ EXPECT_EQ("hello there", val);
+}
+
+/*
+ * This tests checks that str.cc's "to_lower" function converts a string to
+ * lowercase.
+ */
+TEST(StrTest, ToLower)
+{
+ std::string val = "gOoDbYe FOO@barr!";
+ to_lower("goodbye foo@bar!");
+}
+
+/*
+ * str.cc's "split_first" and "split_last" fucntions split a string on a
+ * character into two parts. "split_first" splits on the first instance of
+ * this character and "split_last" splits on the last instance of this
+ * character. The character itself is not included in either of the output
+ * right-hand side and left-hand side strings. If the character cannot be
+ * found in the string then the left-hand side string is equal to the input
+ * string and the right-hand side string is empty.
+ */
+TEST(StrTest, SplitFirst)
+{
+ std::string val = "abcdefg abcdefg";
+ std::string lhs;
+ std::string rhs;
+
+ split_first(val , lhs, rhs, 'f');
+ EXPECT_EQ("abcdefg abcdefg", val);
+ EXPECT_EQ("abcde", lhs);
+ EXPECT_EQ("g abcdefg", rhs);
+}
+
+TEST(StrTest, SplitFirstNoChar)
+{
+ std::string val = "abcdefg abcdefg";
+ std::string lhs;
+ std::string rhs;
+
+ split_first(val , lhs, rhs, 'h');
+ EXPECT_EQ("abcdefg abcdefg", val);
+ EXPECT_EQ("abcdefg abcdefg", lhs);
+ EXPECT_EQ("", rhs);
+}
+
+TEST(StrTest, SplitFirstOnFirstChar)
+{
+ std::string val = "abcdefg abcdefg";
+ std::string lhs;
+ std::string rhs;
+
+ split_first(val , lhs, rhs, 'a');
+ EXPECT_EQ("abcdefg abcdefg", val);
+ EXPECT_EQ("", lhs);
+ EXPECT_EQ("bcdefg abcdefg", rhs);
+}
+
+TEST(StrTest, SplitLast)
+{
+ std::string val = "abcdefg abcdefg";
+ std::string lhs;
+ std::string rhs;
+
+ split_last(val , lhs, rhs, 'f');
+ EXPECT_EQ("abcdefg abcdefg", val);
+ EXPECT_EQ("abcdefg abcde", lhs);
+ EXPECT_EQ("g", rhs);
+}
+
+TEST(StrTest, SplitLastNoChar)
+{
+ std::string val = "abcdefg abcdefg";
+ std::string lhs;
+ std::string rhs;
+
+ split_last(val , lhs, rhs, 'h');
+ EXPECT_EQ("abcdefg abcdefg", val);
+ EXPECT_EQ("abcdefg abcdefg", lhs);
+ EXPECT_EQ("", rhs);
+}
+
+TEST(StrTest, SplitLastOnLastChar)
+{
+ std::string val = "abcdefg abcdefg";
+ std::string lhs;
+ std::string rhs;
+
+ split_last(val , lhs, rhs, 'g');
+ EXPECT_EQ("abcdefg abcdefg", val);
+ EXPECT_EQ("abcdefg abcdef", lhs);
+ EXPECT_EQ("", rhs);
+}
+
+
+/*
+ * str.cc's "tokenize" function splits a string into its constituent
tokens.
+ * It splits based on an input character.
+ */
+TEST(StrTest, TokenizeOnSpace)
+{
+ /*
+ * val has a double space between each token with trailing and leading
+ * whitespace.
+ */
+ std::string val = " Hello, this is a sentence. ";
+ std::vector<std::string> tokens;
+
+ /*
+ * By default 'ign' is true. This means empty tokens are not included
in
+ * the output list.
+ */
+ tokenize(tokens, val, ' ');
+ EXPECT_EQ(" Hello, this is a sentence. ", val);
+ EXPECT_EQ(5, tokens.size());
+ EXPECT_EQ("Hello,", tokens[0]);
+ EXPECT_EQ("this", tokens[1]);
+ EXPECT_EQ("is", tokens[2]);
+ EXPECT_EQ("a", tokens[3]);
+ EXPECT_EQ("sentence.", tokens[4]);
+}
+
+TEST(StrTest, TokenizeOnSpaceIgnFalse)
+{
+ /*
+ * val has a double space between each token with trailing and leading
+ * whitespace.
+ */
+ std::string val = " Hello, this is a sentence. ";
+ std::vector<std::string> tokens;
+
+ tokenize(tokens, val, ' ', false);
+ EXPECT_EQ(" Hello, this is a sentence. ", val);
+ EXPECT_EQ(11, tokens.size());
+ EXPECT_EQ("", tokens[0]);
+ EXPECT_EQ("Hello,", tokens[1]);
+ EXPECT_EQ("", tokens[2]);
+ EXPECT_EQ("this", tokens[3]);
+ EXPECT_EQ("", tokens[4]);
+ EXPECT_EQ("is", tokens[5]);
+ EXPECT_EQ("", tokens[6]);
+ EXPECT_EQ("a", tokens[7]);
+ EXPECT_EQ("", tokens[8]);
+ EXPECT_EQ("sentence.", tokens[9]);
+ EXPECT_EQ("", tokens[10]);
+}
+
+TEST(StrTest, TokenizedTokenDoesNotExist)
+{
+ std::string val = "abcdefg";
+ std::vector<std::string> tokens;
+
+ tokenize(tokens, val, 'h');
+ EXPECT_EQ("abcdefg", val);
+ EXPECT_EQ(1, tokens.size());
+ EXPECT_EQ("abcdefg", tokens[0]);
+}
+
+/*
+ * str.cc's "to_number" function converts a string to a number. The
function
+ * will return false if this is not possible either because the string
+ * represents a number out-of-range, or because the string cannot be
parsed.
+ */
+TEST(StrTest, ToNumber8BitInt)
+{
+ int8_t output;
+ std::string input = "-128";
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(-128, output);
+}
+
+TEST(StrTest, ToNumber8BitIntStringOutOfRange)
+{
+ int8_t output;
+ std::string input = "-129";
+ EXPECT_FALSE(to_number(input, output));
+}
+
+TEST(StrTest, ToNumber8BitIntInvalidString)
+{
+ int8_t output;
+ std::string input = "onetwoeight";
+ EXPECT_FALSE(to_number(input, output));
+}
+
+TEST(StrTest, ToNumberUnsigned8BitInt)
+{
+ uint8_t output;
+ std::string input = "255";
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(255, output);
+}
+
+TEST(StrTest, ToNumberUnsigned8BitIntNegative)
+{
+ uint8_t output;
+ std::string input = "-1";
+ EXPECT_FALSE(to_number(input, output));
+}
+
+TEST(StrTest, ToNumber64BitInt)
+{
+ int64_t output;
+ int64_t input_number = 0xFFFFFFFFFFFFFFFF;
+ std::string input = std::to_string(input_number);
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(input_number, output);
+}
+
+TEST(StrTest, ToNumber64BitIntInvalidString)
+{
+ int64_t output;
+ std::string input = " ";
+ EXPECT_FALSE(to_number(input, output));
+}
+
+TEST(StrTest, ToNumberFloat)
+{
+ float output;
+ std::string input = "0.1";
+ float expected_output = 0.1;
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(expected_output, output);
+}
+
+TEST(StrTest, ToNumberFloatIntegerString)
+{
+ float output;
+ std::string input = "10";
+ float expected_output = 10.0;
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(expected_output, output);
+}
+
+TEST(StrTest, ToNumberFloatNegative)
+{
+ float output;
+ std::string input = "-0.1";
+ float expected_output = -0.1;
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(expected_output, output);
+}
+
+TEST(StrTest, ToNumberDouble)
+{
+ double output;
+ std::string input = "0.0001";
+ double expected_output = 0.0001;
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(expected_output, output);
+}
+
+TEST(StrTest, ToNumberDoubleIntegerString)
+{
+ double output;
+ std::string input = "12345";
+ double expected_output = 12345.0;
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(expected_output, output);
+}
+
+TEST(StrTest, ToNumberDoubleNegative)
+{
+ double output;
+ std::string input = "-1.2345";
+ double expected_output = -1.2345;
+ EXPECT_TRUE(to_number(input, output));
+ EXPECT_EQ(expected_output, output);
+}
+
+/*
+ * The "to_bool" function takes a string, "true" or "false"
+ * (case-insenstive), and sets the second argument to the bool equivilent.
+ * The function will return false if it cannot parse the string.
+ */
+TEST(StrTest, ToBoolTrue)
+{
+ bool output = false;
+ EXPECT_TRUE(to_bool("TrUe", output));
+ EXPECT_TRUE(output);
+}
+
+TEST(StrTest, ToBoolFalse){
+ bool output = true;
+ EXPECT_TRUE(to_bool("fAlSe", output));
+ EXPECT_FALSE(output);
+}
+
+TEST(StrTest, ToBoolInvalidInput)
+{
+ bool output;
+ EXPECT_FALSE(to_bool("falsify", output));
+}
+
+/*
+ * The "quote" function take a string and returns that string quoted (i.e.,
+ * between double-quotes) if the string contains a space.
+ */
+TEST(StrTest, QuoteStringNoSpace)
+{
+ EXPECT_EQ("hello", quote("hello"));
+}
+
+TEST(StrTest, QuoteStringWithSpace)
+{
+ EXPECT_EQ("\"hello world\"", quote("hello world"));
+}
+
+TEST(StrTest, QuoteQuotedString)
+{
+ /*
+ * At present, a quoted string can be quoted again.
+ */
+ EXPECT_EQ("\"\"hello world\"\"", quote("\"hello world\""));
+}
+
+TEST(StrTest, QuoteStringWithTab)
+{
+ /*
+ * The "quote" function only works with standard space, not any
+ * whitepsace.
+ */
+ EXPECT_EQ("hello\tworld", quote("hello\tworld"));
+}
+
+/*
+ * str.hh has three implementations of "startswith"; a function that takes
+ * string and a prefix and returns true if the string starts with the
prefix.
+ * One implementation takes two strings, another takes two char*, and the
+ * third takes a string and a char* as a prefix.
+ */
+TEST(StrTest, StartswithDoubleStringDoesStartWith)
+{
+ std::string s = "Hello, how are you?";
+ std::string prefix = "Hello";
+ EXPECT_TRUE(startswith(s, prefix));
+}
+
+TEST(StrTest, StartswithDoubleStringDoesNotStartWith)
+{
+ std::string s = "Hello, how are you?";
+ std::string prefix = "ello";
+ EXPECT_FALSE(startswith(s, prefix));
+}
+
+TEST(StrTest, StartswithDoubleCharArrayDoesStartWith)
+{
+ const char* s = "abcdefg";
+ const char* prefix = "ab";
+ EXPECT_TRUE(startswith(s, prefix));
+}
+
+TEST(StrTest, StartswithDoubleCharArrayDoesNotStartWith)
+{
+ const char* s = " abcdefg";
+ const char* prefix = "a";
+ EXPECT_FALSE(startswith(s, prefix));
+}
+
+TEST(StrTest, StartswithStringCharArrayDoesStartWith)
+{
+ std::string s = "foobarr";
+ const char* prefix = "f";
+ EXPECT_TRUE(startswith(s, prefix));
+}
+
+TEST(StrTest, StartswithStringCharArrayDoesNotStartWith)
+{
+ std::string s = "foobarr";
+ const char* prefix = "barr";
+ EXPECT_FALSE(startswith(s, prefix));
+}
\ No newline at end of file
diff --git a/src/unittest/SConscript b/src/unittest/SConscript
index f437a1d..0ca0702 100644
--- a/src/unittest/SConscript
+++ b/src/unittest/SConscript
@@ -35,10 +35,8 @@
UnitTest('cprintftime', 'cprintftime.cc')
UnitTest('nmtest', 'nmtest.cc')
UnitTest('refcnttest', 'refcnttest.cc')
-UnitTest('strnumtest', 'strnumtest.cc')
stattest_py = PySource('m5', 'stattestmain.py', tags='stattest')
UnitTest('stattest', 'stattest.cc', with_tag('stattest'), main=True)
UnitTest('symtest', 'symtest.cc')
-UnitTest('tokentest', 'tokentest.cc')
diff --git a/src/unittest/strnumtest.cc b/src/unittest/strnumtest.cc
deleted file mode 100644
index 0e23488..0000000
--- a/src/unittest/strnumtest.cc
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2002-2005 The Regents of The University of Michigan
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Authors: Nathan Binkert
- */
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "base/str.hh"
-
-using namespace std;
-
-int
-main(int argc, char *argv[])
-{
- if (argc != 2) {
- cout << "Usage: " << argv[0] << " <number>\n";
- exit(1);
- }
-
- string s = argv[1];
-
-#define OUTVAL(valtype, type) do { \
- valtype value; \
- cout << "TYPE = " #valtype "\n"; \
- if (to_number(s, value)) { \
- cout << "Number(" << s << ") = " << dec \
- << (unsigned long long)(unsigned type)value << "\n" \
- << "Number(" << s << ") = " << dec \
- << (signed long long)(signed type)value << "\n" \
- << "Number(" << s << ") = 0x" << hex \
- << (unsigned long long)(unsigned type)value << "\n" \
- << "Number(" << s << ") = 0" << oct \
- << (unsigned long long)(unsigned type)value << "\n\n"; \
- } else \
- cout << "Number(" << s << ") is invalid\n\n"; \
- } while (0)
-
- OUTVAL(signed long long, long long);
- OUTVAL(unsigned long long, long long);
- OUTVAL(signed long, long);
- OUTVAL(unsigned long, long);
- OUTVAL(signed int, int);
- OUTVAL(unsigned int, int);
- OUTVAL(signed short, short);
- OUTVAL(unsigned short, short);
- OUTVAL(signed char, char);
- OUTVAL(unsigned char, char);
-
- return 0;
-}
diff --git a/src/unittest/tokentest.cc b/src/unittest/tokentest.cc
deleted file mode 100644
index 128346b..0000000
--- a/src/unittest/tokentest.cc
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2002-2005 The Regents of The University of Michigan
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Authors: Nathan Binkert
- */
-
-#include <iostream>
-#include <string>
-#include <vector>
-
-#include "base/str.hh"
-
-int
-main(int argc, char *argv[])
-{
- using namespace std;
-
- if (argc != 3) {
- cout << "Usage: " << argv[0] << " <string> <token>\n";
- exit(1);
- }
-
- int i;
- string test = argv[1];
- vector<string> tokens1;
- vector<string> tokens2;
- char token = argv[2][0];
-
- cout << "string = \"" << test << "\", token = \'" << token << "\'\n";
- cout << "testing without ignore\n";
- tokenize(tokens1, test, token, false);
-
- if (tokens1.size()) {
- int size = tokens1.size();
- cout << "size = " << size << "\n";
- for (i = 0; i < size; i++) {
- cout << "'" << tokens1[i] << "' (" << tokens1[i].size()
- << ")" << ((i == size - 1) ? "\n" : ", ");
- }
- } else {
- cout << "no tokens" << endl;
- }
-
- cout << "testing with ignore\n";
- tokenize(tokens2, test, token, true);
-
- if (tokens2.size()) {
- int size = tokens2.size();
- cout << "size = " << size << "\n";
- for (i = 0; i < size; i++) {
- cout << "'" << tokens2[i] << "' (" << tokens2[i].size()
- << ")" << ((i == size - 1) ? "\n" : ", ");
- }
- } else {
- cout << "no tokens" << endl;
- }
-
- return 0;
-}
--
To view, visit https://gem5-review.googlesource.com/c/public/gem5/+/22084
To unsubscribe, or for help writing mail filters, visit
https://gem5-review.googlesource.com/settings
Gerrit-Project: public/gem5
Gerrit-Branch: master
Gerrit-Change-Id: I16e0fe40d884e22dd010db4045857eb6e7f33d4a
Gerrit-Change-Number: 22084
Gerrit-PatchSet: 4
Gerrit-Owner: Bobby R. Bruce <bbr...@ucdavis.edu>
Gerrit-Reviewer: Andreas Sandberg <andreas.sandb...@arm.com>
Gerrit-Reviewer: Bobby R. Bruce <bbr...@ucdavis.edu>
Gerrit-Reviewer: Daniel Carvalho <oda...@yahoo.com.br>
Gerrit-Reviewer: Jason Lowe-Power <ja...@lowepower.com>
Gerrit-Reviewer: Steve Reinhardt <ste...@gmail.com>
Gerrit-Reviewer: kokoro <noreply+kok...@google.com>
Gerrit-MessageType: merged
_______________________________________________
gem5-dev mailing list
gem5-dev@gem5.org
http://m5sim.org/mailman/listinfo/gem5-dev
