ceph/src/boost/tools/build/test/debugger.py

   1 #!/usr/bin/python
   2
   3 # Copyright 2016 Steven Watanabe
   4 # Distributed under the Boost Software License, Version 1.0.
   5 # (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
   6
   7 # Test for the debugger
   8
   9 import BoostBuild
  10 import TestCmd
  11 import re
  12
  13 def split_stdin_stdout(text):
  14     """stdin is all text after the prompt up to and including
  15     the next newline.  Everything else is stdout.  stdout
  16     may contain regular expressions enclosed in {{}}."""
  17     prompt = re.escape('(b2db) ')
  18     pattern = re.compile('(?<=%s)(.*\n)' % prompt)
  19     text = text.replace("{{bjam}}", "{{.*}}bjam{{(?:\\.exe)?}}")
  20     stdin = ''.join(re.findall(pattern, text))
  21     stdout = re.sub(pattern, '', text)
  22     outside_pattern = re.compile(r'(?:\A|(?<=\}\}))(?:[^\{]|(?:\{(?!\{)))*(?:(?=\{\{)|\Z)')
  23
  24     def escape_line(line):
  25         line = re.sub(outside_pattern, lambda m: re.escape(m.group(0)), line)
  26         return re.sub(r'\{\{|\}\}', '', line)
  27
  28     stdout = '\n'.join([escape_line(line) for line in stdout.split('\n')])
  29     return (stdin,stdout)
  30
  31 def run(tester, io):
  32     (input,output) = split_stdin_stdout(io)
  33     tester.run_build_system(stdin=input, stdout=output, match=TestCmd.match_re)
  34
  35 def make_tester():
  36     return BoostBuild.Tester(["-dconsole"], pass_toolset=False, pass_d0=False,
  37         use_test_config=False, ignore_toolset_requirements=False, match=TestCmd.match_re)
  38
  39 def test_run():
  40     t = make_tester()
  41     t.write("test.jam", """\
  42         UPDATE ;
  43     """)
  44
  45     run(t, """\
  46 (b2db) run -ftest.jam
  47 Starting program: {{bjam}} -ftest.jam
  48 Child {{\d+}} exited with status 0
  49 (b2db) quit
  50 """)
  51
  52     t.cleanup()
  53
  54 def test_exit_status():
  55     t = make_tester()
  56     t.write("test.jam", """\
  57         EXIT : 1 ;
  58     """)
  59     run(t, """\
  60 (b2db) run -ftest.jam
  61 Starting program: {{bjam}} -ftest.jam
  62
  63 Child {{\d+}} exited with status 1
  64 (b2db) quit
  65 """)
  66     t.cleanup()
  67
  68 def test_step():
  69     t = make_tester()
  70     t.write("test.jam", """\
  71         rule g ( )
  72         {
  73             a = 1 ;
  74             b = 2 ;
  75         }
  76         rule f ( )
  77         {
  78             g ;
  79             c = 3 ;
  80         }
  81         f ;
  82     """)
  83     run(t, """\
  84 (b2db) break f
  85 Breakpoint 1 set at f
  86 (b2db) run -ftest.jam
  87 Starting program: {{bjam}} -ftest.jam
  88 Breakpoint 1, f ( ) at test.jam:8
  89 8                   g ;
  90 (b2db) step
  91 3                   a = 1 ;
  92 (b2db) step
  93 4                   b = 2 ;
  94 (b2db) step
  95 9                   c = 3 ;
  96 (b2db) quit
  97 """)
  98     t.cleanup()
  99
 100 def test_next():
 101     t = make_tester()
 102     t.write("test.jam", """\
 103         rule g ( )
 104         {
 105             a = 1 ;
 106         }
 107         rule f ( )
 108         {
 109             g ;
 110             b = 2 ;
 111             c = 3 ;
 112         }
 113         rule h ( )
 114         {
 115             f ;
 116             g ;
 117         }
 118         h ;
 119         d = 4 ;
 120     """)
 121     run(t, """\
 122 (b2db) break f
 123 Breakpoint 1 set at f
 124 (b2db) run -ftest.jam
 125 Starting program: {{bjam}} -ftest.jam
 126 Breakpoint 1, f ( ) at test.jam:7
 127 7                   g ;
 128 (b2db) next
 129 8                   b = 2 ;
 130 (b2db) next
 131 9                   c = 3 ;
 132 (b2db) next
 133 14                  g ;
 134 (b2db) next
 135 17              d = 4 ;
 136 (b2db) quit
 137 """)
 138     t.cleanup()
 139
 140 def test_finish():
 141     t = make_tester()
 142     t.write("test.jam", """\
 143         rule f ( )
 144         {
 145             a = 1 ;
 146         }
 147         rule g ( )
 148         {
 149             f ;
 150             b = 2 ;
 151             i ;
 152         }
 153         rule h ( )
 154         {
 155             g ;
 156             i ;
 157         }
 158         rule i ( )
 159         {
 160             c = 3 ;
 161         }
 162         h ;
 163         d = 4 ;
 164     """)
 165     run(t, """\
 166 (b2db) break f
 167 Breakpoint 1 set at f
 168 (b2db) run -ftest.jam
 169 Starting program: {{bjam}} -ftest.jam
 170 Breakpoint 1, f ( ) at test.jam:3
 171 3                   a = 1 ;
 172 (b2db) finish
 173 8                   b = 2 ;
 174 (b2db) finish
 175 14                  i ;
 176 (b2db) finish
 177 21              d = 4 ;
 178 (b2db) quit
 179 """)
 180     t.cleanup()
 181
 182 def test_breakpoints():
 183     """Tests the interaction between the following commands:
 184     break, clear, delete, disable, enable"""
 185     t = make_tester()
 186     t.write("test.jam", """\
 187         rule f ( )
 188         {
 189             a = 1 ;
 190         }
 191         rule g ( )
 192         {
 193             b = 2 ;
 194         }
 195         rule h ( )
 196         {
 197             c = 3 ;
 198             d = 4 ;
 199         }
 200         f ;
 201         g ;
 202         h ;
 203         UPDATE ;
 204     """)
 205     run(t, """\
 206 (b2db) break f
 207 Breakpoint 1 set at f
 208 (b2db) run -ftest.jam
 209 Starting program: {{bjam}} -ftest.jam
 210 Breakpoint 1, f ( ) at test.jam:3
 211 3                   a = 1 ;
 212 (b2db) kill
 213 (b2db) break g
 214 Breakpoint 2 set at g
 215 (b2db) disable 1
 216 (b2db) run -ftest.jam
 217 Starting program: {{bjam}} -ftest.jam
 218 Breakpoint 2, g ( ) at test.jam:7
 219 7                   b = 2 ;
 220 (b2db) kill
 221 (b2db) enable 1
 222 (b2db) run -ftest.jam
 223 Starting program: {{bjam}} -ftest.jam
 224 Breakpoint 1, f ( ) at test.jam:3
 225 3                   a = 1 ;
 226 (b2db) kill
 227 (b2db) delete 1
 228 (b2db) run -ftest.jam
 229 Starting program: {{bjam}} -ftest.jam
 230 Breakpoint 2, g ( ) at test.jam:7
 231 7                   b = 2 ;
 232 (b2db) kill
 233 (b2db) break test.jam:12
 234 Breakpoint 3 set at test.jam:12
 235 (b2db) clear g
 236 Deleted breakpoint 2
 237 (b2db) run -ftest.jam
 238 Starting program: {{bjam}} -ftest.jam
 239 Breakpoint 3, h ( ) at test.jam:12
 240 12                  d = 4 ;
 241 (b2db) kill
 242 (b2db) clear test.jam:12
 243 Deleted breakpoint 3
 244 (b2db) run -ftest.jam
 245 Starting program: {{bjam}} -ftest.jam
 246 Child {{\d+}} exited with status 0
 247 (b2db) quit
 248 """)
 249     t.cleanup()
 250
 251 def test_breakpoints_running():
 252     """Tests that breakpoints can be added and modified
 253     while the program is running."""
 254     t = make_tester()
 255     t.write("test.jam", """\
 256         rule f ( )
 257         {
 258             a = 1 ;
 259         }
 260         rule g ( )
 261         {
 262             b = 2 ;
 263         }
 264         rule h ( )
 265         {
 266             c = 3 ;
 267             d = 4 ;
 268         }
 269         f ;
 270         g ;
 271         h ;
 272         UPDATE ;
 273     """)
 274     run(t, """\
 275 (b2db) break test.jam:14
 276 Breakpoint 1 set at test.jam:14
 277 (b2db) run -ftest.jam
 278 Starting program: {{bjam}} -ftest.jam
 279 Breakpoint 1, module scope at test.jam:14
 280 14              f ;
 281 (b2db) break f
 282 Breakpoint 2 set at f
 283 (b2db) continue
 284 Breakpoint 2, f ( ) at test.jam:3
 285 3                   a = 1 ;
 286 (b2db) kill
 287 (b2db) run -ftest.jam
 288 Starting program: {{bjam}} -ftest.jam
 289 Breakpoint 1, module scope at test.jam:14
 290 14              f ;
 291 (b2db) break g
 292 Breakpoint 3 set at g
 293 (b2db) disable 2
 294 (b2db) continue
 295 Breakpoint 3, g ( ) at test.jam:7
 296 7                   b = 2 ;
 297 (b2db) kill
 298 (b2db) run -ftest.jam
 299 Starting program: {{bjam}} -ftest.jam
 300 Breakpoint 1, module scope at test.jam:14
 301 14              f ;
 302 (b2db) enable 2
 303 (b2db) continue
 304 Breakpoint 2, f ( ) at test.jam:3
 305 3                   a = 1 ;
 306 (b2db) kill
 307 (b2db) run -ftest.jam
 308 Starting program: {{bjam}} -ftest.jam
 309 Breakpoint 1, module scope at test.jam:14
 310 14              f ;
 311 (b2db) delete 2
 312 (b2db) continue
 313 Breakpoint 3, g ( ) at test.jam:7
 314 7                   b = 2 ;
 315 (b2db) kill
 316 (b2db) run -ftest.jam
 317 Starting program: {{bjam}} -ftest.jam
 318 Breakpoint 1, module scope at test.jam:14
 319 14              f ;
 320 (b2db) break test.jam:12
 321 Breakpoint 4 set at test.jam:12
 322 (b2db) clear g
 323 Deleted breakpoint 3
 324 (b2db) continue
 325 Breakpoint 4, h ( ) at test.jam:12
 326 12                  d = 4 ;
 327 (b2db) kill
 328 (b2db) run -ftest.jam
 329 Starting program: {{bjam}} -ftest.jam
 330 Breakpoint 1, module scope at test.jam:14
 331 14              f ;
 332 (b2db) clear test.jam:12
 333 Deleted breakpoint 4
 334 (b2db) continue
 335 Child {{\d+}} exited with status 0
 336 (b2db) quit
 337 """)
 338     t.cleanup()
 339
 340 def test_backtrace():
 341     t = make_tester()
 342     t.write("test.jam", """\
 343         rule f ( x * : y * : z * )
 344         {
 345             return $(x) ;
 346         }
 347         rule g ( x * : y * : z * )
 348         {
 349             return [ f $(x) : $(y) : $(z) ] ;
 350         }
 351         g 1 : 2 : 3 ;
 352     """)
 353     run(t, """\
 354 (b2db) break f
 355 Breakpoint 1 set at f
 356 (b2db) run -ftest.jam
 357 Starting program: {{bjam}} -ftest.jam
 358 Breakpoint 1, f ( 1 : 2 : 3 ) at test.jam:3
 359 3                   return $(x) ;
 360 (b2db) backtrace
 361 #0  in f ( 1 : 2 : 3 ) at test.jam:3
 362 #1  in g ( 1 : 2 : 3 ) at test.jam:7
 363 #2  in module scope at test.jam:9
 364 (b2db) quit
 365 """)
 366     t.cleanup()
 367
 368 def test_print():
 369     t = make_tester()
 370     t.write("test.jam", """\
 371         rule f ( args * )
 372         {
 373             return $(args) ;
 374         }
 375         f x ;
 376         f x y ;
 377     """)
 378
 379     run(t, """\
 380 (b2db) break f
 381 Breakpoint 1 set at f
 382 (b2db) run -ftest.jam
 383 Starting program: {{bjam}} -ftest.jam
 384 Breakpoint 1, f ( x ) at test.jam:3
 385 3                   return $(args) ;
 386 (b2db) print $(args)
 387 x
 388 (b2db) continue
 389 Breakpoint 1, f ( x y ) at test.jam:3
 390 3                   return $(args) ;
 391 (b2db) print $(args)
 392 x y
 393 (b2db) disable 1
 394 (b2db) print [ f z ]
 395 z
 396 (b2db) quit
 397 """)
 398
 399     t.cleanup()
 400
 401 def test_run_running():
 402     t = make_tester()
 403     t.write("test.jam", """\
 404         UPDATE ;
 405     """)
 406
 407     run(t, """\
 408 (b2db) break test.jam:1
 409 Breakpoint 1 set at test.jam:1
 410 (b2db) run -ftest.jam
 411 Starting program: {{bjam}} -ftest.jam
 412 Breakpoint 1, module scope at test.jam:1
 413 1               UPDATE ;
 414 (b2db) run -ftest.jam
 415 Child {{\d+}} exited with status 0
 416 Starting program: {{bjam}} -ftest.jam
 417 Breakpoint 1, module scope at test.jam:1
 418 1               UPDATE ;
 419 (b2db) quit
 420 """)
 421
 422     t.cleanup()
 423
 424 def test_error_not_running():
 425     t = make_tester()
 426     run(t, """\
 427 (b2db) continue
 428 The program is not being run.
 429 (b2db) step
 430 The program is not being run.
 431 (b2db) next
 432 The program is not being run.
 433 (b2db) finish
 434 The program is not being run.
 435 (b2db) kill
 436 The program is not being run.
 437 (b2db) backtrace
 438 The program is not being run.
 439 (b2db) print 1
 440 The program is not being run.
 441 (b2db) quit
 442 """)
 443
 444     t.cleanup()
 445
 446 def test_bad_arguments():
 447     t = make_tester()
 448     t.write("test.jam", """\
 449         UPDATE ;
 450     """)
 451
 452     run(t, """\
 453 (b2db) break test.jam:1
 454 Breakpoint 1 set at test.jam:1
 455 (b2db) run -ftest.jam
 456 Starting program: {{bjam}} -ftest.jam
 457 Breakpoint 1, module scope at test.jam:1
 458 1               UPDATE ;
 459 (b2db) continue 1
 460 Too many arguments to continue.
 461 (b2db) step 1
 462 Too many arguments to step.
 463 (b2db) next 1
 464 Too many arguments to next.
 465 (b2db) finish 1
 466 Too many arguments to finish.
 467 (b2db) break
 468 Missing argument to break.
 469 (b2db) break x y
 470 Too many arguments to break.
 471 (b2db) disable
 472 Missing argument to disable.
 473 (b2db) disable 1 2
 474 Too many arguments to disable.
 475 (b2db) disable x
 476 Invalid breakpoint number x.
 477 (b2db) disable 2
 478 Unknown breakpoint 2.
 479 (b2db) enable
 480 Missing argument to enable.
 481 (b2db) enable 1 2
 482 Too many arguments to enable.
 483 (b2db) enable x
 484 Invalid breakpoint number x.
 485 (b2db) enable 2
 486 Unknown breakpoint 2.
 487 (b2db) delete
 488 Missing argument to delete.
 489 (b2db) delete 1 2
 490 Too many arguments to delete.
 491 (b2db) delete x
 492 Invalid breakpoint number x.
 493 (b2db) delete 2
 494 Unknown breakpoint 2.
 495 (b2db) clear
 496 Missing argument to clear.
 497 (b2db) clear test.jam:1 test.jam:1
 498 Too many arguments to clear.
 499 (b2db) clear test.jam:2
 500 No breakpoint at test.jam:2.
 501 (b2db) quit
 502 """)
 503
 504     t.cleanup()
 505
 506 def test_unknown_command():
 507     t = make_tester()
 508     run(t, """\
 509 (b2db) xyzzy
 510 Unknown command: xyzzy
 511 (b2db) gnusto rezrov
 512 Unknown command: gnusto
 513 (b2db) quit
 514 """)
 515
 516     t.cleanup()
 517
 518 test_run()
 519 test_exit_status()
 520 test_step()
 521 test_next()
 522 test_finish()
 523 test_breakpoints()
 524 test_breakpoints_running()
 525 test_backtrace()
 526 test_print()
 527 test_run_running()
 528 test_error_not_running()
 529 test_bad_arguments()
 530 test_unknown_command()