debug-test.c++ 13 KB
Newer Older
Kenton Varda's avatar
Kenton Varda committed
1 2
// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
// Licensed under the MIT License:
3
//
Kenton Varda's avatar
Kenton Varda committed
4 5 6 7 8 9
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
10
//
Kenton Varda's avatar
Kenton Varda committed
11 12
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
13
//
Kenton Varda's avatar
Kenton Varda committed
14 15 16 17 18 19 20
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
21

22
#ifndef _GNU_SOURCE
Ivan Shynkarenka's avatar
Ivan Shynkarenka committed
23 24 25
#define _GNU_SOURCE
#endif

Kenton Varda's avatar
Kenton Varda committed
26
#include "debug.h"
27
#include "exception.h"
28
#include <kj/compat/gtest.h>
29 30
#include <string>
#include <stdio.h>
31
#include <signal.h>
32 33
#include <errno.h>
#include <string.h>
34
#include <exception>
35
#include <stdlib.h>
36

37 38
#include "miniposix.h"

39
#if !_WIN32
40
#include <sys/wait.h>
41
#endif
42

43 44 45 46 47
#if _MSC_VER
#pragma warning(disable: 4996)
// Warns that sprintf() is buffer-overrunny. Yeah, I know, it's cool.
#endif

48
namespace kj {
49
namespace _ {  // private
50 51 52 53 54 55 56 57 58 59
namespace {

class MockException {};

class MockExceptionCallback: public ExceptionCallback {
public:
  ~MockExceptionCallback() {}

  std::string text;

60 61 62 63 64 65
  int outputPipe = -1;

  bool forkForDeathTest() {
    // This is called when exceptions are disabled.  We fork the process instead and then expect
    // the child to die.

66 67 68 69 70
#if _WIN32
    // Windows doesn't support fork() or anything like it. Just skip the test.
    return false;

#else
71
    int pipeFds[2];
Kenton Varda's avatar
Kenton Varda committed
72
    KJ_SYSCALL(pipe(pipeFds));
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
    pid_t child = fork();
    if (child == 0) {
      // This is the child!
      close(pipeFds[0]);
      outputPipe = pipeFds[1];
      return true;
    } else {
      close(pipeFds[1]);

      // Read child error messages into our local buffer.
      char buf[1024];
      for (;;) {
        ssize_t n = read(pipeFds[0], buf, sizeof(buf));
        if (n < 0) {
          if (errno == EINTR) {
            continue;
          } else {
            break;
          }
        } else if (n == 0) {
          break;
        } else {
          text.append(buf, n);
        }
      }

      close(pipeFds[0]);

      // Get exit status.
      int status;
103
      KJ_SYSCALL(waitpid(child, &status, 0));
104 105 106 107 108 109

      EXPECT_TRUE(WIFEXITED(status));
      EXPECT_EQ(74, WEXITSTATUS(status));

      return false;
    }
110
#endif  // _WIN32, else
111 112 113 114 115 116 117 118
  }

  void flush() {
    if (outputPipe != -1) {
      const char* pos = &*text.begin();
      const char* end = pos + text.size();

      while (pos < end) {
119
        miniposix::ssize_t n = miniposix::write(outputPipe, pos, end - pos);
120 121 122 123 124 125 126 127 128 129 130 131 132 133
        if (n < 0) {
          if (errno == EINTR) {
            continue;
          } else {
            break;  // Give up on error.
          }
        }
        pos += n;
      }

      text.clear();
    }
  }

134 135
  void onRecoverableException(Exception&& exception) override {
    text += "recoverable exception: ";
136
    auto what = str(exception);
137 138
    // Discard the stack trace.
    const char* end = strstr(what.cStr(), "\nstack: ");
139
    if (end == nullptr) {
140
      text += what.cStr();
141
    } else {
142
      text.append(what.cStr(), end);
143
    }
144
    text += '\n';
145
    flush();
146 147 148 149
  }

