use ggbasm::parser::parse_asm;
use ggbasm::ast::*;

#[test]
fn test_empty() {
    assert_eq!(parse_asm("").unwrap().as_slice(), &[]);
}

#[test]
fn test_single_newline() {
    let result: Vec<Instruction> = parse_asm("\n").unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(Instruction::EmptyLine));
}

#[test]
fn test_two_newline() {
    let result: Vec<Instruction> = parse_asm("\n\n").unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::EmptyLine,
    ));
}

#[test]
fn test_two_newline_and_space() {
    let result: Vec<Instruction> = parse_asm("\n   \n").unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::EmptyLine,
    ));
}

#[test]
fn test_final_newline_missing() {
    let result: Vec<Instruction> = parse_asm("nop\nnop\nnop").unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::Nop,
        Instruction::Nop,
        Instruction::Nop,
    ));
}

#[test]
fn test_final_newline_included() {
    let result: Vec<Instruction> = parse_asm("nop\nnop\nnop\n").unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::Nop,
        Instruction::Nop,
        Instruction::Nop,
    ));
}

#[test]
fn test_whacky_line_handling() {
    let text = r#" nop
label:
    nop

0this_complicated_id3ntifi3r:

nop

    that:
foo:

; comment at start of line
;
     ; comment after whitespace
        nop ; comment after command
   label:; comment after label
nop ; comment after command
label2: ; some very important message

  stop    ; another comment
    ; the following lines has whitespace afterwards
    nop        
stop    
whitespace_following: 
xor 13   ; instructions ending with expression need to handle spaces at the end
xor a    ; instructions ending with registers need to handle spaces at the end
xor [hl] ; instructions ending with [hl] need to handle spaces at the end
xor a,42 ; minimal spaces
xor a, 42 ; regular spaces
xor     a   ,    42 ; lots of spaces
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::Nop,
        Instruction::Label(String::from("label")),
        Instruction::Nop,
        Instruction::EmptyLine,
        Instruction::Label(String::from("0this_complicated_id3ntifi3r")),
        Instruction::EmptyLine,
        Instruction::Nop,
        Instruction::EmptyLine,
        Instruction::Label(String::from("that")),
        Instruction::Label(String::from("foo")),
        Instruction::EmptyLine,
        Instruction::EmptyLine,
        Instruction::EmptyLine,
        Instruction::EmptyLine,
        Instruction::Nop,
        Instruction::Label(String::from("label")),
        Instruction::Nop,
        Instruction::Label(String::from("label2")),
        Instruction::EmptyLine,
        Instruction::Stop,
        Instruction::EmptyLine,
        Instruction::Nop,
        Instruction::Stop,
        Instruction::Label(String::from("whitespace_following")),
        Instruction::XorI8 (Expr::Const(13)),
        Instruction::XorR8 (Reg8::A),
        Instruction::XorMRhl,
        Instruction::XorI8 (Expr::Const(42)),
        Instruction::XorI8 (Expr::Const(42)),
        Instruction::XorI8 (Expr::Const(42)),
    ));
}

#[test]
fn test_simple_instructions() {
    let text = r#"
    nop
    stop
    halt
    di
    ei
    rrca
    rra
    cpl
    ccf
    rlca
    rla
    daa
    scf
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Nop,
        Instruction::Stop,
        Instruction::Halt,
        Instruction::Di,
        Instruction::Ei,
        Instruction::Rrca,
        Instruction::Rra,
        Instruction::Cpl,
        Instruction::Ccf,
        Instruction::Rlca,
        Instruction::Rla,
        Instruction::Daa,
        Instruction::Scf,
    ));
}

#[test]
fn test_exprs_simple() {
    let text = r#"
    jp foo_bar
    jp -foo
    jp foo + bar
    jp foo - bar
    jp foo * bar
    jp foo / bar
    jp foo % bar
    jp foo & bar
    jp foo | bar
    jp foo ^ bar

    jp foo-42
    jp 413*1111
    jp foo /0x40
    jp foo% bar

    jp z, foo_bar
    jp z, foo + bar
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::JpI16 (Flag::Always, Expr::Ident (String::from("foo_bar"))),
        Instruction::JpI16 (Flag::Always, Expr::unary(Expr::Ident(String::from("foo")), UnaryOperator::Minus)),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Sub, Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Mul, Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Div, Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Rem, Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::And, Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Or,  Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Xor, Expr::Ident(String::from("bar")))),
        Instruction::EmptyLine,
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Sub, Expr::Const(42))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Const(413),                 BinaryOperator::Mul, Expr::Const(1111))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Div, Expr::Const(0x40))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Rem, Expr::Ident(String::from("bar")))),
        Instruction::EmptyLine,
        Instruction::JpI16 (Flag::Z, Expr::Ident (String::from("foo_bar"))),
        Instruction::JpI16 (Flag::Z, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::Ident(String::from("bar")))),
    ));
}

