考え方:値を「記号」として持ち歩く

実際には実行しないので、変数の中身は数値や文字列ではなく、その値がどこから来たか という記号として持つ。たとえば 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 で表す。

testgen/cases.py(データ構造)
# ---------- テスト内で組み立てる値 ----------
@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回ずつ通す」ことだけなので、すべての組み合わせを作る必要はない。そこで次のルールでケースを作る。

  1. 各判定で「抜けない側」(return / throw しない側)を 主経路 とし、主経路の状態はそのまま先へ進む
  2. 主経路の状態が判定に出会ったら、主経路でない結果ごとに状態を複製して 枝分かれ させる
  3. 枝分かれした状態は、その後の判定では主経路側だけを通る(さらに枝分かれしない)
  4. ただし、まだどのケースも通っていない結果に出会ったときは、枝分かれした先でも新しいケースを作る
placeOrder の6つの判定B1からB6を主経路が順に通り、各判定から枝分かれしたケースが下に並ぶ図。B3の0回は到達不能、B5のtrueは解けずTODOになる

図1: placeOrder のケース設計。主経路1本と、判定ごとの枝分かれ

4番目のルールは else if の連鎖のためにある。PointService.calcPoints の B3(rank == Rank.SILVER)は、B2 が false のときしか評価されない。B2 の false 側は枝分かれしたケースなので、ルール3だけだと B3 の false 側(BRONZE)を通るケースができない。どの結果をすでに通ったかを seen に覚えておき、未通過の結果なら枝分かれ先でも分岐させる。

testgen/cases.py(fork)
    # ----- 分岐での分かれ方 -----
    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つだ。&& はその逆になる。

testgen/cases.py(alternatives)
    # ----- 条件を満たす組み合わせ -----
    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 が truenullplaceOrder_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 の引数truefalse
testgen/cases.py(solve_compare)
    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 / catchtry 本体を処理したあと、本体の最初のモック呼び出しに例外を投げさせる枝を作り、catch 本体を処理する
switchcase ごとに枝分かれし、対象がサンプルの getter なら setter で、引数なら引数で値を決める。default には、どの case にもない定数を使う
return / throw状態を「抜けた」にし、戻り値の式や例外の型を記録する
式の中の三項演算子式文・宣言・return の中で見つけたら、その場で枝分かれする
testgen/cases.py(exec_if・exec_foreach・exec_try)
    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

exec_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 → 1return order
B1 truenull—IllegalArgumentException
B1 true" "—IllegalArgumentException
B2 trueList.of()—IllegalArgumentException
B4 true明細1件(数量 1)getStock → 0OutOfStockException
B5 true明細1件getStock → 1(入力値 TODO)return order
B6 catch明細1件getStock → 1、send → MailExceptionreturn order
cancelOrder主経路1LfindById → Optional.of(order)、status = NEWreturn true
B1 true1LfindById → Optional.empty()return false
B2 SHIPPED1Lstatus = SHIPPEDIllegalStateException
B2 default1Lstatus = CANCELLEDreturn false

B5(order.total() >= 10000)だけは、order がメソッドの中で new された値で、合計は明細から計算されるため決められなかった。PART 02 で予想したとおり、ここは人に任せる部分になる。それ以外の分岐は、すべて入力とスタブが自動で決まった。

cases.py の全体を表示する
testgen/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 のテストクラスとして出力する。

→ PART 06 — テストコード生成へ