m68000 0.2.2

A Motorola 68000 interpreter, disassembler and assembler (code emitter)
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

use m68000::MemoryAccess;

use std::panic::catch_unwind;

#[test]
fn memory_access_slice() {
    let mut mem8 = [0xFFu8; 12];
    let mut mem16 = [0xFFFFu16; 6];

    for i in 0..4 {
        let iu8 = i as u8;

        let _ = mem8.set_byte(i, iu8);
        assert_eq!(iu8, mem8.get_byte(i).unwrap());
        assert_eq!(iu8, (&mem8 as &[u8]).get_byte(i).unwrap());
        assert!(catch_unwind(|| (&mem8 as &[u8]).set_byte(0, 0)).is_err());

        let _ = mem16.set_byte(i, iu8);
        assert_eq!(iu8, mem16.get_byte(i).unwrap());
        assert_eq!(iu8, (&mem16 as &[u16]).get_byte(i).unwrap());
        assert!(catch_unwind(|| (&mem16 as &[u16]).set_byte(0, 0)).is_err());
    }

    for i in (4..8).step_by(2) {
        let iu16 = i as u16;

        let _ = mem8.set_word(i, iu16);
        assert_eq!(iu16, mem8.get_word(i).unwrap());
        assert_eq!(iu16, (&mem8 as &[u8]).get_word(i).unwrap());
        assert!(catch_unwind(|| (&mem8 as &[u8]).set_word(0, 0)).is_err());

        let _ = mem16.set_word(i, iu16);
        assert_eq!(iu16, mem16.get_word(i).unwrap());
        assert_eq!(iu16, (&mem16 as &[u16]).get_word(i).unwrap());
        assert!(catch_unwind(|| (&mem16 as &[u16]).set_word(0, 0)).is_err());
    }

    {
        let i = 8;
        let iu32 = i as u32;

        let _ = mem8.set_long(i, iu32);
        assert_eq!(iu32, mem8.get_long(i).unwrap());
        assert_eq!(iu32, (&mem8 as &[u8]).get_long(i).unwrap());
        assert!(catch_unwind(|| (&mem8 as &[u8]).set_long(0, 0)).is_err());

        let _ = mem16.set_long(i, iu32);
        assert_eq!(iu32, mem16.get_long(i).unwrap());
        assert_eq!(iu32, (&mem16 as &[u16]).get_long(i).unwrap());
        assert!(catch_unwind(|| (&mem16 as &[u16]).set_long(0, 0)).is_err());
    }

    let expected_mem8 = [0, 1, 2, 3, 0, 4, 0, 6, 0, 0, 0, 8];
    assert_eq!(expected_mem8, mem8);

    let expected_mem16 = [0x0001, 0x0203, 4, 6, 0, 8];
    assert_eq!(expected_mem16, mem16);

    assert!(catch_unwind(|| [0u8; 1].get_byte(1).unwrap()).is_err());
    assert!(catch_unwind(|| [0u8; 1].get_word(1).unwrap()).is_err());
    assert!(catch_unwind(|| [0u8; 1].get_long(1).unwrap()).is_err());
    assert!(catch_unwind(|| [0u8; 1].set_byte(1, 0).unwrap()).is_err());
    assert!(catch_unwind(|| [0u8; 1].set_word(1, 0).unwrap()).is_err());
    assert!(catch_unwind(|| [0u8; 1].set_long(1, 0).unwrap()).is_err());

    assert!(catch_unwind(|| [0u16; 1].get_byte(2).unwrap()).is_err());
    assert!(catch_unwind(|| [0u16; 1].get_word(2).unwrap()).is_err());
    assert!(catch_unwind(|| [0u16; 1].get_long(2).unwrap()).is_err());
    assert!(catch_unwind(|| [0u16; 1].set_byte(2, 0).unwrap()).is_err());
    assert!(catch_unwind(|| [0u16; 1].set_word(2, 0).unwrap()).is_err());
    assert!(catch_unwind(|| [0u16; 1].set_long(2, 0).unwrap()).is_err());
}