clang-format runtime/bin

runtime/bin/run_vm_tests_fuchsia.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <fcntl.h>
 #include <launchpad/launchpad.h>
 #include <launchpad/vmo.h>
 #include <magenta/status.h>
 #include <magenta/syscalls.h>
 #include <magenta/syscalls/object.h>
 #include <mxio/util.h>
 #include <pthread.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 // This program runs Dart VM unit tests. The Dart VM unit tests are contained
 // in a separate binary whose location is defined in kRunVmTestsPath below.
 // That program accepts a command line argument --list to list all the available
 // tests, or the name of a single test to run. This program grabs the list of
 // tests, and then runs them.
 
 // TODO(zra): Make this a command line argument
 const char* kRunVmTestsPath = "/boot/bin/dart_vm_tests";
 
+// clang-format off
 // Tests that are invalid, wedge, or cause panics.
 const char* kSkip[] = {
   // These expect a file to exist that we aren't putting in the image.
   "Read",
   "FileLength",
   "FilePosition",
   // Crash in abort() and then hang. (MG-252)
   "ArrayLengthMaxElements",
   "Int8ListLengthMaxElements",
   "ArrayNew_Overflow_Crash",
@@ skipping 62 matching lines @@
   "CodeImmutability",
   // Assumes initial thread's stack is the same size as spawned thread stacks.
   "StackOverflowStacktraceInfo",
 };
 
 // Bugs to fix, or things that are not yet implemented.
 const char* kBugs[] = {
   // Needs read of RSS.
   "InitialRSS",
 };
-
+// clang-format on
 
 static bool contains(const char** list, intptr_t len, const char* str) {
   for (intptr_t i = 0; i < len; i++) {
     if (strcmp(list[i], str) == 0) {
       return true;
     }
   }
   return false;
 }
 
 
 static bool isSkip(const char* test) {
-  return contains(
-      kSkip, sizeof(kSkip) / sizeof(kSkip[0]), test);
+  return contains(kSkip, sizeof(kSkip) / sizeof(kSkip[0]), test);
 }
 
 
 static bool isExpectFail(const char* test) {
-  return contains(
-      kExpectFail, sizeof(kExpectFail) / sizeof(kExpectFail[0]), test);
+  return contains(kExpectFail, sizeof(kExpectFail) / sizeof(kExpectFail[0]),
+                  test);
 }
 
 
 static bool isBug(const char* test) {
   return contains(kBugs, sizeof(kBugs) / sizeof(kBugs[0]), test);
 }
 
 #define RETURN_IF_ERROR(status)                                                \
   if (status < 0) {                                                            \
     fprintf(stderr, "%s:%d: Magenta call failed: %s\n", __FILE__, __LINE__,    \
             mx_status_get_string(static_cast<mx_status_t>(status)));           \
     fflush(0);                                                                 \
     return status;                                                             \
   }
 
 // This is mostly taken from //magenta/system/uapp/mxsh with the addtion of
 // launchpad_add_pipe calls to setup pipes for stdout and stderr.
