strcspn_test.c

/*-
 * Copyright (c) 2023 The FreeBSD Foundation
 *
 * This software was developed by Robert Clausecker <[email protected]>
 * under sponsorship from the FreeBSD Foundation.
 *
 * 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 AUTHOR 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 AUTHOR 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 <atf-c.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <string.h>

enum {
	MAXALIGN = 16,	/* test all offsets from this alignment */
	MAXBUF = 64,	/* test up to this buffer length */
};

enum { NOMATCH, MATCH };

#ifdef STRSPN
#define STRXSPN strspn
#else
#define STRXSPN strcspn
#endif

static void
testcase(char *buf, size_t buflen, char *set, size_t setlen, int want_match)
{
	size_t i, outcome, expected;

	assert(setlen < UCHAR_MAX - 2);

	for (i = 0; i < buflen; i++)
#ifdef STRSPN
		buf[i] = UCHAR_MAX - i % (setlen > 0 ? setlen : 1);
#else /* strcspn */
		buf[i] = 1 + i % (UCHAR_MAX - setlen - 1);
#endif

	buf[i] = '\0';

	for (i = 0; i < setlen; i++)
		set[i] = UCHAR_MAX - i;

	set[i] = '\0';

#ifdef STRSPN
	if (setlen == 0)
		expected = 0;
	else if (want_match == MATCH && buflen > 0) {
		buf[buflen - 1] = 1;
		expected = buflen - 1;
	} else
		expected = buflen;
#else /* strcspn */
	if (want_match == MATCH && buflen > 0 && setlen > 0) {
		buf[buflen - 1] = UCHAR_MAX;
		expected = buflen - 1;
	} else
		expected = buflen;
#endif

	outcome = STRXSPN(buf, set);
	ATF_CHECK_EQ_MSG(expected, outcome, "%s(%p[%zu], %p[%zu]) = %zu != %zu",
	    __XSTRING(STRXSPN), buf, buflen, set, setlen, outcome, expected);
}

/* test set with all alignments and lengths of buf */
static void
test_buf_alignments(char *set, size_t setlen, int want_match)
{
	char buf[MAXALIGN + MAXBUF + 1];
	size_t i, j;

	for (i = 0; i < MAXALIGN; i++)
		for (j = 0; j <= MAXBUF; j++)
			testcase(buf + i, j, set, setlen, want_match);
}

/* test buf with all alignments and lengths of set */
static void
test_set_alignments(char *buf, size_t buflen, int want_match)
{
	char set[MAXALIGN + MAXBUF + 1];
	size_t i, j;

	for (i = 0; i < MAXALIGN; i++)
		for (j = 0; j <= MAXBUF; j++)
			testcase(buf, buflen, set + i, j, want_match);
}

ATF_TC_WITHOUT_HEAD(buf_alignments);
ATF_TC_BODY(buf_alignments, tc)
{
	char set[41];

	test_buf_alignments(set, 0, MATCH);
	test_buf_alignments(set, 1, MATCH);
	test_buf_alignments(set, 5, MATCH);
	test_buf_alignments(set, 20, MATCH);
	test_buf_alignments(set, 40, MATCH);

	test_buf_alignments(set, 0, NOMATCH);
	test_buf_alignments(set, 1, NOMATCH);
	test_buf_alignments(set, 5, NOMATCH);
	test_buf_alignments(set, 20, NOMATCH);
	test_buf_alignments(set, 40, NOMATCH);
}

ATF_TC_WITHOUT_HEAD(set_alignments);
ATF_TC_BODY(set_alignments, tc)
{
	char buf[31];

	test_set_alignments(buf,  0, MATCH);
	test_set_alignments(buf, 10, MATCH);
	test_set_alignments(buf, 20, MATCH);
	test_set_alignments(buf, 30, MATCH);

	test_set_alignments(buf,  0, NOMATCH);
	test_set_alignments(buf, 10, NOMATCH);
	test_set_alignments(buf, 20, NOMATCH);
	test_set_alignments(buf, 30, NOMATCH);
}

