org.scalatest.funspec.AnyFunSpec Scala Examples

package be.dataminded.lighthouse.pipeline

import be.dataminded.lighthouse.testing.SharedSparkSession
import better.files._
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class PartitionedOrcSinkSpec extends AnyFunSpec with SharedSparkSession with Matchers {

  import spark.implicits._

  describe("PartitionedOrcSink") {
    it("should write the DataFrame partitioned by a sequence of columns") {
      val data = Seq(("Boy", 15), ("Girl", 22), ("Dog", 3)).toDF("name", "age")

      SparkFunction.of(data).write(PartitionedOrcSink("./target/output/orc", Seq("age"))).run(spark)

      ("target" / "output" / "orc").list.filter(_.isDirectory).map(_.name).toList should contain theSameElementsAs Seq(
        "age=22",
        "age=15",
        "age=3"
      )
    }
  }
} 

package contravariant

import scalaz.Contravariant
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class ContravariantSpec
  extends AnyFunSpec
    with Matchers {

  case class Predicate[A](fun: A => Boolean)

  describe("Contravariant") {

    it("split complex Predicate into simpler + function - csutom contramap") {
      val lenAbove5 = Predicate[String](_.length > 5)
      lenAbove5.fun("123456") mustBe true

      // predicate
      val above5 = Predicate[Int](_ > 5)
      above5.fun(42) mustBe true

      // function
      val len: String => Int = _.length

      // way to combine them
      def contramap(pred: Predicate[Int], f: String => Int): Predicate[String] =
        Predicate[String](f andThen pred.fun)

      // yeach !
      val pr = contramap(above5, len)
      pr.fun("123456") mustBe true
    }

    it("custom contramap for Predicate on Person and Balance") {
      case class Person(name: String)
      case class Balance(amount: Int)

      val balanceOverdrawnPred = Predicate[Balance](_.amount > 0)

      val getAccountBalance: Person => Balance = p => // that hows Banks works :)
        if(p.name.startsWith("A")) Balance(-1)
        else Balance(42)

      def contramap[A, B](pred: Predicate[A])(f: B => A): Predicate[B] =
        Predicate[B](f andThen pred.fun)

      val hasOverdrawnBalance = contramap(balanceOverdrawnPred)(getAccountBalance)

      hasOverdrawnBalance.fun(Person("Alice")) mustBe false
      hasOverdrawnBalance.fun(Person("Bob")) mustBe true
    }

    it("contramap with Contravariant instance") {

      implicit val predicateContravariant: Contravariant[Predicate] =
        new Contravariant[Predicate] {
          def contramap[A, B](pred: Predicate[A])(fba: B => A): Predicate[B] =
            Predicate[B](fba andThen pred.fun)
        }

      case class Person(name: String)
      case class Balance(amount: Int)

      val balanceOverdrawn = Predicate[Balance](_.amount > 0)

      val getAccountBalance: Person => Balance = p =>
        if(p.name.startsWith("A")) Balance(-1)
        else Balance(42)

      val hasOverdrawnBalance = Contravariant[Predicate]
        .contramap(balanceOverdrawn)(getAccountBalance)

      hasOverdrawnBalance.fun(Person("Alice")) mustBe false
      hasOverdrawnBalance.fun(Person("Bob")) mustBe true
    }
  }
} 

package mtl

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers


class TraverseEmptyListPermutationsSpec
  extends AnyFunSpec
  with Matchers {

  describe("filterA") {
    it("compute all permutations of the lit if given List(true, false)") {
      import cats._
      import cats.implicits._

      val allPermutations = List(
        List(1, 2, 3),
        List(1, 2),
        List(1, 3),
        List(2, 3),
        List(1),
        List(2),
        List(3),
        Nil
      )
      val result: List[List[Int]] = List(1, 2, 3).filterA(_ => List(true, false))
      result contains theSameElementsAs (allPermutations)
    }
  }
} 

package monad

import scala.concurrent.duration.Duration
import scala.concurrent.duration._
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

case class Reader[A, B](run: A => B) { // B is changing and A is constant

  def map[C](f: B => C): Reader[A, C] = Reader(run andThen f)

  def flatMap[C](f: B => Reader[A, C]): Reader[A, C] = {
//    def attempt1: A => Reader[A, C] = a => f(run(a))
//    def attempt2: A => (A => C) = (a:A) => f(run(a)).run
    def attempt3: A => C = (a:A) => {
      val b: B = run(a)
      val reader: Reader[A, C] = f(b)
      reader.run(a)
    }
    Reader(attempt3)
  }

  def flatten(r: Reader[A, Reader[A, B]]): Reader[A, B] = { // pass the context A to outer computation and inner computation
    def newRun: A => B = a => {
      val firstRun: Reader[A, B] = r.run(a)
      firstRun.run(a)
    }
    Reader(newRun)
  }
}

object Reader {

  def ask[A]: Reader[A, A] = Reader(identity)
}

class ReaderMonadSpec
  extends AnyFunSpec
  with Matchers {

  describe("Reader") {
    case class DbConfig(maxTimeout: Duration, jdbc: String, user: String, pass: String)

    val baseConfig = DbConfig(60.seconds, "jdbc://localhost:5432/db", "admin", "1234")
    type FindById = Int => String

    def getAllCustomerIds: DbConfig => List[Int] = _ => List(1, 42) // it pass the tests so who cares
    def getDefaultCustomer: DbConfig => FindById = conf => id => s"Johnny Bravo $id"

    it("produces something from configuration") {
      val reader: Reader[DbConfig, (Int => String)] = Reader(getDefaultCustomer)
      reader.run(baseConfig)(1) mustBe "Johnny Bravo 1"
    }

    it("is like Functor") {
      val reader: Reader[DbConfig, List[Int]] = Reader(getAllCustomerIds)
      reader.map(_.mkString(", ")).run(baseConfig) mustBe "1, 42"
    }
  }
} 

package be.dataminded.lighthouse.testing

import org.scalatest.funspec.AnyFunSpec

private case class Person(name: String, age: Int)

class DatasetComparerSpec extends AnyFunSpec with SharedSparkSession with DatasetComparer {

  import spark.implicits._

  describe("assertDatasetEquality") {
    it("does nothing true if the Datasets have the same schemas and content") {
      val actual   = Seq(Person("bob", 1), Person("frank", 5)).toDS
      val expected = Seq(Person("bob", 1), Person("frank", 5)).toDS

      assertDatasetEquality(actual, expected)
    }

    it("can performed unordered Dataset comparisons") {
      val actual   = Seq(Person("bob", 1), Person("frank", 5)).toDS
      val expected = Seq(Person("frank", 5), Person("bob", 1)).toDS

      assertDatasetEquality(actual, expected, orderedComparison = false)
    }

    it("throws an error for unordered Dataset comparisons that don't match") {
      val actual   = Seq(Person("bob", 1), Person("frank", 5)).toDS
      val expected = Seq(Person("frank", 5), Person("bob", 1), Person("sadie", 2)).toDS

      intercept[AssertionError] {
        assertDatasetEquality(actual, expected, orderedComparison = false)
      }
    }

    it("returns false if the Dataset content is different") {
      val actual   = Seq(Person("bob", 1), Person("frank", 5)).toDS
      val expected = Seq(Person("sally", 66), Person("sue", 54)).toDS

      intercept[AssertionError] {
        assertDatasetEquality(actual, expected)
      }
    }
  }

  describe("assertDatasetEquality using DataFrames") {
    it("does nothing if the DataFrames have the same schemas and content") {
      val actual   = Seq(1, 5).toDF("number")
      val expected = Seq(1, 5).toDF("number")

      assertDatasetEquality(actual, expected)
    }

    it("assert fails if the DataFrames have different schemas") {
      val actual   = Seq(1, 5).toDF("number")
      val expected = Seq((1, "hi"), (5, "bye")).toDF("number", "word")

      intercept[AssertionError] {
        assertDatasetEquality(actual, expected)
      }
    }

    it("throws an error if the DataFrames content is different") {
      val actual   = Seq(1, 5).toDF("number")
      val expected = Seq(10, 5).toDF("number")

      intercept[AssertionError] {
        assertDatasetEquality(actual, expected)
      }
    }

    it("can performed unordered DataFrame comparisons") {
      val actual   = Seq(1, 5).toDF("number")
      val expected = Seq(5, 1).toDF("number")

      assertDatasetEquality(actual, expected, orderedComparison = false)
    }

    it("throws an error for unordered DataFrame comparisons that don't match") {
      val actual   = Seq(1, 5).toDF("number")
      val expected = Seq(5, 2).toDF("number")

      intercept[AssertionError] {
        assertDatasetEquality(actual, expected)
      }
    }
  }
} 

package be.dataminded.lighthouse.testing

import org.apache.spark.sql.functions._
import org.scalatest.funspec.AnyFunSpec

class ColumnComparerSpec extends AnyFunSpec with SharedSparkSession with ColumnComparer {

  import spark.implicits._

  describe("assertColumnEquality") {

    it("doesn't do anything if all the column values are equal") {
      val source = Seq((1, 1), (5, 5)).toDF("num", "expected")

      assertColumnEquality(source, "num", "expected")
    }

    it("throws an error if the columns aren't equal") {
      val source = Seq((1, 3), (5, 5)).toDF("num", "expected")

      intercept[AssertionError] {
        assertColumnEquality(source, "num", "expected")
      }
    }

    it("throws an error if the columns are different types") {
      val source = Seq((1, "hi"), (5, "bye")).toDF("num", "word")

      intercept[AssertionError] {
        assertColumnEquality(source, "num", "word")
      }
    }

    it("works properly, even when null is compared with a value") {
      val source = Seq((1, 1), (null.asInstanceOf[Int], 5), (null.asInstanceOf[Int], null.asInstanceOf[Int]))
        .toDF("num", "expected")

      intercept[AssertionError] {
        assertColumnEquality(source, "num", "expected")
      }
    }

    it("works for ArrayType columns") {
      val source =
        Seq((Array("a"), Array("a")), (Array("a", "b"), Array("a", "b"))).toDF("left", "right")
      assertColumnEquality(source, "left", "right")
    }

    it("works for computed ArrayType columns") {
      val source = Seq(
        ("i like blue and red", Array("blue", "red")),
        ("you pink and blue", Array("blue", "pink")),
        ("i like fun", Array(""))
      ).toDF("words", "expected_colors")

      val actual = source.withColumn(
        "colors",
        split(
          concat_ws(
            ",",
            when(col("words").contains("blue"), "blue"),
            when(col("words").contains("red"), "red"),
            when(col("words").contains("pink"), "pink"),
            when(col("words").contains("cyan"), "cyan")
          ),
          ","
        )
      )
      assertColumnEquality(actual, "colors", "expected_colors")
    }
  }
} 

package be.dataminded.lighthouse.common

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class DatabaseTest extends AnyFunSpec with Matchers {

  describe("An in-memory database") {

    val database = Database.inMemory("test")

    it("can easily be created using the factory method") {
      database.driverClassName should equal("org.h2.Driver")
    }

    it("has a function for using the connection") {
      database.withConnection { connection =>
        connection.createStatement.execute("CREATE TABLE nothing (id varchar, name varchar)")
      }
    }

    it("is by default auto-commited") {
      val isAutoCommit = database.withConnection { connection =>
        connection.getAutoCommit
      }
      isAutoCommit should be(true)
    }

    it("can be configured to not be auto-commited") {
      val isAutoCommit = database.withConnection(autoCommit = false) { connection =>
        connection.getAutoCommit
      }
      isAutoCommit should be(false)
    }
  }
} 

package be.dataminded.lighthouse.datalake

import java.util.Properties

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class PackageTest extends AnyFunSpec with Matchers {

  describe("asProperties") {
    it("should convert a Scala to Java Properties implicitly") {
      val properties: Properties = Map("test1" -> "1", "test2" -> "2")

      properties.getProperty("test1") should equal("1")
      properties.getProperty("test2") should equal("2")
    }

    it("does only convert maps of type Map[String, String]") {
      assertDoesNotCompile("val properties: Properties = Map(\"test1\" -> 1, \"test2\" -> 2)")
    }
  }
} 

package be.dataminded.lighthouse.pipeline

import be.dataminded.lighthouse.testing.SharedSparkSession
import better.files._
import org.scalatest.BeforeAndAfterEach
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class TextSinkSpec extends AnyFunSpec with SharedSparkSession with Matchers with BeforeAndAfterEach {

  import spark.implicits._

  describe("TextSink") {
    it("should write the contents of a DataFrame as text") {
      val data = Seq("datadata", "datadatadata").toDF("single")

      SparkFunction.of(data).write(TextSink("./target/output/text")).run(spark)

      ("target" / "output" / "text").glob("*.txt").map(_.contentAsString).toSeq should contain theSameElementsAs Seq(
        "datadata\n",
        "datadatadata\n"
      )
    }
  }

  override protected def afterEach(): Unit = {
    ("target" / "output" / "text").delete(true)
  }
} 

package be.dataminded.lighthouse.pipeline

import java.io.ByteArrayOutputStream

import be.dataminded.lighthouse.testing.SharedSparkSession
import better.files._
import org.apache.spark.sql.Dataset
import org.apache.spark.storage.StorageLevel
import org.scalatest.BeforeAndAfter
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class RichSparkFunctionsSpec extends AnyFunSpec with Matchers with SharedSparkSession with BeforeAndAfter {

  import spark.implicits._

  describe("SparkFunctions with a DataSet inside should have extra functionality") {

    val function = SparkFunction.of(Seq(1, 2, 3, 4, 5).toDS())

    it("can cache") {
      function.cache().run(spark).storageLevel should equal(StorageLevel.MEMORY_ONLY)
    }

    it("can drop the cache") {
      function.cache().dropCache().run(spark).storageLevel should equal(StorageLevel.NONE)
    }

    it("can be written to a sink") {
      function.write(OrcSink("target/output/orc")).run(spark)

      file"target/output/orc".exists should be(true)
    }

    it("can be written to multiple sinks") {
      function.write(OrcSink("target/output/orc"), OrcSink("target/output/orc2")).run(spark)

      file"target/output/orc".exists should be(true)
      file"target/output/orc2".exists should be(true)
    }

    it("is being cached when writing to multiple sinks for performance") {
      val result = function.write(OrcSink("target/output/orc"), OrcSink("target/output/orc2")).run(spark)

      result.storageLevel should equal(StorageLevel.MEMORY_ONLY)
    }

    it("can easily be counted") {
      function.count().run(spark) should equal(5)
    }

    it("can print the schema") {
      val stream = new ByteArrayOutputStream()
      Console.withOut(stream) {
        function.printSchema().run(spark)
      }
      stream.toString() should include("value: integer (nullable = false)")
    }

    it("can be be used as a Dataset") {
      function.as[Int].run(spark) shouldBe a[Dataset[_]]
    }
  }

  after {
    file"target/output/orc".delete(true)
    file"target/output/orc2".delete(true)
  }
} 

