%% -*- erlang-indent-level: 4 -*-
%%
%% 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.
%%
-module(erl_types_SUITE).

-export([all/0,
         consistency_and_to_string/1]).

%% Simplify calls into erl_types and avoid importing the entire module.
-define(M, erl_types).

-include_lib("common_test/include/ct.hrl").

all() ->
    [consistency_and_to_string].

consistency_and_to_string(_Config) ->
    %% Check consistency of types
    Atom1  = ?M:t_atom(),
    Atom2  = ?M:t_atom(foo),
    Atom3  = ?M:t_atom(bar),
    true   = ?M:t_is_atom(Atom2),

    True   = ?M:t_atom(true),
    False  = ?M:t_atom(false),
    Bool   = ?M:t_boolean(),
    true   = ?M:t_is_boolean(True),
    true   = ?M:t_is_boolean(Bool),
    false  = ?M:t_is_boolean(Atom1),

    Binary = ?M:t_binary(),
    true   = ?M:t_is_binary(Binary),

    Bitstr = ?M:t_bitstr(),
    true   = ?M:t_is_bitstr(Bitstr),

    Bitstr1 = ?M:t_bitstr(7, 3),
    true   = ?M:t_is_bitstr(Bitstr1),
    false  = ?M:t_is_binary(Bitstr1),

    Bitstr2 = ?M:t_bitstr(16, 8),
    true   = ?M:t_is_bitstr(Bitstr2),
    true   = ?M:t_is_binary(Bitstr2),

    BitStr816 = ?M:t_bitstr(8,16),
    BitStr816 = ?M:t_subtract(?M:t_bitstr(4, 12), ?M:t_bitstr(8, 12)),

    Int1   = ?M:t_integer(),
    Int2   = ?M:t_integer(1),
    Int3   = ?M:t_integer(16#ffffffff),
    true   = ?M:t_is_integer(Int2),
    true   = ?M:t_is_byte(Int2),
    false  = ?M:t_is_byte(Int3),
    false  = ?M:t_is_byte(?M:t_from_range(-1, 1)),
    true   = ?M:t_is_byte(?M:t_from_range(1, 255)),

    Tuple1 = ?M:t_tuple(),
    Tuple2 = ?M:t_tuple(3),
    Tuple3 = ?M:t_tuple([Atom1, Int1]),
    Tuple4 = ?M:t_tuple([Tuple1, Tuple2]),
    Tuple5 = ?M:t_tuple([Tuple3, Tuple4]),
    Tuple6 = ?M:t_limit(Tuple5, 2),
    Tuple7 = ?M:t_limit(Tuple5, 3),
    true   = ?M:t_is_tuple(Tuple1),

    Port   = ?M:t_port(),
    Pid    = ?M:t_pid(),
    Ref    = ?M:t_reference(),
    Identifier = ?M:t_identifier(),
    false  = ?M:t_is_reference(Port),
    true   = ?M:t_is_identifier(Port),

    Function1 = ?M:t_fun(),
    Function2 = ?M:t_fun(Pid),
    Function3 = ?M:t_fun([], Pid),
    Function4 = ?M:t_fun([Port, Pid], Pid),
    Function5 = ?M:t_fun([Pid, Atom1], Int2),
    true      = ?M:t_is_fun(Function3),

    List1 = ?M:t_list(),
    List2 = ?M:t_list(?M:t_boolean()),
    List3 = ?M:t_cons(?M:t_boolean(), List2),
    List4 = ?M:t_cons(?M:t_boolean(), ?M:t_atom()),
    List5 = ?M:t_cons(?M:t_boolean(), ?M:t_nil()),
    List6 = ?M:t_cons_tl(List5),
    List7 = ?M:t_sup(List4, List5),
    List8 = ?M:t_inf(List7, ?M:t_list()),
    List9 = ?M:t_cons(),
    List10 = ?M:t_cons_tl(List9),
    true  = ?M:t_is_boolean(?M:t_cons_hd(List5)),
    true  = ?M:t_is_list(List5),
    false = ?M:t_is_list(List4),

    Product1 = ?M:t_product([Atom1, Atom2]),
    Product2 = ?M:t_product([Atom3, Atom1]),
    Product3 = ?M:t_product([Atom3, Atom2]),

    Union1 = ?M:t_sup(Atom2, Atom3),
    Union2 = ?M:t_sup(Tuple2, Tuple3),
    Union3 = ?M:t_sup(Int2, Atom3),
    Union4 = ?M:t_sup(Port, Pid),
    Union5 = ?M:t_sup(Union4, Int1),
    Union6 = ?M:t_sup(Function1, Function2),
    Union7 = ?M:t_sup(Function4, Function5),
    Union8 = ?M:t_sup(True, False),
    true   = ?M:t_is_boolean(Union8),
    Union9 = ?M:t_sup(Int2, ?M:t_integer(2)),
    true   = ?M:t_is_byte(Union9),
    Union10 = ?M:t_sup(?M:t_tuple([?M:t_atom(true), ?M:t_any()]),
                       ?M:t_tuple([?M:t_atom(false), ?M:t_any()])),

    Any   = ?M:t_any(),
    Any   = ?M:t_sup(Product3, Function5),

    Atom3  = ?M:t_inf(Union3, Atom1),
    Union2 = ?M:t_inf(Union2, Tuple1),
    Int2   = ?M:t_inf(Int1, Union3),
    Union4 = ?M:t_inf(Union4, Identifier),
    Port   = ?M:t_inf(Union5, Port),
    Function4 = ?M:t_inf(Union7, Function4),
    None   = ?M:t_none(),
    None   = ?M:t_inf(Product2, Atom1),
    Product3 = ?M:t_inf(Product1, Product2),
    Function5 = ?M:t_inf(Union7, Function5),
    true   = ?M:t_is_byte(?M:t_inf(Union9, ?M:t_number())),
    true   = ?M:t_is_char(?M:t_inf(Union9, ?M:t_number())),

    RecDict = #{{record, foo} => {{?FILE, ?LINE}, [{2, [{bar, [], ?M:t_any()},
                                                        {baz, [], ?M:t_any()}]}]}},
    Record1 = ?M:t_from_term({foo, [1,2], {1,2,3}}),

    %% Check string representations
    "atom()" = ?M:t_to_string(Atom1),
    "'foo'"  = ?M:t_to_string(Atom2),
    "'bar'"  = ?M:t_to_string(Atom3),

    "binary()" = ?M:t_to_string(Binary),

    "integer()" = ?M:t_to_string(Int1),
    "1" = ?M:t_to_string(Int2),

    "tuple()" = ?M:t_to_string(Tuple1),
    "{_,_,_}" = ?M:t_to_string(Tuple2),
    "{atom(),integer()}" = ?M:t_to_string(Tuple3),
    "{tuple(),{_,_,_}}" = ?M:t_to_string(Tuple4),
    "{{atom(),integer()},{tuple(),{_,_,_}}}" = ?M:t_to_string(Tuple5),
    "{{_,_},{_,_}}" = ?M:t_to_string(Tuple6),
    "{{atom(),integer()},{tuple(),{_,_,_}}}" = ?M:t_to_string(Tuple7),

    "reference()" = ?M:t_to_string(Ref),
    "port()" = ?M:t_to_string(Port),
    "pid()" = ?M:t_to_string(Pid),
    "identifier()" = ?M:t_to_string(Identifier),

    "[any()]" = ?M:t_to_string(List1),
    "[boolean()]" = ?M:t_to_string(List2),
    "[boolean(),...]" = ?M:t_to_string(List3),
    "nonempty_improper_list(boolean(),atom())" = ?M:t_to_string(List4),
    "[boolean(),...]" = ?M:t_to_string(List5),
    "[boolean()]" = ?M:t_to_string(List6),
    "nonempty_maybe_improper_list(boolean(),atom() | [])" = ?M:t_to_string(List7),
    "[boolean(),...]" = ?M:t_to_string(List8),
    "nonempty_maybe_improper_list()" = ?M:t_to_string(List9),
    "any()" = ?M:t_to_string(List10),

    "fun()" = ?M:t_to_string(Function1),
    "fun((...) -> pid())" = ?M:t_to_string(Function2),
    "fun(() -> pid())" = ?M:t_to_string(Function3),
    "fun((port(),pid()) -> pid())" = ?M:t_to_string(Function4),
    "fun((pid(),atom()) -> 1)" = ?M:t_to_string(Function5),

    "<atom(),'foo'>" = ?M:t_to_string(Product1),
    "<'bar',atom()>" = ?M:t_to_string(Product2),

    "#foo{bar::[1 | 2,...],baz::{1,2,3}}" = ?M:t_to_string(Record1, RecDict),

    "'bar' | 'foo'" = ?M:t_to_string(Union1),
    "{atom(),integer()} | {_,_,_}" = ?M:t_to_string(Union2),
    "'bar' | 1" = ?M:t_to_string(Union3),
    "pid() | port()" = ?M:t_to_string(Union4),
    "pid() | port() | integer()" = ?M:t_to_string(Union5),
    "fun()" = ?M:t_to_string(Union6),
    "fun((pid() | port(),atom() | pid()) -> pid() | 1)" = ?M:t_to_string(Union7),
    "boolean()" = ?M:t_to_string(Union8),
    "{'false',_} | {'true',_}" = ?M:t_to_string(Union10),
    "{'true',integer()}" = ?M:t_to_string(?M:t_inf(Union10, ?M:t_tuple([?M:t_atom(true), ?M:t_integer()]))).