//设置package包名称以及导入依赖的类
package com.groupon.dse.kafka.topic

import org.mockito.Mockito
import org.scalatest.{BeforeAndAfter, FlatSpec}

class HttpJsonTopicFetcherTest extends FlatSpec with BeforeAndAfter {

  "The topic fetcher" should "return the correct list of topics " in {
    val http = Mockito.spy(new HttpJsonTopicFetcher("http://test-url"))
    val content = "{\"topics\":[{\"name\":\"topic1\",\"metadata\":{\"m1\":\"v1\",\"m2\":true}},{\"name\":\"topic2\",\"metadata\":{\"m3\":\"v3\"}}],\"extras\":\"test\"}"
    Mockito.doReturn(Some(content)).when(http).getContentFromUrl
    assert(http.fetchTopics == Seq(TopicAndMetadata("topic1", Map("m1" -> "v1", "m2" -> true.asInstanceOf[AnyRef])), TopicAndMetadata("topic2", Map("m3" -> "v3"))))
  }

  "The topic fetcher" should "return an empty list if the Json in incorrect " in {
    val http = Mockito.spy(new HttpJsonTopicFetcher("http://test-url"))
    val content = "{\"topics\":[{\"name\":\"topic1\",\"metadata\":{\"m1\":\"v1\",\"m2\":true}}{\"name\":\"topic2\",\"metadata\":{\"m3\":\"v3\"}}],\"extras\":\"test\"}"
    Mockito.doReturn(Some(content)).when(http).getContentFromUrl
    assert(http.fetchTopics == Seq())
  }

  "The topic fetcher " should "return the filtered list if the name field is missing for any topic" in {
    val http = Mockito.spy(new HttpJsonTopicFetcher("http://test-url"))
    val contents = "{\"topics\":[{\"name\":\"topic1\",\"metadata\":{\"m1\":\"v1\",\"m2\":\"v2\"}},{\"name1\":\"topic2\",\"enabled\":\"false\",\"metadata\":{\"m3\":\"v3\",\"m4\":\"v4\"}},{\"name\":\"topic3\",\"enabled\":\"true\",\"metadata\":{\"m3\":\"v3\",\"m4\":\"v4\"}}],\"extras\":\"test\"}"
    Mockito.doReturn(Some(contents)).when(http).getContentFromUrl
    assert(http.fetchTopics == Seq(TopicAndMetadata("topic1", Map("m1" -> "v1", "m2" -> "v2")), TopicAndMetadata("topic3", Map("m3" -> "v3", "m4" -> "v4"))))
  }

  "The topic fetcher" should "return an empty map if no metadata is provided" in {
    val http = Mockito.spy(new HttpJsonTopicFetcher("http://test-url"))
    val contents = "{\"topics\":[{\"name\":\"topic1\"},{\"name\":\"topic2\",\"metadata\":{\"m3\":\"v3\",\"m4\":{\"m5\":\"v5\"},\"bool\":true}}]}"
    Mockito.doReturn(Some(contents)).when(http).getContentFromUrl
    assert(http.fetchTopics == Seq(TopicAndMetadata("topic1", Map()), TopicAndMetadata("topic2", Map("m3" -> "v3", "m4" -> Map("m5" -> "v5").asInstanceOf[AnyRef], "bool" -> true.asInstanceOf[AnyRef]))))
  }

  "The topic fetcher" should "return an empty list of topics if there is any problem when fetching the Json" in {
    val http = Mockito.spy(new HttpJsonTopicFetcher("http://test-url"))
    Mockito.doReturn(None).when(http).getContentFromUrl
    assert(http.fetchTopics == Seq.empty)
  }

} 

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

import com.kurz.services.RedisConnectionPool
import com.twitter.finagle.http.Status
import io.finch.Input
import org.scalatest.{BeforeAndAfter, FunSpec, Matchers}

class RedirectionSpec extends FunSpec with Matchers with BeforeAndAfter {
  import com.kurz.Server.redirection

  before {
    RedisConnectionPool.instance.getResource().del("mb")
    RedisConnectionPool.instance.getResource().set("mb", "http://marceloboeira.com")
  }