package contravariant

import scalaz.Divide
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class DivideSpec
  extends AnyFunSpec
  with Matchers {

  describe("Divide") {

    case class Serializer[A](run: A => Array[Byte])
    val strSerial = Serializer[String](_.getBytes)
    val intSerial = Serializer[Int](_.toString.getBytes)

    case class Fragment(name: String, size: Int)

    it("custom implementation of Fragment serializer") {

      val fragmentSerial = Serializer[Fragment] { frag =>
        val a1 = strSerial.run(frag.name)
        val a2 = intSerial.run(frag.size)
        a1 ++ a2
      }

      val serialized = fragmentSerial.run(Fragment("Area", 52))
      new String(serialized ) mustBe "Area52"
    }

    it("Fragment serializer using Divide") {

      implicit val fragmentDivide: Divide[Serializer] = new Divide[Serializer] {
        def divide2[A1, A2, Z](s1: => Serializer[A1], s2: => Serializer[A2])(f: Z => (A1, A2)):
            Serializer[Z] = Serializer{ frag =>
          val (a1,a2) = f(frag)
          val serialized1 = s1.run(a1)
          val serializedB = s2.run(a2)
          serialized1 ++ serializedB
        }

        def contramap[A, B](r: Serializer[A])(f: B => A): Serializer[B] = Serializer(f andThen r.run)
      }

      val fragAsTuple: Fragment => (String, Int) = frag => (frag.name, frag.size)
      val fragmentSerial: Serializer[Fragment] = Divide[Serializer].divide(
        strSerial, intSerial)(fragAsTuple)

      val serialized = fragmentSerial.run(Fragment("Area", 52))
      new String(serialized ) mustBe "Area52"
    }
  }
} 

package org.jmotor.sbt.parser

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers
import sbt.ModuleID

class PluginParserSpec extends AnyFunSpec with Matchers {

  describe("PluginParser") {
    it("reads normal plugin") {
      val lines =
        """
          |addSbtPlugin("org.jmotor.sbt" % "sbt-dependency-updates" % "1.1.0")
        """.stripMargin.split("\n")
      val found = PluginParser.parse(lines).toList
      found shouldBe Seq(ModuleID("org.jmotor.sbt", "sbt-dependency-updates", "1.1.0"))
    }

    it("reads a few plugins with mixed content") {
      val lines =
        """
          | // comments
          |
          |addSbtPlugin("org.jmotor.sbt" % "sbt-dependency-updates" % "1.1.0")
          |
          |  addSbtPlugin("org.scalastyle" %% "scalastyle-sbt-plugin" % "1.0.0")
          |
        """.stripMargin.split("\n")

      val found = PluginParser.parse(lines).toList
      found shouldBe Seq(
        ModuleID("org.jmotor.sbt", "sbt-dependency-updates", "1.1.0"),
        ModuleID("org.scalastyle", "scalastyle-sbt-plugin", "1.0.0"))
    }

    it("doesnt crash on the intellij plugin") {
      val lines =
        """
          |// Generated by IntelliJ-IDEA Scala plugin.
          |// Add settings when starting sbt from IDEA.
          |// Manual changes to this file will be lost.
          |if (java.lang.System.getProperty("idea.runid", "false") == "2017.2") scala.collection.Seq(
          |addSbtPlugin("org.jetbrains" % "sbt-structure-extractor" % "2017.2"),
          |addSbtPlugin("org.jetbrains" % "sbt-idea-shell" % "2017.2")
          |) else scala.collection.Seq.empty%
        """.stripMargin.split("\n")

      PluginParser.parse(lines) shouldBe Seq(ModuleID("org.jetbrains", "sbt-idea-shell", "2017.2"))
    }
  }
} 

package com.sksamuel.avro4s.schema

import com.sksamuel.avro4s.{AvroSchema, Encoder, FromRecord, ImmutableRecord, ToRecord}
import org.apache.avro.util.Utf8
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class SchemaForUtf8Test extends AnyFunSpec with Matchers {

  describe("Serialization of objects containing Utf8 fields") {
    it("should serialize objects that contains simple Utf8 attributes") {
      case class Person(name: Utf8, alias: Utf8, age: Int)

      ToRecord[Person].to(Person(new Utf8("Name"), new Utf8("Alias"), 30))
    }

    it("should serialize objects that contains simple Utf8 attributes and one attribute has a default value") {
      case class Person(name: Utf8, alias: Utf8 = new Utf8("Not specified"), age: Int)

      ToRecord[Person].to(Person(name = new Utf8("Name"), age = 30))
    }

    it("should serialize objects that contains Optional Utf8 attributes") {
      case class Person(name: Utf8, alias: Option[Utf8], age: Int)

      ToRecord[Person].to(Person(new Utf8("Name"), Some(new Utf8("Alias")), 30))
      ToRecord[Person].to(Person(new Utf8("Name"), None, 30))
    }

    it("should serialize objects that contains Optional Utf8 attributes and one attribute has a default value") {
      case class Person(name: Utf8, alias: Option[Utf8] = Some(new Utf8("Not specified")), age: Int)

      ToRecord[Person].to(Person(new Utf8("Name"), Some(new Utf8("Alias")), 30))
      ToRecord[Person].to(Person(new Utf8("Name"), None, 30))
    }
  }

  describe("Deserialization of objects containing Utf8 fields") {
    it("should deserialize objects that contains simple Utf8 attributes") {
      case class Person(name: Utf8, alias: Utf8, age: Int)

      val record = ImmutableRecord(AvroSchema[Person], Vector(new Utf8("Name"), new Utf8("Alias"), 30.asInstanceOf[AnyRef]))
      FromRecord[Person].from(record)
    }

    it("should deserialize objects that contains Optional Utf8 attributes") {
      case class Person(name: Utf8, familyName: Option[Utf8], alias: Option[Utf8], age: Int)

      val record = ImmutableRecord(AvroSchema[Person], Vector(new Utf8("Name"), None, Some(new Utf8("Alias")), 30.asInstanceOf[AnyRef]))
      FromRecord[Person].from(record)
    }
  }

} 

package com.sksamuel.avro4s.github

import com.sksamuel.avro4s.github.SampleProtocol.SubPart1.InnerEnum
import com.sksamuel.avro4s.{AvroSchema, FromRecord, ToRecord}
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

import scala.language.higherKinds

object TopEnum extends Enumeration {
  type TopEnumVal = Value
  val v1, v2 = Value
}

case class WithTopEnum(topEnum: TopEnum.TopEnumVal)

object SampleProtocol {
  object SubPart1 {
    object InnerEnum extends Enumeration {
      type InnerEnum = Value
      val vv1, vv2 = Value
    }
  }
}

case class WithInnerEnum(ie: InnerEnum.InnerEnum)

class Githu4bIssue180 extends AnyFunSpec with Matchers {

  describe("SchemaFor : FromRecord : ToRecord") {
    describe("with top level scala Enumerations") {
      val withTopEnum = WithTopEnum(TopEnum.v1)
      it("should be able to compile `FromRecord`") {
        FromRecord[WithTopEnum] shouldNot be(null)
      }
      it("should be able to compile `ToRecord`") {
        ToRecord[WithTopEnum] shouldNot be(null)
      }
      it("should be able to compile `SchemaFor`") {
        AvroSchema[WithTopEnum] shouldNot be(null)
      }
    }

    describe("with non-top level scala Enumerations") {
      val withInnerEnum = WithInnerEnum(InnerEnum.vv1)
      it("should be able to compile `FromRecord`") {
        FromRecord[WithInnerEnum] shouldNot be(null)
      }
      it("should be able to compile `ToRecord`") {
        ToRecord[WithInnerEnum] shouldNot be(null)
      }
      it("should be able to compile `SchemaFor`") {
        AvroSchema[WithInnerEnum] shouldNot be(null)
      }
    }
  }
} 

package core.issues

import com.twilio.guardrail._
import com.twilio.guardrail.generators.Scala.AkkaHttp
import com.twilio.guardrail.generators.syntax.Scala.companionForStaticDefns
import support.SwaggerSpecRunner

import scala.meta._
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class Issue145 extends AnyFunSpec with Matchers with SwaggerSpecRunner {

  describe("Generate hierarchical classes") {

    val swagger: String = """
      | swagger: '2.0'
      | info:
      |   title: Parsing Error Sample
      |   version: 1.0.0
      | definitions:
      |   Pet:
      |     type: object
      |     properties:
      |       name:
      |         type: string
      |         x-scala-empty-is-null: true
      |         x-scala-type: CustomThing
      |       underscore_name:
      |         type: string
      |         x-scala-empty-is-null: true
      |         x-scala-type: CustomThing
      |       dash-name:
      |         type: string
      |         x-scala-empty-is-null: true
      |         x-scala-type: CustomThing
      |""".stripMargin

    val (
      ProtocolDefinitions(
        ClassDefinition(namePet, tpePet, _, clsPet, staticDefnsPet, catParents) :: Nil,
        _,
        _,
        _
      ),
      _,
      _
    ) = runSwaggerSpec(swagger)(Context.empty, AkkaHttp)

    it("should generate right companion object") {
      val cmp       = companionForStaticDefns(staticDefnsPet)
      val companion = q"""
        object Pet {
          implicit val encodePet: Encoder.AsObject[Pet] = {
            val readOnlyKeys = Set[String]()
            Encoder.AsObject.instance[Pet](a => JsonObject.fromIterable(Vector(("name", a.name.asJson), ("underscore_name", a.underscoreName.asJson), ("dash-name", a.dashName.asJson)))).mapJsonObject(_.filterKeys(key => !(readOnlyKeys contains key)))
          }
          implicit val decodePet: Decoder[Pet] = new Decoder[Pet] { final def apply(c: HCursor): Decoder.Result[Pet] = for (v0 <- c.downField("name").withFocus(j => j.asString.fold(j)(s => if (s.isEmpty) Json.Null else j)).as[Option[CustomThing]]; v1 <- c.downField("underscore_name").withFocus(j => j.asString.fold(j)(s => if (s.isEmpty) Json.Null else j)).as[Option[CustomThing]]; v2 <- c.downField("dash-name").withFocus(j => j.asString.fold(j)(s => if (s.isEmpty) Json.Null else j)).as[Option[CustomThing]]) yield Pet(v0, v1, v2) }
        }
      """

      cmp.structure shouldBe companion.structure
    }

  }
} 

package core.issues

import com.twilio.guardrail.generators.Scala.Http4s
import com.twilio.guardrail.{ Context, Server, Servers }
import support.SwaggerSpecRunner
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class Issue260 extends AnyFunSpec with Matchers with SwaggerSpecRunner {

  describe("LocalDate path param is generated more than once") {

    val swagger: String = """
      | openapi: "3.0.0"
      | info:
      |   title: Generator Error Sample
      |   version: 1.0.0
      | paths:
      |   /users/{userId}/occasions/{date}:
      |     parameters:
      |       - $ref: '#/components/parameters/UserIdParam'
      |       - $ref: '#/components/parameters/DateParam'
      |     get:
      |       operationId: getOccasionByDate
      |       responses:
      |         200:
      |           description: Requested occasion
      |           content:
      |             application/json:
      |               schema:
      |                 $ref: '#/components/schemas/OccasionResponseJson'
      |         404:
      |           description: Requested user or occasion was not found
      |     delete:
      |       operationId: deleteOccasionByDate
      |       responses:
      |         204:
      |           description: Succesfully deleted occasion
      |         404:
      |           description: Requested user or occasion was not found
      | components:
      |   parameters:
      |     UserIdParam:
      |       name: userId
      |       in: path
      |       description: Id of the specific user
      |       required: true
      |       schema:
      |         type: string
      |     DateParam:
      |       name: date
      |       in: path
      |       description: Date of the specific occasion
      |       required: true
      |       schema:
      |         type: string
      |         format: date
      |   schemas:
      |     OccasionResponseJson:
      |       type: object
      |       properties:
      |         date:
      |           type: string
      |           format: date
      |       required:
      |         - date""".stripMargin

    val (
      _, // ProtocolDefinitions
      _, // clients
      Servers(
        Server(
          _, // pkg
          _, // extraImports
          _, // genHandler
          serverDefinition :: _
        ) :: Nil,
        _ // supportDefinitions
      )
    ) = runSwaggerSpec(swagger)(Context.empty, Http4s)

    it("Ensure LocalDateVar is generated only once") {

      val pattern = "object LocalDateVar".r

      val hits = pattern.findAllIn(serverDefinition.toString()).length

      hits shouldBe 1
    }
  }
} 

package es.weso.slang
import org.scalatest.matchers.should.Matchers 
import org.scalatest.funspec.AnyFunSpec

import es.weso.rdf.jena.RDFAsJenaModel
import es.weso.rdf.nodes.IRI
import es.weso.shex.Schema
import cats.data._ 
import cats.effect._ 
import es.weso.utils.IOUtils._

class ValidationTest extends AnyFunSpec with Matchers with SLang2Clingo with ShEx2SLang {

  describe(s"SLang validation") {
    it(s"Should validate simple example") {
      val node = IRI("http://example.org/a")
      val shape: SLang  = Ref(IRILabel(IRI("http://example.org/User")))
      val r: EitherT[IO,String,ShapesMap] = for {
        rdf <- io2es(RDFAsJenaModel.fromChars(
          """|<a> <name> "a" ;
             | <knows> <a> .
            |
          """.stripMargin, "TURTLE",Some(IRI("http://example.org/"))))
        schema <- io2es(Schema.fromString(
          """|
             |<User> {
             | <name> . ;
             | <knows> .
             |}
          """.stripMargin, "ShEXC",Some(IRI("http://example.org/"))))
        slangSchema <- shex2SLang(schema)
        eitherResult <- io2es(Validation.runValidation(node, shape, rdf, slangSchema))
        result <- either2es(eitherResult)
      } yield result

      run_es(r).unsafeRunSync.fold(e => fail(s"Error: $e"), result => {
        result.isConforming(node, shape) should be(Conforms)
      })
    }
  }
} 

package com.chatwork.quiz.collection

