~dobey/unity-api/add-simple-logger

« back to all changes in this revision

Viewing changes to test/gtest/unity/util/Logger/Logger_test.cpp

  • Committer: Rodney Dawes
  • Date: 2017-04-03 21:10:23 UTC
  • Revision ID: rodney.dawes@canonical.com-20170403211023-2dttuxcug3l3t1b1
Move some code into C++ and greatly simplify the implementation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
18
18
 
19
19
#include <unity/util/Logger.h>
20
20
 
 
21
#include <glib.h>
21
22
#include <gtest/gtest.h>
22
 
 
23
 
#include <sstream>
 
23
#include <unistd.h>
24
24
 
25
25
using namespace unity::util;
26
26
 
29
29
class LoggerTest : public ::testing::Test
30
30
{
31
31
public:
32
 
    std::streambuf *old_stdout_buf;
33
 
    std::stringstream stdout_buffer;
34
 
    std::streambuf *old_stderr_buf;
35
 
    std::stringstream stderr_buffer;
36
 
 
37
 
    virtual void SetUp() override
38
 
    {
39
 
        // Trap stdout to verify tests.
40
 
        old_stdout_buf = std::cout.rdbuf();
41
 
        std::cout.rdbuf(stdout_buffer.rdbuf());
42
 
 
43
 
        // Trap stderr to verify tests.
44
 
        old_stderr_buf = std::cerr.rdbuf();
45
 
        std::cerr.rdbuf(stderr_buffer.rdbuf());
46
 
    }
47
 
 
48
 
    virtual void TearDown() override
49
 
    {
50
 
        std::cout.rdbuf(old_stdout_buf);
51
 
        std::cerr.rdbuf(old_stderr_buf);
52
 
    }
 
32
    LoggerTest()
 
33
    {
 
34
        _handler_id = g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
 
35
                                        _log_handler, this);
 
36
        std::cerr << "Set up handler: " << _handler_id << std::endl;
 
37
    }
 
38
 
 
39
    virtual ~LoggerTest()
 
40
    {
 
41
        if (_handler_id != 0) {
 
42
            g_log_remove_handler(G_LOG_DOMAIN, _handler_id);
 
43
        }
 
44
    }
 
45
 
 
46
    std::string str()
 
47
    {
 
48
        return _stream.str();
 
49
    }
 
50
 
 
51
private:
 
52
    static void _log_handler(const gchar*, GLogLevelFlags,
 
53
                             const gchar* message, gpointer gthis)
 
54
    {
 
55
        static_cast<LoggerTest*>(gthis)->log_message(message);
 
56
    }
 
57
 
 
58
    void log_message(const char* message)
 
59
    {
 
60
        std::cerr << "Message: " << message << std::endl;
 
61
        _stream << message;
 
62
        usleep(200);
 
63
    }
 
64
 
 
65
    std::ostringstream _stream;
 
66
    guint _handler_id;
53
67
};
54
68
 
55
 
TEST_F(LoggerTest, testEndingSpace)
56
 
{
57
 
    warn() << "This ends with a space ";
58
 
}
59
 
 
60
69
TEST_F(LoggerTest, testDebug)
61
70
{
62
 
    debug() << "Some data about things happening.";
 
71
    auto expected = "Some data about things happening.";
 
72
    debug() << expected;
 
73
    ASSERT_STREQ(expected, str().c_str());
 
74
}
 
75
 
 
76
TEST_F(LoggerTest, testInfo)
 
77
{
 
78
    auto expected = "Some info.";
 
79
    info() << expected;
 
80
    ASSERT_STREQ(expected, str().c_str());
63
81
}
64
82
 
65
83
TEST_F(LoggerTest, testWarning)
66
84
{
67
 
    warn() << "This shouldn't normally happen.";
 
85
    auto expected = "This shouldn't normally happen.";
 
86
    warn() << expected;
 
87
    ASSERT_STREQ(expected, str().c_str());
68
88
}
69
89
 
