#
# Test of return
#
# Copyright © 2022-2023 Samuel Lidén Borell <samuel@kodafritt.se>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
#

func retflow_none1()
{
}

func retflow_none2(bool choice)
{
    if choice { }
    else { }
}

func retflow_simple1() -> bool
{
    return true
}

func retflow_simple2(bool choice) -> bool
{
    if choice { }
    else { }
    return true
}

func retflow_nested() -> bool
{
    {
        return true
    }
}

func retflow_if(int choice) -> bool
{
    if choice == 1 return true
    else return false
}

func retflow_elseif(int choice) -> bool
{
    if      choice ==   1 return true
    else if choice < -100 return choice == -300
    else if choice <  -10 return choice == -30
    else if choice <    0 return choice == -3
    else return false
}

func retflow_elseif_nested(int choice) -> bool
{
    if choice < 100 {
        if choice == 1 return true
        else if choice < -10 return choice == -30
        else if choice < 0 return choice == -3
        else return false
    } else {
        if choice == 101 return true
        else {
            do { } while false
            return false
        }
    }
}

func retflow_if_goto1(int choice) -> int
{
    if choice == 1 return 11
    else if choice == 2 goto cont
    else return 33
  cont:
    return 22
}

func retflow_if_goto2(int choice) -> int
{
    if choice == 1 return 11
    else if choice == 2 { }
    else goto out
  back:
    return 33
  out:
    goto back
}

func retflow_goto() -> bool
{
  again:
    goto again
}

func retflow_while_endless1() -> bool
{
    while true { }
}

func retflow_while_endless2(int choice) -> bool
{
    var int x = choice
    while true {
        x += 1
      top:
        if x == 10 goto bottom
        else if x == 20 goto top
        else if x == 30 goto inner
        else if x > 100 {
          inner:
            x = 0
        }
      bottom:
    }
}

func retflow_while_not_endless1(int choice) -> bool
{
    var int x = choice
    while true {
        x += 1
      top:
        if x == 10 goto bottom
        else if x == 20 goto top
        else if x == 30 goto inner
        else if x > 100 {
          inner:
            x = 0
            goto after
        }
      bottom:
    }
  after:
    return true
}

func retflow_while_not_endless2(int choice) -> bool
{
    var int x = choice
    if choice == 0 {
      before:
        return false
    }
    while true {
        x += 1
      top:
        if x == 10 goto bottom
        else if x == 20 goto top
        else if x == 30 goto inner
        else if x > 100 {
          inner:
            x = 0
            goto before
        }
      bottom:
    }
}

func retflow_dowhile_endless() -> bool
{
    do { } while true
}

func retflow_dowhile_not_endless() -> bool
{
    do { } while false
    return true
}

func retflow_switch1(int x) -> int
{
    switch x {
    case 1:
        return 11
    default:
        return 99
    }
}

func retflow_switch2(int x) -> int
{
    switch x {
    case 1:
        return 11
    case 2:
        return 22
    case 3:
        return 33
    default:
        return 99
    }
}

func retflow_switch3(int x, int y) -> int
{
    if x < 0 {
        switch y {
        case 1:
            return 1
        default:
            return 9
        }
    } else if x > 0 {
        switch y {
        case 1:
            return 11
        case 2:
            return 22
        default:
            return 99
        }
    } else {
        switch y {
        case 1:
            return 111
        case 2:
            return 222
        case 3:
            return 333
        default:
            return 999
        }
    }
}

func retflow_gototarget_simple(int choice) -> bool
{
    if choice == 1 goto skip
    return true
  skip:
    return false
}

func retflow_gototarget_loop(int choice) -> bool
{
    if choice == 1 goto skip
    return true
    while true {
        {
          skip:
            return false
        }
    }
}

func return_test()
{
    retflow_none1()
    retflow_none2(true)
    assert retflow_simple1()
    assert retflow_simple2(false)
    assert retflow_nested()
    assert retflow_if(1)
    assert not retflow_if(2)
    assert retflow_elseif(1)
    assert retflow_elseif(-300)
    assert retflow_elseif(-30)
    assert retflow_elseif(-3)
    assert not retflow_elseif(-101)
    assert not retflow_elseif(-11)
    assert not retflow_elseif(-1)
    assert retflow_elseif(1)
    assert retflow_elseif_nested(1)
    assert retflow_elseif_nested(-30)
    assert retflow_elseif_nested(-3)
    assert not retflow_elseif_nested(-11)
    assert not retflow_elseif_nested(-1)
    assert not retflow_elseif_nested(99)
    assert retflow_elseif_nested(101)
    assert not retflow_elseif_nested(100)
    assert retflow_if_goto1(1) == 11
    assert retflow_if_goto1(2) == 22
    assert retflow_if_goto1(3) == 33
    assert retflow_if_goto1(0) == 33
    assert retflow_if_goto1(0x40000001) == 33
    assert retflow_if_goto2(1) == 11
    assert retflow_if_goto2(2) == 33
    assert retflow_if_goto2(3) == 33
    # These contain endless loops. So they have to be skipped
    #retflow_goto()
    #retflow_while_endless1()
    #retflow_while_endless2()
    assert retflow_while_not_endless1(100)
    assert retflow_while_not_endless1(90)
    assert retflow_while_not_endless1(29)
    assert retflow_while_not_endless1(20) # values < 20 cause an endless loop
    assert not retflow_while_not_endless2(0)
    assert not retflow_while_not_endless2(31)
    assert not retflow_while_not_endless2(20) # values < 20 cause an endless loop
    # More endless loops. Skipped
    #retflow_dowhile_endless()
    #retflow_dowhile_not_endless()
    assert retflow_switch1(1) == 11
    assert retflow_switch1(0) == 99
    assert retflow_switch1(2) == 99
    assert retflow_switch2(1) == 11
    assert retflow_switch2(2) == 22
    assert retflow_switch2(3) == 33
    assert retflow_switch2(4) == 99
    assert retflow_switch2(0) == 99
    assert retflow_switch3(-1, 1) == 1
    assert retflow_switch3(-1, 2) == 9
    assert retflow_switch3(1, 1) == 11
    assert retflow_switch3(1, 2) == 22
    assert retflow_switch3(1, 3) == 99
    assert retflow_switch3(0, 1) == 111
    assert retflow_switch3(0, 2) == 222
    assert retflow_switch3(0, 3) == 333
    assert retflow_switch3(0, 4) == 999
    assert retflow_switch3(0, 0) == 999
    assert not retflow_gototarget_simple(1)
    assert retflow_gototarget_simple(2)
    assert not retflow_gototarget_loop(1)
    assert retflow_gototarget_loop(2)
}