xref: /netbsd-src/lib/libedit/TEST/test_filecompletion.c (revision c3d00a7d309653c77fafcb230c6ec61124cdf8e2)

/*	$NetBSD: test_filecompletion.c,v 1.5 2019/09/08 05:50:58 abhinav Exp $	*/

/*-
 * Copyright (c) 2017 Abhinav Upadhyay <abhinav@NetBSD.org>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <assert.h>
#include <err.h>
#include <stdio.h>
#include <histedit.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>

#include "filecomplete.h"
#include "el.h"

typedef struct {
	const wchar_t *user_typed_text; /* The actual text typed by the user on the terminal */
	const char *completion_function_input ; /*the text received by fn_filename_completion_function */
	const char *expanded_text[2]; /* the value to which completion_function_input should be expanded */
	const wchar_t *escaped_output; /* expected escaped value of expanded_text */
} test_input;

static test_input inputs[] = {
	{
		/* simple test for escaping angular brackets */
		L"ls ang",
		"ang",
		{"ang<ular>test", NULL},
		L"ls ang\\<ular\\>test "
	},
	{
		/* test angular bracket inside double quotes: ls "dq_ang */
		L"ls \"dq_ang",
		"dq_ang",
		{"dq_ang<ular>test", NULL},
		L"ls \"dq_ang<ular>test\""
	},
	{
		/* test angular bracket inside singlq quotes: ls "sq_ang */
		L"ls 'sq_ang",
		"sq_ang",
		{"sq_ang<ular>test", NULL},
		L"ls 'sq_ang<ular>test'"
	},
	{
		/* simple test for backslash */
		L"ls back",
		"back",
		{"backslash\\test", NULL},
		L"ls backslash\\\\test "
	},
	{
		/* backslash inside single quotes */
		L"ls 'sback",
		"sback",
		{"sbackslash\\test", NULL},
		L"ls 'sbackslash\\test'"
	},
	{
		/* backslash inside double quotes */
		L"ls \"dback",
		"dback",
		{"dbackslash\\test", NULL},
		L"ls \"dbackslash\\\\test\""
	},
	{
		/* test braces */
		L"ls br",
		"br",
		{"braces{test}", NULL},
		L"ls braces\\{test\\} "
	},
	{
		/* test braces inside single quotes */
		L"ls 'sbr",
		"sbr",
		{"sbraces{test}", NULL},
		L"ls 'sbraces{test}'"
	},
	{
		/* test braces inside double quotes */
		L"ls \"dbr",
		"dbr",
		{"dbraces{test}", NULL},
		L"ls \"dbraces{test}\""
	},
	{
		/* test dollar */
		L"ls doll",
		"doll",
		{"doll$artest", NULL},
		L"ls doll\\$artest "
	},
	{
		/* test dollar inside single quotes */
		L"ls 'sdoll",
		"sdoll",
		{"sdoll$artest", NULL},
		L"ls 'sdoll$artest'"
	},
	{
		/* test dollar inside double quotes */
		L"ls \"ddoll",
		"ddoll",
		{"ddoll$artest", NULL},
		L"ls \"ddoll\\$artest\""
	},
	{
		/* test equals */
		L"ls eq",
		"eq",
		{"equals==test", NULL},
		L"ls equals\\=\\=test "
	},
	{
		/* test equals inside sinqle quotes */
		L"ls 'seq",
		"seq",
		{"sequals==test", NULL},
		L"ls 'sequals==test'"
	},
	{
		/* test equals inside double quotes */
		L"ls \"deq",
		"deq",
		{"dequals==test", NULL},
		L"ls \"dequals==test\""
	},
	{
		/* test \n */
		L"ls new",
		"new",
		{"new\\nline", NULL},
		L"ls new\\\\nline "
	},
	{
		/* test \n inside single quotes */
		L"ls 'snew",
		"snew",
		{"snew\nline", NULL},
		L"ls 'snew\nline'"
	},
	{
		/* test \n inside double quotes */
		L"ls \"dnew",
		"dnew",
		{"dnew\nline", NULL},
		L"ls \"dnew\nline\""
	},
	{
		/* test single space */
		L"ls spac",
		"spac",
		{"space test", NULL},
		L"ls space\\ test "
	},
	{
		/* test single space inside singlq quotes */
		L"ls 's_spac",
		"s_spac",
		{"s_space test", NULL},
		L"ls 's_space test'"
	},
	{
		/* test single space inside double quotes */
		L"ls \"d_spac",
		"d_spac",
		{"d_space test", NULL},
		L"ls \"d_space test\""
	},
	{
		/* test multiple spaces */
		L"ls multi",
		"multi",
		{"multi space  test", NULL},
		L"ls multi\\ space\\ \\ test "
	},
	{
		/* test multiple spaces inside single quotes */
		L"ls 's_multi",
		"s_multi",
		{"s_multi space  test", NULL},
		L"ls 's_multi space  test'"
	},
	{
		/* test multiple spaces inside double quotes */
		L"ls \"d_multi",
		"d_multi",
		{"d_multi space  test", NULL},
		L"ls \"d_multi space  test\""
	},
	{
		/* test double quotes */
		L"ls doub",
		"doub",
		{"doub\"quotes", NULL},
		L"ls doub\\\"quotes "
	},
	{
		/* test double quotes inside single quotes */
		L"ls 's_doub",
		"s_doub",
		{"s_doub\"quotes", NULL},
		L"ls 's_doub\"quotes'"
	},
	{
		/* test double quotes inside double quotes */
		L"ls \"d_doub",
		"d_doub",
		{"d_doub\"quotes", NULL},
		L"ls \"d_doub\\\"quotes\""
	},
	{
		/* test multiple double quotes */
		L"ls mud",
		"mud",
		{"mud\"qu\"otes\"", NULL},
		L"ls mud\\\"qu\\\"otes\\\" "
	},
	{
		/* test multiple double quotes inside single quotes */
		L"ls 'smud",
		"smud",
		{"smud\"qu\"otes\"", NULL},
		L"ls 'smud\"qu\"otes\"'"
	},
	{
		/* test multiple double quotes inside double quotes */
		L"ls \"dmud",
		"dmud",
		{"dmud\"qu\"otes\"", NULL},
		L"ls \"dmud\\\"qu\\\"otes\\\"\""
	},
	{
		/* test one single quote */
		L"ls sing",
		"sing",
		{"single'quote", NULL},
		L"ls single\\'quote "
	},
	{
		/* test one single quote inside single quote */
		L"ls 'ssing",
		"ssing",
		{"ssingle'quote", NULL},
		L"ls 'ssingle'\\''quote'"
	},
	{
		/* test one single quote inside double quote */
		L"ls \"dsing",
		"dsing",
		{"dsingle'quote", NULL},
		L"ls \"dsingle'quote\""
	},
	{
		/* test multiple single quotes */
		L"ls mu_sing",
		"mu_sing",
		{"mu_single''quotes''", NULL},
		L"ls mu_single\\'\\'quotes\\'\\' "
	},
	{
		/* test multiple single quotes inside single quote */
		L"ls 'smu_sing",
		"smu_sing",
		{"smu_single''quotes''", NULL},
		L"ls 'smu_single'\\'''\\''quotes'\\\'''\\'''"
	},
	{
		/* test multiple single quotes inside double quote */
		L"ls \"dmu_sing",
		"dmu_sing",
		{"dmu_single''quotes''", NULL},
		L"ls \"dmu_single''quotes''\""
	},
	{
		/* test parenthesis */
		L"ls paren",
		"paren",
		{"paren(test)", NULL},
		L"ls paren\\(test\\) "
	},
	{
		/* test parenthesis inside single quote */
		L"ls 'sparen",
		"sparen",
		{"sparen(test)", NULL},
		L"ls 'sparen(test)'"
	},
	{
		/* test parenthesis inside double quote */
		L"ls \"dparen",
		"dparen",
		{"dparen(test)", NULL},
		L"ls \"dparen(test)\""
	},
	{
		/* test pipe */
		L"ls pip",
		"pip",
		{"pipe|test", NULL},
		L"ls pipe\\|test "
	},
	{
		/* test pipe inside single quote */
		L"ls 'spip",
		"spip",
		{"spipe|test", NULL},
		L"ls 'spipe|test'",
	},
	{
		/* test pipe inside double quote */
		L"ls \"dpip",
		"dpip",
		{"dpipe|test", NULL},
		L"ls \"dpipe|test\""
	},
	{
		/* test tab */
		L"ls ta",
		"ta",
		{"tab\ttest", NULL},
		L"ls tab\\\ttest "
	},
	{
		/* test tab inside single quote */
		L"ls 'sta",
		"sta",
		{"stab\ttest", NULL},
		L"ls 'stab\ttest'"
	},
	{
		/* test tab inside double quote */
		L"ls \"dta",
		"dta",
		{"dtab\ttest", NULL},
		L"ls \"dtab\ttest\""
	},
	{
		/* test back tick */
		L"ls tic",
		"tic",
		{"tick`test`", NULL},
		L"ls tick\\`test\\` "
	},
	{
		/* test back tick inside single quote */
		L"ls 'stic",
		"stic",
		{"stick`test`", NULL},
		L"ls 'stick`test`'"
	},
	{
		/* test back tick inside double quote */
		L"ls \"dtic",
		"dtic",
		{"dtick`test`", NULL},
		L"ls \"dtick\\`test\\`\""
	},
	{
		/* test for @ */
		L"ls at",
		"at",
		{"atthe@rate", NULL},
		L"ls atthe\\@rate "
	},
	{
		/* test for @ inside single quote */
		L"ls 'sat",
		"sat",
		{"satthe@rate", NULL},
		L"ls 'satthe@rate'"
	},
	{
		/* test for @ inside double quote */
		L"ls \"dat",
		"dat",
		{"datthe@rate", NULL},
		L"ls \"datthe@rate\""
	},
	{
		/* test ; */
		L"ls semi",
		"semi",
		{"semi;colon;test", NULL},
		L"ls semi\\;colon\\;test "
	},
	{
		/* test ; inside single quote */
		L"ls 'ssemi",
		"ssemi",
		{"ssemi;colon;test", NULL},
		L"ls 'ssemi;colon;test'"
	},
	{
		/* test ; inside double quote */
		L"ls \"dsemi",
		"dsemi",
		{"dsemi;colon;test", NULL},
		L"ls \"dsemi;colon;test\""
	},
	{
		/* test & */
		L"ls amp",
		"amp",
		{"ampers&and", NULL},
		L"ls ampers\\&and "
	},
	{
		/* test & inside single quote */
		L"ls 'samp",
		"samp",
		{"sampers&and", NULL},
		L"ls 'sampers&and'"
	},
	{
		/* test & inside double quote */
		L"ls \"damp",
		"damp",
		{"dampers&and", NULL},
		L"ls \"dampers&and\""
	},
	{
		/* test completion when cursor at \ */
		L"ls foo\\",
		"foo",
		{"foo bar", NULL},
		L"ls foo\\ bar "
	},
	{
		/* test completion when cursor at single quote */
		L"ls foo'",
		"foo'",
		{"foo bar", NULL},
		L"ls foo\\ bar "
	},
	{
		/* test completion when cursor at double quote */
		L"ls foo\"",
		"foo\"",
		{"foo bar", NULL},
		L"ls foo\\ bar "
	},
	{
		/* test multiple completion matches */
		L"ls fo",
		"fo",
		{"foo bar", "foo baz"},
		L"ls foo\\ ba"
	},
	{
		L"ls ba",
		"ba",
		{"bar <bar>", "bar <baz>"},
		L"ls bar\\ \\<ba"
	}
};

