def test_rel_subs():
    e = Relational(x, y, '==')
    e = e.subs(x,z)

    assert isinstance(e, Equality)
    assert e.lhs == z
    assert e.rhs == y

    e = Relational(x, y, '<')
    e = e.subs(x,z)

    assert isinstance(e, StrictInequality)
    assert e.lhs == z
    assert e.rhs == y

def test_rel_subs():
    e = Relational(x, y, "==")
    e = e.subs(x, z)

    assert isinstance(e, Equality)
    assert e.lhs == z
    assert e.rhs == y

    e = Relational(x, y, "<")
    e = e.subs(x, z)

    assert isinstance(e, StrictInequality)
    assert e.lhs == z
    assert e.rhs == y

    e = Eq(x, 0)
    assert e.subs(x, 0) == True
    assert e.subs(x, 1) == False

 def __new__(cls, lhs, rhs=0, **assumptions):
     from sympy.matrices.expressions.matexpr import (
         MatrixElement, MatrixSymbol)
     from sympy.tensor.indexed import Indexed
     lhs = _sympify(lhs)
     rhs = _sympify(rhs)
     # Tuple of things that can be on the lhs of an assignment
     assignable = (Symbol, MatrixSymbol, MatrixElement, Indexed)
     if not isinstance(lhs, assignable):
         raise TypeError("Cannot assign to lhs of type %s." % type(lhs))
     # Indexed types implement shape, but don't define it until later. This
     # causes issues in assignment validation. For now, matrices are defined
     # as anything with a shape that is not an Indexed
     lhs_is_mat = hasattr(lhs, 'shape') and not isinstance(lhs, Indexed)
     rhs_is_mat = hasattr(rhs, 'shape') and not isinstance(rhs, Indexed)
     # If lhs and rhs have same structure, then this assignment is ok
     if lhs_is_mat:
         if not rhs_is_mat:
             raise ValueError("Cannot assign a scalar to a matrix.")
         elif lhs.shape != rhs.shape:
             raise ValueError("Dimensions of lhs and rhs don't align.")
     elif rhs_is_mat and not lhs_is_mat:
         raise ValueError("Cannot assign a matrix to a scalar.")
     return Relational.__new__(cls, lhs, rhs, **assumptions)

def test_rel_subs():
    e = Relational(x, y, '==')
    e = e.subs(x, z)

    assert isinstance(e, Equality)
    assert e.lhs == z
    assert e.rhs == y

    e = Relational(x, y, '>=')
    e = e.subs(x, z)

    assert isinstance(e, GreaterThan)
    assert e.lhs == z
    assert e.rhs == y

    e = Relational(x, y, '<=')
    e = e.subs(x, z)

    assert isinstance(e, LessThan)
    assert e.lhs == z
    assert e.rhs == y

    e = Relational(x, y, '>')
    e = e.subs(x, z)

    assert isinstance(e, StrictGreaterThan)
    assert e.lhs == z
    assert e.rhs == y

    e = Relational(x, y, '<')
    e = e.subs(x, z)

    assert isinstance(e, StrictLessThan)
    assert e.lhs == z
    assert e.rhs == y

    e = Eq(x, 0)
    assert e.subs(x, 0) is S.true
    assert e.subs(x, 1) is S.false

    def __new__(cls, lhs, rhs=0, **options):
        lhs = _sympify(lhs)
        rhs = _sympify(rhs)

        return Relational.__new__(cls, lhs, rhs, **options)