#[test]
fn test_exprs_complex() {
    let text = r#"
    jp (foo + bar)
    jp (foo + bar) + baz
    jp foo + (bar + baz)
    jp foo * (bar + baz)
    jp (foo + bar) * baz
    jp ((foo + bar) * baz)
    jp (foo * -bar)
    jp ((-foo + bar) * baz)
    jp foo + bar * baz
    jp foo + bar / baz
    jp foo + bar % baz
    jp foo * bar + baz
    jp foo / bar + baz
    jp foo % bar + baz
    jp foo % bar ^ baz
    jp foo - bar & baz
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::Ident(String::from("bar")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::Ident(String::from("bar"))), BinaryOperator::Add, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::binary(Expr::Ident(String::from("bar")), BinaryOperator::Add, Expr::Ident(String::from("baz"))))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Mul, Expr::binary(Expr::Ident(String::from("bar")), BinaryOperator::Add, Expr::Ident(String::from("baz"))))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::Ident(String::from("bar"))), BinaryOperator::Mul, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::Ident(String::from("bar"))), BinaryOperator::Mul, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Mul, Expr::unary(Expr::Ident(String::from("bar")), UnaryOperator::Minus))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::unary(Expr::Ident(String::from("foo")), UnaryOperator::Minus), BinaryOperator::Add, Expr::Ident(String::from("bar"))), BinaryOperator::Mul, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::binary(Expr::Ident(String::from("bar")), BinaryOperator::Mul, Expr::Ident(String::from("baz"))))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::binary(Expr::Ident(String::from("bar")), BinaryOperator::Div, Expr::Ident(String::from("baz"))))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Add, Expr::binary(Expr::Ident(String::from("bar")), BinaryOperator::Rem, Expr::Ident(String::from("baz"))))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Mul, Expr::Ident(String::from("bar"))), BinaryOperator::Add, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Div, Expr::Ident(String::from("bar"))), BinaryOperator::Add, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Rem, Expr::Ident(String::from("bar"))), BinaryOperator::Add, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Rem, Expr::Ident(String::from("bar"))), BinaryOperator::Xor, Expr::Ident(String::from("baz")))),
        Instruction::JpI16 (Flag::Always, Expr::binary(Expr::binary(Expr::Ident(String::from("foo")), BinaryOperator::Sub, Expr::Ident(String::from("bar"))), BinaryOperator::And, Expr::Ident(String::from("baz")))),
    ));
}

#[test]
fn test_ret() {
    let text = r#"
    ret Z
    ret NZ
    ret C
    ret NC
    ret
    reti
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Ret (Flag::Z),
        Instruction::Ret (Flag::NZ),
        Instruction::Ret (Flag::C),
        Instruction::Ret (Flag::NC),
        Instruction::Ret (Flag::Always),
        Instruction::Reti,
    ));
}

#[test]
fn test_call() {
    let text = r#"
    call Z, foobar
    call NZ, 0x1337
    call C, 0
    call NC, 42
    call 413
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Call (Flag::Z, Expr::Ident(String::from("foobar"))),
        Instruction::Call (Flag::NZ, Expr::Const(0x1337)),
        Instruction::Call (Flag::C, Expr::Const(0)),
        Instruction::Call (Flag::NC, Expr::Const(42)),
        Instruction::Call (Flag::Always, Expr::Const(413)),
    ));
}

#[test]
fn test_equ() {
    let text = r#"
    foo equ bar
    bar EQU 0xFF
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Equ (String::from("foo"), Expr::Ident(String::from("bar"))),
        Instruction::Equ (String::from("bar"), Expr::Const(0xFF)),
    ));
}

#[test]
fn test_db() {
    let text = r#"
    db 0
    db 255
    db 42
    db 0x42
    db 0x0
    db 0xB
    db 0x00
    db 0xFF
    db 0x04, 0x13
    db 0, 1
    db 0, 0, 1, 2, 3, 4
    db 0, 0x1, 2, 0x3, 5, 0x4
    db "a"
    db "Hello World!"
    db "hi", 0x13, 37
    db 4, 13, "hammers"
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Db (vec!(0)),
        Instruction::Db (vec!(255)),
        Instruction::Db (vec!(42)),
        Instruction::Db (vec!(0x42)),
        Instruction::Db (vec!(0x00)),
        Instruction::Db (vec!(0x0B)),
        Instruction::Db (vec!(0x00)),
        Instruction::Db (vec!(0xFF)),
        Instruction::Db (vec!(0x04, 0x13)),
        Instruction::Db (vec!(0, 1)),
        Instruction::Db (vec!(0, 0, 1, 2, 3, 4)),
        Instruction::Db (vec!(0, 1, 2, 3, 5, 4)),
        Instruction::Db (vec!(0x61)),
        Instruction::Db (vec!(0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21)),
        Instruction::Db (vec!(0x68, 0x69, 0x13, 37)),
        Instruction::Db (vec!(4, 13, 0x68, 0x61, 0x6d, 0x6d, 0x65, 0x72, 0x73)),
    ));
}

#[test]
fn test_dw() {
    let text = r#"
    dw 0
    dw 413
    dw 65535
    dw 0x0
    dw 0xE
    dw 0x13
    dw 0x413
    dw 0x0000
    dw 0xFFFF
    dw 0x1337
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Db (vec!(0x00, 0x00)),
        Instruction::Db (vec!(0x9d, 0x01)),
        Instruction::Db (vec!(0xFF, 0xFF)),
        Instruction::Db (vec!(0x00, 0x00)),
        Instruction::Db (vec!(0x0E, 0x00)),
        Instruction::Db (vec!(0x13, 0x00)),
        Instruction::Db (vec!(0x13, 0x04)),
        Instruction::Db (vec!(0x00, 0x00)),
        Instruction::Db (vec!(0xFF, 0xFF)),
        Instruction::Db (vec!(0x37, 0x13)),
    ));
}

