code: def test_fourier_transform():
      from sympy.core.function import (
          expand,
          expand_complex,
          expand_trig,
      )
      from sympy.polys.polytools import factor
      from sympy.simplify.simplify import simplify
  
      FT = fourier_transform
      IFT = inverse_fourier_transform
  
      def simp(x):
          return simplify(expand_trig(expand_complex(expand(x))))
  
      def sinc(x):
          return sin(pi * x) / (pi * x)
  
      k = symbols("k", real=True)
      f = Function("f")
  
      # TODO for this to work with real a, need to expand abs(a*x) to abs(a)*abs(x)
      a = symbols("a", positive=True)
      b = symbols("b", positive=True)
  
      posk = symbols("posk", positive=True)
  
      # Test unevaluated form
      assert fourier_transform(f(x), x, k) == FourierTransform(
          f(x), x, k
      )
      assert inverse_fourier_transform(
          f(k), k, x
      ) == InverseFourierTransform(f(k), k, x)
  
      # basic examples from wikipedia
      assert (
          simp(FT(Heaviside(1 - abs(2 * a * x)), x, k))
          == sinc(k / a) / a
      )
      # TODO IFT is a *mess*
      assert (
          simp(FT(Heaviside(1 - abs(a * x)) * (1 - abs(a * x)), x, k))
          == sinc(k / a) ** 2 / a
      )
      # TODO IFT
  
      assert factor(
          FT(exp(-a * x) * Heaviside(x), x, k), extension=I
      ) == 1 / (a + 2 * pi * I * k)
      # NOTE: the ift comes out in pieces
      assert IFT(1 / (a + 2 * pi * I * x), x, posk, noconds=False) == (
          exp(-a * posk),
          True,
      )
      assert IFT(1 / (a + 2 * pi * I * x), x, -posk, noconds=False) == (
          0,
          True,
      )
      assert IFT(
          1 / (a + 2 * pi * I * x),
          x,
          symbols("k", negative=True),
          noconds=False,
      ) == (0, True)
      # TODO IFT without factoring comes out as meijer g
  
      assert (
          factor(FT(x * exp(-a * x) * Heaviside(x), x, k), extension=I)
          == 1 / (a + 2 * pi * I * k) ** 2
      )
      assert FT(exp(-a * x) * sin(b * x) * Heaviside(x), x, k) == b / (
          b**2 + (a + 2 * I * pi * k) ** 2
      )
  
      assert FT(exp(-a * x**2), x, k) == sqrt(pi) * exp(
          -(pi**2) * k**2 / a
      ) / sqrt(a)
      assert IFT(sqrt(pi / a) * exp(-((pi * k) ** 2) / a), k, x) == exp(
          -a * x**2
      )
      assert FT(exp(-a * abs(x)), x, k) == 2 * a / (
          a**2 + 4 * pi**2 * k**2
      )
  
imports: from sympy.integrals.transforms import mellin_transform, inverse_mellin_transform, fourier_transform, inverse_fourier_transform, sine_transform, inverse_sine_transform, cosine_transform, inverse_cosine_transform, hankel_transform, inverse_hankel_transform, FourierTransform, SineTransform, CosineTransform, InverseFourierTransform, InverseSineTransform, InverseCosineTransform, IntegralTransformError
  from sympy.integrals.laplace import laplace_transform, inverse_laplace_transform
  from sympy.core.function import Function, expand_mul
  from sympy.core import EulerGamma
  from sympy.core.numbers import I, Rational, oo, pi
  from sympy.core.singleton import S
  from sympy.core.symbol import Symbol, symbols
  from sympy.functions.combinatorial.factorials import factorial
  from sympy.functions.elementary.complexes import re, unpolarify
  from sympy.functions.elementary.exponential import exp, exp_polar, log
  from sympy.functions.elementary.miscellaneous import sqrt
  from sympy.functions.elementary.trigonometric import atan, cos, sin, tan
  from sympy.functions.special.bessel import besseli, besselj, besselk, bessely
  from sympy.functions.special.delta_functions import Heaviside
  from sympy.functions.special.error_functions import erf, expint
  from sympy.functions.special.gamma_functions import gamma
  from sympy.functions.special.hyper import meijerg
  from sympy.simplify.gammasimp import gammasimp
  from sympy.simplify.hyperexpand import hyperexpand
  from sympy.simplify.trigsimp import trigsimp
  from sympy.testing.pytest import XFAIL, slow, skip, raises
  from sympy.abc import x, s, a, b, c, d
label_desc: Use image node_id 10 for calling a global function with example usage: test_fourier_transform() and returns: simplify, unknown