blob: a72ef545786169842c42d8cab288df0243b3b306 [file] [log] [blame]
/*
* Copyright (c) 2021 Daniel R. Carvalho
* 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.
*/
#include <gtest/gtest.h>
#include <sstream>
#include <string>
#include "base/gtest/cur_tick_fake.hh"
#include "base/gtest/logging.hh"
#include "base/named.hh"
#include "base/trace.hh"
using namespace gem5;
// In test SetGetLogger this logger will be assigned to be the one returned
// by Tracer::getDebugLogger(). All tests before that test should assume
// that getDebugLogger() returns a cerr-based logger, and all tests after
// that test should assume that this logger is returned
std::stringstream ss;
trace::OstreamLogger main_logger(ss);
// Instantiate the mock class to have a valid curTick of 0
GTestTickHandler tickHandler;
namespace gem5
{
namespace debug
{
/** Debug flag used for the tests in this file. */
SimpleFlag TraceTestDebugFlag("TraceTestDebugFlag",
"Exclusive debug flag for the trace tests");
} // namespace debug
} // namespace gem5
/** @return The ostream as a std::string. */
std::string
getString(std::ostream &os)
{
auto buf = os.rdbuf();
std::ostringstream oss;
oss << buf;
return oss.str();
}
/** @return The logger's ostream as a std::string. */
std::string
getString(trace::Logger *logger)
{
return getString(logger->getOstream());
}
/** Test creating a simple log message. */
TEST(TraceTest, LogSimpleMessage)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.logMessage(Tick(100), "", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Test message");
}
/** Test creating a simple log message with a name. */
TEST(TraceTest, LogMessageName)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
}
/** Test that when the tick is set to MaxTick it is not printed. */
TEST(TraceTest, LogMessageMaxTick)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.logMessage(MaxTick, "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), "Foo: Test message");
}
/** Test that by default the flag is not printed. */
TEST(TraceTest, LogMessageFlagDisabled)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.logMessage(Tick(100), "Foo", "Bar", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
}
/**
* Test creating a simple log message without tick information and that
* enabling and disabling format flags work.
*/
TEST(TraceTest, LogMessageTickDisabledAndEnableDisable)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
trace::enable();
EXPECT_TRUE(debug::changeFlag("FmtTicksOff", true));
logger.logMessage(Tick(200), "Foo", "", "Test message");
#if TRACING_ON
ASSERT_EQ(getString(&logger), "Foo: Test message");
#else
ASSERT_EQ(getString(&logger), " 200: Foo: Test message");
#endif
debug::changeFlag("FmtTicksOff", false);
trace::disable();
logger.logMessage(Tick(300), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 300: Foo: Test message");
}
/**
* Test creating a full log message to verify expected order of appearance.
* This does not include the backtrace.
*/
TEST(TraceTest, LogMessageFlagEnabled)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
trace::enable();
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
logger.logMessage(Tick(100), "Foo", "Bar", "Test message");
#if TRACING_ON
ASSERT_EQ(getString(&logger), " 100: Bar: Foo: Test message");
#else
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
#endif
debug::changeFlag("FmtFlag", false);
trace::disable();
}
/** Test that log messages are displayed for activated objects (single). */
TEST(TraceTest, LogMessageActivateOne)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch activate_foo("Foo");
ObjectMatch activate_bar("Bar");
// Activate foo.
logger.setActivate(activate_foo);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), "");
// When setting a new activate, the old activates are not kept.
logger.setActivate(activate_bar);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), "");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Bar: Test message");
}
/** Test that log messages are displayed for activated objects (multiple). */
TEST(TraceTest, LogMessageActivateMultiple)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch activate_foo("Foo");
ObjectMatch activate_bar("Bar");
ObjectMatch activate_thy("Thy");
// Activate foo and bar
logger.setActivate(activate_foo);
logger.addActivate(activate_bar);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Bar: Test message");
logger.logMessage(Tick(100), "Thy", "", "Test message");
ASSERT_EQ(getString(&logger), "");
// Make sure that when setting a new activate, the old activates
// are not kept
logger.setActivate(activate_thy);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), "");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), "");
logger.logMessage(Tick(100), "Thy", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Thy: Test message");
}
/** Test that log messages are not displayed for ignored objects (single). */
TEST(TraceTest, LogMessageIgnoreOne)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch ignore_foo("Foo");
ObjectMatch ignore_bar("Bar");
// Ignore foo
logger.setIgnore(ignore_foo);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), "");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Bar: Test message");
// Make sure that when setting a new ignore the old ignores are not kept
logger.setIgnore(ignore_bar);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), "");
}
/** Test that log messages are not displayed for ignored objects (multiple). */
TEST(TraceTest, LogMessageIgnoreMultiple)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch ignore_foo("Foo");
ObjectMatch ignore_bar("Bar");
ObjectMatch ignore_thy("Thy");
// Ignore foo and bar
logger.setIgnore(ignore_foo);
logger.addIgnore(ignore_bar);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), "");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), "");
logger.logMessage(Tick(100), "Thy", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Thy: Test message");
// Make sure that when setting a new ignore, the old sub-ignores
// are not kept
logger.setIgnore(ignore_thy);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Bar: Test message");
logger.logMessage(Tick(100), "Thy", "", "Test message");
ASSERT_EQ(getString(&logger), "");
}
/** Test that log messages are displayed properly within ignore and activate */
TEST(TraceTest, LogMessageActivateAndIgnore)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch foo("Foo");
ObjectMatch bar("Bar");
// Activate foo and ignore bar
logger.setActivate(foo);
logger.setIgnore(bar);
logger.logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
logger.logMessage(Tick(100), "Bar", "", "Test message");
ASSERT_EQ(getString(&logger), "");
logger.logMessage(Tick(100), "Thy", "", "Test message");
// When the Activate list is not empty and thy is not in the list,
// log of Thy will not be displayed.
ASSERT_EQ(getString(&logger), "");
}
/** Test that dumping for an ignored name does not log anything. */
TEST(TraceTest, DumpIgnored)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch ignore_foo("Foo");
logger.setIgnore(ignore_foo);
std::string message = "Test message";
logger.dump(Tick(100), "Foo", message.c_str(), message.size(), "");
ASSERT_EQ(getString(&logger), "");
}
/**
* Test that a regular dump will change the message so that it contains both
* the hex and char representation of every byte. There is a space between
* every 8 bytes. For each 16-byte line of a message the order of appearance is
* <byte number> <2 spaces> <8 spaced bytes> <1 space> <8 spaced bytes>
* <3-spaces missing to fill 16 bytes> <1 space> <16 bytes as chars> <\n>
*/
TEST(TraceTest, DumpSimple)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
trace::enable();
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
std::string message = "Test message";
logger.dump(Tick(100), "Foo", message.c_str(), message.size(), "Bar");
#if TRACING_ON
ASSERT_EQ(getString(&logger),
// logMessage prefix
" 100: Bar: Foo: "
// Byte number + 2 spaces
"00000000 "
// 8 bytes + 1 space + 4 bytes + ((16 - 12) * 3) spaces
"54 65 73 74 20 6d 65 73 73 61 67 65 "
// 1 space + 12 chars + \n
" Test message\n");
#else
ASSERT_EQ(getString(&logger),
// logMessage prefix
" 100: Foo: "
// Byte number + 2 spaces
"00000000 "
// 8 bytes + 1 space + 4 bytes + ((16 - 12) * 3) spaces
"54 65 73 74 20 6d 65 73 73 61 67 65 "
// 1 space + 12 chars + \n
" Test message\n");
#endif
debug::changeFlag("FmtFlag", false);
trace::disable();
}
/**
* Test that a regular dump will change the message so that it contains both
* the hex and char representation of every byte, for a multi-line message.
*/
TEST(TraceTest, DumpMultiLine)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
std::string message =
"This is a very long line that will span over multiple lines";
logger.dump(Tick(100), "Foo", message.c_str(), message.size(), "");
ASSERT_EQ(getString(&logger),
" 100: Foo: 00000000 "
"54 68 69 73 20 69 73 20 61 20 76 65 72 79 20 6c This is a very l\n"
" 100: Foo: 00000010 "
"6f 6e 67 20 6c 69 6e 65 20 74 68 61 74 20 77 69 ong line that wi\n"
" 100: Foo: 00000020 "
"6c 6c 20 73 70 61 6e 20 6f 76 65 72 20 6d 75 6c ll span over mul\n"
" 100: Foo: 00000030 "
"74 69 70 6c 65 20 6c 69 6e 65 73 tiple lines\n");
}
/**
* Test that when no logger exists a logger is created redirecting to cerr.
* This is the only test that uses cerr. All other test will use main_logger.
*/
TEST(TraceTest, DISABLED_GetNullLogger)
{
trace::Logger *logger = trace::getDebugLogger();
ASSERT_FALSE(logger == nullptr);
gtestLogOutput.str("");
logger->logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(gtestLogOutput.str(), " 100: Foo: Test message");
}
/** Test that the logger is set properly. */
TEST(TraceTest, SetGetLogger)
{
// NOTE: From now on getDebugLogger will use main_logger to avoid
// having to check cerr. This assumes that tests are run in the order
// they appear from line 1 to the last line of this file.
trace::setDebugLogger(&main_logger);
// Set message with local variable, and retrieve the string with
// the debug-logger getter
main_logger.logMessage(Tick(100), "Foo", "", "Test message");
auto logger_from_getter = trace::getDebugLogger();
ASSERT_EQ(getString(logger_from_getter), " 100: Foo: Test message");
}
/** Test that output() gets the ostream of the current debug logger. */
TEST(TraceTest, Output)
{
trace::getDebugLogger()->logMessage(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(trace::output()), " 100: Foo: Test message");
}
/** Test dprintf_flag with ignored name. */
TEST(TraceTest, DprintfFlagIgnore)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch ignore_foo("Foo");
logger.setIgnore(ignore_foo);
logger.dprintf_flag(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), "");
}
/** Test dprintf_flag with zero args. */
TEST(TraceTest, DprintfFlagZeroArgs)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.dprintf_flag(Tick(100), "Foo", "", "Test message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
}
/** Test dprintf_flag with one arg. */
TEST(TraceTest, DprintfFlagOneArg)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.dprintf_flag(Tick(100), "Foo", "", "Test %s", "message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
}
/** Test dprintf_flag with multiple args. */
TEST(TraceTest, DprintfFlagMultipleArgs)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
logger.dprintf_flag(Tick(100), "Foo", "", "Test %s %c %d %x",
"message", 'A', 217, 0x30);
ASSERT_EQ(getString(&logger), " 100: Foo: Test message A 217 30");
}
/** Test dprintf_flag with flag. */
TEST(TraceTest, DprintfFlagEnabled)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
trace::enable();
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
logger.dprintf_flag(Tick(100), "Foo", "Bar", "Test %s", "message");
#if TRACING_ON
ASSERT_EQ(getString(&logger), " 100: Bar: Foo: Test message");
#else
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
#endif
debug::changeFlag("FmtFlag", false);
trace::disable();
}
/** Test dprintf with ignored name. */
TEST(TraceTest, DprintfIgnore)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
ObjectMatch ignore_foo("Foo");
logger.setIgnore(ignore_foo);
logger.dprintf(Tick(100), "Foo", "Test message");
ASSERT_EQ(getString(&logger), "");
}
/** Test that dprintf does not have a flag. */
TEST(TraceTest, DprintfEnabled)
{
std::stringstream ss;
trace::OstreamLogger logger(ss);
trace::enable();
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
logger.dprintf(Tick(100), "Foo", "Test %s", "message");
ASSERT_EQ(getString(&logger), " 100: Foo: Test message");
debug::changeFlag("FmtFlag", false);
trace::disable();
}
/** Test that dprintf is just a flagless wrapper for dprintf_flag. */
TEST(TraceTest, DprintfWrapper)
{
std::stringstream ss, ss_flag;
trace::OstreamLogger logger(ss);
trace::OstreamLogger logger_flag(ss_flag);
logger.dprintf(Tick(100), "Foo", "Test %s %c %d %x",
"message", 'A', 217, 0x30);
logger_flag.dprintf_flag(Tick(100), "Foo", "", "Test %s %c %d %x",
"message", 'A', 217, 0x30);
ASSERT_EQ(getString(&logger), getString(&logger_flag));
}
/** Test DDUMP with tracing on. */
TEST(TraceTest, MacroDDUMP)
{
StringWrap name("Foo");
std::string message = "Test message";
// Flag enabled
trace::enable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", true));
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
DDUMP(TraceTestDebugFlag, message.c_str(), message.size());
#if TRACING_ON
ASSERT_EQ(getString(trace::output()),
" 0: TraceTestDebugFlag: Foo: 00000000 "
"54 65 73 74 20 6d 65 73 73 61 67 65 Test message\n");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
// Flag disabled
trace::disable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", false));
DDUMP(TraceTestDebugFlag, message.c_str(), message.size());
ASSERT_EQ(getString(trace::output()), "");
}
/** Test DPRINTF with tracing on. */
TEST(TraceTest, MacroDPRINTF)
{
StringWrap name("Foo");
// Flag enabled
trace::enable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", true));
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
DPRINTF(TraceTestDebugFlag, "Test message");
#if TRACING_ON
ASSERT_EQ(getString(trace::output()),
" 0: TraceTestDebugFlag: Foo: Test message");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
// Flag disabled
trace::disable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", false));
DPRINTF(TraceTestDebugFlag, "Test message");
ASSERT_EQ(getString(trace::output()), "");
}
/** Test DPRINTFS with tracing on. */
TEST(TraceTest, MacroDPRINTFS)
{
Named named("Foo");
#if TRACING_ON
Named *named_ptr = &named;
#endif
// Flag enabled
trace::enable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", true));
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
#if TRACING_ON
DPRINTFS(TraceTestDebugFlag, named_ptr, "Test message");
ASSERT_EQ(getString(trace::output()),
" 0: TraceTestDebugFlag: Foo: Test message");
#endif
// Flag disabled
trace::disable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", false));
#if TRACING_ON
DPRINTFS(TraceTestDebugFlag, named_ptr, "Test message");
ASSERT_EQ(getString(trace::output()), "");
#endif
}
/** Test DPRINTFR with tracing on. */
TEST(TraceTest, MacroDPRINTFR)
{
// Flag enabled
trace::enable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", true));
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
DPRINTFR(TraceTestDebugFlag, "Test message");
#if TRACING_ON
ASSERT_EQ(getString(trace::output()), "TraceTestDebugFlag: Test message");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
// Flag disabled
trace::disable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", false));
DPRINTFR(TraceTestDebugFlag, "Test message");
ASSERT_EQ(getString(trace::output()), "");
}
/** Test DPRINTFN with tracing on. */
TEST(TraceTest, MacroDPRINTFN)
{
StringWrap name("Foo");
DPRINTFN("Test message");
#if TRACING_ON
ASSERT_EQ(getString(trace::output()), " 0: Foo: Test message");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
}
/** Test DPRINTFNR with tracing on. */
TEST(TraceTest, MacroDPRINTFNR)
{
DPRINTFNR("Test message");
#if TRACING_ON
ASSERT_EQ(getString(trace::output()), "Test message");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
}
/** Test DPRINTF_UNCONDITIONAL with tracing on. */
TEST(TraceTest, MacroDPRINTF_UNCONDITIONAL)
{
StringWrap name("Foo");
// Flag enabled
trace::enable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", true));
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
DPRINTF_UNCONDITIONAL(TraceTestDebugFlag, "Test message");
#if TRACING_ON
ASSERT_EQ(getString(trace::output()),
" 0: TraceTestDebugFlag: Foo: Test message");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
// Flag disabled
trace::disable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", false));
DPRINTF_UNCONDITIONAL(TraceTestDebugFlag, "Test message");
#if TRACING_ON
ASSERT_EQ(getString(trace::output()), " 0: Foo: Test message");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
}
/**
* Test that there is a global name() to fall through when a locally scoped
* name() is not defined.
*/
TEST(TraceTest, GlobalName)
{
// Flag enabled
trace::enable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", true));
EXPECT_TRUE(debug::changeFlag("FmtFlag", true));
DPRINTF(TraceTestDebugFlag, "Test message");
#if TRACING_ON
ASSERT_EQ(getString(trace::output()),
" 0: TraceTestDebugFlag: global: Test message");
#else
ASSERT_EQ(getString(trace::output()), "");
#endif
// Flag disabled
trace::disable();
EXPECT_TRUE(debug::changeFlag("TraceTestDebugFlag", false));
DPRINTF(TraceTestDebugFlag, "Test message");
ASSERT_EQ(getString(trace::output()), "");
}