# Copyright (c) 2021-2025, PostgreSQL Global Development Group

# Test success or failure of the incremental (table-driven) JSON parser
# for a variety of small inputs.

use strict;
use warnings FATAL => 'all';

use PostgreSQL::Test::Utils;
use Test::More;

use File::Temp qw(tempfile);

my $dir = PostgreSQL::Test::Utils::tempdir;
my @exe;

sub test
{
	local $Test::Builder::Level = $Test::Builder::Level + 1;

	my ($name, $json, %params) = @_;
	my $chunk = length($json);

	# Test the input with chunk sizes from max(input_size, 64) down to 1

	if ($chunk > 64)
	{
		$chunk = 64;
	}

	my ($fh, $fname) = tempfile(DIR => $dir);
	print $fh "$json";
	close($fh);

	# The -r mode runs the parser in a loop, with output separated by nulls.
	# Unpack that as a list of null-terminated ASCII strings (Z*) and check that
	# each run produces the same result.
	my ($all_stdout, $all_stderr) =
	  run_command([ @exe, "-r", $chunk, $fname ]);

	my @stdout = unpack("(Z*)*", $all_stdout);
	my @stderr = unpack("(Z*)*", $all_stderr);

	is(scalar @stdout, $chunk, "$name: stdout has correct number of entries");
	is(scalar @stderr, $chunk, "$name: stderr has correct number of entries");

	my $i = 0;

	foreach my $size (reverse(1 .. $chunk))
	{
		if (defined($params{error}))
		{
			unlike($stdout[$i], qr/SUCCESS/,
				"$name, chunk size $size: test fails");
			like($stderr[$i], $params{error},
				"$name, chunk size $size: correct error output");
		}
		else
		{
			like($stdout[$i], qr/SUCCESS/,
				"$name, chunk size $size: test succeeds");
			is($stderr[$i], "", "$name, chunk size $size: no error output");
		}

		$i++;
	}
}

my @exes = (
	[ "test_json_parser_incremental", ],
	[ "test_json_parser_incremental", "-o", ],
	[ "test_json_parser_incremental_shlib", ],
	[ "test_json_parser_incremental_shlib", "-o", ]);

foreach (@exes)
{
	@exe = @$_;
	note "testing executable @exe";

	test("number", "12345");
	test("string", '"hello"');
	test("false", "false");
	test("true", "true");
	test("null", "null");
	test("empty object", "{}");
	test("empty array", "[]");
	test("array with number", "[12345]");
	test("array with numbers", "[12345,67890]");
	test("array with null", "[null]");
	test("array with string", '["hello"]');
	test("array with boolean", '[false]');
	test("single pair", '{"key": "value"}');
	test("heavily nested array", "[" x 3200 . "]" x 3200);
	test("serial escapes", '"\\\\\\\\\\\\\\\\"');
	test("interrupted escapes", '"\\\\\\"\\\\\\\\\\"\\\\"');
	test("whitespace", '     ""     ');

	test("unclosed empty object",
		"{", error => qr/input string ended unexpectedly/);
	test("bad key", "{{",
		error => qr/Expected string or "}", but found "\{"/);
	test("bad key", "{{}",
		error => qr/Expected string or "}", but found "\{"/);
	test("numeric key", "{1234: 2}",
		error => qr/Expected string or "}", but found "1234"/);
	test(
		"second numeric key",
		'{"a": "a", 1234: 2}',
		error => qr/Expected string, but found "1234"/);
	test(
		"unclosed object with pair",
		'{"key": "value"',
		error => qr/input string ended unexpectedly/);
	test("missing key value",
		'{"key": }', error => qr/Expected JSON value, but found "}"/);
	test(
		"missing colon",
		'{"key" 12345}',
		error => qr/Expected ":", but found "12345"/);
	test(
		"missing comma",
		'{"key": 12345 12345}',
		error => qr/Expected "," or "}", but found "12345"/);
	test("overnested array",
		"[" x 6401, error => qr/maximum permitted depth is 6400/);
	test("overclosed array",
		"[]]", error => qr/Expected end of input, but found "]"/);
	test("unexpected token in array",
		"[ }}} ]", error => qr/Expected array element or "]", but found "}"/);
	test("junk punctuation", "[ ||| ]", error => qr/Token "|" is invalid/);
	test("missing comma in array",
		"[123 123]", error => qr/Expected "," or "]", but found "123"/);
	test("misspelled boolean", "tru", error => qr/Token "tru" is invalid/);
	test(
		"misspelled boolean in array",
		"[tru]",
		error => qr/Token "tru" is invalid/);
	test(
		"smashed top-level scalar",
		"12zz",
		error => qr/Token "12zz" is invalid/);
	test(
		"smashed scalar in array",
		"[12zz]",
		error => qr/Token "12zz" is invalid/);
	test(
		"unknown escape sequence",
		'"hello\vworld"',
		error => qr/Escape sequence "\\v" is invalid/);
	test("unescaped control",
		"\"hello\tworld\"",
		error => qr/Character with value 0x09 must be escaped/);
	test(
		"incorrect escape count",
		'"\\\\\\\\\\\\\\"',
		error => qr/Token ""\\\\\\\\\\\\\\"" is invalid/);

	# Case with three bytes: double-quote, backslash and <f5>.
	# Both invalid-token and invalid-escape are possible errors, because for
	# smaller chunk sizes the incremental parser skips the string parsing when
	# it cannot find an ending quote.
	test("incomplete UTF-8 sequence",
		"\"\\\x{F5}",
		error => qr/(Token|Escape sequence) ""?\\\x{F5}" is invalid/);
}

done_testing();