From: =?utf-8?q?Andreas_R=C3=B6nnquist?= <gusnan@debian.org>
Date: Wed, 30 Apr 2025 19:11:36 +0200
Subject: Cast argv.size to int to avoid errors
Forwarded: https://github.com/vietjtnguyen/argagg/pull/45

---
 examples/joinargs.cpp |   2 +-
 test/test.cpp         | 140 +++++++++++++++++++++++++-------------------------
 test/test_csv.cpp     |  18 +++----
 3 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/examples/joinargs.cpp b/examples/joinargs.cpp
index 6897e5f..d92d2bc 100644
--- a/examples/joinargs.cpp
+++ b/examples/joinargs.cpp
@@ -93,7 +93,7 @@ int main(
   // Respect verbosity. Okay, the logging here is a little ludicrous. The point
   // I want to show here is that you can quickly get the number of times an
   // option shows up.
-  int verbose_level = args["verbose"].count();
+  int verbose_level = (int)args["verbose"].count();
 
   // Set up our verbose log output stream selector that selects stderr if the
   // requested log level is lower than or equal to the currently set verbose
diff --git a/test/test.cpp b/test/test.cpp
index 30dcee5..62c7261 100644
--- a/test/test.cpp
+++ b/test/test.cpp
@@ -82,7 +82,7 @@ TEST_CASE("intro example")
       "-b", "--blah"};
     argagg::parser_results args;
     try {
-      args = argparser.parse(argv.size(), &(argv.front()));
+      args = argparser.parse((int)argv.size(), &(argv.front()));
     } catch (const std::exception& e) {
       std::cerr << e.what() << '\n';
     }
@@ -122,7 +122,7 @@ TEST_CASE("intro example")
       "-b", "--blah"};
     argagg::parser_results args;
     try {
-      args = argparser.parse(argv.size(), &(argv.front()));
+      args = argparser.parse((int)argv.size(), &(argv.front()));
     } catch (const std::exception& e) {
       std::cerr << e.what() << '\n';
     }
