[babeltrace.git] / tests / plugins / sink.text.pretty / test_enum

#!/bin/bash
#
# SPDX-License-Identifier: GPL-2.0-only
#
# Copyright (C) 2020 Geneviève Bastien <gbastien@versatic.net>
#
# This file tests pretty printing in details some event classes that are
# not all covered by the main babeltrace tests with traces.
SH_TAP=1

if [ -n "${BT_TESTS_SRCDIR:-}" ]; then
	UTILSSH="$BT_TESTS_SRCDIR/utils/utils.sh"
else
	UTILSSH="$(dirname "$0")/../../utils/utils.sh"
fi

# shellcheck source=../../utils/utils.sh
source "$UTILSSH"

data_dir="$BT_TESTS_DATADIR/plugins/sink.text.pretty"
temp_stdout_expected_file=$(mktemp -t test_pretty_expected_stdout.XXXXXX)

plan_tests 31

function compare_enum_sorted
{
	local expected_file="$1"
	local actual_file="$2"

	# The order in which enum labels are printed by a `sink.text.pretty`
	# component directly depends on the order in which mappings were added
	# to the enum field class in the source component. This order should
	# not be relied on when testing. Relying on it caused problems with
	# Python component classes because different versions of Python sort
	# data structures differently (e.g. dictionaries are insertion sorted
	# since Python 3.7).

	run_python_bt2 "${BT_TESTS_PYTHON_BIN}" "${BT_TESTS_SRCDIR}/utils/python/split_sort_compare.py" \
		"$(cat "$expected_file")" "$(cat "$actual_file")"
}

function run_test
{
	local test_name=$1
	local expected_to_fail="$2"
	local value="$3"
	local expected_stdout_file="$4"
	local actual_stdout_file
	local actual_stderr_file
	local ret=0
	local local_args=(
		"--plugin-path" "$data_dir"
		"-c" "src.test-pretty.TheSourceOfProblems"
		"-p" "enum-values=\"$enum_values\""
		"-p" "value=$value"
		"-p" "enum-signed=$enum_signed"
		"-c" "sink.text.pretty"
		"-p" "print-enum-flags=true"
	)

	actual_stdout_file="$(mktemp -t actual_pretty_stdout.XXXXXX)"
	actual_stderr_file="$(mktemp -t actual_pretty_stderr.XXXXXX)"

	bt_cli "$actual_stdout_file" "$actual_stderr_file" "${local_args[@]}"

	compare_enum_sorted "$expected_stdout_file" "$actual_stdout_file"
	ret_stdout=$?

	bt_diff /dev/null "$actual_stderr_file"
	ret_stderr=$?

	if ((ret_stdout != 0 || ret_stderr != 0)); then
		ret=1
	fi

	rm -f "$actual_stdout_file" "$actual_stderr_file"

	if [ "$expected_to_fail" = "1" ]; then
		isnt $ret 0 "$test_name signed=$enum_signed with value=$value doesn't match as expected"
	else
		ok $ret "$test_name signed=$enum_signed with value=$value matches"
	fi

}

function test_normal_enum {
	test_name="Normal enum"
	enum_signed="$1"
	enum_values="single,1,1 single2,2,2 single3,4,4 range,4,8 range2,15,20"

	# Hit a single value
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "single" : container = 1 ) }
	END
	run_test "$test_name" 0 1 "$temp_stdout_expected_file"

	# Hit a single range
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "range" : container = 7 ) }
	END
	run_test "$test_name" 0 7 "$temp_stdout_expected_file"

	# Hit a range and a value
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( { "single3", "range" } : container = 4 ) }
	END
	run_test "$test_name" 0 4 "$temp_stdout_expected_file"

	# Hit a range and a value
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( { "NOT_A_LABEL", "DOESNT_EXIST" } : container = 4 ) }
	END
	run_test "$test_name" 1 4 "$temp_stdout_expected_file"

	# Unknown
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( <unknown> : container = 21 ) }
	END
	run_test "$test_name" 0 21 "$temp_stdout_expected_file"

	# Unknown but with bits with a value, but range larger than 1 element
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( <unknown> : container = 12 ) }
	END
	run_test "$test_name" 0 12 "$temp_stdout_expected_file"

	# Unknown value of 0
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( <unknown> : container = 0 ) }
	END
	run_test "$test_name" 0 0 "$temp_stdout_expected_file"
}

