%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1999-2014. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%% http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%%
-module(match_spec_SUITE).
-export([all/0, suite/0, not_run/1]).
-export([test_1/1, test_2/1, test_3/1, bad_match_spec_bin/1,
trace_control_word/1, silent/1, silent_no_ms/1, silent_test/1,
ms_trace2/1, ms_trace3/1, boxed_and_small/1,
destructive_in_test_bif/1, guard_exceptions/1,
empty_list/1,
unary_plus/1, unary_minus/1, moving_labels/1]).
-export([fpe/1]).
-export([otp_9422/1]).
-export([faulty_seq_trace/1, do_faulty_seq_trace/0]).
-export([maps/1]).
-export([runner/2, loop_runner/3]).
-export([f1/1, f2/2, f3/2, fn/1, fn/2, fn/3]).
-export([do_boxed_and_small/0]).
% This test suite assumes that tracing in general works. What we test is
% the match spec functionality.
-include_lib("common_test/include/ct.hrl").
suite() ->
[{ct_hooks,[ts_install_cth]},
{timetrap, {seconds, 30}}].
all() ->
case test_server:is_native(match_spec_SUITE) of
false ->
[test_1, test_2, test_3, bad_match_spec_bin,
trace_control_word, silent, silent_no_ms, silent_test, ms_trace2,
ms_trace3, boxed_and_small, destructive_in_test_bif,
guard_exceptions, unary_plus, unary_minus, fpe,
moving_labels,
faulty_seq_trace,
empty_list,
otp_9422,
maps];
true -> [not_run]
end.
not_run(Config) when is_list(Config) ->
{skipped, "Native Code"}.
test_1(doc) ->
[""];
test_1(suite) -> [];
test_1(Config) when is_list(Config) ->
?line tr(fun() -> ?MODULE:f1(a) end,
{?MODULE, f1, 1},
[],
[{call, {?MODULE, f1, [a]}}]),
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$1','$1'],[{is_atom, '$1'}],[]}],
[{call, {?MODULE, f2, [a, a]}}]),
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$1','$1'],[{is_atom, '$1'}],[{message, false}]}],
[]),
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$1','$1'],[{is_atom, '$1'}],[{message, 4711}]}],
[{call, {?MODULE, f2, [a, a]}, 4711}]),
Ref = make_ref(),
?line tr(fun() -> ?MODULE:f2(Ref, Ref) end,
{?MODULE, f2, 2},
[{[Ref,'$1'],[{is_reference, '$1'}],[{message, 4711}]}],
[{call, {?MODULE, f2, [Ref, Ref]}, 4711}]),
?line tr(fun() -> ?MODULE:f2(Ref, Ref) end,
{?MODULE, f2, 2},
[{['$1',Ref],[{is_reference, '$1'}],[{message, 4711}]}],
[{call, {?MODULE, f2, [Ref, Ref]}, 4711}]),
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$0','$0'],[{is_atom, '$0'}],[{message, 4711}]}],
[{call, {?MODULE, f2, [a, a]}, 4711}]),
?line tr(fun() -> ?MODULE:f2(a, b) end,
{?MODULE, f2, 2},
[{['_','_'],[],[]}],
[{call, {?MODULE, f2, [a, b]}}]),
?line tr(fun() -> ?MODULE:f2(a, b) end,
{?MODULE, f2, 2},
[{['_','_'],[],[{message, '$_'}]}],
[{call, {?MODULE, f2, [a, b]}, [a, b]}]),
?line tr(fun() -> ?MODULE:f2(a, '$_') end,
{?MODULE, f2, 2},
[{['$1','$_'],[{is_atom, '$1'}],[]}],
[{call, {?MODULE, f2, [a, '$_']}}]),
?line tr(fun() -> ?MODULE:f1({a}) end,
{?MODULE, f1, 1},
[{['$1'],[{'==', '$1', {const, {a}}}],[]}],
[{call, {?MODULE, f1, [{a}]}}]),
?line tr(fun() -> ?MODULE:f1({a}) end,
{?MODULE, f1, 1},
[{['$1'],[{'==', '$1', {{a}}}],[]}],
[{call, {?MODULE, f1, [{a}]}}]),
%% Undocumented, currently.
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$1','$1'],[{is_atom, '$1'}],[{message, 4711},
{message, true}]}],
[{call, {?MODULE, f2, [a, a]}}]),
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$1','$1'],[{is_atom, '$1'}],[{message, 4711},
{message, false}]}],
[]),
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$1','$1'],[{is_atom, '$1'}],[kakalorum]}],
[{call, {?MODULE, f2, [a, a]}}]),
%% Verify that 'process_dump' can handle a matchstate on the stack.
tr(fun() -> fbinmatch(<<0>>, 0) end,
{?MODULE, f1, 1},
[{['_'],[],[{message, {process_dump}}]}],
[fun({trace, _, call, {?MODULE, f1, [0]}, _Bin}) -> true end]),
% Error cases
?line errchk([{['$1','$1'],[{is_atom, '$1'}],[{banka, kanin}]}]),
ok.
test_2(doc) ->
[""];
test_2(suite) -> [];
test_2(Config) when is_list(Config) ->
?line tr(fun() -> ?MODULE:f2(a, a) end,
{?MODULE, f2, 2},
[{['$1','$1'],[{is_atom, '$1'}],[{return_trace}]}],
[{call, {?MODULE, f2, [a, a]}},
{return_from, {?MODULE, f2, 2}, {a, a}}]),
ok.
test_3(doc) ->
["Test the enable_trace/2 and caller/0 PAM instructions"];
test_3(suite) -> [];
test_3(Config) when is_list(Config) ->
?line Fun1 = fun() ->
register(fnoppelklopfer,self()),
?MODULE:f2(a, b),
?MODULE:f2(a, b)
end,
?line P1 = spawn(?MODULE, runner, [self(), Fun1]),
?line Pat = [{['$1','$1'],[],[{message,
[{enable_trace, P1, call},{caller}]}]},
{['_','_'],[],[{message,
[{disable_trace, fnoppelklopfer, call}]}]}],
?line Fun2 = fun() -> ?MODULE:f3(a, a) end,
?line P2 = spawn(?MODULE, runner, [self(), Fun2]),
?line erlang:trace(P2, true, [call]),
?line erlang:trace_pattern({?MODULE, f2, 2}, Pat),
?line collect(P2, [{trace, P2, call, {?MODULE, f2, [a, a]}, [true,
{?MODULE,f3,2}]}]),
?line collect(P1, [{trace, P1, call, {?MODULE, f2, [a, b]}, [true]}]),
?line ok.
otp_9422(doc) -> [];
otp_9422(Config) when is_list(Config) ->
Laps = 10000,
?line Fun1 = fun() -> otp_9422_tracee() end,
?line P1 = spawn_link(?MODULE, loop_runner, [self(), Fun1, Laps]),
io:format("spawned ~p as tracee\n", [P1]),
?line erlang:trace(P1, true, [call, silent]),
?line Fun2 = fun() -> otp_9422_trace_changer() end,
?line P2 = spawn_link(?MODULE, loop_runner, [self(), Fun2, Laps]),
io:format("spawned ~p as trace_changer\n", [P2]),
start_collect(P1),
start_collect(P2),
%%receive after 10*1000 -> ok end,
stop_collect(P1),
stop_collect(P2, abort),
ok.
otp_9422_tracee() ->
?MODULE:f1(a),
?MODULE:f1(b),
?MODULE:f1(c).
otp_9422_trace_changer() ->
Pat1 = [{[a], [], [{enable_trace, arity}]}],
?line erlang:trace_pattern({?MODULE, f1, 1}, Pat1),
Pat2 = [{[b], [], [{disable_trace, arity}]}],
?line erlang:trace_pattern({?MODULE, f1, 1}, Pat2).
bad_match_spec_bin(Config) when is_list(Config) ->
{'EXIT',{badarg,_}} = (catch ets:match_spec_run([1], <<>>)),
B0 = <<1,2>>,
{B,_} = split_binary(B0, 0),
{'EXIT',{badarg,_}} = (catch ets:match_spec_run([1], B)),
ok.
trace_control_word(doc) ->
["Test the erlang:system_info(trace_control_word) and ",
"erlang:system_flag(trace_control_word, Value) BIFs, ",
"as well as the get_tcw/0 and set_tcw/1 PAM instructions"];
trace_control_word(suite) -> [];
trace_control_word(Config) when is_list(Config) ->
?line 32 = Bits = tcw_bits(),
?line High = 1 bsl (Bits - 1),
?line erlang:system_flag(trace_control_word, 17),
?line tr(fun() -> ?MODULE:f1(a) end,
{?MODULE, f1, 1},
[{'_',[{'=:=', {get_tcw}, 17}],[]}],
[{call, {?MODULE, f1, [a]}}]),
?line tr(fun() -> ?MODULE:f1(a) end,
{?MODULE, f1, 1},
[{'_',[{'=:=', {get_tcw}, 18}],[]}],
[]),
?line erlang:system_flag(trace_control_word, High),
?line tr(fun() -> ?MODULE:f1(a) end,
{?MODULE, f1, 1},
[{'_',[{'=:=', {get_tcw}, High}],[]}],
[{call, {?MODULE, f1, [a]}}]),
?line erlang:system_flag(trace_control_word, 0),
?line tr(fun() ->
?MODULE:f1(a),
?MODULE:f1(start),
?MODULE:f1(b),
?MODULE:f1(c),
?MODULE:f1(high),
?MODULE:f1(d),
?MODULE:f1(stop),
?MODULE:f1(e)
end,
{?MODULE, f1, 1},
[{[start],
[],
[{message, {set_tcw, 17}}]},
{[stop],
[],
[{message, {set_tcw, 0}}]},
{[high],
[],
[{message, {set_tcw, High}}]},
{['_'],
[{'>', {get_tcw}, 0}],
[{set_tcw, {'+', 1, {get_tcw}}}, {message, {get_tcw}}] }],
[{call, {?MODULE, f1, [start]}, 0},
{call, {?MODULE, f1, [b]}, 18},
{call, {?MODULE, f1, [c]}, 19},
{call, {?MODULE, f1, [high]}, 19},
{call, {?MODULE, f1, [d]}, High + 1},
{call, {?MODULE, f1, [stop]}, High + 1}]),
?line 0 = erlang:system_info(trace_control_word),
ok.
tcw_bits() ->
?line tcw_bits(erlang:system_flag(trace_control_word, 0), 0, 0).
tcw_bits(Save, Prev, Bits) ->
?line Curr = 1 bsl Bits,
?line case catch erlang:system_flag(trace_control_word, Curr) of
{'EXIT' , {badarg, _}} ->
?line Prev = erlang:system_flag(trace_control_word, Save),
Bits;
Prev ->
?line Curr = erlang:system_info(trace_control_word),
tcw_bits(Save, Curr, Bits+1)
end.
silent(doc) ->
["Test the erlang:trace(_, _, [silent]) flag ",
"as well as the silent/0 PAM instruction"];
silent(suite) -> [];
silent(Config) when is_list(Config) ->
%% Global call trace
?line tr(fun() ->
?MODULE:f1(a), % No trace - not active
?MODULE:f1(miss), % No trace - no activation
?MODULE:f1(b), % No trace - still not active
?MODULE:f1(start), % Trace - activation
?MODULE:f1(c), % Trace - active
f1(d), % No trace - local call
?MODULE:f1(miss), % Trace - no inactivation
?MODULE:f1(e), % Trace - still active
?MODULE:f1(stop), % No trace - inactivation
?MODULE:f1(f) % No trace - not active
end,
{?MODULE, f1, 1},
[call, silent],
[{[start],
[],
[{silent, false}, {message, start}]},
{[stop],
[],
[{silent, true}, {message, stop}]},
{[miss],
[],
[{silent, neither_true_nor_false}, {message, miss}]},
{['$1'],
[],
[{message, '$1'}] }],
[global],
[{call, {?MODULE, f1, [start]}, start},
{call, {?MODULE, f1, [c]}, c},
{call, {?MODULE, f1, [miss]}, miss},
{call, {?MODULE, f1, [e]}, e} ]),
%% Local call trace
?line tr(fun() ->
?MODULE:f1(a), % No trace - not active
f1(b), % No trace - not active
?MODULE:f1(start), % Trace - activation
?MODULE:f1(c), % Trace - active
f1(d), % Trace - active
f1(stop), % No trace - inactivation
?MODULE:f1(e), % No trace - not active
f1(f) % No trace - not active
end,
{?MODULE, f1, 1},
[call, silent],
[{[start],
[],
[{silent, false}, {message, start}]},
{[stop],
[],
[{silent, true}, {message, stop}]},
{['$1'],
[],
[{message, '$1'}] }],
[local],
[{call, {?MODULE, f1, [start]}, start},
{call, {?MODULE, f1, [c]}, c},
{call, {?MODULE, f1, [d]}, d} ]),
ok.
silent_no_ms(doc) ->
["Test the erlang:trace(_, _, [silent]) flag without match specs"];
silent_no_ms(suite) -> [];
silent_no_ms(Config) when is_list(Config) ->
%% Global call trace
%%
%% Trace f2/2 and erlang:integer_to_list/1 without match spec
%% and use match spec on f1/1 to control silent flag.
?line tr(
fun () ->
?MODULE:f1(a),
?MODULE:f2(b, c),
_ = erlang:integer_to_list(id(1)),
?MODULE:f3(d, e),
?MODULE:f1(start),
?MODULE:f2(f, g),
_ = erlang:integer_to_list(id(2)),
?MODULE:f3(h, i),
?MODULE:f1(stop),
?MODULE:f2(j, k),
_ = erlang:integer_to_list(id(3)),
?MODULE:f3(l, m)
end,
fun (Tracee) ->
?line 1 =
erlang:trace(Tracee, true,
[call,silent,return_to]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f2,2},
[],
[global]),
?line 1 =
erlang:trace_pattern(
{erlang,integer_to_list,1},
[],
[global]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f1,1},
[{[start],[],[{silent,false}]},
{[stop],[],[{silent,true}]}],
[global]),
%%
%% Expected: (no return_to for global call trace)
%%
?line
[{trace,Tracee,call,{?MODULE,f1,[start]}},
{trace,Tracee,call,{?MODULE,f2,[f,g]}},
{trace,Tracee,call,{erlang,integer_to_list,[2]}},
{trace,Tracee,call,{?MODULE,f2,[h,i]}}]
end),
%% Local call trace
%%
%% Trace f2/2 and erlang:integer_to_list/1 without match spec
%% and use match spec on f1/1 to control silent flag.
?line tr(
fun () ->
?MODULE:f1(a),
?MODULE:f2(b, c),
_ = erlang:integer_to_list(id(1)),
?MODULE:f3(d, e),
?MODULE:f1(start),
?MODULE:f2(f, g),
_ = erlang:integer_to_list(id(2)),
?MODULE:f3(h, i),
?MODULE:f1(stop),
?MODULE:f2(j, k),
_ = erlang:integer_to_list(id(3)),
?MODULE:f3(l, m)
end,
fun (Tracee) ->
?line 1 =
erlang:trace(Tracee, true,
[call,silent,return_to]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f2,2},
[],
[local]),
?line 1 =
erlang:trace_pattern(
{erlang,integer_to_list,1},
[],
[local]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f1,1},
[{[start],[],[{silent,false}]},
{[stop],[],[{silent,true}]}],
[local]),
%%
%% Expected:
%%
?line
[{trace,Tracee,call,{?MODULE,f1,[start]}},
{trace,Tracee,return_to,
{?MODULE,'-silent_no_ms/1-fun-2-',0}},
{trace,Tracee,call,{?MODULE,f2,[f,g]}},
{trace,Tracee,return_to,
{?MODULE,'-silent_no_ms/1-fun-2-',0}},
{trace,Tracee,call,{erlang,integer_to_list,[2]}},
{trace,Tracee,return_to,
{?MODULE,'-silent_no_ms/1-fun-2-',0}},
{trace,Tracee,call,{?MODULE,f2,[h,i]}},
{trace,Tracee,return_to,{?MODULE,f3,2}}]
end).
silent_test(doc) ->
["Test that match_spec_test does not activate silent"];
silent_test(_Config) ->
{flags,[]} = erlang:trace_info(self(),flags),
erlang:match_spec_test([],[{'_',[],[{silent,true}]}],trace),
{flags,[]} = erlang:trace_info(self(),flags).
ms_trace2(doc) ->
["Test the match spec functions {trace/2}"];
ms_trace2(suite) -> [];
ms_trace2(Config) when is_list(Config) ->
Tracer = self(),
%% Meta trace init
%%
%% Trace global f1/1, local f2/2, global erlang:integer_to_list/1
%% without match spec. Use match spec functions
%% {trace/2} to control trace through fn/2,3.
?line tr(
fun () ->
?MODULE:f1(a),
?MODULE:f2(b, c),
_ = erlang:integer_to_list(id(1)),
?MODULE:f3(d, e),
fn([all], [call,return_to,{tracer,Tracer}]),
?MODULE:f1(f),
f2(g, h),
f1(i),
_ = erlang:integer_to_list(id(2)),
?MODULE:f3(j, k),
fn([call,return_to], []),
?MODULE:f1(l),
?MODULE:f2(m, n),
_ = erlang:integer_to_list(id(3)),
?MODULE:f3(o, p)
end,
fun (Tracee) ->
?line 1 =
erlang:trace(Tracee, false, [all]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f1,1},
[],
[global]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f2,2},
[],
[local]),
?line 1 =
erlang:trace_pattern(
{erlang,integer_to_list,1},
[],
[global]),
?line 3 =
erlang:trace_pattern(
{?MODULE,fn,'_'},
[{['$1','$2'],[],
[{trace,'$1','$2'},{message,ms_trace2}]}],
[meta]),
%%
%% Expected: (no return_to for global call trace)
%%
?line Origin = {match_spec_SUITE,'-ms_trace2/1-fun-0-',1},
?line
[{trace_ts,Tracee,call,
{?MODULE,fn,
[[all],[call,return_to,{tracer,Tracer}]]},
ms_trace2},
{trace,Tracee,call,{?MODULE,f1,[f]}},
{trace,Tracee,call,{?MODULE,f2,[g,h]}},
{trace,Tracee,return_to,Origin},
{trace,Tracee,call,{erlang,integer_to_list,[2]}},
{trace,Tracee,call,{?MODULE,f2,[j,k]}},
{trace,Tracee,return_to,{?MODULE,f3,2}},
{trace_ts,Tracee,call,
{?MODULE,fn,
[[call,return_to],[]]},
ms_trace2}]
end),
ok.
ms_trace3(doc) ->
["Test the match spec functions {trace/3}"];
ms_trace3(suite) -> [];
ms_trace3(Config) when is_list(Config) ->
TraceeName = 'match_spec_SUITE:ms_trace3',
Tracer = self(),
%% Meta trace init
%%
%% Trace global f1/1, local f2/2, global erlang:integer_to_list/1
%% without match spec. Use match spec functions
%% {trace/2} to control trace through fn/2,3.
Tag = make_ref(),
Controller =
spawn_link(
fun () ->
receive
{Tracee,Tag,start} ->
fn(TraceeName, [all],
[call,return_to,send,'receive',
{tracer,Tracer}]),
Tracee ! {self(),Tag,started},
receive {Tracee,Tag,stop_1} -> ok end,
fn(Tracee, [call,return_to], []),
Tracee ! {self(),Tag,stopped_1},
receive {Tracee,Tag,stop_2} -> ok end,
fn(Tracee, [all], []),
Tracee ! {self(),Tag,stopped_2}
end
end),
?line tr(
fun () -> %% Action
register(TraceeName, self()),
?MODULE:f1(a),
?MODULE:f2(b, c),
_ = erlang:integer_to_list(id(1)),
?MODULE:f3(d, e),
Controller ! {self(),Tag,start},
receive {Controller,Tag,started} -> ok end,
?MODULE:f1(f),
f2(g, h),
f1(i),
_ = erlang:integer_to_list(id(2)),
?MODULE:f3(j, k),
Controller ! {self(),Tag,stop_1},
receive {Controller,Tag,stopped_1} -> ok end,
?MODULE:f1(l),
?MODULE:f2(m, n),
_ = erlang:integer_to_list(id(3)),
?MODULE:f3(o, p),
Controller ! {self(),Tag,stop_2},
receive {Controller,Tag,stopped_2} -> ok end,
?MODULE:f1(q),
?MODULE:f2(r, s),
_ = erlang:integer_to_list(id(4)),
?MODULE:f3(t, u)
end,
fun (Tracee) -> %% Startup
?line 1 =
erlang:trace(Tracee, false, [all]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f1,1},
[],
[global]),
?line 1 =
erlang:trace_pattern(
{?MODULE,f2,2},
[],
[local]),
?line 1 =
erlang:trace_pattern(
{erlang,integer_to_list,1},
[],
[global]),
?line 3 =
erlang:trace_pattern(
{?MODULE,fn,'_'},
[{['$1','$2','$3'],[],
[{trace,'$1','$2','$3'},{message,Tag}]}],
[meta]),
%%
%% Expected: (no return_to for global call trace)
%%
?line Origin = {match_spec_SUITE,'-ms_trace3/1-fun-1-',2},
?line
[{trace_ts,Controller,call,
{?MODULE,fn,[TraceeName,[all],
[call,return_to,send,'receive',
{tracer,Tracer}]]},
Tag},
{trace,Tracee,'receive',{Controller,Tag,started}},
{trace,Tracee,call,{?MODULE,f1,[f]}},
{trace,Tracee,call,{?MODULE,f2,[g,h]}},
{trace,Tracee,return_to,Origin},
{trace,Tracee,call,{erlang,integer_to_list,[2]}},
{trace,Tracee,call,{?MODULE,f2,[j,k]}},
{trace,Tracee,return_to,{?MODULE,f3,2}},
{trace,Tracee,send,{Tracee,Tag,stop_1},Controller},
{trace_ts,Controller,call,
{?MODULE,fn,[Tracee,[call,return_to],[]]},
Tag},
{trace_ts,Controller,call,
{?MODULE,fn,[Tracee,[all],[]]},
Tag}]
end),
ok.
destructive_in_test_bif(doc) ->
["Test that destructive operations in test bif does not really happen"];
destructive_in_test_bif(suite) -> [];
destructive_in_test_bif(Config) when is_list(Config) ->
?line {ok,OldToken,_,_} = erlang:match_spec_test
([],
[{'_',[],[{message,{get_seq_token}}]}],trace),
?line {ok,_,_,_} = erlang:match_spec_test
([],
[{'_',[],[{message,{set_seq_token, label, 1}}]}],
trace),
?line {ok,OldToken,_,_} = erlang:match_spec_test
([],
[{'_',[],[{message,{get_seq_token}}]}],trace),
?line {ok, OldTCW,_,_} = erlang:match_spec_test
([],[{'_',[],[{message,{get_tcw}}]}],trace),
?line {ok,OldTCW,_,_} = erlang:match_spec_test
([],
[{'_',[],[{message,{set_tcw, OldTCW+1}}]}],
trace),
?line {ok, OldTCW,_,_} = erlang:match_spec_test
([],[{'_',[],[{message,{get_tcw}}]}],trace),
ok.
boxed_and_small(doc) ->
["Test that the comparision between boxed and small does not crash emulator"];
boxed_and_small(suite) -> [];
boxed_and_small(Config) when is_list(Config) ->
?line {ok, Node} = start_node(match_spec_suite_other),
?line ok = rpc:call(Node,?MODULE,do_boxed_and_small,[]),
?line stop_node(Node),
ok.
do_boxed_and_small() ->
{ok, false, _, _} = erlang:match_spec_test({0,3},[{{1.47,'_'},[],['$_']}],table),
{ok, false, _, _} = erlang:match_spec_test({0,3},[{{12345678901234567890,'_'},[],['$_']}],table),
{ok, false, _, _} = erlang:match_spec_test({0,3},[{{<<1,2,3,4>>,'_'},[],['$_']}],table),
{ok, false, _, _} = erlang:match_spec_test({0,3},[{{make_ref(),'_'},[],['$_']}],table),
ok.
faulty_seq_trace(doc) ->
["Test that faulty seq_trace_call does not crash emulator"];
faulty_seq_trace(suite) -> [];
faulty_seq_trace(Config) when is_list(Config) ->
?line {ok, Node} = start_node(match_spec_suite_other),
?line ok = rpc:call(Node,?MODULE,do_faulty_seq_trace,[]),
?line stop_node(Node),
ok.
do_faulty_seq_trace() ->
{ok,'EXIT',_,_} = erlang:match_spec_test([],[{'_',[],[{message,{set_seq_token,yxa,true}}]}],trace),
ok.
errchk(Pat) ->
case catch erlang:trace_pattern({?MODULE, f2, 2}, Pat) of
{'EXIT', {badarg, _}} ->
ok;
Other ->
test_server:fail({noerror, Other})
end.
unary_minus(suite) ->
[];
unary_minus(doc) ->
["Checks that unary minus works"];
unary_minus(Config) when is_list(Config) ->
?line {ok,true,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'<',{'-','$1'},-4}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'<',{'-','$1'},-6}],
[true]}],
table),
?line {ok,true,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'=:=',{'-','$1',2},3}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(hej,
[{'$1',
[{'=/=',{'-','$1'},0}],
[true]}],
table),
ok.
unary_plus(suite) ->
[];
unary_plus(doc) ->
["Checks that unary plus works"];
unary_plus(Config) when is_list(Config) ->
?line {ok,true,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'<',{'+','$1'},6}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'<',{'+','$1'},4}],
[true]}],
table),
?line {ok,true,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'=:=',{'+','$1',2},7}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(hej,
[{'$1',
[{'=/=',{'+','$1'},0}],
[true]}],
table),
ok.
guard_exceptions(suite) ->
[];
guard_exceptions(doc) ->
["Checks that exceptions in guards are handled correctly"];
guard_exceptions(Config) when is_list(Config) ->
?line {ok,false,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'or',{is_integer,'$1'},{'or','$1','$1'}}],
[true]}],
table),
?line {ok,true,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'orelse',{is_integer,'$1'},
{'or','$1','$1'}}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'orelse',{'or','$1',true},
{is_integer,'$1'}}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'or',{is_integer,'$1'},
{'orelse','$1',true}}],
[true]}],
table),
?line {ok,true,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'or',{is_integer,'$1'},
{'orelse',true,'$1'}}],
[true]}],
table),
?line {ok,true,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'or',{is_integer,'$1'},
{'andalso',false,'$1'}}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'or',{is_integer,'$1'},
{'andalso','$1',false}}],
[true]}],
table),
?line {ok,false,[],[]} = erlang:match_spec_test
(5,
[{'$1',
[{'or',{is_integer,'$1'},
{'andalso','$1',false}}],
[true]}],
table),
ok.
fpe(suite) ->
[];
fpe(doc) ->
["Checks floating point exceptions in match-specs"];
fpe(Config) when is_list(Config) ->
MS = [{{'$1'},[],[{'/','$1',0}]}],
case catch (['EXIT','EXIT'] =
ets:match_spec_run([{1},{2}],ets:match_spec_compile(MS))) of
{'EXIT',_} -> test_server:fail({error,
"Floating point exceptions faulty"});
_ -> ok
end.
maps(Config) when is_list(Config) ->
{ok,#{},[],[]} = erlang:match_spec_test(#{}, [{'_',[],['$_']}], table),
{ok,#{},[],[]} = erlang:match_spec_test(#{}, [{#{},[],['$_']}], table),
{ok,false,[],[]} =
erlang:match_spec_test(#{}, [{not_a_map,[],['$_']}], table),
{ok,bar,[],[]} =
erlang:match_spec_test(#{foo => bar},
[{#{foo => '$1'},[],['$1']}],
table),
{ok,false,[],[]} =
erlang:match_spec_test(#{foo => bar},
[{#{foo => qux},[],[qux]}],
table),
{ok,false,[],[]} =
erlang:match_spec_test(#{}, [{#{foo => '_'},[],[foo]}], table),
{error,_} =
erlang:match_spec_test(#{}, [{#{'$1' => '_'},[],[foo]}], table),
{ok,bar,[],[]} =
erlang:match_spec_test({#{foo => bar}},
[{{#{foo => '$1'}},[],['$1']}],
table),
{ok,#{foo := 3},[],[]} =
erlang:match_spec_test({}, [{{},[],[#{foo => {'+',1,2}}]}], table),
{ok,"camembert",[],[]} =
erlang:match_spec_test(#{b => "camembert",c => "cabécou"},
[{#{b => '$1',c => "cabécou"},[],['$1']}], table),
{ok,#{a :="camembert",b := "hi"},[],[]} =
erlang:match_spec_test(#{<<"b">> =>"camembert","c"=>"cabécou", "wat"=>"hi", b=><<"other">>},
[{#{<<"b">> => '$1',"wat" => '$2'},[],[#{a=>'$1',b=>'$2'}]}],
table),
%% large maps
Ls0 = [{I,<<I:32>>}||I <- lists:seq(1,415)],
M0 = maps:from_list(Ls0),
M1 = #{a=>1,b=>2,c=>3,d=>4},
R1 = M0#{263 := #{ a=> 3 }},
Ms1 = [{M1#{c:='$1'},[],[M0#{263 := #{a => '$1'}}]}],
{ok,R1,[],[]} = erlang:match_spec_test(M1,Ms1,table),
Ms2 = [{M0#{63:='$1', 19:='$2'},[],[M0#{19:='$1', 63:='$2'}]}],
R2 = M0#{63 := maps:get(19,M0), 19 := maps:get(63,M0) },
{ok,R2,[],[]} = erlang:match_spec_test(M0,Ms2,table),
ok = maps_check_loop(M1),
ok = maps_check_loop(M0),
M2 = maps:from_list([{integer_to_list(K),V} || {K,V} <- Ls0]),
ok = maps_check_loop(M2),
ok.
maps_check_loop(M) ->
Ks = maps:keys(M),
maps_check_loop(M,M,M,M,Ks,lists:reverse(Ks),1).
maps_check_loop(Orig,M0,MsM0,Rm0,[K|Ks],[Rk|Rks],Ix) ->
MsK = list_to_atom([$$]++integer_to_list(Ix)),
MsM1 = MsM0#{K := MsK},
Rm1 = Rm0#{Rk := MsK},
M1 = M0#{Rk := maps:get(K,MsM0)},
Ms = [{MsM1,[],[Rm1]}],
{ok,M1,[],[]} = erlang:match_spec_test(Orig,Ms,table),
maps_check_loop(Orig,M1,MsM1,Rm1,Ks,Rks,Ix+1);
maps_check_loop(_,_,_,_,[],[],_) -> ok.
empty_list(Config) when is_list(Config) ->
Val=[{'$1',[], [{message,'$1'},{message,{caller}},{return_trace}]}],
%% Did crash debug VM in faulty assert:
erlang:match_spec_test([],Val,trace).
moving_labels(Config) when is_list(Config) ->
%% Force an andalso/orelse construction to be moved by placing it
%% in a tuple followed by a constant term. Labels should still
%% point at their correct target.
%%
Ms = [{{'$1','$2'},[],[{{ok,{'andalso','$1','$2'},[1,2,3]}}]}],
?line {ok,{ok,false,[1,2,3]},[],[]} =
erlang:match_spec_test({true,false}, Ms, table),
Ms2 = [{{'$1','$2'},[],[{{ok,{'orelse','$1','$2'},[1,2,3]}}]}],
?line {ok,{ok,true,[1,2,3]},[],[]} =
erlang:match_spec_test({true,false}, Ms2, table),
ok.
tr(Fun, MFA, Pat, Expected) ->
tr(Fun, MFA, [call], Pat, [global], Expected).
tr(Fun, MFA, TraceFlags, Pat, PatFlags, Expected0) ->
tr(Fun,
fun(P) ->
erlang:trace(P, true, TraceFlags),
erlang:trace_pattern(MFA, Pat, PatFlags),
lists:map(
fun(X) when is_function(X,1) -> X;
(X) -> list_to_tuple([trace, P | tuple_to_list(X)])
end,
Expected0)
end).
tr(RunFun, ControlFun) ->
P = spawn_link(?MODULE, runner, [self(), RunFun]),
collect(P, ControlFun(P)).
collect(P, TMs) ->
start_collect(P),
collect(TMs),
stop_collect(P).
collect([]) ->
receive
M ->
?t:format("Got unexpected: ~p~n", [M]),
flush({got_unexpected,M})
after 17 ->
ok
end;
collect([TM | TMs]) ->
?t:format( "Expecting: ~p~n", [TM]),
receive
M0 ->
M = case element(1, M0) of
trace_ts ->
list_to_tuple(lists:reverse(
tl(lists:reverse(tuple_to_list(M0)))));
_ -> M0
end,
case is_function(TM,1) of
true ->
case (catch TM(M)) of
true ->
?t:format("Got: ~p~n", [M]),
collect(TMs);
_ ->
?t:format("Got unexpected: ~p~n", [M]),
flush({got_unexpected,M})
end;
false ->
case M of
TM ->
?t:format("Got: ~p~n", [M]),
collect(TMs);
_ ->
?t:format("Got unexpected: ~p~n", [M]),
flush({got_unexpected,M})
end
end
end.
flush(Reason) ->
receive
M ->
?t:format("In queue: ~p~n", [M]),
flush(Reason)
after 17 ->
?t:fail(Reason)
end.
start_collect(P) ->
P ! {go, self()}.
stop_collect(P) ->
stop_collect(P, done).
stop_collect(P, Order) ->
P ! {Order, self()},
receive
{gone, P} ->
ok
end.
runner(Collector, Fun) ->
receive
{go, Collector} ->
go
end,
Fun(),
receive
{done, Collector} ->
Collector ! {gone, self()}
end.
loop_runner(Collector, Fun, Laps) ->
receive
{go, Collector} ->
go
end,
loop_runner_cont(Collector, Fun, 0, Laps).
loop_runner_cont(Collector, _Fun, Laps, Laps) ->
receive
{done, Collector} -> ok;
{abort, Collector} -> ok
end,
io:format("loop_runner ~p exit after ~p laps\n", [self(), Laps]),
Collector ! {gone, self()};
loop_runner_cont(Collector, Fun, N, Laps) ->
Fun(),
receive
{abort, Collector} ->
io:format("loop_runner ~p aborted after ~p of ~p laps\n", [self(), N+1, Laps]),
Collector ! {gone, self()}
after 0 ->
loop_runner_cont(Collector, Fun, N+1, Laps)
end.
f1(X) ->
{X}.
f2(X, Y) ->
{X, Y}.
f3(X,Y) ->
?MODULE:f2(X,Y),
ok.
fn(X) ->
[X].
fn(X, Y) ->
[X, Y].
fn(X, Y, Z) ->
[X, Y, Z].
fbinmatch(<<Int, Rest/binary>>, Acc) ->
fbinmatch(Rest, [?MODULE:f1(Int) | Acc]);
fbinmatch(<<>>, Acc) -> Acc.
id(X) ->
X.
start_node(Name) ->
Pa = filename:dirname(code:which(?MODULE)),
Cookie = atom_to_list(erlang:get_cookie()),
test_server:start_node(Name, slave,
[{args, "-setcookie " ++ Cookie ++" -pa " ++ Pa}]).
stop_node(Node) ->
test_server:stop_node(Node).
