TST: Add typing tests for the newly (re-)annotated `ndarray`/`generic` methods

5 files changed, 168 insertions, 51 deletions

diff --git a/numpy/typing/tests/data/fail/ndarray_misc.py b/numpy/typing/tests/data/fail/ndarray_misc.py
index 1e1496bfe..653b9267b 100644
--- a/numpy/typing/tests/data/fail/ndarray_misc.py
+++ b/numpy/typing/tests/data/fail/ndarray_misc.py
@@ -6,9 +6,13 @@ function-based counterpart in `../from_numeric.py`.
 
 """
 
+from typing import Any
 import numpy as np
 
 f8: np.float64
+AR_f8: np.ndarray[Any, np.dtype[np.float64]]
+AR_M: np.ndarray[Any, np.dtype[np.datetime64]]
+AR_b: np.ndarray[Any, np.dtype[np.bool_]]
 
 f8.argpartition(0)  # E: has no attribute
 f8.diagonal()  # E: has no attribute
@@ -19,3 +23,8 @@ f8.put(0, 2)  # E: has no attribute
 f8.setfield(2, np.float64)  # E: has no attribute
 f8.sort()  # E: has no attribute
 f8.trace()  # E: has no attribute
+
+AR_M.__int__()  # E: Invalid self argument
+AR_M.__float__()  # E: Invalid self argument
+AR_M.__complex__()  # E: Invalid self argument
+AR_b.__index__()  # E: Invalid self argument
diff --git a/numpy/typing/tests/data/pass/ndarray_misc.py b/numpy/typing/tests/data/pass/ndarray_misc.py
index ba10ce974..62024603c 100644
--- a/numpy/typing/tests/data/pass/ndarray_misc.py
+++ b/numpy/typing/tests/data/pass/ndarray_misc.py
@@ -8,7 +8,9 @@ function-based counterpart in `../from_numeric.py`.
 
 from __future__ import annotations
 
+import operator
 from typing import cast, Any
+
 import numpy as np
 
 class SubClass(np.ndarray): ...
@@ -162,3 +164,22 @@ void.setfield(10, np.float64)
 
 A.item(0)
 C.item(0)
+
+A.ravel()
+C.ravel()
+
+A.flatten()
+C.flatten()
+
+A.reshape(1)
+C.reshape(3)
+
+int(np.array(1.0, dtype=np.float64))
+int(np.array("1", dtype=np.str_))
+
+float(np.array(1.0, dtype=np.float64))
+float(np.array("1", dtype=np.str_))
+
+complex(np.array(1.0, dtype=np.float64))
+
+operator.index(np.array(1, dtype=np.int64))
diff --git a/numpy/typing/tests/data/pass/scalars.py b/numpy/typing/tests/data/pass/scalars.py
index f7965e1c5..b258db49f 100644
--- a/numpy/typing/tests/data/pass/scalars.py
+++ b/numpy/typing/tests/data/pass/scalars.py
@@ -4,6 +4,14 @@ import datetime as dt
 import pytest
 import numpy as np
 
+b =  np.bool_()
+u8 = np.uint64()
+i8 = np.int64()
+f8 = np.float64()
+c16 = np.complex128()
+U = np.str_()
+S = np.bytes_()
+
 
 # Construction
 class D:
@@ -205,18 +213,42 @@ np.clongdouble()
 np.clongfloat()
 np.longcomplex()
 
-np.bool_().item()
-np.int_().item()
-np.uint64().item()
-np.float32().item()
-np.complex128().item()
-np.str_().item()
-np.bytes_().item()
-
-np.bool_().tolist()
-np.int_().tolist()
-np.uint64().tolist()
-np.float32().tolist()
-np.complex128().tolist()
-np.str_().tolist()
-np.bytes_().tolist()
+b.item()
+i8.item()
+u8.item()
+f8.item()
+c16.item()
+U.item()
+S.item()
+
+b.tolist()
+i8.tolist()
+u8.tolist()
+f8.tolist()
+c16.tolist()
+U.tolist()
+S.tolist()
+
+b.ravel()
+i8.ravel()
+u8.ravel()
+f8.ravel()
+c16.ravel()
+U.ravel()
+S.ravel()
+
+b.flatten()
+i8.flatten()
+u8.flatten()
+f8.flatten()
+c16.flatten()
+U.flatten()
+S.flatten()
+
+b.reshape(1)
+i8.reshape(1)
+u8.reshape(1)
+f8.reshape(1)
+c16.reshape(1)
+U.reshape(1)
+S.reshape(1)
diff --git a/numpy/typing/tests/data/reveal/ndarray_misc.py b/numpy/typing/tests/data/reveal/ndarray_misc.py
index 8c45eb6f3..ecc322251 100644
--- a/numpy/typing/tests/data/reveal/ndarray_misc.py
+++ b/numpy/typing/tests/data/reveal/ndarray_misc.py
@@ -6,14 +6,17 @@ function-based counterpart in `../from_numeric.py`.
 
 """
 
