fn test_simple_string_interpolation() {
    a := 'Hello'
    b := 'World'
    res := '${a} ${b}'
    assert res == 'Hello World'
}

fn test_mixed_string_interpolation() {
    num := 7
    str := 'abc'
    s1 := 'number=${num}'
    assert s1 == 'number=7'
    s2 := 'string=${str}'
    assert s2 == 'string=abc'
    s3 := 'a: ${num} | b: ${str}'
    assert s3 == 'a: 7 | b: abc'
}

fn test_formatted_string_interpolation() {
    x := 'abc'
    axb := 'a:${x}:b'
    assert axb == 'a:abc:b'
    x_10 := 'a:${x:10s}:b'
    x10_ := 'a:${x:-10s}:b'
    assert x_10 == 'a:       abc:b'
    assert x10_ == 'a:abc       :b'
    i := 23
    si_right := '${i:10d}'
    si__left := '${i:-10d}'
    assert si_right == '        23'
    assert si__left == '23        '
}

fn test_dynamic_format_widths() {
    width := 10
    left_width := -10
    zero_width := 5
    sign_width := 6
    name := 'abc'
    num := 42
    assert '>${name:(width)}<' == '>       abc<'
    assert '>${name:(left_width)}<' == '>abc       <'
    assert '>${name:(-width)}<' == '>abc       <'
    assert '${num:0(zero_width)d}' == '00042'
    assert '${num:+(sign_width)d}' == '   +42'
}

fn test_dynamic_format_precision() {
    width := 8
    precision := 3
    value := 12.34567
    assert '>${value:(width).(precision)f}<' == '>  12.346<'
}

fn test_escape_dollar_in_string() {
    i := 42
    assert '(${i})' == '(42)'
    assert '(\$i)'.contains('i') && !'(\$i)'.contains('42')
    assert !'(\\${i})'.contains('i') && '(\\${i})'.contains('42') && '(\\${i})'.contains('\\')
    assert '(\\\$i)'.contains('i') && !'(\\\$i)'.contains('42') && '(\\${i})'.contains('\\')
    assert !'(\\\\${i})'.contains('i') && '(\\\\${i})'.contains('42')
        && '(\\\\${i})'.contains('\\\\')
    assert '(${i})' == '(42)'
    assert '(\${i})'.contains('i') && !'(\${i})'.contains('42')
    assert !'(\\${i})'.contains('i') && '(\\${i})'.contains('42') && '(\\${i})'.contains('\\')
    assert '(\\\${i})'.contains('i') && !'(\\\${i})'.contains('42') && '(\\${i})'.contains('\\')
    assert !'(\\\\${i})'.contains('i') && '(\\\\${i})'.contains('42')
        && '(\\\\${i})'.contains('\\\\')
    assert i == 42
}

fn test_dollar_sign_is_literal_without_braces() {
    b := 10
    text := 'a$b'
    assert text == 'a$b'
    assert b == 10
}

fn test_implicit_str() {
    i := 42
    assert 'int ${i}' == 'int 42'
    assert '${i}' == '42'
    check := '${i}' == '42'
    assert check
    text := '${i}' + '42'
    assert text == '4242'
}

fn test_string_interpolation_percent_escaping() {
    test := 'hello'
    hello := 'world'
    x := '%.*s${hello}${test} |${hello:-30s}|'
    assert x == '%.*sworldhello |world                         |'
}

fn test_string_interpolation_string_prefix() {
    // `r`, `c` and `js` are also used as a string prefix.
    r := 'r'
    rr := '${r}${r}'
    assert rr == 'rr'
    c := 'c'
    cc := '${c}${c}'
    assert cc == 'cc'
    js := 'js'
    jsjs := '${js}${js}'
    assert jsjs == 'jsjs'
}

fn test_interpolation_string_prefix_expr() {
    r := 1
    c := 2
    js := 1
    assert '>${3 + r}<' == '>4<'
    assert '${r == js} ${js}' == 'true 1'
    assert '>${js + c} ${js + r == c}<' == '>3 true<'
}

fn test_inttypes_string_interpolation() {
    c := i8(-103) // -0x67
    uc := u8(217) // 0xD9
    uc2 := u8(13) // 0x0D
    s := i16(-23456) // -0x5BA0
    us := u16(54321) // 0xD431
    i := -1622999040 // -0x60BD 0000
    ui := u32(3421958087) // 0xCBF6 EFC7
    vp := voidptr(ui)
    mut bp := &u8(unsafe { nil })
    unsafe {
        $if x64 {
            bp = &u8(15541149836) // 0x3 9E53 208C
        } $else {
            bp = &u8(3541149836) // 0xD311 A88C
        }
    }
    l := i64(-7694555558525237396)
    ul := u64(17234006112912956370)
    assert '${s} ${us}' == '-23456 54321'
    assert '${ui} ${i}' == '3421958087 -1622999040'
    assert '${l} ${ul}' == '-7694555558525237396 17234006112912956370'
    assert '>${s:11}:${us:-13}<' == '>     -23456:54321        <'
    assert '0x${ul:-19x}:${l:22d}' == '0xef2b7d4001165bd2   :  -7694555558525237396'
    assert '${c:5}${uc:-7}x' == ' -103217    x'
    assert '${c:x}:${uc:x}:${uc2:02X}' == '-67:d9:0D'
    assert '${s:X}:${us:x}:${u16(uc):04x}' == '-5BA0:d431:00d9'
    assert '${i:x}:${ui:X}:${int(s):x}' == '-60bd0000:CBF6EFC7:-5ba0'
    assert '${l:x}:${ul:X}' == '-6ac88d8352677894:EF2B7D4001165BD2'
    // default pointer format is platform dependent, so try a few
    eprintln("platform pointer format: '${vp:p}:${bp}'")
    $if x64 {
        assert '${vp:p}:${bp}' == '0xcbf6efc7:0x39e53208c'
            || '${vp:p}:${bp}' == 'CBF6EFC7:39E53208C' || '${vp:p}:${bp}' == 'cbf6efc7:39e53208c'
            || '${vp:p}:${bp}' == '00000000CBF6EFC7:000000039E53208C'
    } $else {
        assert '${vp:p}:${bp}' == 'CBF6EFC7:D311A88C' || '${vp:p}:${bp}' == 'cbf6efc7:d311a88c'
            || '${vp:p}:${bp}' == '0xcbf6efc7:0xd311a88c'
    }
}

