libutil

// test_optget.c
// optget unit test for libutil
// Copyright (C) 2020, Jakob Wakeling
// MIT Licence

#include "../optget.h"
#include "unit.h"

#include <stdbool.h>
#include <stdio.h>
#include <string.h>

#define SEQ(s1, s2) (strcmp(s1, s2) == 0)

int main(void) {
	struct opt opt;
	
	{
		char *av[] = { "G00", "-a", "-bfoo", "-c", "bar", "--", "baz", NULL };
		
		opt = OPTGET_INIT; opt.str = ":ab:c:";
		ASSERT("G00T00 option",
				optget(&opt, av, 1) == 'a');
		ASSERT("G00T01 option with shared argument",
				optget(&opt, av, 1) == 'b');
		ASSERT("G00T02 optarg shared argument",
				opt.arg == av[2] + 2);
		ASSERT("G00T03 option with seperate argument",
				optget(&opt, av, 1) == 'c');
		ASSERT("G00T04 optarg seperate argument",
				opt.arg == av[4]);
		ASSERT("G00T05 options end",
				optget(&opt, av, 1) == -1);
		ASSERT("G00T06 operand",
				SEQ(av[opt.ind], "baz"));
	}
	
	{
		char *av[] = { "G01", "-abcfoo", "bar", NULL };
		
		opt = OPTGET_INIT; opt.str = ":abc:";
		ASSERT("G01T00 option",
				optget(&opt, av, 1) == 'a');
		ASSERT("G01T01 option",
				optget(&opt, av, 1) == 'b');
		ASSERT("G01T02 option with shared argument",
				optget(&opt, av, 1) == 'c');
		ASSERT("G01T03 optarg shared argument",
				opt.arg == av[1] + 4);
		ASSERT("G01T04 options end",
				optget(&opt, av, 1) == -1);
		ASSERT("G01T05 optind at end",
				opt.ind == 2);
		ASSERT("G01T06 optarg after end",
				opt.arg == av[1] + 4);
		ASSERT("G01T07 options still end",
				optget(&opt, av, 1) == -1);
		ASSERT("G01T08 optind still at end",
				opt.ind == 2);
		ASSERT("G01T09 operand",
				SEQ(av[opt.ind], "bar"));
	}
	
	{
		char *av[] = { "G02", "-aa", "-b", NULL };
		
		opt = OPTGET_INIT; opt.str = ":b:";
		ASSERT("G02T00 invalid option",
				optget(&opt, av, 1) == '?');
		ASSERT("G02T01 optopt",
				opt.opt == 'a');
		ASSERT("G02T00 invalid option again",
				optget(&opt, av, 1) == '?');
		ASSERT("G02T01 optopt",
				opt.opt == 'a');
		ASSERT("G02T02 missing option argument",
				optget(&opt, av, 1) == ':');
		ASSERT("G02T03 optopt",
				opt.opt == 'b');
	}
	
	{
		char *av[] = { "G03", "foo", "-a", "bar", "-b", "baz", NULL };
		int argc = (sizeof (av) / sizeof (*av) - 1);
		
		opt = OPTGET_INIT; opt.str = ":ab:";
		ASSERT("G03T00 option",
				optget(&opt, av, 1) == 'a');
		ASSERT("G03T01 option with seperate argument",
				optget(&opt, av, 1) == 'b');
		ASSERT("G03T02 optarg seperate argument",
				SEQ(opt.arg, "baz"));
		ASSERT("G03T03 options end",
				optget(&opt, av, 1) == -1);
		ASSERT("G03T04 optind at end",
				opt.ind == 4);
		ASSERT("G03T05 options still end",
				optget(&opt, av, 1) == -1);
		ASSERT("G03T06 optind still at end",
				opt.ind == 4);
		ASSERT("G03T07 permuted operand",
				SEQ(av[opt.ind], "foo")); ++opt.ind;
		ASSERT("G03T08 permuted operand",
				SEQ(av[opt.ind], "bar")); ++opt.ind;
		ASSERT("G03T09 permuted operands end",
				opt.ind >= argc);
	}
	
	{
		char *av[] = { "G04", "--foo", "--bar=arg", "--bar", "argument",
			"--baz", NULL };
		
		struct lop lops[] = {
			{ "foo", ARG_NUL, 256 },
			{ "bar", ARG_REQ, 257 },
			{ "baz", ARG_OPT, 258 },
			{ NULL, 0, 0 }
		};
		
		opt = OPTGET_INIT; opt.str = ":"; opt.lops = lops;
		ASSERT("G04T00 long option",
				optget(&opt, av, 1) == 256);
		ASSERT("G04T01 long option with shared argument",
				optget(&opt, av, 1) == 257);
		ASSERT("G04T02 optarg shared argument",
				SEQ(opt.arg, "arg"));
		ASSERT("G04T03 long option with seperate argument",
				optget(&opt, av, 1) == 257);
		ASSERT("G04T04 optarg seperate argument",
				SEQ(opt.arg, "argument"));
		ASSERT("G04T05 long option without argument",
				optget(&opt, av, 1) == 258);
		ASSERT("G04T06 optarg seperate argument",
				opt.arg == NULL);
	}
	
	{
		char *av[] = { "G05", "foo", "--bar", "--", "baz", NULL };
		int argc = (sizeof (av) / sizeof (*av) - 1);
		
		struct lop lops[] = {
			{ "bar", ARG_NUL, 256 },
			{ NULL, 0, 0 }
		};
		
		opt = OPTGET_INIT; opt.str = ":"; opt.lops = lops;
		ASSERT("G05T00 long option",
				optget(&opt, av, 1) == 256);
		ASSERT("G05T01 options end",
				optget(&opt, av, 1) == -1);
		ASSERT("G05T02 permuted operand",
				SEQ(av[opt.ind], "foo")); ++opt.ind;
		ASSERT("G05T03 permuted operand",
				SEQ(av[opt.ind], "baz")); ++opt.ind;
		ASSERT("G05T04 permuted operands end",
				opt.ind >= argc);
		ASSERT("G05T05 options still end",
				optget(&opt, av, 1) == -1);
		ASSERT("G05T06 permutes operands still end",
				opt.ind >= argc);
		
	}
	
	{
		char *av[] = { "G06", "--foo", "bar", "-a", NULL };
		
		opt = OPTGET_INIT; opt.str = ":a";
		ASSERT("G06T00 invalid option with NULL lopts",
				optget(&opt, av, 0) == '?');
		ASSERT("G06T01 options end without permute",
				optget(&opt, av, 0) == -1);
		ASSERT("G06T02 unpermuted operand",
				SEQ(av[opt.ind], "bar"));
		ASSERT("G06T03 still no permute",
				optget(&opt, av, 0) == -1);
		ASSERT("G06T04 still unpermuted operand",
				SEQ(av[opt.ind], "bar"));
	}
	
	printf("%d of %d tests passed\n", testspassed, testsrun);
	return testsfailed;
}