Issue with fillna on Extension Array Unit Tests
#### Code Sample, a copy-pastable example if possible

```python
import operator
import json
import numpy as np

from pandas.core.arrays import ExtensionArray
from pandas.core.dtypes.dtypes import ExtensionDtype
from arcgis.geometry import Geometry
import pandas as pd
from .parser import _to_geo_array


#####################################################################
class NumPyBackedExtensionArrayMixin(ExtensionArray):
    """
    Geo-Specific Extension Array Mixin
    """
    @property
    def dtype(self):
        """The dtype for this extension array, GeoType"""
        return self._dtype

    @classmethod
    def _from_sequence(cls, scalars):
        return cls(scalars)

    @classmethod
    def _constructor_from_sequence(cls, scalars):
        return cls(scalars)

    @classmethod
    def _from_factorized(cls, values, original):
        return cls(values)

    @property
    def shape(self):
        return (len(self.data),)

    def __len__(self):
        return len(self.data)

    def __getitem__(self, *args):
        result = operator.getitem(self.data, *args)
        if isinstance(result, (dict, Geometry)):
            return result
        elif isinstance(result, type(None)) or \
             isinstance(result, type(np.nan)):
            return None
        elif not isinstance(result, GeoArray):
            return GeoArray(result)
        return result


    def setitem(self, indexer, value):
        """Set the 'value' inplace.
        """
        self[indexer] = value
        return self

    @property
    def nbytes(self):
        return self._itemsize * len(self)

    def _formatting_values(self):
        return np.array(self._format_values(), dtype='object')

    def copy(self, deep=False):
        return type(self)(self.data.copy())

    @classmethod
    def _concat_same_type(cls, to_concat):
        return cls(np.concatenate([array.data for array in to_concat]))

    def tolist(self):
        return self.data.tolist()

    def argsort(self, axis=-1, kind='quicksort', order=None):
        return self.data.argsort()

    def unique(self):
        _, indices = np.unique(self.data, return_index=True)
        data = self.data.take(np.sort(indices))
        return self._from_ndarray(data)
#####################################################################
class GeoType(ExtensionDtype):
    name = 'geometry'
    type = Geometry
    kind = 'O'
    _record_type = np.dtype('O')
    na_value = None

    @classmethod
    def construct_from_string(cls, string):
        if string == cls.name:
            return cls()
        else:
            raise TypeError("Cannot construct a '{}' from "
                            "'{}'".format(cls, string))
#####################################################################
class GeoArray(NumPyBackedExtensionArrayMixin):
    """Array for Geometry data.
    """
    _dtype = GeoType()
    _itemsize = 8
    ndim = 1
    can_hold_na = True

    def __init__(self, values, copy=True):
        self.data = np.array(values, dtype='O', copy=copy)

    @classmethod
    def _from_ndarray(cls, data, copy=False):
        return cls(data, copy=copy)

    @property
    def na_value(self):
        return self.dtype.na_value

    def __repr__(self):
        formatted = self._format_values()
        return "GeoArray({!r})".format(formatted)

    def __str__(self):
        return self.__repr__()

    def _format_values(self):
        if self.data.ndim == 0:
            return ""
        return [_format(x) if x else None for x in self.data]

    @classmethod
    def from_geometry(cls, data, copy=False):
        """"""
        if copy:
            data = data.copy()
        new = GeoArray([])
        new.data = np.array(data)
        return new

    def __setitem__(self, key, value):
        if value is None or  \
           (isinstance(value, str) and value == ""):
            self.data[key] = value
        else:
            value = Geometry(value)
            self.data[key] = value

    def __iter__(self):
        return iter(self.data.tolist())

    def __eq__(self, other):
        return self.data == other

    def equals(self, other):
        if not isinstance(other, type(self)):
            raise TypeError
        return (self.data == other.data).all()

    def _values_for_factorize(self):
        # Should hit pandas' UInt64Hashtable
        return self, 0

    def isna(self):
        return (self.data == self._dtype.na_value)

    @property
    def _parser(self):
        return lambda x: x

    def take(self, indexer, allow_fill=True, fill_value=None):
        mask = indexer == -1
        result = self.data.take(indexer)
        result[mask] = self.dtype.na_value
        return type(self)(result, copy=False)

    def _formatting_values(self):
        return np.array(self._format_values(), dtype='object')

    @classmethod
    def _concat_same_type(cls, to_concat):
        return cls(np.concatenate([array.data for array in to_concat]))

    def take_nd(self, indexer, allow_fill=True, fill_value=None):
        return self.take(indexer, allow_fill=allow_fill, fill_value=fill_value)

    def copy(self, deep=False):
        return type(self)(self.data.copy())

class Geometry(dict):
     """Universal Geometry Class that will use either Shapely or ArcPy Geometry objects."""
    _ao = None
    _type = None
    _HASARCPY = None
    _HASSHAPELY = None
    #----------------------------------------------------------------------
    def __init__(self, iterable=None):
        if iterable is None:
            iterable = {}
        self.update(iterable)
    #----------------------------------------------------------------------
    def is_valid(self):
        return True#_is_valid(self)
    #----------------------------------------------------------------------
    def _check_geometry_engine(self):
        if self._HASARCPY is None:
            try:
                import arcpy
                self._HASARCPY = True
            except:
                self._HASARCPY = False
        if self._HASSHAPELY is None:
            try:
                import shapely
                self._HASSHAPELY = True
            except:
                self._HASSHAPELY = False
        return self._HASARCPY, self._HASSHAPELY
    #----------------------------------------------------------------------
    def __setattr__(self, key, value):
        """sets the attribute"""
        if key in {'_ao','_type', '_HASARCPY', '_HASSHAPELY',
                   '_ipython_canary_method_should_not_exist_'}:
            super(BaseGeometry, self).__setattr__(key,value)
        else:
            self[key] = value
            self._ao = None
    #----------------------------------------------------------------------
    def __setattribute__ (self, key, value):
        if key in {'_ao','_type', '_HASARCPY', '_HASSHAPELY',
                   '_ipython_canary_method_should_not_exist_'}:
            super(BaseGeometry, self).__setattr__(key,value)
        else:
            self[key] = value
            self._ao = None
    #----------------------------------------------------------------------
    def __setitem__(self, key, value):
        dict.__setitem__(self, key, value)
        self._ao = None
    #----------------------------------------------------------------------
    def __getattribute__ (self, name):
        return super(BaseGeometry, self).__getattribute__(name)
    #----------------------------------------------------------------------
    def __getattr__(self, name):
        try:
            if name in {'_ao',"_type", '_HASARCPY', '_HASSHAPELY',
                        '_ipython_canary_method_should_not_exist_'}:
                return super(BaseGeometry, self).__getattr__(k)
            return dict.__getitem__(self, name)
        except:
            raise AttributeError("'%s' object has no attribute '%s'" % (type(self).__name__, name))
    #----------------------------------------------------------------------
    def __getitem__(self, k):
        return dict.__getitem__(self, k)

@pytest.fixture
def dtype():
    """A fixture providing the ExtensionDtype to validate."""
    return GeoType()

@pytest.fixture
def data():
    """Length-100 array for this type."""
    from arcgis.geometry._types import Geometry, Point
    data = [Point({'x':1,'y':2,'spatialReference': {'wkid':4326}})]
    data *= 100
    return GeoArray(data)


@pytest.fixture
def data_missing():
    """Length-2 array with [NA, Valid]"""
    from arcgis.geometry._types import BaseGeometry, Point
    data = [None, BaseGeometry({'x':1,'y':2,'spatialReference': {'wkid':4326}})]
    return GeoArray(data)

@pytest.fixture
def na_cmp():
    """Binary operator for comparing NA values.

    Should return a function of two arguments that returns
    True if both arguments are (scalar) NA for your type.

    By default, uses ``operator.is_``
    """
    return operator.is_


@pytest.fixture
def na_value():
    """The scalar missing value for this type. Default 'None'"""
    return None

class TestBaseMissing(base.BaseMissingTests): pass
TestBaseMissing().test_fillna_series(data_missing())  # I can't get this to pass.
```
#### Problem description

