prompt
large_stringlengths 72
9.34k
| completion
large_stringlengths 0
7.61k
|
|---|---|
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def <|fim_middle|>(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | setUp |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def <|fim_middle|>(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | reset_testable |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def <|fim_middle|>(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_ports_list |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def <|fim_middle|>(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_get_memory_size |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def <|fim_middle|>(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_initial_state |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def <|fim_middle|>(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_byte_updates_video_ram |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def <|fim_middle|>(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_byte_calls_char_generator_top_left |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def <|fim_middle|>(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_byte_calls_char_generator_bottom_right |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def <|fim_middle|>(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_byte_char_before_attribute |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def <|fim_middle|>(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_byte_attribute_before_char |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def <|fim_middle|>(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_byte_write_off_screen |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def <|fim_middle|>(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_read_byte |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def <|fim_middle|>(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_read_byte_off_screen |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def <|fim_middle|>(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_reset_on_high_resolution_enable |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def <|fim_middle|>(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_word_at_top_left |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def <|fim_middle|>(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_word_at_bottom_right |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def <|fim_middle|>(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_write_word_at_bottom_right_just_past |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def <|fim_middle|>(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_read_word |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def <|fim_middle|>(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_mem_read_word_just_past_the_end |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def <|fim_middle|>(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_horizontal_retrace_toggles |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def <|fim_middle|>(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_current_pixel_updates_on_status_read |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def <|fim_middle|>(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_current_pixel_wraps_right |
<|file_name|>test_mda.py<|end_file_name|><｜fim▁begin｜>import unittest
from pyxt.mda import *
from pyxt.chargen import CharacterGeneratorMock
class MDATests(unittest.TestCase):
def setUp(self):
self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip("We need to initialize Pygame exactly once at startup.")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def <|fim_middle|>(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
<｜fim▁end｜> | test_current_pixel_wraps_bottom |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:<｜fim▁hole｜>### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result<｜fim▁end｜> | ### errors included |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
<|fim_middle|>
<｜fim▁end｜> | num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: <|fim_middle|>
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | return num |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": <|fim_middle|>
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | return "0" |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
<|fim_middle|>
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | positive = False
num = num[1:] |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
<|fim_middle|>
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result) |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): <|fim_middle|>
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | value -= 48 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): <|fim_middle|>
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | value -= 55 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): <|fim_middle|>
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | value -= 61 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: <|fim_middle|>
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | value = 62 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: <|fim_middle|>
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | value = 63 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
<|fim_middle|>
if not positive: result = "-" + result
return result
<｜fim▁end｜> | num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: <|fim_middle|>
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | digit = value + 48 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: <|fim_middle|>
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | digit = value + 55 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: <|fim_middle|>
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | digit = value + 61 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: <|fim_middle|>
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | digit = 64 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: <|fim_middle|>
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | digit = 95 |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def scale(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: <|fim_middle|>
return result
<｜fim▁end｜> | result = "-" + result |
<|file_name|>scale_strict.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python3
### rev: 5.0
### author: <zhq>
### features:
### errors included
### up to 63 bases (2 to 64)
### caps recognition and same output format (deprecated)
### for the function parameters, `cur` represents the current (input) base, `res` represents the result (output) base, and `num` represents the current (input) number.
def <|fim_middle|>(cur, res, num):
# int, int, str -> str
# Default Settings
num = str(num)
iscaps = False
positive = True
# Input
if cur == res: return num
if num == "0": return "0"
assert cur in range(2, 65) and res in range(2, 65), "Base not defined."
if num[0] == "-":
positive = False
num = num[1:]
result = 0
unit = 1
if cur != 10:
for i in num[::-1]:
value = ord(i)
if value in range(48, 58): value -= 48
elif value in range(65, 92): value -= 55
elif value in range(97, 123): value -= 61
elif value == 64: value = 62
elif value == 95: value = 63
assert value <= cur, "Digit larger than original base. v:%d(%s) b:%d\nCall: scale(%d, %d, %s)" % (value, i, cur, cur, res, num)
result += value * unit
unit *= cur
result = str(result)
# Output
if res != 10:
num = int(result or num)
result = ""
while num > 0:
num, value = divmod(num, res)
if value < 10: digit = value + 48
elif value < 36: digit = value + 55
elif value < 62: digit = value + 61
elif value == 62: digit = 64
elif value == 63: digit = 95
result = chr(digit) + result
if not positive: result = "-" + result
return result
<｜fim▁end｜> | scale |
<|file_name|>ly_proxy_test.py<|end_file_name|><｜fim▁begin｜># Author: Jason Lu
import urllib.request
from bs4 import BeautifulSoup
import time
req_header = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
#'Accept-Language': 'en-US,en;q=0.8,zh-Hans-CN;q=0.5,zh-Hans;q=0.3',
'Accept-Charset':'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
'Accept-Encoding':'en-us',
'Connection':'keep-alive',
'Referer':'http://www.baidu.com/'
}
req_timeout = 5
testUrl = "http://www.baidu.com/"
testStr = "wahaha"
file1 = open('proxy.txt' , 'w')
# url = ""
# req = urllib2.Request(url,None,req_header)
# jsondatas = urllib2.urlopen(req,None,req_timeout).read()
# cookies = urllib2.HTTPCookieProcessor()
# 希望登录状态一直保持，使用Cookie处理<｜fim▁hole｜>cookies = urllib.request.HTTPCookieProcessor(cjar)
checked_num = 0
grasp_num = 0
for page in range(1, 3):
# req = urllib2.Request('http://www.xici.net.co/nn/' + str(page), None, req_header)
# html_doc = urllib2.urlopen(req, None, req_timeout).read()
req = urllib.request.Request('http://www.xici.net.co/nn/' + str(page))
req.add_header('User-Agent',
"Mozilla/5.0 (iPhone; CPU iPhone OS 10_3 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) CriOS/56.0.2924.75 Mobile/14E5239e Safari/602.1")
html_doc = urllib.request.urlopen(req).read().decode('utf-8')
# html_doc = urllib2.urlopen('http://www.xici.net.co/nn/' + str(page)).read()
soup = BeautifulSoup(html_doc)
trs = soup.find('table', id='ip_list').find_all('tr')
print(trs)
for tr in trs[1:]:
tds = tr.find_all('td')
ip = tds[1].text.strip()
port = tds[2].text.strip()
protocol = tds[5].text.strip()
if protocol == 'HTTP' or protocol == 'HTTPS':
#of.write('%s=%s:%s\n' % (protocol, ip, port))
print('%s=%s:%s' % (protocol, ip, port))
grasp_num +=1
proxyHandler = urllib.request.ProxyHandler({"http": r'http://%s:%s' % (ip, port)})
opener = urllib.request.build_opener(cookies, proxyHandler)
opener.addheaders = [('User-Agent',
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36')]
t1 = time.time()
try:
req = opener.open(testUrl, timeout=req_timeout)
result = req.read()
timeused = time.time() - t1
pos = result.find(testStr)
if pos > 1:
file1.write(protocol+"\t"+ip+"\t"+port+"\n")
checked_num+=1
print(checked_num, grasp_num)
else:
continue
except Exception as e:
print(str(e))
continue
file1.close()
print(checked_num,grasp_num)<｜fim▁end｜> | import http.cookiejar
# 使用http.cookiejar.CookieJar()创建CookieJar对象
cjar = http.cookiejar.CookieJar() |
<|file_name|>ly_proxy_test.py<|end_file_name|><｜fim▁begin｜># Author: Jason Lu
import urllib.request
from bs4 import BeautifulSoup
import time
req_header = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
#'Accept-Language': 'en-US,en;q=0.8,zh-Hans-CN;q=0.5,zh-Hans;q=0.3',
'Accept-Charset':'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
'Accept-Encoding':'en-us',
'Connection':'keep-alive',
'Referer':'http://www.baidu.com/'
}
req_timeout = 5
testUrl = "http://www.baidu.com/"
testStr = "wahaha"
file1 = open('proxy.txt' , 'w')
# url = ""
# req = urllib2.Request(url,None,req_header)
# jsondatas = urllib2.urlopen(req,None,req_timeout).read()
# cookies = urllib2.HTTPCookieProcessor()
# 希望登录状态一直保持，使用Cookie处理
import http.cookiejar
# 使用http.cookiejar.CookieJar()创建CookieJar对象
cjar = http.cookiejar.CookieJar()
cookies = urllib.request.HTTPCookieProcessor(cjar)
checked_num = 0
grasp_num = 0
for page in range(1, 3):
# req = urllib2.Request('http://www.xici.net.co/nn/' + str(page), None, req_header)
# html_doc = urllib2.urlopen(req, None, req_timeout).read()
req = urllib.request.Request('http://www.xici.net.co/nn/' + str(page))
req.add_header('User-Agent',
"Mozilla/5.0 (iPhone; CPU iPhone OS 10_3 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) CriOS/56.0.2924.75 Mobile/14E5239e Safari/602.1")
html_doc = urllib.request.urlopen(req).read().decode('utf-8')
# html_doc = urllib2.urlopen('http://www.xici.net.co/nn/' + str(page)).read()
soup = BeautifulSoup(html_doc)
trs = soup.find('table', id='ip_list').find_all('tr')
print(trs)
for tr in trs[1:]:
tds = tr.find_all('td')
ip = tds[1].text.strip()
port = tds[2].text.strip()
protocol = tds[5].text.strip()
if protocol == 'HTTP' or protocol == 'HTTPS':
#of.write('%s=%s:%s\n' % (protocol, ip, port))
print('%s=%s:%s' % (protocol, ip, port))
<|fim_middle|>
)<｜fim▁end｜> | grasp_num +=1
proxyHandler = urllib.request.ProxyHandler({"http": r'http://%s:%s' % (ip, port)})
opener = urllib.request.build_opener(cookies, proxyHandler)
opener.addheaders = [('User-Agent',
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36')]
t1 = time.time()
try:
req = opener.open(testUrl, timeout=req_timeout)
result = req.read()
timeused = time.time() - t1
pos = result.find(testStr)
if pos > 1:
file1.write(protocol+"\t"+ip+"\t"+port+"\n")
checked_num+=1
print(checked_num, grasp_num)
else:
continue
except Exception as e:
print(str(e))
continue
file1.close()
print(checked_num,grasp_num |
<|file_name|>ly_proxy_test.py<|end_file_name|><｜fim▁begin｜># Author: Jason Lu
import urllib.request
from bs4 import BeautifulSoup
import time
req_header = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
#'Accept-Language': 'en-US,en;q=0.8,zh-Hans-CN;q=0.5,zh-Hans;q=0.3',
'Accept-Charset':'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
'Accept-Encoding':'en-us',
'Connection':'keep-alive',
'Referer':'http://www.baidu.com/'
}
req_timeout = 5
testUrl = "http://www.baidu.com/"
testStr = "wahaha"
file1 = open('proxy.txt' , 'w')
# url = ""
# req = urllib2.Request(url,None,req_header)
# jsondatas = urllib2.urlopen(req,None,req_timeout).read()
# cookies = urllib2.HTTPCookieProcessor()
# 希望登录状态一直保持，使用Cookie处理
import http.cookiejar
# 使用http.cookiejar.CookieJar()创建CookieJar对象
cjar = http.cookiejar.CookieJar()
cookies = urllib.request.HTTPCookieProcessor(cjar)
checked_num = 0
grasp_num = 0
for page in range(1, 3):
# req = urllib2.Request('http://www.xici.net.co/nn/' + str(page), None, req_header)
# html_doc = urllib2.urlopen(req, None, req_timeout).read()
req = urllib.request.Request('http://www.xici.net.co/nn/' + str(page))
req.add_header('User-Agent',
"Mozilla/5.0 (iPhone; CPU iPhone OS 10_3 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) CriOS/56.0.2924.75 Mobile/14E5239e Safari/602.1")
html_doc = urllib.request.urlopen(req).read().decode('utf-8')
# html_doc = urllib2.urlopen('http://www.xici.net.co/nn/' + str(page)).read()
soup = BeautifulSoup(html_doc)
trs = soup.find('table', id='ip_list').find_all('tr')
print(trs)
for tr in trs[1:]:
tds = tr.find_all('td')
ip = tds[1].text.strip()
port = tds[2].text.strip()
protocol = tds[5].text.strip()
if protocol == 'HTTP' or protocol == 'HTTPS':
#of.write('%s=%s:%s\n' % (protocol, ip, port))
print('%s=%s:%s' % (protocol, ip, port))
grasp_num +=1
proxyHandler = urllib.request.ProxyHandler({"http": r'http://%s:%s' % (ip, port)})
opener = urllib.request.build_opener(cookies, proxyHandler)
opener.addheaders = [('User-Agent',
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36')]
t1 = time.time()
try:
req = opener.open(testUrl, timeout=req_timeout)
result = req.read()
timeused = time.time() - t1
pos = result.find(testStr)
if pos > 1:
file1.write(protocol+"\t"+ip+"\t"+port+"\n <|fim_middle|>
continue
except Exception as e:
print(str(e))
continue
file1.close()
print(checked_num,grasp_num)<｜fim▁end｜> | ")
checked_num+=1
print(checked_num, grasp_num)
else:
|
<|file_name|>ly_proxy_test.py<|end_file_name|><｜fim▁begin｜># Author: Jason Lu
import urllib.request
from bs4 import BeautifulSoup
import time
req_header = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
#'Accept-Language': 'en-US,en;q=0.8,zh-Hans-CN;q=0.5,zh-Hans;q=0.3',
'Accept-Charset':'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
'Accept-Encoding':'en-us',
'Connection':'keep-alive',
'Referer':'http://www.baidu.com/'
}
req_timeout = 5
testUrl = "http://www.baidu.com/"
testStr = "wahaha"
file1 = open('proxy.txt' , 'w')
# url = ""
# req = urllib2.Request(url,None,req_header)
# jsondatas = urllib2.urlopen(req,None,req_timeout).read()
# cookies = urllib2.HTTPCookieProcessor()
# 希望登录状态一直保持，使用Cookie处理
import http.cookiejar
# 使用http.cookiejar.CookieJar()创建CookieJar对象
cjar = http.cookiejar.CookieJar()
cookies = urllib.request.HTTPCookieProcessor(cjar)
checked_num = 0
grasp_num = 0
for page in range(1, 3):
# req = urllib2.Request('http://www.xici.net.co/nn/' + str(page), None, req_header)
# html_doc = urllib2.urlopen(req, None, req_timeout).read()
req = urllib.request.Request('http://www.xici.net.co/nn/' + str(page))
req.add_header('User-Agent',
"Mozilla/5.0 (iPhone; CPU iPhone OS 10_3 like Mac OS X) AppleWebKit/602.1.50 (KHTML, like Gecko) CriOS/56.0.2924.75 Mobile/14E5239e Safari/602.1")
html_doc = urllib.request.urlopen(req).read().decode('utf-8')
# html_doc = urllib2.urlopen('http://www.xici.net.co/nn/' + str(page)).read()
soup = BeautifulSoup(html_doc)
trs = soup.find('table', id='ip_list').find_all('tr')
print(trs)
for tr in trs[1:]:
tds = tr.find_all('td')
ip = tds[1].text.strip()
port = tds[2].text.strip()
protocol = tds[5].text.strip()
if protocol == 'HTTP' or protocol == 'HTTPS':
#of.write('%s=%s:%s\n' % (protocol, ip, port))
print('%s=%s:%s' % (protocol, ip, port))
grasp_num +=1
proxyHandler = urllib.request.ProxyHandler({"http": r'http://%s:%s' % (ip, port)})
opener = urllib.request.build_opener(cookies, proxyHandler)
opener.addheaders = [('User-Agent',
'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.63 Safari/537.36')]
t1 = time.time()
try:
req = opener.open(testUrl, timeout=req_timeout)
result = req.read()
timeused = time.time() - t1
pos = result.find(testStr)
if pos > 1:
file1.write(protocol+"\t"+ip+"\t"+port+"\n")
checked_num+=1
print(checked_num, grasp_num)
else:
continue
except Exception as e <|fim_middle|>
print(str(e))
continue
file1.close()
print(checked_num,grasp_num)<｜fim▁end｜> | :
|
<|file_name|>shared_dressed_rebel_brigadier_general_sullustan_male.py<|end_file_name|><｜fim▁begin｜>#### NOTICE: THIS FILE IS AUTOGENERATED
#### MODIFICATIONS MAY BE LOST IF DONE IMPROPERLY
#### PLEASE SEE THE ONLINE DOCUMENTATION FOR EXAMPLES
from swgpy.object import *
def create(kernel):
result = Creature()
result.template = "object/mobile/shared_dressed_rebel_brigadier_general_sullustan_male.iff"
result.attribute_template_id = 9
result.stfName("npc_name","sullustan_base_male")
#### BEGIN MODIFICATIONS ####
#### END MODIFICATIONS ####
<｜fim▁hole｜><｜fim▁end｜> | return result |
<|file_name|>shared_dressed_rebel_brigadier_general_sullustan_male.py<|end_file_name|><｜fim▁begin｜>#### NOTICE: THIS FILE IS AUTOGENERATED
#### MODIFICATIONS MAY BE LOST IF DONE IMPROPERLY
#### PLEASE SEE THE ONLINE DOCUMENTATION FOR EXAMPLES
from swgpy.object import *
def create(kernel):
<|fim_middle|>
<｜fim▁end｜> | result = Creature()
result.template = "object/mobile/shared_dressed_rebel_brigadier_general_sullustan_male.iff"
result.attribute_template_id = 9
result.stfName("npc_name","sullustan_base_male")
#### BEGIN MODIFICATIONS ####
#### END MODIFICATIONS ####
return result |
<|file_name|>shared_dressed_rebel_brigadier_general_sullustan_male.py<|end_file_name|><｜fim▁begin｜>#### NOTICE: THIS FILE IS AUTOGENERATED
#### MODIFICATIONS MAY BE LOST IF DONE IMPROPERLY
#### PLEASE SEE THE ONLINE DOCUMENTATION FOR EXAMPLES
from swgpy.object import *
def <|fim_middle|>(kernel):
result = Creature()
result.template = "object/mobile/shared_dressed_rebel_brigadier_general_sullustan_male.iff"
result.attribute_template_id = 9
result.stfName("npc_name","sullustan_base_male")
#### BEGIN MODIFICATIONS ####
#### END MODIFICATIONS ####
return result<｜fim▁end｜> | create |
<|file_name|>tail-latency.py<|end_file_name|><｜fim▁begin｜># Note that this is not a valid measurement of tail latency. This uses the execution times we measure because they're convenient, but this does not include queueing time inside BitFunnel nor does it include head-of-line blocking queue waiting time on the queue into BitFunnel.
import csv
filename = "/tmp/QueryPipelineStatistics.csv"
times = []
with open(filename) as f:
reader = csv.reader(f)
header = next(reader)
assert header == ['query',
'rows',
'matches',
'quadwords',
'cachelines',<｜fim▁hole｜> 'parse',
'plan',
'match']
for row in reader:
total_time = float(row[-1]) + float(row[-2]) + float(row[-3])
times.append(total_time)
times.sort(reverse=True)
idx_max = len(times) - 1
idx = [round(idx_max / 2),
round(idx_max / 10),
round(idx_max / 100),
round(idx_max / 1000),
0]
tails = [times[x] for x in idx]
print(tails)<｜fim▁end｜> | |
<|file_name|>livebargraph.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 25 21:11:45 2017
@author: hubert
"""
import numpy as np
import matplotlib.pyplot as plt
class LiveBarGraph(object):
"""
"""
def __init__(self, band_names=['delta', 'theta', 'alpha', 'beta'],
ch_names=['TP9', 'AF7', 'AF8', 'TP10']):
"""
"""
self.band_names = band_names
self.ch_names = ch_names
self.n_bars = self.band_names * self.ch_names
self.x =
self.fig, self.ax = plt.subplots()
self.ax.set_ylim((0, 1))
y = np.zeros((self.n_bars,))
x = range(self.n_bars)
self.rects = self.ax.bar(x, y)
def update(self, new_y):
[rect.set_height(y) for rect, y in zip(self.rects, new_y)]
if __name__ == '__main__':<｜fim▁hole｜>
bar = LiveBarGraph()
plt.show()
while True:
bar.update(np.random.random(10))
plt.pause(0.1)<｜fim▁end｜> | |
<|file_name|>livebargraph.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 25 21:11:45 2017
@author: hubert
"""
import numpy as np
import matplotlib.pyplot as plt
class LiveBarGraph(object):
<|fim_middle|>
if __name__ == '__main__':
bar = LiveBarGraph()
plt.show()
while True:
bar.update(np.random.random(10))
plt.pause(0.1)
<｜fim▁end｜> | """
"""
def __init__(self, band_names=['delta', 'theta', 'alpha', 'beta'],
ch_names=['TP9', 'AF7', 'AF8', 'TP10']):
"""
"""
self.band_names = band_names
self.ch_names = ch_names
self.n_bars = self.band_names * self.ch_names
self.x =
self.fig, self.ax = plt.subplots()
self.ax.set_ylim((0, 1))
y = np.zeros((self.n_bars,))
x = range(self.n_bars)
self.rects = self.ax.bar(x, y)
def update(self, new_y):
[rect.set_height(y) for rect, y in zip(self.rects, new_y)] |
<|file_name|>livebargraph.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 25 21:11:45 2017
@author: hubert
"""
import numpy as np
import matplotlib.pyplot as plt
class LiveBarGraph(object):
"""
"""
def __init__(self, band_names=['delta', 'theta', 'alpha', 'beta'],
ch_names=['TP9', 'AF7', 'AF8', 'TP10']):
<|fim_middle|>
def update(self, new_y):
[rect.set_height(y) for rect, y in zip(self.rects, new_y)]
if __name__ == '__main__':
bar = LiveBarGraph()
plt.show()
while True:
bar.update(np.random.random(10))
plt.pause(0.1)
<｜fim▁end｜> | """
"""
self.band_names = band_names
self.ch_names = ch_names
self.n_bars = self.band_names * self.ch_names
self.x =
self.fig, self.ax = plt.subplots()
self.ax.set_ylim((0, 1))
y = np.zeros((self.n_bars,))
x = range(self.n_bars)
self.rects = self.ax.bar(x, y) |
<|file_name|>livebargraph.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 25 21:11:45 2017
@author: hubert
"""
import numpy as np
import matplotlib.pyplot as plt
class LiveBarGraph(object):
"""
"""
def __init__(self, band_names=['delta', 'theta', 'alpha', 'beta'],
ch_names=['TP9', 'AF7', 'AF8', 'TP10']):
"""
"""
self.band_names = band_names
self.ch_names = ch_names
self.n_bars = self.band_names * self.ch_names
self.x =
self.fig, self.ax = plt.subplots()
self.ax.set_ylim((0, 1))
y = np.zeros((self.n_bars,))
x = range(self.n_bars)
self.rects = self.ax.bar(x, y)
def update(self, new_y):
<|fim_middle|>
if __name__ == '__main__':
bar = LiveBarGraph()
plt.show()
while True:
bar.update(np.random.random(10))
plt.pause(0.1)
<｜fim▁end｜> | [rect.set_height(y) for rect, y in zip(self.rects, new_y)] |
<|file_name|>livebargraph.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 25 21:11:45 2017
@author: hubert
"""
import numpy as np
import matplotlib.pyplot as plt
class LiveBarGraph(object):
"""
"""
def __init__(self, band_names=['delta', 'theta', 'alpha', 'beta'],
ch_names=['TP9', 'AF7', 'AF8', 'TP10']):
"""
"""
self.band_names = band_names
self.ch_names = ch_names
self.n_bars = self.band_names * self.ch_names
self.x =
self.fig, self.ax = plt.subplots()
self.ax.set_ylim((0, 1))
y = np.zeros((self.n_bars,))
x = range(self.n_bars)
self.rects = self.ax.bar(x, y)
def update(self, new_y):
[rect.set_height(y) for rect, y in zip(self.rects, new_y)]
if __name__ == '__main__':
<|fim_middle|>
<｜fim▁end｜> | bar = LiveBarGraph()
plt.show()
while True:
bar.update(np.random.random(10))
plt.pause(0.1) |
<|file_name|>livebargraph.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 25 21:11:45 2017
@author: hubert
"""
import numpy as np
import matplotlib.pyplot as plt
class LiveBarGraph(object):
"""
"""
def <|fim_middle|>(self, band_names=['delta', 'theta', 'alpha', 'beta'],
ch_names=['TP9', 'AF7', 'AF8', 'TP10']):
"""
"""
self.band_names = band_names
self.ch_names = ch_names
self.n_bars = self.band_names * self.ch_names
self.x =
self.fig, self.ax = plt.subplots()
self.ax.set_ylim((0, 1))
y = np.zeros((self.n_bars,))
x = range(self.n_bars)
self.rects = self.ax.bar(x, y)
def update(self, new_y):
[rect.set_height(y) for rect, y in zip(self.rects, new_y)]
if __name__ == '__main__':
bar = LiveBarGraph()
plt.show()
while True:
bar.update(np.random.random(10))
plt.pause(0.1)
<｜fim▁end｜> | __init__ |
<|file_name|>livebargraph.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 25 21:11:45 2017
@author: hubert
"""
import numpy as np
import matplotlib.pyplot as plt
class LiveBarGraph(object):
"""
"""
def __init__(self, band_names=['delta', 'theta', 'alpha', 'beta'],
ch_names=['TP9', 'AF7', 'AF8', 'TP10']):
"""
"""
self.band_names = band_names
self.ch_names = ch_names
self.n_bars = self.band_names * self.ch_names
self.x =
self.fig, self.ax = plt.subplots()
self.ax.set_ylim((0, 1))
y = np.zeros((self.n_bars,))
x = range(self.n_bars)
self.rects = self.ax.bar(x, y)
def <|fim_middle|>(self, new_y):
[rect.set_height(y) for rect, y in zip(self.rects, new_y)]
if __name__ == '__main__':
bar = LiveBarGraph()
plt.show()
while True:
bar.update(np.random.random(10))
plt.pause(0.1)
<｜fim▁end｜> | update |
<|file_name|>actions.py<|end_file_name|><｜fim▁begin｜>from turbo.flux import Mutation, register, dispatch, register_dispatch
import mutation_types
@register_dispatch('user', mutation_types.INCREASE)
def increase(rank):
pass
def decrease(rank):<｜fim▁hole｜>
@register_dispatch('metric', 'inc_qps')
def inc_qps():
pass<｜fim▁end｜> | return dispatch('user', mutation_types.DECREASE, rank) |
<|file_name|>actions.py<|end_file_name|><｜fim▁begin｜>from turbo.flux import Mutation, register, dispatch, register_dispatch
import mutation_types
@register_dispatch('user', mutation_types.INCREASE)
def increase(rank):
<|fim_middle|>
def decrease(rank):
return dispatch('user', mutation_types.DECREASE, rank)
@register_dispatch('metric', 'inc_qps')
def inc_qps():
pass<｜fim▁end｜> | pass |
<|file_name|>actions.py<|end_file_name|><｜fim▁begin｜>from turbo.flux import Mutation, register, dispatch, register_dispatch
import mutation_types
@register_dispatch('user', mutation_types.INCREASE)
def increase(rank):
pass
def decrease(rank):
<|fim_middle|>
@register_dispatch('metric', 'inc_qps')
def inc_qps():
pass<｜fim▁end｜> | return dispatch('user', mutation_types.DECREASE, rank) |
<|file_name|>actions.py<|end_file_name|><｜fim▁begin｜>from turbo.flux import Mutation, register, dispatch, register_dispatch
import mutation_types
@register_dispatch('user', mutation_types.INCREASE)
def increase(rank):
pass
def decrease(rank):
return dispatch('user', mutation_types.DECREASE, rank)
@register_dispatch('metric', 'inc_qps')
def inc_qps():
<|fim_middle|>
<｜fim▁end｜> | pass |
<|file_name|>actions.py<|end_file_name|><｜fim▁begin｜>from turbo.flux import Mutation, register, dispatch, register_dispatch
import mutation_types
@register_dispatch('user', mutation_types.INCREASE)
def <|fim_middle|>(rank):
pass
def decrease(rank):
return dispatch('user', mutation_types.DECREASE, rank)
@register_dispatch('metric', 'inc_qps')
def inc_qps():
pass<｜fim▁end｜> | increase |
<|file_name|>actions.py<|end_file_name|><｜fim▁begin｜>from turbo.flux import Mutation, register, dispatch, register_dispatch
import mutation_types
@register_dispatch('user', mutation_types.INCREASE)
def increase(rank):
pass
def <|fim_middle|>(rank):
return dispatch('user', mutation_types.DECREASE, rank)
@register_dispatch('metric', 'inc_qps')
def inc_qps():
pass<｜fim▁end｜> | decrease |
<|file_name|>actions.py<|end_file_name|><｜fim▁begin｜>from turbo.flux import Mutation, register, dispatch, register_dispatch
import mutation_types
@register_dispatch('user', mutation_types.INCREASE)
def increase(rank):
pass
def decrease(rank):
return dispatch('user', mutation_types.DECREASE, rank)
@register_dispatch('metric', 'inc_qps')
def <|fim_middle|>():
pass<｜fim▁end｜> | inc_qps |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
<｜fim▁hole｜> def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)<｜fim▁end｜> | |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
<|fim_middle|>
<｜fim▁end｜> | def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default) |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
<|fim_middle|>
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
<|fim_middle|>
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | if self.initialized:
return
self.initialized = True |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
<|fim_middle|>
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return self.initialized |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
<|fim_middle|>
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return Base(parent) |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
<|fim_middle|>
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return getattr(Base, '__designer_name__', Base.__name__) |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
<|fim_middle|>
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return getattr(Base, '__designer_group__', 'ProjexUI') |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
<|fim_middle|>
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default)) |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
<|fim_middle|>
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs) |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
<|fim_middle|>
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return '' |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
<|fim_middle|>
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return getattr(Base, '__designer_container__', False) |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
<|fim_middle|>
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return 'projexui.widgets.xviewwidget' |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
<|fim_middle|>
<｜fim▁end｜> | opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default) |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
<|fim_middle|>
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | return |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
<|fim_middle|>
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | docs = '' |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def <|fim_middle|>(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | __init__ |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def <|fim_middle|>(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | initialize |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def <|fim_middle|>(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | isInitialized |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def <|fim_middle|>(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | createWidget |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def <|fim_middle|>(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | name |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def <|fim_middle|>(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | group |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def <|fim_middle|>(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | icon |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def <|fim_middle|>( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | toolTip |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def <|fim_middle|>( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | whatsThis |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def <|fim_middle|>( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | isContainer |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def <|fim_middle|>( self ):
return 'projexui.widgets.xviewwidget'
def domXml( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | includeFile |
<|file_name|>xviewwidgetplugin.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
''' Auto-generated ui widget plugin '''
from projexui.qt.QtDesigner import QPyDesignerCustomWidgetPlugin
from projexui.qt.QtGui import QIcon
import projex.resources
from projexui.widgets.xviewwidget import XViewWidget as Base
setattr(Base, '__designer_mode__', True)
DEFAULT_XML = '''<ui language="c++" displayname="XViewWidget">
<widget class="XViewWidget" name="XViewWidget"/>
<customwidgets>
<customwidget>
<class>XViewWidget</class>
<header>projexui.widgets.xviewwidget</header>
<addpagemethod>%(addpagemethod)s</addpagemethod>
<propertyspecifications>
%(propertyspecs)s
</propertyspecifications>
</customwidget>
</customwidgets>
</ui>'''
class XViewWidgetPlugin(QPyDesignerCustomWidgetPlugin):
def __init__(self, parent=None):
super(XViewWidgetPlugin, self).__init__(parent)
self.initialized = False
def initialize(self, core):
if self.initialized:
return
self.initialized = True
def isInitialized(self):
return self.initialized
def createWidget(self, parent):
return Base(parent)
def name(self):
return getattr(Base, '__designer_name__', Base.__name__)
def group(self):
return getattr(Base, '__designer_group__', 'ProjexUI')
def icon(self):
default = projex.resources.find('img/logo_16.png')
return QIcon(getattr(Base, '__designer_icon__', default))
def toolTip( self ):
docs = getattr(Base, '__doc__', '')
if docs is None:
docs = ''
return getattr(Base, '__designer_tooltip__', docs)
def whatsThis( self ):
return ''
def isContainer( self ):
return getattr(Base, '__designer_container__', False)
def includeFile( self ):
return 'projexui.widgets.xviewwidget'
def <|fim_middle|>( self ):
opts = {}
specs = []
for prop, info in getattr(Base, '__designer_propspecs__', {}).items():
xml = '<%spropertyspecification name="%s" type="%s"/>'
xml %= (info[0], prop, info[1])
specs.append(xml)
opts['addpagemethod'] = getattr(Base, '__designer_addpage__', '')
opts['propertyspecs'] = ''.join(specs)
default = DEFAULT_XML % opts
return getattr(Base, '__designer_xml__', default)
<｜fim▁end｜> | domXml |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
)
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
""" Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")<｜fim▁hole｜>
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls
def get_test_contract(name):
contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts
def deploy_rpc_test_contract(deploy_client, name):
contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy
def get_list_of_block_numbers(item):
""" Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list()<｜fim▁end｜> | assert pfs_address is None |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
<|fim_middle|>
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
""" Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")
assert pfs_address is None
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls
def get_test_contract(name):
contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts
def deploy_rpc_test_contract(deploy_client, name):
contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy
def get_list_of_block_numbers(item):
""" Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list()
<｜fim▁end｜> | token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
) |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
)
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
<|fim_middle|>
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")
assert pfs_address is None
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls
def get_test_contract(name):
contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts
def deploy_rpc_test_contract(deploy_client, name):
contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy
def get_list_of_block_numbers(item):
""" Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list()
<｜fim▁end｜> | """ Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
)
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
""" Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
<|fim_middle|>
def get_test_contract(name):
contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts
def deploy_rpc_test_contract(deploy_client, name):
contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy
def get_list_of_block_numbers(item):
""" Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list()
<｜fim▁end｜> | urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")
assert pfs_address is None
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
)
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
""" Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")
assert pfs_address is None
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls
def get_test_contract(name):
<|fim_middle|>
def deploy_rpc_test_contract(deploy_client, name):
contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy
def get_list_of_block_numbers(item):
""" Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list()
<｜fim▁end｜> | contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
)
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
""" Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")
assert pfs_address is None
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls
def get_test_contract(name):
contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts
def deploy_rpc_test_contract(deploy_client, name):
<|fim_middle|>
def get_list_of_block_numbers(item):
""" Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list()
<｜fim▁end｜> | contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
)
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
""" Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")
assert pfs_address is None
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls
def get_test_contract(name):
contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts
def deploy_rpc_test_contract(deploy_client, name):
contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy
def get_list_of_block_numbers(item):
<|fim_middle|>
<｜fim▁end｜> | """ Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
return [element["blockNumber"] for element in item]
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list() |
<|file_name|>smartcontracts.py<|end_file_name|><｜fim▁begin｜>import os
from typing import List, Tuple
from raiden.network.blockchain_service import BlockChainService
from raiden.network.pathfinding import get_random_service
from raiden.network.proxies.service_registry import ServiceRegistry
from raiden.network.rpc.client import JSONRPCClient
from raiden.network.rpc.smartcontract_proxy import ContractProxy
from raiden.utils import typing
from raiden.utils.smart_contracts import deploy_contract_web3
from raiden.utils.solc import compile_files_cwd
from raiden_contracts.constants import CONTRACT_HUMAN_STANDARD_TOKEN
from raiden_contracts.contract_manager import ContractManager
def deploy_token(
deploy_client: JSONRPCClient,
contract_manager: ContractManager,
initial_amount: typing.TokenAmount,
decimals: int,
token_name: str,
token_symbol: str,
) -> ContractProxy:
token_address = deploy_contract_web3(
contract_name=CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_client=deploy_client,
contract_manager=contract_manager,
constructor_arguments=(initial_amount, decimals, token_name, token_symbol),
)
contract_abi = contract_manager.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
return deploy_client.new_contract_proxy(
contract_interface=contract_abi, contract_address=token_address
)
def deploy_tokens_and_fund_accounts(
token_amount: int,
number_of_tokens: int,
deploy_service: BlockChainService,
participants: typing.List[typing.Address],
contract_manager: ContractManager,
) -> typing.List[typing.TokenAddress]:
""" Deploy `number_of_tokens` ERC20 token instances with `token_amount` minted and
distributed among `blockchain_services`. Optionally the instances will be registered with
the raiden registry.
Args:
token_amount (int): number of units that will be created per token
number_of_tokens (int): number of token instances that will be created
deploy_service (BlockChainService): the blockchain connection that will deploy
participants (list(address)): participant addresses that will receive tokens
"""
result = list()
for _ in range(number_of_tokens):
token_address = deploy_contract_web3(
CONTRACT_HUMAN_STANDARD_TOKEN,
deploy_service.client,
contract_manager=contract_manager,
constructor_arguments=(token_amount, 2, "raiden", "Rd"),
)
result.append(token_address)
# only the creator of the token starts with a balance (deploy_service),
# transfer from the creator to the other nodes
for transfer_to in participants:
deploy_service.token(token_address).transfer(
to_address=transfer_to, amount=token_amount // len(participants)
)
return result
def deploy_service_registry_and_set_urls(
private_keys, web3, contract_manager, service_registry_address
) -> Tuple[ServiceRegistry, List[str]]:
urls = ["http://foo", "http://boo", "http://coo"]
c1_client = JSONRPCClient(web3, private_keys[0])
c1_service_proxy = ServiceRegistry(
jsonrpc_client=c1_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c2_client = JSONRPCClient(web3, private_keys[1])
c2_service_proxy = ServiceRegistry(
jsonrpc_client=c2_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
c3_client = JSONRPCClient(web3, private_keys[2])
c3_service_proxy = ServiceRegistry(
jsonrpc_client=c3_client,
service_registry_address=service_registry_address,
contract_manager=contract_manager,
)
# Test that getting a random service for an empty registry returns None
pfs_address = get_random_service(c1_service_proxy, "latest")
assert pfs_address is None
# Test that setting the urls works
c1_service_proxy.set_url(urls[0])
c2_service_proxy.set_url(urls[1])
c3_service_proxy.set_url(urls[2])
return c1_service_proxy, urls
def get_test_contract(name):
contract_path = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "smart_contracts", name)
)
contracts = compile_files_cwd([contract_path])
return contract_path, contracts
def deploy_rpc_test_contract(deploy_client, name):
contract_path, contracts = get_test_contract(f"{name}.sol")
contract_proxy, _ = deploy_client.deploy_solidity_contract(
name, contracts, libraries=dict(), constructor_parameters=None, contract_path=contract_path
)
return contract_proxy
def get_list_of_block_numbers(item):
""" Creates a list of block numbers of the given list/single event"""
if isinstance(item, list):
<|fim_middle|>
if isinstance(item, dict):
block_number = item["blockNumber"]
return [block_number]
return list()
<｜fim▁end｜> | return [element["blockNumber"] for element in item] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.