def test_insert_middle(self):
"""
Inserting into the middle shifts elements to the right, to the right.
"""
a = DynamicArray()
a.append('fee')
a.append('fi')
a.append('fo')
a.insert(1, 'foo')
self.assertEqual(4, len(a))
self.assertEqual('fee', a[0])
self.assertEqual('foo', a[1])
self.assertEqual('fi', a[2])
self.assertEqual('fo', a[3])
def test_is_empty(self):
array = DynamicArray()
self.assertTrue(array.is_empty())
array.push(1)
self.assertFalse(array.is_empty())
def test_insert_first(self):
"""
Inserting a new first element shifts remaining elements to the right.
"""
a = DynamicArray()
a.append('fee')
a.append('fi')
a.append('fo')
a.insert(0, 'foo')
self.assertEqual(4, len(a))
self.assertEqual('foo', a[0])
self.assertEqual('fee', a[1])
self.assertEqual('fi', a[2])
self.assertEqual('fo', a[3])
def test_size(self):
array = DynamicArray()
self.assertEqual(array.size(), 0)
array.push(1)
self.assertEqual(array.size(), 1)
def test_imul(self):
arr = DynamicArray()
id1 = id(arr)
arr *= 1
id2 = id(arr)
assert id1 == id2
assert arr == DynamicArray()
arr *= 0
id2 = id(arr)
assert id1 == id2
assert arr == DynamicArray()
arr = DynamicArray([1, 2, 3])
id1 = id(arr)
arr *= 3
id2 = id(arr)
assert id1 == id2
assert arr == DynamicArray([1, 2, 3, 1, 2, 3, 1, 2, 3])
arr *= -10
id2 = id(arr)
assert id1 == id2
assert arr == DynamicArray()
with pytest.raises(TypeError):
arr *= 1.1
def test_pop(self):
"""
Popping removes and returns the last element
"""
a = DynamicArray()
a.append('fee')
a.append('fi')
a.append('fo')
last_element = a.pop()
self.assertEqual('fo', last_element)
self.assertEqual(2, len(a))
def test_is_empty(self):
"""
A dynamic array containing data is not empty.
"""
a = DynamicArray()
self.assertTrue(a.is_empty())
a.append('FAKE')
self.assertFalse(a.is_empty())
def test_dynamic_array_should_return_specified_value_after_insert():
da = DynamicArray()
da.insert(0, 1)
assert da[0] == 1
assert len(da) == 1
assert da._cap == 1
da.insert(0, 2)
assert len(da) == 2
assert da._cap == 2
assert da[0] == 2
da.insert(2, 3)
assert len(da) == 3
assert da._cap == 4
assert da[2] == 3
def test_append_to_full(self):
"""
A full dynamic array expands to accommodate a new appended element.
"""
a = DynamicArray()
for _ in range(0, a.capacity):
a.append('fake')
a.append('new value')
self.assertEqual('new value', a[10])
def tearDown(self):
# add the tearDown tasks
print("running tearDown tasks")
# reset values
self.test_1 = DynamicArray([2,4,6,8,10])
self.test_2 = DynamicArray([1,2,3,4,5,6,7,8,9])
self.test_3 = DynamicArray(['apple','banana','mango','grape','orange'])
self.test_4 = DynamicArray([{'name': 'John','age': 30},{'name': 'Janet','age': 40},{'name': 'Bob','age': 25},])
self.test_5 = DynamicArray([True, False, 'True', 'False', 0, 1])
self.test_6 = DynamicArray([])
def test_new_capacity(self):
"""
When expanding, a dynamic array doubles its capacity
"""
a = DynamicArray()
for _ in range(0, a.capacity):
a.append('fake')
old_capacity = a.capacity
a.append('new value')
self.assertEqual(2 * old_capacity, a.capacity)
def test_dynamic_array_should_double_capacity_automatically():
da = DynamicArray()
for i in range(2):
da.append(i)
assert len(da) == 2
assert da[0] == 0
assert da[1] == 1
da.append(2)
assert da._cap == 4
def test_iter(self):
array = DynamicArray()
test_data = [1, 2, 3]
array.append(test_data[0])
array.append(test_data[1])
array.append(test_data[2])
start = 0
for i in array:
assert i == test_data[start]
start += 1
def test_insert_to_full(self):
"""
A full dynamic array expands to accommodate a new inserted element.
"""
a = DynamicArray()
for i in range(0, a.capacity):
a.append(f"fake{i}")
a.insert(0, 'new value')
self.assertEqual('new value', a[0])
self.assertEqual('fake0', a[1])
self.assertEqual('fake9', a[10])
def test_dynamic_array(self):
# To test that our new array object is actually dynamic:
# We test with an input size less than our predefined size of 10
arr = DynamicArray(3, 5, 6, 7)
self.assertEqual(arr.size, 10)
# We also test with an input size greater than our predefined size and if the size size of our array has doubled
arr = DynamicArray(9, 4, 6, 3, 4, 5, 1, 4, 6, 8, 4, 8, 9, 0, 4, 7)
self.assertEqual(arr.size, 20)
# Testing the delete method
arr.arr_del()
self.assertEqual(arr.values,
[9, 4, 6, 3, 4, 5, 1, 4, 6, 8, 4, 8, 9, 0, 4])
def test_slice(self):
array = DynamicArray()
array.append(1)
array.append(2)
array.append(3)
test_slice = array[:2]
assert len(test_slice) == 2
assert test_slice[0] == 1
assert test_slice[1] == 2
with pytest.raises(IndexError):
_ = array[1:5:1]
with pytest.raises(IndexError):
_ = array[5:1]
def compute_average(n, version):
"""Perform n appends to an empty list and return average time elapsed."""
data = DynamicArray()
start = time() # record the start time (in seconds)
if version == 1:
for k in range(n):
data.append(k)
elif version == 2:
c = int(input("Enter a value in which to increase array by: "))
for k in range(n):
data.append1(k, c)
end = time() # record the end time (in seconds)
return (end - start) / n # compute average per operation
def test_dynamic_array():
"""Test methods of array"""
arr = DynamicArray(3)
arr[0] = "this"
arr[1] = "is"
arr[2] = "just"
arr[3] = "another"
arr[4] = "test"
arr[5] = "!"
assert arr.num_items == 6
assert arr.size == 12
arr[0] = None
assert arr.num_items == 5
arr[1] = "text"
assert arr.num_items == 5
def test_remove(self):
array = DynamicArray()
array.append(1)
array.append(2)
array.remove(2)
assert 2 not in array and len(array) == 1
array.append(3)
array.append(3)
array.remove(3)
assert 3 in array and len(array) == 2
for i in range(100):
array.append(4)
for i in range(100):
array.remove(4)
assert 4 not in array and len(array) == 2
assert array._capacity == 8
def test_repr(self):
array = DynamicArray()
array.append(1)
array.append(2)
assert repr(array) == '[1, 2, ]'
assert str(array) == '[1, 2, ]'
def test_initial_length(self):
"""
A dynamic array has an initial length of 0.
"""
a = DynamicArray()
self.assertEqual(0, len(a))
def test_dynamic_array_should_get_element_by_its_index():
da = DynamicArray()
for i in range(10):
da.append(i)
assert da[i] == i
def test_append(self):
array = DynamicArray()
array.append(2)
array.append(3)
assert 2 in array
def __init__(self):
self._data = DynamicArray()
def test_empty_not_full(self):
"""
An empty dynamic array is not full.
"""
a = DynamicArray()
self.assertFalse(a.is_full())
def test_dynamic_array_should_raises_IndexError_when_it_is_out_of_index():
da = DynamicArray()
with pytest.raises(IndexError, match="wrong index"):
da[1]
def test_bool(self):
array = DynamicArray()
assert bool(array) is False
array.append(1)
assert bool(array) is True
def test_index(self):
array = DynamicArray()
array.append(1)
assert array[0] == 1
with pytest.raises(IndexError):
_ = array[1]
def main():
test1 = DynamicArray()
test2 = DynamicArray()
for n in range(5, 11):
test1.append(n)
test2.append(n)
print("Test 1:", test1)
print("Test 2:", test2)
print()
# positive or negative index
print("__getitem__")
print("test1[3] =", test1[3])
print("test2[-1] =", test2[-1])
print()
print("__setitem__")
print("Test 1:", test1)
print("Test 2:", test2)
test1[1] = 7
test2[0] = 9
print("test1[1] = 7")
print("test2[0] = 9")
print("Test 1:", test1)
print("Test 2:", test2)
print()
# return, resize
print("pop")
print("Test 1:", test1)
print("Test 2:", test2)
print("test1.pop() =", test1.pop())
print("test2.pop() =", test2.pop())
print("Test 1:", test1)
print("Test 2:", test2)
print()
# contents/length equal
print("__eq__")
test3 = DynamicArray()
for i in range(len(test2)):
test3.append(test2[i])
test4 = DynamicArray()
for i in range(10):
test4.append(i)
print("Test 1:", test1)
print("Test 2:", test2)
print("Test 3:", test3)
print("Test 4:", test4)
print("test1 == test2 =", test1 == test2)
print("test2 == test3 =", test2 == test3)
print("test4 == test1 =", test4 == test1)
def test_initially_empty(self):
"""
A dynamic array is initially empty.
"""
a = DynamicArray()
self.assertTrue(a.is_empty())
