Skip to content

Commit

Permalink
switch all eunit to ct
Browse files Browse the repository at this point in the history
  • Loading branch information
Rahul Garg committed Jun 5, 2018
1 parent 4bc7341 commit e6b33be
Show file tree
Hide file tree
Showing 10 changed files with 793 additions and 724 deletions.
243 changes: 1 addition & 242 deletions src/hbbft.erl
View file

Large diffs are not rendered by default.

28 changes: 0 additions & 28 deletions src/hbbft_acs.erl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -245,31 +245,3 @@ serialize_bba_state(#bba_state{bba_data=BBAData, input=Input, result=Result}) ->
-spec deserialize_bba_state(bba_serialized_state(), tpke_privkey:privkey()) -> bba_state().
deserialize_bba_state(#bba_serialized_state{bba_data=BBAData, input=Input, result=Result}, SK) ->
#bba_state{bba_data=hbbft_bba:deserialize(BBAData, SK), input=Input, result=Result}.

-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").

init_test_() ->
{timeout, 60, [
fun() ->
N = 5,
F = N div 4,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
Msgs = [ crypto:strong_rand_bytes(512) || _ <- lists:seq(1, N)],
StatesWithId = [{J, hbbft_acs:init(Sk, N, F, J)} || {J, Sk} <- lists:zip(lists:seq(0, N - 1), PrivateKeys)],
MixedList = lists:zip(Msgs, StatesWithId),
Res = lists:map(fun({Msg, {J, State}}) ->
{NewState, Result} = input(State, Msg),
{{J, NewState}, {J, Result}}
end, MixedList),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
?assertEqual(N, sets:size(ConvergedResults)),
DistinctResults = sets:from_list([BVal || {result, {_, BVal}} <- sets:to_list(ConvergedResults)]),
?assertEqual(1, sets:size(DistinctResults)),
?assert(sets:is_subset(sets:from_list([ X || {_, X} <- lists:flatten(sets:to_list(DistinctResults))]), sets:from_list(Msgs))),
ok
end]}.
-endif.
160 changes: 0 additions & 160 deletions src/hbbft_bba.erl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -350,163 +350,3 @@ val(2#10) -> 1.
add_witness(Id, Value, Witness) ->
Old = maps:get(Id, Witness, 0),
maps:put(Id, add(Value, Old), Witness).

-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").

init_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
States = [hbbft_bba:init(Sk, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, length(States) - 1), States),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = input(State, 1),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% everyone should converge
?assertEqual(N, sets:size(ConvergedResults)),
ok.

init_with_zeroes_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
States = [hbbft_bba:init(Sk, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, length(States) - 1), States),
ZeroList = lists:zip([1, 0, 0, 0, 0], StatesWithId),
%% all valid members should call get_coin
Res = lists:map(fun({I, {J, State}}) ->
{NewState, Result} = input(State, I),
{{J, NewState}, {J, Result}}
end, ZeroList),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
DistinctResults = sets:from_list([BVal || {result, {_, BVal}} <- sets:to_list(ConvergedResults)]),
?assertEqual(N, sets:size(ConvergedResults)),
?assertEqual([0], sets:to_list(DistinctResults)),
ok.

init_with_ones_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
States = [hbbft_bba:init(Sk, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, length(States) - 1), States),
OneList = lists:zip([1, 1, 1, 1, 0], StatesWithId),
%% all valid members should call get_coin
Res = lists:map(fun({I, {J, State}}) ->
{NewState, Result} = input(State, I),
{{J, NewState}, {J, Result}}
end, OneList),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
DistinctResults = sets:from_list([BVal || {result, {_, BVal}} <- sets:to_list(ConvergedResults)]),
?assertEqual(N, sets:size(ConvergedResults)),
?assertEqual([1], sets:to_list(DistinctResults)),
ok.

init_with_mixed_zeros_and_ones_test_() ->
{timeout, 60, fun() ->
N = 10,
F = 2,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
States = [hbbft_bba:init(Sk, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, length(States) - 1), States),
MixedList = lists:zip([1, 1, 1, 0, 1, 0, 0, 0, 0, 0], StatesWithId),
%% all valid members should call get_coin
Res = lists:map(fun({I, {J, State}}) ->
{NewState, Result} = input(State, I),
{{J, NewState}, {J, Result}}
end, MixedList),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
DistinctResults = sets:from_list([BVal || {result, {_, BVal}} <- sets:to_list(ConvergedResults)]),
?assertEqual(N, sets:size(ConvergedResults)),
?assertEqual(1, sets:size(DistinctResults)),
ok
end}.

termination_test_() ->
Fun = fun(Vals) ->
fun() ->
N = 7,
F = 2,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
States = [hbbft_bba:init(Sk, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, length(States) - 1), States),
MixedList = lists:zip(Vals, StatesWithId),
%% all valid members should call get_coin
Res = lists:map(fun({I, {J, State}}) ->
{NewState, Result} = input(State, I),
{{J, NewState}, {J, Result}}
end, MixedList),
{NewStates, Results} = lists:unzip(Res),
{_FinalStates, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
DistinctResults = sets:from_list([BVal || {result, {_, BVal}} <- sets:to_list(ConvergedResults)]),
?assertEqual(N, sets:size(ConvergedResults)),
?assertEqual(1, sets:size(DistinctResults)),
ok
end
end,
[
Fun([1, 0, 0, 0, 0, 0, 0]),
Fun([1, 1, 0, 0, 0, 0, 0]),
Fun([1, 1, 1, 0, 0, 0, 0]),
Fun([1, 1, 1, 1, 0, 0, 0]),
Fun([1, 1, 1, 1, 1, 0, 0]),
Fun([1, 1, 1, 1, 1, 1, 0]),
Fun([1, 1, 1, 1, 1, 1, 1])
].

one_dead_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
[S0, S1, _S2, S3, S4] = [hbbft_bba:init(Sk, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, N - 2), [S0, S1, S3, S4]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = input(State, 1),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% everyone but one should converge
?assertEqual(N - 1, sets:size(ConvergedResults)),
ok.

two_dead_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, _PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
[S0, S1, _S2, S3, _S4] = [hbbft_bba:init(Sk, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, N - 3), [S0, S1, S3]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = input(State, 1),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% should not converge
?assertEqual(0, sets:size(ConvergedResults)),
ok.
-endif.
167 changes: 0 additions & 167 deletions src/hbbft_cc.erl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -114,170 +114,3 @@ serialize_shares(Shares) ->
-spec deserialize_shares(#{non_neg_integer() => binary()}, tpke_privkey:privkey()) -> #{non_neg_integer() => tpke_privkey:share()}.
deserialize_shares(Shares, SK) ->
maps:map(fun(_K, V) -> hbbft_utils:binary_to_share(V, SK) end, Shares).

-ifdef(TEST).
-include_lib("eunit/include/eunit.hrl").

init_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
Sid = tpke_pubkey:hash_message(PubKey, crypto:strong_rand_bytes(32)),
States = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, length(States) - 1), States),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = get_coin(State),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% everyone should converge
?assertEqual(N, sets:size(ConvergedResults)),
ok.

one_dead_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
Sid = tpke_pubkey:hash_message(PubKey, crypto:strong_rand_bytes(32)),
[S0, S1, _S2, S3, S4] = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, N - 2), [S0, S1, S3, S4]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = get_coin(State),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% everyone but one should converge
?assertEqual(N - 1, sets:size(ConvergedResults)),
%% everyone should have the same value
DistinctResults = lists:usort([ Sig || {result, {_J, Sig}} <- sets:to_list(ConvergedResults) ]),
?assertEqual(1, length(DistinctResults)),
ok.

two_dead_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
Sid = tpke_pubkey:hash_message(PubKey, crypto:strong_rand_bytes(32)),
[S0, S1, _S2, S3, _S4] = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, N - 3), [S0, S1, S3]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = get_coin(State),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% everyone but two should converge
?assertEqual(N - 2, sets:size(ConvergedResults)),
%% everyone should have the same value
DistinctResults = lists:usort([ Sig || {result, {_J, Sig}} <- sets:to_list(ConvergedResults) ]),
?assertEqual(1, length(DistinctResults)),
ok.

too_many_dead_test() ->
N = 5,
F = 4,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, PubKey, PrivateKeys} = dealer:deal(Dealer),
gen_server:stop(Dealer),
Sid = tpke_pubkey:hash_message(PubKey, crypto:strong_rand_bytes(32)),
[S0, S1, _S2, S3, _S4] = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- PrivateKeys],
StatesWithId = lists:zip(lists:seq(0, N - 3), [S0, S1, S3]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = get_coin(State),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% nobody should converge
?assertEqual(0, sets:size(ConvergedResults)),
ok.

key_mismatch_f1_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, PubKey, PrivateKeys} = dealer:deal(Dealer),
{ok, _, PrivateKeys2} = dealer:deal(Dealer),
gen_server:stop(Dealer),
Sid = tpke_pubkey:hash_message(PubKey, crypto:strong_rand_bytes(32)),
[S0, S1, S2, S3, S4] = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- lists:sublist(PrivateKeys, 3) ++ lists:sublist(PrivateKeys2, 2)],
StatesWithId = lists:zip(lists:seq(0, N - 1), [S0, S1, S2, S3, S4]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = get_coin(State),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% all 5 should converge, but there should be 2 distinct results
?assertEqual(5, sets:size(ConvergedResults)),
DistinctResults = lists:usort([ Sig || {result, {_J, Sig}} <- sets:to_list(ConvergedResults) ]),
?assertEqual(2, length(DistinctResults)),
ok.


key_mismatch_f2_test() ->
N = 5,
F = 2,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, PubKey, PrivateKeys} = dealer:deal(Dealer),
{ok, _, PrivateKeys2} = dealer:deal(Dealer),
gen_server:stop(Dealer),
Sid = tpke_pubkey:hash_message(PubKey, crypto:strong_rand_bytes(32)),
[S0, S1, S2, S3, S4] = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- lists:sublist(PrivateKeys, 3) ++ lists:sublist(PrivateKeys2, 2)],
StatesWithId = lists:zip(lists:seq(0, N - 1), [S0, S1, S2, S3, S4]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = get_coin(State),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),
%% the 3 with the right keys should converge to the same value
?assertEqual(3, sets:size(ConvergedResults)),
DistinctResults = lists:usort([ Sig || {result, {_J, Sig}} <- sets:to_list(ConvergedResults) ]),
?assertEqual(1, length(DistinctResults)),
ok.

