use std::mem;

use std::testing;

use std::lang::strings;

/// String pool used by assembler scanner tests.

static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Create a scanner for test input.

fn testScanner(source: *[u8]) -> super::Scanner {

    return super::scanner(super::SourceKind::String, source, &mut TEST_STRING_POOL);

}

/// Scanner recognizes assembler-specific sigils and scoped names.

@test fn testScanRegisterDirectiveAndLabelTokens() throws (testing::TestError) {

    let mut s = testScanner(

        ".text %sp @entry name::tail 42"

    );

    let directive = super::next(&mut s);

    try testing::expect(directive.kind == super::TokenKind::Directive);

    try testing::expect(mem::eq(directive.source, ".text"));

    let reg = super::next(&mut s);

    try testing::expect(reg.kind == super::TokenKind::Register);

    try testing::expect(mem::eq(reg.source, "%sp"));

    let label = super::next(&mut s);

    try testing::expect(label.kind == super::TokenKind::Label);

    try testing::expect(mem::eq(label.source, "@entry"));

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::ColonColon);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Number);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);

}

/// Keyword-shaped text remains plain assembler identifiers.

@test fn testScanKeywordShapedAsmNamesRemainAsmTokens() throws (testing::TestError) {

    let mut s = testScanner(

        "and or not align addi .text @label"

    );

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Directive);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Label);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);

}

/// Quoted labels can spell symbol names that are not identifier-shaped.

@test fn testScanQuotedLabelToken() throws (testing::TestError) {

    let mut s = testScanner(

        "@\"foo.bar.baz\""

    );

    let label = super::next(&mut s);

    try testing::expect(label.kind == super::TokenKind::QuotedLabel);

    try testing::expect(mem::eq(label.source, "@\"foo.bar.baz\""));

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);

}

/// Sigil-prefixed tokens require the name to start immediately after the sigil.

@test fn testScanSigilsRequireAdjacency() throws (testing::TestError) {

    let mut regScan = testScanner("% a0");

    try testing::expect(super::next(&mut regScan).kind == super::TokenKind::Invalid);

    let mut labelScan = testScanner("@ entry");

    try testing::expect(super::next(&mut labelScan).kind == super::TokenKind::Invalid);

    let mut directiveScan = testScanner(". text");

    try testing::expect(super::next(&mut directiveScan).kind == super::TokenKind::Invalid);

}

/// Scanner reaches EOF after trailing whitespace and comments.

@test fn testScanProgramEndingWithNewline() throws (testing::TestError) {

    let mut s = testScanner(

        ".text;\n@start\naddi %a0 %zero 42;\nsd %a0 8(%sp);\n// comment\nbeq %a0 %zero @done;\n@done\nret;\n"

    );

    loop {

        let tok = super::next(&mut s);

        if tok.kind == super::TokenKind::Eof {

            try testing::expect(tok.source.len == 0);

            return;

        }

    }

}

/// Signed numbers scan only the numeric formats supported by the assembler scanner.

@test fn testScanSignedHexAndUnsupportedNumericForms() throws (testing::TestError) {

    let mut s = testScanner(

        "+0x2a -0b10 45.5"

    );

    let mut tok = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "+0x2a"));

    set tok = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "-0"));

    set tok = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Ident);

    try testing::expect(mem::eq(tok.source, "b10"));

    set tok = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "45"));

    set tok = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(tok.source, "expected directive name after `.`"));

    set tok = super::next(&mut s);

    try testing::expect(tok.kind == super::TokenKind::Number);

    try testing::expect(mem::eq(tok.source, "5"));

}

/// Unterminated string and character literals report invalid tokens.

@test fn testScanUnterminatedDelimitedLiterals() throws (testing::TestError) {

    let mut stringScan = testScanner("\"unterminated");

    let stringTok = super::next(&mut stringScan);

    try testing::expect(stringTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(stringTok.source, "unterminated string"));

    let mut escapedStringScan = testScanner("\"unterminated\\");

    let escapedStringTok = super::next(&mut escapedStringScan);

    try testing::expect(escapedStringTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(escapedStringTok.source, "unterminated string"));

    let mut charScan = testScanner("'x");

    let charTok = super::next(&mut charScan);

    try testing::expect(charTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(charTok.source, "unterminated character"));

    let mut escapedCharScan = testScanner("'\\");

    let escapedCharTok = super::next(&mut escapedCharScan);

    try testing::expect(escapedCharTok.kind == super::TokenKind::Invalid);

    try testing::expect(mem::eq(escapedCharTok.source, "unterminated character"));

}