%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 1997-2016. 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(erl_match_SUITE).
-include_lib("common_test/include/ct.hrl").
-include("erl_match_SUITE_data/match_test_cases.hrl").
-export([all/0, suite/0,
atoms/1, lists/1, tuples/1, references/1, pids/1, ports/1,
bind/1, integers/1, floats/1, binaries/1, strings/1]).
%% For interactive running of matcher.
-export([start_matcher/1, erl_match/3]).
%% This test suite tests the erl_match() function.
suite() ->
[{ct_hooks,[ts_install_cth]}].
all() ->
[atoms, lists, tuples, references, pids, ports, bind,
integers, floats, binaries, strings].
atoms(Config) when is_list(Config) ->
P = start_matcher(Config),
eq(P, '', ''),
eq(P, a, a),
ne(P, a, b),
ne(P, a, aa),
eq(P, kalle, kalle),
ne(P, kalle, arne),
ne(P, kalle, 42),
ne(P, 42, kalle),
runner:finish(P),
ok.
lists(Config) when is_list(Config) ->
P = start_matcher(Config),
eq(P, [], []),
ne(P, [], [a]),
ne(P, [a], []),
eq(P, [a], [a]),
ne(P, [a], [b]),
eq(P, [a|b], [a|b]),
ne(P, [a|b], [a|x]),
eq(P, [a, b], [a, b]),
ne(P, [a, b], [a, x]),
eq(P, [a, b, c], [a, b, c]),
ne(P, [a, b|c], [a, b|x]),
ne(P, [a, b, c], [a, b, x]),
ne(P, [a, b|c], [a, b|x]),
ne(P, [a, x|c], [a, b|c]),
ne(P, [a, b, c], [a, x, c]),
runner:finish(P),
ok.
tuples(Config) when is_list(Config) ->
P = start_matcher(Config),
ne(P, {}, {a, b}),
ne(P, {a, b}, {}),
ne(P, {a}, {a, b}),
ne(P, {a, b}, {a}),
eq(P, {}, {}),
eq(P, {a}, {a}),
ne(P, {a}, {b}),
eq(P, {1}, {1}),
ne(P, {1}, {2}),
eq(P, {a, b}, {a, b}),
ne(P, {x, b}, {a, b}),
ne(P, {error, x}, {error, y}),
ne(P, {error, {undefined, {subscriber, last}}},
{error, {undefined, {subscriber, name}}}),
runner:finish(P),
ok.
references(Config) when is_list(Config) ->
P = start_matcher(Config),
Ref1 = make_ref(),
Ref2 = make_ref(),
eq(P, Ref1, Ref1),
eq(P, Ref2, Ref2),
ne(P, Ref1, Ref2),
ne(P, Ref2, Ref1),
runner:finish(P),
ok.
pids(Config) when is_list(Config) ->
P = start_matcher(Config),
Pid1 = c:pid(0,1,2),
Pid2 = c:pid(0,1,3),
eq(P, self(), self()),
eq(P, Pid1, Pid1),
ne(P, Pid1, self()),
ne(P, Pid2, Pid1),
runner:finish(P),
ok.
ports(Config) when is_list(Config) ->
case os:type() of
vxworks ->
{skipped,"not on vxworks, pucko"};
_ ->
P = start_matcher(Config),
P2 = start_matcher(Config),
eq(P, P, P),
ne(P, P, P2),
runner:finish(P),
runner:finish(P2),
ok
end.
integers(Config) when is_list(Config) ->
P = start_matcher(Config),
I1 = 123,
I2 = 12345,
I3 = -123,
I4 = 2234,
eq(P, I1, I1),
eq(P, I2, I2),
ne(P, I1, I2),
ne(P, I1, I3),
eq(P, I4, I4),
runner:finish(P),
ok.
floats(Config) when is_list(Config) ->
P = start_matcher(Config),
F1 = 3.1414,
F2 = 3.1415,
F3 = 3.1416,
S1 = "string",
S2 = "string2",
eq(P, F1, F1),
eq(P, F2, F2),
ne(P, F1, F2),
ne(P, F3, F2),
eq(P, S2, S2),
ne(P, S1, S2),
runner:finish(P),
ok.
binaries(Config) when is_list(Config) ->
P = start_matcher(Config),
Bin1 = term_to_binary({kalle, 146015, {kungsgatan, 23}}),
Bin2 = term_to_binary(sune),
Bin3 = list_to_binary("sune"),
eq(P, Bin1, Bin1),
eq(P, Bin2, Bin2),
eq(P, Bin3, Bin3),
ne(P, Bin1, Bin2),
ne(P, Bin1, Bin3),
ne(P, Bin2, Bin3),
runner:finish(P),
ok.
strings(Config) when is_list(Config) ->
P = start_matcher(Config),
S1 = "string",
S2 = "streng",
S3 = "String",
eq(P, S1, S1),
ne(P, S1, S2),
ne(P, S1, S3),
runner:finish(P),
ok.
bind(Config) when is_list(Config) ->
P = start_bind(Config),
S = "[X,Y,Z]",
L1 = [301,302,302],
L2 = [65,66,67],
bind_ok(P, S, L1),
bind_ok(P, S, L2),
runner:finish(P),
ok.
start_bind(Config) ->
runner:start(?erl_match_bind).
bind_ok(Port, Bind, Term) ->
true = erl_bind(Port, Bind, Term).
%bind_nok(Port, Bind, Term) ->
% false = erl_bind(Port, Bind, Term).
erl_bind(Port, Pattern, Term) ->
Port ! {self(), {command, [$b, Pattern, 0]}},
runner:send_term(Port, Term),
case runner:get_term(Port) of
{term, 0} -> false;
{term, 1} -> true
end.
start_matcher(Config) ->
runner:start(?erl_match_server).
eq(Port, Pattern, Term) ->
true = erl_match(Port, Pattern, Term).
ne(Port, Pattern, Term) ->
false = erl_match(Port, Pattern, Term).
erl_match(Port, Pattern, Term) ->
runner:send_term(Port, Pattern),
runner:send_term(Port, Term),
case runner:get_term(Port) of
{term, 0} -> false;
{term, 1} -> true
end.
