//设置package包名称以及导入依赖的类
package daos

import scala.concurrent.Await

import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.test._
import play.api.test.Helpers._

import org.joda.time.DateTime
import org.specs2.mutable.Specification

import java.util.UUID

import scala.concurrent.Await
import scala.concurrent.duration.DurationInt

import models.UserToken

class UserTokenDaoSpec extends Specification {

  val timeout = DurationInt(10).seconds
  def fakeApp = FakeApplication(additionalConfiguration = Map("mongodb.uri" -> "mongodb://localhost:27017/test"))

  def withUserTokenDao[T](t:UserTokenDao => T):T = running(fakeApp) {
    val userTokenDao = new MongoUserTokenDao
    Await.ready(userTokenDao.tokens.drop(), timeout)
    t(userTokenDao)
  }

  val token = UserToken(id=UUID.randomUUID(), userId=UUID.randomUUID(), "[email protected]", new DateTime(), true)

  "UserTokenDao" should {
    "Persist and find a token" in withUserTokenDao { userTokenDao =>
      val future = for {
        _ <- userTokenDao.save(token)
        maybeToken <- userTokenDao.find(token.id)
      } yield maybeToken.map(_ == token)
      Await.result(future, timeout) must beSome(true)
    }

    "Remove a token" in withUserTokenDao { userTokenDao =>
      val future = for {
        _ <- userTokenDao.save(token)
        _ <- userTokenDao.remove(token.id)
        maybeToken <- userTokenDao.find(token.id)
      } yield maybeToken
      Await.result(future, timeout) must beNone       
    }
  }
} 

//设置package包名称以及导入依赖的类
package code
package snippet

import net.liftweb._
import http._
import net.liftweb.util._
import net.liftweb.common._
import Helpers._
import lib._
import org.specs2.mutable.Specification
import org.specs2.specification.AroundExample
import org.specs2.execute.AsResult


object HelloWorldTestSpecs extends Specification with AroundExample{
  val session = new LiftSession("", randomString(20), Empty)
  val stableTime = now

  
  def around[T : AsResult](body: =>T) = {
    S.initIfUninitted(session) {
      DependencyFactory.time.doWith(stableTime) {
        AsResult( body)  // execute t inside a http session
      }
    }
  }