mixed_keys_test() ->
N = 5,
F = 1,
{ok, Dealer} = dealer:start_link(N, F+1, 'SS512'),
{ok, PubKey, PrivateKeys} = dealer:deal(Dealer),
{ok, _, PrivateKeys2} = dealer:deal(Dealer),
gen_server:stop(Dealer),

Sid = tpke_pubkey:hash_message(PubKey, crypto:strong_rand_bytes(32)),

[S0, S1, S2, _, _] = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- PrivateKeys],
[_, _, _, S3, S4] = [hbbft_cc:init(Sk, Sid, N, F) || Sk <- PrivateKeys2],

StatesWithId = lists:zip(lists:seq(0, N - 1), [S0, S1, S2, S3, S4]),
%% all valid members should call get_coin
Res = lists:map(fun({J, State}) ->
{NewState, Result} = get_coin(State),
{{J, NewState}, {J, Result}}
end, StatesWithId),
{NewStates, Results} = lists:unzip(Res),
{_, ConvergedResults} = hbbft_test_utils:do_send_outer(?MODULE, Results, NewStates, sets:new()),

DistinctCoins = sets:from_list([Coin || {result, {_, Coin}} <- sets:to_list(ConvergedResults)]),
%% two distinct sets have converged with different coins each
?assertEqual(2, sets:size(DistinctCoins)),

%% everyone but two should converge
?assertEqual(N, sets:size(ConvergedResults)),
ok.
-endif.
Loading

0 comments on commit e6b33be

Please sign in to comment.