# ----------------------------------------------------------------------------
# -                        Open3D: www.open3d.org                            -
# ----------------------------------------------------------------------------
# Copyright (c) 2018-2024 www.open3d.org
# SPDX-License-Identifier: MIT
# ----------------------------------------------------------------------------

import open3d as o3d
import open3d.core as o3c
import numpy as np
import pytest
import tempfile
import pickle

import sys
import os
sys.path.append(os.path.dirname(os.path.realpath(__file__)) + "/..")
from open3d_test import list_devices


def list_dtypes():
    return [
        o3c.float32,
        o3c.float64,
        o3c.int8,
        o3c.int16,
        o3c.int32,
        o3c.int64,
        o3c.uint8,
        o3c.uint16,
        o3c.uint32,
        o3c.uint64,
        o3c.bool,
    ]


def list_non_bool_dtypes():
    return [
        o3c.float32,
        o3c.float64,
        o3c.int8,
        o3c.int16,
        o3c.int32,
        o3c.int64,
        o3c.uint8,
        o3c.uint16,
        o3c.uint32,
        o3c.uint64,
    ]


def to_numpy_dtype(dtype: o3c.Dtype):
    conversions = {
        o3c.float32: np.float32,
        o3c.float64: np.float64,
        o3c.int8: np.int8,
        o3c.int16: np.int16,
        o3c.int32: np.int32,
        o3c.int64: np.int64,
        o3c.uint8: np.uint8,
        o3c.uint16: np.uint16,
        o3c.uint32: np.uint32,
        o3c.uint64: np.uint64,
        o3c.bool8: np.bool_,
        o3c.bool: np.bool_,  # o3c.bool is an alias for o3c.bool8
    }
    return conversions[dtype]


@pytest.mark.parametrize("dtype", list_dtypes())
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_creation(dtype, device):
    # Shape takes tuple, list or o3c.SizeVector
    t = o3c.Tensor.empty((2, 3), dtype, device=device)
    assert t.shape == o3c.SizeVector([2, 3])
    t = o3c.Tensor.empty([2, 3], dtype, device=device)
    assert t.shape == o3c.SizeVector([2, 3])
    t = o3c.Tensor.empty(o3c.SizeVector([2, 3]), dtype, device=device)
    assert t.shape == o3c.SizeVector([2, 3])

    # Test zeros and ones
    t = o3c.Tensor.zeros((2, 3), dtype, device=device)
    np.testing.assert_equal(t.cpu().numpy(), np.zeros((2, 3), dtype=np.float32))
    t = o3c.Tensor.ones((2, 3), dtype, device=device)
    np.testing.assert_equal(t.cpu().numpy(), np.ones((2, 3), dtype=np.float32))

    # Automatic casting of dtype.
    t = o3c.Tensor.full((2,), False, o3c.float32, device=device)
    np.testing.assert_equal(t.cpu().numpy(),
                            np.full((2,), False, dtype=np.float32))
    t = o3c.Tensor.full((2,), 3.5, o3c.uint8, device=device)
    np.testing.assert_equal(t.cpu().numpy(), np.full((2,), 3.5, dtype=np.uint8))


@pytest.mark.parametrize("shape", [(), (0,), (1,), (0, 2), (0, 0, 2),
                                   (2, 0, 3)])
@pytest.mark.parametrize("dtype", list_dtypes())
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_creation_special_shapes(shape, dtype, device):
    o3_t = o3c.Tensor.full(shape, 3.14, dtype, device=device)
    np_t = np.full(shape, 3.14, dtype=to_numpy_dtype(dtype))
    np.testing.assert_allclose(o3_t.cpu().numpy(), np_t)


def test_dtype():
    dtype = o3c.int32
    assert dtype.byte_size() == 4
    assert "{}".format(dtype) == "Int32"


def test_device():
    device = o3c.Device()
    assert device.get_type() == o3c.Device.DeviceType.CPU
    assert device.get_id() == 0

    device = o3c.Device("CUDA", 1)
    assert device.get_type() == o3c.Device.DeviceType.CUDA
    assert device.get_id() == 1

    device = o3c.Device("CUDA:2")
    assert device.get_type() == o3c.Device.DeviceType.CUDA
    assert device.get_id() == 2

    assert o3c.Device("CUDA", 1) == o3c.Device("CUDA:1")
    assert o3c.Device("CUDA", 1) != o3c.Device("CUDA:0")

    assert o3c.Device("CUDA", 1).__str__() == "CUDA:1"


