]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
1 | # encoding: UTF-8 |
2 | # | |
3 | # Licensed to the Apache Software Foundation (ASF) under one | |
4 | # or more contributor license agreements. See the NOTICE file | |
5 | # distributed with this work for additional information | |
6 | # regarding copyright ownership. The ASF licenses this file | |
7 | # to you under the Apache License, Version 2.0 (the | |
8 | # "License"); you may not use this file except in compliance | |
9 | # with the License. You may obtain a copy of the License at | |
10 | # | |
11 | # http://www.apache.org/licenses/LICENSE-2.0 | |
12 | # | |
13 | # Unless required by applicable law or agreed to in writing, | |
14 | # software distributed under the License is distributed on an | |
15 | # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
16 | # KIND, either express or implied. See the License for the | |
17 | # specific language governing permissions and limitations | |
18 | # under the License. | |
19 | # | |
20 | ||
21 | require 'spec_helper' | |
22 | ||
23 | describe Thrift::CompactProtocol do | |
24 | TESTS = { | |
25 | :byte => (-127..127).to_a, | |
26 | :i16 => (0..14).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort, | |
27 | :i32 => (0..30).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort, | |
28 | :i64 => (0..62).map {|shift| [1 << shift, -(1 << shift)]}.flatten.sort, | |
29 | :string => ["", "1", "short", "fourteen123456", "fifteen12345678", "unicode characters: \u20AC \u20AD", "1" * 127, "1" * 3000], | |
30 | :binary => ["", "\001", "\001" * 5, "\001" * 14, "\001" * 15, "\001" * 127, "\001" * 3000], | |
31 | :double => [0.0, 1.0, -1.0, 1.1, -1.1, 10000000.1, 1.0/0.0, -1.0/0.0], | |
32 | :bool => [true, false] | |
33 | } | |
34 | ||
35 | it "should encode and decode naked primitives correctly" do | |
36 | TESTS.each_pair do |primitive_type, test_values| | |
37 | test_values.each do |value| | |
38 | # puts "testing #{value}" if primitive_type == :i64 | |
39 | trans = Thrift::MemoryBufferTransport.new | |
40 | proto = Thrift::CompactProtocol.new(trans) | |
41 | ||
42 | proto.send(writer(primitive_type), value) | |
43 | # puts "buf: #{trans.inspect_buffer}" if primitive_type == :i64 | |
44 | read_back = proto.send(reader(primitive_type)) | |
45 | expect(read_back).to eq(value) | |
46 | end | |
47 | end | |
48 | end | |
49 | ||
50 | it "should encode and decode primitives in fields correctly" do | |
51 | TESTS.each_pair do |primitive_type, test_values| | |
52 | final_primitive_type = primitive_type == :binary ? :string : primitive_type | |
53 | thrift_type = Thrift::Types.const_get(final_primitive_type.to_s.upcase) | |
54 | # puts primitive_type | |
55 | test_values.each do |value| | |
56 | trans = Thrift::MemoryBufferTransport.new | |
57 | proto = Thrift::CompactProtocol.new(trans) | |
58 | ||
59 | proto.write_field_begin(nil, thrift_type, 15) | |
60 | proto.send(writer(primitive_type), value) | |
61 | proto.write_field_end | |
62 | ||
63 | proto = Thrift::CompactProtocol.new(trans) | |
64 | name, type, id = proto.read_field_begin | |
65 | expect(type).to eq(thrift_type) | |
66 | expect(id).to eq(15) | |
67 | read_back = proto.send(reader(primitive_type)) | |
68 | expect(read_back).to eq(value) | |
69 | proto.read_field_end | |
70 | end | |
71 | end | |
72 | end | |
73 | ||
74 | it "should encode and decode a monster struct correctly" do | |
75 | trans = Thrift::MemoryBufferTransport.new | |
76 | proto = Thrift::CompactProtocol.new(trans) | |
77 | ||
78 | struct = Thrift::Test::CompactProtoTestStruct.new | |
79 | # sets and maps don't hash well... not sure what to do here. | |
80 | struct.write(proto) | |
81 | ||
82 | struct2 = Thrift::Test::CompactProtoTestStruct.new | |
83 | struct2.read(proto) | |
84 | expect(struct2).to eq(struct) | |
85 | end | |
86 | ||
87 | it "should make method calls correctly" do | |
88 | client_out_trans = Thrift::MemoryBufferTransport.new | |
89 | client_out_proto = Thrift::CompactProtocol.new(client_out_trans) | |
90 | ||
91 | client_in_trans = Thrift::MemoryBufferTransport.new | |
92 | client_in_proto = Thrift::CompactProtocol.new(client_in_trans) | |
93 | ||
94 | processor = Thrift::Test::Srv::Processor.new(JankyHandler.new) | |
95 | ||
96 | client = Thrift::Test::Srv::Client.new(client_in_proto, client_out_proto) | |
97 | client.send_Janky(1) | |
98 | # puts client_out_trans.inspect_buffer | |
99 | processor.process(client_out_proto, client_in_proto) | |
100 | expect(client.recv_Janky).to eq(2) | |
101 | end | |
102 | ||
103 | it "should deal with fields following fields that have non-delta ids" do | |
104 | brcp = Thrift::Test::BreaksRubyCompactProtocol.new( | |
105 | :field1 => "blah", | |
106 | :field2 => Thrift::Test::BigFieldIdStruct.new( | |
107 | :field1 => "string1", | |
108 | :field2 => "string2"), | |
109 | :field3 => 3) | |
110 | ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new) | |
111 | bytes = ser.serialize(brcp) | |
112 | ||
113 | deser = Thrift::Deserializer.new(Thrift::CompactProtocolFactory.new) | |
114 | brcp2 = Thrift::Test::BreaksRubyCompactProtocol.new | |
115 | deser.deserialize(brcp2, bytes) | |
116 | expect(brcp2).to eq(brcp) | |
117 | end | |
118 | ||
119 | it "should deserialize an empty map to an empty hash" do | |
120 | struct = Thrift::Test::SingleMapTestStruct.new(:i32_map => {}) | |
121 | ser = Thrift::Serializer.new(Thrift::CompactProtocolFactory.new) | |
122 | bytes = ser.serialize(struct) | |
123 | ||
124 | deser = Thrift::Deserializer.new(Thrift::CompactProtocolFactory.new) | |
125 | struct2 = Thrift::Test::SingleMapTestStruct.new | |
126 | deser.deserialize(struct2, bytes) | |
127 | expect(struct).to eq(struct2) | |
128 | end | |
129 | ||
130 | it "should provide a reasonable to_s" do | |
131 | trans = Thrift::MemoryBufferTransport.new | |
132 | expect(Thrift::CompactProtocol.new(trans).to_s).to eq("compact(memory)") | |
133 | end | |
134 | ||
135 | class JankyHandler | |
136 | def Janky(i32arg) | |
137 | i32arg * 2 | |
138 | end | |
139 | end | |
140 | ||
141 | def writer(sym) | |
142 | "write_#{sym.to_s}" | |
143 | end | |
144 | ||
145 | def reader(sym) | |
146 | "read_#{sym.to_s}" | |
147 | end | |
148 | end | |
149 | ||
150 | describe Thrift::CompactProtocolFactory do | |
151 | it "should create a CompactProtocol" do | |
152 | expect(Thrift::CompactProtocolFactory.new.get_protocol(double("MockTransport"))).to be_instance_of(Thrift::CompactProtocol) | |
153 | end | |
154 | ||
155 | it "should provide a reasonable to_s" do | |
156 | expect(Thrift::CompactProtocolFactory.new.to_s).to eq("compact") | |
157 | end | |
158 | end |