考え方:値を「記号」として持ち歩く
実際には実行しないので、変数の中身は数値や文字列ではなく、その値がどこから来たか という記号として持つ。たとえば placeOrder の33行目 if (stock < line.quantity()) では、それぞれ次の記号になる。
stock:32行目で代入された 在庫 API のモック呼び出しstockClient.getStock(...)の戻り値。スタブで自由に決められるline.quantity():引数linesの要素として作った サンプルの OrderLine のquantity。値は既定値の1
片方が「自由に決められる値」、もう片方が「わかっている値」なら、境界値が計算できる。true にするならスタブは 1 - 1 = 0、false にするなら 1 だ。cases.py では、記号を次の種類で表す。
| Sym.kind | 意味 | 例 | Java の式にすると |
|---|---|---|---|
param | テスト対象メソッドの引数 | customerId | ケースごとの引数の値 |
call | モック呼び出しの戻り値 | stockClient.getStock(...) | スタブの値(thenReturn) |
sample | テストで組み立てる値オブジェクト | orderLine | 変数名 |
prop | サンプルの項目(アクセサー・getter) | line.quantity() | コンストラクタ引数か setter の値 |
const | リテラル・定数 | 10000、Rank.GOLD | そのまま |
mock | モックのフィールドそのもの | stockClient | — |
unknown | 追えない値 | order.total()(メソッド内で new した Order) | 決められない → TODO |
1つのテストケースは、引数の値・サンプルの値・モック呼び出しの記録・通った分岐をまとめた Case で表す。
# ---------- テスト内で組み立てる値 ----------
@dataclass
class Sample:
var: str # テストコード上の変数名
type: str
args: dict # コンストラクタ引数(名前 -> Java の式)
setters: dict = field(default_factory=dict) # setXxx -> Java の式
@dataclass
class Call:
mock: str
method: str
args: list # 引数の記号値(Sym)
used: bool # 戻り値を使っているか(使うならスタブが必要)
ret: str # 戻り値の型
stub: str | None = None # thenReturn に渡す Java の式
throw: str | None = None # thenThrow / doThrow に渡す Java の式
excluded: set = field(default_factory=set) # 「この値ではない」と決まった enum 定数
@dataclass
class Sym:
"""記号値:kind = param / const / call / sample / prop / mock / unknown"""
kind: str
ref: object = None
prop: str | None = None
@dataclass
class Case:
method: str
params: dict # 引数名 -> Java の式
param_types: dict
samples: dict = field(default_factory=dict) # 変数名 -> Sample
calls: list = field(default_factory=list) # 到達したモック呼び出し(順番どおり)
env: dict = field(default_factory=dict) # ローカル変数 -> Sym
facts: set = field(default_factory=set)
target: tuple | None = None # 狙う分岐と結果。主経路は None
path: list = field(default_factory=list) # 通った分岐と結果
todos: list = field(default_factory=list)
end: tuple = ("normal", None)主経路と枝分かれ
判定が n 個あると、経路の組み合わせは最大で 2n 通りになる。C1 に必要なのは「各判定の各結果を1回ずつ通す」ことだけなので、すべての組み合わせを作る必要はない。そこで次のルールでケースを作る。
- 各判定で「抜けない側」(return / throw しない側)を 主経路 とし、主経路の状態はそのまま先へ進む
- 主経路の状態が判定に出会ったら、主経路でない結果ごとに状態を複製して 枝分かれ させる
- 枝分かれした状態は、その後の判定では主経路側だけを通る(さらに枝分かれしない)
- ただし、まだどのケースも通っていない結果に出会ったときは、枝分かれした先でも新しいケースを作る
図1: placeOrder のケース設計。主経路1本と、判定ごとの枝分かれ
4番目のルールは else if の連鎖のためにある。PointService.calcPoints の B3(rank == Rank.SILVER)は、B2 が false のときしか評価されない。B2 の false 側は枝分かれしたケースなので、ルール3だけだと B3 の false 側(BRONZE)を通るケースができない。どの結果をすでに通ったかを seen に覚えておき、未通過の結果なら枝分かれ先でも分岐させる。
# ----- 分岐での分かれ方 -----
def fork(self, case, forking, options, branch):
"""options = [(結果ラベル, 準備関数, 主経路か[, 補足])]。主経路の状態だけが以後も分岐を増やす"""
options = [o if len(o) == 4 else (*o, "") for o in options]
# 主経路は常に進む。それ以外は「分岐を増やす状態」か「まだ誰も通っていない結果」なら作る
chosen, labels = [], set()
for o in options:
if o[2] or forking or ((branch.id, o[0]) not in self.seen and o[0] not in labels):
chosen.append(o)
labels.add(o[0])
self.seen |= {(branch.id, label) for label in labels}
states = [case if main else copy.deepcopy(case) for _, _, main, _ in chosen]
result = []
for (label, prepare, main, detail), c in zip(chosen, states):
prepare(c)
if not main:
c.target = (branch.id, label, branch.kind, branch.condition, branch.line, detail)
result.append((c, forking and main, label))
return result&& と || の組み合わせを作る
条件式は、まず 評価されるアトムの並び の候補に分解する。a || b を true にする方法は「a が true(b は評価されない)」と「a が false で b が true」の2つ、false にする方法は「a も b も false」の1つだ。&& はその逆になる。
# ----- 条件を満たす組み合わせ -----
def alternatives(self, expr, want):
"""expr を want にする、評価されるアトムの並び [(アトム, 期待値), ...] の候補一覧"""
if expr.type == "parenthesized_expression":
return self.alternatives(expr.named_children[0], want)
if expr.type == "unary_expression" and text(expr.child_by_field_name("operator")) == "!":
return self.alternatives(expr.child_by_field_name("operand"), not want)
if expr.type == "binary_expression":
op = expr.child_by_field_name("operator").type
left, right = expr.child_by_field_name("left"), expr.child_by_field_name("right")
if op in ("||", "&&"):
decider = op == "||" # 左だけで結果が決まる左の値(|| は true、&& は false)
both = [a + b for a in self.alternatives(left, not decider)
for b in self.alternatives(right, want)]
if want == decider:
return self.alternatives(left, decider) + both
return both
return [[(expr, want)]]placeOrder の B1 なら、候補は次のようになる。
| B1 の結果 | 評価されるアトム | 引数 customerId | ケース |
|---|---|---|---|
| true(その1) | customerId == null が true | null | placeOrder_B1_true |
| true(その2) | customerId == null が false、customerId.isBlank() が true | " " | placeOrder_B1_true_2 |
| false(主経路) | 両方 false | "customerId-1" | 主経路 |
true 側の候補を2つとも別のケースにしているので、判定の結果(C1)だけでなく、JaCoCo が数える条件ごとの分岐(4つ)もすべて通る。短絡評価で評価されないアトムに出てくるモック呼び出しは記録しない。記録するとスタブが使われず、Mockito の strict stubs(MockitoExtension の既定)で UnnecessaryStubbingException になるからだ。
アトムを満たす値を決める
アトムの形ごとに、値の決め方を用意する。決められない形は False を返し、そのケースに入力値の TODO が付く。
| アトムの形 | true にするには | false にするには |
|---|---|---|
引数 == null | 引数を null | 既定値のまま |
引数.isBlank() / isEmpty()(String) | " " / "" | 既定値のまま |
引数.isEmpty()(List / Set) | List.of() | 既定値(要素1つ)。「空でない」と記録する |
Optional.isEmpty() / isPresent()(モックの戻り値) | スタブを Optional.empty()(isEmpty の場合) | スタブを Optional.of(サンプル) |
数値 比較演算子 数値(片方がモックの戻り値か引数) | もう片方の値 k から境界値を計算(< なら true: k-1 / false: k) | |
モックの戻り値 == Enum.定数 | スタブをその定数 | スタブを、ほかの判定で除外されていない別の定数 |
モック.boolean メソッド() | スタブを true | スタブを false |
boolean の引数 | true | false |
def solve_compare(self, left, op, right, want, case):
ls, rs = self.sym(left, case), self.sym(right, case)
def known(s):
v = self.render(s, case)
return int(v.rstrip("L")) if v and re.fullmatch(r"-?\d+L?", v) else None
def controllable(s):
return (s.kind == "call" and s.ref.ret in NUM_TYPES) or \
(s.kind == "param" and case.param_types[s.ref] in NUM_TYPES)
if controllable(ls) and known(rs) is not None:
ctrl, k = ls, known(rs)
elif controllable(rs) and known(ls) is not None:
ctrl, k, op = rs, known(ls), FLIP[op]
else:
return False
table = {"<": (k - 1, k), "<=": (k, k + 1), ">": (k + 1, k), ">=": (k, k - 1),
"==": (k, k + 1), "!=": (k + 1, k)}
value = str(table[op][0 if want else 1])
if ctrl.kind == "call":
ctrl.ref.stub = value
else:
case.params[ctrl.ref] = value + ("L" if case.param_types[ctrl.ref] in ("long", "Long") else "")
return True比較演算子の表(table)が境界値の中心だ。stock < line.quantity() は左がモックの戻り値(決められる値)、右がサンプルの値 1(わかっている値)なので、true なら 0、false なら 1 をスタブにする。PART 02 で人が選んだ「1少ない」と「ちょうど」と同じ考え方になっている。
ℹ️ enum の「それ以外」は除外を覚えておく
rank == Rank.GOLD を false、続く rank == Rank.SILVER も false にするとき、2つ目で単純に「SILVER 以外の最初の定数」を選ぶと GOLD になり、1つ目の判定が true に戻ってしまう。そこで、モック呼び出しごとに「この値ではない」とわかった定数(excluded)を覚え、残りから選ぶ(ここでは BRONZE)。
文をたどる
メソッド本体は exec_stmts で1文ずつ処理する。状態(Case)の一覧を持ち、各文を処理するたびに「抜けた状態」と「続く状態」に分ける。文の種類ごとの処理は次のとおり。
| 文 | 処理 |
|---|---|
変数宣言 int stock = ...; | 右辺のモック呼び出しを記録し(戻り値を使うのでスタブ対象)、変数に記号を結び付ける |
式文 orderRepository.save(order); | モック呼び出しを記録する(戻り値は使わないので、スタブせず verify の対象)。代入があれば、その変数を「不明」にする |
if | 候補ごとに枝分かれし、選んだ側のブロックを処理する |
| 拡張 for | 引数のリストなら、要素のサンプルを変数に結び付けて1回だけ本体を処理する。0回の枝は、前に「空でない」と記録されていれば到達不能として作らない |
try / catch | try 本体を処理したあと、本体の最初のモック呼び出しに例外を投げさせる枝を作り、catch 本体を処理する |
switch | case ごとに枝分かれし、対象がサンプルの getter なら setter で、引数なら引数で値を決める。default には、どの case にもない定数を使う |
return / throw | 状態を「抜けた」にし、戻り値の式や例外の型を記録する |
| 式の中の三項演算子 | 式文・宣言・return の中で見つけたら、その場で枝分かれする |
def exec_if(self, node, case, forking):
branch = self.branch_ids[node.start_point[0] + 1, "if"]
cond = node.child_by_field_name("condition")
cons, alt_node = node.child_by_field_name("consequence"), node.child_by_field_name("alternative")
main_want = not ends_with_exit(cons) if ends_with_exit(cons) != ends_with_exit(alt_node) else True
options = []
for want in (True, False):
alts = self.alternatives(cond, want)
for j, alt in enumerate(alts):
main = want == main_want and j == 0
detail = "、".join(f"{text(a)} が {str(w).lower()}" for a, w in alt) if len(alt) > 1 or len(alts) > 1 else ""
options.append((str(want).lower(),
lambda c, alt=alt, w=want, m=main: self.apply(alt, c, branch, str(w).lower(), m),
main, detail))
result = []
for c, f, label in self.fork(case, forking, options, branch):
result += self.body(cons if label == "true" else alt_node, c, f)
return result
def exec_foreach(self, node, case, forking):
branch = self.branch_ids[node.start_point[0] + 1, "loop"]
s = self.sym(node.child_by_field_name("value"), case)
var = text(node.child_by_field_name("name"))
options = [("1回以上", lambda c: c.path.append((branch.id, "1回以上")), True)]
if s.kind == "param":
if ("nonempty", s.ref) in case.facts:
self.notes.append(f"{branch.id}(L{branch.line})の 0回 は到達できません(前の判定で空のときは抜けるため)")
else:
options.append(("0回", lambda c: (c.params.__setitem__(s.ref, "List.of()"),
c.path.append((branch.id, "0回"))), False))
result = []
for c, f, label in self.fork(case, forking, options, branch):
if label == "0回":
result.append((c, f, False))
continue
value = c.params.get(s.ref, "") if s.kind == "param" else ""
m = re.fullmatch(r"(?:List|Set)\.of\((\w+)\)", value)
c.env[var] = Sym("sample", m.group(1)) if m else Sym("unknown")
result += self.body(node.child_by_field_name("body"), c, f)
return result
def exec_try(self, node, case, forking):
start = len(case.calls)
states = self.body(node.child_by_field_name("body"), case, forking)
result = []
for c, f, done in states:
result.append((c, f, done))
if not f or done:
continue
for clause in [n for n in node.named_children if n.type == "catch_clause"]:
branch = self.branch_ids[clause.start_point[0] + 1, "catch"]
exc = text(clause.named_children[0]).split()[0]
tried = c.calls[start:]
if not tried:
self.notes.append(f"{branch.id}(L{branch.line})は try の中にモック呼び出しがないため例外を起こせません")
continue
def prepare(cc, exc=exc, branch=branch):
first = cc.calls[start]
first.throw = f'new {exc}({self.exception_args(exc)})'
first.stub = None
del cc.calls[start + 1:]
cc.path[-1] = (branch.id, "catch")
c.path.append((branch.id, "例外なし"))
for cc, ff, _ in self.fork(c, f, [("catch", prepare, False)], branch):
result += self.body(clause.child_by_field_name("body"), cc, ff)
return resultexec_try では、例外を投げさせたモック呼び出しより後の呼び出しを記録から消している。try の中で例外が起きれば、その後ろは実行されないからだ。消さずに残すと、使われないスタブや、実際には呼ばれない verify が生成されてしまう。
到達できない分岐と、引数の書き換え
ケースを作っていると、2種類の「おかしな状態」に出会う。どちらもエラーにはせず、注意として出力する。
- 到達できない結果:
placeOrderの for の0回は、B2 で「空でない」と決めた後なので作らない。生成時にNOTE placeOrder: B3(L31)の 0回 は到達できませんと表示する。enum のすべての定数が case にある switch の default も同じ扱いだ - 引数の書き換え:前の判定で使った引数を、後の判定がまた別の値に書き換えることがある。たとえば
switch (x)でx = 1にしたあと、x > 5 ? ...を true にしようとしてx = 6にすると、switch の結果が変わってしまう。check_overwriteがこれを見つけると、経路に「?」を付け、「経路を確認してください」という TODO を残す
OrderService のケース一覧
ここまでの処理で、OrderService から次の11ケースができる(生成されたテストの中身は PART 06 で見る)。
| メソッド | 狙う結果 | 引数 | スタブ・サンプル | 終わり方 |
|---|---|---|---|---|
| placeOrder | 主経路 | "customerId-1", 明細1件 | getStock → 1 | return order |
| B1 true | null | — | IllegalArgumentException | |
| B1 true | " " | — | IllegalArgumentException | |
| B2 true | List.of() | — | IllegalArgumentException | |
| B4 true | 明細1件(数量 1) | getStock → 0 | OutOfStockException | |
| B5 true | 明細1件 | getStock → 1(入力値 TODO) | return order | |
| B6 catch | 明細1件 | getStock → 1、send → MailException | return order | |
| cancelOrder | 主経路 | 1L | findById → Optional.of(order)、status = NEW | return true |
| B1 true | 1L | findById → Optional.empty() | return false | |
| B2 SHIPPED | 1L | status = SHIPPED | IllegalStateException | |
| B2 default | 1L | status = CANCELLED | return false |
B5(order.total() >= 10000)だけは、order がメソッドの中で new された値で、合計は明細から計算されるため決められなかった。PART 02 で予想したとおり、ここは人に任せる部分になる。それ以外の分岐は、すべて入力とスタブが自動で決まった。
cases.py の全体を表示する
"""メソッド本体をたどり、分岐の結果ごとにテストケース(引数・スタブ・到達した呼び出し)を組み立てる"""
import copy
import re
from dataclasses import dataclass, field
from branches import ends_with_exit, extract, switch_outcomes
from ts_common import text
NUM_TYPES = {"int", "long", "short", "byte", "Integer", "Long"}
FLIP = {"<": ">", "<=": ">=", ">": "<", ">=": "<=", "==": "==", "!=": "!="}
# ---------- テスト内で組み立てる値 ----------
@dataclass
class Sample:
var: str # テストコード上の変数名
type: str
args: dict # コンストラクタ引数(名前 -> Java の式)
setters: dict = field(default_factory=dict) # setXxx -> Java の式
@dataclass
class Call:
mock: str
method: str
args: list # 引数の記号値(Sym)
used: bool # 戻り値を使っているか(使うならスタブが必要)
ret: str # 戻り値の型
stub: str | None = None # thenReturn に渡す Java の式
throw: str | None = None # thenThrow / doThrow に渡す Java の式
excluded: set = field(default_factory=set) # 「この値ではない」と決まった enum 定数
@dataclass
class Sym:
"""記号値:kind = param / const / call / sample / prop / mock / unknown"""
kind: str
ref: object = None
prop: str | None = None
@dataclass
class Case:
method: str
params: dict # 引数名 -> Java の式
param_types: dict
samples: dict = field(default_factory=dict) # 変数名 -> Sample
calls: list = field(default_factory=list) # 到達したモック呼び出し(順番どおり)
env: dict = field(default_factory=dict) # ローカル変数 -> Sym
facts: set = field(default_factory=set)
target: tuple | None = None # 狙う分岐と結果。主経路は None
path: list = field(default_factory=list) # 通った分岐と結果
todos: list = field(default_factory=list)
end: tuple = ("normal", None)
class Planner:
def __init__(self, method_node, deps, index):
self.node = method_node
self.index = index
self.mocks = {d.name: d.type for d in deps if d.handling == "MOCK"}
self.branch_ids = {}
for b in extract(method_node):
self.branch_ids[b.line, b.kind] = b
self.notes = [] # 到達できない分岐などの注意
self.seen = set() # どこかのケースで通った (分岐ID, 結果)
# ----- 値の既定値 -----
def default_value(self, typ, name, case):
base = typ.split("<")[0]
inner = typ[typ.find("<") + 1:-1] if "<" in typ else None
if base == "String":
return f'"{name}-1"'
if base in ("int", "Integer", "short", "byte"):
return "1"
if base in ("long", "Long"):
return "1L"
if base in ("double", "Double"):
return "1.0"
if base in ("boolean", "Boolean"):
return "false"
if base == "LocalDateTime":
return "LocalDateTime.of(2026, 1, 1, 9, 0)"
if base == "LocalDate":
return "LocalDate.of(2026, 1, 1)"
if base in ("List", "Collection", "Set"):
elem = self.default_value(inner, name.rstrip("s") or "item", case)
return f"{'Set' if base == 'Set' else 'List'}.of({elem})"
if base == "Optional":
return f"Optional.of({self.default_value(inner, inner[0].lower() + inner[1:], case)})"
info = self.index.get(base)
if info and info.kind == "enum":
return f"{base}.{info.constants[0]}"
if info and info.kind in ("record", "class"):
ctor = info.components if info.kind == "record" else (max(info.constructors, key=len) if info.constructors else [])
var = self.new_var(base[0].lower() + base[1:], case)
case.samples[var] = Sample(var, base, {n: self.default_value(t, n, case) for t, n in ctor})
return var
return "null"
def new_var(self, stem, case):
var, n = stem, 2
while var in case.samples or var in case.params:
var, n = f"{stem}{n}", n + 1
return var
# ----- 記号値 -----
def sym(self, expr, case):
t = expr.type
if t == "parenthesized_expression":
return self.sym(expr.named_children[0], case)
if t == "identifier":
name = text(expr)
if name in case.env:
return case.env[name]
if name in case.params:
return Sym("param", name)
if name in self.mocks:
return Sym("mock", name)
return Sym("unknown")
if t in ("decimal_integer_literal", "string_literal", "true", "false", "null_literal",
"decimal_floating_point_literal", "field_access"):
return Sym("const", text(expr))
if t == "method_invocation":
obj = expr.child_by_field_name("object")
name = text(expr.child_by_field_name("name"))
if obj is None:
return Sym("unknown")
o = self.sym(obj, case)
if o.kind == "mock":
for c in reversed(case.calls):
if c.mock == o.ref and c.method == name:
return Sym("call", c)
if o.kind == "call" and o.ref.ret.startswith("Optional") and name in ("get", "orElseThrow"):
return Sym("sample", o.ref.stub[len("Optional.of("):-1]) # Optional.of(order) の order
if o.kind == "sample" and o.ref in case.samples:
return Sym("prop", o.ref, name)
return Sym("unknown")
def render(self, s, case):
"""記号値を Java の式にする。決まらなければ None"""
if s.kind == "param":
return case.params[s.ref]
if s.kind == "const":
return s.ref
if s.kind == "sample":
return s.ref
if s.kind == "prop":
sample = case.samples[s.ref]
prop = re.sub(r"^(get|is)", "", s.prop)
prop = prop[0].lower() + prop[1:] if prop else s.prop
setter = "set" + prop[0].upper() + prop[1:]
return sample.setters.get(setter, sample.args.get(prop))
return None
# ----- モック呼び出しの記録 -----
def record_calls(self, expr, case, used=False):
if expr.type in ("lambda_expression", "ternary_expression"):
return
for child in expr.named_children: # 内側の呼び出しの戻り値は外側が使う
self.record_calls(child, case, used=True)
if expr.type == "method_invocation":
obj = expr.child_by_field_name("object")
if obj is not None and obj.type == "identifier" and text(obj) in self.mocks:
mock, name = text(obj), text(expr.child_by_field_name("name"))
ret = self.index[self.mocks[mock].split("<")[0]].methods.get(name, "void") \
if self.mocks[mock].split("<")[0] in self.index else "Object"
args = [self.sym(a, case) for a in expr.child_by_field_name("arguments").named_children]
call = Call(mock, name, args, used and ret != "void", ret)
if call.used:
call.stub = self.default_value(ret, name, case)
case.calls.append(call)
# ----- 条件を満たす組み合わせ -----
def alternatives(self, expr, want):
"""expr を want にする、評価されるアトムの並び [(アトム, 期待値), ...] の候補一覧"""
if expr.type == "parenthesized_expression":
return self.alternatives(expr.named_children[0], want)
if expr.type == "unary_expression" and text(expr.child_by_field_name("operator")) == "!":
return self.alternatives(expr.child_by_field_name("operand"), not want)
if expr.type == "binary_expression":
op = expr.child_by_field_name("operator").type
left, right = expr.child_by_field_name("left"), expr.child_by_field_name("right")
if op in ("||", "&&"):
decider = op == "||" # 左だけで結果が決まる左の値(|| は true、&& は false)
both = [a + b for a in self.alternatives(left, not decider)
for b in self.alternatives(right, want)]
if want == decider:
return self.alternatives(left, decider) + both
return both
return [[(expr, want)]]
def solve_atom(self, atom, want, case):
"""アトムを want にする値を case に設定する。決められなければ False"""
t = atom.type
if t == "parenthesized_expression":
return self.solve_atom(atom.named_children[0], want, case)
if t == "identifier":
s = self.sym(atom, case)
if s.kind == "param":
case.params[s.ref] = "true" if want else "false"
return True
if t == "binary_expression":
op = atom.child_by_field_name("operator").type
left, right = atom.child_by_field_name("left"), atom.child_by_field_name("right")
if op in ("==", "!=") and "null_literal" in (left.type, right.type):
other = self.sym(right if left.type == "null_literal" else left, case)
is_null = want if op == "==" else not want
if other.kind == "param":
if is_null:
case.params[other.ref] = "null"
return True
if other.kind == "call":
other.ref.stub = "null" if is_null else other.ref.stub
return True
return False
if op in ("==", "!=") and self.solve_enum(left, right, want if op == "==" else not want, case):
return True
if op in FLIP:
return self.solve_compare(left, op, right, want, case)
if t == "method_invocation":
name = text(atom.child_by_field_name("name"))
obj = atom.child_by_field_name("object")
s = self.sym(obj, case) if obj is not None else Sym("unknown")
if name in ("isEmpty", "isBlank", "isPresent"):
empty = want if name != "isPresent" else not want
if s.kind == "param":
ptype = case.param_types[s.ref].split("<")[0]
if ptype == "String":
if empty:
case.params[s.ref] = '" "' if name == "isBlank" else '""'
return True
if ptype in ("List", "Collection", "Set"):
if empty:
case.params[s.ref] = f"{'Set' if ptype == 'Set' else 'List'}.of()"
else:
case.facts.add(("nonempty", s.ref))
return True
if s.kind == "call" and s.ref.ret.startswith("Optional"):
if empty:
s.ref.stub = "Optional.empty()"
return True
mock_call = self.sym(atom, case)
if mock_call.kind == "call" and mock_call.ref.ret in ("boolean", "Boolean"):
mock_call.ref.stub = "true" if want else "false"
return True
return False
def solve_enum(self, left, right, equal, case):
"""モックの戻り値(enum)と定数の比較: rank == Rank.GOLD など"""
for a, b in ((left, right), (right, left)):
s = self.sym(a, case)
if s.kind == "call" and b.type == "field_access" and s.ref.ret in self.index \
and self.index[s.ref.ret].kind == "enum":
consts = self.index[s.ref.ret].constants
target = text(b.child_by_field_name("field"))
if equal:
s.ref.stub = f"{s.ref.ret}.{target}"
return True
s.ref.excluded.add(target)
other = next((k for k in consts if k not in s.ref.excluded), None)
if other is None:
return False
s.ref.stub = f"{s.ref.ret}.{other}"
return True
return False
def solve_compare(self, left, op, right, want, case):
ls, rs = self.sym(left, case), self.sym(right, case)
def known(s):
v = self.render(s, case)
return int(v.rstrip("L")) if v and re.fullmatch(r"-?\d+L?", v) else None
def controllable(s):
return (s.kind == "call" and s.ref.ret in NUM_TYPES) or \
(s.kind == "param" and case.param_types[s.ref] in NUM_TYPES)
if controllable(ls) and known(rs) is not None:
ctrl, k = ls, known(rs)
elif controllable(rs) and known(ls) is not None:
ctrl, k, op = rs, known(ls), FLIP[op]
else:
return False
table = {"<": (k - 1, k), "<=": (k, k + 1), ">": (k + 1, k), ">=": (k, k - 1),
"==": (k, k + 1), "!=": (k + 1, k)}
value = str(table[op][0 if want else 1])
if ctrl.kind == "call":
ctrl.ref.stub = value
else:
case.params[ctrl.ref] = value + ("L" if case.param_types[ctrl.ref] in ("long", "Long") else "")
return True
def apply(self, alt, case, branch, outcome, main=False):
before = dict(case.params)
for atom, want in alt:
self.record_calls(atom, case, used=True)
if not self.solve_atom(atom, want, case):
if not main:
case.todos.append(f"{branch.id} の条件 `{text(atom)}` を {str(want).lower()} にする入力値を設定してください")
if branch.kind != "ternary": # 三項演算子は値が変わるだけで、通る文は変わらない
outcome = outcome.rstrip("?") + "?"
touched = {text(n) for atom, _ in alt for n in [atom, *self.descendants(atom)]
if n.type == "identifier" and text(n) in case.params}
if self.check_overwrite(before, case, branch, touched):
outcome = outcome.rstrip("?") + "?"
case.path.append((branch.id, outcome))
def check_overwrite(self, before, case, branch, touched):
"""前の分岐で使った引数の値を、この分岐が書き換えていないか"""
overwritten = False
for name, value in case.params.items():
if before.get(name) != value and ("fixed", name) in case.facts:
case.todos.append(f"引数 {name} の値を {branch.id} が書き換えたため、前の分岐の結果が変わった可能性があります。経路を確認してください")
overwritten = True
case.facts |= {("fixed", name) for name in touched}
return overwritten
# ----- 分岐での分かれ方 -----
def fork(self, case, forking, options, branch):
"""options = [(結果ラベル, 準備関数, 主経路か[, 補足])]。主経路の状態だけが以後も分岐を増やす"""
options = [o if len(o) == 4 else (*o, "") for o in options]
# 主経路は常に進む。それ以外は「分岐を増やす状態」か「まだ誰も通っていない結果」なら作る
chosen, labels = [], set()
for o in options:
if o[2] or forking or ((branch.id, o[0]) not in self.seen and o[0] not in labels):
chosen.append(o)
labels.add(o[0])
self.seen |= {(branch.id, label) for label in labels}
states = [case if main else copy.deepcopy(case) for _, _, main, _ in chosen]
result = []
for (label, prepare, main, detail), c in zip(chosen, states):
prepare(c)
if not main:
c.target = (branch.id, label, branch.kind, branch.condition, branch.line, detail)
result.append((c, forking and main, label))
return result
# ----- 文の実行 -----
def exec_stmts(self, stmts, case, forking):
frontier, finished = [(case, forking)], []
for stmt in stmts:
nxt = []
for cur, f in frontier:
for c, cf, done in self.exec_stmt(stmt, cur, f):
(finished if done else nxt).append((c, cf))
frontier = nxt
return [(c, f, True) for c, f in finished] + [(c, f, False) for c, f in frontier]
def body(self, node, case, forking):
if node is None:
return [(case, forking, False)]
if node.type in ("block", "switch_block_statement_group"):
return self.exec_stmts([n for n in node.named_children if n.type != "switch_label"], case, forking)
return self.exec_stmt(node, case, forking)
def exec_stmt(self, node, case, forking):
t = node.type
if t == "block":
return self.body(node, case, forking)
if t == "local_variable_declaration":
for d in node.children_by_field_name("declarator"):
value = d.child_by_field_name("value")
if value is not None:
states = self.scan_expr(value, case, forking, used=True)
for c, _ in states:
c.env[text(d.child_by_field_name("name"))] = self.sym(value, c)
return [(c, f, False) for c, f in states]
return [(case, forking, False)]
if t == "expression_statement":
states = self.scan_expr(node.named_children[0], case, forking)
for c, _ in states:
self.track_assignments(node, c)
return [(c, f, False) for c, f in states]
if t == "return_statement":
value = node.named_children[0] if node.named_children else None
states = self.scan_expr(value, case, forking) if value is not None else [(case, forking)]
for c, _ in states:
c.end = ("return", text(value) if value is not None else None)
return [(c, f, True) for c, f in states]
if t == "throw_statement":
created = node.named_children[0]
exc = text(created.child_by_field_name("type")) if created.type == "object_creation_expression" else "Exception"
case.end = ("throw", exc)
return [(case, forking, True)]
if t == "if_statement":
return self.exec_if(node, case, forking)
if t == "enhanced_for_statement":
return self.exec_foreach(node, case, forking)
if t == "try_statement":
return self.exec_try(node, case, forking)
if t == "switch_expression":
return self.exec_switch(node, case, forking)
return [(c, f, False) for c, f in self.scan_expr(node, case, forking)]
def track_assignments(self, node, case):
"""ローカル変数への代入を反映する(式の値は追わず、不明にする)"""
for n in [node, *self.descendants(node)]:
if n.type in ("assignment_expression", "update_expression"):
target = n.child_by_field_name("left") or n.named_children[0]
if target.type == "identifier" and text(target) in case.env:
case.env[text(target)] = Sym("unknown")
def scan_expr(self, expr, case, forking, used=False):
"""式の中のモック呼び出しを記録し、三項演算子があれば分岐する"""
ternaries = [n for n in [expr, *self.descendants(expr)] if n.type == "ternary_expression"]
states = [(case, forking)]
for tern in ternaries:
branch = self.branch_ids[tern.start_point[0] + 1, "ternary"]
cond = tern.child_by_field_name("condition")
nxt = []
for c, f in states:
options = []
for i, want in enumerate((True, False)):
for j, alt in enumerate(self.alternatives(cond, want)):
options.append((str(want).lower(),
lambda cc, alt=alt, w=want, m=(i == 1 and j == 0):
self.apply(alt, cc, branch, str(w).lower(), m),
i == 1 and j == 0))
nxt += [(cc, ff) for cc, ff, _ in self.fork(c, f, options, branch)]
states = nxt
for c, _ in states:
self.record_calls(expr, c, used=used)
return states
def descendants(self, node):
for child in node.named_children:
if child.type != "lambda_expression":
yield child
yield from self.descendants(child)
def exec_if(self, node, case, forking):
branch = self.branch_ids[node.start_point[0] + 1, "if"]
cond = node.child_by_field_name("condition")
cons, alt_node = node.child_by_field_name("consequence"), node.child_by_field_name("alternative")
main_want = not ends_with_exit(cons) if ends_with_exit(cons) != ends_with_exit(alt_node) else True
options = []
for want in (True, False):
alts = self.alternatives(cond, want)
for j, alt in enumerate(alts):
main = want == main_want and j == 0
detail = "、".join(f"{text(a)} が {str(w).lower()}" for a, w in alt) if len(alt) > 1 or len(alts) > 1 else ""
options.append((str(want).lower(),
lambda c, alt=alt, w=want, m=main: self.apply(alt, c, branch, str(w).lower(), m),
main, detail))
result = []
for c, f, label in self.fork(case, forking, options, branch):
result += self.body(cons if label == "true" else alt_node, c, f)
return result
def exec_foreach(self, node, case, forking):
branch = self.branch_ids[node.start_point[0] + 1, "loop"]
s = self.sym(node.child_by_field_name("value"), case)
var = text(node.child_by_field_name("name"))
options = [("1回以上", lambda c: c.path.append((branch.id, "1回以上")), True)]
if s.kind == "param":
if ("nonempty", s.ref) in case.facts:
self.notes.append(f"{branch.id}(L{branch.line})の 0回 は到達できません(前の判定で空のときは抜けるため)")
else:
options.append(("0回", lambda c: (c.params.__setitem__(s.ref, "List.of()"),
c.path.append((branch.id, "0回"))), False))
result = []
for c, f, label in self.fork(case, forking, options, branch):
if label == "0回":
result.append((c, f, False))
continue
value = c.params.get(s.ref, "") if s.kind == "param" else ""
m = re.fullmatch(r"(?:List|Set)\.of\((\w+)\)", value)
c.env[var] = Sym("sample", m.group(1)) if m else Sym("unknown")
result += self.body(node.child_by_field_name("body"), c, f)
return result
def exec_try(self, node, case, forking):
start = len(case.calls)
states = self.body(node.child_by_field_name("body"), case, forking)
result = []
for c, f, done in states:
result.append((c, f, done))
if not f or done:
continue
for clause in [n for n in node.named_children if n.type == "catch_clause"]:
branch = self.branch_ids[clause.start_point[0] + 1, "catch"]
exc = text(clause.named_children[0]).split()[0]
tried = c.calls[start:]
if not tried:
self.notes.append(f"{branch.id}(L{branch.line})は try の中にモック呼び出しがないため例外を起こせません")
continue
def prepare(cc, exc=exc, branch=branch):
first = cc.calls[start]
first.throw = f'new {exc}({self.exception_args(exc)})'
first.stub = None
del cc.calls[start + 1:]
cc.path[-1] = (branch.id, "catch")
c.path.append((branch.id, "例外なし"))
for cc, ff, _ in self.fork(c, f, [("catch", prepare, False)], branch):
result += self.body(clause.child_by_field_name("body"), cc, ff)
return result
def exception_args(self, exc):
info = self.index.get(exc)
if info and info.constructors:
ctor = min(info.constructors, key=len)
return ", ".join('"test"' if t == "String" else "null" for t, _ in ctor)
return '"test"'
def other_value(self, typ, is_enum, listed):
"""どの case にも当たらない値(default 用)"""
if is_enum:
return next((k for k in self.index[typ].constants if k not in listed), None)
if all(re.fullmatch(r"-?\d+", v) for v in listed):
return str(max([int(v) for v in listed] + [0]) + 1)
if all(v.startswith('"') for v in listed):
return '"other"'
return None
def exec_switch(self, node, case, forking):
branch = self.branch_ids[node.start_point[0] + 1, "switch"]
subject = self.sym(node.child_by_field_name("condition"), case)
outs = switch_outcomes(node)
enum_type = None
if subject.kind == "prop":
enum_type = self.index[case.samples[subject.ref].type].methods.get(subject.prop)
elif subject.kind == "param":
enum_type = case.param_types[subject.ref]
is_enum = enum_type in self.index and self.index[enum_type].kind == "enum"
listed = [n for label, _ in outs for n in label.split(",") if n != "default"]
main_idx = next((i for i, (_, b) in enumerate(outs) if not ends_with_exit(b)), 0)
options = []
for i, (label, _) in enumerate(outs):
value = label.split(",")[0]
if value == "default":
value = self.other_value(enum_type, is_enum, listed)
if value is None:
self.notes.append(f"{branch.id}(L{branch.line})の default は、すべての定数が case にあるため到達できません")
continue
def prepare(c, value=value, label=label):
expr = f"{enum_type}.{value}" if is_enum else value
if subject.kind == "prop":
prop = re.sub(r"^(get|is)", "", subject.prop)
c.samples[subject.ref].setters["set" + prop] = expr
elif subject.kind == "param":
before = dict(c.params)
c.params[subject.ref] = expr
self.check_overwrite(before, c, branch, {subject.ref})
else:
c.todos.append(f"{branch.id} の switch が {label} になる入力値を設定してください")
c.path.append((branch.id, label))
options.append((label, prepare, i == main_idx))
result = []
for c, f, label in self.fork(case, forking, options, branch):
body = dict(outs)[label]
result += self.body(body, c, f)
return result
# ----- 入口 -----
def plan(self):
params = []
for p in self.node.child_by_field_name("parameters").named_children:
if p.type == "formal_parameter":
params.append((text(p.child_by_field_name("type")), text(p.child_by_field_name("name"))))
case = Case(text(self.node.child_by_field_name("name")), {}, {t[1]: t[0] for t in params})
for t, n in params:
case.params[n] = self.default_value(t, n, case)
results = self.exec_stmts(self.node.child_by_field_name("body").named_children, case, True)
cases = [c for c, _, _ in results]
cases.sort(key=lambda c: (c.target is not None, int(c.target[0][1:]) if c.target else 0))
return cases
def all_call_sites(self):
"""メソッド内に書かれているモック呼び出し(never() の検証に使う)"""
sites = []
for n in self.descendants(self.node.child_by_field_name("body")):
if n.type == "method_invocation":
obj = n.child_by_field_name("object")
if obj is not None and obj.type == "identifier" and text(obj) in self.mocks:
key = (text(obj), text(n.child_by_field_name("name")))
if key not in sites:
sites.append(key)
return sites✅ 次の記事では…
PART 06 では、ここで作ったケースを Jinja2 のテンプレートに流し込み、JUnit 5 + Mockito のテストクラスとして出力する。