def test_peek():
    ''' Simple test of the peek method. '''
    queue = Queue(10)
    queue.enqueue(1)
    assert queue.peek() == 1

    queue.dequeue()
    queue.enqueue(4)
    assert queue.peek() == 4
def test_enqueue_object():
    queue = Queue(0)
    queue.enqueue(HelperClass("abc"))
    queue.enqueue(HelperClass("def"))
    assert queue.dequeue().value == "abc"
    assert queue.dequeue().value == "def"

    queue.enqueue(HelperClass("ghi"))
    assert queue.dequeue().value == "ghi"
def none_test_helper(max: int):
    queue = Queue(max)

    with pytest.raises(Exception):
        queue.dequeue()

    queue.enqueue(1)
    queue.enqueue(None)

    assert queue.count == 2
    assert queue.dequeue() == 1
    assert queue.dequeue() is None
    assert queue.count == 0
def test_disk_only():
    queue = Queue(0)
    total_count = 100
    halfway = 100 // 2

    queue.enqueue(0)
    assert queue.on_disk_count == 1
    assert queue.on_disk_count == queue.count
    assert queue.in_memory_count == 0

    for i in range(1, total_count):
        queue.enqueue(i)
        assert queue.on_disk_count == i + 1
        assert queue.on_disk_count == queue.count
        assert queue.in_memory_count == 0

    for i in range(0, halfway):
        peek = queue.peek()
        assert i == peek
        assert i == queue.dequeue()
        assert queue.on_disk_count == total_count - (i + 1)
        assert queue.on_disk_count == queue.count
        assert queue.in_memory_count == 0

    queue.enqueue(total_count)
    assert queue.on_disk_count == halfway + 1
    assert queue.on_disk_count == queue.count
    assert queue.in_memory_count == 0

    for i in range(halfway, total_count + 1):
        peek = queue.peek()
        assert i == peek
        assert i == queue.dequeue()
        assert queue.on_disk_count == total_count - i
        assert queue.on_disk_count == queue.count
        assert queue.in_memory_count == 0

    assert queue.count == 0
    assert queue.on_disk_count == 0
    assert queue.in_memory_count == 0

    with pytest.raises(Exception):
        queue.dequeue()
def test_negative_max():
    with pytest.raises(Exception) as e:
        Queue(-1)
def test_mixed():
    total_count = 100
    halfway = 100 // 2
    queue = Queue(halfway)

    queue.enqueue(0)
    assert queue.in_memory_count == 1
    assert queue.in_memory_count == queue.count
    assert queue.on_disk_count == 0

    for i in range(1, total_count):
        queue.enqueue(i)

        if i < halfway:
            assert queue.in_memory_count == i + 1
            assert queue.in_memory_count == queue.count
            assert queue.on_disk_count == 0
        else:
            assert queue.in_memory_count == halfway
            assert queue.on_disk_count == i - halfway + 1
            assert queue.count == queue.in_memory_count + queue.on_disk_count

    for i in range(0, halfway):
        peek = queue.peek()
        assert i == peek
        assert i == queue.dequeue()
        assert queue.in_memory_count == halfway
        assert queue.on_disk_count == halfway - (i + 1)
        assert queue.count == queue.in_memory_count + queue.on_disk_count

    queue.enqueue(total_count)
    assert queue.in_memory_count == halfway
    assert queue.on_disk_count == 1
    assert queue.count == queue.in_memory_count + queue.on_disk_count

    for i in range(halfway, total_count + 1):
        peek = queue.peek()
        assert i == peek
        assert i == queue.dequeue()
        assert queue.count == queue.in_memory_count
        assert queue.on_disk_count == 0
        assert queue.in_memory_count == total_count - i

    assert queue.count == 0
    assert queue.on_disk_count == 0
    assert queue.in_memory_count == 0

    with pytest.raises(Exception):
        queue.dequeue()
Exemple #7
0
 def setUp(self):
     self.queue = Queue(5)
Exemple #8
0
class TestQueue(unittest.TestCase):
    def setUp(self):
        self.queue = Queue(5)

    def test_peek_empty_queue(self):
        self.assertRaises(AssertionError, self.queue.peek)

    def test_peek_non_empty_queue(self):
        for i in [1, 43, 7]:
            self.queue.enqueue(i)
        self.assertEqual(self.queue.peek(), 1)

    def test_enqueue_one_element(self):
        self.queue.enqueue(4)
        self.assertEqual(self.queue.peek(), 4)
        self.assertEqual(self.queue.in_memory_count, 1)

    def test_enqueue_string(self):
        self.queue.enqueue("Hello")
        self.assertEqual(self.queue.peek(), "Hello")

    def test_enqueue_when_full(self):
        for i in [4, 98, 51, 5, 8, 90, 43, 89]:
            self.queue.enqueue(i)
        self.assertEqual(self.queue.on_disk_count, 3)

    def test_full_queue(self):
        for i in [7, 2, 4, 12, 3, 9]:
            self.queue.enqueue(i)
        self.assertTrue(self.queue.is_full)
        self.assertEqual(self.queue.in_memory_count, 5)
        self.assertEqual(self.queue.on_disk_count, 1)
        self.assertEqual(self.queue.count, 6)

    def test_empty_queue_true(self):
        self.assertTrue(self.queue.is_empty)

    def test_empty_queue_false(self):
        self.queue.enqueue(9)
        self.assertFalse(self.queue.is_empty)

    def test_dequeue_empty_queue(self):
        self.assertRaises(AssertionError, self.queue.dequeue)

    def test_dequeue_unfull_queue(self):
        for i in [4, 98, 51]:
            self.queue.enqueue(i)
        self.assertEqual(self.queue.dequeue(), 4)
        self.assertEqual(self.queue.peek(), 98)
        self.assertEqual(self.queue.in_memory_count, 2)
        self.assertEqual(self.queue.on_disk_count, 0)

    def test_dequeue_full_queue(self):
        for i in [12, 83, 51, 100, 8, 90, 43, 89]:
            self.queue.enqueue(i)
        self.assertEqual(self.queue.dequeue(), 12)
        self.assertEqual(self.queue.peek(), 83)
        self.assertEqual(self.queue.in_memory_count, 5)
        self.assertEqual(self.queue.on_disk_count, 2)

    def test_dequeue_one_element(self):
        self.queue.enqueue(4)
        self.assertEqual(self.queue.dequeue(), 4)
        self.assertRaises(AssertionError, self.queue.peek)

    def test_non_int_max_memory(self):
        self.assertRaises(ValueError, Queue, "6")