#[test]
fn test_advance_address() {
    let text = r#"
    advance_address 0
    advance_address 0x0
    advance_address 413
    advance_address 0x1337
    advance_address 0xFFFF
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::AdvanceAddress (0),
        Instruction::AdvanceAddress (0x0),
        Instruction::AdvanceAddress (413),
        Instruction::AdvanceAddress (0x1337),
        Instruction::AdvanceAddress (0xFFFF),
    ));
}

#[test]
fn test_invalid_instruction() {
    let text = r#"
    nop

    foobar

    nop
    stop that
    nop
    stopthat
    nop
a b c d
"#;
    assert_eq!(parse_asm(text).unwrap(), vec!(
        Some(Instruction::EmptyLine),
        Some(Instruction::Nop),
        Some(Instruction::EmptyLine),
        None,
        Some(Instruction::EmptyLine),
        Some(Instruction::Nop),
        None,
        Some(Instruction::Nop),
        None,
        Some(Instruction::Nop),
        None,
    ));
}

#[test]
fn test_jp() {
    let text = r#"
    jp 0x150
    jp nz, foo_bar
    jp z, 413
    jp nc, 1111
    jp c, 42
    jp hl
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::JpI16 (Flag::Always, Expr::Const (0x0150)),
        Instruction::JpI16 (Flag::NZ,     Expr::Ident (String::from("foo_bar"))),
        Instruction::JpI16 (Flag::Z,      Expr::Const (413)),
        Instruction::JpI16 (Flag::NC,     Expr::Const (1111)),
        Instruction::JpI16 (Flag::C,      Expr::Const (42)),
        Instruction::JpRhl,
    ));
}

#[test]
fn test_jr() {
    let text = r#"
    jr 0x42
    jr nz, foo_bar
    jr z, 255
    jr nc, 11
    jr c, 42
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Jr (Flag::Always, Expr::Const (0x42)),
        Instruction::Jr (Flag::NZ,     Expr::Ident (String::from("foo_bar"))),
        Instruction::Jr (Flag::Z,      Expr::Const (255)),
        Instruction::Jr (Flag::NC,     Expr::Const (11)),
        Instruction::Jr (Flag::C,      Expr::Const (42)),
    ));
}

#[test]
fn test_inc_dec() {
    let text = r#"
    inc BC
    inc DE
    inc HL
    inc SP
    inc A
    inc B
    inc C
    inc D
    inc E
    inc H
    inc L
    inc [hl]
    dec BC
    dec DE
    dec HL
    dec SP
    dec A
    dec B
    dec C
    dec D
    dec E
    dec H
    dec L
    dec [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::IncR16 (Reg16::BC),
        Instruction::IncR16 (Reg16::DE),
        Instruction::IncR16 (Reg16::HL),
        Instruction::IncR16 (Reg16::SP),
        Instruction::IncR8  (Reg8::A),
        Instruction::IncR8  (Reg8::B),
        Instruction::IncR8  (Reg8::C),
        Instruction::IncR8  (Reg8::D),
        Instruction::IncR8  (Reg8::E),
        Instruction::IncR8  (Reg8::H),
        Instruction::IncR8  (Reg8::L),
        Instruction::IncMRhl,
        Instruction::DecR16 (Reg16::BC),
        Instruction::DecR16 (Reg16::DE),
        Instruction::DecR16 (Reg16::HL),
        Instruction::DecR16 (Reg16::SP),
        Instruction::DecR8  (Reg8::A),
        Instruction::DecR8  (Reg8::B),
        Instruction::DecR8  (Reg8::C),
        Instruction::DecR8  (Reg8::D),
        Instruction::DecR8  (Reg8::E),
        Instruction::DecR8  (Reg8::H),
        Instruction::DecR8  (Reg8::L),
        Instruction::DecMRhl,
    ));
}

#[test]
fn test_add() {
    let text = r#"
    add 0xFF
    add [hl]
    add a
    add b
    add c
    add d
    add e
    add h
    add l

    add a, 0xFF
    add a, [hl]
    add a, a
    add a, b
    add a, c
    add a, d
    add a, e
    add a, h
    add a, l

    add hl, bc
    add hl, de
    add hl, hl
    add hl, sp
    add sp, 2
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::AddI8 (Expr::Const(0xFF)),
        Instruction::AddMRhl,
        Instruction::AddR8 (Reg8::A),
        Instruction::AddR8 (Reg8::B),
        Instruction::AddR8 (Reg8::C),
        Instruction::AddR8 (Reg8::D),
        Instruction::AddR8 (Reg8::E),
        Instruction::AddR8 (Reg8::H),
        Instruction::AddR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::AddI8 (Expr::Const(0xFF)),
        Instruction::AddMRhl,
        Instruction::AddR8 (Reg8::A),
        Instruction::AddR8 (Reg8::B),
        Instruction::AddR8 (Reg8::C),
        Instruction::AddR8 (Reg8::D),
        Instruction::AddR8 (Reg8::E),
        Instruction::AddR8 (Reg8::H),
        Instruction::AddR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::AddRhlR16 (Reg16::BC),
        Instruction::AddRhlR16 (Reg16::DE),
        Instruction::AddRhlR16 (Reg16::HL),
        Instruction::AddRhlR16 (Reg16::SP),
        Instruction::AddRspI8 (Expr::Const(2)),
    ));
}

