code: def test_ci():
      m1 = exp_polar(I * pi)
      m1_ = exp_polar(-I * pi)
      pI = exp_polar(I * pi / 2)
      mI = exp_polar(-I * pi / 2)
  
      assert Ci(m1 * x) == Ci(x) + I * pi
      assert Ci(m1_ * x) == Ci(x) - I * pi
      assert Ci(pI * x) == Chi(x) + I * pi / 2
      assert Ci(mI * x) == Chi(x) - I * pi / 2
      assert Chi(m1 * x) == Chi(x) + I * pi
      assert Chi(m1_ * x) == Chi(x) - I * pi
      assert Chi(pI * x) == Ci(x) + I * pi / 2
      assert Chi(mI * x) == Ci(x) - I * pi / 2
      assert Ci(exp_polar(2 * I * pi) * x) == Ci(x) + 2 * I * pi
      assert Chi(exp_polar(-2 * I * pi) * x) == Chi(x) - 2 * I * pi
      assert Chi(exp_polar(2 * I * pi) * x) == Chi(x) + 2 * I * pi
      assert Ci(exp_polar(-2 * I * pi) * x) == Ci(x) - 2 * I * pi
  
      assert Ci(oo) is S.Zero
      assert Ci(-oo) == I * pi
      assert Chi(oo) is oo
      assert Chi(-oo) is oo
  
      assert mytd(Ci(x), cos(x) / x, x)
      assert mytd(Chi(x), cosh(x) / x, x)
  
      assert mytn(
          Ci(x),
          Ci(x).rewrite(Ei),
          Ei(x * exp_polar(-I * pi / 2)) / 2
          + Ei(x * exp_polar(I * pi / 2)) / 2,
          x,
      )
      assert mytn(
          Chi(x),
          Chi(x).rewrite(Ei),
          Ei(x) / 2 + Ei(x * exp_polar(I * pi)) / 2 - I * pi / 2,
          x,
      )
  
      assert tn_arg(Ci)
      assert tn_arg(Chi)
  
      assert Ci(x).nseries(x, n=4) == EulerGamma + log(
          x
      ) - x**2 / 4 + x**4 / 96 + O(x**5)
      assert Chi(x).nseries(x, n=4) == EulerGamma + log(
          x
      ) + x**2 / 4 + x**4 / 96 + O(x**5)
  
      assert (
          Ci(x).series(x, oo)
          == -cos(x) * (-6 / x**3 + 1 / x + O(x ** (-7), (x, oo))) / x
          + (24 / x**4 - 2 / x**2 + 1 + O(x ** (-7), (x, oo)))
          * sin(x)
          / x
      )
      assert limit(log(x) - Ci(2 * x), x, 0) == -log(2) - EulerGamma
      assert (
          Ci(x).rewrite(uppergamma)
          == -expint(1, x * exp_polar(-I * pi / 2)) / 2
          - expint(1, x * exp_polar(I * pi / 2)) / 2
      )
      assert (
          Ci(x).rewrite(expint)
          == -expint(1, x * exp_polar(-I * pi / 2)) / 2
          - expint(1, x * exp_polar(I * pi / 2)) / 2
      )
      raises(ArgumentIndexError, lambda: Ci(x).fdiff(2))
  
imports: from sympy.core.function import diff, expand, expand_func
  from sympy.core import EulerGamma
  from sympy.core.numbers import E, Float, I, Rational, nan, oo, pi
  from sympy.core.singleton import S
  from sympy.core.symbol import Symbol, symbols
  from sympy.functions.elementary.complexes import conjugate, im, polar_lift, re
  from sympy.functions.elementary.exponential import exp, exp_polar, log
  from sympy.functions.elementary.hyperbolic import cosh, sinh
  from sympy.functions.elementary.miscellaneous import sqrt
  from sympy.functions.elementary.trigonometric import cos, sin, sinc
  from sympy.functions.special.error_functions import Chi, Ci, E1, Ei, Li, Shi, Si, erf, erf2, erf2inv, erfc, erfcinv, erfi, erfinv, expint, fresnelc, fresnels, li
  from sympy.functions.special.gamma_functions import gamma, uppergamma
  from sympy.functions.special.hyper import hyper, meijerg
  from sympy.integrals.integrals import Integral, integrate
  from sympy.series.gruntz import gruntz
  from sympy.series.limits import limit
  from sympy.series.order import O
  from sympy.core.expr import unchanged
  from sympy.core.function import ArgumentIndexError
  from sympy.functions.special.error_functions import _erfs, _eis
  from sympy.testing.pytest import raises
label_desc: Use image node_id 26 for calling a global function with example usage: test_ci() without return types