  "HelloWorld Snippet" should {
    "Put the time in the node" in {
      val hello = new HelloWorld
      Thread.sleep(1000) // make sure the time changes

      val str = hello.howdy(<span>Welcome to your Lift app at <span id="time">Time goes here</span></span>).toString

      str.indexOf(stableTime.toString) must be >= 0
      str must startWith("<span>Welcome to")
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.dwolla.awssdk.utils

import com.amazonaws.services.ecs.AmazonECSAsync
import com.amazonaws.services.ecs.model.{ListClustersRequest, ListClustersResult, ListContainerInstancesRequest, ListContainerInstancesResult}
import com.dwolla.awssdk.AmazonAsyncMockingImplicits._
import com.dwolla.awssdk.utils.PaginatedResponseRetriever._
import org.specs2.concurrent.ExecutionEnv
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import org.specs2.specification.Scope

import scala.collection.JavaConverters._

class PaginatedResponseRetrieverSpec(implicit ee: ExecutionEnv) extends Specification with Mockito {

  trait Setup extends Scope {
    val mockEcsClient = mock[AmazonECSAsync]
  }

  "PaginatedResponseRetriever" should {
    "make all the requests necessary to fetch all paginated results" in new Setup {
      def reqWithNextToken(x: Option[Int]) = new ListContainerInstancesRequest().withCluster("cluster1").withNextToken(x.map(i ? s"next-token-$i").orNull)

      def res(x: Int, y: Option[Int] = None) = Right(new ListContainerInstancesResult().withContainerInstanceArns(s"arn$x").withNextToken(y.map(i ? s"next-token-$i").orNull))

      val pages = 1 to 50
      val pairs = pages.sliding(2).toSeq.map {
        case Vector(1, y) ? reqWithNextToken(None) ? res(1, Option(y))
        case Vector(x, y) if x > 1 && y < pages.last ? reqWithNextToken(Option(x)) ? res(x, Option(y))
        case Vector(x, _) ? reqWithNextToken(Option(x)) ? res(x, None)
      }

      mockedMethod(mockEcsClient.listContainerInstancesAsync) answers (pairs: _*)

      val output = fetchAll(() ? new ListContainerInstancesRequest().withCluster("cluster1"),mockEcsClient.listContainerInstancesAsync)
        .map(_.flatMap(_.getContainerInstanceArns.asScala.toList))

      output must containTheSameElementsAs(pages.dropRight(1).map(x ? s"arn$x")).await
    }

    "support default request factory" in new Setup {
      new ListClustersResult() completes mockEcsClient.listClustersAsync

      val output = fetchAllWithDefaultRequestsVia(mockEcsClient.listClustersAsync)

      output must contain(new ListClustersResult()).await
    }

    "support builder syntax with factory as initial parameter" in new Setup {
      new ListClustersResult() completes mockEcsClient.listClustersAsync

      val output = fetchAllWithRequestsLike(() ? new ListClustersRequest).via(mockEcsClient.listClustersAsync)

      output must contain(new ListClustersResult()).await
    }
  }
} 

//设置package包名称以及导入依赖的类
package kissthinker.shopping

import org.specs2.mutable.Specification
import Checkout._

class CheckoutSpec extends Specification {
  "Shopping cart" should {
    "cost nothing when there are no items" in {
      costOf(ShoppingCart()) mustEqual 0.00
    }

    "cost 60p for 1 apple" in {
      costOf(ShoppingCart(Apple)) mustEqual 0.60
    }

    "cost £1.20 for 2 apples" in {
      costOf(ShoppingCart(Apple, Apple)) mustEqual 1.20
    }

    "cost 25p for 1 orange" in {
      costOf(ShoppingCart(Orange)) mustEqual 0.25
    }

    "cost 50p for 2 oranges" in {
      costOf(ShoppingCart(Orange, Orange)) mustEqual 0.50
    }

    "£2.05 for 3 apples and 1 orange" in {
      costOf(ShoppingCart(Apple, Apple, Orange, Apple)) mustEqual 2.05
    }

    "cost 20p for 1 banana" in {
      costOf(ShoppingCart(Banana)) mustEqual 0.20
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.hotels

import org.specs2.matcher.DataTables
import org.specs2.mutable.Specification


class SearchDataTest extends Specification with DataTables {
  "Hotels dataset" should {
    "have the correct number of elements" >> {
      SearchData.trainDataEncoded.size must_== SearchData.TrainSetSize
      SearchData.trainLabels.size must_== SearchData.TrainSetSize
      SearchData.testDataEncoded.size must_== SearchData.TestSetSize
      SearchData.testLabels.size must_== SearchData.TestSetSize
    }

    "have primitives in train data" >> {
      "elementClass" |
      SearchData.trainDataEncoded.next().next().getClass |
      SearchData.trainingAndTestData()._1.head._2.next().getClass |> { elementClass =>
        elementClass.isPrimitive must beTrue
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.knn

import com.danylchuk.swiftlearner.data.{FisherIris, Mnist}
import org.specs2.mutable.Specification


class KNearestNeighborsTest extends Specification {
  "KNearestNeighbors" should {
    "sort the flowers from the Fisher Iris dataset" >> {
      val (trainingSet, testSet) = FisherIris.trainingAndTestData(Some(0L))

      val classifier = new KNearestNeighbors(trainingSet)

      val accuracy = (for ((species, params) <- testSet) yield {
        classifier.predict(params, 1) == species
      }).count { x: Boolean => x } / testSet.size.toDouble

      accuracy must be_>(0.8)  // 0.94 is typical
    }

    "sort the digits from the MNIST dataset" >> {
      val (trainingSet, testSet) = Mnist.shuffledTrainingAndTestDataDouble(nTrainPoints = 700, randomSeed = Some(0L))
      val expectedAccuracy = 0.8
      // 0.89 with 3000 points; better with more; the current naive algorithm is slow

      val classifier = new KNearestNeighbors(trainingSet)

      val accuracy = (for ((species, params) <- testSet) yield {
        classifier.predict(params, 1) == species
      }).count { x: Boolean => x } / testSet.size.toDouble

      accuracy must be_>(expectedAccuracy)
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.ga

import org.specs2.mutable.Specification


class GeneticTest extends Specification {
  "Genetic algorithm" should {
    "solve the Hello World example" >> {
      val result = new Genetic[HelloGenetic](50, 10).optimize(100, 30000L)
      result.genome must_== HelloGenetic.HelloDouble
      result.fitness must_== 0
    }

    "sort the flowers from the Fisher Iris dataset" >> {
      val testSet = GeneticIris.testSet

      val classifier = new Genetic[GeneticIris](100, 10)
        .optimize(200, 60000L).genome

      val accuracy = (for ((species, params) <- testSet) yield {
        GeneticIris.predict(classifier, params) == species
      }).count { x: Boolean => x } / testSet.size.toDouble

      accuracy must be_>(0.7)  // 0.94 is typical
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.kmeans

import com.danylchuk.swiftlearner.data.FisherIris
import org.specs2.mutable.Specification


class KMeansTest extends Specification{
  "KMeans" should {
    "create clusters similar to the known Iris dataset labels" >> {
      val (knownLabels, data) = FisherIris.irisData.unzip
      val k = knownLabels.distinct.size
      val kMeans = new KMeans(data, k)

      // Now, we have a small problem because the label values are different,
      // although the sets they define should be similar.

      // Pair the labels. Then the most common k pairs will be the correct labels,
      // and we can count the rest to find the number of errors and the accuracy.
      val labelPairs = knownLabels zip kMeans.labels
      val groups = labelPairs.groupBy(identity).values.toVector
      val errorGroups = groups.sortWith((a, b) => a.size > b.size).drop(k)
      val nErrors = errorGroups.map(_.size).sum
      val accuracy = 1.0 - nErrors.toDouble / data.size

      accuracy must be_>(0.8)  // typical is 0.87
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.data

import org.specs2.matcher.DataTables
import org.specs2.mutable.Specification


class MnistTest extends Specification with DataTables {
  "MNIST dataset" should {
    "have the correct number of elements" >> {
      Mnist.trainImagesByteArray.size must_== Mnist.TrainSetSize
      Mnist.trainLabels.size must_== Mnist.TrainSetSize
      Mnist.testImages.size must_== Mnist.TestSetSize
      Mnist.testLabels.size must_== Mnist.TestSetSize
    }

    "have primitives in trainImages" >> {
      "elementClass" |
      Mnist.trainImagesByteArray(0)(0).getClass |
      Mnist.trainImages.next()(0).getClass |
      Mnist.trainImagesDouble.next()(0).getClass |
      Mnist.trainingAndTestDataDouble()._1.head._2.head.getClass |> { elementClass =>
        elementClass.isPrimitive must beTrue
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.bayes

import com.danylchuk.swiftlearner.data.FisherIris
import org.specs2.mutable.Specification


class GaussianNaiveBayesTest extends Specification {
  "GaussianNaiveBayes" should {
    "sort the flowers from the Fisher Iris dataset" >> {
      val (trainingSet, testSet) = FisherIris.trainingAndTestData(Some(0L))

      val classifier = GaussianNaiveBayes.fromTrainingSet(trainingSet)

      val accuracy = (for ((species, params) <- testSet) yield {
        classifier.predict(params) == species
      }).count { x: Boolean => x } / testSet.size.toDouble

      accuracy must be_>(0.8)  // 0.94 is typical
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.math

import com.danylchuk.swiftlearner.math.VectorOp._
import org.specs2.mutable.Specification


class VectorOpTest extends Specification {
  "VectorOp dot product" should {
    "calculate dot product of two vectors" >> {
      Vector(2.0, 3.0) * Vector(4.0, 5.0) must_== 2 * 4 + 3 * 5
    }
    "throw IllegalArgumentException on non-matching size" >> {
      {
        Vector(2.0, 3.0) * Vector(4.0)
      } must throwA(
        new IllegalArgumentException("requirement failed: vector size mismatch"))
    }
  }

  "VectorOp.distance" should {
    "calculate the distance correctly" >> {
      distance(Vector(0, 0), Vector(10, 0)) must_== 10
      distance(Vector(0, 0), Vector(0, 10)) must_== 10
      distance(Vector(0, 0), Vector(3, 4)) must_== 5
      distance(Vector(0, 0), Vector(4, 3)) must_== 5
      distance(Vector(3, 0), Vector(0, 4)) must_== 5
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.math

import org.specs2.mutable.Specification


class StatTest extends Specification {
  "Stat" should {
    "calculate the mean correctly" >> {
      Stat.mean(Seq(0.8, 1.2)) must beCloseTo(1.0 +/- 0.0001)
      Stat.mean(Seq(1.9, 2.1)) must beCloseTo(2.0 +/- 0.0001)
    }

    "calculate the variance correctly" >> {
      Stat.variance(Seq(0.8, 1.2)) must beCloseTo(0.04 +/- 0.0001)
      Stat.variance(Seq(1.9, 2.1)) must beCloseTo(0.01 +/- 0.0001)
    }

    "calculate the standard deviation correctly" >> {
      Stat.stdDev(Seq(0.8, 1.2)) must beCloseTo(0.2 +/- 0.0001)
      Stat.stdDev(Seq(1.9, 2.1)) must beCloseTo(0.1 +/- 0.0001)
    }

    "calculate Gaussian probability density correctly" >> {
      val normalDistributionMax = 1 / math.sqrt(2 * math.Pi)
      Stat.gaussianDensity(0, 0, 1) must beCloseTo(normalDistributionMax +/- 0.0001)
      Stat.gaussianDensity(1, 1, 1) must beCloseTo(normalDistributionMax +/- 0.0001)
      Stat.gaussianDensity(0, 0, 2) must beCloseTo(0.2821 +/- 0.0001)
      Stat.gaussianDensity(0, 1, 2) must beCloseTo(0.2197 +/- 0.0001)
      Stat.gaussianDensity(1, 0, 2) must beCloseTo(0.2197 +/- 0.0001)
      Stat.gaussianDensity(1, 0, 1) must beCloseTo(0.2420 +/- 0.0001)
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.danylchuk.swiftlearner.math

import org.specs2.mutable.Specification


class MatrixOpTest extends Specification {
  "MatrixOp" should {
    "mulMatrixByColumnFloat" >> {
      val a = Array(1.0f, 2.0f, 3.0f, 5.0f, 7.0f, 9.0f, 99.99f, 99.99f, 99.99f)
      val x = Array(11.0f, 13.0f, 17.0f)
      val result = MatrixOp.mulMatrixByColumnFloat(a, x, 2, 3)
      val expected = Array(11.0f * 1.0f + 13.0f * 2.0f + 17.0f * 3.0f,
                           11.0f * 5.0f + 13.0f * 7.0f + 17.0f * 9.0f)
      result must_== expected
    }

    "mulMatrixByColumnDouble" >> {
      val a = Array(1.0, 2.0, 3.0, 5.0, 7.0, 9.0, 99.99, 99.99, 99.99)
      val x = Array(11.0, 13.0, 17.0)
      val result = MatrixOp.mulMatrixByColumnDouble(a, x, 2, 3)
      val expected = Array(11.0 * 1.0 + 13.0 * 2.0 + 17.0 * 3.0,
                           11.0 * 5.0 + 13.0 * 7.0 + 17.0 * 9.0)
      result must_== expected
    }
  }
} 

//设置package包名称以及导入依赖的类
package kartograffel.server

import org.http4s._
import org.http4s.testing.Http4sMatchers
import org.specs2.mutable.Specification

object ServiceSpec extends Specification with Http4sMatchers {
  "Service.api" >> {
    "/now.json has status 200" >> {
      val request = Request(Method.GET, Uri.uri("/now.json"))
      val response = unsafeGetResponse(Service.api, request)
      response must haveStatus(Status.Ok)
    }
    "/version has MediaType application/json" >> {
      val request = Request(Method.GET, Uri.uri("/version"))
      val response = unsafeGetResponse(Service.api, request)
      response must haveMediaType(MediaType.`application/json`)
    }
  }

  "Service.assets" >> {
    "/client-opt.js contains 'Hello, world!'" >> {
      val path = s"/${BuildInfo.moduleName}/${BuildInfo.version}/client-opt.js"
      val request = Request(Method.GET, Uri(path = path))
      val response = unsafeGetResponse(Service.assets, request)
      response must haveBody(contain("Hello, world!"))
    }
  }

  def unsafeGetResponse(service: HttpService, request: Request): Response =
    service.run(request).unsafeRun().orNotFound
} 

//设置package包名称以及导入依赖的类
package com.shopping

import org.specs2.mutable.Specification
import Checkout._

class CheckoutSpec extends Specification {
  "Shopping cart" should {
    "cost nothing when there are no items" in {
      costOf(ShoppingCart()) mustEqual 0.00
    }

    "cost 60p for 1 apple" in {
      costOf(ShoppingCart(Apple)) mustEqual 0.60
    }

    "cost £1.20 for 2 apples" in {
      costOf(ShoppingCart(Apple, Apple)) mustEqual 1.20
    }

    "cost 25p for 1 orange" in {
      costOf(ShoppingCart(Orange)) mustEqual 0.25
    }

    "cost 50p for 2 oranges" in {
      costOf(ShoppingCart(Orange, Orange)) mustEqual 0.50
    }

    "£2.05 for 3 apples and 1 orange" in {
      costOf(ShoppingCart(Apple, Apple, Orange, Apple)) mustEqual 2.05
    }

   }
} 

//设置package包名称以及导入依赖的类
package repository

import models.Award
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner
import play.api.Application
import play.api.test.WithApplication

import scala.concurrent.Await
import scala.concurrent.duration.Duration

@RunWith(classOf[JUnitRunner])
class AwardRepoTest extends Specification{

  def awardRepo(implicit app:Application)=Application.instanceCache[AwardRepo].apply(app)

  "Award Repository" should {
    "get award records" in new WithApplication {
      val res = awardRepo.getAll()
      val response = Await.result(res, Duration.Inf)
      response.head.id ===1
    }

    "insert award records" in new WithApplication() {
      val res=awardRepo.insert(4,"best orator","school level")
      val response=Await.result(res,Duration.Inf)
      response===1
    }

    "update award records" in new WithApplication{
      val res=awardRepo.update(1,"best singer","school level")
      val response=Await.result(res,Duration.Inf)
      response===0
    }

    "delete award records" in new WithApplication() {
      val res=awardRepo.delete("best dancer")
      val response=Await.result(res,Duration.Inf)
      response===0
    }

    "get awards by id" in new WithApplication() {
      val res=awardRepo.getAward(1)
      val response=Await.result(res,Duration.Inf)
      response===Vector(Award(1,"best programmer","school level"))
    }
  }
} 

//设置package包名称以及导入依赖的类
package repository

import models.Language
import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner
import play.api.Application
import play.api.test.WithApplication

import scala.concurrent.Await
import scala.concurrent.duration.Duration

@RunWith(classOf[JUnitRunner])
class LanguageRepoTest extends Specification{

  def langRepo(implicit app:Application)=Application.instanceCache[LanguageRepo].apply(app)

  "Language Repository" should {
    "get language records" in new WithApplication {
      val res = langRepo.getAll()
      val response = Await.result(res, Duration.Inf)
      response.head.id ===1
    }

    "insert language records" in new WithApplication() {
      val res=langRepo.insert(1,"french","basic")
      val response=Await.result(res,Duration.Inf)
      response===1
    }


    "update language records" in new WithApplication(){
      val res=langRepo.update(1,"spansih","basic")
      val response=Await.result(res,Duration.Inf)
      response === 1
    }

    "delete language record" in new WithApplication() {
      val res=langRepo.delete("hindi")
      val response=Await.result(res,Duration.Inf)
      response===1
    }

    "get records by id" in new WithApplication() {
      val res=langRepo.getLanguage(1)
      val response=Await.result(res,Duration.Inf)
      response===Vector(Language(1,"hindi","advanced"))
    }


  }

} 

//设置package包名称以及导入依赖的类
package com.pacb.itg.metrics.pbbam.aligned

import falkner.jayson.metrics.io.CSV
import org.specs2.mutable.Specification


class AlignedBamSpec extends Specification {

  "Aligned PB BAM Metrics" should {
    "Current version calculates without error" in {
      println(s"Current PB BAM Version: ${AlignedPacBioBam.currentVersion}")
      AlignedPacBioBam.currentVersion != null mustEqual true
    }
    "Support blank CSV generation" in {
      CSV(AlignedPacBioBam.blank).all != null mustEqual true
    }

  }
} 

//设置package包名称以及导入依赖的类
package play.api.libs.ws.ahc.cache

import org.specs2.mutable.Specification
import play.shaded.ahc.io.netty.handler.codec.http.HttpHeaders.Names._

class CacheableResponseSpec extends Specification {

  "CacheableResponse" should {

    "get body" in {

      "when it is text/plain" in {
        val response = CacheableResponse(200, "https://playframework.com/", "PlayFramework Homepage").withHeaders(CONTENT_TYPE -> "text/plain")
        response.getResponseBody must beEqualTo("PlayFramework Homepage")
        response.getContentType must beEqualTo("text/plain")
      }

      "when it is application/json" in {
        val response = CacheableResponse(200, "https://playframework.com/", """{ "a": "b" }""").withHeaders("Content-Type" -> "application/json")
        response.getResponseBody must beEqualTo("""{ "a": "b" }""")
        response.getContentType must beEqualTo("application/json")
      }

      "when it is application/json; charset=utf-8" in {
        val response = CacheableResponse(200, "https://playframework.com/", """{ "a": "b" }""").withHeaders("Content-Type" -> "application/json; charset=utf-8")
        response.getResponseBody must beEqualTo("""{ "a": "b" }""")
        response.getContentType must beEqualTo("application/json; charset=utf-8")
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
package play.api.libs.ws.ahc

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.util.ByteString
import org.specs2.mock.Mockito
import org.specs2.mutable.Specification
import org.specs2.specification.AfterAll
import play.api.libs.ws.{ XML, XMLBodyReadables, XMLBodyWritables }
import play.shaded.ahc.org.asynchttpclient.{ Response => AHCResponse }

import scala.xml.Elem


class XMLRequestSpec extends Specification with Mockito with AfterAll {
  sequential

  implicit val system = ActorSystem()
  implicit val materializer = ActorMaterializer()

  override def afterAll: Unit = {
    system.terminate()
  }

  "write an XML node" in {
    import XMLBodyWritables._

    val xml = XML.parser.loadString("<hello><test></test></hello>")
    val client = mock[StandaloneAhcWSClient]
    val req = new StandaloneAhcWSRequest(client, "http://playframework.com/", null)
      .withBody(xml)
      .asInstanceOf[StandaloneAhcWSRequest]
      .buildRequest()

    req.getHeaders.get("Content-Type") must be_==("text/xml")
    ByteString.fromArray(req.getByteData).utf8String must be_==("<hello><test/></hello>")
  }

  "read an XML node" in {
    import XMLBodyReadables._

    val ahcResponse = mock[AHCResponse]
    ahcResponse.getResponseBody returns "<hello><test></test></hello>"
    val response = new StandaloneAhcWSResponse(ahcResponse)

    val expected = XML.parser.loadString("<hello><test></test></hello>")
    val actual = response.body[Elem]
    actual must be_==(expected)
  }
}