def test_large_heterogeneous_LiteralStrKeyDict_literal_values(self):
        """Check the literal values for a LiteralStrKeyDict requiring
        optimizations because it is heterogeneous.
        """

        def bar(d):
            ...

        @overload(bar)
        def ol_bar(d):
            a = {
                "A": 1,
                "B": 1,
                "C": 1,
                "D": 1,
                "E": 1,
                "F": 1,
                "G": 1,
                "H": 1,
                "I": 1,
                "J": 1,
                "K": 1,
                "L": 1,
                "M": 1,
                "N": 1,
                "O": 1,
                "P": 1,
                "Q": 1,
                "R": 1,
                "S": 'a',
            }

            def specific_ty(z):
                return types.literal(z) if types.maybe_literal(z) else typeof(z)
            expected = {types.literal(x): specific_ty(y) for x, y in a.items()}
            self.assertTrue(isinstance(d, types.LiteralStrKeyDict))
            self.assertEqual(d.literal_value, expected)
            self.assertEqual(hasattr(d, 'initial_value'), False)
            return lambda d: d

        @njit
        def foo():
            # D is a heterogeneous dictionary
            # so this code can only compile if
            # d has the correct literal values.
            d = {
                "A": 1,
                "B": 1,
                "C": 1,
                "D": 1,
                "E": 1,
                "F": 1,
                "G": 1,
                "H": 1,
                "I": 1,
                "J": 1,
                "K": 1,
                "L": 1,
                "M": 1,
                "N": 1,
                "O": 1,
                "P": 1,
                "Q": 1,
                "R": 1,
                "S": 'a',
            }
            bar(d)

        foo()
Check the literal values for a LiteralStrKeyDict requiring
        optimizations because it is heterogeneous.
        
numba/tests/test_interpreter.py