//! Tests for formatting functions.

use std::fmt;

use std::mem;

use std::vec;

use std::testing;

use std::sys::unix;

// fmt /////////////////////////////////////////////////////////////////////////

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatU32(0, &mut buffer[..]);

    try testing::expect(result.len == 1);

    try testing::expectBytesEq(result, "0");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatU32(123, &mut buffer[..]);

    try testing::expect(result.len == 3);

    try testing::expectBytesEq(result, "123");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatU32(90000, &mut buffer[..]);

    try testing::expect(result.len == 5);

    try testing::expectBytesEq(result, "90000");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatU32(4294967295, &mut buffer[..]);

    try testing::expect(result.len == 10);

    try testing::expectBytesEq(result, "4294967295");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatI32(456, &mut buffer[..]);

    try testing::expect(result.len == 3);

    try testing::expectBytesEq(result, "456");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatI32(-789, &mut buffer[..]);

    try testing::expect(result.len == 4);

    try testing::expectBytesEq(result, "-789");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatI32(0, &mut buffer[..]);

    try testing::expect(result.len == 1);

    try testing::expectBytesEq(result, "0");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatI32(2147483647, &mut buffer[..]);

    try testing::expect(result.len == 10);

    try testing::expectBytesEq(result, "2147483647");

}

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

    let mut buffer: [u8; 11] = [0; 11];

    let result: *[u8] = fmt::formatI32(-2147483648, &mut buffer[..]);

    try testing::expect(result.len == 11);

    try testing::expectBytesEq(result, "-2147483648");

}

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

    let mut buffer: [u8; 20] = [0; 20];

    let result: *[u8] = fmt::formatU64(0, &mut buffer[..]);

    try testing::expect(result.len == 1);

    try testing::expectBytesEq(result, "0");

}

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

    let mut buffer: [u8; 20] = [0; 20];

    let result: *[u8] = fmt::formatU64(18446744073709551615, &mut buffer[..]);

    try testing::expect(result.len == 20);

    try testing::expectBytesEq(result, "18446744073709551615");

}

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

    let mut buffer: [u8; 20] = [0; 20];

    let result: *[u8] = fmt::formatI64(-9876543210, &mut buffer[..]);

    try testing::expect(result.len == 11);

    try testing::expectBytesEq(result, "-9876543210");

}

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

    let mut buffer: [u8; 20] = [0; 20];

    let result: *[u8] = fmt::formatI64(-9223372036854775808, &mut buffer[..]);

    try testing::expect(result.len == 20);

    try testing::expectBytesEq(result, "-9223372036854775808");

}

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

    let dec = try fmt::parseInt("123") catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(dec.magnitude == 123);

    try testing::expect(dec.radix == fmt::Radix::Decimal);

    let hex = try fmt::parseInt("0x2a") catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(hex.magnitude == 42);

    try testing::expect(hex.radix == fmt::Radix::Hex);

    let bin = try fmt::parseInt("0b101") catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(bin.magnitude == 5);

    try testing::expect(bin.radix == fmt::Radix::Binary);

}

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

    let zero = fmt::digitFromAscii('0', 10) else throw testing::TestError::Failed;

    try testing::expect(zero == 0);

    let nine = fmt::digitFromAscii('9', 10) else throw testing::TestError::Failed;

    try testing::expect(nine == 9);

    let lower = fmt::digitFromAscii('a', 16) else throw testing::TestError::Failed;

    try testing::expect(lower == 10);

    let lowerF = fmt::digitFromAscii('f', 16) else throw testing::TestError::Failed;

    try testing::expect(lowerF == 15);

    let upper = fmt::digitFromAscii('A', 16) else throw testing::TestError::Failed;

    try testing::expect(upper == 10);

    let upperF = fmt::digitFromAscii('F', 16) else throw testing::TestError::Failed;

    try testing::expect(upperF == 15);

    try testing::expect(fmt::digitFromAscii('g', 16) == nil);

    try testing::expect(fmt::digitFromAscii('_', 10) == nil);

}

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

    try fmt::parseInt("") catch {

        return;

    };

    throw testing::TestError::Failed;

}

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

    try fmt::parseInt("-1") catch {

        try fmt::parseInt("+1") catch {

            return;

        };

    };

    throw testing::TestError::Failed;

}

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

    try fmt::parseInt("0b2") catch {

        return;

    };

    throw testing::TestError::Failed;

}

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

    try fmt::parseInt("18446744073709551616") catch {

        return;

    };

    throw testing::TestError::Failed;

}

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

    let x = try fmt::parseChar("'x'") catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(x == 'x');

    let newline = try fmt::parseChar("'\\n'") catch {

        throw testing::TestError::Failed;

    };

    try testing::expect(newline == '\n');

}

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

    try fmt::parseChar("''") catch {

        return;

    };

    throw testing::TestError::Failed;

}

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

    let mut buffer: [u8; 8] = [0; 8];

    let len = fmt::unescapeString("a\\n\\0", &mut buffer[..]);

    try testing::expect(len == 3);

    try testing::expect(buffer[0] == 'a');

    try testing::expect(buffer[1] == '\n');

    try testing::expect(buffer[2] == 0);

}

