✅ @endpointInput should derive correct input for @query, @cookie, @header
✅ @endpointInput should derive correct input for dealiased bodies
✅ @endpointInput should derive correct input for @queries, @headers, @cookies
✅ @endpointInput should derive correct input for auth annotations
✅ @endpointInput should derive correct input for auth annotations with named security schemes
✅ @endpointInput should derive input with descriptions
✅ @endpointInput should derive input with paths
✅ @endpointInput should derive correct input with schema annotations
✅ @endpointInput should derive default annotation correctly
✅ @endpointInput should customise inputs
✅ @endpointInput should derive correct input for byte array body
✅ @endpointInput should derive correct input for byte buffer body
✅ @endpointInput should derive correct input for input stream body
✅ @endpointInput should derive correct input for form body
✅ @endpointInput should derive correct input for file body
✅ @endpointInput should derive correct input for multipart body
✅ @endpointInput should accept empty case classes when annotated with @endpointInput
✅ @endpointInput should not compile if there is field without annotation
✅ @endpointInput should not compile if there are two body annotations
✅ @endpointInput should not compile for alone @apikey
✅ @endpointInput should not compile for body without JSON codec
✅ @endpointInput should not compile when not all paths are captured in case class
✅ @endpointInput should not compile when not all paths are captured in path
✅ @endpointInput should not compile when path contains duplicated variable
✅ @endpointOutput should devive correct output for @header, @setCookie, @statusCode
✅ @endpointOutput should derive correct output for @headers, @cookies, @setCookies
✅ @endpointOutput should not compile if there is field without annotation
✅ @endpointOutput should not compile if there are two body annotations
✅ @endpointOutput should not compile for wrong field type
✅ @endpointOutput should not report ambiguous header import errors

✅ should create an attribute key for a case class
✅ should create an attribute key for a list of case classes
✅ should create an attribute key for a list of generic case classes

✅ should encode and decode comma-separated values
✅ should encode and decode comma-separated values in a list

✅ should derive a codec for a string-based union type

✅ should encode simple types using .toString
✅ should use default, when available
✅ should correctly encode and decode Date
✅ should create a part codec
✅ should call the validator during decoding when using .mapValidate
✅ should provide a mapEither function

✅ oneOfVariant should compile when using parametrised enums
✅ oneOfVariant should compile when using parameterless sealed traits
✅ oneOfVariant should not compile when using parameterless enums