#[test]
fn test_sub() {
    let text = r#"
    sub 0xFF
    sub [hl]
    sub a
    sub b
    sub c
    sub d
    sub e
    sub h
    sub l

    sub a, 0xFF
    sub a, [hl]
    sub a, a
    sub a, b
    sub a, c
    sub a, d
    sub a, e
    sub a, h
    sub a, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::SubI8 (Expr::Const(0xFF)),
        Instruction::SubMRhl,
        Instruction::SubR8 (Reg8::A),
        Instruction::SubR8 (Reg8::B),
        Instruction::SubR8 (Reg8::C),
        Instruction::SubR8 (Reg8::D),
        Instruction::SubR8 (Reg8::E),
        Instruction::SubR8 (Reg8::H),
        Instruction::SubR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::SubI8 (Expr::Const(0xFF)),
        Instruction::SubMRhl,
        Instruction::SubR8 (Reg8::A),
        Instruction::SubR8 (Reg8::B),
        Instruction::SubR8 (Reg8::C),
        Instruction::SubR8 (Reg8::D),
        Instruction::SubR8 (Reg8::E),
        Instruction::SubR8 (Reg8::H),
        Instruction::SubR8 (Reg8::L),
    ));
}

#[test]
fn test_and() {
    let text = r#"
    and 0xFF
    and [hl]
    and a
    and b
    and c
    and d
    and e
    and h
    and l

    and a, 0xFF
    and a, [hl]
    and a, a
    and a, b
    and a, c
    and a, d
    and a, e
    and a, h
    and a, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::AndI8 (Expr::Const(0xFF)),
        Instruction::AndMRhl,
        Instruction::AndR8 (Reg8::A),
        Instruction::AndR8 (Reg8::B),
        Instruction::AndR8 (Reg8::C),
        Instruction::AndR8 (Reg8::D),
        Instruction::AndR8 (Reg8::E),
        Instruction::AndR8 (Reg8::H),
        Instruction::AndR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::AndI8 (Expr::Const(0xFF)),
        Instruction::AndMRhl,
        Instruction::AndR8 (Reg8::A),
        Instruction::AndR8 (Reg8::B),
        Instruction::AndR8 (Reg8::C),
        Instruction::AndR8 (Reg8::D),
        Instruction::AndR8 (Reg8::E),
        Instruction::AndR8 (Reg8::H),
        Instruction::AndR8 (Reg8::L),
    ));
}

#[test]
fn test_or() {
    let text = r#"
    or 0xFF
    or [hl]
    or a
    or b
    or c
    or d
    or e
    or h
    or l

    or a, 0xFF
    or a, [hl]
    or a, a
    or a, b
    or a, c
    or a, d
    or a, e
    or a, h
    or a, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::OrI8 (Expr::Const(0xFF)),
        Instruction::OrMRhl,
        Instruction::OrR8 (Reg8::A),
        Instruction::OrR8 (Reg8::B),
        Instruction::OrR8 (Reg8::C),
        Instruction::OrR8 (Reg8::D),
        Instruction::OrR8 (Reg8::E),
        Instruction::OrR8 (Reg8::H),
        Instruction::OrR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::OrI8 (Expr::Const(0xFF)),
        Instruction::OrMRhl,
        Instruction::OrR8 (Reg8::A),
        Instruction::OrR8 (Reg8::B),
        Instruction::OrR8 (Reg8::C),
        Instruction::OrR8 (Reg8::D),
        Instruction::OrR8 (Reg8::E),
        Instruction::OrR8 (Reg8::H),
        Instruction::OrR8 (Reg8::L),
    ));
}

#[test]
fn test_adc() {
    let text = r#"
    adc 0xFF
    adc [hl]
    adc a
    adc b
    adc c
    adc d
    adc e
    adc h
    adc l

    adc a, 0xFF
    adc a, [hl]
    adc a, a
    adc a, b
    adc a, c
    adc a, d
    adc a, e
    adc a, h
    adc a, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::AdcI8 (Expr::Const(0xFF)),
        Instruction::AdcMRhl,
        Instruction::AdcR8 (Reg8::A),
        Instruction::AdcR8 (Reg8::B),
        Instruction::AdcR8 (Reg8::C),
        Instruction::AdcR8 (Reg8::D),
        Instruction::AdcR8 (Reg8::E),
        Instruction::AdcR8 (Reg8::H),
        Instruction::AdcR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::AdcI8 (Expr::Const(0xFF)),
        Instruction::AdcMRhl,
        Instruction::AdcR8 (Reg8::A),
        Instruction::AdcR8 (Reg8::B),
        Instruction::AdcR8 (Reg8::C),
        Instruction::AdcR8 (Reg8::D),
        Instruction::AdcR8 (Reg8::E),
        Instruction::AdcR8 (Reg8::H),
        Instruction::AdcR8 (Reg8::L),
    ));
}

