def test_create():
ds = Disks(800, 800, 100, 20, 0, 1)
ds.create(50, 50, 1)
assert ds.matrix[0][0].color == 1
assert ds.black_count == 0
assert ds.white_count == 1
assert ds.total_disks == 1
def test_computer_update():
# NEEDS TA ACTION!!! For this one please comment out
# elf.flip_tiles(x, y, True) from computer_update in disks.py
gr4 = GameRef(gc, 100)
d4 = Disks(400, 400, 100, gr4)
d4.computer_update(50, 150)
assert d4.white_score == 3
assert d4.gr.player_turn is True
def __init__(self, WIDTH, HEIGHT, CELL_WIDTH, EDGE, game_controller,
HUMAN_COLOR, AI_COLOR):
'''draw the chess board and handles interaction
between game controller, player, and disks'''
self.WIDTH = WIDTH
self.HEIGHT = HEIGHT
self.CELL_WIDTH = CELL_WIDTH
self.EDGE = EDGE
self.gc = game_controller
self.disks = Disks(WIDTH, HEIGHT, CELL_WIDTH, EDGE, HUMAN_COLOR,
AI_COLOR)
self.human_color = HUMAN_COLOR
self.ai_color = AI_COLOR
# create the beginning 4 disks in the middle
self.initial_four(WIDTH, HEIGHT, CELL_WIDTH, HUMAN_COLOR, AI_COLOR)
def test_check_legal():
"""Test if the method store correct legal moves into the set."""
d = Disks(400, 400, 100, gr)
d.check_legal(True)
assert d.legal_table == set([(1, 0), (0, 1), (2, 3), (3, 2)])
d1 = Disks(800, 800, 100, gr)
d1.check_legal(False)
assert d1.legal_table == set([(2, 4), (3, 5), (4, 2), (5, 3)])
def test__flip_tiles_one_dir():
# NEEDS TA ACTION!!! _flip_tiles_one_dir contains display,
# please comment out everything below if next result:....
gr5 = GameRef(gc, 100)
d5 = Disks(400, 400, 100, gr5)
assert d5._flip_tiles_one_dir((5, 0), d5._move_right, True) is False
gr6 = GameRef(gc, 100)
d6 = Disks(400, 400, 100, gr6)
assert d6._flip_tiles_one_dir((1, 0), d6._move_right, True) is False
gr7 = GameRef(gc, 100)
d7 = Disks(400, 400, 100, gr7)
assert d7._flip_tiles_one_dir((1, 2), d6._move_right, True) is True
def test_is_position_valid():
"""Test if the method correctly return the boolean of a given position
that is within the board size.."""
d = Disks(100, 100, 50, gr)
position = (0, 0)
assert d._is_position_valid(position) is True
d1 = Disks(100, 100, 50, gr)
position = (-1, -3)
assert d1._is_position_valid(position) is False
d2 = Disks(100, 100, 50, gr)
position = (3, 7)
assert d2._is_position_valid(position) is False
def est_list_disks(self):
ucs_session = UCSSession()
handle, err = ucs_session.login("admin", "admin", "10.93.130.107")
s = {"blades": ["1/1"]}
d, rc = Disks.list_ucsm(handle, s)
assert (rc == 200)
ucs_session.logout(handle)
def test_is_full():
ds = Disks(800, 800, 100, 20, 0, 1)
for j in range(8):
ds.create(50 + j * 100, 50, 0)
assert ds.is_full() is False
for i in range(1, 8):
for j in range(8):
ds.create(50 + j * 100, 50 + i * 100, 0)
assert ds.is_full() is True
def test_list_disks_ucsc(self):
session = UCSCSession()
handle, err = session.login("admin", "Cisco.123", "10.93.140.102")
s = {"blades": ["1009/1/3"]}
d, rc = Disks.list_ucsc(handle, s)
print d
assert (rc == 200)
session.logout(handle)
def __init__(self, WIDTH, HEIGHT, CELL_WIDTH, EDGE, game_controller):
'''draw the chess board and handles interaction
between game controller, player, and disks'''
self.WIDTH = WIDTH
self.HEIGHT = HEIGHT
self.CELL_WIDTH = CELL_WIDTH
self.EDGE = EDGE
self.gc = game_controller
self.disks = Disks(WIDTH, HEIGHT, CELL_WIDTH, EDGE)
# create the beginning 4 disks in the middle
self.disks.create(WIDTH / 2 + CELL_WIDTH / 2,
HEIGHT / 2 - CELL_WIDTH / 2)
self.disks.create(WIDTH / 2 - CELL_WIDTH / 2,
HEIGHT / 2 - CELL_WIDTH / 2)
self.disks.create(WIDTH / 2 - CELL_WIDTH / 2,
HEIGHT / 2 + CELL_WIDTH / 2)
self.disks.create(WIDTH / 2 + CELL_WIDTH / 2,
HEIGHT / 2 + CELL_WIDTH / 2)
def test_move_right_up():
"""Test if the method correctly return the coordinate on the upper right
of current position."""
d = Disks(100, 100, 50, gr)
position = (0, 1)
assert d._move_right_up(position) == (-1, 2)
d1 = Disks(100, 100, 50, gr)
position = (-1, -3)
assert d._move_right_up(position) == (-2, -2)
d2 = Disks(100, 100, 50, gr)
position = (3, 7)
assert d2._move_right_up(position) == (2, 8)
def test_move_right():
"""Test if the method correctly return the coordinate on the right
of current position."""
d = Disks(100, 100, 50, gr)
position = (0, 0)
assert d._move_right(position) == (0, 1)
d1 = Disks(100, 100, 50, gr)
position = (-1, -2)
assert d._move_right(position) == (-1, -1)
d2 = Disks(100, 100, 50, gr)
position = (3, 7)
assert d2._move_right(position) == (3, 8)
def test_move_right_down():
"""Test if the method correctly return the coordinate on the right down
of current position."""
d = Disks(100, 100, 50, gr)
position = (0, 1)
assert d._move_right_down(position) == (1, 2)
d1 = Disks(100, 100, 50, gr)
position = (-1, -3)
assert d._move_right_down(position) == (0, -2)
d2 = Disks(100, 100, 50, gr)
position = (3, 7)
assert d2._move_right_down(position) == (4, 8)
def test_constructor():
"""Test constructor"""
score_file_name = "score.txt"
s = ScoreSheet(score_file_name)
gc = GameController(600, 400, 50, s)
gr = GameRef(gc, 100)
d = Disks(600, 400, 50, gr)
b = Board(600, 400, 50, d)
assert b.WIDTH == 600
assert b.HEIGHT == 400
assert b.CELL == 50
assert b.disk is d
def test_constructor():
ds = Disks(800, 800, 100, 20, 0, 1)
assert ds.WIDTH == 800
assert ds.HEIGHT == 800
assert ds.CELL_WIDTH == 100
assert ds.EDGE == 20
assert ds.num_of_rows == int(ds.HEIGHT / ds.CELL_WIDTH)
assert ds.num_of_cols == int(ds.WIDTH / ds.CELL_WIDTH)
assert ds.matrix == [[None] * ds.num_of_cols
for i in range(ds.num_of_rows)]
assert ds.black_count == 0
assert ds.white_count == 0
assert ds.total_disks == 0
assert ds.human_color == 0
assert ds.ai_color == 1
def add_server(self, details={}):
'''
Add a server to the Environment
'''
server = {}
server.update({'memory': Memory(details)})
server.update({'disks': Disks(details)})
server.update({'cpus': CPUS(details)})
server.update({
'processes':
Processes(cpus=server.get('cpus'),
memory=server.get('memory'),
disks=server.get('disks'),
conf=details)
})
return server
def test_constructor():
"""Test constructor"""
d = Disks(100, 100, 50, gr)
assert d.WIDTH == 100
assert d.HEIGHT == 100
assert d.cell == 50
num_start_disks = 4
assert d.black_score == 2
assert d.white_score == 2
assert d.total_count == 4
assert d.gr is gr
assert d.total_col == 2
assert d.total_row == 2
assert d.table == [[d.disk3, d.disk1], [d.disk2, d.disk4]]
half_cell = d.cell / 2
assert half_cell == 25
assert repr(d.disk1) == "Black"
assert repr(d.disk2) == "Black"
assert repr(d.disk3) == "White"
assert repr(d.disk4) == "White"
assert d.disk3.draw_black is False
assert d.disk4.draw_black is False
assert d.legal_table == set()
parser_back.add_argument('--drive', '-d', dest='drive', type=str, help="Disk drive where the backups should be put to.")
parser_del = subparsers.add_parser('delete', help='Delete a Backup')
parser_del.add_argument('--date', '-t', dest='date', type=int, required=True, help="Unix time of the backup to delete")
parser_del.add_argument('--drive', '-d', dest='drive', type=str, help="Disk drive where the backups should be put to.")
options = parser.parse_args()
#print
#print "Options:",options
#print
op = Operations()
if options.subcommand == 'ld':
from disks import Disks
disks = Disks()
for i, dinfo in enumerate(disks.list_devices()):
print "%2d. Device: %s Label: %s"%(i+1, dinfo.dev_file(), dinfo.label())
if options.subcommand == 'prepare':
latest_dir = os.path.join(options.backup_dir, 'latest')
if 1:
logger.info("* Unmounting Volume")
ret = op.unmount_backup(options.drive)
logger.info(ret)
if 1:
logger.info("* Creating Volume")
ret = op.create_btrfs(options.drive, 'backup_volume')
logger.info(ret)
if not os.path.exists(options.backup_dir):
logger.info("* mkdir mountpoint")
from encryptor import Encryptor
from disks import Disks
from constants import SHIFT
if __name__ == '__main__':
text = 'Some encrypted tex'
discs = Disks().discs
out = Encryptor().jefferson_encryption(text, discs, SHIFT, reverse=False)
print(out)
def test_check_adjacent():
"""Test if the method correctly check the adjacent position
for legal moves."""
d = Disks(400, 400, 100, gr)
d.check_adjacent(1, 1, 0, -1, True)
assert d.legal_table == set([(1, 0)])
d1 = Disks(400, 400, 100, gr)
d1.check_adjacent(1, 3, 0, 1, True)
assert d1.legal_table == set([(1, 3)])
d2 = Disks(400, 400, 100, gr)
d2.check_adjacent(2, 1, 1, 0, False)
assert d2.legal_table == set([(3, 1)])
def test_player_update():
# NEEDS TA ACTION!!! For this one please comment out
# self.flip_tiles(x, y, True) from player_update in disks.py
d = Disks(400, 400, 100, gr)
d.player_update(50, 150)
assert d.black_score == 2
assert d.gr.player_turn is True
gr1 = GameRef(gc, 100)
d1 = Disks(400, 400, 100, gr1)
d1.legal_table = set([(1, 0)])
d1.player_update(50, 150)
assert d1.black_score == 3
assert d1.gr.player_turn is False
gr2 = GameRef(gc, 100)
d2 = Disks(400, 400, 100, gr2)
d2.legal_table = set([(1, 0)])
d2.table[1][0] = 3
d2.player_update(50, 150)
assert d2.black_score == 2
assert d2.gr.player_turn is True
gr3 = GameRef(gc, 100)
d3 = Disks(400, 400, 100, gr3)
d3.legal_table = set([(1, 2)])
d3.player_update(250, 150)
assert d3.black_score == 2
assert d3.gr.player_turn is True
def est_reset_disks(self):
ucs_session = UCSSession()
handle, err = ucs_session.login("admin", "admin", "10.93.130.107")
s = {"blades": ["1/1"]}
d, rc = Disks.delete_ucsm(handle, s)
ucs_session.logout(handle)
from game_controller import GameController
from game_ref import GameRef
from score_sheet import ScoreSheet
import time
import random
from disks import Disks
score_file_name = "score.txt"
s = ScoreSheet(score_file_name)
gc = GameController(400, 400, 100, s)
gr = GameRef(gc, 100)
d = Disks(400, 400, 100, gr)
def test_constructor():
gr1 = GameRef(gc, 100)
assert gr1.player_turn is True
assert gr1.gc is gc
assert gr1.cell == 100
# Both player_move and computer_move includes methods that display drawing
# on screen, so I was not able to test for those two functions.
class Board:
def __init__(self, WIDTH, HEIGHT, CELL_WIDTH, EDGE, game_controller,
HUMAN_COLOR, AI_COLOR):
'''draw the chess board and handles interaction
between game controller, player, and disks'''
self.WIDTH = WIDTH
self.HEIGHT = HEIGHT
self.CELL_WIDTH = CELL_WIDTH
self.EDGE = EDGE
self.gc = game_controller
self.disks = Disks(WIDTH, HEIGHT, CELL_WIDTH, EDGE, HUMAN_COLOR,
AI_COLOR)
self.human_color = HUMAN_COLOR
self.ai_color = AI_COLOR
# create the beginning 4 disks in the middle
self.initial_four(WIDTH, HEIGHT, CELL_WIDTH, HUMAN_COLOR, AI_COLOR)
def initial_four(self, WIDTH, HEIGHT, CELL_WIDTH, color1, color2):
self.disks.create(WIDTH / 2 + CELL_WIDTH / 2,
HEIGHT / 2 - CELL_WIDTH / 2, color1)
self.disks.create(WIDTH / 2 - CELL_WIDTH / 2,
HEIGHT / 2 - CELL_WIDTH / 2, color2)
self.disks.create(WIDTH / 2 - CELL_WIDTH / 2,
HEIGHT / 2 + CELL_WIDTH / 2, color1)
self.disks.create(WIDTH / 2 + CELL_WIDTH / 2,
HEIGHT / 2 + CELL_WIDTH / 2, color2)
def create_disk(self, playerX, playerY, color):
'''call the disks' create method,
passing the desired place to disks'''
self.disks.create(playerX, playerY, color)
def update(self):
'''make necessary changes'''
# check whether the board is full
if self.disks.is_full():
# tell gc what happened
self.gc.game_over = True
self.gc.black_count = self.disks.black_count
self.gc.white_count = self.disks.white_count
if self.disks.black_count > self.disks.white_count:
self.gc.black_wins = True
elif self.disks.black_count < self.disks.white_count:
self.gc.white_wins = True
else:
self.gc.a_tie = True
else:
if self.gc.game_over:
self.gc.black_count = self.disks.black_count
self.gc.white_count = self.disks.white_count
if self.disks.black_count > self.disks.white_count:
self.gc.black_wins = True
elif self.disks.black_count < self.disks.white_count:
self.gc.white_wins = True
else:
self.gc.a_tie = True
def display(self):
'''display the board'''
# display the disks
self.update()
self.disks.display()
# draw the cross lines
stroke(0.0, 0.0, 0.0)
strokeWeight(5)
for i in range(self.WIDTH // self.CELL_WIDTH + 1):
line(0, self.CELL_WIDTH * i, self.WIDTH, self.CELL_WIDTH * i)
for i in range(self.HEIGHT // self.CELL_WIDTH + 1):
line(self.CELL_WIDTH * i, 0, self.CELL_WIDTH * i, self.HEIGHT)