@pytest.mark.parametrize("dtype", list_dtypes())
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_tensor_constructor(dtype, device):
    # Numpy array
    np_t = np.array([[0, 1, 2], [3, 4, 5]], dtype=to_numpy_dtype(dtype))
    o3_t = o3c.Tensor(np_t, device=device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # 2D list
    li_t = [[0, 1, 2], [3, 4, 5]]
    np_t = np.array(li_t, dtype=to_numpy_dtype(dtype))
    o3_t = o3c.Tensor(li_t, dtype, device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # 2D list, inconsistent length
    li_t = [[0, 1, 2], [3, 4]]
    with pytest.raises(Exception):
        # Suppress inconsistent length warning as this check is intentional
        import warnings
        with warnings.catch_warnings():
            warnings.filterwarnings("ignore",
                                    category=np.VisibleDeprecationWarning)
            o3_t = o3c.Tensor(li_t, dtype, device)

    # Automatic casting
    np_t_double = np.array([[0., 1.5, 2.], [3., 4., 5.]])
    np_t_int = np.array([[0, 1, 2], [3, 4, 5]])
    o3_t = o3c.Tensor(np_t_double, o3c.int32, device)
    np.testing.assert_equal(np_t_int, o3_t.cpu().numpy())

    # Special strides
    np_t = np.random.randint(10, size=(10, 10))[1:10:2, 1:10:3].T
    o3_t = o3c.Tensor(np_t, o3c.int32, device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Boolean
    np_t = np.array([True, False, True], dtype=np.bool_)
    o3_t = o3c.Tensor([True, False, True], o3c.bool, device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())
    o3_t = o3c.Tensor(np_t, o3c.bool, device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Scalar Boolean
    np_t = np.array(True)
    o3_t = o3c.Tensor(True, dtype=None, device=device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())
    o3_t = o3c.Tensor(True, dtype=o3c.bool, device=device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_arange(device):
    # Full parameters.
    setups = [(0, 10, 1), (0, 10, 1), (0.0, 10.0, 2.0), (0.0, -10.0, -2.0)]
    for start, stop, step in setups:
        np_t = np.arange(start, stop, step)
        o3_t = o3c.Tensor.arange(start, stop, step, dtype=None, device=device)
        np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Only stop.
    for stop in [1.0, 2.0, 3.0, 1, 2, 3]:
        np_t = np.arange(stop)
        o3_t = o3c.Tensor.arange(stop, dtype=None, device=device)
        np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Only start, stop (step = 1).
    setups = [(0, 10), (0, 10), (0.0, 10.0), (0.0, -10.0)]
    for start, stop in setups:
        np_t = np.arange(start, stop)
        # Not full parameter list, need to specify device by kw.
        o3_t = o3c.Tensor.arange(start, stop, dtype=None, device=device)
        np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Type inference: int -> int.
    o3_t = o3c.Tensor.arange(0, 5, dtype=None, device=device)
    np_t = np.arange(0, 5)
    assert o3_t.dtype == o3c.int64
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Type inference: int, float -> float.
    o3_t = o3c.Tensor.arange(0, 5.0, dtype=None, device=device)
    np_t = np.arange(0, 5)
    assert o3_t.dtype == o3c.float64
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Type inference: float, float -> float.
    o3_t = o3c.Tensor.arange(0.0, 5.0, dtype=None, device=device)
    np_t = np.arange(0, 5)
    assert o3_t.dtype == o3c.float64
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    # Type inference: explicit type.
    o3_t = o3c.Tensor.arange(0.0, 5.0, dtype=o3c.int64, device=device)
    np_t = np.arange(0, 5)
    assert o3_t.dtype == o3c.int64
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_flatten(device):

    # Flatten 0-D tensor
    src_t = o3c.Tensor(3, dtype=o3c.Dtype.Int64).to(device)
    dst_t = o3c.Tensor([3], dtype=o3c.Dtype.Int64).to(device)
    assert dst_t.allclose(src_t.flatten())
    assert dst_t.allclose(src_t.flatten(0))
    assert dst_t.allclose(src_t.flatten(-1))

    assert dst_t.allclose(src_t.flatten(0, 0))
    assert dst_t.allclose(src_t.flatten(0, -1))
    assert dst_t.allclose(src_t.flatten(-1, 0))
    assert dst_t.allclose(src_t.flatten(-1, -1))

    with pytest.raises(RuntimeError):
        src_t.flatten(-2)
    with pytest.raises(RuntimeError):
        src_t.flatten(1)
    with pytest.raises(RuntimeError):
        src_t.flatten(0, -2)
    with pytest.raises(RuntimeError):
        src_t.flatten(0, 1)

    # Flatten 1-D tensor
    src_t = o3c.Tensor([1, 2, 3], dtype=o3c.Dtype.Int64).to(device)
    dst_t = o3c.Tensor([1, 2, 3], dtype=o3c.Dtype.Int64).to(device)

    assert dst_t.allclose(src_t.flatten())
    assert dst_t.allclose(src_t.flatten(0))
    assert dst_t.allclose(src_t.flatten(-1))

    assert dst_t.allclose(src_t.flatten(0, 0))
    assert dst_t.allclose(src_t.flatten(0, -1))
    assert dst_t.allclose(src_t.flatten(-1, 0))
    assert dst_t.allclose(src_t.flatten(-1, -1))

    with pytest.raises(RuntimeError):
        src_t.flatten(-2)
    with pytest.raises(RuntimeError):
        src_t.flatten(1)
    with pytest.raises(RuntimeError):
        src_t.flatten(0, -2)
    with pytest.raises(RuntimeError):
        src_t.flatten(0, 1)

    # Flatten 2-D tensor
    src_t = o3c.Tensor([[1, 2, 3], [4, 5, 6]], dtype=o3c.Dtype.Int64).to(device)
    dst_t_flat = o3c.Tensor([1, 2, 3, 4, 5, 6],
                            dtype=o3c.Dtype.Int64).to(device)
    dst_t_unchanged = o3c.Tensor([[1, 2, 3], [4, 5, 6]],
                                 dtype=o3c.Dtype.Int64).to(device)

    assert dst_t_flat.allclose(src_t.flatten())
    assert dst_t_flat.allclose(src_t.flatten(0))
    assert dst_t_flat.allclose(src_t.flatten(-2))

    assert dst_t_flat.allclose(src_t.flatten(0, 1))
    assert dst_t_flat.allclose(src_t.flatten(-2, 1))
    assert dst_t_flat.allclose(src_t.flatten(0, -1))
    assert dst_t_flat.allclose(src_t.flatten(-2, -1))

    assert dst_t_unchanged.allclose(src_t.flatten(1))
    assert dst_t_unchanged.allclose(src_t.flatten(-1))

    for dim in range(-2, 2):
        assert dst_t_unchanged.allclose(src_t.flatten(dim, dim))

    # Out of bounds dimensions
    with pytest.raises(RuntimeError):
        src_t.flatten(0, 2)
    with pytest.raises(RuntimeError):
        src_t.flatten(0, -3)
    with pytest.raises(RuntimeError):
        src_t.flatten(-3, 0)
    with pytest.raises(RuntimeError):
        src_t.flatten(2, 0)

    # end_dim is greater than start_dim
    with pytest.raises(RuntimeError):
        src_t.flatten(1, 0)
    with pytest.raises(RuntimeError):
        src_t.flatten(-1, 0)
    with pytest.raises(RuntimeError):
        src_t.flatten(1, -2)
    with pytest.raises(RuntimeError):
        src_t.flatten(-1, -2)

    # Flatten 3-D tensor
    src_t = o3c.Tensor([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]],
                       dtype=o3c.Dtype.Int64).to(device)
    dst_t_flat = o3c.Tensor([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],
                            dtype=o3c.Dtype.Int64).to(device)
    dst_t_unchanged = o3c.Tensor(
        [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]],
        dtype=o3c.Dtype.Int64).to(device)
    dst_t_first_two_flat = o3c.Tensor(
        [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]],
        dtype=o3c.Dtype.Int64).to(device)
    dst_t_last_two_flat = o3c.Tensor(
        [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]],
        dtype=o3c.Dtype.Int64).to(device)

    assert dst_t_flat.allclose(src_t.flatten())
    assert dst_t_flat.allclose(src_t.flatten(0))
    assert dst_t_flat.allclose(src_t.flatten(-3))

    assert dst_t_flat.allclose(src_t.flatten(0, 2))
    assert dst_t_flat.allclose(src_t.flatten(-3, 2))
    assert dst_t_flat.allclose(src_t.flatten(0, -1))
    assert dst_t_flat.allclose(src_t.flatten(-3, -1))

    assert dst_t_first_two_flat.allclose(src_t.flatten(0, 1))
    assert dst_t_first_two_flat.allclose(src_t.flatten(0, -2))
    assert dst_t_first_two_flat.allclose(src_t.flatten(-3, 1))
    assert dst_t_first_two_flat.allclose(src_t.flatten(-3, -2))

    assert dst_t_last_two_flat.allclose(src_t.flatten(1, 2))
    assert dst_t_last_two_flat.allclose(src_t.flatten(1, -1))
    assert dst_t_last_two_flat.allclose(src_t.flatten(-2, 2))
    assert dst_t_last_two_flat.allclose(src_t.flatten(-2, -1))

    for dim in range(-3, 3):
        assert dst_t_unchanged.allclose(src_t.flatten(dim, dim))

    # Out of bounds dimensions
    with pytest.raises(RuntimeError):
        src_t.flatten(0, 3)
    with pytest.raises(RuntimeError):
        src_t.flatten(0, -4)
    with pytest.raises(RuntimeError):
        src_t.flatten(-4, 0)
    with pytest.raises(RuntimeError):
        src_t.flatten(3, 0)

    # end_dim is greater than start_dim
    with pytest.raises(RuntimeError):
        src_t.flatten(1, 0)
    with pytest.raises(RuntimeError):
        src_t.flatten(2, 0)
    with pytest.raises(RuntimeError):
        src_t.flatten(2, 0)


@pytest.mark.parametrize("dtype", list_non_bool_dtypes())
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_append(dtype, device):
    # Appending 0-D.
    # 0-D can only be appended along axis = null.
    self = o3c.Tensor(0, dtype=dtype, device=device)
    values = o3c.Tensor(1, dtype=dtype, device=device)
    output_t = self.append(values)
    output_np = np.append(arr=self.cpu().numpy(), values=values.cpu().numpy())

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    with pytest.raises(
            RuntimeError,
            match=r"Zero-dimensional tensor can only be concatenated along "
            "axis = null, but got 0."):
        self.append(values, axis=0)

    # Appending 1-D.
    # 1-D can be appended along axis = 0, -1.
    self = o3c.Tensor([0, 1], dtype=dtype, device=device)
    values = o3c.Tensor([2, 3, 4], dtype=dtype, device=device)
    output_t = self.append(values)
    output_np = np.append(arr=self.cpu().numpy(), values=values.cpu().numpy())

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=0)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=0)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=-1)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=-1)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    # axis must always be in range [-num_dims, num_dims).
    # So, 1-D tensor cannot be appended along axis 1 or -2.
    with pytest.raises(
            RuntimeError,
            match=
            r"Index out-of-range: dim == 1, but it must satisfy -1 <= dim <= 0"
    ):
        self.append(values, axis=1)

    with pytest.raises(
            RuntimeError,
            match=
            r"Index out-of-range: dim == -2, but it must satisfy -1 <= dim <= 0"
    ):
        self.append(values, axis=-2)

    # Appending 2-D. [2, 2] to [2, 2].
    # [2, 2] to [2, 2] can be appended along axis = 0, 1, -1, -2.
    self = o3c.Tensor([[0, 1], [2, 3]], dtype=dtype, device=device)
    values = o3c.Tensor([[4, 5], [6, 7]], dtype=dtype, device=device)

    output_t = self.append(values)
    output_np = np.append(arr=self.cpu().numpy(), values=values.cpu().numpy())

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=0)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=0)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=1)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=1)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=-1)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=-1)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=-2)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=-2)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    # axis must always be in range [-num_dims, num_dims).
    # So, 2-D tensor cannot be appended along axis 2 or -3.
    with pytest.raises(
            RuntimeError,
            match=
            r"Index out-of-range: dim == 2, but it must satisfy -2 <= dim <= 1"
    ):
        self.append(values, axis=2)

    with pytest.raises(
            RuntimeError,
            match=
            r"Index out-of-range: dim == -3, but it must satisfy -2 <= dim <= 1"
    ):
        self.append(values, axis=-3)

    # Appending 2-D. [1, 2] to [2, 2].
    # [1, 2] to [2, 2] can be appended along axis = 0, -2.
    self = o3c.Tensor([[0, 1], [2, 3]], dtype=dtype, device=device)
    values = o3c.Tensor([[4, 5]], dtype=dtype, device=device)

    output_t = self.append(values)
    output_np = np.append(arr=self.cpu().numpy(), values=values.cpu().numpy())

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=0)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=0)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    output_t = self.append(values, axis=-2)
    output_np = np.append(arr=self.cpu().numpy(),
                          values=values.cpu().numpy(),
                          axis=-2)

    np.testing.assert_equal(output_np, output_t.cpu().numpy())

    # all the dimensions other than the dimension along the axis, must be
    # exactly same.
    with pytest.raises(
            RuntimeError,
            match=
            r"All the input tensor dimensions, other than dimension size along "
            "concatenation axis must be same, but along dimension 0, the "
            "tensor at index 0 has size 2 and the tensor at index 1 has size 1."
    ):
        self.append(values, axis=1)

    with pytest.raises(
            RuntimeError,
            match=
            r"All the input tensor dimensions, other than dimension size along "
            "concatenation axis must be same, but along dimension 0, the "
            "tensor at index 0 has size 2 and the tensor at index 1 has size 1."
    ):
        self.append(values, axis=-1)

    # dtype and device must be same for all the input tensors.
    self = o3c.Tensor([[0, 1], [2, 3]], dtype=o3c.Dtype.Float32, device=device)
    values = o3c.Tensor([[4, 5]], dtype=o3c.Dtype.Float64, device=device)
    with pytest.raises(
            RuntimeError,
            match=r"Tensor has dtype Float64, but is expected to have Float32"):
        self.append(values)