-static mx_status_t lp_setup(launchpad_t** lp_out, mx_handle_t binary_vmo,
-                            int argc, const char* const* argv,
-                            int *stdout_out, int *stderr_out) {
+static mx_status_t lp_setup(launchpad_t** lp_out,
+                            mx_handle_t binary_vmo,
+                            int argc,
+                            const char* const* argv,
+                            int* stdout_out,
+                            int* stderr_out) {
   if ((lp_out == NULL) || (stdout_out == NULL) || (stderr_out == NULL)) {
     return ERR_INVALID_ARGS;
   }
   launchpad_t* lp;
   mx_status_t status;
   status = launchpad_create(0, argv[0], &lp);
   RETURN_IF_ERROR(status);
   status = launchpad_arguments(lp, argc, argv);
   RETURN_IF_ERROR(status);
   status = launchpad_clone_mxio_root(lp);
   RETURN_IF_ERROR(status);
   status = launchpad_add_pipe(lp, stdout_out, 1);
   RETURN_IF_ERROR(status);
   status = launchpad_add_pipe(lp, stderr_out, 2);
   RETURN_IF_ERROR(status);
   status = launchpad_add_vdso_vmo(lp);
   RETURN_IF_ERROR(status);
   status = launchpad_elf_load(lp, binary_vmo);
   RETURN_IF_ERROR(status);
   status = launchpad_load_vdso(lp, MX_HANDLE_INVALID);
   RETURN_IF_ERROR(status);
   *lp_out = lp;
   return status;
 }
 
 
 // Start the test running and return file descriptors for the stdout and stderr
 // pipes.
-static mx_handle_t start_test(mx_handle_t binary_vmo, const char* test_name,
-                              int* stdout_out, int* stderr_out) {
+static mx_handle_t start_test(mx_handle_t binary_vmo,
+                              const char* test_name,
+                              int* stdout_out,
+                              int* stderr_out) {
   const intptr_t kArgc = 2;
   const char* argv[kArgc];
 
   argv[0] = kRunVmTestsPath;
   argv[1] = test_name;
 
   launchpad_t* lp = NULL;
   int stdout_pipe = -1;
   int stderr_pipe = -1;
-  mx_status_t status = lp_setup(
-      &lp, binary_vmo, kArgc, argv, &stdout_pipe, &stderr_pipe);
+  mx_status_t status =
+      lp_setup(&lp, binary_vmo, kArgc, argv, &stdout_pipe, &stderr_pipe);
   if (status != NO_ERROR) {
     if (lp != NULL) {
       launchpad_destroy(lp);
     }
     if (stdout_pipe != -1) {
       close(stdout_pipe);
     }
     if (stderr_pipe != -1) {
       close(stderr_pipe);
     }
@@ skipping 45 matching lines @@
   }
   buf[total_read] = '\0';
   close(fd);
   *buffer = buf;
   return total_read;
 }
 
 
 // Runs test 'test_name' and gives stdout and stderr for the test in
 // 'test_stdout' and 'test_stderr'. Returns the exit code from the test.
-static int run_test(mx_handle_t binary_vmo, const char* test_name,
-                    char** test_stdout, char** test_stderr) {
+static int run_test(mx_handle_t binary_vmo,
+                    const char* test_name,
+                    char** test_stdout,
+                    char** test_stderr) {
   int stdout_pipe = -1;
   int stderr_pipe = -1;
   mx_handle_t p = start_test(binary_vmo, test_name, &stdout_pipe, &stderr_pipe);
   RETURN_IF_ERROR(p);
 
   drain_fd(stdout_pipe, test_stdout);
   drain_fd(stderr_pipe, test_stderr);
 
-  mx_status_t r = mx_handle_wait_one(
-      p, MX_SIGNAL_SIGNALED, MX_TIME_INFINITE, NULL);
+  mx_status_t r =
+      mx_handle_wait_one(p, MX_SIGNAL_SIGNALED, MX_TIME_INFINITE, NULL);
   RETURN_IF_ERROR(r);
 
   mx_info_process_t proc_info;
   mx_size_t info_size;
   mx_status_t status =
-      mx_object_get_info(p, MX_INFO_PROCESS, sizeof(proc_info.rec),
-                         &proc_info, sizeof(proc_info), &info_size);
+      mx_object_get_info(p, MX_INFO_PROCESS, sizeof(proc_info.rec), &proc_info,
+                         sizeof(proc_info), &info_size);
   RETURN_IF_ERROR(status);
 
   r = mx_handle_close(p);
   RETURN_IF_ERROR(r);
   return proc_info.rec.return_code;
 }
 
 
-static void handle_result(
-    intptr_t result, char* test_stdout, char* test_stderr, const char* test) {
+static void handle_result(intptr_t result,
+                          char* test_stdout,
+                          char* test_stderr,
+                          const char* test) {
   if (result != 0) {
     if (!isExpectFail(test) && !isBug(test)) {
-      printf("**** Test %s FAILED\n\nstdout:\n%s\nstderr:\n%s\n",
-          test, test_stdout, test_stderr);
+      printf("**** Test %s FAILED\n\nstdout:\n%s\nstderr:\n%s\n", test,
+             test_stdout, test_stderr);
     } else {
       printf("Test %s FAILED and is expected to fail\n", test);
     }
   } else {
     if (isExpectFail(test)) {
-      printf("**** Test %s is expected to fail, but PASSED\n\n"
-             "stdout:\n%s\nstderr:\n%s\n",
-             test, test_stdout, test_stderr);
+      printf(
+          "**** Test %s is expected to fail, but PASSED\n\n"
+          "stdout:\n%s\nstderr:\n%s\n",
+          test, test_stdout, test_stderr);
     } else if (isBug(test)) {
       printf("**** Test %s is marked as a bug, but PASSED\n", test);
     } else {
       printf("Test %s PASSED\n", test);
     }
   }
 }
 
 
 typedef struct {
@@ skipping 131 matching lines @@
   RETURN_IF_ERROR(status);
 
   // Complain if we didn't try to run all of the tests.
   if (test_list_index != lines_count) {
     fprintf(stderr, "Failed to attempt all the tests!\n");
     fflush(0);
     return -1;
   }
   return 0;
 }