from ivoire import describe, context
from expects import expect
from expects.matchers.built_in import equal, be_below_or_equal
from src.sorting_algorithms.insertion_sort import insertion_sort
import random
with describe(insertion_sort) as it:
@it.before
def before(test):
unodered_list = [random.randrange(-1000, 1000) for x in xrange(100)]
test.manual_sorted_list, test.swaps = insertion_sort(unodered_list)
test.automatic_sorted_list = sorted(unodered_list)
test.worst_case = len(test.manual_sorted_list)**2
with it('sorts the list') as test:
expect(test.manual_sorted_list).to(equal(test.automatic_sorted_list))
with it('performs better/equal to O(n**2) in the worst case') as test:
expect(test.swaps).to(be_below_or_equal(test.worst_case))
from ivoire import describe, context
from expects import expect
from expects.matchers.built_in import equal, be_below_or_equal
from src.searching_algorithms.breadth_first_search import breadth_first_search
import random
with describe(breadth_first_search) as it:
@it.before
def before(test):
test.adjacency_list = [
[1, 2, 3, 4],
[0, 3],
[0],
[0, 1, 5, 7],
[0, 7],
[3, 6, 7],
[5],
[3, 4, 5],
]
with it('makes a breadth first traversal') as test:
response = breadth_first_search(test.adjacency_list, 0)
expected_response = [{
'predecessor': None,
'distance': 0
}, {
'predecessor': 0,
'distance': 1
}, {
from ivoire import describe, load
from ivoire.spec.util import ExampleWithPatch, mock
with describe(load.load_by_name, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.path_exists = test.patchObject(load.os.path, "exists")
test.load_from_path = test.patchObject(load, "load_from_path")
test.__import__ = test.patchObject(load, "__import__", create=True)
with it("loads paths") as test:
test.path_exists.return_value = True
load.load_by_name("foo")
test.load_from_path.assert_called_once_with("foo")
with it("loads modules") as test:
test.path_exists.return_value = False
load.load_by_name("foo")
test.__import__.assert_called_once_with("foo")
with describe(load.load_from_path, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.isdir = test.patchObject(load.os.path, "isdir")
test.load_source = test.patchObject(load.imp, "load_source")
test.path = "foo/bar"
with it("discovers specs if given a directory") as test:
test.isdir.return_value = True
A simple calculator specification.
"""
from ivoire import describe
class Calculator(object):
def add(self, x, y):
return x + y
def divide(self, x, y):
return x / y
with describe(Calculator) as it:
@it.before
def before(test):
test.calc = Calculator()
with it("adds two numbers") as test:
test.assertEqual(test.calc.add(2, 4), 6)
with it("divides two numbers") as test:
test.assertEqual(test.calc.divide(8, 4), 2)
with it("doesn't divide by zero") as test:
with test.assertRaises(ZeroDivisionError):
test.calc.divide(8, 0)
with it("multiplies two numbers") as test:
from ivoire import describe, context
from expects import expect
from src.queues.queue_list import QueueList
from src.queues.queue_interface import QueueInterface
with describe(QueueList) as it:
@it.before
def before(test):
test.queue = QueueList()
with it('inherits from the QueueInterface') as test:
expect(test.queue).to.be.a(QueueInterface)
with context(QueueList.__init__):
with it('creates an empty queue') as test:
expect(test.queue.list).to.be.empty
with context(QueueList.isEmpty):
with it('returns true when queue is empty') as test:
expect(test.queue.isEmpty()).to.be.true
with it('returns false when queue is not empty') as test:
test.queue.insert(1)
expect(test.queue.isEmpty()).to.be.false
with context(QueueList.insert):
with it('adds a new node at the end of the queue') as test:
test.queue.insert(2)
test.queue.insert(3)
expect(test.queue.list[-1].cargo).to.equal(3)
from ivoire import describe, context
from expects import expect
from src.list.node import Node
with describe(Node) as it:
@it.before
def before(test):
nextNode = Node(1)
test.node = Node(2, nextNode)
with context(Node.__init__):
with it('assign a cargo value') as test:
expect(test.node.cargo).to.be(2)
with it('link to another Node object') as test:
expect(test.node.next).to.be.a(Node)
with context(Node.__str__):
with it('set its representation to the cargo value') as test:
expect(test.node.__str__()).to.equal(str(test.node.cargo))
with context(Node.__cmp__):
with it('compares its cargo value to another one') as test:
expect(test.node).to.be.above(Node(1))
with it('returns True when greater') as test:
expect(test.node > Node(0)).to.be.true
with it('returns False when lesser') as test:
expect(test.node > Node(3)).to.be.false
with it('returns False when equal') as test:
from ivoire import describe, context
from expects import expect
from src.list.unordered_linked_list import UnorderedLinkedList
from src.list.node import Node
with describe(UnorderedLinkedList) as it:
@it.before
def before(test):
test.list = UnorderedLinkedList()
with context(UnorderedLinkedList.__init__):
with it('create an empty list') as test:
expect(test.list.length).to.be(0)
expect(test.list.head).to.be.none
with context(UnorderedLinkedList.isEmpty):
with it('return true if the list is empty') as test:
expect(test.list.isEmpty()).to.be.true
with context(UnorderedLinkedList.addNode):
with it('does not add a new item when it is None') as test:
test.list.addNode(None)
expect(test.list.head).to.be.none
with it('create a Node object and add it to the list') as test:
test.list.addNode(33)
expect(test.list.head).to.be.a(Node)
with it('increments the length of the linked list') as test:
test.list.addNode(22)
expect(test.list.length).to.be(1)
from ivoire import describe, load
from ivoire.spec.util import ExampleWithPatch, mock
with describe(load.load_by_name, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.path_exists = test.patchObject(load.os.path, "exists")
test.load_from_path = test.patchObject(load, "load_from_path")
test.__import__ = test.patchObject(load, "__import__", create=True)
with it("loads paths") as test:
test.path_exists.return_value = True
load.load_by_name("foo")
test.load_from_path.assert_called_once_with("foo")
with it("loads modules") as test:
test.path_exists.return_value = False
load.load_by_name("foo")
test.__import__.assert_called_once_with("foo")
with describe(load.load_from_path, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.isdir = test.patchObject(load.os.path, "isdir")
test.load_source = test.patchObject(load.imp, "load_source")
test.path = "foo/bar"
with it("discovers specs if given a directory") as test:
test.isdir.return_value = True
"""
A spec for the next() standard library function.
"""
from ivoire import describe
with describe(next) as it:
with it("returns the next element of an iterable") as test:
iterable = iter(range(5))
test.assertEqual(next(iterable), 0)
with it("raises StopIteration if no elements are found") as test:
with test.assertRaises(StopIteration):
next(iter([]))
with it("returns default instead of StopIteration if given") as test:
default = "a default"
test.assertEqual(next(iter([]), default), default)
from ivoire import describe, context
from expects import expect
from src.trees.tree import Tree
with describe(Tree) as it:
@it.before
def before(test):
test.defaultCargo = 2.22
test.tree = Tree(test.defaultCargo)
with context(Tree.__init__):
with it('creates a new tree with a cargo value') as test:
expect(test.tree).to.have.property('cargo', test.defaultCargo)
with it('creates a new tree with an empty left node') as test:
expect(test.tree).to.have.property('left', None)
with it('creates a new tree with an empty right node') as test:
expect(test.tree).to.have.property('right', None)
with context(Tree.__str__):
with it('returns the representation of the tree: its cargo') as test:
expect(test.tree.__str__()).to.equal(str(test.tree.cargo))
with context(Tree.getCargo):
with it('returns the cargo of the tree') as test:
expect(test.tree.getCargo()).to.equal(test.tree.cargo)
with context(Tree.getLeft):
with it('returns the left node of the tree') as test:
leftTreeNode = Tree(22)
from ivoire import describe, context
from expects import expect
from src.new_data_type.gcd import gcd
with describe(gcd) as it:
with context('when x divides y evenly'):
with it('y is the gdc') as test:
expect(gcd(2, 2)).to.equal(2)
with context('when x does not divides y evenly'):
with it('find the gdc of y and the reminder of x divided by y'
) as test:
expect(gcd(9, 4)).to.equal(gcd(4, 9 % 4))
from ivoire import describe, result, run
from ivoire.spec.util import ExampleWithPatch, mock
import ivoire
with describe(run.parse, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.specs = ["a_spec"]
with it("sets reasonable defaults") as test:
should_color = test.patchObject(run, "should_color")
arguments = run.parse(test.specs)
test.assertEqual(vars(arguments), {
"Formatter" : result.DotsFormatter,
"color" : should_color.return_value,
"exitfirst" : False,
"specs" : test.specs,
"func" : run.run,
"verbose" : False,
})
should_color.assert_called_once_with("auto")
with it("can exitfirst") as test:
arguments = run.parse(["--exitfirst"] + test.specs)
test.assertTrue(arguments.exitfirst)
arguments = run.parse(["-x"] + test.specs)
test.assertTrue(arguments.exitfirst)
with it("can be verbose") as test:
from ivoire import describe, context
from expects import expect
from src.queues.helper import Helper
with describe(Helper) as it:
@it.before
def before(test):
test.list = [22,100,2,98,0]
with context(Helper.remove_item_from_list_at_index):
with it('remove an element from a list at the given index') as test:
Helper.remove_item_from_list_at_index(test.list, 2)
expect(test.list[2]).to.equal(98)
with context(Helper.get_max_item_index):
with it('find and return the index of the element with the max value in the list') as test:
expect(Helper.get_max_item_index(test.list)).to.equal(1)
from ivoire import describe, context
from expects import expect
from expects.matchers.built_in import equal, be_below_or_equal
from src.sorting_algorithms.selection_sort import selection_sort
import random
with describe(selection_sort) as it:
@it.before
def before(test):
unodered_list = [random.randrange(-1000, 1000) for x in xrange(100)]
test.manual_sorted_list = selection_sort(unodered_list)
test.automatic_sorted_list = sorted(unodered_list)
with it('sorts the list') as test:
expect(test.manual_sorted_list).to(equal(test.automatic_sorted_list))
from ivoire import describe, context
from expects import expect
from src.new_data_type.gcd import gcd
with describe(gcd) as it:
with context('when x divides y evenly'):
with it('y is the gdc') as test:
expect(gcd(2,2)).to.equal(2)
with context('when x does not divides y evenly'):
with it('find the gdc of y and the reminder of x divided by y') as test:
expect(gcd(9,4)).to.equal(gcd(4,9%4))
from io import StringIO
import sys
from ivoire import describe, result
from ivoire.compat import indent
from ivoire.spec.util import ExampleWithPatch, mock
def fake_exc_info():
try:
raise Exception("Used to construct exc_info")
except Exception:
return sys.exc_info()
with describe(result.ExampleResult, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.formatter = mock.Mock()
test.result = result.ExampleResult(test.formatter)
test.test = mock.Mock()
test.exc_info = fake_exc_info()
def assertShown(test, output):
test.formatter.show.assert_called_with(output)
with it("enters groups") as test:
test.result.enterGroup(test.test.group)
test.formatter.enter_group.assert_called_once_with(test.test.group)
assertShown(test, test.formatter.enter_group.return_value)
from ivoire import describe, transform
from ivoire.spec.util import ExampleWithPatch, mock
def dump(node): # pragma: no cover
return(dedent("""
--- Dumping Node ---
{}
--- End ---
""".format(ast.dump(node))))
with describe(transform.ExampleTransformer, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.transformer = transform.ExampleTransformer()
def execute(test, source):
test.globals, test.locals = {}, {}
test.node = ast.parse(dedent(source))
test.transformed = test.transformer.transform(test.node)
compiled = compile(test.transformed, "<testing transform>", "exec")
try:
exec(compiled, test.globals, test.locals)
except Exception: # pragma: no cover
print(dump(test.transformed))
raise
from ivoire import describe, result, run
from ivoire.spec.util import ExampleWithPatch, mock
import ivoire
with describe(run.parse, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.specs = ["a_spec"]
with it("sets reasonable defaults") as test:
should_color = test.patchObject(run, "should_color")
arguments = run.parse(test.specs)
test.assertEqual(
vars(arguments), {
"Formatter": result.DotsFormatter,
"color": should_color.return_value,
"exitfirst": False,
"specs": test.specs,
"func": run.run,
"verbose": False,
})
should_color.assert_called_once_with("auto")
with it("can exitfirst") as test:
arguments = run.parse(["--exitfirst"] + test.specs)
test.assertTrue(arguments.exitfirst)
arguments = run.parse(["-x"] + test.specs)
test.assertTrue(arguments.exitfirst)
A simple calculator specification.
"""
from ivoire import describe
class Calculator(object):
def add(self, x, y):
return x + y
def divide(self, x, y):
return x / y
with describe(Calculator) as it:
@it.before
def before(test):
test.calc = Calculator()
with it("adds two numbers") as test:
test.assertEqual(test.calc.add(2, 4), 6)
with it("divides two numbers") as test:
test.assertEqual(test.calc.divide(8, 4), 2)
with it("doesn't divide by zero") as test:
with test.assertRaises(ZeroDivisionError):
test.calc.divide(8, 0)
from ivoire import describe, context
from expects import expect
from src.queues.priority_queue_list import PriorityQueueList
from src.queues.priority_queue_interface import PriorityQueueInterface
with describe(PriorityQueueList) as it:
@it.before
def before(test):
test.queue = PriorityQueueList()
with it('inherits from PriorityQueueInterface') as test:
expect(test.queue).to.be.a(PriorityQueueInterface)
with context(PriorityQueueList.__init__):
with it('creates an empty queue') as test:
expect(test.queue.items).to.be.empty
with context(PriorityQueueList.insert):
with it('add a new item at the end of the queue') as test:
test.queue.insert(22)
test.queue.insert(33)
expect(test.queue.items[-1]).to.equal(33)
with context(PriorityQueueList.remove):
with it('remove and return the item with the highest priority from the queue'
) as test:
test.queue.insert(55)
test.queue.insert(8)
test.queue.insert(100)
test.queue.insert(22)
from ivoire import describe, context
from expects import expect
from src.queues.linked_queue_improved import LinkedQueueImproved
from src.queues.queue_interface import QueueInterface
with describe(LinkedQueueImproved) as it:
@it.before
def before(test):
test.queue = LinkedQueueImproved()
with it('inherits from QueueInterface') as test:
expect(test.queue).to.be.a(QueueInterface)
with context(LinkedQueueImproved.__init__):
with it('creates an empty queue') as test:
expect(test.queue).to.have.property('length', 0)
expect(test.queue).to.have.property('head', None)
expect(test.queue).to.have.property('tail', None)
with context(LinkedQueueImproved.isEmpty):
with it('returns True when queue is empty') as test:
expect(test.queue.isEmpty()).to.be.true
with it('returns False when queue is not empty') as test:
test.queue.insert(88)
expect(test.queue.isEmpty()).to.be.false
with context(LinkedQueueImproved.insert):
with it('adds a new node to the end/tail of the queue') as test:
test.queue.insert(11)
test.queue.insert(22)
from ivoire import describe
from ivoire.manager import Context
from ivoire.spec.util import ExampleWithPatch, mock
with describe(Context, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.manager = mock.Mock()
test.context = Context("a test context", test.manager)
with it("calls its manager when used as a context manager") as test:
with test.context:
test.manager.enter.assert_called_once_with(test.context)
test.manager.exit.assert_called_once_with()
from ivoire import describe, context
from expects import expect
from src.new_data_type.fraction import Fraction
with describe(Fraction) as it:
@it.before
def before(test):
test.fraction = Fraction(2, 3)
test.other_fraction = Fraction(3, 2)
test.other_int = 3
test.fraction_equal = Fraction(2, 3)
test.fraction_almost_equal = Fraction(2, 4)
with context(Fraction.__init__):
with it('set the fraction numerator') as test:
expect(test.fraction.numerator).not_to.be.none
with it('set the fraction denominator') as test:
expect(test.fraction.denominator).not_to.be.none
with context(Fraction.__mul__):
with it('multiply a fraction by another one') as test:
expect(test.fraction * test.other_fraction).to.equal(Fraction(
1, 1))
with it('multiply a fraction by an int number') as test:
expect(test.fraction * test.other_int).to.equal(Fraction(2, 1))
from ivoire import describe, context
from expects import expect
from src.stack.stack_list import StackList
from src.stack.stack_interface import StackInterface
with describe(StackList) as it:
@it.before
def before(test):
test.stack = StackList()
with it('inherits from StackInterface') as test:
expect(test.stack).to.be.a(StackInterface)
with context(StackList.__init__):
with it('create an empty stack') as test:
expect(test.stack.items).to.be.empty
with context(StackList.push):
with it('add a new item to the end of the stack') as test:
item = 4
test.stack.push(item)
last_item = test.stack.items[-1]
expect(last_item).to.be(item)
with context(StackList.pop):
with it('remove and return the last added item from the stack') as test:
item = 4
test.stack.push(item)
last_item = test.stack.pop()
from ivoire import describe, context
from expects import expect
from src.new_data_type.fraction import Fraction
with describe(Fraction) as it:
@it.before
def before(test):
test.fraction = Fraction(2,3)
test.other_fraction = Fraction(3,2)
test.other_int = 3
test.fraction_equal = Fraction(2,3)
test.fraction_almost_equal = Fraction(2,4)
with context(Fraction.__init__):
with it('set the fraction numerator') as test:
expect(test.fraction.numerator).not_to.be.none
with it('set the fraction denominator') as test:
expect(test.fraction.denominator).not_to.be.none
with context(Fraction.__mul__):
with it('multiply a fraction by another one') as test:
expect(test.fraction * test.other_fraction).to.equal(Fraction(1,1))
with it('multiply a fraction by an int number') as test:
expect(test.fraction * test.other_int).to.equal(Fraction(2,1))
with it('multiply an int number by a fraction') as test:
expect(test.other_int * test.fraction).to.equal(Fraction(2,1))
from ivoire import describe, context
from expects import expect
from src.deque.deque_list import DequeList
from src.deque.deque_interface import DequeInterface
with describe(DequeList) as it:
@it.before
def before(test):
test.deque = DequeList()
with it('inherits from the DequeInterface') as test:
expect(test.deque).to.be.a(DequeInterface)
with context(DequeList.__init__):
with it('creates an empty deque') as test:
expect(test.deque.items).to.be.empty
with context(DequeList.isEmpty):
with it('returns true when deque is empty') as test:
expect(test.deque.isEmpty()).to.be.true
with it('returns false when deque is not empty') as test:
test.deque.insertFirst(10)
test.deque.insertLast(9)
expect(test.deque.isEmpty()).to.be.false
with context(DequeList.insertFirst):
with it('adds an item at the top of the deque') as test:
items = [11, 22, 33]
from ivoire import describe, context
from expects import expect
from src.deque.deque_list import DequeList
from src.deque.deque_interface import DequeInterface
with describe(DequeList) as it:
@it.before
def before(test):
test.deque = DequeList()
with it('inherits from the DequeInterface') as test:
expect(test.deque).to.be.a(DequeInterface)
with context(DequeList.__init__):
with it('creates an empty deque') as test:
expect(test.deque.items).to.be.empty
with context(DequeList.isEmpty):
with it('returns true when deque is empty') as test:
expect(test.deque.isEmpty()).to.be.true
with it('returns false when deque is not empty') as test:
test.deque.insertFirst(10)
test.deque.insertLast(9)
expect(test.deque.isEmpty()).to.be.false
with context(DequeList.insertFirst):
with it('adds an item at the top of the deque') as test:
items = [11,22,33]
topItem = items[-1]
from ivoire import describe, transform
from ivoire.spec.util import ExampleWithPatch
def dump(node): # pragma: no cover
return (dedent("""
--- Dumping Node ---
{}
--- End ---
""".format(ast.dump(node))))
with describe(transform.ExampleTransformer, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.transformer = transform.ExampleTransformer()
def execute(test, source):
test.globals, test.locals = {}, {}
test.node = ast.parse(dedent(source))
test.transformed = test.transformer.transform(test.node)
compiled = compile(test.transformed, "<testing transform>", "exec")
try:
exec(compiled, test.globals, test.locals)
except Exception: # pragma: no cover
print(dump(test.transformed))
from ivoire import describe, context
from expects import expect
from src.list.node import Node
with describe(Node) as it:
@it.before
def before(test):
nextNode = Node(1)
test.node = Node(2, nextNode)
with context(Node.__init__):
with it('assign a cargo value') as test:
expect(test.node.cargo).to.be(2)
with it('link to another Node object') as test:
expect(test.node.next).to.be.a(Node)
with context(Node.__str__):
with it('set its representation to the cargo value') as test:
expect(test.node.__str__()).to.equal(str(test.node.cargo))
with context(Node.__cmp__):
with it('compares its cargo value to another one') as test:
expect(test.node).to.be.above(Node(1))
with it('returns True when greater') as test:
expect(test.node > Node(0)).to.be.true
with it('returns False when lesser') as test:
expect(test.node > Node(3)).to.be.false
from ivoire import context, describe, ContextManager
from ivoire.manager import Context
from ivoire.spec.util import ExampleWithPatch, mock
with describe(ContextManager, Example=ExampleWithPatch) as it:
@it.before
def before(test):
test.result = mock.Mock()
test.manager = ContextManager(test.result)
test.context = test.manager.create_context("a test context")
with context(context):
with it("creates contexts") as test:
context = test.manager.create_context("a test context")
test.assertEqual(context, Context("a test context", test.manager))
with it("is a bit nasty and tries to get __name__s") as test:
def foo():
pass
context = test.manager.create_context(foo)
test.assertEqual(context, Context("foo", test.manager))
with it("starts off at a global context depth of 0") as test:
test.assertEqual(test.manager.context_depth, 0)
with it("enters and exits contexts") as test:
test.manager.enter(test.context)
test.result.enterContext.assert_called_once_with(test.context, depth=1)
from ivoire import describe, context
from expects import expect
from src.queues.linked_queue_improved import LinkedQueueImproved
from src.queues.queue_interface import QueueInterface
with describe(LinkedQueueImproved) as it:
@it.before
def before(test):
test.queue = LinkedQueueImproved()
with it('inherits from QueueInterface') as test:
expect(test.queue).to.be.a(QueueInterface)
with context(LinkedQueueImproved.__init__):
with it('creates an empty queue') as test:
expect(test.queue).to.have.property('length', 0)
expect(test.queue).to.have.property('head', None)
expect(test.queue).to.have.property('tail', None)
with context(LinkedQueueImproved.isEmpty):
with it('returns True when queue is empty') as test:
expect(test.queue.isEmpty()).to.be.true
with it('returns False when queue is not empty') as test:
test.queue.insert(88)
expect(test.queue.isEmpty()).to.be.false
with context(LinkedQueueImproved.insert):
with it('adds a new node to the end/tail of the queue') as test:
test.queue.insert(11)
from ivoire import describe, context
from expects import expect
from src.queues.linked_queue import LinkedQueue
with describe(LinkedQueue) as it:
@it.before
def before(test):
test.queue = LinkedQueue()
@it.after
def after(test):
test.queue = None
with context(LinkedQueue.__init__):
with it('creates an empty queue') as test:
expect(test.queue).to.have.property('length', 0)
expect(test.queue).to.have.property('head', None)
with context(LinkedQueue.isEmpty):
with it('return true if the queue is empty') as test:
expect(test.queue.isEmpty()).to.be.true
with it('returns false if the queue is not empty') as test:
test.queue.insert(7)
expect(test.queue.isEmpty()).to.be.false
with context(LinkedQueue.insert):
with it('add node at the end of the queue') as test:
test.queue.insert(1)
test.queue.insert(2)
test.queue.insert(7)
from ivoire import describe, context
from expects import expect
from src.queues.linked_priority_queue import PriorityQueueLinkedList
from src.queues.priority_queue_interface import PriorityQueueInterface
from src.list.node import Node
with describe(PriorityQueueLinkedList) as it:
@it.before
def before(test):
test.queue = PriorityQueueLinkedList()
with it('inherits from PriorityQueueInterface') as test:
expect(test.queue).to.be.a(PriorityQueueInterface)
with context(PriorityQueueLinkedList.__init__):
with it('creates an empty queue') as test:
expect(test.queue).to.have.property('length', 0)
expect(test.queue).to.have.property('head', None)
with context(PriorityQueueLinkedList.insert):
with it('when queue is empty, add a node at the top of the queue') as test:
test.queue.insert(100)
expect(test.queue).to.have.property('head', Node(100))
with it('increments the length of the queue') as test:
test.queue.insert(100)
expect(test.queue).to.have.property('length', 1)
with it('add a node at the queue in a position based on its priority') as test:
test.queue.insert(33)
test.queue.insert(2)
"""
A spec for the next() standard library function.
"""
from ivoire import describe
with describe(next) as it:
with it("returns the next element of an iterable") as test:
iterable = iter(range(5))
test.assertEqual(next(iterable), 0)
with it("raises StopIteration if no elements are found") as test:
with test.assertRaises(StopIteration):
next(iter([]))
with it("returns default instead of StopIteration if given") as test:
default = "a default"
test.assertEqual(next(iter([]), default), default)
from ivoire import describe, context
from expects import expect
from src.list.unordered_linked_list import UnorderedLinkedList
from src.list.node import Node
with describe(UnorderedLinkedList) as it:
@it.before
def before(test):
test.list = UnorderedLinkedList()
with context(UnorderedLinkedList.__init__):
with it('create an empty list') as test:
expect(test.list.length).to.be(0)
expect(test.list.head).to.be.none
with context(UnorderedLinkedList.isEmpty):
with it('return true if the list is empty') as test:
expect(test.list.isEmpty()).to.be.true
with context(UnorderedLinkedList.addNode):
with it('does not add a new item when it is None') as test:
test.list.addNode(None)
expect(test.list.head).to.be.none
with it('create a Node object and add it to the list') as test:
test.list.addNode(33)
expect(test.list.head).to.be.a(Node)
with it('increments the length of the linked list') as test:
test.list.addNode(22)
