Scala

set logLevel := Level.Debug

testOnly *MySuite* // suite
test-only *MySuite* -- -z "text" // Use Only test case from suite which name contains "text"

sbt test:runMain "com.package.Main"
# or  specyfying project:
sbt project/test:runMain "com.package.Main"

val alaDependencies = Seq(
  ("org.organization" %% "common-mongo" % "1.2.3")
    .exclude("org.reactivemongo", "reactivemongo_2.13"),
  //...
)

bloop test foo -o "*CubeCalculatorTest*" -- -z "a single test case"  # Just like in sbt

// scala 2.12.12
// ammonite 2.3.8

def dropTables(db: Database)(implicit ec: ExecutionContext) =
  Await.result(
    db.run(
      DBIO.sequence(
        schemas.map(tab =>
          sqlu"DROP TABLE IF EXISTS #${tab.baseTableRow.tableName}"
        ))), 10 seconds)

val regex = raw"hello:(.*)/(.*)".r

"hello:xe/lol" match{
    case regex(a,b) => print((a,b))
    case _ => print("nic")
}
// ("xe", "lol")

import java.time.ZonedDateTime
import java.time.format.{DateTimeFormatter,FormatStyle}
// val date = ZonedDateTime.now()
val date = ZonedDateTime.ofInstant(ZonedDateTime.now.toInstant(), ZoneOffset.UTC)

def formatDateFancy1(zdt: ZonedDateTime): String = {
    def daySuffix(n: Int) = {
      require(n >= 1 && n <= 31, "illegal day of month: " + n)

      if (n >= 11 && n <= 13) {
        "th";
      } else
        (n % 10) match {
          case 1 => "st"
          case 2 => "nd"
          case 3 => "rd"
          case _ => "th"
        }
    }

    zdt.getDayOfMonth.toString + daySuffix(zdt.getDayOfMonth) + " "
    + zdt.format(DateTimeFormatter.ofPattern("MMM yyyy, K:mm a"))
  }



val formatters : List[ZonedDateTime => String] = List(
    DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"),
    DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG),
    DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM),
    DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT),
    DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG),
    DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM),
    DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT),
    DateTimeFormatter.ofPattern("E, MMM dd, yyyy  HH:mm:ss"),
    DateTimeFormatter.ofPattern("E, MMM dd, yyyy"),
    DateTimeFormatter.ofPattern("HH:mm:ss"),
    DateTimeFormatter.ofPattern("HH:mm:ss VV"),
    DateTimeFormatter.ofPattern("HH:mm:ss O"),
    DateTimeFormatter.ISO_OFFSET_DATE_TIME
).map(fmt => (fmt.format _)) :+ (formatDateFancy1 _)

formatters.map(f => f(date)).reduce(_ + "\n" + _)

ZonedDateTime.now().withZoneSameInstant(ZoneOffset.ofTotalSeconds(timeZoneOffsetSeconds))

import java.nio.file.{Files,Path,Paths}
import java.util.stream.Collectors
import scala.jdk.CollectionConverters.ListHasAsScala

val ls :List[Path] =Files
    .list(Paths.get("."))
    .collect(Collectors.toList[Path])
    .asScala.toList

ls

import scala.jdk.CollectionConverters.MapHasAsScala
import scala.collection.mutable
import javax.annotation.concurrent.NotThreadSafe

// From https://stackoverflow.com/a/59116615
@NotThreadSafe
class LRUCache[K, V](maxEntries: Int)
  extends java.util.LinkedHashMap[K, V](100, .75f, true) {

  override def removeEldestEntry(eldest: java.util.Map.Entry[K, V]): Boolean
     = size > maxEntries

}

object LRUCache {
  def apply[K, V](maxEntries: Int): mutable.Map[K, V]
    = new LRUCache[K, V](maxEntries).asScala // thread safe??
}