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

import java.io.{File, FileNotFoundException}
import tech.artemisia.TestSpec
import tech.artemisia.core.Keywords.Config
import tech.artemisia.core.TestEnv.TestOsUtil
import tech.artemisia.core.{Keywords, env}




class UtilSpec extends TestSpec {

  var os_util: TestOsUtil = _

  override def beforeEach(): Unit = {
    super.beforeEach()
    os_util = env.osUtil.asInstanceOf[TestOsUtil]
  }

  "The Util.readConfigFile" must "throw FileNotFoundException on non-existent file" in {
    intercept[FileNotFoundException] {
      Util.readConfigFile(new File("Some_Non_Existant_File.conf"))
    }
  }

  "Util.getGlobalConfigFileLocation" must s"must provide default value when is ${Config.GLOBAL_FILE_REF_VAR} not set" in {
    os_util.withSysVar(Map()) {
      val default_value = this.getClass.getResource("/code/code_with_simple_mysql_component.conf").getFile
      Util.getGlobalConfigFileLocation(default_value).get must equal(default_value)
    }
  }

  it must s"must give a None if ${Keywords.Config.GLOBAL_FILE_REF_VAR} not set and the default file doesn't exist" in {
    os_util.withSysVar(Map("foo2" -> "baz2")) {
      val default_value = "A_Non_Existant_File.conf"
      Util.getGlobalConfigFileLocation(default_value) must equal(None)
    }
  }

} 

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

import java.io.FileNotFoundException

import com.typesafe.config.{Config, ConfigFactory}
import net.ceedubs.ficus.Ficus._
import net.ceedubs.ficus.readers.ArbitraryTypeReader._
import net.jcazevedo.moultingyaml._
import scala.util.Try
import scala.io.Source.fromFile

// $COVERAGE-OFF$

case class TipConfig(owner: String, repo: String, personalAccessToken: String, label: String)

class TipConfigurationException(msg: String = "Missing TiP config. Please refer to README.") extends RuntimeException(msg)
class MissingPathConfigurationFile(msg: String = "Missing tip.yaml. Please refer to README") extends RuntimeException(msg)
class PathConfigurationSyntaxError(msg: String = "Bad syntax in tip.yaml. Please refer to README") extends RuntimeException(msg)

object Configuration {
  object TipYamlProtocol extends DefaultYamlProtocol { implicit val pathFormat = yamlFormat2(Path) }

  import TipYamlProtocol._

  val config: Config = ConfigFactory.load()
  val tipConfig = config.as[Option[TipConfig]]("tip").getOrElse(throw new TipConfigurationException)

  def readFile(filename: String): String =
    Option(getClass.getClassLoader.getResource(filename)).map {
      path => fromFile(path.getPath).mkString
    }.getOrElse(throw new FileNotFoundException(s"Path definition file not found on the classpath: $filename"))

  def readPaths(filename: String): List[Path] = Try(readFile(filename).parseYaml.convertTo[List[Path]]).recover {
    case e: FileNotFoundException => throw new MissingPathConfigurationFile
    case _ => throw new PathConfigurationSyntaxError
  }.get
}

// $COVERAGE-ON$ 

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

import java.io.FileNotFoundException

import com.badlogic.gdx.graphics.glutils.ShaderProgram
import com.github.gigurra.glasciia.impl.LoadFile


object Shader {

  def fromLocation(vertexShader: String, fragmentShader: String): ShaderProgram = {
    fromSourceCode(
      LoadFile(vertexShader).getOrElse(throw new FileNotFoundException(s"Could not find vertex shader source file '$vertexShader'")).readString(),
      LoadFile(fragmentShader).getOrElse(throw new FileNotFoundException(s"Could not find fragment shader source file '$fragmentShader'")).readString()
    )
  }

  def fromSourceCode(vertexShader: String, fragmentShader: String): ShaderProgram = {
    val out = new ShaderProgram(vertexShader, fragmentShader)
    if (!out.isCompiled)
      throw new IllegalArgumentException(s"Compilation of shader failed!: ${out.getLog}")
    out
  }
} 

