X-Git-Url: http://git.efficios.com/?p=argpar.git;a=blobdiff_plain;f=tests%2Ftest_argpar.c;h=b04b412db3f12258370c6e4fe64414ddd4d67e50;hp=4674d8984fc706cecab75cc5b3d032e25f4531ed;hb=11003cd5369dbb2422796b6ee2d8433895e4b05d;hpb=7ac57709d4964e2c59c9b0592632c374056caa00

diff --git a/tests/test_argpar.c b/tests/test_argpar.c
index 4674d89..b04b412 100644
--- a/tests/test_argpar.c
+++ b/tests/test_argpar.c
@@ -1,5 +1,6 @@
 /*
- * Copyright (c) 2019 Philippe Proulx <pproulx@efficios.com>
+ * Copyright (c) 2019-2021 Philippe Proulx <pproulx@efficios.com>
+ * Copyright (c) 2020-2021 Simon Marchi <simon.marchi@efficios.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -18,121 +19,252 @@
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <glib.h>
 
 #include "tap/tap.h"
 #include "argpar/argpar.h"
 
 /*
- * Tests that the command line `cmdline`, with non-quoted
- * space-delimited arguments, once parsed given the option descriptors
- * `descrs` and the option `fail_on_unknown_opt`, succeeds and gives the
- * expected command line `expected_cmd_line` and number of ingested
- * original arguments `expected_ingested_orig_args`.
+ * Formats `item` and appends the resulting string to `res_str` to
+ * incrementally build an expected command line string.
  *
- * The resulting command-line is built from the resulting arguments,
- * space-delimiting each argument, preferring the `--long-opt=arg` style
- * over the `-s arg` style, and using the `arg<A,B>` form for non-option
- * arguments where `A` is the original argument index and `B` is the
- * non-option argument index.
+ * This function:
+ *
+ * * Prefers the `--long-opt=arg` style over the `-s arg` style.
+ *
+ * * Uses the `arg<A,B>` form for non-option arguments, where `A` is the
+ *   original argument index and `B` is the non-option argument index.
+ */
+static
+void append_to_res_str(GString * const res_str,
+		const struct argpar_item * const item)
+{
+	if (res_str->len > 0) {
+		g_string_append_c(res_str, ' ');
+	}
+
+	switch (item->type) {
+	case ARGPAR_ITEM_TYPE_OPT:
+	{
+		const struct argpar_item_opt *const item_opt =
+			(const void *) item;
+
+		if (item_opt->descr->long_name) {
+			g_string_append_printf(res_str, "--%s",
+				item_opt->descr->long_name);
+
+			if (item_opt->arg) {
+				g_string_append_printf(res_str, "=%s",
+					item_opt->arg);
+			}
+		} else if (item_opt->descr->short_name) {
+			g_string_append_printf(res_str, "-%c",
+				item_opt->descr->short_name);
+
+			if (item_opt->arg) {
+				g_string_append_printf(res_str, " %s",
+					item_opt->arg);
+			}
+		}
+
+		break;
+	}
+	case ARGPAR_ITEM_TYPE_NON_OPT:
+	{
+		const struct argpar_item_non_opt * const item_non_opt =
+			(const void *) item;
+
+		g_string_append_printf(res_str, "%s<%u,%u>",
+			item_non_opt->arg, item_non_opt->orig_index,
+			item_non_opt->non_opt_index);
+		break;
+	}
+	default:
+		abort();
+	}
+}
+
+/*
+ * Parses `cmdline` with argpar_parse() using the option descriptors
+ * `descrs`, and ensures that the resulting effective command line is
+ * `expected_cmd_line` and that the number of ingested original
+ * arguments is `expected_ingested_orig_args`.
+ *
+ * This function splits `cmdline` on spaces to create an original
+ * argument array.
+ *
+ * This function builds the resulting command line from parsing items
+ * by space-separating each formatted item (see append_to_res_str()).
  */
 static