  void onFatalException(Exception&& exception) override {
    text += "fatal exception: ";
150
    auto what = str(exception);
151 152
    // Discard the stack trace.
    const char* end = strstr(what.cStr(), "\nstack: ");
153
    if (end == nullptr) {
154
      text += what.cStr();
155
    } else {
156
      text.append(what.cStr(), end);
157
    }
158
    text += '\n';
159 160 161 162 163 164 165 166 167
    flush();
#if KJ_NO_EXCEPTIONS
    if (outputPipe >= 0) {
      // This is a child process.  We got what we want, now exit quickly without writing any
      // additional messages, with a status code that the parent will interpret as "exited in the
      // way we expected".
      _exit(74);
    }
#else
168
    throw MockException();
169
#endif
170 171
  }

172 173
  void logMessage(LogSeverity severity, const char* file, int line, int contextDepth,
                  String&& text) override {
174
    this->text += "log message: ";
175
    text = str(file, ":", line, ":+", contextDepth, ": ", severity, ": ", mv(text));
176 177 178 179
    this->text.append(text.begin(), text.end());
  }
};

180 181 182
#if KJ_NO_EXCEPTIONS
#define EXPECT_FATAL(code) if (mockCallback.forkForDeathTest()) { code; abort(); }
#else
183 184 185 186
#define EXPECT_FATAL(code) \
  try { code; KJ_FAIL_EXPECT("expected exception"); } \
  catch (MockException e) {} \
  catch (...) { KJ_FAIL_EXPECT("wrong exception"); }
187 188
#endif

189
std::string fileLine(std::string file, int line) {
190 191
  file = trimSourceFilename(file.c_str()).cStr();

192 193 194 195 196 197 198
  file += ':';
  char buffer[32];
  sprintf(buffer, "%d", line);
  file += buffer;
  return file;
}

199
TEST(Debug, Log) {
200 201 202
  MockExceptionCallback mockCallback;
  int line;

203
  KJ_LOG(WARNING, "Hello world!"); line = __LINE__;
204
  EXPECT_EQ("log message: " + fileLine(__FILE__, line) + ":+0: warning: Hello world!\n",
205 206 207 208 209 210
            mockCallback.text);
  mockCallback.text.clear();

  int i = 123;
  const char* str = "foo";

211
  KJ_LOG(ERROR, i, str); line = __LINE__;
212
  EXPECT_EQ("log message: " + fileLine(__FILE__, line) + ":+0: error: i = 123; str = foo\n",
213 214 215
            mockCallback.text);
  mockCallback.text.clear();

216
  KJ_DBG("Some debug text."); line = __LINE__;
217
  EXPECT_EQ("log message: " + fileLine(__FILE__, line) + ":+0: debug: Some debug text.\n",
218 219 220 221 222 223 224 225 226
            mockCallback.text);
  mockCallback.text.clear();

  // INFO logging is disabled by default.
  KJ_LOG(INFO, "Info."); line = __LINE__;
  EXPECT_EQ("", mockCallback.text);
  mockCallback.text.clear();

  // Enable it.
Kenton Varda's avatar
Kenton Varda committed
227
  Debug::setLogLevel(Debug::Severity::INFO);
228
  KJ_LOG(INFO, "Some text."); line = __LINE__;
229
  EXPECT_EQ("log message: " + fileLine(__FILE__, line) + ":+0: info: Some text.\n",
230 231 232 233
            mockCallback.text);
  mockCallback.text.clear();

  // Back to default.
Kenton Varda's avatar
Kenton Varda committed
234
  Debug::setLogLevel(Debug::Severity::WARNING);
235

236
  KJ_ASSERT(1 == 1);
237
  EXPECT_FATAL(KJ_ASSERT(1 == 2)); line = __LINE__;
238
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) + ": failed: expected "
239 240 241
            "1 == 2\n", mockCallback.text);
  mockCallback.text.clear();

242
  KJ_ASSERT(1 == 1) {
243
    ADD_FAILURE() << "Shouldn't call recovery code when check passes.";
244
    break;
245 246 247
  };

  bool recovered = false;
248
  KJ_ASSERT(1 == 2, "1 is not 2") { recovered = true; break; } line = __LINE__;
249
  EXPECT_EQ("recoverable exception: " + fileLine(__FILE__, line) + ": failed: expected "
250 251 252 253
            "1 == 2; 1 is not 2\n", mockCallback.text);
  EXPECT_TRUE(recovered);
  mockCallback.text.clear();

254
  EXPECT_FATAL(KJ_ASSERT(1 == 2, i, "hi", str)); line = __LINE__;
255
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) + ": failed: expected "
256 257 258
            "1 == 2; i = 123; hi; str = foo\n", mockCallback.text);
  mockCallback.text.clear();