function test_normal_enum_negative {
	test_name="Normal enum with negative value"
	enum_signed="true"
	enum_values="zero,0,0 single,1,1 single2,2,2 single3,4,4 range,4,8 negative,-1,-1 rangeNegative,-6,-2"

	# Hit a single negative value
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "negative" : container = -1 ) }
	END
	run_test "$test_name" 0 -1 "$temp_stdout_expected_file"

	# Hit a single negative range
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "rangeNegative" : container = -6 ) }
	END
	run_test "$test_name" 0 -6 "$temp_stdout_expected_file"

	# Unknown
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( <unknown> : container = -7 ) }
	END
	run_test "$test_name" 0 -7 "$temp_stdout_expected_file"

	# value of 0
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "zero" : container = 0 ) }
	END
	run_test "$test_name" 0 0 "$temp_stdout_expected_file"
}

function test_bit_flag_enum {
	test_name="Bit flag enum"
	enum_signed="false"
	enum_values="bit0,1,1 bit0bis,1,1 bit1,2,2 bit3,4,4 bit4,8,8 bit5,16,16 bit5,32,32"

	# Single value hit
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "bit1" : container = 2 ) }
	END
	run_test "$test_name" 0 2 "$temp_stdout_expected_file"

	# Multiple flags set
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "bit3" | "bit4" : container = 12 ) }
	END
	run_test "$test_name" 0 12 "$temp_stdout_expected_file"

	# Some unknown bit
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( <unknown> : container = 68 ) }
	END
	run_test "$test_name" 0 68 "$temp_stdout_expected_file"

	# Multiple labels for bit 0
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( { "bit0", "bit0bis" } : container = 1 ) }
	END
	run_test "$test_name" 0 1 "$temp_stdout_expected_file"

	# Two labels for bit 0 and one label for bit 1
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( { "bit0", "bit0bis" } | "bit1" : container = 3 ) }
	END
	run_test "$test_name" 0 3 "$temp_stdout_expected_file"

	# Single label for bit 0
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "bit5" | "bit5" : container = 48 ) }
	END
	run_test "$test_name" 0 48 "$temp_stdout_expected_file"

	# negative value
	enum_signed="true"
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( <unknown> : container = -1 ) }
	END
	run_test "$test_name" 0 -1 "$temp_stdout_expected_file"
}

function test_mixed_enum {
	test_name="Mixed enum bits at beginning"
	enum_signed="false"
	enum_values="bit0,1,1 bit1,2,2 bit2,4,4 bit3,8,8 bit4,16,16 range,32,44 singleValue,45,45"

	# Value with bit fields
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "bit0" | "bit1" | "bit2" | "bit3" | "bit4" : container = 31 ) }
	END
	run_test "$test_name" 0 31 "$temp_stdout_expected_file"

	# A value with some bit flags set, but within another range
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "range" : container = 36 ) }
	END
	run_test "$test_name" 0 36 "$temp_stdout_expected_file"

	# A value with some bit flags set, but corresponding to another value
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "singleValue" : container = 45 ) }
	END
	run_test "$test_name" 0 45 "$temp_stdout_expected_file"

	# Value above the ranges
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( <unknown> : container = 46 ) }
	END
	run_test "$test_name" 0 46 "$temp_stdout_expected_file"

	# Since low values are often powers of 2, they may be considered bit flags too
	test_name="Mixed enum bits at end"
	enum_signed="false"
	enum_values="val1,1,1 val2,2,2 val3,3,3 val4,4,4 val5,5,5 bit3,8,8 bit4,16,16 bit5,32,32"

	# Value with bit fields
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "bit4" : container = 16 ) }
	END
	run_test "$test_name" 0 16 "$temp_stdout_expected_file"

	# Value with a bit field set both at beginning and end
	cat <<- 'END' > "$temp_stdout_expected_file"
	with_enum: { enum_field = ( "val1" | "bit4" : container = 17 ) }
	END
	run_test "$test_name" 0 17 "$temp_stdout_expected_file"
}

# Enumerations tests
test_normal_enum "false"
test_normal_enum "true"
test_normal_enum_negative
test_bit_flag_enum
test_mixed_enum