static const wchar_t break_chars[] = L" \t\n\"\\'`@$><=;|&{(";

/*
 * Custom completion function passed to fn_complet, NULLe.
 * The function returns hardcoded completion matches
 * based on the test cases present in inputs[] (above)
 */
static char *
mycomplet_func(const char *text, int index)
{
	static int last_index = 0;
	size_t i = 0;
	if (last_index == 2) {
		last_index = 0;
		return NULL;
	}

	for (i = 0; i < sizeof(inputs)/sizeof(inputs[0]); i++) {
		if (strcmp(text, inputs[i].completion_function_input) == 0) {
			if (inputs[i].expanded_text[last_index] != NULL)
				return strdup(inputs[i].expanded_text[last_index++]);
			else {
				last_index = 0;
				return NULL;
			}
		}
	}

	return NULL;
}

int
main(int argc, char **argv)
{
	EditLine *el = el_init(argv[0], stdin, stdout, stderr);
	size_t i;
	size_t input_len;
	el_line_t line;
	wchar_t *buffer = malloc(64 * sizeof(*buffer));
	if (buffer == NULL)
		err(EXIT_FAILURE, "malloc failed");

	for (i = 0; i < sizeof(inputs)/sizeof(inputs[0]); i++) {
		memset(buffer, 0, 64 * sizeof(*buffer));
		input_len = wcslen(inputs[i].user_typed_text);
		wmemcpy(buffer, inputs[i].user_typed_text, input_len);
		buffer[input_len] = 0;
		line.buffer = buffer;
		line.cursor = line.buffer + input_len ;
		line.lastchar = line.cursor - 1;
		line.limit = line.buffer + 64 * sizeof(*buffer);
		el->el_line = line;
		fn_complete(el, mycomplet_func, NULL, break_chars, NULL, NULL, 10, NULL, NULL, NULL, NULL);

		/*
		 * fn_complete would have expanded and escaped the input in el->el_line.buffer.
		 * We need to assert that it matches with the expected value in our test data
		 */
		printf("User input: %ls\t Expected output: %ls\t Generated output: %ls\n",
				inputs[i].user_typed_text, inputs[i].escaped_output, el->el_line.buffer);
		assert(wcscmp(el->el_line.buffer, inputs[i].escaped_output) == 0);
	}
	el_end(el);
	return 0;

}