struct St {
mut:
    i int
}

fn test_lock_expr() {
    shared xx := St{
        i: 173
    }
    shared y := St{
        i: -57
    }
    mut m := 0
    m = lock y {
        y.i
    }
    n := rlock xx {
        xx.i
    }
    assert m == -57
    assert n == 173
}

struct Abc {
mut:
    a f64
}

fn test_multi_objects() {
    shared x := Abc{
        a: 12.5
    }
    shared y := Abc{
        a: -7.5
    }
    shared z := Abc{
        a: 13.125
    }
    a, b, c := rlock z, x, y {
        y.a, z.a, x.a
    }
    assert a == -7.5
    assert b == 13.125
    assert c == 12.5
}

fn (mut st Abc) getvals(mut a Abc, mut b Abc) (f64, f64, f64) {
    return a.a, st.a, b.a
}

fn test_mult_ret_method() {
    shared x := Abc{
        a: 12.5
    }
    shared y := Abc{
        a: -7.5
    }
    shared z := Abc{
        a: 13.125
    }
    a, b, c := lock z, x, y {
        z.getvals(mut x, mut y)
    }
    assert a == 12.5
    assert b == 13.125
    assert c == -7.5
}

fn test_shared_lock_map_index_expr() {
    shared m := {
        'qwe': 'asd'
    }
    for key in ['fdf', 'qwe'] {
        v := rlock m {
            m[key] or { 'key not found' }
        }
        if key == 'qwe' {
            assert v == 'asd'
        } else {
            assert v == 'key not found'
        }
    }
}

fn test_shared_lock_array_index_expr() {
    shared a := [-12.5, 6.25]
    for i in -2 .. 4 {
        v := rlock a {
            a[i] or { 23.75 }
        }
        if i == 0 {
            assert v == -12.5
        } else if i == 1 {
            assert v == 6.25
        } else {
            assert v == 23.75
        }
    }
}

fn test_shared_lock_array_slice_expr() {
    // Test slicing shared arrays in rlock expressions (fixes issue #26663)
    // Note: slicing a shared array automatically clones for safety,
    // since a slice is a view over the same memory buffer.
    shared a := ['a', 'b', 'c', 'd']

    // Basic slice - implicit clone happens (safe independent copy)
    slice1 := lock {
        a[1..3]
    }
    assert slice1.len == 2
    assert slice1[0] == 'b'
    assert slice1[1] == 'c'

    // Full slice
    slice2 := lock {
        a[..]
    }
    assert slice2.len == 4
    assert slice2 == ['a', 'b', 'c', 'd']

    // Slice from start
    slice3 := lock {
        a[..2]
    }
    assert slice3.len == 2
    assert slice3[0] == 'a'
    assert slice3[1] == 'b'

    // Slice to end
    slice4 := lock {
        a[2..]
    }
    assert slice4.len == 2
    assert slice4[0] == 'c'
    assert slice4[1] == 'd'

    // Test with int array
    shared arr := [1, 2, 3, 4, 5]
    slice5 := lock {
        arr[1..4]
    }
    assert slice5.len == 3
    assert slice5[0] == 2
    assert slice5[1] == 3
    assert slice5[2] == 4

    // Explicit clone - same behavior, no warning
    slice6 := lock {
        a[1..3].clone()
    }
    assert slice6 == ['b', 'c']

    // Unsafe block - get a view (user takes responsibility)
    slice7 := lock {
        unsafe { a[1..3] }
    }
    assert slice7 == ['b', 'c']
}

struct DummySt {
    a int
}

fn test_shared_lock_chan_rec_expr() {
    ch := chan int{cap: 10}
    shared st := DummySt{}
    ch <- 7
    ch <- -13
    ch.close()
    for i in 0 .. 3 {
        v := rlock st {
            <-ch or { -17 }
        }
        if i == 0 {
            assert v == 7
        } else if i == 1 {
            assert v == -13
        } else {
            assert v == -17
        }
    }
}