예제 #1
0
 def testInsertRow(self):
     q1 = LinkedMatrix(2, 3, "t")
     x1, y1 = q1.dimensions
     q1.insertRow(0)
     x2, y2 = q1.dimensions
     self.assertEquals(x1, x2, "inserting row: a new column appeared from nowhere!")
     self.assertNotEquals(y1, y2, "inserting row: dimensions didn't change")
     self.assertEquals(y1 + 1, y2, "inserting row: wrong new dimensions")
예제 #2
0
 def testInsertRow(self):
     q1 = LinkedMatrix(2, 3, "t")
     x1, y1 = q1.dimensions
     q1.insertRow(0)
     x2, y2 = q1.dimensions
     self.assertEquals(
         x1, x2, "inserting row: a new column appeared from nowhere!")
     self.assertNotEquals(y1, y2, "inserting row: dimensions didn't change")
     self.assertEquals(y1 + 1, y2, "inserting row: wrong new dimensions")
예제 #3
0
 def testRemoveColumn(self):
     q1 = LinkedMatrix(3, 4, "t")
     q1[(1, 0)] = "should be removed"
     x1, y1 = q1.dimensions
     q1.removeColumn(1)
     x2, y2 = q1.dimensions
     self.assertEquals(y1, y2, "deleting column: a row disappeared!")
     self.assertNotEquals(x1, x2, "deleting column: dimensions didn't change")
     self.assertEquals(x1 - 1, x2, "deleting column: wrong new dimensions")
     self.assertNotEquals(q1[(1, 0)], "should be removed",
         "deleting column: old column still remains")
예제 #4
0
 def testRemoveRow(self):
     q1 = LinkedMatrix(2, 3, "t")
     q1[(0, 1)] = "should be removed"
     x1, y1 = q1.dimensions
     q1.removeRow(1)
     x2, y2 = q1.dimensions
     self.assertEquals(x1, x2, "deleting row: a column disappeared!")
     self.assertNotEquals(y1, y2, "deleting row: dimensions didn't change")
     self.assertEquals(y1 - 1, y2, "deleting row: wrong new dimensions")
     self.assertNotEquals(q1[(0, 1)], "should be removed",
         "deleting row: old row still remains")
예제 #5
0
 def testRemoveRow(self):
     q1 = LinkedMatrix(2, 3, "t")
     q1[(0, 1)] = "should be removed"
     x1, y1 = q1.dimensions
     q1.removeRow(1)
     x2, y2 = q1.dimensions
     self.assertEquals(x1, x2, "deleting row: a column disappeared!")
     self.assertNotEquals(y1, y2, "deleting row: dimensions didn't change")
     self.assertEquals(y1 - 1, y2, "deleting row: wrong new dimensions")
     self.assertNotEquals(q1[(0, 1)], "should be removed",
                          "deleting row: old row still remains")
예제 #6
0
 def testRemoveColumn(self):
     q1 = LinkedMatrix(3, 4, "t")
     q1[(1, 0)] = "should be removed"
     x1, y1 = q1.dimensions
     q1.removeColumn(1)
     x2, y2 = q1.dimensions
     self.assertEquals(y1, y2, "deleting column: a row disappeared!")
     self.assertNotEquals(x1, x2,
                          "deleting column: dimensions didn't change")
     self.assertEquals(x1 - 1, x2, "deleting column: wrong new dimensions")
     self.assertNotEquals(q1[(1, 0)], "should be removed",
                          "deleting column: old column still remains")
예제 #7
0
    def setUp(self):
        self.empty = LinkedMatrix(0, 0, None)
        self.expected = [[row * 6 + col for col in range(5)]
                         for row in range(6)]

        # flatten the expected values from self.expected (stored as nested
        # lists) as one long list
        self.flatExpected = [
            item for sublist in self.expected for item in sublist
        ]

        self.q = LinkedMatrix(5, 6, row * 6 + col)
        for row in range(6):
            for col in range(5):
                self.q[(col, row)] = row * 6 + col
예제 #8
0
 def testOneRowMatrix(self):
     ok = False
     try:
         q1 = LinkedMatrix(5, 1, "t")
         ok = True
     except:
         pass
     finally:
         self.assertTrue(ok, "one-row matrix: failed to construct")
예제 #9
0
 def testOneColumnMatrix(self):
     ok = False
     try:
         q1 = LinkedMatrix(1, 5, "t")
         ok = True
     except:
         pass
     finally:
         self.assertTrue(ok, "one-column matrix: failed to construct")
예제 #10
0
    def testInsertAndDeleteRow2(self):
        q1 = LinkedMatrix(2, 3, "t")
        strBefore = str(q1)
        d = q1.dimensions
        q1.removeRow(1)
        strDuring = str(q1)
        q1.insertRow(1)
        strAfter = str(q1)
        self.assertEquals(d, q1.dimensions,
            "inserting & deleting rows: dimensions were not updated")
        self.assertNotEquals(strBefore, strDuring,
            "inserting & deleting rows: nothing changed during delete")
        message = '''inserting & deleting rows: values changed unexpectedly
before we deleted, the test matrix contained:
{}
after we deleted, the test matrix contained:
{}
after we inserted, the test matrix contained:
{}'''
        message = message.format(strBefore, strDuring, strAfter)
        self.assertEquals(strBefore, strAfter, message)
