common_tests.rb 41 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325
  1. # Defines tests which are common between proto2 and proto3 syntax.
  2. #
  3. # Requires that the proto messages are exactly the same in proto2 and proto3 syntax
  4. # and that the including class should define a 'proto_module' method which returns
  5. # the enclosing module of the proto message classes.
  6. module CommonTests
  7. def test_defaults
  8. m = proto_module::TestMessage.new
  9. assert m.optional_int32 == 0
  10. assert m.optional_int64 == 0
  11. assert m.optional_uint32 == 0
  12. assert m.optional_uint64 == 0
  13. assert m.optional_bool == false
  14. assert m.optional_float == 0.0
  15. assert m.optional_double == 0.0
  16. assert m.optional_string == ""
  17. assert m.optional_bytes == ""
  18. assert m.optional_msg == nil
  19. assert m.optional_enum == :Default
  20. end
  21. def test_setters
  22. m = proto_module::TestMessage.new
  23. m.optional_int32 = -42
  24. assert m.optional_int32 == -42
  25. m.optional_int64 = -0x1_0000_0000
  26. assert m.optional_int64 == -0x1_0000_0000
  27. m.optional_uint32 = 0x9000_0000
  28. assert m.optional_uint32 == 0x9000_0000
  29. m.optional_uint64 = 0x9000_0000_0000_0000
  30. assert m.optional_uint64 == 0x9000_0000_0000_0000
  31. m.optional_bool = true
  32. assert m.optional_bool == true
  33. m.optional_float = 0.5
  34. assert m.optional_float == 0.5
  35. m.optional_double = 0.5
  36. assert m.optional_double == 0.5
  37. m.optional_string = "hello"
  38. assert m.optional_string == "hello"
  39. m.optional_string = :hello
  40. assert m.optional_string == "hello"
  41. m.optional_bytes = "world".encode!('ASCII-8BIT')
  42. assert m.optional_bytes == "world"
  43. m.optional_msg = proto_module::TestMessage2.new(:foo => 42)
  44. assert m.optional_msg == proto_module::TestMessage2.new(:foo => 42)
  45. m.optional_msg = nil
  46. assert m.optional_msg == nil
  47. m.optional_enum = :C
  48. assert m.optional_enum == :C
  49. m.optional_enum = 'C'
  50. assert m.optional_enum == :C
  51. end
  52. def test_ctor_args
  53. m = proto_module::TestMessage.new(:optional_int32 => -42,
  54. :optional_msg => proto_module::TestMessage2.new,
  55. :optional_enum => :C,
  56. :repeated_string => ["hello", "there", "world"])
  57. assert m.optional_int32 == -42
  58. assert m.optional_msg.class == proto_module::TestMessage2
  59. assert m.repeated_string.length == 3
  60. assert m.optional_enum == :C
  61. assert m.repeated_string[0] == "hello"
  62. assert m.repeated_string[1] == "there"
  63. assert m.repeated_string[2] == "world"
  64. end
  65. def test_ctor_string_symbol_args
  66. m = proto_module::TestMessage.new(:optional_enum => 'C', :repeated_enum => ['A', 'B'])
  67. assert_equal :C, m.optional_enum
  68. assert_equal [:A, :B], m.repeated_enum
  69. m = proto_module::TestMessage.new(:optional_string => :foo, :repeated_string => [:foo, :bar])
  70. assert_equal 'foo', m.optional_string
  71. assert_equal ['foo', 'bar'], m.repeated_string
  72. end
  73. def test_ctor_nil_args
  74. m = proto_module::TestMessage.new(:optional_enum => nil, :optional_int32 => nil, :optional_string => nil, :optional_msg => nil)
  75. assert_equal :Default, m.optional_enum
  76. assert_equal 0, m.optional_int32
  77. assert_equal "", m.optional_string
  78. assert_nil m.optional_msg
  79. end
  80. def test_embeddedmsg_hash_init
  81. m = proto_module::TestEmbeddedMessageParent.new(
  82. :child_msg => {sub_child: {optional_int32: 1}},
  83. :number => 2,
  84. :repeated_msg => [{sub_child: {optional_int32: 3}}],
  85. :repeated_number => [10, 20, 30])
  86. assert_equal 2, m.number
  87. assert_equal [10, 20, 30], m.repeated_number
  88. assert_not_nil m.child_msg
  89. assert_not_nil m.child_msg.sub_child
  90. assert_equal m.child_msg.sub_child.optional_int32, 1
  91. assert_not_nil m.repeated_msg
  92. assert_equal 1, m.repeated_msg.length
  93. assert_equal 3, m.repeated_msg.first.sub_child.optional_int32
  94. end
  95. def test_inspect_eq_to_s
  96. m = proto_module::TestMessage.new(
  97. :optional_int32 => -42,
  98. :optional_enum => :A,
  99. :optional_msg => proto_module::TestMessage2.new,
  100. :repeated_string => ["hello", "there", "world"])
  101. expected = "<#{proto_module}::TestMessage: optional_int32: -42, optional_int64: 0, optional_uint32: 0, optional_uint64: 0, optional_bool: false, optional_float: 0.0, optional_double: 0.0, optional_string: \"\", optional_bytes: \"\", optional_msg: <#{proto_module}::TestMessage2: foo: 0>, optional_enum: :A, repeated_int32: [], repeated_int64: [], repeated_uint32: [], repeated_uint64: [], repeated_bool: [], repeated_float: [], repeated_double: [], repeated_string: [\"hello\", \"there\", \"world\"], repeated_bytes: [], repeated_msg: [], repeated_enum: []>"
  102. assert_equal expected, m.inspect
  103. assert_equal expected, m.to_s
  104. m = proto_module::OneofMessage.new(:b => -42)
  105. expected = "<#{proto_module}::OneofMessage: a: \"\", b: -42, c: nil, d: :Default>"
  106. assert_equal expected, m.inspect
  107. assert_equal expected, m.to_s
  108. end
  109. def test_hash
  110. m1 = proto_module::TestMessage.new(:optional_int32 => 42)
  111. m2 = proto_module::TestMessage.new(:optional_int32 => 102, repeated_string: ['please', 'work', 'ok?'])
  112. m3 = proto_module::TestMessage.new(:optional_int32 => 102, repeated_string: ['please', 'work', 'ok?'])
  113. assert m1.hash != 0
  114. assert m2.hash != 0
  115. assert m3.hash != 0
  116. # relying on the randomness here -- if hash function changes and we are
  117. # unlucky enough to get a collision, then change the values above.
  118. assert m1.hash != m2.hash
  119. assert_equal m2.hash, m3.hash
  120. end
  121. def test_unknown_field_errors
  122. e = assert_raise NoMethodError do
  123. proto_module::TestMessage.new.hello
  124. end
  125. assert_match(/hello/, e.message)
  126. e = assert_raise NoMethodError do
  127. proto_module::TestMessage.new.hello = "world"
  128. end
  129. assert_match(/hello/, e.message)
  130. end
  131. def test_type_errors
  132. m = proto_module::TestMessage.new
  133. e = assert_raise Google::Protobuf::TypeError do
  134. m.optional_int32 = "hello"
  135. end
  136. # Google::Protobuf::TypeError should inherit from TypeError for backwards compatibility
  137. # TODO: This can be removed when we can safely migrate to Google::Protobuf::TypeError
  138. assert e.is_a?(::TypeError)
  139. assert_raise Google::Protobuf::TypeError do
  140. m.optional_string = 42
  141. end
  142. assert_raise Google::Protobuf::TypeError do
  143. m.optional_string = nil
  144. end
  145. assert_raise Google::Protobuf::TypeError do
  146. m.optional_bool = 42
  147. end
  148. assert_raise Google::Protobuf::TypeError do
  149. m.optional_msg = proto_module::TestMessage.new # expects TestMessage2
  150. end
  151. assert_raise Google::Protobuf::TypeError do
  152. m.repeated_int32 = [] # needs RepeatedField
  153. end
  154. assert_raise Google::Protobuf::TypeError do
  155. m.repeated_int32.push "hello"
  156. end
  157. assert_raise Google::Protobuf::TypeError do
  158. m.repeated_msg.push proto_module::TestMessage.new
  159. end
  160. end
  161. def test_string_encoding
  162. m = proto_module::TestMessage.new
  163. # Assigning a normal (ASCII or UTF8) string to a bytes field, or
  164. # ASCII-8BIT to a string field will convert to the proper encoding.
  165. m.optional_bytes = "Test string ASCII".encode!('ASCII')
  166. assert m.optional_bytes.frozen?
  167. assert_equal Encoding::ASCII_8BIT, m.optional_bytes.encoding
  168. assert_equal "Test string ASCII", m.optional_bytes
  169. assert_raise Encoding::UndefinedConversionError do
  170. m.optional_bytes = "Test string UTF-8 \u0100".encode!('UTF-8')
  171. end
  172. assert_raise Encoding::UndefinedConversionError do
  173. m.optional_string = ["FFFF"].pack('H*')
  174. end
  175. # "Ordinary" use case.
  176. m.optional_bytes = ["FFFF"].pack('H*')
  177. m.optional_string = "\u0100"
  178. # strings are immutable so we can't do this, but serialize should catch it.
  179. m.optional_string = "asdf".encode!('UTF-8')
  180. # Ruby 2.5 changed to raise FrozenError. However, assert_raise don't
  181. # accept subclass.
  182. ok = false
  183. begin
  184. m.optional_string.encode!('ASCII-8BIT')
  185. rescue RuntimeError
  186. ok = true
  187. end
  188. assert ok
  189. end
  190. def test_rptfield_int32
  191. l = Google::Protobuf::RepeatedField.new(:int32)
  192. assert l.count == 0
  193. l = Google::Protobuf::RepeatedField.new(:int32, [1, 2, 3])
  194. assert l.count == 3
  195. assert_equal [1, 2, 3], l
  196. assert_equal l, [1, 2, 3]
  197. l.push 4
  198. assert l == [1, 2, 3, 4]
  199. dst_list = []
  200. l.each { |val| dst_list.push val }
  201. assert dst_list == [1, 2, 3, 4]
  202. assert l.to_a == [1, 2, 3, 4]
  203. assert l[0] == 1
  204. assert l[3] == 4
  205. l[0] = 5
  206. assert l == [5, 2, 3, 4]
  207. l2 = l.dup
  208. assert l == l2
  209. assert l.object_id != l2.object_id
  210. l2.push 6
  211. assert l.count == 4
  212. assert l2.count == 5
  213. assert l.inspect == '[5, 2, 3, 4]'
  214. l.concat([7, 8, 9])
  215. assert l == [5, 2, 3, 4, 7, 8, 9]
  216. assert l.pop == 9
  217. assert l == [5, 2, 3, 4, 7, 8]
  218. assert_raise Google::Protobuf::TypeError do
  219. m = proto_module::TestMessage.new
  220. l.push m
  221. end
  222. m = proto_module::TestMessage.new
  223. m.repeated_int32 = l
  224. assert m.repeated_int32 == [5, 2, 3, 4, 7, 8]
  225. assert m.repeated_int32.object_id == l.object_id
  226. l.push 42
  227. assert m.repeated_int32.pop == 42
  228. l3 = l + l.dup
  229. assert l3.count == l.count * 2
  230. l.count.times do |i|
  231. assert l3[i] == l[i]
  232. assert l3[l.count + i] == l[i]
  233. end
  234. l.clear
  235. assert l.count == 0
  236. l += [1, 2, 3, 4]
  237. l.replace([5, 6, 7, 8])
  238. assert l == [5, 6, 7, 8]
  239. l4 = Google::Protobuf::RepeatedField.new(:int32)
  240. l4[5] = 42
  241. assert l4 == [0, 0, 0, 0, 0, 42]
  242. l4 << 100
  243. assert l4 == [0, 0, 0, 0, 0, 42, 100]
  244. l4 << 101 << 102
  245. assert l4 == [0, 0, 0, 0, 0, 42, 100, 101, 102]
  246. end
  247. def test_parent_rptfield
  248. #make sure we set the RepeatedField and can add to it
  249. m = proto_module::TestMessage.new
  250. assert m.repeated_string == []
  251. m.repeated_string << 'ok'
  252. m.repeated_string.push('ok2')
  253. assert m.repeated_string == ['ok', 'ok2']
  254. m.repeated_string += ['ok3']
  255. assert m.repeated_string == ['ok', 'ok2', 'ok3']
  256. end
  257. def test_rptfield_msg
  258. l = Google::Protobuf::RepeatedField.new(:message, proto_module::TestMessage)
  259. l.push proto_module::TestMessage.new
  260. assert l.count == 1
  261. assert_raise Google::Protobuf::TypeError do
  262. l.push proto_module::TestMessage2.new
  263. end
  264. assert_raise Google::Protobuf::TypeError do
  265. l.push 42
  266. end
  267. l2 = l.dup
  268. assert l2[0] == l[0]
  269. assert l2[0].object_id == l[0].object_id
  270. l2 = Google::Protobuf.deep_copy(l)
  271. assert l2[0] == l[0]
  272. assert l2[0].object_id != l[0].object_id
  273. l3 = l + l2
  274. assert l3.count == 2
  275. assert l3[0] == l[0]
  276. assert l3[1] == l2[0]
  277. l3[0].optional_int32 = 1000
  278. assert l[0].optional_int32 == 1000
  279. new_msg = proto_module::TestMessage.new(:optional_int32 => 200)
  280. l4 = l + [new_msg]
  281. assert l4.count == 2
  282. new_msg.optional_int32 = 1000
  283. assert l4[1].optional_int32 == 1000
  284. end
  285. def test_rptfield_enum
  286. l = Google::Protobuf::RepeatedField.new(:enum, proto_module::TestEnum)
  287. l.push :A
  288. l.push :B
  289. l.push :C
  290. assert l.count == 3
  291. assert_raise RangeError do
  292. l.push :D
  293. end
  294. assert l[0] == :A
  295. l.push 4
  296. assert l[3] == 4
  297. end
  298. def test_rptfield_initialize
  299. assert_raise ArgumentError do
  300. Google::Protobuf::RepeatedField.new
  301. end
  302. assert_raise ArgumentError do
  303. Google::Protobuf::RepeatedField.new(:message)
  304. end
  305. assert_raise ArgumentError do
  306. Google::Protobuf::RepeatedField.new([1, 2, 3])
  307. end
  308. assert_raise ArgumentError do
  309. Google::Protobuf::RepeatedField.new(:message, [proto_module::TestMessage2.new])
  310. end
  311. end
  312. def test_rptfield_array_ducktyping
  313. l = Google::Protobuf::RepeatedField.new(:int32)
  314. length_methods = %w(count length size)
  315. length_methods.each do |lm|
  316. assert l.send(lm) == 0
  317. end
  318. # out of bounds returns a nil
  319. assert l[0] == nil
  320. assert l[1] == nil
  321. assert l[-1] == nil
  322. l.push 4
  323. length_methods.each do |lm|
  324. assert l.send(lm) == 1
  325. end
  326. assert l[0] == 4
  327. assert l[1] == nil
  328. assert l[-1] == 4
  329. assert l[-2] == nil
  330. l.push 2
  331. length_methods.each do |lm|
  332. assert l.send(lm) == 2
  333. end
  334. assert l[0] == 4
  335. assert l[1] == 2
  336. assert l[2] == nil
  337. assert l[-1] == 2
  338. assert l[-2] == 4
  339. assert l[-3] == nil
  340. #adding out of scope will backfill with empty objects
  341. end
  342. def test_map_basic
  343. # allowed key types:
  344. # :int32, :int64, :uint32, :uint64, :bool, :string, :bytes.
  345. m = Google::Protobuf::Map.new(:string, :int32)
  346. m["asdf"] = 1
  347. assert m["asdf"] == 1
  348. m["jkl;"] = 42
  349. assert m == { "jkl;" => 42, "asdf" => 1 }
  350. assert m.has_key?("asdf")
  351. assert !m.has_key?("qwerty")
  352. assert m.length == 2
  353. m2 = m.dup
  354. assert_equal m, m2
  355. assert m.hash != 0
  356. assert_equal m.hash, m2.hash
  357. collected = {}
  358. m.each { |k,v| collected[v] = k }
  359. assert collected == { 42 => "jkl;", 1 => "asdf" }
  360. assert m.delete("asdf") == 1
  361. assert !m.has_key?("asdf")
  362. assert m["asdf"] == nil
  363. assert !m.has_key?("asdf")
  364. # We only assert on inspect value when there is one map entry because the
  365. # order in which elements appear is unspecified (depends on the internal
  366. # hash function). We don't want a brittle test.
  367. assert m.inspect == "{\"jkl;\"=>42}"
  368. assert m.keys == ["jkl;"]
  369. assert m.values == [42]
  370. m.clear
  371. assert m.length == 0
  372. assert m == {}
  373. assert_raise TypeError do
  374. m[1] = 1
  375. end
  376. assert_raise RangeError do
  377. m["asdf"] = 0x1_0000_0000
  378. end
  379. end
  380. def test_map_ctor
  381. m = Google::Protobuf::Map.new(:string, :int32,
  382. {"a" => 1, "b" => 2, "c" => 3})
  383. assert m == {"a" => 1, "c" => 3, "b" => 2}
  384. end
  385. def test_map_keytypes
  386. m = Google::Protobuf::Map.new(:int32, :int32)
  387. m[1] = 42
  388. m[-1] = 42
  389. assert_raise RangeError do
  390. m[0x8000_0000] = 1
  391. end
  392. assert_raise Google::Protobuf::TypeError do
  393. m["asdf"] = 1
  394. end
  395. m = Google::Protobuf::Map.new(:int64, :int32)
  396. m[0x1000_0000_0000_0000] = 1
  397. assert_raise RangeError do
  398. m[0x1_0000_0000_0000_0000] = 1
  399. end
  400. assert_raise Google::Protobuf::TypeError do
  401. m["asdf"] = 1
  402. end
  403. m = Google::Protobuf::Map.new(:uint32, :int32)
  404. m[0x8000_0000] = 1
  405. assert_raise RangeError do
  406. m[0x1_0000_0000] = 1
  407. end
  408. assert_raise RangeError do
  409. m[-1] = 1
  410. end
  411. m = Google::Protobuf::Map.new(:uint64, :int32)
  412. m[0x8000_0000_0000_0000] = 1
  413. assert_raise RangeError do
  414. m[0x1_0000_0000_0000_0000] = 1
  415. end
  416. assert_raise RangeError do
  417. m[-1] = 1
  418. end
  419. m = Google::Protobuf::Map.new(:bool, :int32)
  420. m[true] = 1
  421. m[false] = 2
  422. assert_raise Google::Protobuf::TypeError do
  423. m[1] = 1
  424. end
  425. assert_raise Google::Protobuf::TypeError do
  426. m["asdf"] = 1
  427. end
  428. m = Google::Protobuf::Map.new(:string, :int32)
  429. m["asdf"] = 1
  430. assert_raise TypeError do
  431. m[1] = 1
  432. end
  433. assert_raise Encoding::UndefinedConversionError do
  434. bytestring = ["FFFF"].pack("H*")
  435. m[bytestring] = 1
  436. end
  437. m = Google::Protobuf::Map.new(:bytes, :int32)
  438. bytestring = ["FFFF"].pack("H*")
  439. m[bytestring] = 1
  440. # Allowed -- we will automatically convert to ASCII-8BIT.
  441. m["asdf"] = 1
  442. assert_raise TypeError do
  443. m[1] = 1
  444. end
  445. end
  446. def test_map_msg_enum_valuetypes
  447. m = Google::Protobuf::Map.new(:string, :message, proto_module::TestMessage)
  448. m["asdf"] = proto_module::TestMessage.new
  449. assert_raise Google::Protobuf::TypeError do
  450. m["jkl;"] = proto_module::TestMessage2.new
  451. end
  452. m = Google::Protobuf::Map.new(
  453. :string, :message, proto_module::TestMessage,
  454. { "a" => proto_module::TestMessage.new(:optional_int32 => 42),
  455. "b" => proto_module::TestMessage.new(:optional_int32 => 84) })
  456. assert m.length == 2
  457. assert m.values.map{|msg| msg.optional_int32}.sort == [42, 84]
  458. m = Google::Protobuf::Map.new(:string, :enum, proto_module::TestEnum,
  459. { "x" => :A, "y" => :B, "z" => :C })
  460. assert m.length == 3
  461. assert m["z"] == :C
  462. m["z"] = 2
  463. assert m["z"] == :B
  464. m["z"] = 4
  465. assert m["z"] == 4
  466. assert_raise RangeError do
  467. m["z"] = :Z
  468. end
  469. assert_raise RangeError do
  470. m["z"] = "z"
  471. end
  472. end
  473. def test_map_dup_deep_copy
  474. m = Google::Protobuf::Map.new(
  475. :string, :message, proto_module::TestMessage,
  476. { "a" => proto_module::TestMessage.new(:optional_int32 => 42),
  477. "b" => proto_module::TestMessage.new(:optional_int32 => 84) })
  478. m2 = m.dup
  479. assert m == m2
  480. assert m.object_id != m2.object_id
  481. assert m["a"].object_id == m2["a"].object_id
  482. assert m["b"].object_id == m2["b"].object_id
  483. m2 = Google::Protobuf.deep_copy(m)
  484. assert m == m2
  485. assert m.object_id != m2.object_id
  486. assert m["a"].object_id != m2["a"].object_id
  487. assert m["b"].object_id != m2["b"].object_id
  488. end
  489. def test_oneof_descriptors
  490. d = proto_module::OneofMessage.descriptor
  491. o = d.lookup_oneof("my_oneof")
  492. assert o != nil
  493. assert o.class == Google::Protobuf::OneofDescriptor
  494. assert o.name == "my_oneof"
  495. oneof_count = 0
  496. d.each_oneof{ |oneof|
  497. oneof_count += 1
  498. assert oneof == o
  499. }
  500. assert oneof_count == 1
  501. assert o.count == 4
  502. field_names = o.map{|f| f.name}.sort
  503. assert field_names == ["a", "b", "c", "d"]
  504. end
  505. def test_oneof
  506. d = proto_module::OneofMessage.new
  507. assert d.a == ""
  508. assert d.b == 0
  509. assert d.c == nil
  510. assert d.d == :Default
  511. assert d.my_oneof == nil
  512. d.a = "hi"
  513. assert d.a == "hi"
  514. assert d.b == 0
  515. assert d.c == nil
  516. assert d.d == :Default
  517. assert d.my_oneof == :a
  518. d.b = 42
  519. assert d.a == ""
  520. assert d.b == 42
  521. assert d.c == nil
  522. assert d.d == :Default
  523. assert d.my_oneof == :b
  524. d.c = proto_module::TestMessage2.new(:foo => 100)
  525. assert d.a == ""
  526. assert d.b == 0
  527. assert d.c.foo == 100
  528. assert d.d == :Default
  529. assert d.my_oneof == :c
  530. d.d = :C
  531. assert d.a == ""
  532. assert d.b == 0
  533. assert d.c == nil
  534. assert d.d == :C
  535. assert d.my_oneof == :d
  536. d2 = proto_module::OneofMessage.decode(proto_module::OneofMessage.encode(d))
  537. assert d2 == d
  538. encoded_field_a = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:a => "string"))
  539. encoded_field_b = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:b => 1000))
  540. encoded_field_c = proto_module::OneofMessage.encode(
  541. proto_module::OneofMessage.new(:c => proto_module::TestMessage2.new(:foo => 1)))
  542. encoded_field_d = proto_module::OneofMessage.encode(proto_module::OneofMessage.new(:d => :B))
  543. d3 = proto_module::OneofMessage.decode(
  544. encoded_field_c + encoded_field_a + encoded_field_b + encoded_field_d)
  545. assert d3.a == ""
  546. assert d3.b == 0
  547. assert d3.c == nil
  548. assert d3.d == :B
  549. d4 = proto_module::OneofMessage.decode(
  550. encoded_field_c + encoded_field_a + encoded_field_b + encoded_field_d +
  551. encoded_field_c)
  552. assert d4.a == ""
  553. assert d4.b == 0
  554. assert d4.c.foo == 1
  555. assert d4.d == :Default
  556. d5 = proto_module::OneofMessage.new(:a => "hello")
  557. assert d5.a == "hello"
  558. d5.a = nil
  559. assert d5.a == ""
  560. assert proto_module::OneofMessage.encode(d5) == ''
  561. assert d5.my_oneof == nil
  562. end
  563. def test_enum_field
  564. m = proto_module::TestMessage.new
  565. assert m.optional_enum == :Default
  566. m.optional_enum = :A
  567. assert m.optional_enum == :A
  568. assert_raise RangeError do
  569. m.optional_enum = :ASDF
  570. end
  571. m.optional_enum = 1
  572. assert m.optional_enum == :A
  573. m.optional_enum = 100
  574. assert m.optional_enum == 100
  575. end
  576. def test_dup
  577. m = proto_module::TestMessage.new
  578. m.optional_string = "hello"
  579. m.optional_int32 = 42
  580. tm1 = proto_module::TestMessage2.new(:foo => 100)
  581. tm2 = proto_module::TestMessage2.new(:foo => 200)
  582. m.repeated_msg.push tm1
  583. assert m.repeated_msg[-1] == tm1
  584. m.repeated_msg.push tm2
  585. assert m.repeated_msg[-1] == tm2
  586. m2 = m.dup
  587. assert m == m2
  588. m.optional_int32 += 1
  589. assert m != m2
  590. assert m.repeated_msg[0] == m2.repeated_msg[0]
  591. assert m.repeated_msg[0].object_id == m2.repeated_msg[0].object_id
  592. end
  593. def test_deep_copy
  594. m = proto_module::TestMessage.new(:optional_int32 => 42,
  595. :repeated_msg => [proto_module::TestMessage2.new(:foo => 100)])
  596. m2 = Google::Protobuf.deep_copy(m)
  597. assert m == m2
  598. assert m.repeated_msg == m2.repeated_msg
  599. assert m.repeated_msg.object_id != m2.repeated_msg.object_id
  600. assert m.repeated_msg[0].object_id != m2.repeated_msg[0].object_id
  601. end
  602. def test_eq
  603. m = proto_module::TestMessage.new(:optional_int32 => 42,
  604. :repeated_int32 => [1, 2, 3])
  605. m2 = proto_module::TestMessage.new(:optional_int32 => 43,
  606. :repeated_int32 => [1, 2, 3])
  607. assert m != m2
  608. end
  609. def test_enum_lookup
  610. assert proto_module::TestEnum::A == 1
  611. assert proto_module::TestEnum::B == 2
  612. assert proto_module::TestEnum::C == 3
  613. assert proto_module::TestEnum::lookup(1) == :A
  614. assert proto_module::TestEnum::lookup(2) == :B
  615. assert proto_module::TestEnum::lookup(3) == :C
  616. assert proto_module::TestEnum::resolve(:A) == 1
  617. assert proto_module::TestEnum::resolve(:B) == 2
  618. assert proto_module::TestEnum::resolve(:C) == 3
  619. end
  620. def test_enum_const_get_helpers
  621. m = proto_module::TestMessage.new
  622. assert_equal proto_module::TestEnum::Default, m.optional_enum_const
  623. assert_equal proto_module::TestEnum.const_get(:Default), m.optional_enum_const
  624. m = proto_module::TestMessage.new({optional_enum: proto_module::TestEnum::A})
  625. assert_equal proto_module::TestEnum::A, m.optional_enum_const
  626. assert_equal proto_module::TestEnum.const_get(:A), m.optional_enum_const
  627. m = proto_module::TestMessage.new({optional_enum: proto_module::TestEnum::B})
  628. assert_equal proto_module::TestEnum::B, m.optional_enum_const
  629. assert_equal proto_module::TestEnum.const_get(:B), m.optional_enum_const
  630. m = proto_module::TestMessage.new({optional_enum: proto_module::TestEnum::C})
  631. assert_equal proto_module::TestEnum::C, m.optional_enum_const
  632. assert_equal proto_module::TestEnum.const_get(:C), m.optional_enum_const
  633. m = proto_module::TestMessage2.new({foo: 2})
  634. assert_equal 2, m.foo
  635. assert_raise(NoMethodError) { m.foo_ }
  636. assert_raise(NoMethodError) { m.foo_X }
  637. assert_raise(NoMethodError) { m.foo_XX }
  638. assert_raise(NoMethodError) { m.foo_XXX }
  639. assert_raise(NoMethodError) { m.foo_XXXX }
  640. assert_raise(NoMethodError) { m.foo_XXXXX }
  641. assert_raise(NoMethodError) { m.foo_XXXXXX }
  642. m = proto_module::Enumer.new({optional_enum: :B})
  643. assert_equal :B, m.optional_enum
  644. assert_raise(NoMethodError) { m.optional_enum_ }
  645. assert_raise(NoMethodError) { m.optional_enum_X }
  646. assert_raise(NoMethodError) { m.optional_enum_XX }
  647. assert_raise(NoMethodError) { m.optional_enum_XXX }
  648. assert_raise(NoMethodError) { m.optional_enum_XXXX }
  649. assert_raise(NoMethodError) { m.optional_enum_XXXXX }
  650. assert_raise(NoMethodError) { m.optional_enum_XXXXXX }
  651. end
  652. def test_enum_getter
  653. m = proto_module::Enumer.new(:optional_enum => :B, :repeated_enum => [:A, :C])
  654. assert_equal :B, m.optional_enum
  655. assert_equal 2, m.optional_enum_const
  656. assert_equal proto_module::TestEnum::B, m.optional_enum_const
  657. assert_equal [:A, :C], m.repeated_enum
  658. assert_equal [1, 3], m.repeated_enum_const
  659. assert_equal [proto_module::TestEnum::A, proto_module::TestEnum::C], m.repeated_enum_const
  660. end
  661. def test_enum_getter_oneof
  662. m = proto_module::Enumer.new(:const => :C)
  663. assert_equal :C, m.const
  664. assert_equal 3, m.const_const
  665. assert_equal proto_module::TestEnum::C, m.const_const
  666. end
  667. def test_enum_getter_only_enums
  668. m = proto_module::Enumer.new(:optional_enum => :B, :a_const => 'thing')
  669. assert_equal 'thing', m.a_const
  670. assert_equal :B, m.optional_enum
  671. assert_raise(NoMethodError) { m.a }
  672. assert_raise(NoMethodError) { m.a_const_const }
  673. end
  674. def test_repeated_push
  675. m = proto_module::TestMessage.new
  676. m.repeated_string += ['one']
  677. m.repeated_string += %w[two three]
  678. assert_equal %w[one two three], m.repeated_string
  679. m.repeated_string.push *['four', 'five']
  680. assert_equal %w[one two three four five], m.repeated_string
  681. m.repeated_string.push 'six', 'seven'
  682. assert_equal %w[one two three four five six seven], m.repeated_string
  683. m = proto_module::TestMessage.new
  684. m.repeated_msg += [proto_module::TestMessage2.new(:foo => 1), proto_module::TestMessage2.new(:foo => 2)]
  685. m.repeated_msg += [proto_module::TestMessage2.new(:foo => 3)]
  686. m.repeated_msg.push proto_module::TestMessage2.new(:foo => 4), proto_module::TestMessage2.new(:foo => 5)
  687. assert_equal [1, 2, 3, 4, 5], m.repeated_msg.map {|x| x.foo}
  688. end
  689. def test_parse_serialize
  690. m = proto_module::TestMessage.new(:optional_int32 => 42,
  691. :optional_string => "hello world",
  692. :optional_enum => :B,
  693. :repeated_string => ["a", "b", "c"],
  694. :repeated_int32 => [42, 43, 44],
  695. :repeated_enum => [:A, :B, :C, 100],
  696. :repeated_msg => [proto_module::TestMessage2.new(:foo => 1),
  697. proto_module::TestMessage2.new(:foo => 2)])
  698. data = proto_module::TestMessage.encode m
  699. m2 = proto_module::TestMessage.decode data
  700. assert m == m2
  701. data = Google::Protobuf.encode m
  702. m2 = Google::Protobuf.decode(proto_module::TestMessage, data)
  703. assert m == m2
  704. end
  705. def test_encode_decode_helpers
  706. m = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
  707. assert_equal 'foo', m.optional_string
  708. assert_equal ['bar1', 'bar2'], m.repeated_string
  709. json = m.to_json
  710. m2 = proto_module::TestMessage.decode_json(json)
  711. assert_equal 'foo', m2.optional_string
  712. assert_equal ['bar1', 'bar2'], m2.repeated_string
  713. if RUBY_PLATFORM != "java"
  714. assert m2.optional_string.frozen?
  715. assert m2.repeated_string[0].frozen?
  716. end
  717. proto = m.to_proto
  718. m2 = proto_module::TestMessage.decode(proto)
  719. assert_equal 'foo', m2.optional_string
  720. assert_equal ['bar1', 'bar2'], m2.repeated_string
  721. end
  722. def test_protobuf_encode_decode_helpers
  723. m = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
  724. encoded_msg = Google::Protobuf.encode(m)
  725. assert_equal m.to_proto, encoded_msg
  726. decoded_msg = Google::Protobuf.decode(proto_module::TestMessage, encoded_msg)
  727. assert_equal proto_module::TestMessage.decode(m.to_proto), decoded_msg
  728. end
  729. def test_protobuf_encode_decode_json_helpers
  730. m = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
  731. encoded_msg = Google::Protobuf.encode_json(m)
  732. assert_equal m.to_json, encoded_msg
  733. decoded_msg = Google::Protobuf.decode_json(proto_module::TestMessage, encoded_msg)
  734. assert_equal proto_module::TestMessage.decode_json(m.to_json), decoded_msg
  735. end
  736. def test_def_errors
  737. s = Google::Protobuf::DescriptorPool.new
  738. assert_raise Google::Protobuf::TypeError do
  739. s.build do
  740. # enum with no default (integer value 0)
  741. add_enum "MyEnum" do
  742. value :A, 1
  743. end
  744. end
  745. end
  746. assert_raise Google::Protobuf::TypeError do
  747. s.build do
  748. # message with required field (unsupported in proto3)
  749. add_message "MyMessage" do
  750. required :foo, :int32, 1
  751. end
  752. end
  753. end
  754. end
  755. def test_corecursive
  756. # just be sure that we can instantiate types with corecursive field-type
  757. # references.
  758. m = proto_module::Recursive1.new(:foo => proto_module::Recursive2.new(:foo => proto_module::Recursive1.new))
  759. assert proto_module::Recursive1.descriptor.lookup("foo").subtype ==
  760. proto_module::Recursive2.descriptor
  761. assert proto_module::Recursive2.descriptor.lookup("foo").subtype ==
  762. proto_module::Recursive1.descriptor
  763. serialized = proto_module::Recursive1.encode(m)
  764. m2 = proto_module::Recursive1.decode(serialized)
  765. assert m == m2
  766. end
  767. def test_serialize_cycle
  768. m = proto_module::Recursive1.new(:foo => proto_module::Recursive2.new)
  769. m.foo.foo = m
  770. assert_raise RuntimeError do
  771. proto_module::Recursive1.encode(m)
  772. end
  773. end
  774. def test_bad_field_names
  775. m = proto_module::BadFieldNames.new(:dup => 1, :class => 2)
  776. m2 = m.dup
  777. assert m == m2
  778. assert m['dup'] == 1
  779. assert m['class'] == 2
  780. m['dup'] = 3
  781. assert m['dup'] == 3
  782. m['a.b'] = 4
  783. assert m['a.b'] == 4
  784. end
  785. def test_int_ranges
  786. m = proto_module::TestMessage.new
  787. m.optional_int32 = 0
  788. m.optional_int32 = -0x8000_0000
  789. m.optional_int32 = +0x7fff_ffff
  790. m.optional_int32 = 1.0
  791. m.optional_int32 = -1.0
  792. m.optional_int32 = 2e9
  793. assert_raise RangeError do
  794. m.optional_int32 = -0x8000_0001
  795. end
  796. assert_raise RangeError do
  797. m.optional_int32 = +0x8000_0000
  798. end
  799. assert_raise RangeError do
  800. m.optional_int32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
  801. end
  802. assert_raise RangeError do
  803. m.optional_int32 = 1e12
  804. end
  805. assert_raise RangeError do
  806. m.optional_int32 = 1.5
  807. end
  808. m.optional_uint32 = 0
  809. m.optional_uint32 = +0xffff_ffff
  810. m.optional_uint32 = 1.0
  811. m.optional_uint32 = 4e9
  812. assert_raise RangeError do
  813. m.optional_uint32 = -1
  814. end
  815. assert_raise RangeError do
  816. m.optional_uint32 = -1.5
  817. end
  818. assert_raise RangeError do
  819. m.optional_uint32 = -1.5e12
  820. end
  821. assert_raise RangeError do
  822. m.optional_uint32 = -0x1000_0000_0000_0000
  823. end
  824. assert_raise RangeError do
  825. m.optional_uint32 = +0x1_0000_0000
  826. end
  827. assert_raise RangeError do
  828. m.optional_uint32 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
  829. end
  830. assert_raise RangeError do
  831. m.optional_uint32 = 1e12
  832. end
  833. assert_raise RangeError do
  834. m.optional_uint32 = 1.5
  835. end
  836. m.optional_int64 = 0
  837. m.optional_int64 = -0x8000_0000_0000_0000
  838. m.optional_int64 = +0x7fff_ffff_ffff_ffff
  839. m.optional_int64 = 1.0
  840. m.optional_int64 = -1.0
  841. m.optional_int64 = 8e18
  842. m.optional_int64 = -8e18
  843. assert_raise RangeError do
  844. m.optional_int64 = -0x8000_0000_0000_0001
  845. end
  846. assert_raise RangeError do
  847. m.optional_int64 = +0x8000_0000_0000_0000
  848. end
  849. assert_raise RangeError do
  850. m.optional_int64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
  851. end
  852. assert_raise RangeError do
  853. m.optional_int64 = 1e50
  854. end
  855. assert_raise RangeError do
  856. m.optional_int64 = 1.5
  857. end
  858. m.optional_uint64 = 0
  859. m.optional_uint64 = +0xffff_ffff_ffff_ffff
  860. m.optional_uint64 = 1.0
  861. m.optional_uint64 = 16e18
  862. assert_raise RangeError do
  863. m.optional_uint64 = -1
  864. end
  865. assert_raise RangeError do
  866. m.optional_uint64 = -1.5
  867. end
  868. assert_raise RangeError do
  869. m.optional_uint64 = -1.5e12
  870. end
  871. assert_raise RangeError do
  872. m.optional_uint64 = -0x1_0000_0000_0000_0000
  873. end
  874. assert_raise RangeError do
  875. m.optional_uint64 = +0x1_0000_0000_0000_0000
  876. end
  877. assert_raise RangeError do
  878. m.optional_uint64 = +0x1000_0000_0000_0000_0000_0000 # force Bignum
  879. end
  880. assert_raise RangeError do
  881. m.optional_uint64 = 1e50
  882. end
  883. assert_raise RangeError do
  884. m.optional_uint64 = 1.5
  885. end
  886. end
  887. def test_stress_test
  888. m = proto_module::TestMessage.new
  889. m.optional_int32 = 42
  890. m.optional_int64 = 0x100000000
  891. m.optional_string = "hello world"
  892. 10.times do m.repeated_msg.push proto_module::TestMessage2.new(:foo => 42) end
  893. 10.times do m.repeated_string.push "hello world" end
  894. data = proto_module::TestMessage.encode(m)
  895. 10_000.times do
  896. m = proto_module::TestMessage.decode(data)
  897. data_new = proto_module::TestMessage.encode(m)
  898. assert data_new == data
  899. data = data_new
  900. end
  901. end
  902. def test_reflection
  903. m = proto_module::TestMessage.new(:optional_int32 => 1234)
  904. msgdef = m.class.descriptor
  905. assert msgdef.class == Google::Protobuf::Descriptor
  906. assert msgdef.any? {|field| field.name == "optional_int32"}
  907. optional_int32 = msgdef.lookup "optional_int32"
  908. assert optional_int32.class == Google::Protobuf::FieldDescriptor
  909. assert optional_int32 != nil
  910. assert optional_int32.name == "optional_int32"
  911. assert optional_int32.type == :int32
  912. optional_int32.set(m, 5678)
  913. assert m.optional_int32 == 5678
  914. m.optional_int32 = 1000
  915. assert optional_int32.get(m) == 1000
  916. optional_msg = msgdef.lookup "optional_msg"
  917. assert optional_msg.subtype == proto_module::TestMessage2.descriptor
  918. optional_msg.set(m, optional_msg.subtype.msgclass.new)
  919. assert msgdef.msgclass == proto_module::TestMessage
  920. optional_enum = msgdef.lookup "optional_enum"
  921. assert optional_enum.subtype == proto_module::TestEnum.descriptor
  922. assert optional_enum.subtype.class == Google::Protobuf::EnumDescriptor
  923. optional_enum.subtype.each do |k, v|
  924. # set with integer, check resolution to symbolic name
  925. optional_enum.set(m, v)
  926. assert optional_enum.get(m) == k
  927. end
  928. end
  929. def test_json
  930. # TODO: Fix JSON in JRuby version.
  931. return if RUBY_PLATFORM == "java"
  932. m = proto_module::TestMessage.new(:optional_int32 => 1234,
  933. :optional_int64 => -0x1_0000_0000,
  934. :optional_uint32 => 0x8000_0000,
  935. :optional_uint64 => 0xffff_ffff_ffff_ffff,
  936. :optional_bool => true,
  937. :optional_float => 1.0,
  938. :optional_double => -1e100,
  939. :optional_string => "Test string",
  940. :optional_bytes => ["FFFFFFFF"].pack('H*'),
  941. :optional_msg => proto_module::TestMessage2.new(:foo => 42),
  942. :repeated_int32 => [1, 2, 3, 4],
  943. :repeated_string => ["a", "b", "c"],
  944. :repeated_bool => [true, false, true, false],
  945. :repeated_msg => [proto_module::TestMessage2.new(:foo => 1),
  946. proto_module::TestMessage2.new(:foo => 2)])
  947. json_text = proto_module::TestMessage.encode_json(m)
  948. m2 = proto_module::TestMessage.decode_json(json_text)
  949. puts m.inspect
  950. puts m2.inspect
  951. assert m == m2
  952. # Crash case from GitHub issue 283.
  953. bar = proto_module::Bar.new(msg: "bar")
  954. baz1 = proto_module::Baz.new(msg: "baz")
  955. baz2 = proto_module::Baz.new(msg: "quux")
  956. proto_module::Foo.encode_json(proto_module::Foo.new)
  957. proto_module::Foo.encode_json(proto_module::Foo.new(bar: bar))
  958. proto_module::Foo.encode_json(proto_module::Foo.new(bar: bar, baz: [baz1, baz2]))
  959. end
  960. def test_json_empty
  961. assert proto_module::TestMessage.encode_json(proto_module::TestMessage.new) == '{}'
  962. end
  963. def test_json_emit_defaults
  964. # TODO: Fix JSON in JRuby version.
  965. return if RUBY_PLATFORM == "java"
  966. m = proto_module::TestMessage.new
  967. expected = {
  968. optionalInt32: 0,
  969. optionalInt64: 0,
  970. optionalUint32: 0,
  971. optionalUint64: 0,
  972. optionalBool: false,
  973. optionalFloat: 0,
  974. optionalDouble: 0,
  975. optionalString: "",
  976. optionalBytes: "",
  977. optionalEnum: "Default",
  978. repeatedInt32: [],
  979. repeatedInt64: [],
  980. repeatedUint32: [],
  981. repeatedUint64: [],
  982. repeatedBool: [],
  983. repeatedFloat: [],
  984. repeatedDouble: [],
  985. repeatedString: [],
  986. repeatedBytes: [],
  987. repeatedMsg: [],
  988. repeatedEnum: []
  989. }
  990. actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
  991. assert JSON.parse(actual, :symbolize_names => true) == expected
  992. end
  993. def test_json_emit_defaults_submsg
  994. # TODO: Fix JSON in JRuby version.
  995. return if RUBY_PLATFORM == "java"
  996. m = proto_module::TestMessage.new(optional_msg: proto_module::TestMessage2.new)
  997. expected = {
  998. optionalInt32: 0,
  999. optionalInt64: 0,
  1000. optionalUint32: 0,
  1001. optionalUint64: 0,
  1002. optionalBool: false,
  1003. optionalFloat: 0,
  1004. optionalDouble: 0,
  1005. optionalString: "",
  1006. optionalBytes: "",
  1007. optionalMsg: {foo: 0},
  1008. optionalEnum: "Default",
  1009. repeatedInt32: [],
  1010. repeatedInt64: [],
  1011. repeatedUint32: [],
  1012. repeatedUint64: [],
  1013. repeatedBool: [],
  1014. repeatedFloat: [],
  1015. repeatedDouble: [],
  1016. repeatedString: [],
  1017. repeatedBytes: [],
  1018. repeatedMsg: [],
  1019. repeatedEnum: []
  1020. }
  1021. actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
  1022. assert JSON.parse(actual, :symbolize_names => true) == expected
  1023. end
  1024. def test_json_emit_defaults_repeated_submsg
  1025. # TODO: Fix JSON in JRuby version.
  1026. return if RUBY_PLATFORM == "java"
  1027. m = proto_module::TestMessage.new(repeated_msg: [proto_module::TestMessage2.new])
  1028. expected = {
  1029. optionalInt32: 0,
  1030. optionalInt64: 0,
  1031. optionalUint32: 0,
  1032. optionalUint64: 0,
  1033. optionalBool: false,
  1034. optionalFloat: 0,
  1035. optionalDouble: 0,
  1036. optionalString: "",
  1037. optionalBytes: "",
  1038. optionalEnum: "Default",
  1039. repeatedInt32: [],
  1040. repeatedInt64: [],
  1041. repeatedUint32: [],
  1042. repeatedUint64: [],
  1043. repeatedBool: [],
  1044. repeatedFloat: [],
  1045. repeatedDouble: [],
  1046. repeatedString: [],
  1047. repeatedBytes: [],
  1048. repeatedMsg: [{foo: 0}],
  1049. repeatedEnum: []
  1050. }
  1051. actual = proto_module::TestMessage.encode_json(m, :emit_defaults => true)
  1052. assert JSON.parse(actual, :symbolize_names => true) == expected
  1053. end
  1054. def value_from_ruby(value)
  1055. ret = Google::Protobuf::Value.new
  1056. case value
  1057. when String
  1058. ret.string_value = value
  1059. when Google::Protobuf::Struct
  1060. ret.struct_value = value
  1061. when Hash
  1062. ret.struct_value = struct_from_ruby(value)
  1063. when Google::Protobuf::ListValue
  1064. ret.list_value = value
  1065. when Array
  1066. ret.list_value = list_from_ruby(value)
  1067. else
  1068. @log.error "Unknown type: #{value.class}"
  1069. raise Google::Protobuf::Error, "Unknown type: #{value.class}"
  1070. end
  1071. ret
  1072. end
  1073. def list_from_ruby(arr)
  1074. ret = Google::Protobuf::ListValue.new
  1075. arr.each do |v|
  1076. ret.values << value_from_ruby(v)
  1077. end
  1078. ret
  1079. end
  1080. def struct_from_ruby(hash)
  1081. ret = Google::Protobuf::Struct.new
  1082. hash.each do |k, v|
  1083. ret.fields[k] ||= value_from_ruby(v)
  1084. end
  1085. ret
  1086. end
  1087. def test_deep_json
  1088. # will not overflow
  1089. json = '{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":{"a":'\
  1090. '{"a":{"a":{"a":{"a":{}}}}}}}}}}}}}}}}'
  1091. struct = struct_from_ruby(JSON.parse(json))
  1092. assert_equal json, struct.to_json
  1093. encoded = proto_module::MyRepeatedStruct.encode(
  1094. proto_module::MyRepeatedStruct.new(structs: [proto_module::MyStruct.new(struct: struct)]))
  1095. assert_equal json, proto_module::MyRepeatedStruct.decode(encoded).structs[0].struct.to_json
  1096. # will overflow
  1097. json = '{"a":{"a":{"a":[{"a":{"a":[{"a":[{"a":{"a":[{"a":[{"a":'\
  1098. '{"a":[{"a":[{"a":{"a":{"a":[{"a":"a"}]}}}]}]}}]}]}}]}]}}]}}}'
  1099. struct = struct_from_ruby(JSON.parse(json))
  1100. assert_equal json, struct.to_json
  1101. assert_raise(RuntimeError, "Maximum recursion depth exceeded during encoding") do
  1102. proto_module::MyRepeatedStruct.encode(
  1103. proto_module::MyRepeatedStruct.new(structs: [proto_module::MyStruct.new(struct: struct)]))
  1104. end
  1105. end
  1106. def test_comparison_with_arbitrary_object
  1107. assert proto_module::TestMessage.new != nil
  1108. end
  1109. def test_freeze
  1110. m = proto_module::TestMessage.new
  1111. m.optional_int32 = 10
  1112. m.freeze
  1113. frozen_error = assert_raise(FrozenError) { m.optional_int32 = 20 }
  1114. assert_equal "can't modify frozen #{proto_module}::TestMessage", frozen_error.message
  1115. assert_equal 10, m.optional_int32
  1116. assert_equal true, m.frozen?
  1117. assert_raise(FrozenError) { m.optional_int64 = 2 }
  1118. assert_raise(FrozenError) { m.optional_uint32 = 3 }
  1119. assert_raise(FrozenError) { m.optional_uint64 = 4 }
  1120. assert_raise(FrozenError) { m.optional_bool = true }
  1121. assert_raise(FrozenError) { m.optional_float = 6.0 }
  1122. assert_raise(FrozenError) { m.optional_double = 7.0 }
  1123. assert_raise(FrozenError) { m.optional_string = '8' }
  1124. assert_raise(FrozenError) { m.optional_bytes = nil }
  1125. assert_raise(FrozenError) { m.optional_msg = proto_module::TestMessage2.new }
  1126. assert_raise(FrozenError) { m.optional_enum = :A }
  1127. assert_raise(FrozenError) { m.repeated_int32 = 1 }
  1128. assert_raise(FrozenError) { m.repeated_int64 = 2 }
  1129. assert_raise(FrozenError) { m.repeated_uint32 = 3 }
  1130. assert_raise(FrozenError) { m.repeated_uint64 = 4 }
  1131. assert_raise(FrozenError) { m.repeated_bool = true }
  1132. assert_raise(FrozenError) { m.repeated_float = 6.0 }
  1133. assert_raise(FrozenError) { m.repeated_double = 7.0 }
  1134. assert_raise(FrozenError) { m.repeated_string = '8' }
  1135. assert_raise(FrozenError) { m.repeated_bytes = nil }
  1136. assert_raise(FrozenError) { m.repeated_msg = proto_module::TestMessage2.new }
  1137. assert_raise(FrozenError) { m.repeated_enum = :A }
  1138. end
  1139. def test_eq
  1140. m1 = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
  1141. m2 = proto_module::TestMessage.new(:optional_string => 'foo', :repeated_string => ['bar1', 'bar2'])
  1142. h = {}
  1143. h[m1] = :yes
  1144. assert m1 == m2
  1145. assert m1.eql?(m2)
  1146. assert m1.hash == m2.hash
  1147. assert h[m1] == :yes
  1148. assert h[m2] == :yes
  1149. m1.optional_int32 = 2
  1150. assert m1 != m2
  1151. assert !m1.eql?(m2)
  1152. assert m1.hash != m2.hash
  1153. assert_nil h[m2]
  1154. end
  1155. end