blob: 4752f04a3e83519642e967a776e7501ef226410d [file] [log] [blame]
/* Copyright (c) 2015, Google Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include "file_test.h"
#include <ctype.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <openssl/err.h>
FileTest::FileTest(const char *path) {
file_ = fopen(path, "r");
if (file_ == nullptr) {
fprintf(stderr, "Could not open file %s: %s.\n", path, strerror(errno));
}
}
FileTest::~FileTest() {
if (file_ != nullptr) {
fclose(file_);
}
}
// FindDelimiter returns a pointer to the first '=' or ':' in |str| or nullptr
// if there is none.
static const char *FindDelimiter(const char *str) {
while (*str) {
if (*str == ':' || *str == '=') {
return str;
}
str++;
}
return nullptr;
}
// StripSpace returns a string containing up to |len| characters from |str| with
// leading and trailing whitespace removed.
static std::string StripSpace(const char *str, size_t len) {
// Remove leading space.
while (len > 0 && isspace(*str)) {
str++;
len--;
}
while (len > 0 && isspace(str[len-1])) {
len--;
}
return std::string(str, len);
}
FileTest::ReadResult FileTest::ReadNext() {
// If the previous test had unused attributes or block, it is an error.
if (!unused_attributes_.empty()) {
for (const std::string &key : unused_attributes_) {
PrintLine("Unused attribute: %s", key.c_str());
}
return kReadError;
}
if (!block_.empty() && !used_block_) {
PrintLine("Unused block");
return kReadError;
}
ClearTest();
bool in_block = false;
while (true) {
// Read the next line.
char buf[4096];
if (fgets(buf, sizeof(buf), file_) == nullptr) {
if (feof(file_)) {
if (in_block) {
fprintf(stderr, "Unterminated block.\n");
return kReadError;
}
// EOF is a valid terminator for a test.
return start_line_ > 0 ? kReadSuccess : kReadEOF;
}
fprintf(stderr, "Error reading from input.\n");
return kReadError;
}
line_++;
size_t len = strlen(buf);
// Check for truncation.
if (len > 0 && buf[len - 1] != '\n' && !feof(file_)) {
fprintf(stderr, "Line %u too long.\n", line_);
return kReadError;
}
bool is_delimiter = strncmp(buf, "---", 3) == 0;
if (in_block) {
block_ += buf;
if (is_delimiter) {
// Ending the block completes the test.
return kReadSuccess;
}
} else if (is_delimiter) {
if (start_line_ == 0) {
fprintf(stderr, "Line %u: Unexpected block.\n", line_);
return kReadError;
}
in_block = true;
block_ += buf;
} else if (buf[0] == '\n' || buf[0] == '\0') {
// Empty lines delimit tests.
if (start_line_ > 0) {
return kReadSuccess;
}
} else if (buf[0] != '#') { // Comment lines are ignored.
// Parse the line as an attribute.
const char *delimiter = FindDelimiter(buf);
if (delimiter == nullptr) {
fprintf(stderr, "Line %u: Could not parse attribute.\n", line_);
return kReadError;
}
std::string key = StripSpace(buf, delimiter - buf);
std::string value = StripSpace(delimiter + 1,
buf + len - delimiter - 1);
unused_attributes_.insert(key);
attributes_[key] = value;
if (start_line_ == 0) {
// This is the start of a test.
type_ = key;
parameter_ = value;
start_line_ = line_;
}
}
}
}
void FileTest::PrintLine(const char *format, ...) {
va_list args;
va_start(args, format);
fprintf(stderr, "Line %u: ", start_line_);
vfprintf(stderr, format, args);
fprintf(stderr, "\n");
va_end(args);
}
const std::string &FileTest::GetType() {
OnKeyUsed(type_);
return type_;
}
const std::string &FileTest::GetParameter() {
OnKeyUsed(type_);
return parameter_;
}
const std::string &FileTest::GetBlock() {
used_block_ = true;
return block_;
}
bool FileTest::HasAttribute(const std::string &key) {
OnKeyUsed(key);
return attributes_.count(key) > 0;
}
bool FileTest::GetAttribute(std::string *out_value, const std::string &key) {
OnKeyUsed(key);
auto iter = attributes_.find(key);
if (iter == attributes_.end()) {
PrintLine("Missing attribute '%s'.", key.c_str());
return false;
}
*out_value = iter->second;
return true;
}
const std::string &FileTest::GetAttributeOrDie(const std::string &key) {
if (!HasAttribute(key)) {
abort();
}
return attributes_[key];
}
static bool FromHexDigit(uint8_t *out, char c) {
if ('0' <= c && c <= '9') {
*out = c - '0';
return true;
}
if ('a' <= c && c <= 'f') {
*out = c - 'a' + 10;
return true;
}
if ('A' <= c && c <= 'F') {
*out = c - 'A' + 10;
return true;
}
return false;
}
bool FileTest::GetBytes(std::vector<uint8_t> *out, const std::string &key) {
std::string value;
if (!GetAttribute(&value, key)) {
return false;
}
if (value.size() >= 2 && value[0] == '"' && value[value.size() - 1] == '"') {
out->assign(value.begin() + 1, value.end() - 1);
return true;
}
if (value.size() % 2 != 0) {
PrintLine("Error decoding value: %s", value.c_str());
return false;
}
out->reserve(value.size() / 2);
for (size_t i = 0; i < value.size(); i += 2) {
uint8_t hi, lo;
if (!FromHexDigit(&hi, value[i]) || !FromHexDigit(&lo, value[i+1])) {
PrintLine("Error decoding value: %s", value.c_str());
return false;
}
out->push_back((hi << 4) | lo);
}
return true;
}
static std::string EncodeHex(const uint8_t *in, size_t in_len) {
static const char kHexDigits[] = "0123456789abcdef";
std::string ret;
ret.reserve(in_len * 2);
for (size_t i = 0; i < in_len; i++) {
ret += kHexDigits[in[i] >> 4];
ret += kHexDigits[in[i] & 0xf];
}
return ret;
}
bool FileTest::ExpectBytesEqual(const uint8_t *expected, size_t expected_len,
const uint8_t *actual, size_t actual_len) {
if (expected_len == actual_len &&
memcmp(expected, actual, expected_len) == 0) {
return true;
}
std::string expected_hex = EncodeHex(expected, expected_len);
std::string actual_hex = EncodeHex(actual, actual_len);
PrintLine("Expected: %s", expected_hex.c_str());
PrintLine("Actual: %s", actual_hex.c_str());
return false;
}
void FileTest::ClearTest() {
start_line_ = 0;
type_.clear();
parameter_.clear();
attributes_.clear();
block_.clear();
unused_attributes_.clear();
used_block_ = false;
}
void FileTest::OnKeyUsed(const std::string &key) {
unused_attributes_.erase(key);
}
int FileTestMain(bool (*run_test)(FileTest *t, void *arg), void *arg,
const char *path) {
FileTest t(path);
if (!t.is_open()) {
return 1;
}
bool failed = false;
while (true) {
FileTest::ReadResult ret = t.ReadNext();
if (ret == FileTest::kReadError) {
return 1;
} else if (ret == FileTest::kReadEOF) {
break;
}
bool result = run_test(&t, arg);
if (t.HasAttribute("Error")) {
if (result) {
t.PrintLine("Operation unexpectedly succeeded.");
failed = true;
continue;
}
uint32_t err = ERR_peek_error();
if (ERR_reason_error_string(err) != t.GetAttributeOrDie("Error")) {
t.PrintLine("Unexpected error; wanted '%s', got '%s'.",
t.GetAttributeOrDie("Error").c_str(),
ERR_reason_error_string(err));
failed = true;
continue;
}
ERR_clear_error();
} else if (!result) {
// In case the test itself doesn't print output, print something so the
// line number is reported.
t.PrintLine("Test failed");
ERR_print_errors_fp(stderr);
failed = true;
continue;
}
}
if (failed) {
return 1;
}
printf("PASS\n");
return 0;
}