예제 #11
0
class TestLinkedMatrix(unittest.TestCase):
	def setUp(self):
		self.x = 5
		self.y = 5
		self.lm = LinkedMatrix(self.x, self.y, 7)

	def test_str(self):
		self.assertEquals(str(self.lm), "7 7 7 7 7 \n7 7 7 7 7 \n7 7 7 7 7 \n7 7 7 7 7 \n7 7 7 7 7 \n")

	def test_getitem(self):
		self.assertEquals(self.lm[(3,2)], 7)

	def test_setitem(self):
		self.lm[(3,2)] = 17
		self.assertEquals(self.lm[(3,2)], 17)

	def test_iter(self):
		self.lm[(3,2)] = 17
		tr = [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 17, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7]
		tl = []
		for it in self.lm:
			tl.append(it)	
		self.assertEquals(tl, tr)

	def test_insertRowAfter(self):
		self.lm[(4,4)] = 23
		self.lm.insertRowAfter(2)
		self.assertEquals(self.lm[(4,5)], 23)

	def test_insertColumnAfter(self):
		self.lm[(4,4)] = 23
		self.lm.insertColumnAfter(3)
		self.assertEquals(self.lm[(5,4)], 23)

	def test_removeRowAfter(self):
		self.lm[(4,4)] = 23
		self.lm.removeRowAfter(2)
		self.assertEquals(self.lm[(4,3)], 23)
	
	def test_removeColumnAfter(self):
		self.lm[(4,4)] = 23
		self.lm.removeColumnAfter(1)
		self.assertEquals(self.lm[(3,4)], 23)
예제 #12
0
    def testInsertAndDeleteRow2(self):
        q1 = LinkedMatrix(2, 3, "t")
        strBefore = str(q1)
        d = q1.dimensions
        q1.removeRow(1)
        strDuring = str(q1)
        q1.insertRow(1)
        strAfter = str(q1)
        self.assertEquals(
            d, q1.dimensions,
            "inserting & deleting rows: dimensions were not updated")
        self.assertNotEquals(
            strBefore, strDuring,
            "inserting & deleting rows: nothing changed during delete")
        message = '''inserting & deleting rows: values changed unexpectedly
before we deleted, the test matrix contained:
{}
after we deleted, the test matrix contained:
{}
after we inserted, the test matrix contained:
{}'''
        message = message.format(strBefore, strDuring, strAfter)
        self.assertEquals(strBefore, strAfter, message)
예제 #13
0
 def testStr(self):
     q1 = LinkedMatrix(1, 1)
     s = str(q1)
     self.assertIsInstance(
         s, str, "str: string/print method did not give a valid string")
예제 #14
0
 def testZeroMatrix(self):
     q1 = LinkedMatrix(0, 0, None)
     self.assertIsNone(
         q1.headnode,
         "zero-size matrix: headnode pointed to something. Perhaps it should point to nothing?"
     )
예제 #15
0
 def testSetItem(self):
     q1 = LinkedMatrix(4, 3, "t")
     q1[(3, 2)] = "changed"
     self.assertEquals(q1[(3, 2)], "changed",
                       "setitem: could not set a node value")
예제 #16
0
	def setUp(self):
		self.x = 5
		self.y = 5
		self.lm = LinkedMatrix(self.x, self.y, 7)
예제 #17
0
def construct( size ):
    cnt = cntX = cntY = 0
    global X, Y
    cave = LinkedMatrix(size + 2, size + 2, ".")
    cave.head.value = '#'
    tmpNode = cave.head
    

    # Construct walls
    while cntX <= size:
        tmpNode = tmpNode.east
        tmpNode.value = '#'
        cntX += 1
    while cntY <= size:
        tmpNode = tmpNode.south
        tmpNode.value = '#'
        cntY += 1
    while cntX > 0:
        tmpNode = tmpNode.west
        tmpNode.value = '#'
        cntX -= 1
    while cntY >= 0:
        tmpNode = tmpNode.north
        tmpNode.value = '#'
        cntY -= 1

    # Place entrance
    X = random.randrange(1, size)
    Y = random.randrange(1, size)
    cave[(X, Y)] = '^'
    
    # Place pits
    while cnt < pits:
        cntX = random.randrange(1, size)
        cntY = random.randrange(1, size)
        if cave[ (cntX, cntY) ] == '.':
            cave[(cntX, cntY)] = 'o'
            cnt += 1

    cnt = 0
    
    # Place weapons
    while cnt < weapons:
        cntX = random.randrange(1, size)
        cntY = random.randrange(1, size)
        if cave[ (cntX, cntY) ] == '.':
            cave[(cntX, cntY)] = 'W'
            cnt += 1

    cnt = 0
    # Place gold
    while cnt < gold:
        cntX = random.randrange(1, size)
        cntY = random.randrange(1, size)
        if cave[ (cntX, cntY) ] == '.':
            cave[(cntX, cntY)] = '$'
            cnt += 1

    cnt = 0

    # Place wumpus monsters
    while cnt < wumpus:
        cntX = random.randrange(1, size)
        cntY = random.randrange(1, size)
        if cave[ (cntX, cntY) ] == '.':
            cave[(cntX, cntY)] = 'm'
            cnt += 1

    return cave