zeolite-lang-0.24.0.0: tests/while.0rt

/* -----------------------------------------------------------------------------
Copyright 2020 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- */

// Author: Kevin P. Barry [ta0kira@gmail.com]

testcase "assign while" {
  error
  require "value.+initialized"
}

@value interface Value { }

concrete Test { }

define Test {
  @value process () -> (optional Value)
  process () (value) {
    while (false) {
      value <- empty
    }
  }
}


testcase "return while" {
  error
  require "return"
}

@value interface Value { }

concrete Test { }

define Test {
  @value process () -> (optional Value)
  process () {
    while (false) {
      return empty
    }
  }
}


testcase "break outside of while" {
  error
  require "while"
  require "break"
}

unittest test {
  break
}


testcase "continue outside of while" {
  error
  require "while"
  require "continue"
}

unittest test {
  continue
}


testcase "successful while loops" {
  success
}

unittest withBreak {
  Int output <- -1
  scoped {
    Int i <- 0
    Int limit <- 5
  } in while (i < limit) {
    output <- i
    break
    fail("Failed")
  }
  if (output != 0) {
    fail("Failed")
  }
}

unittest withUpdate {
  Int output <- -1
  scoped {
    Int i <- 0
    Int limit <- 5
  } in while (i < limit) {
    output <- i
  } update {
    i <- i+1
  }
  if (output != 4) {
    fail("Failed")
  }
}

unittest breakInUpdate {
  Int output <- 0
  while (true) {
  } update {
    if (output > 5) {
      break
      fail("Failed")
    }
    output <- output+1
  }
  if (output != 6) {
    fail("Failed")
  }
}

concrete ReturnInUpdate {
  @type test () -> (Int)
}

define ReturnInUpdate {
  test () {
    Int output <- 0
    while ((output <- output+1) > 0) {
    } update {
      if (output > 5) {
        return output
        fail("Failed")
      }
    }
    return -1
  }
}

unittest returnInUpdate {
  if (ReturnInUpdate.test() != 6) {
    fail("Failed")
  }
}

unittest breakContinueInIfElse {
  Int i <- 0
  while (true) {
    if (i > 5) {
      break
    } else {
      continue
    }
    fail("Failed")
  } update {
    i <- i+1
  }
  if (i != 6) {
    fail("Failed")
  }
}

unittest updateHasSeparateScope {
  while (false) {
    Int x <- 2
  } update {
    Int x <- 1
  }
}

unittest noUpdate {
    Int output <- -1
    scoped {
      Int i <- 0
      Int limit <- 5
    } in while (i < limit) {
      output <- i
      i <- i+1
    }
    if (output != 4) {
      fail("Failed")
    }
}

unittest continueWithUpdate {
  Int output <- -1
  scoped {
    Int i <- 0
    Int limit <- 5
  } in while (i < limit) {
    output <- i
    continue
    fail("Failed")
  } update {
    i <- i+1
  }
  if (output != 4) {
    fail("Failed")
  }
}

unittest continueWithoutUpdate {
  Int output <- -1
  scoped {
    Int i <- 0
    Int limit <- 5
  } in while (i < limit) {
    output <- i
    i <- i+1
    continue
    fail("Failed")
  }
  if (output != 4) {
    fail("Failed")
  }
}

unittest cleanupAfterBreak {
  Int value <- 0
  scoped {
    value <- 1
  } cleanup {
    value <- 2
  } in while (true) {
    value <- 3
    break
  }
  if (value != 2) {
    fail(value)
  }
}

unittest cleanupAfterContinue {
  Int value <- 0
  scoped {
    value <- 1
  } cleanup {
    value <- 2
  } in while (value < 3) {
    value <- 3
    continue
  }
  if (value != 2) {
    fail(value)
  }
}

concrete CleanupBeforeReturn {
  @type create () -> (CleanupBeforeReturn)
  @value call () -> (Int)
  @value get () -> (Int)
}

define CleanupBeforeReturn {
  @value Int value

  create () {
    return CleanupBeforeReturn{ 0 }
  }

  call () {
    value <- 1
    scoped {
      value <- 2
    } cleanup {
      value <- 3
    } in while (true) {
      return value
    }
    return 4
  }

  get () {
    return value
  }
}

unittest cleanupBeforeReturn {
  CleanupBeforeReturn value <- CleanupBeforeReturn.create()
  Int value1 <- value.call()
  if (value1 != 2) {
    fail(value1)
  }
  Int value2 <- value.get()
  if (value2 != 3) {
    fail(value2)
  }
}


testcase "crash in while" {
  failure
  require "empty"
}

unittest test {
  \ Test.run()
}

define Test {
  run () {
    optional Bool test <- empty
    while (require(test)) {
      // empty
    }
  }
}

concrete Test {
  @type run () -> ()
}


testcase "cleanup cannot use uninitialized named return" {
  error
  require "cleanup"
  require "message.+initialized"
}

unittest test {
  \ Type.call()
}

concrete Type {
  @type call () -> (String)
}

define Type {
  call () (message) {
    while (true) {
      cleanup {
        fail(message)
      } in { }
    }
    return "return"
  }
}


testcase "break not allowed in cleanup" {
  error
  require "cleanup"
  require "break"
}

unittest test {
  while(true) {
    cleanup {
      break
    } in { }
  }
}


testcase "continue not allowed in cleanup" {
  error
  require "cleanup"
  require "continue"
}

unittest test {
  while(true) {
    cleanup {
      continue
    } in { }
  }
}


testcase "procedure nesting preserves required named returns" {
  error
  require "cleanup"
  require "message.+initialized"
}

unittest test {
  \ Type.call()
}

concrete Type {
  @type call () -> (String)
}

define Type {
  call () (message) {
    while (true) {
      cleanup {
        if (true) {
          fail(message)
        } else {
        }
      } in {
      }
    }
    return "return"
  }
}


testcase "no error for cleanup without named returns" {
  compiles
}

unittest test {
  \ Type.call()
}

concrete Type {
  @type call () -> (String)
}

define Type {
  call () (message) {
    while (true) {
      cleanup {
      } in {
        if (true) {
          break
        }
        message <- "message"
      }
    }
    return "return"
  }
}


testcase "return set in predicate" {
  failure
  require "message"
}

unittest test {
  \ Value.process()
}

concrete Value {
  @type process () -> (String)
}

define Value {
  process () (message) {
    while ((message <- "message") != "") {
      fail(message)
    }
  }
}