// Step 1939: BehavioralParityChecker
//
//  t1: check — all match → allMatch=true, empty divergentLanguages
//  t2: check — one diverges → allMatch=false, divergentLanguages lists it
//  t3: checkAgainstReference uses named language as reference
//  t4: allPass — true when all ran+match; false when one doesn't run
//  t5: failingLanguages returns divergent set

#include "BehavioralParityChecker.h"
#include <iostream>

namespace ws = whetstone;
static int p=0,f=0;
#define T(n) { std::cout<<"  "<<#n<<"... "; }
#define P() { std::cout<<"PASS\n"; ++p; }
#define F(m) { std::cout<<"FAIL: "<<m<<"\n"; ++f; }
#define C(c,m) if(!(c)){F(m);return;}

static std::vector<ws::RunResult> matching() {
    return {{"Python","1 2 3\n",0,true},{"Rust","1 2 3\n",0,true},{"Go","1 2 3\n",0,true}};
}

void t1(){
    T(check_all_match);
    ws::BehavioralParityChecker c;
    auto r = c.check(matching());
    C(r.allMatch,                    "allMatch true");
    C(r.divergentLanguages.empty(),  "no divergents");
    C(r.referenceLanguage == "Python","reference is Python (first)");
    P();
}

void t2(){
    T(check_one_diverges);
    ws::BehavioralParityChecker c;
    auto results = matching();
    results[2].output = "3 2 1\n"; // Go diverges
    auto r = c.check(results);
    C(!r.allMatch,                   "not allMatch");
    C(r.divergentLanguages.size()==1,"one divergent");
    C(r.divergentLanguages[0]=="Go", "Go divergent");
    P();
}

void t3(){
    T(checkAgainstReference_named_language);
    ws::BehavioralParityChecker c;
    std::vector<ws::RunResult> results = {
        {"Python","A\n",0,true},
        {"Rust",  "B\n",0,true},
        {"Go",    "A\n",0,true}
    };
    // Reference = Python ("A\n"); Rust diverges
    auto r = c.checkAgainstReference(results,"Python");
    C(!r.allMatch,                    "not allMatch");
    C(r.referenceOutput == "A\n",     "reference output");
    C(r.divergentLanguages.size()==1, "one divergent");
    C(r.divergentLanguages[0]=="Rust","Rust diverges");
    // Reference = Rust ("B\n"); Python and Go diverge
    auto r2 = c.checkAgainstReference(results,"Rust");
    C(r2.divergentLanguages.size()==2,"two diverge vs Rust");
    P();
}

void t4(){
    T(allPass_true_and_false);
    ws::BehavioralParityChecker c;
    C(c.allPass(matching()), "matching all pass");
    auto withFail = matching();
    withFail[1].ran = false;
    C(!c.allPass(withFail), "not all pass when one didn't run");
    auto diverged = matching();
    diverged[2].output = "wrong";
    C(!c.allPass(diverged), "not all pass when output diverges");
    P();
}

void t5(){
    T(failingLanguages_returns_divergent_set);
    ws::BehavioralParityChecker c;
    auto results = matching();
    results[1].output = "X\n";
    results[2].output = "Y\n";
    auto fl = c.failingLanguages(results);
    C(fl.size() == 2, "two failing");
    P();
}

int main(){
    std::cout << "Step 1939: BehavioralParityChecker\n";
    t1(); t2(); t3(); t4(); t5();
    std::cout << "\n" << p << "/" << (p+f) << " passed\n";
    return f > 0 ? 1 : 0;
}