528 lines
16 KiB
Python
528 lines
16 KiB
Python
|
"""
|
||
|
|
Testing C implementation of the numba typed-list
|
||
|
|
"""
|
||
|
|
|
||
|
|
import ctypes
|
||
|
|
import struct
|
||
|
|
|
||
|
|
from numba.tests.support import TestCase
|
||
|
|
from numba import _helperlib
|
||
|
|
|
||
|
|
|
||
|
|
LIST_OK = 0
|
||
|
|
LIST_ERR_INDEX = -1
|
||
|
|
LIST_ERR_NO_MEMORY = -2
|
||
|
|
LIST_ERR_MUTATED = -3
|
||
|
|
LIST_ERR_ITER_EXHAUSTED = -4
|
||
|
|
LIST_ERR_IMMUTABLE = -5
|
||
|
|
|
||
|
|
|
||
|
|
class List(object):
|
||
|
|
"""A wrapper around the C-API to provide a minimal list object for
|
||
|
|
testing.
|
||
|
|
"""
|
||
|
|
def __init__(self, tc, item_size, allocated):
|
||
|
|
"""
|
||
|
|
Parameters
|
||
|
|
----------
|
||
|
|
tc : TestCase instance
|
||
|
|
item_size : int
|
||
|
|
byte size for the items
|
||
|
|
allocated : int
|
||
|
|
number of items to allocate for
|
||
|
|
"""
|
||
|
|
self.tc = tc
|
||
|
|
self.item_size = item_size
|
||
|
|
self.lp = self.list_new(item_size, allocated)
|
||
|
|
|
||
|
|
# The following methods implement part of the list API
|
||
|
|
|
||
|
|
def __del__(self):
|
||
|
|
self.tc.numba_list_free(self.lp)
|
||
|
|
|
||
|
|
def __len__(self):
|
||
|
|
return self.list_length()
|
||
|
|
|
||
|
|
def __setitem__(self, i, item):
|
||
|
|
return self.list_setitem(i, item)
|
||
|
|
|
||
|
|
def __getitem__(self, i):
|
||
|
|
return self.list_getitem(i)
|
||
|
|
|
||
|
|
def __iter__(self):
|
||
|
|
return ListIter(self)
|
||
|
|
|
||
|
|
def __delitem__(self, i):
|
||
|
|
self.list_delitem(i)
|
||
|
|
|
||
|
|
def handle_index(self, i):
|
||
|
|
# handling negative indices is done at the compiler level, so we only
|
||
|
|
# support -1 to be last element of the list here
|
||
|
|
if i < -1 or len(self) == 0:
|
||
|
|
IndexError("list index out of range")
|
||
|
|
elif i == -1:
|
||
|
|
i = len(self) - 1
|
||
|
|
return i
|
||
|
|
|
||
|
|
@property
|
||
|
|
def allocated(self):
|
||
|
|
return self.list_allocated()
|
||
|
|
|
||
|
|
@property
|
||
|
|
def is_mutable(self):
|
||
|
|
return self.list_is_mutable()
|
||
|
|
|
||
|
|
def set_mutable(self):
|
||
|
|
return self.list_set_is_mutable(1)
|
||
|
|
|
||
|
|
def set_immutable(self):
|
||
|
|
return self.list_set_is_mutable(0)
|
||
|
|
|
||
|
|
def append(self, item):
|
||
|
|
self.list_append(item)
|
||
|
|
|
||
|
|
def pop(self, i=-1):
|
||
|
|
return self.list_pop(i)
|
||
|
|
|
||
|
|
# The methods below are higher-level wrappers for the C-API wrappers
|
||
|
|
|
||
|
|
def list_new(self, item_size, allocated):
|
||
|
|
lp = ctypes.c_void_p()
|
||
|
|
status = self.tc.numba_list_new(
|
||
|
|
ctypes.byref(lp), item_size, allocated,
|
||
|
|
)
|
||
|
|
self.tc.assertEqual(status, LIST_OK)
|
||
|
|
return lp
|
||
|
|
|
||
|
|
def list_length(self):
|
||
|
|
return self.tc.numba_list_length(self.lp)
|
||
|
|
|
||
|
|
def list_allocated(self):
|
||
|
|
return self.tc.numba_list_allocated(self.lp)
|
||
|
|
|
||
|
|
def list_is_mutable(self):
|
||
|
|
return self.tc.numba_list_is_mutable(self.lp)
|
||
|
|
|
||
|
|
def list_set_is_mutable(self, is_mutable):
|
||
|
|
return self.tc.numba_list_set_is_mutable(self.lp, is_mutable)
|
||
|
|
|
||
|
|
def list_setitem(self, i, item):
|
||
|
|
status = self.tc.numba_list_setitem(self.lp, i, item)
|
||
|
|
if status == LIST_ERR_INDEX:
|
||
|
|
raise IndexError("list index out of range")
|
||
|
|
elif status == LIST_ERR_IMMUTABLE:
|
||
|
|
raise ValueError("list is immutable")
|
||
|
|
else:
|
||
|
|
self.tc.assertEqual(status, LIST_OK)
|
||
|
|
|
||
|
|
def list_getitem(self, i):
|
||
|
|
i = self.handle_index(i)
|
||
|
|
item_out_buffer = ctypes.create_string_buffer(self.item_size)
|
||
|
|
status = self.tc.numba_list_getitem(self.lp, i, item_out_buffer)
|
||
|
|
if status == LIST_ERR_INDEX:
|
||
|
|
raise IndexError("list index out of range")
|
||
|
|
else:
|
||
|
|
self.tc.assertEqual(status, LIST_OK)
|
||
|
|
return item_out_buffer.raw
|
||
|
|
|
||
|
|
def list_append(self, item):
|
||
|
|
status = self.tc.numba_list_append(self.lp, item)
|
||
|
|
if status == LIST_ERR_IMMUTABLE:
|
||
|
|
raise ValueError("list is immutable")
|
||
|
|
self.tc.assertEqual(status, LIST_OK)
|
||
|
|
|
||
|
|
def list_pop(self, i):
|
||
|
|
# pop is getitem and delitem
|
||
|
|
i = self.handle_index(i)
|
||
|
|
item = self.list_getitem(i)
|
||
|
|
self.list_delitem(i)
|
||
|
|
return item
|
||
|
|
|
||
|
|
def list_delitem(self, i):
|
||
|
|
# special case slice
|
||
|
|
if isinstance(i, slice):
|
||
|
|
status = self.tc.numba_list_delete_slice(self.lp,
|
||
|
|
i.start,
|
||
|
|
i.stop,
|
||
|
|
i.step)
|
||
|
|
if status == LIST_ERR_IMMUTABLE:
|
||
|
|
raise ValueError("list is immutable")
|
||
|
|
self.tc.assertEqual(status, LIST_OK)
|
||
|
|
# must be an integer, defer to delitem
|
||
|
|
else:
|
||
|
|
i = self.handle_index(i)
|
||
|
|
status = self.tc.numba_list_delitem(self.lp, i)
|
||
|
|
if status == LIST_ERR_INDEX:
|
||
|
|
raise IndexError("list index out of range")
|
||
|
|
elif status == LIST_ERR_IMMUTABLE:
|
||
|
|
raise ValueError("list is immutable")
|
||
|
|
self.tc.assertEqual(status, LIST_OK)
|
||
|
|
|
||
|
|
def list_iter(self, itptr):
|
||
|
|
self.tc.numba_list_iter(itptr, self.lp)
|
||
|
|
|
||
|
|
def list_iter_next(self, itptr):
|
||
|
|
bi = ctypes.c_void_p(0)
|
||
|
|
status = self.tc.numba_list_iter_next(
|
||
|
|
itptr, ctypes.byref(bi),
|
||
|
|
)
|
||
|
|
if status == LIST_ERR_MUTATED:
|
||
|
|
raise ValueError('list mutated')
|
||
|
|
elif status == LIST_ERR_ITER_EXHAUSTED:
|
||
|
|
raise StopIteration
|
||
|
|
else:
|
||
|
|
self.tc.assertGreaterEqual(status, 0)
|
||
|
|
item = (ctypes.c_char * self.item_size).from_address(bi.value)
|
||
|
|
return item.value
|
||
|
|
|
||
|
|
|
||
|
|
class ListIter(object):
|
||
|
|
"""An iterator for the `List`.
|
||
|
|
"""
|
||
|
|
def __init__(self, parent):
|
||
|
|
self.parent = parent
|
||
|
|
itsize = self.parent.tc.numba_list_iter_sizeof()
|
||
|
|
self.it_state_buf = (ctypes.c_char_p * itsize)(0)
|
||
|
|
self.it = ctypes.cast(self.it_state_buf, ctypes.c_void_p)
|
||
|
|
self.parent.list_iter(self.it)
|
||
|
|
|
||
|
|
def __iter__(self):
|
||
|
|
return self
|
||
|
|
|
||
|
|
def __next__(self):
|
||
|
|
return self.parent.list_iter_next(self.it)
|
||
|
|
|
||
|
|
next = __next__ # needed for py2 only
|
||
|
|
|
||
|
|
|
||
|
|
class TestListImpl(TestCase):
|
||
|
|
def setUp(self):
|
||
|
|
"""Bind to the c_helper library and provide the ctypes wrapper.
|
||
|
|
"""
|
||
|
|
list_t = ctypes.c_void_p
|
||
|
|
iter_t = ctypes.c_void_p
|
||
|
|
|
||
|
|
def wrap(name, restype, argtypes=()):
|
||
|
|
proto = ctypes.CFUNCTYPE(restype, *argtypes)
|
||
|
|
return proto(_helperlib.c_helpers[name])
|
||
|
|
|
||
|
|
# numba_test_list()
|
||
|
|
self.numba_test_list = wrap(
|
||
|
|
'test_list',
|
||
|
|
ctypes.c_int,
|
||
|
|
)
|
||
|
|
|
||
|
|
# numba_list_new(NB_List *l, Py_ssize_t item_size, Py_ssize_t allocated)
|
||
|
|
self.numba_list_new = wrap(
|
||
|
|
'list_new',
|
||
|
|
ctypes.c_int,
|
||
|
|
[ctypes.POINTER(list_t), ctypes.c_ssize_t, ctypes.c_ssize_t],
|
||
|
|
)
|
||
|
|
# numba_list_free(NB_List *l)
|
||
|
|
self.numba_list_free = wrap(
|
||
|
|
'list_free',
|
||
|
|
None,
|
||
|
|
[list_t],
|
||
|
|
)
|
||
|
|
# numba_list_length(NB_List *l)
|
||
|
|
self.numba_list_length = wrap(
|
||
|
|
'list_length',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t],
|
||
|
|
)
|
||
|
|
# numba_list_allocated(NB_List *l)
|
||
|
|
self.numba_list_allocated = wrap(
|
||
|
|
'list_allocated',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t],
|
||
|
|
)
|
||
|
|
# numba_list_is_mutable(NB_List *lp)
|
||
|
|
self.numba_list_is_mutable = wrap(
|
||
|
|
'list_is_mutable',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t],
|
||
|
|
)
|
||
|
|
# numba_list_set_is_mutable(NB_List *lp, int is_mutable)
|
||
|
|
self.numba_list_set_is_mutable = wrap(
|
||
|
|
'list_set_is_mutable',
|
||
|
|
None,
|
||
|
|
[list_t, ctypes.c_int],
|
||
|
|
)
|
||
|
|
# numba_list_setitem(NB_List *l, Py_ssize_t i, const char *item)
|
||
|
|
self.numba_list_setitem = wrap(
|
||
|
|
'list_setitem',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t, ctypes.c_ssize_t, ctypes.c_char_p],
|
||
|
|
)
|
||
|
|
# numba_list_append(NB_List *l, const char *item)
|
||
|
|
self.numba_list_append = wrap(
|
||
|
|
'list_append',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t, ctypes.c_char_p],
|
||
|
|
)
|
||
|
|
# numba_list_getitem(NB_List *l, Py_ssize_t i, char *out)
|
||
|
|
self.numba_list_getitem = wrap(
|
||
|
|
'list_getitem',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t, ctypes.c_ssize_t, ctypes.c_char_p],
|
||
|
|
)
|
||
|
|
# numba_list_delitem(NB_List *l, Py_ssize_t i)
|
||
|
|
self.numba_list_delitem = wrap(
|
||
|
|
'list_delitem',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t, ctypes.c_ssize_t],
|
||
|
|
)
|
||
|
|
# numba_list_delete_slice(NB_List *l,
|
||
|
|
# Py_ssize_t start,
|
||
|
|
# Py_ssize_t stop,
|
||
|
|
# Py_ssize_t step)
|
||
|
|
self.numba_list_delete_slice = wrap(
|
||
|
|
'list_delete_slice',
|
||
|
|
ctypes.c_int,
|
||
|
|
[list_t, ctypes.c_ssize_t, ctypes.c_ssize_t, ctypes.c_ssize_t],
|
||
|
|
)
|
||
|
|
# numba_list_iter_sizeof()
|
||
|
|
self.numba_list_iter_sizeof = wrap(
|
||
|
|
'list_iter_sizeof',
|
||
|
|
ctypes.c_size_t,
|
||
|
|
)
|
||
|
|
# numba_list_iter(NB_ListIter *it, NB_List *l)
|
||
|
|
self.numba_list_iter = wrap(
|
||
|
|
'list_iter',
|
||
|
|
None,
|
||
|
|
[
|
||
|
|
iter_t,
|
||
|
|
list_t,
|
||
|
|
],
|
||
|
|
)
|
||
|
|
# numba_list_iter_next(NB_ListIter *it, const char **item_ptr)
|
||
|
|
self.numba_list_iter_next = wrap(
|
||
|
|
'list_iter_next',
|
||
|
|
ctypes.c_int,
|
||
|
|
[
|
||
|
|
iter_t, # it
|
||
|
|
ctypes.POINTER(ctypes.c_void_p), # item_ptr
|
||
|
|
],
|
||
|
|
)
|
||
|
|
|
||
|
|
def test_simple_c_test(self):
|
||
|
|
# Runs the basic test in C.
|
||
|
|
ret = self.numba_test_list()
|
||
|
|
self.assertEqual(ret, 0)
|
||
|
|
|
||
|
|
def test_length(self):
|
||
|
|
l = List(self, 8, 0)
|
||
|
|
self.assertEqual(len(l), 0)
|
||
|
|
|
||
|
|
def test_allocation(self):
|
||
|
|
for i in range(16):
|
||
|
|
l = List(self, 8, i)
|
||
|
|
self.assertEqual(len(l), 0)
|
||
|
|
self.assertEqual(l.allocated, i)
|
||
|
|
|
||
|
|
def test_append_get_string(self):
|
||
|
|
l = List(self, 8, 1)
|
||
|
|
l.append(b"abcdefgh")
|
||
|
|
self.assertEqual(len(l), 1)
|
||
|
|
r = l[0]
|
||
|
|
self.assertEqual(r, b"abcdefgh")
|
||
|
|
|
||
|
|
def test_append_get_int(self):
|
||
|
|
l = List(self, 8, 1)
|
||
|
|
l.append(struct.pack("q", 1))
|
||
|
|
self.assertEqual(len(l), 1)
|
||
|
|
r = struct.unpack("q", l[0])[0]
|
||
|
|
self.assertEqual(r, 1)
|
||
|
|
|
||
|
|
def test_append_get_string_realloc(self):
|
||
|
|
l = List(self, 8, 1)
|
||
|
|
l.append(b"abcdefgh")
|
||
|
|
self.assertEqual(len(l), 1)
|
||
|
|
l.append(b"hijklmno")
|
||
|
|
self.assertEqual(len(l), 2)
|
||
|
|
r = l[1]
|
||
|
|
self.assertEqual(r, b"hijklmno")
|
||
|
|
|
||
|
|
def test_set_item_getitem_index_error(self):
|
||
|
|
l = List(self, 8, 0)
|
||
|
|
with self.assertRaises(IndexError):
|
||
|
|
l[0]
|
||
|
|
with self.assertRaises(IndexError):
|
||
|
|
l[0] = b"abcdefgh"
|
||
|
|
|
||
|
|
def test_iter(self):
|
||
|
|
l = List(self, 1, 0)
|
||
|
|
values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
|
||
|
|
for i in values:
|
||
|
|
l.append(i)
|
||
|
|
received = []
|
||
|
|
for j in l:
|
||
|
|
received.append(j)
|
||
|
|
self.assertEqual(values, received)
|
||
|
|
|
||
|
|
def test_pop(self):
|
||
|
|
l = List(self, 1, 0)
|
||
|
|
values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
|
||
|
|
for i in values:
|
||
|
|
l.append(i)
|
||
|
|
self.assertEqual(len(l), 8)
|
||
|
|
|
||
|
|
received = l.pop()
|
||
|
|
self.assertEqual(b'h', received)
|
||
|
|
self.assertEqual(len(l), 7)
|
||
|
|
received = [j for j in l]
|
||
|
|
self.assertEqual(received, values[:-1])
|
||
|
|
|
||
|
|
received = l.pop(0)
|
||
|
|
self.assertEqual(b'a', received)
|
||
|
|
self.assertEqual(len(l), 6)
|
||
|
|
|
||
|
|
received = l.pop(2)
|
||
|
|
self.assertEqual(b'd', received)
|
||
|
|
self.assertEqual(len(l), 5)
|
||
|
|
|
||
|
|
expected = [b'b', b'c', b'e', b'f', b'g']
|
||
|
|
received = [j for j in l]
|
||
|
|
self.assertEqual(received, expected)
|
||
|
|
|
||
|
|
def test_pop_index_error(self):
|
||
|
|
l = List(self, 8, 0)
|
||
|
|
with self.assertRaises(IndexError):
|
||
|
|
l.pop()
|
||
|
|
|
||
|
|
def test_pop_byte(self):
|
||
|
|
l = List(self, 4, 0)
|
||
|
|
values = [b'aaaa', b'bbbb', b'cccc', b'dddd',
|
||
|
|
b'eeee', b'ffff', b'gggg', b'hhhhh']
|
||
|
|
for i in values:
|
||
|
|
l.append(i)
|
||
|
|
self.assertEqual(len(l), 8)
|
||
|
|
|
||
|
|
received = l.pop()
|
||
|
|
self.assertEqual(b'hhhh', received)
|
||
|
|
self.assertEqual(len(l), 7)
|
||
|
|
received = [j for j in l]
|
||
|
|
self.assertEqual(received, values[:-1])
|
||
|
|
|
||
|
|
received = l.pop(0)
|
||
|
|
self.assertEqual(b'aaaa', received)
|
||
|
|
self.assertEqual(len(l), 6)
|
||
|
|
|
||
|
|
received = l.pop(2)
|
||
|
|
self.assertEqual(b'dddd', received)
|
||
|
|
self.assertEqual(len(l), 5)
|
||
|
|
|
||
|
|
expected = [b'bbbb', b'cccc', b'eeee', b'ffff', b'gggg']
|
||
|
|
received = [j for j in l]
|
||
|
|
self.assertEqual(received, expected)
|
||
|
|
|
||
|
|
def test_delitem(self):
|
||
|
|
l = List(self, 1, 0)
|
||
|
|
values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
|
||
|
|
for i in values:
|
||
|
|
l.append(i)
|
||
|
|
self.assertEqual(len(l), 8)
|
||
|
|
|
||
|
|
# delete first item
|
||
|
|
del l[0]
|
||
|
|
self.assertEqual(len(l), 7)
|
||
|
|
self.assertEqual(list(l), values[1:])
|
||
|
|
# delete last item
|
||
|
|
del l[-1]
|
||
|
|
self.assertEqual(len(l), 6)
|
||
|
|
self.assertEqual(list(l), values[1:-1])
|
||
|
|
# delete item from middle
|
||
|
|
del l[2]
|
||
|
|
self.assertEqual(len(l), 5)
|
||
|
|
self.assertEqual(list(l), [b'b', b'c', b'e', b'f', b'g'])
|
||
|
|
|
||
|
|
def test_delete_slice(self):
|
||
|
|
l = List(self, 1, 0)
|
||
|
|
values = [b'a', b'b', b'c', b'd', b'e', b'f', b'g', b'h']
|
||
|
|
for i in values:
|
||
|
|
l.append(i)
|
||
|
|
self.assertEqual(len(l), 8)
|
||
|
|
|
||
|
|
# delete every second item
|
||
|
|
# no slice default normalization here, be explicit about start anb stop
|
||
|
|
del l[0:8:2]
|
||
|
|
self.assertEqual(len(l), 4)
|
||
|
|
self.assertEqual(list(l), values[1:8:2])
|
||
|
|
|
||
|
|
# delete first item
|
||
|
|
del l[0:1:1]
|
||
|
|
self.assertEqual(len(l), 3)
|
||
|
|
self.assertEqual(list(l), [b'd', b'f', b'h'])
|
||
|
|
|
||
|
|
# delete last item
|
||
|
|
del l[2:3:1]
|
||
|
|
self.assertEqual(len(l), 2)
|
||
|
|
self.assertEqual(list(l), [b'd', b'f'])
|
||
|
|
|
||
|
|
# delete all left items
|
||
|
|
del l[0:2:1]
|
||
|
|
self.assertEqual(len(l), 0)
|
||
|
|
self.assertEqual(list(l), [])
|
||
|
|
|
||
|
|
def check_sizing(self, item_size, nmax):
|
||
|
|
# Helper to verify different item_sizes
|
||
|
|
l = List(self, item_size, 0)
|
||
|
|
|
||
|
|
def make_item(v):
|
||
|
|
tmp = "{:0{}}".format(nmax - v - 1, item_size).encode("latin-1")
|
||
|
|
return tmp[:item_size]
|
||
|
|
|
||
|
|
for i in range(nmax):
|
||
|
|
l.append(make_item(i))
|
||
|
|
|
||
|
|
self.assertEqual(len(l), nmax)
|
||
|
|
|
||
|
|
for i in range(nmax):
|
||
|
|
self.assertEqual(l[i], make_item(i))
|
||
|
|
|
||
|
|
def test_sizing(self):
|
||
|
|
# Check different sizes of the key & value.
|
||
|
|
for i in range(1, 16):
|
||
|
|
self.check_sizing(item_size=i, nmax=2**i)
|
||
|
|
|
||
|
|
def test_mutability(self):
|
||
|
|
# setup and populate a singleton
|
||
|
|
l = List(self, 8, 1)
|
||
|
|
one = struct.pack("q", 1)
|
||
|
|
l.append(one)
|
||
|
|
self.assertTrue(l.is_mutable)
|
||
|
|
self.assertEqual(len(l), 1)
|
||
|
|
r = struct.unpack("q", l[0])[0]
|
||
|
|
self.assertEqual(r, 1)
|
||
|
|
|
||
|
|
# set to immutable and test guards
|
||
|
|
l.set_immutable()
|
||
|
|
self.assertFalse(l.is_mutable)
|
||
|
|
# append
|
||
|
|
with self.assertRaises(ValueError) as raises:
|
||
|
|
l.append(one)
|
||
|
|
self.assertIn("list is immutable", str(raises.exception))
|
||
|
|
# setitem
|
||
|
|
with self.assertRaises(ValueError) as raises:
|
||
|
|
l[0] = one
|
||
|
|
self.assertIn("list is immutable", str(raises.exception))
|
||
|
|
# pop
|
||
|
|
with self.assertRaises(ValueError) as raises:
|
||
|
|
l.pop()
|
||
|
|
self.assertIn("list is immutable", str(raises.exception))
|
||
|
|
# delitem with index
|
||
|
|
with self.assertRaises(ValueError) as raises:
|
||
|
|
del l[0]
|
||
|
|
self.assertIn("list is immutable", str(raises.exception))
|
||
|
|
# delitem with slice
|
||
|
|
with self.assertRaises(ValueError) as raises:
|
||
|
|
del l[0:1:1]
|
||
|
|
self.assertIn("list is immutable", str(raises.exception))
|
||
|
|
l.set_mutable()
|
||
|
|
|
||
|
|
# check that nothing has changed
|
||
|
|
self.assertTrue(l.is_mutable)
|
||
|
|
self.assertEqual(len(l), 1)
|
||
|
|
r = struct.unpack("q", l[0])[0]
|
||
|
|
self.assertEqual(r, 1)
|