then:
        localResource.getFile() >> new File('ivy.xml')
        disconnectedParser != null
        disconnectedParser instanceof DisconnectedIvyXmlModuleDescriptorParser.DisconnectedParser
    }

    def "creates new internal Ivy parser"() throws Exception {
        when:

        parser.parseNotation(" foo:bar ") == new UnversionedModuleComponentSelector(moduleIdentifierFactory.module("foo", "bar"))
    }

    def "parses module component identifier notation"() {
        expect:
        parser.parseNotation("org.gradle:gradle-core:1.+") == DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId("org.gradle", "gradle-core"), new DefaultMutableVersionConstraint("1.+"))

	cases := []struct {
		name               string
		xfccHeader         string
		caller             *security.Caller
		authenticateErrMsg string
		useHttpRequest     bool //nolint
	}{
		{
			name:               "No xfcc header",
			xfccHeader:         "",
			authenticateErrMsg: "caller from 127.0.0.1:2301 does not have Xfcc header",
		},
		{
			name:               "junk xfcc header",

    public void configure(CommandLineParser parser) {
        welcomeMessageConfigurationCommandLineConverter.configure(parser);
        loggingConfigurationCommandLineConverter.configure(parser);
        parallelConfigurationCommandLineConverter.configure(parser);
        projectPropertiesCommandLineConverter.configure(parser);
        parser.allowMixedSubcommandsAndOptions();
        buildOptionsConverter.configure(parser);

		},
		{
			name:                    "unknown caller",
			caller:                  ztunnelCaller,
			trustedAccounts:         allowZtunnel,
			requestedIdentityString: podSameNode.Identity(),
			pods:                    []pod{podSameNode},
			wantErr:                 "pod istio-system/ztunnel-a not found",
		},
		{
			name: "bad UID",
			caller: func(k security.KubernetesInfo) security.KubernetesInfo {

				"\"stack\":\".*\"}",
			json:       true,
			caller:     true,
			stackLevel: DebugLevel,
		},
		{
			f: func() { Warn("Hello") },
			pat: "{\"level\":\"warn\",\"time\":\"" + timePattern + "\",\"caller\":\"log/default_test.go:.*\",\"msg\":\"Hello\"," +
				"\"stack\":\".*\"}",
			json:       true,
			caller:     true,

    NotationParser<Object, IvyArtifact> parser

    def "setup"() {
        def fileResolver = Stub(FileResolver) {
            asNotationParser() >> fileNotationParser
        }
        def identity = TestUtil.objectFactory().newInstance(IvyPublicationCoordinates)
        identity.getModule().set('pub-name')

        System.out.println(">>> Measuring format: " + packerName + " with accessor " + accessorName);
        Packer packer = PACKERS.get(packerName);
        DataAccessor accessor = ACCESSORS.get(accessorName);
        this.inputs = createInputFiles(fileCount, minFileSize, maxFileSize, accessor);
        this.sample = packSample("sample." + packerName, inputs, packer, accessor);
    }

    @TearDown(Level.Trial)

		certChain          [][]*x509.Certificate
		caller             *security.Caller
		authenticateErrMsg string
		fakeAuthInfo       *mockAuthInfo
	}{
		"No client certificate": {
			certChain:          nil,
			caller:             nil,
			authenticateErrMsg: "no client certificate is presented",
		},
		"Unsupported auth type": {
			certChain:          nil,
			caller:             nil,

  // parse schema first, so we can use it to parse the data after
  flatbuffers::Parser parser;
  const bool schema_parse_result =
      parser.Parse(schema.c_str()) && parser.Parse(json.c_str());
  if (!schema_parse_result) {
    std::cerr << "Parse error.\n";
    return 1;
  }
  const size_t length = parser.builder_.GetSize();
  const size_t n =
      std::fwrite(parser.builder_.GetBufferPointer(), 1, length, stdout);
  if (n != length) {