mustExist: Boolean,
  ): Sink {
    log("appendingSink($file)")

    return super.appendingSink(file, mustExist)
  }

  override fun atomicMove(
    source: Path,
    target: Path,
  ) {
    log("atomicMove($source, $target)")

    super.atomicMove(source, target)
  }

  override fun createDirectory(
    dir: Path,
    mustCreate: Boolean,
  ) {
    log("createDirectory($dir)")

    } else {
      renameFaults.remove(file)
    }
  }

  @Throws(IOException::class)
  override fun atomicMove(
    source: Path,
    target: Path,
  ) {
    if (renameFaults.contains(source) || renameFaults.contains(target)) throw IOException("boom!")
    super.atomicMove(source, target)
  }

  @Throws(IOException::class)
  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {

        }
      }
    }

    if (fileSystem.exists(journalFile)) {
      fileSystem.atomicMove(journalFile, journalFileBackup)
      fileSystem.atomicMove(journalFileTmp, journalFile)
      fileSystem.deleteIfExists(journalFileBackup)
    } else {
      fileSystem.atomicMove(journalFileTmp, journalFile)
    }

    journalWriter?.closeQuietly()
    journalWriter = newJournalWriter()

      "delete:/cache/journal.bkp",
      "metadataOrNull:/cache/journal",
      "metadataOrNull:/cache",
      "sink:/cache/journal.tmp",
      "metadataOrNull:/cache/journal",
      "atomicMove:/cache/journal.tmp",
      "atomicMove:/cache/journal",
      "appendingSink:/cache/journal",
    )
    events.clear()
    c.size()
    assertThat(events).isEmpty()
  }

    setUp(parameters.first, parameters.second)
    val creator = cache.edit("k1")!!
    creator.setString(0, "ABC")
    creator.setString(1, "DE")
    creator.commit()
    cache.close()
    filesystem.atomicMove(journalFile, journalBkpFile)
    assertThat(filesystem.exists(journalFile)).isFalse()
    createNewCache()
    val snapshot = cache["k1"]!!
    snapshot.assertValue(0, "ABC")
    snapshot.assertValue(1, "DE")