Example #1
0
    def test_three_deep(self):
        suite.banner(self.test_three_deep)
        self.shell.config.err = True 
        self.run_test("""
a(jsr, 'test.one')
a(brk) 
a(nop)
a('test.one')
a(nop)
a(pha)
a(pha)
a(jsr, 'test.two')
a(pla)
a(pla)
a(rts) 
a('test.two')
a(nop)
a(jsr, 'test.three')
a(rts) 
a('test.three')
a(pha) 
a(nop)
a('break.here')
a(nop)
a(pla) 
a(rts) 
d('PROGRAM_START', 0x2011)
b('break.here')
r
t""")
        self.assertEquals('$2015  1 <current>', self.results[-6])
        self.assertEquals('$200f  0 jsr test.three', self.results[-5])
        self.assertEquals('$2008  2 jsr test.two', self.results[-4])
        self.assertEquals('$2000  0 jsr test.one', self.results[-3])
 def test_imm_alias(self):
     suite.banner(self.test_imm_alias)
     self.a.alias("baz", 0x42)
     self.a(lda_imm, "baz")
     result = self.d.next()
     suite.log.info(str(result))
     self.assertEquals("$2000: a9 42     lda #baz", str(result).strip())
 def test_data(self):
     suite.banner(self.test_data) 
     self.d.instruction = nop
     self.d.bytes = [nop.opcode] 
     self.d.data = tools.Data(0xa1b0, 5, repr('Hello'))
     suite.log.info(str(self.d)) 
     self.assertEquals("    $a1b0: data      'Hello'", str(self.d))
Example #4
0
    def test_chrin(self):
        suite.banner(self.test_chrin)
        a = self.a

        termin = mock.TerminalInput("123456\x00")
        self.comp.terminal_input.source = termin

        _
        a(ldx_imm, 0)
        _
        a("test.loop")
        _
        a(jsr, "CHRIN")
        _
        a(cmp_imm, 0x00)
        _
        a(beq, "test.done")
        _
        a(sta_abx, 0x5000)
        _
        a(inx)
        _
        a(bra, "test.loop")
        _
        a("test.done")

        self.run_test()
        chars = [chr(self.mem[0x5000 + i]) for i in xrange(6)]
        self.assertEquals("123456", "".join(chars))
 def test_abs_label(self):
     suite.banner(self.test_abs_label)
     self.a.label("foo", 0x1234)
     self.a(lda_abs, "foo")
     result = self.d.next()
     suite.log.info(str(result))
     self.assertEquals("$2000: ad 34 12  lda foo", str(result).strip())
Example #6
0
    def test_end_only(self):
        suite.banner(self.test_end_only) 
        self.run_test("""\
m(0x5000, 0x50ff)
m(end=0x51ff)""")
        self.assertTrue(self.results[-18].startswith('$5100'))
        self.assertTrue(self.results[-3].startswith('$51f0')) 
Example #7
0
    def test_no_end(self):
        suite.banner(self.test_no_end)
        self.run_test("""\
conf.lines = 5
d(0x5000)""")
        self.assertEquals('$5005: 00        brk', self.results[-3])
        self.assertEquals('mach8>', self.results[-2])
 def test_clear_binary_flag_on_load(self):
     """
     === Defect ===
     Programs may raise an InvalidBCDNumberError trap after running 
     'asm.fib'
     
     === Steps to reproduce ===
     mach8> l('asm.fib')
     mach8> r
     mach8> l('asm.hello')
     mach8> r
     
     === Incorrect execution ===
     InvalidBCDNumberError trap raised. 
     
     === Correct execution ===
     Prints 'Hello world!'
     
     === Reason ===
     D flag needs to be cleared when loading a new program. Corrective
     action for now is to clear the flag at the end of asm.fib, but this
     needs to be fixed later. A bug in the test suite is preventing proper
     testing at the moment. 
     """
     suite.banner(self.test_clear_binary_flag_on_load) 
     
     sh = monitor.Shell(self.comp) 
     sh.l('asm.fib')
     sh.r()
     sh.l('asm.hello')
     sh.r()
Example #9
0
 def test_strcat(self):
     suite.banner(self.test_strcat)
     a = self.a
     
     self.mem[memmap.HEAP - 1::2] = 0xdead
     self.mem[memmap.HEAP + 1::2] = 0xbeef 
     
     _;      a.macro   (ldxy_imm, 'test.str1')
     _;      a.macro   (stxy_zp,  'R1')
     _;      a.macro   (ldxy_imm, 'test.str2')
     _;      a.macro   (stxy_zp,  'R3')
     _;      a(jsr,    'STRCAT')
     _;      a(brk)
     _;      a(nop)
     
     _;  a('test.str1')
     _;      a.data('123', 0) 
     _;  a('test.str2')
     _;      a.data('4567', 0)  
     
     self.run_test() 
     ptr = self.mem[memmap.R1::2]
     value = ''.join(map(chr, self.mem[ptr:ptr + 8])) 
     self.assertEquals('1234567\x00', value) 
     self.assertEquals(0xbeef, self.mem[memmap.HEAP + 1::2])
