#include<rational/rational.h>

#include<iostream>
#include<sstream>

bool testParse(const std::string&str) {
    std::istringstream istrm(str);
    Rational z(1,1);
    istrm>>z;
    if(istrm.good()) {
        std::cout<<"Read success: "<<str<<"->"<<z<<std::endl;
    } else{
        std::cout<<"Read error:   "<<str<<"->"<<z<<std::endl;
    }
    return istrm.good();
}
bool testComplexEquality(Rational lhs, Rational answer) {
    if (lhs == answer) {
        std::cout<<"Operator == success:"<<lhs<<"=="<<answer<<std::endl;
        return true;
    } else {
        std::cout<<"Operator == error:"<<lhs<<"=="<<answer<<std::endl;
        return false;
    }
}
bool testComplexUnequality(Rational lhs, Rational answer) {
    if (lhs != answer) {
        std::cout<<"Operator != success:"<<lhs<<"!="<<answer<<std::endl;
        return true;
    } else {
        std::cout<<"Operator != error:"<<lhs<<"!="<<answer<<std::endl;
        return false;
    }
}
bool testComplexSum(Rational lhs, Rational rhs, Rational answer) {
    bool t(false);
    if (lhs+rhs == answer) {
        std::cout<<"Operator +  success:"<<lhs<<"+"<<rhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator +  error:"<<lhs<<"+"<<rhs<<"="<<answer<<std::endl;
        t = false;
    }

    lhs+=rhs;

    if (lhs == answer) {
        std::cout<<"Operator += success:"<<lhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator += error:"<<lhs<<"="<<answer<<std::endl;
        t = false;
    }

    return t;
}
bool testComplexSubtracting(Rational lhs, Rational rhs, Rational answer) {
    bool t(false);
    if (lhs-rhs == answer) {
        std::cout<<"Operator -  success:"<<lhs<<"-"<<rhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator -  error:"<<lhs<<"-"<<rhs<<"="<<answer<<std::endl;
        t = false;
    }

    lhs-=rhs;

    if (lhs == answer) {
        std::cout<<"Operator -= success:"<<lhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator -= success:"<<lhs<<"="<<answer<<std::endl;
        t = false;
    }
    return t;
}
bool testComplexMultiplication(Rational lhs, Rational rhs, Rational answer) {
    bool t(false);
    if (lhs*rhs == answer) {
        std::cout<<"Operator *  success:"<<lhs<<"*"<<rhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator *  error:"<<lhs<<"*"<<rhs<<"="<<answer<<std::endl;
        t = false;
    }

    lhs *= rhs;

    if (lhs == answer) {
        std::cout<<"Operator *= success:"<<lhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator *= error:"<<lhs<<"="<<answer<<std::endl;
        t = false;
    }
    return t;
}
bool testComplexDividing(Rational lhs, Rational rhs, Rational answer) {
    bool t(false);
    if (lhs/rhs == answer) {
        std::cout<<"Operator /  success:"<<lhs<<"/"<<rhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator /  error:"<<lhs<<"/"<<rhs<<"="<<answer<<std::endl;
        t = false;
    }

    lhs /= rhs;

    if (lhs == answer) {
        std::cout<<"Operator /= success:"<<lhs<<"="<<answer<<std::endl;
        t = true;
    } else {
        std::cout<<"Operator /= error:"<<lhs<<"="<<answer<<std::endl;
        t = false;
    }
    return t;
}

bool complexEqualityTest() {
    //TODO add more tests here
    if (testComplexEquality(Rational(1,1), Rational(1,1))
        && testComplexUnequality(Rational(1,1), Rational(1,2)))
        return true;
    return false;
}

int main() {
    using namespace std;
    Rational b(1, 1);
    cin >> b;
    cout << b;

    if (complexEqualityTest()) {
        Rational lhs(1,1);
        Rational rhs(5, 5);

        testComplexSum(lhs, rhs, Rational(2, 1));
        testComplexSubtracting(lhs, rhs, Rational(0, 1));
        testComplexMultiplication(lhs, rhs, Rational(1,1));
        testComplexDividing(lhs, rhs, Rational(1,1));
    }
    return 0;
}