1#!/usr/bin/ruby 2 3require 'google/protobuf' 4require 'test/unit' 5 6class RepeatedFieldTest < Test::Unit::TestCase 7 8 def test_acts_like_enumerator 9 m = TestMessage.new 10 (Enumerable.instance_methods - TestMessage.new.repeated_string.methods).each do |method_name| 11 assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}" 12 end 13 end 14 15 def test_acts_like_an_array 16 m = TestMessage.new 17 arr_methods = ([].methods - TestMessage.new.repeated_string.methods) 18 # jRuby additions to the Array class that we can ignore 19 arr_methods -= [ :indices, :iter_for_each, :iter_for_each_index, 20 :iter_for_each_with_index, :dimensions, :copy_data, :copy_data_simple, 21 :nitems, :iter_for_reverse_each, :indexes, :append, :prepend] 22 arr_methods -= [:union, :difference, :filter!] 23 arr_methods -= [:intersection, :deconstruct] # ruby 2.7 methods we can ignore 24 arr_methods -= [:intersect?] # ruby 3.1 methods we can ignore 25 arr_methods.each do |method_name| 26 assert m.repeated_string.respond_to?(method_name) == true, "does not respond to #{method_name}" 27 end 28 end 29 30 def test_first 31 m = TestMessage.new 32 repeated_field_names(TestMessage).each do |field_name| 33 assert_nil m.send(field_name).first 34 assert_equal [], m.send(field_name).first(0) 35 assert_equal [], m.send(field_name).first(1) 36 end 37 38 fill_test_msg(m) 39 assert_equal( -10, m.repeated_int32.first ) 40 assert_equal( -1_000_000, m.repeated_int64.first ) 41 assert_equal 10, m.repeated_uint32.first 42 assert_equal 1_000_000, m.repeated_uint64.first 43 assert_equal true, m.repeated_bool.first 44 assert_equal( -1.01, m.repeated_float.first.round(2) ) 45 assert_equal( -1.0000000000001, m.repeated_double.first ) 46 assert_equal 'foo', m.repeated_string.first 47 assert_equal "bar".encode!('ASCII-8BIT'), m.repeated_bytes.first 48 assert_equal TestMessage2.new(:foo => 1), m.repeated_msg.first 49 assert_equal :A, m.repeated_enum.first 50 51 err = assert_raises(ArgumentError) do 52 m.repeated_int32.first(-1) 53 end 54 assert_equal "negative array size", err.message 55 assert_equal [], m.repeated_int32.first(0) 56 assert_equal [-10], m.repeated_int32.first(1) 57 assert_equal [-10, -11], m.repeated_int32.first(2) 58 assert_equal [-10, -11], m.repeated_int32.first(3) 59 end 60 61 62 def test_last 63 m = TestMessage.new 64 repeated_field_names(TestMessage).each do |field_name| 65 assert_nil m.send(field_name).first 66 end 67 fill_test_msg(m) 68 assert_equal( -11, m.repeated_int32.last ) 69 assert_equal( -1_000_001, m.repeated_int64.last ) 70 assert_equal 11, m.repeated_uint32.last 71 assert_equal 1_000_001, m.repeated_uint64.last 72 assert_equal false, m.repeated_bool.last 73 assert_equal( -1.02, m.repeated_float.last.round(2) ) 74 assert_equal( -1.0000000000002, m.repeated_double.last ) 75 assert_equal 'bar', m.repeated_string.last 76 assert_equal "foo".encode!('ASCII-8BIT'), m.repeated_bytes.last 77 assert_equal TestMessage2.new(:foo => 2), m.repeated_msg.last 78 assert_equal :B, m.repeated_enum.last 79 80 err = assert_raises(ArgumentError) do 81 m.repeated_int32.last(-1) 82 end 83 assert_equal "negative array size", err.message 84 assert_equal [], m.repeated_int32.last(0) 85 assert_equal [-11], m.repeated_int32.last(1) 86 assert_equal [-10, -11], m.repeated_int32.last(2) 87 assert_equal [-10, -11], m.repeated_int32.last(3) 88 end 89 90 91 def test_pop 92 m = TestMessage.new 93 repeated_field_names(TestMessage).each do |field_name| 94 assert_nil m.send(field_name).pop 95 end 96 fill_test_msg(m) 97 98 assert_equal( -11, m.repeated_int32.pop ) 99 assert_equal( -10, m.repeated_int32.pop ) 100 assert_equal( -1_000_001, m.repeated_int64.pop ) 101 assert_equal( -1_000_000, m.repeated_int64.pop ) 102 assert_equal 11, m.repeated_uint32.pop 103 assert_equal 10, m.repeated_uint32.pop 104 assert_equal 1_000_001, m.repeated_uint64.pop 105 assert_equal 1_000_000, m.repeated_uint64.pop 106 assert_equal false, m.repeated_bool.pop 107 assert_equal true, m.repeated_bool.pop 108 assert_equal( -1.02, m.repeated_float.pop.round(2) ) 109 assert_equal( -1.01, m.repeated_float.pop.round(2) ) 110 assert_equal( -1.0000000000002, m.repeated_double.pop ) 111 assert_equal( -1.0000000000001, m.repeated_double.pop ) 112 assert_equal 'bar', m.repeated_string.pop 113 assert_equal 'foo', m.repeated_string.pop 114 assert_equal "foo".encode!('ASCII-8BIT'), m.repeated_bytes.pop 115 assert_equal "bar".encode!('ASCII-8BIT'), m.repeated_bytes.pop 116 assert_equal TestMessage2.new(:foo => 2), m.repeated_msg.pop 117 assert_equal TestMessage2.new(:foo => 1), m.repeated_msg.pop 118 assert_equal :B, m.repeated_enum.pop 119 assert_equal :A, m.repeated_enum.pop 120 repeated_field_names(TestMessage).each do |field_name| 121 assert_nil m.send(field_name).pop 122 end 123 124 fill_test_msg(m) 125 assert_equal ['bar', 'foo'], m.repeated_string.pop(2) 126 assert_nil m.repeated_string.pop 127 end 128 129 130 def test_each 131 m = TestMessage.new 132 5.times{|i| m.repeated_string << 'string' } 133 count = 0 134 m.repeated_string.each do |val| 135 assert_equal 'string', val 136 count += 1 137 end 138 assert_equal 5, count 139 result = m.repeated_string.each{|val| val + '_junk'} 140 assert_equal ['string'] * 5, result 141 end 142 143 144 def test_empty? 145 m = TestMessage.new 146 assert_equal true, m.repeated_string.empty? 147 m.repeated_string << 'foo' 148 assert_equal false, m.repeated_string.empty? 149 m.repeated_string << 'bar' 150 assert_equal false, m.repeated_string.empty? 151 end 152 153 def test_reassign 154 m = TestMessage.new 155 m.repeated_msg = Google::Protobuf::RepeatedField.new(:message, TestMessage2, [TestMessage2.new(:foo => 1)]) 156 assert_equal m.repeated_msg.first, TestMessage2.new(:foo => 1) 157 end 158 159 def test_array_accessor 160 m = TestMessage.new 161 reference_arr = %w(foo bar baz) 162 m.repeated_string += reference_arr.clone 163 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 164 arr[1] 165 end 166 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 167 arr[-2] 168 end 169 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 170 arr[20] 171 end 172 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 173 arr[1, 2] 174 end 175 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 176 arr[0..2] 177 end 178 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 179 arr[0..5] 180 end 181 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 182 arr[0..-1] 183 end 184 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 185 arr[0..-3] 186 end 187 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 188 arr[0...-1] # Exclusive range 189 end 190 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 191 arr[0...-3] # Exclusive range 192 end 193 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 194 arr[-2..-1] 195 end 196 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 197 arr[-5..-1] 198 end 199 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 200 # Infinite range; introduce in Ruby 2.7. 201 if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7') 202 eval "arr[0..]" 203 end 204 end 205 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 206 # Beginless range; introduced in Ruby 2.7. 207 if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7') 208 eval "arr[..-1]" 209 end 210 end 211 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 212 # Infinite range; introduce in Ruby 2.7. 213 if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7') 214 eval "arr[0...]" # Exclusive range 215 end 216 end 217 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 218 # Beginless range; introduced in Ruby 2.7. 219 if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7') 220 eval "arr[...-1]" # Exclusive range 221 end 222 end 223 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 224 arr[-1, 1] 225 end 226 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 227 arr[10, 12] 228 end 229 end 230 231 def test_array_settor 232 m = TestMessage.new 233 reference_arr = %w(foo bar baz) 234 m.repeated_string += reference_arr.clone 235 236 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 237 arr[1] = 'junk' 238 end 239 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 240 arr[-2] = 'snappy' 241 end 242 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 243 arr[3] = '' 244 end 245 # slight deviation; we are strongly typed, and nil is not allowed 246 # for string types; 247 m.repeated_string[5] = 'spacious' 248 assert_equal ["foo", "snappy", "baz", "", "", "spacious"], m.repeated_string 249 250 #make sure it sests the default types for other fields besides strings 251 %w(repeated_int32 repeated_int64 repeated_uint32 repeated_uint64).each do |field_name| 252 m.send(field_name)[3] = 10 253 assert_equal [0,0,0,10], m.send(field_name) 254 end 255 m.repeated_float[3] = 10.1 256 #wonky mri float handling 257 assert_equal [0,0,0], m.repeated_float.to_a[0..2] 258 assert_equal 10.1, m.repeated_float[3].round(1) 259 m.repeated_double[3] = 10.1 260 assert_equal [0,0,0,10.1], m.repeated_double 261 m.repeated_bool[3] = true 262 assert_equal [false, false, false, true], m.repeated_bool 263 m.repeated_bytes[3] = "bar".encode!('ASCII-8BIT') 264 assert_equal ['', '', '', "bar".encode!('ASCII-8BIT')], m.repeated_bytes 265 m.repeated_msg[3] = TestMessage2.new(:foo => 1) 266 assert_equal [nil, nil, nil, TestMessage2.new(:foo => 1)], m.repeated_msg 267 m.repeated_enum[3] = :A 268 assert_equal [:Default, :Default, :Default, :A], m.repeated_enum 269 270 # check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 271 # arr[20] = 'spacious' 272 # end 273 # TODO: accessor doesn't allow other ruby-like methods 274 # check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 275 # arr[1, 2] = 'fizz' 276 # end 277 # check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 278 # arr[0..2] = 'buzz' 279 # end 280 end 281 282 def test_push 283 m = TestMessage.new 284 reference_arr = %w[foo bar baz] 285 m.repeated_string += reference_arr.clone 286 287 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 288 arr.push('fizz') 289 end 290 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 291 arr << 'fizz' 292 end 293 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 294 arr.push('fizz', 'buzz') 295 end 296 end 297 298 def test_clear 299 m = TestMessage.new 300 reference_arr = %w(foo bar baz) 301 m.repeated_string += reference_arr.clone 302 303 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 304 arr.clear 305 end 306 end 307 308 def test_concat 309 m = TestMessage.new 310 reference_arr = %w(foo bar baz) 311 m.repeated_string += reference_arr.clone 312 m.repeated_string.concat(['fizz', 'buzz']) 313 assert_equal %w(foo bar baz fizz buzz), m.repeated_string 314 #TODO: concat should return the orig array 315 # check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 316 # arr.concat(['fizz', 'buzz']) 317 # end 318 end 319 320 def test_equal 321 m = TestMessage.new 322 reference_arr = %w(foo bar baz) 323 m.repeated_string += reference_arr.clone 324 assert_equal reference_arr, m.repeated_string 325 reference_arr << 'fizz' 326 assert_not_equal reference_arr, m.repeated_string 327 m.repeated_string << 'fizz' 328 assert_equal reference_arr, m.repeated_string 329 end 330 331 def test_hash 332 # just a sanity check 333 m = TestMessage.new 334 reference_arr = %w(foo bar baz) 335 m.repeated_string += reference_arr.clone 336 assert m.repeated_string.hash.is_a?(Integer) 337 hash = m.repeated_string.hash 338 assert_equal hash, m.repeated_string.hash 339 m.repeated_string << 'j' 340 assert_not_equal hash, m.repeated_string.hash 341 end 342 343 def test_plus 344 m = TestMessage.new 345 reference_arr = %w(foo bar baz) 346 m.repeated_string += reference_arr.clone 347 348 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 349 arr + ['fizz', 'buzz'] 350 end 351 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 352 arr += ['fizz', 'buzz'] 353 end 354 end 355 356 def test_replace 357 m = TestMessage.new 358 reference_arr = %w(foo bar baz) 359 m.repeated_string += reference_arr.clone 360 361 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 362 arr.replace(['fizz', 'buzz']) 363 end 364 end 365 366 def test_to_a 367 m = TestMessage.new 368 reference_arr = %w(foo bar baz) 369 m.repeated_string += reference_arr.clone 370 371 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 372 arr.to_a 373 end 374 end 375 376 def test_to_ary 377 m = TestMessage.new 378 reference_arr = %w(foo bar baz) 379 m.repeated_string += reference_arr.clone 380 381 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 382 arr.to_ary 383 end 384 end 385 386 # emulate Array behavior 387 ########################## 388 389 def test_collect! 390 m = TestMessage.new 391 reference_arr = %w(foo bar baz) 392 m.repeated_string += reference_arr.clone 393 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 394 arr.collect!{|x| x + "!" } 395 end 396 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 397 arr.collect!.with_index{|x, i| x[0...i] } 398 end 399 end 400 401 def test_delete 402 m = TestMessage.new 403 reference_arr = %w(foo bar baz) 404 m.repeated_string += reference_arr.clone 405 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 406 arr.delete('bar') 407 end 408 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 409 arr.delete('nope') 410 end 411 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 412 arr.delete('nope'){'within'} 413 end 414 end 415 416 def test_delete_at 417 m = TestMessage.new 418 reference_arr = %w(foo bar baz) 419 m.repeated_string += reference_arr.clone 420 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 421 arr.delete_at(2) 422 end 423 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 424 arr.delete_at(10) 425 end 426 end 427 428 def test_delete_if 429 m = TestMessage.new 430 reference_arr = %w(foo bar baz) 431 m.repeated_string += reference_arr.clone 432 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 433 arr.delete_if { |v| v == "bar" } 434 end 435 end 436 437 def test_fill 438 m = TestMessage.new 439 reference_arr = %w(foo bar baz) 440 m.repeated_string += reference_arr.clone 441 442 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 443 arr.fill("x") 444 end 445 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 446 arr.fill("z", 2, 2) 447 end 448 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 449 arr.fill("y", 0..1) 450 end 451 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 452 arr.fill { |i| (i*i).to_s } 453 end 454 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 455 arr.fill(-2) { |i| (i*i*i).to_s } 456 end 457 end 458 459 def test_flatten! 460 m = TestMessage.new 461 reference_arr = %w(foo bar baz) 462 m.repeated_string += reference_arr.clone 463 464 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 465 arr.flatten! 466 end 467 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 468 arr.flatten!(1) 469 end 470 end 471 472 def test_insert 473 m = TestMessage.new 474 reference_arr = %w(foo bar baz) 475 m.repeated_string += reference_arr.clone 476 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 477 arr.insert(2, 'fizz') 478 end 479 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 480 arr.insert(3, 'fizz', 'buzz', 'bazz') 481 end 482 end 483 484 def test_inspect 485 m = TestMessage.new 486 assert_equal '[]', m.repeated_string.inspect 487 m.repeated_string << 'foo' 488 assert_equal m.repeated_string.to_a.inspect, m.repeated_string.inspect 489 m.repeated_string << 'bar' 490 assert_equal m.repeated_string.to_a.inspect, m.repeated_string.inspect 491 end 492 493 def test_reverse! 494 m = TestMessage.new 495 reference_arr = %w(foo bar baz) 496 m.repeated_string += reference_arr.clone 497 498 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 499 arr.reverse! 500 end 501 end 502 503 def test_rotate! 504 m = TestMessage.new 505 reference_arr = %w(foo bar baz) 506 m.repeated_string += reference_arr.clone 507 508 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 509 arr.rotate! 510 end 511 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 512 arr.rotate!(2) 513 end 514 end 515 516 def test_select! 517 m = TestMessage.new 518 reference_arr = %w(foo bar baz) 519 m.repeated_string += reference_arr.clone 520 521 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 522 arr.select! { |v| v =~ /[aeiou]/ } 523 end 524 end 525 526 def test_shift 527 m = TestMessage.new 528 reference_arr = %w(foo bar baz) 529 m.repeated_string += reference_arr.clone 530 531 # should return an element 532 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 533 arr.shift 534 end 535 # should return an array 536 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 537 arr.shift(2) 538 end 539 # should return nil 540 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 541 arr.shift 542 end 543 end 544 545 def test_shuffle! 546 m = TestMessage.new 547 m.repeated_string += %w(foo bar baz) 548 result = m.repeated_string.shuffle! 549 assert_equal m.repeated_string, result 550 end 551 552 def test_slice! 553 m = TestMessage.new 554 reference_arr = %w(foo bar baz bar fizz buzz) 555 m.repeated_string += reference_arr.clone 556 557 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 558 arr.slice!(2) 559 end 560 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 561 arr.slice!(1,2) 562 end 563 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 564 arr.slice!(0..1) 565 end 566 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 567 arr.slice!(10) 568 end 569 end 570 571 def test_sort! 572 m = TestMessage.new 573 reference_arr = %w(foo bar baz) 574 m.repeated_string += reference_arr.clone 575 576 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 577 arr.sort! 578 end 579 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 580 arr.sort! { |x,y| y <=> x } 581 end 582 end 583 584 def test_sort_by! 585 m = TestMessage.new 586 reference_arr = %w(foo bar baz) 587 m.repeated_string += reference_arr.clone 588 589 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 590 arr.sort_by! 591 end 592 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 593 arr.sort_by!(&:hash) 594 end 595 end 596 597 def test_uniq! 598 m = TestMessage.new 599 reference_arr = %w(foo bar baz) 600 m.repeated_string += reference_arr.clone 601 602 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 603 arr.uniq! 604 end 605 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 606 arr.uniq!{|s| s[0] } 607 end 608 end 609 610 def test_unshift 611 m = TestMessage.new 612 reference_arr = %w(foo bar baz) 613 m.repeated_string += reference_arr.clone 614 615 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 616 arr.unshift('1') 617 end 618 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 619 arr.unshift('a', 'b') 620 end 621 check_self_modifying_method(m.repeated_string, reference_arr) do |arr| 622 arr.unshift('') 623 end 624 end 625 626 627 ##### HELPER METHODS 628 629 def check_self_modifying_method(repeated_field, ref_array) 630 expected_result = yield(ref_array) 631 actual_result = yield(repeated_field) 632 if expected_result.is_a?(Enumerator) 633 assert_equal expected_result.to_a, actual_result.to_a 634 else 635 assert_equal expected_result, actual_result 636 end 637 assert_equal ref_array, repeated_field 638 end 639 640 641 def repeated_field_names(klass) 642 klass.descriptor.find_all{|f| f.label == :repeated}.map(&:name) 643 end 644 645 646 def fill_test_msg(test_msg) 647 test_msg.repeated_int32 += [-10, -11] 648 test_msg.repeated_int64 += [-1_000_000, -1_000_001] 649 test_msg.repeated_uint32 += [10, 11] 650 test_msg.repeated_uint64 += [1_000_000, 1_000_001] 651 test_msg.repeated_bool += [true, false] 652 test_msg.repeated_float += [-1.01, -1.02] 653 test_msg.repeated_double += [-1.0000000000001, -1.0000000000002] 654 test_msg.repeated_string += %w(foo bar) 655 test_msg.repeated_bytes += ["bar".encode!('ASCII-8BIT'), "foo".encode!('ASCII-8BIT')] 656 test_msg.repeated_msg << TestMessage2.new(:foo => 1) 657 test_msg.repeated_msg << TestMessage2.new(:foo => 2) 658 test_msg.repeated_enum << :A 659 test_msg.repeated_enum << :B 660 end 661 662 663 pool = Google::Protobuf::DescriptorPool.new 664 pool.build do 665 666 add_message "TestMessage" do 667 optional :optional_int32, :int32, 1 668 optional :optional_int64, :int64, 2 669 optional :optional_uint32, :uint32, 3 670 optional :optional_uint64, :uint64, 4 671 optional :optional_bool, :bool, 5 672 optional :optional_float, :float, 6 673 optional :optional_double, :double, 7 674 optional :optional_string, :string, 8 675 optional :optional_bytes, :bytes, 9 676 optional :optional_msg, :message, 10, "TestMessage2" 677 optional :optional_enum, :enum, 11, "TestEnum" 678 679 repeated :repeated_int32, :int32, 12 680 repeated :repeated_int64, :int64, 13 681 repeated :repeated_uint32, :uint32, 14 682 repeated :repeated_uint64, :uint64, 15 683 repeated :repeated_bool, :bool, 16 684 repeated :repeated_float, :float, 17 685 repeated :repeated_double, :double, 18 686 repeated :repeated_string, :string, 19 687 repeated :repeated_bytes, :bytes, 20 688 repeated :repeated_msg, :message, 21, "TestMessage2" 689 repeated :repeated_enum, :enum, 22, "TestEnum" 690 end 691 add_message "TestMessage2" do 692 optional :foo, :int32, 1 693 end 694 695 add_enum "TestEnum" do 696 value :Default, 0 697 value :A, 1 698 value :B, 2 699 value :C, 3 700 value :v0, 4 701 end 702 end 703 704 TestMessage = pool.lookup("TestMessage").msgclass 705 TestMessage2 = pool.lookup("TestMessage2").msgclass 706 TestEnum = pool.lookup("TestEnum").enummodule 707 708 709end 710