|
| 1 | +#!/bin/sh |
| 2 | +exec scala -savecompiled "$0" "$@" |
| 3 | +!# |
| 4 | + |
| 5 | +import scala.io.Source |
| 6 | +import scala.collection.mutable.Buffer |
| 7 | +import scala.collection.mutable.ListBuffer |
| 8 | +import scala.collection.mutable.StringBuilder |
| 9 | + |
| 10 | +/** Automate testing debuggability of generated code using JDB and expect |
| 11 | + * |
| 12 | + * The debugging information is annotated as comments to the code in brackets: |
| 13 | + * |
| 14 | + * val x = f(3) // [break] [next: line=5] |
| 15 | + * val y = 5 |
| 16 | + * |
| 17 | + * 1. A jdb command must be wrapped in brackets, like `[step]`. All jdb commands can be used. |
| 18 | + * 2. To check output of jdb for a command, use `[cmd: expect]`. |
| 19 | + * 3. If `expect` is wrapped in double quotes, regex is supported. |
| 20 | + * 4. Break commands are collected and set globally. |
| 21 | + * 5. Other commands will be send to jdb in the order they appear in the source file |
| 22 | + * |
| 23 | + * Note: jdb uses line number starts from 1 |
| 24 | + */ |
| 25 | + |
| 26 | +object Gen { |
| 27 | + val MainObject = "Test" |
| 28 | + |
| 29 | + sealed trait Tree |
| 30 | + |
| 31 | + case class Break(line: Int) extends Tree |
| 32 | + |
| 33 | + case class Command(val name: String, val expect: Expect = EmptyExpect) extends Tree |
| 34 | + |
| 35 | + sealed trait Expect |
| 36 | + |
| 37 | + case object EmptyExpect extends Expect |
| 38 | + |
| 39 | + case class LitExpect(lit: String) extends Expect |
| 40 | + |
| 41 | + case class PatExpect(pat: String) extends Expect |
| 42 | + |
| 43 | + case class Program(breaks: Seq[Break], commands: Seq[Command]) |
| 44 | + |
| 45 | + def error(msg: String): Nothing = { |
| 46 | + throw new Exception(msg) |
| 47 | + } |
| 48 | + |
| 49 | + def parseCommand(command: String, lineNo: Int): Tree = { |
| 50 | + val index = command.indexOf(':') |
| 51 | + if (index == -1) { |
| 52 | + // simple command |
| 53 | + if (command == "break") Break(lineNo) |
| 54 | + else Command(command) |
| 55 | + } else { |
| 56 | + val Seq(cmd, rhs) = command.split(":", 2).toSeq.map(_.trim) |
| 57 | + if (rhs.startsWith("\"")) { |
| 58 | + // regex match |
| 59 | + val content = "\"(.+)\"".r |
| 60 | + rhs match { |
| 61 | + case content(expect) => Command(cmd, PatExpect(expect)) |
| 62 | + case _ => error(s"""incorrect specification: `$rhs` for `$cmd` at line $lineNo. Ending " expected.""") |
| 63 | + } |
| 64 | + } else { |
| 65 | + // literal match |
| 66 | + Command(cmd, LitExpect(rhs)) |
| 67 | + } |
| 68 | + } |
| 69 | + } |
| 70 | +
|
| 71 | + def parse(file: String): Program = { |
| 72 | + val lines = Source.fromFile(file).getLines.toBuffer |
| 73 | +
|
| 74 | + val breaks = new ListBuffer[Break]() |
| 75 | + val cmds = new ListBuffer[Command]() |
| 76 | + lines.zipWithIndex.map { case (code, line) => |
| 77 | + val comment = if (code.indexOf("//") != -1) code.split("//").last else "" |
| 78 | + val regex = """(?<=\[).*?(?=\])""".r |
| 79 | + for (p <- regex findAllIn comment) parseCommand(p.trim, line + 1) match { // jdb index from 0 |
| 80 | + case b: Break => breaks += b |
| 81 | + case c: Command => cmds += c |
| 82 | + } |
| 83 | + } |
| 84 | +
|
| 85 | + Program(breaks, cmds) |
| 86 | + } |
| 87 | +
|
| 88 | + def generate(program: Program, source: String = "tests/debug/"): String = { |
| 89 | + val Program(breaks, cmds) = program |
| 90 | + val breakpoints = (breaks.map { |
| 91 | + case Break(point) => |
| 92 | + s"""|send "stop at $MainObject$$:$point\\r" |
| 93 | + |expect "breakpoint $MainObject$$:$point" |
| 94 | + """.stripMargin |
| 95 | + }).mkString("\n\n") |
| 96 | +
|
| 97 | + val commands = (cmds.map { |
| 98 | + case Command(cmd, EmptyExpect) => |
| 99 | + s"""|# send_user "send command `$cmd`\\n" |
| 100 | + |send "$cmd\\r" |
| 101 | + """.stripMargin |
| 102 | + case Command(cmd, LitExpect(lit)) => |
| 103 | + s"""|# send_user "send command `$cmd`\\n" |
| 104 | + |send "$cmd\\r" |
| 105 | + |expect { |
| 106 | + | "*$lit*" { send_user "success - $cmd : $lit \\n" } |
| 107 | + | timeout { |
| 108 | + | send_user "timeout while waiting for response: $cmd : $lit\\n" |
| 109 | + | exit 1 |
| 110 | + | } |
| 111 | + |} |
| 112 | + |""".stripMargin |
| 113 | + case Command(cmd, PatExpect(pat)) => |
| 114 | + s"""|# send_user "send command `$cmd`\\n" |
| 115 | + |send "$cmd\\r" |
| 116 | + |expect { |
| 117 | + | -re {$pat} { send_user "success - $cmd : $pat \\n" } |
| 118 | + | timeout { |
| 119 | + | send_user "timeout while waiting for response: $cmd : $pat\\n" |
| 120 | + | exit 1 |
| 121 | + | } |
| 122 | + |} |
| 123 | + |""".stripMargin |
| 124 | + }).mkString("\n\n") |
| 125 | +
|
| 126 | +s"""|#!/usr/bin/expect |
| 127 | + | |
| 128 | + |# log_user 1 |
| 129 | + |# exp_internal 1 |
| 130 | + |# set timeout 5 |
| 131 | + | |
| 132 | + |send_user "spawning job...\\n" |
| 133 | + | |
| 134 | + |spawn jdb -attach 5005 -sourcepath $source |
| 135 | + | |
| 136 | + |send_user "interacting...\\n" |
| 137 | + | |
| 138 | + |expect { |
| 139 | + | "*VM Started*" { send_user "success - connected to server \\n" } |
| 140 | + | timeout { |
| 141 | + | send_user "timeout while waiting for: *VM Started*\\n" |
| 142 | + | exit 1 |
| 143 | + | } |
| 144 | + |} |
| 145 | + | |
| 146 | + |send_user "setting breakpoints...\\n" |
| 147 | + | |
| 148 | + |# breakpoints |
| 149 | + |$breakpoints |
| 150 | + | |
| 151 | + |# run |
| 152 | + |send_user "run program...\\n" |
| 153 | + |send "run\\r" |
| 154 | + |expect "Breakpoint hit" |
| 155 | + | |
| 156 | + |# interactions |
| 157 | + |$commands""".stripMargin |
| 158 | + } |
| 159 | +} |
| 160 | +
|
| 161 | +val prog = Gen.parse(args(0)) |
| 162 | +// println("--------------------------------") |
| 163 | +// println("prog:" + prog) |
| 164 | +// println("\n\n\n scrip:") |
| 165 | +// println("--------------------------------") |
| 166 | +println(Gen.generate(prog)) |
| 167 | +
|
| 168 | +
|
0 commit comments