#[test]
fn test_sbc() {
    let text = r#"
    sbc 0xFF
    sbc [hl]
    sbc a
    sbc b
    sbc c
    sbc d
    sbc e
    sbc h
    sbc l

    sbc a, 0xFF
    sbc a, [hl]
    sbc a, a
    sbc a, b
    sbc a, c
    sbc a, d
    sbc a, e
    sbc a, h
    sbc a, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::SbcI8 (Expr::Const(0xFF)),
        Instruction::SbcMRhl,
        Instruction::SbcR8 (Reg8::A),
        Instruction::SbcR8 (Reg8::B),
        Instruction::SbcR8 (Reg8::C),
        Instruction::SbcR8 (Reg8::D),
        Instruction::SbcR8 (Reg8::E),
        Instruction::SbcR8 (Reg8::H),
        Instruction::SbcR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::SbcI8 (Expr::Const(0xFF)),
        Instruction::SbcMRhl,
        Instruction::SbcR8 (Reg8::A),
        Instruction::SbcR8 (Reg8::B),
        Instruction::SbcR8 (Reg8::C),
        Instruction::SbcR8 (Reg8::D),
        Instruction::SbcR8 (Reg8::E),
        Instruction::SbcR8 (Reg8::H),
        Instruction::SbcR8 (Reg8::L),
    ));
}

#[test]
fn test_xor() {
    let text = r#"
    xor 0xFF
    xor [hl]
    xor a
    xor b
    xor c
    xor d
    xor e
    xor h
    xor l

    xor a, 0xFF
    xor a, [hl]
    xor a, a
    xor a, b
    xor a, c
    xor a, d
    xor a, e
    xor a, h
    xor a, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::XorI8 (Expr::Const(0xFF)),
        Instruction::XorMRhl,
        Instruction::XorR8 (Reg8::A),
        Instruction::XorR8 (Reg8::B),
        Instruction::XorR8 (Reg8::C),
        Instruction::XorR8 (Reg8::D),
        Instruction::XorR8 (Reg8::E),
        Instruction::XorR8 (Reg8::H),
        Instruction::XorR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::XorI8 (Expr::Const(0xFF)),
        Instruction::XorMRhl,
        Instruction::XorR8 (Reg8::A),
        Instruction::XorR8 (Reg8::B),
        Instruction::XorR8 (Reg8::C),
        Instruction::XorR8 (Reg8::D),
        Instruction::XorR8 (Reg8::E),
        Instruction::XorR8 (Reg8::H),
        Instruction::XorR8 (Reg8::L),
    ));
}

#[test]
fn test_cp() {
    let text = r#"
    cp 0xFF
    cp [hl]
    cp a
    cp b
    cp c
    cp d
    cp e
    cp h
    cp l

    cp a, 0xFF
    cp a, [hl]
    cp a, a
    cp a, b
    cp a, c
    cp a, d
    cp a, e
    cp a, h
    cp a, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::CpI8 (Expr::Const(0xFF)),
        Instruction::CpMRhl,
        Instruction::CpR8 (Reg8::A),
        Instruction::CpR8 (Reg8::B),
        Instruction::CpR8 (Reg8::C),
        Instruction::CpR8 (Reg8::D),
        Instruction::CpR8 (Reg8::E),
        Instruction::CpR8 (Reg8::H),
        Instruction::CpR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::CpI8 (Expr::Const(0xFF)),
        Instruction::CpMRhl,
        Instruction::CpR8 (Reg8::A),
        Instruction::CpR8 (Reg8::B),
        Instruction::CpR8 (Reg8::C),
        Instruction::CpR8 (Reg8::D),
        Instruction::CpR8 (Reg8::E),
        Instruction::CpR8 (Reg8::H),
        Instruction::CpR8 (Reg8::L),
    ));
}