-void test_succeed(const char *cmdline,
-		const char *expected_cmd_line,
-		const struct bt_argpar_opt_descr *descrs,
-		unsigned int expected_ingested_orig_args)
+void test_succeed_argpar_parse(const char * const cmdline,
+		const char * const expected_cmd_line,
+		const struct argpar_opt_descr * const descrs,
+		const unsigned int expected_ingested_orig_args)
 {
-	struct bt_argpar_parse_ret parse_ret;
-	GString *res_str = g_string_new(NULL);
-	gchar **argv = g_strsplit(cmdline, " ", 0);
+	struct argpar_parse_ret parse_ret;
+	GString * const res_str = g_string_new(NULL);
+	gchar ** const argv = g_strsplit(cmdline, " ", 0);
 	unsigned int i;
 
 	assert(argv);
 	assert(res_str);
-	parse_ret = bt_argpar_parse(g_strv_length(argv),
+	parse_ret = argpar_parse(g_strv_length(argv),
 		(const char * const *) argv, descrs, false);
 	ok(parse_ret.items,
-		"bt_argpar_parse() succeeds for command line `%s`", cmdline);
+		"argpar_parse() succeeds for command line `%s`", cmdline);
 	ok(!parse_ret.error,
-		"bt_argpar_parse() does not write an error for command line `%s`", cmdline);
+		"argpar_parse() doesn't set an error for command line `%s`",
+		cmdline);
 	ok(parse_ret.ingested_orig_args == expected_ingested_orig_args,
-		"bt_argpar_parse() returns the correct number of ingested "
+		"argpar_parse() returns the correct number of ingested "
 		"original arguments for command line `%s`", cmdline);