//设置package包名称以及导入依赖的类
package com.chapter3.ScalaFP
import java.io.IOException
import java.io.FileReader
import java.io.FileNotFoundException
object TryCatch {
  def main(args: Array[String]) {
    try {
      val f = new FileReader("data/data.txt")
    } catch {
      case ex: FileNotFoundException => println("File not found exception")
      case ex: IOException => println("IO Exception") 
    } finally {
      println("Finally block always executes");
    }
  }
} 

//设置package包名称以及导入依赖的类
package org.hammerlab.test.resources

import java.io.FileNotFoundException
import java.lang.Thread.currentThread
import java.net.URL

object Url {
  def apply(path: String): URL =
    Option(
      currentThread()
        .getContextClassLoader
        .getResource(path)
    ) match {
      case Some(url) ? url
      case None ?
        throw new FileNotFoundException(
          s"Test resource not found: $path"
        )
    }
} 

//设置package包名称以及导入依赖的类
package org.hammerlab.test.resources

import java.io.FileNotFoundException
import org.hammerlab.test.Suite

class ResourcesTest extends Suite {
  test("non-existent url") {
    intercept[FileNotFoundException] {
      Url("foo")
    }
  }

  test("non-existent file") {
    intercept[FileNotFoundException] {
      File("foo")
    }
  }

  test("read file") {
    File("a/numbers").read should be(
      """1
        |2
        |3
        |"""
      .stripMargin
    )
  }

  test("read file bytes") {
    File("a/numbers").readBytes should be(
      """1
        |2
        |3
        |"""
      .stripMargin
      .getBytes
    )
  }
} 

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

import java.io.FileNotFoundException
import java.io.IOException
import java.io.FileReader

object ExceptionUtils {

  def main(args: Array[String]) {

    try {
      val f = new FileReader("input.txt")
    } catch {
      case ex: FileNotFoundException => {
        println("FileNotFoundException"+ex.getMessage)
      }
      case ex: IOException => {
        println("IOException")
      }
    }finally{  //finally ?????????????????????????????
      println("?????????????")
    }
    
    
  }
  
   def matchTest(x: Int){
      x match{
        case 1 if x<=4 => println("one")
        case 2 => println("two")
        //case _x => println("age"+_x)
        case _ => println("many")
      }
      
   }
  
} 

//设置package包名称以及导入依赖的类
import java.io.FileNotFoundException

import model.PSP1List
import org.scalatest.Matchers._
import org.scalatest.WordSpec


class ReadFromFileTest extends WordSpec {
  val emptyFileName: String = getClass.getResource("testEmpty.txt").getFile
  val testFileName: String = getClass.getResource("test.txt").getFile
  val fileWithWrongFormat: String = getClass.getResource("fileWithWrongFormat.txt").getFile