  describe ("redirection") {
    describe("when the slug exists") {
      it("returns with the temporary redirection status") {
        redirection(Input.get("/mb")).awaitOutputUnsafe().map(_.status) shouldBe Some(Status.TemporaryRedirect)
      }

      it("returns with the proper header for Location") {
        redirection(Input.get("/mb")).awaitOutputUnsafe().map(_.headers) shouldBe Some(Map("Location" -> "http://marceloboeira.com"))
      }
    }

    describe("when the slug does not exist") {
      it("returns with the not found status") {
        redirection(Input.get("/invalid")).awaitOutputUnsafe().map(_.status) shouldBe Some(Status.NotFound)
      }
    }
  }
} 

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

import com.softwaremill.modemconnector.FrameUtils
import org.scalatest.{BeforeAndAfter, FlatSpec, Matchers}

class AX25FrameSpec extends FlatSpec with Matchers with BeforeAndAfter {

  "A simple AX25Frame" should "contain decoded data" in {
    val ax25frame: AX25Frame = FrameUtils.ax25frameFromFile("/andrej.bin")
    new String(ax25frame.body) should equal("=4603.63N/01431.26E-Op. Andrej")
  }

  "A simple AX25Frame" should "contain sender callsign" in {
    val ax25frame: AX25Frame = FrameUtils.ax25frameFromFile("/andrej.bin")
    ax25frame.sender.callsign should equal("S57LN")
  }

  "A simple AX25Frame" should "contain destination callsign" in {
    val ax25frame: AX25Frame = FrameUtils.ax25frameFromFile("/andrej.bin")
    ax25frame.dest.callsign should equal("APRS")
  }

  "A simple AX25Frame" should "encode byte array" in {
    val ax25frame = AX25Frame(FrameUtils.ax25frameFromFile("/andrej.bin").toBytes)
    new String(ax25frame.body) should equal("=4603.63N/01431.26E-Op. Andrej")
    ax25frame.dest.callsign should equal("APRS")
    ax25frame.sender.callsign should equal("S57LN")
  }

  "An AX25Frame with digipiters" should "contain decoded data" in {
    val ax25frame = FrameUtils.ax25frameFromFile("/complexFrame.bin")
    new String(ax25frame.body) should equal("`'4< \\4>/]\"3k}145.500MHz qrv her=\r")
  }

  "An AX25Frame with digipiters" should "contain sender callsign" in {
    val ax25frame = FrameUtils.ax25frameFromFile("/complexFrame.bin")
    ax25frame.sender.toString should equal("OZ1IEP-9")
  }

  "An AX25Frame with digipiters" should "contain destination callsign" in {
    val ax25frame = FrameUtils.ax25frameFromFile("/complexFrame.bin")
    ax25frame.dest.toString should equal("U4TQ33")
  }

  "An AX25Frame with digipiters" should "contain digipiters" in {
    val ax25frame = FrameUtils.ax25frameFromFile("/complexFrame.bin")
    ax25frame.digipeaters.map(_.toString).toSeq should contain theSameElementsInOrderAs List("OZ6DIA-2", "OZ4DIA-2", "OZ4DIE-2")
  }

  "An AX25Frame with digipiters" should "encode byte array" in {
    val ax25frame = AX25Frame(FrameUtils.ax25frameFromFile("/complexFrame.bin").toBytes)
    ax25frame.digipeaters.map(_.toString).toSeq should contain theSameElementsInOrderAs List("OZ6DIA-2", "OZ4DIA-2", "OZ4DIE-2")
    ax25frame.dest.toString should equal("U4TQ33")
    ax25frame.sender.toString should equal("OZ1IEP-9")
    new String(ax25frame.body) should equal("`'4< \\4>/]\"3k}145.500MHz qrv her=\r")
  }

} 

//设置package包名称以及导入依赖的类
package hu.blackbelt.cd.bintray.deploy

import java.io.{File, FileInputStream}
import java.util.Properties

import org.scalatest.{BeforeAndAfter, Suite}

trait Creds extends BeforeAndAfter {
  this: Suite =>

  def fillFromEnv(prop: Properties) = {
    def put(key: String) = sys.env.get(key.replace('.','_')).map(prop.put(key.replace('_','.'), _))
    put(Access.aws_accessKeyId)
    put(Access.aws_secretKey)
    put(Access.bintray_organization)
    put(Access.bintray_user)
    put(Access.bintray_apikey)
  }

  before {
    import scala.collection.JavaConverters._
    val prop = new Properties()
    val propsFile = new File("env.properties")
    if (propsFile.exists()) {
      prop.load(new FileInputStream(propsFile))
    } else {
      fillFromEnv(prop)
    }
    prop.entrySet().asScala.foreach {
      (entry) => {
        sys.props += ((entry.getKey.asInstanceOf[String], entry.getValue.asInstanceOf[String]))
      }
    }
  }


} 