Example #10
0
    def test_add_watch_label(self):
        suite.banner(self.test_add_watch_label)
        self.run_test("""
a.label('test.label', 0x4000)
w('test.label')
mem[0x4000] = 0x42""")
        self.assertEquals('mem $4000 <-= $42: test.label', self.results[-3])
Example #11
0
    def test_remove_watch(self):
        suite.banner(self.test_remove_watch)
        self.run_test("""
w(0x4000)
w(0x4000)
mem[0x4000] = 0x42""")
        self.assertEquals('mach8>', self.results[-2]) 
Example #12
0
    def test_bcs_false(self):
        suite.banner(self.test_bcs_false)
        a = self.a

        _
        a(clc)
        _
        a(lda_imm, 0x00)
        _
        a(adc_imm, 0x01)
        _
        a(bcs, "test.exit")

        _
        a(ldx_imm, 0xAA)
        _
        a(brk)
        _
        a(nop)

        _
        a("test.exit")
        _
        a(ldx_imm, 0xBB)

        self.run_test()
        self.assertEquals(0xAA, self.cpu.x)
Example #13
0
    def test_bvs(self):
        suite.banner(self.test_bvs)
        a = self.a

        _
        a(clc)
        _
        a(lda_imm, 0x7F)
        _
        a(adc_imm, 0x01)
        _
        a(bvs, "test.exit")

        _
        a(ldx_imm, 0xAA)
        _
        a(brk)
        _
        a(nop)

        _
        a("test.exit")
        _
        a(ldx_imm, 0xBB)

        self.run_test()
        self.assertEquals(0xBB, self.cpu.x)
Example #14
0
    def test_run(self):
        suite.banner(self.test_run) 
        self.run_test("""\
a(jsr, 'WELCOME')
a(rts) 
r""")
        self.assertEquals('Welcome to the Mach-8!', self.results[-4])
Example #15
0
 def test_fac2str_08(self):
     suite.banner(self.test_fac2str_08) 
     self.mem[memmap.FAC0_MANTISSA:m0_end] = [0x70, 0x56, 0x34, 0x12]
     self.mem[memmap.FAC0_EXPONENT] = 1
     self.mem[memmap.FAC0_SIGN] = aliases.SIGN_EXPONENT
     self.run_test() 
     self.assertEquals('0.1234567', self.output.getvalue())   
Example #16
0
    def test_adc_16(self):
        suite.banner(self.test_adc_16) 
        a = self.a
        
        _;      a.remark    ('Add $2312')
        _;      a(lda_imm,  0x12)
        _;      a(sta_zp,   0xa0)
        _;      a(lda_imm,  0x23)
        _;      a(sta_zp,   0xa1)
        
        _;      a.remark    ('to $3322')
        _;      a(lda_imm,  0x22)
        _;      a(sta_zp,   0xa2)
        _;      a(lda_imm,  0x33)
        _;      a(sta_zp,   0xa3) 
        
        _;      a.remark    ('Perform addition')
        _;      a(clc)
        _;      a(lda_zp,  0xa0)
        _;      a(adc_zp,  0xa2)
        _;      a(sta_zp,  0xa4)
        _;      a(lda_zp,  0xa1)
        _;      a(adc_zp,  0xa3)
        _;      a(sta_zp,  0xa5)

        _;      a.remark    ('equals $5634')        
        _;      a(ldx_zp,  0xa4)
        _;      a(ldy_zp,  0xa5)
        
        self.run_test()
        self.assertEquals(0x34, self.cpu.x) 
        self.assertEquals(0x56, self.cpu.y)
Example #17
0
 def test_fac2str_09(self):
     suite.banner(self.test_fac2str_09)
     self.mem[memmap.FAC0_MANTISSA:m0_end] = [0x00, 0x00, 0x10, 0x42]
     self.mem[memmap.FAC0_EXPONENT] = 2
     self.mem[memmap.FAC0_SIGN] = aliases.SIGN_EXPONENT
     self.run_test() 
     self.assertEquals('0.0421', self.output.getvalue())  
Example #18
0
 def test_sbc_16(self):
     suite.banner(self.test_sbc_16) 
     a = self.a
     
     _;      a.remark    ('From $3322')
     _;      a(lda_imm,  0x22)
     _;      a(sta_zp,   0xa0)
     _;      a(lda_imm,  0x33)
     _;      a(sta_zp,   0xa1)
     
     _;      a.remark    ('subtract $1012')
     _;      a(lda_imm,  0x12)
     _;      a(sta_zp,   0xa2)
     _;      a(lda_imm,  0x10)
     _;      a(sta_zp,   0xa3) 
     
     _;      a.remark    ('Perform subtraction')
     _;      a(sec)
     _;      a(lda_zp,   0xa0)
     _;      a(sbc_zp,   0xa2)
     _;      a(sta_zp,   0xa4)
     _;      a(lda_zp,   0xa1)
     _;      a(sbc_zp,   0xa3)
     _;      a(sta_zp,   0xa5)
     
     _;      a.remark    ('equals $2310')
     _;      a(ldx_zp,   0xa4)
     _;      a(ldy_zp,   0xa5)
     
     self.run_test()
     self.assertEquals(0x10, self.cpu.x) 
     self.assertEquals(0x23, self.cpu.y)