rm -f "$temp_stdout_expected_file"
Commit	Line	Data
ed30eb8d GB	1	#!/bin/bash
	2	#
	3	# SPDX-License-Identifier: GPL-2.0-only
	4	#
	5	# Copyright (C) 2020 Geneviève Bastien <gbastien@versatic.net>
	6	#
	7	# This file tests pretty printing in details some event classes that are
	8	# not all covered by the main babeltrace tests with traces.
	9	SH_TAP=1
	10
75e396f6	11	if [ -n "${BT_TESTS_SRCDIR:-}" ]; then
ed30eb8d GB	12	UTILSSH="$BT_TESTS_SRCDIR/utils/utils.sh"
	13	else
	14	UTILSSH="$(dirname "$0")/../../utils/utils.sh"
	15	fi
	16
	17	# shellcheck source=../../utils/utils.sh
	18	source "$UTILSSH"
	19
	20	data_dir="$BT_TESTS_DATADIR/plugins/sink.text.pretty"
	21	temp_stdout_expected_file=$(mktemp -t test_pretty_expected_stdout.XXXXXX)
ed30eb8d	22
5288c8ae	23	plan_tests 31
ed30eb8d GB	24
	25	function compare_enum_sorted
	26	{
	27	local expected_file="$1"
	28	local actual_file="$2"
	29
	30	# The order in which enum labels are printed by a `sink.text.pretty`
	31	# component directly depends on the order in which mappings were added
	32	# to the enum field class in the source component. This order should
	33	# not be relied on when testing. Relying on it caused problems with
	34	# Python component classes because different versions of Python sort
	35	# data structures differently (e.g. dictionaries are insertion sorted
	36	# since Python 3.7).
	37
ae5c1a44	38	run_python_bt2 "${BT_TESTS_PYTHON_BIN}" "${BT_TESTS_SRCDIR}/utils/python/split_sort_compare.py" \
ffa209ad	39	"$(cat "$expected_file")" "$(cat "$actual_file")"
ed30eb8d GB	40	}
	41
	42	function run_test
	43	{
	44	local test_name=$1
	45	local expected_to_fail="$2"
	46	local value="$3"
	47	local expected_stdout_file="$4"
ed30eb8d GB	48	local actual_stdout_file
	49	local actual_stderr_file
	50	local ret=0
	51	local local_args=(
	52	"--plugin-path" "$data_dir"
	53	"-c" "src.test-pretty.TheSourceOfProblems"
	54	"-p" "enum-values=\"$enum_values\""
	55	"-p" "value=$value"
	56	"-p" "enum-signed=$enum_signed"
	57	"-c" "sink.text.pretty"
5288c8ae	58	"-p" "print-enum-flags=true"
ed30eb8d GB	59	)
	60
	61	actual_stdout_file="$(mktemp -t actual_pretty_stdout.XXXXXX)"
	62	actual_stderr_file="$(mktemp -t actual_pretty_stderr.XXXXXX)"
	63
	64	bt_cli "$actual_stdout_file" "$actual_stderr_file" "${local_args[@]}"
	65
	66	compare_enum_sorted "$expected_stdout_file" "$actual_stdout_file"
	67	ret_stdout=$?
	68
	69	bt_diff /dev/null "$actual_stderr_file"
	70	ret_stderr=$?
	71
	72	if ((ret_stdout != 0 \|\| ret_stderr != 0)); then
	73	ret=1
	74	fi
	75
	76	rm -f "$actual_stdout_file" "$actual_stderr_file"
	77
ffa209ad	78	if [ "$expected_to_fail" = "1" ]; then
ed30eb8d GB	79	isnt $ret 0 "$test_name signed=$enum_signed with value=$value doesn't match as expected"
	80	else
	81	ok $ret "$test_name signed=$enum_signed with value=$value matches"
	82	fi
	83
	84	}
	85
	86	function test_normal_enum {
	87	test_name="Normal enum"
	88	enum_signed="$1"
	89	enum_values="single,1,1 single2,2,2 single3,4,4 range,4,8 range2,15,20"
	90
	91	# Hit a single value
	92	cat <<- 'END' > "$temp_stdout_expected_file"
	93	with_enum: { enum_field = ( "single" : container = 1 ) }
	94	END
	95	run_test "$test_name" 0 1 "$temp_stdout_expected_file"
	96
	97	# Hit a single range
	98	cat <<- 'END' > "$temp_stdout_expected_file"
	99	with_enum: { enum_field = ( "range" : container = 7 ) }
	100	END
	101	run_test "$test_name" 0 7 "$temp_stdout_expected_file"
	102
5288c8ae GB	103	# Hit a range and a value
	104	cat <<- 'END' > "$temp_stdout_expected_file"
	105	with_enum: { enum_field = ( { "single3", "range" } : container = 4 ) }
	106	END
	107	run_test "$test_name" 0 4 "$temp_stdout_expected_file"
	108
	109	# Hit a range and a value
	110	cat <<- 'END' > "$temp_stdout_expected_file"
	111	with_enum: { enum_field = ( { "NOT_A_LABEL", "DOESNT_EXIST" } : container = 4 ) }
	112	END
	113	run_test "$test_name" 1 4 "$temp_stdout_expected_file"
	114
ed30eb8d GB	115	# Unknown
	116	cat <<- 'END' > "$temp_stdout_expected_file"
	117	with_enum: { enum_field = ( <unknown> : container = 21 ) }
	118	END
	119	run_test "$test_name" 0 21 "$temp_stdout_expected_file"
	120
	121	# Unknown but with bits with a value, but range larger than 1 element
	122	cat <<- 'END' > "$temp_stdout_expected_file"
	123	with_enum: { enum_field = ( <unknown> : container = 12 ) }
	124	END
	125	run_test "$test_name" 0 12 "$temp_stdout_expected_file"
	126
	127	# Unknown value of 0
	128	cat <<- 'END' > "$temp_stdout_expected_file"
	129	with_enum: { enum_field = ( <unknown> : container = 0 ) }
	130	END
	131	run_test "$test_name" 0 0 "$temp_stdout_expected_file"
	132	}
	133
	134	function test_normal_enum_negative {
	135	test_name="Normal enum with negative value"
	136	enum_signed="true"
	137	enum_values="zero,0,0 single,1,1 single2,2,2 single3,4,4 range,4,8 negative,-1,-1 rangeNegative,-6,-2"
	138
	139	# Hit a single negative value
	140	cat <<- 'END' > "$temp_stdout_expected_file"
	141	with_enum: { enum_field = ( "negative" : container = -1 ) }
	142	END
	143	run_test "$test_name" 0 -1 "$temp_stdout_expected_file"
	144
	145	# Hit a single negative range
	146	cat <<- 'END' > "$temp_stdout_expected_file"
	147	with_enum: { enum_field = ( "rangeNegative" : container = -6 ) }
	148	END
	149	run_test "$test_name" 0 -6 "$temp_stdout_expected_file"
	150
	151	# Unknown
	152	cat <<- 'END' > "$temp_stdout_expected_file"
	153	with_enum: { enum_field = ( <unknown> : container = -7 ) }
	154	END
	155	run_test "$test_name" 0 -7 "$temp_stdout_expected_file"
	156
	157	# value of 0
	158	cat <<- 'END' > "$temp_stdout_expected_file"
	159	with_enum: { enum_field = ( "zero" : container = 0 ) }
	160	END
	161	run_test "$test_name" 0 0 "$temp_stdout_expected_file"
	162	}
	163
