How to use the pyccel.printers.fcode function in pyccel

def test_FunctionDef():
    from test_parser import test_FunctionDef as test
    ast = test()

    for stmt in ast.statements:
        if isinstance(stmt, FunctionDefStmt):
            code    = fcode(stmt.expr)

            prelude = ""
            for s in stmt.declarations:
                prelude += fcode(s) + "\n"
#            print prelude
            print code
# ...

def test_Import():
    from test_parser import test_Import as test
    ast = test()

    for stmt in ast.statements:
        if isinstance(stmt, ImportFromStmt):
            code = fcode(stmt.expr)
            print code
# ...

def test_fcode_Piecewise():
    expr = Piecewise((x, x < 1), (x**2, True))
    assert fcode(expr) == "merge(x, x**2, x < 1)"
    expr = Piecewise((Assign(c, x), x < 1), (Assign(c, x**2), True))
    assert fcode(expr) == (
            "if (x < 1) then\n"
            "    c = x\n"
            "else\n"
            "    c = x**2\n"
            "end if"
    )
    expr = Piecewise((x, x < 1), (x + 1, x < 2), (x**2, True))
    assert fcode(expr) == "merge(x, merge(x + 1, x**2, x < 2), x < 1)"
    expr = Piecewise((Assign(c, x), x < 1), (Assign(c, x + 1), x < 2), (Assign(c, x**2), True))
    assert fcode(expr) == (
            "if (x < 1) then\n"
            "    c = x\n"
            "else if (x < 2) then\n"
            "    c = x + 1\n"
            "else\n"
            "    c = x**2\n"
            "end if")
    # Check that Piecewise without a True (default) condition error
    expr = Piecewise((x, x < 1), (x**2, x > 1), (sin(x), x > 0))
    raises(ValueError, lambda: fcode(expr))

def test_fcode_complex():
    assert fcode(I) == "cmplx(0,1)"
    assert fcode(4*I) == "cmplx(0,4)"
    assert fcode(3 + 4*I) == "cmplx(3,4)"
    assert fcode(3 + 4*I + x) == "cmplx(3,4) + x"
    assert fcode(I*x) == "cmplx(0,1)*x"
    assert fcode(3 + 4*I - x) == "cmplx(3,4) - x"
    assert fcode(5*m) == "5*m"
    assert fcode(I*m) == "cmplx(0,1)*m"
    assert fcode(3 + m) == "m + 3"

assert fcode(Or(Equivalent(z, x), y)) == "y .or. (x .eqv. z)"
    assert fcode(Or(Equivalent(x, y), z)) == "z .or. (x .eqv. y)"
    # mixed Xor/Equivalent
    assert fcode(Equivalent(Xor(y, z, evaluate=False), x)) == "x .eqv. (y .neqv. z)"
    assert fcode(Equivalent(Xor(z, x, evaluate=False), y)) == "y .eqv. (x .neqv. z)"
    assert fcode(Equivalent(Xor(x, y, evaluate=False), z)) == "z .eqv. (x .neqv. y)"
    assert fcode(Xor(Equivalent(y, z), x, evaluate=False)) == "x .neqv. (y .eqv. z)"
    assert fcode(Xor(Equivalent(z, x), y, evaluate=False)) == "y .neqv. (x .eqv. z)"
    assert fcode(Xor(Equivalent(x, y), z, evaluate=False)) == "z .neqv. (x .eqv. y)"
    # mixed And/Xor
    assert fcode(Xor(And(y, z), x, evaluate=False)) == "x .neqv. y .and. z"
    assert fcode(Xor(And(z, x), y, evaluate=False)) == "y .neqv. x .and. z"
    assert fcode(Xor(And(x, y), z, evaluate=False)) == "z .neqv. x .and. y"
    assert fcode(And(Xor(y, z, evaluate=False), x)) == "x .and. (y .neqv. z)"
    assert fcode(And(Xor(z, x, evaluate=False), y)) == "y .and. (x .neqv. z)"
    assert fcode(And(Xor(x, y, evaluate=False), z)) == "z .and. (x .neqv. y)"
    # mixed Or/Xor
    assert fcode(Xor(Or(y, z), x, evaluate=False)) == "x .neqv. y .or. z"
    assert fcode(Xor(Or(z, x), y, evaluate=False)) == "y .neqv. x .or. z"
    assert fcode(Xor(Or(x, y), z, evaluate=False)) == "z .neqv. x .or. y"
    assert fcode(Or(Xor(y, z, evaluate=False), x)) == "x .or. (y .neqv. z)"
    assert fcode(Or(Xor(z, x, evaluate=False), y)) == "y .or. (x .neqv. z)"
    assert fcode(Or(Xor(x, y, evaluate=False), z)) == "z .or. (x .neqv. y)"
    # ternary Xor
    assert fcode(Xor(x, y, z, evaluate=False)) == "x .neqv. y .neqv. z"
    assert fcode(Xor(x, y, Not(z), evaluate=False)) == "x .neqv. y .neqv. .not. z"
    assert fcode(Xor(x, Not(y), z, evaluate=False)) == "x .neqv. z .neqv. .not. y"
    assert fcode(Xor(Not(x), y, z, evaluate=False)) == "y .neqv. z .neqv. .not. x"

def test_fcode_Indexed():
    n, m, o = symbols('n m o', integer=True)
    i, j, k = Idx('i', n), Idx('j', m), Idx('k', o)
    x = IndexedBase('x')[j]
    assert fcode(x) == 'x(j)'
    A = IndexedBase('A')[i, j]
    assert fcode(A) == 'A(i, j)'
    B = IndexedBase('B')[i, j, k]
    assert fcode(B) == 'B(i, j, k)'

def test_fcode_precedence():
    assert fcode(And(x < y, y < x + 1)) == "x < y .and. y < x + 1"
    assert fcode(Or(x < y, y < x + 1)) == "x < y .or. y < x + 1"
    assert fcode(Xor(x < y, y < x + 1, evaluate=False)) == "x < y .neqv. y < x + 1"
    assert fcode(Equivalent(x < y, y < x + 1)) == "x < y .eqv. y < x + 1"

def test_fcode_sqrt():
    assert fcode(sqrt(x)) == 'sqrt(x)'
    assert fcode(sqrt(n)) == 'sqrt(dble(n))'
    assert fcode(x**0.5) == 'sqrt(x)'
    assert fcode(sqrt(10)) == 'sqrt(10.0d0)'

def test_fcode_Pow():
    assert fcode(x**3) == "x**3"
    assert fcode(x**(y**3)) == "x**(y**3)"
    g = implemented_function('g2', Lambda(x, sin(x)))
    assert fcode((g(x)*3.5)**(x - y**x)/(x**2 + y)) == "(3.5d0*sin(x))**(x - y**x)/(x**2 + y)"
    assert fcode(x**-1.0) == '1.0/x'
    assert fcode(x**Rational(2, 3)) == 'x**(2.0d0/3.0d0)'
    assert fcode(x**-2.0, 'y') == 'y = x**(-2.0d0)'

def test_fcode_Import():
    assert fcode(Import('math', 'sin')) == 'use math, only: sin'