//设置package包名称以及导入依赖的类
package org.invisibletech.datasciencefromscratch

import DataSciencester._

import org.scalatest.FunSpec
import org.scalatest.BeforeAndAfter

class CompiledUserDirectorySpec extends FunSpec with BeforeAndAfter {
  var friendships: List[(Int, Int)] = _

  var users: List[User] = _

  before {
    friendships = List((0, 1))
    users = List(
      Map("id" -> 0, "name" -> "Hero"),
      Map("id" -> 1, "name" -> "Dunn"))
  }

  describe("Relations can be made bidirectional") {
    it("should show graph edge both ways") {
      val result = CompiledUserDirectory(users, friendships).createBiDirectionalRelations(List((1, 2)))

      assert(result == List((1, 2), (2, 1)))
    }
    it("will produce duplicates if 1 way relationships repeat relations") {
      val result = CompiledUserDirectory(users, friendships).createBiDirectionalRelations(List((1, 2), (2, 1)))

      assert(result == List((1, 2), (2, 1), (2, 1), (1, 2)))
    }
  }

  describe("We should be able to establish friendships immutably and with delayed evaluation") {
    it("should allow following friends from myself and back again") {
      val result = CompiledUserDirectory(users, friendships)

      assert(result.usersWithFriends.size == 2)

      val herosFriends: List[scala.Function0[CompiledUser]] = result.usersWithFriends(0).friends
      assert(herosFriends.size == 1)

      val dunnsFriends: List[scala.Function0[CompiledUser]] = result.usersWithFriends(1).friends
      assert(dunnsFriends.size == 1)
    }
  }

} 

//设置package包名称以及导入依赖的类
package uk.pkerrigan.dmarcparser

import org.scalatest.{BeforeAndAfter, FlatSpec}
import uk.pkerrigan.dmarcparser.report._

import scala.io.Source

class EmailParserSpec extends FlatSpec with BeforeAndAfter with ParserTrait {

  val dummyFeedback = Feedback(1.0, ReportMetadata("", "", "", "", DateRange(1,1), List()), PolicyPublished("", AlignmentRelaxed, AlignmentRelaxed, DispositionNone, DispositionNone, 0, ""), List())
  val emailParser = new EmailParser(this)
  var passedToParser: String = ""

  before {
    passedToParser = ""
  }

  "An email with a zip file" should "invoke the DMARC parser with unzipped contents" in {
    val result = emailParser.parseEmail(Source.fromResource("test.zip.eml").mkString)
    assert(passedToParser == "Test zip file")
    assert(result.get == dummyFeedback)
  }

  "An email with a gzip file" should "invoke the DMARC parser with unzipped contents" in {
    val result = emailParser.parseEmail(Source.fromResource("test.gz.eml").mkString)
    assert(passedToParser == "Test gzip file")
    assert(result.get == dummyFeedback)
  }

  "An email with a an unrecognised attachment" should "not invoke the DMARC parser" in {
    val result = emailParser.parseEmail(Source.fromResource("test.txt.eml").mkString)
    assert(passedToParser == "")
    assert(result.isEmpty)
  }

  "An email with no attachment" should "not invoke the DMARC parser" in {
    val result = emailParser.parseEmail(Source.fromResource("test.none.eml").mkString)
    assert(passedToParser == "")
    assert(result.isEmpty)
  }

  override def parse(rawReport: String): Feedback = {
    passedToParser = rawReport.trim
    dummyFeedback
  }
} 

//设置package包名称以及导入依赖的类
package com.atomist.rug.function.github

import com.atomist.source.ArtifactSourceException
import com.atomist.source.git.GitHubServices
import com.atomist.source.git.domain.Issue
import com.typesafe.scalalogging.LazyLogging
import org.scalatest.{BeforeAndAfter, BeforeAndAfterAll, FlatSpec, Matchers}

import scala.util.{Failure, Success, Try}