#ifndef STRSPN
/* test all positions in which set could match buf */
static void
test_match_positions(char *buf, char *set, size_t buflen, size_t setlen)
{
	size_t i, j, outcome;

	memset(buf, '-', buflen);

	for (i = 0; i < setlen; i++)
		set[i] = 'A' + i;

	buf[buflen] = '\0';
	set[setlen] = '\0';

	/*
	 * Check for (mis)match at buffer position i
	 * against set position j.
	 */
	for (i = 0; i < buflen; i++) {
		for (j = 0; j < setlen; j++) {
			buf[i] = set[j];

			outcome = strcspn(buf, set);
			ATF_CHECK_EQ_MSG(i, outcome,
			    "strcspn(\"%s\", \"%s\") = %zu != %zu",
			    buf, set, outcome, i);
		}

		buf[i] = '-';
	}
}

ATF_TC_WITHOUT_HEAD(match_positions);
ATF_TC_BODY(match_positions, tc)
{
	char buf[129], set[65];

	test_match_positions(buf, set, 128, 64);
	test_match_positions(buf, set, 64, 64);
	test_match_positions(buf, set, 32, 64);
	test_match_positions(buf, set, 16, 64);
	test_match_positions(buf, set, 8, 64);
	test_match_positions(buf, set, 128, 32);
	test_match_positions(buf, set, 64, 32);
	test_match_positions(buf, set, 32, 32);
	test_match_positions(buf, set, 16, 32);
	test_match_positions(buf, set, 8, 32);
	test_match_positions(buf, set, 128, 16);
	test_match_positions(buf, set, 64, 16);
	test_match_positions(buf, set, 32, 16);
	test_match_positions(buf, set, 16, 16);
	test_match_positions(buf, set, 8, 16);
	test_match_positions(buf, set, 128, 8);
	test_match_positions(buf, set, 64, 8);
	test_match_positions(buf, set, 32, 8);
	test_match_positions(buf, set, 16, 8);
	test_match_positions(buf, set, 8, 8);
}

/* if there are two matches, check that the earlier match is taken */
static void
test_match_order(char *buf, char *set, size_t buflen, size_t setlen)
{
	size_t i, j, k, l, outcome;

	memset(buf, '-', buflen);

	for (i = 0; i < setlen; i++)
		set[i] = 'A' + i;

	buf[buflen] = '\0';
	set[setlen] = '\0';

	for (i = 0; i < setlen; i++)
		for (j = 0; j < setlen; j++)
			for (k = 0; k + 1 < buflen; k++)
				for (l = k + 1; l < buflen; l++) {
					buf[k] = set[i];
					buf[l] = set[j];
					outcome = strcspn(buf, set);
					ATF_CHECK_EQ_MSG(k, outcome,
					    "strcspn(\"%s\", \"%s\") = %zu != %zu",
					    buf, set, outcome, k);
					buf[k] = '-';
					buf[l] = '-';
				}
}

ATF_TC_WITHOUT_HEAD(match_order);
ATF_TC_BODY(match_order, tc)
{
	char buf[33], set[65];

	test_match_order(buf, set, 32, 64);
	test_match_order(buf, set, 16, 64);
	test_match_order(buf, set, 8, 64);
	test_match_order(buf, set, 32, 32);
	test_match_order(buf, set, 16, 32);
	test_match_order(buf, set, 8, 32);
	test_match_order(buf, set, 32, 16);
	test_match_order(buf, set, 16, 16);
	test_match_order(buf, set, 8, 16);
	test_match_order(buf, set, 32, 8);
	test_match_order(buf, set, 16, 8);
	test_match_order(buf, set, 8, 8);
}
#endif /* !defined(STRSPN) */

ATF_TP_ADD_TCS(tp)
{
	ATF_TP_ADD_TC(tp, buf_alignments);
	ATF_TP_ADD_TC(tp, set_alignments);
#ifndef STRSPN
	ATF_TP_ADD_TC(tp, match_positions);
	ATF_TP_ADD_TC(tp, match_order);
#endif

	return (atf_no_error());
}