LoggingTests.cpp File Reference

#include <folly/io/IOBuf.h>
#include <glog/logging.h>
#include <folly/portability/GTest.h>
#include <proxygen/lib/utils/Logging.h>

Go to the source code of this file.

Classes
class	LoggingTests

Functions
	TEST_F (LoggingTests, PrintHexIobuf)
	TEST_F (LoggingTests, HexString)
	TEST_F (LoggingTests, DumpBin)
	TEST_F (LoggingTests, DumpBinToFile)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_LT_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_LE_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_GT_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_GE_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_EQ_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_NE_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_NOT_NULL_TEST)
	TEST_F (LoggingTests, CHECK_LOG_AND_THROW_NULL_TEST)

Function Documentation

TEST_F	(	LoggingTests	,
		PrintHexIobuf
	)

Definition at line 23 of file LoggingTests.cpp.

References folly::IOBuf::append(), folly::IOBuf::create(), folly::data(), EXPECT_EQ, EXPECT_TRUE, i, deadlock::info(), uint8_t, and folly::IOBuf::writableData().

                                    {
  unique_ptr<IOBuf> buf = IOBuf::create(128);
  EXPECT_EQ(IOBufPrinter::printHexFolly(buf.get()), "");
  EXPECT_EQ(IOBufPrinter::printHex16(buf.get()), "");

  uint8_t* data = buf->writableData();
  data[0] = 0x0C;
  data[1] = 0xFF;
  data[2] = 0x00;
  data[3] = 0x10;
  buf->append(4);
  EXPECT_TRUE(IOBufPrinter::printHexFolly(buf.get()) != "");
  EXPECT_EQ(IOBufPrinter::printHex16(buf.get()), "0cff 0010 ");

  // some linewrap
  for (int i = 0; i < 16; i++) {
    data[4 + i] = 0xFE;
  }
  buf->append(16);
  EXPECT_TRUE(IOBufPrinter::printHexFolly(buf.get()) != "");
  string info = IOBufPrinter::printChainInfo(buf.get());
  EXPECT_TRUE(info.find("iobuf of size 20 tailroom ") != string::npos);
  EXPECT_EQ(IOBufPrinter::printHex16(buf.get()),
            "0cff 0010 fefe fefe fefe fefe fefe fefe \nfefe fefe ");
}

TEST_F	(	LoggingTests	,
		HexString
	)

Definition at line 49 of file LoggingTests.cpp.

References EXPECT_EQ, proxygen::hexStr(), s, and uint8_t.

                                {
  uint8_t buf[] = {
    0x03, 0x04, 0x11, 0x22, 0xBB, 0xAA
  };
  string s((const char *)buf, sizeof(buf));
  EXPECT_EQ("03041122bbaa", hexStr(s));
}

TEST_F	(	LoggingTests	,
		DumpBin
	)

Definition at line 57 of file LoggingTests.cpp.

References folly::IOBuf::append(), folly::IOBuf::appendChain(), folly::IOBuf::create(), EXPECT_EQ, folly::gen::move, and folly::IOBuf::writableData().

                              {
  // null IOBuf
  EXPECT_EQ(IOBufPrinter::printBin(nullptr), "");

  unique_ptr<IOBuf> b1 = IOBuf::create(128);
  b1->writableData()[0] = 0x33;
  b1->writableData()[1] = 0x77;
  b1->append(2);
  unique_ptr<IOBuf> b2 = IOBuf::create(128);
  b2->writableData()[0] = 0xFF;
  b2->append(1);
  b1->appendChain(std::move(b2));
  EXPECT_EQ(IOBufPrinter::printBin(b1.get()),
            "00110011 3 01110111 w \n11111111   \n");
  // with coalescing
  EXPECT_EQ(IOBufPrinter::printBin(b1.get(), true),
            "00110011 3 01110111 w 11111111   \n");
}

TEST_F	(	LoggingTests	,
		DumpBinToFile
	)

Definition at line 76 of file LoggingTests.cpp.

References folly::IOBuf::create(), proxygen::dumpBinToFile(), and EXPECT_EQ.

                                    {
  struct stat fstat;
  string tmpfile("/tmp/test.bin");

  unlink(tmpfile.c_str());
  unique_ptr<IOBuf> buf = IOBuf::create(128);
  // the content doesn't matter
  buf->append(2);
  dumpBinToFile(tmpfile, buf.get());
  EXPECT_EQ(stat(tmpfile.c_str(), &fstat), 0);

  // check if it's going to overwrite the existing file
  buf->append(4);
  dumpBinToFile(tmpfile, buf.get());
  EXPECT_EQ(stat(tmpfile.c_str(), &fstat), 0);
  EXPECT_EQ(fstat.st_size, 2);
  unlink(tmpfile.c_str());

  // null iobuf
  dumpBinToFile(tmpfile, nullptr);
  // unable to open file
  dumpBinToFile("/proc/test", nullptr);
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_TEST
	)

Definition at line 100 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                               {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW(false, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW(true, ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_LT_TEST
	)

Definition at line 111 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_LT, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                  {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_LT(5, 4, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_LT(3, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_LE_TEST
	)

Definition at line 122 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_LE, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                  {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_LE(5, 4, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_LE(3, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_LE(4, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_GT_TEST
	)

Definition at line 137 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_GT, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                  {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_GT(3, 4, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_GT(5, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_GE_TEST
	)

Definition at line 148 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_GE, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                  {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_GE(3, 4, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_GE(5, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_GE(4, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_EQ_TEST
	)

Definition at line 163 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_EQ, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                  {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_EQ(5, 4, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_EQ(4, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_NE_TEST
	)

Definition at line 174 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_NE, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                  {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_NE(4, 4, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_NE(3, 4, ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_NOT_NULL_TEST
	)

Definition at line 185 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_NOT_NULL, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                        {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_NOT_NULL(nullptr, ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_NOT_NULL("hello", ERROR, runtime_error)
      << "This should not be logged";
  });
}

TEST_F	(	LoggingTests	,
		CHECK_LOG_AND_THROW_NULL_TEST
	)

Definition at line 196 of file LoggingTests.cpp.

References CHECK_LOG_AND_THROW_NULL, proxygen::ERROR, EXPECT_NO_THROW, and EXPECT_THROW.

                                                    {
  EXPECT_THROW([]{
    CHECK_LOG_AND_THROW_NULL("hello", ERROR, runtime_error)
      << "Test log and exception message";
  }(), runtime_error);
  EXPECT_NO_THROW([]{
    CHECK_LOG_AND_THROW_NULL(nullptr, ERROR, runtime_error)
      << "This should not be logged";
  });
}