import copy
import math
import pprint

import pytest

from pint import Context, DimensionalityError, UnitRegistry, get_application_registry
from pint.compat import np
from pint.testsuite import QuantityTestCase, helpers
from pint.unit import UnitsContainer
from pint.util import ParserHelper

ureg = UnitRegistry()


class TestIssues(QuantityTestCase):

    kwargs = dict(autoconvert_offset_to_baseunit=False)

    @pytest.mark.xfail
    def test_issue25(self):
        x = ParserHelper.from_string("10 %")
        assert x == ParserHelper(10, {"%": 1})
        x = ParserHelper.from_string("10 ‰")
        assert x == ParserHelper(10, {"‰": 1})
        ureg.define("percent = [fraction]; offset: 0 = %")
        ureg.define("permille = percent / 10 = ‰")
        x = ureg.parse_expression("10 %")
        assert x == ureg.Quantity(10, {"%": 1})
        y = ureg.parse_expression("10 ‰")
        assert y == ureg.Quantity(10, {"‰": 1})
        assert x.to("‰") == ureg.Quantity(1, {"‰": 1})

    def test_issue29(self):
        t = 4 * ureg("mW")
        assert t.magnitude == 4
        assert t._units == UnitsContainer(milliwatt=1)
        assert t.to("joule / second") == 4e-3 * ureg("W")

    @pytest.mark.xfail
    @helpers.requires_numpy
    def test_issue37(self):
        x = np.ma.masked_array([1, 2, 3], mask=[True, True, False])
        q = ureg.meter * x
        assert isinstance(q, ureg.Quantity)
        np.testing.assert_array_equal(q.magnitude, x)
        assert q.units == ureg.meter.units
        q = x * ureg.meter
        assert isinstance(q, ureg.Quantity)
        np.testing.assert_array_equal(q.magnitude, x)
        assert q.units == ureg.meter.units

        m = np.ma.masked_array(2 * np.ones(3, 3))
        qq = q * m
        assert isinstance(qq, ureg.Quantity)
        np.testing.assert_array_equal(qq.magnitude, x * m)
        assert qq.units == ureg.meter.units
        qq = m * q
        assert isinstance(qq, ureg.Quantity)
        np.testing.assert_array_equal(qq.magnitude, x * m)
        assert qq.units == ureg.meter.units

    @pytest.mark.xfail
    @helpers.requires_numpy
    def test_issue39(self):
        x = np.matrix([[1, 2, 3], [1, 2, 3], [1, 2, 3]])
        q = ureg.meter * x
        assert isinstance(q, ureg.Quantity)
        np.testing.assert_array_equal(q.magnitude, x)
        assert q.units == ureg.meter.units
        q = x * ureg.meter
        assert isinstance(q, ureg.Quantity)
        np.testing.assert_array_equal(q.magnitude, x)
        assert q.units == ureg.meter.units

        m = np.matrix(2 * np.ones(3, 3))
        qq = q * m
        assert isinstance(qq, ureg.Quantity)
        np.testing.assert_array_equal(qq.magnitude, x * m)
        assert qq.units == ureg.meter.units
        qq = m * q
        assert isinstance(qq, ureg.Quantity)
        np.testing.assert_array_equal(qq.magnitude, x * m)
        assert qq.units == ureg.meter.units

    @helpers.requires_numpy
    def test_issue44(self):
        x = 4.0 * ureg.dimensionless
        np.sqrt(x)
        helpers.assert_quantity_almost_equal(
            np.sqrt([4.0] * ureg.dimensionless), [2.0] * ureg.dimensionless
        )
        helpers.assert_quantity_almost_equal(
            np.sqrt(4.0 * ureg.dimensionless), 2.0 * ureg.dimensionless
        )

    def test_issue45(self):
        import math

        helpers.assert_quantity_almost_equal(
            math.sqrt(4 * ureg.m / ureg.cm), math.sqrt(4 * 100)
        )
        helpers.assert_quantity_almost_equal(float(ureg.V / ureg.mV), 1000.0)

    @helpers.requires_numpy
    def test_issue45b(self):
        helpers.assert_quantity_almost_equal(
            np.sin([np.pi / 2] * ureg.m / ureg.m),
            np.sin([np.pi / 2] * ureg.dimensionless),
        )
        helpers.assert_quantity_almost_equal(
            np.sin([np.pi / 2] * ureg.cm / ureg.m),
            np.sin([np.pi / 2] * ureg.dimensionless * 0.01),
        )

    def test_issue50(self):
        Q_ = ureg.Quantity
        assert Q_(100) == 100 * ureg.dimensionless
        assert Q_("100") == 100 * ureg.dimensionless

    def test_issue52(self):
        u1 = UnitRegistry()
        u2 = UnitRegistry()
        q1 = 1 * u1.meter
        q2 = 1 * u2.meter
        import operator as op

        for fun in (
            op.add,
            op.iadd,
            op.sub,
            op.isub,
            op.mul,
            op.imul,
            op.floordiv,
            op.ifloordiv,
            op.truediv,
            op.itruediv,
        ):
            with pytest.raises(ValueError):
                fun(q1, q2)

    def test_issue54(self):
        assert (1 * ureg.km / ureg.m + 1).magnitude == 1001

    def test_issue54_related(self):
        assert ureg.km / ureg.m == 1000
        assert 1000 == ureg.km / ureg.m
        assert 900 < ureg.km / ureg.m
        assert 1100 > ureg.km / ureg.m

    def test_issue61(self):
        Q_ = ureg.Quantity
        for value in ({}, {"a": 3}, None):
            with pytest.raises(TypeError):
                Q_(value)
            with pytest.raises(TypeError):
                Q_(value, "meter")
        with pytest.raises(ValueError):
            Q_("", "meter")
        with pytest.raises(ValueError):
            Q_("")

    @helpers.requires_not_numpy()
    def test_issue61_notNP(self):
        Q_ = ureg.Quantity
        for value in ([1, 2, 3], (1, 2, 3)):
            with pytest.raises(TypeError):
                Q_(value)
            with pytest.raises(TypeError):
                Q_(value, "meter")

    def test_issue62(self):
        m = ureg("m**0.5")
        assert str(m.units) == "meter ** 0.5"

    def test_issue66(self):
        assert ureg.get_dimensionality(
            UnitsContainer({"[temperature]": 1})
        ) == UnitsContainer({"[temperature]": 1})
        assert ureg.get_dimensionality(ureg.kelvin) == UnitsContainer(
            {"[temperature]": 1}
        )
        assert ureg.get_dimensionality(ureg.degC) == UnitsContainer(
            {"[temperature]": 1}
        )

    def test_issue66b(self):
        assert ureg.get_base_units(ureg.kelvin) == (
            1.0,
            ureg.Unit(UnitsContainer({"kelvin": 1})),
        )
        assert ureg.get_base_units(ureg.degC) == (
            1.0,
            ureg.Unit(UnitsContainer({"kelvin": 1})),
        )

    def test_issue69(self):
        q = ureg("m").to(ureg("in"))
        assert q == ureg("m").to("in")

    @helpers.requires_numpy
    def test_issue74(self):
        v1 = np.asarray([1.0, 2.0, 3.0])
        v2 = np.asarray([3.0, 2.0, 1.0])
        q1 = v1 * ureg.ms
        q2 = v2 * ureg.ms

        np.testing.assert_array_equal(q1 < q2, v1 < v2)
        np.testing.assert_array_equal(q1 > q2, v1 > v2)

        np.testing.assert_array_equal(q1 <= q2, v1 <= v2)
        np.testing.assert_array_equal(q1 >= q2, v1 >= v2)

        q2s = np.asarray([0.003, 0.002, 0.001]) * ureg.s
        v2s = q2s.to("ms").magnitude

        np.testing.assert_array_equal(q1 < q2s, v1 < v2s)
        np.testing.assert_array_equal(q1 > q2s, v1 > v2s)

        np.testing.assert_array_equal(q1 <= q2s, v1 <= v2s)
        np.testing.assert_array_equal(q1 >= q2s, v1 >= v2s)

    @helpers.requires_numpy
    def test_issue75(self):
        v1 = np.asarray([1.0, 2.0, 3.0])
        v2 = np.asarray([3.0, 2.0, 1.0])
        q1 = v1 * ureg.ms
        q2 = v2 * ureg.ms

        np.testing.assert_array_equal(q1 == q2, v1 == v2)
        np.testing.assert_array_equal(q1 != q2, v1 != v2)

        q2s = np.asarray([0.003, 0.002, 0.001]) * ureg.s
        v2s = q2s.to("ms").magnitude

        np.testing.assert_array_equal(q1 == q2s, v1 == v2s)
        np.testing.assert_array_equal(q1 != q2s, v1 != v2s)

    @helpers.requires_uncertainties()
    def test_issue77(self):
        acc = (5.0 * ureg("m/s/s")).plus_minus(0.25)
        tim = (37.0 * ureg("s")).plus_minus(0.16)
        dis = acc * tim ** 2 / 2
        assert dis.value == acc.value * tim.value ** 2 / 2

    def test_issue85(self):

        T = 4.0 * ureg.kelvin
        m = 1.0 * ureg.amu
        va = 2.0 * ureg.k * T / m

        va.to_base_units()

        boltmk = 1.380649e-23 * ureg.J / ureg.K
        vb = 2.0 * boltmk * T / m

        helpers.assert_quantity_almost_equal(va.to_base_units(), vb.to_base_units())

    def test_issue86(self):
        ureg = self.ureg
        ureg.autoconvert_offset_to_baseunit = True

        def parts(q):
            return q.magnitude, q.units

        q1 = 10.0 * ureg.degC
        q2 = 10.0 * ureg.kelvin

        k1 = q1.to_base_units()

        q3 = 3.0 * ureg.meter

        q1m, q1u = parts(q1)
        q2m, q2u = parts(q2)
        q3m, q3u = parts(q3)

        k1m, k1u = parts(k1)

        assert parts(q2 * q3) == (q2m * q3m, q2u * q3u)
        assert parts(q2 / q3) == (q2m / q3m, q2u / q3u)
        assert parts(q3 * q2) == (q3m * q2m, q3u * q2u)
        assert parts(q3 / q2) == (q3m / q2m, q3u / q2u)
        assert parts(q2 ** 1) == (q2m ** 1, q2u ** 1)
        assert parts(q2 ** -1) == (q2m ** -1, q2u ** -1)
        assert parts(q2 ** 2) == (q2m ** 2, q2u ** 2)
        assert parts(q2 ** -2) == (q2m ** -2, q2u ** -2)

        assert parts(q1 * q3) == (k1m * q3m, k1u * q3u)
        assert parts(q1 / q3) == (k1m / q3m, k1u / q3u)
        assert parts(q3 * q1) == (q3m * k1m, q3u * k1u)
        assert parts(q3 / q1) == (q3m / k1m, q3u / k1u)
        assert parts(q1 ** -1) == (k1m ** -1, k1u ** -1)
        assert parts(q1 ** 2) == (k1m ** 2, k1u ** 2)
        assert parts(q1 ** -2) == (k1m ** -2, k1u ** -2)

    def test_issues86b(self):
        ureg = self.ureg

        T1 = 200.0 * ureg.degC
        T2 = T1.to(ureg.kelvin)
        m = 132.9054519 * ureg.amu
        v1 = 2 * ureg.k * T1 / m
        v2 = 2 * ureg.k * T2 / m

        helpers.assert_quantity_almost_equal(v1, v2)
        helpers.assert_quantity_almost_equal(v1, v2.to_base_units())
        helpers.assert_quantity_almost_equal(v1.to_base_units(), v2)
        helpers.assert_quantity_almost_equal(v1.to_base_units(), v2.to_base_units())

    @pytest.mark.xfail
    def test_issue86c(self):
        ureg = self.ureg
        ureg.autoconvert_offset_to_baseunit = True
        T = ureg.degC
        T = 100.0 * T
        helpers.assert_quantity_almost_equal(ureg.k * 2 * T, ureg.k * (2 * T))

    def test_issue93(self):
        x = 5 * ureg.meter
        assert isinstance(x.magnitude, int)
        y = 0.1 * ureg.meter
        assert isinstance(y.magnitude, float)
        z = 5 * ureg.meter
        assert isinstance(z.magnitude, int)
        z += y
        assert isinstance(z.magnitude, float)

        helpers.assert_quantity_almost_equal(x + y, 5.1 * ureg.meter)
        helpers.assert_quantity_almost_equal(z, 5.1 * ureg.meter)

    def test_issue104(self):

        x = [ureg("1 meter"), ureg("1 meter"), ureg("1 meter")]
        y = [ureg("1 meter")] * 3

        def summer(values):
            if not values:
                return 0
            total = values[0]
            for v in values[1:]:
                total += v

            return total

        helpers.assert_quantity_almost_equal(summer(x), ureg.Quantity(3, "meter"))
        helpers.assert_quantity_almost_equal(x[0], ureg.Quantity(1, "meter"))
        helpers.assert_quantity_almost_equal(summer(y), ureg.Quantity(3, "meter"))
        helpers.assert_quantity_almost_equal(y[0], ureg.Quantity(1, "meter"))

    def test_issue105(self):

        func = ureg.parse_unit_name
        val = list(func("meter"))
        assert list(func("METER")) == []
        assert val == list(func("METER", False))

        for func in (ureg.get_name, ureg.parse_expression):
            val = func("meter")
            with pytest.raises(AttributeError):
                func("METER")
            assert val == func("METER", False)

    @helpers.requires_numpy
    def test_issue127(self):
        q = [1.0, 2.0, 3.0, 4.0] * self.ureg.meter
        q[0] = np.nan
        assert q[0] != 1.0
        assert math.isnan(q[0].magnitude)
        q[1] = float("NaN")
        assert q[1] != 2.0
        assert math.isnan(q[1].magnitude)

    def test_issue170(self):
        Q_ = UnitRegistry().Quantity
        q = Q_("1 kHz") / Q_("100 Hz")
        iq = int(q)
        assert iq == 10
        assert isinstance(iq, int)

    def test_angstrom_creation(self):
        ureg.Quantity(2, "Å")

    def test_alternative_angstrom_definition(self):
        ureg.Quantity(2, "\u212B")

    def test_micro_creation(self):
        ureg.Quantity(2, "µm")

    @helpers.requires_numpy
    def test_issue171_real_imag(self):
        qr = [1.0, 2.0, 3.0, 4.0] * self.ureg.meter
        qi = [4.0, 3.0, 2.0, 1.0] * self.ureg.meter
        q = qr + 1j * qi
        helpers.assert_quantity_equal(q.real, qr)
        helpers.assert_quantity_equal(q.imag, qi)

    @helpers.requires_numpy
    def test_issue171_T(self):
        a = np.asarray([[1.0, 2.0, 3.0, 4.0], [4.0, 3.0, 2.0, 1.0]])
        q1 = a * self.ureg.meter
        q2 = a.T * self.ureg.meter
        helpers.assert_quantity_equal(q1.T, q2)

    @helpers.requires_numpy
    def test_issue250(self):
        a = self.ureg.V
        b = self.ureg.mV
        assert np.float16(a / b) == 1000.0
        assert np.float32(a / b) == 1000.0
        assert np.float64(a / b) == 1000.0
        if "float128" in dir(np):
            assert np.float128(a / b) == 1000.0

    def test_issue252(self):
        ur = UnitRegistry()
        q = ur("3 F")
        t = copy.deepcopy(q)
        u = t.to(ur.mF)
        helpers.assert_quantity_equal(q.to(ur.mF), u)

    def test_issue323(self):
        from fractions import Fraction as F

        assert (self.Q_(F(2, 3), "s")).to("ms") == self.Q_(F(2000, 3), "ms")
        assert (self.Q_(F(2, 3), "m")).to("km") == self.Q_(F(1, 1500), "km")

    def test_issue339(self):
        q1 = self.ureg("")
        assert q1.magnitude == 1
        assert q1.units == self.ureg.dimensionless
        q2 = self.ureg("1 dimensionless")
        assert q1 == q2

    def test_issue354_356_370(self):
        assert (
            "{:~}".format(1 * self.ureg.second / self.ureg.millisecond) == "1.0 s / ms"
        )
        assert "{:~}".format(1 * self.ureg.count) == "1 count"
        assert "{:~}".format(1 * self.ureg("MiB")) == "1 MiB"

    def test_issue468(self):
        @ureg.wraps("kg", "meter")
        def f(x):
            return x

        x = ureg.Quantity(1.0, "meter")
        y = f(x)
        z = x * y
        assert z == ureg.Quantity(1.0, "meter * kilogram")

    @helpers.requires_numpy
    def test_issue482(self):
        q = self.ureg.Quantity(1, self.ureg.dimensionless)
        qe = np.exp(q)
        assert isinstance(qe, self.ureg.Quantity)

    @helpers.requires_numpy
    def test_issue483(self):
        ureg = self.ureg
        a = np.asarray([1, 2, 3])
        q = [1, 2, 3] * ureg.dimensionless
        p = (q ** q).m
        np.testing.assert_array_equal(p, a ** a)

    def test_issue507(self):
        # leading underscore in unit works with numbers
        ureg.define("_100km = 100 * kilometer")
        battery_ec = 16 * ureg.kWh / ureg._100km  # noqa: F841
        # ... but not with text
        ureg.define("_home = 4700 * kWh / year")
        with pytest.raises(AttributeError):
            home_elec_power = 1 * ureg._home  # noqa: F841
        # ... or with *only* underscores
        ureg.define("_ = 45 * km")
        with pytest.raises(AttributeError):
            one_blank = 1 * ureg._  # noqa: F841

    def test_issue523(self):
        src, dst = UnitsContainer({"meter": 1}), UnitsContainer({"degF": 1})
        value = 10.0
        convert = self.ureg.convert
        with pytest.raises(DimensionalityError):
            convert(value, src, dst)
        with pytest.raises(DimensionalityError):
            convert(value, dst, src)

    def test_issue532(self):
        ureg = self.ureg

        @ureg.check(ureg(""))
        def f(x):
            return 2 * x

        assert f(ureg.Quantity(1, "")) == 2
        with pytest.raises(DimensionalityError):
            f(ureg.Quantity(1, "m"))

    def test_issue625a(self):
        Q_ = ureg.Quantity
        from math import sqrt

        @ureg.wraps(ureg.second, (ureg.meters, ureg.meters / ureg.second ** 2))
        def calculate_time_to_fall(height, gravity=Q_(9.8, "m/s^2")):
            """Calculate time to fall from a height h with a default gravity.

            By default, the gravity is assumed to be earth gravity,
            but it can be modified.

            d = .5 * g * t**2
            t = sqrt(2 * d / g)

            Parameters
            ----------
            height :

            gravity :
                 (Default value = Q_(9.8)
            "m/s^2") :


            Returns
            -------

            """
            return sqrt(2 * height / gravity)

        lunar_module_height = Q_(10, "m")
        t1 = calculate_time_to_fall(lunar_module_height)
        # print(t1)
        assert round(abs(t1 - Q_(1.4285714285714286, "s")), 7) == 0

        moon_gravity = Q_(1.625, "m/s^2")
        t2 = calculate_time_to_fall(lunar_module_height, moon_gravity)
        assert round(abs(t2 - Q_(3.508232077228117, "s")), 7) == 0

    def test_issue625b(self):
        Q_ = ureg.Quantity

        @ureg.wraps("=A*B", ("=A", "=B"))
        def get_displacement(time, rate=Q_(1, "m/s")):
            """Calculates displacement from a duration and default rate.

            Parameters
            ----------
            time :

            rate :
                 (Default value = Q_(1)
            "m/s") :


            Returns
            -------

            """
            return time * rate

        d1 = get_displacement(Q_(2, "s"))
        assert round(abs(d1 - Q_(2, "m")), 7) == 0

        d2 = get_displacement(Q_(2, "s"), Q_(1, "deg/s"))
        assert round(abs(d2 - Q_(2, " deg")), 7) == 0

    def test_issue625c(self):
        u = UnitRegistry()

        @u.wraps("=A*B*C", ("=A", "=B", "=C"))
        def get_product(a=2 * u.m, b=3 * u.m, c=5 * u.m):
            return a * b * c

        assert get_product(a=3 * u.m) == 45 * u.m ** 3
        assert get_product(b=2 * u.m) == 20 * u.m ** 3
        assert get_product(c=1 * u.dimensionless) == 6 * u.m ** 2

    def test_issue655a(self):
        distance = 1 * ureg.m
        time = 1 * ureg.s
        velocity = distance / time
        assert distance.check("[length]")
        assert not distance.check("[time]")
        assert velocity.check("[length] / [time]")
        assert velocity.check("1 / [time] * [length]")

    def test_issue655b(self):
        Q_ = ureg.Quantity

        @ureg.check("[length]", "[length]/[time]^2")
        def pendulum_period(length, G=Q_(1, "standard_gravity")):
            # print(length)
            return (2 * math.pi * (length / G) ** 0.5).to("s")

        length = Q_(1, ureg.m)
        # Assume earth gravity
        t = pendulum_period(length)
        assert round(abs(t - Q_("2.0064092925890407 second")), 7) == 0
        # Use moon gravity
        moon_gravity = Q_(1.625, "m/s^2")
        t = pendulum_period(length, moon_gravity)
        assert round(abs(t - Q_("4.928936075204336 second")), 7) == 0

    def test_issue783(self):
        assert not ureg("g") == []

    def test_issue856(self):
        ph1 = ParserHelper(scale=123)
        ph2 = copy.deepcopy(ph1)
        assert ph2.scale == ph1.scale

        ureg1 = UnitRegistry()
        ureg2 = copy.deepcopy(ureg1)
        # Very basic functionality test
        assert ureg2("1 t").to("kg").magnitude == 1000

    def test_issue856b(self):
        # Test that, after a deepcopy(), the two UnitRegistries are
        # independent from each other
        ureg1 = UnitRegistry()
        ureg2 = copy.deepcopy(ureg1)
        ureg1.define("test123 = 123 kg")
        ureg2.define("test123 = 456 kg")
        assert ureg1("1 test123").to("kg").magnitude == 123
        assert ureg2("1 test123").to("kg").magnitude == 456

    def test_issue876(self):
        # Same hash must not imply equality.

        # As an implementation detail of CPython, hash(-1) == hash(-2).
        # This test is useless in potential alternative Python implementations where
        # hash(-1) != hash(-2); one would need to find hash collisions specific for each
        # implementation

        a = UnitsContainer({"[mass]": -1})
        b = UnitsContainer({"[mass]": -2})
        c = UnitsContainer({"[mass]": -3})

        # Guarantee working on alternative Python implementations
        assert (hash(-1) == hash(-2)) == (hash(a) == hash(b))
        assert (hash(-1) == hash(-3)) == (hash(a) == hash(c))
        assert a != b
        assert a != c

    def test_issue902(self):
        ureg = UnitRegistry(auto_reduce_dimensions=True)
        velocity = 1 * ureg.m / ureg.s
        cross_section = 1 * ureg.um ** 2
        result = cross_section / velocity
        assert result == 1e-12 * ureg.m * ureg.s

    def test_issue912(self):
        """pprint.pformat() invokes sorted() on large sets and frozensets and graciously
        handles TypeError, but not generic Exceptions. This test will fail if
        pint.DimensionalityError stops being a subclass of TypeError.

        Parameters
        ----------

        Returns
        -------

        """
        meter_units = ureg.get_compatible_units(ureg.meter)
        hertz_units = ureg.get_compatible_units(ureg.hertz)
        pprint.pformat(meter_units | hertz_units)

    def test_issue932(self):
        q = ureg.Quantity("1 kg")
        with pytest.raises(DimensionalityError):
            q.to("joule")
        ureg.enable_contexts("energy", *(Context() for _ in range(20)))
        q.to("joule")
        ureg.disable_contexts()
        with pytest.raises(DimensionalityError):
            q.to("joule")

    def test_issue960(self):
        q = (1 * ureg.nanometer).to_compact("micrometer")
        assert q.units == ureg.nanometer
        assert q.magnitude == 1

    def test_issue1032(self):
        class MultiplicativeDictionary(dict):
            def __rmul__(self, other):
                return self.__class__(
                    {key: value * other for key, value in self.items()}
                )

        q = 3 * ureg.s
        d = MultiplicativeDictionary({4: 5, 6: 7})
        assert q * d == MultiplicativeDictionary({4: 15 * ureg.s, 6: 21 * ureg.s})
        with pytest.raises(TypeError):
            d * q

    @helpers.requires_numpy
    def test_issue973(self):
        """Verify that an empty array Quantity can be created through multiplication."""
        q0 = np.array([]) * ureg.m  # by Unit
        q1 = np.array([]) * ureg("m")  # by Quantity
        assert isinstance(q0, ureg.Quantity)
        assert isinstance(q1, ureg.Quantity)
        assert len(q0) == len(q1) == 0

    def test_issue1058(self):
        """verify that auto-reducing quantities with three or more units
        of same base type succeeds"""
        q = 1 * ureg.mg / ureg.g / ureg.kg
        q.ito_reduced_units()
        assert isinstance(q, ureg.Quantity)

    def test_issue1062_issue1097(self):
        # Must not be used by any other tests
        ureg = UnitRegistry()
        assert "nanometer" not in ureg._units
        for i in range(5):
            ctx = Context.from_lines(["@context _", "cal = 4 J"])
            with ureg.context("sp", ctx):
                q = ureg.Quantity(1, "nm")
                q.to("J")

    def test_issue1086(self):
        # units with prefixes should correctly test as 'in' the registry
        assert "bits" in ureg
        assert "gigabits" in ureg
        assert "meters" in ureg
        assert "kilometers" in ureg
        # unknown or incorrect units should test as 'not in' the registry
        assert "magicbits" not in ureg
        assert "unknownmeters" not in ureg
        assert "gigatrees" not in ureg

    def test_issue1112(self):
        ureg = UnitRegistry(
            """
            m = [length]
            g = [mass]
            s = [time]

            ft = 0.305 m
            lb = 454 g

            @context c1
                [time]->[length] : value * 10 m/s
            @end
            @context c2
                ft = 0.3 m
            @end
            @context c3
                lb = 500 g
            @end
            """.splitlines()
        )
        ureg.enable_contexts("c1")
        ureg.enable_contexts("c2")
        ureg.enable_contexts("c3")

    @helpers.requires_numpy
    def test_issue1144_1102(self):
        # Performing operations shouldn't modify the original objects
        # Issue 1144
        ddc = "delta_degree_Celsius"
        q1 = ureg.Quantity([-287.78, -32.24, -1.94], ddc)
        q2 = ureg.Quantity(70.0, "degree_Fahrenheit")
        q1 - q2
        assert all(q1 == ureg.Quantity([-287.78, -32.24, -1.94], ddc))
        assert q2 == ureg.Quantity(70.0, "degree_Fahrenheit")
        q2 - q1
        assert all(q1 == ureg.Quantity([-287.78, -32.24, -1.94], ddc))
        assert q2 == ureg.Quantity(70.0, "degree_Fahrenheit")
        # Issue 1102
        val = [30.0, 45.0, 60.0] * ureg.degree
        val == 1
        1 == val
        assert all(val == ureg.Quantity([30.0, 45.0, 60.0], "degree"))
        # Test for another bug identified by searching on "_convert_magnitude"
        q2 = ureg.Quantity(3, "degree_Kelvin")
        q1 - q2
        assert all(q1 == ureg.Quantity([-287.78, -32.24, -1.94], ddc))

    @helpers.requires_numpy
    def test_issue_1136(self):
        assert (2 ** ureg.Quantity([2, 3], "") == 2 ** np.array([2, 3])).all()

        with pytest.raises(DimensionalityError):
            2 ** ureg.Quantity([2, 3], "m")

    def test_issue1175(self):
        import pickle

        foo1 = get_application_registry().Quantity(1, "s")
        foo2 = pickle.loads(pickle.dumps(foo1))
        assert isinstance(foo1, foo2.__class__)
        assert isinstance(foo2, foo1.__class__)

    @helpers.requires_numpy
    def test_issue1174(self):
        q = [1.0, -2.0, 3.0, -4.0] * self.ureg.meter
        assert np.sign(q[0].magnitude)
        assert np.sign(q[1].magnitude)

    @helpers.requires_numpy()
    def test_issue_1185(self):
        # Test __pow__
        foo = ureg.Quantity((3, 3), "mm / cm")
        assert np.allclose(foo ** ureg.Quantity([2, 3], ""), 0.3 ** np.array([2, 3]))
        assert np.allclose(foo ** np.array([2, 3]), 0.3 ** np.array([2, 3]))
        assert np.allclose(np.array([2, 3]) ** foo, np.array([2, 3]) ** 0.3)
        # Test __ipow__
        foo **= np.array([2, 3])
        assert np.allclose(foo, 0.3 ** np.array([2, 3]))
        # Test __rpow__
        assert np.allclose(
            np.array((1, 1)).__rpow__(ureg.Quantity((2, 3), "mm / cm")),
            np.array((0.2, 0.3)),
        )
        assert np.allclose(
            ureg.Quantity((20, 20), "mm / cm").__rpow__(np.array((0.2, 0.3))),
            np.array((0.04, 0.09)),
        )

    @helpers.requires_uncertainties()
    def test_issue_1300(self):
        ureg = UnitRegistry()
        ureg.default_format = "~P"
        m = ureg.Measurement(1, 0.1, "meter")
        assert m.default_format == "~P"