abstract class GitHubFunctionTest(val oAuthToken: String, val apiUrl: String = "")
  extends FlatSpec
    with Matchers
    with BeforeAndAfter
    with BeforeAndAfterAll
    with LazyLogging {

  import TestConstants._

  protected val ghs = GitHubServices(oAuthToken, apiUrl)

  override protected def afterAll(): Unit = cleanUp()

  
  private def cleanUp() =
    Try(ghs.searchRepositories(Map("q" -> s"user:$TestOrg in:name $TemporaryRepoPrefix", "per_page" -> "100"))) match {
      case Success(repos) => repos.items.foreach(repo => ghs.deleteRepository(repo.name, repo.ownerName))
      case Failure(e) => throw ArtifactSourceException(e.getMessage, e)
    }

  private def getRepoName = s"$TemporaryRepoPrefix${System.nanoTime}"

  protected def createIssue(repo: String, owner: String): Issue =
    ghs.createIssue(repo, owner, "test issue", "Issue body")
} 

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

import state._
import org.scalatest.mockito.MockitoSugar
import org.scalatest.BeforeAndAfter
import org.junit.runner.RunWith
import org.scalatest.OneInstancePerTest
import org.scalatest.FlatSpec
import org.scalatest.Matchers
import org.scalatest.junit.JUnitRunner
import hanabi._
import hanabi.ai._
import org.scalatest.prop.PropertyChecks

@RunWith(classOf[JUnitRunner])
class RulesSpec extends FlatSpec with Matchers with MockitoSugar with OneInstancePerTest with BeforeAndAfter
    with PropertyChecks with HanabiDomain {
  import SimpleRules._
  import Cards._

  "simple rules" should "have proper number of cards" in {
    forAll { c: Card =>
      whenever(c.level == 1) {
        count(c) shouldBe 3
      }
    }
    forAll { c: Card =>
      whenever(c.level == 5) {
        count(c) shouldBe 1
      }
    }
    forAll { c: Card =>
      whenever(c.level > 1 && c.level < 5) {
        count(c) shouldBe 2
      }
    }
  }

  implicit override val generatorDrivenConfig = PropertyCheckConfiguration(
    minSuccessful = 100,
    maxDiscardedFactor = 15)
} 

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

import state._
import org.scalatest.mockito.MockitoSugar
import org.scalatest.BeforeAndAfter
import org.junit.runner.RunWith
import org.scalatest.OneInstancePerTest
import org.scalatest.FlatSpec
import org.scalatest.Matchers
import org.scalatest.junit.JUnitRunner
import hanabi._
import hanabi.ai._

@RunWith(classOf[JUnitRunner])
class PlayerSpec extends FlatSpec with Matchers with MockitoSugar with OneInstancePerTest with BeforeAndAfter {
  import SimpleRules._

  val player = new Player {
    def nextMove(s: GameState) = ???
  }

  val onesToThrees = allCards.filter(_.level < 4)
  val foursFives = allCards.filter(_.level >= 4)
  val (fives, allExceptFives) = allCards.partition(_.level == 5)

  "a player" should "guess its possible cards with no clues" in {
    val possible = player.possibleCards(allExceptFives, 5)
    for (p <- 0 to 4)
      possible(p) should contain theSameElementsAs fives
  }

  it should "guess its possible cards with a single clue" in {
    val possible = player.possibleCards(onesToThrees, 5, Seq(LevelClue(level = 5, position = 3)))
    possible(1) should contain theSameElementsAs allCards.filter(_.level == 5)
  }

  val clues = Seq(
    LevelClue(position = 3, level = 5),
    ColorClue(position = 3, color = Blue))

  it should "guess its possible cards with a 2 clues on the same card" in {
    val possible = player.possibleCards(onesToThrees, 5, clues)
    possible(3) should contain theSameElementsAs Seq(Card(5, Blue))
  }

  //  it should "guess its possible cards with a 2 clues on another card" in {
  //    player.possibleCards(4, onesToThrees, clues) should
  //      contain theSameElementsAs (foursFives diff Seq(Card(5, Blue)))
  //  }
} 

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

import state._

import org.scalatest.mockito.MockitoSugar
import org.scalatest.BeforeAndAfter
import org.junit.runner.RunWith
import org.scalatest.OneInstancePerTest
import org.scalatest.FlatSpec
import org.scalatest.Matchers
import org.scalatest.junit.JUnitRunner
import hanabi._
import hanabi.Card._
import hanabi.ai._
import SimpleRules._

