code: def test_datetime64_tz_fillna(self, tz, unit):
      # DatetimeLikeBlock
      ser = Series(
          [
              Timestamp("2011-01-01 10:00"),
              NaT,
              Timestamp("2011-01-03 10:00"),
              NaT,
          ],
          dtype=f"M8[{unit}]",
      )
      null_loc = Series([False, True, False, True])
  
      result = ser.fillna(Timestamp("2011-01-02 10:00"))
      expected = Series(
          [
              Timestamp("2011-01-01 10:00"),
              Timestamp("2011-01-02 10:00"),
              Timestamp("2011-01-03 10:00"),
              Timestamp("2011-01-02 10:00"),
          ],
          dtype=f"M8[{unit}]",
      )
      tm.assert_series_equal(expected, result)
      # check s is not changed
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz))
      expected = Series(
          [
              Timestamp("2011-01-01 10:00"),
              Timestamp("2011-01-02 10:00", tz=tz),
              Timestamp("2011-01-03 10:00"),
              Timestamp("2011-01-02 10:00", tz=tz),
          ]
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna("AAA")
      expected = Series(
          [
              Timestamp("2011-01-01 10:00"),
              "AAA",
              Timestamp("2011-01-03 10:00"),
              "AAA",
          ],
          dtype=object,
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(
          {
              1: Timestamp("2011-01-02 10:00", tz=tz),
              3: Timestamp("2011-01-04 10:00"),
          }
      )
      expected = Series(
          [
              Timestamp("2011-01-01 10:00"),
              Timestamp("2011-01-02 10:00", tz=tz),
              Timestamp("2011-01-03 10:00"),
              Timestamp("2011-01-04 10:00"),
          ]
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(
          {
              1: Timestamp("2011-01-02 10:00"),
              3: Timestamp("2011-01-04 10:00"),
          }
      )
      expected = Series(
          [
              Timestamp("2011-01-01 10:00"),
              Timestamp("2011-01-02 10:00"),
              Timestamp("2011-01-03 10:00"),
              Timestamp("2011-01-04 10:00"),
          ],
          dtype=f"M8[{unit}]",
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      # DatetimeTZBlock
      idx = DatetimeIndex(
          ["2011-01-01 10:00", NaT, "2011-01-03 10:00", NaT], tz=tz
      ).as_unit(unit)
      ser = Series(idx)
      assert ser.dtype == f"datetime64[{unit}, {tz}]"
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(Timestamp("2011-01-02 10:00"))
      expected = Series(
          [
              Timestamp("2011-01-01 10:00", tz=tz),
              Timestamp("2011-01-02 10:00"),
              Timestamp("2011-01-03 10:00", tz=tz),
              Timestamp("2011-01-02 10:00"),
          ]
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(Timestamp("2011-01-02 10:00", tz=tz))
      idx = DatetimeIndex(
          [
              "2011-01-01 10:00",
              "2011-01-02 10:00",
              "2011-01-03 10:00",
              "2011-01-02 10:00",
          ],
          tz=tz,
      ).as_unit(unit)
      expected = Series(idx)
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(
          Timestamp("2011-01-02 10:00", tz=tz).to_pydatetime()
      )
      idx = DatetimeIndex(
          [
              "2011-01-01 10:00",
              "2011-01-02 10:00",
              "2011-01-03 10:00",
              "2011-01-02 10:00",
          ],
          tz=tz,
      ).as_unit(unit)
      expected = Series(idx)
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna("AAA")
      expected = Series(
          [
              Timestamp("2011-01-01 10:00", tz=tz),
              "AAA",
              Timestamp("2011-01-03 10:00", tz=tz),
              "AAA",
          ],
          dtype=object,
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(
          {
              1: Timestamp("2011-01-02 10:00", tz=tz),
              3: Timestamp("2011-01-04 10:00"),
          }
      )
      expected = Series(
          [
              Timestamp("2011-01-01 10:00", tz=tz),
              Timestamp("2011-01-02 10:00", tz=tz),
              Timestamp("2011-01-03 10:00", tz=tz),
              Timestamp("2011-01-04 10:00"),
          ]
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      result = ser.fillna(
          {
              1: Timestamp("2011-01-02 10:00", tz=tz),
              3: Timestamp("2011-01-04 10:00", tz=tz),
          }
      )
      expected = Series(
          [
              Timestamp("2011-01-01 10:00", tz=tz),
              Timestamp("2011-01-02 10:00", tz=tz),
              Timestamp("2011-01-03 10:00", tz=tz),
              Timestamp("2011-01-04 10:00", tz=tz),
          ]
      ).dt.as_unit(unit)
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      # filling with a naive/other zone, coerce to object
      result = ser.fillna(Timestamp("20130101"))
      expected = Series(
          [
              Timestamp("2011-01-01 10:00", tz=tz),
              Timestamp("2013-01-01"),
              Timestamp("2011-01-03 10:00", tz=tz),
              Timestamp("2013-01-01"),
          ]
      )
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
      # pre-2.0 fillna with mixed tzs would cast to object, in 2.0
      #  it retains dtype.
      result = ser.fillna(Timestamp("20130101", tz="US/Pacific"))
      expected = Series(
          [
              Timestamp("2011-01-01 10:00", tz=tz),
              Timestamp("2013-01-01", tz="US/Pacific").tz_convert(tz),
              Timestamp("2011-01-03 10:00", tz=tz),
              Timestamp("2013-01-01", tz="US/Pacific").tz_convert(tz),
          ]
      ).dt.as_unit(unit)
      tm.assert_series_equal(expected, result)
      tm.assert_series_equal(isna(ser), null_loc)
  
imports: from datetime import datetime, timedelta, timezone
  import numpy
  import pytest
  import pytz
  from pandas import Categorical, DataFrame, DatetimeIndex, NaT, Period, Series, Timedelta, Timestamp, date_range, isna, timedelta_range
  import pandas._testing
  from pandas.core.arrays import period_array
label_desc: Use image node_id 16 for calling the TestSeriesFillNA obj's underlying member method code with example usage: obj.test_datetime64_tz_fillna(tz, unit) without return types