if !reflect.DeepEqual(want, got) {
		t.Errorf("got unexpected result: %#v", got)
	}
}

func Test_metaCacheEntry_isInDir(t *testing.T) {
	tests := []struct {
		testName string
		entry    string
		dir      string
		sep      string
		want     bool
	}{
		{
			testName: "basic-file",
			entry:    "src/file",
			dir:      "src/",
			sep:      slashSeparator,
			want:     true,
		},

    }

    @Nonnull
    default T read(@Nonnull Reader reader) throws XmlReaderException {
        return read(reader, true);
    }

    @Nonnull
    default T read(@Nonnull Reader reader, boolean strict) throws XmlReaderException {
        return read(XmlReaderRequest.builder().reader(reader).strict(strict).build());
    }

    @Nonnull

                "alias_priority": alias_priority,
                "validation_alias": validation_alias,
                "serialization_alias": serialization_alias,
                "strict": strict,
                "json_schema_extra": current_json_schema_extra,
            }
        )
        kwargs["pattern"] = pattern or regex

        use_kwargs = {k: v for k, v in kwargs.items() if v is not _Unset}

            throws XmlPullParserException {
        if (s == null) {
            if (strict) {
                throw new XmlPullParserException(
                        "Missing required value for attribute '" + attribute + "'", parser, null);
            }
        }
        return s;
    } // -- String getRequiredAttributeValue( String, String, XmlPullParser, boolean )

        delegate.setAddDefaultEntities(addDefaultEntities);
    }

    public Settings read(Reader reader, boolean strict) throws IOException, XmlPullParserException {
        try {
            return new Settings(delegate.read(reader, strict, null));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

        }

        public XmlReaderRequestBuilder strict(boolean strict) {
            this.strict = strict;
            return this;
        }

        public XmlReaderRequestBuilder modelId(String modelId) {
            this.modelId = modelId;
            return this;
        }

        public XmlReaderRequestBuilder location(String location) {
            this.location = location;

     * @param in a in object.
     * @param strict a strict object.
     * @return PersistedToolchains
     * @throws IOException IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     *         any.
     */
    public PersistedToolchains read(InputStream in, boolean strict) throws IOException, XmlPullParserException {
        return read(new XmlStreamReader(in), strict);
    }

    /**

// The string can be an encrypted, singlepart
// or multipart S3 ETag. It returns an error if s is
// not a valid textual representation of an ETag.
func Parse(s string) (ETag, error) {
	const strict = false
	return parse(s, strict)
}

// parse parse s as an S3 ETag, returning the result.
// It operates in one of two modes:
//   - strict
//   - non-strict
//

        Doc(
            """
            Parameter field name for discriminating the type in a tagged union.
            """
        ),
    ] = None,
    strict: Annotated[
        Union[bool, None],
        Doc(
            """
            If `True`, strict validation is applied to the field.
            """
        ),
    ] = _Unset,
    multiple_of: Annotated[
        Union[float, None],
        Doc(

            analysisFlags = mapOf(
                JvmAnalysisFlags.javaTypeEnhancementState to JavaTypeEnhancementState(
                    Jsr305Settings(ReportLevel.STRICT, ReportLevel.STRICT)
                ) { ReportLevel.STRICT },
            )
        )
    )

    put(JVMConfigurationKeys.SAM_CONVERSIONS, JvmClosureGenerationScheme.CLASS)
    put(JVMConfigurationKeys.PARAMETERS_METADATA, true)