// No context mocks needed for static method test
        assertEquals(expected, SmbResourceLocatorImpl.queryLookup(query, key));
    }

    @Test
    @DisplayName("resolveInContext builds relative paths with and without share")
    void testResolveInContext() {
        // Context without share: first element becomes share, rest path
        SmbResourceLocatorImpl base = locator("smb://server/");

                        "Comma-delimited list of specified reactor projects to build instead of all projects. Don't use spaces between commas or double quote the full list. A project can be specified by [groupId]:artifactId or by its relative path. Prefixing a project with ! excludes it, and ? marks it as optional.")
                .hasArg()
                .build());
        options.addOption(Option.builder(ALSO_MAKE)
                .longOpt("also-make")

 * parameter and data buffer encoding, multi-part transactions, and setup word management.
 */
public abstract class SmbComTransaction extends ServerMessageBlock implements Enumeration<SmbComTransaction> {

    // relative to headerStart
    private static final int PRIMARY_SETUP_OFFSET = 61;
    private static final int SECONDARY_PARAMETER_OFFSET = 51;

    static final int DISCONNECT_TID = 0x01;

        setHeaderStart(response, 64);

        // Write structure header (9 bytes)
        SMBUtil.writeInt2(9, buffer, offset); // Structure size
        SMBUtil.writeInt2(80 - 64, buffer, offset + 2); // Buffer offset (relative to header)
        SMBUtil.writeInt4(50, buffer, offset + 4); // Total length of notification data

        // Write notification data at buffer offset 80
        int notifyOffset = 80;

        // When
        request.encode(buffer, headerStart);

        // Then
        int bodyOffset = headerStart + Smb2Constants.SMB2_HEADER_LENGTH;
        // Path offset should be relative to headerStart
        int pathOffset = SMBUtil.readInt2(buffer, bodyOffset + 4);
        int expectedOffset = Smb2Constants.SMB2_HEADER_LENGTH + 8;
        assertEquals(expectedOffset, pathOffset);
    }

     * weight from the default (16) to a new value.
     *
     * @param streamId stream which has a priority change.
     * @param streamDependency the stream ID this stream is dependent on.
     * @param weight relative proportion of priority in `[1..256]`.
     * @param exclusive inserts this stream ID as the sole child of `streamDependency`.
     */
    fun priority(
      streamId: Int,
      streamDependency: Int,

e(null,g,r,i):I.apply(g,r)})}function wb(a){for(var b,c,e,f=a.length,g=d.relative[a[0].type],h=g||d.relative[" "],i=g?1:0,k=rb(function(a){return a===b},h,!0),l=rb(function(a){return K.call(b,a)>-1},h,!0),m=[function(a,c,d){return!g&&(d||c!==j)||((b=c).nodeType?k(a,c,d):l(a,c,d))}];f>i;i++)if(c=d.relative[a[i].type])m=[rb(sb(m),c)];else{if(c=d.filter[a[i].type].apply(null,a[i].matches),c[u]){for(e=++i;f>e;e++)if(d.relative[a[e].type])break;return vb(i>1&&sb(m),i>1&&qb(a.slice(0,i-1).concat({value:"...

                .map(container -> fixRepositoryExpressions(container, pomDocument, context))
                .reduce(false, Boolean::logicalOr);
    }

    /**
     * Fixes incorrect parent relative paths.
     */
    private boolean fixIncorrectParentRelativePaths(
            Document pomDocument, Path pomPath, Map<Path, Document> pomMap, UpgradeContext context) {
        Element root = pomDocument.root();

		var s string
		if lookup(EnvKMSSecretKeyFile) {
			b, err := os.ReadFile(env.Get(EnvKMSSecretKeyFile, ""))
			if err != nil && !os.IsNotExist(err) {
				return nil, err
			}
			if os.IsNotExist(err) {
				// Relative path where "/run/secrets" is the default docker path for secrets
				b, err = os.ReadFile(filepath.Join("/run/secrets", env.Get(EnvKMSSecretKeyFile, "")))
			}
			if err != nil {
				return nil, err
			}

    checkElementsNotNull((Object[]) array);
    Arrays.sort(array);
    return asImmutableList(array);
  }

  /**
   * Returns an immutable list containing the given elements, in sorted order relative to the
   * specified comparator. The sorting algorithm used is stable, so elements that compare as equal
   * will stay in the order in which they appear in the input.
   *