libedit/TEST/test_filecompletion.c

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

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

/*
 * Custom completion function passed to fn_complete.
 * 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 char *last_input = NULL;
	size_t i = 0;
	if (last_input && strcmp(last_input, text) == 0) {
		free(last_input);
		last_input = NULL;
		return NULL;
	}
	last_input = strdup(text);

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

	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;

}