Files
mercury/tests/hard_coded/test_pretty_printer.exp
Peter Wang 0d5b044452 Fix some problems with non-ASCII strings.
Branches: main

Fix some problems with non-ASCII strings.

compiler/error_util.m:
	Make string formatting routines count code points instead of code
	units.

	Iterate over non-ASCII strings correctly.

compiler/llds_out_data.m:
compiler/stack_layout.m:
	Explicitly count UTF-8 code units when counting the length of strings
	that will be written to C source files, in case the compiler is built
	in a grade which uses some other encoding. (The length argument to
	the `MR_string_const' macro isn't actually used, so that change won't
	have any practical effect.)

compiler/inst_check.m:
compiler/mercury_to_mercury.m:
compiler/structure_reuse.direct.choose_reuse.m:
	Fix some code unit counts which should be code point counts.

compiler/make.m:
	Iterate over non-ASCII characters correctly.

compiler/passes_aux.m:
	Simplify the implementation of `stage_num_str'.

compiler/timestamp.m:
	Make `string_to_timestamp' handle non-ASCII strings cleanly,
	although they should never occur.

compiler/x86_64_out.m:
	Split long comments at code point boundaries.

compiler/elds_to_erlang.m:
compiler/erl_code_gen.m:
compiler/mlds_to_cs.m:
compiler/pickle.m:
compiler/switch_util.m:
	Add some comments relating to non-ASCII characters.

library/parsing_utils.m:
	Fix the string and keyword parsers to work on non-ASCII characters.

library/pprint.m:
library/pretty_printer.m:
	Fix code unit counts which should be code point counts.

library/string.m:
	Add `count_utf8_code_units'.

	Fix the portable implementation of `string.to_char_list' (not
	actually used) to work on non-ASCII strings.

	Make string formatting routines count code points instead of code
	units.

library/term_io.m:
	Use a direct string comparison to check string is non-empty.

tests/general/test_parsing_utils.exp:
tests/general/test_parsing_utils.m:
tests/hard_coded/test_pretty_printer.exp:
tests/hard_coded/test_pretty_printer.m:
	Test non-ASCII strings.
2011-05-17 05:37:30 +00:00

1883 lines
68 KiB
Plaintext

limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
non_canonical_bool(...)
...
...
...
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
{...}
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
100....
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
succ(...)
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
-...
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
1, ...
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(...)
...
...
...
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
{...}
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
100....
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
succ(...)
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
-...
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
1, ...
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
non_canonical_bool(...)
...
...
...
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
{...}
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
100....
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
succ(...)
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
-...
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
1, ...
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(...)
...
...
...
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
{...}
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
100....
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
succ(...)
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
-...
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
1, ...
|----------------------------------------------------------------------------|
limit = triangular(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
non_canonical_bool(...)
...
...
...
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
{...}
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
100....
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
succ(...)
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
-...
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
1, ...
|------------------------------------|
limit = linear(1), max lines = 3, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(...)
...
...
...
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
{...}
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
100....
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
succ(...)
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
-...
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
1, ...
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
non_canonical_bool(...)
...
...
...
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
{...}
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
100....
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
succ(...)
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
-...
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
map([...])
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
1, ...
|------------------------------------|
limit = linear(1), max lines = 10, line width = 38
|------------------------------------|
[...]
|------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(...)
...
...
...
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
{...}
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
100....
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
succ(...)
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
-...
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([...])
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
1, ...
|----------------------------------------------------------------------------|
limit = linear(1), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[...]
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...],
[1, 2, 3, 4, 5, 6, 7, ...],
[1, 2, 3, 4, 5, 6, ...],
...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
100.99.98.97.96........
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
succ(
succ(
succ(
...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
-(-(-(-((... + ...) * ... /
(... * ...)) /
(... / ... * ... + -...)) /
...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), (4 -> "0x4"),
(5 -> "0x5"), (6 -> "0x6"),
...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), (4 -> 4.0), (5 -> 5.0),
(6 -> 6.0), (7 -> 7.0), (8 -> ...),
...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...], [1, 2, 3, 4, 5, 6, 7, ...],
[1, 2, 3, 4, 5, 6, ...], [1, 2, 3, 4, 5, ...], [1, 2, 3, 4, ...],
[1, 2, 3, ...], [1, 2, ...], [1, ...], [...], ...]
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96........
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(...))))))))))
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((... + ...) * ... / (... * ...)) / (... / ... * ... + -...)) /
((x / ... * (... / ...) + -(... / ...)) * ((x + ...) * (... + ...)))) /
((x / x * (x / ...) + -(x / ...)) * ((x + x) * (x + ...)) +
...
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), (4 -> "0x4"), (5 -> "0x5"),
(6 -> "0x6"), (7 -> "0x7"), (8 -> ...), (... -> ...), ...])
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), (4 -> 4.0), (5 -> 5.0), (6 -> 6.0),
(7 -> 7.0), (8 -> ...), (... -> ...), ...])
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...],
[1, 2, 3, 4, 5, 6, 7, ...],
[1, 2, 3, 4, 5, 6, ...],
[1, 2, 3, 4, 5, ...],
[1, 2, 3, 4, ...], [1, 2, 3, ...],
[1, 2, ...], [1, ...], [...], ...]
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
100.99.98.97.96........
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(...))))))))))
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
-(-(-(-((... + ...) * ... /
(... * ...)) /
(... / ... * ... + -...)) /
((x / ... * (... / ...) +
-(... / ...)) *
((x + ...) * (... + ...)))) /
((x / x * (x / ...) + -(x / ...)) *
((x + x) * (x + ...)) +
(x / ... - x - -(... / ...) -
x / ... * (... / ...))))
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), (4 -> "0x4"),
(5 -> "0x5"), (6 -> "0x6"),
(7 -> "0x7"), (8 -> ...),
(... -> ...), ...])
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), (4 -> 4.0), (5 -> 5.0),
(6 -> 6.0), (7 -> 7.0), (8 -> ...),
(... -> ...), ...])
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...], [1, 2, 3, 4, 5, 6, 7, ...],
[1, 2, 3, 4, 5, 6, ...], [1, 2, 3, 4, 5, ...], [1, 2, 3, 4, ...],
[1, 2, 3, ...], [1, 2, ...], [1, ...], [...], ...]
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96........
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(...))))))))))
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((... + ...) * ... / (... * ...)) / (... / ... * ... + -...)) /
((x / ... * (... / ...) + -(... / ...)) * ((x + ...) * (... + ...)))) /
((x / x * (x / ...) + -(x / ...)) * ((x + x) * (x + ...)) +
(x / ... - x - -(... / ...) - x / ... * (... / ...))))
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), (4 -> "0x4"), (5 -> "0x5"),
(6 -> "0x6"), (7 -> "0x7"), (8 -> ...), (... -> ...), ...])
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), (4 -> 4.0), (5 -> 5.0), (6 -> 6.0),
(7 -> 7.0), (8 -> ...), (... -> ...), ...])
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|----------------------------------------------------------------------------|
limit = triangular(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.
88.87.86.85.84.83.82.81.80.79.78.77.
76.75.74.73.72.71.70.69.68.67.66.65.
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
succ(
succ(
succ(
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
-(-(-(-((x + x) * (x + x) /
(x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), (4 -> "0x4"),
(5 -> "0x5"), (6 -> "0x6"),
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), (4 -> 4.0), (5 -> 5.0),
(6 -> 6.0), (7 -> 7.0), (8 -> 8.0),
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
...
|------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.88.87.86.85.84.83.82.81.80.79.78.77.76.
75.74.73.72.71.70.69.68.67.66.65.64.63.62.61.60.59.58.57.56.55.54.53.52.51.
.......
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((x + x) * (x + x) / (x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
((x / x * (x / x) + -(x / x)) * ((x + x) * (x + x)))) /
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), (4 -> "0x4"), (5 -> "0x5"),
(6 -> "0x6"), (7 -> "0x7"), (8 -> "0x8"), (9 -> "0x9"), (10 -> "0xA"),
(11 -> "0xB"), (12 -> "0xC"), (13 -> "0xD"), (14 -> "0xE"), (15 -> "0xF"),
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), (4 -> 4.0), (5 -> 5.0), (6 -> 6.0),
(7 -> 7.0), (8 -> 8.0), (9 -> 9.0), (10 -> 10.0), (11 -> 11.0),
(12 -> 12.0), (13 -> 13.0), (14 -> 14.0), (15 -> 15.0), (16 -> 16.0),
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.
88.87.86.85.84.83.82.81.80.79.78.77.
76.75.74.73.72.71.70.69.68.67.66.65.
64.63.62.61.60.59.58.57.56.55.54.53.
52.51........
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(zero))))))))))
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
-(-(-(-((x + x) * (x + x) /
(x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
((x / x * (x / x) + -(x / x)) *
((x + x) * (x + x)))) /
((x / x * (x / x) + -(x / x)) *
((x + x) * (x + x)) +
(x / x - x - -(x / x) -
x / x * (x / x))))
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), (4 -> "0x4"),
(5 -> "0x5"), (6 -> "0x6"),
(7 -> "0x7"), (8 -> "0x8"),
(9 -> "0x9"), (10 -> "0xA"),
(11 -> "0xB"), (12 -> "0xC"),
(13 -> "0xD"), (14 -> "0xE"),
(15 -> "0xF"), (16 -> "0x10"),
(17 -> "0x11"), (18 -> "0x12"),
(19 -> "0x13"), (20 -> "0x14"),
...
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), (4 -> 4.0), (5 -> 5.0),
(6 -> 6.0), (7 -> 7.0), (8 -> 8.0),
(9 -> 9.0), (10 -> 10.0),
(11 -> 11.0), (12 -> 12.0),
(13 -> 13.0), (14 -> 14.0),
(15 -> 15.0), (16 -> 16.0),
(17 -> 17.0), (18 -> 18.0),
(19 -> 19.0), (20 -> 20.0),
(21 -> 21.0), (22 -> 22.0),
...
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83,
84, 85, 86, 87, 88, 89, 90, 91, 92,
...
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83,
84, 85, 86, 87, 88, 89, 90, 91, 92,
...
|------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.88.87.86.85.84.83.82.81.80.79.78.77.76.
75.74.73.72.71.70.69.68.67.66.65.64.63.62.61.60.59.58.57.56.55.54.53.52.51.
.......
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((x + x) * (x + x) / (x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
((x / x * (x / x) + -(x / x)) * ((x + x) * (x + x)))) /
((x / x * (x / x) + -(x / x)) * ((x + x) * (x + x)) +
(x / x - x - -(x / x) - x / x * (x / x))))
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), (4 -> "0x4"), (5 -> "0x5"),
(6 -> "0x6"), (7 -> "0x7"), (8 -> "0x8"), (9 -> "0x9"), (10 -> "0xA"),
(11 -> "0xB"), (12 -> "0xC"), (13 -> "0xD"), (14 -> "0xE"), (15 -> "0xF"),
(16 -> "0x10"), (17 -> "0x11"), (18 -> "0x12"), (19 -> "0x13"),
(20 -> "0x14"), (21 -> "0x15"), (22 -> "0x16"), (23 -> "0x17"),
(24 -> "0x18"), (25 -> "0x19"), (26 -> "0x1A"), (27 -> "0x1B"),
(28 -> "0x1C"), (29 -> "0x1D"), (30 -> "0x1E"), (31 -> "0x1F"),
(32 -> "0x20"), (33 -> "0x21"), (34 -> "0x22"), (35 -> "0x23"),
(36 -> "0x24"), (37 -> "0x25"), (38 -> "0x26"), (39 -> "0x27"),
(40 -> "0x28"), (41 -> "0x29"), (42 -> "0x2A"), (43 -> "0x2B"),
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), (4 -> 4.0), (5 -> 5.0), (6 -> 6.0),
(7 -> 7.0), (8 -> 8.0), (9 -> 9.0), (10 -> 10.0), (11 -> 11.0),
(12 -> 12.0), (13 -> 13.0), (14 -> 14.0), (15 -> 15.0), (16 -> 16.0),
(17 -> 17.0), (18 -> 18.0), (19 -> 19.0), (20 -> 20.0), (21 -> 21.0),
(22 -> 22.0), (23 -> 23.0), (24 -> 24.0), (25 -> 25.0), (26 -> 26.0),
(27 -> 27.0), (28 -> 28.0), (29 -> 29.0), (30 -> 30.0), (31 -> 31.0),
(32 -> 32.0), (33 -> 33.0), (34 -> 34.0), (35 -> 35.0), (36 -> 36.0),
(37 -> 37.0), (38 -> 38.0), (39 -> 39.0), (40 -> 40.0), (41 -> 41.0),
(42 -> 42.0), (43 -> 43.0), (44 -> 44.0), (45 -> 45.0), (46 -> 46.0),
(47 -> 47.0), (48 -> 48.0), (49 -> 49.0), (50 -> 50.0), (51 -> 51.0),
...
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, 100
|----------------------------------------------------------------------------|
limit = triangular(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, ...]
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...], ...]
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
100.99.98.97.96........
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
succ(
succ(
succ(
...
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
-(-(-(-((... + ...) * ... / ...) /
...) /
...) /
...
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), ...])
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), ...])
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|------------------------------------|
limit = linear(10), max lines = 3, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...], ...]
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96........
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(...))))))))))
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((... + ...) * ... / ...) / ...) / ...) / ...)
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), ...])
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), ...])
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...], ...]
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
100.99.98.97.96........
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(...))))))))))
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
-(-(-(-((... + ...) * ... / ...) /
...) /
...) /
...)
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), ...])
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), ...])
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|------------------------------------|
limit = linear(10), max lines = 10, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, ...], ...]
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96........
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(...))))))))))
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((... + ...) * ... / ...) / ...) / ...) / ...)
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), ...])
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), ...])
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...
|----------------------------------------------------------------------------|
limit = linear(10), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, ...]
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.
88.87.86.85.84.83.82.81.80.79.78.77.
76.75.74.73.72.71.70.69.68.67.66.65.
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
succ(
succ(
succ(
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
-(-(-(-((x + x) * (x + x) /
(x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), (4 -> "0x4"),
(5 -> "0x5"), (6 -> "0x6"),
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), (4 -> 4.0), (5 -> 5.0),
(6 -> 6.0), (7 -> 7.0), (8 -> 8.0),
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
...
|------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.88.87.86.85.84.83.82.81.80.79.78.77.76.
75.74.73.72.71.70.69.68.67.66.65.64.63.62.61.60.59.58.57.56.55.54.53.52.51.
.......
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((x + x) * (x + x) / (x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
((x / x * (x / x) + -(x / x)) * ((x + x) * (x + x)))) /
...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), (4 -> "0x4"), (5 -> "0x5"),
(6 -> "0x6"), (7 -> "0x7"), (8 -> "0x8"), (9 -> "0x9"), (10 -> "0xA"),
(11 -> "0xB"), (12 -> "0xC"), (13 -> "0xD"), (14 -> "0xE"), (15 -> "0xF"),
...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), (4 -> 4.0), (5 -> 5.0), (6 -> 6.0),
(7 -> 7.0), (8 -> 8.0), (9 -> 9.0), (10 -> 10.0), (11 -> 11.0),
(12 -> 12.0), (13 -> 13.0), (14 -> 14.0), (15 -> 15.0), (16 -> 16.0),
...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 3, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
...
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9,
10], ...]
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.
88.87.86.85.84.83.82.81.80.79.78.77.
76.75.74.73.72.71.70.69.68.67.66.65.
64.63.62.61.60.59.58.57.56.55.54.53.
52.51........
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(
succ(zero))))))))))
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
-(-(-(-((x + x) * (x + x) /
(x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
((x / x * (x / x) + -(x / x)) *
((x + x) * (x + x)))) /
((x / x * (x / x) + -(x / x)) *
((x + x) * (x + x)) +
(x / x - x - -(x / x) -
x / x * (x / x))))
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"),
(3 -> "0x3"), (4 -> "0x4"),
(5 -> "0x5"), (6 -> "0x6"),
(7 -> "0x7"), (8 -> "0x8"),
(9 -> "0x9"), (10 -> "0xA"),
(11 -> "0xB"), (12 -> "0xC"),
(13 -> "0xD"), (14 -> "0xE"),
(15 -> "0xF"), (16 -> "0x10"),
(17 -> "0x11"), (18 -> "0x12"),
(19 -> "0x13"), (20 -> "0x14"),
...
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
map([(1 -> 1.0), (2 -> 2.0),
(3 -> 3.0), (4 -> 4.0), (5 -> 5.0),
(6 -> 6.0), (7 -> 7.0), (8 -> 8.0),
(9 -> 9.0), (10 -> 10.0),
(11 -> 11.0), (12 -> 12.0),
(13 -> 13.0), (14 -> 14.0),
(15 -> 15.0), (16 -> 16.0),
(17 -> 17.0), (18 -> 18.0),
(19 -> 19.0), (20 -> 20.0),
(21 -> 21.0), (22 -> 22.0),
...
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83,
84, 85, 86, 87, 88, 89, 90, 91, 92,
...
|------------------------------------|
limit = linear(100), max lines = 10, line width = 38
|------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38,
39, 40, 41, 42, 43, 44, 45, 46, 47,
48, 49, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 61, 62, 63, 64, 65,
66, 67, 68, 69, 70, 71, 72, 73, 74,
75, 76, 77, 78, 79, 80, 81, 82, 83,
84, 85, 86, 87, 88, 89, 90, 91, 92,
...
|------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
indentation test:
_1_ one
_1__2_ two
_1__2__3_ three
_1__2__3__4_ four
_1__2__3__4__5_ five
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
non_canonical_bool(0)
non_canonical_bool(1)
non_canonical_bool(42)
non_canonical_bool(43)
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], ...]
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
{1, 2.0, "three", '4', {5}, "«ąąąąą»"}
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
100.99.98.97.96.95.94.93.92.91.90.89.88.87.86.85.84.83.82.81.80.79.78.77.76.
75.74.73.72.71.70.69.68.67.66.65.64.63.62.61.60.59.58.57.56.55.54.53.52.51.
.......
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
succ(succ(succ(succ(succ(succ(succ(succ(succ(succ(zero))))))))))
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
-(-(-(-((x + x) * (x + x) / (x / x * (x / x))) /
(x / x * (x / x) + -(x / x))) /
((x / x * (x / x) + -(x / x)) * ((x + x) * (x + x)))) /
((x / x * (x / x) + -(x / x)) * ((x + x) * (x + x)) +
(x / x - x - -(x / x) - x / x * (x / x))))
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> "0x1"), (2 -> "0x2"), (3 -> "0x3"), (4 -> "0x4"), (5 -> "0x5"),
(6 -> "0x6"), (7 -> "0x7"), (8 -> "0x8"), (9 -> "0x9"), (10 -> "0xA"),
(11 -> "0xB"), (12 -> "0xC"), (13 -> "0xD"), (14 -> "0xE"), (15 -> "0xF"),
(16 -> "0x10"), (17 -> "0x11"), (18 -> "0x12"), (19 -> "0x13"),
(20 -> "0x14"), (21 -> "0x15"), (22 -> "0x16"), (23 -> "0x17"),
(24 -> "0x18"), (25 -> "0x19"), (26 -> "0x1A"), (27 -> "0x1B"),
(28 -> "0x1C"), (29 -> "0x1D"), (30 -> "0x1E"), (31 -> "0x1F"),
(32 -> "0x20"), (33 -> "0x21"), ...])
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
map([(1 -> 1.0), (2 -> 2.0), (3 -> 3.0), (4 -> 4.0), (5 -> 5.0), (6 -> 6.0),
(7 -> 7.0), (8 -> 8.0), (9 -> 9.0), (10 -> 10.0), (11 -> 11.0),
(12 -> 12.0), (13 -> 13.0), (14 -> 14.0), (15 -> 15.0), (16 -> 16.0),
(17 -> 17.0), (18 -> 18.0), (19 -> 19.0), (20 -> 20.0), (21 -> 21.0),
(22 -> 22.0), (23 -> 23.0), (24 -> 24.0), (25 -> 25.0), (26 -> 26.0),
(27 -> 27.0), (28 -> 28.0), (29 -> 29.0), (30 -> 30.0), (31 -> 31.0),
(32 -> 32.0), (33 -> 33.0), ...])
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, 100
|----------------------------------------------------------------------------|
limit = linear(100), max lines = 10, line width = 78
|----------------------------------------------------------------------------|
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
98, 99, ...]
|----------------------------------------------------------------------------|