+import operator
 from typing import Any
+
 import numpy as np
 
 class SubClass(np.ndarray): ...
 
 f8: np.float64
-AR_f8: np.ndarray[Any, np.dtype[np.float64]]
 B: SubClass
+AR_f8: np.ndarray[Any, np.dtype[np.float64]]
+AR_i8: np.ndarray[Any, np.dtype[np.int64]]
 AR_U: np.ndarray[Any, np.dtype[np.str_]]
 
 reveal_type(f8.all())  # E: numpy.bool_
@@ -137,19 +140,40 @@ reveal_type(AR_f8.var(axis=0))  # E: Any
 reveal_type(AR_f8.var(keepdims=True))  # E: Any
 reveal_type(AR_f8.var(out=B))  # E: SubClass
 
-reveal_type(AR_f8.argpartition([0]))  # E: numpy.ndarray[Any, Any]
+reveal_type(AR_f8.argpartition([0]))  # E: numpy.ndarray[Any, numpy.dtype[{intp}]]
 
 reveal_type(AR_f8.diagonal())  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
 
-reveal_type(AR_f8.dot(1))  # E: Any
+reveal_type(AR_f8.dot(1))  # E: numpy.ndarray[Any, Any]
+reveal_type(AR_f8.dot([1]))  # E: Any
 reveal_type(AR_f8.dot(1, out=B))  # E: SubClass
 
-reveal_type(AR_f8.nonzero())  # E: tuple[numpy.ndarray[Any, Any]]
+reveal_type(AR_f8.nonzero())  # E: tuple[numpy.ndarray[Any, numpy.dtype[{intp}]]]
 
-reveal_type(AR_f8.searchsorted([1]))  # E: numpy.ndarray[Any, Any]
+reveal_type(AR_f8.searchsorted(1))  # E: {intp}
+reveal_type(AR_f8.searchsorted([1]))  # E: numpy.ndarray[Any, numpy.dtype[{intp}]]
 
 reveal_type(AR_f8.trace())  # E: Any
 reveal_type(AR_f8.trace(out=B))  # E: SubClass
 
 reveal_type(AR_f8.item())  # E: float
 reveal_type(AR_U.item())  # E: str
+
+reveal_type(AR_f8.ravel())  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(AR_U.ravel())  # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]]
+
+reveal_type(AR_f8.flatten())  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(AR_U.flatten())  # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]]
+
+reveal_type(AR_f8.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(AR_U.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]]
+
+reveal_type(int(AR_f8))  # E: int
+reveal_type(int(AR_U))  # E: int
+
+reveal_type(float(AR_f8))  # E: float
+reveal_type(float(AR_U))  # E: float
+
+reveal_type(complex(AR_f8))  # E: complex
+
+reveal_type(operator.index(AR_i8))  # E: int
diff --git a/numpy/typing/tests/data/reveal/scalars.py b/numpy/typing/tests/data/reveal/scalars.py
index f50c46c43..d98388422 100644
--- a/numpy/typing/tests/data/reveal/scalars.py
+++ b/numpy/typing/tests/data/reveal/scalars.py
@@ -1,28 +1,35 @@
 import numpy as np
 
-x = np.complex64(3 + 2j)
+b: np.bool_
+u8: np.uint64
+i8: np.int64
+f8: np.float64
+c8: np.complex64
+c16: np.complex128
+U: np.str_
+S: np.bytes_
 
-reveal_type(x.real)  # E: {float32}
-reveal_type(x.imag)  # E: {float32}
+reveal_type(c8.real)  # E: {float32}
+reveal_type(c8.imag)  # E: {float32}
 
-reveal_type(x.real.real)  # E: {float32}
-reveal_type(x.real.imag)  # E: {float32}
+reveal_type(c8.real.real)  # E: {float32}
+reveal_type(c8.real.imag)  # E: {float32}
 
