bool test_file_reader_destroy_invalid_argument (Test *test)
{
TITLE ();
file_reader_destroy (NULL);
CATCH (error_count () != 1);
CATCH (error_at (0).error != ErrorInvalidArgument);
PASS ();
}
bool test_file_reader_create (Test *test)
{
FileReader *reader;
char *path;
TITLE ();
CATCH (!(path = directory_current_path ()));
CATCH (!string_append (&path, "/stage/file_reader/file"));
CATCH (!(reader = file_reader_create (path)));
CATCH (reader->size != 5);
CATCH (!string_equals ((const char *)reader->map, "test\n"));
file_reader_destroy (reader);
string_destroy (path);
PASS ();
}
FileReader *file_reader_create (const char *path)
{
FileReader *reader;
struct stat st;
if (!file_path_is_valid (path)) {
error_code (FunctionCall, 1);
return NULL;
}
if (!(reader = memory_create (sizeof (FileReader)))) {
error_code (FunctionCall, 2);
return NULL;
}
reader->file_descriptor = -1;
if (stat (path, &st) != 0) {
file_reader_destroy (reader);
error_code (SystemCall, 1);
return NULL;
}
reader->size = st.st_size;
if ((reader->file_descriptor = open (path, O_RDONLY, 0)) == -1) {
file_reader_destroy (reader);
error_code (SystemCall, 2);
return NULL;
}
if ((reader->map = (unsigned char *)mmap (NULL,
(size_t)reader->size,
PROT_READ,
MAP_PRIVATE | MAP_POPULATE,
reader->file_descriptor, 0)) == MAP_FAILED) {
file_reader_destroy (reader);
error_code (SystemCall, 3);
return NULL;
}
return reader;
}
void mov_reader_destroy(void* p)
{
size_t i;
struct mov_reader_t* reader;
reader = (struct mov_reader_t*)p;
file_reader_destroy(&reader->mov.fp);
for (i = 0; i < reader->mov.track_count; i++)
{
FREE(reader->mov.tracks[i].extra_data);
FREE(reader->mov.tracks[i].stsd);
FREE(reader->mov.tracks[i].elst);
FREE(reader->mov.tracks[i].samples);
FREE(reader->mov.tracks[i].stbl.stco);
FREE(reader->mov.tracks[i].stbl.stsc);
FREE(reader->mov.tracks[i].stbl.stss);
FREE(reader->mov.tracks[i].stbl.stts);
FREE(reader->mov.tracks[i].stbl.ctts);
}
free(reader);
}
bool test_file_writer_write_args (Test *test)
{
FileWriter *writer;
FileReader *reader;
char *path;
TITLE ();
CATCH (!(path = directory_current_path ()));
CATCH (!string_append (&path, "/stage/file_writer/args"));
if (file_exists (path)) {
CATCH (!file_remove (path));
}
CATCH (!(writer = file_writer_create (path, FileWriterModeTruncate)));
CATCH (!file_writer_write_args (writer, "abc%i123%s", 0, "4"));
file_writer_destroy (writer);
CATCH (!(reader = file_reader_create (path)));
CATCH (!string_equals ((const char *)reader->map, "abc01234"));
file_reader_destroy (reader);
string_destroy (path);
PASS ();
}
bool test_print_log_2 (Test *test)
{
FileReader *reader;
char *path;
TITLE ();
CATCH (!(path = directory_current_path ()));
CATCH (!string_append (&path, "/stage/print_log/log"));
print_silent (false);
if (file_exists (path)) {
CATCH (!file_remove (path));
}
CATCH (!print_log_begin (path));
CATCH (!print (" \b"));
CATCH (!print_log_end ());
CATCH (!(reader = file_reader_create (path)));
print_silent (true);
CATCH (!string_equals ((const char *)reader->map, " \b"));
file_reader_destroy (reader);
string_destroy (path);
PASS ();
}
int main (int argc, char **argv)
{
char *pattern;
char *file;
FileReader *reader = NULL;
PatternSearch *search = NULL;
bool success;
AppArgument arguments[] = {
ARGUMENT_ORDINAL_STRING (NULL, true, &pattern, "Pattern."),
ARGUMENT_ORDINAL_STRING (NULL, true, &file, "File."),
ARGUMENT_DEFAULT,
ARGUMENT_END
};
if (!app_arguments (argc, argv, arguments)) {
app_arguments_usage (argc, argv, arguments);
return EXIT_FAILURE;
}
success = try (&reader, &search, pattern, file);
if (reader) {
file_reader_destroy (reader);
}
if (search) {
pattern_search_destroy (search);
}
if (!success || error_count () != 0) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
static bool try (FileReader **reader, PatternSearch **search, const char *pattern, const char *file)
{
size_t from, to;
if (!(*reader = file_reader_create (file))) {
error_code (FunctionCall, 1);
return false;
}
if (!(*search = pattern_search_create ((*reader)->map, (size_t)(*reader)->size, pattern, false))) {
error_code (FunctionCall, 2);
return false;
}
while (pattern_search_next (*search, &from, &to)) {
if (!print_range ((const char *)(*reader)->map, from, to)) {
error_code (FunctionCall, 3);
return false;
}
if (putc ((int)'\n', stdout) == EOF) {
error (SystemCall);
return false;
}
}
return true;
}
static bool print_range (const char *buffer, size_t from, size_t to)
{
if (to - from == 0) {
return true;
}
if (fwrite (buffer + from, 1, to - from, stdout) != to - from) {
error (SystemCall);
return false;
}
return true;
}
