| /** |
| * Copyright (c) Zygmunt Krynicki <zygmunt.krynicki@linaro.org> 2012 |
| **/ |
| |
| #include <assert.h> |
| #include <errno.h> |
| #include <stdarg.h> |
| #include <stdbool.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/time.h> |
| #include <sys/types.h> |
| #include <sys/wait.h> |
| #include <time.h> |
| #include <unistd.h> |
| |
| #include "bundle.h" |
| #include "debug.h" |
| #include "json-format.h" |
| #include "json-test.h" |
| #include "text-utils.h" |
| #include "uuid.h" |
| |
| /** Patterns used to discover gtest-like output */ |
| #define GTEST_LOG1_PATTERN "[==========] " |
| #define GTEST_LOG2_PATTERN "[----------] " |
| #define GTEST_RUN_PATTERN "[ RUN ] " |
| #define GTEST_OK_PATTERN "[ OK ] " |
| #define GTEST_PASSED_PATTERN "[ PASSED ] " |
| #define GTEST_FAILED_PATTERN "[ FAILED ] " |
| |
| enum gtest_line_type { |
| GTEST_LINE_LOG1, |
| GTEST_LINE_LOG2, |
| GTEST_LINE_RUN, |
| GTEST_LINE_OK, |
| GTEST_LINE_PASSED, |
| GTEST_LINE_FAILED, |
| GTEST_LINE_OTHER |
| }; |
| |
| |
| static |
| void |
| process_output( |
| FILE *bundle_stream, |
| FILE *child_stream, |
| unsigned flags |
| ) |
| { |
| char *line = NULL; |
| size_t line_capacity = 0; |
| char *line_sans_pattern = NULL; |
| int lineno = 0; |
| enum gtest_line_type line_type; |
| |
| int test_run_cnt = 0; |
| char *previous_test_id = NULL; |
| size_t previous_test_id_capacity = 0; |
| |
| int test_result_cnt = 0; |
| bool test_result_open = false; |
| const char *test_result_result = "unknown"; |
| bool test_result_ready = false; |
| struct timeval test_result_start = { .tv_sec = 0, .tv_usec = 0}; |
| |
| struct timeval line_timestamp; |
| do { |
| /* Read a line from the child stream */ |
| if (text_readline(&line, &line_capacity, child_stream) != 0) { |
| perror("text_readline()"); |
| abort(); |
| } |
| lineno += 1; |
| /* Measure the time, we may need it in several spots below */ |
| gettimeofday(&line_timestamp, NULL); |
| /* We need to classify each line, there are a number of options: |
| * 0) status lines (either '=' or '-') |
| * 1) a 'RUN' line is where we start to run a test case |
| * 2) a 'OK' line is when the test passes |
| * 3) a 'FAILED' line is when the test has failed (but it must be |
| * paired with 'RUN' line just directly before. |
| * 4) other lines, arbitrary messages generated by the the case |
| * 5) a summary line like 'PASSED' or FAILED (we ignore those) */ |
| if (strstr(line, GTEST_LOG1_PATTERN)) { |
| line_type = GTEST_LINE_LOG1; |
| line_sans_pattern = line + strlen(GTEST_LOG1_PATTERN); |
| } else if (strstr(line, GTEST_LOG2_PATTERN)) { |
| line_type = GTEST_LINE_LOG2; |
| line_sans_pattern = line + strlen(GTEST_LOG2_PATTERN); |
| } else if (strstr(line, GTEST_RUN_PATTERN)) { |
| line_type = GTEST_LINE_RUN; |
| line_sans_pattern = line + strlen(GTEST_RUN_PATTERN); |
| } else if (strstr(line, GTEST_OK_PATTERN)) { |
| line_type = GTEST_LINE_OK; |
| line_sans_pattern = line + strlen(GTEST_OK_PATTERN); |
| } else if (strstr(line, GTEST_PASSED_PATTERN)) { |
| line_type = GTEST_LINE_PASSED; |
| line_sans_pattern = line + strlen(GTEST_PASSED_PATTERN); |
| } else if (strstr(line, GTEST_FAILED_PATTERN)) { |
| line_type = GTEST_LINE_FAILED; |
| line_sans_pattern = line + strlen(GTEST_FAILED_PATTERN); |
| } else { |
| line_type = GTEST_LINE_OTHER; |
| line_sans_pattern = line; |
| } |
| /* Now that we know what kind of line we have we can run our simple state |
| * machine to react to the data */ |
| switch (line_type) { |
| case GTEST_LINE_LOG1: |
| case GTEST_LINE_LOG2: |
| case GTEST_LINE_PASSED: |
| debug_log("message from gtest: %s\n", line_sans_pattern); |
| break; |
| case GTEST_LINE_FAILED: |
| /* FAILED line is printed when a test case fails |
| * and we need to keep track of that. Sadly, it is |
| * also printed as a 'summary' line at the end of a test run. |
| * |
| * To differentiate them we will treat any FAILED line that was |
| * printed after a RUN line was seen (which opens a test case) |
| * as the terminator */ |
| if (test_result_open) { |
| debug_log("test case finished unsuccessfully\n"); |
| /* This test case has failed */ |
| test_result_result = "fail"; |
| /* And we have enough data to print the test case footer */ |
| test_result_ready = true; |
| } else |
| debug_log("message from gtest: %s\n", line_sans_pattern); |
| break; |
| case GTEST_LINE_RUN: |
| { |
| char *dot; |
| char *test_case_id; |
| char *test_id; |
| /* We need to terminate previous test case that has probably |
| * crashed bad enough not to print the failure record */ |
| if (test_result_open) { |
| struct timeval duration; |
| duration.tv_sec = line_timestamp.tv_sec - test_result_start.tv_sec; |
| duration.tv_usec = line_timestamp.tv_usec - test_result_start.tv_usec; |
| debug_log("closing previous test result\n"); |
| bundle_print_test_result_footer( |
| bundle_stream, flags, |
| test_result_result, "<stdout>", lineno, duration); |
| test_result_ready = false; |
| test_result_open = false; |
| } |
| /* Parse the RUN line. Try to find the test case id (it |
| * should be right after the dot component that separates |
| * test id from test case id */ |
| dot = strchr(line_sans_pattern, '.'); |
| if (dot != NULL) { |
| /* The test case has a dot component. We can use that to |
| * discover the test id and test case id. Let's just split |
| * it there by modifying the dot to a nul character */ |
| *dot = 0; |
| test_id = line_sans_pattern; |
| test_case_id = dot + 1; |
| } else { |
| /* For some reason the test case did not have the dot that |
| * otherwise separates test id from test case id. */ |
| test_id = "unknown-gtest-based-test"; |
| test_case_id = line_sans_pattern; |
| } |
| /* We may need to print the test run header. |
| * |
| * This can happen when we see a change in test_id or when |
| * we need the initial header for the very first test case. */ |
| if (previous_test_id == NULL || strcmp(previous_test_id, test_id) != 0) { |
| char analyzer_assigned_uuid[UUID_ASCII_LEN + 1]; |
| const bool time_check_performed = false; |
| /* Close the previous test run if it is open */ |
| if (test_run_cnt > 0) { |
| debug_log("closing previous test run\n"); |
| bundle_print_test_run_footer(bundle_stream, flags); |
| } |
| /* Copy the old test_id so that we can keep comparing it */ |
| if (text_copy(&previous_test_id, |
| &previous_test_id_capacity, test_id) != 0) { |
| perror("text_copy()"); |
| abort(); |
| } |
| /* Generate an UUID */ |
| if (uuid_gen(analyzer_assigned_uuid) != 0) { |
| perror("uuid_gen()"); |
| abort(); |
| } |
| debug_log("generated analyzer_assigned_uuid: %s\n", analyzer_assigned_uuid); |
| /* Open another test run */ |
| debug_log("starting new test run for test_id: %s\n", test_id); |
| bundle_print_test_run_header( |
| bundle_stream, flags, test_run_cnt > 0, |
| analyzer_assigned_uuid, line_timestamp.tv_sec, |
| time_check_performed, test_id); |
| /* Keep track of the number of test runs we have printed */ |
| test_run_cnt += 1; |
| /* Reset the number of test cases we've printed in this test run */ |
| test_result_cnt = 0; |
| } |
| debug_log("starting new test result for test_case_id: %s\n", test_case_id); |
| test_result_start = line_timestamp; |
| /* Print the header of the test result */ |
| bundle_print_test_result_header( |
| bundle_stream, flags, test_result_cnt > 0, test_case_id, |
| test_result_start.tv_sec); |
| /* Keep track of subsequent test cases in one test run */ |
| test_result_cnt += 1; |
| /* Keep track of output state */ |
| test_result_open = true; |
| /* Reset result to unknown */ |
| test_result_result = "unknown"; |
| } |
| break; |
| case GTEST_LINE_OK: |
| debug_log("test case finished successfully\n"); |
| /* This test case has passed */ |
| test_result_result = "pass"; |
| /* And we have enough data to print the test case footer */ |
| test_result_ready = true; |
| break; |
| case GTEST_LINE_OTHER: |
| /* Once we've seen a RUN line that opens a test case |
| * we want to capture any output as test case message. */ |
| if (test_result_open) { |
| debug_log("message from test: %s\n", line_sans_pattern); |
| bundle_print_test_result_message( |
| bundle_stream, flags, |
| line_sans_pattern); |
| } else |
| debug_log("message from gtest: %s\n", line_sans_pattern); |
| break; |
| default: |
| abort(); |
| } |
| /* Write out the test result once we have everything */ |
| if (test_result_ready) { |
| struct timeval duration; |
| duration.tv_sec = line_timestamp.tv_sec - test_result_start.tv_sec; |
| duration.tv_usec = line_timestamp.tv_usec - test_result_start.tv_usec; |
| debug_log("closing previous test result\n"); |
| bundle_print_test_result_footer( |
| bundle_stream, flags, |
| test_result_result, "<stdout>", lineno, duration); |
| test_result_ready = false; |
| test_result_open = false; |
| } |
| } while (!feof(child_stream)); |
| /* We may need to terminate the final test result */ |
| if (test_result_open) { |
| struct timeval duration; |
| duration.tv_sec = line_timestamp.tv_sec - test_result_start.tv_sec; |
| duration.tv_usec = line_timestamp.tv_usec - test_result_start.tv_usec; |
| debug_log("closing previous (final) test result\n"); |
| bundle_print_test_result_footer( |
| bundle_stream, flags, |
| test_result_result, "<stdout>", lineno, duration); |
| } |
| /* We may need to terminate the final test run */ |
| if (test_run_cnt > 0) { |
| debug_log("closing previous (final) test run\n"); |
| bundle_print_test_run_footer(bundle_stream, flags); |
| } |
| /* Reclaim line cache */ |
| if (line) |
| free(line); |
| /* Reclaim memory used to keep the previous test_id */ |
| if (previous_test_id) |
| free(previous_test_id); |
| } |
| |
| |
| static void |
| run_test_prog( |
| const char *test_prog, |
| const char *bundle_name, |
| unsigned flags |
| ) |
| { |
| FILE *child_stream; |
| FILE *bundle_stream; |
| /* Open the bundle file */ |
| bundle_stream = fopen(bundle_name, "wt"); |
| if (bundle_stream == NULL) { |
| perror("fopen()"); |
| abort(); |
| } |
| /* Open the child process */ |
| child_stream = popen(test_prog, "r"); |
| if (child_stream == NULL) { |
| perror("popen()"); |
| abort(); |
| } |
| /* Write the bundle header */ |
| debug_log("Saving bundle to %s\n", bundle_name); |
| bundle_print_header(bundle_stream, flags, "Dashboard Bundle Format 1.3"); |
| /* Process the output data */ |
| process_output(bundle_stream, child_stream, flags); |
| /* Terminate the test process */ |
| pclose(child_stream); |
| /* Write the bundle footer */ |
| bundle_print_footer(bundle_stream, flags); |
| } |
| |
| |
| static void show_usage() { |
| printf("Usage: android-lava-wrapper [-o BUNDLE] [-r] [-d] <executable>\n" |
| " android-lava-wrapper -t\n" |
| "\n" |
| "The first form runs the specified executable and parses\n" |
| "the output as a gtest-based test.\n" |
| "-r creates a human-readable bundle\n" |
| "-o sets the name of the bundle, by default it is bundle.json\n" |
| "-d enables debugging\n" |
| "\n" |
| "The second form runs the internal self-test\n"); |
| } |
| |
| |
| int main(int argc, char *argv[]) { |
| int opt; |
| unsigned flags = 0; |
| const char *bundle_pathname = "bundle.json"; |
| while ((opt = getopt(argc, argv, "drto:")) != -1) { |
| switch (opt) { |
| case 'd': |
| debug_enable(stderr); |
| break; |
| case 'r': |
| flags |= JSON_READABLE; |
| break; |
| case 't': |
| json_test_all(); |
| return 0; |
| case 'o': |
| bundle_pathname = optarg; |
| break; |
| default: |
| show_usage(); |
| printf("\nUnsupported option: %c\n", optopt); |
| return 1; |
| } |
| } |
| if (optind >= argc) { |
| show_usage(); |
| printf("\nYou have to pass the pathname of the executable to run\n"); |
| return 1; |
| } else { |
| run_test_prog(argv[optind], bundle_pathname, flags); |
| return 0; |
| } |
| } |