When creating a custom array and dtype the `test_fillna_series` always fails regardless of code change.  

I am at my wits end trying to see where I am going wrong.  The `isna()` works like a charms and returns the proper value.  When fillna is called it does not work at all I am getting:

```builtins.ValueError: The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().```

So the `fillna` is passing in a series to ```__setitem__``` which is then it's trying to create a `Geometry` object from that.  But the ```__setitem__``` value is a `nan` value, which makes no sense at all.  I thought the value would be my replacement point.  Is something wrong with the fillna logic?

Also, when I modify the `__setitem__` to handle the series, it then sets the row, in this case index 0 to a GeoArray.



#### Expected Output

```
0    {"x": 1, "y": 2, "spatialReference": {"wkid": ...
1    {"x": 1, "y": 2, "spatialReference": {"wkid": ...
dtype: geometry
```




#### Output of ``pd.show_versions()``

<details>


INSTALLED VERSIONS
------------------
commit: None
python: 3.6.6.final.0
python-bits: 64
OS: Windows
OS-release: 10
machine: AMD64
processor: Intel64 Family 6 Model 94 Stepping 3, GenuineIntel
byteorder: little
LC_ALL: None
LANG: None
LOCALE: English_United States.1252

pandas: 0.23.4
pytest: 3.7.1
pip: 18.0
setuptools: 40.0.0
Cython: None
numpy: 1.14.3
scipy: 1.1.0
pyarrow: None
xarray: None
IPython: 6.5.0
sphinx: None
patsy: 0.5.0
dateutil: 2.7.3
pytz: 2018.5
blosc: None
bottleneck: None
tables: 3.4.2
numexpr: 2.6.6
feather: None
matplotlib: 2.2.2
openpyxl: 2.5.5
xlrd: 1.1.0
xlwt: 1.3.0
xlsxwriter: None
lxml: 4.2.3
bs4: 4.6.3
html5lib: 1.0.1
sqlalchemy: None
pymysql: None
psycopg2: None
jinja2: 2.10
s3fs: None
fastparquet: None
pandas_gbq: None
pandas_datareader: None

</details>
