স্টেটমেন্ট ও ব্রাঞ্চ কভারেজ

import sys

def measure_coverage(func, test_calls):
    # test_calls: একটি লিস্ট, প্রতিটি এলিমেন্ট (args_tuple, kwargs_dict)
    target_code = func.__code__
    executed_lines = set()
    edges = set()

    def tracer(frame, event, arg):
        if event == 'call':
            if frame.f_code is target_code:
                tracer.prev_line = None
                return tracer   # ফ্রেমটি আমাদের ফাংশনের -- এর 'line' ইভেন্টও চাই
            return None         # অন্য কোনো ফাংশন-কল -- এর ভেতরে ট্রেস করার দরকার নেই
        if event == 'line' and frame.f_code is target_code:
            lineno = frame.f_lineno
            executed_lines.add(lineno)
            if tracer.prev_line is not None:
                edges.add((tracer.prev_line, lineno))
            tracer.prev_line = lineno
        return tracer

    tracer.prev_line = None

    results = []
    for args, kwargs in test_calls:
        sys.settrace(tracer)
        try:
            results.append(func(*args, **kwargs))
        finally:
            sys.settrace(None)   # প্রতিটি মাপার পর ট্রেসিং বন্ধ করা আবশ্যক
    return executed_lines, edges, results


def count_executable_lines(func):
    # func.__code__.co_lines() কম্পাইল-করা বাইটকোড থেকে সরাসরি প্রতিটি প্রকৃত এক্সিকিউটেবল
    # লাইন-নাম্বার দেয় (Python 3.10+, PEP 626) -- এর জন্য সোর্স ফাইল পড়ার দরকার নেই, তাই এই
    # লেসন-স্যান্ডবক্সে exec() দিয়ে চালানো কোডের ক্ষেত্রেও (যেখানে inspect.getsource() কাজ করে
    # না, কারণ কোনো real ফাইল নেই) এটি নির্ভুলভাবে কাজ করে। এই একই লাইন-নাম্বারগুলো
    # sys.settrace()-এর 'line' ইভেন্টেও (frame.f_lineno) দেখা যাবে, তাই দুটো সংখ্যা তুলনাযোগ্য।
    code = func.__code__
    line_numbers = set()
    for _start, _end, lineno in code.co_lines():
        if lineno is not None and lineno != code.co_firstlineno:
            line_numbers.add(lineno)
    return sorted(line_numbers)


def grade_score(score):
    if score >= 90:
        grade = "A"
    elif score >= 75:
        grade = "B"
    else:
        grade = "C"
    return grade


executable_lines = count_executable_lines(grade_score)
print("grade_score-এর executable লাইন সংখ্যা:", len(executable_lines), "-> লাইন:", executable_lines)

test_calls = [((95,), {}), ((80,), {}), ((50,), {})]
executed_lines, edges, results = measure_coverage(grade_score, test_calls)

print("প্রতিটি কলের রেজাল্ট:", results)
print("মোট এক্সিকিউটেড লাইন (ইউনিয়ন):", sorted(executed_lines))

coverage_pct = len(executed_lines) / len(executable_lines) * 100
print(f"স্টেটমেন্ট কভারেজ: {len(executed_lines)}/{len(executable_lines)} = {coverage_pct:.1f}%")

# (এই সেলটি আগের সেলে ডিফাইন করা measure_coverage() ও count_executable_lines() পুনরায় ব্যবহার করছে)

def apply_discount(price, is_vip):
    if is_vip:
        price = price * 0.9
    return price

exec_lines_discount = count_executable_lines(apply_discount)
print("apply_discount-এর executable লাইন:", exec_lines_discount)

if_line, body_line, after_line = exec_lines_discount

# --- টেস্ট সেট ১: শুধু is_vip=True দিয়ে একবার কল করা হলো ---
executed1, edges1, results1 = measure_coverage(apply_discount, [((100, True), {})])
stmt_cov1 = len(executed1) / len(exec_lines_discount) * 100

true_branch_1 = (if_line, body_line) in edges1     # if -> discount লাইন (True পথ)
false_branch_1 = (if_line, after_line) in edges1   # if -> সরাসরি return (False পথ)
branch_cov1 = (true_branch_1 + false_branch_1) / 2 * 100

print("\n[টেস্ট সেট ১: শুধু is_vip=True]")
print("এক্সিকিউটেড লাইন:", sorted(executed1), f"-> স্টেটমেন্ট কভারেজ: {stmt_cov1:.0f}%")
print(f"True ব্রাঞ্চ কভার হয়েছে: {true_branch_1}  |  False ব্রাঞ্চ কভার হয়েছে: {false_branch_1}")
print(f"ব্রাঞ্চ কভারেজ: {branch_cov1:.0f}%   (স্টেটমেন্ট কভারেজ {stmt_cov1:.0f}% হওয়া সত্ত্বেও!)")

# --- টেস্ট সেট ২: is_vip=True এবং is_vip=False দুটোই কল করা হলো ---
executed2, edges2, results2 = measure_coverage(
    apply_discount, [((100, True), {}), ((100, False), {})]
)
stmt_cov2 = len(executed2) / len(exec_lines_discount) * 100
true_branch_2 = (if_line, body_line) in edges2
false_branch_2 = (if_line, after_line) in edges2
branch_cov2 = (true_branch_2 + false_branch_2) / 2 * 100

print("\n[টেস্ট সেট ২: is_vip=True এবং is_vip=False দুটোই]")
print("এক্সিকিউটেড লাইন:", sorted(executed2), f"-> স্টেটমেন্ট কভারেজ: {stmt_cov2:.0f}%")
print(f"ব্রাঞ্চ কভারেজ: {branch_cov2:.0f}%")