use std;
import str;

fn test(actual: str, expected: str) {
    log(debug, actual);
    log(debug, expected);
    assert (str::eq(actual, expected));
}

fn main() {
    test(#fmt["hello %d friends and %s things", 10, "formatted"],
         "hello 10 friends and formatted things");

    test(#fmt["test"], "test");

    // a quadratic optimization in LLVM (jump-threading) makes this test a
    // bit slow to compile unless we break it up
    part1();
    part2();
    part3();
    part4();
    part5();
    part6();
    percent();
    more_floats();
}

fn part1() {
    // Simple tests for types

    test(#fmt["%d", 1], "1");
    test(#fmt["%i", 2], "2");
    test(#fmt["%i", -1], "-1");
    test(#fmt["%u", 10u], "10");
    test(#fmt["%s", "test"], "test");
    test(#fmt["%b", true], "true");
    test(#fmt["%b", false], "false");
    test(#fmt["%c", 'A'], "A");
    test(#fmt["%x", 0xff_u], "ff");
    test(#fmt["%X", 0x12ab_u], "12AB");
    test(#fmt["%o", 10u], "12");
    test(#fmt["%t", 0b11010101_u], "11010101");
    test(#fmt["%f", 5.82], "5.82");
    // 32-bit limits

    test(#fmt["%i", -2147483648], "-2147483648");
    test(#fmt["%i", 2147483647], "2147483647");
    test(#fmt["%u", 4294967295u], "4294967295");
    test(#fmt["%x", 0xffffffff_u], "ffffffff");
    test(#fmt["%o", 0xffffffff_u], "37777777777");
    test(#fmt["%t", 0xffffffff_u], "11111111111111111111111111111111");
}
fn part2() {
    // Widths

    test(#fmt["%1d", 500], "500");
    test(#fmt["%10d", 500], "       500");
    test(#fmt["%10d", -500], "      -500");
    test(#fmt["%10u", 500u], "       500");
    test(#fmt["%10s", "test"], "      test");
    test(#fmt["%10b", true], "      true");
    test(#fmt["%10x", 0xff_u], "        ff");
    test(#fmt["%10X", 0xff_u], "        FF");
    test(#fmt["%10o", 10u], "        12");
    test(#fmt["%10t", 0xff_u], "  11111111");
    test(#fmt["%10c", 'A'], "         A");
    test(#fmt["%10f", 5.82], "      5.82");
    // Left justify

    test(#fmt["%-10d", 500], "500       ");
    test(#fmt["%-10d", -500], "-500      ");
    test(#fmt["%-10u", 500u], "500       ");
    test(#fmt["%-10s", "test"], "test      ");
    test(#fmt["%-10b", true], "true      ");
    test(#fmt["%-10x", 0xff_u], "ff        ");
    test(#fmt["%-10X", 0xff_u], "FF        ");
    test(#fmt["%-10o", 10u], "12        ");
    test(#fmt["%-10t", 0xff_u], "11111111  ");
    test(#fmt["%-10c", 'A'], "A         ");
    test(#fmt["%-10f", 5.82], "5.82      ");
}

fn part3() {
    // Precision

    test(#fmt["%.d", 0], "");
    test(#fmt["%.u", 0u], "");
    test(#fmt["%.x", 0u], "");
    test(#fmt["%.t", 0u], "");
    test(#fmt["%.d", 10], "10");
    test(#fmt["%.d", -10], "-10");
    test(#fmt["%.u", 10u], "10");
    test(#fmt["%.s", "test"], "");
    test(#fmt["%.x", 127u], "7f");
    test(#fmt["%.o", 10u], "12");
    test(#fmt["%.t", 3u], "11");
    test(#fmt["%.c", 'A'], "A");
    test(#fmt["%.f", 5.82], "6");
    test(#fmt["%.0d", 0], "");
    test(#fmt["%.0u", 0u], "");
    test(#fmt["%.0x", 0u], "");
    test(#fmt["%.0t", 0u], "");
    test(#fmt["%.0d", 10], "10");
    test(#fmt["%.0d", -10], "-10");
    test(#fmt["%.0u", 10u], "10");
    test(#fmt["%.0s", "test"], "");
    test(#fmt["%.0x", 127u], "7f");
    test(#fmt["%.0o", 10u], "12");
    test(#fmt["%.0t", 3u], "11");
    test(#fmt["%.0c", 'A'], "A");
    test(#fmt["%.0f", 5.892], "6");
    test(#fmt["%.1d", 0], "0");
    test(#fmt["%.1u", 0u], "0");
    test(#fmt["%.1x", 0u], "0");
    test(#fmt["%.1t", 0u], "0");
    test(#fmt["%.1d", 10], "10");
    test(#fmt["%.1d", -10], "-10");
    test(#fmt["%.1u", 10u], "10");
    test(#fmt["%.1s", "test"], "t");
    test(#fmt["%.1x", 127u], "7f");
    test(#fmt["%.1o", 10u], "12");
    test(#fmt["%.1t", 3u], "11");
    test(#fmt["%.1c", 'A'], "A");
    test(#fmt["%.1f", 5.82], "5.8");
}
fn part4() {
    test(#fmt["%.5d", 0], "00000");
    test(#fmt["%.5u", 0u], "00000");
    test(#fmt["%.5x", 0u], "00000");
    test(#fmt["%.5t", 0u], "00000");
    test(#fmt["%.5d", 10], "00010");
    test(#fmt["%.5d", -10], "-00010");
    test(#fmt["%.5u", 10u], "00010");
    test(#fmt["%.5s", "test"], "test");
    test(#fmt["%.5x", 127u], "0007f");
    test(#fmt["%.5o", 10u], "00012");
    test(#fmt["%.5t", 3u], "00011");
    test(#fmt["%.5c", 'A'], "A");
    test(#fmt["%.5f", 5.82], "5.82000");
    test(#fmt["%.5f", 5.0], "5.00000");
    // Bool precision. I'm not sure if it's good or bad to have bool
    // conversions support precision - it's not standard printf so we
    // can do whatever. For now I'm making it behave the same as string
    // conversions.

    test(#fmt["%.b", true], "");
    test(#fmt["%.0b", true], "");
    test(#fmt["%.1b", true], "t");
}

fn part5() {
    // Explicit + sign. Only for signed conversions

    test(#fmt["%+d", 0], "+0");
    test(#fmt["%+d", 1], "+1");
    test(#fmt["%+d", -1], "-1");
    test(#fmt["%+f", 0.0], "+0");
    // Leave space for sign

    test(#fmt["% d", 0], " 0");
    test(#fmt["% d", 1], " 1");
    test(#fmt["% d", -1], "-1");
    test(#fmt["% f", 0.0], " 0");
    // Plus overrides space

    test(#fmt["% +d", 0], "+0");
    test(#fmt["%+ d", 0], "+0");
    test(#fmt["% +f", 0.0], "+0");
    test(#fmt["%+ f", 0.0], "+0");
    // 0-padding

    test(#fmt["%05d", 0], "00000");
    test(#fmt["%05d", 1], "00001");
    test(#fmt["%05d", -1], "-0001");
    test(#fmt["%05u", 1u], "00001");
    test(#fmt["%05x", 127u], "0007f");
    test(#fmt["%05X", 127u], "0007F");
    test(#fmt["%05o", 10u], "00012");
    test(#fmt["%05t", 3u], "00011");
    test(#fmt["%05f", 5.82], "05.82");
    // 0-padding a string is undefined but glibc does this:

    test(#fmt["%05s", "test"], " test");
    test(#fmt["%05c", 'A'], "    A");
    test(#fmt["%05b", true], " true");
    // Left-justify overrides 0-padding

    test(#fmt["%-05d", 0], "0    ");
    test(#fmt["%-05d", 1], "1    ");
    test(#fmt["%-05d", -1], "-1   ");
    test(#fmt["%-05u", 1u], "1    ");
    test(#fmt["%-05x", 127u], "7f   ");
    test(#fmt["%-05X", 127u], "7F   ");
    test(#fmt["%-05o", 10u], "12   ");
    test(#fmt["%-05t", 3u], "11   ");
    test(#fmt["%-05s", "test"], "test ");
    test(#fmt["%-05c", 'A'], "A    ");
    test(#fmt["%-05b", true], "true ");
    test(#fmt["%-05f", 5.82], "5.82 ");
}
fn part6() {
    // Precision overrides 0-padding
    // FIXME #2481: Recent gcc's report some of these as warnings

    test(#fmt["%06.5d", 0], " 00000");
    test(#fmt["%06.5u", 0u], " 00000");
    test(#fmt["%06.5x", 0u], " 00000");
    test(#fmt["%06.5d", 10], " 00010");
    test(#fmt["%06.5d", -10], "-00010");
    test(#fmt["%06.5u", 10u], " 00010");
    test(#fmt["%06.5s", "test"], "  test");
    test(#fmt["%06.5c", 'A'], "     A");
    test(#fmt["%06.5x", 127u], " 0007f");
    test(#fmt["%06.5X", 127u], " 0007F");
    test(#fmt["%06.5o", 10u], " 00012");

    // Precision does not override zero-padding for floats
    test(#fmt["%08.5f", 5.82], "05.82000");

    // Signed combinations

    test(#fmt["% 5d", 1], "    1");
    test(#fmt["% 5d", -1], "   -1");
    test(#fmt["%+5d", 1], "   +1");
    test(#fmt["%+5d", -1], "   -1");
    test(#fmt["% 05d", 1], " 0001");
    test(#fmt["% 05d", -1], "-0001");
    test(#fmt["%+05d", 1], "+0001");
    test(#fmt["%+05d", -1], "-0001");
    test(#fmt["%- 5d", 1], " 1   ");
    test(#fmt["%- 5d", -1], "-1   ");
    test(#fmt["%-+5d", 1], "+1   ");
    test(#fmt["%-+5d", -1], "-1   ");
    test(#fmt["%- 05d", 1], " 1   ");
    test(#fmt["%- 05d", -1], "-1   ");
    test(#fmt["%-+05d", 1], "+1   ");
    test(#fmt["%-+05d", -1], "-1   ");
}

fn percent() {
    let s = #fmt["ab%%cd"];
    assert(s == "ab%cd");
}

fn more_floats() {
    assert "3.1416"      == #fmt["%.4f", 3.14159];
    assert "3"           == #fmt["%.0f", 3.14159];
    assert "99"          == #fmt["%.0f", 98.5];
    assert "7.0000"      == #fmt["%.4f", 6.999999999];
    assert "3.141590000" == #fmt["%.9f", 3.14159];
}