import com.chatwork.quiz.{ MyNone, MySome }
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class MyListSpec extends AnyFunSpec with Matchers {

  describe("MyList#apply") {
    it("should return a new MyList instance") {
      MyList(1, 2, 3) shouldEqual MyCons(1, MyCons(2, MyCons(3, MyNil)))
      MyList() shouldEqual MyNil
    }
  }

  describe("MyList#foldLeft") {
    it("should apply an operator a start value and all elements from left to right") {
      MyList("H", "e", "l", "l", "o").foldLeft("Say ") { _ + _ } shouldEqual "Say Hello"
    }
  }

  describe("MyList#foldRight") {
    it("should apply an operator a start value and all elements from right to left") {
      MyList("H", "e", "l", "l", "o").foldRight(" World") { _ + _ } shouldEqual "Hello World"
    }
  }

  describe("MyList#::") {
    it("should return a new MyList added an element at the beginning of this list") {
      "H" :: MyList("e", "l", "l", "o") shouldEqual MyList("H", "e", "l", "l", "o")
    }
  }

  describe("MyList#reverse") {
    it("should return a new MyList with elements in reversed order") {
      MyList(1, 2, 3, 4).reverse shouldEqual MyList(4, 3, 2, 1)
    }
  }

  describe("MyList#++") {
    it("should return a new MyList with elements appended") {
      MyList(1, 2) ++ MyList(3, 4) shouldEqual MyList(1, 2, 3, 4)
    }
  }

  describe("MyList#map") {
    it("should apply an operator to each element in the list") {
      MyList(1, 2, 3, 4).map(_ * 2) shouldEqual MyList(2, 4, 6, 8)
    }
  }

  describe("MyList#flatMap") {
    it("should apply an operator to each element in the list and flatten") {
      MyList(MyList(1, 2), MyList(3, 4), MyList(5, 6), MyList(7, 8))
        .flatMap(_.map(_ * 2)) shouldEqual MyList(2, 4, 6, 8, 10, 12, 14, 16)
    }
  }

  describe("MyList#filter") {
    it("should return a new MyList containing elements filtered by the given predicate") {
      MyList(1, 2, 3, 4, 5).filter(_ > 3) shouldEqual MyList(4, 5)
    }
  }

  describe("MyList#find") {
    it("should return the first element of the sequence satisfying a predicate") {
      MyList(1, 2, 3, 4, 5).find(_ == 1) shouldEqual MySome(1)
      MyList(1, 2, 3, 4, 5).find(_ == 6) shouldEqual MyNone
    }
  }

  describe("for comprehension") {
    it("should provide for comprehension") {
      (for {
        suit   <- MyList("Diamond", "Heart", "Spade", "Club")
        number <- MyList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
        if suit == "Diamond"
      } yield {
        (suit, number)
      }).length shouldBe 13
    }
  }

} 

package com.chatwork.quiz.misc

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class WordCounterSpec extends AnyFunSpec with Matchers {

  describe("WordCounter#countWord") {
    it("should count words") {
      val words = List("apple banana", "orange apple mango", "kiwi papaya orange", "mango orange muscat apple")
      WordCounter.countWords(words) shouldBe Map(
        "banana" -> 1,
        "muscat" -> 1,
        "orange" -> 3,
        "mango"  -> 2,
        "apple"  -> 3,
        "kiwi"   -> 1,
        "papaya" -> 1
      )
    }
  }

} 

package com.chatwork.quiz.misc

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

import scala.math.Ordering.IntOrdering

class BTreeSpec extends AnyFunSpec with Matchers {

  describe("BTree#size") {
    it("should return the number of elements in the BTree") {
      BTree(Branch(Leaf(1), 2, Leaf(3))).size shouldBe 3
      BTree(Leaf(1)).size shouldBe 1
    }
  }

  describe("BTree#max") {
    it("should return the max value in the BTree") {
      BTree(Branch(Leaf(1), 2, Leaf(3))).max shouldBe 3
    }
  }

  describe("BTree#min") {
    it("should return the min value in the BTree") {
      BTree(Branch(Leaf(1), 2, Leaf(3))).min shouldBe 1
    }
  }

  describe("BTree#sum") {
    it("should return the sum of values in the BTree") {
      BTree(Branch(Leaf(1), 2, Leaf(3))).sum shouldBe 6
    }
  }

  describe("BTree#avg") {
    it("should return the average of values in the BTree") {
      BTree(Branch(Leaf(1), 2, Leaf(3))).avg shouldBe 2.0d
    }
  }

  describe("BTree#find") {
    it("should return a node has the value in the BTree") {
      BTree(Branch(Leaf(1), 2, Leaf(3))).find(1) shouldBe Some(Leaf(1))
    }
  }

  describe("BTree#apply") {
    it("should return a new BTree from List[Int]") {
      BTree(List(1, 2, 3)) shouldEqual BTree(Branch(Leaf(1), 2, Leaf(3)))
    }
  }

} 

package applicative

import educational.category_theory.Applicative
import educational.collections.HeadNel
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class ApplicativeExamplesSpec
  extends AnyFunSpec
  with Matchers {

  describe("derived methods") {
    it("option instance") {
      val optionApplicative: Applicative[Option] = new Applicative[Option] {
        def pure[A](a: A): Option[A] = ???
        def ap[A, B](ff: Option[A => B])(fa: Option[A]): Option[B] = ???
      }

      // TODO
    }

    it("ValidatedNel instance") {
      sealed trait ValidatedNel[A]
      case class SuccessVN[A](value: A) extends ValidatedNel[A]
      case class Errors[A](errors: HeadNel[Throwable]) extends ValidatedNel[A]

      val optionApplicative: Applicative[ValidatedNel] = new Applicative[ValidatedNel] {
        override def pure[A](value: A): ValidatedNel[A] = ???
        override def ap[A, B](ff: ValidatedNel[A => B])(fa: ValidatedNel[A]): ValidatedNel[B] = ???
      }

      // TODO
    }

    it("examples for Option") {
      import cats.Applicative
      import cats.implicits.catsStdInstancesForOption

      val add3: Int => Int = a => a + 3

      Applicative[Option].pure(42) mustBe Some(42)
      Applicative[Option].ap(Some(add3))(Some(39)) mustBe Some(42)
    }

    it("examples for List") {
      import cats.Applicative
      import cats.implicits.catsStdInstancesForList


      val list1 = List(1, 2)
      val listFns: List[Int => Int] = List(a => a + 3, a => a * a)

      Applicative[List].ap(listFns)(list1) mustBe List(4,5,1,4)
      Applicative[List].pure("foo") mustBe List("foo")
    }

    it("map2 on composed Applicative") {
      import cats.Applicative
      import cats.implicits.catsStdInstancesForList
      import cats.implicits.catsStdInstancesForOption

      val listOpt = Applicative[List] compose Applicative[Option]

      val list1 = List(Some(2), None)
      val list2 = List(Some(10), Some(2))
      listOpt.map2(list1, list2)(_ + _) mustBe List(Some(12), Some(4), None, None)
    }
  }
} 

package org.deeplearning4j.scalphagozero.agents

import java.util.Random
import org.scalatest.funspec.AnyFunSpec

class ProbabilityDistributionTest extends AnyFunSpec {

  describe("Select from a distribution") {

    it("should be low index if distribution skewed low") {
      val dist = createPDist(Array(0.9, 0.8, 0.5, 0.3, 0.2, 0.1, 0.01, 0.001))
      assert(dist.selectRandomIdx() == 2)
      assert(dist.selectRandomIdx() == 1)
      assert(dist.selectRandomIdx() == 0)
    }

    it("should be high index if distribution skewed high") {
      val dist = createPDist(Array(0.001, 0.01, 0.1, 0.3, 0.8, 0.5, 0.8, 0.9))
      assert(dist.selectRandomIdx() == 6)
    }

    it("should be highest index if distribution skewed very high") {
      val dist = createPDist(Array(0.001, 0.01, 0.01, 0.01, 0.01, 0.1, 0.9))
      assert(dist.selectRandomIdx() == 6)
    }

    it("should be near middle if gaussian distribution") {
      val dist = createPDist(Array(0.001, 0.01, 0.1, 0.3, 0.6, 0.8, 0.9, 0.9, 0.8, 0.55, 0.4, 0.2, 0.05, 0.01))
      assert(dist.selectRandomIdx() == 8)
    }

    it("random if uniform distribution") {
      val dist = createPDist(Array(0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2, 0.2))
      assert(dist.selectRandomIdx() == 5)
    }

    it("should be 0 index if distribution has only 1 0 value") {
      val dist = createPDist(Array(0.0))
      assert(dist.selectRandomIdx() == 0)
    }
  }

  private def createPDist(a: Array[Double]) = ProbabilityDistribution(a, new Random(1))
} 

package org.deeplearning4j.scalphagozero.agents

import java.io.File

import org.deeplearning4j.nn.graph.ComputationGraph
import org.deeplearning4j.scalphagozero.board.{ BlackPlayer, GameState, GoBoard }
import org.deeplearning4j.scalphagozero.board.Move.Play
import org.deeplearning4j.scalphagozero.encoders.ZeroEncoder
//import org.nd4j.linalg.api.ndarray.INDArray
import org.scalatest.funspec.AnyFunSpec
import org.deeplearning4j.scalphagozero.PATH_PREFIX
//import scala.collection.mutable.ListBuffer
import scala.util.Random



  // 1 .O.O.
  // 2 OOOO.
  // 3 .XX.X
  // 4 .X.X.
  // 5 .XOX.
  //   12345
  private def createSimple5x5GameState(): GameState = {
    var state = GameState(GoBoard(5), BlackPlayer)
    state = state.applyMove(Play(3, 3))
    state = state.applyMove(Play(2, 3)) // white
    state = state.applyMove(Play(3, 2))
    state = state.applyMove(Play(2, 2)) // white
    state = state.applyMove(Play(4, 2))
    state = state.applyMove(Play(2, 1)) // white
    state = state.applyMove(Play(4, 4))
    state = state.applyMove(Play(5, 3)) // white
    state = state.applyMove(Play(5, 2))
    state = state.applyMove(Play(2, 4)) // white
    state = state.applyMove(Play(3, 5))
    state = state.applyMove(Play(1, 4)) // white
    state = state.applyMove(Play(5, 4))
    state = state.applyMove(Play(1, 2)) // white
    //println(state.board)
    state
  }
} 

package org.deeplearning4j.scalphagozero.agents

import java.io.File
import org.deeplearning4j.nn.graph.ComputationGraph
import org.deeplearning4j.scalphagozero.PATH_PREFIX
import org.deeplearning4j.scalphagozero.board.Move.Play
import org.deeplearning4j.scalphagozero.board.{ BlackPlayer, GameState, GoBoard, Move }
import org.deeplearning4j.scalphagozero.encoders.ZeroEncoder
import org.deeplearning4j.scalphagozero.strip
import org.scalatest.funspec.AnyFunSpec

class ZeroTreeNodeCreatorTest extends AnyFunSpec {

  describe("zeroTreeNode creation") {

    val model: ComputationGraph =
      ComputationGraph.load(new File(PATH_PREFIX + "model_size_5_layers_2_test.model"), true)
    val encoder = new ZeroEncoder(5)
    val creator = new ZeroTreeNodeCreator(model, encoder)

    val gameState = createSimple5x5GameState()

    val zeroTreeNode = creator.createNode(gameState: GameState)
    it("should create expected zero tree node given gameState") {
      assert(zeroTreeNode.lastMove.isEmpty)
      assert(
        zeroTreeNode.gameState.board.toString ==
          strip("""--------
            | 5 .O.O.
            | 4 OOOO.
            | 3 .XX.X
            | 2 .X.X.
            | 1 .XOX.
            |   ABCDE
            |--------""")
      )
      assert(zeroTreeNode.totalVisitCount == 1)

      val validNextMoves = List(
        Play(5, 1),
        Play(3, 1),
        Play(5, 5),
        Play(4, 1),
        Play(4, 5),
        Play(4, 3),
        Play(1, 5),
        Move.Pass,
        Play(2, 5),
        Play(3, 4)
      )
      assert(zeroTreeNode.moves == validNextMoves)
    }

    it("should not have a child move that is not a valid next move") {
      assert(!zeroTreeNode.branches.keySet.contains(Play(2, 3)))
    }

    it("should have expected values after move(3, 4)") {
      val move = Move.Play(3, 4)
      assert(zeroTreeNode.branches.keySet.contains(move))
      assert(zeroTreeNode.expectedValue(move) == 0)
      assert(zeroTreeNode.visitCount(move) == 0)
      assert(Math.abs(zeroTreeNode.prior(move) - 0.0465302057564) < 0.000001)
    }

    it("should have expected values after move(2, 5)") {
      val move = Move.Play(2, 5)
      assert(zeroTreeNode.branches.keySet.contains(move))
      assert(zeroTreeNode.expectedValue(move) == 0)
      assert(zeroTreeNode.visitCount(move) == 0)
      assert(Math.abs(zeroTreeNode.prior(move) - 0.04731213673949) < 0.000001)
    }
  }

  // 1 .O.O.
  // 2 OOOO.
  // 3 .XX.X
  // 4 .X.X.
  // 5 .XOX.
  //   12345
  private def createSimple5x5GameState(): GameState = {
    var state = GameState(GoBoard(5), BlackPlayer)
    state = state.applyMove(Play(3, 3))
    state = state.applyMove(Play(2, 3)) // white
    state = state.applyMove(Play(3, 2))
    state = state.applyMove(Play(2, 2)) // white
    state = state.applyMove(Play(4, 2))
    state = state.applyMove(Play(2, 1)) // white
    state = state.applyMove(Play(4, 4))
    state = state.applyMove(Play(5, 3)) // white
    state = state.applyMove(Play(5, 2))
    state = state.applyMove(Play(2, 4)) // white
    state = state.applyMove(Play(3, 5))
    state = state.applyMove(Play(1, 4)) // white
    state = state.applyMove(Play(5, 4))
    state = state.applyMove(Play(1, 2)) // white
    //println(state.board)
    state
  }
} 

package org.deeplearning4j.scalphagozero.input

import org.deeplearning4j.scalphagozero.board.Move.Play
import org.scalatest.funspec.AnyFunSpec

class ValidatorTest extends AnyFunSpec {

  val validator = new Validator()

  describe("Input 4,C") {

    val expectedResult = Some(Play(2, 3))
    it("should have input = 4C") {
      assertResult(expectedResult) { validator.getValidMove("4,C", 5) }
      assertResult(expectedResult) { validator.getValidMove("4,c", 5) }
      assertResult(expectedResult) { validator.getValidMove("4;C", 5) }
      assertResult(expectedResult) { validator.getValidMove("4C", 5) }
      assertResult(expectedResult) { validator.getValidMove("4c", 5) }
    }
  }

