THRIFT-2628 struct member name conflicts due to lowercased names

Client: Erlang
Patch: Alisdair Sullivan

This closes #228

6 files changed, 805 insertions, 48 deletions

diff --git a/test/erl/LegacyNames.thrift b/test/erl/LegacyNames.thrift
new file mode 100644
index 000000000..38f272907
--- /dev/null
+++ b/test/erl/LegacyNames.thrift
@@ -0,0 +1,33 @@
+enum Numberz
+{
+  ONE = 1,
+  TWO,
+  THREE,
+  FIVE = 5,
+  SIX,
+  EIGHT = 8
+}
+
+const Numberz myNumberz = Numberz.ONE;
+
+struct CapitalizedStruct
+{
+  1: i32 Id,
+  2: binary message
+}
+
+struct ListCapitalizedStructs
+{
+  1: list<CapitalizedStruct> structs
+}
+
+exception Xception {
+  1: i32 errorCode,
+  2: binary message
+}
+
+service LegacyNames
+{
+  ListCapitalizedStructs Names(1: CapitalizedStruct foo, 2: CapitalizedStruct bar)
+    throws(1: Xception err)
+}
\ No newline at end of file
diff --git a/test/erl/Makefile.am b/test/erl/Makefile.am
index 911fceb60..309d07e2d 100644
--- a/test/erl/Makefile.am
+++ b/test/erl/Makefile.am
@@ -26,6 +26,7 @@ THRIFT_FILES = $(wildcard ../*.thrift)
 	for f in $(THRIFT_FILES) ; do \
 	  $(THRIFT) --gen erl $$f ; \
 	done ; \
+	$(THRIFT) --gen erl:legacynames LegacyNames.thrift
 	touch .generated
 
 check: .generated
diff --git a/test/erl/src/legacy_names_test.erl b/test/erl/src/legacy_names_test.erl
new file mode 100644
index 000000000..2ace7d066
--- /dev/null
+++ b/test/erl/src/legacy_names_test.erl
@@ -0,0 +1,69 @@
+%%
+%% 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(legacy_names_test).
+-compile(export_all).
+
+-include_lib("eunit/include/eunit.hrl").
+
+-include("legacyNames_constants.hrl").
+
+record_generation_test_() ->
+  [
+    {"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)
+    )}
+  ].
+
+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)
+    )}
+  ].
\ No newline at end of file
diff --git a/test/erl/src/nameConflictTest_test.erl b/test/erl/src/name_conflict_test.erl
index 7ce4886c5..40c820410 100644
--- a/test/erl/src/nameConflictTest_test.erl
+++ b/test/erl/src/name_conflict_test.erl
@@ -17,12 +17,12 @@
 %% under the License.
 %%
 
--module(nameConflictTest_test).
+-module(name_conflict_test).
 -compile(export_all).
 
 -include_lib("eunit/include/eunit.hrl").
 
--include("nameConflictTest_constants.hrl").
+-include("name_conflict_test_constants.hrl").
 
 record_generation_test_() ->
   [
@@ -116,85 +116,85 @@ struct_info_test_() ->
   [
     {"using definition", ?_assertEqual(
       {struct, [{1, double},{2, double}]},
-      nameConflictTest_types:struct_info(using)
+      name_conflict_test_types:struct_info(using)
     )},
     {"delegate definition", ?_assertEqual(
       {struct, [
         {1, string},
-        {2, {struct, {nameConflictTest_types, delegate}}}
+        {2, {struct, {name_conflict_test_types, delegate}}}
       ]},
-      nameConflictTest_types:struct_info(delegate)
+      name_conflict_test_types:struct_info(delegate)
     )},
     {"get definition", ?_assertEqual(
       {struct, [{1, bool}]},
-      nameConflictTest_types:struct_info(get)
+      name_conflict_test_types:struct_info(get)
     )},
     {"partial definition", ?_assertEqual(
-      {struct, [{1, {struct, {nameConflictTest_types, using}}}]},
-      nameConflictTest_types:struct_info(partial)
+      {struct, [{1, {struct, {name_conflict_test_types, using}}}]},
+      name_conflict_test_types:struct_info(partial)
     )},
     {"ClassAndProp definition", ?_assertEqual(
       {struct, [{1, bool},{2, bool},{3, bool},{4, bool}]},
-      nameConflictTest_types:struct_info('ClassAndProp')
+      name_conflict_test_types:struct_info('ClassAndProp')
     )},
     {"second_chance definition", ?_assertEqual(
       {struct, [{1, bool},{2, bool},{3, bool},{4, bool}]},
-      nameConflictTest_types:struct_info(second_chance)
+      name_conflict_test_types:struct_info(second_chance)
     )},
     {"NOW_EAT_THIS definition", ?_assertEqual(
       {struct, [{1, bool},{2, bool},{3, bool},{4, bool}]},
-      nameConflictTest_types:struct_info('NOW_EAT_THIS')
+      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}]},
-      nameConflictTest_types:struct_info('TheEdgeCase')
+      name_conflict_test_types:struct_info('TheEdgeCase')
     )},
     {"theEdgeCase definition", ?_assertEqual(
       {struct, [{1, bool},{2, bool},{3, bool},{4, bool},{5, bool},{6, bool}]},
-      nameConflictTest_types:struct_info(theEdgeCase)
+      name_conflict_test_types:struct_info(theEdgeCase)
     )},
     {"Tricky_ definition", ?_assertEqual(
       {struct, [{1, bool},{2, bool}]},
-      nameConflictTest_types:struct_info('Tricky_')
+      name_conflict_test_types:struct_info('Tricky_')
     )},
     {"Nested definition", ?_assertEqual(
       {struct, [
-        {1, {struct, {nameConflictTest_types, 'ClassAndProp'}}},
-        {2, {struct, {nameConflictTest_types, second_chance}}},
-        {3, {struct, {nameConflictTest_types, 'NOW_EAT_THIS'}}},
-        {4, {struct, {nameConflictTest_types, 'TheEdgeCase'}}},
-        {5, {struct, {nameConflictTest_types, 'Tricky_'}}},
-        {6, {struct, {nameConflictTest_types, 'Nested'}}}
+        {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'}}}
       ]},
-      nameConflictTest_types:struct_info('Nested')
+      name_conflict_test_types:struct_info('Nested')
     )},
     {"Problem_ definition", ?_assertEqual(
       {struct, [{1, bool},{2, bool}]},
-      nameConflictTest_types:struct_info('Problem_')
+      name_conflict_test_types:struct_info('Problem_')
     )},
     {"using extended definition", ?_assertEqual(
       {struct, [
         {1, undefined, double, single, undefined},
         {2, undefined, double, integer, undefined}
       ]},
-      nameConflictTest_types:struct_info_ext(using)
+      name_conflict_test_types:struct_info_ext(using)
     )},
     {"delegate extended definition", ?_assertEqual(
       {struct, [
         {1, undefined, string, partial, undefined},
-        {2, undefined, {struct, {nameConflictTest_types, delegate}}, delegate, undefined}
+        {2, undefined, {struct, {name_conflict_test_types, delegate}}, delegate, undefined}
       ]},
-      nameConflictTest_types:struct_info_ext(delegate)
+      name_conflict_test_types:struct_info_ext(delegate)
     )},
     {"get extended definition", ?_assertEqual(
       {struct, [{1, undefined, bool, sbyte, undefined}]},
-      nameConflictTest_types:struct_info_ext(get)
+      name_conflict_test_types:struct_info_ext(get)
     )},
     {"partial extended definition", ?_assertEqual(
       {struct, [
-        {1, undefined, {struct, {nameConflictTest_types, using}}, using, #using{}}
+        {1, undefined, {struct, {name_conflict_test_types, using}}, using, #using{}}
       ]},
-      nameConflictTest_types:struct_info_ext(partial)
+      name_conflict_test_types:struct_info_ext(partial)
     )},
     {"ClassAndProp extended definition", ?_assertEqual(
       {struct, [
@@ -203,7 +203,7 @@ struct_info_test_() ->
         {3, undefined, bool, 'ClassAndProp__', undefined},
         {4, undefined, bool, 'ClassAndProper', undefined}
       ]},
-      nameConflictTest_types:struct_info_ext('ClassAndProp')
+      name_conflict_test_types:struct_info_ext('ClassAndProp')
     )},
     {"second_chance extended definition", ?_assertEqual(
       {struct, [
@@ -212,7 +212,7 @@ struct_info_test_() ->
         {3, undefined, bool, 'SECOND_CHANCE__', undefined},
         {4, undefined, bool, 'SECOND_CHANCES', undefined}
       ]},
-      nameConflictTest_types:struct_info_ext(second_chance)
+      name_conflict_test_types:struct_info_ext(second_chance)
     )},
     {"NOW_EAT_THIS extended definition", ?_assertEqual(
       {struct, [
@@ -221,7 +221,7 @@ struct_info_test_() ->
         {3, undefined, bool, now_eat_this__, undefined},
         {4, undefined, bool, now_eat_this_and_this, undefined}
       ]},
-      nameConflictTest_types:struct_info_ext('NOW_EAT_THIS')
+      name_conflict_test_types:struct_info_ext('NOW_EAT_THIS')
     )},
     {"TheEdgeCase extended definition", ?_assertEqual(
       {struct, [
@@ -232,7 +232,7 @@ struct_info_test_() ->
         {5, undefined, bool, 'TheEdgeCase_', undefined},
         {6, undefined, bool, 'TheEdgeCase__', undefined}
       ]},
-      nameConflictTest_types:struct_info_ext('TheEdgeCase')
+      name_conflict_test_types:struct_info_ext('TheEdgeCase')
     )},
     {"TheEdgeCase extended definition", ?_assertEqual(
       {struct, [
@@ -243,61 +243,61 @@ struct_info_test_() ->
         {5, undefined, bool, 'TheEdgeCase_', undefined},
         {6, undefined, bool, 'TheEdgeCase__', undefined}
       ]},
-      nameConflictTest_types:struct_info_ext(theEdgeCase)
+      name_conflict_test_types:struct_info_ext(theEdgeCase)
     )},
     {"Tricky_ extended definition", ?_assertEqual(
       {struct, [
         {1, undefined, bool, tricky, undefined},
         {2, undefined, bool, 'Tricky', undefined}
       ]},
-      nameConflictTest_types:struct_info_ext('Tricky_')
+      name_conflict_test_types:struct_info_ext('Tricky_')
     )},
     {"Nested extended definition", ?_assertEqual(
       {struct, [
         {1, undefined, {struct, {
-          nameConflictTest_types,
+          name_conflict_test_types,
           'ClassAndProp'
         }}, 'ClassAndProp', #'ClassAndProp'{}},
         {2, undefined, {struct, {
-          nameConflictTest_types,
+          name_conflict_test_types,
           second_chance
         }}, second_chance, #second_chance{}},
         {3, undefined, {struct, {
-          nameConflictTest_types,
+          name_conflict_test_types,
           'NOW_EAT_THIS'
         }}, 'NOW_EAT_THIS', #'NOW_EAT_THIS'{}},
         {4, undefined, {struct, {
-          nameConflictTest_types,
+          name_conflict_test_types,
           'TheEdgeCase'
         }}, 'TheEdgeCase', #'TheEdgeCase'{}},
         {5, undefined, {struct, {
-          nameConflictTest_types,
+          name_conflict_test_types,
           'Tricky_'
         }}, 'Tricky_', #'Tricky_'{}},
         {6, undefined, {struct, {
-          nameConflictTest_types,
+          name_conflict_test_types,
           'Nested'
         }}, 'Nested', undefined}
       ]},
-      nameConflictTest_types:struct_info_ext('Nested')
+      name_conflict_test_types:struct_info_ext('Nested')
     )},
     {"Problem_ extended definition", ?_assertEqual(
       {struct, [
         {1, undefined, bool, problem, undefined},
         {2, undefined, bool, 'Problem', undefined}
       ]},
-      nameConflictTest_types:struct_info_ext('Problem_')
+      name_conflict_test_types:struct_info_ext('Problem_')
     )}
   ].
 
 service_info_test_() ->
   [
     {"event params", ?_assertEqual(
-      {struct, [{1, {struct, {nameConflictTest_types, partial}}}]},
+      {struct, [{1, {struct, {name_conflict_test_types, partial}}}]},
       extern_thrift:function_info(event, params_type)
     )},
     {"event reply", ?_assertEqual(
-      {struct, {nameConflictTest_types, delegate}},
+      {struct, {name_conflict_test_types, delegate}},
       extern_thrift:function_info(event, reply_type)
     )},
     {"event exceptions", ?_assertEqual(
@@ -305,7 +305,7 @@ service_info_test_() ->
       extern_thrift:function_info(event, exceptions)
     )},
     {"Foo params", ?_assertEqual(
-      {struct, [{1, {struct, {nameConflictTest_types, 'Nested'}}}]},
+      {struct, [{1, {struct, {name_conflict_test_types, 'Nested'}}}]},
       extern_thrift:function_info('Foo', params_type)
     )},
     {"Foo reply", ?_assertEqual(
@@ -313,7 +313,7 @@ service_info_test_() ->
       extern_thrift:function_info('Foo', reply_type)
     )},
     {"Foo exceptions", ?_assertEqual(
-      {struct, [{1, {struct, {nameConflictTest_types, 'Problem_'}}}]},
+      {struct, [{1, {struct, {name_conflict_test_types, 'Problem_'}}}]},
       extern_thrift:function_info('Foo', exceptions)
     )}
   ].
\ No newline at end of file
diff --git a/test/erl/src/thrift_test.app.src b/test/erl/src/thrift_test.app.src
index dd0492670..4dcd37734 100644
--- a/test/erl/src/thrift_test.app.src
+++ b/test/erl/src/thrift_test.app.src
@@ -25,8 +25,7 @@
   {vsn, "1.0.0-dev"},
 
   % All modules used by the application.
-  {modules, [
-  ]},
+  {modules, [legacy_names_test, name_conflict_test, thrift_test_test]},
 
   % All of the registered names the application uses. This can be ignored.
   {registered, []},
diff --git a/test/erl/src/thrift_test_test.erl b/test/erl/src/thrift_test_test.erl
new file mode 100644
index 000000000..07dfe1c0e
--- /dev/null
+++ b/test/erl/src/thrift_test_test.erl
@@ -0,0 +1,655 @@
+%%
+%% 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.
+%%
+
+% don't rename this thrift_test, it clobbers generated files
+-module(thrift_test_test).
+-compile(export_all).
+
+-include_lib("eunit/include/eunit.hrl").
+
+-include("thrift_test_constants.hrl").
+
+constant_test_() ->
+  [
+    {"myNumberz equals 1", ?_assertEqual(1, ?THRIFT_TEST_MYNUMBERZ)}
+  ].
+
+record_generation_test_() ->
+  [
+    {"Bonk record", ?_assertMatch(
+      {'Bonk', _, _},
+      #'Bonk'{message=null,type=null}
+    )},
+    {"Bools record", ?_assertMatch(
+      {'Bools', _, _},
+      #'Bools'{im_true=null,im_false=null}
+    )},
+    {"Xtruct record", ?_assertMatch(
+      {'Xtruct', _, _, _, _},
+      #'Xtruct'{string_thing=null,byte_thing=null,i32_thing=null,i64_thing=null}
+    )},
+    {"Xtruct2 record", ?_assertMatch(
+      {'Xtruct2', _, _, _},
+      #'Xtruct2'{byte_thing=null,struct_thing=null,i32_thing=null}
+    )},
+    {"Xtruct3 record", ?_assertMatch(
+      {'Xtruct3', _, _, _, _},
+      #'Xtruct3'{string_thing=null,changed=null,i32_thing=null,i64_thing=null}
+    )},
+    {"Insanity record", ?_assertMatch(
+      {'Insanity', _, _},
+      #'Insanity'{userMap=null,xtructs=null}
+    )},
+    {"CrazyNesting record", ?_assertMatch(
+      {'CrazyNesting', _, _, _, _},
+      #'CrazyNesting'{
+        string_field=null,
+        set_field=null,
+        list_field=null,
+        binary_field=null
+      }
+    )},
+    {"Xception record", ?_assertMatch(
+      {'Xception', _, _},
+      #'Xception'{errorCode=null,message=null}
+    )},
+    {"Xception2 record", ?_assertMatch(
+      {'Xception2', _, _},
+      #'Xception2'{errorCode=null,struct_thing=null}
+    )},
+    {"EmptyStruct record", ?_assertMatch({'EmptyStruct'}, #'EmptyStruct'{})},
+    {"OneField record", ?_assertMatch({'OneField', _}, #'OneField'{field=null})},
+    {"VersioningTestV1 record", ?_assertMatch(
+      {'VersioningTestV1', _, _, _},
+      #'VersioningTestV1'{begin_in_both=null,old_string=null,end_in_both=null}
+    )},
+    {"VersioningTestV2 record", ?_assertMatch(
+      {'VersioningTestV2', _, _, _, _, _, _, _, _, _, _, _, _},
+      #'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(
+      {'ListTypeVersioningV1', _, _},
+      #'ListTypeVersioningV1'{myints=null,hello=null}
+    )},
+    {"ListTypeVersioningV2 record", ?_assertMatch(
+      {'ListTypeVersioningV2', _, _},
+      #'ListTypeVersioningV2'{strings=null,hello=null}
+    )},
+    {"GuessProtocolStruct record", ?_assertMatch(
+      {'GuessProtocolStruct', _},
+      #'GuessProtocolStruct'{map_field=null}
+    )},
+    {"LargeDeltas record", ?_assertMatch(
+      {'LargeDeltas', _, _, _, _, _, _, _, _, _, _},
+      #'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(
+      {'NestedListsI32x2', _},
+      #'NestedListsI32x2'{integerlist=null}
+    )},
+    {"NestedListsI32x3 record", ?_assertMatch(
+      {'NestedListsI32x3', _},
+      #'NestedListsI32x3'{integerlist=null}
+    )},
+    {"NestedMixedx2 record", ?_assertMatch(
+      {'NestedMixedx2', _, _, _},
+      #'NestedMixedx2'{
+        int_set_list=null,
+        map_int_strset=null,
+        map_int_strset_list=null
+      }
+    )},
+    {"ListBonks record", ?_assertMatch({'ListBonks', _}, #'ListBonks'{bonk=null})},
+    {"NestedListsBonk record", ?_assertMatch(
+      {'NestedListsBonk', _},
+      #'NestedListsBonk'{bonk=null}
+    )},
+    {"BoolTest record", ?_assertMatch(
+      {'BoolTest', _, _},
+      #'BoolTest'{b=null,s=null}
+    )},
+    {"StructA record", ?_assertMatch({'StructA', _}, #'StructA'{s=null})},
+    {"StructB record", ?_assertMatch(
+      {'StructB', _, _},
+      #'StructB'{aa=null,ab=null}
+    )}
+  ].
+
+struct_info_test_() ->
+  [
+    {"Bonk definition (short version)", ?_assertEqual(
+      {struct, [{1, string}, {2, i32}]},
+      thrift_test_types:struct_info('Bonk')
+    )},
+    {"Bonk definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, string, message, undefined},
+        {2, undefined, i32, type, undefined}
+      ]},
+      thrift_test_types:struct_info_ext('Bonk')
+    )},
+    {"Bools definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, bool, im_true, undefined},
+        {2, undefined, bool, im_false, undefined}
+      ]},
+      thrift_test_types:struct_info_ext('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('Xtruct')
+    )},
+    {"Xtruct2 definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, byte, byte_thing, undefined},
+        {2, undefined, {struct, {'thrift_test_types', 'Xtruct'}}, struct_thing, #'Xtruct'{}},
+        {3, undefined, i32, i32_thing, undefined}
+      ]},
+      thrift_test_types:struct_info_ext('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('Xtruct3')
+    )},
+    {"Insanity definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {map, i32, i64}, userMap, dict:new()},
+        {2, undefined, {list, {struct, {'thrift_test_types', 'Xtruct'}}}, xtructs, []}
+      ]},
+      thrift_test_types:struct_info_ext('Insanity')
+    )},
+    {"CrazyNesting definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, string, string_field, undefined},
+        {2, optional, {set, {struct, {'thrift_test_types', 'Insanity'}}}, set_field, sets:new()},
+        {3, required, {list, {map, 
+          {set, i32},
+          {map, i32, {set, {list, {map, {struct, {'thrift_test_types', 'Insanity'}}, string}}}}
+        }}, list_field, []},
+        {4, undefined, string, binary_field, undefined}
+      ]},
+      thrift_test_types:struct_info_ext('CrazyNesting')
+    )},
+    {"Xception definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, i32, errorCode, undefined},
+        {2, undefined, string, message, undefined}
+      ]},
+      thrift_test_types:struct_info_ext('Xception')
+    )},
+    {"Xception2 definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, i32, errorCode, undefined},
+        {2, undefined, {struct, {'thrift_test_types', 'Xtruct'}}, struct_thing, #'Xtruct'{}}
+      ]},
+      thrift_test_types:struct_info_ext('Xception2')
+    )},
+    {"EmptyStruct definition", ?_assertEqual(
+      {struct, []},
+      thrift_test_types:struct_info_ext('EmptyStruct')
+    )},
+    {"OneField definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {struct, {'thrift_test_types', 'EmptyStruct'}}, field, #'EmptyStruct'{}}
+      ]},
+      thrift_test_types:struct_info_ext('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('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, 'Bonk'}}, newstruct, #'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('VersioningTestV2')
+    )},
+    {"ListTypeVersioningV1 definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {list, i32}, myints, []},
+        {2, undefined, string, hello, undefined}
+      ]},
+      thrift_test_types:struct_info_ext('ListTypeVersioningV1')
+    )},
+    {"ListTypeVersioningV2 definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {list, string}, strings, []},
+        {2, undefined, string, hello, undefined}
+      ]},
+      thrift_test_types:struct_info_ext('ListTypeVersioningV2')
+    )},
+    {"GuessProtocolStruct definition", ?_assertEqual(
+      {struct, [
+        {7, undefined, {map, string, string}, map_field, dict:new()}
+      ]},
+      thrift_test_types:struct_info_ext('GuessProtocolStruct')
+    )},
+    {"LargeDeltas definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {struct, {thrift_test_types, 'Bools'}}, b1, #'Bools'{}},
+        {10, undefined, {struct, {thrift_test_types, 'Bools'}}, b10, #'Bools'{}},
+        {100, undefined, {struct, {thrift_test_types, 'Bools'}}, b100, #'Bools'{}},
+        {500, undefined, bool, check_true, undefined},
+        {1000, undefined, {struct, {thrift_test_types, 'Bools'}}, b1000, #'Bools'{}},
+        {1500, undefined, bool, check_false, undefined},
+        {2000, undefined, {struct, {thrift_test_types, 'VersioningTestV2'}}, vertwo2000, #'VersioningTestV2'{}},
+        {2500, undefined, {set, string}, a_set2500, sets:new()},
+        {3000, undefined, {struct, {thrift_test_types, 'VersioningTestV2'}}, vertwo3000, #'VersioningTestV2'{}},
+        {4000, undefined, {list, i32}, big_numbers, []}
+      ]},
+      thrift_test_types:struct_info_ext('LargeDeltas')
+    )},
+    {"NestedListsI32x2 definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {list, {list, i32}}, integerlist, []}
+      ]},
+      thrift_test_types:struct_info_ext('NestedListsI32x2')
+    )},
+    {"NestedListsI32x3 definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {list, {list, {list, i32}}}, integerlist, []}
+      ]},
+      thrift_test_types:struct_info_ext('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('NestedMixedx2')
+    )},
+    {"ListBonks definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {list, {struct, {thrift_test_types, 'Bonk'}}}, bonk, []}
+      ]},
+      thrift_test_types:struct_info_ext('ListBonks')
+    )},
+    {"NestedListsBonk definition", ?_assertEqual(
+      {struct, [
+        {1, undefined, {list, {list, {list, {struct, {thrift_test_types, 'Bonk'}}}}}, bonk, []}
+      ]},
+      thrift_test_types:struct_info_ext('NestedListsBonk')
+    )},
+    {"BoolTest definition", ?_assertEqual(
+      {struct, [
+        {1, optional, bool, b, true},
+        {2, optional, string, s, "true"}
+      ]},
+      thrift_test_types:struct_info_ext('BoolTest')
+    )},
+    {"StructA definition", ?_assertEqual(
+      {struct, [{1, required, string, s, undefined}]},
+      thrift_test_types:struct_info_ext('StructA')
+    )},
+    {"StructB definition", ?_assertEqual(
+      {struct, [
+        {1, optional, {struct, {thrift_test_types, 'StructA'}}, aa, #'StructA'{}},
+        {2, required, {struct, {thrift_test_types, 'StructA'}}, ab, #'StructA'{}}
+      ]},
+      thrift_test_types:struct_info_ext('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, 'Xtruct'}}}
+      ]},
+      thrift_test_thrift:function_info(testStruct, params_type)
+    )},
+    {"testStruct reply", ?_assertEqual(
+      {struct, {thrift_test_types, '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, 'Xtruct2'}}}
+      ]},
+      thrift_test_thrift:function_info(testNest, params_type)
+    )},
+    {"testNest reply", ?_assertEqual(
+      {struct, {thrift_test_types, '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, 'Insanity'}}}
+      ]},
+      thrift_test_thrift:function_info(testInsanity, params_type)
+    )},
+    {"testInsanity reply", ?_assertEqual(
+      {map, i64, {map, i32, {struct, {'thrift_test_types', '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, '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, '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, 'Xtruct'}},
+      thrift_test_thrift:function_info(testMultiException, reply_type)
+    )},
+    {"testMultiException exceptions", ?_assertEqual(
+      {struct, [
+        {1, {struct, {thrift_test_types, 'Xception'}}},
+        {2, {struct, {thrift_test_types, '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)
+    )},
+    {"blahBlah params", ?_assertEqual(
+      {struct, []},
+      second_service_thrift:function_info(blahBlah, params_type)
+    )},
+    {"blahBlah reply", ?_assertEqual(
+      {struct, []},
+      second_service_thrift:function_info(blahBlah, reply_type)
+    )},
+    {"blahBlah exceptions", ?_assertEqual(
+      {struct, []},
+      second_service_thrift:function_info(blahBlah, 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)
+    )}
+  ].
\ No newline at end of file