fn int_ref_mut_string(mut n &int) string {
    return '${n}'
}

fn int_ref_string(n &int) string {
    return '${n}'
}

fn test_int_ref_string_interpolation() {
    mut count := 10
    count_ref := &count
    assert int_ref_mut_string(mut &count) == '10'
    assert int_ref_string(&count) == '10'
    assert '${count_ref}' == '10'
    assert '${&count}' == '10'
    assert '${count_ref:x}' == 'a'
}

fn test_utf8_string_interpolation() {
    a := 'à-côté'
    st := 'Sträßle'
    m := '10€'
    assert '${a} ${st} ${m}' == 'à-côté Sträßle 10€'
    zz := '>${a:10}< >${st:-8}< >${m:5}<-'
    zz_expected := '>    à-côté< >Sträßle < >  10€<-'
    eprintln('         zz: ${zz}')
    eprintln('zz_expected: ${zz_expected}')
    assert zz == zz_expected
    // e := '\u20AC' // Eurosign doesn' work with MSVC and tcc
    e := '€'
    assert '100.00 ${e}' == '100.00 €'
    m2 := 'Москва́' // cyrillic а́: combination of U+0430 and U+0301, UTF-8: d0 b0 cc 81
    d := 'Antonín Dvořák' // latin á: U+00E1, UTF-8: c3 a1
    assert ':${m2:7}:${d:-15}:' == ': Москва́:Antonín Dvořák :'
    g := 'Πελοπόννησος'
    assert '>${g:-13}<' == '>Πελοπόννησος <'
}

fn test_utf8_string_interpolation_uses_grapheme_clusters() {
    assert '>${'\u006E\u0303':10}<' == '>         ñ<'
    assert '>${'\U0001F3F3\uFE0F\u200D\U0001F308':10}<' == '>        🏳️‍🌈<'
    assert '>${'ห์':10}<' == '>         ห์<'
    assert '>${'ปีเตอร์':10}<' == '>     ปีเตอร์<'
    assert '>${'👩🏽‍💻':10}<' == '>        👩🏽‍💻<'
}

struct Sss {
    v1 int
    v2 f64
}

fn (s Sss) str() string {
    return '[${s.v1}, ${s.v2:.3f}]'
}

fn test_string_interpolation_str_evaluation() {
    mut x := Sss{17, 13.455893}
    assert '${x}' == '[17, 13.456]'
}

fn test_string_interpolation_with_negative_format_width_should_compile_and_run_without_segfaulting() {
    // discovered during debugging VLS
    i := 3
    input := '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}'
    eprintln('---------------------------------------------------------------------------------------------')
    eprintln('+60 ${i:10} | input.len: ${input.len:10} | ${input.hex():60} | ${input}')
    eprintln('-60 ${i:10} | input.len: ${input.len:10} | ${input.hex():-60} | ${input}')
    eprintln('---------------------------------------------------------------------------------------------')
    assert true
}

struct Aa {
    a int
}

struct Bb {
    b Aa
}

fn (x Bb) f() Aa {
    return x.b
}

fn test_method_interpolation() {
    y := Bb{
        b: Aa{
            a: 2
        }
    }
    assert '>${y.f().a}<' == '>2<'
    assert '>${y.f().a}<' == '>2<'
}

fn f(i int) int {
    return i
}

fn test_call() {
    s := '${f(4)}'
    assert s == '4'
}

// for issue: 19048
struct Foo {
}

fn (mut f Foo) intp_pointer() string {
    return '${f:p}'
}

fn test_intp_pointer_specifier_p() {
    mut foo := Foo{}
    str1 := foo.intp_pointer()

    str2 := '${&foo:p}'
    assert str1 == str2
}

// for issue: 20199
// string contains the zero character: `\0`
fn test_contains_zero_characters() {
    mut str := 'abc'
    str = '${str}\x00${str}'
    assert str.len == 7
    assert str == 'abc\0abc'
}

// for issue: 20432
// non-ascii escape was lost
fn test_interpo_non_ascii_characters() {
    hello := '你好'
    assert '${hello},世界！' == '你好,世界！'
}

fn test_float_exponent_sign() {
    a := 1234567.0123456e03
    assert '${a:6.1e}' == '1.2e+09'
    assert '${a:6.2e}' == '1.23e+09'
    assert '${a:6.5e}' == '1.23457e+09'
}