259
  EXPECT_FATAL(KJ_REQUIRE(1 == 2, i, "hi", str)); line = __LINE__;
260
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) + ": failed: expected "
261 262
            "1 == 2; i = 123; hi; str = foo\n", mockCallback.text);
  mockCallback.text.clear();
263

264
  EXPECT_FATAL(KJ_FAIL_ASSERT("foo")); line = __LINE__;
265
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) + ": failed: foo\n",
266 267 268 269
            mockCallback.text);
  mockCallback.text.clear();
}

270 271 272 273 274 275
TEST(Debug, Exception) {
  int i = 123;

  int line = __LINE__; Exception exception = KJ_EXCEPTION(DISCONNECTED, "foo", i);

  EXPECT_EQ(Exception::Type::DISCONNECTED, exception.getType());
276
  EXPECT_TRUE(kj::StringPtr(__FILE__).endsWith(exception.getFile()));
277 278 279 280
  EXPECT_EQ(line, exception.getLine());
  EXPECT_EQ("foo; i = 123", exception.getDescription());
}

281
TEST(Debug, Catch) {
282 283
  int line;

284 285 286 287 288 289 290 291
  {
    // Catch recoverable as kj::Exception.
    Maybe<Exception> exception = kj::runCatchingExceptions([&](){
      line = __LINE__; KJ_FAIL_ASSERT("foo") { break; }
    });

    KJ_IF_MAYBE(e, exception) {
      String what = str(*e);
292 293 294 295
      KJ_IF_MAYBE(eol, what.findFirst('\n')) {
        what = kj::str(what.slice(0, *eol));
      }
      std::string text(what.cStr());
296
      EXPECT_EQ(fileLine(__FILE__, line) + ": failed: foo", text);
297 298 299
    } else {
      ADD_FAILURE() << "Expected exception.";
    }
300 301
  }

302
#if !KJ_NO_EXCEPTIONS
303 304 305 306 307 308 309 310
  {
    // Catch fatal as kj::Exception.
    Maybe<Exception> exception = kj::runCatchingExceptions([&](){
      line = __LINE__; KJ_FAIL_ASSERT("foo");
    });

    KJ_IF_MAYBE(e, exception) {
      String what = str(*e);
311 312 313 314
      KJ_IF_MAYBE(eol, what.findFirst('\n')) {
        what = kj::str(what.slice(0, *eol));
      }
      std::string text(what.cStr());
315
      EXPECT_EQ(fileLine(__FILE__, line) + ": failed: foo", text);
316 317 318 319 320 321 322 323 324 325 326
    } else {
      ADD_FAILURE() << "Expected exception.";
    }
  }

  {
    // Catch as std::exception.
    try {
      line = __LINE__; KJ_FAIL_ASSERT("foo");
      ADD_FAILURE() << "Expected exception.";
    } catch (const std::exception& e) {
327
      kj::StringPtr what = e.what();
Kenton Varda's avatar
Kenton Varda committed
328
      std::string text;
329 330 331 332 333
      KJ_IF_MAYBE(eol, what.findFirst('\n')) {
        text.assign(what.cStr(), *eol);
      } else {
        text.assign(what.cStr());
      }
334
      EXPECT_EQ(fileLine(__FILE__, line) + ": failed: foo", text);
335
    }
336
  }
337
#endif
338 339
}

340 341 342 343 344
int mockSyscall(int i, int error = 0) {
  errno = error;
  return i;
}