@@ -155,14 +155,14 @@ TEST_CASE("intro example")
     std::vector<const char*> argv {"test", "-d"};
     argagg::parser_results args;
     CHECK_THROWS_AS({
-      args = argparser.parse(argv.size(), &(argv.front()));
+      args = argparser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::option_lacks_argument_error&);
   }
   SUBCASE("no arguments") {
     std::vector<const char*> argv {"test"};
     argagg::parser_results args;
     try {
-      args = argparser.parse(argv.size(), &(argv.front()));
+      args = argparser.parse((int)argv.size(), &(argv.front()));
     } catch (const std::exception& e) {
       std::cerr << e.what() << '\n';
     }
@@ -186,7 +186,7 @@ TEST_CASE("no definitions")
   SUBCASE("no arguments") {
     std::vector<const char*> argv {
       "test"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("output") == false);
@@ -195,7 +195,7 @@ TEST_CASE("no definitions")
   SUBCASE("with arguments") {
     std::vector<const char*> argv {
       "test", "foo", "bar", "baz"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("output") == false);
@@ -208,13 +208,13 @@ TEST_CASE("no definitions")
     std::vector<const char*> argv {
       "test", "--verbose", "-o", "baz"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::unexpected_option_error&);
   }
   SUBCASE("invalid parser_results indexing") {
     std::vector<const char*> argv {
       "test"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK_THROWS_AS({
       args["help"];
     }, const argagg::unknown_option&);
@@ -237,7 +237,7 @@ TEST_CASE("invalid definitions")
         {"bad", {}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("too short") {
@@ -245,7 +245,7 @@ TEST_CASE("invalid definitions")
         {"bad", {"-"}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("too short 2") {
@@ -253,7 +253,7 @@ TEST_CASE("invalid definitions")
         {"bad", {"a"}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("no hyphen") {
@@ -261,7 +261,7 @@ TEST_CASE("invalid definitions")
         {"bad", {"bad"}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("short flag group") {
@@ -269,7 +269,7 @@ TEST_CASE("invalid definitions")
         {"bad", {"-bad"}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("invalid character") {
@@ -277,7 +277,7 @@ TEST_CASE("invalid definitions")
         {"bad", {"-b ad"}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("too many hyphens") {
@@ -285,7 +285,7 @@ TEST_CASE("invalid definitions")
         {"bad", {"---bad"}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("long flag equal assignment") {
@@ -293,7 +293,7 @@ TEST_CASE("invalid definitions")
         {"bad", {"--bad=still-bad"}, "bad", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("duplicate short flags") {
@@ -302,7 +302,7 @@ TEST_CASE("invalid definitions")
         {"bad2", {"-b"}, "bad2", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
   SUBCASE("duplicate long flags") {
@@ -311,7 +311,7 @@ TEST_CASE("invalid definitions")
         {"bad2", {"--bad"}, "bad2", 0},
       }};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::invalid_flag&);
   }
 }
@@ -326,7 +326,7 @@ TEST_CASE("simple")
   SUBCASE("no arguments") {
     std::vector<const char*> argv {
       "test"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("output") == false);
@@ -335,7 +335,7 @@ TEST_CASE("simple")
   SUBCASE("no flags") {
     std::vector<const char*> argv {
       "test", "foo", "bar", "baz"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == false);
     CHECK_THROWS_AS({
@@ -351,7 +351,7 @@ TEST_CASE("simple")
   SUBCASE("only flags") {
     std::vector<const char*> argv {
       "test", "--verbose", "--output", "foo", "-v", "-o", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == true);
     CHECK(args["verbose"].count() == 2);
@@ -372,7 +372,7 @@ TEST_CASE("simple")
   SUBCASE("simple mixed") {
     std::vector<const char*> argv {
       "test", "-v", "--output", "foo", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == true);
     CHECK(args["verbose"].count() == 1);
@@ -386,7 +386,7 @@ TEST_CASE("simple")
   SUBCASE("trailing flags") {
     std::vector<const char*> argv {
       "test", "foo", "bar", "-v", "--output", "baz"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == true);
     CHECK(args["verbose"].count() == 1);
@@ -401,7 +401,7 @@ TEST_CASE("simple")
   SUBCASE("interleaved positional arguments") {
     std::vector<const char*> argv {
       "test", "foo", "-v", "bar", "--verbose", "baz", "--output", "dog", "cat"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == true);
     CHECK(args["verbose"].count() == 2);
@@ -419,14 +419,14 @@ TEST_CASE("simple")
     std::vector<const char*> argv {
       "test", "--output", "foo", "-h", "bar", "-v"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::unexpected_option_error&);
   }
   SUBCASE("unused long flag") {
     std::vector<const char*> argv {
       "test", "--output", "foo", "--help", "bar", "-v"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::unexpected_option_error&);
   }
 }
@@ -442,7 +442,7 @@ TEST_CASE("long flag equal format for arguments")
   SUBCASE("basic") {
     std::vector<const char*> argv {
       "test", "-v", "--output=foo", "--delim=bar", "baz"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("output") == true);
     CHECK(args["output"].as<std::string>() == "foo");
@@ -454,7 +454,7 @@ TEST_CASE("long flag equal format for arguments")
   SUBCASE("empty") {
     std::vector<const char*> argv {
       "test", "-v", "--output=", "--delim=", "baz"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("output") == true);
     CHECK(args["output"].as<std::string>() == "");
@@ -466,7 +466,7 @@ TEST_CASE("long flag equal format for arguments")
   SUBCASE("symbols") {
     std::vector<const char*> argv {
       "test", "-v", "--output=--foo!!", "--delim=,", "baz"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("output") == true);
     CHECK(args["output"].as<std::string>() == "--foo!!");
@@ -479,7 +479,7 @@ TEST_CASE("long flag equal format for arguments")
     std::vector<const char*> argv {
       "test", "--verbose=bad"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::unexpected_argument_error&);
   }
 }
@@ -496,7 +496,7 @@ TEST_CASE("short flag groups")
   SUBCASE("basic") {
     std::vector<const char*> argv {
       "test", "-vhf", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("help") == true);
     CHECK(args.has_option("foo") == true);
@@ -507,7 +507,7 @@ TEST_CASE("short flag groups")
   SUBCASE("basic 2") {
     std::vector<const char*> argv {
       "test", "-fvh", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("help") == true);
     CHECK(args.has_option("foo") == true);
@@ -518,7 +518,7 @@ TEST_CASE("short flag groups")
   SUBCASE("basic 3") {
     std::vector<const char*> argv {
       "test", "-fh", "-v", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("help") == true);
     CHECK(args.has_option("foo") == true);
@@ -530,20 +530,20 @@ TEST_CASE("short flag groups")
     std::vector<const char*> argv {
       "test", "--vfh", "bar"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::unexpected_option_error&);
   }
   SUBCASE("unexpected symbol") {
     std::vector<const char*> argv {
       "test", "-v-fh", "bar"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const std::domain_error&);
   }
   SUBCASE("trailing flag with argument") {
     std::vector<const char*> argv {
       "test", "-vhfo", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("help") == true);
     CHECK(args.has_option("foo") == true);
@@ -554,7 +554,7 @@ TEST_CASE("short flag groups")
   SUBCASE("leading flag with argument") {
     std::vector<const char*> argv {
       "test", "-ohfv", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("foo") == false);
@@ -566,7 +566,7 @@ TEST_CASE("short flag groups")
   SUBCASE("middling flag with argument") {
     std::vector<const char*> argv {
       "test", "-vfoh", "bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == true);
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("foo") == true);
@@ -588,7 +588,7 @@ TEST_CASE("flag stop")
     std::vector<const char*> argv {
       "test", "-v", "--", "bar", "--verbose", "baz",
       "--delim", "dog", "-d", "cat"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == true);
     CHECK(args["verbose"].count() == 1);
@@ -606,7 +606,7 @@ TEST_CASE("flag stop")
   SUBCASE("flag stop consumed as argument for option") {
     std::vector<const char*> argv {
       "test", "-d", "--", "--", "-", "boo"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("help") == false);
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("delim") == true);
@@ -627,7 +627,7 @@ TEST_CASE("option requires argument")
   SUBCASE("arguments provided") {
     std::vector<const char*> argv {
       "test", "-n", "1", "2", "-n", "4"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("number") == true);
     CHECK(args["number"].count() == 2);
@@ -639,7 +639,7 @@ TEST_CASE("option requires argument")
   SUBCASE("negative numbers") {
     std::vector<const char*> argv {
       "test", "-n", "-1", "-n", "-4444", "--", "-22"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("number") == true);
     CHECK(args["number"].count() == 2);
@@ -652,7 +652,7 @@ TEST_CASE("option requires argument")
   {
     std::vector<const char*> argv {
       "test", "-n", "-v"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("number") == true);
     CHECK(args["number"].count() == 1);
     CHECK(args["number"][0].as<std::string>() == "-v");
@@ -662,14 +662,14 @@ TEST_CASE("option requires argument")
     std::vector<const char*> argv {
       "test", "-n", "1", "2", "-c"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::unexpected_option_error&);
   }
   SUBCASE("given zero, end of args") {
     std::vector<const char*> argv {
       "test", "-n"};
     CHECK_THROWS_AS({
-      argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+      argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     }, const argagg::option_lacks_argument_error&);
   }
 }
@@ -686,7 +686,7 @@ TEST_CASE("greedy processing")
   SUBCASE("short group example 1") {
     std::vector<const char*> argv {
       "test", "-abco", "foo"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("a") == true);
     CHECK(args.has_option("b") == true);
     CHECK(args.has_option("c") == true);
@@ -697,7 +697,7 @@ TEST_CASE("greedy processing")
   SUBCASE("short group example 2") {
     std::vector<const char*> argv {
       "test", "-aboc", "foo"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("a") == true);
     CHECK(args.has_option("b") == true);
     CHECK(args.has_option("c") == false);
@@ -709,7 +709,7 @@ TEST_CASE("greedy processing")
   SUBCASE("short group example 3") {
     std::vector<const char*> argv {
       "test", "-aobc", "foo"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("a") == true);
     CHECK(args.has_option("b") == false);
     CHECK(args.has_option("c") == false);
@@ -721,7 +721,7 @@ TEST_CASE("greedy processing")
   SUBCASE("short group example 4") {
     std::vector<const char*> argv {
       "test", "-oabc", "foo"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("a") == false);
     CHECK(args.has_option("b") == false);
     CHECK(args.has_option("c") == false);
@@ -733,7 +733,7 @@ TEST_CASE("greedy processing")
   SUBCASE("long example 1") {
     std::vector<const char*> argv {
       "test", "--output=foo", "--", "--bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("a") == false);
     CHECK(args.has_option("b") == false);
     CHECK(args.has_option("c") == false);
@@ -745,7 +745,7 @@ TEST_CASE("greedy processing")
   SUBCASE("long example 2") {
     std::vector<const char*> argv {
       "test", "--output", "--", "--bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("a") == false);
     CHECK(args.has_option("b") == true);
     CHECK(args.has_option("c") == false);
@@ -756,7 +756,7 @@ TEST_CASE("greedy processing")
   SUBCASE("long example 3") {
     std::vector<const char*> argv {
       "test", "--output", "--bar"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("a") == false);
     CHECK(args.has_option("b") == false);
     CHECK(args.has_option("c") == false);
@@ -780,7 +780,7 @@ TEST_CASE("gcc example")
   SUBCASE("version") {
     std::vector<const char*> argv {
       "gcc", "--version"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("version") == true);
     CHECK(args.has_option("include path") == false);
@@ -792,7 +792,7 @@ TEST_CASE("gcc example")
   SUBCASE("simple") {
     std::vector<const char*> argv {
       "gcc", "test.c"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("version") == false);
     CHECK(args.has_option("include path") == false);
@@ -805,7 +805,7 @@ TEST_CASE("gcc example")
   SUBCASE("simple 2") {
     std::vector<const char*> argv {
       "gcc", "-I/usr/local/include", "test.c", "-otest"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("version") == false);
     CHECK(args.has_option("include path") == true);
@@ -823,7 +823,7 @@ TEST_CASE("gcc example")
     std::vector<const char*> argv {
       "gcc", "-I/usr/local/include", "-I.", "-L/usr/local/lib", "-lz", "-lm",
       "test.c", "-otest"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("verbose") == false);
     CHECK(args.has_option("version") == false);
     CHECK(args.has_option("include path") == true);
@@ -854,7 +854,7 @@ TEST_CASE("argument conversions")
   SUBCASE("positional integer") {
     std::vector<const char*> argv {
       "test", "1", "2"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.pos.size() == 2);
     CHECK(args.as<char>() == 1);
     CHECK(args.as<unsigned char>() == 1);
@@ -893,7 +893,7 @@ TEST_CASE("argument conversions")
   SUBCASE("positional floating point") {
     std::vector<const char*> argv {
       "test", "3.141592653", "2.71828182846"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.pos.size() == 2);
     CHECK(args.as<float>() == doctest::Approx(3.141592653f));
     CHECK(args.as<double>() == doctest::Approx(3.141592653));
@@ -905,7 +905,7 @@ TEST_CASE("argument conversions")
   SUBCASE("positional vector") {
     std::vector<const char*> argv {
       "test", "0", "1", "2"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.pos.size() == 3);
     auto v = args.all_as<int>();
     CHECK(v[0] == 0);
@@ -915,7 +915,7 @@ TEST_CASE("argument conversions")
   SUBCASE("option integer") {
     std::vector<const char*> argv {
       "test", "-n", "1"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("number") == true);
     CHECK(args["number"].count() == 1);
     CHECK(args["number"].as<char>() == 1);
@@ -938,7 +938,7 @@ TEST_CASE("argument conversions")
   SUBCASE("option floating point") {
     std::vector<const char*> argv {
       "test", "-n", "3.141592653"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("number") == true);
     CHECK(args["number"].count() == 1);
     CHECK(args["number"].as<float>() == doctest::Approx(3.141592653f));
@@ -948,7 +948,7 @@ TEST_CASE("argument conversions")
   SUBCASE("option implicit conversions") {
     std::vector<const char*> argv {
       "test", "-n", "3.141592653", "-n", "2"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("number") == true);
     if (args["number"]) {
     } else {
@@ -967,7 +967,7 @@ TEST_CASE("argument conversions")
   SUBCASE("exception on bad conversion") {
     std::vector<const char*> argv {
       "test", "-n", "not-an-number"};
-    argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+    argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("number") == true);
     CHECK(args["number"].count() == 1);
     CHECK_THROWS_AS({
@@ -1015,7 +1015,7 @@ TEST_CASE("custom conversion function")
     }};
   std::vector<const char*> argv {
     "test", "-w", "hello,world,foo,bar,baz"};
-  argagg::parser_results args = parser.parse(argv.size(), &(argv.front()));
+  argagg::parser_results args = parser.parse((int)argv.size(), &(argv.front()));
   CHECK(args.has_option("words") == true);
   auto v = args["words"].as<std::vector<std::string>>();
   CHECK(v.size() == 5);
@@ -1067,7 +1067,7 @@ TEST_CASE("parse_next_component() example")
     std::vector<const char*> argv {
       "test", "-o", "1.2,3.45,6.789"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("origin") == true);
     auto origin = args["origin"].as<position3>();
     CHECK(origin.x == 1.2);
@@ -1078,7 +1078,7 @@ TEST_CASE("parse_next_component() example")
     std::vector<const char*> argv {
       "test", "-o", "1.2,3.45"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("origin") == true);
     auto origin = args["origin"].as<position3>();
     CHECK(origin.x == 1.2);
@@ -1089,7 +1089,7 @@ TEST_CASE("parse_next_component() example")
     std::vector<const char*> argv {
       "test", "-o", "1.23456789"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("origin") == true);
     auto origin = args["origin"].as<position3>();
     CHECK(origin.x == 1.23456789);
@@ -1139,7 +1139,7 @@ TEST_CASE("parse_next_component() example with non-default delimiter")
     std::vector<const char*> argv {
       "test", "--velocity", "1.2+3.45+6.789"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("velocity") == true);
     auto velocity = args["velocity"].as<velocity3>();
     CHECK(velocity.x == 1.2);
@@ -1150,7 +1150,7 @@ TEST_CASE("parse_next_component() example with non-default delimiter")
     std::vector<const char*> argv {
       "test", "--velocity", "1.2+3.45"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("velocity") == true);
     auto velocity = args["velocity"].as<velocity3>();
     CHECK(velocity.x == 1.2);
@@ -1161,7 +1161,7 @@ TEST_CASE("parse_next_component() example with non-default delimiter")
     std::vector<const char*> argv {
       "test", "--velocity", "1.23456789"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("velocity") == true);
     auto velocity = args["velocity"].as<velocity3>();
     CHECK(velocity.x == 1.23456789);
diff --git a/test/test_csv.cpp b/test/test_csv.cpp
index 3124da4..b380190 100644
--- a/test/test_csv.cpp
+++ b/test/test_csv.cpp
@@ -44,7 +44,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", ""};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     auto items = args["items"].as<argagg::csv<std::string>>();
     CHECK(items.values.size() == 1);
@@ -54,7 +54,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "alice"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     auto items = args["items"].as<argagg::csv<std::string>>();
     CHECK(items.values.size() == 1);
@@ -64,7 +64,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "alice,bob"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     auto items = args["items"].as<argagg::csv<std::string>>();
     CHECK(items.values.size() == 2);
@@ -75,7 +75,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "alice,,,bob"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     auto items = args["items"].as<argagg::csv<std::string>>();
     CHECK(items.values.size() == 4);
@@ -88,7 +88,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "1,2,3"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     auto items = args["items"].as<argagg::csv<int>>();
     CHECK(items.values.size() == 3);
@@ -100,7 +100,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "1,bob,3"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     CHECK_THROWS({
       args["items"].as<argagg::csv<int>>();
@@ -110,7 +110,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "1.2,3.45,6.789"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     auto items = args["items"].as<argagg::csv<double>>();
     CHECK(items.values.size() == 3);
@@ -122,7 +122,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "alice,3.45,6.789"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     CHECK_THROWS({
       args["items"].as<argagg::csv<double>>();
@@ -131,7 +131,7 @@ TEST_CASE("comma separated values")
     std::vector<const char*> argv {
       "test", "--items", "1.2+2.4+3.141,4.0+5.32,6.5341"};
     argagg::parser_results args =
-      argparser.parse(argv.size(), &(argv.front()));
+      argparser.parse((int)argv.size(), &(argv.front()));
     CHECK(args.has_option("items") == true);
     auto items = args["items"].as<argagg::csv<plus_triple>>();
     CHECK(items.values.size() == 3);