//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentmapping.support

import com.codahale.metrics.MetricRegistry
import com.kenshoo.play.metrics.Metrics
import org.scalatest.Matchers
import org.scalatestplus.play.OneAppPerSuite

import scala.collection.JavaConversions

trait MetricTestSupport {
  self: OneAppPerSuite with Matchers =>

  private var metricsRegistry: MetricRegistry = _

  def givenCleanMetricRegistry(): Unit = {
    val registry = app.injector.instanceOf[Metrics].defaultRegistry
    for (metric <- JavaConversions.asScalaIterator[String](registry.getMetrics.keySet().iterator())) {
      registry.remove(metric)
    }
    metricsRegistry = registry
  }

  def timerShouldExistsAndBeenUpdated(metric: String): Unit = {
    metricsRegistry.getTimers.get(s"Timer-$metric").getCount should be >= 1L
  }

} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentaccesscontrol.support

import com.codahale.metrics.MetricRegistry
import com.kenshoo.play.metrics.Metrics
import org.scalatest.Matchers
import org.scalatestplus.play.OneAppPerSuite

import scala.collection.JavaConversions

trait MetricTestSupport {
  self: OneAppPerSuite with Matchers =>

  private var metricsRegistry: MetricRegistry = _

  def givenCleanMetricRegistry(): Unit = {
    val registry = app.injector.instanceOf[Metrics].defaultRegistry
    for (metric <- JavaConversions.asScalaIterator[String](registry.getMetrics.keySet().iterator())) {
      registry.remove(metric)
    }
    metricsRegistry = registry
  }

  def timerShouldExistsAndBeenUpdated(metric: String): Unit = {
    metricsRegistry.getTimers.get(s"Timer-$metric").getCount should be >= 1L
  }

} 

//设置package包名称以及导入依赖的类
package uk.gov.hmrc.agentrelationships.support

import com.codahale.metrics.MetricRegistry
import com.kenshoo.play.metrics.Metrics
import org.scalatest.{Matchers, Suite}
import play.api.Application

import scala.collection.JavaConversions

trait MetricTestSupport {
  self: Suite with Matchers =>

  def app: Application

  private var metricsRegistry: MetricRegistry = _

  def givenCleanMetricRegistry(): Unit = {
    val registry = app.injector.instanceOf[Metrics].defaultRegistry
    for (metric <- JavaConversions.asScalaIterator[String](registry.getMetrics.keySet().iterator())) {
      registry.remove(metric)
    }
    metricsRegistry = registry
  }

  def timerShouldExistsAndBeenUpdated(metric: String): Unit = {
    metricsRegistry.getTimers.get(s"Timer-$metric").getCount should be >= 1L
  }

} 

//设置package包名称以及导入依赖的类
package com.github.madoc.create_sbt_project.io

import java.nio.charset.Charset
import java.nio.file.Files

import com.google.common.jimfs.{Configuration, Jimfs}

import scala.collection.JavaConversions

class TestFileSystemSupport(workingDirectory:String="/home/user/projectdir", userHome:String="/home/user")
extends FileSystemSupport.Default(Jimfs.newFileSystem(Configuration.unix().toBuilder.setWorkingDirectory(workingDirectory).build())) {
  private var errorOutput = ""
  private var standardOutput = ""
  private val lock = new Object

  locally {mkdirs(workingDirectory)}

  def getErrorOutput:String = lock synchronized errorOutput
  def getStandardOutput:String = lock synchronized standardOutput
  def setUserPreferencesFileContents(contents:String) =
    outputToFile(contents, userPreferencesFilePath, Charset forName "utf-8")(new Output[String] {
      def apply(the:String)(write:Write) = write(the)
    })
  def getFileContents(path:String, charset:Charset=Charset forName "utf-8"):String =
    JavaConversions.asScalaBuffer(Files.readAllLines(fs getPath path, charset)).mkString("\n")

  override protected def userHomeDirectory = userHome
  override protected def systemErr = new Appendable {
    def append(csq:CharSequence) = {lock synchronized {errorOutput += csq.toString}; this}
    def append(csq:CharSequence, start:Int, end:Int) = append(csq subSequence (start, end))
    def append(c:Char) = append(c toString)
  }
  override protected def systemOut = new Appendable {
    def append(csq:CharSequence) = {lock synchronized {standardOutput += csq.toString}; this}
    def append(csq:CharSequence, start:Int, end:Int) = append(csq subSequence (start, end))
    def append(c:Char) = append(c toString)
  }
} 

//设置package包名称以及导入依赖的类
package yuck.util.testing

import scala.collection.JavaConversions

import java.util.concurrent.Callable
import yuck.util.logging.LazyLogger


class ProcessRunner(logger: LazyLogger, commandLine: Seq[String]) extends Callable[(List[String], List[String])] {

    override def call = {
        val processBuilder = new java.lang.ProcessBuilder(JavaConversions.seqAsJavaList(commandLine))
        logger.log(JavaConversions.asScalaBuffer(processBuilder.command).toIterator.mkString(" "))
        val process = processBuilder.start
        val stdout = scala.io.Source.fromInputStream(process.getInputStream)
        val stderr = scala.io.Source.fromInputStream(process.getErrorStream)
        val outputLines = stdout.mkString.lines.toList
        val (errorLines, warningLines) = stderr.mkString.lines.toList.partition(_.toLowerCase.contains("error"))
        outputLines.foreach(logger.log(_))
        warningLines.foreach(logger.log(_))
        errorLines.foreach(logger.log(_))
        (outputLines, errorLines)
    }

} 

