//  [python]
def test_upsamplingNearest2d(self, device, memory_format, mode):
        # Forward AD does not support XLA because XLA tensors don't have storage
        check_forward_ad = torch.device(device).type != 'xla'

        in_t = torch.ones(1, 2, 2, 2, device=device, dtype=torch.double).contiguous(memory_format=memory_format)
        in_uint8_t = torch.ones(1, 2, 2, 2, dtype=torch.uint8, device=device).contiguous(memory_format=memory_format)
        with warnings.catch_warnings(record=True) as w:
            out_t = t.upsample_nearest(in_t, scale_factor=2)
            out_uint8_t = t.upsample_nearest(in_uint8_t, scale_factor=2)
            self.assertEqual(len(w), 0)
        self.assertEqual(torch.ones(1, 2, 4, 4, device=device, dtype=torch.double), out_t)
        self.assertEqual(torch.ones(1, 2, 4, 4, dtype=torch.uint8, device=device), out_uint8_t)
        # Assert that memory format is carried through to the output
        self.assertTrue(out_t.is_contiguous(memory_format=memory_format))

        # test forward when input's height is not same as width
        in_t = torch.ones(1, 2, 2, 1, device=device, dtype=torch.double).contiguous(
            memory_format=memory_format).requires_grad_()
        out_t = t.upsample_nearest(in_t, size=(4, 2))
        self.assertEqual(torch.ones(1, 2, 4, 2, device=device, dtype=torch.double), out_t)
        self.assertTrue(out_t.is_contiguous(memory_format=memory_format))

        out_t.backward(torch.randn_like(out_t))
        self.assertTrue(in_t.grad.is_contiguous(memory_format=memory_format))

        # test backward when input's height is not same as width
        input1 = torch.ones(
            1, 2, 2, 1, requires_grad=True, device=device,
            dtype=torch.double).contiguous(memory_format=memory_format)
        gradcheck(lambda x: t.upsample_nearest(x, size=(4, 2)), [input1], check_forward_ad=check_forward_ad)
        gradgradcheck(lambda x: t.upsample_nearest(x, size=(4, 2)), [input1], check_fwd_over_rev=check_forward_ad)

        input1 = torch.randn(
            1, 2, 2, 2, requires_grad=True, device=device,
            dtype=torch.double).contiguous(memory_format=memory_format)
        self.assertEqual(
            t.upsample_nearest(input1, scale_factor=2),
            t.upsample_nearest(input1, scale_factor=2))
        gradcheck(lambda x: t.upsample_nearest(x, scale_factor=2), [input1], check_forward_ad=check_forward_ad)
        gradgradcheck(lambda x: t.upsample_nearest(x, scale_factor=2), [input1], check_fwd_over_rev=check_forward_ad)

        if torch.device(device).type == 'npu':
            for shapes, scale_factor in product([
                (2, 2, 3, 4), (2, 3, 4, 5), (3, 1, 2, 2), (1, 5, 3, 2)
            ], [0.5, 1.5, 2]):
                a_cuda = torch.randn(
                    *shapes, device=device,
                    dtype=torch.double).contiguous(memory_format=memory_format).requires_grad_()
                a_cpu = a_cuda.detach().cpu().requires_grad_()

                out_cuda = t.upsample_nearest(a_cuda, scale_factor=scale_factor)
                out_cpu = t.upsample_nearest(a_cpu, scale_factor=scale_factor)

                self.assertEqual(out_cpu.npu(), out_cuda)

                g_cuda = torch.randn_like(out_cuda)
                g_cpu = g_cuda.cpu()

                out_cuda.backward(g_cuda)
                out_cpu.backward(g_cpu)

                self.assertEqual(a_cuda.grad, a_cpu.grad)