@RunWith(classOf[JUnitRunner])
class DeckSpec extends FlatSpec
    with Matchers with MockitoSugar with OneInstancePerTest with BeforeAndAfter
    with StackedDeck {

  "a Deck" should "distribute cards one by one" in {
    val (h, rest) = Deck(allCards.distinct).deal(hands = 5, cardsPerHand = 5)
    val hnds = h.toVector
    println(hnds)
    def expected(lvl: Int) = allColors.map(c => Card(lvl, c)).toVector
    for {
      h <- 0 until 5
      (c, i) <- hnds(h).cards.zipWithIndex
    } c.level should be(5 - i)
  }

  //  it should "allow to try to draw from an empty deck an return unchanged deck" in {
  //  }

} 

//设置package包名称以及导入依赖的类
package com.unity.analytics.spark.utils.parquet

import org.apache.spark.sql.SQLContext
import org.apache.spark.{SparkConf, SparkContext}
import org.scalatest.{BeforeAndAfter, BeforeAndAfterAll, FunSuite}


class BaseTest extends FunSuite with BeforeAndAfterAll with BeforeAndAfter {
  private val master = "local[*]"
  private val appName = "example-spark"
  private val conf = new SparkConf()
    .setMaster(master)
    .setAppName(appName)
    .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
    .set("spark.task.maxFailures", "1")


  protected var sc: SparkContext = _
  protected var sqlContext: SQLContext = _

  protected def getSQLContext(): SQLContext = sqlContext


  override def beforeAll() {
    System.clearProperty("spark.driver.port")
    System.clearProperty("spark.hostPort")
    sc = new SparkContext(conf)
    sc.setLogLevel("ERROR")
    sqlContext = new SQLContext(sc)
  }

  override def afterAll() {
    if (sc != null) {
      sc.stop()
      sc = null
      System.clearProperty("spark.driver.port")
      System.clearProperty("spark.hostPort")
    }
  }
} 

//设置package包名称以及导入依赖的类
package mesosphere.marathon.core.task.bus.impl

import mesosphere.marathon.core.instance.TestInstanceBuilder
import mesosphere.marathon.core.instance.update.InstanceChange
import mesosphere.marathon.core.task.bus.{ TaskBusModule, TaskStatusUpdateTestHelper }
import mesosphere.marathon.state.PathId
import org.scalatest.{ BeforeAndAfter, FunSuite }

class TaskStatusModuleTest extends FunSuite with BeforeAndAfter {
  var module: TaskBusModule = _
  before {
    module = new TaskBusModule
  }

  test("observable forAll includes all app status updates") {
    var received = List.empty[InstanceChange]
    module.taskStatusObservables.forAll.foreach(received :+= _)

    TaskStatusUpdateTestHelper.running()
    val aa: InstanceChange = TaskStatusUpdateTestHelper.running(instance("/a/a")).wrapped
    val ab: InstanceChange = TaskStatusUpdateTestHelper.running(instance("/a/b")).wrapped
    module.taskStatusEmitter.publish(aa)
    module.taskStatusEmitter.publish(ab)
    assert(received == List(aa, ab))
  }

  test("observable forAll unsubscribe works") {
    var received = List.empty[InstanceChange]
    val subscription = module.taskStatusObservables.forAll.subscribe(received :+= _)
    subscription.unsubscribe()
    val aa: InstanceChange = TaskStatusUpdateTestHelper.running(instance("/a/a")).wrapped
    module.taskStatusEmitter.publish(aa)
    assert(received == List.empty)
  }

  test("observable forAppId includes only app status updates") {
    var received = List.empty[InstanceChange]
    module.taskStatusObservables.forRunSpecId(PathId("/a/a")).foreach(received :+= _)
    val aa: InstanceChange = TaskStatusUpdateTestHelper.running(instance("/a/a")).wrapped
    val ab: InstanceChange = TaskStatusUpdateTestHelper.running(instance("/a/b")).wrapped
    module.taskStatusEmitter.publish(aa)
    module.taskStatusEmitter.publish(ab)
    assert(received == List(aa))
  }

  test("observable forAppId unsubscribe works") {
    var received = List.empty[InstanceChange]
    val subscription = module.taskStatusObservables.forRunSpecId(PathId("/a/a")).subscribe(received :+= _)
    subscription.unsubscribe()
    val aa: InstanceChange = TaskStatusUpdateTestHelper.running(instance("/a/a")).wrapped
    module.taskStatusEmitter.publish(aa)
    assert(received == List.empty)
  }

  private[this] def instance(appId: String) = TestInstanceBuilder.newBuilder(PathId(appId)).addTaskStaged().getInstance()

} 