  describe("Invalid input") {

    it("should give None for invalid input") {
      assertResult(None) { validator.getValidMove("XX", 5) }
      assertResult(None) { validator.getValidMove("X", 5) }
      assertResult(None) { validator.getValidMove("", 5) }
      assertResult(None) { validator.getValidMove(",,", 5) }
      assertResult(None) { validator.getValidMove("sdf;sd", 5) }
      assertResult(None) { validator.getValidMove("$a", 5) }
    }

  }
} 

package org.deeplearning4j.scalphagozero.gtp

import org.deeplearning4j.scalphagozero.board.GoBoardSerializer
import org.deeplearning4j.scalphagozero.strip
import org.lisoft.gonector.{ Move, Player }
import org.scalatest.funspec.AnyFunSpec
import scala.util.Random

class ScalphaGoEngineTest extends AnyFunSpec {

  val serializer = new GoBoardSerializer()
  val numLayers = 2

  describe("For Engine genmove black") {
    val engine = createGoEngine
    engine.resizeBoard(5)

    it("has valid next black move") {
      assert(engine.nextMove(Player.BLACK) == new Move(2, 2))
    }
  }

  describe("For Engine genmove white") {
    val engine = createGoEngine
    engine.resizeBoard(5)

    engine.addMove(new Move(2, 3), Player.BLACK)
    engine.addMove(new Move(3, 2), Player.WHITE)
    engine.addMove(new Move(3, 3), Player.BLACK)

    println(serializer.serialize(engine.getGameState.board))

    it("has valid next white move") {
      assert(engine.nextMove(Player.WHITE) == new Move(1, 1))
    }
  }

  describe("For Engine genmove black after many stones placed") {
    val engine = createGoEngine
    engine.resizeBoard(5)

    engine.addMove(new Move(2, 3), Player.BLACK)
    engine.addMove(new Move(3, 2), Player.WHITE)
    engine.addMove(new Move(3, 3), Player.BLACK)
    engine.addMove(new Move(4, 4), Player.WHITE)

    println(serializer.serialize(engine.getGameState.board))

    it("has valid next black move") {
      assert(engine.nextMove(Player.BLACK) == new Move(2, 2))
    }
  }

  describe("Play game with genmoves") {
    val engine = createGoEngine
    engine.resizeBoard(5)

    engine.nextMove(Player.BLACK)
    engine.nextMove(Player.WHITE)
    engine.nextMove(Player.BLACK)
    engine.nextMove(Player.WHITE)
    engine.nextMove(Player.BLACK)
    engine.nextMove(Player.WHITE)

    // println(serializer.serialize(engine.getGameState.board))

    it("has expected board state") {
      assert(
        engine.getGameState.board.toString ==
          strip("""--------
           | 5 .....
           | 4 .....
           | 3 .OXX.
           | 2 .XOO.
           | 1 .....
           |   ABCDE
           |--------""")
      )
    }
  }

  private def createGoEngine = ScalphaGoEngine(numLayers, new Random(1))
} 

package org.deeplearning4j.scalphagozero.board

import org.deeplearning4j.scalphagozero.board.Move.Play
import org.scalatest.funspec.AnyFunSpec

class GameStateTest extends AnyFunSpec {

  describe("Starting a new 19x19 game") {
    val start = GameState.newGame(19)
    it("should apply moves") {
      val nextState = start.applyMove(Move.Play(Point(16, 16)))

      assert(start == nextState.previousState.get)
      assert(nextState.board.getPlayer(Point(16, 16)).get == BlackPlayer)
      assert(nextState.nextPlayer == WhitePlayer)
    }
  }

  describe("Detect ko in a 5x5 game") {
    var game = GameState.newGame(5)

    it("Apply moves, until ko rule is take the first time") {
      game = game.applyMove(Play(3, 3))
      game = game.applyMove(Play(3, 4))
      game = game.applyMove(Play(4, 4))
      game = game.applyMove(Play(4, 5))
      game = game.applyMove(Play(2, 4))
      game = game.applyMove(Play(2, 5))
      val previous = game
      game = game.applyMove(Play(Point(3, 5))) // initial ko capture
      println("After initial ko: " + game.board)

      assert(previous == game.previousState.get)
      assert(game.board.getPlayer(Point(3, 5)).get == BlackPlayer)
      assert(game.board.getPlayer(Point(3, 4)).isEmpty)
    }

    it("Ko is not allowed to be immediately retaken") {
      println("After initial ko2: " + game.board)
      assert(game.doesMoveViolateKo(WhitePlayer, Play(3, 4)))
    }
  }

  describe("No winner at start of the game") {
    var game = GameState.newGame(5)
    it("should have no winner yet") {
      assert(game.gameResult().isEmpty)
    }

    game = game.applyMove(Play(3, 3))
    game = game.applyMove(Play(3, 4))
    game = game.applyMove(Play(4, 4))
    game = game.applyMove(Play(4, 5))
    it("should have no winner after a few moves played") {
      assert(game.gameResult().isEmpty)
    }
  }

  describe("Won after black player resigns") {
    var game = GameState.newGame(5)
    game = game.applyMove(Play(3, 3)) // black play
    game = game.applyMove(Play(2, 3)) // white play

    it("should be a white win by resignation") {
      game = game.applyMove(Move.Resign)
      val result = game.gameResult().get
      assert(result.winner == WhitePlayer)
      assert(result.toString == "White won by resignation")
    }
  }

  describe("Won after white player resigns") {
    var game = GameState.newGame(5)
    game = game.applyMove(Play(3, 3))
    it("should be a black win") {
      game = game.applyMove(Move.Resign)
      val result = game.gameResult().get
      assert(result.winner == BlackPlayer)
      assert(result.toString == "Black won by resignation")
    }
  }

  describe("Won only after both players pass") {
    var game = GameState.newGame(5)
    game = game.applyMove(Play(3, 3))
    game = game.applyMove(Move.Pass)
    it("should have no winner yet") {
      assert(game.gameResult().isEmpty)
    }

    it("should have winner after the second consecutive pass") {
      game = game.applyMove(Move.Pass)
      // black wins because they have one more stone on the board.
      val result = game.gameResult().get
      assert(result.winner == BlackPlayer)
      assert(result.toString == "Black +24.5")
    }
  }
} 

package org.deeplearning4j.scalphagozero.board

import org.scalatest.funspec.AnyFunSpec

class GoStringTest extends AnyFunSpec {

  describe("Create an empty string") {
    it("should create empty string") {
      val goString = GoString(BlackPlayer, Set(), Set())

      assertResult(0) { goString.numLiberties }
      assertResult("GoString(BlackPlayer,Set(),Set())") {
        goString.toString
      }
    }
  }

  describe("Create a simple string") {

    val stones = Set(Point(2, 2))
    val liberties = Set((1, 2), (3, 2), (2, 1), (2, 3)).map(p => new Point(p))

    it("should create simple string with one stone") {
      val goString = GoString(BlackPlayer, stones, liberties)

      assertResult(4) { goString.numLiberties }
      assertResult("GoString(BlackPlayer,Set(Point(2,2)),Set(Point(1,2), Point(3,2), Point(2,1), Point(2,3)))") {
        goString.toString
      }
    }
  }

  // OOO
  // O O
  // OO    assume surrounded by black
  describe("Create a string with one eye") {

    val stones = Set((2, 2), (2, 3), (2, 4), (3, 2), (3, 4), (4, 2), (4, 3)).map(new Point(_))
    val liberties = Set(Point(3, 3))

    it("should create simple string with one eye and one liberty") {
      val goString = GoString(BlackPlayer, stones, liberties)

      assertResult(1) { goString.numLiberties }
    }
  }

  describe("Add liberty to string") {

    val stones = Set(Point(2, 2))
    val liberties = Set((1, 2), (3, 2)).map(p => new Point(p))
    it("should have one more liberty") {
      val goString = GoString(BlackPlayer, stones, liberties)
      assert(goString.numLiberties === 2)
      assertResult(3) { goString.withLiberty(Point(2, 1)).numLiberties }
    }
  }

  describe("Remove liberty from string") {

    val stones = Set(Point(2, 2))
    val liberties = Set((1, 2), (3, 2), (2, 1), (2, 3)).map(p => new Point(p))

    it("should have one fewer liberties") {
      val goString = GoString(BlackPlayer, stones, liberties)
      assert(goString.numLiberties === 4)
      var gs = goString.withoutLiberty(Point(2, 1))
      assertResult(3) { gs.numLiberties }
      gs = gs.withoutLiberty(Point(2, 3))
      assertResult(2) { gs.numLiberties }
    }
  }

  describe("Merge strings") {

    it("should have 6 liberties when merged") {
      val stones1 = Set(Point(2, 2))
      val liberties1 = Set((1, 2), (2, 1), (3, 2), (2, 3)).map(p => new Point(p))
      val goString1 = GoString(BlackPlayer, stones1, liberties1)

      val stones2 = Set(Point(2, 3))
      val liberties2 = Set((2, 2), (2, 4), (1, 3), (3, 3)).map(p => new Point(p))
      val goString2 = GoString(BlackPlayer, stones2, liberties2)

      assertResult(4) { goString1.numLiberties }
      assertResult(4) { goString2.numLiberties }
      val mergedString = goString1.mergedWith(goString2)
      assertResult(6) { mergedString.numLiberties }
      assertResult(
        "GoString(BlackPlayer,Set(Point(2,2), Point(2,3)),Set(Point(3,2), Point(1,3), Point(2,4), Point(3,3), Point(1,2), Point(2,1)))"
      ) {
        mergedString.toString
      }
    }
  }

} 

package org.deeplearning4j.scalphagozero.board

import org.scalatest.funspec.AnyFunSpec

class GoBoardBoundsCheckerTest extends AnyFunSpec {

  describe("Verify piece played on the board") {
    val boundsChecker = GoBoardBoundsChecker.get(9)

    it("is within the board boundary") {
      assert(boundsChecker.inBounds(Point(2, 2)))
      assert(boundsChecker.inBounds(Point(1, 1)))
      assert(boundsChecker.inBounds(Point(9, 9)))
      assert(boundsChecker.inBounds(Point(1, 9)))
    }
  }

  describe("Verify piece played outside the board") {
    val boundsChecker = GoBoardBoundsChecker.get(9)

    it("is not within the board boundary") {
      assert(!boundsChecker.inBounds(Point(0, 2)))
      assert(!boundsChecker.inBounds(Point(1, 0)))
      assert(!boundsChecker.inBounds(Point(10, 9)))
      assert(!boundsChecker.inBounds(Point(8, 10)))
      assert(!boundsChecker.inBounds(Point(0, 0)))
      assert(!boundsChecker.inBounds(Point(-3, 10)))
      assert(!boundsChecker.inBounds(Point(102, 140)))
    }
  }

  describe("Verify piece played not on the edge") {
    val boundsChecker = GoBoardBoundsChecker.get(9)

    it("is not on the edge") {
      assert(!boundsChecker.isEdge(Point(2, 2)))
      assert(!boundsChecker.isEdge(Point(5, 5)))
      assert(!boundsChecker.isEdge(Point(8, 7)))
      assert(!boundsChecker.isEdge(Point(-3, 10)))
      assert(!boundsChecker.isEdge(Point(102, 140)))
    }
  }

  describe("Verify piece played on the edge") {
    val boundsChecker = GoBoardBoundsChecker.get(9)

    it("is on the edge") {
      assert(boundsChecker.isEdge(Point(1, 7)))
      assert(boundsChecker.isEdge(Point(7, 1)))
      assert(boundsChecker.isEdge(Point(9, 5)))
      assert(boundsChecker.isEdge(Point(4, 9)))
      assert(boundsChecker.isEdge(Point(9, 9)))
      assert(boundsChecker.isEdge(Point(1, 1)))
    }
  }

  describe("Verify piece played not in a corner") {
    val boundsChecker = GoBoardBoundsChecker.get(9)

    it("is not in a corner") {
      assert(!boundsChecker.isCorner(Point(2, 2)))
      assert(!boundsChecker.isCorner(Point(5, 5)))
      assert(!boundsChecker.isCorner(Point(8, 7)))
      assert(!boundsChecker.isCorner(Point(-3, 10)))
      assert(!boundsChecker.isCorner(Point(102, 140)))
    }
  }

  describe("Verify piece played in a corner") {
    val boundsChecker = GoBoardBoundsChecker.get(9)

    it("is in a corner") {
      assert(boundsChecker.isCorner(Point(1, 1)))
      assert(boundsChecker.isCorner(Point(9, 9)))
      assert(boundsChecker.isCorner(Point(9, 1)))
      assert(boundsChecker.isCorner(Point(1, 9)))
    }
  }
} 

package org.deeplearning4j.scalphagozero.board

import org.deeplearning4j.scalphagozero.strip
import org.scalatest.funspec.AnyFunSpec

class GoBoardSerializerTest extends AnyFunSpec {

  describe("Serialize a board") {
    var board = GoBoard(9)
    it("should have this format") {
      board = board.placeStone(BlackPlayer, Point(2, 2))
      board = board.placeStone(WhitePlayer, Point(3, 3))
      board = board.placeStone(BlackPlayer, Point(2, 3))
      board = board.placeStone(WhitePlayer, Point(5, 4))

      assertResult(strip("""------------
                     | 9 .........
                     | 8 .XX......
                     | 7 ..O......
                     | 6 .........
                     | 5 ...O.....
                     | 4 .........
                     | 3 .........
                     | 2 .........
                     | 1 .........
                     |   ABCDEFGHI
                     |------------""")) { board.toString }
    }
  }

  describe("Serialize another board") {
    var board = GoBoard(9)
    it("should have this format") {
      board = board.placeStone(BlackPlayer, Point(1, 1))
      board = board.placeStone(WhitePlayer, Point(3, 3))
      board = board.placeStone(BlackPlayer, Point(2, 3))
      board = board.placeStone(WhitePlayer, Point(5, 4))

      assertResult(strip("""------------
                           | 9 X........
                           | 8 ..X......
                           | 7 ..O......
                           | 6 .........
                           | 5 ...O.....
                           | 4 .........
                           | 3 .........
                           | 2 .........
                           | 1 .........
                           |   ABCDEFGHI
                           |------------""")) { board.toString }
    }

  }
} 

package dev.profunktor.fs2rabbit.laws

import java.time.Instant

import cats._
import cats.implicits._
import cats.kernel.laws.discipline._
import dev.profunktor.fs2rabbit.model.AmqpFieldValue._
import dev.profunktor.fs2rabbit.model._
import dev.profunktor.fs2rabbit.testkit._
import org.scalacheck.Arbitrary._
import org.scalatest.funspec.AnyFunSpec
import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
import org.typelevel.discipline.scalatest.FunSpecDiscipline