#[test]
fn test_ld_r8_r8() {
    let text = r#"
    ld a, a
    ld a, b
    ld a, c
    ld a, d
    ld a, e
    ld a, h
    ld a, l
    ld b, a
    ld b, b
    ld b, c
    ld b, d
    ld b, e
    ld b, h
    ld b, l
    ld c, a
    ld c, b
    ld c, c
    ld c, d
    ld c, e
    ld c, h
    ld c, l
    ld d, a
    ld d, b
    ld d, c
    ld d, d
    ld d, e
    ld d, h
    ld d, l
    ld e, a
    ld e, b
    ld e, c
    ld e, d
    ld e, e
    ld e, h
    ld e, l
    ld h, a
    ld h, b
    ld h, c
    ld h, d
    ld h, e
    ld h, h
    ld h, l
    ld l, a
    ld l, b
    ld l, c
    ld l, d
    ld l, e
    ld l, h
    ld l, l
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::LdR8R8 (Reg8::A, Reg8::A),
        Instruction::LdR8R8 (Reg8::A, Reg8::B),
        Instruction::LdR8R8 (Reg8::A, Reg8::C),
        Instruction::LdR8R8 (Reg8::A, Reg8::D),
        Instruction::LdR8R8 (Reg8::A, Reg8::E),
        Instruction::LdR8R8 (Reg8::A, Reg8::H),
        Instruction::LdR8R8 (Reg8::A, Reg8::L),
        Instruction::LdR8R8 (Reg8::B, Reg8::A),
        Instruction::LdR8R8 (Reg8::B, Reg8::B),
        Instruction::LdR8R8 (Reg8::B, Reg8::C),
        Instruction::LdR8R8 (Reg8::B, Reg8::D),
        Instruction::LdR8R8 (Reg8::B, Reg8::E),
        Instruction::LdR8R8 (Reg8::B, Reg8::H),
        Instruction::LdR8R8 (Reg8::B, Reg8::L),
        Instruction::LdR8R8 (Reg8::C, Reg8::A),
        Instruction::LdR8R8 (Reg8::C, Reg8::B),
        Instruction::LdR8R8 (Reg8::C, Reg8::C),
        Instruction::LdR8R8 (Reg8::C, Reg8::D),
        Instruction::LdR8R8 (Reg8::C, Reg8::E),
        Instruction::LdR8R8 (Reg8::C, Reg8::H),
        Instruction::LdR8R8 (Reg8::C, Reg8::L),
        Instruction::LdR8R8 (Reg8::D, Reg8::A),
        Instruction::LdR8R8 (Reg8::D, Reg8::B),
        Instruction::LdR8R8 (Reg8::D, Reg8::C),
        Instruction::LdR8R8 (Reg8::D, Reg8::D),
        Instruction::LdR8R8 (Reg8::D, Reg8::E),
        Instruction::LdR8R8 (Reg8::D, Reg8::H),
        Instruction::LdR8R8 (Reg8::D, Reg8::L),
        Instruction::LdR8R8 (Reg8::E, Reg8::A),
        Instruction::LdR8R8 (Reg8::E, Reg8::B),
        Instruction::LdR8R8 (Reg8::E, Reg8::C),
        Instruction::LdR8R8 (Reg8::E, Reg8::D),
        Instruction::LdR8R8 (Reg8::E, Reg8::E),
        Instruction::LdR8R8 (Reg8::E, Reg8::H),
        Instruction::LdR8R8 (Reg8::E, Reg8::L),
        Instruction::LdR8R8 (Reg8::H, Reg8::A),
        Instruction::LdR8R8 (Reg8::H, Reg8::B),
        Instruction::LdR8R8 (Reg8::H, Reg8::C),
        Instruction::LdR8R8 (Reg8::H, Reg8::D),
        Instruction::LdR8R8 (Reg8::H, Reg8::E),
        Instruction::LdR8R8 (Reg8::H, Reg8::H),
        Instruction::LdR8R8 (Reg8::H, Reg8::L),
        Instruction::LdR8R8 (Reg8::L, Reg8::A),
        Instruction::LdR8R8 (Reg8::L, Reg8::B),
        Instruction::LdR8R8 (Reg8::L, Reg8::C),
        Instruction::LdR8R8 (Reg8::L, Reg8::D),
        Instruction::LdR8R8 (Reg8::L, Reg8::E),
        Instruction::LdR8R8 (Reg8::L, Reg8::H),
        Instruction::LdR8R8 (Reg8::L, Reg8::L),
    ));
}