//设置package包名称以及导入依赖的类
package com.groupon.dse.kafka.cluster.impl

import com.groupon.dse.configs.KafkaServerConfig
import com.groupon.dse.testutils.{EmbeddedKafka, TestDefaults}
import com.groupon.dse.zookeeper.ZkClientBuilder
import kafka.producer.{Producer, ProducerConfig}
import org.I0Itec.zkclient.ZkClient
import org.scalatest.{BeforeAndAfter, FlatSpec}

class ClusterImplTest extends FlatSpec with BeforeAndAfter {

  val kafkaTopic = TestDefaults.TestTopic
  val zkConnTimeout = 10000
  val zkSessionTimeout = 10000
  var producer: Producer[String, Array[Byte]] = _
  var embeddedKafka: EmbeddedKafka = _
  var cluster: ClusterImpl = _
  var zkConnect: String = _
  var kafkaServerConfigs: KafkaServerConfig = _
  var zkClient: ZkClient = _

  before {
    embeddedKafka = new EmbeddedKafka
    embeddedKafka.startCluster()
    producer = new Producer[String, Array[Byte]](new ProducerConfig(embeddedKafka.kafkaProducerProperties))
    zkConnect = embeddedKafka.zkServer.connectString
    kafkaServerConfigs = TestDefaults.testKafkaServerConfig(zkConnect)
    cluster = new ClusterImpl(kafkaServerConfigs)
    zkClient = ZkClientBuilder(zkConnect, zkConnTimeout, zkSessionTimeout)
  }

  after {
    zkClient.close()
    embeddedKafka.stopCluster()
  }

  "The topic list" must "have size 0 before producing" in {
    assert(cluster.topics(zkClient).size == 0)
  }

  "The topic list" must "have size 1 after producing" in {
    embeddedKafka.sendMessage(4, producer, kafkaTopic)
    assert(cluster.topics(zkClient).size == 1)
  }

  "The number of partitions for a topic" should "be 1 for 1 valid topic" in {
    embeddedKafka.sendMessage(4, producer, kafkaTopic)
    assert(cluster.partitions(List(kafkaTopic), zkClient).size == 1)
  }

  "The number of partitions" should "be 0 for an invalid topic" in {
    embeddedKafka.sendMessage(4, producer, kafkaTopic)
    assert(cluster.partitions(List("invalid_topic"), zkClient).size == 0)
  }

  "The number of partitions" should "be 1 for a valid and invalid topic" in {
    embeddedKafka.sendMessage(4, producer, kafkaTopic)
    assert(cluster.partitions(List(kafkaTopic, "invalid_topic"), zkClient).size == 1)
  }

} 

//设置package包名称以及导入依赖的类
package com.groupon.dse.kafka.topic

import java.util.Properties

import com.groupon.dse.configs.AppConfigs
import com.groupon.dse.kafka.topic.TopicFetcherBuilder.InvalidTopicFetcherException
import org.scalatest.{BeforeAndAfter, FlatSpec}

class TopicFetcherBuilder$Test extends FlatSpec with BeforeAndAfter {

  var properties: Properties = _
  before {
    properties = new Properties()
  }

  "The topic Fetcher builder" should "return the appropriate TopicFetcher" in {
    properties.setProperty("topics", "sometopic")
    assert(TopicFetcherBuilder(properties).getClass == classOf[LocalTopicFetcher])
    properties.setProperty("topics.fetcher.type", "HDFS")
    properties.setProperty("topics.fetcher.hdfs.source", "/path/in/hdfs")
    assert(TopicFetcherBuilder(properties).getClass == classOf[HdfsJsonTopicFetcher])
    properties.setProperty("topics.fetcher.type", "LOCAL")
    assert(TopicFetcherBuilder(properties).getClass == classOf[LocalTopicFetcher])
  }

  "the topic fetcher builder" should "throw an exception if invalid type is provided" in {
    intercept[InvalidTopicFetcherException] {
      properties.setProperty("topics.fetcher.type", "INVALID")
      TopicFetcherBuilder(properties)
    }
  }

  "the topic fetcher" should "throw an exception if there are any missing configs" in {
    intercept[AppConfigs.MissingConfigException] {
      TopicFetcherBuilder(properties)
    }

    intercept[AppConfigs.MissingConfigException] {
      properties.setProperty("topics.fetcher.type", "HDFS")
      TopicFetcherBuilder(properties)
    }
  }
} 

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

