Using unittests in a hash map in python?

New to both stack overflow and Python; Anyway, I'm trying to make sure all my tests are working for this HashMap class, and it won't even run the tests - and for the life of me I can't figure out why. I believe it's related to the set item function. Any help would be greatly appreciated! Thanks!

my code so far:

from __future__ import print_function
import unittest


class HashSet:

#ignore indentation above this

def __init__(self, init=None):
    self.__limit = 10
    self.__items = [[] for _ in range(self.__limit)]
    self.__count = 0

    if init:
        for i in init:
            self.__setitem__(i[0], i[1])

def __len__(self):
    return self.__count
pass

def _flattened(self):
    return [item for inner in self.__items for item in inner]

def __iter__(self): return iter(self._flattened())
def __str__(self): return str(self._flattened())

def __hash(self, item):
    return (hash(item) % self.__limit)


def __rehash(self):
    # Double size and add existing
    old_items = self._flattened()
    self.__limit *= 2
    self.__items = [[]for _ in range(self.__limit)]
    for i in old_items:
        self.__setitem__(i[0], i[1])
    pass







def __contains__(self, key):
    # Return True or False
    index = self.__hash(key)
    while self.__items[index] is not None:
        if self.__items[index] is not None: return False
        for i in self.__items[index]:
            if i == key: return True
    return False


def __add(self, item):
    keyval = 0
    for i in item:
        keyval = i[0]
        value = i[1]

    key_hash = self.__hash(keyval)
    self.__count += 1

    self.__items[key_hash].append(item)

    load = (0.00 + self.__count) / self.__limit
    if load >= 0.75: self.__rehash()


def __setitem__(self, key, value):
    # Rehash when load > 75%

    key_hash = self.__hash(key)
    key_value = [key, value]
    loc = -1
    tempval = 0

    breakpoint = False

    while breakpoint == False:

        for i in self.__items[key_hash]:
            tempkey = i[0]
            tempval = i[1]
            if tempkey == key:
                breakpoint = True
                return False

        if loc < 0 and self.__items[key_hash] is None:
            loc = key_hash
            breakpoint = True
        key_hash = (key_hash + 1) % self.__limit

    if loc < 0:
        loc = key_hash

    key_value = [loc, value]
    self.__add(key_value)

def __getitem__(self, key):
    # Return value associated with key
    tempval = 0
    index = self.__hash(key)
    for i in self.__items[index]:
        tempkey = i[0]
        tempval = i[1]
    return tempval
    pass

class test_HashSet(unittest.TestCase):
#ignore the lack of indentation
def test_empty(self):
    self.assertEqual(len(HashSet()), 0)
def test_add_one(self):
    s = HashSet()
    s[1] = "one"
    self.assertEquals(len(s), 1)
    self.assertEquals(s[1], "one")
def test_add_two(self):
    s = HashSet()
    s[1] = "one"
    s[2] = "two"
    self.assertEquals(len(s), 2)
def test_add_twice(self):
    s = HashSet()
    s[1] = "one"
    s[1] = "one"
    self.assertEquals(len(s), 1)
def test_remove(self):
    s = HashSet()
    s["one"] = 1
    del s["one"]
    self.assertRaises(KeyError, lambda: s.__delitem__("two"))
    # this doesn't work:
    # self.assertRaises(KeyError, lambda: del s["two"])
    self.assertEquals(len(s), 0)
def test_one_in(self):
    s = HashSet()
    s["one"] = 1
    self.assertTrue("one" in s)
    self.assertFalse("two" in s)
    self.assertRaises(KeyError, lambda: s[0])
def test_collide(self):
    s = HashSet()
    s[0] = "zero"
    s[10] = "ten"
    self.assertEquals(len(s), 2)
    self.assertTrue(0 in s)
    self.assertTrue(10 in s)
    self.assertFalse(20 in s)
def test_rehash(self):
    s = HashSet()
    s[0] = "zero"; s[10] = "ten"; s[1] = "one"; s[2] = "two"
    s[3] = "three"; s[4] = "four"; s[5] = "five"; s[6] = "six"
    s[7] = "seven"; s[8] = "eight"; s[9] = "nine"; s[11] = "eleven"
    self.assertEquals(len(s), 12)
    expected = 
'''[[0, 'zero'], [1, 'one'], [2, 'two'], [3, 'three'], 
[4, 'four'], [5, 'five'], [6, 'six'], [7, 'seven'], 
[8, 'eight'], [9, 'nine'], [10, 'ten'], [11, 'eleven']]'''
    self.assertEquals(str(s), expected)
    t = HashSet(s)
    self.assertEquals(str(t), expected)
def test_store_false(self):
    s = HashSet()
    s[1] = False
    self.assertTrue(1 in s)
    self.assertFalse(s[1])
def test_store_none(self):
    s = HashSet()
    s[1] = None
    self.assertTrue(1 in s)
    self.assertEquals(s[1], None)
def test_none_key(self):
    s = HashSet()
    s[None] = 1
    self.assertTrue(None in s)
    self.assertEquals(s[None], 1)
def test_False_key(self):
    s = HashSet()
    s[False] = 1
    self.assertTrue(False in s)
    self.assertEquals(s[False], 1)