  "A read file" when {
    "it is not found" should {
      "throw a FileNotFoundException" in {
        intercept[FileNotFoundException](ReadFromFile.getListFromFile("aowjdoaiwjdoaiwjdoaiwjdoaiwjdoaiwjdo"))
      }
    }
    "it is empty" should {
      "return an empty list" in {
        assert(ReadFromFile.getListFromFile(emptyFileName).isEmpty)
      }
    }
    "has numbers" should {
      val result = ReadFromFile.getListFromFile(testFileName)
      "return its content as a PSP1List" in {
        result shouldBe an[PSP1List]
      }
      "return its content as a non-empty List" in {
        assert(result.nonEmpty)
      }
      "its content should match to the expected ones" in {
        result.list match {
          case 160.0 :: 15.0 :: (-15.0) :: Nil => succeed
          case _ => fail
        }
      }
    }
    "has a wrong format" should {
      "throw a NumberFormatException" in {
        intercept[NumberFormatException](ReadFromFile.getListFromFile(fileWithWrongFormat))
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
import java.io.FileNotFoundException

import model.PSP1List
import org.scalatest.Matchers._
import org.scalatest.WordSpec


class ReadFromFileTest extends WordSpec {
  val emptyFileName: String = getClass.getResource("testEmpty.txt").getFile
  val testFileName: String = getClass.getResource("test.txt").getFile
  val fileWithWrongFormat: String = getClass.getResource("fileWithWrongFormat.txt").getFile

  "A read file" when {
    "it is not found" should {
      "throw a FileNotFoundException" in {
        intercept[FileNotFoundException](ReadFromFile.getListFromFile("aowjdoaiwjdoaiwjdoaiwjdoaiwjdoaiwjdo"))
      }
    }
    "it is empty" should {
      "return an empty list" in {
        assert(ReadFromFile.getListFromFile(emptyFileName).isEmpty)
      }
    }
    "has numbers" should {
      val result = ReadFromFile.getListFromFile(testFileName)
      "return its content as a PSP1List" in {
        result shouldBe an[PSP1List]
      }
      "return its content as a non-empty List" in {
        assert(result.nonEmpty)
      }
      "its content should match to the expected ones" in {
        result.list match {
          case Vector(160.0, 15.0, -15.0) => succeed
          case _ => fail
        }
      }
    }
    "has a wrong format" should {
      "throw a NumberFormatException" in {
        intercept[NumberFormatException](ReadFromFile.getListFromFile(fileWithWrongFormat))
      }
    }
  }
} 

//设置package包名称以及导入依赖的类
package gv.jleon
package domain

import java.io.{ FileNotFoundException }
import java.nio.file.{ FileAlreadyExistsException }

object LockingStorages {

  final type Underlying = Storage

  final case class Locked(uri: Uri, cause: Throwable) extends Exception(s"locked: $uri", cause)

  trait Ops extends Any {

    def self: Underlying

    final def lockPath(uri: Uri): Storage.Path =
      self storagePathWithExt (uri, "lock")

    final def lock(uri: Uri): Try[WritableByteChannel] = {
      File.createNew(lockPath(uri))
        .recoverWith {
          case cause: FileAlreadyExistsException ?
            Failure(Locked(uri, cause))
        }
    }

    final def isLocked(uri: Uri): Boolean =
      File exists lockPath(uri)

    final def unlock(uri: Uri): Try[Unit] =
      if (File.delete(lockPath(uri)))
        Success {}
      else
        Failure {
          new FileNotFoundException(s"$uri - ${lockPath(uri)}")
        }
  }

} 

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

import java.io.FileNotFoundException

import com.badlogic.gdx.Gdx
import com.badlogic.gdx.assets.loaders.FileHandleResolver
import com.badlogic.gdx.assets.loaders.resolvers.InternalFileHandleResolver
import org.luaj.vm2.LuaError
import org.luaj.vm2.lib.jse.JsePlatform

object ScriptManager {
  private val TAG = getClass.getSimpleName
  private val globals = JsePlatform.standardGlobals()

  def run(fileName: String): Unit = run(fileName, new InternalFileHandleResolver)

  def run(fileName: String, resolver: FileHandleResolver) = {
    val file = resolver.resolve(fileName)

    try {
      if (!file.exists) throw new FileNotFoundException

      val chunk = globals.load(file.readString())
      val luaValue = chunk.call()

      println(luaValue.toString)
    }
    catch {
      case ex: FileNotFoundException => Gdx.app.error(TAG, "Could not load Lua script <" + file.name + ">", ex)
      case ex: LuaError => Gdx.app.error(TAG, "Error running Lua script <" + file.name + ">", ex)
    }
  }
} 

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

import java.io.{FileNotFoundException, IOException}

import org.specs2._

import scala.collection.immutable.SortedSet

class ScannerSpec extends mutable.Specification {

  case class MockFilesystem(directories: Map[Directory, List[FilePath]], fileSizes: Map[File, Long]) extends Filesystem {

    def length(file: File) = fileSizes.getOrElse(file, throw new IOException())

    def listFiles(directory: Directory) =
      directories.getOrElse(directory, throw new FileNotFoundException(directory.path))
  }

  "Report Format" ! {
    val base = Directory("base")
    val base1 = File(s"${base.path}/1.txt")
    val base2 = File(s"${base.path}/2.txt")
    val subdir = Directory(s"${base.path}/subdir")
    val sub1 = File(s"${subdir.path}/1.txt")
    val sub3 = File(s"${subdir.path}/3.txt")
    val fs = MockFilesystem(
      Map(
        base -> List(subdir, base1, base2),
        subdir -> List(sub1, sub3)
      ),
      Map(base1 -> 1, base2 -> 2, sub1 -> 1, sub3 -> 3)
    )

    val actual = Scanner.pathScan(base, 2, fs)
    val expected = Right(new PathScan(SortedSet(FileSize(sub3, 3), FileSize(base2, 2)), 7, 4))

    actual.mustEqual(expected)
  }

  "Error handling" ! {
    val base = Directory("base")
    val fs = MockFilesystem(Map.empty, Map.empty)

    val actual = Scanner.pathScan(base, 2, fs)
    val expected = ???

    //Cant directly compare 2 different FileNotFoundException instances for equality, so convert to Strings first
    actual.toString.mustEqual(expected.toString)
  }

} 

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

import java.io.{FileNotFoundException, IOException}

import org.specs2._

import scala.collection.immutable.SortedSet

class ScannerSpec extends mutable.Specification {

  case class MockFilesystem(directories: Map[Directory, List[FilePath]], fileSizes: Map[File, Long]) extends Filesystem {

    def length(file: File) = fileSizes.getOrElse(file, throw new IOException())

    def listFiles(directory: Directory) =
      directories.getOrElse(directory, throw new FileNotFoundException(directory.path))
  }

  "Report Format" ! {
    val base = Directory("base")
    val base1 = File(s"${base.path}/1.txt")
    val base2 = File(s"${base.path}/2.txt")
    val subdir = Directory(s"${base.path}/subdir")
    val sub1 = File(s"${subdir.path}/1.txt")
    val sub3 = File(s"${subdir.path}/3.txt")
    val fs = MockFilesystem(
      Map(
        base -> List(subdir, base1, base2),
        subdir -> List(sub1, sub3)
      ),
      Map(base1 -> 1, base2 -> 2, sub1 -> 1, sub3 -> 3)
    )

    val actual = Scanner.pathScan(base, 2, fs)
    val expected = Right(new PathScan(SortedSet(FileSize(sub3, 3), FileSize(base2, 2)), 7, 4))

    actual.mustEqual(expected)
  }

  "Error handling" ! {
    val base = Directory("base")
    val fs = MockFilesystem(Map.empty, Map.empty)

    val actual = Scanner.pathScan(base, 2, fs)
    val expected = Left(new FileNotFoundException("base"))

    //Cant directly compare 2 different FileNotFoundException instances for equality, so convert to Strings first
    actual.toString.mustEqual(expected.toString)
  }

} 

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

import cats._
import cats.data._
import cats.implicits._

import scodec.bits._

import java.io.{FileInputStream, InputStream, FileNotFoundException}

#+desktop
object ResourceLoader {

  def loadFile(name: String): Xor[FileNotFoundException, BitVector] =
    try {
      val stream: InputStream = new FileInputStream(name)
      val r = BitVector.fromInputStream(stream).force
      stream.close()
      r.right
    } catch {
      case e: FileNotFoundException => e.left
    }
}
#-desktop

#+android
import android.content.res.Resources

object ResourceLoader {

  var resources: Resources = _

  def loadFile(name: String): Xor[FileNotFoundException, BitVector] =
    try {
      val stream: InputStream = resources.getAssets().open(name)
      val r = BitVector.fromInputStream(stream).force
      println(s"bitvector is ${r}")
      stream.close()
      r.right
    } catch {
      case e: FileNotFoundException => e.left
    }
}
#-android 

//设置package包名称以及导入依赖的类
package io.gloriousfuture.openapi.v2.circe

import java.io.FileNotFoundException

import cats.syntax.either._
import cats.syntax.show._
import io.circe.Json
import io.circe.optics.JsonPath.root
import io.circe.parser.parse
import io.gloriousfuture.genrpc.openapi.v2.Root
import org.scalatest.{Matchers, WordSpec}

import scala.io.Source
import scala.reflect.ClassTag

class PetstoreExampleSpec extends WordSpec with Matchers {

  import CirceFormats._

  object ExampleJson {
    val petstore: Json = {
      val petstoreExample = Option(getClass.getResource("/petstore.json")) getOrElse {
        throw new FileNotFoundException("Could not find resource /petstore.json")
      }
      parse(Source.fromURL(petstoreExample).mkString).valueOr(throw _)
    }
  }

  def typeName[T](implicit clsTag: ClassTag[T]): String = s"openapi.v2.${clsTag.runtimeClass.getSimpleName}"

  "petstore.json" should {

    s"parse as ${typeName[Root]}" in {
      val result = ExampleJson.petstore.as[Root].valueOr(e => fail(e.show))
      assert(result.info.title contains "Petstore")
      val petModelTypeName = result.definitions.get("Pet").properties("name").asPrimitive.get.`type`
      assertResult("string")(petModelTypeName)
    }

    s"read tags field from ${typeName[Root]}" in {
      val tags = root.tags.each.name.string.getAll(ExampleJson.petstore)
      tags should contain theSameElementsAs Seq("pet", "store", "user")
    }
  }
} 

//设置package包名称以及导入依赖的类
package fi.kajstrom.efpscala.E45

import java.io.{File, FileNotFoundException, PrintWriter}

import fi.kajstrom.efpscala.Util.FilePath

import scala.io.StdIn._
import scala.io.Source

object E45 extends App{
  val replaceWord = readLine("Enter word to replace: ")
  val replaceWith = readLine(s"Replace '$replaceWord' with: ")

  val modifiedContents = replaceInFile(replaceWord, replaceWith)

  print("Replace result: ")
  println(modifiedContents)

  val saveToFile = readLine("Enter filename to save into: ")
  val saveFilePath = FilePath.makeResourcePath(saveToFile)


  try {
    writeModifiedToFile(saveToFile)
    println(s"File saved: $saveFilePath")
  } catch {
    case notFound: FileNotFoundException => println(s"Couldn't write to $saveFilePath: ${notFound.getMessage}")
  }

  private def replaceInFile(find: String, replace: String) : String = {
    val fileContents = Source.fromFile(FilePath.makeResourcePath("E45_in.txt")).mkString
    fileContents.replaceAll(replaceWord, replaceWith)
  }

  private def writeModifiedToFile(saveToFile: String) = {
      val saveFile = new File(saveFilePath)

      val pw = new PrintWriter(saveFile)
      pw.write(modifiedContents)
      pw.close()
  }
} 

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

import java.io.FileNotFoundException
import java.net.URL

import org.powerscala.Version
import org.powerscala.io._

import scala.xml.XML

case class MavenRepository(name: String, baseURL: String) extends Repository {
  @transient lazy val internal = coursier.MavenRepository(baseURL)

  def info(dependency: Dependency): Option[DependencyInfo] = {
    val url = s"$baseURL/${dependency.group.replace('.', '/')}/${dependency.name}"
    val metadataURL = s"$url/maven-metadata.xml"

    try {
      val metadata = IO.stream(new URL(metadataURL), new StringBuilder).toString
      val xml = XML.loadString(metadata)
      val latest = (xml \ "versioning" \ "latest").text match {
        case "" | null => None
        case Version(v) => Some(v)
      }
      val release = (xml \ "versioning" \ "release").text match {
        case null | "" => None
        case Version(v) => Some(v)
      }
      val versions = (xml \ "versioning" \ "versions" \ "version").toList.map(_.text).collect {
        case Version(v) => v
      }.sorted.reverse
//      val lastUpdated = (xml \ "versioning" \ "lastUpdated").text

      Some(DependencyInfo(
        dependency = dependency,
        latest = VersionedDependency(dependency, latest.getOrElse(versions.find(!_.snapshot).getOrElse(versions.head)), None, Some(this)),
        release = release.map(VersionedDependency(dependency, _, None, Some(this))),
        versions = versions.map(VersionedDependency(dependency, _, None, Some(this)))
      ))
    } catch {
      case exc: FileNotFoundException => None
      case t: Throwable => throw new RuntimeException(s"Failed to process maven metadata: $metadataURL.", t)
    }
  }

  def tupled: (String, String) = name -> baseURL

  override def toString: String = name
} 

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

import java.io.FileNotFoundException
import java.util.Properties

import textengine.Cluster
import textengine.messengers.Messenger

import scala.collection.JavaConversions._

object SettingsParser {

  def parseSettings(cluster: Cluster, messenger: Messenger): Settings = {

    val properties = new Properties
    try {
      properties.load(getClass.getResourceAsStream("/settings.properties"))
    } catch {
      case e: FileNotFoundException =>
        cluster.info.text =
          messenger.settingsMessenger.couldNotFindSettingsFile
    }

    val settings = new Settings(cluster)
    var unsupported_setting = false

    for (key <- properties.stringPropertyNames()) {
      val value = properties.getProperty(key)
      key match {
        case "defaultTheme" =>
          settings.theme.value = value
        case "fontStyle" =>
          settings.fontStyle.value = value
        case "fontSize" =>
          settings.fontSize.value = value.toInt
        case "tabSize" =>
          settings.tabSize.value = value.toInt
        case "maxFileSize" =>
          settings.maxFileSize.value = value.toInt
        case "showHiddenFiles" =>
          settings.hiddenFiles.value = value
        case _ =>
          unsupported_setting = true
      }
    }

    if (unsupported_setting) {
      cluster.info.text = messenger.settingsMessenger.notSupportedSettings
    } else {
      cluster.info.text =
        messenger.settingsMessenger.settingsLoadedSuccessfully
    }
    settings
  }

} 

//设置package包名称以及导入依赖的类
import sbt._
import java.io.FileNotFoundException
import java.io.File

object Resources {

	
	def getJavaHome: File = {
		val javaHome =
	    Option(System.getenv("JAVA_HOME")).map(_+"/jre").
	      orElse(Option(System.getProperty("java.home")))
		javaHome match {
			case Some(str) =>
				file(str)
			case None =>
				throw new FileNotFoundException("$JAVA_HOME is undefined as well as the system property `java.home`." +
																			"Setup a environment variable JAVA_HOME")
		}
	}

	def checkExists(file:File): File = {
		if(file.exists()) file
		else throw new FileNotFoundException(s"Can't find needed resource: $file")
	}
} 

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

import com.mariotti.urlshortener.dao.cache.Cache
import com.mariotti.urlshortener.utils.ShortUrl
import com.mariotti.urlshortener.dao.persistence.MapperWriterDB
import com.mariotti.urlshortener.dao.persistence.MapperReaderDB
import com.mariotti.urlshortener.model.Stats
import java.io.FileNotFoundException

object MapperWriter {
  def put(url: String): String = {
    val id: Int = Cache.put(url)
    // write to the DB
    MapperWriterDB.put(id, url)
    ShortUrl.encode(id)
  }
  def bump(short: String) {
    var stats: Stats = null
    val id = ShortUrl.decode(short)
    try {
      stats = MapperReader.readStats(short)
      if (stats != null) {
        stats = stats.copy(stats.clicks + 1)
        MapperWriterDB.putStats(id, stats)
      }
    } catch {
      case t: Throwable =>
        // the file does not exists, create it 
        if (t.isInstanceOf[FileNotFoundException]) {
          stats = new Stats(1)
          MapperWriterDB.putStats(id, stats)
        }
        else {
          // TODO log that something happened
          t.printStackTrace()
        }
    }
  }
}