/* -----------------------------------------------------------------------------
Copyright 2020-2021 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 "not true" {
  success
}

unittest test {
  if (!true) {
    fail("Failed")
  }
}


testcase "reduce Bool" {
  success
}

unittest bool {
  if (!present(reduce<Bool,Bool>(true))) {
    fail("Failed")
  }
}

unittest asBool {
  if (!present(reduce<Bool,AsBool>(true))) {
    fail("Failed")
  }
}

unittest asChar {
  if (present(reduce<Bool,AsChar>(true))) {
    fail("Failed")
  }
}

unittest asInt {
  if (!present(reduce<Bool,AsInt>(true))) {
    fail("Failed")
  }
}

unittest asFloat {
  if (!present(reduce<Bool,AsFloat>(true))) {
    fail("Failed")
  }
}

unittest formatted {
  if (!present(reduce<Bool,Formatted>(true))) {
    fail("Failed")
  }
}


testcase "reduce Char" {
  success
}

unittest char {
  if (!present(reduce<Char,Char>('a'))) {
    fail("Failed")
  }
}

unittest asBool {
  if (!present(reduce<Char,AsBool>('a'))) {
    fail("Failed")
  }
}

unittest asChar {
  if (!present(reduce<Char,AsChar>('a'))) {
    fail("Failed")
  }
}

unittest asInt {
  if (!present(reduce<Char,AsInt>('a'))) {
    fail("Failed")
  }
}

unittest asFloat {
  if (!present(reduce<Char,AsFloat>('a'))) {
    fail("Failed")
  }
}

unittest formatted {
  if (!present(reduce<Char,Formatted>('a'))) {
    fail("Failed")
  }
}


testcase "reduce Int" {
  success
}

unittest int {
  if (!present(reduce<Int,Int>(1))) {
    fail("Failed")
  }
}

unittest asBool {
  if (!present(reduce<Int,AsBool>(1))) {
    fail("Failed")
  }
}

unittest asChar {
  if (!present(reduce<Int,AsChar>(1))) {
    fail("Failed")
  }
}

unittest asInt {
  if (!present(reduce<Int,AsInt>(1))) {
    fail("Failed")
  }
}

unittest asFloat {
  if (!present(reduce<Int,AsFloat>(1))) {
    fail("Failed")
  }
}

unittest formatted {
  if (!present(reduce<Int,Formatted>(1))) {
    fail("Failed")
  }
}


testcase "reduce Float" {
  success
}

unittest float {
  if (!present(reduce<Float,Float>(1.0))) {
    fail("Failed")
  }
}

unittest asBool {
  if (!present(reduce<Float,AsBool>(1.0))) {
    fail("Failed")
  }
}

unittest asChar {
  if (present(reduce<Float,AsChar>(1.0))) {
    fail("Failed")
  }
}

unittest asInt {
  if (!present(reduce<Float,AsInt>(1.0))) {
    fail("Failed")
  }
}

unittest asFloat {
  if (!present(reduce<Float,AsFloat>(1.0))) {
    fail("Failed")
  }
}

unittest formatted {
  if (!present(reduce<Float,Formatted>(1.0))) {
    fail("Failed")
  }
}


testcase "reduce CharBuffer" {
  success
}

unittest charBuffer {
  if (!present(reduce<CharBuffer,CharBuffer>(CharBuffer.new(0)))) {
    fail("Failed")
  }
}

unittest readAt {
  if (!present(reduce<CharBuffer,ReadAt<Char>>(CharBuffer.new(0)))) {
    fail("Failed")
  }
  if (present(reduce<CharBuffer,ReadAt<Int>>(CharBuffer.new(0)))) {
    fail("Failed")
  }
}

unittest writeAt {
  if (!present(reduce<CharBuffer,WriteAt<Char>>(CharBuffer.new(0)))) {
    fail("Failed")
  }
  if (present(reduce<CharBuffer,WriteAt<Int>>(CharBuffer.new(0)))) {
    fail("Failed")
  }
}

unittest container {
  if (!present(reduce<CharBuffer,Container>(CharBuffer.new(0)))) {
    fail("Failed")
  }
}


testcase "reduce String" {
  success
}

unittest string {
  if (!present(reduce<String,String>("a"))) {
    fail("Failed")
  }
}

unittest asBool {
  if (!present(reduce<String,AsBool>("a"))) {
    fail("Failed")
  }
}

unittest asChar {
  if (present(reduce<String,AsChar>("a"))) {
    fail("Failed")
  }
}

unittest asInt {
  if (present(reduce<String,AsInt>("a"))) {
    fail("Failed")
  }
}

unittest asFloat {
  if (present(reduce<String,AsFloat>("a"))) {
    fail("Failed")
  }
}

unittest formatted {
  if (!present(reduce<String,Formatted>("a"))) {
    fail("Failed")
  }
}

unittest defaultOrder {
  if (!present(reduce<String,DefaultOrder<Char>>("a"))) {
    fail("Failed")
  }
  if (present(reduce<String,DefaultOrder<Int>>("a"))) {
    fail("Failed")
  }
}

unittest subSequence {
  if (!present(reduce<String,SubSequence>("a"))) {
    fail("Failed")
  }
}

unittest readAt {
  if (!present(reduce<String,ReadAt<Char>>("a"))) {
    fail("Failed")
  }
  if (present(reduce<String,ReadAt<Int>>("a"))) {
    fail("Failed")
  }
}

unittest container {
  if (!present(reduce<String,Container>("a"))) {
    fail("Failed")
  }
}


testcase "interface implementations" {
  success
}

unittest boolDefault {
  \ Testing.checkEquals<?>(Bool.default(),false)
}

unittest charDefault {
  \ Testing.checkEquals<?>(Char.default(),'\000')
}

unittest floatDefault {
  \ Testing.checkEquals<?>(Float.default(),0.0)
}

unittest intDefault {
  \ Testing.checkEquals<?>(Int.default(),0)
}

unittest stringDefault {
  \ Testing.checkEquals<?>(String.default(),"")
}

unittest stringLessThan {
  if (!("x" `String.lessThan` "y")) {
    fail("Failed")
  }
}

unittest boolEquals {
  if (!(true `Bool.equals` true)) {
    fail("Failed")
  }
}

unittest stringEquals {
  if (!("x" `String.equals` "x")) {
    fail("Failed")
  }
}

unittest stringBuilder {
  [Append<String>&Build<String>] builder <- String.builder()
  \ Testing.checkEquals<?>(builder.build(),"")
  \ Testing.checkEquals<?>(builder.append("xyz").build(),"xyz")
  \ Testing.checkEquals<?>(builder.append("123").build(),"xyz123")
}

unittest charLessThan {
  if (!('x' `Char.lessThan` 'y')) {
    fail("Failed")
  }
}

unittest charEquals {
  if (!('x' `Char.equals` 'x')) {
    fail("Failed")
  }
}

unittest intLessThan {
  if (!(1 `Int.lessThan` 2)) {
    fail("Failed")
  }
}

unittest intEquals {
  if (!(1 `Int.equals` 1)) {
    fail("Failed")
  }
}

unittest floatLessThan {
  if (!(1.0 `Float.lessThan` 2.0)) {
    fail("Failed")
  }
}

unittest floatEquals {
  if (!(1.0 `Float.equals` 1.0)) {
    fail("Failed")
  }
}

unittest stringFormatted {
  String s <- ("x").formatted()
  if (s != "x") {
    fail(s)
  }
}

unittest charFormatted {
  String s <- ('x').formatted()
  if (s != "x") {
    fail(s)
  }
}

unittest charFormattedOct {
  String s <- ('\170').formatted()
  if (s != "x") {
    fail(s)
  }
}

unittest charFormattedHex {
  String s <- ('\x78').formatted()
  if (s != "x") {
    fail(s)
  }
}

unittest intFormatted {
  String s <- (1).formatted()
  if (s != "1") {
    fail(s)
  }
}

unittest intFormattedHex {
  String s <- (\x0010).formatted()
  if (s != "16") {
    fail(s)
  }
}

unittest floatFormatted {
  String s <- (1.1).formatted()
  if (s != "1.1") {  // precision might vary
    fail(s)
  }
}

unittest boolFormatted {
  String s <- (false).formatted()
  if (s != "false") {
    fail(s)
  }
}


testcase "reference sharing" {
  success
}

unittest boolShared {
  Bool value1 <- true
  // Shared because true and false are boxed constants.
  weak Bool value2 <- value1
  if (!present(strong(value2))) {
    fail("Failed")
  }
}

unittest stringShared {
  String value1 <- "x"
  weak String value2 <- value1
  if (!present(strong(value2))) {
    fail("Failed")
  }
}

unittest charNotShared {
  Char value1 <- 'x'
  weak Char value2 <- value1
  if (present(strong(value2))) {
    fail("Failed")
  }
}

unittest intNotShared {
  Int value1 <- 1
  weak Int value2 <- value1
  if (present(strong(value2))) {
    fail("Failed")
  }
}

unittest floatNotShared {
  Float value1 <- 1.1
  weak Float value2 <- value1
  if (present(strong(value2))) {
    fail("Failed")
  }
}


testcase "CharBuffer stuff" {
  success
}

unittest writeAndRead {
  CharBuffer buffer <- CharBuffer.new(5)
      .writeAt(0,'a')
      .writeAt(1,'b')
      .writeAt(2,'c')
      .writeAt(3,'d')
      .writeAt(4,'e')
      // overwriting here
      .writeAt(1,'B')
      .writeAt(2,'C')

  \ Testing.checkEquals<?>(buffer.size(),5)
  \ Testing.checkEquals<?>(buffer.readAt(0),'a')
  \ Testing.checkEquals<?>(buffer.readAt(1),'B')
  \ Testing.checkEquals<?>(buffer.readAt(2),'C')
  \ Testing.checkEquals<?>(buffer.readAt(3),'d')
  \ Testing.checkEquals<?>(buffer.readAt(4),'e')
}

unittest resizeDown {
  CharBuffer buffer <- CharBuffer.new(5).resize(3).writeAt(2,'a')
  \ Testing.checkEquals<?>(buffer.size(),3)
  \ Testing.checkEquals<?>(buffer.readAt(2),'a')
}

unittest resizeUp {
  CharBuffer buffer <- CharBuffer.new(5).resize(7).writeAt(6,'a')
  \ Testing.checkEquals<?>(buffer.size(),7)
  \ Testing.checkEquals<?>(buffer.readAt(6),'a')
}


testcase "CharBuffer read negative" {
  crash
  require "-10"
  require "bounds"
}

unittest test {
  \ CharBuffer.new(3).readAt(-10)
}


testcase "CharBuffer read past end" {
  crash
  require "3"
  require "bounds"
}

unittest test {
  \ CharBuffer.new(3).readAt(3)
}


testcase "CharBuffer write negative" {
  crash
  require "-10"
  require "bounds"
}

unittest test {
  \ CharBuffer.new(3).writeAt(-10,'a')
}


testcase "CharBuffer write past end" {
  crash
  require "3"
  require "bounds"
}

unittest test {
  \ CharBuffer.new(3).writeAt(3,'a')
}


testcase "CharBuffer new negative" {
  crash
  require "-10"
  require "size"
}

unittest test {
  \ CharBuffer.new(-10)
}


testcase "CharBuffer resize negative" {
  crash
  require "-10"
  require "size"
}

unittest test {
  \ CharBuffer.new(0).resize(-10)
}


testcase "String stuff" {
  success
}

unittest builderNotLazy {
  optional String value1 <- "value"
  weak String value2 <- value1
  if (!present(strong(value2))) {
    fail("Failed")
  }
  [Append<String>&Build<String>] builder <- String.builder().append(require(value1))
  value1 <- empty
  if (present(strong(value2))) {
    fail("Failed")
  }
}

unittest simpleAccess {
  String s <- "abcde"
  Char c <- s.readAt(3)
  if (c != 'd') {
    fail(c)
  }
  Int size <- s.size()
  if (size != 5) {
    fail(size)
  }
}

unittest subsequence {
  String s <- "abcde"
  String s2 <- s.subSequence(1,3)
  if (s2 != "bcd") {
    fail(s2)
  }
}

unittest emptySubsequence {
  String s <- ""
  String s2 <- s.subSequence(0,0)
  if (s2 != "") {
    fail(s2)
  }
}

unittest nullChar {
  if ("abc\x00def" == "abc") {
    fail("Failed")
  }
  if (("abc\x00def").readAt(4) != 'd') {
    fail("Failed")
  }
}

unittest traverseString {
  Int index <- 0
  String value <- "abcdefg"

  traverse (value.defaultOrder() -> Char c) {
    \ Testing.checkEquals<?>(c,value.readAt(index))
    index <- index+1
  }

  \ Testing.checkEquals<?>(index,7)
}

unittest fromCharBuffer {
  CharBuffer buffer <- CharBuffer.new(5)
      .writeAt(0,'a')
      .writeAt(1,'b')
      .writeAt(2,'c')
      .writeAt(3,'d')
      .writeAt(4,'e')
  \ Testing.checkEquals<?>(String.fromCharBuffer(buffer),"abcde")
}


testcase "String access negative" {
  crash
  require "-10"
  require "bounds"
}

unittest test {
  \ Test.run()
}

define Test {
  run () {
    \ ("abc").readAt(-10)
  }
}

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


testcase "String access past end" {
  crash
  require "3"
  require "bounds"
}

unittest test {
  \ Test.run()
}

define Test {
  run () {
    \ ("abc").readAt(3)
  }
}

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


testcase "String subsequence past end" {
  crash
  require "3"
  require "size"
}

unittest test {
  \ Test.run()
}

define Test {
  run () {
    \ ("abc").subSequence(1,3)
  }
}

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


testcase "Int stuff" {
  success
}

unittest accurateMax {
  Int x <- 9223372036854775807 - 1
  if (x != 9223372036854775806) {
    fail(x)
  }
}

unittest accurateMin {
  Int x <- -9223372036854775806 + 1
  if (x != -9223372036854775805) {
    fail(x)
  }
}

unittest hexUnsigned {
  if (\xffffffffffffffff != -1) {
    fail("Failed")
  }
}


testcase "Int literal too large" {
  error
  require "9223372036854775808"
  require "max"
}

define Test {
  run () {
    \ 9223372036854775808
  }
}

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


testcase "Int unsigned literal too large" {
  error
  require "18446744073709551616"
  require "max"
}

define Test {
  run () {
    \ \x10000000000000000
  }
}

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


testcase "Int literal too small" {
  error
  require "-9223372036854775807"
  require "min"
}

define Test {
  run () {
    \ -9223372036854775807
  }
}

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


testcase "Float exponent does not cross whitespace" {
  success
}

unittest test {
  \ Test.run()
}

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

define E10 {
  create () {
    return E10{ }
  }
}

define Test {
  run () {
    Float x <- 1.2345
    E10 y <- E10.create()
  }
}

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


testcase "Bool conversions" {
  success
}

unittest falseAsBool {
  Bool b1 <- (false).asBool()
  if (b1 != false) {
    fail(b1)
  }
}

unittest trueAsBool {
  Bool b2 <- (true).asBool()
  if (b2 != true) {
    fail(b2)
  }
}

unittest asInt {
  Int i <- (true).asInt()
  if (i != 1) {
    fail(i)
  }
}

unittest asFloat {
  Float f <- (true).asFloat()
  if (f != 1.0) {
    fail(f)
  }
}


testcase "Char conversions" {
  success
}

unittest nullAsBool {
  Bool b1 <- ('\x00').asBool()
  if (b1 != false) {
    fail(b1)
  }
}

unittest nonNullAsBool {
  Bool b2 <- ('\x10').asBool()
  if (b2 != true) {
    fail(b2)
  }
}

unittest asChar {
  Char c <- ('a').asChar()
  if (c != 'a') {
    fail(c)
  }
}

unittest asInt {
  Int i <- ('\x10').asInt()
  if (i != 16) {
    fail(i)
  }
}

unittest asFloat {
  Float f <- ('\x10').asFloat()
  if (f != 16.0) {
    fail(f)
  }
}


testcase "Int conversions" {
  success
}

unittest zeroAsBool {
  Bool b1 <- (0).asBool()
  if (b1 != false) {
    fail(b1)
  }
}

unittest nonZeroAsBool {
  Bool b2 <- (16).asBool()
  if (b2 != true) {
    fail(b2)
  }
}

unittest asChar {
  Char c <- (97).asChar()
  if (c != 'a') {
    fail(c)
  }
}

unittest asInt {
  Int i <- (16).asInt()
  if (i != 16) {
    fail(i)
  }
}

unittest asFloat {
  Float f <- (16).asFloat()
  if (f != 16.0) {
    fail(f)
  }
}


testcase "Float conversions" {
  success
}

unittest zeroAsBool {
  Bool b1 <- (0.0).asBool()
  if (b1 != false) {
    fail(b1)
  }
}

unittest nonZeroAsBool {
  Bool b2 <- (16.0).asBool()
  if (b2 != true) {
    fail(b2)
  }
}

unittest asInt {
  Int i <- (16.0).asInt()
  if (i != 16) {
    fail(i)
  }
}

unittest asFloat {
  Float f <- (16.0).asFloat()
  if (f != 16.0) {
    fail(f)
  }
}


testcase "String conversions" {
  success
}

unittest emptyAsBool {
  Bool b1 <- ("").asBool()
  if (b1 != false) {
    fail(b1)
  }
}

unittest singleNullAsBool {
  Bool b2 <- ("\x00").asBool()
  if (b2 != true) {
    fail(b2)
  }
}