user: implement mlibc as the libc, finally.

It's finally done..

Signed-off-by: kaguya <vpshinomiya@protonmail.com>

user/include/mlibc/tests/glibc/getopt.c

@@ -0,0 +1,884 @@
+#include <assert.h>
+#include <getopt.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))
+#define dump(x) fprintf(stderr, "getopt c '%c' (%d), optind %d ('%s'), optarg '%s', optopt '%c' (%d)\n", \
+		(x), (x), optind, (size_t)optind >= COUNT_OF(test_argv) ? "out of range" : test_argv[optind], optarg, optopt, optopt);
+
+#define dumpargv(argv) do { \
+	fprintf(stderr, "args(%zu) {\n", COUNT_OF(argv)); \
+	for (size_t i = 0; i < COUNT_OF(argv); i++) { \
+		fprintf(stderr, "\targv[%zu] = '%s'\n", i, argv[i]); \
+	} \
+	fprintf(stderr, "}\n"); \
+} while (0)
+
+void test1() {
+	const char *shortopts = "b:cdef";
+
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, no_argument, NULL, 0}
+	};
+
+	int test_argc = 7;
+
+	char *test_argv[] = {
+		"dummy",
+		"--foo",
+		"abc",
+		"-b",
+		"abc",
+		"abc",
+		"abc"
+	};
+
+	optind = 0;
+	int c = getopt_long(test_argc, test_argv, shortopts, longopts, NULL);
+	dump(c)
+	assert(c == 'f');
+
+	c = getopt_long(test_argc, test_argv, shortopts, longopts, NULL);
+	dump(c)
+	assert(optarg && !strcmp(optarg, "abc"));
+	assert(c == 'b');
+
+	c = getopt_long(test_argc, test_argv, shortopts, longopts, NULL);
+	dump(c);
+	assert(c == -1);
+	assert(optarg == NULL);
+
+	// we have 2 non-option arguments
+	assert((optind + 2) == test_argc);
+}
+
+void test2() {
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, no_argument, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-c",
+	};
+
+	fputs("Situation: we pass a non-existant short option in argv\n", stderr);
+
+	optind = 0;
+	opterr = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "ab:", longopts, NULL);
+	// Expected result: return '?', optopt is set to the offender
+	assert(c == '?');
+	assert(optopt == 'c');
+
+	fputs("Situation: we pass a non-existant short option in argv, while passing a leading colon in optstring\n", stderr);
+	optind = 0;
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, ":ab:", longopts, NULL);
+	// Expected result: return '?', optopt is set to the offender
+	assert(c == '?');
+	assert(optopt == 'c');
+
+	fputs("Situation: we omit the required arg to a short option\n", stderr);
+	optind = 0;
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "ab:c:", longopts, NULL);
+	// Expected result: return '?', optopt is set to the offender
+	assert(c == '?');
+	assert(optopt == 'c');
+
+	fputs("Situation: we omit the required arg to a short option, while passing a leading colon in optstring\n", stderr);
+	optind = 0;
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, ":ab:c:", longopts, NULL);
+	// Expected result: return ':', optopt is set to the offender
+	assert(c == ':');
+	assert(optopt == 'c');
+}
+
+void test3() {
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, no_argument, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-cmanagarm",
+	};
+
+	fputs("Situation: we pass a concatenated argument to a short option\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "ab:c:", longopts, NULL);
+	dump(c);
+	// Expected result:
+	assert(c == 'c');
+	assert(!strcmp(optarg, "managarm"));
+}
+
+void test4() {
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, no_argument, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-acmanagarm",
+	};
+
+	fputs("Situation: we pass concatenated short options to getopt\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "ab:c:", longopts, NULL);
+	assert(c == 'a');
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "ab:c:", longopts, NULL);
+	// Expected result:
+	assert(c == 'c');
+	assert(!strcmp(optarg, "managarm"));
+}
+
+void test5() {
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, no_argument, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"su",
+		"-",
+		"managarm",
+		0
+	};
+
+	int test_argc = 3;
+
+	fputs("Situation: testing `su - managarm`\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(test_argc, test_argv, "ab:", longopts, NULL);
+	dump(c);
+	assert(c == -1);
+
+	if (optind < test_argc && !strcmp(test_argv[optind], "-")) {
+		++optind;
+	}
+
+	assert(optind < test_argc);
+	assert(!strcmp(test_argv[optind++], "managarm"));
+	assert(optind == test_argc);
+}
+
+void test6() {
+	char *test_argv[] = {
+		"telescope",
+		"gemini://electrode.codes",
+		"-S",
+		0
+	};
+
+	int test_argc = 3;
+	optind = 0;
+
+	const struct option longopts[] = {
+		{"colors",      no_argument,    NULL,   'C'},
+		{"colours",	no_argument,    NULL,   'C'},
+		{"help",	no_argument,	NULL,	'h'},
+		{"safe",	no_argument,	NULL,	'S'},
+		{"version",	no_argument,	NULL,	'v'},
+		{NULL,		0,		NULL,	0},
+	};
+
+	int c = getopt_long(test_argc, test_argv, "Cc:hnST:v", longopts, NULL);
+	dump(c);
+	dumpargv(test_argv);
+	assert(c == 'S');
+	c = getopt_long(test_argc, test_argv, "Cc:hnST:v", longopts, NULL);
+	dump(c);
+	dumpargv(test_argv);
+	assert(optind == 2);
+	assert(!optarg);
+}
+
+void test7() {
+	int c;
+
+	static const struct option options[] = {
+		{ "debug", no_argument, NULL, 'd' },
+		{ "help", no_argument, NULL, 'h' },
+		{ "version", no_argument, NULL, 'V' },
+		{}
+	};
+	const char *command;
+
+	char *test_argv[] = {
+		"udevadm",
+		"hwdb",
+		"--update",
+		0
+	};
+
+	int test_argc = 3;
+	setenv("POSIXLY_CORRECT", "1", 1);
+	optind = 0;
+
+	while ((c = getopt_long(test_argc, test_argv, "+dhV", options, NULL)) >= 0) {
+		switch (c) {
+			case 'd':
+				break;
+			case 'h':
+				break;
+			case 'V':
+				break;
+			default:
+				break;
+		}
+	}
+
+	dump(c);
+	command = test_argv[optind];
+	assert(command);
+	assert(!strcmp(command, "hwdb"));
+	unsetenv("POSIXLY_CORRECT");
+}
+
+void test8() {
+	const char *shortopts = "b:cde";
+
+	int foo = false;
+	int bar = false;
+
+	const struct option longopts[] = {
+		{"foo", required_argument, &foo, 'x'},
+		{"bar", required_argument, &bar, 'y'},
+		{NULL, no_argument, NULL, 0}
+	};
+
+	int test_argc = 6;
+
+	char *test_argv[] = {
+		"dummy",
+		"-foo",
+		"abc",
+		"-bar=def",
+		"ghi",
+		"jkl"
+	};
+
+	#ifdef __GLIBC__
+		optind = 0;
+	#else
+		optreset = 1;
+	#endif
+	optopt = 0;
+	int c = getopt_long_only(test_argc, test_argv, shortopts, longopts, NULL);
+	dump(c);
+	assert(foo && !c);
+	assert(optind == 3);
+
+	c = getopt_long_only(test_argc, test_argv, shortopts, longopts, NULL);
+	dump(c);
+	assert(bar && !c);
+	assert(optind == 4);
+}
+
+void test9() {
+	char *test_argv[] = {
+		"foo",
+	};
+	struct option opts[] = { {0} };
+	optind = 0;
+	int c = getopt_long(1, test_argv, "abc", opts, NULL);
+	dump(c);
+	assert(c == -1);
+}
+
+void test10() {
+	char *test_argv[] = {
+		"foo",
+		"nonoption",
+		"-a",
+		"nonoption2",
+		"nonoption3",
+		"-b",
+		"-c",
+	};
+	struct option opts[] = { {0} };
+	optind = 2;
+	dump(0);
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "abc", opts, NULL);
+	dump(c);
+	dumpargv(test_argv);
+	assert(c == 'a');
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "abc", opts, NULL);
+	dump(c);
+	dumpargv(test_argv);
+	assert(c == 'b');
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "abc", opts, NULL);
+	dump(c);
+	dumpargv(test_argv);
+	assert(c == 'c');
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "abc", opts, NULL);
+	dump(c);
+	dumpargv(test_argv);
+	assert(c == -1);
+
+	assert(!strcmp(test_argv[0], "foo"));
+	assert(!strcmp(test_argv[1], "nonoption"));
+	assert(!strcmp(test_argv[2], "-a"));
+	assert(!strcmp(test_argv[3], "-b"));
+	assert(!strcmp(test_argv[4], "-c"));
+	assert(!strcmp(test_argv[5], "nonoption2"));
+	assert(!strcmp(test_argv[6], "nonoption3"));
+}
+
+void test11() {
+	const struct option longopts[] = {
+		{"op", optional_argument, NULL, 'o'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"--op",
+		"--op=arg",
+		"non-option",
+		"--op"
+	};
+
+	fputs("Situation: optional argument to long option\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == 'o');
+	assert(optarg == NULL);
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == 'o');
+	assert(!strcmp(optarg, "arg"));
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == 'o');
+	assert(optarg == NULL);
+}
+
+void test12() {
+	char *test_argv[] = {
+		"dummy",
+		"-a",
+		"-b",
+		"arg",
+		"-carg",
+		"arg",
+	};
+
+	fputs("Situation: optional argument to short option\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "ab::c::", NULL, NULL);
+	assert(c == 'a');
+	assert(optarg == NULL);
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "ab::c::", NULL, NULL);
+	assert(c == 'b');
+	assert(!optarg);
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "ab::c::", NULL, NULL);
+	assert(c == 'c');
+	assert(!strcmp(optarg, "arg"));
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "ab::c::", NULL, NULL);
+	assert(c == -1);
+	assert(optind == 4);
+	assert(!strcmp(test_argv[optind], "arg"));
+}
+
+void test13() {
+	const struct option longopts[] = {
+		{"ambiguous-opt", no_argument, NULL, 0},
+		{"ambiguous-option", no_argument, NULL, 1},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"--ambiguous-o"
+	};
+
+	fputs("Situation: ambiguous long option\n", stderr);
+
+	optind = 0;
+	opterr = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == '?');
+}
+
+void test14() {
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-Wfoo=bar",
+	};
+
+	fputs("Situation: -W for long options\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "W;", longopts, NULL);
+	assert(c == 'f');
+	assert(!strcmp(optarg, "bar"));
+}
+
+void test15() {
+	char *test_argv[] = {
+		"dummy",
+		"-c",
+		"-a",
+		"--",
+		"-b"
+	};
+
+	fputs("Situation: -- to stop option processing\n", stderr);
+
+	optind = 0;
+	int c = getopt(COUNT_OF(test_argv), test_argv, "+ab");
+	assert(c == '?');
+	assert(optind == 2);
+
+	c = getopt(COUNT_OF(test_argv), test_argv, "+ab");
+	assert(c == 'a');
+	assert(optind == 3);
+
+	c = getopt(COUNT_OF(test_argv), test_argv, "+ab");
+	assert(c == -1);
+	assert(optind == 4);
+	assert(!strcmp(test_argv[optind], "-b"));
+}
+
+void test16() {
+	const struct option longopts[] = {
+		{"add", required_argument, NULL, 'a'},
+		{"append", no_argument, NULL, 'p'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"--ad=foo",
+		"--appe"
+	};
+
+	fputs("Situation: non-ambiguous long option prefix\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == 'a');
+	assert(!strcmp(optarg, "foo"));
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == 'p');
+	assert(optarg == NULL);
+}
+
+void test17() {
+	const struct option longopts[] = {
+		{"foo", no_argument, NULL, 'l'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-foo"
+	};
+
+	fputs("Situation: getopt_long_only with what could be short opts or a long opt\n", stderr);
+
+	// Case 1: long option "foo" exists, so "-foo" should be treated as "--foo"
+	optind = 0;
+	int c = getopt_long_only(COUNT_OF(test_argv), test_argv, "f:o", longopts, NULL);
+	assert(c == 'l');
+
+	// Case 2: long option "foo" does not exist.
+	const struct option longopts2[] = {
+		{"bar", no_argument, NULL, 'b'},
+		{NULL, 0, NULL, 0}
+	};
+	optind = 0;
+	c = getopt_long_only(COUNT_OF(test_argv), test_argv, "f:o", longopts2, NULL);
+	assert(c == 'f');
+	assert(!strcmp(optarg, "oo"));
+}
+
+void test18() {
+	const struct option longopts[] = {
+		{"op", optional_argument, NULL, 'o'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-Wop=val",
+	};
+
+	fputs("Situation: -W with a long option with an optional argument (with value)\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "W;", longopts, NULL);
+	assert(c == 'o');
+	assert(!strcmp(optarg, "val"));
+
+	char *test_argv2[] = {
+		"dummy",
+		"-Wop",
+	};
+
+	fputs("Situation: -W with a long option with an optional argument (no value)\n", stderr);
+
+	optind = 0;
+	c = getopt_long(COUNT_OF(test_argv2), test_argv2, "W;", longopts, NULL);
+	assert(c == 'o');
+	assert(optarg == NULL);
+}
+
+void test19() {
+	char *test_argv[] = {
+		"dummy",
+		"-a",
+		"non-option",
+		"-b",
+	};
+
+	fputs("Situation: POSIXLY_CORRECT behavior with '+'\n", stderr);
+
+	optind = 0;
+	int c = getopt(COUNT_OF(test_argv), test_argv, "+ab");
+	assert(c == 'a');
+
+	c = getopt(COUNT_OF(test_argv), test_argv, "+ab");
+	assert(c == -1);
+	assert(optind == 2);
+	assert(!strcmp(test_argv[optind], "non-option"));
+}
+
+void test20() {
+	const struct option longopts[] = {
+		{"option", required_argument, NULL, 'o'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"--option",
+		"-x",
+	};
+
+	fputs("Situation: long option with argument that looks like an option\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "x", longopts, NULL);
+	assert(c == 'o');
+	assert(!strcmp(optarg, "-x"));
+	assert(optind == 3);
+}
+
+void test21() {
+	const struct option longopts[] = {
+		{"ambig-one", no_argument, NULL, '1'},
+		{"ambig-two", no_argument, NULL, '2'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-ambig",
+	};
+
+	fputs("Situation: ambiguous long option with getopt_long_only\n", stderr);
+
+	optind = 0;
+	opterr = 0;
+	int c = getopt_long_only(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == '?');
+}
+
+void test22() {
+	const struct option longopts[] = {
+		{"foo", no_argument, NULL, 'f'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-Wbar",
+	};
+
+	fputs("Situation: -W with non-existent long option\n", stderr);
+
+	optind = 0;
+	opterr = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "W;", longopts, NULL);
+	assert(c == '?');
+	assert(optind == 2);
+}
+
+void test23() {
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-foo",
+		"val1",
+		"-foo=val2",
+	};
+
+	fputs("Situation: getopt_long_only with required argument\n", stderr);
+
+	optind = 0;
+	int c = getopt_long_only(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == 'f');
+	assert(!strcmp(optarg, "val1"));
+	assert(optind == 3);
+
+	c = getopt_long_only(COUNT_OF(test_argv), test_argv, "", longopts, NULL);
+	assert(c == 'f');
+	assert(!strcmp(optarg, "val2"));
+	assert(optind == 4);
+}
+
+void test24() {
+	char *test_argv[] = {
+		"dummy",
+		"-W",
+	};
+
+	fputs("Situation: -W as a short option, not for passing long options\n", stderr);
+
+	optind = 0;
+	int c = getopt(COUNT_OF(test_argv), test_argv, "W");
+	assert(c == 'W');
+	assert(optind == 2);
+}
+
+void test25() {
+	const struct option longopts[] = {
+		{"foo", required_argument, NULL, 'f'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-Wfoo",
+	};
+
+	fputs("Situation: -W with missing argument for a long option, with ':' in optstring\n", stderr);
+
+	optind = 0;
+	opterr = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, ":W;", longopts, NULL);
+	assert(c == ':');
+	assert(optopt == 'f');
+	assert(optind == 2);
+}
+
+void test26() {
+	const struct option longopts[] = {
+		{"foo", no_argument, NULL, 0},
+		{"ambig-one", no_argument, NULL, 1},
+		{"ambig-two", no_argument, NULL, 2},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"dummy",
+		"-W",
+	};
+
+	fputs("Situation: -W without an argument\n", stderr);
+
+	optind = 0;
+	opterr = 1;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, ":W;", longopts, NULL);
+	assert(c == ':');
+	assert(optopt == 'W');
+	assert(optind == 2);
+}
+
+void test27() {
+	char *test_argv[] = {
+		"dummy",
+		"-Wambig",
+	};
+
+	const struct option longopts[] = {
+		{"foo", no_argument, NULL, 0},
+		{"ambig-one", no_argument, NULL, 1},
+		{"ambig-two", no_argument, NULL, 2},
+		{NULL, 0, NULL, 0}
+	};
+
+	fputs("Situation: -W with an ambiguous long option\n", stderr);
+
+	optind = 0;
+	opterr = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "W;", longopts, NULL);
+	assert(c == '?');
+	assert(optind == 2);
+}
+
+void test28() {
+	char *test_argv[] = {
+		"dummy",
+		"-Wfoo=bar",
+		"-Wfoo=",
+	};
+
+	const struct option longopts[] = {
+		{"foo", no_argument, NULL, 0},
+		{"ambig-one", no_argument, NULL, 1},
+		{"ambig-two", no_argument, NULL, 2},
+		{NULL, 0, NULL, 0}
+	};
+
+	fputs("Situation: -W with an argument to a long option that does not take one\n", stderr);
+
+	optind = 0;
+	opterr = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "W;", longopts, NULL);
+	assert(c == '?');
+	assert(optind == 2);
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "W;", longopts, NULL);
+	assert(c == '?');
+	assert(optind == 3);
+
+	c = getopt_long(COUNT_OF(test_argv), test_argv, "W;", longopts, NULL);
+	assert(c == -1);
+}
+
+void test29() {
+	char *test_argv[] = {
+		"dummy",
+		"--a",
+	};
+
+	const struct option longopts[] = {
+		{"load-credentials", no_argument, NULL, 0x103},
+		{NULL, 0, NULL, 0},
+	};
+
+	optind = 0;
+	opterr = 1;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "el:sSRp:m:t:Vh", longopts, NULL);
+	dump(c);
+	assert(c == '?');
+	assert(optind == 2);
+}
+
+void test30() {
+	const struct option longopts[] = {
+		{"long-opt", required_argument, NULL, 'l'},
+		{NULL, 0, NULL, 0}
+	};
+
+	char *test_argv[] = {
+		"getopt_test",
+		"non-arg1",
+		"--long-opt",
+		"val",
+		"non-arg2"
+	};
+
+	fputs("Situation: non-arguments before valid long arguments\n", stderr);
+
+	optind = 0;
+	int c = getopt_long(COUNT_OF(test_argv), test_argv, "+", longopts, NULL);
+	assert(c == -1);
+	assert(optind == 1);
+	assert(!strcmp(test_argv[0], "getopt_test"));
+	assert(!strcmp(test_argv[1], "non-arg1"));
+	assert(!strcmp(test_argv[2], "--long-opt"));
+	assert(!strcmp(test_argv[3], "val"));
+	assert(!strcmp(test_argv[4], "non-arg2"));
+
+	optind = 2;
+	while ((c = getopt_long(COUNT_OF(test_argv), test_argv, "+", longopts, NULL)) != -1) {
+		switch (c) {
+			case 'l':
+				assert(!strcmp(optarg, "val"));
+				break;
+			default:
+				break;
+		}
+	}
+
+	assert(c == -1);
+	assert(optind == 4);
+
+	optind = 0;
+	while ((c = getopt_long(COUNT_OF(test_argv), test_argv, "", longopts, NULL)) != -1) {
+		switch (c) {
+			case 'l':
+				assert(!strcmp(optarg, "val"));
+				break;
+			default:
+				break;
+		}
+	}
+
+	assert(optind == 3);
+	assert(!strcmp(test_argv[0], "getopt_test"));
+	assert(!strcmp(test_argv[1], "--long-opt"));
+	assert(!strcmp(test_argv[2], "val"));
+	assert(!strcmp(test_argv[3], "non-arg1"));
+	assert(!strcmp(test_argv[4], "non-arg2"));
+}
+
+int main() {
+	test1();
+	test2();
+	test3();
+	test4();
+	test5();
+	test6();
+	test7();
+	test8();
+	test9();
+	test10();
+	test11();
+	test12();
+	test13();
+	test14();
+	test15();
+	test16();
+	test17();
+	test18();
+	test19();
+	test20();
+	test21();
+	test22();
+	test23();
+	test24();
+	test25();
+	test26();
+	test27();
+	test28();
+	test29();
+	test30();
+
+	return 0;
+}