Add codec suite based on pure ct

1 files changed, 500 insertions, 0 deletions

diff --git a/lib/diameter/test/diameter_codec_test.erl b/lib/diameter/test/diameter_codec_test.erl
new file mode 100644
index 0000000000..aab7ab35cc
--- /dev/null
+++ b/lib/diameter/test/diameter_codec_test.erl
@@ -0,0 +1,500 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2010-2011. All Rights Reserved.
+%%
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%%
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%%
+%% %CopyrightEnd%
+%%
+
+-module(diameter_codec_test).
+
+-compile(export_all).
+
+%%
+%% Test encode/decode of dictionary-related modules.
+%%
+
+-include_lib("diameter/include/diameter.hrl").
+
+-define(BASE, diameter_gen_base_rfc3588).
+-define(BOOL, [true, false]).
+
+%% ===========================================================================
+%% Interface.
+
+base() ->
+    [] = run([{?MODULE, [base, T]} || T <- [zero, decode]]).
+
+gen(Mod) ->
+    Fs = [{Mod, F, []} || F <- [name, id, vendor_id, vendor_name]],
+    [] = run(Fs ++ [{?MODULE, [gen, Mod, T]} || T <- [messages,
+                                                      command_codes,
+                                                      avp_types,
+                                                      grouped,
+                                                      enums,
+                                                      import_avps,
+                                                      import_groups,
+                                                      import_enums]]).
+
+lib() ->
+    Vs = {_,_} = values('Address'),
+    [] = run([[fun lib/2, N, Vs] || N <- [1,2]]).
+
+%% ===========================================================================
+%% Internal functions.
+
+lib(N, {_,_} = T) ->
+    B = 1 == N rem 2,
+    [] = run([[fun lib/2, A, B] || A <- element(N,T)]);
+
+lib(IP, B) ->
+    LA = tuple_to_list(IP),
+    {SA,Fun} = ip(LA),
+    [] = run([[fun lib/4, IP, B, Fun, A] || A <- [IP, LA, SA]]).
+
+lib(IP, B, Fun, A) ->
+    try Fun(A) of
+        IP when B ->
+            ok
+    catch
+        error:_ when not B ->
+            ok
+    end.
+
+ip([_,_,_,_] = A) ->
+    [$.|S] = lists:append(["." ++ integer_to_list(N) || N <- A]),
+    {S, fun diameter_lib:ip4address/1};
+ip([_,_,_,_,_,_,_,_] = A) ->
+    [$:|S] = lists:flatten([":" ++ io_lib:format("~.16B", [N]) || N <- A]),
+    {S, fun diameter_lib:ip6address/1}.
+
+%% ------------------------------------------------------------------------
+%% base/1
+%%
+%% Test of diameter_types.
+%% ------------------------------------------------------------------------
+
+base(T) ->
+    [] = run([{?MODULE, [base, T, F]} || F <- types()]).
+
+%% Ensure that 'zero' values encode only zeros.
+base(zero = T, F) ->
+    B = diameter_types:F(encode, T),
+    B = z(B);
+
+%% Ensure that we can decode what we encode and vice-versa, and that
+%% we can't decode invalid values.
+base(decode, F) ->
+    {Eq, Vs, Ns} = b(values(F)),
+    [] = run([{?MODULE, [base_decode, F, Eq, V]}  || V <- Vs]),
+    [] = run([{?MODULE, [base_invalid, F, Eq, V]} || V <- Ns]).
+
+base_decode(F, Eq, Value) ->
+    d(fun(X,V) -> diameter_types:F(X,V) end, Eq, Value).
+
+base_invalid(F, Eq, Value) ->
+    try
+        base_decode(F, Eq, Value),
+        exit(nok)
+    catch
+        error: _ ->
+            ok
+    end.
+
+b({_,_,_} = T) ->
+    T;
+b({B,Vs})
+  when is_atom(B) ->
+    {B,Vs,[]};
+b({Vs,Ns}) ->
+    {true, Vs, Ns};
+b(Vs) ->
+    {true, Vs, []}.
+
+types() ->
+    [F || {F,2} <- diameter_types:module_info(exports)].
+
+%% ------------------------------------------------------------------------
+%% gen/2
+%%
+%% Test of generated encode/decode module.
+%% ------------------------------------------------------------------------
+
+gen(M, T) ->
+    [] = run(lists:map(fun(X) -> {?MODULE, [gen, M, T, X]} end,
+                       fetch(T, M:dict()))).
+
+fetch(T, Spec) ->
+    case orddict:find(T, Spec) of
+        {ok, L} ->
+            L;
+        error ->
+            []
+    end.
+
+gen(M, messages, {Name, Code, Flags, _, _}) ->
+    Rname = M:msg2rec(Name),
+    Name = M:rec2msg(Rname),
+    {Code, F, _} = M:msg_header(Name),
+    0 = F band 2#00001111,
+    Name = case M:msg_name(Code, lists:member('REQ', Flags)) of
+               N when Name /= 'answer-message' ->
+                   N;
+               '' when Name == 'answer-message', M == ?BASE ->
+                   Name
+           end,
+    [] = arity(M, Name, Rname);
+
+gen(M, command_codes = T, {Code, {Req, Abbr}, Ans}) ->
+    Rname = M:msg2rec(Req),
+    Rname = M:msg2rec(Abbr),
+    gen(M, T, {Code, Req, Ans});
+
+gen(M, command_codes = T, {Code, Req, {Ans, Abbr}}) ->
+    Rname = M:msg2rec(Ans),
+    Rname = M:msg2rec(Abbr),
+    gen(M, T, {Code, Req, Ans});
+
+gen(M, command_codes, {Code, Req, Ans}) ->
+    Msgs = orddict:fetch(messages, M:dict()),
+    {_, Code, _, _, _} = lists:keyfind(Req, 1, Msgs),
+    {_, Code, _, _, _} = lists:keyfind(Ans, 1, Msgs);
+
+gen(M, avp_types, {Name, Code, Type, _Flags, _Encr}) ->
+    {Code, Flags, VendorId} = M:avp_header(Name),
+    0 = Flags band 2#00011111,
+    V = undefined /= VendorId,
+    V = 0 /= Flags band 2#10000000,
+    {Name, Type} = M:avp_name(Code, VendorId),
+    B = M:empty_value(Name),
+    B = z(B),
+    [] = avp_decode(M, Type, Name);
+
+gen(M, grouped, {Name, _, _, _}) ->
+    Rname = M:name2rec(Name),
+    [] = arity(M, Name, Rname);
+
+gen(M, enums, {Name, ED}) ->
+    [] = run([{?MODULE, [enum, M, Name, T]} || T <- ED]);
+
+gen(M, Tag, {_Mod, L}) ->
+    T = retag(Tag),
+    [] = run([{?MODULE, [gen, M, T, I]} || I <- L]).
+
+%% avp_decode/3
+
+avp_decode(Mod, Type, Name) ->
+    {Eq, Vs, _} = b(values(Type, Name, Mod)),
+    [] = run([{?MODULE, [avp_decode, Mod, Name, Type, Eq, V]}
+              || V <- v(Vs)]).
+
+avp_decode(Mod, Name, Type, Eq, Value) ->
+    d(fun(X,V) -> avp(Mod, X, V, Name, Type) end, Eq, Value).
+
+avp(Mod, decode = X, V, Name, 'Grouped') ->
+    {Rec, _} = Mod:avp(X, V, Name),
+    Rec;
+avp(Mod, X, V, Name, _) ->
+    Mod:avp(X, V, Name).
+
+%% v/1
+
+%% List of values ...
+v(Vs)
+  when is_list(Vs) ->
+    Vs;
+
+%% .. or enumeration for grouped avps. This could be quite large
+%% (millions of values) but since the avps are also tested
+%% individually don't bother trying everything. Instead, choose a
+%% reasonable number of values at random.
+v(E) ->
+    v(2000, E(0), E).
+
+v(Max, Ord, E)
+  when Ord =< Max ->
+    diameter_enum:to_list(E);
+v(Max, Ord, E) ->
+    {M,S,U} = now(),
+    random:seed(M,S,U),
+    v(Max, Ord, E, []).
+
+v(0, _, _, Acc) ->
+    Acc;
+v(N, Ord, E, Acc) ->
+    v(N-1, Ord, E, [E(random:uniform(Ord)) | Acc]).
+
+%% arity/3
+
+arity(M, Name, Rname) ->
+    Rec = M:'#new-'(Rname),
+    [] = run([{?MODULE, [arity, M, Name, F, Rec]}
+              || F <- M:'#info-'(Rname, fields)]).
+
+arity(M, Name, AvpName, Rec) ->
+    Def = M:'#get-'(AvpName, Rec),
+    Def = case M:avp_arity(Name, AvpName) of
+              1 ->
+                  undefined;
+              A when 0 /= A ->
+                  []
+          end.
+
+%% enum/3
+
+enum(M, Name, {E,_}) ->
+    B = <<E:32/integer>>,
+    B = M:avp(encode, E, Name),
+    E = M:avp(decode, B, Name).
+
+retag(import_avps)   -> avp_types;
+retag(import_groups) -> grouped;
+retag(import_enums)  -> enums;
+
+retag(avp_types) -> import_avps;
+retag(enums)     -> import_enums.
+
+%% ===========================================================================
+
+d(F, Eq, V) ->
+    B = F(encode, V),
+    D = F(decode, B),
+    V = if Eq ->    %% test for value equality ...
+                D;
+           true ->  %% ... or that encode/decode is idempotent
+                D = F(decode, F(encode, D)),
+                V
+        end.
+
+z(B) ->
+    << <<0>> || <<_>> <= B >>.
+
+%% values/1
+%%
+%% Return a list of base type values. Can also be wrapped in a tuple
+%% with 'false' to indicate that encode followed by decode may not be
+%% the identity map. (Although that this composition is idempotent is
+%% tested.)
+
+values('OctetString' = T) ->
+    {["", atom_to_list(T)], [-1, 256]};
+
+values('Integer32') ->
+    Mx = (1 bsl 31) - 1,
+    Mn = -1*Mx,
+    {[Mn, 0, random(Mn,Mx), Mx], [Mn - 1, Mx + 1]};
+
+values('Integer64') ->
+    Mx = (1 bsl 63) - 1,
+    Mn = -1*Mx,
+    {[Mn, 0, random(Mn,Mx), Mx], [Mn - 1, Mx + 1]};
+
+values('Unsigned32') ->
+    M = (1 bsl 32) - 1,
+    {[0, random(M), M], [-1, M + 1]};
+
+values('Unsigned64') ->
+    M = (1 bsl 64) - 1,
+    {[0, random(M), M], [-1, M + 1]};
+
+values('Float32') ->
+    E = (1 bsl  8) - 2,
+    F = (1 bsl 23) - 1,
+    <<Mx:32/float>> = <<0:1/integer, E:8/integer, F:23/integer>>,
+    <<Mn:32/float>> = <<1:1/integer, E:8/integer, F:23/integer>>,
+    {[0.0, infinity, '-infinity', Mx, Mn], [0]};
+
+values('Float64') ->
+    E = (1 bsl 11) - 2,
+    F = (1 bsl 52) - 1,
+    <<Mx:64/float>> = <<0:1/integer, E:11/integer, F:52/integer>>,
+    <<Mn:64/float>> = <<1:1/integer, E:11/integer, F:52/integer>>,
+    {[0.0, infinity, '-infinity', Mx, Mn], [0]};
+
+values('Address') ->
+    {[{255,0,random(16#FF),1}, {65535,0,0,random(16#FFFF),0,0,0,1}],
+     [{256,0,0,1}, {65536,0,0,0,0,0,0,1}]};
+
+values('DiameterIdentity') ->
+    {["x", "diameter.com"], [""]};
+
+values('DiameterURI') ->
+    {false, ["aaa" ++ S ++ "://diameter.se" ++ P ++ Tr ++ Pr
+             || S  <- ["", "s"],
+                P  <- ["", ":1234"],
+                Tr <- ["" | [";transport=" ++ X
+                             || X <- ["tcp", "sctp", "udp"]]],
+                Pr <- ["" | [";protocol=" ++ X
+                             || X <- ["diameter","radius","tacacs+"]]]]};
+
+values(T)
+  when T == 'IPFilterRule';
+       T == 'QoSFilterRule' ->
+    ["deny in 0 from 127.0.0.1 to 10.0.0.1"];
+
+%% RFC 3629 defines the UTF-8 encoding of U+0000 through U+10FFFF with the
+%% exception of U+D800 through U+DFFF.
+values('UTF8String') ->
+    {[[],
+      lists:seq(0,16#1FF),
+      [0,16#D7FF,16#E000,16#10FFFF],
+      [random(16#D7FF), random(16#E000,16#10FFFF)]],
+     [[-1],
+      [16#D800],
+      [16#DFFF],
+      [16#110000]]};
+
+values('Time') ->
+    {[{{1968,1,20},{3,14,8}},    %% 19000101T000000 + 1 bsl 31
+      {date(), time()},
+      {{2036,2,7},{6,28,15}},
+      {{2036,2,7},{6,28,16}},    %% 19000101T000000 + 2 bsl 31
+      {{2104,2,26},{9,42,23}}],
+     [{{1968,1,20},{3,14,7}},
+      {{2104,2,26},{9,42,24}}]}. %% 19000101T000000 + 3 bsl 31
+
+%% values/3
+%%
+%% Return list or enumerations of values for a given AVP. Can be
+%% wrapped as for values/1.
+
+values('Enumerated', Name, Mod) ->
+    {_Name, Vals} = lists:keyfind(Name, 1, types(enums, Mod)),
+    lists:map(fun({N,_}) -> N end, Vals);
+
+values('Grouped', Name, Mod) ->
+    Rname = Mod:name2rec(Name),
+    Rec = Mod:'#new-'(Rname),
+    Avps = Mod:'#info-'(Rname, fields),
+    Enum = diameter_enum:combine(lists:map(fun({_,Vs,_}) -> to_enum(Vs) end,
+                                           [values(F, Mod) || F <- Avps])),
+    {false, diameter_enum:append(group(Mod, Name, Rec, Avps, Enum))};
+
+values(_, 'Framed-IP-Address', _) ->
+    [{127,0,0,1}];
+
+values(Type, _, _) ->
+    values(Type).
+
+to_enum(Vs)
+  when is_list(Vs) ->
+    diameter_enum:new(Vs);
+to_enum(E) ->
+    E.
+
+%% values/2
+
+values('AVP', _) ->
+    {true, [#diameter_avp{code = 0, data = <<0>>}], []};
+
+values(Name, Mod) ->
+    Avps = types(avp_types, Mod),
+    {Name, _Code, Type, _Flags, _Encr} = lists:keyfind(Name, 1, Avps),
+    b(values(Type, Name, Mod)).
+
+%% group/5
+%%
+%% Pack four variants of group values: tagged list containing all
+%% values, the corresponding record, a minimal tagged list and the
+%% coresponding record.
+
+group(Mod, Name, Rec, Avps, Enum) ->
+    lists:map(fun(B) -> group(Mod, Name, Rec, Avps, Enum, B) end,
+              [{A,R} || A <- ?BOOL, R <- ?BOOL]).
+
+group(Mod, Name, Rec, Avps, Enum, B) ->
+    diameter_enum:map(fun(Vs) -> g(Mod, Name, Rec, Avps, Vs, B) end, Enum).
+
+g(Mod, Name, Rec, Avps, Values, {All, AsRec}) ->
+    {Tagged, []}
+        = lists:foldl(fun(N, {A, [V|Vs]}) ->
+                              {pack(All, Mod:avp_arity(Name, N), N, V, A), Vs}
+                      end,
+                      {[], Values},
+                      Avps),
+    g(AsRec, Mod, Tagged, Rec).
+
+g(true, Mod, Vals, Rec) ->
+    Mod:'#set-'(Vals, Rec);
+g(false, _, Vals, _) ->
+    Vals.
+
+pack(true, Arity, Avp, Value, Acc) ->
+    [all(Arity, Avp, Value) | Acc];
+pack(false, Arity, Avp, Value, Acc) ->
+    min(Arity, Avp, Value, Acc).
+
+all(Mod, Name, Avp, V) ->
+    all(Mod:avp_arity(Name, Avp), Avp, V).
+
+all(1, Avp, V) ->
+    {Avp, V};
+all({0,'*'}, Avp, V) ->
+    a(1, Avp, V);
+all({N,'*'}, Avp, V) ->
+    a(N, Avp, V);
+all({_,N}, Avp, V) ->
+    a(N, Avp, V).
+
+a(N, Avp, V)
+  when N /= 0 ->
+    {Avp, lists:duplicate(N,V)}.
+
+min(Mod, Name, Avp, V, Acc) ->
+    min(Mod:avp_arity(Name, Avp), Avp, V, Acc).
+
+min(1, Avp, V, Acc) ->
+    [{Avp, V} | Acc];
+min({0,_}, _, _, Acc) ->
+    Acc;
+min({N,_}, Avp, V, Acc) ->
+    [{Avp, lists:duplicate(N,V)} | Acc].
+
+%% types/2
+
+types(T, Mod) ->
+    types(T, retag(T), Mod).
+
+types(T, IT, Mod) ->
+    Dict = Mod:dict(),
+    fetch(T, Dict) ++ lists:flatmap(fun({_,As}) -> As end, fetch(IT, Dict)).
+
+%% random/[12]
+
+random(M) ->
+    random(0,M).
+
+random(Mn,Mx) ->
+    seed(get({?MODULE, seed})),
+    Mn + random:uniform(Mx - Mn + 1) - 1.
+
+seed(undefined) ->
+    put({?MODULE, seed}, true),
+    random:seed(now());
+
+seed(true) ->
+    ok.
+
+%% run/1
+%%
+%% Unravel nested badmatches resulting from [] matches on calls to
+%% run/1 to make for more readable failures.
+
+run(L) ->
+    lists:flatmap(fun flatten/1, diameter_util:run(L)).
+
+flatten({_, {{badmatch, [{_, {{badmatch, _}, _}} | _] = L}, _}}) ->
+    L;
+flatten(T) ->
+    [T].