70
90
TEST_F(LoggerTest, testCritical)
71
91
{
72
 
    critical() << "Critical fail.";
 
92
    auto expected = "Critical fail.";
 
93
    critical() << expected;
 
94
    ASSERT_STREQ(expected, str().c_str());
73
95
}
74
96
 
75
97
TEST_F(LoggerTest, testError)
76
98
{
77
 
    ASSERT_EXIT({error() << "Error crash.";},
78
 
                ::testing::KilledBySignal(SIGTRAP), "Error crash.");
79
 
}
80
 
 
81
 
TEST_F(LoggerTest, testStreamLevelDebug)
82
 
{
83
 
    debug() << "Level:" << Logger::Level::DEBUG;
84
 
}
85
 
 
86
 
TEST_F(LoggerTest, testStreamLevelWarning)
87
 
{
88
 
    debug() << "Level:" << Logger::Level::WARNING;
89
 
}
90
 
 
91
 
TEST_F(LoggerTest, testStreamLevelCritical)
92
 
{
93
 
    debug() << "Level:" << Logger::Level::CRITICAL;
94
 
}
95
 
 
96
 
TEST_F(LoggerTest, testStreamLevelERROR)
97
 
{
98
 
    debug() << "Level:" << Logger::Level::ERROR;
99
 
}
100
 
 
101
 
TEST_F(LoggerTest, testStreamLevelUnknown)
102
 
{
103
 
    debug() << "Level:" << Logger::Level::UNKNOWN;
104
 
}
105
 
 
106
 
TEST_F(LoggerTest, testStreamBool)
107
 
{
108
 
    debug() << "Bool:" << true;
109
 
}
110
 
 
111
 
TEST_F(LoggerTest, testStreamPointer)
112
 
{
113
 
    debug() << "Pointer:" << this;
114
 
}
115
 
 
116
 
TEST_F(LoggerTest, testStreamNullPointer)
117
 
{
118
 
    debug() << "Pointer:" << nullptr;
119
 
}
120
 
 
121
 
TEST_F(LoggerTest, testStreamInt)
122
 
{
123
 
    debug() << "Count:" << 42;
124
 
}
125
 
 
126
 
TEST_F(LoggerTest, testStreamShort)
127
 
{
128
 
    debug() << "Count:" << (short)42;
129
 
}
130
 
 
131
 
TEST_F(LoggerTest, testStreamLong)
132
 
{
133
 
    debug() << "Count:" << (long)42;
134
 
}
135
 
 
136
 
TEST_F(LoggerTest, testStreamLongLong)
137
 
{
138
 
    debug() << "Count" << (long long)42;
139
 
}
140
 
 
141
 
TEST_F(LoggerTest, testStreamUnsignedInt)
142
 
{
143
 
    debug() << "Unsigned:" << (unsigned int)42;
144
 
}
145
 
 
146
 
TEST_F(LoggerTest, testStreamUnsignedShort)
147
 
{
148
 
    debug() << "Unsigned:" << (unsigned short)42;
149
 
}
150
 
 
151
 
TEST_F(LoggerTest, testStreamUnsignedLong)
152
 
{
153
 
    debug() << "Unsigned Long:" << (unsigned long)42;
154
 
}
155
 
 
156
 
TEST_F(LoggerTest, testStreamUnsignedLongLong)
157
 
{
158
 
    debug() << "Unsigned long long:" << (unsigned long long)42;
159
 
}
160
 
 
161
 
TEST_F(LoggerTest, testStreamFloat)
162
 
{
163
 
    debug() << "Float:" << 2.2f;
164
 
}
165
 
 
166
 
TEST_F(LoggerTest, testStreamDouble)
167
 
{
168
 
    debug() << "Double:" << (double)2.2f;
 
99
    auto expected = "Error crash.";
 
100
    ASSERT_EXIT({error() << expected;},
 
101
                ::testing::KilledBySignal(SIGTRAP), expected);
 
102
    ASSERT_STREQ(expected, str().c_str());
169
103
}
170
104
 
171
105
} // namespace