345
TEST(Debug, Syscall) {
346 347 348 349 350 351
  MockExceptionCallback mockCallback;
  int line;

  int i = 123;
  const char* str = "foo";

352 353 354 355 356
  KJ_SYSCALL(mockSyscall(0));
  KJ_SYSCALL(mockSyscall(1));

  EXPECT_FATAL(KJ_SYSCALL(mockSyscall(-1, EBADF), i, "bar", str)); line = __LINE__;
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) +
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
            ": failed: mockSyscall(-1, EBADF): " + strerror(EBADF) +
            "; i = 123; bar; str = foo\n", mockCallback.text);
  mockCallback.text.clear();

  EXPECT_FATAL(KJ_SYSCALL(mockSyscall(-1, ECONNRESET), i, "bar", str)); line = __LINE__;
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) +
            ": disconnected: mockSyscall(-1, ECONNRESET): " + strerror(ECONNRESET) +
            "; i = 123; bar; str = foo\n", mockCallback.text);
  mockCallback.text.clear();

  EXPECT_FATAL(KJ_SYSCALL(mockSyscall(-1, ENOMEM), i, "bar", str)); line = __LINE__;
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) +
            ": overloaded: mockSyscall(-1, ENOMEM): " + strerror(ENOMEM) +
            "; i = 123; bar; str = foo\n", mockCallback.text);
  mockCallback.text.clear();

  EXPECT_FATAL(KJ_SYSCALL(mockSyscall(-1, ENOSYS), i, "bar", str)); line = __LINE__;
  EXPECT_EQ("fatal exception: " + fileLine(__FILE__, line) +
            ": unimplemented: mockSyscall(-1, ENOSYS): " + strerror(ENOSYS) +
376
            "; i = 123; bar; str = foo\n", mockCallback.text);
377 378 379 380
  mockCallback.text.clear();

  int result = 0;
  bool recovered = false;
381 382
  KJ_SYSCALL(result = mockSyscall(-2, EBADF), i, "bar", str) { recovered = true; break; } line = __LINE__;
  EXPECT_EQ("recoverable exception: " + fileLine(__FILE__, line) +
383
            ": failed: mockSyscall(-2, EBADF): " + strerror(EBADF) +
384
            "; i = 123; bar; str = foo\n", mockCallback.text);
385
  EXPECT_EQ(-2, result);
386
  EXPECT_TRUE(recovered);
387 388
}

389
TEST(Debug, Context) {
390 391 392
  MockExceptionCallback mockCallback;

  {
393
    KJ_CONTEXT("foo"); int cline = __LINE__;
394

395 396 397 398 399 400
    KJ_LOG(WARNING, "blah"); int line = __LINE__;
    EXPECT_EQ("log message: " + fileLine(__FILE__, cline) + ":+0: context: foo\n"
              "log message: " + fileLine(__FILE__, line) + ":+1: warning: blah\n",
              mockCallback.text);
    mockCallback.text.clear();

401
    EXPECT_FATAL(KJ_FAIL_ASSERT("bar")); line = __LINE__;
402
    EXPECT_EQ("fatal exception: " + fileLine(__FILE__, cline) + ": context: foo\n"
403
              + fileLine(__FILE__, line) + ": failed: bar\n",
404 405 406 407 408 409
              mockCallback.text);
    mockCallback.text.clear();

    {
      int i = 123;
      const char* str = "qux";
410
      KJ_CONTEXT("baz", i, "corge", str); int cline2 = __LINE__;
411
      EXPECT_FATAL(KJ_FAIL_ASSERT("bar")); line = __LINE__;
412 413 414

      EXPECT_EQ("fatal exception: " + fileLine(__FILE__, cline) + ": context: foo\n"
                + fileLine(__FILE__, cline2) + ": context: baz; i = 123; corge; str = qux\n"
415
                + fileLine(__FILE__, line) + ": failed: bar\n",
416 417 418 419 420
                mockCallback.text);
      mockCallback.text.clear();
    }

    {
421
      KJ_CONTEXT("grault"); int cline2 = __LINE__;
422
      EXPECT_FATAL(KJ_FAIL_ASSERT("bar")); line = __LINE__;
423 424 425

      EXPECT_EQ("fatal exception: " + fileLine(__FILE__, cline) + ": context: foo\n"
                + fileLine(__FILE__, cline2) + ": context: grault\n"
426
                + fileLine(__FILE__, line) + ": failed: bar\n",
427 428 429 430 431 432
                mockCallback.text);
      mockCallback.text.clear();
    }
  }
}

433
}  // namespace
434
}  // namespace _ (private)
435
}  // namespace kj