/*
* Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include "precompiled.hpp"
#include "jvm.h"
#include "memory/allocation.inline.hpp"
#include "memory/resourceArea.hpp"
#include "runtime/os.hpp"
#include "utilities/istream.hpp"
#include "unittest.hpp"
template<typename BlockClass>
class BlockInputStream : public inputStream {
BlockClass _input;
public:
template<typename... Arg>
BlockInputStream(Arg... arg)
: _input(arg...) {
set_input(&_input);
}
};
#define EXPECT_MEMEQ(s1, s2, len) \
EXPECT_PRED_FORMAT3(CmpHelperMEMEQ, s1, s2, len)
// cf. ::testing::internal::CmpHelperSTREQ
testing::AssertionResult CmpHelperMEMEQ(const char* s1_expression,
const char* s2_expression,
const char* len_expression,
const char* s1, const char* s2,
size_t len) {
if (s1 == nullptr || s2 == nullptr) {
return testing::internal::CmpHelperEQ(s1_expression, s2_expression,
s1, s2);
}
int c = ::memcmp(s1, s2, len);
if (c == 0) {
return testing::AssertionSuccess();
}
::std::string str1, str2;
for (auto which = 0; which <= 1; which++) {
auto s = which ? s1 : s2;
auto &str = which ? str1 : str2;
std::stringstream buf;
buf << "{";
for (size_t i = 0; i < len; i++) {
char c = s[i];
switch (c) {
case '\0': buf << "\\0"; break;
case '\n': buf << "\\n"; break;
case '\\': buf << "\\\\"; break;
default: buf << c; break;
}
}
buf << "}[" << len_expression << "=" << len << "]";
str = buf.str();
}
return testing::internal::CmpHelperSTREQ(s1_expression, s2_expression,
str1.c_str(), str2.c_str());
}
static int firstdiff(char* b1, char* b2, int blen) {
for (int i = 0; i < blen; i++) {
if (b1[i] != b2[i]) return i;
}
return -1;
}
static char* get_temp_file(bool VERBOSE, const char* filename) {
const char* tmp_dir = os::get_temp_directory();
const char* file_sep = os::file_separator();
size_t temp_file_len = strlen(tmp_dir) + strlen(file_sep) + strlen(filename) + 28;
char* temp_file = NEW_C_HEAP_ARRAY(char, temp_file_len, mtInternal);
int ret = jio_snprintf(temp_file, temp_file_len, "%s%spid%d.%s",
tmp_dir, file_sep,
os::current_process_id(), filename);
if (VERBOSE) tty->print_cr("temp_file = %s", temp_file);
return temp_file;
}
static const char* get_temp_file(bool VERBOSE) {
static const char* temp_file = get_temp_file(VERBOSE, "test_istream");
return temp_file;
}
#define EIGHTY 80
#define LC0(x) ('/' + (((unsigned)(x)+1) % EIGHTY))
#define LC(line,col) LC0((col) * (line))
#define COLS 30
static int cases, total, zeroes;
#ifdef ASSERT
#define istream_coverage_mode(mode, a,b,c) \
inputStream::coverage_mode(mode, a,b,c)
#else
#define istream_coverage_mode(mode, a,b,c)
#endif
// Fill in a test pattern of ascii characters.
// Each line is ncols long, plus a line termination of lelen (1 or 2).
// Each character is a fixed, static function of the line and column.
// This enables test logic to predict exactly what will be read in each line.
static void fill_pattern(bool VERBOSE,
char* pat, int patlen, int ncols, int lelen,
int& full_lines, int& partial_line,
const char* &line_end,
const char* &partial_line_end) {
full_lines = partial_line = 0;
for (int i = 0; i < patlen; i++) {
int line = (i / (ncols+lelen)) + 1; // 1-based line number
int col = (i % (ncols+lelen)) + 1; // 1-based column number
if (col <= ncols) {
pat[i] = LC(line, col);
partial_line = 1;
} else if (col < ncols+lelen) {
pat[i] = i == patlen - 1 ? '!' : '%';
partial_line = 1;
} else {
assert(col == ncols+lelen, "");
pat[i] = '!';
full_lines++;
partial_line = 0;
}
}
pat[patlen] = '\0';
if (VERBOSE) tty->print_cr("PATTERN=%d+%d[%s]",
full_lines, partial_line, pat);
for (int i = 0; i < patlen; i++) {
assert(pat[i] != '%' || (i+1 < patlen && pat[i+1] == '!'), "");
if (pat[i] == '!') pat[i] = '\n';
if (pat[i] == '%') pat[i] = '\r';
}
assert(pat[patlen-1] != '\r', "");
line_end = (lelen == 2 ? "\r\n" : "\n");
int partial_line_bytes = patlen - (full_lines * (ncols + lelen));
assert(partial_line_bytes < ncols + lelen, "");
partial_line_end = (partial_line_bytes == ncols + 1) ? "\n" : "";
}
static const int MAX_PATLEN = COLS * (COLS-1);
static void istream_test_driver(const bool VERBOSE,
const int patlen,
const int ncols,
const int lelen,
const bool TEST_SET_POSITION,
const bool TEST_PUSH_BACK,
const bool TEST_EXPAND_REDUCE) {
DEBUG_ONLY( istream_coverage_mode(VERBOSE ? 2 : 1, cases, total, zeroes) );
const char* temp_file = get_temp_file(VERBOSE);
unlink(temp_file);
char pat[MAX_PATLEN+1];
int full_lines = 0, partial_line = 0;
const char* line_end = "\n";
const char* partial_line_end = "";
fill_pattern(VERBOSE, pat, patlen, ncols, lelen,
full_lines, partial_line,
line_end, partial_line_end);
char pat2[sizeof(pat)]; // copy of pat to help detect scribbling
memcpy(pat2, pat, sizeof(pat));
// Make three kinds of stream and test them all.
MemoryInput _min(pat2, patlen);
inputStream sin(&_min);
if (VERBOSE) {
tty->print("at %llx ", (unsigned long long)(intptr_t)&sin);
sin.dump("sin");
}
{
fileStream tfs(temp_file);
guarantee(tfs.is_open(), "cannot open temp file");
tfs.write(pat, patlen);
}
BlockInputStream<FileInput> fin(temp_file);
if (VERBOSE) {
tty->print("at %llx ", (unsigned long long)(intptr_t)&fin);
fin.dump("fin");
}
BlockInputStream<MemoryInput> min(&pat2[0], patlen);
if (VERBOSE) {
tty->print("at %llx ", (unsigned long long)(intptr_t)&min);
sin.dump("min");
}
inputStream* ins[] = { &sin, &fin, &min };
const char* in_names[] = { "sin", "fin", "min" };
const char* test_mode = (TEST_SET_POSITION
? (!TEST_PUSH_BACK ? "(seek)" : "(seek/push)")
: TEST_EXPAND_REDUCE
? (!TEST_PUSH_BACK ? "(exp/red)" : "(exp/red/push)")
: (!TEST_PUSH_BACK ? "(plain)" : "(push)"));
for (int which = 0; which < 3; which++) {
inputStream& in = *ins[which];
const char* in_name = in_names[which];
int lineno;
char* lp = (char*)"--";
#define LPEQ \
in_name << test_mode \
<< " ncols=" << ncols << " lelen=" << lelen \
<< " full=" << full_lines << " lineno=" << lineno \
<< " [" << lp << "]" << (in.dump("expect"), "")
if (VERBOSE)
tty->print_cr("testing %s%s patlen=%d ncols=%d full_lines=%d partial_line=%d",
in_name, test_mode,
patlen, ncols, full_lines, partial_line);
int pos_to_set = 0, line_to_set = 1; // for TEST_SET_POSITION only
for (int phase = 0; phase <= (TEST_SET_POSITION ? 1 : 0); phase++) {
lineno = 1;
for (; lineno <= full_lines + partial_line; lineno++) {
EXPECT_EQ(-1, firstdiff(pat, pat2, patlen + 1));
if (VERBOSE) in.dump("!done?");
bool done = in.done();
EXPECT_TRUE(!done) <<LPEQ;
if (done) break;
lp = in.current_line();
const char* expect_endl =
(lineno <= full_lines) ? line_end : partial_line_end;
bool verify_lp = true;
if (verify_lp) {
int actual_lineno = (int) in.lineno();
if (VERBOSE) in.dump("CL ");
EXPECT_EQ(actual_lineno, lineno) <<LPEQ;
int len = (int) in.current_line_length();
EXPECT_EQ(len, (int) strlen(lp)) <<LPEQ;
int expect_len = ncols;
if (lineno > full_lines)
expect_len = MIN2(ncols, patlen % (ncols+lelen));
EXPECT_EQ(len, expect_len) <<LPEQ;
for (int j = 0; j < len; j++) {
int lc = LC(lineno, j+1); // 1-based column
EXPECT_EQ(lc, lp[j]) <<LPEQ;
}
if (len != expect_len || len != (int)strlen(lp)) {
return; // no error cascades please
}
}
if (VERBOSE) in.dump("next ");
in.next();
}
for (int done_test = 0; done_test <= 3; done_test++) {
if (done_test == 2) in.set_done();
lp = in.current_line(); // should be empty line
if (VERBOSE) in.dump("done!!");
EXPECT_TRUE(lp != nullptr);
EXPECT_TRUE(in.done()) <<LPEQ;
if (!in.done()) break;
EXPECT_EQ((int)in.current_line_length(), 0) <<LPEQ;
EXPECT_EQ(strlen(lp), in.current_line_length()) <<LPEQ;
bool extra_next = in.next();
EXPECT_TRUE(!extra_next) <<LPEQ;
}
// no memory side effects
EXPECT_EQ(-1, firstdiff(pat, pat2, patlen + 1));
}
}
unlink(temp_file);
}
static void istream_test_driver(const bool VERBOSE,
const bool TEST_SET_POSITION,
const bool TEST_PUSH_BACK,
const bool TEST_EXPAND_REDUCE) {
ResourceMark rm;
int patlen = MAX_PATLEN;
const bool SHORT_TEST = false;
const int SHORT_NCOLS = 1, SHORT_PATLEN = 37;
if (SHORT_TEST) patlen = SHORT_PATLEN;
for (int ncols = 0; ncols <= patlen; ncols++) {
if (SHORT_TEST) {
if (ncols < SHORT_NCOLS) ncols = SHORT_NCOLS;
if (ncols > SHORT_NCOLS) break;
} else if (ncols > COLS && ncols < patlen - COLS) {
ncols += ncols / 7;
if (ncols > patlen - COLS) ncols = (patlen - COLS);
}
for (int lelen = 1; lelen <= 2; lelen++) { // try both kinds of newline
istream_test_driver(VERBOSE,
patlen, ncols, lelen,
TEST_SET_POSITION, TEST_PUSH_BACK, TEST_EXPAND_REDUCE);
}
}
}
TEST_VM(istream, basic) {
const bool VERBOSE = false;
istream_test_driver(VERBOSE, false, false, false);
}
TEST_VM(istream, coverage) {
const bool VERBOSE = false;
#ifdef ASSERT
istream_coverage_mode(0, cases, total, zeroes);
if (cases == 0) return;
if (VERBOSE || zeroes != 0)
istream_coverage_mode(-1, cases, total, zeroes);
EXPECT_EQ(zeroes, 0) << "zeroes: " << zeroes << "/" << cases;
#endif //ASSERT
}