// mem /////////////////////////////////////////////////////////////////////////

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

    let mut xs: [u8; 3] = [1, 2, 3];

    let mut ys: [u8; 3] = [4, 5, 6];

    try! mem::copy(&mut xs[..], &ys[..]);

    try testing::expectBytesEq(&xs[..], &ys[..]);

    try testing::expectBytesEq(&xs[..], &[4, 5, 6]);

}

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

    let mut xs: [u8; 3] = [1, 2, 3];

    try! mem::copy(&mut xs[..2], &[8, 9]);

    try testing::expectBytesEq(&xs[..], &[8, 9, 3]);

}

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

    let mut xs: [u8; 3] = [1, 2, 3];

    try! mem::copy(&mut xs[..], &[7]);

    try testing::expectBytesEq(&xs[..], &[7, 2, 3]);

}

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

    let mut xs: [u8; 2] = [1, 2];

    let ys: [u8; 3] = [4, 5, 6];

    let mut threw = false;

    try mem::copy(&mut xs[..], &ys[..]) catch {

        set threw = true;

    };

    try testing::expect(threw);

}

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

    let path = "/tmp/radiance-std-write-file-parts.test";

    let mut buffer: [u8; 16] = undefined;

    if not unix::writeFileParts(path, &["hello", " ", "world"]) {

        throw testing::TestError::Failed;

    }

    let data = unix::readFile(path, &mut buffer[..]) else {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(data, "hello world");

}

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

    let input: *[u8] = "hello world";

    let prefix: *[u8] = "hello";

    let result = mem::stripPrefix(prefix, input) else {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(result, " world");

}

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

    let input: *[u8] = "hello world";

    let prefix: *[u8] = "goodbye";

    let result = mem::stripPrefix(prefix, input);

    try testing::expect(result == nil);

}

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

    let input: *[u8] = "hello";

    let prefix: *[u8] = "";

    let result = mem::stripPrefix(prefix, input) else {

        throw testing::TestError::Failed;

    };

    try testing::expectBytesEq(result, input);

}

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

    let input: *[u8] = "hi";

    let prefix: *[u8] = "hello";

    let result = mem::stripPrefix(prefix, input);

    try testing::expect(result == nil);

}

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

    let a: *[u8] = "abc";

    let b: *[u8] = "abc";

    try testing::expect(mem::eq(a, b));

}

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

    let a: *[u8] = "abc";

    let b: *[u8] = "abd";

    try testing::expectNot(mem::eq(a, b));

}

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

    let a: *[u8] = "abc";

    let b: *[u8] = "abcd";

    try testing::expectNot(mem::eq(a, b));

}

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

    let a: *[u8] = "";

    let b: *[u8] = "";

    try testing::expect(mem::eq(a, b));

}

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

    try testing::expect(mem::cmp("abc", "abc") == 0);

}

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

    try testing::expect(mem::cmp("abc", "abd") < 0);

}

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

    try testing::expect(mem::cmp("abd", "abc") > 0);

}

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

    try testing::expect(mem::cmp("abc", "abcd") < 0);

    try testing::expect(mem::cmp("abcd", "abc") > 0);

}

