diff --git a/src/test_typing_extensions.py b/src/test_typing_extensions.py
index b8f5d4b7..72713589 100644
--- a/src/test_typing_extensions.py
+++ b/src/test_typing_extensions.py
@@ -882,10 +882,12 @@ async def coro(self):
 
 class DeprecatedCoroTests(BaseTestCase):
     def test_asyncio_iscoroutinefunction(self):
-        self.assertFalse(asyncio.coroutines.iscoroutinefunction(func))
-        self.assertFalse(asyncio.coroutines.iscoroutinefunction(Cls.func))
-        self.assertTrue(asyncio.coroutines.iscoroutinefunction(coro))
-        self.assertTrue(asyncio.coroutines.iscoroutinefunction(Cls.coro))
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            self.assertFalse(asyncio.coroutines.iscoroutinefunction(func))
+            self.assertFalse(asyncio.coroutines.iscoroutinefunction(Cls.func))
+            self.assertTrue(asyncio.coroutines.iscoroutinefunction(coro))
+            self.assertTrue(asyncio.coroutines.iscoroutinefunction(Cls.coro))
 
     @skipUnless(TYPING_3_12_ONLY or TYPING_3_13_0_RC, "inspect.iscoroutinefunction works differently on Python < 3.12")
     def test_inspect_iscoroutinefunction(self):
@@ -7209,7 +7211,7 @@ def test_cannot_instantiate_vars(self):
 
     def test_bound_errors(self):
         with self.assertRaises(TypeError):
-            TypeVar('X', bound=Union)
+            TypeVar('X', bound=Optional)
         with self.assertRaises(TypeError):
             TypeVar('X', str, float, bound=Employee)
         with self.assertRaisesRegex(TypeError,
@@ -8194,19 +8196,26 @@ def f2(a: "undefined"):  # noqa: F821
             get_annotations(f2, format=Format.FORWARDREF),
             {"a": "undefined"},
         )
-        self.assertEqual(get_annotations(f2, format=2), {"a": "undefined"})
+        # Test that the raw int also works
+        self.assertEqual(
+            get_annotations(f2, format=Format.FORWARDREF.value),
+            {"a": "undefined"},
+        )
 
         self.assertEqual(
             get_annotations(f1, format=Format.STRING),
             {"a": "int"},
         )
-        self.assertEqual(get_annotations(f1, format=3), {"a": "int"})
+        self.assertEqual(
+            get_annotations(f1, format=Format.STRING.value),
+            {"a": "int"},
+        )
 
         with self.assertRaises(ValueError):
             get_annotations(f1, format=0)
 
         with self.assertRaises(ValueError):
-            get_annotations(f1, format=4)
+            get_annotations(f1, format=42)
 
     def test_custom_object_with_annotations(self):
         class C:
@@ -8245,10 +8254,17 @@ def foo(a: int, b: str):
         foo.__annotations__ = {"a": "foo", "b": "str"}
         for format in Format:
             with self.subTest(format=format):
-                self.assertEqual(
-                    get_annotations(foo, format=format),
-                    {"a": "foo", "b": "str"},
-                )
+                if format is Format.VALUE_WITH_FAKE_GLOBALS:
+                    with self.assertRaisesRegex(
+                        ValueError,
+                        "The VALUE_WITH_FAKE_GLOBALS format is for internal use only"
+                    ):
+                        get_annotations(foo, format=format)
+                else:
+                    self.assertEqual(
+                        get_annotations(foo, format=format),
+                        {"a": "foo", "b": "str"},
+                    )
 
         self.assertEqual(
             get_annotations(foo, eval_str=True, locals=locals()),
diff --git a/src/typing_extensions.py b/src/typing_extensions.py
index c6c3b88e..ff74ac5d 100644
--- a/src/typing_extensions.py
+++ b/src/typing_extensions.py
@@ -4152,8 +4152,9 @@ def __eq__(self, other: object) -> bool:
 
 class Format(enum.IntEnum):
     VALUE = 1
-    FORWARDREF = 2
-    STRING = 3
+    VALUE_WITH_FAKE_GLOBALS = 2
+    FORWARDREF = 3
+    STRING = 4
 
 
 if _PEP_649_OR_749_IMPLEMENTED:
@@ -4197,6 +4198,10 @@ def get_annotations(obj, *, globals=None, locals=None, eval_str=False,
 
         """
         format = Format(format)
+        if format is Format.VALUE_WITH_FAKE_GLOBALS:
+            raise ValueError(
+                "The VALUE_WITH_FAKE_GLOBALS format is for internal use only"
+            )
 
         if eval_str and format is not Format.VALUE:
             raise ValueError("eval_str=True is only supported with format=Format.VALUE")