third-party/mruby/mrbgems/mruby-bin-debugger/bintest/print.rb

   1 require 'open3'
   2 require 'tempfile'
   3
   4 class BinTest_MrubyBinDebugger
   5   @debug1=false
   6   @debug2=true
   7   def self.test(rubysource, testcase)
   8     script, bin = Tempfile.new(['test', '.rb']), Tempfile.new(['test', '.mrb'])
   9
  10     # .rb
  11     script.write rubysource
  12     script.flush
  13
  14     # compile
  15     `./bin/mrbc -g -o "#{bin.path}" "#{script.path}"`
  16
  17     # add mrdb quit
  18     testcase << {:cmd=>"quit"}
  19
  20     stdin_data = testcase.map{|t| t[:cmd]}.join("\n") << "\n"
  21
  22     ["bin/mrdb #{script.path}","bin/mrdb -b #{bin.path}"].each do |cmd|
  23       o, s = Open3.capture2(cmd, :stdin_data => stdin_data)
  24
  25       exp_vals = testcase.map{|t| t.fetch(:exp, nil)}
  26 =begin
  27 if @debug1
  28   o.split("\n").each_with_index do |i,actual|
  29     p [i,actual]
  30   end
  31 end
  32       # compare actual / expected
  33       o.split("\n").each do |actual|
  34         next if actual.empty?
  35         exp = exp_vals.shift
  36 if @debug2
  37   a = true
  38   a = actual.include?(exp) unless exp.nil?
  39   p [actual, exp] unless a
  40 end
  41         assert_true actual.include?(exp) unless exp.nil?
  42       end
  43 =end
  44       idx = 0
  45       exp_vals.each do |exp|
  46         next if exp.nil?
  47         idx = o.index(exp, idx)
  48         assert_false idx.nil?
  49         break unless idx
  50         idx += 1
  51       end
  52     end
  53   end
  54 end
  55
  56 assert('mruby-bin-debugger(print) invalid arguments') do
  57   # ruby source
  58   src =  "foo = 'foo'\n"
  59
  60   # test case
  61   tc = []
  62   tc << {:cmd=>"p",   :exp=>"Parameter not specified."}
  63
  64   BinTest_MrubyBinDebugger.test(src, tc)
  65 end
  66
  67 assert('mruby-bin-debugger(print) nomal') do
  68   # ruby source
  69   src = <<"SRC"
  70 foo = 'foo'
  71 bar = foo
  72 baz = bar
  73 SRC
  74
  75   # test case
  76   tc = []
  77   tc << {:cmd=>"s"}
  78   tc << {:cmd=>"p (1+2)",   :exp=>'$1 = 3'}
  79   tc << {:cmd=>"p foo",     :exp=>'$2 = "foo"'}
  80   tc << {:cmd=>"p foo*=2",  :exp=>'$3 = "foofoo"'}
  81   tc << {:cmd=>"s"}
  82   tc << {:cmd=>"p bar",     :exp=>'$4 = "foofoo"'}
  83
  84   BinTest_MrubyBinDebugger.test(src, tc)
  85 end
  86
  87 assert('mruby-bin-debugger(print) error') do
  88   # ruby source
  89   src =  "foo = 'foo'\n"
  90
  91   # test case
  92   tc = []
  93   tc << {:cmd=>"p (1+2",  :exp=>'$1 = SyntaxError'}
  94   tc << {:cmd=>"p bar",   :exp=>'$2 = (eval):2: undefined method'}
  95
  96   BinTest_MrubyBinDebugger.test(src, tc)
  97 end
  98
  99 # Kernel#instance_eval(string) does't work multiple statements.
 100 =begin
 101 assert('mruby-bin-debugger(print) multiple statements') do
 102   # ruby source
 103   src = <<"SRC"
 104 x = 0
 105 y = 0
 106 z = 0
 107 SRC
 108
 109   # test case
 110   tc = []
 111   tc << {:cmd=>"s",}
 112   tc << {:cmd=>"p x=1;x+=2",  :exp=>"3"}
 113   tc << {:cmd=>"s",}
 114   tc << {:cmd=>"p x",         :exp=>"3"}
 115
 116   BinTest_MrubyBinDebugger.test(src, tc)
 117 end
 118 =end
 119
 120 assert('mruby-bin-debugger(print) scope:top') do
 121   # ruby source (bp is break point)
 122   src = "bp=nil\n"
 123
 124   # test case
 125   tc = []
 126   tc << {:cmd=>"p self",  :exp=>'$1 = main'}
 127
 128   BinTest_MrubyBinDebugger.test(src, tc)
 129 end
 130
 131 assert('mruby-bin-debugger(print) scope:class') do
 132   # ruby source (bp is break point)
 133   src = <<"SRC"
 134 class TestClassScope
 135   bp = nil
 136 end
 137 SRC
 138
 139   # test case
 140   tc = []
 141   tc << {:cmd=>"s"}
 142   tc << {:cmd=>"p self",  :exp=>'$1 = TestClassScope'}
 143
 144   BinTest_MrubyBinDebugger.test(src, tc)
 145 end
 146
 147 assert('mruby-bin-debugger(print) scope:module') do
 148   # ruby source (bp is break point)
 149   src = <<"SRC"
 150 class TestModuleScope
 151   bp = nil
 152 end
 153 SRC
 154
 155   # test case
 156   tc = []
 157   tc << {:cmd=>"s"}
 158   tc << {:cmd=>"p self",  :exp=>'$1 = TestModuleScope'}
 159
 160   BinTest_MrubyBinDebugger.test(src, tc)
 161 end
 162
 163 assert('mruby-bin-debugger(print) scope:instance method') do
 164   # ruby source (bp is break point)
 165   src = <<"SRC"
 166 class TestMethodScope
 167   def m
 168     bp = nil
 169   end
 170 end
 171 TestMethodScope.new.m
 172 SRC
 173
 174   tc = []
 175   tc << {:cmd=>"b 3"}
 176   tc << {:cmd=>"r"}
 177   tc << {:cmd=>"p self",  :exp=>'$1 = #<TestMethodScope:'}
 178
 179   BinTest_MrubyBinDebugger.test(src, tc)
 180 end
 181
 182 assert('mruby-bin-debugger(print) scope:class method') do
 183   # ruby source (bp is break point)
 184   src = <<"SRC"
 185 class TestClassMethodScope
 186   def self.cm
 187     bp = nil
 188   end
 189 end
 190 TestClassMethodScope.cm
 191 SRC
 192
 193   tc = []
 194   tc << {:cmd=>"b 3"}
 195   tc << {:cmd=>"r"}
 196   tc << {:cmd=>"p self",  :exp=>'$1 = TestClassMethodScope'}
 197
 198   BinTest_MrubyBinDebugger.test(src, tc)
 199 end
 200
 201 assert('mruby-bin-debugger(print) scope:block') do
 202   # ruby source (bp is break point)
 203   src = <<"SRC"
 204 1.times do
 205   bp = nil
 206 end
 207 class TestBlockScope
 208   1.times do
 209     bp = nil
 210   end
 211   def m
 212     1.times do
 213       bp = nil
 214     end
 215   end
 216 end
 217 TestBlockScope.new.m
 218 SRC
 219
 220   tc = []
 221   tc << {:cmd=>"b 2"}
 222   tc << {:cmd=>"b 6"}
 223   tc << {:cmd=>"b 10"}
 224   tc << {:cmd=>"c"}
 225   tc << {:cmd=>"p self", :exp=>'$1 = main'}
 226   tc << {:cmd=>"c"}
 227   tc << {:cmd=>"p self", :exp=>'$2 = TestBlockScope'}
 228   tc << {:cmd=>"c"}
 229   tc << {:cmd=>"p self", :exp=>'$3 = #<TestBlockScope:'}
 230
 231   BinTest_MrubyBinDebugger.test(src, tc)
 232 end
 233
 234 assert('mruby-bin-debugger(print) same name:local variabe') do
 235   # ruby source (bp is break point)
 236   src = <<"SRC"
 237 lv = 'top'
 238 class TestLocalVariableName
 239   lv = 'class'
 240   def m
 241     lv = 'instance method'
 242     bp = nil
 243   end
 244   bp = nil
 245 end
 246 TestLocalVariableName.new.m
 247 bp = nil
 248 SRC
 249
 250   tc = []
 251   tc << {:cmd=>"b 6"}
 252   tc << {:cmd=>"b 8"}
 253   tc << {:cmd=>"b 11"}
 254   tc << {:cmd=>"r"}
 255   tc << {:cmd=>"p lv", :exp=>'$1 = "class"'}
 256   tc << {:cmd=>"c"}
 257   tc << {:cmd=>"p lv", :exp=>'$2 = "instance method"'}
 258   tc << {:cmd=>"c"}
 259   tc << {:cmd=>"p lv", :exp=>'$3 = "top"'}
 260
 261   BinTest_MrubyBinDebugger.test(src, tc)
 262 end
 263
 264 assert('mruby-bin-debugger(print) same name:instance variabe') do
 265   # ruby source (bp is break point)
 266   src = <<"SRC"
 267 @iv = 'top'
 268 class TestInstanceVariableName
 269   def initialize(v)
 270     @iv = v
 271   end
 272   def m
 273     bp = nil
 274   end
 275 end
 276 i1 = TestInstanceVariableName.new('instance1')
 277 i2 = TestInstanceVariableName.new('instance2')
 278 i1.m
 279 i2.m
 280 bp = nil
 281 SRC
 282
 283   tc = []
 284   tc << {:cmd=>"b 7"}
 285   tc << {:cmd=>"b 14"}
 286   tc << {:cmd=>"r"}
 287   tc << {:cmd=>"p @iv", :exp=>'$1 = "instance1"'}
 288   tc << {:cmd=>"c"}
 289   tc << {:cmd=>"p @iv", :exp=>'$2 = "instance2"'}
 290   tc << {:cmd=>"c"}
 291   tc << {:cmd=>"p @iv", :exp=>'$3 = "top"'}
 292
 293   BinTest_MrubyBinDebugger.test(src, tc)
 294 end
 295
 296 # Kernel#instance_eval(string) does't work const.
 297 =begin
 298 assert('mruby-bin-debugger(print) same name:const') do
 299   # ruby source (bp is break point)
 300   src = <<"SRC"
 301 CONST='top'
 302 class TestConstNameSuperClass
 303   CONST='super class'
 304   def m
 305     bp = nil
 306   end
 307 end
 308 class TestConstNameSubClass < TestConstNameSuperClass
 309   CONST='sub class'
 310   def m
 311     bp = nil
 312   end
 313 end
 314
 315 TestConstNameSuperClass.new.m()
 316 TestConstNameSubClass.new.m()
 317 bp = nil
 318 SRC
 319
 320   # todo: wait for 'break' to be implemented
 321   tc = []
 322   9.times { tc << {:cmd=>"s"} }
 323   tc << {:cmd=>"p CONST", :exp=>"super class"}
 324   3.times { tc << {:cmd=>"s"} }
 325   tc << {:cmd=>"p CONST", :exp=>"sub class"}
 326   1.times { tc << {:cmd=>"s"} }
 327   tc << {:cmd=>"p CONST", :exp=>"top"}
 328
 329   BinTest_MrubyBinDebugger.test(src, tc)
 330 end
 331 =end
 332
 333 assert('mruby-bin-debugger(print) Literal:Numeric') do
 334   # ruby source
 335   src =  "foo = 'foo'\n"
 336
 337   # test case
 338   tc = []
 339   tc << {:cmd=>"p 100",     :exp=>'$1 = 100'}
 340   tc << {:cmd=>"p -0b100",  :exp=>'$2 = -4'}
 341   tc << {:cmd=>"p +0100",   :exp=>'$3 = 64'}
 342   tc << {:cmd=>"p 0x100",   :exp=>'$4 = 256'}
 343   tc << {:cmd=>"p 1_234",   :exp=>'$5 = 1234'}
 344   tc << {:cmd=>"p 0b1000_0000", :exp=>"$6 = #{0b1000_0000}"}
 345   tc << {:cmd=>"p 0x1000_0000", :exp=>"$7 = #{0x1000_0000}"}
 346
 347   tc << {:cmd=>"p 3.14",    :exp=>'$8 = 3.14'}
 348   tc << {:cmd=>"p -12.3",   :exp=>'$9 = -12.3'}
 349   tc << {:cmd=>"p +12.000", :exp=>'$10 = 12'}
 350   tc << {:cmd=>"p 1e4",     :exp=>'$11 = 10000'}
 351   tc << {:cmd=>"p -0.1e-2", :exp=>'$12 = -0.001'}
 352
 353   BinTest_MrubyBinDebugger.test(src, tc)
 354 end
 355
 356 assert('mruby-bin-debugger(print) Literal:String') do
 357   # ruby source
 358   src = <<"SRC"
 359 foo = 'foo'
 360 bar = "bar"
 361 baz = "baz"
 362 SRC
 363
 364   # test case
 365   tc = []
 366   tc << {:cmd=>"s"}
 367   tc << {:cmd=>"s"}
 368
 369   tc << {:cmd=>'p "str"',        :exp=>'$1 = "str"'}
 370   tc << {:cmd=>'p "s\tt\rr\n"',  :exp=>'$2 = "s\\tt\\rr\\n"'}
 371   tc << {:cmd=>'p "\C-a\C-z"',   :exp=>'$3 = "\\x01\\x1a"'}
 372   tc << {:cmd=>'p "#{foo+bar}"', :exp=>'$4 = "foobar"'}
 373
 374   tc << {:cmd=>'p \'str\'',          :exp=>'$5 = "str"'}
 375   tc << {:cmd=>'p \'s\\tt\\rr\\n\'', :exp=>'$6 = "s\\\\tt\\\\rr\\\\n"'}
 376   tc << {:cmd=>'p \'\\C-a\\C-z\'',   :exp=>'$7 = "\\\\C-a\\\\C-z"'}
 377   tc << {:cmd=>'p \'#{foo+bar}\'',   :exp=>'$8 = "\\#{foo+bar}"'}
 378
 379   tc << {:cmd=>'p %!str!',        :exp=>'$9 = "str"'}
 380   tc << {:cmd=>'p %!s\tt\rr\n!',  :exp=>'$10 = "s\\tt\\rr\\n"'}
 381   tc << {:cmd=>'p %!\C-a\C-z!',   :exp=>'$11 = "\\x01\\x1a"'}
 382   tc << {:cmd=>'p %!#{foo+bar}!', :exp=>'$12 = "foobar"'}
 383
 384   tc << {:cmd=>'p %Q!str!',        :exp=>'$13 = "str"'}
 385   tc << {:cmd=>'p %Q!s\tt\rr\n!',  :exp=>'$14 = "s\\tt\\rr\\n"'}
 386   tc << {:cmd=>'p %Q!\C-a\C-z!',   :exp=>'$15 = "\\x01\\x1a"'}
 387   tc << {:cmd=>'p %Q!#{foo+bar}!', :exp=>'$16 = "foobar"'}
 388
 389   tc << {:cmd=>'p %q!str!',          :exp=>'$17 = "str"'}
 390   tc << {:cmd=>'p %q!s\\tt\\rr\\n!', :exp=>'$18 = "s\\\\tt\\\\rr\\\\n"'}
 391   tc << {:cmd=>'p %q!\\C-a\\C-z!',   :exp=>'$19 = "\\\\C-a\\\\C-z"'}
 392   tc << {:cmd=>'p %q!#{foo+bar}!',   :exp=>'$20 = "\\#{foo+bar}"'}
 393
 394   BinTest_MrubyBinDebugger.test(src, tc)
 395 end
 396
 397 assert('mruby-bin-debugger(print) Literal:Array') do
 398   # ruby source
 399   src = <<"SRC"
 400 foo = 'foo'
 401 bar = "bar"
 402 baz = "baz"
 403 SRC
 404
 405   # test case
 406   tc = []
 407   tc << {:cmd=>"s"}
 408   tc << {:cmd=>"s"}
 409
 410   tc << {:cmd=>'p []',                      :exp=>'$1 = []'}
 411   tc << {:cmd=>'p [ 5,  12,   8,    10, ]', :exp=>'$2 = [5, 12, 8, 10]'}
 412   tc << {:cmd=>'p [1,2.5,"#{foo+bar}"]',    :exp=>'$3 = [1, 2.5, "foobar"]'}
 413   tc << {:cmd=>'p %w[3.14 A\ &\ B #{foo}]', :exp=>'$4 = ["3.14", "A & B", "\#{foo}"]'}
 414   tc << {:cmd=>'p %W[3.14 A\ &\ B #{foo}]', :exp=>'$5 = ["3.14", "A & B", "foo"]'}
 415
 416   BinTest_MrubyBinDebugger.test(src, tc)
 417 end
 418
 419 assert('mruby-bin-debugger(print) Literal:Hash') do
 420   # ruby source
 421   src = <<"SRC"
 422 foo = 'foo'
 423 bar = "bar"
 424 baz = "baz"
 425 SRC
 426
 427   # test case
 428   tc = []
 429   tc << {:cmd=>"s"}
 430   tc << {:cmd=>"s"}
 431
 432   tc << {:cmd=>'p {}',                              :exp=>'$1 = {}'}
 433   tc << {:cmd=>'p {"one"=>1,"two"=>2}',             :exp=>'$2 = {"one"=>1, "two"=>2}'}
 434   tc << {:cmd=>'p {:eins=>"1",   :zwei=>"2", }',    :exp=>'$3 = {:eins=>"1", :zwei=>"2"}'}
 435   tc << {:cmd=>'p {uno:"one", dos: 2}',             :exp=>'$4 = {:uno=>"one", :dos=>2}'}
 436   tc << {:cmd=>'p {"one"=>1, :zwei=>2, tres:3}',    :exp=>'$5 = {"one"=>1, :zwei=>2, :tres=>3}'}
 437   tc << {:cmd=>'p {:foo=>"#{foo}",:bar=>"#{bar}"}', :exp=>'$6 = {:foo=>"foo", :bar=>"bar"}'}
 438
 439   BinTest_MrubyBinDebugger.test(src, tc)
 440 end
 441
 442 assert('mruby-bin-debugger(print) Literal:Range') do
 443   # ruby source
 444   src = "foo = 'foo'\n"
 445
 446   # test case
 447   tc = []
 448   tc << {:cmd=>'p 1..10',    :exp=>'$1 = 1..10'}
 449   tc << {:cmd=>'p 1...10',   :exp=>'$2 = 1...10'}
 450   tc << {:cmd=>'p 100..10',  :exp=>'$3 = 100..10'}
 451   tc << {:cmd=>'p 1 ... 10', :exp=>'$4 = 1...10'}
 452
 453   tc << {:cmd=>'p "1" .. "9"',  :exp=>'$5 = "1".."9"'}
 454   tc << {:cmd=>'p "A" ... "Z"', :exp=>'$6 = "A"..."Z"'}
 455
 456   BinTest_MrubyBinDebugger.test(src, tc)
 457 end
 458
 459 assert('mruby-bin-debugger(print) Literal:Symbol') do
 460   # ruby source
 461   src = <<"SRC"
 462 foo = 'foo'
 463 bar = "bar"
 464 baz = "baz"
 465 SRC
 466
 467   # test case
 468   tc = []
 469   tc << {:cmd=>"s"}
 470   tc << {:cmd=>"s"}
 471
 472   tc << {:cmd=>'p :sym',          :exp=>'$1 = :sym'}
 473   tc << {:cmd=>'p :"sd"',         :exp=>'$2 = :sd'}
 474   tc << {:cmd=>"p :'ss'",         :exp=>'$3 = :ss'}
 475   tc << {:cmd=>'p :"123"',        :exp=>'$4 = :"123"'}
 476   tc << {:cmd=>'p :"#{foo} baz"', :exp=>'$5 = :"foo baz"'}
 477   tc << {:cmd=>'p %s!symsym!',    :exp=>'$6 = :symsym'}
 478
 479   BinTest_MrubyBinDebugger.test(src, tc)
 480 end
 481
 482 assert('mruby-bin-debugger(print) Unary operation') do
 483   # ruby source
 484   src = "foo = 'foo'\n"
 485
 486   # test case
 487   tc = []
 488   tc << {:cmd=>'p +10',    :exp=>'$1 = 10'}
 489   tc << {:cmd=>'p -100',   :exp=>'$2 = -100'}
 490   tc << {:cmd=>'p !true',  :exp=>'$3 = false'}
 491   tc << {:cmd=>'p !false', :exp=>'$4 = true'}
 492   tc << {:cmd=>'p !nil',   :exp=>'$5 = true'}
 493   tc << {:cmd=>'p !1',     :exp=>'$6 = false'}
 494
 495   BinTest_MrubyBinDebugger.test(src, tc)
 496 end
 497
 498 assert('mruby-bin-debugger(print) Binary operation') do
 499   # ruby source
 500   src = <<"SRC"
 501 CONST = 100
 502 a,b,c = 1, 5, 8
 503 foo,bar,baz = 'foo','bar','baz'
 504 ary = []
 505 SRC
 506
 507   # test case
 508   tc = []
 509   tc << {:cmd=>'s'}
 510   tc << {:cmd=>'s'}
 511   tc << {:cmd=>'s'}
 512
 513   tc << {:cmd=>'p a+1',   :exp=>'$1 = 2'}
 514   tc << {:cmd=>'p 2-b',   :exp=>'$2 = -3'}
 515   tc << {:cmd=>'p c * 3', :exp=>'$3 = 24'}
 516   tc << {:cmd=>'p a/b',   :exp=>'$4 = 0.2'}
 517   tc << {:cmd=>'p c%b',   :exp=>'$5 = 3'}
 518   tc << {:cmd=>'p 2**10', :exp=>'$6 = 1024'}
 519   tc << {:cmd=>'p ~3',    :exp=>'$7 = -4'}
 520
 521   tc << {:cmd=>'p 1<<2',  :exp=>'$8 = 4'}
 522   tc << {:cmd=>'p 64>>5', :exp=>'$9 = 2'}
 523
 524   tc << {:cmd=>'p a|c',   :exp=>'$10 = 9'}
 525   tc << {:cmd=>'p a&b',   :exp=>'$11 = 1'}
 526   tc << {:cmd=>'p a^b',   :exp=>'$12 = 4'}
 527
 528   tc << {:cmd=>'p a>b',   :exp=>'$13 = false'}
 529   tc << {:cmd=>'p a<b',   :exp=>'$14 = true'}
 530   tc << {:cmd=>'p b>=5',  :exp=>'$15 = true'}
 531   tc << {:cmd=>'p b<=5',  :exp=>'$16 = true'}
 532
 533   tc << {:cmd=>'p "A"<=>"B"', :exp=>'$17 = -1'}
 534   tc << {:cmd=>'p "A"=="B"',  :exp=>'$18 = false'}
 535   tc << {:cmd=>'p "A"==="B"', :exp=>'$19 = false'}
 536   tc << {:cmd=>'p "A"!="B"',  :exp=>'$20 = true'}
 537
 538   tc << {:cmd=>'p false || true', :exp=>'$21 = true'}
 539   tc << {:cmd=>'p false && true', :exp=>'$22 = false'}
 540
 541   tc << {:cmd=>'p not nil',        :exp=>'$23 = true'}
 542   tc << {:cmd=>'p false or true',  :exp=>'$24 = true'}
 543   tc << {:cmd=>'p false and true', :exp=>'$25 = false'}
 544
 545   BinTest_MrubyBinDebugger.test(src, tc)
 546 end
 547
 548 assert('mruby-bin-debugger(print) Ternary operation') do
 549   # ruby source
 550   src = <<"SRC"
 551 CONST = 100
 552 a,b,c = 1, 5, -10
 553 foo,bar,baz = 'foo','bar','baz'
 554 ary = []
 555 SRC
 556
 557   # test case
 558   tc = []
 559   tc << {:cmd=>'s'}
 560   tc << {:cmd=>'s'}
 561   tc << {:cmd=>'s'}
 562
 563   tc << {:cmd=>'p (a < b) ? a : b',          :exp=>'$1 = 1'}
 564   tc << {:cmd=>'p (a > b) ? a : b',          :exp=>'$2 = 5'}
 565   tc << {:cmd=>'p true ? "true" : "false"',  :exp=>'$3 = "true"'}
 566   tc << {:cmd=>'p false ? "true" : "false"', :exp=>'$4 = "false"'}
 567   tc << {:cmd=>'p nil ? "true" : "false"',   :exp=>'$5 = "false"'}
 568
 569   BinTest_MrubyBinDebugger.test(src, tc)
 570 end
 571
 572 assert('mruby-bin-debugger(print) Substitution:simple') do
 573   # ruby source
 574   src = <<"SRC"
 575 CONST = 100
 576 a,b,c = 1, 5, -10
 577 foo,bar,baz = 'foo','bar','baz'
 578 ary = []
 579 SRC
 580
 581   # test case
 582   tc = []
 583   tc << {:cmd=>'s'}
 584   tc << {:cmd=>'s'}
 585   tc << {:cmd=>'s'}
 586
 587   tc << {:cmd=>'p a=2',               :exp=>'$1 = 2'}
 588   tc << {:cmd=>'p foo=[foo,bar,baz]', :exp=>'$2 = ["foo", "bar", "baz"]'}
 589
 590   tc << {:cmd=>'p undefined=-1',      :exp=>'$3 = -1'}
 591   tc << {:cmd=>'p "#{undefined}"',    :exp=>'$4 = (eval):2: undefined method'}
 592
 593   BinTest_MrubyBinDebugger.test(src, tc)
 594 end
 595
 596 assert('mruby-bin-debugger(print) Substitution:self') do
 597   # ruby source
 598   src = <<"SRC"
 599 CONST = 100
 600 a,b,c = 1, 5, -10
 601 foo,bar,baz = 'foo','bar','baz'
 602 ary = []
 603 SRC
 604
 605   # test case
 606   tc = []
 607   tc << {:cmd=>'s'}
 608   tc << {:cmd=>'s'}
 609   tc << {:cmd=>'s'}
 610
 611   tc << {:cmd=>'p a+=9',   :exp=>'$1 = 10'}
 612   tc << {:cmd=>'p b-=c',   :exp=>'$2 = 15'}
 613   tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
 614   tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2.5'}
 615   tc << {:cmd=>'p c%=4',   :exp=>'$5 = 2'}
 616
 617   tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
 618   tc << {:cmd=>'p c|=0x10',   :exp=>'$7 = 18'}
 619
 620   tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2.5 5 18"'}
 621   tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
 622
 623   tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
 624   tc << {:cmd=>'p [a,b,c]',         :exp=>'$11 = [10, 20, 30]'}
 625   tc << {:cmd=>'p a,b=b,a',         :exp=>'$12 = [20, 10]'}
 626   tc << {:cmd=>'p [a,b]',           :exp=>'$13 = [20, 10]'}
 627
 628   tc << {:cmd=>'p undefined=-1',    :exp=>'$14 = -1'}
 629   tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = (eval):2: undefined method'}
 630
 631   BinTest_MrubyBinDebugger.test(src, tc)
 632 end
 633
 634 assert('mruby-bin-debugger(print) Substitution:multiple') do
 635   # ruby source
 636   src = <<"SRC"
 637 CONST = 100
 638 a,b,c = 1, 5, -10
 639 foo,bar,baz = 'foo','bar','baz'
 640 ary = []
 641 SRC
 642
 643   # test case
 644   tc = []
 645   tc << {:cmd=>'s'}
 646   tc << {:cmd=>'s'}
 647   tc << {:cmd=>'s'}
 648
 649   tc << {:cmd=>'p a,b=[10,20]',   :exp=>'$1 = [10, 20]'}
 650   tc << {:cmd=>'p [a,b,c]',       :exp=>'$2 = [10, 20, -10]'}
 651
 652   tc << {:cmd=>'p foo,bar=["FOO","BAR","BAZ"]', :exp=>'$3 = ["FOO", "BAR", "BAZ"]'}
 653   tc << {:cmd=>'p [foo,bar,baz]', :exp=>'$4 = ["FOO", "BAR", "baz"]'}
 654
 655   tc << {:cmd=>'p a,foo=foo,a',   :exp=>'$5 = ["FOO", 10]'}
 656   tc << {:cmd=>'p [a,foo]',       :exp=>'$6 = ["FOO", 10]'}
 657
 658 #  tc << {:cmd=>'p a,*b=[123, 456, 789]'}
 659 #  tc << {:cmd=>'p [a,b]',       :exp=>'[123, [456, 789]]'}
 660
 661   BinTest_MrubyBinDebugger.test(src, tc)
 662 end
 663
 664 assert('mruby-bin-debugger(print) Substitution:self') do
 665   # ruby source
 666   src = <<"SRC"
 667 CONST = 100
 668 a,b,c = 1, 5, -10
 669 foo,bar,baz = 'foo','bar','baz'
 670 ary = []
 671 SRC
 672
 673   # test case
 674   tc = []
 675   tc << {:cmd=>'s'}
 676   tc << {:cmd=>'s'}
 677   tc << {:cmd=>'s'}
 678
 679   tc << {:cmd=>'p a+=9',   :exp=>'$1 = 10'}
 680   tc << {:cmd=>'p b-=c',   :exp=>'$2 = 15'}
 681   tc << {:cmd=>'p bar*=2', :exp=>'$3 = "barbar"'}
 682   tc << {:cmd=>'p a/=4',   :exp=>'$4 = 2.5'}
 683   tc << {:cmd=>'p c%=4',   :exp=>'$5 = 2'}
 684
 685   tc << {:cmd=>'p b&=0b0101', :exp=>'$6 = 5'}
 686   tc << {:cmd=>'p c|=0x10',   :exp=>'$7 = 18'}
 687
 688   tc << {:cmd=>'p "#{a} #{b} #{c}"',     :exp=>'$8 = "2.5 5 18"'}
 689   tc << {:cmd=>'p "#{foo}#{bar}#{baz}"', :exp=>'$9 = "foobarbarbaz"'}
 690
 691   tc << {:cmd=>'p a,b,c=[10,20,30]',:exp=>'$10 = [10, 20, 30]'}
 692   tc << {:cmd=>'p [a,b,c]',         :exp=>'$11 = [10, 20, 30]'}
 693   tc << {:cmd=>'p a,b=b,a',         :exp=>'$12 = [20, 10]'}
 694   tc << {:cmd=>'p [a,b]',           :exp=>'$13 = [20, 10]'}
 695
 696   tc << {:cmd=>'p undefined=-1',    :exp=>'$14 = -1'}
 697   tc << {:cmd=>'p "#{undefined}"',  :exp=>'$15 = (eval):2: undefined method'}
 698
 699   BinTest_MrubyBinDebugger.test(src, tc)
 700 end
 701