if np is not None:

    @pytest.mark.parametrize(
        "callable",
        [
            lambda x: np.sin(x / x.units),  # Issue 399
            lambda x: np.cos(x / x.units),  # Issue 399
            np.isfinite,  # Issue 481
            np.shape,  # Issue 509
            np.size,  # Issue 509
            np.sqrt,  # Issue 622
            lambda x: x.mean(),  # Issue 678
            lambda x: x.copy(),  # Issue 678
            np.array,
            lambda x: x.conjugate,
        ],
    )
    @pytest.mark.parametrize(
        "q",
        [
            pytest.param(ureg.Quantity(1, "m"), id="python scalar int"),
            pytest.param(ureg.Quantity([1, 2, 3, 4], "m"), id="array int"),
            pytest.param(ureg.Quantity([1], "m")[0], id="numpy scalar int"),
            pytest.param(ureg.Quantity(1.0, "m"), id="python scalar float"),
            pytest.param(ureg.Quantity([1.0, 2.0, 3.0, 4.0], "m"), id="array float"),
            pytest.param(ureg.Quantity([1.0], "m")[0], id="numpy scalar float"),
        ],
    )
    def test_issue925(callable, q):
        # Test for immutability of type
        type_before = type(q._magnitude)
        callable(q)
        assert isinstance(q._magnitude, type_before)
