from unittest import TestCase
import sys
from random import randint

from nose.tools import raises

from softwaretesting import fixedsizequeue


MAXINT = sys.maxint
MININT = -sys.maxint - 1


class TestFixedCheckRep(TestCase):
def setUp(self):
self.size = randint(1, 100)
self.items = [randint(MININT, MAXINT) for item in range(self.size)]
self.q = fixedsizequeue.FixedsizeQueue(self.size)
return

def check_fail_reset(self):
"""
        Checks if the check_rep fails then resets the q
        """
print("Testing: {0}".format(self.q))
self.assertRaises(AssertionError, self.q.check_representation)
self.q.reset()
print("Passed: {0}".format(self.q))
return

def test_okay(self):
"""
        The enqueue takes a single integer and returns True if added.
        """
self.q.check_representation()
return

@raises(AssertionError)
def test_enqueue_wraparound_error(self):
"""
        The tail should wrap around when it fills
        """
self.q.reset()
for item in self.items:
self.q.enqueue(item)
self.q.tail = 1
self.q.check_representation()
return

@raises(AssertionError)
def test_dequeue_wraparound_error(self):
"""
        After emptying the queue, the head should be 0
        """
self.q.reset()
for item in self.items:
self.q.enqueue(item)
for item in self.items:
self.q.dequeue()
self.q.head = 1
self.q.check_representation()
return

def test_negative_error(self):
"""
        The properties of the queue should never become negative.
        """
self.q.reset()
value = -1 * abs(self.items[0])
self.q.check_representation()
self.q.head = value
self.check_fail_reset()
self.q.tail = value
self.check_fail_reset()
self.q.head = value
self.check_fail_reset()


self.q.size = value
self.check_fail_reset()

self.q.max = value
self.check_fail_reset()
return

def test_negative_offset_error(self):
self.q.reset()
self.q.check_representation()
value  = -1 * abs(self.items[0])
self.q.head += value
self.q.size -= value
self.check_fail_reset()

self.q.head -= value
self.q.size += value
self.check_fail_reset()
return
# end class TestCheckRep

def check_representation(self):
    """
    Checks that the internal representation is correct.

    :raise: AssertionError if an error is found.
    """
    for attribute in (self.max, self.head, self.size):
        assert attribute >= 0, "{0} shouldn't be negative. ({1})".format(attribute, str(self))
    assert ((self.head + self.size) % self.max == self.tail), str(self)
    return

1. Create Clean Code -- code for which you can:
   • describe exactly what it does
   • describe exactly how it interacts with other entities
2. Minimize Threads
3. Minimize Global Variables -- these create implicit inputs to any software in the same module.
4. Reduce references and pointers.
5. Maximize Assertions

from unittest import TestCase
import sys
from random import randint

from nose.tools import raises

from softwaretesting import fixedsizequeue


MAXINT = sys.maxint
MININT = -sys.maxint - 1


class TestFixedSizeQueue(TestCase):
def setUp(self):
self.size = 10
self.items = [randint(MININT, MAXINT) for item in range(self.size)]
self.q = fixedsizequeue.FixedsizeQueue(self.size)
return

def test_enqueue(self):
"""
        The enqueue takes a single integer and returns True if added.
        """
self.q.reset()
self.assertFalse(self.q.full())
for index, item in enumerate(self.items):
self.assertTrue(self.q.enqueue(item))
self.assertEqual(index + 1, self.q.size)
self.assertEqual(item, self.q.data[index])
self.assertEqual((index + 1) % len(self.items), self.q.tail)
self.assertFalse(self.q.empty())
self.assertTrue(self.q.full())
return

def test_dequeue(self):
"""
        The dequeue returns the oldest item or None.
        """
self.q.reset()
self.assertIsNone(self.q.dequeue())
self.assertEqual(0, self.q.size)
for item in self.items:
self.q.enqueue(item)

for expected in self.items:
actual = self.q.dequeue()
self.assertEqual(expected, actual)
self.assertTrue(self.q.empty())
self.assertEqual(0, self.q.head)
return

def test_reset(self):
"""
        The reset resets the pointers and count
        """
self.q.enqueue(9)
self.q.enqueue(8)
self.q.dequeue()
self.q.reset()
self.assertTrue(self.q.empty())
self.assertEqual(0, self.q.size)
self.assertEqual(0, self.q.tail)
self.assertEqual(0, self.q.head)
return

def test_empty(self):
"""
        If the queue is empty dequeue returns False and does nothing.
        """
q = fixedsizequeue.FixedsizeQueue(3)
self.assertTrue(q.empty())
q.enqueue(randint(MININT, MAXINT))
self.assertFalse(q.empty())
q.dequeue()
self.assertTrue(q.empty())
return

def test_overfull(self):
"""
        The array doesn't add items once full
        """
self.q.reset()

for item in self.items:
self.q.enqueue(item)
self.assertEqual(0, self.q.tail)
self.assertTrue(self.q.full())
self.assertEqual(len(self.items), self.q.size)
self.assertFalse(self.q.enqueue(1))
self.assertEqual(len(self.items), self.q.size)
self.assertEqual(self.q.size, self.q.max)

for item in self.items:
self.assertEqual(item, self.q.dequeue())
self.assertTrue(self.q.empty())

return

@raises(TypeError)
def test_non_int(self):
"""
        The array has to be homogeneous.
        """
self.q.enqueue(1.0)
return
# end class TestFixedSizeQueue