def test_tensor_from_to_numpy():
    # a->b copy; b, c share memory
    a = np.ones((2, 2))
    b = o3c.Tensor(a)
    c = b.numpy()

    c[0, 1] = 200
    r = np.array([[1., 200.], [1., 1.]])
    np.testing.assert_equal(r, b.numpy())
    np.testing.assert_equal(r, c)

    # a, b, c share memory
    a = np.array([[1., 1.], [1., 1.]])
    b = o3c.Tensor.from_numpy(a)
    c = b.numpy()

    a[0, 0] = 100
    c[0, 1] = 200
    r = np.array([[100., 200.], [1., 1.]])
    np.testing.assert_equal(r, a)
    np.testing.assert_equal(r, b.numpy())
    np.testing.assert_equal(r, c)

    # Special strides
    ran_t = np.random.randint(10, size=(10, 10)).astype(np.int32)
    src_t = ran_t[1:10:2, 1:10:3].T
    o3d_t = o3c.Tensor.from_numpy(src_t)  # Shared memory
    dst_t = o3d_t.numpy()
    np.testing.assert_equal(dst_t, src_t)

    dst_t[0, 0] = 100
    np.testing.assert_equal(dst_t, src_t)
    np.testing.assert_equal(dst_t, o3d_t.numpy())

    src_t[0, 1] = 200
    np.testing.assert_equal(dst_t, src_t)
    np.testing.assert_equal(dst_t, o3d_t.numpy())


def test_tensor_to_numpy_scope():
    src_t = np.array([[10., 11., 12.], [13., 14., 15.]])

    def get_dst_t():
        o3d_t = o3c.Tensor(src_t)  # Copy
        dst_t = o3d_t.numpy()
        return dst_t

    dst_t = get_dst_t()
    np.testing.assert_equal(dst_t, src_t)


