Daniel Carvalho has uploaded this change for review. (
https://gem5-review.googlesource.com/c/public/gem5/+/38776 )
Change subject: sim: Fix ParseParam<char> and add Parse/ShowParam tests
......................................................................
sim: Fix ParseParam<char> and add Parse/ShowParam tests
Add a GTest for the functionality of sim/serialize_handlers.hh.
Since there is a specialization for chars in showParam, there
must be a corresponding specialization for parseParam; otherwise,
the converting from one to the other and back will result in a
value that does not match the original value.
Change-Id: I1128c7adb12a3c7d091e26db13733ba45e1e61fe
Signed-off-by: Daniel R. Carvalho <oda...@yahoo.com.br>
---
M src/sim/SConscript
M src/sim/serialize_handlers.hh
A src/sim/serialize_handlers.test.cc
3 files changed, 433 insertions(+), 0 deletions(-)
diff --git a/src/sim/SConscript b/src/sim/SConscript
index 5436f78..5a2169f 100644
--- a/src/sim/SConscript
+++ b/src/sim/SConscript
@@ -87,6 +87,7 @@
GTest('byteswap.test', 'byteswap.test.cc', '../base/types.cc')
GTest('guest_abi.test', 'guest_abi.test.cc')
GTest('proxy_ptr.test', 'proxy_ptr.test.cc')
+GTest('serialize_handlers.test', 'serialize_handlers.test.cc')
if env['TARGET_ISA'] != 'null':
SimObject('InstTracer.py')
diff --git a/src/sim/serialize_handlers.hh b/src/sim/serialize_handlers.hh
index 5e5c3ff..ebd2c49 100644
--- a/src/sim/serialize_handlers.hh
+++ b/src/sim/serialize_handlers.hh
@@ -96,6 +96,24 @@
};
template <>
+struct ParseParam<char>
+{
+ static bool
+ parse(const std::string &s, char &value)
+ {
+ // In its ShowParam counterpart, characters are always printed as
+ // values, not the characters they encode. Match that behavior by
+ // accepting strings containing the integer representation of the
+ // ascii values, not the characters themselves. For example, "70",
+ // generates the character 'F' (int('F')=70).
+ int8_t aux;
+ const bool success = to_number(s, aux);
+ value = (char)aux;
+ return success;
+ }
+};
+
+template <>
struct ParseParam<std::string>
{
static bool
diff --git a/src/sim/serialize_handlers.test.cc
b/src/sim/serialize_handlers.test.cc
new file mode 100644
index 0000000..2ea790e
--- /dev/null
+++ b/src/sim/serialize_handlers.test.cc
@@ -0,0 +1,414 @@
+/*
+ * Copyright 2020 Daniel R. Carvalho
+ *
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+
+#include <cstdint>
+#include <string>
+
+#include "sim/serialize_handlers.hh"
+
+TEST(SerializeTest, ParseParamInt8)
+{
+ ParseParam<int8_t> parser;
+ int8_t value(0);
+
+ // Zero
+ EXPECT_TRUE(parser.parse("0", value));
+ EXPECT_EQ(0, value);
+
+ // Booleans
+ EXPECT_FALSE(parser.parse("true", value));
+ EXPECT_FALSE(parser.parse("false", value));
+
+ // 8-bit values
+ EXPECT_FALSE(parser.parse("255", value));
+ EXPECT_TRUE(parser.parse("-128", value));
+ EXPECT_EQ(-128, value);
+
+ // 16-bit values
+ EXPECT_FALSE(parser.parse("1000", value));
+ EXPECT_FALSE(parser.parse("-1000", value));
+
+ // 32-bit values
+ EXPECT_FALSE(parser.parse("2147483648", value));
+ EXPECT_FALSE(parser.parse("-1073741824", value));
+
+ // Doubles (scientific numbers should not be converted to integers
+ // correctly)
+ EXPECT_FALSE(parser.parse("123456.789", value));
+ EXPECT_FALSE(parser.parse("-123456.789", value));
+ EXPECT_TRUE(parser.parse("9.87654e+06", value));
+ EXPECT_EQ(9, value);
+
+ // Characters
+ EXPECT_FALSE(parser.parse("E", value));
+ EXPECT_FALSE(parser.parse("a", value));
+
+ // Strings
+ EXPECT_FALSE(parser.parse("Test", value));
+}
+
+TEST(SerializeTest, ParseParamUint32)
+{
+ ParseParam<uint32_t> parser;
+ uint32_t value(0);
+
+ // Zero
+ EXPECT_TRUE(parser.parse("0", value));
+ EXPECT_EQ(0, value);
+
+ // Booleans
+ EXPECT_FALSE(parser.parse("true", value));
+ EXPECT_FALSE(parser.parse("false", value));
+
+ // 8-bit values
+ EXPECT_TRUE(parser.parse("255", value));
+ EXPECT_EQ(255, value);
+ EXPECT_FALSE(parser.parse("-128", value));
+
+ // 16-bit values
+ EXPECT_TRUE(parser.parse("1000", value));
+ EXPECT_EQ(1000, value);
+ EXPECT_FALSE(parser.parse("-1000", value));
+
+ // 32-bit values
+ EXPECT_TRUE(parser.parse("2147483648", value));
+ EXPECT_EQ(2147483648, value);
+ EXPECT_FALSE(parser.parse("-1073741824", value));
+
+ // Doubles (scientific numbers should not be converted to integers
+ // correctly)
+ EXPECT_TRUE(parser.parse("123456.789", value));
+ EXPECT_EQ(123456, value);
+ EXPECT_FALSE(parser.parse("-123456.789", value));
+ EXPECT_TRUE(parser.parse("9.87654e+06", value));
+ EXPECT_EQ(9, value);
+
+ // Characters
+ EXPECT_FALSE(parser.parse("E", value));
+ EXPECT_FALSE(parser.parse("a", value));
+
+ // Strings
+ EXPECT_FALSE(parser.parse("Test", value));
+}
+
+TEST(SerializeTest, ParseParamDouble)
+{
+ ParseParam<double> parser;
+ double value(0.0);
+
+ // Zero
+ EXPECT_TRUE(parser.parse("0", value));
+ EXPECT_EQ(0.0, value);
+
+ // Booleans
+ EXPECT_FALSE(parser.parse("true", value));
+ EXPECT_FALSE(parser.parse("false", value));
+
+ // 8-bit values
+ EXPECT_TRUE(parser.parse("255", value));
+ EXPECT_EQ(255.0, value);
+ EXPECT_TRUE(parser.parse("-128", value));
+ EXPECT_EQ(-128.0, value);
+
+ // 16-bit values
+ EXPECT_TRUE(parser.parse("1000", value));
+ EXPECT_EQ(1000.0, value);
+ EXPECT_TRUE(parser.parse("-1000", value));
+ EXPECT_EQ(-1000.0, value);
+
+ // 32-bit values
+ EXPECT_TRUE(parser.parse("2147483648", value));
+ EXPECT_EQ(2147483648.0, value);
+ EXPECT_TRUE(parser.parse("-1073741824", value));
+ EXPECT_EQ(-1073741824.0, value);
+
+ // Doubles
+ EXPECT_TRUE(parser.parse("123456.789", value));
+ EXPECT_EQ(123456.789, value);
+ EXPECT_TRUE(parser.parse("-123456.789", value));
+ EXPECT_EQ(-123456.789, value);
+ EXPECT_TRUE(parser.parse("9.87654e+06", value));
+ EXPECT_EQ(9.87654e+06, value);
+
+ // Characters
+ EXPECT_FALSE(parser.parse("E", value));
+ EXPECT_FALSE(parser.parse("a", value));
+
+ // Strings
+ EXPECT_FALSE(parser.parse("Test", value));
+}
+
+TEST(SerializeTest, ParseParamBool)
+{
+ ParseParam<bool> parser;
+ bool value(false);
+
+ // Zero
+ EXPECT_FALSE(parser.parse("0", value));
+
+ // Booleans
+ EXPECT_TRUE(parser.parse("true", value));
+ EXPECT_EQ(true, value);
+ EXPECT_TRUE(parser.parse("false", value));
+ EXPECT_EQ(false, value);
+
+ // 8-bit values
+ EXPECT_FALSE(parser.parse("255", value));
+ EXPECT_FALSE(parser.parse("-128", value));
+
+ // 16-bit values
+ EXPECT_FALSE(parser.parse("1000", value));
+ EXPECT_FALSE(parser.parse("-1000", value));
+
+ // 32-bit values
+ EXPECT_FALSE(parser.parse("2147483648", value));
+ EXPECT_FALSE(parser.parse("-1073741824", value));
+
+ // Doubles
+ EXPECT_FALSE(parser.parse("123456.789", value));
+ EXPECT_FALSE(parser.parse("-123456.789", value));
+ EXPECT_FALSE(parser.parse("9.87654e+06", value));
+
+ // Characters
+ EXPECT_FALSE(parser.parse("E", value));
+ EXPECT_FALSE(parser.parse("a", value));
+
+ // Strings
+ EXPECT_FALSE(parser.parse("Test", value));
+}
+
+/** Characters are parsed as integers. */
+TEST(SerializeTest, ParseParamChar)
+{
+ ParseParam<char> parser;
+ char value;
+
+ // Zero
+ EXPECT_TRUE(parser.parse("48", value));
+ EXPECT_EQ('0', value);
+
+ // Booleans
+ EXPECT_FALSE(parser.parse("true", value));
+ EXPECT_FALSE(parser.parse("false", value));
+
+ // 8-bit values
+ EXPECT_FALSE(parser.parse("255", value));
+ EXPECT_TRUE(parser.parse("-128", value));
+ EXPECT_EQ(char(-128), value);
+
+ // 16-bit values
+ EXPECT_FALSE(parser.parse("1000", value));
+ EXPECT_FALSE(parser.parse("-1000", value));
+
+ // 32-bit values
+ EXPECT_FALSE(parser.parse("2147483648", value));
+ EXPECT_FALSE(parser.parse("-1073741824", value));
+
+ // Doubles
+ EXPECT_FALSE(parser.parse("123456.789", value));
+ EXPECT_FALSE(parser.parse("-123456.789", value));
+ EXPECT_TRUE(parser.parse("9.87654e+06", value));
+ EXPECT_EQ(char(9), value);
+
+ // Characters
+ EXPECT_TRUE(parser.parse("69", value));
+ EXPECT_EQ('E', value);
+ EXPECT_TRUE(parser.parse("97", value));
+ EXPECT_EQ('a', value);
+
+ // Strings
+ EXPECT_FALSE(parser.parse("Test", value));
+}
+
+TEST(SerializeTest, ParseParamString)
+{
+ ParseParam<std::string> parser;
+ std::string value("");
+
+ // Zero
+ EXPECT_TRUE(parser.parse("0", value));
+ EXPECT_EQ("0", value);
+
+ // Booleans
+ EXPECT_TRUE(parser.parse("true", value));
+ EXPECT_EQ("true", value);
+ EXPECT_TRUE(parser.parse("false", value));
+ EXPECT_EQ("false", value);
+
+ // 8-bit values
+ EXPECT_TRUE(parser.parse("255", value));
+ EXPECT_EQ("255", value);
+ EXPECT_TRUE(parser.parse("-128", value));
+ EXPECT_EQ("-128", value);
+
+ // 16-bit values
+ EXPECT_TRUE(parser.parse("1000", value));
+ EXPECT_EQ("1000", value);
+ EXPECT_TRUE(parser.parse("-1000", value));
+ EXPECT_EQ("-1000", value);
+
+ // 32-bit values
+ EXPECT_TRUE(parser.parse("2147483648", value));
+ EXPECT_EQ("2147483648", value);
+ EXPECT_TRUE(parser.parse("-1073741824", value));
+ EXPECT_EQ("-1073741824", value);
+
+ // Doubles
+ EXPECT_TRUE(parser.parse("123456.789", value));
+ EXPECT_EQ("123456.789", value);
+ EXPECT_TRUE(parser.parse("-123456.789", value));
+ EXPECT_EQ("-123456.789", value);
+ EXPECT_TRUE(parser.parse("9.87654e+06", value));
+ EXPECT_EQ("9.87654e+06", value);
+
+ // Characters
+ EXPECT_TRUE(parser.parse("E", value));
+ EXPECT_EQ("E", value);
+ EXPECT_TRUE(parser.parse("a", value));
+ EXPECT_EQ("a", value);
+
+ // Strings
+ EXPECT_TRUE(parser.parse("Test", value));
+ EXPECT_EQ("Test", value);
+}
+
+TEST(SerializeTest, ShowParamInt8)
+{
+ ShowParam<int8_t> parser;
+ std::stringstream ss;
+
+ parser.show(ss, 0);
+ EXPECT_EQ("0", ss.str());
+ ss.str("");
+ parser.show(ss, 127);
+ EXPECT_EQ("127", ss.str());
+ ss.str("");
+ parser.show(ss, -128);
+ EXPECT_EQ("-128", ss.str());
+ ss.str("");
+}
+
+TEST(SerializeTest, ShowParamUint32)
+{
+ ShowParam<uint32_t> parser;
+ std::stringstream ss;
+
+ parser.show(ss, 0);
+ EXPECT_EQ("0", ss.str());
+ ss.str("");
+ parser.show(ss, 255);
+ EXPECT_EQ("255", ss.str());
+ ss.str("");
+ parser.show(ss, 1000);
+ EXPECT_EQ("1000", ss.str());
+ ss.str("");
+ parser.show(ss, 2147483648);
+ EXPECT_EQ("2147483648", ss.str());
+ ss.str("");
+ parser.show(ss, 123456.789);
+ EXPECT_EQ("123456", ss.str());
+ ss.str("");
+ parser.show(ss, 9.87654e+06);
+ EXPECT_EQ("9876540", ss.str());
+ ss.str("");
+}
+
+/**
+ * Test converting doubles to strings. Floating numbers are expected to
+ * have 6-digit precision.
+ */
+TEST(SerializeTest, ShowParamDouble)
+{
+ ShowParam<double> parser;
+ std::stringstream ss;
+
+ parser.show(ss, 0);
+ EXPECT_EQ("0", ss.str());
+ ss.str("");
+ parser.show(ss, 255);
+ EXPECT_EQ("255", ss.str());
+ ss.str("");
+ parser.show(ss, -1000);
+ EXPECT_EQ("-1000", ss.str());
+ ss.str("");
+ parser.show(ss, 123456.789);
+ EXPECT_EQ("123457", ss.str());
+ ss.str("");
+ parser.show(ss, -123456.789);
+ EXPECT_EQ("-123457", ss.str());
+ ss.str("");
+ parser.show(ss, 1234567.89);
+ EXPECT_EQ("1.23457e+06", ss.str());
+ ss.str("");
+ parser.show(ss, -1234567.89);
+ EXPECT_EQ("-1.23457e+06", ss.str());
+ ss.str("");
+ parser.show(ss, 9.87654e+06);
+ EXPECT_EQ("9.87654e+06", ss.str());
+ ss.str("");
+}
+
+TEST(SerializeTest, ShowParamBool)
+{
+ ShowParam<bool> parser;
+ std::stringstream ss;
+
+ parser.show(ss, true);
+ EXPECT_EQ("true", ss.str());
+ ss.str("");
+ parser.show(ss, false);
+ EXPECT_EQ("false", ss.str());
+ ss.str("");
+}
+
+TEST(SerializeTest, ShowParamChar)
+{
+ ShowParam<char> parser;
+ std::stringstream ss;
+
+ parser.show(ss, 'E');
+ EXPECT_EQ("69", ss.str()); // int('E')=69
+ ss.str("");
+ parser.show(ss, 'a');
+ EXPECT_EQ("97", ss.str()); // int('a')=97
+ ss.str("");
+}
+
+TEST(SerializeTest, ShowParamString)
+{
+ ShowParam<std::string> parser;
+ std::stringstream ss;
+
+ parser.show(ss, "test");
+ EXPECT_EQ("test", ss.str());
+ ss.str("");
+ parser.show(ss, "tEsT");
+ EXPECT_EQ("tEsT", ss.str());
+ ss.str("");
+}
--
To view, visit https://gem5-review.googlesource.com/c/public/gem5/+/38776
To unsubscribe, or for help writing mail filters, visit
https://gem5-review.googlesource.com/settings
Gerrit-Project: public/gem5
Gerrit-Branch: develop
Gerrit-Change-Id: I1128c7adb12a3c7d091e26db13733ba45e1e61fe
Gerrit-Change-Number: 38776
Gerrit-PatchSet: 1
Gerrit-Owner: Daniel Carvalho <oda...@yahoo.com.br>
Gerrit-MessageType: newchange
_______________________________________________
gem5-dev mailing list -- gem5-dev@gem5.org
To unsubscribe send an email to gem5-dev-le...@gem5.org
%(web_page_url)slistinfo%(cgiext)s/%(_internal_name)s
