/* -----------------------------------------------------------------------------
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 "optional persists" {
  success
}

unittest test {
  Test value <- Test.create()
  \ value.set()
  \ value.check()
}

concrete Test {
  @type create () -> (Test)
  @value set () -> ()
  @value check () -> ()
}

define Test {
  @value optional Test self2

  create () {
    return Test{ empty }
  }

  set () {
    scoped {
      Test value <- create()
    } in self2 <- value
  }

  check () {
    \ require(self2)
  }
}


testcase "weak is weak" {
  success
}

unittest test {
  Test value <- Test.create()
  \ value.set()
  \ value.check()
}

concrete Test {
  @type create () -> (Test)
  @value set () -> ()
  @value check () -> ()
}

define Test {
  @value weak Test self2

  create () {
    return Test{ empty }
  }

  set () {
    scoped {
      Test value <- create()
    } in self2 <- value
  }

  check () {
    scoped {
      optional Test self3 <- strong(self2)
    } in if (present(self3)) {
      fail("Failed")
    }
  }
}


testcase "present weak" {
  success
}

unittest test {
  Test value <- Test.create()
  \ value.check()
}

concrete Test {
  @type create () -> (Test)
  @value check () -> ()
}

define Test {
  create () {
    return Test{ }
  }

  check () {
    weak Test value <- create()
    if (present(strong(value))) {  // value should be nullptr here
      fail("Failed")
    }
  }
}


testcase "weak variable to weak variable" {
  success
}

unittest test {
  \ Test.run()
}

define Test {
  @category weak Test one <- empty

  run () {
    weak Test two <- one
    one <- two
  }
}

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


testcase "optional variable to weak variable" {
  success
}

unittest test {
  \ Test.run()
}

define Test {
  @category optional Test one <- empty

  run () {
    weak Test two <- one
    two <- one
  }
}

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


testcase "weak in multi assign" {
  success
}

unittest test {
  // value1 ensures value2 is present.
  Value value1, weak Value value2 <- Test.get()
  if (!present(strong(value2))) {
    fail("Failed")
  }
}

concrete Value {
  @type create () -> (Value)
}

define Value {
  create () {
    return Value{ }
  }
}

concrete Test {
  @type get () -> (Value,Value)
}

define Test {
  get () {
    Value value <- Value.create()
    return value, value
  }
}


testcase "weak in inline assign" {
  success
}

unittest test {
  Value value1 <- Value.create()
  weak Value value2 <- empty
  if (!present(strong((value2 <- value1)))) {
    fail("Failed")
  }
}

concrete Value {
  @type create () -> (Value)
}

define Value {
  create () {
    return Value{ }
  }
}


testcase "present required" {
  success
}

unittest test {
  Test value <- Test.create()
  if (!present(value)) {
    fail("Failed")
  }
}

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

define Test {
  create () {
    return Test{ }
  }
}


testcase "require required" {
  success
}

unittest test {
  Test value <- Test.create()
  \ require(value).call()
}

concrete Test {
  @type create () -> (Test)
  @value call () -> ()
}

define Test {
  create () {
    return Test{ }
  }

  call () {}
}