Add scripts to build a toolchain for running VM tests

tools/init.cpp

@@ -0,0 +1,185 @@
+#include <algorithm>
+#include <memory>
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <dirent.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/reboot.h>
+
+template<std::size_t size>
+std::size_t read_command(int descriptor, char *command_buffer)
+{
+    std::ptrdiff_t bytes_read{ 0 };
+    std::size_t read_so_far{ 0 };
+
+    while ((bytes_read = read(descriptor, command_buffer + read_so_far, size - read_so_far - 1)) > 0)
+    {
+        read_so_far += bytes_read;
+        if (read_so_far >= size - 1)
+        {
+            break;
+        }
+    }
+    command_buffer[read_so_far] = 0;
+    return read_so_far;
+}
+
+enum class status
+{
+    success,
+    failure,
+    warning,
+    fatal
+};
+
+template<std::size_t size>
+void make_path(char *destination, const char *directory, const char *filename, const char *extension)
+{
+    memcpy(destination, directory, strlen(directory));
+    std::size_t remaining_space = size - strlen(directory);
+
+    if (extension != nullptr)
+    {
+        remaining_space -= strlen(extension) + 1;
+    }
+    strncpy(destination + strlen(directory), filename, remaining_space);
+
+    if (extension != nullptr)
+    {
+        strncpy(destination + strlen(destination), extension, strlen(extension));
+    }
+}
+
+status run_test(const char *file_entry_name)
+{
+    printf("Running %s. ", file_entry_name);
+
+    char filename[256];
+    char command_buffer[256];
+    char file_buffer[256];
+    int pipe_ends[2];
+
+    if (pipe(pipe_ends) == -1)
+    {
+        perror("pipe");
+        return status::fatal;
+    }
+    make_path<sizeof(filename)>(filename, "./tests/", file_entry_name, nullptr);
+
+    auto child_pid = fork();
+    if (child_pid == -1)
+    {
+        return status::fatal;
+    }
+    else if (child_pid == 0)
+    {
+        close(STDIN_FILENO);
+        close(STDERR_FILENO);
+        close(pipe_ends[0]); // Close the read end.
+
+        if (dup2(pipe_ends[1], STDOUT_FILENO) == -1)
+        {
+            perror("dup2");
+        }
+        else
+        {
+            execl(filename, filename);
+            perror("execl");
+        }
+        close(STDOUT_FILENO);
+        close(pipe_ends[1]);
+        std::exit(1);
+    }
+    else
+    {
+        close(pipe_ends[1]); // Close the write end.
+        auto read_from_command = read_command<sizeof(command_buffer)>(pipe_ends[0], command_buffer);
+        close(pipe_ends[0]);
+
+        int wait_status{ 0 };
+        wait(&wait_status);
+
+        make_path<sizeof(filename)>(filename, "./expectations/", file_entry_name, ".txt");
+
+        std::unique_ptr<FILE, int(*)(FILE *)> expectation_descriptor(fopen(filename, "r"), &fclose);
+
+        if (expectation_descriptor == nullptr)
+        {
+            return status::warning;
+        }
+        auto read_from_file = fread(file_buffer, 1, sizeof(file_buffer) - 1, expectation_descriptor.get());
+        file_buffer[std::max<std::ptrdiff_t>(0, read_from_file)] = 0;
+
+        if (strcmp(command_buffer, file_buffer) != 0)
+        {
+            printf("Failed. Got:\n%s", command_buffer);
+
+            return status::failure;
+        }
+        else
+        {
+            fwrite("\n", 1, 1, stdout);
+            return status::success;
+        }
+    }
+}
+
+struct summary
+{
+    std::size_t total{ 0 };
+    std::size_t failure{ 0 };
+    std::size_t success{ 0 };
+};
+
+void walk()
+{
+    auto directory_stream = opendir("./tests");
+    dirent *file_entry;
+
+    summary test_summary;
+
+    while ((file_entry = readdir(directory_stream)) != nullptr)
+    {
+        if (file_entry->d_name[0] == '.')
+        {
+            continue;
+        }
+        ++test_summary.total;
+        switch (run_test(file_entry->d_name))
+        {
+            case status::failure:
+                ++test_summary.failure;
+                break;
+            case status::success:
+                ++test_summary.success;
+                break;
+            case status::warning:
+                break;
+            case status::fatal:
+                goto end_walk;
+        }
+    }
+    printf("Successful: %lu, Failed: %lu, Total: %lu.\n",
+            test_summary.success, test_summary.failure, test_summary.total);
+end_walk:
+    closedir(directory_stream);
+}
+
+int main()
+{
+    auto dev_console = open("/dev/console", O_WRONLY);
+    if (dev_console != -1)
+    {
+        dup2(dev_console, STDOUT_FILENO);
+        walk();
+        close(dev_console);
+    }
+    sync();
+    reboot(RB_POWER_OFF);
+
+    return 1;
+}