Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:Ledest:erlang:24
erlang
2911-Strengthen-tests-of-relational-operators.p...
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File 2911-Strengthen-tests-of-relational-operators.patch of Package erlang
From cc712e241005c08d81b6d980fa477011c29b0b88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org> Date: Wed, 27 Apr 2022 07:00:30 +0200 Subject: [PATCH] Strengthen tests of relational operators Strengthen tests of relational operators to better test current and potential future optimizations done by the JIT. --- erts/emulator/test/op_SUITE.erl | 255 ++++++++++++++++++++++++++++-- lib/compiler/test/guard_SUITE.erl | 29 +++- 2 files changed, 269 insertions(+), 15 deletions(-) diff --git a/erts/emulator/test/op_SUITE.erl b/erts/emulator/test/op_SUITE.erl index 8353bae15e..fa03262f09 100644 --- a/erts/emulator/test/op_SUITE.erl +++ b/erts/emulator/test/op_SUITE.erl @@ -23,18 +23,19 @@ -include_lib("common_test/include/ct.hrl"). -export([all/0, suite/0, - bsl_bsr/1,logical/1,t_not/1,relop_simple/1,relop/1,complex_relop/1]). + bsl_bsr/1,logical/1,t_not/1,relop_simple/1,relop/1, + complex_relop/1, + range_tests/1]). --export([]). -import(lists, [foldl/3,flatmap/2]). suite() -> [{ct_hooks,[ts_install_cth]}, {timetrap, {minutes, 5}}]. -all() -> +all() -> [bsl_bsr, logical, t_not, relop_simple, relop, - complex_relop]. + complex_relop, range_tests]. %% Test the bsl and bsr operators. bsl_bsr(Config) when is_list(Config) -> @@ -334,18 +334,25 @@ run_test_module(Cases, GuardsOk) -> Module = erl_parse:new_anno(Module0), lists:foreach(fun(F) -> io:put_chars([erl_pp:form(F),"\n"]) end, Module), - %% Compile, load, and run the generated module. + %% Compile, load, and run the generated module. Test both with and + %% without compiler optimizations to ensure that we test both the + %% implementation of the BIFs and the BEAM instructions. + do_run_test_module(Module, []), + do_run_test_module(Module, [no_copt,no_ssa_opt,no_postopt]). + +do_run_test_module(Module, Opts) -> + {ok,Mod,Code1} = compile:forms(Module, [time|Opts]), + _ = code:delete(Mod), + _ = code:purge(Mod), - {ok,Mod,Code1} = compile:forms(Module, [time]), - code:delete(Mod), - code:purge(Mod), {module,Mod} = code:load_binary(Mod, Mod, Code1), + run_function(Mod, guard_tests), run_function(Mod, body_tests), run_function(Mod, bif_tests), true = code:delete(Mod), - code:purge(Mod), + _ = code:purge(Mod), ok. @@ -424,6 +432,236 @@ eval(E0) -> {value,Val,_Bs} -> Val end. +range_tests(_Config) -> + %% Define the limits for smalls on a 64-bit system. + {MinSmall, MaxSmall} = {-1 bsl 59, (1 bsl 59) - 1}, + case erlang:system_info(wordsize) of + 8 -> + %% Assertions. + 2 = erts_debug:flat_size(MinSmall-1), + 0 = erts_debug:flat_size(MinSmall), + 0 = erts_debug:flat_size(MaxSmall), + 2 = erts_debug:flat_size(MaxSmall+1); + 4 -> + ok + end, + + lesser = range(-1 bsl 64), + lesser = range(MinSmall), + lesser = range(0), + lesser = range(-1), + lesser = range(0.9999), + + inside = range_any(1), + inside = range_any(2), + inside = range_any(2.5), + inside = range_any(math:pi()), + inside = range_any(5), + inside = range_any(9), + inside = range_any(10), + + greater = range(10.0001), + greater = range(11), + greater = range(MaxSmall), + greater = range(1 bsl 64), + greater = range(atom), + greater = range(self()), + greater = range(make_ref()), + greater = range({a,b}), + greater = range([a,b]), + greater = range([]), + greater = range(<<1,2,3>>), + greater = range(fun() -> ok end), + greater = range(fun ?MODULE:range_tests/1), + + lesser = range(-1 bsl 64), + lesser = range(float(-1 bsl 64)), + lesser = range_big(MinSmall - 2), + lesser = range_barely_small(MinSmall - 1), + + inside = range_barely_small(MinSmall), + inside = range_barely_small(-1 bsl 58), + inside = range_barely_small(0), + inside = range_barely_small(17.75), + inside = range_barely_small(1 bsl 58), + inside = range_barely_small(MaxSmall), + + greater = range_barely_small(MaxSmall + 1), + greater = range_big(MaxSmall + 2), + greater = range_big(1 bsl 64), + greater = range_big(float(1 bsl 64)), + + lesser = range(-1 bsl 64), + lesser = range(float(-1 bsl 64)), + lesser = range_big(MinSmall - 2), + + inside = range_big(MinSmall), + inside = range_big(-1 bsl 58), + inside = range_big(0), + inside = range_barely_small(17.75), + inside = range_big(1 bsl 58), + inside = range_big(MaxSmall), + + greater = range_big(MaxSmall + 2), + greater = range_big(1 bsl 64), + greater = range_big(float(1 bsl 64)), + + ok. + +range(X) -> + Res = range_any(X), + if + is_integer(X) -> + Res = range_any(float(X)), + Res = range_number(X), + Res = range_number(float(X)), + Res = range_int(X), + if + X =:= X band 16#ffff -> + Res = range_small_int(X); + true -> + Res + end; + is_number(X) -> + Res = range_number(X); + true -> + Res = range_big(X), + Res = range_barely_small(X) + end. + +range_any(X0) -> + X = id(X0), + case range_any_1(X) of + inside -> + inside = range_any_2(X); + Other -> + outside = range_any_2(X), + Other + end. + +%% The guard tests have different failure labels. +range_any_1(X) when 1 =< X, X =< 10 -> + inside; +range_any_1(X) when X < 1 -> + lesser; +range_any_1(X) when X > 10 -> + greater. + +%% The guard tests have the same failure label. +range_any_2(X) when 1 =< X, X =< 10 -> + inside; +range_any_2(_) -> + outside. + +range_number(X) when is_number(X) -> + case range_number_1(X) of + inside -> + inside = range_number_2(X); + Other -> + outside = range_number_2(X), + Other + end. + +range_number_1(X) when 1 =< X, X =< 10 -> + inside; +range_number_1(X) when X < 1 -> + lesser; +range_number_1(X) when X > 10 -> + greater. + +range_number_2(X) when 1 =< X, X =< 10 -> + inside; +range_number_2(_) -> + outside. + +range_int(X) when is_integer(X) -> + case range_int_1(X) of + inside -> + inside = range_int_2(X); + Other -> + outside = range_int_2(X), + Other + end. + +range_int_1(X) when 1 =< X, X =< 10 -> + inside; +range_int_1(X) when X < 1 -> + lesser; +range_int_1(X) when X > 10 -> + greater. + +range_int_2(X) when 1 =< X, X =< 10 -> + inside; +range_int_2(_) -> + outside. + +range_small_int(X) when is_integer(X) -> + case range_small_int_1(X) of + inside -> + inside = range_small_int_2(X); + Other -> + outside = range_small_int_2(X), + Other + end. + +range_small_int_1(X) when 1 =< X, X =< 10 -> + inside; +range_small_int_1(X) when X < 1 -> + lesser; +range_small_int_1(X) when X > 10 -> + greater. + +range_small_int_2(X) when 1 =< X, X =< 10 -> + inside; +range_small_int_2(_) -> + outside. + +range_barely_small(X) -> + case range_barely_small_1(X) of + inside -> + inside = range_barely_small_2(X); + Other -> + outside = range_barely_small_2(X), + Other + end. + +range_barely_small_1(X) when -1 bsl 59 =< X, X =< (1 bsl 59) - 1 -> + inside; +range_barely_small_1(X) when X < -1 bsl 59 -> + lesser; +range_barely_small_1(X) when X > (1 bsl 59) - 1 -> + greater. + +range_barely_small_2(X) when -1 bsl 59 =< X, X =< (1 bsl 59) - 1 -> + inside; +range_barely_small_2(_) -> + outside. + +range_big(X) -> + case range_big_1(X) of + inside -> + inside = range_big_2(X); + Other -> + outside = range_big_2(X), + Other + end. + +range_big_1(X) when (-1 bsl 59) - 1 =< X, X =< 1 bsl 59 -> + inside; +range_big_1(X) when X < (-1 bsl 59) - 1 -> + lesser; +range_big_1(X) when X > 1 bsl 59 -> + greater. + +range_big_2(X) when (-1 bsl 59) - 1 =< X, X =< 1 bsl 59 -> + inside; +range_big_2(_) -> + outside. + +%%% +%%% Utilities. +%%% + unvalue(V) -> Abstr = erl_parse:abstract(V), erl_parse:anno_to_term(Abstr). diff --git a/lib/compiler/test/guard_SUITE.erl b/lib/compiler/test/guard_SUITE.erl index 5a4d8d1e80..ba89255e7b 100644 --- a/lib/compiler/test/guard_SUITE.erl +++ b/lib/compiler/test/guard_SUITE.erl @@ -1435,16 +1435,24 @@ rel_op_combinations(Config) when is_list(Config) -> lists:seq(16#06F0, 16#06F9), Digits = gb_sets:from_list(Digits0), rel_op_combinations_1(16#0700, Digits), + false = is_digit(-1 bsl 59), + false = is_digit(-1 bsl 64), + false = is_digit((1 bsl 59) - 1), + false = is_digit(1 bsl 64), BrokenRange0 = lists:seq(3, 5) ++ lists:seq(10, 12) ++ lists:seq(14, 20), BrokenRange = gb_sets:from_list(BrokenRange0), rel_op_combinations_2(30, BrokenRange), + false = broken_range(-1 bsl 64), + false = broken_range(1 bsl 64), Red0 = [{I,2*I} || I <- lists:seq(0, 50)] ++ [{I,5*I} || I <- lists:seq(51, 80)], Red = gb_trees:from_orddict(Red0), rel_op_combinations_3(100, Red), + 2 * (-1 bsl 64) = redundant(-1 bsl 64), + none = redundant(1 bsl 64), rel_op_combinations_4(), @@ -1454,6 +1462,10 @@ rel_op_combinations_1(0, _) -> ok; rel_op_combinations_1(N, Digits) -> Bool = gb_sets:is_member(N, Digits), + Bool = is_digit(N), + rel_op_combinations_1(N-1, Digits). + +is_digit(N) -> Bool = is_digit_1(N), Bool = is_digit_2(N), Bool = is_digit_3(N), @@ -1464,8 +1476,7 @@ rel_op_combinations_1(N, Digits) -> Bool = is_digit_8(N), Bool = is_digit_9(42, N), Bool = is_digit_10(N, 0), - Bool = is_digit_11(N, 0), - rel_op_combinations_1(N-1, Digits). + Bool = is_digit_11(N, 0). is_digit_1(X) when 16#0660 =< X, X =< 16#0669 -> true; is_digit_1(X) when 16#0030 =< X, X =< 16#0039 -> true; @@ -1530,6 +1541,10 @@ rel_op_combinations_2(0, _) -> ok; rel_op_combinations_2(N, Range) -> Bool = gb_sets:is_member(N, Range), + Bool = broken_range(N), + rel_op_combinations_2(N-1, Range). + +broken_range(N) -> Bool = broken_range_1(N), Bool = broken_range_2(N), Bool = broken_range_3(N), @@ -1542,8 +1557,7 @@ rel_op_combinations_2(N, Range) -> Bool = broken_range_10(N), Bool = broken_range_11(N), Bool = broken_range_12(N), - Bool = broken_range_13(N), - rel_op_combinations_2(N-1, Range). + Bool = broken_range_13(N). broken_range_1(X) when X >= 10, X =< 20, X =/= 13 -> true; broken_range_1(X) when X >= 3, X =< 5 -> true; @@ -1615,6 +1629,10 @@ rel_op_combinations_3(N, Red) -> none -> none; {value,V} -> V end, + Val = redundant(N), + rel_op_combinations_3(N-1, Red). + +redundant(N) -> Val = redundant_1(N), Val = redundant_2(N), Val = redundant_3(N), @@ -1626,8 +1644,7 @@ rel_op_combinations_3(N, Red) -> Val = redundant_9(N), Val = redundant_10(N), Val = redundant_11(N), - Val = redundant_12(N), - rel_op_combinations_3(N-1, Red). + Val = redundant_12(N). redundant_1(X) when X >= 51, X =< 80 -> 5*X; redundant_1(X) when X < 51 -> 2*X; -- 2.34.1
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor