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

diff --git a/lib/java/test/org/apache/thrift/test/Fixtures.java b/lib/java/test/org/apache/thrift/test/Fixtures.java
index 9882d4e..14ac44f 100644 (file)
--- a/lib/java/test/org/apache/thrift/test/Fixtures.java
+++ b/lib/java/test/org/apache/thrift/test/Fixtures.java
@@ -117,11 +117,11 @@ public class Fixtures {
       holyMoley.bonks.put("poe", stage2);
       
       // superhuge compact proto test struct
-      compactProtoTestStruct = new CompactProtoTestStruct();
+      compactProtoTestStruct = new CompactProtoTestStruct(thrift.test.Constants.COMPACT_TEST);
       compactProtoTestStruct.a_binary = new byte[]{0,1,2,3,4,5,6,7,8};
     } catch (Exception e) {
       throw new RuntimeException(e);
     }
   }
   
-}
\ No newline at end of file
+}

diff --git a/test/DebugProtoTest.thrift b/test/DebugProtoTest.thrift
index fb4ce07..12c4613 100644 (file)
--- 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]},
 }