@pytest.mark.parametrize("dtype", list_non_bool_dtypes())
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_binary_ew_ops(dtype, device):
    a = o3c.Tensor(np.array([4, 6, 8, 10, 12, 14]), dtype=dtype, device=device)
    b = o3c.Tensor(np.array([2, 3, 4, 5, 6, 7]), dtype=dtype, device=device)
    np.testing.assert_equal((a + b).cpu().numpy(),
                            np.array([6, 9, 12, 15, 18, 21]))
    np.testing.assert_equal((a - b).cpu().numpy(), np.array([2, 3, 4, 5, 6, 7]))
    np.testing.assert_equal((a * b).cpu().numpy(),
                            np.array([8, 18, 32, 50, 72, 98]))
    np.testing.assert_equal((a / b).cpu().numpy(), np.array([2, 2, 2, 2, 2, 2]))

    a = o3c.Tensor(np.array([4, 6, 8, 10, 12, 14]), dtype=dtype, device=device)
    a += b
    np.testing.assert_equal(a.cpu().numpy(), np.array([6, 9, 12, 15, 18, 21]))

    a = o3c.Tensor(np.array([4, 6, 8, 10, 12, 14]), dtype=dtype, device=device)
    a -= b
    np.testing.assert_equal(a.cpu().numpy(), np.array([2, 3, 4, 5, 6, 7]))

    a = o3c.Tensor(np.array([4, 6, 8, 10, 12, 14]), dtype=dtype, device=device)
    a *= b
    np.testing.assert_equal(a.cpu().numpy(), np.array([8, 18, 32, 50, 72, 98]))

    a = o3c.Tensor(np.array([4, 6, 8, 10, 12, 14]), dtype=dtype, device=device)
    a //= b
    np.testing.assert_equal(a.cpu().numpy(), np.array([2, 2, 2, 2, 2, 2]))


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_to(device):
    a = o3c.Tensor(np.array([0.1, 1.2, 2.3, 3.4, 4.5, 5.6]).astype(np.float32),
                   device=device)
    b = a.to(o3c.int32)
    np.testing.assert_equal(b.cpu().numpy(), np.array([0, 1, 2, 3, 4, 5]))
    assert b.shape == o3c.SizeVector([6])
    assert b.strides == o3c.SizeVector([1])
    assert b.dtype == o3c.int32
    assert b.device == a.device


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_unary_ew_ops(device):
    src_vals = np.array([0, 1, 2, 3, 4, 5]).astype(np.float32)
    src = o3c.Tensor(src_vals, device=device)

    rtol = 1e-5
    atol = 0
    np.testing.assert_allclose(src.sqrt().cpu().numpy(),
                               np.sqrt(src_vals),
                               rtol=rtol,
                               atol=atol)
    np.testing.assert_allclose(src.sin().cpu().numpy(),
                               np.sin(src_vals),
                               rtol=rtol,
                               atol=atol)
    np.testing.assert_allclose(src.cos().cpu().numpy(),
                               np.cos(src_vals),
                               rtol=rtol,
                               atol=atol)
    np.testing.assert_allclose(src.neg().cpu().numpy(),
                               -src_vals,
                               rtol=rtol,
                               atol=atol)
    np.testing.assert_allclose((-src).cpu().numpy(),
                               -src_vals,
                               rtol=rtol,
                               atol=atol)
    np.testing.assert_allclose(src.exp().cpu().numpy(),
                               np.exp(src_vals),
                               rtol=rtol,
                               atol=atol)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_getitem(device):
    np_t = np.array(range(24)).reshape((2, 3, 4))
    o3_t = o3c.Tensor(np_t, device=device)

    np.testing.assert_equal(o3_t[:].cpu().numpy(), np_t[:])
    np.testing.assert_equal(o3_t[0].cpu().numpy(), np_t[0])
    np.testing.assert_equal(o3_t[0, 1].cpu().numpy(), np_t[0, 1])
    np.testing.assert_equal(o3_t[0, :].cpu().numpy(), np_t[0, :])
    np.testing.assert_equal(o3_t[0, 1:3].cpu().numpy(), np_t[0, 1:3])
    np.testing.assert_equal(o3_t[0, :, :-2].cpu().numpy(), np_t[0, :, :-2])
    np.testing.assert_equal(o3_t[0, 1:3, 2].cpu().numpy(), np_t[0, 1:3, 2])
    np.testing.assert_equal(o3_t[0, 1:-1, 2].cpu().numpy(), np_t[0, 1:-1, 2])
    np.testing.assert_equal(o3_t[0, 1:3, 0:4:2].cpu().numpy(), np_t[0, 1:3,
                                                                    0:4:2])
    np.testing.assert_equal(o3_t[0, 1:3, 0:-1:2].cpu().numpy(), np_t[0, 1:3,
                                                                     0:-1:2])
    np.testing.assert_equal(o3_t[0, 1, :].cpu().numpy(), np_t[0, 1, :])

    # Slice out-of-range
    np.testing.assert_equal(o3_t[1:6].cpu().numpy(), np_t[1:6])
    np.testing.assert_equal(o3_t[2:5, -10:20].cpu().numpy(), np_t[2:5, -10:20])
    np.testing.assert_equal(o3_t[2:2, 3:3, 4:4].cpu().numpy(), np_t[2:2, 3:3,
                                                                    4:4])
    np.testing.assert_equal(o3_t[2:20, 3:30, 4:40].cpu().numpy(),
                            np_t[2:20, 3:30, 4:40])
    np.testing.assert_equal(o3_t[-2:20, -3:30, -4:40].cpu().numpy(),
                            np_t[-2:20, -3:30, -4:40])

    # Slice the slice
    np.testing.assert_equal(o3_t[0:2, 1:3, 0:4][0:1, 0:2, 2:3].cpu().numpy(),
                            np_t[0:2, 1:3, 0:4][0:1, 0:2, 2:3])

    # Slice a zero-dim tensor
    with pytest.raises(RuntimeError,
                       match=r"Cannot slice a scalar \(0-dim\) tensor."):
        o3c.Tensor.ones((), device=device)[:]
    with pytest.raises(RuntimeError,
                       match=r"Cannot slice a scalar \(0-dim\) tensor."):
        o3c.Tensor.ones((), device=device)[0:1]


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_setitem(device):
    np_ref = np.array(range(24)).reshape((2, 3, 4))

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[:].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[:] = np_fill_t
    o3_t[:] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0] = np_fill_t
    o3_t[0] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, 1].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, 1] = np_fill_t
    o3_t[0, 1] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, :].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, :] = np_fill_t
    o3_t[0, :] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, 1:3].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, 1:3] = np_fill_t
    o3_t[0, 1:3] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, :, :-2].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, :, :-2] = np_fill_t
    o3_t[0, :, :-2] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, 1:3, 2].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, 1:3, 2] = np_fill_t
    o3_t[0, 1:3, 2] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, 1:-1, 2].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, 1:-1, 2] = np_fill_t
    o3_t[0, 1:-1, 2] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, 1:3, 0:4:2].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, 1:3, 0:4:2] = np_fill_t
    o3_t[0, 1:3, 0:4:2] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, 1:3, 0:-1:2].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, 1:3, 0:-1:2] = np_fill_t
    o3_t[0, 1:3, 0:-1:2] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0, 1, :].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0, 1, :] = np_fill_t
    o3_t[0, 1, :] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    np_t = np_ref.copy()
    o3_t = o3c.Tensor(np_t, device=device)
    np_fill_t = np.random.rand(*np_t[0:2, 1:3, 0:4][0:1, 0:2, 2:3].shape)
    o3_fill_t = o3c.Tensor(np_fill_t, device=device)
    np_t[0:2, 1:3, 0:4][0:1, 0:2, 2:3] = np_fill_t
    o3_t[0:2, 1:3, 0:4][0:1, 0:2, 2:3] = o3_fill_t
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    # Scalar boolean set item
    np_t = np.eye(4, dtype=np.bool_)
    o3_t = o3c.Tensor.eye(4, dtype=o3c.bool)
    np_t[2, 2] = False
    o3_t[2, 2] = False
    np.testing.assert_equal(o3_t.cpu().numpy(), np_t)

    # Slice a zero-dim tensor
    # match=".*Cannot slice a scalar (0-dim) tensor.*"
    with pytest.raises(RuntimeError,
                       match=r"Cannot slice a scalar \(0-dim\) tensor."):
        o3c.Tensor.ones((), device=device)[:] = 0
    with pytest.raises(RuntimeError,
                       match=r"Cannot slice a scalar \(0-dim\) tensor."):
        o3c.Tensor.ones((), device=device)[0:1] = 0


@pytest.mark.parametrize(
    "dim",
    [0, 1, 2, (), (0,), (1,), (2,), (0, 1), (0, 2), (1, 2), (0, 1, 2), None])