#[test]
fn test_ld() {
    let text = r#"
    ld BC, 0x0413
    ld BC, something
    ld DE, 0x413
    ld HL, 0x413
    ld SP, 0x413

    ld [0x3535], sp
    ld [ 0x3535 ], sp
    ld [0x3535  ], sp
    ld [    0x3535], sp
    ld [    0x3535  ], sp

    ld a, 0xFF
    ld b, foo
    ld c, 0x10
    ld d, 42
    ld e, 42
    ld h, 42
    ld l, 42

    ld [bc], a
    ld [de], a
    ld a, [bc]
    ld a, [de]

    ldi [hl], a
    ldd [hl], a
    ldi a, [hl]
    ldd a, [hl]

    ld [hl], 42

    ld a, [hl]
    ld b, [hl]
    ld c, [hl]
    ld d, [hl]
    ld e, [hl]
    ld h, [hl]
    ld l, [hl]

    ld [hl], a
    ld [hl], b
    ld [hl], c
    ld [hl], d
    ld [hl], e
    ld [hl], h
    ld [hl], l

    ld [0xFF00 + 42], a
    ld [0xFF00+42], a
    ld a, [0xFF00 + 42]
    ld a, [0xFF00+42]

    ld [0xFF00 + c], a
    ld [0xFF00+c], a
    ld [  0xFF00   +   c   ], a
    ld a, [0xFF00 + c]
    ld a, [0xFF00+c]

    ld hl, sp+13
    ld hl, sp + 13
    ld sp, hl
    ld [0x413], a
    ld a, [0x0413]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::LdR16I16 (Reg16::BC, Expr::Const (0x0413)),
        Instruction::LdR16I16 (Reg16::BC, Expr::Ident (String::from("something"))),
        Instruction::LdR16I16 (Reg16::DE, Expr::Const (0x0413)),
        Instruction::LdR16I16 (Reg16::HL, Expr::Const (0x0413)),
        Instruction::LdR16I16 (Reg16::SP, Expr::Const (0x0413)),
        Instruction::EmptyLine,
        Instruction::LdMI16Rsp (Expr::Const (0x3535)),
        Instruction::LdMI16Rsp (Expr::Const (0x3535)),
        Instruction::LdMI16Rsp (Expr::Const (0x3535)),
        Instruction::LdMI16Rsp (Expr::Const (0x3535)),
        Instruction::LdMI16Rsp (Expr::Const (0x3535)),
        Instruction::EmptyLine,
        Instruction::LdR8I8 (Reg8::A, Expr::Const (0xFF)),
        Instruction::LdR8I8 (Reg8::B, Expr::Ident (String::from("foo"))),
        Instruction::LdR8I8 (Reg8::C, Expr::Const (0x10)),
        Instruction::LdR8I8 (Reg8::D, Expr::Const (42)),
        Instruction::LdR8I8 (Reg8::E, Expr::Const (42)),
        Instruction::LdR8I8 (Reg8::H, Expr::Const (42)),
        Instruction::LdR8I8 (Reg8::L, Expr::Const (42)),
        Instruction::EmptyLine,
        Instruction::LdMRbcRa,
        Instruction::LdMRdeRa,
        Instruction::LdRaMRbc,
        Instruction::LdRaMRde,
        Instruction::EmptyLine,
        Instruction::LdiMRhlRa,
        Instruction::LddMRhlRa,
        Instruction::LdiRaMRhl,
        Instruction::LddRaMRhl,
        Instruction::EmptyLine,
        Instruction::LdMRhlI8 (Expr::Const (42)),
        Instruction::EmptyLine,
        Instruction::LdR8MRhl (Reg8::A),
        Instruction::LdR8MRhl (Reg8::B),
        Instruction::LdR8MRhl (Reg8::C),
        Instruction::LdR8MRhl (Reg8::D),
        Instruction::LdR8MRhl (Reg8::E),
        Instruction::LdR8MRhl (Reg8::H),
        Instruction::LdR8MRhl (Reg8::L),
        Instruction::EmptyLine,
        Instruction::LdMRhlR8 (Reg8::A),
        Instruction::LdMRhlR8 (Reg8::B),
        Instruction::LdMRhlR8 (Reg8::C),
        Instruction::LdMRhlR8 (Reg8::D),
        Instruction::LdMRhlR8 (Reg8::E),
        Instruction::LdMRhlR8 (Reg8::H),
        Instruction::LdMRhlR8 (Reg8::L),
        Instruction::EmptyLine,
        Instruction::LdhMI8Ra (Expr::Const (42)),
        Instruction::LdhMI8Ra (Expr::Const (42)),
        Instruction::LdhRaMI8 (Expr::Const (42)),
        Instruction::LdhRaMI8 (Expr::Const (42)),
        Instruction::EmptyLine,
        Instruction::LdhMRcRa,
        Instruction::LdhMRcRa,
        Instruction::LdhMRcRa,
        Instruction::LdhRaMRc,
        Instruction::LdhRaMRc,
        Instruction::EmptyLine,
        Instruction::LdRhlRspI8 (Expr::Const (13)),
        Instruction::LdRhlRspI8 (Expr::Const (13)),
        Instruction::LdRspRhl,
        Instruction::LdMI16Ra (Expr::Const (0x413)),
        Instruction::LdRaMI16 (Expr::Const (0x413)),
    ));
}

#[test]
fn test_push_pop() {
    let text = r#"
    push BC
    push DE
    push HL
    push AF
    pop BC
    pop DE
    pop HL
    pop AF
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::Push (Reg16Push::BC),
        Instruction::Push (Reg16Push::DE),
        Instruction::Push (Reg16Push::HL),
        Instruction::Push (Reg16Push::AF),
        Instruction::Pop  (Reg16Push::BC),
        Instruction::Pop  (Reg16Push::DE),
        Instruction::Pop  (Reg16Push::HL),
        Instruction::Pop  (Reg16Push::AF),
    ));
}

#[test]
fn test_rlc() {
    let text = r#"
    rlc a
    rlc b
    rlc c
    rlc d
    rlc e
    rlc h
    rlc l
    rlc [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::RlcR8   (Reg8::A),
        Instruction::RlcR8   (Reg8::B),
        Instruction::RlcR8   (Reg8::C),
        Instruction::RlcR8   (Reg8::D),
        Instruction::RlcR8   (Reg8::E),
        Instruction::RlcR8   (Reg8::H),
        Instruction::RlcR8   (Reg8::L),
        Instruction::RlcMRhl,
    ));
}

#[test]
fn test_rrc() {
    let text = r#"
    rrc a
    rrc b
    rrc c
    rrc d
    rrc e
    rrc h
    rrc l
    rrc [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::RrcR8   (Reg8::A),
        Instruction::RrcR8   (Reg8::B),
        Instruction::RrcR8   (Reg8::C),
        Instruction::RrcR8   (Reg8::D),
        Instruction::RrcR8   (Reg8::E),
        Instruction::RrcR8   (Reg8::H),
        Instruction::RrcR8   (Reg8::L),
        Instruction::RrcMRhl,
    ));
}

#[test]
fn test_rl() {
    let text = r#"
    rl a
    rl b
    rl c
    rl d
    rl e
    rl h
    rl l
    rl [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::RlR8   (Reg8::A),
        Instruction::RlR8   (Reg8::B),
        Instruction::RlR8   (Reg8::C),
        Instruction::RlR8   (Reg8::D),
        Instruction::RlR8   (Reg8::E),
        Instruction::RlR8   (Reg8::H),
        Instruction::RlR8   (Reg8::L),
        Instruction::RlMRhl,
    ));
}