class OrderInstancesSpec
    extends AnyFunSpec
    with FunSpecDiscipline
    with ScalaCheckPropertyChecks
    with InstantArbitraries {
  implicit val orderInstant: Order[Instant] = Order.by(_.getEpochSecond)

  checkAll("ExchangeName.OrderLaws", OrderTests[ExchangeName].order)
  checkAll("QueueName.OrderLaws", OrderTests[QueueName].order)
  checkAll("RoutingKey.OrderLaws", OrderTests[RoutingKey].order)
  checkAll("DeliveryTag.OrderLaws", OrderTests[DeliveryTag].order)
  checkAll("ConsumerTag.OrderLaws", OrderTests[ConsumerTag].order)
  checkAll("Instant.OrderLaws", OrderTests[Instant](instantOrderWithSecondPrecision).order)
  checkAll("DeliveryMode.OrderLaws", OrderTests[DeliveryMode].order)
  checkAll("ShortString.OrderLaws", OrderTests[ShortString].order)
  checkAll("TimestampVal.OrderLaws", OrderTests[TimestampVal].order)
  checkAll("DecimalVal.OrderLaws", OrderTests[DecimalVal].order)
  checkAll("ByteVal.OrderLaws", OrderTests[ByteVal].order)
  checkAll("DoubleVal.OrderLaws", OrderTests[DoubleVal].order)
  checkAll("FloatVal.OrderLaws", OrderTests[FloatVal].order)
  checkAll("ShortVal.OrderLaws", OrderTests[ShortVal].order)
  checkAll("BooleanVal.OrderLaws", OrderTests[BooleanVal].order)
  checkAll("IntVal.OrderLaws", OrderTests[IntVal].order)
  checkAll("LongVal.OrderLaws", OrderTests[LongVal].order)
  checkAll("StringVal.OrderLaws", OrderTests[StringVal].order)
  checkAll("NullVal.OrderLaws", OrderTests[NullVal.type].order)
} 

package functor

import educational.collections.{Branch, Leaf}
import educational.collections.TreeInstances.treeFunctor.map
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class TreeFunctorSpec
  extends AnyFunSpec
    with Matchers {

  describe("map over Tree") {
    it("execute function for value stored inside Left") {
      map(Leaf("foo"))(stringLength) mustBe Leaf(3)
      map(Leaf("foo"))(toUpperCase) mustBe Leaf("FOO")
    }

    it("called with Branch execute function for every subtree") {
      map(Branch(Leaf("foo"), Leaf("bar")))(stringLength) mustBe Branch(Leaf(3), Leaf(3))

      map(Branch(Leaf("foo"), Branch(Leaf("quux"), Leaf("foobar"))))(toUpperCase) mustBe
        Branch(Leaf("FOO"), Branch(Leaf("QUUX"), Leaf("FOOBAR")))
    }

    it("called with complicated Tree execute function for every subtree") {
      val tree = Branch(
        Leaf("a"),
        Branch(
          Leaf("b"),
          Leaf("c")))

      val expected = Branch(
        Leaf("A"),
        Branch(
          Leaf("B"),
          Leaf("C")))

      map(tree)(toUpperCase) mustBe expected
    }
  }

  private def stringLength(s: String) = s.length
  private def toUpperCase(s: String) = s.toUpperCase
} 

package functor

import cats.Id
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class FunctorExamplesSpec
  extends AnyFunSpec
  with Matchers {

  private def isOdd(i: Int): Boolean = i % 2 == 1

  describe("Functor") {
    describe("map") {
      it("apply given function for each element of List") {
        import cats.Functor
        import cats.implicits._

        Functor[List].map(List(2, 3, 4))(isOdd) mustBe List(false, true, false)
        Functor[Option].map(Option(42))(isOdd) mustBe Option(false)

        val myId: Id[Int] = 42
        Functor[Id].map(myId)(isOdd) mustBe false
      }
    }

    describe("derived methods") {
      it("can be called directly when Functor syntax is imported") {
        import cats.syntax.functor._
        import cats.implicits.catsStdInstancesForList

        List(2, 3, 4).void mustBe List((), (), ())
        List(2, 3, 4).as("foo") mustBe List("foo", "foo", "foo")
        List(2, 3, 4).fproduct(isOdd) mustBe List((2, false), (3, true), (4, false))
      }

      it("for Vector") {
        import cats.syntax.functor._
        import cats.implicits.catsStdInstancesForVector

        Vector(2, 3, 4).void mustBe Vector((), (), ())
        Vector(2, 3, 4).as("foo") mustBe Vector("foo", "foo", "foo")
        Vector(2, 3, 4).fproduct(isOdd) mustBe Vector((2, false), (3, true), (4, false))
      }

      it("for Option") {
        import cats.syntax.functor._
        import cats.implicits.catsStdInstancesForOption

        Option(42).void mustBe Option(())
        Option(42).as("foo") mustBe Option("foo")
        Option(42).fproduct(isOdd) mustBe Option((42, false))
      }
    }

    describe("compose") {
      it("can chain multiple map") {
        import cats.Functor
        import cats.implicits.catsStdInstancesForList
        import cats.implicits.catsStdInstancesForOption

        val functor = Functor[List] compose Functor[Option]
        functor.map(List(Some(42), Some(15), None))(isOdd) mustBe List(Some(false), Some(true), None)
      }

      it("can chain multiple map 2") {
        import cats.Functor
        import cats.implicits.catsStdInstancesForList
        import cats.implicits.catsStdInstancesForOption

        val listOption = Functor[List] compose Functor[Option]
        import listOption.map
        map(List(Some(42), Some(15), None))(isOdd) mustBe List(Some(false), Some(true), None)
      }
    }
  }
} 

package educational.category_theory.two.profunctor

import educational.category_theory.two.profunctor.strong.Strong
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

case class DoubleFun[X,Y](fun: (X,X) => (Y,Y))

trait DoubleFunPro extends Profunctor[DoubleFun] {
  override def dimap[S, T, A, B](pab: DoubleFun[A, B])(f: S => A, g: B => T): DoubleFun[S, T] =
    DoubleFun[S, T] { (c1, c2) => pab.fun(f(c1), f(c2)) match {case (z1, z2) => (g(z1), g(z2)) } }
}

class StrongSpec
  extends AnyFunSpec
  with Matchers {

  it("Functions from A to B are Strong Profunctors") {
    trait Function1Profunctor extends Profunctor[Function1] {
      override def dimap[S,T,A,B](pab: A => B)(ab: S => A, cd: B => T): S => T = ab andThen pab andThen cd
    }

    val functionPro: Profunctor[Function1] = new Function1Profunctor {}

    val functionStrong: Strong[Function1] = new Strong[Function1] with Function1Profunctor {
      def first[X, Y, Z](pab: X => Y): Function1[(X, Z), (Y, Z)] = (xz: (X, Z)) => (pab(xz._1), xz._2)
    }

    def len: String => Int = _.length

    functionStrong.first(len)(("foo", 42)) mustBe (3,42)
  }

  it("You can define multiple Strong Profunctors for P[_,_]") {
    val doubleFunProStrength: Strong[DoubleFun] with DoubleFunPro = new Strong[DoubleFun] with DoubleFunPro {
      override def first[A, B, C](fa: DoubleFun[A, B]): DoubleFun[(A, C), (B, C)] = DoubleFun {
        (a1: (A, C), a2: (A, C)) =>
          val bb = fa.fun(a1._1, a2._1)
          ((bb._1, a1._2), (bb._2, a2._2))
      }
    }

    val doubleFunProStrength2: Strong[DoubleFun] with DoubleFunPro = new Strong[DoubleFun] with DoubleFunPro {
      override def first[A, B, C](fa: DoubleFun[A, B]): DoubleFun[(A, C), (B, C)] = DoubleFun {
        (a1: (A, C), a2: (A, C)) =>
          val bb = fa.fun(a1._1, a2._1)
          ((bb._1, a1._2), (bb._1, a2._2))
      }
    }

    def bothLength(a: String, b: String): (Int, Int) = (a.length, b.length)

    doubleFunProStrength.first(DoubleFun(bothLength)) must not be doubleFunProStrength2.first(DoubleFun(bothLength))
  }
} 

package educational.category_theory.two.profunctor

import scalaz._
import Scalaz._
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class ProfunctorSpec
  extends AnyFunSpec
    with Matchers {

  describe("Profunctor") {
    it("Profunctor for Function1 is Functor + Contravariant") {
      case class Person(name: String, age: Int)

      val len: String => Int = _.length // String => Int
      val getPersonName: Person => String = _.name // Person => String
      val above5: Int => Boolean = _ > 5 // Int => Boolean

      val personNameAbove5 = Profunctor[Function1].dimap(len)(getPersonName)(above5) // AA => BB
      personNameAbove5(Person("Foo", 100)) mustBe false
    }
  }
} 

package monoid

import cats.Monoid
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class AlternativeMonoidInstancesSpec
  extends AnyFunSpec
  with Matchers {

  
  implicit def createMonoidTuple[L, R](left: Monoid[L], right: Monoid[R]): Monoid[(L, R)] = new Monoid[(L, R)] {
    def empty: (L, R) = (left.empty, right.empty)
    def combine(x: (L, R), y: (L, R)): (L, R) =
      ( left.combine(x._1, y._1), right.combine(x._2, y._2) )
  }

  describe("custom Monoid for multiply Int") {
    it("can use |+| syntax and combineAll method") {
      import cats.Monoid
      import cats.syntax.semigroup._
      import monoid.AlternativeMonoidInstances.multiplyIntMonoid

      Monoid[Int].combineAll(Nil) mustBe 1
      Monoid[Int].combineAll(List(1, 2, 3, 4)) mustBe 24

      2 |+| 3 mustBe 6
    }
  }

  describe("custom Monoid instance for first non empty Option") {
    it("get first non empty option") {
      import cats.Monoid
      import cats.syntax.semigroup._
      import cats.syntax.option._
      import monoid.AlternativeMonoidInstances.optionFirstNonEmpty

      case class Foo(v: Int)

      Monoid[Option[Foo]].combineAll(List(None, Foo(2).some, Foo(3).some)) mustBe Some(Foo(2))
      Foo(2).some |+| Foo(3).some mustBe Foo(2).some
    }
  }
}

object AlternativeMonoidInstances {
  def createMonoid[A](mempty: A, mapply: (A, A) => A): Monoid[A] = new Monoid[A] {
    def empty: A = mempty
    def combine(x: A, y: A) = mapply(x, y)
  }

  implicit val multiplyIntMonoid: Monoid[Int] = createMonoid(1, _ * _)

  implicit def optionFirstNonEmpty[A]: Monoid[Option[A]] = createMonoid(None, _ orElse _)
} 

package monoid

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class MonoidExamplesSpec
  extends AnyFunSpec
  with Matchers {

  describe("combineAll") {
    it("invoke operation for all elements") {
      import cats.implicits._

      List(1, 2, 3).combineAll mustBe 6
      List[Int]().combineAll mustBe 0
    }
  }
} 

package kan

import cats.{Functor, Monad}

import scala.language.higherKinds
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class RanCustomImpl
  extends AnyFunSpec
    with Matchers {

  describe("Right Kan extension implemented from Haskell definition") {
    
      def ranMonad[G[_]]: Monad[Ran3[G, G, ?]] =
        new Monad[Ran3[G, G, ?]] {
          override def map[A, B](fa: Ran3[G, G, A])(f: A => B): Ran3[G, G, B] = fa.map(f)

          override def flatMap[A, B](fa: Ran3[G, G, A])(f: A => Ran3[G, G, B]): Ran3[G, G, B] = flatten(map(fa)(f))

          override def tailRecM[A, B](a: A)(f: A => Ran3[G, G, Either[A, B]]): Ran3[G, G, B] = ???

          override def pure[A](x: A): Ran3[G, G, A] =
            new Ran3[G, G, A] {
              def runRan[C](f2: A => G[C]): G[C] = f2(x)
            }
        }
    }
  }
} 

package traverse

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class TraverseExamplesSpec
  extends AnyFunSpec
  with Matchers {

  describe("Traversing List ") {
    it("traverse") {
      import cats.implicits._

      val xs1: Vector[Int] = Vector(1, 2, 3)
      xs1.traverse(a => Option(a)) mustBe Some(Vector(1, 2, 3))
    }

    it("sequence") {
      import cats.implicits._
      val xs1: List[Option[Int]] = List(Some(1), Some(2), None)
      xs1.sequence mustBe None

      val xs2: List[Option[Int]] = List(Some(1), Some(2), Some(42))
      xs2.sequence mustBe Some(List(1,2,42))
    }
  }
} 

package bifunctor

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.must.Matchers

class BifunctorExamplesSpec
  extends AnyFunSpec
  with Matchers {

  describe("Bifunctor") {
    describe("bimap") {
      it("apply given functions for first and second element of tuple") {
        import cats.implicits._
        (List("foo", "bar"), 42).bimap(_.headOption, _ - 1) mustBe(Some("foo"), 41)
      }
    }

    describe("leftmap") {
      it("apply given functions for first and second element of tuple") {
        import cats.implicits._
        (List("foo", "bar"), 42).leftMap(_.headOption) mustBe (Some("foo"), 42)
      }
    }
  }
} 

package jp.co.dwango.s99