import org.scalatest.{BeforeAndAfter, Matchers, FlatSpec}
import CompilerTestMatchers.passIntegrationTest

class IntegrationTest extends FlatSpec with Matchers with BeforeAndAfter {

  val TestDir = "mj-test/run/"
  val testFiles = new java.io.File(TestDir).listFiles.filter(_.getName.endsWith(".mj")).sortBy(_.getName.toLowerCase)

  val weirdFirmTests = Set("prometheus3.mj")

  for (file <- testFiles) {
    if (!weirdFirmTests(file.getName))
      file.getName should "produce correct output with the FIRM backend" in {
        file.getPath should passIntegrationTest(Seq("--compile-firm"))
      }

    file.getName should "produce correct output with our backend" in {
      file.getPath should passIntegrationTest(Seq())
    }
  }
} 

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

import mjis.CompilerTestMatchers._
import org.scalatest.{BeforeAndAfter, Matchers, FlatSpec}

class InterpreterTest  extends FlatSpec with Matchers with BeforeAndAfter {

  val TestDir = "mj-test/run/"
  val testFiles = new java.io.File(TestDir).listFiles.filter(_.getName.endsWith(".mj")).sortBy(_.getName.toLowerCase)

  val slowTests = List("fannkuch.mj", "fixedpoint.mj", "mandelbrot.mj", "mandelbrot-mutable.mj", "MMul.mj", "Pi.mj", "RecursiveArraySum.mj", "Sorter.mj")
  val failingTests = List("Simon_048.mj")
  val ignoredTests = slowTests ++ failingTests