Example #19
0
    def test_continue(self):
        suite.banner(self.test_continue) 
        self.run_test("""\
m(0x5000, 0x50ff)
m""")
        self.assertTrue(self.results[-18].startswith('$5100'))
        self.assertTrue(self.results[-3].startswith('$51f0')) 
Example #20
0
    def test_line0(self):
        suite.banner(self.test_line0)
        result = memory.dump(self.mem, 0x00, 0x0f) 
        suite.log.info(result) 
        self.assertEquals("""
$0000: 41 42 43 44 45 46 47 48  49 4a 4b 4c 4d 4e 4f 50  ABCDEFGHIJKLMNOP
""".strip(), result)
Example #21
0
    def test_linein_long(self):
        suite.banner(self.test_linein_long)
        a = self.a

        termin = mock.TerminalInput("*" * 256)
        self.comp.terminal_input.source = termin
        self.cpu.cycle_limit = 10000

        _
        a.macro(ldxy_imm, "test.abort")
        _
        a.macro(stxy_abs, "YAP_ABORT_VECTOR")
        _
        a(jsr, "LINEIN")
        _
        a(lda_zp, "ERRNO")
        _
        a(brk)
        _
        a(nop)

        _
        a("test.abort")
        _
        a(rts)

        self.run_test()
        self.assertEquals(aliases.ERR_STRING_TOO_LONG, self.cpu.a)
Example #22
0
    def test_line1(self):
        suite.banner(self.test_line1) 
        result = memory.dump(self.mem, 0x10, 0x1f) 
        suite.log.info(result) 
        self.assertEquals("""
$0010: 61 62 63 64 65 66 67 68  69 6a 6b 6c 6d 6e 6f 70  abcdefghijklmnop
""".strip(), result) 
 def test_data_branch(self):
     suite.banner(self.test_data_branch)
     self.mem[0x2000] = 0x80
     self.mem[0x2001] = 0xFE
     result = self.d.next()
     suite.log.info(str(result))
     self.assertEquals("$2000: 80 fe     bra $2000", str(result).strip())
Example #24
0
    def test_partial_line(self):
        suite.banner(self.test_partial_line) 
        result = memory.dump(self.mem, 0x07, 0x0d)
        suite.log.info(result) 
        self.assertEquals("""
$0000:                      48  49 4a 4b 4c 4d 4e               HIJKLMN  
""".strip(), result)
 def test_abs_expression(self):
     suite.banner(self.test_abs_expression)
     self.a.label("foo", 0x1000)
     self.a(lda_abs, add("foo", x16(0x234)))
     result = self.d.next()
     suite.log.info(str(result))
     self.assertEquals("$2000: ad 34 12  lda [foo + $0234]", str(result).strip())
Example #26
0
 def test_fac2str_11(self):
     suite.banner(self.test_fac2str_11) 
     self.mem[memmap.FAC0_MANTISSA:m0_end] = [0x00, 0x00, 0x00, 0x40]
     self.mem[memmap.FAC0_EXPONENT] = 8
     self.mem[memmap.FAC0_SIGN] = aliases.SIGN_EXPONENT
     self.run_test() 
     self.assertEquals('4.000000E-08', self.output.getvalue())   
 def test_text_arg(self):
     suite.banner(self.test_text_arg)
     self.d.instruction = jmp_abs
     self.d.bytes = [jmp_abs.opcode, 0x34, 0x12]
     self.d.argument = 'argument'
     suite.log.info(str(self.d)) 
     self.assertEquals("    $a1b2: 4c 34 12  jmp argument", str(self.d)) 
Example #28
0
 def test_fac2str_14(self):
     suite.banner(self.test_fac2str_14) 
     self.mem[memmap.FAC0_MANTISSA:m0_end] = [0x00, 0x00, 0x00, 0x10]
     self.mem[memmap.FAC0_EXPONENT] = 1
     self.run_test() 
     self.assertEquals('10', self.output.getvalue()) 
     
Example #29
0
 def test_trap(self):
     suite.banner(self.test_trap) 
     a = self.a 
     
     _;      a.data  (x8(0x02)) 
     
     self.assertRaises(x6502.IllegalInstructionError, self.run_test)
Example #30
0
 def test_txtout(self):
     suite.banner(self.test_txtout) 
     a = self.a 
     
     _;      a(ldx_imm,  0)
     
     _;  a('test.loop')
     _;      a(lda_abx,  'test.str')
     _;      a(sta_abx,  'TEXT_WORK')
     _;      a(beq,      'test.done')
     _;      a(inx)
     _;      a(bra,      'test.loop')
     
     _;  a('test.done')
     _;      a(jsr,      'TXTOUT')
     _;      a(brk)
     _;      a(nop)
     
     _;  a('test.str')
     _;      a.data      ('123456')
     
     self.run_test()         
     self.assertEquals('123456', self.output.getvalue())