zeolite-lang-0.12.0.0: tests/conditionals.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 if/elif/else" {
  compiles
}

define Value {
  @value process () -> (optional Value)
  process () (value) {
    if (false) {
      value <- empty
    } elif (false) {
      value <- empty
    } else {
      value <- empty
    }
  }
}

concrete Value {}


testcase "return if/elif/else" {
  compiles
}

define Value {
  @value process () -> (optional Value)
  process () {
    if (false) {
      return empty
    } elif (false) {
      return empty
    } else {
      return empty
    }
  }
}

concrete Value {}


testcase "assign if/elif condition" {
  compiles
}

define Value {
  @value process () -> (optional Value)
  process () (value) {
    if (present((value <- empty))) {
    } elif (present((value <- empty))) {
    } else {
      value <- empty
    }
  }
}

concrete Value {}


testcase "different in if and else" {
  error
  require "value1.+initialized"
  require "value2.+initialized"
}

define Value {
  @value process () -> (optional Value,optional Value)
  process () (value1,value2) {
    if (false) {
      value1 <- empty
    } else {
      value2 <- empty
    }
  }
}

concrete Value {}


testcase "missing in if" {
  error
  require "value.+initialized"
}

define Value {
  @value process () -> (optional Value)
  process () (value) {
    if (false) {
    } elif (false) {
      value <- empty
    } else {
      value <- empty
    }
  }
}

concrete Value {}


testcase "missing in elif" {
  error
  require "value.+initialized"
}

define Value {
  @value process () -> (optional Value)
  process () (value) {
    if (false) {
      value <- empty
    } elif (false) {
    } else {
      value <- empty
    }
  }
}

concrete Value {}


testcase "missing in else" {
  error
  require "value.+initialized"
}

define Value {
  @value process () -> (optional Value)
  process () (value) {
    if (false) {
      value <- empty
    } elif (false) {
      value <- empty
    } else {
    }
  }
}


concrete Value {}


testcase "missing in implicit else" {
  error
  require "value.+initialized"
}

define Value {
  @value process () -> (optional Value)
  process () (value) {
    if (false) {
      value <- empty
    } elif (false) {
      value <- empty
    }
  }
}

concrete Value {}


testcase "return set in predicate for subsequent blocks" {
  compiles
}

define Value {
  @value process () -> (Int)
  process () (x) {
    if (false) {
      x <- 1
    } elif ((x <- 1) > 0) {
      fail(x)
    } else {
    }
  }
}

concrete Value {}



testcase "return in set in predicates is conditional" {
  error
  require "implicit return"
  require "x.+initialized"
}

define Value {
  @value process () -> (Int)
  process () (x) {
    if (false) {
    } elif ((x <- 1) > 0) {
      fail(x)
    } else {
      fail(x)
    }
  }
}

concrete Value {}


testcase "branch jump skips validation of named return" {
  compiles
}

concrete Test {}

define Test {
  @value process () -> (Bool)
  process () (value) {
    while (true) {
      if (true) {
        // This skips past fail(value) below.
        break
      } else {
        value <- true
      }
      fail(value)
    }
    return false
  }
}


testcase "crash in if" {
  crash
  require "empty"
}

unittest test {
  optional Bool test <- empty
  if (require(test)) {
    // empty
  }
}


testcase "crash in elif" {
  crash
  require "empty"
}

unittest test {
  optional Bool test <- empty
  if (false) {
  } elif (require(test)) {
    // empty
  }
}


testcase "multi assign if/elif/else" {
  compiles
}

define Value {
  @value process () -> (optional Value,optional Value)
  process () (value1,value2) {
    if (false) {
      value1 <- empty
      value2 <- empty
    } elif (false) {
      value1 <- empty
      value2 <- empty
    } else {
      value1 <- empty
      value2 <- empty
    }
  }
}

concrete Value {}


testcase "multi missing in if" {
  error
  require "value2"
}

define Value {
  @value process () -> (optional Value,optional Value)
  process () (value1,value2) {
    if (false) {
      value1 <- empty
    } elif (false) {
      value1 <- empty
      value2 <- empty
    } else {
      value1 <- empty
      value2 <- empty
    }
  }
}

concrete Value {}


testcase "multi missing in elif" {
  error
  require "value2"
}

define Value {
  @value process () -> (optional Value,optional Value)
  process () (value1,value2) {
    if (false) {
      value1 <- empty
      value2 <- empty
    } elif (false) {
      value1 <- empty
    } else {
      value1 <- empty
      value2 <- empty
    }
  }
}

concrete Value {}


testcase "multi missing in else" {
  error
  require "value2"
}

define Value {
  @value process () -> (optional Value,optional Value)
  process () (value1,value2) {
    if (false) {
      value1 <- empty
      value2 <- empty
    } elif (false) {
      value1 <- empty
      value2 <- empty
    } else {
      value1 <- empty
    }
  }
}

concrete Value {}


testcase "cleanup before return in if" {
  success
}

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

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

define Value {
  @value Int value

  create () {
    return Value{ 0 }
  }

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

  get () {
    return value
  }
}