  for (file <- testFiles if !ignoredTests.contains(file.getName)) {
    file.getName should "produce correct output with the interpreter" in {
      file.getPath should passInterpreterTest
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.scalawag.jibe.backend.ubuntu

import org.scalatest.{BeforeAndAfter, BeforeAndAfterAll, FunSpec, Matchers}
import org.scalawag.jibe.mandate.command._

class IsUserInAllGroupsTest extends FunSpec with Matchers with BeforeAndAfter with BeforeAndAfterAll with VagrantTest {
  val groupA = "groupA"
  val groupB = "groupB"
  val groupC = "groupC"
  val userA = "userA"

  override protected def beforeAll() = {
    rootCommander.execute(CreateOrUpdateGroup(Group(groupA)))
    rootCommander.execute(CreateOrUpdateGroup(Group(groupB)))
    rootCommander.execute(CreateOrUpdateGroup(Group(groupC)))
    rootCommander.execute(DeleteUser(userA))
    rootCommander.execute(CreateOrUpdateUser(User(userA)))
  }

  before {
    rootSsh.exec(log, s"usermod $userA -G ''") shouldBe 0
  }

  it("should detect presence of user in a single group") {
    rootSsh.exec(log, s"usermod $userA -G '$groupA'") shouldBe 0

    rootCommander.execute(IsUserInAllGroups(userA, Seq(groupA))) shouldBe true
  }

  it("should detect presence of user in multiple groups") {
    Some(rootSsh.exec(log, s"usermod $userA -G '$groupA,$groupB'")) should contain oneOf(0, 6)

    rootCommander.execute(IsUserInAllGroups(userA, Seq(groupA, groupB))) shouldBe true
  }

  it("should detect presence of the user's primary group") {
    rootCommander.execute(IsUserInAllGroups(userA, Seq(userA))) shouldBe true
  }

  it("should detect absence of the user from a single group") {
    rootCommander.execute(IsUserInAllGroups(userA, Seq(groupA))) shouldBe false
  }

  it("should detect absence of the user from a at least one specified group") {
    rootSsh.exec(log, s"usermod $userA -G '$groupA'") shouldBe 0

    rootCommander.execute(IsUserInAllGroups(userA, Seq(groupA, groupB))) shouldBe false
  }
} 

//设置package包名称以及导入依赖的类
package org.scalawag.jibe.backend.ubuntu

import org.scalatest.{BeforeAndAfter, BeforeAndAfterAll, FunSpec, Matchers}
import org.scalawag.jibe.mandate.command._

class AddUserToGroupsTest extends FunSpec with Matchers with BeforeAndAfter with BeforeAndAfterAll with VagrantTest {
  val groupA = "groupA"
  val groupB = "groupB"
  val groupC = "groupC"
  val userA = "userA"

  override protected def beforeAll() = {
    rootCommander.execute(CreateOrUpdateGroup(Group(groupA)))
    rootCommander.execute(CreateOrUpdateGroup(Group(groupB)))
    rootCommander.execute(CreateOrUpdateGroup(Group(groupC)))
    rootCommander.execute(DeleteUser(userA))
    rootCommander.execute(CreateOrUpdateUser(User(userA)))
  }

  before {
    rootSsh.exec(log, s"usermod $userA -G ''") shouldBe 0
  }

  it("should add user to a single group") {
    commander.execute(IsUserInAllGroups(userA, Set(groupA))) shouldBe false

    rootCommander.execute(AddUserToGroups(userA, Set(groupA)))

    commander.execute(IsUserInAllGroups(userA, Set(groupA))) shouldBe true
  }

  it("should add user to a multiple groups") {
    commander.execute(IsUserInAllGroups(userA, Set(groupA, groupB))) shouldBe false

    rootCommander.execute(AddUserToGroups(userA, Set(groupA, groupB)))

    commander.execute(IsUserInAllGroups(userA, Set(groupA, groupB))) shouldBe true
  }

  it("should add user to some new groups while leaving old ones alone") {
    rootCommander.execute(AddUserToGroups(userA, Set(groupA)))
    commander.execute(IsUserInAllGroups(userA, Set(groupA, groupB))) shouldBe false

    rootCommander.execute(AddUserToGroups(userA, Set(groupA, groupB)))

    commander.execute(IsUserInAllGroups(userA, Set(groupA, groupB))) shouldBe true
  }

  it("should leave user in all existing groups") {
    rootCommander.execute(AddUserToGroups(userA, Set(groupA, groupB)))
    commander.execute(IsUserInAllGroups(userA, Set(groupA, groupB))) shouldBe true

    rootCommander.execute(AddUserToGroups(userA, Set(groupA, groupB)))

    commander.execute(IsUserInAllGroups(userA, Set(groupA, groupB))) shouldBe true
  }

  it("should throw when not run as root") {
    an [Exception] should be thrownBy commander.execute(AddUserToGroups(userA, Set(groupA)))
  }
} 

//设置package包名称以及导入依赖的类
package pl.writeonly.babel.beans

import org.scalatest.FunSuite
import org.scalatest.BeforeAndAfter
import pl.writeonly.babel.mediators._
import pl.writeonly.babel.entities.Lang
import com.weiglewilczek.slf4s.Logging

class LernuSuite extends FunSuite with BeforeAndAfter with Logging {
  val lernuService = AppContext.bean[LernuBean]("lernuBean")

  before {
  }

  test("lernuService.searchs"){
    
    logger.debug("lernuService.searchs")
    lernuService.searchAsynAll(List("eo"), new Lang("eo"), List (new Lang("eo")))
    assert(1 == 2)
  }
} 

//设置package包名称以及导入依赖的类
package it.agilelab.bigdata.wasp.consumers

import java.nio.file.Files

import akka.actor.ActorSystem
import org.apache.spark.streaming.{Seconds, StreamingContext}
import org.apache.spark.{SparkConf, SparkContext}
import org.apache.spark.sql.SQLContext
import org.scalatest.concurrent.ScalaFutures
import org.scalatest.{ConfigMap, BeforeAndAfterAllConfigMap, BeforeAndAfter, FlatSpec}


class SparkFlatSpec extends FlatSpec with BeforeAndAfterAllConfigMap with ScalaFutures  {
  private val master = "local[2]"
  private val appName = "example-spark-streaming"
  private val batchDuration = Seconds(1)
  private val checkpointDir = Files.createTempDirectory(appName).toString

  protected var ssc: StreamingContext = _
  protected var sc: SparkContext = _
  protected var sqlContext: SQLContext = _
  protected var actorSystem = ActorSystem()


  override def beforeAll(cm: ConfigMap) {
    val sparkConf: SparkConf = new SparkConf()
      .setMaster("local[2]").setAppName("Instant Matching")

    ssc = new StreamingContext(sparkConf, batchDuration)

    sc = ssc.sparkContext

    sqlContext = new SQLContext(sc)
  }

  override def afterAll(cm: ConfigMap) {
    if (ssc != null) {
      ssc.awaitTerminationOrTimeout(1000)
      ssc.stop()
    }
    if (sc != null) {
      sc.stop()
      sc.clearCallSite()
    }
    actorSystem.shutdown()
  }
}