//设置package包名称以及导入依赖的类
package fhj.swengb.project.courseware.components

import javafx.beans.value.ObservableValue
import javafx.collections.{FXCollections, ObservableList}
import javafx.scene.control.TableColumn
import javafx.util.Callback
import scala.collection.JavaConversions

object JfxUtils {

  type TCDF[S, T] = TableColumn.CellDataFeatures[S, T]

  import JavaConversions._

  def mkObservableList[T](collection: Iterable[T]): ObservableList[T] = {
    FXCollections.observableList(new java.util.ArrayList[T](collection))
  }

  private def mkCellValueFactory[S, T](fn: TCDF[S, T] => ObservableValue[T]): Callback[TCDF[S, T], ObservableValue[T]] = {
    new Callback[TCDF[S, T], ObservableValue[T]] {
      def call(cdf: TCDF[S, T]): ObservableValue[T] = fn(cdf)
    }
  }

  def initTableViewColumnCellValueFactory[S, T](tc: TableColumn[S, T], f: S => Any): Unit = {
    tc.setCellValueFactory(mkCellValueFactory(cdf => f(cdf.getValue).asInstanceOf[ObservableValue[T]]))
  }

} 

//设置package包名称以及导入依赖的类
package temportalist.origin.api.common.lib.loader

import net.minecraftforge.fml.common.discovery.ASMDataTable
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent

import scala.collection.mutable.ListBuffer
import scala.collection.{JavaConversions, mutable}


class AnnotationLoader[C, T](private val annotation: Class[C], private val instance: Class[T]) {

	private val classInstances = mutable.Map[Class[_ <: T], mutable.Map[String, AnyRef]]()
	private var mapKeys = ListBuffer[Class[_ <: T]]()

	final def loadAnnotations(event: FMLPreInitializationEvent): Unit = {
		this.findInstanceClasses(event.getAsmData)
	}

	final def findInstanceClasses(asmData: ASMDataTable): Unit = {
		val annotationName = this.annotation.getName
		val dataAnnotatedClasses = JavaConversions.asScalaSet(asmData.getAll(annotationName))
		for (dataAnnotatedClass <- dataAnnotatedClasses) {
			try {
				val annotatedClass = Class.forName(dataAnnotatedClass.getClassName)
				val annotatedClassAsSub = annotatedClass.asSubclass(this.instance)
				val annotationInfo = JavaConversions.mapAsScalaMap(dataAnnotatedClass.getAnnotationInfo)
				this.classInstances.put(annotatedClassAsSub, annotationInfo)
				this.onAnnotationClassFound(annotatedClassAsSub, annotationInfo)
			}
			catch {
				case e: Exception =>
					e.printStackTrace()
			}
		}
		this.mapKeys ++= this.classInstances.keySet.toSeq.sortWith(this.keySorter)
	}

	def keySorter(a: Class[_ <: T], b: Class[_ <: T]): Boolean = a.getSimpleName < b.getSimpleName

	def onAnnotationClassFound[I <: T](implementer: Class[I], info: mutable.Map[String, AnyRef]): Unit = {}

	final def getClassInstances: Iterable[Class[_ <: T]] = this.mapKeys

	final def getAnnotationInfo(clazz: Class[_ <: T]) =
		this.classInstances.getOrElse(clazz, Map[String, AnyRef]())

} 

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

import com.google.api.client.http.{GenericUrl, HttpRequestFactory, HttpResponse, UrlEncodedContent}
import com.wix.pay.PaymentErrorException

import scala.collection.JavaConversions
import scala.concurrent.duration.Duration
import scala.util.Try

class AccessTokenRetriever(requestFactory: HttpRequestFactory,
                           connectTimeout: Option[Duration] = None,
                           readTimeout: Option[Duration] = None,
                           numberOfRetries: Int = 0,
                           endpointUrl: String) {
  
  def retrieveAccessToken(clientId: String, clientSecret: String): Try[String] = {
    Try {
      val params = MercadopagoHelper.createOauthRequest(clientId, clientSecret)

      val httpRequest = requestFactory.buildPostRequest(
        new GenericUrl(endpointUrl),
        new UrlEncodedContent(JavaConversions.mapAsJavaMap(params))
      )

      connectTimeout foreach (to => httpRequest.setConnectTimeout(to.toMillis.toInt))
      readTimeout foreach (to => httpRequest.setReadTimeout(to.toMillis.toInt))
      httpRequest.setNumberOfRetries(numberOfRetries)

      httpRequest.setThrowExceptionOnExecuteError(false)

      val httpResponse = httpRequest.execute()
      val responseJson = extractResponseAndClose(httpResponse)
      if (httpResponse.isSuccessStatusCode) {
        val oauthResponse = OauthResponseParser.parse(responseJson)
        oauthResponse.access_token
      } else {
        val oauthErrorResponse = OauthErrorResponseParser.parse(responseJson)
        throw PaymentErrorException(oauthErrorResponse.message)
      }
    }
  }

  private def extractResponseAndClose(httpResponse: HttpResponse): String = {
    try {
      httpResponse.parseAsString()
    } finally {
      httpResponse.ignore()
    }
  }
}