code: def test_expint():
      """Test various exponential integrals."""
      from sympy.core.symbol import Symbol
      from sympy.functions.elementary.hyperbolic import sinh
      from sympy.functions.special.error_functions import (
          Chi,
          Ci,
          Ei,
          Shi,
          Si,
          expint,
      )
  
      assert simplify(
          unpolarify(
              integrate(
                  exp(-z * x) / x**y,
                  (x, 1, oo),
                  meijerg=True,
                  conds="none",
              )
              .rewrite(expint)
              .expand(func=True)
          )
      ) == expint(y, z)
  
      assert integrate(
          exp(-z * x) / x, (x, 1, oo), meijerg=True, conds="none"
      ).rewrite(expint).expand() == expint(1, z)
      assert integrate(
          exp(-z * x) / x**2, (x, 1, oo), meijerg=True, conds="none"
      ).rewrite(expint).expand() == expint(2, z).rewrite(Ei).rewrite(
          expint
      )
      assert (
          integrate(
              exp(-z * x) / x**3,
              (x, 1, oo),
              meijerg=True,
              conds="none",
          )
          .rewrite(expint)
          .expand()
          == expint(3, z).rewrite(Ei).rewrite(expint).expand()
      )
  
      t = Symbol("t", positive=True)
      assert integrate(
          -cos(x) / x, (x, t, oo), meijerg=True
      ).expand() == Ci(t)
      assert (
          integrate(-sin(x) / x, (x, t, oo), meijerg=True).expand()
          == Si(t) - pi / 2
      )
      assert integrate(sin(x) / x, (x, 0, z), meijerg=True) == Si(z)
      assert integrate(sinh(x) / x, (x, 0, z), meijerg=True) == Shi(z)
      assert integrate(exp(-x) / x, x, meijerg=True).expand().rewrite(
          expint
      ) == I * pi - expint(1, x)
      assert (
          integrate(exp(-x) / x**2, x, meijerg=True)
          .rewrite(expint)
          .expand()
          == expint(1, x) - exp(-x) / x - I * pi
      )
  
      u = Symbol("u", polar=True)
      assert integrate(
          cos(u) / u, u, meijerg=True
      ).expand().as_independent(u)[1] == Ci(u)
      assert integrate(
          cosh(u) / u, u, meijerg=True
      ).expand().as_independent(u)[1] == Chi(u)
  
      assert integrate(expint(1, x), x, meijerg=True).rewrite(
          expint
      ).expand() == x * expint(1, x) - exp(-x)
      assert (
          integrate(expint(2, x), x, meijerg=True)
          .rewrite(expint)
          .expand()
          == -(x**2) * expint(1, x) / 2
          + x * exp(-x) / 2
          - exp(-x) / 2
      )
      assert simplify(
          unpolarify(
              integrate(expint(y, x), x, meijerg=True)
              .rewrite(expint)
              .expand(func=True)
          )
      ) == -expint(y + 1, x)
  
      assert integrate(Si(x), x, meijerg=True) == x * Si(x) + cos(x)
      assert integrate(Ci(u), u, meijerg=True).expand() == u * Ci(
          u
      ) - sin(u)
      assert integrate(Shi(x), x, meijerg=True) == x * Shi(x) - cosh(x)
      assert integrate(Chi(u), u, meijerg=True).expand() == u * Chi(
          u
      ) - sinh(u)
  
      assert (
          integrate(Si(x) * exp(-x), (x, 0, oo), meijerg=True) == pi / 4
      )
      assert (
          integrate(expint(1, x) * sin(x), (x, 0, oo), meijerg=True)
          == log(2) / 2
      )
  
imports: from sympy.core.function import expand_func
  from sympy.core.numbers import I, Rational, oo, pi
  from sympy.core.singleton import S
  from sympy.core.sorting import default_sort_key
  from sympy.functions.elementary.complexes import Abs, arg, re, unpolarify
  from sympy.functions.elementary.exponential import exp, exp_polar, log
  from sympy.functions.elementary.hyperbolic import cosh, acosh
  from sympy.functions.elementary.miscellaneous import sqrt
  from sympy.functions.elementary.piecewise import Piecewise, piecewise_fold
  from sympy.functions.elementary.trigonometric import cos, sin, sinc, asin
  from sympy.functions.special.error_functions import erf, erfc
  from sympy.functions.special.gamma_functions import gamma, polygamma
  from sympy.functions.special.hyper import hyper, meijerg
  from sympy.integrals.integrals import Integral, integrate
  from sympy.simplify.hyperexpand import hyperexpand
  from sympy.simplify.simplify import simplify
  from sympy.integrals.meijerint import _rewrite_single, _rewrite1, meijerint_indefinite, _inflate_g, _create_lookup_table, meijerint_definite, meijerint_inversion
  from sympy.testing.pytest import slow
  from sympy.core.random import verify_numerically, random_complex_number
  from sympy.abc import x, y, a, b, c, d, s, t, z
label_desc: Use image node_id 16 for calling a global function with example usage: test_expint() without return types