test_Apex

Complexity

Total Complexity

159

Size/Duplication

Total Lines	1847
Duplicated Lines	3.57 %

Importance

Changes

0

2 Functions

Rating	Name	Duplication	Size	Complexity
B	igrf_file()	0	33	5
A	test_set_epoch_file_error()	0	8	2

# -*- coding: utf-8 -*-
"""Test the apexpy.Apex class

Notes
-----
Whenever function outputs are tested against hard-coded numbers, the test
results (numbers) were obtained by running the code that is tested.  Therefore,
these tests below only check that nothing changes when refactoring, etc., and
not if the results are actually correct.

These results are expected to change when IGRF is updated.

"""

import datetime as dt
import numpy as np
import os
import pytest
import shutil
import warnings

import apexpy


@pytest.fixture()
def igrf_file(max_attempts=100):
    """A fixture for handling the coefficient file.

    Parameters
    ----------
    max_attempts : int
        Maximum rename attemps, needed for Windows (default=100)

    """
    # Ensure the coefficient file exists
    original_file = os.path.join(os.path.dirname(apexpy.helpers.__file__),
                                 'igrf13coeffs.txt')
    tmp_file = "temp_coeff.txt"
    assert os.path.isfile(original_file)

    # Move the coefficient file
    for _ in range(max_attempts):
        try:
            shutil.move(original_file, tmp_file)
            break
        except Exception:
            pass
    yield original_file

    # Move the coefficient file back
    for _ in range(max_attempts):
        try:
            shutil.move(tmp_file, original_file)
            break
        except Exception:
            pass
    return


def test_set_epoch_file_error(igrf_file):
    """Test raises OSError when IGRF coefficient file is missing."""
    # Test missing coefficient file failure
    with pytest.raises(OSError) as oerr:
        apexpy.Apex()
    error_string = "File {:} does not exist".format(igrf_file)
    assert str(oerr.value).startswith(error_string)
    return


class TestApexInit(object):
    """Test class for the Apex class object."""

    def setup_method(self):
        """Initialize all tests."""
        self.apex_out = None
        self.test_date = dt.datetime.utcnow()
        self.test_refh = 0
        self.bad_file = 'foo/path/to/datafile.blah'

    def teardown_method(self):
        """Clean up after each test."""
        del self.apex_out, self.test_date, self.test_refh, self.bad_file

    def eval_date(self):
        """Evaluate the times in self.test_date and self.apex_out."""
        if isinstance(self.test_date, dt.datetime) \
           or isinstance(self.test_date, dt.date):
            self.test_date = apexpy.helpers.toYearFraction(self.test_date)

        # Assert the times are the same on the order of tens of seconds.
        # Necessary to evaluate the current UTC
        np.testing.assert_almost_equal(self.test_date, self.apex_out.year, 6)
        return

    def eval_refh(self):
        """Evaluate the reference height in self.refh and self.apex_out."""
        eval_str = "".join(["expected reference height [",
                            "{:}] not equal to Apex ".format(self.test_refh),
                            "reference height ",
                            "[{:}]".format(self.apex_out.refh)])
        assert self.test_refh == self.apex_out.refh, eval_str
        return

    def test_init_defaults(self):
        """Test Apex class default initialization."""
        self.apex_out = apexpy.Apex()
        self.eval_date()
        self.eval_refh()
        return

    def test_init_today(self):
        """Test Apex class initialization with today's date."""
        self.apex_out = apexpy.Apex(date=self.test_date)
        self.eval_date()
        self.eval_refh()
        return

    @pytest.mark.parametrize("in_date",
                             [2015, 2015.5, dt.date(2015, 1, 1),
                              dt.datetime(2015, 6, 1, 18, 23, 45)])
    def test_init_date(self, in_date):
        """Test Apex class with date initialization.

        Parameters
        ----------
        in_date : int, float, dt.date, or dt.datetime
            Input date in a variety of formats

        """
        self.test_date = in_date
        self.apex_out = apexpy.Apex(date=self.test_date)
        self.eval_date()
        self.eval_refh()
        return

    @pytest.mark.parametrize("new_date", [2015, 2015.5])
    def test_set_epoch(self, new_date):
        """Test successful setting of Apex epoch after initialization.

        Parameters
        ----------
        new_date : int or float
            New date for the Apex class

        """
        # Evaluate the default initialization
        self.apex_out = apexpy.Apex()
        self.eval_date()
        self.eval_refh()

        # Update the epoch
        ref_apex = eval(self.apex_out.__repr__())
        self.apex_out.set_epoch(new_date)
        assert ref_apex != self.apex_out
        self.test_date = new_date
        self.eval_date()
        return

    @pytest.mark.parametrize("in_refh", [0.0, 300.0, 30000.0, -1.0])
    def test_init_refh(self, in_refh):
        """Test Apex class with reference height initialization.

        Parameters
        ----------
        in_refh : float
            Input reference height in km

        """
        self.test_refh = in_refh
        self.apex_out = apexpy.Apex(refh=self.test_refh)
        self.eval_date()
        self.eval_refh()
        return

    @pytest.mark.parametrize("new_refh", [0.0, 300.0, 30000.0, -1.0])
    def test_set_refh(self, new_refh):
        """Test the method used to set the reference height after the init.

        Parameters
        ----------
        new_refh : float
            Reference height in km

        """
        # Verify the defaults are set
        self.apex_out = apexpy.Apex(date=self.test_date)
        self.eval_date()
        self.eval_refh()

        # Update to a new reference height and test
        ref_apex = eval(self.apex_out.__repr__())
        self.apex_out.set_refh(new_refh)

        if self.test_refh == new_refh:
            assert ref_apex == self.apex_out
        else:
            assert ref_apex != self.apex_out
            self.test_refh = new_refh
        self.eval_refh()
        return

    def test_init_with_bad_datafile(self):
        """Test raises IOError with non-existent datafile input."""
        with pytest.raises(IOError) as oerr:
            apexpy.Apex(datafile=self.bad_file)
        assert str(oerr.value).startswith('Data file does not exist')
        return

    def test_init_with_bad_fortranlib(self):
        """Test raises IOError with non-existent datafile input."""
        with pytest.raises(IOError) as oerr:
            apexpy.Apex(fortranlib=self.bad_file)
        assert str(oerr.value).startswith('Fortran library does not exist')
        return

    def test_repr_eval(self):
        """Test the Apex.__repr__ results."""
        # Initialize the apex object
        self.apex_out = apexpy.Apex()
        self.eval_date()
        self.eval_refh()

        # Get and test the repr string
        out_str = self.apex_out.__repr__()
        assert out_str.find("apexpy.Apex(") == 0

        # Test the ability to re-create the apex object from the repr string
        new_apex = eval(out_str)
        assert new_apex == self.apex_out
        return

    def test_ne_other_class(self):
        """Test Apex class inequality to a different class."""
        self.apex_out = apexpy.Apex()
        self.eval_date()
        self.eval_refh()

        assert self.apex_out != self.test_date
        return

    def test_ne_missing_attr(self):
        """Test Apex class inequality when attributes are missing from one."""
        self.apex_out = apexpy.Apex()
        self.eval_date()
        self.eval_refh()
        ref_apex = eval(self.apex_out.__repr__())
        del ref_apex.RE

        assert ref_apex != self.apex_out
        assert self.apex_out != ref_apex
        return

    def test_eq_missing_attr(self):
        """Test Apex class equality when attributes are missing from both."""
        self.apex_out = apexpy.Apex()
        self.eval_date()
        self.eval_refh()
        ref_apex = eval(self.apex_out.__repr__())
        del ref_apex.RE, self.apex_out.RE

        assert ref_apex == self.apex_out
        return

    def test_str_eval(self):
        """Test the Apex.__str__ results."""
        # Initialize the apex object
        self.apex_out = apexpy.Apex()
        self.eval_date()
        self.eval_refh()

        # Get and test the printed string
        out_str = self.apex_out.__str__()
        assert out_str.find("Decimal year") > 0
        return


