Scala

import exercises.DerevoADT
import exercises.DerevoADT.{Derevo, Listok, Vetka}
import org.scalacheck.Prop.forAll
import org.scalacheck.{Gen, Prop, Properties}

class DerevoADT extends Properties("DerevoADT") {
  val listokGen = for {
    s <- Gen.chooseNum(0, 9)
  } yield Listok(s)

  val vetkaGen = for {
    s <- listokGen.sample
    b <- listokGen.sample
  } yield Vetka(s, b)

//  val listokSimpleSize: Prop
  property("listokSimpleSize")= forAll(listokGen) { (n: Listok[Int]) => DerevoADT.size(n) == 1 && DerevoADT.sizeF(n) == 1
  }

//  val listokSimpleDepth: Prop
  property("listokSimpleDepth")= forAll(listokGen) { (n: Listok[Int]) => DerevoADT.depth(n) == 1 && DerevoADT.depth(n) == 1
  }

//  val listokSimpleMax: Prop
  property("listokSimpleMax")= forAll(listokGen) { (n: Listok[Int]) => DerevoADT.maximum(n) == n.a && DerevoADT.maximumF(n) == n.a
  }

//  val listokSimpleMap: Prop
  property("listokSimpleMap")= forAll(listokGen) { (n: Listok[Int]) =>
    val b: Int = n.a
    val c: Listok[Int] = Listok(b)
    val first: Derevo[Int] = DerevoADT.map(n)(a => a * 2)
    val second: Derevo[Int] = DerevoADT.mapF(c)(c => c * 3)
    (first, second) match {
      case (f: Listok[Int], s: Listok[Int]) => (b * 2 == f.a) && (b * 3 == s.a)
    }
  }

//  val vetkaSimpleSize: Prop
  property("vetkaSimpleSize")= forAll(vetkaGen) { case (n: Some[Vetka[Int]]) => DerevoADT.size(n.get) == 2 && DerevoADT.sizeF(n.get) == 2 }

//  val vetkaSimpleDepth: Prop
  property("vetkaSimpleDepth")= forAll(vetkaGen) { case (n: Some[Vetka[Int]]) => DerevoADT.depth(n.get) == 2 && DerevoADT.depth(n.get) == 2
  }


//  val vetkaSimpleMax: Prop
  property("vetkaSimpleMax")= forAll(vetkaGen) { case (n: Some[Vetka[Int]]) => {
    val lft = n.get.lft
    val rgt = n.get.rgt
    val b = DerevoADT.maximum(n.get)
    val c = DerevoADT.maximumF(n.get)
    (lft, rgt) match {
      case (lft: Listok[Int], rgt: Listok[Int])
      => {
        (b == Math.max(lft.a, rgt.a)) && (c == Math.max(lft.a, rgt.a))
      }
    }
  }
  }

//  val vetkaSimpleMap: Prop
  property("vetkaSimpleMap")= forAll(vetkaGen) { case (n: Some[Vetka[Int]]) => {
    val lft = n.get.lft
    val rgt = n.get.rgt
    (lft, rgt) match {
      case (lft: Listok[Int], rgt: Listok[Int])
      => {
        val first = lft.a
        val sec = rgt.a
        val newV = DerevoADT.map(n.get)(a => a * 2)
        val newF = DerevoADT.mapF(n.get)(a => a * 3)
        (newV, newF) match {
          case (newV: Vetka[Int], newF: Vetka[Int]) => {
            val l1 = newV.lft
            val r1 = newV.rgt
            val l2 = newF.lft
            val r2 = newF.rgt
            (l1, r1, l2, r2) match {
              case (l1: Listok[Int], r1: Listok[Int], l2: Listok[Int], r2: Listok[Int]) => {
                (first * 2 == l1.a) && (sec * 2 == r1.a) && (first * 3 == l2.a) && (sec * 3 == r2.a)
              }
            }
          }
        }
      }
    }
  }
  }

//  property("simpleListokFunctions") = listokSimpleDepth && listokSimpleSize && listokSimpleMax && listokSimpleMap
//  property("simpleVetkaFunctions") = vetkaSimpleDepth && vetkaSimpleSize && vetkaSimpleMax && vetkaSimpleMap

  //  val a = Vetka(Vetka(Listok(1), Listok(2)), Vetka(Vetka(Listok(1), Listok(2)), Listok(3)))
  //  val b = DerevoADT.fold(a)((m: Int) => m) { (m: Int, n: Int) => println("m: " + m + " n:" + n); m + n }

}