I think I did this mainly so that the 3rd positional argument would be 'precision' instead of 'strict' -- that makes it consistent with assert_array_almost_equal, and the alternative is a potential pitfall
 -- e.g. ```assert_array_almost_equal(a, b, 2)``` is a test to 2dp, but ```self.assertMaskedArrayAlmostEqual(a, b, 2)``` would perform a *strict* test to 6 dp.

An alternative would be to support 'strict' as a named keyword **only**.  That has to work via kwargs though, so the documentation is not quite so neat to read.  Something like --
```
    def assertMaskedArrayAlmostEqual(self, a, b, **kwargs):
        """
        Check that masked arrays are almost equal. This requires the
        masks to be identical, and the unmasked values to be almost
        equal.

        Args:

        * a, b (array-like):
            Two arrays to compare.

        Kwargs:

        * strict (bool):
            If True, perform a complete mask and data array equality check.
            If False (default), the data array equality considers only unmasked
            elements.

        * (other)
            Other keywords are passed to :meth:`numpy.testing.assert_array_almost_equal`.

        """
        strict = kwargs.pop('strict', False)
```

It's also probably true that it comes from following the existing ```assertArrayAlmostEqual```.
If you think this needs fixing, we could also apply that to assertArrayAlmostEqual and assertArrayAllClose.
But then
If you think this is really preferable, we could do this with the other too.