+
 	if (parse_ret.ingested_orig_args != expected_ingested_orig_args) {
 		diag("Expected: %u    Got: %u", expected_ingested_orig_args,
 			parse_ret.ingested_orig_args);
 	}
 
 	if (!parse_ret.items) {
-		fail("bt_argpar_parse() returns the expected parsed arguments "
+		fail("argpar_parse() returns the expected parsing items "
 			"for command line `%s`", cmdline);
 		goto end;
 	}
 
 	for (i = 0; i < parse_ret.items->n_items; i++) {
-		const struct bt_argpar_item *arg = parse_ret.items->items[i];
-
-		switch (arg->type) {
-		case BT_ARGPAR_ITEM_TYPE_OPT:
-		{
-			const struct bt_argpar_item_opt *arg_opt =
-				(const void *) arg;
-
-			if (arg_opt->descr->long_name) {
-				g_string_append_printf(res_str, "--%s",
-					arg_opt->descr->long_name);
-
-				if (arg_opt->arg) {
-					g_string_append_printf(res_str, "=%s",
-						arg_opt->arg);
-				}
-
-				g_string_append_c(res_str, ' ');
-			} else if (arg_opt->descr->short_name) {
-				g_string_append_printf(res_str, "-%c",
-					arg_opt->descr->short_name);
-
-				if (arg_opt->arg) {
-					g_string_append_printf(res_str, " %s",
-						arg_opt->arg);
-				}
-
-				g_string_append_c(res_str, ' ');
-			}
+		append_to_res_str(res_str, parse_ret.items->items[i]);
+	}
 
-			break;
+	ok(strcmp(expected_cmd_line, res_str->str) == 0,
+		"argpar_parse() returns the expected parsed arguments "
+		"for command line `%s`", cmdline);
+
+	if (strcmp(expected_cmd_line, res_str->str) != 0) {
+		diag("Expected: `%s`", expected_cmd_line);
+		diag("Got:      `%s`", res_str->str);
+	}
+
+end:
+	argpar_parse_ret_fini(&parse_ret);
+	g_string_free(res_str, TRUE);
+	g_strfreev(argv);
+}
+
+/*
+ * Parses `cmdline` with the iterator API using the option descriptors
+ * `descrs`, and ensures that the resulting effective command line is
+ * `expected_cmd_line` and that the number of ingested original
+ * arguments is `expected_ingested_orig_args`.
+ *
+ * This function splits `cmdline` on spaces to create an original
+ * argument array.
+ *
+ * This function builds the resulting command line from parsing items
+ * by space-separating each formatted item (see append_to_res_str()).
+ */
+static
+void test_succeed_argpar_iter(const char * const cmdline,
+		const char * const expected_cmd_line,
+		const struct argpar_opt_descr * const descrs,
+		const unsigned int expected_ingested_orig_args)
+{
+	struct argpar_iter *iter = NULL;
+	const struct argpar_item *item = NULL;
+	char *error = NULL;
+	GString * const res_str = g_string_new(NULL);
+	gchar ** const argv = g_strsplit(cmdline, " ", 0);
+	unsigned int i, actual_ingested_orig_args;
+
+	assert(argv);
+	assert(res_str);
+	iter = argpar_iter_create(g_strv_length(argv),
+		(const char * const *) argv, descrs);
+	assert(iter);
+
+	for (i = 0; ; i++) {
+		enum argpar_iter_parse_next_status status;
+
+		ARGPAR_ITEM_DESTROY_AND_RESET(item);
+		status = argpar_iter_parse_next(iter, &item, &error);
+
+		ok(status == ARGPAR_ITER_PARSE_NEXT_STATUS_OK ||
+			status == ARGPAR_ITER_PARSE_NEXT_STATUS_END ||
+			status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT,
+			"argpar_iter_parse_next() returns the expected status "
+			"(%d) for command line `%s` (call %u)",
+			status, cmdline, i + 1);
+
+		if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
+			ok(error,
+				"argpar_iter_parse_next() sets an error for "
+				"status `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT` "
+				"and command line `%s` (call %u)",
+				cmdline, i + 1);
+		} else {
+			ok(!error,
+				"argpar_iter_parse_next() doesn't set an error "
+				"for other status than "
+				"`ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT` "
+				"and command line `%s` (call %u)",
+				cmdline, i + 1);
 		}
-		case BT_ARGPAR_ITEM_TYPE_NON_OPT:
-		{
-			const struct bt_argpar_item_non_opt *arg_non_opt =
-				(const void *) arg;
-
-			g_string_append_printf(res_str, "%s<%u,%u> ",
-				arg_non_opt->arg, arg_non_opt->orig_index,
-				arg_non_opt->non_opt_index);
+
+		if (status == ARGPAR_ITER_PARSE_NEXT_STATUS_END ||
+				status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT) {
+			ok(!item,
+				"argpar_iter_parse_next() doesn't set an item "
+				"for status `ARGPAR_ITER_PARSE_NEXT_STATUS_END` "
+				"or `ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT` "
+				"and command line `%s` (call %u)",
+				cmdline, i + 1);
 			break;
 		}
-		default:
-			abort();
-		}
+
+		append_to_res_str(res_str, item);
 	}
 
-	if (res_str->len > 0) {
-		g_string_truncate(res_str, res_str->len - 1);
+	actual_ingested_orig_args = argpar_iter_get_ingested_orig_args(iter);
+	ok(actual_ingested_orig_args == expected_ingested_orig_args,
+		"argpar_iter_get_ingested_orig_args() returns the expected "
+		"number of ingested original arguments for command line `%s`",
+		cmdline);
+
+	if (actual_ingested_orig_args != expected_ingested_orig_args) {
+		diag("Expected: %u    Got: %u", expected_ingested_orig_args,
+			actual_ingested_orig_args);
 	}
 
 	ok(strcmp(expected_cmd_line, res_str->str) == 0,
-		"bt_argpar_parse() returns the expected parsed arguments "
+		"argpar_iter_parse_next() returns the expected parsing items "
 		"for command line `%s`", cmdline);
+
 	if (strcmp(expected_cmd_line, res_str->str) != 0) {
 		diag("Expected: `%s`", expected_cmd_line);
 		diag("Got:      `%s`", res_str->str);
 	}
 
-end:
-	bt_argpar_parse_ret_fini(&parse_ret);
+	argpar_item_destroy(item);
+	argpar_iter_destroy(iter);
 	g_string_free(res_str, TRUE);
 	g_strfreev(argv);
+	free(error);
+}
+
+/*
+ * Calls test_succeed_argpar_parse() and test_succeed_argpar_iter()
+ * with the provided parameters.
+ */
+static
+void test_succeed(const char * const cmdline,
+		const char * const expected_cmd_line,
+		const struct argpar_opt_descr * const descrs,
+		const unsigned int expected_ingested_orig_args)
+{
+	test_succeed_argpar_parse(cmdline, expected_cmd_line, descrs,
+		expected_ingested_orig_args);
+	test_succeed_argpar_iter(cmdline, expected_cmd_line, descrs,
+		expected_ingested_orig_args);
 }
 
 static
@@ -140,8 +272,8 @@ void succeed_tests(void)
 {
 	/* No arguments */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+		const struct argpar_opt_descr descrs[] = {
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -152,9 +284,9 @@ void succeed_tests(void)
 
 	/* Single long option */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "salut", false },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -165,9 +297,9 @@ void succeed_tests(void)
 
 	/* Single short option */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'f', NULL, false },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -178,9 +310,9 @@ void succeed_tests(void)
 
 	/* Short and long option (aliases) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'f', "flaw", false },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -191,9 +323,9 @@ void succeed_tests(void)
 
 	/* Long option with argument (space form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "tooth", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -204,9 +336,9 @@ void succeed_tests(void)
 
 	/* Long option with argument (equal form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "polish", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -217,9 +349,9 @@ void succeed_tests(void)
 
 	/* Short option with argument (space form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'c', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -230,9 +362,9 @@ void succeed_tests(void)
 
 	/* Short option with argument (glued form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'c', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -243,9 +375,9 @@ void succeed_tests(void)
 
 	/* Short and long option (aliases) with argument (all forms) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'd', "dry", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -256,11 +388,11 @@ void succeed_tests(void)
 
 	/* Many short options, last one with argument (glued form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'd', NULL, false },
 			{ 0, 'e', NULL, false },
 			{ 0, 'f', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -271,11 +403,11 @@ void succeed_tests(void)
 
 	/* Many options */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'd', NULL, false },
 			{ 0, 'e', "east", true },
 			{ 0, '\0', "mind", false },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -286,8 +418,8 @@ void succeed_tests(void)
 
 	/* Single non-option argument */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+		const struct argpar_opt_descr descrs[] = {
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -298,8 +430,8 @@ void succeed_tests(void)
 
 	/* Two non-option arguments */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+		const struct argpar_opt_descr descrs[] = {
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -310,10 +442,10 @@ void succeed_tests(void)
 
 	/* Single non-option argument mixed with options */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'd', NULL, false },
 			{ 0, '\0', "squeeze", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -324,9 +456,9 @@ void succeed_tests(void)
 
 	/* Unknown short option (space form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'd', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -337,9 +469,9 @@ void succeed_tests(void)
 
 	/* Unknown short option (glued form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'd', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -350,9 +482,9 @@ void succeed_tests(void)
 
 	/* Unknown long option (space form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "sink", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -363,9 +495,9 @@ void succeed_tests(void)
 
 	/* Unknown long option (equal form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "sink", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -376,9 +508,9 @@ void succeed_tests(void)
 
 	/* Unknown option before non-option argument */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "thumb", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -389,9 +521,9 @@ void succeed_tests(void)
 
 	/* Unknown option after non-option argument */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "thumb", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -402,9 +534,9 @@ void succeed_tests(void)
 
 	/* Valid `---opt` */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "-fuel", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -415,9 +547,9 @@ void succeed_tests(void)
 
 	/* Long option containing `=` in argument (equal form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "zebra", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -428,9 +560,9 @@ void succeed_tests(void)
 
 	/* Short option's argument starting with `-` (glued form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'z', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -441,9 +573,9 @@ void succeed_tests(void)
 
 	/* Short option's argument starting with `-` (space form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'z', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -454,9 +586,9 @@ void succeed_tests(void)
 
 	/* Long option's argument starting with `-` (space form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "janine", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -467,9 +599,9 @@ void succeed_tests(void)
 
 	/* Long option's argument starting with `-` (equal form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "janine", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -480,10 +612,10 @@ void succeed_tests(void)
 
 	/* Long option's empty argument (equal form) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'f', NULL, false },
 			{ 0, '\0', "yeah", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_succeed(
@@ -494,50 +626,147 @@ void succeed_tests(void)
 }
 
 /*
- * Tests that the command line `cmdline`, with non-quoted
- * space-delimited arguments, once parsed given the option descriptors
- * `descrs`, fails and gives the expected error `expected_error`.
+ * Parses `cmdline` with argpar_parse() using the option descriptors
+ * `descrs`, and ensures that the function fails and that it sets an
+ * error which is equal to `expected_error`.
+ *
+ * This function splits `cmdline` on spaces to create an original
+ * argument array.
  */
 static
-void test_fail(const char *cmdline, const char *expected_error,
-		const struct bt_argpar_opt_descr *descrs)
+void test_fail_argpar_parse(const char * const cmdline,
+		const char * const expected_error,
+		const struct argpar_opt_descr * const descrs)
 {
-	struct bt_argpar_parse_ret parse_ret;
-	gchar **argv = g_strsplit(cmdline, " ", 0);
+	struct argpar_parse_ret parse_ret;
+	gchar ** const argv = g_strsplit(cmdline, " ", 0);
 
-	parse_ret = bt_argpar_parse(g_strv_length(argv),
+	parse_ret = argpar_parse(g_strv_length(argv),
 		(const char * const *) argv, descrs, true);
 	ok(!parse_ret.items,
-		"bt_argpar_parse() fails for command line `%s`", cmdline);
+		"argpar_parse() fails for command line `%s`", cmdline);
 	ok(parse_ret.error,
-		"bt_argpar_parse() writes an error string for command line `%s`",
+		"argpar_parse() sets an error string for command line `%s`",
 		cmdline);
+
 	if (parse_ret.items) {
-		fail("bt_argpar_parse() writes the expected error string");
+		fail("argpar_parse() sets the expected error string");
 		goto end;
 	}
 
 	ok(strcmp(expected_error, parse_ret.error) == 0,
-		"bt_argpar_parse() writes the expected error string "
+		"argpar_parse() sets the expected error string "
 		"for command line `%s`", cmdline);
+
 	if (strcmp(expected_error, parse_ret.error) != 0) {
 		diag("Expected: `%s`", expected_error);
 		diag("Got:      `%s`", parse_ret.error);
 	}
 
 end:
-	bt_argpar_parse_ret_fini(&parse_ret);
+	argpar_parse_ret_fini(&parse_ret);
 	g_strfreev(argv);
 }
 
+/*
+ * Parses `cmdline` with the iterator API using the option descriptors
+ * `descrs`, and ensures that argpar_iter_parse_next() fails and that it
+ * sets an error which is equal to `expected_error`.
+ *
+ * This function splits `cmdline` on spaces to create an original
+ * argument array.
+ */
+static
+void test_fail_argpar_iter(const char * const cmdline,
+		const char * const expected_error,
+		const struct argpar_opt_descr * const descrs)
+{
+	struct argpar_iter *iter = NULL;
+	const struct argpar_item *item = NULL;
+	gchar ** const argv = g_strsplit(cmdline, " ", 0);
+	unsigned int i;
+	char *error = NULL;
+
+	iter = argpar_iter_create(g_strv_length(argv),
+		(const char * const *) argv, descrs);
+	assert(iter);
+
+	for (i = 0; ; i++) {
+		enum argpar_iter_parse_next_status status;
+
+		ARGPAR_ITEM_DESTROY_AND_RESET(item);
+		status = argpar_iter_parse_next(iter, &item, &error);
+
+		ok(status == ARGPAR_ITER_PARSE_NEXT_STATUS_OK ||
+			status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR ||
+			status == ARGPAR_ITER_PARSE_NEXT_STATUS_ERROR_UNKNOWN_OPT,
+			"argpar_iter_parse_next() returns the expected status "
+			"(%d) for command line `%s` (call %u)",
+			status, cmdline, i + 1);
+
+		if (status != ARGPAR_ITER_PARSE_NEXT_STATUS_OK) {
+			ok(!item,
+				"argpar_iter_parse_next() doesn't set an item "
+				"for other status than "
+				"`ARGPAR_ITER_PARSE_NEXT_STATUS_OK` "
+				"and command line `%s` (call %u)",
+				cmdline, i + 1);
+			ok(error,
+				"argpar_iter_parse_next() sets an error for "
+				"other status than "
+				" `ARGPAR_ITER_PARSE_NEXT_STATUS_OK` "
+				"and command line `%s` (call %u)",
+				cmdline, i + 1);
+			break;
+		}
+
+		ok(item,
+			"argpar_iter_parse_next() sets an item for status "
+			"`ARGPAR_ITER_PARSE_NEXT_STATUS_OK` "
+			"and command line `%s` (call %u)",
+			cmdline, i + 1);
+		ok(!error,
+			"argpar_iter_parse_next() doesn't set an error for status "
+			"`ARGPAR_ITER_PARSE_NEXT_STATUS_OK` "
+			"and command line `%s` (call %u)",
+			cmdline, i + 1);
+	}
+
+	ok(strcmp(expected_error, error) == 0,
+		"argpar_iter_parse_next() sets the expected error string "
+		"for command line `%s`", cmdline);
+
+	if (strcmp(expected_error, error) != 0) {
+		diag("Expected: `%s`", expected_error);
+		diag("Got:      `%s`", error);
+	}
+
+	argpar_item_destroy(item);
+	argpar_iter_destroy(iter);
+	free(error);
+	g_strfreev(argv);
+}
+
+/*
+ * Calls test_fail_argpar_parse() and test_fail_argpar_iter() with the
+ * provided parameters.
+ */
+static
+void test_fail(const char * const cmdline, const char * const expected_error,
+		const struct argpar_opt_descr * const descrs)
+{
+	test_fail_argpar_parse(cmdline, expected_error, descrs);
+	test_fail_argpar_iter(cmdline, expected_error, descrs);
+}
+
 static
 void fail_tests(void)
 {
 	/* Unknown long option */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "thumb", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_fail(
@@ -548,9 +777,9 @@ void fail_tests(void)
 
 	/* Unknown short option */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "thumb", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_fail(
@@ -561,9 +790,9 @@ void fail_tests(void)
 
 	/* Missing long option argument */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, '\0', "thumb", true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_fail(
@@ -574,9 +803,9 @@ void fail_tests(void)
 
 	/* Missing short option argument */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'k', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_fail(
@@ -587,11 +816,11 @@ void fail_tests(void)
 
 	/* Missing short option argument (multiple glued) */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'a', NULL, false },
 			{ 0, 'b', NULL, false },
 			{ 0, 'c', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_fail(
@@ -602,11 +831,11 @@ void fail_tests(void)
 
 	/* Invalid `-` */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'a', NULL, false },
 			{ 0, 'b', NULL, false },
 			{ 0, 'c', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_fail(
@@ -617,11 +846,11 @@ void fail_tests(void)
 
 	/* Invalid `--` */
 	{
-		const struct bt_argpar_opt_descr descrs[] = {
+		const struct argpar_opt_descr descrs[] = {
 			{ 0, 'a', NULL, false },
 			{ 0, 'b', NULL, false },
 			{ 0, 'c', NULL, true },
-			BT_ARGPAR_OPT_DESCR_SENTINEL
+			ARGPAR_OPT_DESCR_SENTINEL
 		};
 
 		test_fail(
@@ -629,11 +858,23 @@ void fail_tests(void)
 			"While parsing argument #2 (`--`): Invalid argument",
 			descrs);
 	}
+
+	{
+		const struct argpar_opt_descr descrs[] = {
+			{ 0, 'c', "chevre", false },
+			ARGPAR_OPT_DESCR_SENTINEL
+		};
+
+		test_fail(
+			"--chevre=fromage",
+			"While parsing argument #1 (`--chevre=fromage`): Unexpected argument for option `--chevre`",
+			descrs);
+	}
 }
 
 int main(void)
 {
-	plan_tests(129);
+	plan_tests(419);
 	succeed_tests();
 	fail_tests();
 	return exit_status();