MojoExecution result = new MojoExecution(plugin, goal, executionId);
        result.setConfiguration(XmlNode.newInstance(executionId + "-" + goal));
        result.setMojoDescriptor(mojoDescriptor);
        result.setLifecyclePhase(mojoDescriptor.getPhase());

        return result;
    }

    public static MojoDescriptor createMojoDescriptor(String phaseName) {

                }))
                .status(ApiResult.Status.OK)
                .result());
    }

    /**
     * Creates a new synonym dictionary item.
     *
     * @param dictId the dictionary ID
     * @param body the request body containing synonym item information
     * @return JSON response with result status
     */
    // POST /api/admin/dict/synonym/setting/{dictId}
    @Execute

		{"config/iam/groups/foo/config.json", "config/iam/groups/", "config.json", "foo"},
	}
	for i, test := range specs {
		result := extractPathPrefixAndSuffix(test.path, test.prefix, test.suffix)
		if result != test.expected {
			t.Errorf("unexpected result on test[%v]: expected[%s] but had [%s]", i, test.expected, result)
		}
	}

     * Default constructor.
     */
    public SearchBody() {
        super();
    }

    // `size` is an alias of `num`.
    // `size` is prepared to be compatible with other Admin APIs
    /** Number of search results to retrieve (alias for num) */
    @ValidateTypeFailure
    public Integer size;

    @Override
    public void initialize() {
        if (size != null) {
            num = num == null || num < size ? size : num;

app = FastAPI()


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item, q: Union[str, None] = None):
    result = {"item_id": item_id, **item.model_dump()}
    if q:
        result.update({"q": q})

    @Override
    public void merge(File existing, File result) throws RepositoryException {
        merge(existing != null ? existing.toPath() : null, result != null ? result.toPath() : null);
    }

    @Override
    public void merge(Path existing, Path result) throws RepositoryException {
        Metadata recessive = read(existing);

        merge(recessive);

        write(result, metadata);

        merged = true;
    }

    assertEquals("[1, 2, 3, 4, 5, 6]", result.toString());
  }

  public void testAppend_toEmpty() {
    FluentIterable<Integer> result =
        FluentIterable.<Integer>of().append(Lists.newArrayList(1, 2, 3));
    assertEquals(asList(1, 2, 3), Lists.newArrayList(result));
  }

  public void testAppend_emptyList() {
    FluentIterable<Integer> result =

    val result = Buffer()
    result.zstdCompress().buffer().use {
      it.write(this@zstdCompress)
    }
    return result.readByteString()
  }

  private fun ByteString.gzipCompress(): ByteString {
    val result = Buffer()
    (result as Sink).gzip().buffer().use {
      it.write(this@gzipCompress)
    }
    return result.readByteString()
  }

        String result = dcerpcBinding.toString();
        assertTrue(result.startsWith(PROTO + ":" + SERVER + "[null,"), "toString should start correctly.");
        assertTrue(result.contains("connect=80"), "toString should contain connect option.");
        assertTrue(result.contains("bind=123"), "toString should contain bind option.");
    }

    @Test

        } else {
          call.eventListener.dnsStart(call, socketHost)

          val result = address.dns.lookup(socketHost)
          if (result.isEmpty()) {
            throw UnknownHostException("${address.dns} returned no addresses for $socketHost")
          }

          call.eventListener.dnsEnd(call, socketHost, result)
          result
        }

      // Try each address for best behavior in mixed IPv4/IPv6 environments.