THRIFT-5635 Update erlang client for Erlang 23-25
Client: erl
Patch: Sergey Yelin
This closes #2677
Summary of changes:
- Add useful compiler options
- Format sources using erlfmt
- Switch to modern callbacks in thrift_* modules
- Add static analysis (dialyzer), disabled by default
- Add/fix types for API calls
NOTE: Enabling static analysis requires additional tweaks in multiplexer module.
diff --git a/lib/erl/test/legacy_names_test.erl b/lib/erl/test/legacy_names_test.erl
index c16aa3e..9076ffb 100644
--- a/lib/erl/test/legacy_names_test.erl
+++ b/lib/erl/test/legacy_names_test.erl
@@ -18,52 +18,58 @@
%%
-module(legacy_names_test).
--compile(export_all).
-include_lib("eunit/include/eunit.hrl").
-include("gen-erl/legacyNames_constants.hrl").
record_generation_test_() ->
- [
- {"capitalizedStruct record", ?_assertMatch(
- {capitalizedStruct, _, _},
- #capitalizedStruct{id=null,message=null}
- )}
- ].
+ [
+ {"capitalizedStruct record",
+ ?_assertMatch(
+ {capitalizedStruct, _, _},
+ #capitalizedStruct{id = null, message = null}
+ )}
+ ].
struct_info_test_() ->
- [
- {"capitalizedStruct extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, i32, 'id', undefined},
- {2, undefined, string, 'message', undefined}
- ]},
- legacyNames_types:struct_info_ext(capitalizedStruct)
- )},
- {"listCapitalizedStructs extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, {struct, {'legacyNames_types', 'capitalizedStruct'}}}, 'structs', []}
- ]},
- legacyNames_types:struct_info_ext(listCapitalizedStructs)
- )}
- ].
+ [
+ {"capitalizedStruct extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, i32, 'id', undefined},
+ {2, undefined, string, 'message', undefined}
+ ]},
+ legacyNames_types:struct_info_ext(capitalizedStruct)
+ )},
+ {"listCapitalizedStructs extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {list, {struct, {'legacyNames_types', 'capitalizedStruct'}}},
+ 'structs', []}
+ ]},
+ legacyNames_types:struct_info_ext(listCapitalizedStructs)
+ )}
+ ].
service_info_test_() ->
- [
- {"names params", ?_assertEqual(
- {struct, [
- {1, {struct, {'legacyNames_types', 'capitalizedStruct'}}},
- {2, {struct, {'legacyNames_types', 'capitalizedStruct'}}}
- ]},
- legacyNames_thrift:function_info(names, params_type)
- )},
- {"names reply", ?_assertEqual(
- {struct, {'legacyNames_types', 'listCapitalizedStructs'}},
- legacyNames_thrift:function_info(names, reply_type)
- )},
- {"names exceptions", ?_assertEqual(
- {struct, [{1, {struct, {'legacyNames_types', 'xception'}}}]},
- legacyNames_thrift:function_info(names, exceptions)
- )}
- ].
+ [
+ {"names params",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {'legacyNames_types', 'capitalizedStruct'}}},
+ {2, {struct, {'legacyNames_types', 'capitalizedStruct'}}}
+ ]},
+ legacyNames_thrift:function_info(names, params_type)
+ )},
+ {"names reply",
+ ?_assertEqual(
+ {struct, {'legacyNames_types', 'listCapitalizedStructs'}},
+ legacyNames_thrift:function_info(names, reply_type)
+ )},
+ {"names exceptions",
+ ?_assertEqual(
+ {struct, [{1, {struct, {'legacyNames_types', 'xception'}}}]},
+ legacyNames_thrift:function_info(names, exceptions)
+ )}
+ ].
diff --git a/lib/erl/test/multiplexing_test.erl b/lib/erl/test/multiplexing_test.erl
index 0f2d616..5752e53 100644
--- a/lib/erl/test/multiplexing_test.erl
+++ b/lib/erl/test/multiplexing_test.erl
@@ -1,19 +1,37 @@
+%%
+%% Licensed to the Apache Software Foundation (ASF) under one
+%% or more contributor license agreements. See the NOTICE file
+%% distributed with this work for additional information
+%% regarding copyright ownership. The ASF licenses this file
+%% to you 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(multiplexing_test).
-include_lib("eunit/include/eunit.hrl").
-export([
- handle_function/2
- ,handle_error/2
+ handle_function/2,
+ handle_error/2
]).
start_multiplexed_server_test() ->
-
Port = 9090,
Services = [
- {"Multiplexing_Calculator", multiplexing__calculator_thrift},
- {"Multiplexing_WeatherReport", multiplexing__weather_report_thrift}
- ],
+ {"Multiplexing_Calculator", multiplexing__calculator_thrift},
+ {"Multiplexing_WeatherReport", multiplexing__weather_report_thrift}
+ ],
{ok, Pid} = thrift_socket_server:start([
{ip, "127.0.0.1"},
@@ -21,21 +39,32 @@
{name, ?MODULE},
{service, Services},
{handler, [
- {"error_handler", ?MODULE},
- {"Multiplexing_Calculator", ?MODULE},
+ {"error_handler", ?MODULE},
+ {"Multiplexing_Calculator", ?MODULE},
{"Multiplexing_WeatherReport", ?MODULE}
]}
- ]),
+ ]),
- {ok, [{"Multiplexing_Calculator", CalculatorClient0},
- {"Multiplexing_WeatherReport", WeatherReportClient0}]} = thrift_client_util:new_multiplexed("127.0.0.1", Port, Services, []),
+ {ok, [
+ {"Multiplexing_Calculator", CalculatorClient0},
+ {"Multiplexing_WeatherReport", WeatherReportClient0}
+ ]} = thrift_client_util:new_multiplexed("127.0.0.1", Port, Services, []),
- ?assertMatch({_, {error, {bad_args, _, _}}}, thrift_client:call(WeatherReportClient0, getTemperature, [1])),
+ ?assertMatch(
+ {_, {error, {bad_args, _, _}}},
+ thrift_client:call(WeatherReportClient0, getTemperature, [1])
+ ),
?assertMatch({_, {error, {bad_args, _, _}}}, thrift_client:call(CalculatorClient0, add, [1])),
- ?assertMatch({_, {error, {bad_args, _, _}}}, thrift_client:call(CalculatorClient0, add, [1,1,1])),
+ ?assertMatch(
+ {_, {error, {bad_args, _, _}}}, thrift_client:call(CalculatorClient0, add, [1, 1, 1])
+ ),
- ?assertMatch({_, {error, {no_function, _}}}, thrift_client:call(CalculatorClient0, getTemperature, [])),
- ?assertMatch({_, {error, {no_function, _}}}, thrift_client:call(WeatherReportClient0, add, [41, 1])),
+ ?assertMatch(
+ {_, {error, {no_function, _}}}, thrift_client:call(CalculatorClient0, getTemperature, [])
+ ),
+ ?assertMatch(
+ {_, {error, {no_function, _}}}, thrift_client:call(WeatherReportClient0, add, [41, 1])
+ ),
?assertMatch({_, {ok, 42}}, thrift_client:call(CalculatorClient0, add, [41, 1])),
?assertMatch({_, {ok, 42.0}}, thrift_client:call(WeatherReportClient0, getTemperature, [])),
@@ -47,11 +76,10 @@
%% Calculator handles
handle_function(add, {X, Y}) ->
{reply, X + Y};
-
%% WeatherReport handles
handle_function(getTemperature, {}) ->
{reply, 42.0}.
handle_error(_F, _Reason) ->
-%% ?debugHere, ?debugVal({_F, _Reason}),
- ok.
\ No newline at end of file
+ %% ?debugHere, ?debugVal({_F, _Reason}),
+ ok.
diff --git a/lib/erl/test/name_conflict_test.erl b/lib/erl/test/name_conflict_test.erl
index b01df57..30c1a8e 100644
--- a/lib/erl/test/name_conflict_test.erl
+++ b/lib/erl/test/name_conflict_test.erl
@@ -18,282 +18,333 @@
%%
-module(name_conflict_test).
--compile(export_all).
-include_lib("eunit/include/eunit.hrl").
-include("gen-erl/name_conflict_test_constants.hrl").
record_generation_test_() ->
- [
- {"using record", ?_assertMatch(
- {using, _, _},
- #using{single=null,integer=null}
- )},
- {"delegate record", ?_assertMatch(
- {delegate, _, _},
- #delegate{partial=null,delegate=null}
- )},
- {"get record", ?_assertMatch(
- {get, _},
- #get{sbyte=null}
- )},
- {"partial record", ?_assertMatch(
- {partial, _, _, _},
- #partial{using=null}
- )},
- {"ClassAndProp record", ?_assertMatch(
- {'ClassAndProp', _, _, _, _},
- #'ClassAndProp'{
- 'ClassAndProp'=null,
- 'ClassAndProp_'=null,
- 'ClassAndProp__'=null,
- 'ClassAndProper'=null
- }
- )},
- {"second_chance record", ?_assertMatch(
- {second_chance, _, _, _, _},
- #second_chance{
- 'SECOND_CHANCE'=null,
- 'SECOND_CHANCE_'=null,
- 'SECOND_CHANCE__'=null,
- 'SECOND_CHANCES'=null
- }
- )},
- {"NOW_EAT_THIS record", ?_assertMatch(
- {'NOW_EAT_THIS', _, _, _, _},
- #'NOW_EAT_THIS'{
- now_eat_this=null,
- now_eat_this_=null,
- now_eat_this__=null,
- now_eat_this_and_this=null
- }
- )},
- {"TheEdgeCase record", ?_assertMatch(
- {'TheEdgeCase', _, _, _, _, _, _},
- #'TheEdgeCase'{
- theEdgeCase=null,
- theEdgeCase_=null,
- theEdgeCase__=null,
- 'TheEdgeCase'=null,
- 'TheEdgeCase_'=null,
- 'TheEdgeCase__'=null
- }
- )},
- {"Tricky_ record", ?_assertMatch(
- {'Tricky_', _, _},
- #'Tricky_'{tricky=null,'Tricky'=null}
- )},
- {"Nested record", ?_assertMatch(
- {'Nested', _, _, _, _, _, _},
- #'Nested'{
- 'ClassAndProp'=null,
- second_chance=null,
- 'NOW_EAT_THIS'=null,
- 'TheEdgeCase'=null,
- 'Tricky_'=null,
- 'Nested'=null
- }
- )},
- {"Problem_ record", ?_assertMatch(
- {'Problem_', _, _},
- #'Problem_'{problem=null,'Problem'=null}
- )}
- ].
+ [
+ {"using record",
+ ?_assertMatch(
+ {using, _, _},
+ #using{single = null, integer = null}
+ )},
+ {"delegate record",
+ ?_assertMatch(
+ {delegate, _, _},
+ #delegate{partial = null, delegate = null}
+ )},
+ {"get record",
+ ?_assertMatch(
+ {get, _},
+ #get{sbyte = null}
+ )},
+ {"partial record",
+ ?_assertMatch(
+ {partial, _, _, _},
+ #partial{using = null}
+ )},
+ {"ClassAndProp record",
+ ?_assertMatch(
+ {'ClassAndProp', _, _, _, _},
+ #'ClassAndProp'{
+ 'ClassAndProp' = null,
+ 'ClassAndProp_' = null,
+ 'ClassAndProp__' = null,
+ 'ClassAndProper' = null
+ }
+ )},
+ {"second_chance record",
+ ?_assertMatch(
+ {second_chance, _, _, _, _},
+ #second_chance{
+ 'SECOND_CHANCE' = null,
+ 'SECOND_CHANCE_' = null,
+ 'SECOND_CHANCE__' = null,
+ 'SECOND_CHANCES' = null
+ }
+ )},
+ {"NOW_EAT_THIS record",
+ ?_assertMatch(
+ {'NOW_EAT_THIS', _, _, _, _},
+ #'NOW_EAT_THIS'{
+ now_eat_this = null,
+ now_eat_this_ = null,
+ now_eat_this__ = null,
+ now_eat_this_and_this = null
+ }
+ )},
+ {"TheEdgeCase record",
+ ?_assertMatch(
+ {'TheEdgeCase', _, _, _, _, _, _},
+ #'TheEdgeCase'{
+ theEdgeCase = null,
+ theEdgeCase_ = null,
+ theEdgeCase__ = null,
+ 'TheEdgeCase' = null,
+ 'TheEdgeCase_' = null,
+ 'TheEdgeCase__' = null
+ }
+ )},
+ {"Tricky_ record",
+ ?_assertMatch(
+ {'Tricky_', _, _},
+ #'Tricky_'{tricky = null, 'Tricky' = null}
+ )},
+ {"Nested record",
+ ?_assertMatch(
+ {'Nested', _, _, _, _, _, _},
+ #'Nested'{
+ 'ClassAndProp' = null,
+ second_chance = null,
+ 'NOW_EAT_THIS' = null,
+ 'TheEdgeCase' = null,
+ 'Tricky_' = null,
+ 'Nested' = null
+ }
+ )},
+ {"Problem_ record",
+ ?_assertMatch(
+ {'Problem_', _, _},
+ #'Problem_'{problem = null, 'Problem' = null}
+ )}
+ ].
struct_info_test_() ->
- [
- {"using definition", ?_assertEqual(
- {struct, [{1, double},{2, double}]},
- name_conflict_test_types:struct_info(using)
- )},
- {"delegate definition", ?_assertEqual(
- {struct, [
- {1, string},
- {2, {struct, {name_conflict_test_types, delegate}}}
- ]},
- name_conflict_test_types:struct_info(delegate)
- )},
- {"get definition", ?_assertEqual(
- {struct, [{1, bool}]},
- name_conflict_test_types:struct_info(get)
- )},
- {"partial definition", ?_assertEqual(
- {struct, [
- {1, {struct, {name_conflict_test_types, using}}},
- {2, bool},
- {3, bool}
- ]},
- name_conflict_test_types:struct_info(partial)
- )},
- {"ClassAndProp definition", ?_assertEqual(
- {struct, [{1, bool},{2, bool},{3, bool},{4, bool}]},
- name_conflict_test_types:struct_info('ClassAndProp')
- )},
- {"second_chance definition", ?_assertEqual(
- {struct, [{1, bool},{2, bool},{3, bool},{4, bool}]},
- name_conflict_test_types:struct_info(second_chance)
- )},
- {"NOW_EAT_THIS definition", ?_assertEqual(
- {struct, [{1, bool},{2, bool},{3, bool},{4, bool}]},
- name_conflict_test_types:struct_info('NOW_EAT_THIS')
- )},
- {"TheEdgeCase definition", ?_assertEqual(
- {struct, [{1, bool},{2, bool},{3, bool},{4, bool},{5, bool},{6, bool}]},
- name_conflict_test_types:struct_info('TheEdgeCase')
- )},
- {"Tricky_ definition", ?_assertEqual(
- {struct, [{1, bool},{2, bool}]},
- name_conflict_test_types:struct_info('Tricky_')
- )},
- {"Nested definition", ?_assertEqual(
- {struct, [
- {1, {struct, {name_conflict_test_types, 'ClassAndProp'}}},
- {2, {struct, {name_conflict_test_types, second_chance}}},
- {3, {struct, {name_conflict_test_types, 'NOW_EAT_THIS'}}},
- {4, {struct, {name_conflict_test_types, 'TheEdgeCase'}}},
- {5, {struct, {name_conflict_test_types, 'Tricky_'}}},
- {6, {struct, {name_conflict_test_types, 'Nested'}}}
- ]},
- name_conflict_test_types:struct_info('Nested')
- )},
- {"Problem_ definition", ?_assertEqual(
- {struct, [{1, bool},{2, bool}]},
- name_conflict_test_types:struct_info('Problem_')
- )},
- {"using extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, double, single, undefined},
- {2, undefined, double, integer, undefined}
- ]},
- name_conflict_test_types:struct_info_ext(using)
- )},
- {"delegate extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, string, partial, undefined},
- {2, undefined, {struct, {name_conflict_test_types, delegate}}, delegate, undefined}
- ]},
- name_conflict_test_types:struct_info_ext(delegate)
- )},
- {"get extended definition", ?_assertEqual(
- {struct, [{1, undefined, bool, sbyte, undefined}]},
- name_conflict_test_types:struct_info_ext(get)
- )},
- {"partial extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, {struct, {name_conflict_test_types, using}}, using, #using{}},
- {2, undefined, bool, read, undefined},
- {3, undefined, bool, write, undefined}
- ]},
- name_conflict_test_types:struct_info_ext(partial)
- )},
- {"ClassAndProp extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, bool, 'ClassAndProp', undefined},
- {2, undefined, bool, 'ClassAndProp_', undefined},
- {3, undefined, bool, 'ClassAndProp__', undefined},
- {4, undefined, bool, 'ClassAndProper', undefined}
- ]},
- name_conflict_test_types:struct_info_ext('ClassAndProp')
- )},
- {"second_chance extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, bool, 'SECOND_CHANCE', undefined},
- {2, undefined, bool, 'SECOND_CHANCE_', undefined},
- {3, undefined, bool, 'SECOND_CHANCE__', undefined},
- {4, undefined, bool, 'SECOND_CHANCES', undefined}
- ]},
- name_conflict_test_types:struct_info_ext(second_chance)
- )},
- {"NOW_EAT_THIS extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, bool, now_eat_this, undefined},
- {2, undefined, bool, now_eat_this_, undefined},
- {3, undefined, bool, now_eat_this__, undefined},
- {4, undefined, bool, now_eat_this_and_this, undefined}
- ]},
- name_conflict_test_types:struct_info_ext('NOW_EAT_THIS')
- )},
- {"TheEdgeCase extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, bool, theEdgeCase, undefined},
- {2, undefined, bool, theEdgeCase_, undefined},
- {3, undefined, bool, theEdgeCase__, undefined},
- {4, undefined, bool, 'TheEdgeCase', undefined},
- {5, undefined, bool, 'TheEdgeCase_', undefined},
- {6, undefined, bool, 'TheEdgeCase__', undefined}
- ]},
- name_conflict_test_types:struct_info_ext('TheEdgeCase')
- )},
- {"Tricky_ extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, bool, tricky, undefined},
- {2, undefined, bool, 'Tricky', undefined}
- ]},
- name_conflict_test_types:struct_info_ext('Tricky_')
- )},
- {"Nested extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, {struct, {
- name_conflict_test_types,
- 'ClassAndProp'
- }}, 'ClassAndProp', #'ClassAndProp'{}},
- {2, undefined, {struct, {
- name_conflict_test_types,
- second_chance
- }}, second_chance, #second_chance{}},
- {3, undefined, {struct, {
- name_conflict_test_types,
- 'NOW_EAT_THIS'
- }}, 'NOW_EAT_THIS', #'NOW_EAT_THIS'{}},
- {4, undefined, {struct, {
- name_conflict_test_types,
- 'TheEdgeCase'
- }}, 'TheEdgeCase', #'TheEdgeCase'{}},
- {5, undefined, {struct, {
- name_conflict_test_types,
- 'Tricky_'
- }}, 'Tricky_', #'Tricky_'{}},
- {6, undefined, {struct, {
- name_conflict_test_types,
- 'Nested'
- }}, 'Nested', undefined}
- ]},
- name_conflict_test_types:struct_info_ext('Nested')
- )},
- {"Problem_ extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, bool, problem, undefined},
- {2, undefined, bool, 'Problem', undefined}
- ]},
- name_conflict_test_types:struct_info_ext('Problem_')
- )}
- ].
+ [
+ {"using definition",
+ ?_assertEqual(
+ {struct, [{1, double}, {2, double}]},
+ name_conflict_test_types:struct_info(using)
+ )},
+ {"delegate definition",
+ ?_assertEqual(
+ {struct, [
+ {1, string},
+ {2, {struct, {name_conflict_test_types, delegate}}}
+ ]},
+ name_conflict_test_types:struct_info(delegate)
+ )},
+ {"get definition",
+ ?_assertEqual(
+ {struct, [{1, bool}]},
+ name_conflict_test_types:struct_info(get)
+ )},
+ {"partial definition",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {name_conflict_test_types, using}}},
+ {2, bool},
+ {3, bool}
+ ]},
+ name_conflict_test_types:struct_info(partial)
+ )},
+ {"ClassAndProp definition",
+ ?_assertEqual(
+ {struct, [{1, bool}, {2, bool}, {3, bool}, {4, bool}]},
+ name_conflict_test_types:struct_info('ClassAndProp')
+ )},
+ {"second_chance definition",
+ ?_assertEqual(
+ {struct, [{1, bool}, {2, bool}, {3, bool}, {4, bool}]},
+ name_conflict_test_types:struct_info(second_chance)
+ )},
+ {"NOW_EAT_THIS definition",
+ ?_assertEqual(
+ {struct, [{1, bool}, {2, bool}, {3, bool}, {4, bool}]},
+ name_conflict_test_types:struct_info('NOW_EAT_THIS')
+ )},
+ {"TheEdgeCase definition",
+ ?_assertEqual(
+ {struct, [{1, bool}, {2, bool}, {3, bool}, {4, bool}, {5, bool}, {6, bool}]},
+ name_conflict_test_types:struct_info('TheEdgeCase')
+ )},
+ {"Tricky_ definition",
+ ?_assertEqual(
+ {struct, [{1, bool}, {2, bool}]},
+ name_conflict_test_types:struct_info('Tricky_')
+ )},
+ {"Nested definition",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {name_conflict_test_types, 'ClassAndProp'}}},
+ {2, {struct, {name_conflict_test_types, second_chance}}},
+ {3, {struct, {name_conflict_test_types, 'NOW_EAT_THIS'}}},
+ {4, {struct, {name_conflict_test_types, 'TheEdgeCase'}}},
+ {5, {struct, {name_conflict_test_types, 'Tricky_'}}},
+ {6, {struct, {name_conflict_test_types, 'Nested'}}}
+ ]},
+ name_conflict_test_types:struct_info('Nested')
+ )},
+ {"Problem_ definition",
+ ?_assertEqual(
+ {struct, [{1, bool}, {2, bool}]},
+ name_conflict_test_types:struct_info('Problem_')
+ )},
+ {"using extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, double, single, undefined},
+ {2, undefined, double, integer, undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext(using)
+ )},
+ {"delegate extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, string, partial, undefined},
+ {2, undefined, {struct, {name_conflict_test_types, delegate}}, delegate,
+ undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext(delegate)
+ )},
+ {"get extended definition",
+ ?_assertEqual(
+ {struct, [{1, undefined, bool, sbyte, undefined}]},
+ name_conflict_test_types:struct_info_ext(get)
+ )},
+ {"partial extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {struct, {name_conflict_test_types, using}}, using, #using{}},
+ {2, undefined, bool, read, undefined},
+ {3, undefined, bool, write, undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext(partial)
+ )},
+ {"ClassAndProp extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, bool, 'ClassAndProp', undefined},
+ {2, undefined, bool, 'ClassAndProp_', undefined},
+ {3, undefined, bool, 'ClassAndProp__', undefined},
+ {4, undefined, bool, 'ClassAndProper', undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext('ClassAndProp')
+ )},
+ {"second_chance extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, bool, 'SECOND_CHANCE', undefined},
+ {2, undefined, bool, 'SECOND_CHANCE_', undefined},
+ {3, undefined, bool, 'SECOND_CHANCE__', undefined},
+ {4, undefined, bool, 'SECOND_CHANCES', undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext(second_chance)
+ )},
+ {"NOW_EAT_THIS extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, bool, now_eat_this, undefined},
+ {2, undefined, bool, now_eat_this_, undefined},
+ {3, undefined, bool, now_eat_this__, undefined},
+ {4, undefined, bool, now_eat_this_and_this, undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext('NOW_EAT_THIS')
+ )},
+ {"TheEdgeCase extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, bool, theEdgeCase, undefined},
+ {2, undefined, bool, theEdgeCase_, undefined},
+ {3, undefined, bool, theEdgeCase__, undefined},
+ {4, undefined, bool, 'TheEdgeCase', undefined},
+ {5, undefined, bool, 'TheEdgeCase_', undefined},
+ {6, undefined, bool, 'TheEdgeCase__', undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext('TheEdgeCase')
+ )},
+ {"Tricky_ extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, bool, tricky, undefined},
+ {2, undefined, bool, 'Tricky', undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext('Tricky_')
+ )},
+ {"Nested extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined,
+ {struct, {
+ name_conflict_test_types,
+ 'ClassAndProp'
+ }},
+ 'ClassAndProp', #'ClassAndProp'{}},
+ {2, undefined,
+ {struct, {
+ name_conflict_test_types,
+ second_chance
+ }},
+ second_chance, #second_chance{}},
+ {3, undefined,
+ {struct, {
+ name_conflict_test_types,
+ 'NOW_EAT_THIS'
+ }},
+ 'NOW_EAT_THIS', #'NOW_EAT_THIS'{}},
+ {4, undefined,
+ {struct, {
+ name_conflict_test_types,
+ 'TheEdgeCase'
+ }},
+ 'TheEdgeCase', #'TheEdgeCase'{}},
+ {5, undefined,
+ {struct, {
+ name_conflict_test_types,
+ 'Tricky_'
+ }},
+ 'Tricky_', #'Tricky_'{}},
+ {6, undefined,
+ {struct, {
+ name_conflict_test_types,
+ 'Nested'
+ }},
+ 'Nested', undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext('Nested')
+ )},
+ {"Problem_ extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, bool, problem, undefined},
+ {2, undefined, bool, 'Problem', undefined}
+ ]},
+ name_conflict_test_types:struct_info_ext('Problem_')
+ )}
+ ].
service_info_test_() ->
- [
- {"event params", ?_assertEqual(
- {struct, [{1, {struct, {name_conflict_test_types, partial}}}]},
- extern_thrift:function_info(event, params_type)
- )},
- {"event reply", ?_assertEqual(
- {struct, {name_conflict_test_types, delegate}},
- extern_thrift:function_info(event, reply_type)
- )},
- {"event exceptions", ?_assertEqual(
- {struct, []},
- extern_thrift:function_info(event, exceptions)
- )},
- {"Foo params", ?_assertEqual(
- {struct, [{1, {struct, {name_conflict_test_types, 'Nested'}}}]},
- extern_thrift:function_info('Foo', params_type)
- )},
- {"Foo reply", ?_assertEqual(
- {struct, []},
- extern_thrift:function_info('Foo', reply_type)
- )},
- {"Foo exceptions", ?_assertEqual(
- {struct, [{1, {struct, {name_conflict_test_types, 'Problem_'}}}]},
- extern_thrift:function_info('Foo', exceptions)
- )}
- ].
+ [
+ {"event params",
+ ?_assertEqual(
+ {struct, [{1, {struct, {name_conflict_test_types, partial}}}]},
+ extern_thrift:function_info(event, params_type)
+ )},
+ {"event reply",
+ ?_assertEqual(
+ {struct, {name_conflict_test_types, delegate}},
+ extern_thrift:function_info(event, reply_type)
+ )},
+ {"event exceptions",
+ ?_assertEqual(
+ {struct, []},
+ extern_thrift:function_info(event, exceptions)
+ )},
+ {"Foo params",
+ ?_assertEqual(
+ {struct, [{1, {struct, {name_conflict_test_types, 'Nested'}}}]},
+ extern_thrift:function_info('Foo', params_type)
+ )},
+ {"Foo reply",
+ ?_assertEqual(
+ {struct, []},
+ extern_thrift:function_info('Foo', reply_type)
+ )},
+ {"Foo exceptions",
+ ?_assertEqual(
+ {struct, [{1, {struct, {name_conflict_test_types, 'Problem_'}}}]},
+ extern_thrift:function_info('Foo', exceptions)
+ )}
+ ].
diff --git a/lib/erl/test/stress_server.erl b/lib/erl/test/stress_server.erl
index 35fff06..78ddefe 100644
--- a/lib/erl/test/stress_server.erl
+++ b/lib/erl/test/stress_server.erl
@@ -19,33 +19,32 @@
-module(stress_server).
+-export([
+ start_link/1,
--export([start_link/1,
+ handle_function/2,
- handle_function/2,
-
- echoVoid/0,
- echoByte/1,
- echoI32/1,
- echoI64/1,
- echoString/1,
- echoList/1,
- echoSet/1,
- echoMap/1
- ]).
+ echoVoid/0,
+ echoByte/1,
+ echoI32/1,
+ echoI64/1,
+ echoString/1,
+ echoList/1,
+ echoSet/1,
+ echoMap/1
+]).
start_link(Port) ->
thrift_server:start_link(Port, service_thrift, ?MODULE).
-
handle_function(Function, Args) ->
case apply(?MODULE, Function, tuple_to_list(Args)) of
ok ->
- ok;
- Else -> {reply, Else}
+ ok;
+ Else ->
+ {reply, Else}
end.
-
echoVoid() ->
ok.
echoByte(X) ->
diff --git a/lib/erl/test/test_const.erl b/lib/erl/test/test_const.erl
index 627777b..74830e9 100644
--- a/lib/erl/test/test_const.erl
+++ b/lib/erl/test/test_const.erl
@@ -25,30 +25,31 @@
-include("gen-erl/constants_demo_types.hrl").
namespace_test() ->
- %% Verify that records produced by ConstantsDemo.thrift have the right namespace.
- io:format(user, "in namespace_test()\n", []),
- {struct, _} = constants_demo_types:struct_info('consts_thing'),
- {struct, _} = constants_demo_types:struct_info('consts_Blah'),
- ok.
+ %% Verify that records produced by ConstantsDemo.thrift have the right namespace.
+ io:format(user, "in namespace_test()\n", []),
+ {struct, _} = constants_demo_types:struct_info('consts_thing'),
+ {struct, _} = constants_demo_types:struct_info('consts_Blah'),
+ ok.
const_map_test() ->
- ?assertEqual(233, constants_demo_constants:gen_map(35532)),
- ?assertError(function_clause, constants_demo_constants:gen_map(0)),
+ ?assertEqual(233, constants_demo_constants:gen_map(35532)),
+ ?assertError(function_clause, constants_demo_constants:gen_map(0)),
- ?assertEqual(853, constants_demo_constants:gen_map(43523, default)),
- ?assertEqual(default, constants_demo_constants:gen_map(10110, default)),
+ ?assertEqual(853, constants_demo_constants:gen_map(43523, default)),
+ ?assertEqual(default, constants_demo_constants:gen_map(10110, default)),
- ?assertEqual(98325, constants_demo_constants:gen_map2("lkjsdf")),
- ?assertError(function_clause, constants_demo_constants:gen_map2("nonexist")),
+ ?assertEqual(98325, constants_demo_constants:gen_map2("lkjsdf")),
+ ?assertError(function_clause, constants_demo_constants:gen_map2("nonexist")),
- ?assertEqual(233, constants_demo_constants:gen_map2("hello", 321)),
- ?assertEqual(321, constants_demo_constants:gen_map2("goodbye", 321)).
+ ?assertEqual(233, constants_demo_constants:gen_map2("hello", 321)),
+ ?assertEqual(321, constants_demo_constants:gen_map2("goodbye", 321)).
const_list_test() ->
- ?assertEqual(23598352, constants_demo_constants:gen_list(2)),
- ?assertError(function_clause, constants_demo_constants:gen_list(0)),
+ ?assertEqual(23598352, constants_demo_constants:gen_list(2)),
+ ?assertError(function_clause, constants_demo_constants:gen_list(0)),
- ?assertEqual(3253523, constants_demo_constants:gen_list(3, default)),
- ?assertEqual(default, constants_demo_constants:gen_list(10, default)).
+ ?assertEqual(3253523, constants_demo_constants:gen_list(3, default)),
+ ?assertEqual(default, constants_demo_constants:gen_list(10, default)).
--endif. %% TEST
+%% TEST
+-endif.
diff --git a/lib/erl/test/test_disklog.erl b/lib/erl/test/test_disklog.erl
index dcb6fc1..742e895 100644
--- a/lib/erl/test/test_disklog.erl
+++ b/lib/erl/test/test_disklog.erl
@@ -23,77 +23,83 @@
-include_lib("eunit/include/eunit.hrl").
disklog_test() ->
- {ok, TransportFactory} =
- thrift_disk_log_transport:new_transport_factory(
- test_disklog,
- [{file, "./test_log"},
- {size, {1024*1024, 10}}]),
- {ok, ProtocolFactory} =
- thrift_binary_protocol:new_protocol_factory( TransportFactory, []),
- {ok, Proto} = ProtocolFactory(),
- {ok, Client0} = thrift_client:new(Proto, thrift_test_thrift),
+ {ok, TransportFactory} =
+ thrift_disk_log_transport:new_transport_factory(
+ test_disklog,
+ [
+ {file, "./test_log"},
+ {size, {1024 * 1024, 10}}
+ ]
+ ),
+ {ok, ProtocolFactory} =
+ thrift_binary_protocol:new_protocol_factory(TransportFactory, []),
+ {ok, Proto} = ProtocolFactory(),
+ {ok, Client0} = thrift_client:new(Proto, thrift_test_thrift),
- io:format("Client started~n"),
+ io:format("Client started~n"),
- % We have to make oneway calls into this client only since otherwise it
- % will try to read from the disklog and go boom.
- {Client1, {ok, ok}} = thrift_client:call(Client0, testOneway, [16#deadbeef]),
- io:format("Call written~n"),
+ % We have to make oneway calls into this client only since otherwise it
+ % will try to read from the disklog and go boom.
+ {Client1, {ok, ok}} = thrift_client:call(Client0, testOneway, [16#deadbeef]),
+ io:format("Call written~n"),
- % Use the send_call method to write a non-oneway call into the log
- {Client2, ok} =
- thrift_client:send_call(Client1, testString, [<<"hello world">>]),
- io:format("Non-oneway call sent~n"),
+ % Use the send_call method to write a non-oneway call into the log
+ {Client2, ok} =
+ thrift_client:send_call(Client1, testString, [<<"hello world">>]),
+ io:format("Non-oneway call sent~n"),
- {_Client3, ok} = thrift_client:close(Client2),
- io:format("Client closed~n"),
-
- lists:foreach(fun(File) -> file:delete(File) end, [
- "./test_log.1",
- "./test_log.idx",
- "./test_log.siz"
- ]),
- io:format("Cleaning up test files~n"),
+ {_Client3, ok} = thrift_client:close(Client2),
+ io:format("Client closed~n"),
- ok.
+ lists:foreach(fun(File) -> file:delete(File) end, [
+ "./test_log.1",
+ "./test_log.idx",
+ "./test_log.siz"
+ ]),
+ io:format("Cleaning up test files~n"),
+
+ ok.
disklog_base64_test() ->
- {ok, TransportFactory} =
- thrift_disk_log_transport:new_transport_factory(
- test_disklog,
- [{file, "./test_b64_log"},
- {size, {1024*1024, 10}}]),
- {ok, B64Factory} =
- thrift_base64_transport:new_transport_factory(TransportFactory),
- {ok, BufFactory} =
- thrift_buffered_transport:new_transport_factory(B64Factory),
- {ok, ProtocolFactory} =
- thrift_binary_protocol:new_protocol_factory(BufFactory, []),
- {ok, Proto} = ProtocolFactory(),
- {ok, Client0} = thrift_client:new(Proto, thrift_test_thrift),
+ {ok, TransportFactory} =
+ thrift_disk_log_transport:new_transport_factory(
+ test_disklog,
+ [
+ {file, "./test_b64_log"},
+ {size, {1024 * 1024, 10}}
+ ]
+ ),
+ {ok, B64Factory} =
+ thrift_base64_transport:new_transport_factory(TransportFactory),
+ {ok, BufFactory} =
+ thrift_buffered_transport:new_transport_factory(B64Factory),
+ {ok, ProtocolFactory} =
+ thrift_binary_protocol:new_protocol_factory(BufFactory, []),
+ {ok, Proto} = ProtocolFactory(),
+ {ok, Client0} = thrift_client:new(Proto, thrift_test_thrift),
- io:format("Client started~n"),
+ io:format("Client started~n"),
- % We have to make oneway calls into this client only since otherwise
- % it will try to read from the disklog and go boom.
- {Client1, {ok, ok}} = thrift_client:call(Client0, testOneway, [16#deadbeef]),
- io:format("Call written~n"),
+ % We have to make oneway calls into this client only since otherwise
+ % it will try to read from the disklog and go boom.
+ {Client1, {ok, ok}} = thrift_client:call(Client0, testOneway, [16#deadbeef]),
+ io:format("Call written~n"),
- % Use the send_call method to write a non-oneway call into the log
- {Client2, ok} =
- thrift_client:send_call(Client1, testString, [<<"hello world">>]),
- io:format("Non-oneway call sent~n"),
+ % Use the send_call method to write a non-oneway call into the log
+ {Client2, ok} =
+ thrift_client:send_call(Client1, testString, [<<"hello world">>]),
+ io:format("Non-oneway call sent~n"),
- {_Client3, ok} = thrift_client:close(Client2),
- io:format("Client closed~n"),
+ {_Client3, ok} = thrift_client:close(Client2),
+ io:format("Client closed~n"),
- lists:foreach(fun(File) -> file:delete(File) end, [
- "./test_b64_log.1",
- "./test_b64_log.idx",
- "./test_b64_log.siz"
- ]),
- io:format("Cleaning up test files~n"),
+ lists:foreach(fun(File) -> file:delete(File) end, [
+ "./test_b64_log.1",
+ "./test_b64_log.idx",
+ "./test_b64_log.siz"
+ ]),
+ io:format("Cleaning up test files~n"),
- ok.
+ ok.
-endif.
diff --git a/lib/erl/test/test_omit.erl b/lib/erl/test/test_omit.erl
index 80841e2..a51f1ed 100644
--- a/lib/erl/test/test_omit.erl
+++ b/lib/erl/test/test_omit.erl
@@ -1,3 +1,22 @@
+%%
+%% Licensed to the Apache Software Foundation (ASF) under one
+%% or more contributor license agreements. See the NOTICE file
+%% distributed with this work for additional information
+%% regarding copyright ownership. The ASF licenses this file
+%% to you 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(test_omit).
-include("gen-erl/thrift_omit_with_types.hrl").
@@ -6,74 +25,83 @@
-include_lib("eunit/include/eunit.hrl").
omit_struct1_test() ->
- %% In this test, the field that is deleted is a basic type (an i32).
- A = #test1{one = 1, three = 3},
- B = #test1{one = 1, two = 2, three = 3},
- {ok, Transport} = thrift_membuffer_transport:new(),
- {ok, P0} = thrift_binary_protocol:new(Transport),
+ %% In this test, the field that is deleted is a basic type (an i32).
+ A = #test1{one = 1, three = 3},
+ B = #test1{one = 1, two = 2, three = 3},
+ {ok, Transport} = thrift_membuffer_transport:new(),
+ {ok, P0} = thrift_binary_protocol:new(Transport),
- {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, A)}}, A}),
- {P2, {ok, O0}} = thrift_protocol:read(P1, {struct, {thrift_omit_without_types, element(1, A)}}),
- ?assertEqual(element(1, A), element(1, O0)),
- ?assertEqual(element(2, A), element(2, O0)),
- ?assertEqual(element(4, A), element(3, O0)),
+ {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, A)}}, A}),
+ {P2, {ok, O0}} = thrift_protocol:read(P1, {struct, {thrift_omit_without_types, element(1, A)}}),
+ ?assertEqual(element(1, A), element(1, O0)),
+ ?assertEqual(element(2, A), element(2, O0)),
+ ?assertEqual(element(4, A), element(3, O0)),
- {P3, ok} = thrift_protocol:write(P2, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
- {_P4, {ok, O1}} = thrift_protocol:read(P3, {struct, {thrift_omit_without_types, element(1, A)}}),
- ?assertEqual(element(1, A), element(1, O1)),
- ?assertEqual(element(2, A), element(2, O1)),
- ?assertEqual(element(4, A), element(3, O1)),
+ {P3, ok} = thrift_protocol:write(P2, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
+ {_P4, {ok, O1}} = thrift_protocol:read(
+ P3, {struct, {thrift_omit_without_types, element(1, A)}}
+ ),
+ ?assertEqual(element(1, A), element(1, O1)),
+ ?assertEqual(element(2, A), element(2, O1)),
+ ?assertEqual(element(4, A), element(3, O1)),
- ok.
+ ok.
omit_struct2_test() ->
- %% In this test, the field that is deleted is a struct.
- A = #test2{one = 1, two = #test2{one = 10, three = 30}, three = 3},
- B = #test2{one = 1, two = #test2{one = 10, two = #test2{one = 100}, three = 30}, three = 3},
+ %% In this test, the field that is deleted is a struct.
+ A = #test2{one = 1, two = #test2{one = 10, three = 30}, three = 3},
+ B = #test2{one = 1, two = #test2{one = 10, two = #test2{one = 100}, three = 30}, three = 3},
- {ok, Transport} = thrift_membuffer_transport:new(),
- {ok, P0} = thrift_binary_protocol:new(Transport),
+ {ok, Transport} = thrift_membuffer_transport:new(),
+ {ok, P0} = thrift_binary_protocol:new(Transport),
- {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, A)}}, A}),
- {P2, {ok, O0}} = thrift_protocol:read(P1, {struct, {thrift_omit_without_types, element(1, A)}}),
- ?assertEqual(element(1, A), element(1, O0)),
- ?assertEqual(element(2, A), element(2, O0)),
- ?assertEqual(element(4, A), element(3, O0)),
+ {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, A)}}, A}),
+ {P2, {ok, O0}} = thrift_protocol:read(P1, {struct, {thrift_omit_without_types, element(1, A)}}),
+ ?assertEqual(element(1, A), element(1, O0)),
+ ?assertEqual(element(2, A), element(2, O0)),
+ ?assertEqual(element(4, A), element(3, O0)),
- {P3, ok} = thrift_protocol:write(P2, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
- {_P4, {ok, O1}} = thrift_protocol:read(P3, {struct, {thrift_omit_without_types, element(1, A)}}),
- ?assertEqual(element(1, A), element(1, O1)),
- ?assertEqual(element(2, A), element(2, O1)),
- ?assertEqual(element(4, A), element(3, O1)),
+ {P3, ok} = thrift_protocol:write(P2, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
+ {_P4, {ok, O1}} = thrift_protocol:read(
+ P3, {struct, {thrift_omit_without_types, element(1, A)}}
+ ),
+ ?assertEqual(element(1, A), element(1, O1)),
+ ?assertEqual(element(2, A), element(2, O1)),
+ ?assertEqual(element(4, A), element(3, O1)),
- ok.
+ ok.
omit_list_test() ->
- %% In this test, the field that is deleted is a list.
- A = #test1{one = 1, two = 2, three = 3},
- B = #test3{one = 1, two = [ A ]},
+ %% In this test, the field that is deleted is a list.
+ A = #test1{one = 1, two = 2, three = 3},
+ B = #test3{one = 1, two = [A]},
- {ok, Transport} = thrift_membuffer_transport:new(),
- {ok, P0} = thrift_binary_protocol:new(Transport),
+ {ok, Transport} = thrift_membuffer_transport:new(),
+ {ok, P0} = thrift_binary_protocol:new(Transport),
- {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
- {_P2, {ok, O0}} = thrift_protocol:read(P1, {struct, {thrift_omit_without_types, element(1, B)}}),
- ?assertEqual(element(2, B), element(2, O0)),
+ {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
+ {_P2, {ok, O0}} = thrift_protocol:read(
+ P1, {struct, {thrift_omit_without_types, element(1, B)}}
+ ),
+ ?assertEqual(element(2, B), element(2, O0)),
- ok.
+ ok.
omit_map_test() ->
- %% In this test, the field that is deleted is a map.
- A = #test1{one = 1, two = 2, three = 3},
- B = #test4{one = 1, two = dict:from_list([ {2, A} ])},
+ %% In this test, the field that is deleted is a map.
+ A = #test1{one = 1, two = 2, three = 3},
+ B = #test4{one = 1, two = dict:from_list([{2, A}])},
- {ok, Transport} = thrift_membuffer_transport:new(),
- {ok, P0} = thrift_binary_protocol:new(Transport),
+ {ok, Transport} = thrift_membuffer_transport:new(),
+ {ok, P0} = thrift_binary_protocol:new(Transport),
- {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
- {_P2, {ok, O0}} = thrift_protocol:read(P1, {struct, {thrift_omit_without_types, element(1, B)}}),
- ?assertEqual(element(2, B), element(2, O0)),
+ {P1, ok} = thrift_protocol:write(P0, {{struct, {thrift_omit_with_types, element(1, B)}}, B}),
+ {_P2, {ok, O0}} = thrift_protocol:read(
+ P1, {struct, {thrift_omit_without_types, element(1, B)}}
+ ),
+ ?assertEqual(element(2, B), element(2, O0)),
- ok.
+ ok.
--endif. %% TEST
+%% TEST
+-endif.
diff --git a/lib/erl/test/test_rendered_double_constants.erl b/lib/erl/test/test_rendered_double_constants.erl
index 87fce81..02950f2 100644
--- a/lib/erl/test/test_rendered_double_constants.erl
+++ b/lib/erl/test/test_rendered_double_constants.erl
@@ -27,42 +27,96 @@
-define(EPSILON, 0.0000001).
rendered_double_constants_test() ->
- ?assert(abs(1.0 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_INT_CONSTANT_TEST) =< ?EPSILON),
- ?assert(abs(-100.0 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_INT_CONSTANT_TEST) =< ?EPSILON),
- ?assert(abs(9223372036854775807.0 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGEST_INT_CONSTANT_TEST) =< ?EPSILON),
- ?assert(abs(-9223372036854775807.0 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALLEST_INT_CONSTANT_TEST) =< ?EPSILON),
- ?assert(abs(3.14159265359 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_DOUBLE_WITH_MANY_DECIMALS_TEST) =< ?EPSILON),
- ?assert(abs(1000000.1 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_FRACTIONAL_DOUBLE_TEST) =< ?EPSILON),
- ?assert(abs(-1000000.1 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_FRACTIONAL_DOUBLE_TEST) =< ?EPSILON),
- ?assert(abs(1.7e+308 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_DOUBLE_TEST) =< ?EPSILON),
- ?assert(abs(9223372036854775816.43 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_FRACTIONAL_DOUBLE_TEST) =< ?EPSILON),
- ?assert(abs(-1.7e+308 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALL_DOUBLE_TEST) =< ?EPSILON),
- ?assert(abs(-9223372036854775816.43 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_BUT_LARGE_FRACTIONAL_DOUBLE_TEST) =< ?EPSILON),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_INT_CONSTANT_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_INT_CONSTANT_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGEST_INT_CONSTANT_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALLEST_INT_CONSTANT_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_DOUBLE_WITH_MANY_DECIMALS_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_FRACTIONAL_DOUBLE_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_FRACTIONAL_DOUBLE_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_DOUBLE_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_FRACTIONAL_DOUBLE_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALL_DOUBLE_TEST)),
- ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_BUT_LARGE_FRACTIONAL_DOUBLE_TEST)).
+ ?assert(abs(1.0 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_INT_CONSTANT_TEST) =< ?EPSILON),
+ ?assert(
+ abs(-100.0 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_INT_CONSTANT_TEST) =<
+ ?EPSILON
+ ),
+ ?assert(
+ abs(
+ 9223372036854775807.0 -
+ ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGEST_INT_CONSTANT_TEST
+ ) =< ?EPSILON
+ ),
+ ?assert(
+ abs(
+ -9223372036854775807.0 -
+ ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALLEST_INT_CONSTANT_TEST
+ ) =< ?EPSILON
+ ),
+ ?assert(
+ abs(
+ 3.14159265359 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_DOUBLE_WITH_MANY_DECIMALS_TEST
+ ) =< ?EPSILON
+ ),
+ ?assert(
+ abs(1000000.1 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_FRACTIONAL_DOUBLE_TEST) =<
+ ?EPSILON
+ ),
+ ?assert(
+ abs(-1000000.1 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_FRACTIONAL_DOUBLE_TEST) =<
+ ?EPSILON
+ ),
+ ?assert(
+ abs(1.7e+308 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_DOUBLE_TEST) =< ?EPSILON
+ ),
+ ?assert(
+ abs(
+ 9223372036854775816.43 -
+ ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_FRACTIONAL_DOUBLE_TEST
+ ) =< ?EPSILON
+ ),
+ ?assert(
+ abs(-1.7e+308 - ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALL_DOUBLE_TEST) =< ?EPSILON
+ ),
+ ?assert(
+ abs(
+ -9223372036854775816.43 -
+ ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_BUT_LARGE_FRACTIONAL_DOUBLE_TEST
+ ) =< ?EPSILON
+ ),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_INT_CONSTANT_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_INT_CONSTANT_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGEST_INT_CONSTANT_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALLEST_INT_CONSTANT_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_DOUBLE_WITH_MANY_DECIMALS_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_FRACTIONAL_DOUBLE_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_FRACTIONAL_DOUBLE_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_DOUBLE_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_LARGE_FRACTIONAL_DOUBLE_TEST)),
+ ?assert(is_float(?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_SMALL_DOUBLE_TEST)),
+ ?assert(
+ is_float(
+ ?DOUBLE_CONSTANTS_TEST_DOUBLE_ASSIGNED_TO_NEGATIVE_BUT_LARGE_FRACTIONAL_DOUBLE_TEST
+ )
+ ).
rendered_double_list_test() ->
- ?assertEqual(12, length(?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)),
- ?assert(abs(1.0 - lists:nth(1, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(-100.0 - lists:nth(2, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(100.0 - lists:nth(3, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(9223372036854775807.0 - lists:nth(4, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(-9223372036854775807.0 - lists:nth(5, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(3.14159265359 - lists:nth(6, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(1000000.1 - lists:nth(7, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(-1000000.1 - lists:nth(8, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(1.7e+308 - lists:nth(9, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(-1.7e+308 - lists:nth(10, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(9223372036854775816.43 - lists:nth(11, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
- ?assert(abs(-9223372036854775816.43 - lists:nth(12, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON).
+ ?assertEqual(12, length(?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)),
+ ?assert(abs(1.0 - lists:nth(1, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(abs(-100.0 - lists:nth(2, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(abs(100.0 - lists:nth(3, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(
+ abs(9223372036854775807.0 - lists:nth(4, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =<
+ ?EPSILON
+ ),
+ ?assert(
+ abs(-9223372036854775807.0 - lists:nth(5, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =<
+ ?EPSILON
+ ),
+ ?assert(abs(3.14159265359 - lists:nth(6, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(abs(1000000.1 - lists:nth(7, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(abs(-1000000.1 - lists:nth(8, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(abs(1.7e+308 - lists:nth(9, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(abs(-1.7e+308 - lists:nth(10, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =< ?EPSILON),
+ ?assert(
+ abs(9223372036854775816.43 - lists:nth(11, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =<
+ ?EPSILON
+ ),
+ ?assert(
+ abs(-9223372036854775816.43 - lists:nth(12, ?DOUBLE_CONSTANTS_TEST_DOUBLE_LIST_TEST)) =<
+ ?EPSILON
+ ).
--endif. %% TEST
\ No newline at end of file
+%% TEST
+-endif.
diff --git a/lib/erl/test/test_thrift_1151.erl b/lib/erl/test/test_thrift_1151.erl
index f4a910e..141787e 100644
--- a/lib/erl/test/test_thrift_1151.erl
+++ b/lib/erl/test/test_thrift_1151.erl
@@ -1,3 +1,22 @@
+%%
+%% Licensed to the Apache Software Foundation (ASF) under one
+%% or more contributor license agreements. See the NOTICE file
+%% distributed with this work for additional information
+%% regarding copyright ownership. The ASF licenses this file
+%% to you 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(test_thrift_1151).
-include("gen-erl/thrift1151_types.hrl").
@@ -6,29 +25,29 @@
-include_lib("eunit/include/eunit.hrl").
unmatched_struct_test() ->
- S1 = #'StructC'{x=#'StructB'{x=1}},
- {ok, Transport} = thrift_memory_buffer:new(),
- {ok, Protocol} = thrift_binary_protocol:new(Transport),
- ?assertException(
- error,
- struct_unmatched,
- thrift_protocol:write(
- Protocol,
- {{struct, element(2, thrift1151_types:struct_info('StructC'))}, S1}
- )
- ).
+ S1 = #'StructC'{x = #'StructB'{x = 1}},
+ {ok, Transport} = thrift_memory_buffer:new(),
+ {ok, Protocol} = thrift_binary_protocol:new(Transport),
+ ?assertException(
+ error,
+ struct_unmatched,
+ thrift_protocol:write(
+ Protocol,
+ {{struct, element(2, thrift1151_types:struct_info('StructC'))}, S1}
+ )
+ ).
badarg_test() ->
- S2 = #'StructC'{x=#'StructA'{x="1"}},
- {ok, Transport} = thrift_memory_buffer:new(),
- {ok, Protocol} = thrift_binary_protocol:new(Transport),
- ?assertException(
- error,
- badarg,
- thrift_protocol:write(
- Protocol,
- {{struct, element(2, thrift1151_types:struct_info('StructC'))}, S2}
- )
- ).
+ S2 = #'StructC'{x = #'StructA'{x = "1"}},
+ {ok, Transport} = thrift_memory_buffer:new(),
+ {ok, Protocol} = thrift_binary_protocol:new(Transport),
+ ?assertException(
+ error,
+ badarg,
+ thrift_protocol:write(
+ Protocol,
+ {{struct, element(2, thrift1151_types:struct_info('StructC'))}, S2}
+ )
+ ).
-endif.
diff --git a/lib/erl/test/test_thrift_3214.erl b/lib/erl/test/test_thrift_3214.erl
index 118e779..4d7dd3e 100644
--- a/lib/erl/test/test_thrift_3214.erl
+++ b/lib/erl/test/test_thrift_3214.erl
@@ -18,7 +18,6 @@
%%
-module(test_thrift_3214).
--compile(export_all).
-include("gen-erl/thrift3214_types.hrl").
@@ -26,33 +25,38 @@
-include_lib("eunit/include/eunit.hrl").
record_generation_test_() ->
- [
- {"StringMap record", ?_assertMatch(
- {'StringMap', _},
- #'StringMap'{data=#{50 => "foo"}}
- )},
- {"StringMap record defaults", ?_assertEqual(
- {'StringMap', #{1 => "a", 2 => "b"}},
- #'StringMap'{}
- )},
- {"StringMap record dict from list", ?_assertNotEqual(
- {'StringMap', dict:from_list([{1, "a"}, {2, "b"}])},
- #'StringMap'{}
- )},
- {"StringMap record map from list", ?_assertEqual(
- {'StringMap', maps:from_list([{1, "a"}, {2, "b"}])},
- #'StringMap'{}
- )}
- ].
+ [
+ {"StringMap record",
+ ?_assertMatch(
+ {'StringMap', _},
+ #'StringMap'{data = #{50 => "foo"}}
+ )},
+ {"StringMap record defaults",
+ ?_assertEqual(
+ {'StringMap', #{1 => "a", 2 => "b"}},
+ #'StringMap'{}
+ )},
+ {"StringMap record dict from list",
+ ?_assertNotEqual(
+ {'StringMap', dict:from_list([{1, "a"}, {2, "b"}])},
+ #'StringMap'{}
+ )},
+ {"StringMap record map from list",
+ ?_assertEqual(
+ {'StringMap', maps:from_list([{1, "a"}, {2, "b"}])},
+ #'StringMap'{}
+ )}
+ ].
struct_info_test_() ->
- [
- {"StringMap extended definition", ?_assertEqual(
- {struct, [
- {1, undefined, {map, i32, string}, 'data', #{1 => "a", 2 => "b"}}
- ]},
- thrift3214_types:struct_info_ext('StringMap')
- )}
- ].
+ [
+ {"StringMap extended definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {map, i32, string}, 'data', #{1 => "a", 2 => "b"}}
+ ]},
+ thrift3214_types:struct_info_ext('StringMap')
+ )}
+ ].
-endif.
diff --git a/lib/erl/test/test_thrift_buffered_transport.erl b/lib/erl/test/test_thrift_buffered_transport.erl
index 8519e82..e7b23ab 100644
--- a/lib/erl/test/test_thrift_buffered_transport.erl
+++ b/lib/erl/test/test_thrift_buffered_transport.erl
@@ -20,340 +20,295 @@
-module(test_thrift_buffered_transport).
-include_lib("eunit/include/eunit.hrl").
-
new(Transport) -> thrift_buffered_transport:new(Transport).
new_test_() ->
- [
- {"new buffered membuffer", ?_assertMatch(
- {ok, {t_transport, thrift_buffered_transport, {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, []}},
- []
- }}},
- new({t_transport, thrift_membuffer_transport, {t_membuffer, []}})
- )}
- ].
-
+ [
+ {"new buffered membuffer",
+ ?_assertMatch(
+ {ok,
+ {t_transport, thrift_buffered_transport,
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, []}},
+ []}}},
+ new({t_transport, thrift_membuffer_transport, {t_membuffer, []}})
+ )}
+ ].
read(Frame, Bytes) -> thrift_buffered_transport:read(Frame, Bytes).
read_test_() ->
- [
- {"read zero bytes from an empty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- {ok, <<>>}
- },
- read(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- 0
- )
- )},
- {"read 1 byte from an empty buffered membuffer", ?_assertMatch(
- {_, {ok, <<>>}},
- read(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- 1
- )
- )},
- {"read zero bytes from nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<"hallo world">>
- }},
- []
- },
- {ok, <<>>}
- },
- read(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<"hallo world">>
- }},
- []
- },
- 0
- )
- )},
- {"read 1 byte from nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
- []
- },
- {ok, <<"h">>}
- },
- read(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
- []
- },
- 1
- )
- )},
- {"read 1 byte from nonempty buffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
- []
- },
- {ok, <<"h">>}
- },
- read(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
- []
- },
- 1
- )
- )},
- {"read a zillion bytes from nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- {ok, <<"hallo world">>}
- },
- read(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
- []
- },
- 65536
- )
- )}
- ].
-
+ [
+ {"read zero bytes from an empty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ {ok, <<>>}
+ },
+ read(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ 0
+ )
+ )},
+ {"read 1 byte from an empty buffered membuffer",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ 1
+ )
+ )},
+ {"read zero bytes from nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ {ok, <<>>}
+ },
+ read(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 0
+ )
+ )},
+ {"read 1 byte from nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
+ []},
+ {ok, <<"h">>}
+ },
+ read(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 1
+ )
+ )},
+ {"read 1 byte from nonempty buffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
+ []},
+ {ok, <<"h">>}
+ },
+ read(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 1
+ )
+ )},
+ {"read a zillion bytes from nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ {ok, <<"hallo world">>}
+ },
+ read(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 65536
+ )
+ )}
+ ].
read_exact(Frame, Bytes) -> thrift_buffered_transport:read_exact(Frame, Bytes).
read_exact_test_() ->
- [
- {"read exactly zero bytes from an empty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- {ok, <<>>}
- },
- read_exact(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- 0
- )
- )},
- {"read exactly 1 byte from an empty buffered membuffer", ?_assertMatch(
- {_, {error, eof}},
- read_exact(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- 1
- )
- )},
- {"read exactly zero bytes from nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
- []
- },
- {ok, <<>>}
- },
- read_exact(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
- []
- },
- 0
- )
- )},
- {"read exactly 1 byte from nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
- []
- },
- {ok, <<"h">>}
- },
- read_exact(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<"hallo world">>
- }},
- []
- },
- 1
- )
- )},
- {"read exactly 1 byte from nonempty buffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
- []
- },
- {ok, <<"h">>}
- },
- read_exact(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
- []
- },
- 1
- )
- )},
- {"read exactly a zillion bytes from nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
- []
- },
- {error, eof}
- },
- read_exact(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<"hallo world">>
- }},
- []
- },
- 65536
- )
- )}
- ].
-
+ [
+ {"read exactly zero bytes from an empty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ {ok, <<>>}
+ },
+ read_exact(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ 0
+ )
+ )},
+ {"read exactly 1 byte from an empty buffered membuffer",
+ ?_assertMatch(
+ {_, {error, eof}},
+ read_exact(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ 1
+ )
+ )},
+ {"read exactly zero bytes from nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ {ok, <<>>}
+ },
+ read_exact(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 0
+ )
+ )},
+ {"read exactly 1 byte from nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
+ []},
+ {ok, <<"h">>}
+ },
+ read_exact(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 1
+ )
+ )},
+ {"read exactly 1 byte from nonempty buffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"allo world">>}},
+ []},
+ {ok, <<"h">>}
+ },
+ read_exact(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 1
+ )
+ )},
+ {"read exactly a zillion bytes from nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ {error, eof}
+ },
+ read_exact(
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport, {t_membuffer, <<"hallo world">>}},
+ []},
+ 65536
+ )
+ )}
+ ].
write(Framed, Data) -> thrift_buffered_transport:write(Framed, Data).
write_test_() ->
- [
- {"write empty list to empty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [[], []]
- },
- ok
- },
- write(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- []
- )
- )},
- {"write empty list to nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [["hallo world"], []]
- },
- ok
- },
- write(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- ["hallo world"]
- },
- []
- )
- )},
- {"write empty binary to empty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [[], <<>>]
- },
- ok
- },
- write(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- <<>>
- )
- )},
- {"write empty binary to nonempty buffered membuffer", ?_assertMatch(
- {
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [["hallo world"], <<>>]
- },
- ok
- },
- write(
- {t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- ["hallo world"]
- },
- <<>>
- )
- )}
- ].
-
+ [
+ {"write empty list to empty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [
+ [], []
+ ]},
+ ok
+ },
+ write(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ []
+ )
+ )},
+ {"write empty list to nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [
+ ["hallo world"], []
+ ]},
+ ok
+ },
+ write(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [
+ "hallo world"
+ ]},
+ []
+ )
+ )},
+ {"write empty binary to empty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [
+ [], <<>>
+ ]},
+ ok
+ },
+ write(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ <<>>
+ )
+ )},
+ {"write empty binary to nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [
+ ["hallo world"], <<>>
+ ]},
+ ok
+ },
+ write(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [
+ "hallo world"
+ ]},
+ <<>>
+ )
+ )}
+ ].
flush(Transport) -> thrift_buffered_transport:flush(Transport).
flush_test_() ->
- [
- {"flush empty buffered membuffer", ?_assertMatch(
- {{t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- ok
- },
- flush({t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- })
- )},
- {"flush nonempty buffered membuffer", ?_assertMatch(
- {{t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- [<<>>, <<"hallo world">>]
- }},
- []
- },
- ok
- },
- flush({t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<"hallo world">>
- })
- )}
- ].
-
+ [
+ {"flush empty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ []},
+ ok
+ },
+ flush(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, []}
+ )
+ )},
+ {"flush nonempty buffered membuffer",
+ ?_assertMatch(
+ {
+ {t_buffered,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, [<<>>, <<"hallo world">>]}},
+ []},
+ ok
+ },
+ flush(
+ {t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ <<"hallo world">>}
+ )
+ )}
+ ].
close(Transport) -> thrift_buffered_transport:close(Transport).
close_test_() ->
- {"close buffered membuffer", ?_assertMatch(
- {{t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- },
- ok
- },
- close({t_buffered,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- []
- })
- )}.
-
+ {"close buffered membuffer",
+ ?_assertMatch(
+ {{t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, []}, ok},
+ close({t_buffered, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, []})
+ )}.
diff --git a/lib/erl/test/test_thrift_compact_protocol.erl b/lib/erl/test/test_thrift_compact_protocol.erl
index 5da78c6..b9efae7 100644
--- a/lib/erl/test/test_thrift_compact_protocol.erl
+++ b/lib/erl/test/test_thrift_compact_protocol.erl
@@ -22,198 +22,203 @@
-include("thrift_constants.hrl").
-include("thrift_protocol.hrl").
-
new(Transport) -> thrift_compact_protocol:new(Transport).
new() ->
- {ok, Transport} = thrift_membuffer_transport:new(),
- thrift_compact_protocol:new(Transport).
+ {ok, Transport} = thrift_membuffer_transport:new(),
+ thrift_compact_protocol:new(Transport).
new_test() ->
- new(thrift_membuffer_transport:new()).
+ new(thrift_membuffer_transport:new()).
write(This, Value) -> thrift_protocol:write(This, Value).
read(This, Type) -> thrift_protocol:read(This, Type).
str(This0, Value0) ->
- {This1, ok} = write(This0, {string, Value0}),
- {This2, {ok, Value1}} = read(This1, string),
- ?assertEqual(Value0, binary_to_list(Value1)),
- {This2, ok}.
+ {This1, ok} = write(This0, {string, Value0}),
+ {This2, {ok, Value1}} = read(This1, string),
+ ?assertEqual(Value0, binary_to_list(Value1)),
+ {This2, ok}.
string_test() ->
- {ok, This0} = new(),
- {This1, ok} = str(This0, "aaa"),
- {This2, ok} = str(This1, ""),
- {This2, ok}.
+ {ok, This0} = new(),
+ {This1, ok} = str(This0, "aaa"),
+ {This2, ok} = str(This1, ""),
+ {This2, ok}.
round_trip(This0, Type, Value0) ->
- {This1, ok} = write(This0, {Type, Value0}),
- {This2, {ok, Value1}} = read(This1, Type),
- ?assertEqual(Value0, Value1),
- {This2, ok}.
+ {This1, ok} = write(This0, {Type, Value0}),
+ {This2, {ok, Value1}} = read(This1, Type),
+ ?assertEqual(Value0, Value1),
+ {This2, ok}.
bool_test() ->
- {ok, This0} = new(),
- {This1, ok} = round_trip(This0, bool, true),
- {This2, ok} = round_trip(This1, bool, false),
- {This2, ok}.
+ {ok, This0} = new(),
+ {This1, ok} = round_trip(This0, bool, true),
+ {This2, ok} = round_trip(This1, bool, false),
+ {This2, ok}.
byte(This0, Value0) -> round_trip(This0, byte, Value0).
byte_test() ->
- {ok, This0} = new(),
- {This1, ok} = byte(This0, 0),
- {This2, ok} = byte(This1, 42),
- {This3, ok} = byte(This2, -1),
- {This4, ok} = byte(This3, -128),
- {This4, ok}.
+ {ok, This0} = new(),
+ {This1, ok} = byte(This0, 0),
+ {This2, ok} = byte(This1, 42),
+ {This3, ok} = byte(This2, -1),
+ {This4, ok} = byte(This3, -128),
+ {This4, ok}.
i16(This0, Value0) -> round_trip(This0, i16, Value0).
i16_test() ->
- {ok, This0} = new(),
- {This1, ok} = i16(This0, 0),
- {This2, ok} = i16(This1, 42),
- {This3, ok} = i16(This2, 30000),
- {This4, ok} = i16(This3, -1),
- {This5, ok} = i16(This4, -128),
- {This6, ok} = i16(This5, -30000),
- {This6, ok}.
+ {ok, This0} = new(),
+ {This1, ok} = i16(This0, 0),
+ {This2, ok} = i16(This1, 42),
+ {This3, ok} = i16(This2, 30000),
+ {This4, ok} = i16(This3, -1),
+ {This5, ok} = i16(This4, -128),
+ {This6, ok} = i16(This5, -30000),
+ {This6, ok}.
i32(This0, Value0) -> round_trip(This0, i32, Value0).
i32_test() ->
- {ok, This0} = new(),
- {This1, ok} = i32(This0, 0),
- {This2, ok} = i32(This1, 42),
- {This3, ok} = i32(This2, 30000),
- {This4, ok} = i32(This3, 2000000002),
- {This5, ok} = i32(This4, -1),
- {This6, ok} = i32(This5, -128),
- {This7, ok} = i32(This6, -30000),
- {This8, ok} = i32(This7, -2000000002),
- {This8, ok}.
+ {ok, This0} = new(),
+ {This1, ok} = i32(This0, 0),
+ {This2, ok} = i32(This1, 42),
+ {This3, ok} = i32(This2, 30000),
+ {This4, ok} = i32(This3, 2000000002),
+ {This5, ok} = i32(This4, -1),
+ {This6, ok} = i32(This5, -128),
+ {This7, ok} = i32(This6, -30000),
+ {This8, ok} = i32(This7, -2000000002),
+ {This8, ok}.
i64(This0, Value0) -> round_trip(This0, i64, Value0).
i64_test() ->
- {ok, This0} = new(),
- {This1, ok} = i64(This0, 0),
- {This2, ok} = i64(This1, 42),
- {This3, ok} = i64(This2, 30000),
- {This4, ok} = i64(This3, 2000000002),
- {This5, ok} = i64(This4, 100000000000000064),
- {This6, ok} = i64(This5, -1),
- {This7, ok} = i64(This6, -128),
- {This8, ok} = i64(This7, -30000),
- {This9, ok} = i64(This8, -2000000002),
- {This10, ok} = i64(This9, -100000000000000064),
- {This10, ok}.
+ {ok, This0} = new(),
+ {This1, ok} = i64(This0, 0),
+ {This2, ok} = i64(This1, 42),
+ {This3, ok} = i64(This2, 30000),
+ {This4, ok} = i64(This3, 2000000002),
+ {This5, ok} = i64(This4, 100000000000000064),
+ {This6, ok} = i64(This5, -1),
+ {This7, ok} = i64(This6, -128),
+ {This8, ok} = i64(This7, -30000),
+ {This9, ok} = i64(This8, -2000000002),
+ {This10, ok} = i64(This9, -100000000000000064),
+ {This10, ok}.
struct_test() ->
- {ok, P0} = new(),
- {P1, ok} = write(P0, #protocol_message_begin{ name = "Message1", type = ?tType_I8, seqid = 3}),
- {P2, ok} = write(P1, #protocol_struct_begin{}),
- {P3, ok} = write(P2, #protocol_field_begin{ name = "field1", type = ?tType_I8, id = 1}),
- {P4, ok} = write(P3, {byte, 42}),
- {P5, ok} = write(P4, field_end),
- {P6, ok} = write(P5, #protocol_field_begin{ name = "field2", type = ?tType_I8, id = 14}),
- {P7, ok} = write(P6, {byte, 3}),
- {P8, ok} = write(P7, field_end),
- {P9, ok} = write(P8, #protocol_field_begin{ name = "field3", type = ?tType_I8, id = 42}),
- {P10, ok} = write(P9, {byte, 8}),
- {P11, ok} = write(P10, field_end),
- {P12, ok} = write(P11, field_stop),
- {P13, ok} = write(P12, struct_end),
- {P14, ok} = write(P13, message_end),
+ {ok, P0} = new(),
+ {P1, ok} = write(P0, #protocol_message_begin{name = "Message1", type = ?tType_I8, seqid = 3}),
+ {P2, ok} = write(P1, #protocol_struct_begin{}),
+ {P3, ok} = write(P2, #protocol_field_begin{name = "field1", type = ?tType_I8, id = 1}),
+ {P4, ok} = write(P3, {byte, 42}),
+ {P5, ok} = write(P4, field_end),
+ {P6, ok} = write(P5, #protocol_field_begin{name = "field2", type = ?tType_I8, id = 14}),
+ {P7, ok} = write(P6, {byte, 3}),
+ {P8, ok} = write(P7, field_end),
+ {P9, ok} = write(P8, #protocol_field_begin{name = "field3", type = ?tType_I8, id = 42}),
+ {P10, ok} = write(P9, {byte, 8}),
+ {P11, ok} = write(P10, field_end),
+ {P12, ok} = write(P11, field_stop),
+ {P13, ok} = write(P12, struct_end),
+ {P14, ok} = write(P13, message_end),
- {P15, #protocol_message_begin{ name = "Message1", type = ?tType_I8, seqid = 3}} = read(P14, message_begin),
- {P16, ok} = read(P15, struct_begin),
- {P17, #protocol_field_begin{ type = ?tType_I8, id = 1 }} = read(P16, field_begin),
- {P18, {ok, 42}} = read(P17, byte),
- {P19, ok} = read(P18, field_end),
- {P20, #protocol_field_begin{ type = ?tType_I8, id = 14 }} = read(P19, field_begin),
- {P21, {ok, 3}} = read(P20, byte),
- {P22, ok} = read(P21, field_end),
- {P23, #protocol_field_begin{ type = ?tType_I8, id = 42 }} = read(P22, field_begin),
- {P24, {ok, 8}} = read(P23, byte),
- {P25, ok} = read(P24, field_end),
- {P26, #protocol_field_begin{ type = ?tType_STOP}} = read(P25, field_begin),
- {P27, ok} = read(P26, struct_end),
- {P28, ok} = read(P27, message_end),
- {P28, ok}.
+ {P15, #protocol_message_begin{name = "Message1", type = ?tType_I8, seqid = 3}} = read(
+ P14, message_begin
+ ),
+ {P16, ok} = read(P15, struct_begin),
+ {P17, #protocol_field_begin{type = ?tType_I8, id = 1}} = read(P16, field_begin),
+ {P18, {ok, 42}} = read(P17, byte),
+ {P19, ok} = read(P18, field_end),
+ {P20, #protocol_field_begin{type = ?tType_I8, id = 14}} = read(P19, field_begin),
+ {P21, {ok, 3}} = read(P20, byte),
+ {P22, ok} = read(P21, field_end),
+ {P23, #protocol_field_begin{type = ?tType_I8, id = 42}} = read(P22, field_begin),
+ {P24, {ok, 8}} = read(P23, byte),
+ {P25, ok} = read(P24, field_end),
+ {P26, #protocol_field_begin{type = ?tType_STOP}} = read(P25, field_begin),
+ {P27, ok} = read(P26, struct_end),
+ {P28, ok} = read(P27, message_end),
+ {P28, ok}.
bool_field_test() ->
- {ok, P0} = new(),
- {P1, ok} = write(P0, #protocol_message_begin{ name = "Message1", type = ?tType_I8, seqid = 3}),
- {P2, ok} = write(P1, #protocol_struct_begin{}),
- {P3, ok} = write(P2, #protocol_field_begin{ name = "field1", type = ?tType_BOOL, id = 1}),
- {P4, ok} = write(P3, {bool, true}),
- {P5, ok} = write(P4, field_end),
- {P6, ok} = write(P5, #protocol_field_begin{ name = "field2", type = ?tType_BOOL, id = 14}),
- {P7, ok} = write(P6, {bool, false}),
- {P8, ok} = write(P7, field_end),
- {P9, ok} = write(P8, #protocol_field_begin{ name = "field3", type = ?tType_BOOL, id = 42}),
- {P10, ok} = write(P9, {bool, true}),
- {P11, ok} = write(P10, field_end),
- {P12, ok} = write(P11, field_stop),
- {P13, ok} = write(P12, struct_end),
- {P14, ok} = write(P13, message_end),
+ {ok, P0} = new(),
+ {P1, ok} = write(P0, #protocol_message_begin{name = "Message1", type = ?tType_I8, seqid = 3}),
+ {P2, ok} = write(P1, #protocol_struct_begin{}),
+ {P3, ok} = write(P2, #protocol_field_begin{name = "field1", type = ?tType_BOOL, id = 1}),
+ {P4, ok} = write(P3, {bool, true}),
+ {P5, ok} = write(P4, field_end),
+ {P6, ok} = write(P5, #protocol_field_begin{name = "field2", type = ?tType_BOOL, id = 14}),
+ {P7, ok} = write(P6, {bool, false}),
+ {P8, ok} = write(P7, field_end),
+ {P9, ok} = write(P8, #protocol_field_begin{name = "field3", type = ?tType_BOOL, id = 42}),
+ {P10, ok} = write(P9, {bool, true}),
+ {P11, ok} = write(P10, field_end),
+ {P12, ok} = write(P11, field_stop),
+ {P13, ok} = write(P12, struct_end),
+ {P14, ok} = write(P13, message_end),
- {P15, #protocol_message_begin{ name = "Message1", type = ?tType_I8, seqid = 3}} = read(P14, message_begin),
- {P16, ok} = read(P15, struct_begin),
- {P17, #protocol_field_begin{ type = ?tType_BOOL, id = 1 }} = read(P16, field_begin),
- {P18, {ok, true}} = read(P17, bool),
- {P19, ok} = read(P18, field_end),
- {P20, #protocol_field_begin{ type = ?tType_BOOL, id = 14 }} = read(P19, field_begin),
- {P21, {ok, false}} = read(P20, bool),
- {P22, ok} = read(P21, field_end),
- {P23, #protocol_field_begin{ type = ?tType_BOOL, id = 42 }} = read(P22, field_begin),
- {P24, {ok, true}} = read(P23, bool),
- {P25, ok} = read(P24, field_end),
- {P26, #protocol_field_begin{ type = ?tType_STOP}} = read(P25, field_begin),
- {P27, ok} = read(P26, struct_end),
- {P28, ok} = read(P27, message_end),
- {P28, ok}.
+ {P15, #protocol_message_begin{name = "Message1", type = ?tType_I8, seqid = 3}} = read(
+ P14, message_begin
+ ),
+ {P16, ok} = read(P15, struct_begin),
+ {P17, #protocol_field_begin{type = ?tType_BOOL, id = 1}} = read(P16, field_begin),
+ {P18, {ok, true}} = read(P17, bool),
+ {P19, ok} = read(P18, field_end),
+ {P20, #protocol_field_begin{type = ?tType_BOOL, id = 14}} = read(P19, field_begin),
+ {P21, {ok, false}} = read(P20, bool),
+ {P22, ok} = read(P21, field_end),
+ {P23, #protocol_field_begin{type = ?tType_BOOL, id = 42}} = read(P22, field_begin),
+ {P24, {ok, true}} = read(P23, bool),
+ {P25, ok} = read(P24, field_end),
+ {P26, #protocol_field_begin{type = ?tType_STOP}} = read(P25, field_begin),
+ {P27, ok} = read(P26, struct_end),
+ {P28, ok} = read(P27, message_end),
+ {P28, ok}.
nesting_test() ->
- {ok, P0} = new(),
- {P1, ok} = write(P0, #protocol_message_begin{ name = "Message1", type = ?tType_I8, seqid = 3}),
- {P2, ok} = write(P1, #protocol_struct_begin{}),
- {P3, ok} = write(P2, #protocol_field_begin{ name = "field1", type = ?tType_BOOL, id = 14}),
- {P4, ok} = write(P3, {bool, true}),
- {P5, ok} = write(P4, field_end),
+ {ok, P0} = new(),
+ {P1, ok} = write(P0, #protocol_message_begin{name = "Message1", type = ?tType_I8, seqid = 3}),
+ {P2, ok} = write(P1, #protocol_struct_begin{}),
+ {P3, ok} = write(P2, #protocol_field_begin{name = "field1", type = ?tType_BOOL, id = 14}),
+ {P4, ok} = write(P3, {bool, true}),
+ {P5, ok} = write(P4, field_end),
- {P6, ok} = write(P5, #protocol_field_begin{ name = "field2", type = ?tType_STRUCT, id = 28}),
- {P7, ok} = write(P6, #protocol_struct_begin{}),
- {P8, ok} = write(P7, #protocol_field_begin{ name = "field2_1", type = ?tType_BOOL, id = 30000}),
- {P9, ok} = write(P8, {bool, false}),
- {P10, ok} = write(P9, field_end),
- {P11, ok} = write(P10, field_stop),
- {P12, ok} = write(P11, struct_end),
- {P13, ok} = write(P12, field_end),
+ {P6, ok} = write(P5, #protocol_field_begin{name = "field2", type = ?tType_STRUCT, id = 28}),
+ {P7, ok} = write(P6, #protocol_struct_begin{}),
+ {P8, ok} = write(P7, #protocol_field_begin{name = "field2_1", type = ?tType_BOOL, id = 30000}),
+ {P9, ok} = write(P8, {bool, false}),
+ {P10, ok} = write(P9, field_end),
+ {P11, ok} = write(P10, field_stop),
+ {P12, ok} = write(P11, struct_end),
+ {P13, ok} = write(P12, field_end),
- {P14, ok} = write(P13, #protocol_field_begin{ name = "field3", type = ?tType_BOOL, id = 42}),
- {P15, ok} = write(P14, {bool, true}),
- {P16, ok} = write(P15, field_end),
- {P17, ok} = write(P16, field_stop),
- {P18, ok} = write(P17, struct_end),
- {P19, ok} = write(P18, message_end),
+ {P14, ok} = write(P13, #protocol_field_begin{name = "field3", type = ?tType_BOOL, id = 42}),
+ {P15, ok} = write(P14, {bool, true}),
+ {P16, ok} = write(P15, field_end),
+ {P17, ok} = write(P16, field_stop),
+ {P18, ok} = write(P17, struct_end),
+ {P19, ok} = write(P18, message_end),
- {P20, #protocol_message_begin{ name = "Message1", type = ?tType_I8, seqid = 3}} = read(P19, message_begin),
- {P21, ok} = read(P20, struct_begin),
- {P22, #protocol_field_begin{ type = ?tType_BOOL, id = 14 }} = read(P21, field_begin),
- {P23, {ok, true}} = read(P22, bool),
- {P24, ok} = read(P23, field_end),
+ {P20, #protocol_message_begin{name = "Message1", type = ?tType_I8, seqid = 3}} = read(
+ P19, message_begin
+ ),
+ {P21, ok} = read(P20, struct_begin),
+ {P22, #protocol_field_begin{type = ?tType_BOOL, id = 14}} = read(P21, field_begin),
+ {P23, {ok, true}} = read(P22, bool),
+ {P24, ok} = read(P23, field_end),
- {P25, #protocol_field_begin{ type = ?tType_STRUCT, id = 28 }} = read(P24, field_begin),
- {P26, ok} = read(P25, struct_begin),
- {P27, #protocol_field_begin{ type = ?tType_BOOL, id = 30000 }} = read(P26, field_begin),
- {P28, {ok, false}} = read(P27, bool),
- {P29, ok} = read(P28, field_end),
- {P30, #protocol_field_begin{ type = ?tType_STOP }} = read(P29, field_begin),
- {P31, ok} = read(P30, struct_end),
- {P32, ok} = read(P31, field_end),
+ {P25, #protocol_field_begin{type = ?tType_STRUCT, id = 28}} = read(P24, field_begin),
+ {P26, ok} = read(P25, struct_begin),
+ {P27, #protocol_field_begin{type = ?tType_BOOL, id = 30000}} = read(P26, field_begin),
+ {P28, {ok, false}} = read(P27, bool),
+ {P29, ok} = read(P28, field_end),
+ {P30, #protocol_field_begin{type = ?tType_STOP}} = read(P29, field_begin),
+ {P31, ok} = read(P30, struct_end),
+ {P32, ok} = read(P31, field_end),
- {P33, #protocol_field_begin{ type = ?tType_BOOL, id = 42 }} = read(P32, field_begin),
- {P34, {ok, true}} = read(P33, bool),
- {P35, ok} = read(P34, field_end),
- {P36, #protocol_field_begin{ type = ?tType_STOP }} = read(P35, field_begin),
- {P37, ok} = read(P36, struct_end),
- {P38, ok} = read(P37, message_end),
- {P38, ok}.
+ {P33, #protocol_field_begin{type = ?tType_BOOL, id = 42}} = read(P32, field_begin),
+ {P34, {ok, true}} = read(P33, bool),
+ {P35, ok} = read(P34, field_end),
+ {P36, #protocol_field_begin{type = ?tType_STOP}} = read(P35, field_begin),
+ {P37, ok} = read(P36, struct_end),
+ {P38, ok} = read(P37, message_end),
+ {P38, ok}.
diff --git a/lib/erl/test/test_thrift_file_transport.erl b/lib/erl/test/test_thrift_file_transport.erl
index 3e5c1d1..85b6c46 100644
--- a/lib/erl/test/test_thrift_file_transport.erl
+++ b/lib/erl/test/test_thrift_file_transport.erl
@@ -20,194 +20,205 @@
-module(test_thrift_file_transport).
-include_lib("eunit/include/eunit.hrl").
-
new(File) -> thrift_file_transport:new(File).
new(File, Opts) -> thrift_file_transport:new(File, Opts).
new_test_() ->
- [
- {"new file", ?_assertMatch(
- {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, write}}},
- new(a_fake_file)
- )},
- {"new file in read mode", ?_assertMatch(
- {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, read}}},
- new(a_fake_file, [{mode, read}])
- )},
- {"new file in write mode", ?_assertMatch(
- {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, write}}},
- new(a_fake_file, [{mode, write}])
- )},
- {"new file in should_close true mode", ?_assertMatch(
- {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, write}}},
- new(a_fake_file, [{should_close, true}])
- )},
- {"new file in should_close false mode", ?_assertMatch(
- {ok, {_, thrift_file_transport, {t_file, a_fake_file, false, write}}},
- new(a_fake_file, [{should_close, false}])
- )}
- ].
-
+ [
+ {"new file",
+ ?_assertMatch(
+ {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, write}}},
+ new(a_fake_file)
+ )},
+ {"new file in read mode",
+ ?_assertMatch(
+ {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, read}}},
+ new(a_fake_file, [{mode, read}])
+ )},
+ {"new file in write mode",
+ ?_assertMatch(
+ {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, write}}},
+ new(a_fake_file, [{mode, write}])
+ )},
+ {"new file in should_close true mode",
+ ?_assertMatch(
+ {ok, {_, thrift_file_transport, {t_file, a_fake_file, true, write}}},
+ new(a_fake_file, [{should_close, true}])
+ )},
+ {"new file in should_close false mode",
+ ?_assertMatch(
+ {ok, {_, thrift_file_transport, {t_file, a_fake_file, false, write}}},
+ new(a_fake_file, [{should_close, false}])
+ )}
+ ].
read(File, Bytes) -> thrift_file_transport:read(File, Bytes).
read_test_() ->
- {setup,
- fun() ->
- meck:new(file, [unstick, passthrough]),
- meck:expect(file, read, fun(Bin, N) ->
- {Result, _} = split_binary(Bin, min(iolist_size(Bin), N)),
- {ok, Result}
- end)
- end,
- fun(_) -> meck:unload(file) end,
- [
- {"read zero bytes from empty file", ?_assertMatch(
- {_, {ok, <<>>}},
- read({t_file, <<>>, true, read}, 0)
- )},
- {"read 1 byte from empty file", ?_assertMatch(
- {_, {ok, <<>>}},
- read({t_file, <<>>, true, read}, 1)
- )},
- {"read zero bytes from nonempty file", ?_assertMatch(
- {_, {ok, <<>>}},
- read({t_file, <<"hallo world">>, true, read}, 0)
- )},
- {"read 1 byte from nonempty file", ?_assertMatch(
- {_, {ok, <<"h">>}},
- read({t_file, <<"hallo world">>, true, read}, 1)
- )},
- {"read a zillion bytes from nonempty file", ?_assertMatch(
- {_, {ok, <<"hallo world">>}},
- read({t_file, <<"hallo world">>, true, read}, 65536)
- )},
- {"read 0 byte from file in write mode", ?_assertMatch(
- {_, {error, write_mode}},
- read({t_file, <<>>, true, write}, 0)
- )},
- {"read 1 byte from file in write mode", ?_assertMatch(
- {_, {error, write_mode}},
- read({t_file, <<>>, true, write}, 1)
- )}
- ]
- }.
-
+ {setup,
+ fun() ->
+ meck:new(file, [unstick, passthrough]),
+ meck:expect(file, read, fun(Bin, N) ->
+ {Result, _} = split_binary(Bin, min(iolist_size(Bin), N)),
+ {ok, Result}
+ end)
+ end,
+ fun(_) -> meck:unload(file) end, [
+ {"read zero bytes from empty file",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read({t_file, <<>>, true, read}, 0)
+ )},
+ {"read 1 byte from empty file",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read({t_file, <<>>, true, read}, 1)
+ )},
+ {"read zero bytes from nonempty file",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read({t_file, <<"hallo world">>, true, read}, 0)
+ )},
+ {"read 1 byte from nonempty file",
+ ?_assertMatch(
+ {_, {ok, <<"h">>}},
+ read({t_file, <<"hallo world">>, true, read}, 1)
+ )},
+ {"read a zillion bytes from nonempty file",
+ ?_assertMatch(
+ {_, {ok, <<"hallo world">>}},
+ read({t_file, <<"hallo world">>, true, read}, 65536)
+ )},
+ {"read 0 byte from file in write mode",
+ ?_assertMatch(
+ {_, {error, write_mode}},
+ read({t_file, <<>>, true, write}, 0)
+ )},
+ {"read 1 byte from file in write mode",
+ ?_assertMatch(
+ {_, {error, write_mode}},
+ read({t_file, <<>>, true, write}, 1)
+ )}
+ ]}.
read_exact(File, Bytes) -> thrift_file_transport:read_exact(File, Bytes).
read_exact_test_() ->
- {setup,
- fun() ->
- meck:new(file, [unstick, passthrough]),
- meck:expect(file, read, fun(Bin, N) ->
- {Result, _} = split_binary(Bin, min(iolist_size(Bin), N)),
- {ok, Result}
- end)
- end,
- fun(_) -> meck:unload(file) end,
- [
- {"read exactly zero bytes from empty file", ?_assertMatch(
- {_, {ok, <<>>}},
- read_exact({t_file, <<>>, true, read}, 0)
- )},
- {"read exactly 1 byte from empty file", ?_assertMatch(
- {_, {error, eof}},
- read_exact({t_file, <<>>, true, read}, 1)
- )},
- {"read exactly zero bytes from nonempty file", ?_assertMatch(
- {_, {ok, <<>>}},
- read_exact({t_file, <<"hallo world">>, true, read}, 0)
- )},
- {"read exactly 1 byte from nonempty file", ?_assertMatch(
- {_, {ok, <<"h">>}},
- read_exact({t_file, <<"hallo world">>, true, read}, 1)
- )},
- {"read exactly a zillion bytes from nonempty file", ?_assertMatch(
- {_, {error, eof}},
- read_exact({t_file, <<"hallo world">>, true, read}, 65536)
- )},
- {"read exactly 0 byte from file in write mode", ?_assertMatch(
- {_, {error, write_mode}},
- read_exact({t_file, <<>>, true, write}, 0)
- )},
- {"read exactly 1 byte from file in write mode", ?_assertMatch(
- {_, {error, write_mode}},
- read_exact({t_file, <<>>, true, write}, 1)
- )}
- ]
- }.
-
+ {setup,
+ fun() ->
+ meck:new(file, [unstick, passthrough]),
+ meck:expect(file, read, fun(Bin, N) ->
+ {Result, _} = split_binary(Bin, min(iolist_size(Bin), N)),
+ {ok, Result}
+ end)
+ end,
+ fun(_) -> meck:unload(file) end, [
+ {"read exactly zero bytes from empty file",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read_exact({t_file, <<>>, true, read}, 0)
+ )},
+ {"read exactly 1 byte from empty file",
+ ?_assertMatch(
+ {_, {error, eof}},
+ read_exact({t_file, <<>>, true, read}, 1)
+ )},
+ {"read exactly zero bytes from nonempty file",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read_exact({t_file, <<"hallo world">>, true, read}, 0)
+ )},
+ {"read exactly 1 byte from nonempty file",
+ ?_assertMatch(
+ {_, {ok, <<"h">>}},
+ read_exact({t_file, <<"hallo world">>, true, read}, 1)
+ )},
+ {"read exactly a zillion bytes from nonempty file",
+ ?_assertMatch(
+ {_, {error, eof}},
+ read_exact({t_file, <<"hallo world">>, true, read}, 65536)
+ )},
+ {"read exactly 0 byte from file in write mode",
+ ?_assertMatch(
+ {_, {error, write_mode}},
+ read_exact({t_file, <<>>, true, write}, 0)
+ )},
+ {"read exactly 1 byte from file in write mode",
+ ?_assertMatch(
+ {_, {error, write_mode}},
+ read_exact({t_file, <<>>, true, write}, 1)
+ )}
+ ]}.
write(File, Data) -> thrift_file_transport:write(File, Data).
write_test_() ->
- {setup,
- fun() ->
- meck:new(file, [unstick, passthrough]),
- meck:expect(file, write, fun(_, _) -> ok end)
- end,
- fun(_) -> meck:unload(file) end,
- [
- {"write empty list to file", ?_assertMatch(
- {{t_file, a_fake_file, true, write}, ok},
- write({t_file, a_fake_file, true, write}, [])
- )},
- {"write empty binary to file", ?_assertMatch(
- {{t_file, a_fake_file, true, write}, ok},
- write({t_file, a_fake_file, true, write}, <<>>)
- )},
- {"write a list to file", ?_assertMatch(
- {{t_file, a_fake_file, true, write}, ok},
- write({t_file, a_fake_file, true, write}, "hallo world")
- )},
- {"write a binary to file", ?_assertMatch(
- {{t_file, a_fake_file, true, write}, ok},
- write({t_file, a_fake_file, true, write}, <<"hallo world">>)
- )},
- {"write a binary to file in read mode", ?_assertMatch(
- {_, {error, read_mode}},
- write({t_file, a_fake_file, true, read}, <<"hallo world">>)
- )},
- {"write a list to file in read mode", ?_assertMatch(
- {_, {error, read_mode}},
- write({t_file, a_fake_file, true, read}, "hallo world")
- )}
- ]
- }.
-
+ {setup,
+ fun() ->
+ meck:new(file, [unstick, passthrough]),
+ meck:expect(file, write, fun(_, _) -> ok end)
+ end,
+ fun(_) -> meck:unload(file) end, [
+ {"write empty list to file",
+ ?_assertMatch(
+ {{t_file, a_fake_file, true, write}, ok},
+ write({t_file, a_fake_file, true, write}, [])
+ )},
+ {"write empty binary to file",
+ ?_assertMatch(
+ {{t_file, a_fake_file, true, write}, ok},
+ write({t_file, a_fake_file, true, write}, <<>>)
+ )},
+ {"write a list to file",
+ ?_assertMatch(
+ {{t_file, a_fake_file, true, write}, ok},
+ write({t_file, a_fake_file, true, write}, "hallo world")
+ )},
+ {"write a binary to file",
+ ?_assertMatch(
+ {{t_file, a_fake_file, true, write}, ok},
+ write({t_file, a_fake_file, true, write}, <<"hallo world">>)
+ )},
+ {"write a binary to file in read mode",
+ ?_assertMatch(
+ {_, {error, read_mode}},
+ write({t_file, a_fake_file, true, read}, <<"hallo world">>)
+ )},
+ {"write a list to file in read mode",
+ ?_assertMatch(
+ {_, {error, read_mode}},
+ write({t_file, a_fake_file, true, read}, "hallo world")
+ )}
+ ]}.
flush(Transport) -> thrift_file_transport:flush(Transport).
flush_test_() ->
- {setup,
- fun() ->
- meck:new(file, [unstick, passthrough]),
- meck:expect(file, sync, fun(_File) -> ok end)
- end,
- fun(_) -> meck:unload(file) end,
- [
- {"flush file", ?_assertMatch(
- {{t_file, a_fake_file, true, write}, ok},
- flush({t_file, a_fake_file, true, write})
- )}
- ]
- }.
-
+ {setup,
+ fun() ->
+ meck:new(file, [unstick, passthrough]),
+ meck:expect(file, sync, fun(_File) -> ok end)
+ end,
+ fun(_) -> meck:unload(file) end, [
+ {"flush file",
+ ?_assertMatch(
+ {{t_file, a_fake_file, true, write}, ok},
+ flush({t_file, a_fake_file, true, write})
+ )}
+ ]}.
close(Transport) -> thrift_file_transport:close(Transport).
close_test_() ->
- {setup,
- fun() ->
- meck:new(file, [unstick, passthrough]),
- meck:expect(file, close, fun(_) -> ok end)
- end,
- fun(_) -> meck:unload(file) end,
- [
- {"close file", ?_assertMatch(
- {{t_file, a_fake_file, true, write}, ok},
- close({t_file, a_fake_file, true, write})
- )}
- ]
- }.
\ No newline at end of file
+ {setup,
+ fun() ->
+ meck:new(file, [unstick, passthrough]),
+ meck:expect(file, close, fun(_) -> ok end)
+ end,
+ fun(_) -> meck:unload(file) end, [
+ {"close file",
+ ?_assertMatch(
+ {{t_file, a_fake_file, true, write}, ok},
+ close({t_file, a_fake_file, true, write})
+ )}
+ ]}.
diff --git a/lib/erl/test/test_thrift_framed_transport.erl b/lib/erl/test/test_thrift_framed_transport.erl
index 8a538a5..b960920 100644
--- a/lib/erl/test/test_thrift_framed_transport.erl
+++ b/lib/erl/test/test_thrift_framed_transport.erl
@@ -20,385 +20,302 @@
-module(test_thrift_framed_transport).
-include_lib("eunit/include/eunit.hrl").
-
new(Transport) -> thrift_framed_transport:new(Transport).
new_test_() ->
- [
- {"new framed membuffer", ?_assertMatch(
- {ok, {t_transport, thrift_framed_transport, {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, []}},
- [],
- []
- }}},
- new({t_transport, thrift_membuffer_transport, {t_membuffer, []}})
- )}
- ].
-
+ [
+ {"new framed membuffer",
+ ?_assertMatch(
+ {ok,
+ {t_transport, thrift_framed_transport,
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, []}}, [],
+ []}}},
+ new({t_transport, thrift_membuffer_transport, {t_membuffer, []}})
+ )}
+ ].
read(Frame, Bytes) -> thrift_framed_transport:read(Frame, Bytes).
read_test_() ->
- [
- {"read zero bytes from an empty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- {ok, <<>>}
- },
- read(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- 0
- )
- )},
- {"read 1 byte from an empty framed membuffer", ?_assertMatch(
- {_, {error, eof}},
- read(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- 1
- )
- )},
- {"read zero bytes from nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- [],
- []
- },
- {ok, <<>>}
- },
- read(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- [],
- []
- },
- 0
- )
- )},
- {"read 1 byte from nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<"allo world">>,
- []
- },
- {ok, <<"h">>}
- },
- read(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- [],
- []
- },
- 1
- )
- )},
- {"read 1 byte from nonempty buffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<"allo world">>,
- []
- },
- {ok, <<"h">>}
- },
- read(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<"hallo world">>,
- []
- },
- 1
- )
- )},
- {"read a zillion bytes from nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<>>,
- []
- },
- {ok, <<"hallo world">>}
- },
- read(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- [],
- []
- },
- 65536
- )
- )}
- ].
-
+ [
+ {"read zero bytes from an empty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ {ok, <<>>}
+ },
+ read(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ 0
+ )
+ )},
+ {"read 1 byte from an empty framed membuffer",
+ ?_assertMatch(
+ {_, {error, eof}},
+ read(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ 1
+ )
+ )},
+ {"read zero bytes from nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ [], []},
+ {ok, <<>>}
+ },
+ read(
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ [], []},
+ 0
+ )
+ )},
+ {"read 1 byte from nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ <<"allo world">>, []},
+ {ok, <<"h">>}
+ },
+ read(
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ [], []},
+ 1
+ )
+ )},
+ {"read 1 byte from nonempty buffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ <<"allo world">>, []},
+ {ok, <<"h">>}
+ },
+ read(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ <<"hallo world">>, []},
+ 1
+ )
+ )},
+ {"read a zillion bytes from nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, <<>>,
+ []},
+ {ok, <<"hallo world">>}
+ },
+ read(
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ [], []},
+ 65536
+ )
+ )}
+ ].
read_exact(Frame, Bytes) -> thrift_framed_transport:read_exact(Frame, Bytes).
read_exact_test_() ->
- [
- {"read exactly zero bytes from an empty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<>>,
- []
- },
- {ok, <<>>}
- },
- read_exact(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- 0
- )
- )},
- {"read exactly 1 byte from an empty framed membuffer", ?_assertMatch(
- {_, {error, eof}},
- read_exact(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- 1
- )
- )},
- {"read exactly zero bytes from nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- <<>>,
- []
- },
- {ok, <<>>}
- },
- read_exact(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- [],
- []
- },
- 0
- )
- )},
- {"read exactly 1 byte from nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<"allo world">>,
- []
- },
- {ok, <<"h">>}
- },
- read_exact(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- [],
- []
- },
- 1
- )
- )},
- {"read exactly 1 byte from nonempty buffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<"allo world">>,
- []
- },
- {ok, <<"h">>}
- },
- read_exact(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- <<"hallo world">>,
- []
- },
- 1
- )
- )},
- {"read exactly a zillion bytes from nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [[],<<"hallo world">>],
- []
- },
- {error, eof}
- },
- read_exact(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- <<0, 0, 0, 11, "hallo world">>
- }},
- [],
- []
- },
- 65536
- )
- )}
- ].
-
+ [
+ {"read exactly zero bytes from an empty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, <<>>,
+ []},
+ {ok, <<>>}
+ },
+ read_exact(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ 0
+ )
+ )},
+ {"read exactly 1 byte from an empty framed membuffer",
+ ?_assertMatch(
+ {_, {error, eof}},
+ read_exact(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ 1
+ )
+ )},
+ {"read exactly zero bytes from nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ <<>>, []},
+ {ok, <<>>}
+ },
+ read_exact(
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ [], []},
+ 0
+ )
+ )},
+ {"read exactly 1 byte from nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ <<"allo world">>, []},
+ {ok, <<"h">>}
+ },
+ read_exact(
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ [], []},
+ 1
+ )
+ )},
+ {"read exactly 1 byte from nonempty buffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ <<"allo world">>, []},
+ {ok, <<"h">>}
+ },
+ read_exact(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ <<"hallo world">>, []},
+ 1
+ )
+ )},
+ {"read exactly a zillion bytes from nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
+ [[], <<"hallo world">>], []},
+ {error, eof}
+ },
+ read_exact(
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, <<0, 0, 0, 11, "hallo world">>}},
+ [], []},
+ 65536
+ )
+ )}
+ ].
write(Framed, Data) -> thrift_framed_transport:write(Framed, Data).
write_test_() ->
- [
- {"write empty list to empty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- [[], []]
- },
- ok
- },
- write(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- []
- )
- )},
- {"write empty list to nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- [["hallo world"], []]
- },
- ok
- },
- write(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- ["hallo world"]
- },
- []
- )
- )},
- {"write empty binary to empty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- [[], <<>>]
- },
- ok
- },
- write(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- <<>>
- )
- )},
- {"write empty binary to nonempty framed membuffer", ?_assertMatch(
- {
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- [["hallo world"], <<>>]
- },
- ok
- },
- write(
- {t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- ["hallo world"]
- },
- <<>>
- )
- )}
- ].
-
+ [
+ {"write empty list to empty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], [
+ [], []
+ ]},
+ ok
+ },
+ write(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ []
+ )
+ )},
+ {"write empty list to nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], [
+ ["hallo world"], []
+ ]},
+ ok
+ },
+ write(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], [
+ "hallo world"
+ ]},
+ []
+ )
+ )},
+ {"write empty binary to empty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], [
+ [], <<>>
+ ]},
+ ok
+ },
+ write(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ <<>>
+ )
+ )},
+ {"write empty binary to nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], [
+ ["hallo world"], <<>>
+ ]},
+ ok
+ },
+ write(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], [
+ "hallo world"
+ ]},
+ <<>>
+ )
+ )}
+ ].
flush(Transport) -> thrift_framed_transport:flush(Transport).
flush_test_() ->
- [
- {"flush empty framed membuffer", ?_assertMatch(
- {{t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- ok
- },
- flush({t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- })
- )},
- {"flush nonempty framed membuffer", ?_assertMatch(
- {{t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer,
- [<<>>, [<<0, 0, 0, 11>>, <<"hallo world">>]]
- }},
- [],
- []
- },
- ok
- },
- flush({t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- <<"hallo world">>
- })
- )}
- ].
-
+ [
+ {"flush empty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []},
+ ok
+ },
+ flush(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ []}
+ )
+ )},
+ {"flush nonempty framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed,
+ {t_transport, thrift_membuffer_transport,
+ {t_membuffer, [<<>>, [<<0, 0, 0, 11>>, <<"hallo world">>]]}},
+ [], []},
+ ok
+ },
+ flush(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [],
+ <<"hallo world">>}
+ )
+ )}
+ ].
close(Transport) -> thrift_framed_transport:close(Transport).
close_test_() ->
- {"close framed membuffer", ?_assertMatch(
- {{t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- },
- ok
- },
- close({t_framed,
- {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}},
- [],
- []
- })
- )}.
-
+ {"close framed membuffer",
+ ?_assertMatch(
+ {
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], []},
+ ok
+ },
+ close(
+ {t_framed, {t_transport, thrift_membuffer_transport, {t_membuffer, <<>>}}, [], []}
+ )
+ )}.
diff --git a/lib/erl/test/test_thrift_membuffer_transport.erl b/lib/erl/test/test_thrift_membuffer_transport.erl
index 9689c79..e388311 100644
--- a/lib/erl/test/test_thrift_membuffer_transport.erl
+++ b/lib/erl/test/test_thrift_membuffer_transport.erl
@@ -20,148 +20,168 @@
-module(test_thrift_membuffer_transport).
-include_lib("eunit/include/eunit.hrl").
-
new() -> thrift_membuffer_transport:new().
new(Data) -> thrift_membuffer_transport:new(Data).
new_test_() ->
- [
- {"new empty membuffer", ?_assertMatch(
- {ok, {_, _, {t_membuffer, []}}},
- new()
- )},
- {"new membuffer with <<>>", ?_assertMatch(
- {ok, {_, _, {t_membuffer, [<<>>]}}},
- new(<<>>)
- )},
- {"new membuffer with []", ?_assertMatch(
- {ok, {_, _, {t_membuffer, []}}},
- new([])
- )},
- {"new membuffer with <<\"hallo world\">>", ?_assertMatch(
- {ok, {_, _, {t_membuffer, [<<"hallo world">>]}}},
- new(<<"hallo world">>)
- )},
- {"new membuffer with \"hallo world\"", ?_assertMatch(
- {ok, {_, _, {t_membuffer, "hallo world"}}},
- new("hallo world")
- )}
- ].
-
+ [
+ {"new empty membuffer",
+ ?_assertMatch(
+ {ok, {_, _, {t_membuffer, []}}},
+ new()
+ )},
+ {"new membuffer with <<>>",
+ ?_assertMatch(
+ {ok, {_, _, {t_membuffer, [<<>>]}}},
+ new(<<>>)
+ )},
+ {"new membuffer with []",
+ ?_assertMatch(
+ {ok, {_, _, {t_membuffer, []}}},
+ new([])
+ )},
+ {"new membuffer with <<\"hallo world\">>",
+ ?_assertMatch(
+ {ok, {_, _, {t_membuffer, [<<"hallo world">>]}}},
+ new(<<"hallo world">>)
+ )},
+ {"new membuffer with \"hallo world\"",
+ ?_assertMatch(
+ {ok, {_, _, {t_membuffer, "hallo world"}}},
+ new("hallo world")
+ )}
+ ].
read(Membuffer, Bytes) -> thrift_membuffer_transport:read(Membuffer, Bytes).
read_test_() ->
- [
- {"read zero bytes from an empty membuffer", ?_assertMatch(
- {_, {ok, <<>>}},
- read({t_membuffer, []}, 0)
- )},
- {"read 1 byte from an empty membuffer", ?_assertMatch(
- {_, {ok, <<>>}},
- read({t_membuffer, []}, 1)
- )},
- {"read zero bytes from nonempty membuffer", ?_assertMatch(
- {{t_membuffer, <<"hallo world">>}, {ok, <<>>}},
- read({t_membuffer, [["hallo", " "], "world"]}, 0)
- )},
- {"read 1 byte from nonempty membuffer", ?_assertMatch(
- {{t_membuffer, <<"allo world">>}, {ok, <<"h">>}},
- read({t_membuffer, [["hallo", " "], "world"]}, 1)
- )},
- {"read a zillion bytes from nonempty buffer", ?_assertMatch(
- {{t_membuffer, <<>>}, {ok, <<"hallo world">>}},
- read({t_membuffer, [["hallo", " "], "world"]}, 65536)
- )}
- ].
-
+ [
+ {"read zero bytes from an empty membuffer",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read({t_membuffer, []}, 0)
+ )},
+ {"read 1 byte from an empty membuffer",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read({t_membuffer, []}, 1)
+ )},
+ {"read zero bytes from nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, <<"hallo world">>}, {ok, <<>>}},
+ read({t_membuffer, [["hallo", " "], "world"]}, 0)
+ )},
+ {"read 1 byte from nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, <<"allo world">>}, {ok, <<"h">>}},
+ read({t_membuffer, [["hallo", " "], "world"]}, 1)
+ )},
+ {"read a zillion bytes from nonempty buffer",
+ ?_assertMatch(
+ {{t_membuffer, <<>>}, {ok, <<"hallo world">>}},
+ read({t_membuffer, [["hallo", " "], "world"]}, 65536)
+ )}
+ ].
read_exact(Membuffer, Bytes) ->
- thrift_membuffer_transport:read_exact(Membuffer, Bytes).
+ thrift_membuffer_transport:read_exact(Membuffer, Bytes).
read_exact_test_() ->
- [
- {"read exactly zero bytes from an empty membuffer", ?_assertMatch(
- {_, {ok, <<>>}},
- read_exact({t_membuffer, []}, 0)
- )},
- {"read exactly 1 byte from an empty membuffer", ?_assertMatch(
- {_, {error, eof}},
- read_exact({t_membuffer, []}, 1)
- )},
- {"read exactly zero bytes from nonempty membuffer", ?_assertMatch(
- {{t_membuffer, <<"hallo world">>}, {ok, <<>>}},
- read_exact({t_membuffer, [["hallo", " "], "world"]}, 0)
- )},
- {"read exactly 1 byte from nonempty membuffer", ?_assertMatch(
- {{t_membuffer, <<"allo world">>}, {ok, <<"h">>}},
- read_exact({t_membuffer, [["hallo", " "], "world"]}, 1)
- )},
- {"read exactly a zillion bytes from nonempty buffer", ?_assertMatch(
- {{t_membuffer, [["hallo", " "], "world"]}, {error, eof}},
- read_exact({t_membuffer, [["hallo", " "], "world"]}, 65536)
- )}
- ].
-
+ [
+ {"read exactly zero bytes from an empty membuffer",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read_exact({t_membuffer, []}, 0)
+ )},
+ {"read exactly 1 byte from an empty membuffer",
+ ?_assertMatch(
+ {_, {error, eof}},
+ read_exact({t_membuffer, []}, 1)
+ )},
+ {"read exactly zero bytes from nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, <<"hallo world">>}, {ok, <<>>}},
+ read_exact({t_membuffer, [["hallo", " "], "world"]}, 0)
+ )},
+ {"read exactly 1 byte from nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, <<"allo world">>}, {ok, <<"h">>}},
+ read_exact({t_membuffer, [["hallo", " "], "world"]}, 1)
+ )},
+ {"read exactly a zillion bytes from nonempty buffer",
+ ?_assertMatch(
+ {{t_membuffer, [["hallo", " "], "world"]}, {error, eof}},
+ read_exact({t_membuffer, [["hallo", " "], "world"]}, 65536)
+ )}
+ ].
write(Membuffer, Data) -> thrift_membuffer_transport:write(Membuffer, Data).
write_test_() ->
- [
- {"write empty list to empty membuffer", ?_assertMatch(
- {{t_membuffer, [[], []]}, ok},
- write({t_membuffer, []}, [])
- )},
- {"write empty list to nonempty membuffer", ?_assertMatch(
- {{t_membuffer, ["hallo world", []]}, ok},
- write({t_membuffer, "hallo world"}, [])
- )},
- {"write empty binary to empty membuffer", ?_assertMatch(
- {{t_membuffer, [[], <<>>]}, ok},
- write({t_membuffer, []}, <<>>)
- )},
- {"write empty binary to nonempty membuffer", ?_assertMatch(
- {{t_membuffer, ["hallo world", <<>>]}, ok},
- write({t_membuffer, "hallo world"}, <<>>)
- )},
- {"write a list to empty membuffer", ?_assertMatch(
- {{t_membuffer, [[], "hallo world"]}, ok},
- write({t_membuffer, []}, "hallo world")
- )},
- {"write a list to nonempty membuffer", ?_assertMatch(
- {{t_membuffer, [["hallo", " "], "world"]}, ok},
- write({t_membuffer, ["hallo", " "]}, "world")
- )},
- {"write a binary to empty membuffer", ?_assertMatch(
- {{t_membuffer, [[], <<"hallo world">>]}, ok},
- write({t_membuffer, []}, <<"hallo world">>)
- )},
- {"write a binary to nonempty membuffer", ?_assertMatch(
- {{t_membuffer, [["hallo", " "], <<"world">>]}, ok},
- write({t_membuffer, ["hallo", " "]}, <<"world">>)
- )}
- ].
-
+ [
+ {"write empty list to empty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, [[], []]}, ok},
+ write({t_membuffer, []}, [])
+ )},
+ {"write empty list to nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, ["hallo world", []]}, ok},
+ write({t_membuffer, "hallo world"}, [])
+ )},
+ {"write empty binary to empty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, [[], <<>>]}, ok},
+ write({t_membuffer, []}, <<>>)
+ )},
+ {"write empty binary to nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, ["hallo world", <<>>]}, ok},
+ write({t_membuffer, "hallo world"}, <<>>)
+ )},
+ {"write a list to empty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, [[], "hallo world"]}, ok},
+ write({t_membuffer, []}, "hallo world")
+ )},
+ {"write a list to nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, [["hallo", " "], "world"]}, ok},
+ write({t_membuffer, ["hallo", " "]}, "world")
+ )},
+ {"write a binary to empty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, [[], <<"hallo world">>]}, ok},
+ write({t_membuffer, []}, <<"hallo world">>)
+ )},
+ {"write a binary to nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, [["hallo", " "], <<"world">>]}, ok},
+ write({t_membuffer, ["hallo", " "]}, <<"world">>)
+ )}
+ ].
flush(Transport) -> thrift_membuffer_transport:flush(Transport).
flush_test_() ->
- [
- {"flush empty membuffer", ?_assertMatch(
- {{t_membuffer, []}, ok},
- flush({t_membuffer, []})
- )},
- {"flush nonempty membuffer", ?_assertMatch(
- {{t_membuffer, [<<"hallo world">>]}, ok},
- flush({t_membuffer, [<<"hallo world">>]})
- )}
- ].
-
+ [
+ {"flush empty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, []}, ok},
+ flush({t_membuffer, []})
+ )},
+ {"flush nonempty membuffer",
+ ?_assertMatch(
+ {{t_membuffer, [<<"hallo world">>]}, ok},
+ flush({t_membuffer, [<<"hallo world">>]})
+ )}
+ ].
close(Transport) -> thrift_membuffer_transport:close(Transport).
close_test_() ->
- {"close membuffer", ?_assertMatch(
- {{t_membuffer, _}, ok},
- close({t_membuffer, []})
- )}.
\ No newline at end of file
+ {"close membuffer",
+ ?_assertMatch(
+ {{t_membuffer, _}, ok},
+ close({t_membuffer, []})
+ )}.
diff --git a/lib/erl/test/test_thrift_socket_transport.erl b/lib/erl/test/test_thrift_socket_transport.erl
index 757c6d9..7e47314 100644
--- a/lib/erl/test/test_thrift_socket_transport.erl
+++ b/lib/erl/test/test_thrift_socket_transport.erl
@@ -20,185 +20,197 @@
-module(test_thrift_socket_transport).
-include_lib("eunit/include/eunit.hrl").
-
new(Socket) -> thrift_socket_transport:new(Socket).
new(Socket, Opts) -> thrift_socket_transport:new(Socket, Opts).
new_test_() ->
- [
- {"new socket", ?_assertMatch(
- {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, 60000, []}}},
- new(a_fake_socket)
- )},
- {"new socket with no options", ?_assertMatch(
- {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, 60000, []}}},
- new(a_fake_socket, [])
- )},
- {"new socket with integer timeout", ?_assertMatch(
- {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, 5000, []}}},
- new(a_fake_socket, [{recv_timeout, 5000}])
- )},
- {"new socket with infinity timeout", ?_assertMatch(
- {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, infinity, []}}},
- new(a_fake_socket, [{recv_timeout, infinity}])
- )}
- ].
-
+ [
+ {"new socket",
+ ?_assertMatch(
+ {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, 60000, []}}},
+ new(a_fake_socket)
+ )},
+ {"new socket with no options",
+ ?_assertMatch(
+ {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, 60000, []}}},
+ new(a_fake_socket, [])
+ )},
+ {"new socket with integer timeout",
+ ?_assertMatch(
+ {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, 5000, []}}},
+ new(a_fake_socket, [{recv_timeout, 5000}])
+ )},
+ {"new socket with infinity timeout",
+ ?_assertMatch(
+ {ok, {_, thrift_socket_transport, {t_socket, a_fake_socket, infinity, []}}},
+ new(a_fake_socket, [{recv_timeout, infinity}])
+ )}
+ ].
read(Socket, Bytes) -> thrift_socket_transport:read(Socket, Bytes).
read_test_() ->
- {setup,
- fun() ->
- meck:new(gen_tcp, [unstick, passthrough]),
- meck:expect(gen_tcp, recv, fun(Bin, 0, _) ->
- case Bin of
- <<"empty">> -> {error, timeout};
- _ -> {ok, Bin}
- end end),
- meck:expect(gen_tcp, close, fun(_) -> ok end)
- end,
- fun(_) -> meck:unload(gen_tcp) end,
- [
- {"read zero bytes from empty socket", ?_assertMatch(
- {_, {ok, <<>>}},
- read({t_socket, <<>>, 60000, []}, 0)
- )},
- {"read 1 byte from empty socket", ?_assertMatch(
- {_, {error, timeout}},
- read({t_socket, <<"empty">>, 60000, []}, 1)
- )},
- {"read zero bytes from nonempty socket", ?_assertMatch(
- {{t_socket, _, _, _}, {ok, <<>>}},
- read({t_socket, <<"hallo world">>, 60000, []}, 0)
- )},
- {"read 1 byte from nonempty socket", ?_assertMatch(
- {{t_socket, _, _, <<"allo world">>}, {ok, <<"h">>}},
- read({t_socket, <<"hallo world">>, 60000, []}, 1)
- )},
- {"read a zillion bytes from nonempty socket", ?_assertMatch(
- {{t_socket, _, _, <<"ld">>}, {ok, <<"hallo world world world world wor">>}},
- read({t_socket, <<"hallo world world world world world">>, 60000, []}, 33)
- )},
- {"read 1 byte from previously buffered socket", ?_assertMatch(
- {{t_socket, _, _, <<"allo">>}, {ok, <<"h">>}},
- read({t_socket, <<" world">>, 60000, <<"hallo">>}, 1)
- )},
- {"read 6 byte from previously buffered socket", ?_assertMatch(
- {{t_socket, _, _, <<"world">>}, {ok, <<"hallo ">>}},
- read({t_socket, <<" world">>, 60000, <<"hallo">>}, 6)
- )},
- {"read a zillion bytes from previously buffered socket", ?_assertMatch(
- {{t_socket, _, _, <<"ld">>}, {ok, <<"hallo world world world world wor">>}},
- read({t_socket, <<" world">>, 60000, <<"hallo">>}, 33)
- )}
- ]
- }.
-
+ {setup,
+ fun() ->
+ meck:new(gen_tcp, [unstick, passthrough]),
+ meck:expect(gen_tcp, recv, fun(Bin, 0, _) ->
+ case Bin of
+ <<"empty">> -> {error, timeout};
+ _ -> {ok, Bin}
+ end
+ end),
+ meck:expect(gen_tcp, close, fun(_) -> ok end)
+ end,
+ fun(_) -> meck:unload(gen_tcp) end, [
+ {"read zero bytes from empty socket",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read({t_socket, <<>>, 60000, []}, 0)
+ )},
+ {"read 1 byte from empty socket",
+ ?_assertMatch(
+ {_, {error, timeout}},
+ read({t_socket, <<"empty">>, 60000, []}, 1)
+ )},
+ {"read zero bytes from nonempty socket",
+ ?_assertMatch(
+ {{t_socket, _, _, _}, {ok, <<>>}},
+ read({t_socket, <<"hallo world">>, 60000, []}, 0)
+ )},
+ {"read 1 byte from nonempty socket",
+ ?_assertMatch(
+ {{t_socket, _, _, <<"allo world">>}, {ok, <<"h">>}},
+ read({t_socket, <<"hallo world">>, 60000, []}, 1)
+ )},
+ {"read a zillion bytes from nonempty socket",
+ ?_assertMatch(
+ {{t_socket, _, _, <<"ld">>}, {ok, <<"hallo world world world world wor">>}},
+ read({t_socket, <<"hallo world world world world world">>, 60000, []}, 33)
+ )},
+ {"read 1 byte from previously buffered socket",
+ ?_assertMatch(
+ {{t_socket, _, _, <<"allo">>}, {ok, <<"h">>}},
+ read({t_socket, <<" world">>, 60000, <<"hallo">>}, 1)
+ )},
+ {"read 6 byte from previously buffered socket",
+ ?_assertMatch(
+ {{t_socket, _, _, <<"world">>}, {ok, <<"hallo ">>}},
+ read({t_socket, <<" world">>, 60000, <<"hallo">>}, 6)
+ )},
+ {"read a zillion bytes from previously buffered socket",
+ ?_assertMatch(
+ {{t_socket, _, _, <<"ld">>}, {ok, <<"hallo world world world world wor">>}},
+ read({t_socket, <<" world">>, 60000, <<"hallo">>}, 33)
+ )}
+ ]}.
read_exact(Socket, Bytes) -> thrift_socket_transport:read_exact(Socket, Bytes).
read_exact_test_() ->
- {setup,
- fun() ->
- meck:new(gen_tcp, [unstick, passthrough]),
- meck:expect(gen_tcp, recv, fun(Bin, N, _) ->
- case N of
- 0 -> {ok, Bin};
- 1 -> {ok, <<"h">>};
- N when N > 2 -> {error, timeout}
- end
- end),
- meck:expect(gen_tcp, close, fun(_) -> ok end)
- end,
- fun(_) -> meck:unload(gen_tcp) end,
- [
- {"read_exact zero bytes from empty socket", ?_assertMatch(
- {_, {ok, <<>>}},
- read_exact({t_socket, <<>>, 60000, []}, 0)
- )},
- {"read_exact zero bytes from nonempty socket", ?_assertMatch(
- {{t_socket, _, _, _}, {ok, <<>>}},
- read_exact({t_socket, <<"hallo world">>, 60000, []}, 0)
- )},
- {"read_exact 1 byte from nonempty socket", ?_assertMatch(
- {{t_socket, _, _, []}, {ok, <<"h">>}},
- read_exact({t_socket, <<"hallo world">>, 60000, []}, 1)
- )},
- {"read_exact a zillion bytes from nonempty socket", ?_assertMatch(
- {{t_socket, _, _, []}, {error, timeout}},
- read_exact({t_socket, <<"hallo world">>, 60000, []}, 65536)
- )},
- {"read_exact 1 byte from previously buffered socket", ?_assertMatch(
- {{t_socket, _, _, <<"allo">>}, {ok, <<"h">>}},
- read_exact({t_socket, <<" world">>, 60000, <<"hallo">>}, 1)
- )},
- {"read_exact 6 byte from previously buffered socket", ?_assertMatch(
- {{t_socket, _, _, []}, {ok, <<"more h">>}},
- read_exact({t_socket, <<"hallo">>, 60000, <<"more ">>}, 6)
- )},
- {"read_exact a zillion bytes from previously buffered socket", ?_assertMatch(
- {{t_socket, _, _, <<"hallo">>}, {error, timeout}},
- read_exact({t_socket, <<" world">>, 60000, <<"hallo">>}, 65536)
- )}
- ]
- }.
-
+ {setup,
+ fun() ->
+ meck:new(gen_tcp, [unstick, passthrough]),
+ meck:expect(gen_tcp, recv, fun(Bin, N, _) ->
+ case N of
+ 0 -> {ok, Bin};
+ 1 -> {ok, <<"h">>};
+ N when N > 2 -> {error, timeout}
+ end
+ end),
+ meck:expect(gen_tcp, close, fun(_) -> ok end)
+ end,
+ fun(_) -> meck:unload(gen_tcp) end, [
+ {"read_exact zero bytes from empty socket",
+ ?_assertMatch(
+ {_, {ok, <<>>}},
+ read_exact({t_socket, <<>>, 60000, []}, 0)
+ )},
+ {"read_exact zero bytes from nonempty socket",
+ ?_assertMatch(
+ {{t_socket, _, _, _}, {ok, <<>>}},
+ read_exact({t_socket, <<"hallo world">>, 60000, []}, 0)
+ )},
+ {"read_exact 1 byte from nonempty socket",
+ ?_assertMatch(
+ {{t_socket, _, _, []}, {ok, <<"h">>}},
+ read_exact({t_socket, <<"hallo world">>, 60000, []}, 1)
+ )},
+ {"read_exact a zillion bytes from nonempty socket",
+ ?_assertMatch(
+ {{t_socket, _, _, []}, {error, timeout}},
+ read_exact({t_socket, <<"hallo world">>, 60000, []}, 65536)
+ )},
+ {"read_exact 1 byte from previously buffered socket",
+ ?_assertMatch(
+ {{t_socket, _, _, <<"allo">>}, {ok, <<"h">>}},
+ read_exact({t_socket, <<" world">>, 60000, <<"hallo">>}, 1)
+ )},
+ {"read_exact 6 byte from previously buffered socket",
+ ?_assertMatch(
+ {{t_socket, _, _, []}, {ok, <<"more h">>}},
+ read_exact({t_socket, <<"hallo">>, 60000, <<"more ">>}, 6)
+ )},
+ {"read_exact a zillion bytes from previously buffered socket",
+ ?_assertMatch(
+ {{t_socket, _, _, <<"hallo">>}, {error, timeout}},
+ read_exact({t_socket, <<" world">>, 60000, <<"hallo">>}, 65536)
+ )}
+ ]}.
write(Socket, Data) -> thrift_socket_transport:write(Socket, Data).
write_test_() ->
- {setup,
- fun() ->
- meck:new(gen_tcp, [unstick, passthrough]),
- meck:expect(gen_tcp, send, fun(_, _) -> ok end)
- end,
- fun(_) -> meck:unload(gen_tcp) end,
- [
- {"write empty list to socket", ?_assertMatch(
- {{t_socket, a_fake_socket, 60000, []}, ok},
- write({t_socket, a_fake_socket, 60000, []}, [])
- )},
- {"write empty binary to socket", ?_assertMatch(
- {{t_socket, a_fake_socket, 60000, []}, ok},
- write({t_socket, a_fake_socket, 60000, []}, <<>>)
- )},
- {"write a list to socket", ?_assertMatch(
- {{t_socket, a_fake_socket, 60000, []}, ok},
- write({t_socket, a_fake_socket, 60000, []}, "hallo world")
- )},
- {"write a binary to socket", ?_assertMatch(
- {{t_socket, a_fake_socket, 60000, []}, ok},
- write({t_socket, a_fake_socket, 60000, []}, <<"hallo world">>)
- )}
- ]
- }.
-
+ {setup,
+ fun() ->
+ meck:new(gen_tcp, [unstick, passthrough]),
+ meck:expect(gen_tcp, send, fun(_, _) -> ok end)
+ end,
+ fun(_) -> meck:unload(gen_tcp) end, [
+ {"write empty list to socket",
+ ?_assertMatch(
+ {{t_socket, a_fake_socket, 60000, []}, ok},
+ write({t_socket, a_fake_socket, 60000, []}, [])
+ )},
+ {"write empty binary to socket",
+ ?_assertMatch(
+ {{t_socket, a_fake_socket, 60000, []}, ok},
+ write({t_socket, a_fake_socket, 60000, []}, <<>>)
+ )},
+ {"write a list to socket",
+ ?_assertMatch(
+ {{t_socket, a_fake_socket, 60000, []}, ok},
+ write({t_socket, a_fake_socket, 60000, []}, "hallo world")
+ )},
+ {"write a binary to socket",
+ ?_assertMatch(
+ {{t_socket, a_fake_socket, 60000, []}, ok},
+ write({t_socket, a_fake_socket, 60000, []}, <<"hallo world">>)
+ )}
+ ]}.
flush(Transport) -> thrift_socket_transport:flush(Transport).
flush_test_() ->
- [
- {"flush socket", ?_assertMatch(
- {{t_socket, a_fake_socket, 60000, []}, ok},
- flush({t_socket, a_fake_socket, 60000, []})
- )}
- ].
-
+ [
+ {"flush socket",
+ ?_assertMatch(
+ {{t_socket, a_fake_socket, 60000, []}, ok},
+ flush({t_socket, a_fake_socket, 60000, []})
+ )}
+ ].
close(Transport) -> thrift_socket_transport:close(Transport).
close_test_() ->
- {setup,
- fun() ->
- meck:new(gen_tcp, [unstick, passthrough]),
- meck:expect(gen_tcp, close, fun(_) -> ok end)
- end,
- fun(_) -> meck:unload(gen_tcp) end,
- [
- {"close membuffer", ?_assertMatch(
- {{t_socket, a_fake_socket, 60000, []}, ok},
- close({t_socket, a_fake_socket, 60000, []})
- )}
- ]
- }.
+ {setup,
+ fun() ->
+ meck:new(gen_tcp, [unstick, passthrough]),
+ meck:expect(gen_tcp, close, fun(_) -> ok end)
+ end,
+ fun(_) -> meck:unload(gen_tcp) end, [
+ {"close membuffer",
+ ?_assertMatch(
+ {{t_socket, a_fake_socket, 60000, []}, ok},
+ close({t_socket, a_fake_socket, 60000, []})
+ )}
+ ]}.
diff --git a/lib/erl/test/thrift_socket_server_test.erl b/lib/erl/test/thrift_socket_server_test.erl
index 0818b84..0330198 100644
--- a/lib/erl/test/thrift_socket_server_test.erl
+++ b/lib/erl/test/thrift_socket_server_test.erl
@@ -1,49 +1,133 @@
--module (thrift_socket_server_test).
+%%
+%% Licensed to the Apache Software Foundation (ASF) under one
+%% or more contributor license agreements. See the NOTICE file
+%% distributed with this work for additional information
+%% regarding copyright ownership. The ASF licenses this file
+%% to you 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(thrift_socket_server_test).
-include_lib("eunit/include/eunit.hrl").
--include ("thrift_constants.hrl").
+-include("thrift_constants.hrl").
parse_handler_options_test_() ->
- CorrectServiceHandlerOptionList = [{?MULTIPLEXED_ERROR_HANDLER_KEY, ?MODULE}, {"Service1", ?MODULE}, {"Service2", ?MODULE}],
- MissingErrorHandlerOptionList = [{"Service1", ?MODULE}, {"Service2", ?MODULE}],
- WrongService2HandlerOptionList = [{?MULTIPLEXED_ERROR_HANDLER_KEY, ?MODULE}, {"Service1", ?MODULE}, {"Service2", "Module"}],
- WrongServiceKeyOptionList = [{?MULTIPLEXED_ERROR_HANDLER_KEY, ?MODULE}, {'service1', ?MODULE}, {"Service2", ?MODULE}],
+ CorrectServiceHandlerOptionList = [
+ {?MULTIPLEXED_ERROR_HANDLER_KEY, ?MODULE}, {"Service1", ?MODULE}, {"Service2", ?MODULE}
+ ],
+ MissingErrorHandlerOptionList = [{"Service1", ?MODULE}, {"Service2", ?MODULE}],
+ WrongService2HandlerOptionList = [
+ {?MULTIPLEXED_ERROR_HANDLER_KEY, ?MODULE}, {"Service1", ?MODULE}, {"Service2", "Module"}
+ ],
+ WrongServiceKeyOptionList = [
+ {?MULTIPLEXED_ERROR_HANDLER_KEY, ?MODULE}, {'service1', ?MODULE}, {"Service2", ?MODULE}
+ ],
CorrectHandlerTestFunction = fun() ->
- ?assertMatch({thrift_socket_server,_,_,_,_,_,_,_,_,_,_,_,_,_}, thrift_socket_server:parse_options([{handler, CorrectServiceHandlerOptionList}])),
- {thrift_socket_server,_,_, HandlerList,_,_,_,_,_,_,_,_,_,_} = thrift_socket_server:parse_options([{handler, CorrectServiceHandlerOptionList}]),
- lists:foreach(fun
- ({ServiceName, HandlerModule}) ->
- ?assertMatch({ok, HandlerModule} when is_atom(HandlerModule), thrift_multiplexed_map_wrapper:find(ServiceName, HandlerList))
- end, CorrectServiceHandlerOptionList)
+ ?assertMatch(
+ #{},
+ thrift_socket_server:parse_options([{handler, CorrectServiceHandlerOptionList}])
+ ),
+ #{handler := HandlerList} = thrift_socket_server:parse_options(
+ [
+ {handler, CorrectServiceHandlerOptionList}
+ ]
+ ),
+ lists:foreach(
+ fun({ServiceName, HandlerModule}) ->
+ ?assertMatch(
+ {ok, HandlerModule} when is_atom(HandlerModule),
+ thrift_multiplexed_map_wrapper:find(ServiceName, HandlerList)
+ )
+ end,
+ CorrectServiceHandlerOptionList
+ )
end,
[
- {"Bad argument for the handler option", ?_assertThrow(_, thrift_socket_server:parse_options([{handler, []}]))},
- {"Try to parse the handler option twice", ?_assertThrow(_, thrift_socket_server:parse_options([{handler, ?MODULE}, {handler, CorrectServiceHandlerOptionList}]))},
- {"Parse the handler option as a non multiplexed service handler", ?_assertMatch({thrift_socket_server,_,_,?MODULE,_,_,_,_,_,_,_,_,_,_}, thrift_socket_server:parse_options([{handler, ?MODULE}]))},
- {"No error handler was defined", ?_assertThrow(_, thrift_socket_server:parse_options([{handler, MissingErrorHandlerOptionList}]))},
- {"Bad handler module for Service2", ?_assertThrow(_, thrift_socket_server:parse_options([{handler, WrongService2HandlerOptionList}]))},
- {"Bad service key for Service1", ?_assertThrow(_, thrift_socket_server:parse_options([{handler, WrongServiceKeyOptionList}]))},
- {"Try to parse a correct handler option list", CorrectHandlerTestFunction}
+ {"Bad argument for the handler option",
+ ?_assertThrow(_, thrift_socket_server:parse_options([{handler, []}]))},
+ {"Try to parse the handler option twice",
+ ?_assertThrow(
+ _,
+ thrift_socket_server:parse_options([
+ {handler, ?MODULE}, {handler, CorrectServiceHandlerOptionList}
+ ])
+ )},
+ {"Parse the handler option as a non multiplexed service handler",
+ ?_assertMatch(
+ #{handler := ?MODULE},
+ thrift_socket_server:parse_options([{handler, ?MODULE}])
+ )},
+ {"No error handler was defined",
+ ?_assertThrow(
+ _, thrift_socket_server:parse_options([{handler, MissingErrorHandlerOptionList}])
+ )},
+ {"Bad handler module for Service2",
+ ?_assertThrow(
+ _, thrift_socket_server:parse_options([{handler, WrongService2HandlerOptionList}])
+ )},
+ {"Bad service key for Service1",
+ ?_assertThrow(
+ _, thrift_socket_server:parse_options([{handler, WrongServiceKeyOptionList}])
+ )},
+ {"Try to parse a correct handler option list", CorrectHandlerTestFunction}
].
parse_service_options_test_() ->
CorrectServiceModuleOptionList = [{"Service1", ?MODULE}, {"Service2", ?MODULE}],
- WrongService2ModuleOptionList = [{"Service1", ?MODULE}, {"Service2", "thrift_service_module"}],
- WrongServiceKeyOptionList = [{'service1', ?MODULE}, {"Service2", ?MODULE}],
+ WrongService2ModuleOptionList = [{"Service1", ?MODULE}, {"Service2", "thrift_service_module"}],
+ WrongServiceKeyOptionList = [{'service1', ?MODULE}, {"Service2", ?MODULE}],
CorrectServiceModuleTestFunction = fun() ->
- ?assertMatch({thrift_socket_server,_,_,_,_,_,_,_,_,_,_,_,_,_}, thrift_socket_server:parse_options([{service, CorrectServiceModuleOptionList}])),
- {thrift_socket_server,_, ServiceModuleList,_,_,_,_,_,_,_,_,_,_,_} = thrift_socket_server:parse_options([{service, CorrectServiceModuleOptionList}]),
- lists:foreach(fun
- ({ServiceName, ServiceModule}) ->
- ?assertMatch({ok, ServiceModule} when is_atom(ServiceModule), thrift_multiplexed_map_wrapper:find(ServiceName, ServiceModuleList))
- end, CorrectServiceModuleOptionList)
+ ?assertMatch(
+ #{},
+ thrift_socket_server:parse_options([{service, CorrectServiceModuleOptionList}])
+ ),
+ #{service := ServiceModuleList} = thrift_socket_server:parse_options(
+ [{service, CorrectServiceModuleOptionList}]
+ ),
+ lists:foreach(
+ fun({ServiceName, ServiceModule}) ->
+ ?assertMatch(
+ {ok, ServiceModule} when is_atom(ServiceModule),
+ thrift_multiplexed_map_wrapper:find(ServiceName, ServiceModuleList)
+ )
+ end,
+ CorrectServiceModuleOptionList
+ )
end,
[
- {"Bad argument for the service option", ?_assertThrow(_, thrift_socket_server:parse_options([{service, []}]))},
- {"Try to parse the service option twice", ?_assertThrow(_, thrift_socket_server:parse_options([{service, ?MODULE}, {service, CorrectServiceModuleOptionList}]))},
- {"Parse a service module for a non multiplexed service", ?_assertMatch({thrift_socket_server,_,?MODULE,_,_,_,_,_,_,_,_,_,_,_}, thrift_socket_server:parse_options([{service, ?MODULE}]))},
- {"Bad service module for Service2", ?_assertThrow(_, thrift_socket_server:parse_options([{service, WrongService2ModuleOptionList}]))},
- {"Bad service key for Service1", ?_assertThrow(_, thrift_socket_server:parse_options([{service, WrongServiceKeyOptionList}]))},
- {"Try to parse a correct service option list", CorrectServiceModuleTestFunction}
+ {"Bad argument for the service option",
+ ?_assertThrow(_, thrift_socket_server:parse_options([{service, []}]))},
+ {"Try to parse the service option twice",
+ ?_assertThrow(
+ _,
+ thrift_socket_server:parse_options([
+ {service, ?MODULE}, {service, CorrectServiceModuleOptionList}
+ ])
+ )},
+ {"Parse a service module for a non multiplexed service",
+ ?_assertMatch(
+ #{service := ?MODULE},
+ thrift_socket_server:parse_options([{service, ?MODULE}])
+ )},
+ {"Bad service module for Service2",
+ ?_assertThrow(
+ _, thrift_socket_server:parse_options([{service, WrongService2ModuleOptionList}])
+ )},
+ {"Bad service key for Service1",
+ ?_assertThrow(
+ _, thrift_socket_server:parse_options([{service, WrongServiceKeyOptionList}])
+ )},
+ {"Try to parse a correct service option list", CorrectServiceModuleTestFunction}
].
diff --git a/lib/erl/test/thrift_test_test.erl b/lib/erl/test/thrift_test_test.erl
index 77df61d..f86627b 100644
--- a/lib/erl/test/thrift_test_test.erl
+++ b/lib/erl/test/thrift_test_test.erl
@@ -19,625 +19,768 @@
% don't rename this thrift_test, it clobbers generated files
-module(thrift_test_test).
--compile(export_all).
-include_lib("eunit/include/eunit.hrl").
-include("gen-erl/thrift_test_constants.hrl").
constant_test_() ->
- [
- {"myNumberz equals 1", ?_assertEqual(1, ?THRIFT_TEST_MYNUMBERZ)}
- ].
+ [
+ {"myNumberz equals 1", ?_assertEqual(1, ?THRIFT_TEST_MYNUMBERZ)}
+ ].
record_generation_test_() ->
- [
- {"Bonk record", ?_assertMatch(
- {'thrift.test.Bonk', _, _},
- #'thrift.test.Bonk'{message=null,type=null}
- )},
- {"Bools record", ?_assertMatch(
- {'thrift.test.Bools', _, _},
- #'thrift.test.Bools'{im_true=null,im_false=null}
- )},
- {"Xtruct record", ?_assertMatch(
- {'thrift.test.Xtruct', _, _, _, _},
- #'thrift.test.Xtruct'{string_thing=null,byte_thing=null,i32_thing=null,i64_thing=null}
- )},
- {"Xtruct2 record", ?_assertMatch(
- {'thrift.test.Xtruct2', _, _, _},
- #'thrift.test.Xtruct2'{byte_thing=null,struct_thing=null,i32_thing=null}
- )},
- {"Xtruct3 record", ?_assertMatch(
- {'thrift.test.Xtruct3', _, _, _, _},
- #'thrift.test.Xtruct3'{string_thing=null,changed=null,i32_thing=null,i64_thing=null}
- )},
- {"Insanity record", ?_assertMatch(
- {'thrift.test.Insanity', _, _},
- #'thrift.test.Insanity'{userMap=null,xtructs=null}
- )},
- {"CrazyNesting record", ?_assertMatch(
- {'thrift.test.CrazyNesting', _, _, _, _},
- #'thrift.test.CrazyNesting'{
- string_field=null,
- set_field=null,
- list_field=null,
- binary_field=null
- }
- )},
- {"Xception record", ?_assertMatch(
- {'thrift.test.Xception', _, _},
- #'thrift.test.Xception'{errorCode=null,message=null}
- )},
- {"Xception2 record", ?_assertMatch(
- {'thrift.test.Xception2', _, _},
- #'thrift.test.Xception2'{errorCode=null,struct_thing=null}
- )},
- {"EmptyStruct record", ?_assertMatch({'thrift.test.EmptyStruct'}, #'thrift.test.EmptyStruct'{})},
- {"OneField record", ?_assertMatch({'thrift.test.OneField', _}, #'thrift.test.OneField'{field=null})},
- {"VersioningTestV1 record", ?_assertMatch(
- {'thrift.test.VersioningTestV1', _, _, _},
- #'thrift.test.VersioningTestV1'{begin_in_both=null,old_string=null,end_in_both=null}
- )},
- {"VersioningTestV2 record", ?_assertMatch(
- {'thrift.test.VersioningTestV2', _, _, _, _, _, _, _, _, _, _, _, _},
- #'thrift.test.VersioningTestV2'{
- begin_in_both=null,
- newint=null,
- newbyte=null,
- newshort=null,
- newlong=null,
- newdouble=null,
- newstruct=null,
- newlist=null,
- newset=null,
- newmap=null,
- newstring=null,
- end_in_both=null
- }
- )},
- {"ListTypeVersioningV1 record", ?_assertMatch(
- {'thrift.test.ListTypeVersioningV1', _, _},
- #'thrift.test.ListTypeVersioningV1'{myints=null,hello=null}
- )},
- {"ListTypeVersioningV2 record", ?_assertMatch(
- {'thrift.test.ListTypeVersioningV2', _, _},
- #'thrift.test.ListTypeVersioningV2'{strings=null,hello=null}
- )},
- {"GuessProtocolStruct record", ?_assertMatch(
- {'thrift.test.GuessProtocolStruct', _},
- #'thrift.test.GuessProtocolStruct'{map_field=null}
- )},
- {"LargeDeltas record", ?_assertMatch(
- {'thrift.test.LargeDeltas', _, _, _, _, _, _, _, _, _, _},
- #'thrift.test.LargeDeltas'{
- b1=null,
- b10=null,
- b100=null,
- check_true=null,
- b1000=null,
- check_false=null,
- vertwo2000=null,
- a_set2500=null,
- vertwo3000=null,
- big_numbers=null
- }
- )},
- {"NestedListsI32x2 record", ?_assertMatch(
- {'thrift.test.NestedListsI32x2', _},
- #'thrift.test.NestedListsI32x2'{integerlist=null}
- )},
- {"NestedListsI32x3 record", ?_assertMatch(
- {'thrift.test.NestedListsI32x3', _},
- #'thrift.test.NestedListsI32x3'{integerlist=null}
- )},
- {"NestedMixedx2 record", ?_assertMatch(
- {'thrift.test.NestedMixedx2', _, _, _},
- #'thrift.test.NestedMixedx2'{
- int_set_list=null,
- map_int_strset=null,
- map_int_strset_list=null
- }
- )},
- {"ListBonks record", ?_assertMatch({'thrift.test.ListBonks', _}, #'thrift.test.ListBonks'{bonk=null})},
- {"NestedListsBonk record", ?_assertMatch(
- {'thrift.test.NestedListsBonk', _},
- #'thrift.test.NestedListsBonk'{bonk=null}
- )},
- {"BoolTest record", ?_assertMatch(
- {'thrift.test.BoolTest', _, _},
- #'thrift.test.BoolTest'{b=null,s=null}
- )},
- {"StructA record", ?_assertMatch({'thrift.test.StructA', _}, #'thrift.test.StructA'{s=null})},
- {"StructB record", ?_assertMatch(
- {'thrift.test.StructB', _, _},
- #'thrift.test.StructB'{aa=null,ab=null}
- )}
- ].
+ [
+ {"Bonk record",
+ ?_assertMatch(
+ {'thrift.test.Bonk', _, _},
+ #'thrift.test.Bonk'{message = null, type = null}
+ )},
+ {"Bools record",
+ ?_assertMatch(
+ {'thrift.test.Bools', _, _},
+ #'thrift.test.Bools'{im_true = null, im_false = null}
+ )},
+ {"Xtruct record",
+ ?_assertMatch(
+ {'thrift.test.Xtruct', _, _, _, _},
+ #'thrift.test.Xtruct'{
+ string_thing = null, byte_thing = null, i32_thing = null, i64_thing = null
+ }
+ )},
+ {"Xtruct2 record",
+ ?_assertMatch(
+ {'thrift.test.Xtruct2', _, _, _},
+ #'thrift.test.Xtruct2'{byte_thing = null, struct_thing = null, i32_thing = null}
+ )},
+ {"Xtruct3 record",
+ ?_assertMatch(
+ {'thrift.test.Xtruct3', _, _, _, _},
+ #'thrift.test.Xtruct3'{
+ string_thing = null, changed = null, i32_thing = null, i64_thing = null
+ }
+ )},
+ {"Insanity record",
+ ?_assertMatch(
+ {'thrift.test.Insanity', _, _},
+ #'thrift.test.Insanity'{userMap = null, xtructs = null}
+ )},
+ {"CrazyNesting record",
+ ?_assertMatch(
+ {'thrift.test.CrazyNesting', _, _, _, _},
+ #'thrift.test.CrazyNesting'{
+ string_field = null,
+ set_field = null,
+ list_field = null,
+ binary_field = null
+ }
+ )},
+ {"Xception record",
+ ?_assertMatch(
+ {'thrift.test.Xception', _, _},
+ #'thrift.test.Xception'{errorCode = null, message = null}
+ )},
+ {"Xception2 record",
+ ?_assertMatch(
+ {'thrift.test.Xception2', _, _},
+ #'thrift.test.Xception2'{errorCode = null, struct_thing = null}
+ )},
+ {"EmptyStruct record",
+ ?_assertMatch({'thrift.test.EmptyStruct'}, #'thrift.test.EmptyStruct'{})},
+ {"OneField record",
+ ?_assertMatch({'thrift.test.OneField', _}, #'thrift.test.OneField'{field = null})},
+ {"VersioningTestV1 record",
+ ?_assertMatch(
+ {'thrift.test.VersioningTestV1', _, _, _},
+ #'thrift.test.VersioningTestV1'{
+ begin_in_both = null, old_string = null, end_in_both = null
+ }
+ )},
+ {"VersioningTestV2 record",
+ ?_assertMatch(
+ {'thrift.test.VersioningTestV2', _, _, _, _, _, _, _, _, _, _, _, _},
+ #'thrift.test.VersioningTestV2'{
+ begin_in_both = null,
+ newint = null,
+ newbyte = null,
+ newshort = null,
+ newlong = null,
+ newdouble = null,
+ newstruct = null,
+ newlist = null,
+ newset = null,
+ newmap = null,
+ newstring = null,
+ end_in_both = null
+ }
+ )},
+ {"ListTypeVersioningV1 record",
+ ?_assertMatch(
+ {'thrift.test.ListTypeVersioningV1', _, _},
+ #'thrift.test.ListTypeVersioningV1'{myints = null, hello = null}
+ )},
+ {"ListTypeVersioningV2 record",
+ ?_assertMatch(
+ {'thrift.test.ListTypeVersioningV2', _, _},
+ #'thrift.test.ListTypeVersioningV2'{strings = null, hello = null}
+ )},
+ {"GuessProtocolStruct record",
+ ?_assertMatch(
+ {'thrift.test.GuessProtocolStruct', _},
+ #'thrift.test.GuessProtocolStruct'{map_field = null}
+ )},
+ {"LargeDeltas record",
+ ?_assertMatch(
+ {'thrift.test.LargeDeltas', _, _, _, _, _, _, _, _, _, _},
+ #'thrift.test.LargeDeltas'{
+ b1 = null,
+ b10 = null,
+ b100 = null,
+ check_true = null,
+ b1000 = null,
+ check_false = null,
+ vertwo2000 = null,
+ a_set2500 = null,
+ vertwo3000 = null,
+ big_numbers = null
+ }
+ )},
+ {"NestedListsI32x2 record",
+ ?_assertMatch(
+ {'thrift.test.NestedListsI32x2', _},
+ #'thrift.test.NestedListsI32x2'{integerlist = null}
+ )},
+ {"NestedListsI32x3 record",
+ ?_assertMatch(
+ {'thrift.test.NestedListsI32x3', _},
+ #'thrift.test.NestedListsI32x3'{integerlist = null}
+ )},
+ {"NestedMixedx2 record",
+ ?_assertMatch(
+ {'thrift.test.NestedMixedx2', _, _, _},
+ #'thrift.test.NestedMixedx2'{
+ int_set_list = null,
+ map_int_strset = null,
+ map_int_strset_list = null
+ }
+ )},
+ {"ListBonks record",
+ ?_assertMatch({'thrift.test.ListBonks', _}, #'thrift.test.ListBonks'{bonk = null})},
+ {"NestedListsBonk record",
+ ?_assertMatch(
+ {'thrift.test.NestedListsBonk', _},
+ #'thrift.test.NestedListsBonk'{bonk = null}
+ )},
+ {"BoolTest record",
+ ?_assertMatch(
+ {'thrift.test.BoolTest', _, _},
+ #'thrift.test.BoolTest'{b = null, s = null}
+ )},
+ {"StructA record",
+ ?_assertMatch({'thrift.test.StructA', _}, #'thrift.test.StructA'{s = null})},
+ {"StructB record",
+ ?_assertMatch(
+ {'thrift.test.StructB', _, _},
+ #'thrift.test.StructB'{aa = null, ab = null}
+ )}
+ ].
struct_info_test_() ->
- [
- {"Bonk definition (short version)", ?_assertEqual(
- {struct, [{1, string}, {2, i32}]},
- thrift_test_types:struct_info('thrift.test.Bonk')
- )},
- {"Bonk definition", ?_assertEqual(
- {struct, [
- {1, undefined, string, message, undefined},
- {2, undefined, i32, type, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Bonk')
- )},
- {"Bools definition", ?_assertEqual(
- {struct, [
- {1, undefined, bool, im_true, undefined},
- {2, undefined, bool, im_false, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Bools')
- )},
- {"Xtruct definition", ?_assertEqual(
- {struct, [
- {1, undefined, string, string_thing, undefined},
- {4, undefined, byte, byte_thing, undefined},
- {9, undefined, i32, i32_thing, undefined},
- {11, undefined, i64, i64_thing, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Xtruct')
- )},
- {"Xtruct2 definition", ?_assertEqual(
- {struct, [
- {1, undefined, byte, byte_thing, undefined},
- {2, undefined, {struct, {'thrift_test_types', 'thrift.test.Xtruct'}}, struct_thing, #'thrift.test.Xtruct'{}},
- {3, undefined, i32, i32_thing, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Xtruct2')
- )},
- {"Xtruct3 definition", ?_assertEqual(
- {struct, [
- {1, undefined, string, string_thing, undefined},
- {4, undefined, i32, changed, undefined},
- {9, undefined, i32, i32_thing, undefined},
- {11, undefined, i64, i64_thing, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Xtruct3')
- )},
- {"Insanity definition", ?_assertEqual(
- {struct, [
- {1, undefined, {map, i32, i64}, userMap, dict:new()},
- {2, undefined, {list, {struct, {'thrift_test_types', 'thrift.test.Xtruct'}}}, xtructs, []}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Insanity')
- )},
- {"CrazyNesting definition", ?_assertEqual(
- {struct, [
- {1, undefined, string, string_field, undefined},
- {2, optional, {set, {struct, {'thrift_test_types', 'thrift.test.Insanity'}}}, set_field, sets:new()},
- {3, required, {list, {map,
- {set, i32},
- {map, i32, {set, {list, {map, {struct, {'thrift_test_types', 'thrift.test.Insanity'}}, string}}}}
- }}, list_field, []},
- {4, undefined, string, binary_field, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.CrazyNesting')
- )},
- {"Xception definition", ?_assertEqual(
- {struct, [
- {1, undefined, i32, errorCode, undefined},
- {2, undefined, string, message, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Xception')
- )},
- {"Xception2 definition", ?_assertEqual(
- {struct, [
- {1, undefined, i32, errorCode, undefined},
- {2, undefined, {struct, {'thrift_test_types', 'thrift.test.Xtruct'}}, struct_thing, #'thrift.test.Xtruct'{}}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.Xception2')
- )},
- {"EmptyStruct definition", ?_assertEqual(
- {struct, []},
- thrift_test_types:struct_info_ext('thrift.test.EmptyStruct')
- )},
- {"OneField definition", ?_assertEqual(
- {struct, [
- {1, undefined, {struct, {'thrift_test_types', 'thrift.test.EmptyStruct'}}, field, #'thrift.test.EmptyStruct'{}}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.OneField')
- )},
- {"VersioningTestV1 definition", ?_assertEqual(
- {struct, [
- {1, undefined, i32, begin_in_both, undefined},
- {3, undefined, string, old_string, undefined},
- {12, undefined, i32, end_in_both, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.VersioningTestV1')
- )},
- {"VersioningTestV2 definition", ?_assertEqual(
- {struct, [
- {1, undefined, i32, begin_in_both, undefined},
- {2, undefined, i32, newint, undefined},
- {3, undefined, byte, newbyte, undefined},
- {4, undefined, i16, newshort, undefined},
- {5, undefined, i64, newlong, undefined},
- {6, undefined, double, newdouble, undefined},
- {7, undefined, {struct, {thrift_test_types, 'thrift.test.Bonk'}}, newstruct, #'thrift.test.Bonk'{}},
- {8, undefined, {list, i32}, newlist, []},
- {9, undefined, {set, i32}, newset, sets:new()},
- {10, undefined, {map, i32, i32}, newmap, dict:new()},
- {11, undefined, string, newstring, undefined},
- {12, undefined, i32, end_in_both, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.VersioningTestV2')
- )},
- {"ListTypeVersioningV1 definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, i32}, myints, []},
- {2, undefined, string, hello, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.ListTypeVersioningV1')
- )},
- {"ListTypeVersioningV2 definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, string}, strings, []},
- {2, undefined, string, hello, undefined}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.ListTypeVersioningV2')
- )},
- {"GuessProtocolStruct definition", ?_assertEqual(
- {struct, [
- {7, undefined, {map, string, string}, map_field, dict:new()}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.GuessProtocolStruct')
- )},
- {"LargeDeltas definition", ?_assertEqual(
- {struct, [
- {1, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b1, #'thrift.test.Bools'{}},
- {10, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b10, #'thrift.test.Bools'{}},
- {100, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b100, #'thrift.test.Bools'{}},
- {500, undefined, bool, check_true, undefined},
- {1000, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b1000, #'thrift.test.Bools'{}},
- {1500, undefined, bool, check_false, undefined},
- {2000, undefined, {struct, {thrift_test_types, 'thrift.test.VersioningTestV2'}}, vertwo2000, #'thrift.test.VersioningTestV2'{}},
- {2500, undefined, {set, string}, a_set2500, sets:new()},
- {3000, undefined, {struct, {thrift_test_types, 'thrift.test.VersioningTestV2'}}, vertwo3000, #'thrift.test.VersioningTestV2'{}},
- {4000, undefined, {list, i32}, big_numbers, []}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.LargeDeltas')
- )},
- {"NestedListsI32x2 definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, {list, i32}}, integerlist, []}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.NestedListsI32x2')
- )},
- {"NestedListsI32x3 definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, {list, {list, i32}}}, integerlist, []}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.NestedListsI32x3')
- )},
- {"NestedMixedx2 definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, {set, i32}}, int_set_list, []},
- {2, undefined, {map, i32, {set, string}}, map_int_strset, dict:new()},
- {3, undefined, {list, {map, i32, {set, string}}}, map_int_strset_list, []}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.NestedMixedx2')
- )},
- {"ListBonks definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, {struct, {thrift_test_types, 'thrift.test.Bonk'}}}, bonk, []}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.ListBonks')
- )},
- {"NestedListsBonk definition", ?_assertEqual(
- {struct, [
- {1, undefined, {list, {list, {list, {struct, {thrift_test_types, 'thrift.test.Bonk'}}}}}, bonk, []}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.NestedListsBonk')
- )},
- {"BoolTest definition", ?_assertEqual(
- {struct, [
- {1, optional, bool, b, true},
- {2, optional, string, s, "true"}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.BoolTest')
- )},
- {"StructA definition", ?_assertEqual(
- {struct, [{1, required, string, s, undefined}]},
- thrift_test_types:struct_info_ext('thrift.test.StructA')
- )},
- {"StructB definition", ?_assertEqual(
- {struct, [
- {1, optional, {struct, {thrift_test_types, 'thrift.test.StructA'}}, aa, #'thrift.test.StructA'{}},
- {2, required, {struct, {thrift_test_types, 'thrift.test.StructA'}}, ab, #'thrift.test.StructA'{}}
- ]},
- thrift_test_types:struct_info_ext('thrift.test.StructB')
- )}
- ].
+ [
+ {"Bonk definition (short version)",
+ ?_assertEqual(
+ {struct, [{1, string}, {2, i32}]},
+ thrift_test_types:struct_info('thrift.test.Bonk')
+ )},
+ {"Bonk definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, string, message, undefined},
+ {2, undefined, i32, type, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Bonk')
+ )},
+ {"Bools definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, bool, im_true, undefined},
+ {2, undefined, bool, im_false, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Bools')
+ )},
+ {"Xtruct definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, string, string_thing, undefined},
+ {4, undefined, byte, byte_thing, undefined},
+ {9, undefined, i32, i32_thing, undefined},
+ {11, undefined, i64, i64_thing, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Xtruct')
+ )},
+ {"Xtruct2 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, byte, byte_thing, undefined},
+ {2, undefined, {struct, {'thrift_test_types', 'thrift.test.Xtruct'}},
+ struct_thing, #'thrift.test.Xtruct'{}},
+ {3, undefined, i32, i32_thing, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Xtruct2')
+ )},
+ {"Xtruct3 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, string, string_thing, undefined},
+ {4, undefined, i32, changed, undefined},
+ {9, undefined, i32, i32_thing, undefined},
+ {11, undefined, i64, i64_thing, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Xtruct3')
+ )},
+ {"Insanity definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {map, i32, i64}, userMap, dict:new()},
+ {2, undefined, {list, {struct, {'thrift_test_types', 'thrift.test.Xtruct'}}},
+ xtructs, []}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Insanity')
+ )},
+ {"CrazyNesting definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, string, string_field, undefined},
+ {2, optional, {set, {struct, {'thrift_test_types', 'thrift.test.Insanity'}}},
+ set_field, sets:new()},
+ {3, required,
+ {list,
+ {map, {set, i32},
+ {map, i32,
+ {set,
+ {list,
+ {map,
+ {struct,
+ {'thrift_test_types', 'thrift.test.Insanity'}},
+ string}}}}}},
+ list_field, []},
+ {4, undefined, string, binary_field, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.CrazyNesting')
+ )},
+ {"Xception definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, i32, errorCode, undefined},
+ {2, undefined, string, message, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Xception')
+ )},
+ {"Xception2 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, i32, errorCode, undefined},
+ {2, undefined, {struct, {'thrift_test_types', 'thrift.test.Xtruct'}},
+ struct_thing, #'thrift.test.Xtruct'{}}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.Xception2')
+ )},
+ {"EmptyStruct definition",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_types:struct_info_ext('thrift.test.EmptyStruct')
+ )},
+ {"OneField definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {struct, {'thrift_test_types', 'thrift.test.EmptyStruct'}},
+ field, #'thrift.test.EmptyStruct'{}}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.OneField')
+ )},
+ {"VersioningTestV1 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, i32, begin_in_both, undefined},
+ {3, undefined, string, old_string, undefined},
+ {12, undefined, i32, end_in_both, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.VersioningTestV1')
+ )},
+ {"VersioningTestV2 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, i32, begin_in_both, undefined},
+ {2, undefined, i32, newint, undefined},
+ {3, undefined, byte, newbyte, undefined},
+ {4, undefined, i16, newshort, undefined},
+ {5, undefined, i64, newlong, undefined},
+ {6, undefined, double, newdouble, undefined},
+ {7, undefined, {struct, {thrift_test_types, 'thrift.test.Bonk'}}, newstruct,
+ #'thrift.test.Bonk'{}},
+ {8, undefined, {list, i32}, newlist, []},
+ {9, undefined, {set, i32}, newset, sets:new()},
+ {10, undefined, {map, i32, i32}, newmap, dict:new()},
+ {11, undefined, string, newstring, undefined},
+ {12, undefined, i32, end_in_both, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.VersioningTestV2')
+ )},
+ {"ListTypeVersioningV1 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {list, i32}, myints, []},
+ {2, undefined, string, hello, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.ListTypeVersioningV1')
+ )},
+ {"ListTypeVersioningV2 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {list, string}, strings, []},
+ {2, undefined, string, hello, undefined}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.ListTypeVersioningV2')
+ )},
+ {"GuessProtocolStruct definition",
+ ?_assertEqual(
+ {struct, [
+ {7, undefined, {map, string, string}, map_field, dict:new()}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.GuessProtocolStruct')
+ )},
+ {"LargeDeltas definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b1,
+ #'thrift.test.Bools'{}},
+ {10, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b10,
+ #'thrift.test.Bools'{}},
+ {100, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b100,
+ #'thrift.test.Bools'{}},
+ {500, undefined, bool, check_true, undefined},
+ {1000, undefined, {struct, {thrift_test_types, 'thrift.test.Bools'}}, b1000,
+ #'thrift.test.Bools'{}},
+ {1500, undefined, bool, check_false, undefined},
+ {2000, undefined, {struct, {thrift_test_types, 'thrift.test.VersioningTestV2'}},
+ vertwo2000, #'thrift.test.VersioningTestV2'{}},
+ {2500, undefined, {set, string}, a_set2500, sets:new()},
+ {3000, undefined, {struct, {thrift_test_types, 'thrift.test.VersioningTestV2'}},
+ vertwo3000, #'thrift.test.VersioningTestV2'{}},
+ {4000, undefined, {list, i32}, big_numbers, []}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.LargeDeltas')
+ )},
+ {"NestedListsI32x2 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {list, {list, i32}}, integerlist, []}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.NestedListsI32x2')
+ )},
+ {"NestedListsI32x3 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {list, {list, {list, i32}}}, integerlist, []}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.NestedListsI32x3')
+ )},
+ {"NestedMixedx2 definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {list, {set, i32}}, int_set_list, []},
+ {2, undefined, {map, i32, {set, string}}, map_int_strset, dict:new()},
+ {3, undefined, {list, {map, i32, {set, string}}}, map_int_strset_list, []}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.NestedMixedx2')
+ )},
+ {"ListBonks definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined, {list, {struct, {thrift_test_types, 'thrift.test.Bonk'}}}, bonk,
+ []}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.ListBonks')
+ )},
+ {"NestedListsBonk definition",
+ ?_assertEqual(
+ {struct, [
+ {1, undefined,
+ {list, {list, {list, {struct, {thrift_test_types, 'thrift.test.Bonk'}}}}},
+ bonk, []}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.NestedListsBonk')
+ )},
+ {"BoolTest definition",
+ ?_assertEqual(
+ {struct, [
+ {1, optional, bool, b, true},
+ {2, optional, string, s, "true"}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.BoolTest')
+ )},
+ {"StructA definition",
+ ?_assertEqual(
+ {struct, [{1, required, string, s, undefined}]},
+ thrift_test_types:struct_info_ext('thrift.test.StructA')
+ )},
+ {"StructB definition",
+ ?_assertEqual(
+ {struct, [
+ {1, optional, {struct, {thrift_test_types, 'thrift.test.StructA'}}, aa,
+ #'thrift.test.StructA'{}},
+ {2, required, {struct, {thrift_test_types, 'thrift.test.StructA'}}, ab,
+ #'thrift.test.StructA'{}}
+ ]},
+ thrift_test_types:struct_info_ext('thrift.test.StructB')
+ )}
+ ].
service_info_test_() ->
- [
- {"testVoid params", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testVoid, params_type)
- )},
- {"testVoid reply", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testVoid, reply_type)
- )},
- {"testVoid exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testVoid, exceptions)
- )},
- {"testString params", ?_assertEqual(
- {struct, [{1, string}]},
- thrift_test_thrift:function_info(testString, params_type)
- )},
- {"testString reply", ?_assertEqual(
- string,
- thrift_test_thrift:function_info(testString, reply_type)
- )},
- {"testString exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testString, exceptions)
- )},
- {"testByte params", ?_assertEqual(
- {struct, [{1, byte}]},
- thrift_test_thrift:function_info(testByte, params_type)
- )},
- {"testByte reply", ?_assertEqual(
- byte,
- thrift_test_thrift:function_info(testByte, reply_type)
- )},
- {"testByte exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testByte, exceptions)
- )},
- {"testI32 params", ?_assertEqual(
- {struct, [{1, i32}]},
- thrift_test_thrift:function_info(testI32, params_type)
- )},
- {"testI32 reply", ?_assertEqual(
- i32,
- thrift_test_thrift:function_info(testI32, reply_type)
- )},
- {"testI32 exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testI32, exceptions)
- )},
- {"testI64 params", ?_assertEqual(
- {struct, [{1, i64}]},
- thrift_test_thrift:function_info(testI64, params_type)
- )},
- {"testI64 reply", ?_assertEqual(
- i64,
- thrift_test_thrift:function_info(testI64, reply_type)
- )},
- {"testI64 exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testI64, exceptions)
- )},
- {"testDouble params", ?_assertEqual(
- {struct, [{1, double}]},
- thrift_test_thrift:function_info(testDouble, params_type)
- )},
- {"testDouble reply", ?_assertEqual(
- double,
- thrift_test_thrift:function_info(testDouble, reply_type)
- )},
- {"testDouble exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testDouble, exceptions)
- )},
- {"testStruct params", ?_assertEqual(
- {struct, [
- {1, {struct, {thrift_test_types, 'thrift.test.Xtruct'}}}
- ]},
- thrift_test_thrift:function_info(testStruct, params_type)
- )},
- {"testStruct reply", ?_assertEqual(
- {struct, {thrift_test_types, 'thrift.test.Xtruct'}},
- thrift_test_thrift:function_info(testStruct, reply_type)
- )},
- {"testStruct exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testStruct, exceptions)
- )},
- {"testNest params", ?_assertEqual(
- {struct, [
- {1, {struct, {thrift_test_types, 'thrift.test.Xtruct2'}}}
- ]},
- thrift_test_thrift:function_info(testNest, params_type)
- )},
- {"testNest reply", ?_assertEqual(
- {struct, {thrift_test_types, 'thrift.test.Xtruct2'}},
- thrift_test_thrift:function_info(testNest, reply_type)
- )},
- {"testNest exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testNest, exceptions)
- )},
- {"testMap params", ?_assertEqual(
- {struct, [
- {1, {map, i32, i32}}
- ]},
- thrift_test_thrift:function_info(testMap, params_type)
- )},
- {"testMap reply", ?_assertEqual(
- {map, i32, i32},
- thrift_test_thrift:function_info(testMap, reply_type)
- )},
- {"testMap exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testMap, exceptions)
- )},
- {"testStringMap params", ?_assertEqual(
- {struct, [
- {1, {map, string, string}}
- ]},
- thrift_test_thrift:function_info(testStringMap, params_type)
- )},
- {"testStringMap reply", ?_assertEqual(
- {map, string, string},
- thrift_test_thrift:function_info(testStringMap, reply_type)
- )},
- {"testStringMap exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testStringMap, exceptions)
- )},
- {"testSet params", ?_assertEqual(
- {struct, [
- {1, {set, i32}}
- ]},
- thrift_test_thrift:function_info(testSet, params_type)
- )},
- {"testSet reply", ?_assertEqual(
- {set, i32},
- thrift_test_thrift:function_info(testSet, reply_type)
- )},
- {"testSet exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testSet, exceptions)
- )},
- {"testList params", ?_assertEqual(
- {struct, [
- {1, {list, i32}}
- ]},
- thrift_test_thrift:function_info(testList, params_type)
- )},
- {"testList reply", ?_assertEqual(
- {list, i32},
- thrift_test_thrift:function_info(testList, reply_type)
- )},
- {"testList exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testList, exceptions)
- )},
- {"testEnum params", ?_assertEqual(
- {struct, [
- {1, i32}
- ]},
- thrift_test_thrift:function_info(testEnum, params_type)
- )},
- {"testEnum reply", ?_assertEqual(
- i32,
- thrift_test_thrift:function_info(testEnum, reply_type)
- )},
- {"testEnum exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testEnum, exceptions)
- )},
- {"testTypedef params", ?_assertEqual(
- {struct, [{1, i64}]},
- thrift_test_thrift:function_info(testTypedef, params_type)
- )},
- {"testTypedef reply", ?_assertEqual(
- i64,
- thrift_test_thrift:function_info(testTypedef, reply_type)
- )},
- {"testTypedef exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testTypedef, exceptions)
- )},
- {"testMapMap params", ?_assertEqual(
- {struct, [
- {1, i32}
- ]},
- thrift_test_thrift:function_info(testMapMap, params_type)
- )},
- {"testMapMap reply", ?_assertEqual(
- {map, i32, {map, i32,i32}},
- thrift_test_thrift:function_info(testMapMap, reply_type)
- )},
- {"testMapMap exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testMapMap, exceptions)
- )},
- {"testInsanity params", ?_assertEqual(
- {struct, [
- {1, {struct, {thrift_test_types, 'thrift.test.Insanity'}}}
- ]},
- thrift_test_thrift:function_info(testInsanity, params_type)
- )},
- {"testInsanity reply", ?_assertEqual(
- {map, i64, {map, i32, {struct, {'thrift_test_types', 'thrift.test.Insanity'}}}},
- thrift_test_thrift:function_info(testInsanity, reply_type)
- )},
- {"testInsanity exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testInsanity, exceptions)
- )},
- {"testMulti params", ?_assertEqual(
- {struct, [
- {1, byte},
- {2, i32},
- {3, i64},
- {4, {map, i16, string}},
- {5, i32},
- {6, i64}
- ]},
- thrift_test_thrift:function_info(testMulti, params_type)
- )},
- {"testMulti reply", ?_assertEqual(
- {struct, {thrift_test_types, 'thrift.test.Xtruct'}},
- thrift_test_thrift:function_info(testMulti, reply_type)
- )},
- {"testMulti exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testMulti, exceptions)
- )},
- {"testException params", ?_assertEqual(
- {struct, [{1, string}]},
- thrift_test_thrift:function_info(testException, params_type)
- )},
- {"testException reply", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testException, reply_type)
- )},
- {"testException exceptions", ?_assertEqual(
- {struct, [
- {1, {struct, {thrift_test_types, 'thrift.test.Xception'}}}
- ]},
- thrift_test_thrift:function_info(testException, exceptions)
- )},
- {"testMultiException params", ?_assertEqual(
- {struct, [{1, string}, {2, string}]},
- thrift_test_thrift:function_info(testMultiException, params_type)
- )},
- {"testMultiException reply", ?_assertEqual(
- {struct, {thrift_test_types, 'thrift.test.Xtruct'}},
- thrift_test_thrift:function_info(testMultiException, reply_type)
- )},
- {"testMultiException exceptions", ?_assertEqual(
- {struct, [
- {1, {struct, {thrift_test_types, 'thrift.test.Xception'}}},
- {2, {struct, {thrift_test_types, 'thrift.test.Xception2'}}}
- ]},
- thrift_test_thrift:function_info(testMultiException, exceptions)
- )},
- {"testOneway params", ?_assertEqual(
- {struct, [{1, i32}]},
- thrift_test_thrift:function_info(testOneway, params_type)
- )},
- {"testOneway reply", ?_assertEqual(
- oneway_void,
- thrift_test_thrift:function_info(testOneway, reply_type)
- )},
- {"testOneway exceptions", ?_assertEqual(
- {struct, []},
- thrift_test_thrift:function_info(testOneway, exceptions)
- )},
- {"secondtestString params", ?_assertEqual(
- {struct, [{1, string}]},
- second_service_thrift:function_info(secondtestString, params_type)
- )},
- {"secondtestString reply", ?_assertEqual(
- string,
- second_service_thrift:function_info(secondtestString, reply_type)
- )},
- {"secondtestString exceptions", ?_assertEqual(
- {struct, []},
- second_service_thrift:function_info(secondtestString, exceptions)
- )}
- ].
+ [
+ {"testVoid params",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testVoid, params_type)
+ )},
+ {"testVoid reply",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testVoid, reply_type)
+ )},
+ {"testVoid exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testVoid, exceptions)
+ )},
+ {"testString params",
+ ?_assertEqual(
+ {struct, [{1, string}]},
+ thrift_test_thrift:function_info(testString, params_type)
+ )},
+ {"testString reply",
+ ?_assertEqual(
+ string,
+ thrift_test_thrift:function_info(testString, reply_type)
+ )},
+ {"testString exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testString, exceptions)
+ )},
+ {"testByte params",
+ ?_assertEqual(
+ {struct, [{1, byte}]},
+ thrift_test_thrift:function_info(testByte, params_type)
+ )},
+ {"testByte reply",
+ ?_assertEqual(
+ byte,
+ thrift_test_thrift:function_info(testByte, reply_type)
+ )},
+ {"testByte exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testByte, exceptions)
+ )},
+ {"testI32 params",
+ ?_assertEqual(
+ {struct, [{1, i32}]},
+ thrift_test_thrift:function_info(testI32, params_type)
+ )},
+ {"testI32 reply",
+ ?_assertEqual(
+ i32,
+ thrift_test_thrift:function_info(testI32, reply_type)
+ )},
+ {"testI32 exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testI32, exceptions)
+ )},
+ {"testI64 params",
+ ?_assertEqual(
+ {struct, [{1, i64}]},
+ thrift_test_thrift:function_info(testI64, params_type)
+ )},
+ {"testI64 reply",
+ ?_assertEqual(
+ i64,
+ thrift_test_thrift:function_info(testI64, reply_type)
+ )},
+ {"testI64 exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testI64, exceptions)
+ )},
+ {"testDouble params",
+ ?_assertEqual(
+ {struct, [{1, double}]},
+ thrift_test_thrift:function_info(testDouble, params_type)
+ )},
+ {"testDouble reply",
+ ?_assertEqual(
+ double,
+ thrift_test_thrift:function_info(testDouble, reply_type)
+ )},
+ {"testDouble exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testDouble, exceptions)
+ )},
+ {"testStruct params",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {thrift_test_types, 'thrift.test.Xtruct'}}}
+ ]},
+ thrift_test_thrift:function_info(testStruct, params_type)
+ )},
+ {"testStruct reply",
+ ?_assertEqual(
+ {struct, {thrift_test_types, 'thrift.test.Xtruct'}},
+ thrift_test_thrift:function_info(testStruct, reply_type)
+ )},
+ {"testStruct exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testStruct, exceptions)
+ )},
+ {"testNest params",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {thrift_test_types, 'thrift.test.Xtruct2'}}}
+ ]},
+ thrift_test_thrift:function_info(testNest, params_type)
+ )},
+ {"testNest reply",
+ ?_assertEqual(
+ {struct, {thrift_test_types, 'thrift.test.Xtruct2'}},
+ thrift_test_thrift:function_info(testNest, reply_type)
+ )},
+ {"testNest exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testNest, exceptions)
+ )},
+ {"testMap params",
+ ?_assertEqual(
+ {struct, [
+ {1, {map, i32, i32}}
+ ]},
+ thrift_test_thrift:function_info(testMap, params_type)
+ )},
+ {"testMap reply",
+ ?_assertEqual(
+ {map, i32, i32},
+ thrift_test_thrift:function_info(testMap, reply_type)
+ )},
+ {"testMap exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testMap, exceptions)
+ )},
+ {"testStringMap params",
+ ?_assertEqual(
+ {struct, [
+ {1, {map, string, string}}
+ ]},
+ thrift_test_thrift:function_info(testStringMap, params_type)
+ )},
+ {"testStringMap reply",
+ ?_assertEqual(
+ {map, string, string},
+ thrift_test_thrift:function_info(testStringMap, reply_type)
+ )},
+ {"testStringMap exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testStringMap, exceptions)
+ )},
+ {"testSet params",
+ ?_assertEqual(
+ {struct, [
+ {1, {set, i32}}
+ ]},
+ thrift_test_thrift:function_info(testSet, params_type)
+ )},
+ {"testSet reply",
+ ?_assertEqual(
+ {set, i32},
+ thrift_test_thrift:function_info(testSet, reply_type)
+ )},
+ {"testSet exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testSet, exceptions)
+ )},
+ {"testList params",
+ ?_assertEqual(
+ {struct, [
+ {1, {list, i32}}
+ ]},
+ thrift_test_thrift:function_info(testList, params_type)
+ )},
+ {"testList reply",
+ ?_assertEqual(
+ {list, i32},
+ thrift_test_thrift:function_info(testList, reply_type)
+ )},
+ {"testList exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testList, exceptions)
+ )},
+ {"testEnum params",
+ ?_assertEqual(
+ {struct, [
+ {1, i32}
+ ]},
+ thrift_test_thrift:function_info(testEnum, params_type)
+ )},
+ {"testEnum reply",
+ ?_assertEqual(
+ i32,
+ thrift_test_thrift:function_info(testEnum, reply_type)
+ )},
+ {"testEnum exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testEnum, exceptions)
+ )},
+ {"testTypedef params",
+ ?_assertEqual(
+ {struct, [{1, i64}]},
+ thrift_test_thrift:function_info(testTypedef, params_type)
+ )},
+ {"testTypedef reply",
+ ?_assertEqual(
+ i64,
+ thrift_test_thrift:function_info(testTypedef, reply_type)
+ )},
+ {"testTypedef exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testTypedef, exceptions)
+ )},
+ {"testMapMap params",
+ ?_assertEqual(
+ {struct, [
+ {1, i32}
+ ]},
+ thrift_test_thrift:function_info(testMapMap, params_type)
+ )},
+ {"testMapMap reply",
+ ?_assertEqual(
+ {map, i32, {map, i32, i32}},
+ thrift_test_thrift:function_info(testMapMap, reply_type)
+ )},
+ {"testMapMap exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testMapMap, exceptions)
+ )},
+ {"testInsanity params",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {thrift_test_types, 'thrift.test.Insanity'}}}
+ ]},
+ thrift_test_thrift:function_info(testInsanity, params_type)
+ )},
+ {"testInsanity reply",
+ ?_assertEqual(
+ {map, i64, {map, i32, {struct, {'thrift_test_types', 'thrift.test.Insanity'}}}},
+ thrift_test_thrift:function_info(testInsanity, reply_type)
+ )},
+ {"testInsanity exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testInsanity, exceptions)
+ )},
+ {"testMulti params",
+ ?_assertEqual(
+ {struct, [
+ {1, byte},
+ {2, i32},
+ {3, i64},
+ {4, {map, i16, string}},
+ {5, i32},
+ {6, i64}
+ ]},
+ thrift_test_thrift:function_info(testMulti, params_type)
+ )},
+ {"testMulti reply",
+ ?_assertEqual(
+ {struct, {thrift_test_types, 'thrift.test.Xtruct'}},
+ thrift_test_thrift:function_info(testMulti, reply_type)
+ )},
+ {"testMulti exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testMulti, exceptions)
+ )},
+ {"testException params",
+ ?_assertEqual(
+ {struct, [{1, string}]},
+ thrift_test_thrift:function_info(testException, params_type)
+ )},
+ {"testException reply",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testException, reply_type)
+ )},
+ {"testException exceptions",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {thrift_test_types, 'thrift.test.Xception'}}}
+ ]},
+ thrift_test_thrift:function_info(testException, exceptions)
+ )},
+ {"testMultiException params",
+ ?_assertEqual(
+ {struct, [{1, string}, {2, string}]},
+ thrift_test_thrift:function_info(testMultiException, params_type)
+ )},
+ {"testMultiException reply",
+ ?_assertEqual(
+ {struct, {thrift_test_types, 'thrift.test.Xtruct'}},
+ thrift_test_thrift:function_info(testMultiException, reply_type)
+ )},
+ {"testMultiException exceptions",
+ ?_assertEqual(
+ {struct, [
+ {1, {struct, {thrift_test_types, 'thrift.test.Xception'}}},
+ {2, {struct, {thrift_test_types, 'thrift.test.Xception2'}}}
+ ]},
+ thrift_test_thrift:function_info(testMultiException, exceptions)
+ )},
+ {"testOneway params",
+ ?_assertEqual(
+ {struct, [{1, i32}]},
+ thrift_test_thrift:function_info(testOneway, params_type)
+ )},
+ {"testOneway reply",
+ ?_assertEqual(
+ oneway_void,
+ thrift_test_thrift:function_info(testOneway, reply_type)
+ )},
+ {"testOneway exceptions",
+ ?_assertEqual(
+ {struct, []},
+ thrift_test_thrift:function_info(testOneway, exceptions)
+ )},
+ {"secondtestString params",
+ ?_assertEqual(
+ {struct, [{1, string}]},
+ second_service_thrift:function_info(secondtestString, params_type)
+ )},
+ {"secondtestString reply",
+ ?_assertEqual(
+ string,
+ second_service_thrift:function_info(secondtestString, reply_type)
+ )},
+ {"secondtestString exceptions",
+ ?_assertEqual(
+ {struct, []},
+ second_service_thrift:function_info(secondtestString, exceptions)
+ )}
+ ].