@pytest.mark.parametrize("keepdim", [True, False])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_reduction_sum(dim, keepdim, device):
    np_src = np.array(range(24)).reshape((2, 3, 4))
    o3_src = o3c.Tensor(np_src, device=device)

    np_dst = np_src.sum(axis=dim, keepdims=keepdim)
    o3_dst = o3_src.sum(dim=dim, keepdim=keepdim)
    np.testing.assert_allclose(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize("shape_and_axis", [
    ((), ()),
    ((0,), ()),
    ((0,), (0)),
    ((0, 2), ()),
    ((0, 2), (0)),
    ((0, 2), (1)),
])
@pytest.mark.parametrize("keepdim", [True, False])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_reduction_special_shapes(shape_and_axis, keepdim, device):
    shape, axis = shape_and_axis
    np_src = np.array(np.random.rand(*shape))
    o3_src = o3c.Tensor(np_src, device=device)
    np.testing.assert_equal(o3_src.cpu().numpy(), np_src)

    np_dst = np_src.sum(axis=axis, keepdims=keepdim)
    o3_dst = o3_src.sum(dim=axis, keepdim=keepdim)
    np.testing.assert_equal(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize(
    "dim",
    [0, 1, 2, (), (0,), (1,), (2,), (0, 1), (0, 2), (1, 2), (0, 1, 2), None])
@pytest.mark.parametrize("keepdim", [True, False])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_reduction_mean(dim, keepdim, device):
    np_src = np.array(range(24)).reshape((2, 3, 4)).astype(np.float32)
    o3_src = o3c.Tensor(np_src, device=device)

    np_dst = np_src.mean(axis=dim, keepdims=keepdim)
    o3_dst = o3_src.mean(dim=dim, keepdim=keepdim)
    np.testing.assert_allclose(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize(
    "dim",
    [0, 1, 2, (), (0,), (1,), (2,), (0, 1), (0, 2), (1, 2), (0, 1, 2), None])
@pytest.mark.parametrize("keepdim", [True, False])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_reduction_prod(dim, keepdim, device):
    np_src = np.array(range(24)).reshape((2, 3, 4))
    o3_src = o3c.Tensor(np_src, device=device)

    np_dst = np_src.prod(axis=dim, keepdims=keepdim)
    o3_dst = o3_src.prod(dim=dim, keepdim=keepdim)
    np.testing.assert_allclose(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize(
    "dim",
    [0, 1, 2, (), (0,), (1,), (2,), (0, 1), (0, 2), (1, 2), (0, 1, 2), None])
@pytest.mark.parametrize("keepdim", [True, False])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_reduction_min(dim, keepdim, device):
    np_src = np.array(range(24))
    np.random.shuffle(np_src)
    np_src = np_src.reshape((2, 3, 4))
    o3_src = o3c.Tensor(np_src, device=device)

    np_dst = np_src.min(axis=dim, keepdims=keepdim)
    o3_dst = o3_src.min(dim=dim, keepdim=keepdim)
    np.testing.assert_allclose(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize(
    "dim",
    [0, 1, 2, (), (0,), (1,), (2,), (0, 1), (0, 2), (1, 2), (0, 1, 2), None])
@pytest.mark.parametrize("keepdim", [True, False])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_reduction_max(dim, keepdim, device):
    np_src = np.array(range(24))
    np.random.shuffle(np_src)
    np_src = np_src.reshape((2, 3, 4))
    o3_src = o3c.Tensor(np_src, device=device)

    np_dst = np_src.max(axis=dim, keepdims=keepdim)
    o3_dst = o3_src.max(dim=dim, keepdim=keepdim)
    np.testing.assert_allclose(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize("dim", [0, 1, 2, None])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_reduction_argmin_argmax(dim, device):
    np_src = np.array(range(24))
    np.random.shuffle(np_src)
    np_src = np_src.reshape((2, 3, 4))
    o3_src = o3c.Tensor(np_src, device=device)

    np_dst = np_src.argmin(axis=dim)
    o3_dst = o3_src.argmin(dim=dim)
    np.testing.assert_allclose(o3_dst.cpu().numpy(), np_dst)

    np_dst = np_src.argmax(axis=dim)
    o3_dst = o3_src.argmax(dim=dim)
    np.testing.assert_allclose(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_advanced_index_get_mixed(device):
    np_src = np.array(range(24)).reshape((2, 3, 4))
    o3_src = o3c.Tensor(np_src, device=device)

    np_dst = np_src[1, 0:2, [1, 2]]
    o3_dst = o3_src[1, 0:2, [1, 2]]
    np.testing.assert_equal(o3_dst.cpu().numpy(), np_dst)

    # Subtle differences between slice and list
    np_src = np.array([0, 100, 200, 300, 400, 500, 600, 700, 800]).reshape(3, 3)
    o3_src = o3c.Tensor(np_src, device=device)
    np.testing.assert_equal(o3_src[1, 2].cpu().numpy(), np_src[1, 2])
    np.testing.assert_equal(o3_src[[1, 2]].cpu().numpy(), np_src[[1, 2]])
    np.testing.assert_equal(o3_src[(1, 2)].cpu().numpy(), np_src[(1, 2)])
    np.testing.assert_equal(o3_src[(1, 2), [1, 2]].cpu().numpy(),
                            np_src[(1, 2), [1, 2]])

    # Complex case: interleaving slice and advanced indexing
    np_src = np.array(range(120)).reshape((2, 3, 4, 5))
    o3_src = o3c.Tensor(np_src, device=device)
    o3_dst = o3_src[1, [[1, 2], [2, 1]], 0:4:2, [3, 4]]
    np_dst = np_src[1, [[1, 2], [2, 1]], 0:4:2, [3, 4]]
    np.testing.assert_equal(o3_dst.cpu().numpy(), np_dst)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_advanced_index_set_mixed(device):
    np_src = np.array(range(24)).reshape((2, 3, 4))
    o3_src = o3c.Tensor(np_src, device=device)

    np_fill = np.array(([[100, 200], [300, 400]]))
    o3_fill = o3c.Tensor(np_fill, device=device)

    np_src[1, 0:2, [1, 2]] = np_fill
    o3_src[1, 0:2, [1, 2]] = o3_fill
    np.testing.assert_equal(o3_src.cpu().numpy(), np_src)

    # Complex case: interleaving slice and advanced indexing
    np_src = np.array(range(120)).reshape((2, 3, 4, 5))
    o3_src = o3c.Tensor(np_src, device=device)
    fill_shape = np_src[1, [[1, 2], [2, 1]], 0:4:2, [3, 4]].shape
    np_fill_val = np.random.randint(5000, size=fill_shape).astype(np_src.dtype)
    o3_fill_val = o3c.Tensor(np_fill_val)
    o3_src[1, [[1, 2], [2, 1]], 0:4:2, [3, 4]] = o3_fill_val
    np_src[1, [[1, 2], [2, 1]], 0:4:2, [3, 4]] = np_fill_val
    np.testing.assert_equal(o3_src.cpu().numpy(), np_src)


@pytest.mark.parametrize("np_func_name,o3_func_name", [("sqrt", "sqrt"),
                                                       ("sin", "sin"),
                                                       ("cos", "cos"),
                                                       ("negative", "neg"),
                                                       ("exp", "exp"),
                                                       ("abs", "abs"),
                                                       ("floor", "floor"),
                                                       ("ceil", "ceil"),
                                                       ("round", "round"),
                                                       ("trunc", "trunc")])
@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_unary_elementwise(np_func_name, o3_func_name, device):
    np_t = np.array([-3.4, -2.6, -1.5, 0, 1.4, 2.6, 3.5]).astype(np.float32)
    o3_t = o3c.Tensor(np_t, device=device)

    # Test non-in-place version
    np.seterr(invalid='ignore')  # e.g. sqrt of negative should be -nan
    np.testing.assert_allclose(getattr(o3_t, o3_func_name)().cpu().numpy(),
                               getattr(np, np_func_name)(np_t),
                               rtol=1e-7,
                               atol=1e-7)

    # Test in-place version
    if o3_func_name not in ["floor", "ceil", "round", "trunc"]:
        o3_func_name_inplace = o3_func_name + "_"
        getattr(o3_t, o3_func_name_inplace)()
        np.testing.assert_allclose(o3_t.cpu().numpy(),
                                   getattr(np, np_func_name)(np_t),
                                   rtol=1e-7,
                                   atol=1e-7)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_logical_ops(device):
    np_a = np.array([True, False, True, False])
    np_b = np.array([True, True, False, False])
    o3_a = o3c.Tensor(np_a, device=device)
    o3_b = o3c.Tensor(np_b, device=device)

    o3_r = o3_a.logical_and(o3_b)
    np_r = np.logical_and(np_a, np_b)
    np.testing.assert_equal(o3_r.cpu().numpy(), np_r)

    o3_r = o3_a.logical_or(o3_b)
    np_r = np.logical_or(np_a, np_b)
    np.testing.assert_equal(o3_r.cpu().numpy(), np_r)

    o3_r = o3_a.logical_xor(o3_b)
    np_r = np.logical_xor(np_a, np_b)
    np.testing.assert_equal(o3_r.cpu().numpy(), np_r)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_comparision_ops(device):
    np_a = np.array([0, 1, -1])
    np_b = np.array([0, 0, 0])
    o3_a = o3c.Tensor(np_a, device=device)
    o3_b = o3c.Tensor(np_b, device=device)

    np.testing.assert_equal((o3_a > o3_b).cpu().numpy(), np_a > np_b)
    np.testing.assert_equal((o3_a >= o3_b).cpu().numpy(), np_a >= np_b)
    np.testing.assert_equal((o3_a < o3_b).cpu().numpy(), np_a < np_b)
    np.testing.assert_equal((o3_a <= o3_b).cpu().numpy(), np_a <= np_b)
    np.testing.assert_equal((o3_a == o3_b).cpu().numpy(), np_a == np_b)
    np.testing.assert_equal((o3_a != o3_b).cpu().numpy(), np_a != np_b)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_non_zero(device):
    np_x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
    np_nonzero_tuple = np.nonzero(np_x)
    o3_x = o3c.Tensor(np_x, device=device)
    o3_nonzero_tuple = o3_x.nonzero(as_tuple=True)
    for np_t, o3_t in zip(np_nonzero_tuple, o3_nonzero_tuple):
        np.testing.assert_equal(np_t, o3_t.cpu().numpy())


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_boolean_advanced_indexing(device):
    np_a = np.array([1, -1, -2, 3])
    o3_a = o3c.Tensor(np_a, device=device)
    np_a[np_a < 0] = 0
    o3_a[o3_a < 0] = 0
    np.testing.assert_equal(np_a, o3_a.cpu().numpy())

    np_x = np.array([[0, 1], [1, 1], [2, 2]])
    np_row_sum = np.array([1, 2, 4])
    np_y = np_x[np_row_sum <= 2, :]
    o3_x = o3c.Tensor(np_x, device=device)
    o3_row_sum = o3c.Tensor(np_row_sum)
    o3_y = o3_x[o3_row_sum <= 2, :]
    np.testing.assert_equal(np_y, o3_y.cpu().numpy())

    np_t = np.array(5)
    np_t[np.array(True)] = 10
    o3_t = o3c.Tensor(5, device=device)
    o3_t[o3c.Tensor(True, device=device)] = 10
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    np_t = np.array(5)
    np_t[np.array(True)] = np.array(10)
    o3_t = o3c.Tensor(5, device=device)
    o3_t[o3c.Tensor(True, device=device)] = o3c.Tensor(10, device=device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    np_t = np.array(5)
    np_t[np.array(True)] = np.array([10])
    o3_t = o3c.Tensor(5, device=device)
    o3_t[o3c.Tensor(True, device=device)] = o3c.Tensor([10], device=device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    np_t = np.array(5)
    with pytest.raises(Exception):
        np_t[np.array(True)] = np.array([[10]])
    o3_t = o3c.Tensor(5, device=device)
    with pytest.raises(Exception):
        o3_t[o3c.Tensor(True, device=device)] = o3c.Tensor([[10]],
                                                           device=device)

    np_t = np.array(5)
    with pytest.raises(Exception):
        np_t[np.array(True)] = np.array([10, 11])
    o3_t = o3c.Tensor(5, device=device)
    with pytest.raises(Exception):
        o3_t[o3c.Tensor(True, device=device)] = o3c.Tensor([10, 11],
                                                           device=device)

    np_t = np.array(5)
    np_t[np.array(False)] = 10
    o3_t = o3c.Tensor(5, device=device)
    o3_t[o3c.Tensor(False, device=device)] = 10
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    np_t = np.array(5)
    np_t[np.array(False)] = np.array(10)
    o3_t = o3c.Tensor(5, device=device)
    o3_t[o3c.Tensor(False, device=device)] = o3c.Tensor(10, device=device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    np_t = np.array(5)
    np_t[np.array(False)] = np.array([10])
    o3_t = o3c.Tensor(5, device=device)
    o3_t[o3c.Tensor(False, device=device)] = o3c.Tensor([10], device=device)
    np.testing.assert_equal(np_t, o3_t.cpu().numpy())

    np_t = np.array(5)
    with pytest.raises(Exception):
        np_t[np.array(False)] = np.array([[10]])
    o3_t = o3c.Tensor(5, device=device)
    with pytest.raises(Exception):
        o3_t[o3c.Tensor(False, device=device)] = o3c.Tensor([[10]],
                                                            device=device)

    np_t = np.array(5)
    with pytest.raises(Exception):
        np_t[np.array(False)] = np.array([10, 11])
    o3_t = o3c.Tensor(5, device=device)
    with pytest.raises(Exception):
        o3_t[o3c.Tensor(False, device=device)] = o3c.Tensor([10, 11],
                                                            device=device)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_scalar_op(device):
    # +
    a = o3c.Tensor.ones((2, 3), o3c.float32, device=device)
    b = a.add(1)
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 2))
    b = a + 1
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 2))
    b = 1 + a
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 2))
    b = a + True
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 2))

    # +=
    a = o3c.Tensor.ones((2, 3), o3c.float32, device=device)
    a.add_(1)
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 2))
    a += 1
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 3))
    a += True
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 4))

    # -
    a = o3c.Tensor.ones((2, 3), o3c.float32, device=device)
    b = a.sub(1)
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 0))
    b = a - 1
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 0))
    b = 10 - a
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 9))
    b = a - True
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 0))

    # -=
    a = o3c.Tensor.ones((2, 3), o3c.float32, device=device)
    a.sub_(1)
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 0))
    a -= 1
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), -1))
    a -= True
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), -2))

    # *
    a = o3c.Tensor.full((2, 3), 2, o3c.float32, device=device)
    b = a.mul(10)
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 20))
    b = a * 10
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 20))
    b = 10 * a
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 20))
    b = a * True
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 2))

    # *=
    a = o3c.Tensor.full((2, 3), 2, o3c.float32, device=device)
    a.mul_(10)
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 20))
    a *= 10
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 200))
    a *= True
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 200))

    # /
    a = o3c.Tensor.full((2, 3), 20, o3c.float32, device=device)
    b = a.div(2)
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 10))
    b = a / 2
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 10))
    b = a // 2
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 10))
    b = 10 / a
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 0.5))
    b = 10 // a
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 0.5))
    b = a / True
    np.testing.assert_equal(b.cpu().numpy(), np.full((2, 3), 20))

    # /=
    a = o3c.Tensor.full((2, 3), 20, o3c.float32, device=device)
    a.div_(2)
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 10))
    a /= 2
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 5))
    a //= 2
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 2.5))
    a /= True
    np.testing.assert_equal(a.cpu().numpy(), np.full((2, 3), 2.5))

    # logical_and
    a = o3c.Tensor([True, False], device=device)
    np.testing.assert_equal(
        a.logical_and(True).cpu().numpy(), np.array([True, False]))
    np.testing.assert_equal(
        a.logical_and(5).cpu().numpy(), np.array([True, False]))
    np.testing.assert_equal(
        a.logical_and(False).cpu().numpy(), np.array([False, False]))
    np.testing.assert_equal(
        a.logical_and(0).cpu().numpy(), np.array([False, False]))

    # logical_and_
    a = o3c.Tensor([True, False], device=device)
    a.logical_and_(True)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False]))
    a = o3c.Tensor([True, False], device=device)
    a.logical_and_(5)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False]))
    a = o3c.Tensor([True, False], device=device)
    a.logical_and_(False)
    np.testing.assert_equal(a.cpu().numpy(), np.array([False, False]))
    a.logical_and_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([False, False]))

    # logical_or
    a = o3c.Tensor([True, False], device=device)
    np.testing.assert_equal(
        a.logical_or(True).cpu().numpy(), np.array([True, True]))
    np.testing.assert_equal(
        a.logical_or(5).cpu().numpy(), np.array([True, True]))
    np.testing.assert_equal(
        a.logical_or(False).cpu().numpy(), np.array([True, False]))
    np.testing.assert_equal(
        a.logical_or(0).cpu().numpy(), np.array([True, False]))

    # logical_or_
    a = o3c.Tensor([True, False], device=device)
    a.logical_or_(True)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, True]))
    a = o3c.Tensor([True, False], device=device)
    a.logical_or_(5)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, True]))
    a = o3c.Tensor([True, False], device=device)
    a.logical_or_(False)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False]))
    a.logical_or_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False]))

    # logical_xor
    a = o3c.Tensor([True, False], device=device)
    np.testing.assert_equal(
        a.logical_xor(True).cpu().numpy(), np.array([False, True]))
    np.testing.assert_equal(
        a.logical_xor(5).cpu().numpy(), np.array([False, True]))
    np.testing.assert_equal(
        a.logical_xor(False).cpu().numpy(), np.array([True, False]))
    np.testing.assert_equal(
        a.logical_xor(0).cpu().numpy(), np.array([True, False]))

    # logical_xor_
    a = o3c.Tensor([True, False], device=device)
    a.logical_xor_(True)
    np.testing.assert_equal(a.cpu().numpy(), np.array([False, True]))
    a = o3c.Tensor([True, False], device=device)
    a.logical_xor_(5)
    np.testing.assert_equal(a.cpu().numpy(), np.array([False, True]))
    a = o3c.Tensor([True, False], device=device)
    a.logical_xor_(False)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False]))
    a.logical_xor_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False]))

    # gt
    dtype = o3c.float32
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    np.testing.assert_equal((a.gt(0)).cpu().numpy(),
                            np.array([False, False, True]))
    np.testing.assert_equal((a > 0).cpu().numpy(),
                            np.array([False, False, True]))

    # gt_
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    a.gt_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([False, False, True]))

    # lt
    dtype = o3c.float32
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    np.testing.assert_equal((a.lt(0)).cpu().numpy(),
                            np.array([True, False, False]))
    np.testing.assert_equal((a < 0).cpu().numpy(),
                            np.array([True, False, False]))

    # lt_
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    a.lt_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False, False]))

    # ge
    dtype = o3c.float32
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    np.testing.assert_equal((a.ge(0)).cpu().numpy(),
                            np.array([False, True, True]))
    np.testing.assert_equal((a >= 0).cpu().numpy(),
                            np.array([False, True, True]))

    # ge_
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    a.ge_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([False, True, True]))

    # le
    dtype = o3c.float32
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    np.testing.assert_equal((a.le(0)).cpu().numpy(),
                            np.array([True, True, False]))
    np.testing.assert_equal((a <= 0).cpu().numpy(),
                            np.array([True, True, False]))

    # le_
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    a.le_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, True, False]))

    # eq
    dtype = o3c.float32
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    np.testing.assert_equal((a.eq(0)).cpu().numpy(),
                            np.array([False, True, False]))
    np.testing.assert_equal((a == 0).cpu().numpy(),
                            np.array([False, True, False]))

    # eq_
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    a.eq_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([False, True, False]))

    # ne
    dtype = o3c.float32
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    np.testing.assert_equal((a.ne(0)).cpu().numpy(),
                            np.array([True, False, True]))
    np.testing.assert_equal((a != 0).cpu().numpy(),
                            np.array([True, False, True]))

    # ne_
    a = o3c.Tensor([-1, 0, 1], dtype=dtype, device=device)
    a.ne_(0)
    np.testing.assert_equal(a.cpu().numpy(), np.array([True, False, True]))

    # clip
    dtype = o3c.int64
    a = o3c.Tensor([2, -1, 1], dtype=dtype, device=device)
    np.testing.assert_equal(a.clip(0, 1).cpu().numpy(), np.array([1, 0, 1]))
    np.testing.assert_equal(a.clip(0.5, 1.2).cpu().numpy(), np.array([1, 0, 1]))

    # clip_
    a = o3c.Tensor([2, -1, 1], dtype=dtype, device=device)
    a.clip_(0, 1)
    np.testing.assert_equal(a.cpu().numpy(), np.array([1, 0, 1]))


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_all_any(device):
    a = o3c.Tensor([False, True, True, True], dtype=o3c.bool, device=device)
    assert not a.all()
    assert a.any()

    a = o3c.Tensor([True, True, True, True], dtype=o3c.bool, device=device)
    assert a.all()

    # Empty
    a = o3c.Tensor([], dtype=o3c.bool, device=device)
    assert a.all()
    assert not a.any()


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_allclose_isclose(device):
    a = o3c.Tensor([1, 2], device=device)
    b = o3c.Tensor([1, 3], device=device)
    assert not a.allclose(b)
    np.testing.assert_allclose(
        a.isclose(b).cpu().numpy(), np.array([True, False]))

    assert a.allclose(b, atol=1)
    np.testing.assert_allclose(
        a.isclose(b, atol=1).cpu().numpy(), np.array([True, True]))

    # Test cases from
    # https://numpy.org/doc/stable/reference/generated/numpy.allclose.html
    a = o3c.Tensor([1e10, 1e-7], device=device)
    b = o3c.Tensor([1.00001e10, 1e-8], device=device)
    assert not a.allclose(b)
    a = o3c.Tensor([1e10, 1e-8], device=device)
    b = o3c.Tensor([1.00001e10, 1e-9], device=device)
    assert a.allclose(b)
    a = o3c.Tensor([1e10, 1e-8], device=device)
    b = o3c.Tensor([1.0001e10, 1e-9], device=device)
    assert not a.allclose(b)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_issame(device):
    dtype = o3c.float32
    a = o3c.Tensor.ones((2, 3), dtype, device=device)
    b = o3c.Tensor.ones((2, 3), dtype, device=device)
    assert a.allclose(b)
    assert not a.issame(b)

    c = a
    assert a.allclose(c)
    assert a.issame(c)

    d = a[:, 0:2]
    e = a[:, 0:2]
    assert d.allclose(e)
    assert d.issame(e)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_item(device):
    o3_t = o3c.Tensor.ones((2, 3), dtype=o3c.float32, device=device) * 1.5
    assert o3_t[0, 0].item() == 1.5
    assert isinstance(o3_t[0, 0].item(), float)

    o3_t = o3c.Tensor.ones((2, 3), dtype=o3c.float64, device=device) * 1.5
    assert o3_t[0, 0].item() == 1.5
    assert isinstance(o3_t[0, 0].item(), float)

    o3_t = o3c.Tensor.ones((2, 3), dtype=o3c.int32, device=device) * 1.5
    assert o3_t[0, 0].item() == 1
    assert isinstance(o3_t[0, 0].item(), int)

    o3_t = o3c.Tensor.ones((2, 3), dtype=o3c.int64, device=device) * 1.5
    assert o3_t[0, 0].item() == 1
    assert isinstance(o3_t[0, 0].item(), int)

    o3_t = o3c.Tensor.ones((2, 3), dtype=o3c.bool, device=device)
    assert o3_t[0, 0].item() == True
    assert isinstance(o3_t[0, 0].item(), bool)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_save_load(device):
    with tempfile.TemporaryDirectory() as temp_dir:
        file_name = f"{temp_dir}/tensor.npy"

        o3_tensors = [
            o3c.Tensor([[1, 2], [3, 4]], dtype=o3c.float32, device=device),
            o3c.Tensor(3.14, dtype=o3c.float32, device=device),
            o3c.Tensor.ones((0,), dtype=o3c.float32, device=device),
            o3c.Tensor.ones((0, 0), dtype=o3c.float32, device=device),
            o3c.Tensor.ones((0, 1, 0), dtype=o3c.float32, device=device)
        ]
        np_tensors = [
            np.array([[1, 2], [3, 4]], dtype=np.float32),
            np.array(3.14, dtype=np.float32),
            np.ones((0,), dtype=np.float32),
            np.ones((0, 0), dtype=np.float32),
            np.ones((0, 1, 0), dtype=np.float32)
        ]
        for o3_t, np_t in zip(o3_tensors, np_tensors):
            # Open3D -> Numpy.
            o3_t.save(file_name)
            o3_t_load = o3c.Tensor.load(file_name)
            np.testing.assert_equal(o3_t_load.cpu().numpy(), np_t)

            # Open3D -> Numpy.
            np_t_load = np.load(file_name)
            np.testing.assert_equal(np_t_load, np_t_load)

            # Numpy -> Open3D.
            np.save(file_name, np_t)
            o3_t_load = o3c.Tensor.load(file_name)
            np.testing.assert_equal(o3_t_load.cpu().numpy(), np_t)

        # Ragged tensor: exception.
        np_t = np.array([[1, 2, 3], [4, 5]], dtype=np.dtype(object))
        np.save(file_name, np_t)
        with pytest.raises(Exception):
            o3_t_load = o3c.Tensor.load(file_name)

        # Fortran order: exception.
        np_t = np.array([[1, 2, 3], [4, 5, 6]])
        np_t = np.asfortranarray(np_t)
        np.save(file_name, np_t)
        with pytest.raises(Exception):
            o3_t_load = o3c.Tensor.load(file_name)

        # Unsupported dtype: exception.
        np_t = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.complex64)
        np.save(file_name, np_t)
        with pytest.raises(Exception):
            o3_t_load = o3c.Tensor.load(file_name)

        # Non-contiguous numpy array.
        np_t = np.arange(24).reshape(2, 3, 4)
        assert np_t.flags['C_CONTIGUOUS']
        np_t = np_t[0:2:1, 0:3:2, 0:4:2]
        assert not np_t.flags['C_CONTIGUOUS']
        np.save(file_name, np_t)
        o3_t_load = o3c.Tensor.load(file_name)
        assert o3_t_load.is_contiguous()
        np.testing.assert_equal(o3_t_load.cpu().numpy(), np_t)


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_iterator(device):
    # 0-d.
    o3_t = o3c.Tensor.ones((), dtype=o3c.float32, device=device)
    with pytest.raises(Exception, match=r'Cannot iterate a scalar'):
        for o3_t_slice in o3_t:
            pass

    # 1-d.
    o3_t = o3c.Tensor([0, 1, 2], device=device)
    np_t = np.array([0, 1, 2])
    for o3_t_slice, np_t_slice in zip(o3_t, np_t):
        np.testing.assert_equal(o3_t_slice.cpu().numpy(), np_t_slice)

    # TODO: 1-d with assignment (assigning to a 0-d slice) is not possible with
    # our current slice API. This issue is not related to the iterator.
    # Operator [:] requires 1 or more dimensions. We need to implement the [...]
    # operator. See: https://stackoverflow.com/a/49581266/1255535.

    # 2-d.
    o3_t = o3c.Tensor([[0, 1, 2], [3, 4, 5]], device=device)
    np_t = np.array([[0, 1, 2], [3, 4, 5]])
    for o3_t_slice, np_t_slice in zip(o3_t, np_t):
        np.testing.assert_equal(o3_t_slice.cpu().numpy(), np_t_slice)

    # 2-d with assignment.
    o3_t = o3c.Tensor([[0, 1, 2], [3, 4, 5]], device=device)
    new_o3_t_slices = [
        o3c.Tensor([0, 10, 20], device=device),
        o3c.Tensor([30, 40, 50], device=device)
    ]
    for o3_t_slice, new_o3_t_slice in zip(o3_t, new_o3_t_slices):
        o3_t_slice[:] = new_o3_t_slice
    np.testing.assert_equal(o3_t.cpu().numpy(),
                            np.array([[0, 10, 20], [30, 40, 50]]))


@pytest.mark.parametrize("device", list_devices(enable_sycl=True))
def test_pickle(device):
    o3_t = o3c.Tensor.ones((100), dtype=o3c.float32, device=device)
    with tempfile.TemporaryDirectory() as temp_dir:
        file_name = f"{temp_dir}/tensor.pkl"
        pickle.dump(o3_t, open(file_name, "wb"))
        o3_t_load = pickle.load(open(file_name, "rb"))
        assert o3_t_load.device == device and o3_t_load.dtype == o3c.float32
        np.testing.assert_equal(o3_t.cpu().numpy(), o3_t_load.cpu().numpy())

        # Test with a non-contiguous tensor.
        o3_t_nc = o3_t[0:100:2]
        pickle.dump(o3_t_nc, open(file_name, "wb"))
        o3_t_nc_load = pickle.load(open(file_name, "rb"))
        assert o3_t_nc_load.is_contiguous()
        np.testing.assert_equal(o3_t_nc.cpu().numpy(),
                                o3_t_nc_load.cpu().numpy())