5288c8ae GB	164	function test_bit_flag_enum {
	165	test_name="Bit flag enum"
	166	enum_signed="false"
	167	enum_values="bit0,1,1 bit0bis,1,1 bit1,2,2 bit3,4,4 bit4,8,8 bit5,16,16 bit5,32,32"
	168
	169	# Single value hit
	170	cat <<- 'END' > "$temp_stdout_expected_file"
	171	with_enum: { enum_field = ( "bit1" : container = 2 ) }
	172	END
	173	run_test "$test_name" 0 2 "$temp_stdout_expected_file"
	174
	175	# Multiple flags set
	176	cat <<- 'END' > "$temp_stdout_expected_file"
	177	with_enum: { enum_field = ( "bit3" \| "bit4" : container = 12 ) }
	178	END
	179	run_test "$test_name" 0 12 "$temp_stdout_expected_file"
	180
	181	# Some unknown bit
	182	cat <<- 'END' > "$temp_stdout_expected_file"
	183	with_enum: { enum_field = ( <unknown> : container = 68 ) }
	184	END
	185	run_test "$test_name" 0 68 "$temp_stdout_expected_file"
	186
	187	# Multiple labels for bit 0
	188	cat <<- 'END' > "$temp_stdout_expected_file"
	189	with_enum: { enum_field = ( { "bit0", "bit0bis" } : container = 1 ) }
	190	END
	191	run_test "$test_name" 0 1 "$temp_stdout_expected_file"
	192
	193	# Two labels for bit 0 and one label for bit 1
	194	cat <<- 'END' > "$temp_stdout_expected_file"
	195	with_enum: { enum_field = ( { "bit0", "bit0bis" } \| "bit1" : container = 3 ) }
	196	END
	197	run_test "$test_name" 0 3 "$temp_stdout_expected_file"
	198
	199	# Single label for bit 0
	200	cat <<- 'END' > "$temp_stdout_expected_file"
	201	with_enum: { enum_field = ( "bit5" \| "bit5" : container = 48 ) }
	202	END
	203	run_test "$test_name" 0 48 "$temp_stdout_expected_file"
	204
	205	# negative value
	206	enum_signed="true"
	207	cat <<- 'END' > "$temp_stdout_expected_file"
	208	with_enum: { enum_field = ( <unknown> : container = -1 ) }
	209	END
	210	run_test "$test_name" 0 -1 "$temp_stdout_expected_file"
	211	}
	212
	213	function test_mixed_enum {
	214	test_name="Mixed enum bits at beginning"
	215	enum_signed="false"
	216	enum_values="bit0,1,1 bit1,2,2 bit2,4,4 bit3,8,8 bit4,16,16 range,32,44 singleValue,45,45"
	217
	218	# Value with bit fields
	219	cat <<- 'END' > "$temp_stdout_expected_file"
	220	with_enum: { enum_field = ( "bit0" \| "bit1" \| "bit2" \| "bit3" \| "bit4" : container = 31 ) }
	221	END
	222	run_test "$test_name" 0 31 "$temp_stdout_expected_file"
	223
	224	# A value with some bit flags set, but within another range
	225	cat <<- 'END' > "$temp_stdout_expected_file"
	226	with_enum: { enum_field = ( "range" : container = 36 ) }
	227	END
228	run_test "$test_name" 0 36 "$temp_stdout_expected_file"
229
230	# A value with some bit flags set, but corresponding to another value
231	cat <<- 'END' > "$temp_stdout_expected_file"
232	with_enum: { enum_field = ( "singleValue" : container = 45 ) }
233	END
234	run_test "$test_name" 0 45 "$temp_stdout_expected_file"
235
236	# Value above the ranges
237	cat <<- 'END' > "$temp_stdout_expected_file"
238	with_enum: { enum_field = ( <unknown> : container = 46 ) }
239	END
240	run_test "$test_name" 0 46 "$temp_stdout_expected_file"
241
242	# Since low values are often powers of 2, they may be considered bit flags too
243	test_name="Mixed enum bits at end"
244	enum_signed="false"
245	enum_values="val1,1,1 val2,2,2 val3,3,3 val4,4,4 val5,5,5 bit3,8,8 bit4,16,16 bit5,32,32"
246
247	# Value with bit fields
248	cat <<- 'END' > "$temp_stdout_expected_file"
249	with_enum: { enum_field = ( "bit4" : container = 16 ) }
250	END
251	run_test "$test_name" 0 16 "$temp_stdout_expected_file"
252
253	# Value with a bit field set both at beginning and end
254	cat <<- 'END' > "$temp_stdout_expected_file"
255	with_enum: { enum_field = ( "val1" \| "bit4" : container = 17 ) }
256	END
257	run_test "$test_name" 0 17 "$temp_stdout_expected_file"
258	}
259
ed30eb8d GB	260	# Enumerations tests
	261	test_normal_enum "false"
	262	test_normal_enum "true"
	263	test_normal_enum_negative
5288c8ae GB	264	test_bit_flag_enum
5288c8ae GB	265	test_mixed_enum
ed30eb8d	266
ed30eb8d	267	rm -f "$temp_stdout_expected_file"