/*
 * Copyright (c) 2026 Jitendra Bhati
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

/*
 * Tests for fts_children().
 */

#include <sys/stat.h>

#include <errno.h>
#include <fcntl.h>
#include <fts.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <atf-c.h>

static int
fts_lexical_compar(const FTSENT * const *a, const FTSENT * const *b)
{
	return (strcmp((*a)->fts_name, (*b)->fts_name));
}

/*
 * fts_children() before fts_read() returns the list of root entries.
 */
ATF_TC(before_read);
ATF_TC_HEAD(before_read, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "fts_children before fts_read returns root entry list");
}
ATF_TC_BODY(before_read, tc)
{
	char *paths[] = { "dir", NULL };
	FTS *fts;
	FTSENT *children, *p;
	int count;

	ATF_REQUIRE_EQ(0, mkdir("dir", 0755));
	ATF_REQUIRE_EQ(0, close(creat("dir/a", 0644)));

	ATF_REQUIRE((fts = fts_open(paths, FTS_PHYSICAL, NULL)) != NULL);

	errno = 0;
	children = fts_children(fts, 0);
	ATF_REQUIRE_MSG(children != NULL,
	    "fts_children before fts_read must return the root list");
	ATF_CHECK_EQ(0, errno);

	count = 0;
	for (p = children; p != NULL; p = p->fts_link) {
		ATF_CHECK_EQ_MSG(FTS_D, p->fts_info,
		    "root entry should be FTS_D, got %d", p->fts_info);
		count++;
	}
	ATF_CHECK_EQ_MSG(1, count,
	    "expected 1 root entry, found %d", count);

	ATF_REQUIRE_EQ_MSG(0, fts_close(fts), "fts_close(): %m");
}

/*
 * fts_children() on an empty directory returns NULL with errno == 0.
 * errno=0 distinguishes "empty" from an actual error.
 */
ATF_TC(empty_dir);
ATF_TC_HEAD(empty_dir, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "fts_children on empty directory returns NULL with errno 0");
}
ATF_TC_BODY(empty_dir, tc)
{
	char *paths[] = { "dir", NULL };
	FTS *fts;
	FTSENT *ent, *children;

	ATF_REQUIRE_EQ(0, mkdir("dir", 0755));

	ATF_REQUIRE((fts = fts_open(paths, FTS_PHYSICAL, NULL)) != NULL);

	ent = fts_read(fts);
	ATF_REQUIRE(ent != NULL);
	ATF_REQUIRE_EQ_MSG(FTS_D, ent->fts_info,
	    "expected FTS_D, got %d", ent->fts_info);

	errno = 1;	/* sentinel — fts_children must clear this */
	children = fts_children(fts, 0);
	ATF_CHECK_MSG(children == NULL,
	    "fts_children on empty dir must return NULL");
	ATF_CHECK_EQ_MSG(0, errno,
	    "fts_children on empty dir must set errno=0, got %d", errno);

	ATF_REQUIRE_EQ_MSG(0, fts_close(fts), "fts_close(): %m");
}

/*
 * fts_children() on a non-empty directory returns a linked list of all
 * children in comparator order.
 */
ATF_TC(nonempty_dir);
ATF_TC_HEAD(nonempty_dir, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "fts_children on non-empty directory returns all children");
}
ATF_TC_BODY(nonempty_dir, tc)
{
	static const char *expected[] = { "a", "b", "c", NULL };
	char *paths[] = { "dir", NULL };
	FTS *fts;
	FTSENT *ent, *children, *p;
	int i;

	ATF_REQUIRE_EQ(0, mkdir("dir", 0755));
	ATF_REQUIRE_EQ(0, close(creat("dir/a", 0644)));
	ATF_REQUIRE_EQ(0, close(creat("dir/b", 0644)));
	ATF_REQUIRE_EQ(0, close(creat("dir/c", 0644)));

	ATF_REQUIRE((fts = fts_open(paths, FTS_PHYSICAL,
	    fts_lexical_compar)) != NULL);

	ent = fts_read(fts);
	ATF_REQUIRE(ent != NULL);
	ATF_REQUIRE_EQ(FTS_D, ent->fts_info);

	children = fts_children(fts, 0);
	ATF_REQUIRE_MSG(children != NULL, "fts_children(): %m");

	i = 0;
	for (p = children; p != NULL; p = p->fts_link, i++) {
		ATF_REQUIRE_MSG(expected[i] != NULL,
		    "more children returned than expected");
		ATF_CHECK_STREQ(expected[i], p->fts_name);
		ATF_CHECK_EQ(FTS_F, p->fts_info);
	}
	ATF_CHECK_MSG(expected[i] == NULL,
	    "fewer children returned than expected");

	ATF_REQUIRE_EQ_MSG(0, fts_close(fts), "fts_close(): %m");
}

/*
 * fts_children() called twice on the same FTS_D node must return an
 * equivalent list both times.
 */