class TestApexMethod(object):
    """Test the Apex methods."""
    def setup_method(self):
        """Initialize all tests."""
        self.apex_out = apexpy.Apex(date=2000, refh=300)
        self.in_lat = 60
        self.in_lon = 15
        self.in_alt = 100

    def teardown_method(self):
        """Clean up after each test."""
        del self.apex_out, self.in_lat, self.in_lon, self.in_alt

    def get_input_args(self, method_name, precision=0.0):
        """Set the input arguments for the different Apex methods.

        Parameters
        ----------
        method_name : str
            Name of the Apex class method
        precision : float
            Value for the precision (default=0.0)

        Returns
        -------
        in_args : list
            List of the appropriate input arguments

        """
        in_args = [self.in_lat, self.in_lon, self.in_alt]

        # Add precision, if needed
        if method_name in ["_qd2geo", "apxq2g", "apex2geo", "qd2geo",
                           "_apex2geo"]:
            in_args.append(precision)

        # Add a reference height, if needed
        if method_name in ["apxg2all"]:
            in_args.append(300)

        # Add a vector flag, if needed
        if method_name in ["apxg2all", "apxg2q"]:
            in_args.append(1)

        return in_args

    def test_apex_conversion_today(self):
        """Test Apex class conversion with today's date."""
        self.apex_out = apexpy.Apex(date=dt.datetime.utcnow(), refh=300)
        assert not np.isnan(self.apex_out.geo2apex(self.in_lat, self.in_lon,
                                                   self.in_alt)).any()
        return

    @pytest.mark.parametrize("apex_method,fortran_method,fslice",
                             [("_geo2qd", "apxg2q", slice(0, 2, 1)),
                              ("_geo2apex", "apxg2all", slice(2, 4, 1)),
                              ("_qd2geo", "apxq2g", slice(None)),
                              ("_basevec", "apxg2q", slice(2, 4, 1))])
    @pytest.mark.parametrize("lat", [0, 30, 60, 89])
    @pytest.mark.parametrize("lon", [-179, -90, 0, 90, 180])
    def test_fortran_scalar_input(self, apex_method, fortran_method, fslice,
                                  lat, lon):
        """Tests Apex/fortran interface consistency for scalars.

        Parameters
        ----------
        apex_method : str
            Name of the Apex class method to test
        fortran_method : str
            Name of the Fortran function to test
        fslice : slice
            Slice used select the appropriate Fortran outputs
        lat : int or float
            Latitude in degrees N
        lon : int or float
            Longitude in degrees E

        """
        # Set the input coordinates
        self.in_lat = lat
        self.in_lon = lon

        # Get the Apex class method and the fortran function call
        apex_func = getattr(self.apex_out, apex_method)
        fortran_func = getattr(apexpy.fortranapex, fortran_method)

        # Get the appropriate input arguments
        apex_args = self.get_input_args(apex_method)
        fortran_args = self.get_input_args(fortran_method)

        # Evaluate the equivalent function calls
        np.testing.assert_allclose(apex_func(*apex_args),
                                   fortran_func(*fortran_args)[fslice])
        return

    @pytest.mark.parametrize("apex_method,fortran_method,fslice",
                             [("_geo2qd", "apxg2q", slice(0, 2, 1)),
                              ("_geo2apex", "apxg2all", slice(2, 4, 1)),
                              ("_qd2geo", "apxq2g", slice(None)),
                              ("_basevec", "apxg2q", slice(2, 4, 1))])
    @pytest.mark.parametrize("lat", [0, 30, 60, 89])
    @pytest.mark.parametrize("lon1,lon2", [(180, 180), (-180, -180),
                                           (180, -180), (-180, 180),
                                           (-345, 15), (375, 15)])
    def test_fortran_longitude_rollover(self, apex_method, fortran_method,
                                        fslice, lat, lon1, lon2):
        """Tests Apex/fortran interface consistency for longitude rollover.

        Parameters
        ----------
        apex_method : str
            Name of the Apex class method to test
        fortran_method : str
            Name of the Fortran function to test
        fslice : slice
            Slice used select the appropriate Fortran outputs
        lat : int or float
            Latitude in degrees N
        lon1 : int or float
            Longitude in degrees E
        lon2 : int or float
            Equivalent longitude in degrees E

        """
        # Set the fixed input coordinate
        self.in_lat = lat

        # Get the Apex class method and the fortran function call
        apex_func = getattr(self.apex_out, apex_method)
        fortran_func = getattr(apexpy.fortranapex, fortran_method)

        # Get the appropriate input arguments
        self.in_lon = lon1
        apex_args = self.get_input_args(apex_method)

        self.in_lon = lon2
        fortran_args = self.get_input_args(fortran_method)

        # Evaluate the equivalent function calls
        np.testing.assert_allclose(apex_func(*apex_args),
                                   fortran_func(*fortran_args)[fslice])
        return

    @pytest.mark.parametrize("arr_shape", [(2, 2), (4,), (1, 4)])
    @pytest.mark.parametrize("apex_method,fortran_method,fslice",
                             [("_geo2qd", "apxg2q", slice(0, 2, 1)),
                              ("_geo2apex", "apxg2all", slice(2, 4, 1)),
                              ("_qd2geo", "apxq2g", slice(None)),
                              ("_basevec", "apxg2q", slice(2, 4, 1))])
    def test_fortran_array_input(self, arr_shape, apex_method, fortran_method,
                                 fslice):
        """Tests Apex/fortran interface consistency for array input.

        Parameters
        ----------
        arr_shape : tuple
            Expected output shape
        apex_method : str
            Name of the Apex class method to test
        fortran_method : str
            Name of the Fortran function to test
        fslice : slice
            Slice used select the appropriate Fortran outputs

        """
        # Get the Apex class method and the fortran function call
        apex_func = getattr(self.apex_out, apex_method)
        fortran_func = getattr(apexpy.fortranapex, fortran_method)

        # Set up the input arrays
        ref_lat = np.array([0, 30, 60, 90])
        ref_alt = np.array([100, 200, 300, 400])
        self.in_lat = ref_lat.reshape(arr_shape)
        self.in_alt = ref_alt.reshape(arr_shape)
        apex_args = self.get_input_args(apex_method)

        # Get the Apex class results
        aret = apex_func(*apex_args)

        # Get the fortran function results
        flats = list()
        flons = list()

        for i, lat in enumerate(ref_lat):
            self.in_lat = lat
            self.in_alt = ref_alt[i]
            fortran_args = self.get_input_args(fortran_method)
            fret = fortran_func(*fortran_args)[fslice]
            flats.append(fret[0])
            flons.append(fret[1])

        flats = np.array(flats)
        flons = np.array(flons)

        # Evaluate results
        try:
            # This returned value is array of floats
            np.testing.assert_allclose(aret[0].astype(float),
                                       flats.reshape(arr_shape).astype(float))
            np.testing.assert_allclose(aret[1].astype(float),
                                       flons.reshape(arr_shape).astype(float))
        except ValueError:
            # This returned value is array of arrays
            alats = aret[0].reshape((4,))
            alons = aret[1].reshape((4,))
            for i, flat in enumerate(flats):
                np.testing.assert_array_almost_equal(alats[i], flat, 2)
                np.testing.assert_array_almost_equal(alons[i], flons[i], 2)

        return

    @pytest.mark.parametrize("lat", [0, 30, 60, 89])
    @pytest.mark.parametrize("lon", [-179, -90, 0, 90, 180])
    def test_geo2apexall_scalar(self, lat, lon):
        """Test Apex/fortran geo2apexall interface consistency for scalars.

        Parameters
        ----------
        lat : int or float
            Latitude in degrees N
        long : int or float
            Longitude in degrees E

        """
        # Get the Apex and Fortran results
        aret = self.apex_out._geo2apexall(lat, lon, self.in_alt)
        fret = apexpy.fortranapex.apxg2all(lat, lon, self.in_alt, 300, 1)

        # Evaluate each element in the results
        for aval, fval in zip(aret, fret):
            np.testing.assert_allclose(aval, fval)

    @pytest.mark.parametrize("arr_shape", [(2, 2), (4,), (1, 4)])
    def test_geo2apexall_array(self, arr_shape):
        """Test Apex/fortran geo2apexall interface consistency for arrays.

        Parameters
        ----------
        arr_shape : tuple
            Expected output shape

        """
        # Set the input
        self.in_lat = np.array([0, 30, 60, 90])
        self.in_alt = np.array([100, 200, 300, 400])

        # Get the Apex class results
        aret = self.apex_out._geo2apexall(self.in_lat.reshape(arr_shape),
                                          self.in_lon,
                                          self.in_alt.reshape(arr_shape))

        # For each lat/alt pair, get the Fortran results
        fret = list()
        for i, lat in enumerate(self.in_lat):
            fret.append(apexpy.fortranapex.apxg2all(lat, self.in_lon,
                                                    self.in_alt[i], 300, 1))

        # Cycle through all returned values
        for i, ret in enumerate(aret):
            try:
                # This returned value is array of floats
                fret_test = np.array([fret[0][i], fret[1][i], fret[2][i],
                                      fret[3][i]]).reshape(arr_shape)
                np.testing.assert_allclose(ret.astype(float),
                                           fret_test.astype(float))
            except ValueError:
                # This returned value is array of arrays
                ret = ret.reshape((4,))
                for j, single_fret in enumerate(fret):
                    np.testing.assert_allclose(ret[j], single_fret[i])
        return

    @pytest.mark.parametrize("in_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("out_coord", ["geo", "apex", "qd"])
    def test_convert_consistency(self, in_coord, out_coord):
        """Test the self-consistency of the Apex convert method.

        Parameters
        ----------
        in_coord : str
            Input coordinate system
        out_coord : str
            Output coordinate system

        """
        if in_coord == out_coord:
            pytest.skip("Test not needed for same src and dest coordinates")

        # Define the method name
        method_name = "2".join([in_coord, out_coord])

        # Get the method and method inputs
        convert_kwargs = {'height': self.in_alt, 'precision': 0.0}
        apex_args = self.get_input_args(method_name)
        apex_method = getattr(self.apex_out, method_name)

        # Define the slice needed to get equivalent output from the named method
        mslice = slice(0, -1, 1) if out_coord == "geo" else slice(None)

        # Get output using convert and named method
        convert_out = self.apex_out.convert(self.in_lat, self.in_lon, in_coord,
                                            out_coord, **convert_kwargs)
        method_out = apex_method(*apex_args)[mslice]

        # Compare both outputs, should be identical
        np.testing.assert_allclose(convert_out, method_out)
        return

    @pytest.mark.parametrize("bound_lat", [90, -90])
    @pytest.mark.parametrize("in_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("out_coord", ["geo", "apex", "qd"])
    def test_convert_at_lat_boundary(self, bound_lat, in_coord, out_coord):
        """Test the conversion at the latitude boundary, with allowed excess.

        Parameters
        ----------
        bound_lat : int or float
            Boundary latitude in degrees N
        in_coord : str
            Input coordinate system
        out_coord : str
            Output coordinate system

        """
        excess_lat = np.sign(bound_lat) * (abs(bound_lat) + 1.0e-5)

        # Get the two outputs, slight tolerance outside of boundary allowed
        bound_out = self.apex_out.convert(bound_lat, 0, in_coord, out_coord)
        excess_out = self.apex_out.convert(excess_lat, 0, in_coord, out_coord)

        # Test the outputs
        np.testing.assert_allclose(excess_out, bound_out, rtol=0, atol=1e-8)
        return

    def test_convert_qd2apex_at_equator(self):
        """Test the quasi-dipole to apex conversion at the magnetic equator."""
        eq_out = self.apex_out.convert(lat=0.0, lon=0, source='qd', dest='apex',
                                       height=320.0)
        close_out = self.apex_out.convert(lat=0.001, lon=0, source='qd',
                                          dest='apex', height=320.0)
        np.testing.assert_allclose(eq_out, close_out, atol=1e-4)
        return

    @pytest.mark.parametrize("src", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("dest", ["geo", "apex", "qd"])
    def test_convert_withnan(self, src, dest):
        """Test Apex.convert success with NaN input.

        Parameters
        ----------
        src : str
            Input coordinate system
        dest : str
            Output coordinate system

        """
        if src == dest:
            pytest.skip("Test not needed for same src and dest coordinates")

        num_nans = 5
        in_loc = np.arange(0, 10, dtype=float)
        in_loc[:num_nans] = np.nan

        out_loc = self.apex_out.convert(in_loc, in_loc, src, dest, height=320)

        for out in out_loc:
            assert np.all(np.isnan(out[:num_nans])), "NaN output expected"
            assert np.all(np.isfinite(out[num_nans:])), "Finite output expected"

        return

    @pytest.mark.parametrize("bad_lat", [91, -91])
    def test_convert_invalid_lat(self, bad_lat):
        """Test convert raises ValueError for invalid latitudes.

        Parameters
        ----------
        bad_lat : int or float
            Latitude ouside the supported range in degrees N

        """

        with pytest.raises(ValueError) as verr:
            self.apex_out.convert(bad_lat, 0, 'geo', 'geo')

        assert str(verr.value).find("must be in [-90, 90]") > 0
        return

    @pytest.mark.parametrize("coords", [("foobar", "geo"), ("geo", "foobar"),
                                        ("geo", "mlt")])
    def test_convert_invalid_transformation(self, coords):
        """Test raises NotImplementedError for bad coordinates.

        Parameters
        ----------
        coords : tuple
            Tuple specifying the input and output coordinate systems

        """
        if "mlt" in coords:
            estr = "datetime must be given for MLT calculations"
        else:
            estr = "Unknown coordinate transformation"

        with pytest.raises(ValueError) as verr:
            self.apex_out.convert(0, 0, *coords)

        assert str(verr).find(estr) >= 0
        return

    @pytest.mark.parametrize("method_name, out_comp",

This code seems to be duplicated in your project.

                             [("geo2apex",
                               (55.94841766357422, 94.10684204101562)),
                              ("apex2geo",
                               (51.476322174072266, -66.22817993164062,
                                5.727287771151168e-06)),
                              ("geo2qd",
                               (56.531288146972656, 94.10684204101562)),
                              ("apex2qd", (60.498401178276744, 15.0)),
                              ("qd2apex", (59.49138097045895, 15.0))])
    def test_method_scalar_input(self, method_name, out_comp):
        """Test the user method against set values with scalars.

        Parameters
        ----------
        method_name : str
            Apex class method to be tested
        out_comp : tuple of floats
            Expected output values

        """
        # Get the desired methods
        user_method = getattr(self.apex_out, method_name)

        # Get the user output
        user_out = user_method(self.in_lat, self.in_lon, self.in_alt)

        # Evaluate the user output
        np.testing.assert_allclose(user_out, out_comp, rtol=1e-5, atol=1e-5)

        for out_val in user_out:
            assert np.asarray(out_val).shape == (), "output is not a scalar"
        return

    @pytest.mark.parametrize("in_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("out_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("method_args, out_shape",
                             [([[60, 60], 15, 100], (2,)),
                              ([60, [15, 15], 100], (2,)),
                              ([60, 15, [100, 100]], (2,)),
                              ([[50, 60], [15, 16], [100, 200]], (2,))])
    def test_method_broadcast_input(self, in_coord, out_coord, method_args,
                                    out_shape):
        """Test the user method with inputs that require some broadcasting.

        Parameters
        ----------
        in_coord : str
            Input coordiante system
        out_coord : str
            Output coordiante system
        method_args : list
            List of input arguments
        out_shape : tuple
            Expected shape of output values

        """
        if in_coord == out_coord:
            pytest.skip("Test not needed for same src and dest coordinates")

        # Get the desired methods
        method_name = "2".join([in_coord, out_coord])
        user_method = getattr(self.apex_out, method_name)

        # Get the user output
        user_out = user_method(*method_args)

        # Evaluate the user output
        for out_val in user_out:
            assert hasattr(out_val, 'shape'), "output coordinate isn't np.array"
            assert out_val.shape == out_shape
        return

    @pytest.mark.parametrize("in_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("out_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("bad_lat", [91, -91])
    def test_method_invalid_lat(self, in_coord, out_coord, bad_lat):
        """Test convert raises ValueError for invalid latitudes.

        Parameters
        ----------
        in_coord : str
            Input coordiante system
        out_coord : str
            Output coordiante system
        bad_lat : int
            Latitude in degrees N that is out of bounds

        """
        if in_coord == out_coord:
            pytest.skip("Test not needed for same src and dest coordinates")

        # Get the desired methods
        method_name = "2".join([in_coord, out_coord])
        user_method = getattr(self.apex_out, method_name)

        with pytest.raises(ValueError) as verr:
            user_method(bad_lat, 15, 100)

        assert str(verr.value).find("must be in [-90, 90]") > 0
        return

    @pytest.mark.parametrize("in_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("out_coord", ["geo", "apex", "qd"])
    @pytest.mark.parametrize("bound_lat", [90, -90])
    def test_method_at_lat_boundary(self, in_coord, out_coord, bound_lat):
        """Test user methods at the latitude boundary, with allowed excess.

        Parameters
        ----------
        in_coord : str
            Input coordiante system
        out_coord : str
            Output coordiante system
        bad_lat : int
            Latitude in degrees N that is at the limits of the boundary

        """
        if in_coord == out_coord:
            pytest.skip("Test not needed for same src and dest coordinates")

        # Get the desired methods
        method_name = "2".join([in_coord, out_coord])
        user_method = getattr(self.apex_out, method_name)

        # Get a latitude just beyond the limit
        excess_lat = np.sign(bound_lat) * (abs(bound_lat) + 1.0e-5)

        # Get the two outputs, slight tolerance outside of boundary allowed
        bound_out = user_method(bound_lat, 0, 100)
        excess_out = user_method(excess_lat, 0, 100)

        # Test the outputs
        np.testing.assert_allclose(excess_out, bound_out, rtol=0, atol=1e-8)
        return

    def test_geo2apex_undefined_warning(self):
        """Test geo2apex warning and fill values for an undefined location."""

        # Update the apex object
        self.apex_out = apexpy.Apex(date=2000, refh=10000)

        # Get the output and the warnings
        with warnings.catch_warnings(record=True) as warn_rec:
            user_lat, user_lon = self.apex_out.geo2apex(0, 0, 0)

        assert np.isnan(user_lat)
        assert np.isfinite(user_lon)
        assert len(warn_rec) == 1
        assert issubclass(warn_rec[-1].category, UserWarning)
        assert 'latitude set to NaN where' in str(warn_rec[-1].message)
        return

    @pytest.mark.parametrize("method_name", ["apex2qd", "qd2apex"])
    @pytest.mark.parametrize("delta_h", [1.0e-6, -1.0e-6])
    def test_quasidipole_apexheight_close(self, method_name, delta_h):
        """Test quasi-dipole success with a height close to the reference.

        Parameters
        ----------
        method_name : str
            Apex class method name to be tested
        delta_h : float
            tolerance for height in km

        """
        qd_method = getattr(self.apex_out, method_name)
        in_args = [0, 15, self.apex_out.refh + delta_h]
        out_coords = qd_method(*in_args)

        for i, out_val in enumerate(out_coords):
            np.testing.assert_almost_equal(out_val, in_args[i], decimal=3)
        return

    @pytest.mark.parametrize("method_name, hinc, msg",
                             [("apex2qd", 1.0, "is > apex height"),
                              ("qd2apex", -1.0, "is < reference height")])
    def test_quasidipole_raises_apexheight(self, method_name, hinc, msg):
        """Quasi-dipole raises ApexHeightError when height above reference.

        Parameters
        ----------
        method_name : str
            Apex class method name to be tested
        hinc : float
            Height increment in km
        msg : str
            Expected output message

        """
        qd_method = getattr(self.apex_out, method_name)

        with pytest.raises(apexpy.ApexHeightError) as aerr:
            qd_method(0, 15, self.apex_out.refh + hinc)

        assert str(aerr).find(msg) > 0
        return


class TestApexMLTMethods(object):
    """Test the Apex Magnetic Local Time (MLT) methods."""
    def setup_method(self):
        """Initialize all tests."""
        self.apex_out = apexpy.Apex(date=2000, refh=300)
        self.in_time = dt.datetime(2000, 2, 3, 4, 5, 6)

    def teardown_method(self):
        """Clean up after each test."""
        del self.apex_out, self.in_time

    @pytest.mark.parametrize("in_coord", ["geo", "apex", "qd"])
    def test_convert_to_mlt(self, in_coord):
        """Test the conversions to MLT using Apex convert.

        Parameters
        ----------
        in_coord : str
            Input coordinate system

        """

        # Get the magnetic longitude from the appropriate method
        if in_coord == "geo":
            apex_method = getattr(self.apex_out, "{:s}2apex".format(in_coord))
            mlon = apex_method(60, 15, 100)[1]
        else:
            mlon = 15

        # Get the output MLT values
        convert_mlt = self.apex_out.convert(60, 15, in_coord, 'mlt',
                                            height=100, ssheight=2e5,
                                            datetime=self.in_time)[1]
        method_mlt = self.apex_out.mlon2mlt(mlon, self.in_time, ssheight=2e5)

        # Test the outputs
        np.testing.assert_allclose(convert_mlt, method_mlt)
        return

    @pytest.mark.parametrize("out_coord", ["geo", "apex", "qd"])
    def test_convert_mlt_to_lon(self, out_coord):
        """Test the conversions from MLT using Apex convert.

        Parameters
        ----------
        out_coord : str
            Output coordinate system

        """
        # Get the output longitudes
        convert_out = self.apex_out.convert(60, 15, 'mlt', out_coord,
                                            height=100, ssheight=2e5,
                                            datetime=self.in_time,
                                            precision=1e-2)
        mlon = self.apex_out.mlt2mlon(15, self.in_time, ssheight=2e5)

        if out_coord == "geo":
            method_out = self.apex_out.apex2geo(60, mlon, 100,
                                                precision=1e-2)[:-1]
        elif out_coord == "qd":
            method_out = self.apex_out.apex2qd(60, mlon, 100)
        else:
            method_out = (60, mlon)

        # Evaluate the outputs
        np.testing.assert_allclose(convert_out, method_out)
        return

    def test_convert_geo2mlt_nodate(self):
        """Test convert from geo to MLT raises ValueError with no datetime."""
        with pytest.raises(ValueError):
            self.apex_out.convert(60, 15, 'geo', 'mlt')
        return

    @pytest.mark.parametrize("mlon_kwargs,test_mlt",
                             [({}, 23.019629923502603),
                              ({"ssheight": 100000}, 23.026712036132814)])
    def test_mlon2mlt_scalar_inputs(self, mlon_kwargs, test_mlt):
        """Test mlon2mlt with scalar inputs.

        Parameters
        ----------
        mlon_kwargs : dict
            Input kwargs
        test_mlt : float
            Output MLT in hours

        """
        mlt = self.apex_out.mlon2mlt(0, self.in_time, **mlon_kwargs)

        np.testing.assert_allclose(mlt, test_mlt)
        assert np.asarray(mlt).shape == ()
        return

    @pytest.mark.parametrize("mlt_kwargs,test_mlon",
                             [({}, 14.705535888671875),
                              ({"ssheight": 100000}, 14.599319458007812)])
    def test_mlt2mlon_scalar_inputs(self, mlt_kwargs, test_mlon):
        """Test mlt2mlon with scalar inputs.

        Parameters
        ----------
        mlt_kwargs : dict
            Input kwargs
        test_mlon : float
            Output longitude in degrees E

        """
        mlon = self.apex_out.mlt2mlon(0, self.in_time, **mlt_kwargs)

        np.testing.assert_allclose(mlon, test_mlon)
        assert np.asarray(mlon).shape == ()
        return

    @pytest.mark.parametrize("mlon,test_mlt",
                             [([0, 180], [23.019261, 11.019261]),
                              (np.array([0, 180]), [23.019261, 11.019261]),
                              (np.array([[0], [180]]),
                               np.array([[23.019261], [11.019261]])),
                              ([[0, 180], [0, 180]], [[23.019261, 11.019261],
                                                      [23.019261, 11.019261]]),
                              (range(0, 361, 30),
                               [23.01963, 1.01963, 3.01963, 5.01963, 7.01963,
                                9.01963, 11.01963, 13.01963, 15.01963, 17.01963,
                                19.01963, 21.01963, 23.01963])])
    def test_mlon2mlt_array(self, mlon, test_mlt):
        """Test mlon2mlt with array inputs.

        Parameters
        ----------
        mlon : array-like
            Input longitudes in degrees E
        test_mlt : float
            Output MLT in hours

        """
        mlt = self.apex_out.mlon2mlt(mlon, self.in_time)

        assert mlt.shape == np.asarray(test_mlt).shape
        np.testing.assert_allclose(mlt, test_mlt, rtol=1e-4)
        return

    @pytest.mark.parametrize("mlt,test_mlon",
                             [([0, 12], [14.705551, 194.705551]),
                              (np.array([0, 12]), [14.705551, 194.705551]),
                              (np.array([[0], [12]]),
                               np.array([[14.705551], [194.705551]])),
                              ([[0, 12], [0, 12]], [[14.705551, 194.705551],
                                                    [14.705551, 194.705551]]),
                              (range(0, 25, 2),
                               [14.705551, 44.705551, 74.705551, 104.705551,
                                134.705551, 164.705551, 194.705551, 224.705551,
                                254.705551, 284.705551, 314.705551, 344.705551,
                                14.705551])])
    def test_mlt2mlon_array(self, mlt, test_mlon):
        """Test mlt2mlon with array inputs.

        Parameters
        ----------
        mlt : array-like
            Input MLT in hours
        test_mlon : float
            Output longitude in degrees E

        """
        mlon = self.apex_out.mlt2mlon(mlt, self.in_time)

        assert mlon.shape == np.asarray(test_mlon).shape
        np.testing.assert_allclose(mlon, test_mlon, rtol=1e-4)
        return

    @pytest.mark.parametrize("method_name", ["mlon2mlt", "mlt2mlon"])
    def test_mlon2mlt_diffdates(self, method_name):
        """Test that MLT varies with universal time.

        Parameters
        ----------
        method_name : str
            Name of Apex class method to be tested

        """
        apex_method = getattr(self.apex_out, method_name)
        mlt1 = apex_method(0, self.in_time)
        mlt2 = apex_method(0, self.in_time + dt.timedelta(hours=1))

        assert mlt1 != mlt2
        return

    @pytest.mark.parametrize("mlt_offset", [1.0, 10.0])
    def test_mlon2mlt_offset(self, mlt_offset):
        """Test the time wrapping logic for the MLT.

        Parameters
        ----------
        mlt_offset : float
            MLT offset in hours

        """
        mlt1 = self.apex_out.mlon2mlt(0.0, self.in_time)
        mlt2 = self.apex_out.mlon2mlt(-15.0 * mlt_offset,
                                      self.in_time) + mlt_offset

        np.testing.assert_allclose(mlt1, mlt2)
        return

    @pytest.mark.parametrize("mlon_offset", [15.0, 150.0])
    def test_mlt2mlon_offset(self, mlon_offset):
        """Test the time wrapping logic for the magnetic longitude.

        Parameters
        ----------
        mlt_offset : float
            MLT offset in hours

        """
        mlon1 = self.apex_out.mlt2mlon(0, self.in_time)
        mlon2 = self.apex_out.mlt2mlon(mlon_offset / 15.0,
                                       self.in_time) - mlon_offset

        np.testing.assert_allclose(mlon1, mlon2)
        return

    @pytest.mark.parametrize("order", [["mlt", "mlon"], ["mlon", "mlt"]])
    @pytest.mark.parametrize("start_val", [0, 6, 12, 18, 22])
    def test_convert_and_return(self, order, start_val):
        """Test the conversion to magnetic longitude or MLT and back again.

        Parameters
        ----------
        order : list
            List of strings specifying the order to run functions
        start_val : int or float
            Input value

        """
        first_method = getattr(self.apex_out, "2".join(order))
        second_method = getattr(self.apex_out, "2".join([order[1], order[0]]))

        middle_val = first_method(start_val, self.in_time)
        end_val = second_method(middle_val, self.in_time)

        np.testing.assert_allclose(start_val, end_val)
        return


class TestApexMapMethods(object):
    """Test the Apex height mapping methods."""
    def setup_method(self):
        """Initialize all tests."""
        self.apex_out = apexpy.Apex(date=2000, refh=300)

    def teardown_method(self):
        """Clean up after each test."""
        del self.apex_out

    @pytest.mark.parametrize("in_args,test_mapped",
                             [([60, 15, 100, 10000],
                               [31.841466903686523, 17.916635513305664,
                                1.7075473124350538e-6]),
                              ([30, 170, 100, 500, False, 1e-2],
                               [25.727270126342773, 169.60546875,
                                0.00017573432705830783]),
                              ([60, 15, 100, 10000, True],
                               [-25.424888610839844, 27.310426712036133,
                                1.2074182222931995e-6]),
                              ([30, 170, 100, 500, True, 1e-2],
                               [-13.76642894744873, 164.24259948730469,
                                0.00056820799363777041])])
    def test_map_to_height(self, in_args, test_mapped):
        """Test the map_to_height function.

        Parameters
        ----------
        in_args : list
            List of input arguments
        test_mapped : list
            List of expected outputs

        """
        mapped = self.apex_out.map_to_height(*in_args)
        np.testing.assert_allclose(mapped, test_mapped, rtol=1e-5, atol=1e-5)
        return

    def test_map_to_height_same_height(self):
        """Test the map_to_height function when mapping to same height."""
        mapped = self.apex_out.map_to_height(60, 15, 100, 100, conjugate=False,
                                             precision=1e-10)
        np.testing.assert_allclose(mapped, (60.0, 15.000003814697266, 0.0),
                                   rtol=1e-5, atol=1e-5)
        return

    @pytest.mark.parametrize('arr_shape', [(2,), (2, 2), (1, 4)])
    @pytest.mark.parametrize('ivec', range(0, 4))
    def test_map_to_height_array_location(self, arr_shape, ivec):
        """Test map_to_height with array input.

        Parameters
        ----------
        arr_shape : tuple
            Expected array shape
        ivec : int
            Input argument index for vectorized input

        """
        # Set the base input and output values
        in_args = [60, 15, 100, 100]
        test_mapped = [60, 15.00000381, 0.0]

        # Update inputs for one vectorized value
        in_args[ivec] = np.full(shape=arr_shape, fill_value=in_args[ivec])

        # Calculate and test function
        mapped = self.apex_out.map_to_height(*in_args)
        for i, test_val in enumerate(test_mapped):
            assert mapped[i].shape == arr_shape
            np.testing.assert_allclose(mapped[i], test_val, rtol=1e-5,
                                       atol=1e-5)
        return

    @pytest.mark.parametrize("method_name,in_args",
                             [("map_to_height", [0, 15, 100, 10000]),
                              ("map_E_to_height",
                               [0, 15, 100, 10000, [1, 2, 3]]),
                              ("map_V_to_height",
                               [0, 15, 100, 10000, [1, 2, 3]])])
    def test_mapping_height_raises_ApexHeightError(self, method_name, in_args):
        """Test map_to_height raises ApexHeightError.

        Parameters
        ----------
        method_name : str
            Name of the Apex class method to test
        in_args : list
            List of input arguments

        """
        apex_method = getattr(self.apex_out, method_name)

        with pytest.raises(apexpy.ApexHeightError) as aerr:
            apex_method(*in_args)

        assert aerr.match("is > apex height")
        return

    @pytest.mark.parametrize("method_name",
                             ["map_E_to_height", "map_V_to_height"])
    @pytest.mark.parametrize("ev_input", [([1, 2, 3, 4, 5]),
                                          ([[1, 2], [3, 4], [5, 6], [7, 8]])])
    def test_mapping_EV_bad_shape(self, method_name, ev_input):
        """Test height mapping of E/V with baddly shaped input raises Error.

        Parameters
        ----------
        method_name : str
            Name of the Apex class method to test
        ev_input : list
            E/V input arguments

        """
        apex_method = getattr(self.apex_out, method_name)
        in_args = [60, 15, 100, 500, ev_input]
        with pytest.raises(ValueError) as verr:
            apex_method(*in_args)

        assert str(verr.value).find("must be (3, N) or (3,) ndarray") >= 0
        return

    def test_mapping_EV_bad_flag(self):
        """Test _map_EV_to_height raises error for bad data type flag."""
        with pytest.raises(ValueError) as verr:
            self.apex_out._map_EV_to_height(60, 15, 100, 500, [1, 2, 3], "P")

        assert str(verr.value).find("unknown electric field/drift flag") >= 0
        return

    @pytest.mark.parametrize("in_args,test_mapped",
                             [([60, 15, 100, 500, [1, 2, 3]],
                               [0.71152183, 2.35624876, 0.57260784]),
                              ([60, 15, 100, 500, [2, 3, 4]],
                               [1.56028502, 3.43916636, 0.78235384]),
                              ([60, 15, 100, 1000, [1, 2, 3]],
                               [0.67796492, 2.08982134, 0.55860785]),
                              ([60, 15, 200, 500, [1, 2, 3]],
                               [0.72377397, 2.42737471, 0.59083726]),
                              ([60, 30, 100, 500, [1, 2, 3]],
                               [0.68626344, 2.37530133, 0.60060124]),
                              ([70, 15, 100, 500, [1, 2, 3]],
                               [0.72760378, 2.18082305, 0.29141979])])
    def test_map_E_to_height_scalar_location(self, in_args, test_mapped):
        """Test mapping of E-field to a specified height.

        Parameters
        ----------
        in_args : list
            List of input arguments
        test_mapped : list
            List of expected outputs

        """
        mapped = self.apex_out.map_E_to_height(*in_args)
        np.testing.assert_allclose(mapped, test_mapped, rtol=1e-5)
        return

    @pytest.mark.parametrize('ev_flag, test_mapped',
                             [('E', [0.71152183, 2.35624876, 0.57260784]),
                              ('V', [0.81971957, 2.84512495, 0.69545001])])
    @pytest.mark.parametrize('arr_shape', [(2,), (5,)])
    @pytest.mark.parametrize('ivec', range(0, 5))
    def test_map_EV_to_height_array_location(self, ev_flag, test_mapped,
                                             arr_shape, ivec):
        """Test mapping of E-field/drift to a specified height with arrays.

        Parameters
        ----------
        ev_flag : str
            Character flag specifying whether to run 'E' or 'V' methods
        test_mapped : list
            List of expected outputs
        arr_shape : tuple
            Shape of the expected output
        ivec : int
            Index of the expected output

        """
        # Set the base input and output values
        eshape = list(arr_shape)
        eshape.insert(0, 3)
        edata = np.array([[1, 2, 3]] * np.product(arr_shape)).transpose()
        in_args = [60, 15, 100, 500, edata.reshape(tuple(eshape))]

        # Update inputs for one vectorized value if this is a location input
        if ivec < 4:
            in_args[ivec] = np.full(shape=arr_shape, fill_value=in_args[ivec])

        # Get the mapped output
        apex_method = getattr(self.apex_out,
                              "map_{:s}_to_height".format(ev_flag))
        mapped = apex_method(*in_args)

        # Test the results
        for i, test_val in enumerate(test_mapped):
            assert mapped[i].shape == arr_shape
            np.testing.assert_allclose(mapped[i], test_val, rtol=1e-5)
        return

    @pytest.mark.parametrize("in_args,test_mapped",
                             [([60, 15, 100, 500, [1, 2, 3]],
                               [0.81971957, 2.84512495, 0.69545001]),
                              ([60, 15, 100, 500, [2, 3, 4]],
                               [1.83027746, 4.14346436, 0.94764179]),
                              ([60, 15, 100, 1000, [1, 2, 3]],
                               [0.92457698, 3.14997661, 0.85135187]),
                              ([60, 15, 200, 500, [1, 2, 3]],
                               [0.80388262, 2.79321504, 0.68285158]),
                              ([60, 30, 100, 500, [1, 2, 3]],
                               [0.76141245, 2.87884673, 0.73655941]),
                              ([70, 15, 100, 500, [1, 2, 3]],
                               [0.84681866, 2.5925821, 0.34792655])])
    def test_map_V_to_height_scalar_location(self, in_args, test_mapped):
        """Test mapping of velocity to a specified height.

        Parameters
        ----------
        in_args : list
            List of input arguments
        test_mapped : list
            List of expected outputs

        """
        mapped = self.apex_out.map_V_to_height(*in_args)
        np.testing.assert_allclose(mapped, test_mapped, rtol=1e-5)
        return


class TestApexBasevectorMethods(object):
    """Test the Apex height base vector methods."""
    def setup_method(self):
        """Initialize all tests."""
        self.apex_out = apexpy.Apex(date=2000, refh=300)
        self.lat = 60
        self.lon = 15
        self.height = 100
        self.test_basevec = None

    def teardown_method(self):
        """Clean up after each test."""
        del self.apex_out, self.test_basevec, self.lat, self.lon, self.height

    def get_comparison_results(self, bv_coord, coords, precision):
        """Get the base vector results using the hidden function for comparison.

        Parameters
        ----------
        bv_coord : str
            Basevector coordinate scheme, expects on of 'apex', 'qd',
            or 'bvectors_apex'
        coords : str
            Expects one of 'geo', 'apex', or 'qd'
        precision : float
            Float specifiying precision

        """
        if coords == "geo":
            glat = self.lat
            glon = self.lon
        else:
            apex_method = getattr(self.apex_out, "{:s}2geo".format(coords))
            glat, glon, _ = apex_method(self.lat, self.lon, self.height,
                                        precision=precision)

        if bv_coord == 'qd':
            self.test_basevec = self.apex_out._basevec(glat, glon, self.height)
        elif bv_coord == 'apex':
            (_, _, _, _, f1, f2, _, d1, d2, d3, _, e1, e2,
             e3) = self.apex_out._geo2apexall(glat, glon, 100)
            self.test_basevec = (f1, f2, d1, d2, d3, e1, e2, e3)
        else:
            # These are set results that need to be updated with IGRF
            if coords == "geo":
                self.test_basevec = (
                    np.array([4.42368795e-05, 4.42368795e-05]),
                    np.array([[0.01047826, 0.01047826],
                              [0.33089194, 0.33089194],
                              [-1.04941, -1.04941]]),
                    np.array([5.3564698e-05, 5.3564698e-05]),
                    np.array([[0.00865356, 0.00865356],
                              [0.27327004, 0.27327004],
                              [-0.8666646, -0.8666646]]))
            elif coords == "apex":
                self.test_basevec = (
                    np.array([4.48672735e-05, 4.48672735e-05]),
                    np.array([[-0.12510721, -0.12510721],
                              [0.28945938, 0.28945938],
                              [-1.1505738, -1.1505738]]),
                    np.array([6.38577444e-05, 6.38577444e-05]),
                    np.array([[-0.08790194, -0.08790194],
                              [0.2033779, 0.2033779],
                              [-0.808408, -0.808408]]))
            else:
                self.test_basevec = (
                    np.array([4.46348578e-05, 4.46348578e-05]),
                    np.array([[-0.12642345, -0.12642345],
                              [0.29695055, 0.29695055],
                              [-1.1517885, -1.1517885]]),
                    np.array([6.38626285e-05, 6.38626285e-05]),
                    np.array([[-0.08835986, -0.08835986],
                              [0.20754464, 0.20754464],
                              [-0.8050078, -0.8050078]]))

        return

    @pytest.mark.parametrize("bv_coord", ["qd", "apex"])
    @pytest.mark.parametrize("coords,precision",
                             [("geo", 1e-10), ("apex", 1.0e-2), ("qd", 1.0e-2)])
    def test_basevectors_scalar(self, bv_coord, coords, precision):
        """Test the base vector calculations with scalars.

        Parameters
        ----------
        bv_coord : str
            Name of the input coordinate system
        coords : str
            Name of the output coordinate system
        precision : float
            Level of run precision requested

        """
        # Get the base vectors
        base_method = getattr(self.apex_out,
                              "basevectors_{:s}".format(bv_coord))
        basevec = base_method(self.lat, self.lon, self.height, coords=coords,
                              precision=precision)
        self.get_comparison_results(bv_coord, coords, precision)
        if bv_coord == "apex":
            basevec = list(basevec)
            for i in range(4):
                # Not able to compare indices 2, 3, 4, and 5
                basevec.pop(2)

        # Test the results
        for i, vec in enumerate(basevec):
            np.testing.assert_allclose(vec, self.test_basevec[i])
        return

    @pytest.mark.parametrize("bv_coord", ["qd", "apex"])
    def test_basevectors_scalar_shape(self, bv_coord):
        """Test the shape of the scalar output.

        Parameters
        ----------
        bv_coord : str
            Name of the input coordinate system

        """
        base_method = getattr(self.apex_out,
                              "basevectors_{:s}".format(bv_coord))
        basevec = base_method(self.lat, self.lon, self.height)

        for i, vec in enumerate(basevec):
            if i < 2:
                assert vec.shape == (2,)
            else:
                assert vec.shape == (3,)
        return

    @pytest.mark.parametrize('arr_shape', [(2,), (5,)])
    @pytest.mark.parametrize("bv_coord", ["qd", "apex"])
    @pytest.mark.parametrize("ivec", range(3))
    def test_basevectors_array(self, arr_shape, bv_coord, ivec):
        """Test the output shape for array inputs.

        Parameters
        ----------
        arr_shape : tuple
            Expected output shape
        bv_coord : str
            Name of the input coordinate system
        ivec : int
            Index of the evaluated output value

        """
        # Define the input arguments
        in_args = [self.lat, self.lon, self.height]
        in_args[ivec] = np.full(shape=arr_shape, fill_value=in_args[ivec])

        # Get the basevectors
        base_method = getattr(self.apex_out,
                              "basevectors_{:s}".format(bv_coord))
        basevec = base_method(*in_args, coords='geo', precision=1e-10)
        self.get_comparison_results(bv_coord, "geo", 1e-10)
        if bv_coord == "apex":
            basevec = list(basevec)
            for i in range(4):
                # Not able to compare indices 2, 3, 4, and 5
                basevec.pop(2)

        # Evaluate the shape and the values
        for i, vec in enumerate(basevec):
            test_shape = list(arr_shape)
            test_shape.insert(0, 2 if i < 2 else 3)
            assert vec.shape == tuple(test_shape)
            assert np.all(self.test_basevec[i][0] == vec[0])
            assert np.all(self.test_basevec[i][1] == vec[1])
        return

    @pytest.mark.parametrize("coords", ["geo", "apex", "qd"])
    def test_bvectors_apex(self, coords):
        """Test the bvectors_apex method.

        Parameters
        ----------
        coords : str
            Name of the coordiante system

        """
        in_args = [[self.lat, self.lat], [self.lon, self.lon],
                   [self.height, self.height]]
        self.get_comparison_results("bvectors_apex", coords, 1e-10)

        basevec = self.apex_out.bvectors_apex(*in_args, coords=coords,
                                              precision=1e-10)
        for i, vec in enumerate(basevec):
            np.testing.assert_array_almost_equal(vec, self.test_basevec[i],
                                                 decimal=5)
        return

    def test_basevectors_apex_extra_values(self):
        """Test specific values in the apex base vector output."""
        # Set the testing arrays
        self.test_basevec = [np.array([0.092637, -0.245951, 0.938848]),
                             np.array([0.939012, 0.073416, -0.07342]),
                             np.array([0.055389, 1.004155, 0.257594]),
                             np.array([0, 0, 1.065135])]

        # Get the desired output
        basevec = self.apex_out.basevectors_apex(0, 15, 100, coords='geo')

        # Test the values not covered by `test_basevectors_scalar`
        for itest, ibase in enumerate(np.arange(2, 6, 1)):
            np.testing.assert_allclose(basevec[ibase],
                                       self.test_basevec[itest], rtol=1e-4)
        return

    @pytest.mark.parametrize("lat", range(0, 90, 10))
    @pytest.mark.parametrize("lon", range(0, 360, 15))
    def test_basevectors_apex_delta(self, lat, lon):
        """Test that vectors are calculated correctly.

        Parameters
        ----------
        lat : int or float
            Latitude in degrees N
        lon : int or float
            Longitude in degrees E

        """
        # Get the apex base vectors and sort them for easy testing
        (f1, f2, f3, g1, g2, g3, d1, d2, d3, e1, e2,
         e3) = self.apex_out.basevectors_apex(lat, lon, 500)
        fvec = [np.append(f1, 0), np.append(f2, 0), f3]
        gvec = [g1, g2, g3]
        dvec = [d1, d2, d3]
        evec = [e1, e2, e3]

        for idelta, jdelta in [(i, j) for i in range(3) for j in range(3)]:
            delta = 1 if idelta == jdelta else 0
            np.testing.assert_allclose(np.sum(fvec[idelta] * gvec[jdelta]),
                                       delta, rtol=0, atol=1e-5)
            np.testing.assert_allclose(np.sum(dvec[idelta] * evec[jdelta]),
                                       delta, rtol=0, atol=1e-5)
        return

    def test_basevectors_apex_invalid_scalar(self):
        """Test warning and fill values for base vectors with bad inputs."""
        self.apex_out = apexpy.Apex(date=2000, refh=10000)
        invalid = np.full(shape=(3,), fill_value=np.nan)

        # Get the output and the warnings
        with warnings.catch_warnings(record=True) as warn_rec:
            basevec = self.apex_out.basevectors_apex(0, 0, 0)

        for i, bvec in enumerate(basevec):
            if i < 2:
                assert not np.allclose(bvec, invalid[:2])
            else:
                np.testing.assert_allclose(bvec, invalid)

        assert issubclass(warn_rec[-1].category, UserWarning)
        assert 'set to NaN where' in str(warn_rec[-1].message)
        return


class TestApexGetMethods(object):
    """Test the Apex `get` methods."""
    def setup_method(self):
        """Initialize all tests."""
        self.apex_out = apexpy.Apex(date=2000, refh=300)

    def teardown_method(self):
        """Clean up after each test."""
        del self.apex_out

    @pytest.mark.parametrize("alat, aheight",
                             [(10, 507.409702543805),
                              (60, 20313.026999999987),
                              ([10, 60],
                               [507.409702543805, 20313.026999999987]),
                              ([[10], [60]],
                               [[507.409702543805], [20313.026999999987]])])
    def test_get_apex(self, alat, aheight):
        """Test the apex height retrieval results.

        Parameters
        ----------
        alat : int or float
            Apex latitude in degrees N
        aheight : int or float
            Apex height in km

        """
        alt = self.apex_out.get_apex(alat)
        np.testing.assert_allclose(alt, aheight)
        return

    @pytest.mark.parametrize("glat,glon,height,test_bmag",
                             [([80], [100], [300], 5.100682377815247e-05),
                              ([80, 80], [100], [300],
                               [5.100682377815247e-05, 5.100682377815247e-05]),
                              ([[80], [80]], [100], [300],
                               [[5.100682377815247e-05],
                                [5.100682377815247e-05]]),
                              (range(50, 90, 8), range(0, 360, 80), [300] * 5,
                               np.array([4.18657154e-05, 5.11118114e-05,
                                         4.91969854e-05, 5.10519207e-05,
                                         4.90054816e-05])),
                              (90.0, 0, 1000, 3.7834718823432923e-05)])
    def test_get_babs(self, glat, glon, height, test_bmag):
        """Test the method to get the magnitude of the magnetic field.

        Parameters
        ----------
        glat : list
            List of latitudes in degrees N
        glon : list
            List of longitudes in degrees E
        height : list
            List of heights in km
        test_bmag : float
            Expected B field magnitude

        """
        bmag = self.apex_out.get_babs(glat, glon, height)
        np.testing.assert_allclose(bmag, test_bmag, rtol=0, atol=1e-5)
        return

    @pytest.mark.parametrize("bad_lat", [(91), (-91)])
    def test_get_apex_with_invalid_lat(self, bad_lat):
        """Test get methods raise ValueError for invalid latitudes.

        Parameters
        ----------
        bad_lat : int or float
            Bad input latitude in degrees N

        """

        with pytest.raises(ValueError) as verr:
            self.apex_out.get_apex(bad_lat)

        assert str(verr.value).find("must be in [-90, 90]") > 0
        return

    @pytest.mark.parametrize("bad_lat", [(91), (-91)])
    def test_get_babs_with_invalid_lat(self, bad_lat):
        """Test get methods raise ValueError for invalid latitudes.

        Parameters
        ----------
        bad_lat : int or float
            Bad input latitude in degrees N

        """

        with pytest.raises(ValueError) as verr:
            self.apex_out.get_babs(bad_lat, 15, 100)

        assert str(verr.value).find("must be in [-90, 90]") > 0
        return

    @pytest.mark.parametrize("bound_lat", [(90), (-90)])
    def test_get_at_lat_boundary(self, bound_lat):
        """Test get methods at the latitude boundary, with allowed excess.

        Parameters
        ----------
        bound_lat : int or float
            Boundary input latitude in degrees N

        """
        # Get a latitude just beyond the limit
        excess_lat = np.sign(bound_lat) * (abs(bound_lat) + 1.0e-5)

        # Get the two outputs, slight tolerance outside of boundary allowed
        bound_out = self.apex_out.get_apex(bound_lat)
        excess_out = self.apex_out.get_apex(excess_lat)

        # Test the outputs
        np.testing.assert_allclose(excess_out, bound_out, rtol=0, atol=1e-8)
        return

    @pytest.mark.parametrize("apex_height", [-100, 0, 300, 10000])
    def test_get_height_at_equator(self, apex_height):
        """Test that `get_height` returns apex height at equator.

        Parameters
        ----------
        apex_height : float
            Apex height

        """

        assert apex_height == self.apex_out.get_height(0.0, apex_height)
        return

    @pytest.mark.parametrize("lat, height", [
        (-90, -6371.009), (-80, -6088.438503309167), (-70, -5274.8091854339655),
        (-60, -4028.256749999999), (-50, -2499.1338178752017),
        (-40, -871.8751821247979), (-30, 657.2477500000014),
        (-20, 1903.8001854339655), (-10, 2717.4295033091657), (0, 3000.0),
        (10, 2717.4295033091657), (20, 1903.8001854339655),
        (30, 657.2477500000014), (40, -871.8751821247979),
        (50, -2499.1338178752017), (60, -4028.256749999999),
        (70, -5274.8091854339655), (80, -6088.438503309167)])
    def test_get_height_along_fieldline(self, lat, height):
        """Test that `get_height` returns expected height of field line.

        Parameters
        ----------
        lat : float
            Input latitude
        height : float
            Output field-line height for line with apex of 3000 km

        """

        fheight = self.apex_out.get_height(lat, 3000.0)
        assert abs(height - fheight) < 1.0e-7, \
            "bad height calculation: {:.7f} != {:.7f}".format(height, fheight)
        return


class TestApexMethodExtrapolateIGRF(object):
    """Test the Apex methods on a year when IGRF must be extrapolated.

    Notes
    -----
    Extrapolation should be done using a year within 5 years of the latest IGRF
    model epoch.

    """

    def setup_method(self):
        """Initialize all tests."""
        self.apex_out = apexpy.Apex(date=2025, refh=300)
        self.in_lat = 60
        self.in_lon = 15
        self.in_alt = 100
        self.in_time = dt.datetime(2024, 2, 3, 4, 5, 6)
        return

    def teardown_method(self):
        """Clean up after each test."""
        del self.apex_out, self.in_lat, self.in_lon, self.in_alt
        return

    @pytest.mark.parametrize("method_name, out_comp",

This code seems to be duplicated in your project.

                             [("geo2apex",
                               (56.25343704223633, 92.04932403564453)),
                              ("apex2geo",
                               (53.84184265136719, -66.93045806884766,
                                3.6222547805664362e-06)),
                              ("geo2qd",
                               (56.82968521118164, 92.04932403564453)),
                              ("apex2qd", (60.498401178276744, 15.0)),
                              ("qd2apex", (59.49138097045895, 15.0))])
    def test_method_scalar_input(self, method_name, out_comp):
        """Test the user method against set values with scalars.

        Parameters
        ----------
        method_name : str
            Apex class method to be tested
        out_comp : tuple of floats
            Expected output values

        """
        # Get the desired methods
        user_method = getattr(self.apex_out, method_name)

        # Get the user output
        user_out = user_method(self.in_lat, self.in_lon, self.in_alt)

        # Evaluate the user output
        np.testing.assert_allclose(user_out, out_comp, rtol=1e-5, atol=1e-5)

        for out_val in user_out:
            assert np.asarray(out_val).shape == (), "output is not a scalar"
        return

    def test_convert_to_mlt(self):
        """Test conversion from mlon to mlt with scalars."""

        # Get user output
        user_out = self.apex_out.mlon2mlt(self.in_lon, self.in_time)

        # Set comparison values
        out_comp = 23.955474853515625

        # Evaluate user output
        np.testing.assert_allclose(user_out, out_comp, rtol=1e-5, atol=1e-5)
        return