vm6502 0.1.1

A 6502 virtual machine backend.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use hex::decode;

use vm6502::prelude::*;

#[test]
fn test_vm_stack() {
    let mut vm = VirtualMachine::new();

    let test_vec: arrayvec::ArrayVec<u8, 0x0FF> =
        (0..0x0FF).map(|_| rand::random::<u8>()).collect();
    let test: [u8; 0x0FF] = test_vec.into_inner().unwrap();

    // Push backwards because the stack grows from 0x01FF to 0x100.
    for i in 0x0FF..0 {
        vm.push(test[i]);
    }

    eprintln!("Stack: {:?}", vm);

    for i in 0x0FF..0 {
        assert_ne!(test[0x0FF - i - 1], 0);
        assert_ne!(vm.flatmap[0x0100 + i], 0);
        assert_eq!(vm.flatmap[0x0100 + i], test[0x0FF - i - 1]);
        vm.pop();
        assert_eq!(vm.registers.ac, test[0x0FF - i - 1]);
        assert_ne!(vm.registers.ac, 0);
    }
}

#[test]
fn test_vm_write_stack() {
    let mut vm = VirtualMachine::new();

    let test_vec: arrayvec::ArrayVec<u8, 0x0FF> =
        (0..0x0FF).map(|_| rand::random::<u8>()).collect();
    let test: [u8; 0x0FF] = test_vec.into_inner().unwrap();

    for i in 0..0x0FF {
        vm.push(test[i]);
    }

    // TODO: For some reason stack isn't being written properly.
    eprintln!("VM: {:?}", vm);
    eprintln!("Test: {:?}", test);

    for i in 0x0ff..=0 {
        vm.pop();
        if test[i] != 0 {
            assert_ne!(vm.registers.ac, 0);
        }
        assert_eq!(vm.registers.ac, test[i]);
    }
}

#[test]
fn test_vm_stack_contig() {
    let mut vm = VirtualMachine::new();

    let test_vec: arrayvec::ArrayVec<u8, 0x0FF> =
        (0..0x0FF).map(|_| rand::random::<u8>()).collect();
    let test: [u8; 0x0FF] = test_vec.into_inner().unwrap();

    // Push backwards because the stack grows from 0x01FF to 0x100.
    for i in 0..0x0FF {
        vm.push(test[i]);
    }

    eprintln!("vm {:?}", vm);
    eprintln!("stack=0x0100..0x01FF: {:?}", &vm.flatmap[0x100..0x01FF]);

    for (i, byte) in test.iter().rev().enumerate() {
        eprintln!("i: {}, byte: 0x{:02X}", i, byte);
        assert_eq!(vm.flatmap[vm.stack_bounds.0 + i + 1], *byte);
    }
}

#[test]
fn test_vm_registers() {
    let mut vm = VirtualMachine::new();
    vm.registers.ac = 0x01;
    vm.registers.x = 0x02;
    vm.registers.y = 0x03;
    vm.registers.sr = 0x04;
    vm.registers.sp = 0x05;
    vm.registers.pc = 0x06;

    assert_eq!(vm.registers.ac, 0x01);
    assert_eq!(vm.registers.x, 0x02);
    assert_eq!(vm.registers.y, 0x03);
    assert_eq!(vm.registers.sr, 0x04);
    assert_eq!(vm.registers.sp, 0x05);
    assert_eq!(vm.registers.pc, 0x06);
}

#[test]
fn test_vm_status() {
    let mut vm = VirtualMachine::new();
    vm.reset_status();
    assert_eq!(vm.registers.sr, 0x00);

    for i in 0..0x07 {
        let sv = 1 << i;

        vm.set_status(Status::from(sv), true);
        vm.flip_status(Status::from(sv));
        assert_eq!(vm.get_status(Status::from(sv)), false);
    }
}

#[test]
fn test_vm_insert_program() {
    let mut vm = VirtualMachine::new();
    let prog = "BADA55AB5214BADA55AB5214BADA55AB5214BADA55AB5214BADA55AB5214BADA55AB5214";
    let decoded = decode(prog).unwrap();

    let offset = 0x0000;
    vm.insert_program(offset, prog);

    for (i, byte) in decoded.iter().enumerate() {
        eprintln!("i: {}, byte: 0x{:02X}", i, byte);
        assert_eq!(
            vm.flatmap[(vm.heap_bounds.0 as u16 + offset + i as u16) as usize],
            *byte
        );
    }
}