ATF_TC(called_twice);
ATF_TC_HEAD(called_twice, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "fts_children called twice returns equivalent results");
}
ATF_TC_BODY(called_twice, tc)
{
	char *paths[] = { "dir", NULL };
	FTS *fts;
	FTSENT *ent, *first, *second, *p;
	int count1, count2;

	ATF_REQUIRE_EQ(0, mkdir("dir", 0755));
	ATF_REQUIRE_EQ(0, close(creat("dir/x", 0644)));
	ATF_REQUIRE_EQ(0, close(creat("dir/y", 0644)));

	ATF_REQUIRE((fts = fts_open(paths, FTS_PHYSICAL, NULL)) != NULL);

	ent = fts_read(fts);
	ATF_REQUIRE(ent != NULL);
	ATF_REQUIRE_EQ(FTS_D, ent->fts_info);

	first = fts_children(fts, 0);
	ATF_REQUIRE_MSG(first != NULL, "first fts_children call: %m");

	count1 = 0;
	for (p = first; p != NULL; p = p->fts_link)
		count1++;

	/*
	 * The second call frees the first list and rebuilds.  Do not
	 * dereference 'first' after this point — it has been freed.
	 */
	second = fts_children(fts, 0);
	ATF_REQUIRE_MSG(second != NULL, "second fts_children call: %m");

	count2 = 0;
	for (p = second; p != NULL; p = p->fts_link)
		count2++;

	ATF_CHECK_EQ_MSG(count1, count2,
	    "first call returned %d children, second returned %d",
	    count1, count2);
	ATF_CHECK_EQ(2, count2);

	ATF_REQUIRE_EQ_MSG(0, fts_close(fts), "fts_close(): %m");
}

/*
 * fts_children(FTS_NAMEONLY): only fts_name and fts_namelen are filled.
 * fts_info is FTS_NSOK for every entry.
 */
ATF_TC(nameonly);
ATF_TC_HEAD(nameonly, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "FTS_NAMEONLY fills only fts_name, fts_info is FTS_NSOK");
}
ATF_TC_BODY(nameonly, tc)
{
	char *paths[] = { "dir", NULL };
	FTS *fts;
	FTSENT *ent, *children, *p;
	int count;

	ATF_REQUIRE_EQ(0, mkdir("dir", 0755));
	ATF_REQUIRE_EQ(0, close(creat("dir/f1", 0644)));
	ATF_REQUIRE_EQ(0, close(creat("dir/f2", 0644)));

	ATF_REQUIRE((fts = fts_open(paths, FTS_PHYSICAL, NULL)) != NULL);

	ent = fts_read(fts);
	ATF_REQUIRE(ent != NULL);
	ATF_REQUIRE_EQ(FTS_D, ent->fts_info);

	children = fts_children(fts, FTS_NAMEONLY);
	ATF_REQUIRE_MSG(children != NULL, "fts_children(FTS_NAMEONLY): %m");

	count = 0;
	for (p = children; p != NULL; p = p->fts_link) {
		ATF_CHECK_MSG(p->fts_name[0] != '\0',
		    "FTS_NAMEONLY: fts_name is empty");
		ATF_CHECK_EQ(strlen(p->fts_name), p->fts_namelen);
		ATF_CHECK_EQ_MSG(FTS_NSOK, p->fts_info,
		    "FTS_NAMEONLY: expected FTS_NSOK, got %d", p->fts_info);
		count++;
	}
	ATF_CHECK_EQ(2, count);

	/* Normal traversal must still work after FTS_NAMEONLY. */
	while (fts_read(fts) != NULL)
		;
	ATF_CHECK_EQ_MSG(0, errno,
	    "traversal after FTS_NAMEONLY ended with errno %d", errno);

	ATF_REQUIRE_EQ_MSG(0, fts_close(fts), "fts_close(): %m");
}

/*
 * fts_children() on a non-directory node must return NULL with errno == 0.
 */
ATF_TC(nondirectory);
ATF_TC_HEAD(nondirectory, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "fts_children on a non-directory node returns NULL with errno 0");
}
ATF_TC_BODY(nondirectory, tc)
{
	char *paths[] = { "dir", NULL };
	FTS *fts;
	FTSENT *ent;

	ATF_REQUIRE_EQ(0, mkdir("dir", 0755));
	ATF_REQUIRE_EQ(0, close(creat("dir/file", 0644)));

	ATF_REQUIRE((fts = fts_open(paths, FTS_PHYSICAL, NULL)) != NULL);

	ent = fts_read(fts);	/* FTS_D dir */
	ATF_REQUIRE(ent != NULL);
	ATF_REQUIRE_EQ(FTS_D, ent->fts_info);

	ent = fts_read(fts);	/* FTS_F file */
	ATF_REQUIRE(ent != NULL);
	ATF_REQUIRE_EQ(FTS_F, ent->fts_info);

	errno = 1;
	ATF_CHECK_MSG(fts_children(fts, 0) == NULL,
	    "fts_children on FTS_F must return NULL");
	ATF_CHECK_EQ_MSG(0, errno,
	    "fts_children on FTS_F must set errno=0, got %d", errno);

	ATF_REQUIRE_EQ_MSG(0, fts_close(fts), "fts_close(): %m");
}

/*
 * fts_children() with an invalid options value must return NULL with
 * errno == EINVAL.
 */
ATF_TC(invalid_options);
ATF_TC_HEAD(invalid_options, tc)
{
	atf_tc_set_md_var(tc, "descr",
	    "fts_children with invalid options returns NULL with EINVAL");
}
ATF_TC_BODY(invalid_options, tc)
{
	char *paths[] = { ".", NULL };
	FTS *fts;

	ATF_REQUIRE((fts = fts_open(paths, FTS_PHYSICAL, NULL)) != NULL);

	ATF_REQUIRE_ERRNO(EINVAL, fts_children(fts, 99) == NULL);

	ATF_REQUIRE_EQ_MSG(0, fts_close(fts), "fts_close(): %m");
}

ATF_TP_ADD_TCS(tp)
{
	ATF_TP_ADD_TC(tp, before_read);
	ATF_TP_ADD_TC(tp, empty_dir);
	ATF_TP_ADD_TC(tp, nonempty_dir);
	ATF_TP_ADD_TC(tp, called_twice);
	ATF_TP_ADD_TC(tp, nameonly);
	ATF_TP_ADD_TC(tp, nondirectory);
	ATF_TP_ADD_TC(tp, invalid_options);

	return (atf_no_error());
}