wip

Author: Alex-PLACET

integration_tests/arrow_file_to_stream.cpp

@@ -1,43 +1,49 @@
 #include <cstdlib>
 #include <filesystem>
+#include <fstream>
 #include <iostream>
 #include <vector>
 
 #include "integration_tools.hpp"
 
 /**
- * @brief Reads a JSON file containing record batches and outputs the serialized Arrow IPC stream to stdout.
+ * @brief Reads a JSON file containing record batches and outputs the serialized Arrow IPC stream to a file.
  *
- * This program takes a JSON file path as a command-line argument, parses the record batches
- * from the JSON data, serializes them into Arrow IPC stream format, and writes the binary
- * stream to stdout. The output can be redirected to a file or piped to another program.
+ * This program takes a JSON file path and an output file path as command-line arguments,
+ * parses the record batches from the JSON data, serializes them into Arrow IPC stream format,
+ * and writes the binary stream to the specified output file.
  *
- * Usage: arrow_file_to_stream <json_file_path>
+ * Usage: arrow_file_to_stream <json_file_path> <output_arrow_file>
  *
  * @param argc Number of command-line arguments
  * @param argv Array of command-line arguments
  * @return EXIT_SUCCESS on success, EXIT_FAILURE on error
  */
 int main(int argc, char* argv[])
 {
-    // Check command-line arguments
-    if (argc != 2)
+    if (argc != 3)
     {
-        std::cerr << "Usage: " << argv[0] << " <json_file_path>\n";
-        std::cerr << "Reads a JSON file and outputs the serialized Arrow IPC stream to stdout.\n";
+        std::cerr << "Usage: " << argv[0] << " <json_file_path> <output_arrow_file>\n";
+        std::cerr << "Reads a JSON file and outputs the serialized Arrow IPC stream to a file.\n";
         return EXIT_FAILURE;
     }
 
     const std::filesystem::path json_path(argv[1]);
+    const std::filesystem::path output_path(argv[2]);
 
     try
     {
-        // Convert JSON file to stream using the library
-        std::vector<uint8_t> stream_data = integration_tools::json_file_to_stream(json_path);
-
-        // Write the binary stream to stdout
-        std::cout.write(reinterpret_cast<const char*>(stream_data.data()), stream_data.size());
-        std::cout.flush();
+        const std::vector<uint8_t> stream_data = integration_tools::json_file_to_stream(json_path);
+        
+        std::ofstream output_file(output_path, std::ios::binary);
+        if (!output_file)
+        {
+            std::cerr << "Error: Could not open output file: " << output_path << "\n";
+            return EXIT_FAILURE;
+        }
+        
+        output_file.write(reinterpret_cast<const char*>(stream_data.data()), static_cast<std::streamsize>(stream_data.size()));
+        output_file.close();
 
         return EXIT_SUCCESS;
     }

integration_tests/arrow_json_to_file.cpp

@@ -21,7 +21,6 @@
  */
 int main(int argc, char* argv[])
 {
-    // Check command-line arguments
     if (argc != 3)
     {
         std::cerr << "Usage: " << argv[0] << " <json_file_path> <output_file_path>\n";
@@ -34,18 +33,15 @@ int main(int argc, char* argv[])
 
     try
     {
-        // Convert JSON file to stream using the library
-        std::vector<uint8_t> stream_data = integration_tools::json_file_to_arrow_file(json_path);
-
-        // Write the binary stream to the output file
+        const std::vector<uint8_t> file_data = integration_tools::json_file_to_arrow_file(json_path);
         std::ofstream output_file(output_path, std::ios::out | std::ios::binary);
         if (!output_file.is_open())
         {
             std::cerr << "Error: Could not open output file: " << output_path << "\n";
             return EXIT_FAILURE;
         }
 
-        output_file.write(reinterpret_cast<const char*>(stream_data.data()), stream_data.size());
+        output_file.write(reinterpret_cast<const char*>(file_data.data()), file_data.size());
         output_file.close();
 
         if (!output_file.good())

integration_tests/arrow_stream_to_file.cpp

@@ -62,20 +62,18 @@ int main(int argc, char* argv[])
             return EXIT_FAILURE;
         }
 
-        // Convert stream to file format using the library
-        const std::vector<uint8_t> output_stream_data = integration_tools::stream_to_file(
+        const std::vector<uint8_t> output_file_data = integration_tools::stream_to_file(
             std::span<const uint8_t>(input_stream_data)
         );
 
-        // Write the stream to the output file
         std::ofstream output_file(output_path, std::ios::out | std::ios::binary);
         if (!output_file.is_open())
         {
             std::cerr << "Error: Could not open output file: " << output_path << "\n";
             return EXIT_FAILURE;
         }
 
-        output_file.write(reinterpret_cast<const char*>(output_stream_data.data()), output_stream_data.size());
+        output_file.write(reinterpret_cast<const char*>(output_file_data.data()), output_file_data.size());
         output_file.close();
 
         if (!output_file.good())

integration_tests/arrow_validate.cpp

@@ -22,7 +22,6 @@
  */
 int main(int argc, char* argv[])
 {
-    // Check command-line arguments
     if (argc != 3)
     {
         std::cerr << "Usage: " << argv[0] << " <json_file_path> <stream_file_path>\n";
@@ -35,7 +34,6 @@ int main(int argc, char* argv[])
 
     try
     {
-        // Check if the stream file exists
         if (!std::filesystem::exists(arrow_file_path))
         {
             std::cerr << "Error: Arrow file not found: " << arrow_file_path << "\n";
@@ -45,7 +43,6 @@ int main(int argc, char* argv[])
         std::cout << "Loading JSON file: " << json_path << "\n";
         std::cout << "Loading Arrow file: " << arrow_file_path << "\n";
 
-        // Read the stream file
         std::ifstream arrow_file(arrow_file_path, std::ios::in | std::ios::binary);
         if (!arrow_file.is_open())
         {