#[test]
fn test_rr() {
    let text = r#"
    rr a
    rr b
    rr c
    rr d
    rr e
    rr h
    rr l
    rr [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::RrR8   (Reg8::A),
        Instruction::RrR8   (Reg8::B),
        Instruction::RrR8   (Reg8::C),
        Instruction::RrR8   (Reg8::D),
        Instruction::RrR8   (Reg8::E),
        Instruction::RrR8   (Reg8::H),
        Instruction::RrR8   (Reg8::L),
        Instruction::RrMRhl,
    ));
}

#[test]
fn test_sla() {
    let text = r#"
    sla a
    sla b
    sla c
    sla d
    sla e
    sla h
    sla l
    sla [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::SlaR8   (Reg8::A),
        Instruction::SlaR8   (Reg8::B),
        Instruction::SlaR8   (Reg8::C),
        Instruction::SlaR8   (Reg8::D),
        Instruction::SlaR8   (Reg8::E),
        Instruction::SlaR8   (Reg8::H),
        Instruction::SlaR8   (Reg8::L),
        Instruction::SlaMRhl,
    ));
}

#[test]
fn test_sra() {
    let text = r#"
    sra a
    sra b
    sra c
    sra d
    sra e
    sra h
    sra l
    sra [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::SraR8   (Reg8::A),
        Instruction::SraR8   (Reg8::B),
        Instruction::SraR8   (Reg8::C),
        Instruction::SraR8   (Reg8::D),
        Instruction::SraR8   (Reg8::E),
        Instruction::SraR8   (Reg8::H),
        Instruction::SraR8   (Reg8::L),
        Instruction::SraMRhl,
    ));
}

#[test]
fn test_swap() {
    let text = r#"
    swap a
    swap b
    swap c
    swap d
    swap e
    swap h
    swap l
    swap [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::SwapR8   (Reg8::A),
        Instruction::SwapR8   (Reg8::B),
        Instruction::SwapR8   (Reg8::C),
        Instruction::SwapR8   (Reg8::D),
        Instruction::SwapR8   (Reg8::E),
        Instruction::SwapR8   (Reg8::H),
        Instruction::SwapR8   (Reg8::L),
        Instruction::SwapMRhl,
    ));
}

#[test]
fn test_srl() {
    let text = r#"
    srl a
    srl b
    srl c
    srl d
    srl e
    srl h
    srl l
    srl [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::SrlR8   (Reg8::A),
        Instruction::SrlR8   (Reg8::B),
        Instruction::SrlR8   (Reg8::C),
        Instruction::SrlR8   (Reg8::D),
        Instruction::SrlR8   (Reg8::E),
        Instruction::SrlR8   (Reg8::H),
        Instruction::SrlR8   (Reg8::L),
        Instruction::SrlMRhl,
    ));
}

#[test]
fn test_bit_bit_r8() {
    let text = r#"
    bit 2, a
    bit 2, b
    bit 2, c
    bit 2, d
    bit 2, e
    bit 2, h
    bit 2, l
    bit 2, [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::BitBitR8   (Expr::Const(2), Reg8::A),
        Instruction::BitBitR8   (Expr::Const(2), Reg8::B),
        Instruction::BitBitR8   (Expr::Const(2), Reg8::C),
        Instruction::BitBitR8   (Expr::Const(2), Reg8::D),
        Instruction::BitBitR8   (Expr::Const(2), Reg8::E),
        Instruction::BitBitR8   (Expr::Const(2), Reg8::H),
        Instruction::BitBitR8   (Expr::Const(2), Reg8::L),
        Instruction::BitBitMRhl (Expr::Const(2)),
    ));
}

#[test]
fn test_res_bit_r8() {
    let text = r#"
    res 2, a
    res 2, b
    res 2, c
    res 2, d
    res 2, e
    res 2, h
    res 2, l
    res 2, [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::ResBitR8   (Expr::Const(2), Reg8::A),
        Instruction::ResBitR8   (Expr::Const(2), Reg8::B),
        Instruction::ResBitR8   (Expr::Const(2), Reg8::C),
        Instruction::ResBitR8   (Expr::Const(2), Reg8::D),
        Instruction::ResBitR8   (Expr::Const(2), Reg8::E),
        Instruction::ResBitR8   (Expr::Const(2), Reg8::H),
        Instruction::ResBitR8   (Expr::Const(2), Reg8::L),
        Instruction::ResBitMRhl (Expr::Const(2)),
    ));
}

#[test]
fn test_set_bit_r8() {
    let text = r#"
    set 2, a
    set 2, b
    set 2, c
    set 2, d
    set 2, e
    set 2, h
    set 2, l
    set 2, [hl]
"#;
    let result: Vec<Instruction> = parse_asm(text).unwrap().into_iter().map(|x| x.unwrap()).collect();
    assert_eq!(result, vec!(
        Instruction::EmptyLine,
        Instruction::SetBitR8   (Expr::Const(2), Reg8::A),
        Instruction::SetBitR8   (Expr::Const(2), Reg8::B),
        Instruction::SetBitR8   (Expr::Const(2), Reg8::C),
        Instruction::SetBitR8   (Expr::Const(2), Reg8::D),
        Instruction::SetBitR8   (Expr::Const(2), Reg8::E),
        Instruction::SetBitR8   (Expr::Const(2), Reg8::H),
        Instruction::SetBitR8   (Expr::Const(2), Reg8::L),
        Instruction::SetBitMRhl (Expr::Const(2)),
    ));
}