// vec /////////////////////////////////////////////////////////////////////////

/// Mixed-width value used by vector tests.

record Obj {

    /// Wide field.

    wide: u64,

    /// Narrow field.

    narrow: u8,

}

instantiate vec::Vec⟨i32⟩,

            vec::init⟨i32⟩,

            vec::len⟨i32⟩,

            vec::capacity⟨i32⟩,

            vec::reset⟨i32⟩,

            vec::get⟨i32⟩,

            vec::push⟨i32⟩,

            vec::put⟨i32⟩,

            vec::pop⟨i32⟩;

instantiate vec::Vec⟨Obj⟩,

            vec::init⟨Obj⟩,

            vec::get⟨Obj⟩,

            vec::push⟨Obj⟩,

            vec::put⟨Obj⟩;

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

    let mut arena: [i32; 4] = undefined;

    let mut v: vec::Vec⟨i32⟩ = undefined;

    vec::init⟨i32⟩(&mut v, &mut arena[..]);

    assert vec::len⟨i32⟩(&v) == 0;

    assert vec::capacity⟨i32⟩(&v) == 4;

}

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

    let mut arena: [i32; 3] = undefined;

    let mut v: vec::Vec⟨i32⟩ = undefined;

    vec::init⟨i32⟩(&mut v, &mut arena[..]);

    assert vec::push⟨i32⟩(&mut v, 10);

    assert vec::push⟨i32⟩(&mut v, 20);

    assert vec::push⟨i32⟩(&mut v, 30);

    assert not vec::push⟨i32⟩(&mut v, 40);

    let first = vec::get⟨i32⟩(&v, 0)

        else throw testing::TestError::Failed;

    assert *first == 10;

    assert vec::get⟨i32⟩(&v, 3) == nil;

    assert vec::put⟨i32⟩(&mut v, 1, 999);

    let replaced = vec::get⟨i32⟩(&v, 1)

        else throw testing::TestError::Failed;

    assert *replaced == 999;

    assert not vec::put⟨i32⟩(&mut v, 3, 1);

}

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

    let mut arena: [i32; 2] = undefined;

    let mut v: vec::Vec⟨i32⟩ = undefined;

    vec::init⟨i32⟩(&mut v, &mut arena[..]);

    assert vec::push⟨i32⟩(&mut v, 42);

    assert vec::push⟨i32⟩(&mut v, 100);

    assert vec::pop⟨i32⟩(&mut v) == 100;

    assert vec::pop⟨i32⟩(&mut v) == 42;

    assert vec::pop⟨i32⟩(&mut v) == nil;

    assert vec::push⟨i32⟩(&mut v, 7);

    vec::reset⟨i32⟩(&mut v);

    assert vec::len⟨i32⟩(&v) == 0;

}

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

    let mut arena: [Obj; 2] = undefined;

    let mut v: vec::Vec⟨Obj⟩ = undefined;

    vec::init⟨Obj⟩(&mut v, &mut arena[..]);

    assert vec::push⟨Obj⟩(&mut v, Obj { wide: 9, narrow: 1 });

    assert vec::put⟨Obj⟩(&mut v, 0, Obj { wide: 12, narrow: 2 });

    let pair = vec::get⟨Obj⟩(&v, 0)

        else throw testing::TestError::Failed;

    assert pair.wide == 12;

    assert pair.narrow == 2;

}