fix: remove trailing whitespace to resolve editorconfig CI failure

- Remove trailing whitespace from common/arg.cpp and test files
- Addresses editorconfig checker failure in CI
- No functional changes, only formatting fixes

Co-Authored-By: Jake Cosme <[email protected]>

Author: devin-ai-integration[bot]

common/arg.cpp

@@ -75,7 +75,7 @@ static void parse_yaml_sampling(const YAML::Node& node, common_params_sampling&
     if (node["timing_per_token"]) sampling.timing_per_token = node["timing_per_token"].as<bool>();
     if (node["grammar"]) sampling.grammar = node["grammar"].as<std::string>();
     if (node["grammar_lazy"]) sampling.grammar_lazy = node["grammar_lazy"].as<bool>();
-    
+
     if (node["dry_sequence_breakers"] && node["dry_sequence_breakers"].IsSequence()) {
         sampling.dry_sequence_breakers.clear();
         for (const auto& breaker : node["dry_sequence_breakers"]) {
@@ -145,7 +145,7 @@ static void parse_yaml_diffusion(const YAML::Node& node, common_params_diffusion
 static bool load_yaml_config(const std::string& config_path, common_params& params) {
     try {
         YAML::Node config = YAML::LoadFile(config_path);
-        
+
         // Parse main parameters
         if (config["n_predict"]) params.n_predict = config["n_predict"].as<int32_t>();
         if (config["n_ctx"]) params.n_ctx = config["n_ctx"].as<int32_t>();
@@ -167,7 +167,7 @@ static bool load_yaml_config(const std::string& config_path, common_params& para
         if (config["yarn_orig_ctx"]) params.yarn_orig_ctx = config["yarn_orig_ctx"].as<int32_t>();
         if (config["n_gpu_layers"]) params.n_gpu_layers = config["n_gpu_layers"].as<int32_t>();
         if (config["main_gpu"]) params.main_gpu = config["main_gpu"].as<int32_t>();
-        
+
         // Parse string parameters
         if (config["model_alias"]) params.model_alias = config["model_alias"].as<std::string>();
         if (config["hf_token"]) params.hf_token = config["hf_token"].as<std::string>();
@@ -180,53 +180,53 @@ static bool load_yaml_config(const std::string& config_path, common_params& para
         if (config["lookup_cache_static"]) params.lookup_cache_static = config["lookup_cache_static"].as<std::string>();
         if (config["lookup_cache_dynamic"]) params.lookup_cache_dynamic = config["lookup_cache_dynamic"].as<std::string>();
         if (config["logits_file"]) params.logits_file = config["logits_file"].as<std::string>();
-        
+
         // Parse boolean parameters
         if (config["lora_init_without_apply"]) params.lora_init_without_apply = config["lora_init_without_apply"].as<bool>();
         if (config["offline"]) params.offline = config["offline"].as<bool>();
-        
+
         // Parse integer parameters
         if (config["verbosity"]) params.verbosity = config["verbosity"].as<int32_t>();
         if (config["control_vector_layer_start"]) params.control_vector_layer_start = config["control_vector_layer_start"].as<int32_t>();
         if (config["control_vector_layer_end"]) params.control_vector_layer_end = config["control_vector_layer_end"].as<int32_t>();
         if (config["ppl_stride"]) params.ppl_stride = config["ppl_stride"].as<int32_t>();
         if (config["ppl_output_type"]) params.ppl_output_type = config["ppl_output_type"].as<int32_t>();
-        
+
         // Parse array parameters
         if (config["in_files"] && config["in_files"].IsSequence()) {
             params.in_files.clear();
             for (const auto& file : config["in_files"]) {
                 params.in_files.push_back(file.as<std::string>());
             }
         }
-        
+
         if (config["antiprompt"] && config["antiprompt"].IsSequence()) {
             params.antiprompt.clear();
             for (const auto& prompt : config["antiprompt"]) {
                 params.antiprompt.push_back(prompt.as<std::string>());
             }
         }
-        
+
         if (config["sampling"]) {
             parse_yaml_sampling(config["sampling"], params.sampling);
         }
-        
+
         if (config["model"]) {
             parse_yaml_model(config["model"], params.model);
         }
-        
+
         if (config["speculative"]) {
             parse_yaml_speculative(config["speculative"], params.speculative);
         }
-        
+
         if (config["vocoder"]) {
             parse_yaml_vocoder(config["vocoder"], params.vocoder);
         }
-        
+
         if (config["diffusion"]) {
             parse_yaml_diffusion(config["diffusion"], params.diffusion);
         }
-        
+
         return true;
     } catch (const YAML::Exception& e) {
         fprintf(stderr, "YAML parsing error: %s\n", e.what());
@@ -1429,7 +1429,7 @@ bool common_params_parse(int argc, char ** argv, common_params & params, llama_e
                 break;
             }
         }
-        
+
         if (!common_params_parse_ex(argc, argv, ctx_arg)) {
             ctx_arg.params = params_org;
             return false;

tests/test-yaml-backward-compat.cpp

@@ -14,7 +14,7 @@ struct TestCase {
 
 static void test_cli_args_without_yaml() {
     std::cout << "Testing CLI arguments without YAML..." << std::endl;
-    
+
     std::vector<TestCase> test_cases = {
         {{"test", "-n", "100"}, "Basic n_predict"},
         {{"test", "-p", "Hello world"}, "Basic prompt"},
@@ -27,33 +27,33 @@ static void test_cli_args_without_yaml() {
         {{"test", "-n", "50", "-p", "Test", "--temp", "0.7"}, "Multiple arguments"},
         {{"test", "--help"}, "Help flag (should exit)"},
     };
-    
+
     for (const auto& test_case : test_cases) {
         if (test_case.description == "Help flag (should exit)") {
             continue;
         }
-        
+
         std::cout << "  Testing: " << test_case.description << std::endl;
-        
+
         common_params params;
         std::vector<char*> argv;
         for (const auto& arg : test_case.args) {
             argv.push_back(const_cast<char*>(arg.c_str()));
         }
-        
+
         bool result = common_params_parse(argv.size(), argv.data(), params, LLAMA_EXAMPLE_COMMON);
-        
+
         if (!result && test_case.description != "Help flag (should exit)") {
             std::cout << "    Warning: " << test_case.description << " failed to parse" << std::endl;
         }
     }
-    
+
     std::cout << "CLI arguments without YAML test completed!" << std::endl;
 }
 
 static void test_equivalent_yaml_and_cli() {
     std::cout << "Testing equivalent YAML and CLI produce same results..." << std::endl;
-    
+
     std::ofstream yaml_file("equivalent_test.yaml");
     yaml_file << R"(
 n_predict: 100
@@ -68,16 +68,16 @@ prompt: "Test prompt"
   penalty_repeat: 1.1
 )";
     yaml_file.close();
-    
+
     common_params yaml_params;
     const char* yaml_argv[] = {"test", "--config", "equivalent_test.yaml"};
     bool yaml_result = common_params_parse(3, const_cast<char**>(yaml_argv), yaml_params, LLAMA_EXAMPLE_COMMON);
-    
+
     common_params cli_params;
     const char* cli_argv[] = {
-        "test", 
+        "test",
         "-n", "100",
-        "--ctx-size", "2048", 
+        "--ctx-size", "2048",
         "-b", "512",
         "-p", "Test prompt",
         "-s", "42",
@@ -87,12 +87,12 @@ prompt: "Test prompt"
         "--repeat-penalty", "1.1"
     };
     bool cli_result = common_params_parse(17, const_cast<char**>(cli_argv), cli_params, LLAMA_EXAMPLE_COMMON);
-    
+
     assert(yaml_result == true);
     assert(cli_result == true);
     (void)yaml_result; // Suppress unused variable warning
     (void)cli_result; // Suppress unused variable warning
-    
+
     assert(yaml_params.n_predict == cli_params.n_predict);
     assert(yaml_params.n_ctx == cli_params.n_ctx);
     assert(yaml_params.n_batch == cli_params.n_batch);
@@ -102,20 +102,20 @@ prompt: "Test prompt"
     assert(yaml_params.sampling.top_k == cli_params.sampling.top_k);
     assert(yaml_params.sampling.top_p == cli_params.sampling.top_p);
     assert(yaml_params.sampling.penalty_repeat == cli_params.sampling.penalty_repeat);
-    
+
     std::filesystem::remove("equivalent_test.yaml");
     std::cout << "Equivalent YAML and CLI test passed!" << std::endl;
 }
 
 static void test_all_major_cli_options() {
     std::cout << "Testing all major CLI options still work..." << std::endl;
-    
+
     struct CliTest {
         std::vector<std::string> args;
         std::string param_name;
         bool should_succeed;
     };
-    
+
     std::vector<CliTest> cli_tests = {
         {{"test", "-m", "model.gguf"}, "model path", true},
         {{"test", "-n", "200"}, "n_predict", true},
@@ -133,35 +133,35 @@ static void test_all_major_cli_options() {
         {{"test", "--color"}, "color output", true},
         {{"test", "--verbose"}, "verbose mode", true},
     };
-    
+
     for (const auto& test : cli_tests) {
         std::cout << "  Testing: " << test.param_name << std::endl;
-        
+
         common_params params;
         std::vector<char*> argv;
         for (const auto& arg : test.args) {
             argv.push_back(const_cast<char*>(arg.c_str()));
         }
-        
+
         bool result = common_params_parse(argv.size(), argv.data(), params, LLAMA_EXAMPLE_COMMON);
-        
+
         if (result != test.should_succeed) {
-            std::cout << "    Unexpected result for " << test.param_name 
+            std::cout << "    Unexpected result for " << test.param_name
                       << ": expected " << test.should_succeed << ", got " << result << std::endl;
         }
     }
-    
+
     std::cout << "Major CLI options test completed!" << std::endl;
 }
 
 int main() {
     std::cout << "Running backward compatibility tests..." << std::endl;
-    
+
     try {
         test_cli_args_without_yaml();
         test_equivalent_yaml_and_cli();
         test_all_major_cli_options();
-        
+
         std::cout << "All backward compatibility tests completed!" << std::endl;
         return 0;
     } catch (const std::exception& e) {