26 #include "logging/log.hpp"

    27 #include "memory/allocation.inline.hpp"

    28 

    29 void LogWriteHelper::write_large(LogTagSet& lts,

    30                                  LogLevelType level,

    31                                  const char* prefix,

    32                                  size_t prefix_len,

    33                                  size_t msg_len,

    34                                  const char* fmt,

    35                                  va_list args) {

    36   size_t newbuf_len = prefix_len + msg_len + 1;

    37   char* newbuf = NEW_C_HEAP_ARRAY(char, newbuf_len, mtLogging);

    38   memcpy(newbuf, prefix, prefix_len);

    39   int ret = os::log_vsnprintf(newbuf + prefix_len, newbuf_len - prefix_len, fmt, args);

    40   assert(ret >= 0, "Log message buffer issue");

    41   lts.log(level, newbuf);

    42   FREE_C_HEAP_ARRAY(char, newbuf);

    43 }

    63 class TestLogFile {

    64  private:

    65   char file_name[256];

    66 

    67   void set_name(const char* test_name) {

    68     const char* tmpdir = os::get_temp_directory();

    69     int pos = jio_snprintf(file_name, sizeof(file_name), "%s%svmtest.%s.%d.log", tmpdir, os::file_separator(), test_name, os::current_process_id());

    70     assert(pos > 0, "too small log file name buffer");

    71     assert((size_t)pos < sizeof(file_name), "too small log file name buffer");

    72   }

    73 

    74  public:

    75   TestLogFile(const char* test_name) {

    76     set_name(test_name);

    77     remove(name());

    78   }

    79 

    80   ~TestLogFile() {

    81     remove(name());

    82   }

    83 

    84   const char* name() {

    85     return file_name;

    86   }

    87 };

    88 

    89 class TestLogSavedConfig {

    90  private:

    91   char* _saved_config;

    92   char* _new_output;

    93   LogHandle(logging) _log;

    94  public:

    95   TestLogSavedConfig(const char* apply_output = NULL, const char* apply_setting = NULL) : _new_output(0) {

    96     _saved_config = os::strdup_check_oom(LogOutput::Stdout->config_string());

    97     bool success = LogConfiguration::parse_log_arguments("stdout", "all=off", NULL, NULL, _log.error_stream());

    98     assert(success, "test unable to turn all off");

    99 

   100     if (apply_output) {

   101       _new_output = os::strdup_check_oom(apply_output);

   102       bool success = LogConfiguration::parse_log_arguments(_new_output, apply_setting,  NULL, NULL, _log.error_stream());

   103       assert(success, "test unable to apply test log configuration");

   104     }

   105   }

   106 

   107   ~TestLogSavedConfig() {

   108     if (_new_output) {

   109       bool success = LogConfiguration::parse_log_arguments(_new_output, "all=off", NULL, NULL, _log.error_stream());

   110       assert(success, "test unable to turn all off");

   111       os::free(_new_output);

   112     }

   113 

   114     bool success = LogConfiguration::parse_log_arguments("stdout", _saved_config, NULL, NULL, _log.error_stream());

   115     assert(success, "test unable to restore log configuration");

   116     os::free(_saved_config);

   117   }

   118 };

   119 

   157   TestLogSavedConfig log_cfg("stdout", "logging+test=trace");

   158 

   169 

   170   // We need to renable stderr error logging since "disable_logging" disable it all.

   171   // TestLogSavedConfig log_cfg will only renable stdout for us.

   172   LogConfiguration::parse_log_arguments("stderr", "all=warning", NULL, NULL, log.error_stream());

   173   assert(Test_logconfiguration_subscribe_triggered == 4, "subscription not triggered (3)");

   174 }

   175 

   176 #define LOG_PREFIX_STR "THE_PREFIX "

   177 #define LOG_LINE_STR "a log line"

   178 

   179 size_t Test_log_prefix_prefixer(char* buf, size_t len) {

   180   int ret = jio_snprintf(buf, len, LOG_PREFIX_STR);

   181   assert(ret > 0, "Failed to print prefix. Log buffer too small?");

   182   return (size_t) ret;

   183 }

   184 

   185 void Test_log_prefix() {

   186   ResourceMark rm;

   187   TestLogFile log_file("log_prefix");

   188   TestLogSavedConfig log_cfg(log_file.name(), "logging+test=trace");

   189 

   190   log_trace(logging, test)(LOG_LINE_STR);

   191 

   192   FILE* fp = fopen(log_file.name(), "r");

   193   assert(fp, "File read error");

   194   char output[1024];

   195   if (fgets(output, 1024, fp) != NULL) {

   196     assert(strstr(output, LOG_PREFIX_STR LOG_LINE_STR), "logging prefix error");

   197   }

   198   fclose(fp);

   199 }

   200 

   201 void Test_log_big() {

   202   char big_msg[4096] = {0};

   203   char Xchar = '~';

   204 

   205   ResourceMark rm;

   206   TestLogFile log_file("log_big");

   207   TestLogSavedConfig log_cfg(log_file.name(), "logging+test=trace");

   208 

   209   memset(big_msg, Xchar, sizeof(big_msg) - 1);

   210 

   211   log_trace(logging, test)("%s", big_msg);

   212 

   213   FILE* fp = fopen(log_file.name(), "r");

   214   assert(fp, "File read error");

   215   char output[sizeof(big_msg)+128 /*decorators*/ ];

   216   if (fgets(output, sizeof(output), fp) != NULL) {

   217     assert(strstr(output, LOG_PREFIX_STR), "logging prefix error");

   218     size_t count = 0;

   219     for (size_t ps = 0 ; output[ps + count] != '\0'; output[ps + count] == Xchar ? count++ : ps++);

   220     assert(count == (sizeof(big_msg) - 1) , "logging msg error");

   221   }

   222   fclose(fp);