import P33.RichInt
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P33Spec extends AnyFunSpec with Diagrams {
  describe("P33") {
    it("for coprime numbers, x.isCoprime(y) returns true") {
      assert(3.isCoPrime(8))
      assert(12.isCoPrime(25))
      assert(64.isCoPrime(35))
      assert(98.isCoPrime(27))
    }
    it("for non-coprime numbers, x.isCoprime(y) returns false") {
      assert(!4.isCoPrime(16))
      assert(!13.isCoPrime(39))
      assert(!48.isCoPrime(4))
      assert(!56.isCoPrime(42))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P19Spec extends AnyFunSpec with Diagrams {
  describe("P19") {
    it("for empty list, rotate(n, s) throws Exception") {
      intercept[Throwable] {
        P19.rotate(-2, List.empty[Int])
      }
      intercept[Throwable] {
        P19.rotate(-1, List.empty[Int])
      }
      intercept[Throwable] {
        P19.rotate(0, List.empty[Int])
      }
      intercept[Throwable] {
        P19.rotate(1, List.empty[Int])
      }
      intercept[Throwable] {
        P19.rotate(2, List.empty[Int])
      }
    }
    it("for list one element, rotate(n, s) returns s itself") {
      assert(P19.rotate(-2, List(1)) == List(1))
      assert(P19.rotate(-1, List(1)) == List(1))
      assert(P19.rotate(-0, List(1)) == List(1))
      assert(P19.rotate(-1, List(1)) == List(1))
      assert(P19.rotate(-2, List(1)) == List(1))
    }
    it("otherwise") {
      assert(P19.rotate(-3, List(1, 2)) == List(2, 1))
      assert(P19.rotate(-2, List(1, 2)) == List(1, 2))
      assert(P19.rotate(-1, List(1, 2)) == List(2, 1))
      assert(P19.rotate(0, List(1, 2)) == List(1, 2))
      assert(P19.rotate(1, List(1, 2)) == List(2, 1))
      assert(P19.rotate(2, List(1, 2)) == List(1, 2))
      assert(P19.rotate(3, List(1, 2)) == List(2, 1))
    }
  }
} 

package jp.co.dwango.s99

import P31._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P31Spec extends AnyFunSpec with Diagrams {
  describe("P31") {
    it("for prime number") {
      assert(2.isPrime)
      assert(5.isPrime)
      assert(19.isPrime)
      assert(937.isPrime)
    }
    it("for not prime number(even)") {
      assert(!4.isPrime)
      assert(!28.isPrime)
      assert(!1024.isPrime)
      assert(!4800.isPrime)
    }
    it("for not prime number(odd)") {
      assert(!9.isPrime)
      assert(!49.isPrime)
      assert(!(13 * 17).isPrime)
      assert(!(23 * 27).isPrime)
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P10Spec extends AnyFunSpec with Diagrams {
  describe("P10") {
    it("for empty list, encode(s) is s") {
      assert(P10.encode(List.empty[Int]) == List.empty[(Int, Int)])
    }
    it("for list has one element, encode(s) is List((1, s))") {
      assert(P10.encode(List(2)) == List((1, 2)))
    }
    it("otherwise") {
      assert(P10.encode(List(1, 1)) == List((2, 1)))
      assert(P10.encode(List(1, 1, 2)) == List((2, 1), (1, 2)))
      assert(P10.encode(List(1, 1, 2, 3)) == List((2, 1), (1, 2), (1, 3)))
      assert(P10.encode(List(1, 1, 2, 2, 3)) == List((2, 1), (2, 2), (1, 3)))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P12Spec extends AnyFunSpec with Diagrams {
  describe("P12") {
    it("for empty list, decode(s) is s") {
      assert(P12.decode(List.empty[(Int, Int)]) == List.empty[(Int, Int)])
    }
    it("for list has one element") {
      assert(P12.decode(List((1, 1))) == List(1))
      assert(P12.decode(List((2, 1))) == List(1, 1))
      assert(P12.decode(List((3, 1))) == List(1, 1, 1))
    }
    it("otherwise") {
      assert(P12.decode(List((1, 1), (1, 2))) == List(1, 2))
      assert(P12.decode(List((2, 1), (1, 2), (1, 3))) == List(1, 1, 2, 3))
      assert(P12.decode(List((2, 1), (2, 2), (1, 3))) == List(1, 1, 2, 2, 3))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P08Spec extends AnyFunSpec with Diagrams {
  describe("P08") {
    it("for empty list, compress(s) is s") {
      assert(P08.compress(List.empty[Int]) == List.empty[Int])
    }
    it("for list has one element, compress(s) is s") {
      assert(P08.compress(List(1)) == List(1))
    }
    it("otherwise") {
      assert(P08.compress(List(1, 1)) == List(1))
      assert(P08.compress(List(1, 2, 1)) == List(1, 2, 1))
      assert(P08.compress(List(1, 2, 2)) == List(1, 2))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P09Spec extends AnyFunSpec with Diagrams {
  describe("P09") {
    it("for empty list, pack(s) is s") {
      assert(P09.pack(List.empty[Int]) == List.empty[List[Int]])
    }
    it("for list has one element, pack(s) is List(s)") {
      assert(P09.pack(List(1)) == List(List(1)))
    }
    it("otherwise") {
      assert(P09.pack(List(1, 1)) == List(List(1, 1)))
      assert(P09.pack(List(1, 1, 2)) == List(List(1, 1), List(2)))
      assert(P09.pack(List(1, 1, 2, 3)) == List(List(1, 1), List(2), List(3)))
      assert(
        P09.pack(List(1, 1, 2, 2, 3)) == List(List(1, 1), List(2, 2), List(3))
      )
    }
  }
} 

package jp.co.dwango.s99

import binary_trees._
import P61._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P61Spec extends AnyFunSpec with Diagrams {
  describe("P61") {
    it("count leaves correctly") {
      assert(Node("a", Node("a"), End).leafCount == 1)
      assert(
        Node(
          'a',
          Node('b', Node('d'), Node('e')),
          Node('c', End, Node('f', Node('g'), End))
        ).leafCount == 3
      )
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P03Spec extends AnyFunSpec with Diagrams {
  describe("P03") {
    it("any index with empty list should fail") {
      val emptyList = List.empty[Int]
      intercept[Throwable] {
        P03.nth(0, emptyList)
      }
      intercept[Throwable] {
        P03.nth(1, emptyList)
      }
      intercept[Throwable] {
        P03.nth(-1, emptyList)
      }
    }
    it("0 index with a list") {
      intercept[Throwable] {
        P03.nth(0, List.empty[Int])
      }
      assert(P03.nth(0, List(2)) == 2)
      assert(P03.nth(0, List(2, 3)) == 2)
    }
    it("negative index with a list should fail") {
      intercept[Throwable] {
        P03.nth(-1, List.empty[Int])
      }
      intercept[Throwable] {
        P03.nth(-1, List(2))
      }
      intercept[Throwable] {
        P03.nth(-1, List(2, 3))
      }
    }
    it("otherwise") {
      intercept[Throwable] {
        P03.nth(1, List(2))
      }
      assert(P03.nth(1, List(2, 3)) == 3)
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P06Spec extends AnyFunSpec with Diagrams {
  describe("P06") {
    it("for empty list, isPalindrome(s) should be true") {
      assert(P06.isPalindrome(List.empty[Int]))
    }
    it("for list has one element, isPalindrome(s) should be true") {
      assert(P06.isPalindrome(List(1)))
    }
    it("otherwise") {
      assert(P06.isPalindrome(List(1, 2, 1)))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P02Spec extends AnyFunSpec with Diagrams {
  describe("P02") {
    it("for empty list(should fail)") {
      intercept[Throwable] {
        P02.penultimate(List[Int]())
      }
    }
    it("for list has one element(also should fail)") {
      intercept[Throwable] {
        P02.penultimate(List(1))
      }
    }
    it("for list has more than one element") {
      assert(P02.penultimate(List(1, 2)) == 1)
    }
    it("for list has more than two element") {
      assert(P02.penultimate(List(1, 2, 3)) == 2)
    }
  }
} 

package jp.co.dwango.s99

import P67._
import binary_trees._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P67Spec extends AnyFunSpec with Diagrams {
  describe("P67") {
    it("represents another string representation") {
      assert(
        Node(
          'a',
          Node('b', Node('d'), Node('e')),
          Node('c', End, Node('f', Node('g'), End))
        ).toString2 == "a(b(d,e),c(,f(g,)))"
      )
    }
    it("build Node from string") {
      assert(
        Tree.fromString("a(b(d,e),c(,f(g,)))") == Node(
          'a',
          Node('b', Node('d'), Node('e')),
          Node('c', End, Node('f', Node('g'), End))
        )
      )
    }
  }
} 

package jp.co.dwango.s99

import P49.gray
import P49.gray2
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P49Spec extends AnyFunSpec with Diagrams {
  describe("P49") {
    it("gray(1)") {
      assert(gray(1) == List("0", "1"))
    }
    it("gray(2)") {
      assert(gray(2) == List("00", "01", "11", "10"))
    }
    it("gray(3)") {
      assert(
        gray(3) == List("000", "001", "011", "010", "110", "111", "101", "100")
      )
    }
    it("gray2(1)") {
      assert(gray2(1) == List("0", "1"))
    }
    it("gray2(2)") {
      assert(gray2(2) == List("00", "01", "11", "10"))
    }
    it("gray2(3)") {
      assert(
        gray2(3) == List("000", "001", "011", "010", "110", "111", "101", "100")
      )
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P13Spec extends AnyFunSpec with Diagrams {
  describe("P13") {
    it("for empty list, encodeDirect(s) is s") {
      assert(P13.encodeDirect(List.empty[Int]) == List.empty[(Int, Int)])
    }
    it("for list has one element, encodeDirect(s) is List((1, s))") {
      assert(P13.encodeDirect(List(2)) == List((1, 2)))
    }
    it("otherwise") {
      assert(P13.encodeDirect(List(1, 1)) == List((2, 1)))
      assert(P13.encodeDirect(List(1, 1, 2)) == List((2, 1), (1, 2)))
      assert(P13.encodeDirect(List(1, 1, 2, 3)) == List((2, 1), (1, 2), (1, 3)))
      assert(
        P13.encodeDirect(List(1, 1, 2, 2, 3)) == List((2, 1), (2, 2), (1, 3))
      )
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P05Spec extends AnyFunSpec with Diagrams {
  describe("P05") {
    it("for empty list, reverse(s) should be itself") {
      assert(P05.reverse(List.empty[Int]) == List.empty[Int])
    }
    it("for list has one element, reverse(s) should be itself") {
      assert(P05.reverse(List(1)) == List(1))
    }
    it("otherwise") {
      assert(P05.reverse(List(1, 2)) == List(2, 1))
    }
  }
} 

package jp.co.dwango.s99

import P90._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P90Spec extends AnyFunSpec with Diagrams {
  describe("P90") {
    it("solve n queens problem") {
      assert(getPatterns(4)() == List(List(1, 3, 0, 2), List(2, 0, 3, 1)))
      assert(getPatterns(5)().size == 10)
      assert(getPatterns(6)().size == 4)
      assert(getPatterns(7)().size == 40)
      assert(getPatterns(8)().size == 92)
      assert(solve.size == 92)
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P14Spec extends AnyFunSpec with Diagrams {
  describe("P14") {
    it("for empty list, duplicate(s) is s") {
      assert(P14.duplicate(List.empty[Int]) == List.empty[Int])
    }
    it("for list has one element") {
      assert(P14.duplicate(List(1)) == List(1, 1))
      assert(P14.duplicate(List(2)) == List(2, 2))
      assert(P14.duplicate(List(3)) == List(3, 3))
      assert(P14.duplicate(List(4)) == List(4, 4))
    }
    it("otherwise") {
      assert(P14.duplicate(List(1, 2, 3)) == List(1, 1, 2, 2, 3, 3))
      assert(P14.duplicate(List(1, 1, 2, 3)) == List(1, 1, 1, 1, 2, 2, 3, 3))
      assert(P14.duplicate(List(1, 2, 3, 3)) == List(1, 1, 2, 2, 3, 3, 3, 3))
      assert(
        P14.duplicate(List(1, 1, 2, 3, 3)) == List(1, 1, 1, 1, 2, 2, 3, 3, 3, 3)
      )
      assert(P14.duplicate(List(1, 2, 2, 3)) == List(1, 1, 2, 2, 2, 2, 3, 3))
    }
  }
} 

package scalapb_circe

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers
import scalapb_circe.ProtoMacrosCirce._
import com.google.protobuf.struct._
import jsontest.test.MyTest

import scala.util.Success

class ProtoMacrosCirceTest extends AnyFunSpec with Matchers {
  describe("ProtoMacrosCirce") {
    it("struct") {
      assert(struct"{}" == Struct.defaultInstance)

      assert(
        struct"""{ "a" : [1, false, null, "x"] }""" == Struct(
          Map(
            "a" -> Value(
              Value.Kind.ListValue(
                ListValue(
                  List(
                    Value(Value.Kind.NumberValue(1.0)),
                    Value(Value.Kind.BoolValue(false)),
                    Value(Value.Kind.NullValue(NullValue.NULL_VALUE)),
                    Value(Value.Kind.StringValue("x"))
                  )
                )
              )
            )
          )
        )
      )

      """ struct" { invalid json " """ shouldNot compile
    }

    it("value") {
      assert(value" 42 " == Value(Value.Kind.NumberValue(42)))
      assert(value" false " == Value(Value.Kind.BoolValue(false)))
      assert(value""" "x" """ == Value(Value.Kind.StringValue("x")))
      assert(value""" [] """ == Value(Value.Kind.ListValue(ListValue())))

      """ value" { invalid json " """ shouldNot compile
    }

    it("fromJson") {
      assert(MyTest.fromJsonConstant("{}") === MyTest())
      assert(
        MyTest.fromJsonConstant(
          """{
            "hello" : "foo",
            "foobar" : 42
          }"""
        ) === MyTest().update(
          _.hello := "foo",
          _.foobar := 42
        )
      )
      """ jsontest.test.MyTest.fromJsonConstant("{") """ shouldNot compile

      assert(MyTest.fromJsonTry("{").isFailure)
      assert(MyTest.fromJsonTry("""{"hello":"foo"}""") === Success(MyTest(hello = Some("foo"))))

      assert(MyTest.fromJsonOpt("{").isEmpty)
      assert(MyTest.fromJsonOpt("""{"hello":"foo"}""") === Some(MyTest(hello = Some("foo"))))

      assert(MyTest.fromJsonEither("{").isLeft)
      assert(MyTest.fromJsonEither("""{"hello":"foo"}""") === Right(MyTest(hello = Some("foo"))))
    }
  }
} 

package com.stephenn.scalatest.jsonassert

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class JsonMatchersSpec extends AnyFunSpec with Matchers {
  describe("JsonMatchers") {
    it("should pass when json is the same") {
      Seq("{}" -> "{}", "[]" -> "[]", "0" -> "0").foreach {
        case (left, right) =>
          val matchResult = JsonMatchers.matchJson(right).apply(left)
          matchResult.matches shouldBe true
      }
    }

    it("should pass when json is equivalent") {
      val matchResult = JsonMatchers.matchJson("{  }").apply("  {}  ")
      matchResult.matches shouldBe true

      Seq("{}" -> " { }",
          " [ ] " -> "[]",
          "0" -> "0",
          """{"a":0, "b":1}""" -> """{"b":1,"a":0}""").foreach {
        case (left, right) =>
          val matchResult = JsonMatchers.matchJson(right).apply(left)
          matchResult.matches shouldBe true
      }
    }

    it("should fail when left has extra fields") {
      val matchResult = JsonMatchers.matchJson("""{"l":1}""").apply("{}")
      matchResult.matches shouldBe false
      matchResult.failureMessage shouldBe
        """
          |Json did not match "{}" did not match "{"l":1}"
          |
          |Json Diff:
          |"
          |Expected: l
          |     but none found
          |"
        """.stripMargin.trim
    }

    it("should fail when right has extra fields") {
      val matchResult = JsonMatchers.matchJson("{}").apply("""{"r":0}""")
      matchResult.matches shouldBe false
      matchResult.failureMessage shouldBe
        """
          |Json did not match "{"r":0}" did not match "{}"
          |
          |Json Diff:
          |"
          |Unexpected: r
          |"
        """.stripMargin.trim
    }

    it("should fail on invalid json") {
      val matchResult =
        JsonMatchers.matchJson("{}").apply("""{"a": [1  "two"]}""")
      matchResult.matches shouldBe false
      matchResult.failureMessage shouldBe """Could not parse json "{"a": [1  "two"]}" did not equal "{}""""
    }
  }
} 

package com.stephenn.scalatest.json4s

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class JsonMatchersSpec extends AnyFunSpec with Matchers {

  describe("JsonMatchers") {
    it("should pass when json is the same") {
      Seq("{}" -> "{}", "[]" -> "[]").foreach {
        case (left, right) =>
          val matchResult = JsonMatchers.matchJson(right).apply(left)
          matchResult.matches shouldBe true
      }
    }

    it("should pass when json is equivalent") {
      val matchResult = JsonMatchers.matchJson("{  }").apply("  {}  ")
      matchResult.matches shouldBe true

      Seq("{}" -> " { }",
          " [ ] " -> "[]",
          """{"a":0, "b":1}""" -> """{"b":1,"a":0}""").foreach {
        case (left, right) =>
          val matchResult = JsonMatchers.matchJson(right).apply(left)
          matchResult.matches shouldBe true
      }
    }

    it("should fail when left has extra fields") {
      val matchResult = JsonMatchers.matchJson("""{"l":1}""").apply("{}")
      matchResult.matches shouldBe false
      matchResult.failureMessage shouldBe "Json did not match \"{}\" did not match \"{\"l\":1}\"\n\nJson Diff:\n\"Added:\n{\"l\":1}\""
    }

    it("should fail when right has extra fields") {
      val matchResult = JsonMatchers.matchJson("{}").apply("""{"r":0}""")
      matchResult.matches shouldBe false
      matchResult.failureMessage shouldBe "Json did not match \"{\"r\":0}\" did not match \"{}\"\n\nJson Diff:\n\"Removed:\n{\"r\":0}\""
    }

    it("should fail on invalid json") {
      val matchResult =
        JsonMatchers.matchJson("{}").apply("""{"a": nope]}""")
      matchResult.matches shouldBe false
      matchResult.failureMessage shouldBe "Could not parse json \"{\"a\": nope]}\" did not equal \"{}\""
    }

    it("should match a json object to a json string") {
      import org.json4s.native.JsonMethods._
      val matchResult = JsonMatchers
        .matchJsonString("""{"b":1,"a":0}""")
        .apply(parse("""{"a":0, "b":1}"""))
      matchResult.matches shouldBe true
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P15Spec extends AnyFunSpec with Diagrams {
  describe("P15") {
    it("for empty list, duplicateN(i, s) is always s") {
      assert(P15.duplicateN(0, List.empty[Int]) == List.empty[Int])
      assert(P15.duplicateN(1, List.empty[Int]) == List.empty[Int])
      assert(P15.duplicateN(2, List.empty[Int]) == List.empty[Int])
      assert(P15.duplicateN(3, List.empty[Int]) == List.empty[Int])
    }
    it("for list has one element") {
      assert(P15.duplicateN(0, List(1)) == List.empty[Int])
      assert(P15.duplicateN(1, List(1)) == List(1))
      assert(P15.duplicateN(2, List(1)) == List(1, 1))
      assert(P15.duplicateN(3, List(1)) == List(1, 1, 1))
    }
    it("otherwise") {
      assert(P15.duplicateN(1, List(1, 2, 3)) == List(1, 2, 3))
      assert(P15.duplicateN(2, List(1, 2, 3)) == List(1, 1, 2, 2, 3, 3))
      assert(P15.duplicateN(1, List(1, 1, 2, 3)) == List(1, 1, 2, 3))
      assert(
        P15.duplicateN(2, List(1, 2, 3, 3)) == List(1, 1, 2, 2, 3, 3, 3, 3)
      )
      assert(
        P15.duplicateN(2, List(1, 1, 2, 3, 3)) == List(1, 1, 1, 1, 2, 2, 3, 3,
          3, 3)
      )
      assert(
        P15.duplicateN(2, List(1, 2, 2, 3)) == List(1, 1, 2, 2, 2, 2, 3, 3)
      )
    }
  }
} 

package org.apache.spark.ml.knn

import org.apache.spark.ml.knn.KNN.{RowWithVector, VectorWithNorm}
import org.apache.spark.ml.linalg.Vectors
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class MetricTreeSpec extends AnyFunSpec with Matchers {

  describe("MetricTree") {
    val origin = Vectors.dense(0, 0)
    describe("can be constructed with empty data") {
      val tree = MetricTree.build(IndexedSeq.empty[RowWithVector])
      it("iterator should be empty") {
        tree.iterator shouldBe empty
      }
      it("should return empty when queried") {
        tree.query(origin) shouldBe empty
      }
      it("should have zero leaf") {
        tree.leafCount shouldBe 0
      }
    }

    describe("without duplicates") {
      val data = (-5 to 5).flatMap(i => (-5 to 5).map(j => new RowWithVector(Vectors.dense(i, j), null)))
      List(1, data.size / 2, data.size, data.size * 2).foreach {
        leafSize =>
          describe(s"with leafSize of $leafSize") {
            val tree = MetricTree.build(data, leafSize)
            it("should have correct size") {
              tree.size shouldBe data.size
            }
            it("should return an iterator that goes through all data points") {
              tree.iterator.toIterable should contain theSameElementsAs data
            }
            it("should return vector itself for those in input set") {
              data.foreach(v => tree.query(v.vector, 1).head._1 shouldBe v)
            }
            it("should return nearest neighbors correctly") {
              tree.query(origin, 5).map(_._1.vector.vector) should contain theSameElementsAs Set(
                Vectors.dense(-1, 0),
                Vectors.dense(1, 0),
                Vectors.dense(0, -1),
                Vectors.dense(0, 1),
                Vectors.dense(0, 0)
              )
              tree.query(origin, 9).map(_._1.vector.vector) should contain theSameElementsAs
                (-1 to 1).flatMap(i => (-1 to 1).map(j => Vectors.dense(i, j)))
            }
            it("should have correct number of leaves") {
              tree.leafCount shouldBe (tree.size / leafSize.toDouble).ceil
            }
            it("all points should fall with radius of pivot") {
              def check(tree: Tree): Unit = {
                tree.iterator.foreach(_.vector.fastDistance(tree.pivot) <= tree.radius)
                tree match {
                  case t: MetricTree =>
                    check(t.leftChild)
                    check(t.rightChild)
                  case _ =>
                }
              }
              check(tree)
            }
          }
      }
    }

    describe("with duplicates") {
      val data = (Vectors.dense(2.0, 0.0) +: Array.fill(5)(Vectors.dense(0.0, 1.0))).map(new RowWithVector(_, null))
      val tree = MetricTree.build(data)
      it("should have 2 leaves") {
        tree.leafCount shouldBe 2
      }
      it("should return all available duplicated candidates") {
        val res = tree.query(origin, 5).map(_._1.vector.vector)
        res.size shouldBe 5
        res.toSet should contain theSameElementsAs Array(Vectors.dense(0.0, 1.0))
      }
    }

    describe("for other corner cases") {
      it("queryCost should work on Empty") {
        Empty.distance(new KNNCandidates(new VectorWithNorm(origin), 1)) shouldBe 0
        Empty.distance(new VectorWithNorm(origin)) shouldBe 0
      }
    }
  }
} 

package org.apache.spark.ml.knn

import org.apache.spark.ml.knn.KNN.RowWithVector
import org.apache.spark.ml.linalg.Vectors
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class SpillTreeSpec extends AnyFunSpec with Matchers {
  describe("SpillTree") {
    val origin = Vectors.dense(0, 0)
    describe("can be constructed with empty data") {
      val tree = SpillTree.build(IndexedSeq.empty[RowWithVector], tau = 0.0)
      it("iterator should be empty") {
        tree.iterator shouldBe empty
      }
      it("should return empty when queried") {
        tree.query(origin) shouldBe empty
      }
      it("should have zero leaf") {
        tree.leafCount shouldBe 0
      }
    }

    describe("with equidistant points on a circle") {
      val n = 12
      val points = (1 to n).map {
        i => new RowWithVector(Vectors.dense(math.sin(2 * math.Pi * i / n), math.cos(2 * math.Pi * i / n)), null)
      }
      val leafSize = n / 4
      describe("built with tau = 0.0") {
        val tree = SpillTree.build(points, leafSize = leafSize, tau = 0.0)
        it("should have correct size") {
          tree.size shouldBe points.size
        }
        it("should return an iterator that goes through all data points") {
          tree.iterator.toIterable should contain theSameElementsAs points
        }
        it("can return more than min leaf size") {
          val k = leafSize + 5
          points.foreach(v => tree.query(v.vector, k).size shouldBe k)
        }
      }
      describe("built with tau = 0.5") {
        val tree = SpillTree.build(points, leafSize = leafSize, tau = 0.5)
        it("should have correct size") {
          tree.size shouldBe points.size
        }
        it("should return an iterator that goes through all data points") {
          tree.iterator.toIterable should contain theSameElementsAs points
        }
        it("works for every point to identify itself") {
          points.foreach(v => tree.query(v.vector, 1).head._1 shouldBe v)
        }
        it("has consistent size and iterator") {
          def check(tree: Tree): Unit = {
            tree match {
              case t: SpillTree =>
                t.iterator.size shouldBe t.size

                check(t.leftChild)
                check(t.rightChild)
              case _ =>
            }
          }
          check(tree)
        }
      }
    }
  }

  describe("HybridTree") {
    val origin = Vectors.dense(0, 0)
    describe("can be constructed with empty data") {
      val tree = HybridTree.build(IndexedSeq.empty[RowWithVector], tau = 0.0)
      it("iterator should be empty") {
        tree.iterator shouldBe empty
      }
      it("should return empty when queried") {
        tree.query(origin) shouldBe empty
      }
      it("should have zero leaf") {
        tree.leafCount shouldBe 0
      }
    }

    describe("with equidistant points on a circle") {
      val n = 12
      val points = (1 to n).map {
        i => new RowWithVector(Vectors.dense(math.sin(2 * math.Pi * i / n), math.cos(2 * math.Pi * i / n)), null)
      }
      val leafSize = n / 4
      val tree = HybridTree.build(points, leafSize = leafSize, tau = 0.5)
      it("should have correct size") {
        tree.size shouldBe points.size
      }
      it("should return an iterator that goes through all data points") {
        tree.iterator.toIterable should contain theSameElementsAs points
      }
    }
  }
} 

package com.crealytics.spark.excel

import org.apache.spark.sql._
import org.apache.spark.sql.types._
import scala.collection.JavaConverters._

import com.holdenkarau.spark.testing.DataFrameSuiteBase
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

object EncryptedReadSuite {
  val simpleSchema = StructType(
    List(
      StructField("A", DoubleType, true),
      StructField("B", DoubleType, true),
      StructField("C", DoubleType, true),
      StructField("D", DoubleType, true)
    )
  )

  val expectedData = List(Row(1.0d, 2.0d, 3.0d, 4.0d)).asJava
}

class EncryptedReadSuite extends AnyFunSpec with DataFrameSuiteBase with Matchers {
  import EncryptedReadSuite._

  lazy val expected = spark.createDataFrame(expectedData, simpleSchema)

  def readFromResources(path: String, password: String, maxRowsInMemory: Option[Int] = None): DataFrame = {
    val url = getClass.getResource(path)
    val reader = spark.read
      .excel(
        dataAddress = s"Sheet1!A1",
        treatEmptyValuesAsNulls = true,
        workbookPassword = password,
        inferSchema = true
      )
    val withMaxRows = maxRowsInMemory.fold(reader)(rows => reader.option("maxRowsInMemory", s"$rows"))
    withMaxRows.load(url.getPath)
  }

  describe("spark-excel") {
    it("should read encrypted xslx file") {
      val df = readFromResources("/spreadsheets/simple_encrypted.xlsx", "fooba")

      assertDataFrameEquals(expected, df)
    }

    it("should read encrypted xlsx file with maxRowsInMem=10") {
      val df = readFromResources("/spreadsheets/simple_encrypted.xlsx", "fooba", maxRowsInMemory = Some(10))

      assertDataFrameEquals(expected, df)
    }

    it("should read encrypted xlsx file with maxRowsInMem=1") {
      val df = readFromResources("/spreadsheets/simple_encrypted.xlsx", "fooba", maxRowsInMemory = Some(1))

      assertDataFrameEquals(expected, df)
    }

    it("should read encrypted xls file") {
      val df = readFromResources("/spreadsheets/simple_encrypted.xls", "fooba")

      assertDataFrameEquals(expected, df)
    }
  }
} 

package com.crealytics.spark.excel
import com.crealytics.tags.WIP
import com.norbitltd.spoiwo.model.{CellRange, Sheet, Workbook}
import org.apache.poi.ss.SpreadsheetVersion
import org.apache.poi.ss.util.AreaReference
import org.apache.poi.xssf.usermodel.XSSFWorkbook
import com.norbitltd.spoiwo.natures.xlsx.Model2XlsxConversions._
import org.scalacheck.Gen

import scala.collection.JavaConverters._
import org.scalatestplus.scalacheck.ScalaCheckPropertyChecks
import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class DataLocatorSuite extends AnyFunSpec with ScalaCheckPropertyChecks with Matchers with Generators {
  describe("with a table reference") {
    val dl = DataLocator(Map("dataAddress" -> s"$tableName[#All]"))
    describe("containing #All") {
      it("extracts the entire table data") {
        forAll(sheetWithTableGen) { sheet =>
          val actualData = dl.readFrom(sheet.convertAsXlsx()).map(_.map(_.value)).to[Seq]
          actualData should contain theSameElementsAs sheet.extractTableData(0)
        }
      }

      it("writes into a new table in a new sheet if no corresponding table exists") {
        forAll(sheetGenerator(withHeader = Gen.const(true), numCols = Gen.choose(1, 200))) { dataSheet =>
          val workbook = new XSSFWorkbook()
          val header = dataSheet.rows.head.cells.map(_.value.toString).toSeq
          val generatedSheet = dl.toSheet(
            header = Some(header),
            data = dataSheet.rows.tail.iterator.map(_.cells.map(_.value.toString).toSeq),
            existingWorkbook = workbook
          )
          generatedSheet.convertAsXlsx(workbook)
          val pTable = workbook.getTable(tableName)
          pTable.getSheetName should equal(tableName)
          pTable.getColumns.asScala.map(_.getName) should contain theSameElementsInOrderAs header
          val actualData = dl.readFrom(workbook).map(_.map(_.value)).to[Seq]
          actualData should contain theSameElementsAs dataSheet.rows.map(_.cells.map(_.value))
        }
      }

      it("overwrites an existing table") {
        forAll(sheetWithTableGen) { sheetWithTable =>
          val workbook = sheetWithTable.convertAsXlsx()
          val table = sheetWithTable.tables.head
          val header = table.columns.map(_.name)
          val tableData = dl.readFrom(workbook).map(_.map(c => s"new_$c")).toList
          val generatedSheet =
            dl.toSheet(header = tableData.headOption, data = tableData.iterator.drop(1), existingWorkbook = workbook)
          Workbook(generatedSheet).writeToExisting(workbook)
          val pTable = workbook.getTable(tableName)
          pTable.getSheetName should equal(sheetName)
          pTable.getColumns.asScala.map(_.getName) should contain theSameElementsInOrderAs header
          val actualData = dl.readFrom(workbook).map(_.map(_.value)).to[Seq]
          actualData should contain theSameElementsAs tableData
        }
      }
    }
  }
  describe("without any dataAddress") {
    it("defaults to starting at cell A1 in the first sheet") {
      val dl = DataLocator(Map())
      dl shouldBe a[CellRangeAddressDataLocator]
      val cradl = dl.asInstanceOf[CellRangeAddressDataLocator]
      cradl.dataAddress.getFirstCell.formatAsString() should equal("A1")
      cradl.dataAddress.getFirstCell.getSheetName should equal(null)
    }
  }
} 

package jp.co.dwango.s99

import jp.co.dwango.s99.P58.Tree
import jp.co.dwango.s99.binary_trees.{Node, End}
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P58Spec extends AnyFunSpec with Diagrams {
  describe("P58") {
    it("""Tree.symmetricBalancedTrees(5, "x")""") {
      assert(
        List(
          Node(
            "x",
            Node("x", End, Node("x")),
            Node("x", Node("x", End, End), End)
          ),
          Node("x", Node("x", Node("x"), End), Node("x", End, Node("x")))
        ) ==
          Tree.symmetricBalancedTrees(5, "x")
      )
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P16Spec extends AnyFunSpec with Diagrams {
  describe("P16") {
    it("for index less than equal 0, drop(i, s) throws Exception") {
      intercept[Throwable] {
        P16.drop(0, List.empty[Int])
      }
      intercept[Throwable] {
        P16.drop(-1, List.empty[Int])
      }
      intercept[Throwable] {
        P16.drop(0, List(1))
      }
      intercept[Throwable] {
        P16.drop(-1, List(1))
      }
    }
    it("for positive index and empty list, drop(i, s) is empty list") {
      assert(P16.drop(1, List.empty[Int]) == List.empty[Int])
      assert(P16.drop(2, List.empty[Int]) == List.empty[Int])
      assert(P16.drop(3, List.empty[Int]) == List.empty[Int])
    }
    it("otherwise") {
      assert(P16.drop(1, List(1)) == List.empty[Int])
      assert(P16.drop(1, List(1, 2)) == List.empty[Int])
      assert(P16.drop(1, List(1, 2, 3)) == List.empty[Int])
      assert(P16.drop(2, List(1, 2)) == List(1))
      assert(P16.drop(2, List(1, 2, 3)) == List(1, 3))
      assert(P16.drop(2, List(0, 0)) == List(0))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P04Spec extends AnyFunSpec with Diagrams {
  describe("P04") {
    it("for empty list") {
      assert(P04.length(List.empty[Int]) == 0)
    }
    it("for list has one element") {
      assert(P04.length(List(1)) == 1)
    }
    it("otherwise") {
      assert(P04.length(List(1, 2)) == 2)
      assert(P04.length(List(1, 2, 3)) == 3)
    }
  }
} 

package jp.co.dwango.s99

import jp.co.dwango.s99.P57.Tree
import jp.co.dwango.s99.P56._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P57Spec extends AnyFunSpec with Diagrams {
  describe("P57") {
    it("Tree.fromList(List(5, 3, 18, 1, 4, 12, 21)") {
      assert(Tree.fromList(List(5, 3, 18, 1, 4, 12, 21)).isSymmetric)
    }
    it("Tree.fromList(List(3, 2, 5, 7, 4))") {
      assert(!Tree.fromList(List(3, 2, 5, 7, 4)).isSymmetric)
    }
  }
} 

package jp.co.dwango.s99

import binary_trees._
import P62._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P62Spec extends AnyFunSpec with Diagrams {
  describe("P62") {
    it("collect value of internal nodes") {
      assert(
        Node(
          'a',
          Node('b'),
          Node('c', Node('d'), Node('e'))
        ).internalList == List(
          'a',
          'c'
        )
      )
    }
  }
} 

package com.stephenn.scalatest.playjson

import org.scalatest.funspec.AnyFunSpec
import org.scalatest.matchers.should.Matchers

class JsonMatchersSpec extends AnyFunSpec with Matchers {

  describe("JsonMatchers") {
    it("should pass when json is the same") {
      Seq("{}" -> "{}", "[]" -> "[]").foreach {
        case (left, right) =>
          val matchResult = JsonMatchers.matchJson(right).apply(left)
          matchResult.matches shouldBe true
      }
    }

    it("should pass when json is equivalent") {
      val matchResult = JsonMatchers.matchJson("{  }").apply("  {}  ")
      matchResult.matches shouldBe true

      Seq(
        "{}" -> " { }",
        " [ ] " -> "[]",
        """{"a":0, "b":1}""" -> """{"b":1,"a":0}"""
      ).foreach {
        case (left, right) =>
          val matchResult = JsonMatchers.matchJson(right).apply(left)
          matchResult.matches shouldBe true
      }
    }

    it("should fail when left has extra fields") {
      val matchResult = JsonMatchers.matchJson("""{"l":1}""").apply("{}")
      matchResult.matches shouldBe false
      matchResult.failureMessage.trim shouldBe
        """
          |Json did not match "{}" did not match "{"l":1}"
          |
          |Json Diff:
          |"JsonPatch(List(Add(Chain(Left(l)),1)))"
        """.stripMargin.trim
    }

    it("should fail when right has extra fields") {
      val matchResult = JsonMatchers.matchJson("{}").apply("""{"r":0}""")
      matchResult.matches shouldBe false
      matchResult.failureMessage.trim shouldBe
        """
          |Json did not match "{"r":0}" did not match "{}"
          |
          |Json Diff:
          |"JsonPatch(List(Remove(Chain(Left(r)),None)))"
        """.stripMargin.trim
    }

    it("should fail on invalid json") {
      val matchResult =
        JsonMatchers.matchJson("{}").apply("""{"a": nope]}""")
      matchResult.matches shouldBe false
      matchResult.failureMessage shouldBe "Could not parse json \"{\"a\": nope]}\" did not equal \"{}\""
    }

    it("should match a json object to a json string") {
      import play.api.libs.json._
      val matchResult = JsonMatchers
        .matchJsonString("""{"b":1,"a":0}""")
        .apply(Json.parse("""{"a":0, "b":1}"""))
      matchResult.matches shouldBe true
    }
  }
} 

package jp.co.dwango.s99

import binary_trees._
import P61a._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P61aSpec extends AnyFunSpec with Diagrams {
  describe("P61a") {
    it("collect value of leaves") {
      assert(
        Node(
          'a',
          Node('b'),
          Node('c', Node('d'), Node('e'))
        ).leafList.toSet == Set(
          'b',
          'd',
          'e'
        )
      )
      assert(End.leafList == Nil)
      assert(Node('b', Node('a'), End).leafList == List('a'))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P17Spec extends AnyFunSpec with Diagrams {
  describe("P17") {
    it("for index less than 0, split(n, s) throws Exception") {
      intercept[Throwable] {
        P17.split(-1, List.empty[Int])
      }
      intercept[Throwable] {
        P17.split(-1, List(1))
      }
      intercept[Throwable] {
        P17.split(-1, List(1, 2))
      }
    }
    it("for index which is out of range, split(n, s) throws Exception") {
      intercept[Throwable] {
        P17.split(1, List.empty[Int])
      }
      intercept[Throwable] {
        P17.split(-1, List.empty[Int])
      }
      intercept[Throwable] {
        P17.split(2, List(1))
      }
      intercept[Throwable] {
        P17.split(3, List(1, 2))
      }
    }
    it("for 0 index and empty list, split(n, s) returns (List(), List())") {
      assert(
        P17.split(0, List.empty[Int]) == ((List.empty[Int], List.empty[Int]))
      )
    }
    it("otherwise") {
      assert(P17.split(0, List(1, 2)) == ((List(), List(1, 2))))
      assert(P17.split(1, List(1, 2)) == ((List(1), List(2))))
      assert(P17.split(0, List(1, 2, 3)) == ((List(), List(1, 2, 3))))
      assert(P17.split(1, List(1, 2, 3)) == ((List(1), List(2, 3))))
      assert(P17.split(2, List(1, 2, 3)) == ((List(1, 2), List(3))))
      assert(P17.split(3, List(1, 2, 3)) == ((List(1, 2, 3), List())))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P07Spec extends AnyFunSpec with Diagrams {
  describe("P07") {
    it("for empty list, flatten(s) is s") {
      assert(P07.flatten(List.empty[Int]) == List.empty[Int])
    }
    it("for list of empty list, flatten(List(List.empty)) is List.empty") {
      assert(P07.flatten(List(List.empty[Int])) == List.empty[Int])
    }
    it("otherwise") {
      assert(P07.flatten(List(List(1))) == List(1))
    }
  }
} 

package jp.co.dwango.s99

import P96._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P96Spec extends AnyFunSpec with Diagrams {
  describe("P96") {
    it("for letter parser") {
      assert(letter("a") == Success(""))
      assert(letter("abc") == Success("bc"))
    }
    it("for ~ parser") {
      val ab = letter ~ letter
      assert(ab("abc") == Success("c"))
    }
    it("for ? parser") {
      val p1 = letter.?
      assert(p1("abc") == Success("bc"))
      assert(p1("123") == Success("123"))
      val p2 = letter ~ letter.?
      assert(p2("a12") == Success("12"))
      assert(p2("ab1") == Success("1"))
      assert(p2("abc") == Success("c"))
    }
    it("for | parser") {
      val p1 = letter | digit
      assert(p1("abc") == Success("bc"))
      assert(p1("123") == Success("23"))
    }
    it("for identifier parser") {
      assert(identifier("abc") == Success(""))
      assert(identifier("Time_of_Day") == Success(""))
      assert(identifier("only_1_percent") == Success(""))
      assert(identifier("abc123_xyz") == Success(""))
    }
  }
} 

package jp.co.dwango.s99

import binary_trees._
import P62b._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P62bSpec extends AnyFunSpec with Diagrams {
  describe("P62b") {
    it("collect value of specific levels") {
      assert(
        Node('a', Node('b'), Node('c', Node('d'), Node('e')))
          .atLevel(2) == List('b', 'c')
      )
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P11Spec extends AnyFunSpec with Diagrams {
  describe("P11") {
    it("for empty list, encodeModified(s) is s") {
      assert(P11.encodeModified(List.empty[Int]) == List.empty[Int])
    }
    it("for list has one element, encodeModified(s) is s") {
      assert(P11.encodeModified(List(1)) == List(1))
      assert(P11.encodeModified(List(2)) == List(2))
      assert(P11.encodeModified(List(2)) == List(2))
    }
    it("otherwise") {
      assert(P11.encodeModified(List(1, 1)) == List((2, 1)))
      assert(P11.encodeModified(List(1, 1, 2)) == List((2, 1), 2))
      assert(P11.encodeModified(List(1, 1, 2, 3)) == List((2, 1), 2, 3))
      assert(P11.encodeModified(List(1, 1, 2, 2, 3)) == List((2, 1), (2, 2), 3))
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P32Spec extends AnyFunSpec with Diagrams {
  describe("P32") {
    it("for zero test") {
      assert(P32.gcd(0, 0) == 0)
      assert(P32.gcd(2, 0) == 2)
      assert(P32.gcd(0, 33) == 33)
    }
    it("for positive integer numbers") {
      assert(
        P32.gcd(3 * 5 * 7 * 11, 3 * 5 * 7 * 11 * 17 * 19) == 3 * 5 * 7 * 11
      )
      assert(P32.gcd(3, 3) == 3)
      assert(P32.gcd(2 * 3 * 5 * 7, 2 * 3 * 5 * 17) == 2 * 3 * 5)
      assert(P32.gcd(Int.MaxValue, Int.MaxValue) == Int.MaxValue)
    }
    it("for negative integer numbers") {
      assert(P32.gcd(-5, -5) == 5)
      assert(P32.gcd(-2, -4) == 2)
      assert(P32.gcd(Int.MinValue, Int.MinValue) == Int.MinValue)
    }
  }
} 

package jp.co.dwango.s99

import P68._
import binary_trees._
import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P68Spec extends AnyFunSpec with Diagrams {
  describe("P68") {
    it("do pre-order traversal") {
      assert(
        Tree.string2Tree("a(b(d,e),c(,f(g,)))").preorder ==
          List('a', 'b', 'd', 'e', 'c', 'f', 'g')
      )
    }
    it("do in-order traversal") {
      assert(
        Tree.string2Tree("a(b(d,e),c(,f(g,)))").inorder ==
          List('d', 'b', 'e', 'a', 'c', 'g', 'f')
      )
    }
  }
} 

package jp.co.dwango.s99

import org.scalatest.diagrams.Diagrams
import org.scalatest.funspec.AnyFunSpec

class P01Spec extends AnyFunSpec with Diagrams {
  describe("P01") {
    it("for empty list(should fail)") {
      intercept[Throwable] {
        P01.last(List[Int]())
      }
    }
    it("for list has one element") {
      assert(P01.last(List(1)) == 1)
    }
    it("for list has more than one element") {
      assert(P01.last(List(1, 2)) == 2)
    }
  }
}