package fossil.domain

object endpoint {

  final case class EndpointDescriptor(
      name: String,
      enabled: Boolean,
      topics: List[String],
      config: Map[String, String]
  )

}

while (current.ne(null) && current.getName != "target") {
  current = current.getParentFile
}

      goldenExamples.flatMap {
        _.traverse { case (encodedString, maybeValue) =>
          maybeValue match {
            case Some(value) =>
              // The golden file contains the current version of the resource.
              // We check that:
              // - encoding the `value` produces the same `encodedString`
              // - decoding the `encodedString` produces the `value`
              parser.decode[A](encodedString)(decode).map { decoded =>
                val decoding = isEqToProp(decoded <-> value)
                val encoding = isEqToProp(printJson(encode(value)) <-> encodedString)
                decoding && encoding
              }.toTry
            case None =>
              // The golden file contains an old version of the resource.
              // We check that:
              // - we can still decode it
              // - encoding and then decoding it produces the same value as
              //   when decoding the old version
              (
                for {
                  decodedOldValue <- parser.decode[A](encodedString)(decode)
                  decodedNewValue <- decode.decodeJson(encode(decodedOldValue))
                } yield isEqToProp(decodedOldValue <-> decodedNewValue)
              ).toTry
          }
        }
      }

package com.example

import cats.Eq
import enumeratum.{CirceEnum, Enum, EnumEntry}
import enumeratum.EnumEntry.Uppercase
import io.circe.Codec
import io.circe.generic.semiauto._
import io.circe.testing.ArbitraryInstances
import io.circe.testing.golden.GoldenCodecTests
import org.scalacheck.{Arbitrary, Gen}
import org.scalacheck.Arbitrary.arbitrary
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.prop.Configuration
import org.typelevel.discipline.scalatest.FlatSpecDiscipline

object CurrencyGoldenTest {
  sealed abstract class Currency extends EnumEntry
  object Currency extends Enum[Currency] with Uppercase with CirceEnum[Currency] {
    override final val values = findValues

    final case object AUD extends Currency
  }

  final case class Price(value: Double, currency: Currency)
  object Price {
    implicit final val codec: Codec[Price] = deriveCodec
  }

  implicit val arbCurrency: Arbitrary[Currency] = Arbitrary(Gen.oneOf(Currency.values))
  implicit val arbPrice: Arbitrary[Price] = Arbitrary {
    for {
      v <- arbitrary[Double]
      c <- arbitrary[Currency]
    } yield Price(value = v, currency = c)
  }
}

class CurrencyGoldenTest extends AnyFlatSpec with FlatSpecDiscipline with Configuration with ArbitraryInstances {

  import CurrencyGoldenTest._

  implicit final val eqCurrency: Eq[Currency] = Eq.fromUniversalEquals
  implicit final val eqPrice: Eq[Price]       = Eq.fromUniversalEquals

  checkAll("GoldenCodec[Currency]", GoldenCodecTests[Currency].goldenCodec)
  checkAll("GoldenCodec[Price]", GoldenCodecTests[Price].goldenCodec)

}

NotSerializableException was thrown during property evaluation.
  Message: com.example.CurrencyGoldenTest$Currency$
  Occurred when passed generated values (

  )
ScalaTestFailureLocation: org.scalatestplus.scalacheck.CheckerAsserting$$anon$2 at (CurrencyGoldenTest.scala:45)
org.scalatest.exceptions.GeneratorDrivenPropertyCheckFailedException: NotSerializableException was thrown during property evaluation.
  Message: com.example.CurrencyGoldenTest$Currency$
  Occurred when passed generated values (

  )
	at org.scalatestplus.scalacheck.CheckerAsserting$$anon$2.indicateFailure(CheckerAsserting.scala:251)
	at org.scalatestplus.scalacheck.CheckerAsserting$$anon$2.indicateFailure(CheckerAsserting.scala:238)
	at org.scalatestplus.scalacheck.UnitCheckerAsserting$CheckerAssertingImpl.check(CheckerAsserting.scala:160)
 ...

Please set the environment variable SCALACTIC_FILL_FILE_PATHNAMES to yes at compile time to enable this feature.

case class Person(name: String, address: Option[String])

object Person {

  implicit val decoderForPerson: Decoder[Person] = deriveDecodder[Person

  implicit val encoderForPerson: Encoder[Person] = deriveEncoder[Person]

  implicit val eqForPerson: Eq[Person] = Eq.fromUniversalEquals[Person]
}

case class Person(name: String, address: Option[String])


object Person {

  implicit val decoderForPerson: Decoder[Person] = new Decoder[Person] {
    def apply(c: HCursor): Decoder.Result[Person] =
      for {
        name <- c.downField("name").as[String]
        address <- c.downField("address").as[Option[Value]]
      } yield Person(name, address.map(_.value))
  }

  implicit val encoderForPerson: Encoder[Person] = new Encoder[Person] {

    def apply(a: Person): Json = Json.obj(
      "name" -> a.name.asJson,
      "address" -> a.address.fold(Json.Null)(addr => Json.obj("value" -> addr.asJson))
    )

  }

  implicit val eqForPerson: Eq[Person] = Eq.fromUniversalEquals[Person]
}

case class Value(value: String)

object Value{
  implicit val decoderForValue: Decoder[Value] = deriveDecoder[Value]
}

  val containsNulls: Algebra[JsonF, Boolean] = Algebra {
    case JsonF.NullF       => true
    case JsonF.ArrayF(xs)  => xs.exists(identity)
    case JsonF.ObjectF(xs) => xs.map(_._2).exists(identity)
    case _                 => false
  }

generator.filter(person => !cata(containsNulls).apply(person))