✅ endpoint should compile inputs
✅ endpoint should compile security inputs
✅ endpoint should compile map security into case class
✅ endpoint should compile a path fold
✅ endpoint should compile inputs with streams
✅ endpoint should compile outputs
✅ endpoint should compile outputs with streams
✅ endpoint should compile error outputs
✅ endpoint should compile one-of empty output
✅ endpoint should allow to map status code multiple times to same format different charset
✅ endpoint should compile one-of empty output of a custom type
✅ endpoint should compile with a single error variant
✅ endpoint should compile with multiple error variants
✅ oneOfVariant should not compile when the type erasure of `T` is different from `T`
✅ tupling should combine two inputs
✅ tupling should combine four inputs in two groups
✅ tupling should combine four inputs in two groups, through an extend method (right)
✅ tupling should combine four inputs in two groups, through an extend method (left)
✅ show for Endpoint(securityin: -, in: /p1%2Fp2, errout: -, out: -) should be /p1%2Fp2 -> -/-
✅ show for Endpoint[E1](securityin: -, in: /p1, errout: -, out: -) should be [E1] /p1 -> -/-
✅ show for Endpoint(securityin: -, in: GET /p1 /p2, errout: -, out: -) should be GET /p1 /p2 -> -/-
✅ show for Endpoint(securityin: -, in: /p1 /[p2] /*, errout: -, out: -) should be /p1 /[p2] /* -> -/-
✅ show for Endpoint(securityin: -, in: POST ?q1 ?q2 {body as text/plain (UTF-8)}, errout: {body as text/plain (UTF-8)}, out: -) should be POST ?q1 ?q2 {body as text/plain (UTF-8)} -> {body as text/plain (UTF-8)}/-
✅ show for Endpoint(securityin: -, in: GET {header X-header}, errout: -, out: {header Y-header}) should be GET {header X-header} -> -/{header Y-header}
✅ show for Endpoint(securityin: -, in: GET, errout: -, out: one of({body as text/plain (UTF-8)}|{body as application/octet-stream})) should be GET -> -/one of({body as text/plain (UTF-8)}|{body as application/octet-stream})
✅ show for Endpoint(securityin: -, in: GET, errout: -, out: {body as text/plain (UTF-8)}) should be GET -> -/{body as text/plain (UTF-8)}
✅ show for Endpoint(securityin: -, in: GET, errout: -, out: {body as application/octet-stream}) should be GET -> -/{body as application/octet-stream}
✅ short show for Endpoint(securityin: -, in: -, errout: -, out: -) should be * *
✅ short show for Endpoint(securityin: -, in: /p1, errout: -, out: -) should be * /p1
✅ short show for Endpoint(securityin: -, in: /p1 /p2, errout: -, out: -) should be * /p1/p2
✅ short show for Endpoint(securityin: -, in: GET /p1 /p2, errout: -, out: -) should be GET /p1/p2
✅ short show for Endpoint(securityin: -, in: POST, errout: -, out: -) should be POST *
✅ short show for Endpoint(securityin: -, in: GET /p1 /*, errout: -, out: -) should be GET /p1/*
✅ short show for Endpoint[my endpoint](securityin: -, in: GET /p1 /p2, errout: -, out: -) should be [my endpoint]
✅ showPathTemplate for Endpoint(securityin: -, in: -, errout: -, out: -) should be *
✅ showPathTemplate for Endpoint(securityin: -, in: /, errout: -, out: -) should be /
✅ showPathTemplate for Endpoint(securityin: -, in: /p1, errout: -, out: -) should be /p1
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 /p2, errout: -, out: -) should be /p1/p2
✅ showPathTemplate for Endpoint(securityin: /p1, in: /p2, errout: -, out: -) should be /p1/p2
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 /[], errout: -, out: -) should be /p1/{param1}
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 /[par], errout: -, out: -) should be /p1/{par}
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 ?par, errout: -, out: -) should be /p1?par={par}
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 ?par1 ?par2, errout: -, out: -) should be /p1?par1={par1}&par2={par2}
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 /[par1] ?par2, errout: -, out: -) should be /p1/{par1}?par2={par2}
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 auth(api key, via ?par2), errout: -, out: -) should be /p1?par2={par2}
✅ showPathTemplate for Endpoint(securityin: -, in: /p2 /[], errout: -, out: -) should be /p2/{param1}
✅ showPathTemplate for Endpoint(securityin: -, in: /p1%2Fp2, errout: -, out: -) should be /p1%2Fp2
✅ showPathTemplate for Endpoint(securityin: -, in: /8*5%29PpDEeXsx4n.9NjyT%3DYtJuUf%26F%21AamMIi-%40%2C%3BvG61VqQL%27bgBl0_2CH%2BcWh%287rKRw%3A%243k%7EOzSdZo, errout: -, out: -) should be /8*5)PpDEeXsx4n.9NjyT=YtJuUf&F!AamMIi-@,;vG61VqQL'bgBl0_2CH+cWh(7rKRw:$3k~OzSdZo
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 /*, errout: -, out: -) should be /p1/*
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 ?*, errout: -, out: -) should be /p1?*
✅ showPathTemplate for Endpoint(securityin: -, in: /p1 /p2 ?par1 ?par2, errout: -, out: -) should be /p1?par1={par1}
✅ showPathTemplate for Endpoint(securityin: -, in: /not /allowed /chars /hi%3Fhello, errout: -, out: -) should be /not/allowed/chars/hi%3Fhello
✅ showPathTemplate should keep param count in show functions
✅ showPathTemplate should skip query parameters
✅ validate should accumulate validators
✅ validate should add validator for an option
✅ validate should add validator for an iterable
✅ validate should map input and output
✅ httpMethod for Endpoint(securityin: -, in: -, errout: -, out: -) should be None
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] GET, errout: -, out: -) should be Some(GET)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] PUT, errout: -, out: -) should be Some(PUT)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] POST, errout: -, out: -) should be Some(POST)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] HEAD, errout: -, out: -) should be Some(HEAD)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] TRACE, errout: -, out: -) should be Some(TRACE)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] PATCH, errout: -, out: -) should be Some(PATCH)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] CONNECT, errout: -, out: -) should be Some(CONNECT)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] DELETE, errout: -, out: -) should be Some(DELETE)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] OPTIONS, errout: -, out: -) should be Some(OPTIONS)
✅ httpMethod for Endpoint(securityin: -, in: /api /cats /[] XX, errout: -, out: -) should be Some(XX)
✅ compile should work for endpoint descriptions providing partial server logic using serverLogicForCurrent
✅ mapTo should properly map between tuples and case classes of arity 1
✅ mapTo should properly map between tuples and case classes of arity 2
✅ mapTo should fail on invalid field type
✅ mapTo should fail on redundant field
✅ mapTo should fail on missing field
✅ mapTo should compile for case class with defined companion object

✅ should derive codec for an sealed-trait based enum
✅ should derive codec for an Scala enumeration
✅ should derive a customised codec for an Scala enumeration
✅ should derive a default codec for an Scala enumeration

✅ should generate a codec for a one-arg case class
✅ should generate a codec for a two-arg case class
✅ should generate a codec for a three-arg case class
✅ should generate a codec for a case class with optional parameters
✅ should use the right schema for a two-arg case class
✅ should generate a codec for a one-arg case class using snake-case naming transformation
✅ should generate a codec for a one-arg case class using screaming-snake-case naming transformation
✅ should generate a codec for a one-arg case class using kebab-case naming transformation
✅ should generate a codec for a one-arg case class with list
✅ should generate a codec for a one-arg case class with set
✅ should generate a codec for a one-arg case class with vector
✅ should generate a codec for a one-arg case class using implicit schema
✅ should generate a codec for a case class with simple types
✅ should generate a codec with custom field name

✅ should generate a codec for a one-arg case class
✅ should generate a codec for a two-arg case class
✅ should generate a codec for a case class with optional parameters
✅ should use the right schema for a case class with part metadata
✅ should generate a codec for a one-arg case class using snake-case naming transformation
✅ should generate a codec for a one-arg case class using screaming-snake-case naming transformation
✅ should generate a codec for a one-arg case class with list
✅ should generate a codec for a case class with part metadata
✅ should generate a codec for a one-arg case class with implicit validator
✅ should generate a codec with a custom field name
✅ should generate a codec for a case class with file part
✅ should use the right schema for an optional file part with metadata 2
✅ should use the right schema for a two-arg case class

✅ Schema auto derivation should find schema for simple types
✅ Schema auto derivation should find schema for optional types
✅ Schema auto derivation should find schema for collections
✅ Schema auto derivation should find schema for collections of case classes
✅ Schema auto derivation should find schema for a simple case class
✅ Schema auto derivation should find schema for a simple case class and use identity naming transformation
✅ Schema auto derivation should find schema for a nested case class
✅ Schema auto derivation should find schema for case classes with collections
✅ Schema auto derivation should use custom schema for custom types
✅ Schema auto derivation should derive schema for parametrised type classes
✅ Schema auto derivation should find schema for map
✅ Schema auto derivation should find schema for map of products
✅ Schema auto derivation should find schema for map of generic products
✅ Schema auto derivation should add meta-data to schema from annotations
✅ Schema auto derivation should find the right schema for a case class with simple types
✅ Schema auto derivation should find schema for a simple case class and use snake case naming transformation
✅ Schema auto derivation should find schema for a simple case class and use screaming snake case naming transformation
✅ Schema auto derivation should find schema for a simple case class and use kebab case naming transformation
✅ Schema auto derivation should not transform names which are annotated with a custom name
✅ Schema auto derivation should customise the schema using the given function
✅ Schema auto derivation should generate one-of schema using the given discriminator
✅ Schema auto derivation should generate one-of schema using the given discriminator (kebab case subtype names)
✅ Schema auto derivation should generate one-of schema using the given discriminator (snake case subtype names)
✅ Schema auto derivation should generate one-of schema using the given discriminator (screaming snake case subtype names)
✅ Schema auto derivation should generate one-of schema using the given discriminator (full subtype names)
✅ Schema auto derivation should generate one-of schema using the given discriminator (full kebab case subtype names)
✅ Schema auto derivation should generate one-of schema using the given discriminator (full snake case subtype names)
✅ Schema auto derivation should find schema for subtypes containing parent metadata from annotations
✅ Schema auto derivation should add validators for collection and option elements

✅ should derive codec for value classes

✅ pathTo should find path to self
✅ pathTo should not find path to non existing input
✅ pathTo should find path to input down the hierarchy
✅ pathTo should find path to input from the middle of hierarchy
✅ pathTo should find path to the middle of hierarchy

✅ output media type should match content type with lower and upper case charset

✅ should handle empty string
✅ should handle single parameter
✅ should handle two parameters
✅ should handle complex data

✅ should compile macro-generated code using derivedEnumeration in a package other than sttp.tapir
✅ should compile macro-generated code for shadowed _root_.scala names

✅ SchemaAnnotations enrich should derive schema annotations and enrich schema

✅ should validate openProduct
✅ should validate option
✅ should validate iterable
✅ should validate array
✅ should skip collection validation for array if element validator is passing
✅ should skip collection validation for iterable if element validator is passing
✅ should validate product
✅ should use validators defined when modifying the schema
✅ should validate recursive values
✅ should show recursive validators
✅ should validate either
✅ should validate mapped either
✅ should validate oneOf object

✅ should derive a one-of-wrapped schema for enums
✅ should derive schema for union types
✅ should derive schema for a named union type
✅ should derive schema for a union type with generics (same type constructor, different arguments)
✅ should derive schema for a union type with generics (different type constructors)
✅ should derive schema for union types with 3 components
✅ should derive schema for a string-based union type
✅ should derive schema for a const as a string-based union type
✅ should derive a schema for a union of unions when all are string-based constants

✅ apply modification should modify basic schema
✅ apply modification should modify product schema
✅ apply modification should modify product schema with derivation
✅ apply modification should modify nested product schema
✅ apply modification should modify array elements in products
✅ apply modification should modify array in products
✅ apply modification should support chained modifications
✅ apply modification should modify optional parameter
✅ apply modification should modify property of optional parameter
✅ apply modification should modify property of open product
✅ apply modification should modify open product
✅ apply modification should create a map schema with string keys
✅ apply modification should create a map schema with non-string keys
✅ apply modification should work with custom naming configuration
✅ apply modification should Not propagate type encodedName to subtypes of a sealed trait, but keep inheritance for fields
✅ apply modification should add discriminator based on a trait method
✅ apply modification should extract type params for discriminator based on a trait method
✅ apply modification should add the discriminator as a field when using oneOfUsingField
✅ apply modification should create a one-of wrapped schema
✅ apply modification should create a schema using oneOfField given an enum extractor
✅ apply modification should create and enrich a schema for an enum
✅ apply modification should derive schema for a scala enumeration and enrich schema
✅ apply modification should derive a customised schema for a scala enumeration and enrich schema
✅ apply default should add default to product
✅ apply example should add example to product
✅ apply description should add description to product

✅ should modify basic schema
✅ should modify product schema
✅ should modify nested product schema
✅ should modify array elements in products
✅ should modify array in products
✅ should modify property of optional parameter
✅ should modify property of map value
✅ should modify open product schema
✅ should generate one-of schema using the given discriminator
✅ should addDiscriminatorField should only add discriminator field to child schemas if not yet present
✅ should propagate format for optional schemas
✅ should generate correct names for Eithers with parameterized types
✅ should generate correct names for Maps with parameterized types

✅ MatchType should provide implicit for basic type
✅ MatchType should provide implicit for all primitive class returning true for other primitive type
✅ MatchType should provide implicit for all primitive class returning false for any other primitive type
✅ MatchType should provide implicit for case class
✅ MatchType should provide implicit for sealed stuff
✅ MatchType should provide implicit for complex nested type
✅ MatchType should provide implicit for recursive structure
✅ MatchType should work for list

✅ should validate enum
✅ should not compile for enum with parameter
✅ should derive a validator for a string-based union type

✅ should validate for min value
✅ should validate for min value (exclusive)
✅ should validate for max value
✅ should validate for max value (exclusive)
✅ should validate for positive value
✅ should validate for positiveOrZero value
✅ should validate for negative value
✅ should validate for in range value
✅ should validate for maxSize of collection
✅ should validate for minSize of collection
✅ should validate for nonEmpty of collection
✅ should validate for fixedSize of collection
✅ should validate for matching regex pattern
✅ should validate for minLength of string
✅ should validate for minLength of string and include unicode characters
✅ should validate for maxLength of string
✅ should validate for maxLength of string and include unicode characters
✅ should validate for fixedLength of string
✅ should validate for fixedLength of string and include unicode characters
✅ should validate for nonEmptyString of string
✅ should validate with reject
✅ should validate with any of validators
✅ should validate with all of validators
✅ should validate with custom validator
✅ should validate coproduct enum
✅ should derive for branched sealed traits where all leafs are objects
✅ should not compile for malformed coproduct enum
✅ should validate closed set of ints

✅ InvariantSemigroupal syntax should work with EndpointInput
✅ InvariantSemigroupal syntax should work with EndpointOutput
✅ InvariantSemigroupal syntax should work with EndpointIO

✅ Example.FunctorLaws.functor.covariant composition
✅ Example.FunctorLaws.functor.covariant identity
✅ Example.FunctorLaws.functor.invariant composition
✅ Example.FunctorLaws.functor.invariant identity
✅ Example.FunctorLaws.functor.mapOrKeepToMapEquivalence

✅ should modify elements in NonEmptyList
✅ should modify elements in NonEmptySet
✅ should modify elements in Chain
✅ should modify elements in NonEmptyChain

✅ should find schema for cats collections
✅ should find proper validator for cats collections
✅ Provided PlainText coder for non empty list should correctly serialize a non empty list
✅ Provided PlainText coder for non empty list should correctly deserialize everything it serialize
✅ Provided PlainText coder for non empty list should fail on empty list
✅ Provided PlainText coder for non empty list should have the proper schema for list
✅ Provided PlainText coder for non empty list should have the proper validator for list
✅ Provided PlainText coder for non empty vector should correctly serialize a non empty vector
✅ Provided PlainText coder for non empty vector should correctly deserialize everything it serialize for vector
✅ Provided PlainText coder for non empty vector should fail on empty vector
✅ Provided PlainText coder for non empty vector should have the proper schema for vector
✅ Provided PlainText coder for non empty vector should have the proper validator for vector
✅ Provided PlainText codec for non empty chain should correctly serialize a non empty chain
✅ Provided PlainText codec for non empty chain should correctly deserialize everything it serialize for chain
✅ Provided PlainText codec for non empty chain should fail on empty chain
✅ Provided PlainText codec for non empty chain should have the proper schema for chain
✅ Provided PlainText codec for non empty chain should have the proper validator for chain
✅ Provided PlainText codec for non empty set should correctly serialize a non empty set
✅ Provided PlainText codec for non empty set should correctly deserialize everything it serialize for set
✅ Provided PlainText codec for non empty set should fail on empty set
✅ Provided PlainText codec for non empty set should have the proper schema for set
✅ Provided PlainText codec for non empty set should have the proper validator for set

✅ should success with non-empty list - NonEmptyList
✅ should success with non-empty list - List
✅ should fail with empty list - List

✅ should return a JSON specific decode error on failure

✅ should encode and decode Scala case class with non-empty Option elements
✅ should encode and decode Scala case class with empty Option elements
✅ should encode and decode String type
✅ should encode and decode Long type
✅ should return a JSON specific decode error on failure

✅ CORS config should provide a valid default config
✅ CORS config should detect an invalid config

✅ A custom CORS interceptor should be created with a valid config
✅ A custom CORS interceptor should not be created with an invalid config

✅ should create a validation error message for a nested field
✅ should create a validation error message including encoded enumeration values
✅ should create an error message including failed json paths
✅ should create an error message including failed multipart parts
✅ should enclose string values in error messages in quotes

✅ should return an error if decoding throws an exception

✅ should filter endpoints with a single fixed path component
✅ should filter endpoints with an empty fixed path component
✅ should not filter endpoints without any path component
✅ should filter endpoints with multiple fixed path components
✅ should filter endpoints with a single fixed and a single path capture component
✅ should filter endpoints with multiple fixed and single capture components
✅ should filter endpoints with multiple fixed and capture components
✅ should filter endpoints with fixed and paths components
✅ should filter endpoints with fixed, capture and paths components

✅ should call the interceptors in the correct order
✅ should decode security inputs, basic regular inputs, and not decode the body, when security logic fails
✅ should use a customized reject interceptor

✅ should should not detect shadowed endpoint when first endpoint has empty path and second fixed path
✅ should not detect shadowed endpoint when second endpoint doesn't have specified method
✅ should detect shadowed endpoint when first endpoint doesn't have specified method
✅ should should detect shadowed endpoint when first endpoint has only wildcard path and second empty path
✅ should detect shadowed endpoint when http methods are provided in different order
✅ should detect shadowed endpoint when security inputs and inputs overlap
✅ should should not detect shadowed endpoint when methods are not provided and paths are different
✅ should should detect shadowed endpoint when methods are not provided
✅ should omit all segments which are not relevant for shadow check
✅ should should detect shadowed endpoints with path variables that contain special characters
✅ should not detect shadowed endpoint when it is only partially shadowed
✅ should detect endpoint with path variable shadowed by endpoint with wildcard
✅ should detect shadowed endpoints for endpoints with similar path structure but with different path vars names
✅ should detect shadowed endpoints for endpoints with path variables and wildcards at the beginning
✅ should detect shadowed endpoints for endpoints with path variables in the middle
✅ should detect shadowed endpoints for fixed paths
✅ should return empty result when no shadowed endpoints exist
✅ should return empty result for empty input
✅ should not detect incorrect path input when input is fixed
✅ should not detect incorrect path input when wildcard `paths` segment appears as the last at input
✅ should not detect incorrect path input when wildcard `paths` segment appears as the last at security input
✅ should detect incorrect path input when wildcard `paths` segment appears before the last at input
✅ should detect incorrect path input when wildcard `paths` segment appears before the last security input
✅ should detect incorrect path input when wildcard `paths` segment and any path is defined in standard input
✅ should not detect any incorrect path input when wildcard `paths` segment is defined as last segment of path
✅ should detect incorrect path input when wildacard `paths` segment overlaps other path segments and return proper index in path
✅ should detect shadowed endpoints and incorrect path simultaneously
✅ should detect duplicated methods under endpoint
✅ should not detect duplicated methods when there is at most one method defined
✅ should detect endpoints with body where status code doesn't allow a body
✅ should detect duplicate names among endpoints, all endpoints names (operationId's) must be unique