THRIFT-356. Improve CompactProtocolTestStruct

- Remove the default values from CompactProtocolTestStruct
- Add a const CompactProtocolTestStruct that contains those values

This has a short-term benefit and a long-term benefit.

The short-term benefit is that it removes the list-as-map-key
(etc.) values from the "types" generated file and puts it into
the "constants" generated file.  This gets them out of the way
of the Python tests, so they pass again.

The long term benefit is that is strengthens the Java TCompactProtocol
test.  Before, it was reading the "full" CompactProtocolTestStruct into
a CompactProtocolTestStruct that was just constructed, but the latter
was already almost equal to the former.  This change makes it much
easier to create an empty CompactProtocolTestStruct to read the serialized
data into.


git-svn-id: https://svn.apache.org/repos/asf/incubator/thrift/trunk@762957 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 97 insertions, 44 deletions

diff --git a/test/DebugProtoTest.thrift b/test/DebugProtoTest.thrift
index fb4ce0716..12c461381 100644
--- a/test/DebugProtoTest.thrift
+++ b/test/DebugProtoTest.thrift
@@ -99,65 +99,118 @@ struct Base64 {
 
 struct CompactProtoTestStruct {
   // primitive fields
-  1: byte   a_byte = 127;
-  2: i16    a_i16 = 32000;
-  3: i32    a_i32 = 1000000000;
-  4: i64    a_i64 = 0xffffffffff;
-  5: double a_double = 5.6789;
-  6: string a_string = "my string";
+  1: byte   a_byte;
+  2: i16    a_i16;
+  3: i32    a_i32;
+  4: i64    a_i64;
+  5: double a_double;
+  6: string a_string;
   7: binary a_binary;
-  8: bool   true_field = 1;
-  9: bool   false_field = 0;
-  10: Empty empty_struct_field = {};
+  8: bool   true_field;
+  9: bool   false_field;
+  10: Empty empty_struct_field;
   
   // primitives in lists
-  11: list<byte>    byte_list = [-127, -1, 0, 1, 127];
-  12: list<i16>     i16_list = [-1, 0, 1, 0x7fff];
-  13: list<i32>     i32_list = [-1, 0, 0xff, 0xffff, 0xffffff, 0x7fffffff];
-  14: list<i64>     i64_list = [-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff];
-  15: list<double>  double_list = [0.1, 0.2, 0.3];
-  16: list<string>  string_list = ["first", "second", "third"];
+  11: list<byte>    byte_list;
+  12: list<i16>     i16_list;
+  13: list<i32>     i32_list;
+  14: list<i64>     i64_list;
+  15: list<double>  double_list;
+  16: list<string>  string_list;
   17: list<binary>  binary_list;
-  18: list<bool>    boolean_list = [1, 1, 1, 0, 0, 0];
-  19: list<Empty>   struct_list = [{}, {}];
+  18: list<bool>    boolean_list;
+  19: list<Empty>   struct_list;
   
   // primitives in sets
-  20: set<byte>     byte_set = [-127, -1, 0, 1, 127];
-  21: set<i16>      i16_set = [-1, 0, 1, 0x7fff];
-  22: set<i32>      i32_set = [1, 2, 3];
-  23: set<i64>      i64_set = [-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff];
-  24: set<double>   double_set = [0.1, 0.2, 0.3];
-  25: set<string>   string_set = ["first", "second", "third"];
+  20: set<byte>     byte_set;
+  21: set<i16>      i16_set;
+  22: set<i32>      i32_set;
+  23: set<i64>      i64_set;
+  24: set<double>   double_set;
+  25: set<string>   string_set;
   26: set<binary>   binary_set;
-  27: set<bool>     boolean_set = [1, 0];
-  28: set<Empty>    struct_set = [{}];
+  27: set<bool>     boolean_set;
+  28: set<Empty>    struct_set;
   
   // maps
   // primitives as keys
-  29: map<byte, byte>             byte_byte_map = {1 : 2};
-  30: map<i16, byte>              i16_byte_map = {1 : 1, -1 : 1, 0x7fff : 1};
-  31: map<i32, byte>              i32_byte_map = {1 : 1, -1 : 1, 0x7fffffff : 1};
-  32: map<i64, byte>              i64_byte_map = {0 : 1,  1 : 1, -1 : 1, 0x7fffffffffffffff : 1};
-  33: map<double, byte>           double_byte_map = {-1.1 : 1, 1.1 : 1};
-  34: map<string, byte>           string_byte_map = {"first" : 1, "second" : 2, "third" : 3, "" : 0};
+  29: map<byte, byte>             byte_byte_map;
+  30: map<i16, byte>              i16_byte_map;
+  31: map<i32, byte>              i32_byte_map;
+  32: map<i64, byte>              i64_byte_map;
+  33: map<double, byte>           double_byte_map;
+  34: map<string, byte>           string_byte_map;
   35: map<binary, byte>           binary_byte_map;
-  36: map<bool, byte>             boolean_byte_map = {1 : 1, 0 : 0};
+  36: map<bool, byte>             boolean_byte_map;
   // primitives as values
-  37: map<byte, i16>              byte_i16_map = {1 : 1, 2 : -1, 3 : 0x7fff};
-  38: map<byte, i32>              byte_i32_map = {1 : 1, 2 : -1, 3 : 0x7fffffff};
-  39: map<byte, i64>              byte_i64_map = {1 : 1, 2 : -1, 3 : 0x7fffffffffffffff};
-  40: map<byte, double>           byte_double_map = {1 : 0.1, 2 : -0.1, 3 : 1000000.1};
-  41: map<byte, string>           byte_string_map = {1 : "", 2 : "blah", 3 : "loooooooooooooong string"};
+  37: map<byte, i16>              byte_i16_map;
+  38: map<byte, i32>              byte_i32_map;
+  39: map<byte, i64>              byte_i64_map;
+  40: map<byte, double>           byte_double_map;
+  41: map<byte, string>           byte_string_map;
   42: map<byte, binary>           byte_binary_map;
-  43: map<byte, bool>             byte_boolean_map = {1 : 1, 2 : 0};
+  43: map<byte, bool>             byte_boolean_map;
   // collections as keys
-  44: map<list<byte>, byte>       list_byte_map = {[1, 2, 3] : 1, [0, 1] : 2, [] : 0};
-  45: map<set<byte>, byte>        set_byte_map = {[1, 2, 3] : 1, [0, 1] : 2, [] : 0};
-  46: map<map<byte,byte>, byte>   map_byte_map = {{1 : 1} : 1, {2 : 2} : 2, {} : 0};
+  44: map<list<byte>, byte>       list_byte_map;
+  45: map<set<byte>, byte>        set_byte_map;
+  46: map<map<byte,byte>, byte>   map_byte_map;
   // collections as values
-  47: map<byte, map<byte,byte>>   byte_map_map = {0 : {}, 1 : {1 : 1}, 2 : {1 : 1, 2 : 2}};
-  48: map<byte, set<byte>>        byte_set_map = {0 : [], 1 : [1], 2 : [1, 2]};
-  49: map<byte, list<byte>>       byte_list_map = {0 : [], 1 : [1], 2 : [1, 2]};
+  47: map<byte, map<byte,byte>>   byte_map_map;
+  48: map<byte, set<byte>>        byte_set_map;
+  49: map<byte, list<byte>>       byte_list_map;
+}
+
+
+const CompactProtoTestStruct COMPACT_TEST = {
+  'a_byte'             : 127,
+  'a_i16'              : 32000,
+  'a_i32'              : 1000000000,
+  'a_i64'              : 0xffffffffff,
+  'a_double'           : 5.6789,
+  'a_string'           : "my string",
+//'a_binary,'
+  'true_field'         : 1,
+  'false_field'        : 0,
+  'empty_struct_field' : {},
+  'byte_list'          : [-127, -1, 0, 1, 127],
+  'i16_list'           : [-1, 0, 1, 0x7fff],
+  'i32_list'           : [-1, 0, 0xff, 0xffff, 0xffffff, 0x7fffffff],
+  'i64_list'           : [-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff],
+  'double_list'        : [0.1, 0.2, 0.3],
+  'string_list'        : ["first", "second", "third"],
+//'binary_list,'
+  'boolean_list'       : [1, 1, 1, 0, 0, 0],
+  'struct_list'        : [{}, {}],
+  'byte_set'           : [-127, -1, 0, 1, 127],
+  'i16_set'            : [-1, 0, 1, 0x7fff],
+  'i32_set'            : [1, 2, 3],
+  'i64_set'            : [-1, 0, 0xff, 0xffff, 0xffffff, 0xffffffff, 0xffffffffff, 0xffffffffffff, 0xffffffffffffff, 0x7fffffffffffffff],
+  'double_set'         : [0.1, 0.2, 0.3],
+  'string_set'         : ["first", "second", "third"],
+//'binary_set,'
+  'boolean_set'        : [1, 0],
+  'struct_set'         : [{}],
+  'byte_byte_map'      : {1 : 2},
+  'i16_byte_map'       : {1 : 1, -1 : 1, 0x7fff : 1},
+  'i32_byte_map'       : {1 : 1, -1 : 1, 0x7fffffff : 1},
+  'i64_byte_map'       : {0 : 1,  1 : 1, -1 : 1, 0x7fffffffffffffff : 1},
+  'double_byte_map'    : {-1.1 : 1, 1.1 : 1},
+  'string_byte_map'    : {"first" : 1, "second" : 2, "third" : 3, "" : 0},
+//'binary_byte_map,'
+  'boolean_byte_map'   : {1 : 1, 0 : 0},
+  'byte_i16_map'       : {1 : 1, 2 : -1, 3 : 0x7fff},
+  'byte_i32_map'       : {1 : 1, 2 : -1, 3 : 0x7fffffff},
+  'byte_i64_map'       : {1 : 1, 2 : -1, 3 : 0x7fffffffffffffff},
+  'byte_double_map'    : {1 : 0.1, 2 : -0.1, 3 : 1000000.1},
+  'byte_string_map'    : {1 : "", 2 : "blah", 3 : "loooooooooooooong string"},
+//'byte_binary_map,'
+  'byte_boolean_map'   : {1 : 1, 2 : 0},
+  'list_byte_map'      : {[1, 2, 3] : 1, [0, 1] : 2, [] : 0},
+  'set_byte_map'       : {[1, 2, 3] : 1, [0, 1] : 2, [] : 0},
+  'map_byte_map'       : {{1 : 1} : 1, {2 : 2} : 2, {} : 0},
+  'byte_map_map'       : {0 : {}, 1 : {1 : 1}, 2 : {1 : 1, 2 : 2}},
+  'byte_set_map'       : {0 : [], 1 : [1], 2 : [1, 2]},
+  'byte_list_map'      : {0 : [], 1 : [1], 2 : [1, 2]},
 }