-reveal_type(x.itemsize)  # E: int
-reveal_type(x.shape)  # E: Tuple[]
-reveal_type(x.strides)  # E: Tuple[]
+reveal_type(c8.itemsize)  # E: int
+reveal_type(c8.shape)  # E: Tuple[]
+reveal_type(c8.strides)  # E: Tuple[]
 
-reveal_type(x.ndim)  # E: Literal[0]
-reveal_type(x.size)  # E: Literal[1]
+reveal_type(c8.ndim)  # E: Literal[0]
+reveal_type(c8.size)  # E: Literal[1]
 
-reveal_type(x.squeeze())  # E: {complex64}
-reveal_type(x.byteswap())  # E: {complex64}
-reveal_type(x.transpose())  # E: {complex64}
+reveal_type(c8.squeeze())  # E: {complex64}
+reveal_type(c8.byteswap())  # E: {complex64}
+reveal_type(c8.transpose())  # E: {complex64}
 
-reveal_type(x.dtype)  # E: numpy.dtype[{complex64}]
+reveal_type(c8.dtype)  # E: numpy.dtype[{complex64}]
 
-reveal_type(np.complex64().real)  # E: {float32}
-reveal_type(np.complex128().imag)  # E: {float64}
+reveal_type(c8.real)  # E: {float32}
+reveal_type(c16.imag)  # E: {float64}
 
 reveal_type(np.unicode_('foo'))  # E: numpy.str_
 reveal_type(np.str0('foo'))  # E: numpy.str_
@@ -68,18 +75,42 @@ reveal_type(np.clongdouble())  # E: {clongdouble}
 reveal_type(np.clongfloat())  # E: {clongdouble}
 reveal_type(np.longcomplex())  # E: {clongdouble}
 
-reveal_type(np.bool_().item())  # E: bool
-reveal_type(np.int_().item())  # E: int
-reveal_type(np.uint64().item())  # E: int
-reveal_type(np.float32().item())  # E: float
-reveal_type(np.complex128().item())  # E: complex
-reveal_type(np.str_().item())  # E: str
-reveal_type(np.bytes_().item())  # E: bytes
-
-reveal_type(np.bool_().tolist())  # E: bool
-reveal_type(np.int_().tolist())  # E: int
-reveal_type(np.uint64().tolist())  # E: int
-reveal_type(np.float32().tolist())  # E: float
-reveal_type(np.complex128().tolist())  # E: complex
-reveal_type(np.str_().tolist())  # E: str
-reveal_type(np.bytes_().tolist())  # E: bytes
+reveal_type(b.item())  # E: bool
+reveal_type(i8.item())  # E: int
+reveal_type(u8.item())  # E: int
+reveal_type(f8.item())  # E: float
+reveal_type(c16.item())  # E: complex
+reveal_type(U.item())  # E: str
+reveal_type(S.item())  # E: bytes
+
+reveal_type(b.tolist())  # E: bool
+reveal_type(i8.tolist())  # E: int
+reveal_type(u8.tolist())  # E: int
+reveal_type(f8.tolist())  # E: float
+reveal_type(c16.tolist())  # E: complex
+reveal_type(U.tolist())  # E: str
+reveal_type(S.tolist())  # E: bytes
+
+reveal_type(b.ravel())  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]]
+reveal_type(i8.ravel())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
+reveal_type(u8.ravel())  # E: numpy.ndarray[Any, numpy.dtype[{uint64}]]
+reveal_type(f8.ravel())  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(c16.ravel())  # E: numpy.ndarray[Any, numpy.dtype[{complex128}]]
+reveal_type(U.ravel())  # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]]
+reveal_type(S.ravel())  # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]]
+
+reveal_type(b.flatten())  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]]
+reveal_type(i8.flatten())  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
+reveal_type(u8.flatten())  # E: numpy.ndarray[Any, numpy.dtype[{uint64}]]
+reveal_type(f8.flatten())  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(c16.flatten())  # E: numpy.ndarray[Any, numpy.dtype[{complex128}]]
+reveal_type(U.flatten())  # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]]
+reveal_type(S.flatten())  # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]]
+
+reveal_type(b.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bool_]]
+reveal_type(i8.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[{int64}]]
+reveal_type(u8.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[{uint64}]]
+reveal_type(f8.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[{float64}]]
+reveal_type(c16.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[{complex128}]]
+reveal_type(U.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.str_]]
+reveal_type(S.reshape(1))  # E: numpy.ndarray[Any, numpy.dtype[numpy.bytes_]]