tests improvements

- suppress the output for unit_evaluate
- improve debug printout codec_conversion_test_testcard_uyvy_to_i420
- improve C variant of ASSERT_EQUAL_MESSAGE macro (prints num values
also in hex)
- remove VLA from codec_conversions_test.cpp (not valid in C++)

Author: MartinPulec

src/utils/fs.h

@@ -43,10 +43,12 @@
 #ifdef _WIN32
 #include <windef.h>            /// for MAX_PATH
 #define MAX_PATH_SIZE (MAX_PATH + 1)
+#define NULL_FILE "NUL"
 #define PATH_SEPARATOR "\\"
 #else
 #include <limits.h>
 #define MAX_PATH_SIZE PATH_MAX
+#define NULL_FILE "/dev/null"
 #define PATH_SEPARATOR "/"
 #endif
 

test/codec_conversions_test.cpp

@@ -41,21 +41,24 @@ int codec_conversion_test_testcard_uyvy_to_i420(void)
                 unsigned char uyvy_pattern[4] = { 'u', 'y', 'v', 'Y' };
                 size_t uyvy_buf_size = ((size_x + 1) & ~1) * 2 * size_y;
 
-                unsigned char uyvy_buf[uyvy_buf_size];
+                vector<unsigned char> uyvy_buf(uyvy_buf_size);
                 for (size_t i = 0; i < size_y * 2 * ((size_x + 1) & ~1); ++i) {
                         uyvy_buf[i] = uyvy_pattern[i % 4];
                 }
 
                 auto *i420_buf = (unsigned char *) malloc(vc_get_datalen(size_x, size_y, I420));
-                testcard_convert_buffer(UYVY, I420, i420_buf, uyvy_buf, size_x, size_y);
+                testcard_convert_buffer(UYVY, I420, i420_buf, uyvy_buf.data(),
+                                        size_x, size_y);
                 unsigned char *y_ptr = i420_buf;
                 for (size_t i = 0; i < size_y; ++i) {
                         for (size_t j = 0; j < size_x; ++j) {
                                 ostringstream oss;
                                 unsigned char expected = uyvy_pattern[((2 * j + 1) % 4)];
                                 unsigned char actual = *y_ptr++;
-                                oss << size_x << "X" << size_y << ": [" << i << ", " << j << "]";
-                                ASSERT_EQUAL_MESSAGE(oss.str(), expected, actual);
+                                oss << "size: " << size_x << "x" << size_y
+                                    << ": [" << i << ", " << j << "]";
+                                ASSERT_EQUAL_MESSAGE(oss.str(), expected,
+                                                     actual);
                         }
                 }
                 // U
@@ -65,7 +68,8 @@ int codec_conversion_test_testcard_uyvy_to_i420(void)
                                 ostringstream oss;
                                 unsigned char expected = 'u';
                                 unsigned char actual = *u_ptr++;
-                                oss << "[" << i << ", " << j << "]";
+                                oss << "size: " << size_x << "x" << size_y
+                                    << ": [" << i << ", " << j << "]";
                                 ASSERT_EQUAL_MESSAGE(oss.str(), expected, actual);
                         }
                 }
@@ -136,7 +140,7 @@ codec_conversion_test_y216_to_p010le(void)
                 y216_to_p010le(out_data, out_linesize,
                                (unsigned char *) &y216_buf[0], size_x, size_y);
 
-                auto *y_ptr = (uint16_t *) out_data[0];
+                auto *y_ptr = (uint16_t *) (void *) out_data[0];
                 for (size_t i = 0; i < size_y; ++i) {
                         for (size_t j = 0; j < size_x; ++j) {
                                 ostringstream oss;
@@ -150,7 +154,8 @@ codec_conversion_test_y216_to_p010le(void)
                 }
                 // UV combined
                 for (size_t i = 0; i < (size_y + 1) / 2; ++i) {
-                        auto *uv_ptr = (uint16_t *) out_data[1] + i * ((size_x + 1) & ~1);
+                        auto *uv_ptr = ((uint16_t *) (void *) out_data[1]) +
+                                       i * ((size_x + 1) & ~1);
                         for (size_t j = 0; j < ((size_x + 1) & ~1); ++j) {
                                 ostringstream oss;
                                 auto expected = y216_pattern[((2 * j + 1) % 4)];

test/misc_test.cpp

@@ -1,12 +1,22 @@
 #include <climits>
-#include <cstring>         // for strcmp
 #include <cmath>           // for abs
+#include <cstring>         // for strcmp
 #include <list>
 #include <sstream>
 #include <string>          // for allocator, basic_string, operator+, string
 
+#include <fcntl.h>
+#include <sys/stat.h>
+#ifdef _WIN32
+#include <cstdlib>
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
 #include "color.h"
 #include "types.h"
+#include "utils/fs.h"      // for NULL_FILE
 #include "utils/misc.h"
 #include "utils/net.h"
 #include "utils/string.h"
@@ -155,13 +165,22 @@ int misc_test_unit_evaluate()
                 { "Gi",    LLONG_MIN,         "Gi" },
         };
 
+        // temporarily redirect output to null file
+        int stdout_save = dup(STDOUT_FILENO);
+        int null_fd = open(NULL_FILE, O_WRONLY);
+        dup2(null_fd, STDOUT_FILENO);
+        close(null_fd);
+
         for (unsigned i = 0; i < sizeof test_cases / sizeof test_cases[0];
              ++i) {
               const char *endptr = nullptr;
               long long val = unit_evaluate(test_cases[i].str, &endptr);
               ASSERT_EQUAL(test_cases[i].exp_val, val);
               ASSERT_EQUAL_STR(test_cases[i].exp_endstr, endptr);
         }
+        // restore output
+        dup2(stdout_save, STDOUT_FILENO);
+        close(stdout_save);
 
         return 0;
 }

test/unit_common.h

@@ -78,9 +78,10 @@
 #define ASSERT_EQUAL_MESSAGE(msg, expected, actual) \
         if ((expected) != (actual)) { \
                 fprintf(stderr, \
-                        "Assertion failed - expected %" PRIdMAX \
-                        ", actual %" PRIdMAX ": %s\n", \
-                        (intmax_t) (expected), (intmax_t) (actual), (msg)); \
+                        "Assertion failed - expected %" PRIdMAX " (%#" PRIxMAX \
+                        "), actual %" PRIdMAX " (%#" PRIxMAX "): %s\n", \
+                        (intmax_t) (expected), (uintmax_t) (expected), \
+                        (intmax_t) (actual), (uintmax_t) (actual), (msg)); \
                 return -1; \
         }
 #endif