From: Aina Niemetz Date: Mon, 1 Mar 2021 14:46:01 +0000 (-0800) Subject: google test: util: Migrate output_black. (#6025) X-Git-Tag: cvc5-1.0.0~2184 X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=4a8e64cb22d4cc2a51035a71a5d6d37dc2f69a6b;p=cvc5.git google test: util: Migrate output_black. (#6025) --- diff --git a/test/unit/util/CMakeLists.txt b/test/unit/util/CMakeLists.txt index 1358e6468..36def716d 100644 --- a/test/unit/util/CMakeLists.txt +++ b/test/unit/util/CMakeLists.txt @@ -26,7 +26,7 @@ cvc4_add_cxx_unit_test_black(floatingpoint_black util) endif() cvc4_add_unit_test_black(integer_black util) cvc4_add_unit_test_white(integer_white util) -cvc4_add_cxx_unit_test_black(output_black util) +cvc4_add_unit_test_black(output_black util) cvc4_add_cxx_unit_test_black(rational_black util) cvc4_add_cxx_unit_test_white(rational_white util) if(CVC4_USE_POLY_IMP) diff --git a/test/unit/util/output_black.cpp b/test/unit/util/output_black.cpp new file mode 100644 index 000000000..120976dcc --- /dev/null +++ b/test/unit/util/output_black.cpp @@ -0,0 +1,244 @@ +/********************* */ +/*! \file output_black.cpp + ** \verbatim + ** Top contributors (to current version): + ** Aina Niemetz, Morgan Deters, Tim King + ** This file is part of the CVC4 project. + ** Copyright (c) 2009-2020 by the authors listed in the file AUTHORS + ** in the top-level source directory and their institutional affiliations. + ** All rights reserved. See the file COPYING in the top-level source + ** directory for licensing information.\endverbatim + ** + ** \brief Black box testing of CVC4 output classes. + ** + ** Black box testing of CVC4 output classes. + **/ + +#include +#include + +#include "base/output.h" +#include "test.h" + +namespace CVC4 { +namespace test { + +class TestUtilBlackOutput : public TestInternal +{ + protected: + void SetUp() override + { + TestInternal::SetUp(); + DebugChannel.setStream(&d_debugStream); + TraceChannel.setStream(&d_traceStream); + NoticeChannel.setStream(&d_noticeStream); + ChatChannel.setStream(&d_chatStream); + MessageChannel.setStream(&d_messageStream); + WarningChannel.setStream(&d_warningStream); + + d_debugStream.str(""); + d_traceStream.str(""); + d_noticeStream.str(""); + d_chatStream.str(""); + d_messageStream.str(""); + d_warningStream.str(""); + } + + int32_t failure() + { + // this represents an expensive function that should NOT be called + // when debugging/tracing is turned off + std::cout << "a function was evaluated under an output operation when it " + "should not have been"; + assert(false); + return 0; + } + std::stringstream d_debugStream; + std::stringstream d_traceStream; + std::stringstream d_noticeStream; + std::stringstream d_chatStream; + std::stringstream d_messageStream; + std::stringstream d_warningStream; +}; + +TEST_F(TestUtilBlackOutput, output) +{ + Debug.on("foo"); + Debug("foo") << "testing1"; + Debug.off("foo"); + Debug("foo") << "testing2"; + Debug.on("foo"); + Debug("foo") << "testing3"; + + CVC4Message() << "a message"; + Warning() << "bad warning!"; + Chat() << "chatty"; + Notice() << "note"; + + Trace.on("foo"); + Trace("foo") << "tracing1"; + Trace.off("foo"); + Trace("foo") << "tracing2"; + Trace.on("foo"); + Trace("foo") << "tracing3"; + +#ifdef CVC4_MUZZLE + + ASSERT_EQ(d_debugStream.str(), ""); + ASSERT_EQ(d_messageStream.str(), ""); + ASSERT_EQ(d_warningStream.str(), ""); + ASSERT_EQ(d_chatStream.str(), ""); + ASSERT_EQ(d_noticeStream.str(), ""); + ASSERT_EQ(d_traceStream.str(), ""); + +#else /* CVC4_MUZZLE */ + +#ifdef CVC4_DEBUG + ASSERT_EQ(d_debugStream.str(), "testing1testing3"); +#else /* CVC4_DEBUG */ + ASSERT_EQ(d_debugStream.str(), ""); +#endif /* CVC4_DEBUG */ + + ASSERT_EQ(d_messageStream.str(), "a message"); + ASSERT_EQ(d_warningStream.str(), "bad warning!"); + ASSERT_EQ(d_chatStream.str(), "chatty"); + ASSERT_EQ(d_noticeStream.str(), "note"); + +#ifdef CVC4_TRACING + ASSERT_EQ(d_traceStream.str(), "tracing1tracing3"); +#else /* CVC4_TRACING */ + ASSERT_EQ(d_traceStream.str(), ""); +#endif /* CVC4_TRACING */ + +#endif /* CVC4_MUZZLE */ +} + +TEST_F(TestUtilBlackOutput, evaluation_off_when_it_is_supposed_to_be) +{ + Debug.on("foo"); +#ifndef CVC4_DEBUG + ASSERT_FALSE(Debug.isOn("foo")); + Debug("foo") << failure() << endl; +#else + ASSERT_TRUE(Debug.isOn("foo")); +#endif + Debug.off("foo"); + + Trace.on("foo"); +#ifndef CVC4_TRACING + ASSERT_FALSE(Trace.isOn("foo")); + Trace("foo") << failure() << endl; +#else + ASSERT_TRUE(Trace.isOn("foo")); +#endif + Trace.off("foo"); + +#ifdef CVC4_MUZZLE + ASSERT_FALSE(Debug.isOn("foo")); + ASSERT_FALSE(Trace.isOn("foo")); + ASSERT_FALSE(Warning.isOn()); + ASSERT_FALSE(CVC4Message.isOn()); + ASSERT_FALSE(Notice.isOn()); + ASSERT_FALSE(Chat.isOn()); + + cout << "debug" << std::endl; + Debug("foo") << failure() << endl; + cout << "trace" << std::endl; + Trace("foo") << failure() << endl; + cout << "warning" << std::endl; + Warning() << failure() << endl; + cout << "message" << std::endl; + CVC4Message() << failure() << endl; + cout << "notice" << std::endl; + Notice() << failure() << endl; + cout << "chat" << std::endl; + Chat() << failure() << endl; +#endif +} + +TEST_F(TestUtilBlackOutput, simple_print) +{ +#ifdef CVC4_MUZZLE + + Debug.off("yo"); + Debug("yo") << "foobar"; + ASSERT_EQ(d_debugStream.str(), std::string()); + d_debugStream.str(""); + Debug.on("yo"); + Debug("yo") << "baz foo"; + ASSERT_EQ(d_debugStream.str(), std::string()); + d_debugStream.str(""); + + Trace.off("yo"); + Trace("yo") << "foobar"; + ASSERT_EQ(d_traceStream.str(), std::string()); + d_traceStream.str(""); + Trace.on("yo"); + Trace("yo") << "baz foo"; + ASSERT_EQ(d_traceStream.str(), std::string()); + d_traceStream.str(""); + + Warning() << "baz foo"; + ASSERT_EQ(d_warningStream.str(), std::string()); + d_warningStream.str(""); + + Chat() << "baz foo"; + ASSERT_EQ(d_chatStream.str(), std::string()); + d_chatStream.str(""); + + CVC4Message() << "baz foo"; + ASSERT_EQ(d_messageStream.str(), std::string()); + d_messageStream.str(""); + + Notice() << "baz foo"; + ASSERT_EQ(d_noticeStream.str(), std::string()); + d_noticeStream.str(""); + +#else /* CVC4_MUZZLE */ + + Debug.off("yo"); + Debug("yo") << "foobar"; + ASSERT_EQ(d_debugStream.str(), std::string()); + d_debugStream.str(""); + Debug.on("yo"); + Debug("yo") << "baz foo"; +#ifdef CVC4_DEBUG + ASSERT_EQ(d_debugStream.str(), std::string("baz foo")); +#else /* CVC4_DEBUG */ + ASSERT_EQ(d_debugStream.str(), std::string()); +#endif /* CVC4_DEBUG */ + d_debugStream.str(""); + + Trace.off("yo"); + Trace("yo") << "foobar"; + ASSERT_EQ(d_traceStream.str(), std::string()); + d_traceStream.str(""); + Trace.on("yo"); + Trace("yo") << "baz foo"; +#ifdef CVC4_TRACING + ASSERT_EQ(d_traceStream.str(), std::string("baz foo")); +#else /* CVC4_TRACING */ + ASSERT_EQ(d_traceStream.str(), std::string()); +#endif /* CVC4_TRACING */ + d_traceStream.str(""); + + Warning() << "baz foo"; + ASSERT_EQ(d_warningStream.str(), std::string("baz foo")); + d_warningStream.str(""); + + Chat() << "baz foo"; + ASSERT_EQ(d_chatStream.str(), std::string("baz foo")); + d_chatStream.str(""); + + CVC4Message() << "baz foo"; + ASSERT_EQ(d_messageStream.str(), std::string("baz foo")); + d_messageStream.str(""); + + Notice() << "baz foo"; + ASSERT_EQ(d_noticeStream.str(), std::string("baz foo")); + d_noticeStream.str(""); + +#endif /* CVC4_MUZZLE */ +} +} // namespace test +} // namespace CVC4 diff --git a/test/unit/util/output_black.h b/test/unit/util/output_black.h deleted file mode 100644 index 298aad812..000000000 --- a/test/unit/util/output_black.h +++ /dev/null @@ -1,243 +0,0 @@ -/********************* */ -/*! \file output_black.h - ** \verbatim - ** Top contributors (to current version): - ** Morgan Deters, Tim King, Aina Niemetz - ** This file is part of the CVC4 project. - ** Copyright (c) 2009-2020 by the authors listed in the file AUTHORS - ** in the top-level source directory and their institutional affiliations. - ** All rights reserved. See the file COPYING in the top-level source - ** directory for licensing information.\endverbatim - ** - ** \brief Black box testing of CVC4 output classes. - ** - ** Black box testing of CVC4 output classes. - **/ - -#include - -#include -#include - -#include "base/output.h" - -using namespace CVC4; -using namespace std; - -class OutputBlack : public CxxTest::TestSuite { - - stringstream d_debugStream; - stringstream d_traceStream; - stringstream d_noticeStream; - stringstream d_chatStream; - stringstream d_messageStream; - stringstream d_warningStream; - - public: - void setUp() override - { - DebugChannel.setStream(&d_debugStream); - TraceChannel.setStream(&d_traceStream); - NoticeChannel.setStream(&d_noticeStream); - ChatChannel.setStream(&d_chatStream); - MessageChannel.setStream(&d_messageStream); - WarningChannel.setStream(&d_warningStream); - - d_debugStream.str(""); - d_traceStream.str(""); - d_noticeStream.str(""); - d_chatStream.str(""); - d_messageStream.str(""); - d_warningStream.str(""); - } - - void tearDown() override {} - - void testOutput() { - Debug.on("foo"); - Debug("foo") << "testing1"; - Debug.off("foo"); - Debug("foo") << "testing2"; - Debug.on("foo"); - Debug("foo") << "testing3"; - - CVC4Message() << "a message"; - Warning() << "bad warning!"; - Chat() << "chatty"; - Notice() << "note"; - - Trace.on("foo"); - Trace("foo") << "tracing1"; - Trace.off("foo"); - Trace("foo") << "tracing2"; - Trace.on("foo"); - Trace("foo") << "tracing3"; - -#ifdef CVC4_MUZZLE - - TS_ASSERT( d_debugStream.str() == "" ); - TS_ASSERT( d_messageStream.str() == "" ); - TS_ASSERT( d_warningStream.str() == "" ); - TS_ASSERT( d_chatStream.str() == "" ); - TS_ASSERT( d_noticeStream.str() == "" ); - TS_ASSERT( d_traceStream.str() == "" ); - -#else /* CVC4_MUZZLE */ - -# ifdef CVC4_DEBUG - TS_ASSERT( d_debugStream.str() == "testing1testing3" ); -# else /* CVC4_DEBUG */ - TS_ASSERT( d_debugStream.str() == "" ); -# endif /* CVC4_DEBUG */ - - TS_ASSERT( d_messageStream.str() == "a message" ); - TS_ASSERT( d_warningStream.str() == "bad warning!" ); - TS_ASSERT( d_chatStream.str() == "chatty" ); - TS_ASSERT( d_noticeStream.str() == "note" ); - -# ifdef CVC4_TRACING - TS_ASSERT( d_traceStream.str() == "tracing1tracing3" ); -# else /* CVC4_TRACING */ - TS_ASSERT( d_traceStream.str() == "" ); -# endif /* CVC4_TRACING */ - -#endif /* CVC4_MUZZLE */ - } - - static int failure() { - // this represents an expensive function that should NOT be called - // when debugging/tracing is turned off - TS_FAIL("a function was evaluated under an output operation when it should not have been"); - return 0; - } - - void testEvaluationOffWhenItIsSupposedToBe() { - Debug.on("foo"); -#ifndef CVC4_DEBUG - TS_ASSERT( !( Debug.isOn("foo") ) ); - Debug("foo") << failure() << endl; -#else /* ! CVC4_DEBUG */ - TS_ASSERT( Debug.isOn("foo") ); -#endif /* ! CVC4_DEBUG */ - Debug.off("foo"); - //Debug("foo") << failure() << endl; - - Trace.on("foo"); -#ifndef CVC4_TRACING - TS_ASSERT( !( Trace.isOn("foo") ) ); - Trace("foo") << failure() << endl; -#else /* ! CVC4_TRACING */ - TS_ASSERT( Trace.isOn("foo") ); -#endif /* ! CVC4_TRACING */ - Trace.off("foo"); - //Trace("foo") << failure() << endl; - -#ifdef CVC4_MUZZLE - TS_ASSERT( !( Debug.isOn("foo") ) ); - TS_ASSERT( !( Trace.isOn("foo") ) ); - TS_ASSERT( !( Warning.isOn() ) ); - TS_ASSERT(!(CVC4Message.isOn())); - TS_ASSERT( !( Notice.isOn() ) ); - TS_ASSERT( !( Chat.isOn() ) ); - - cout << "debug" << std::endl; - Debug("foo") << failure() << endl; - cout << "trace" << std::endl; - Trace("foo") << failure() << endl; - cout << "warning" << std::endl; - Warning() << failure() << endl; - cout << "message" << std::endl; - CVC4Message() << failure() << endl; - cout << "notice" << std::endl; - Notice() << failure() << endl; - cout << "chat" << std::endl; - Chat() << failure() << endl; -#endif /* CVC4_MUZZLE */ - } - - void testSimplePrint() { - -#ifdef CVC4_MUZZLE - - Debug.off("yo"); - Debug("yo") << "foobar"; - TS_ASSERT_EQUALS(d_debugStream.str(), string()); - d_debugStream.str(""); - Debug.on("yo"); - Debug("yo") << "baz foo"; - TS_ASSERT_EQUALS(d_debugStream.str(), string()); - d_debugStream.str(""); - - Trace.off("yo"); - Trace("yo") << "foobar"; - TS_ASSERT_EQUALS(d_traceStream.str(), string()); - d_traceStream.str(""); - Trace.on("yo"); - Trace("yo") << "baz foo"; - TS_ASSERT_EQUALS(d_traceStream.str(), string()); - d_traceStream.str(""); - - Warning() << "baz foo"; - TS_ASSERT_EQUALS(d_warningStream.str(), string()); - d_warningStream.str(""); - - Chat() << "baz foo"; - TS_ASSERT_EQUALS(d_chatStream.str(), string()); - d_chatStream.str(""); - - CVC4Message() << "baz foo"; - TS_ASSERT_EQUALS(d_messageStream.str(), string()); - d_messageStream.str(""); - - Notice() << "baz foo"; - TS_ASSERT_EQUALS(d_noticeStream.str(), string()); - d_noticeStream.str(""); - -#else /* CVC4_MUZZLE */ - - Debug.off("yo"); - Debug("yo") << "foobar"; - TS_ASSERT_EQUALS(d_debugStream.str(), string()); - d_debugStream.str(""); - Debug.on("yo"); - Debug("yo") << "baz foo"; -# ifdef CVC4_DEBUG - TS_ASSERT_EQUALS(d_debugStream.str(), string("baz foo")); -# else /* CVC4_DEBUG */ - TS_ASSERT_EQUALS(d_debugStream.str(), string()); -# endif /* CVC4_DEBUG */ - d_debugStream.str(""); - - Trace.off("yo"); - Trace("yo") << "foobar"; - TS_ASSERT_EQUALS(d_traceStream.str(), string()); - d_traceStream.str(""); - Trace.on("yo"); - Trace("yo") << "baz foo"; -# ifdef CVC4_TRACING - TS_ASSERT_EQUALS(d_traceStream.str(), string("baz foo")); -# else /* CVC4_TRACING */ - TS_ASSERT_EQUALS(d_traceStream.str(), string()); -# endif /* CVC4_TRACING */ - d_traceStream.str(""); - - Warning() << "baz foo"; - TS_ASSERT_EQUALS(d_warningStream.str(), string("baz foo")); - d_warningStream.str(""); - - Chat() << "baz foo"; - TS_ASSERT_EQUALS(d_chatStream.str(), string("baz foo")); - d_chatStream.str(""); - - CVC4Message() << "baz foo"; - TS_ASSERT_EQUALS(d_messageStream.str(), string("baz foo")); - d_messageStream.str(""); - - Notice() << "baz foo"; - TS_ASSERT_EQUALS(d_noticeStream.str(), string("baz foo")); - d_noticeStream.str(""); - -#endif /* CVC4_MUZZLE */ - - } -};