return nil
			}
			if entry == "" {
				continue
			}
			meta := metaCacheEntry{name: pathJoinBuf(sb, current, entry)}

			// If directory entry on stack before this, pop it now.
			for len(dirStack) > 0 && dirStack[len(dirStack)-1] < meta.name {
				pop := dirStack[len(dirStack)-1]
				select {
				case <-ctx.Done():
					return ctx.Err()

     * @param text
     *            the text to decrypt
     * @return the decrypted text
     */
    public String decryptText(final String text) {
        try {
            return new String(decrypt(Base64Util.decode(text)), charsetName);
        } catch (final UnsupportedEncodingException e) {
            throw new UnsupportedEncodingRuntimeException(e);
        }
    }

    /**
     * Decrypts the given text.
     *

        // Check that only the 2 bytes at offset were modified
        for (int i = 0; i < offset; i++) {
            assertEquals((byte) (i % 256), buffer[i], "Buffer before offset should be unchanged");
        }

        for (int i = offset + 2; i < buffer.length; i++) {
            assertEquals((byte) (i % 256), buffer[i], "Buffer after written data should be unchanged");
        }

        assertNotNull(trans2SetFileInfo);
    }

    @Test
    @DisplayName("Test concurrent access")
    void testConcurrentAccess() throws InterruptedException {
        // Setup mock before creating the object
        when(mockFileInfo.getFileInformationLevel()).thenReturn((byte) FileInformation.FILE_BASIC_INFO);
        trans2SetFileInfo = new Trans2SetFileInformation(config, TEST_FID, mockFileInfo);

                .build();

        CommandLine commandLine = parser.parse(options, cleanArgs);
        // to trigger deprecation handler, so we can report deprecation BEFORE we actually use options
        options.getOptions().forEach(commandLine::hasOption);
        return commandLine;
    }

    public Set<Option> getUsedDeprecatedOptions() {
        return usedDeprecatedOptions;

    prefixItems: Optional[list["SchemaOrBool"]] = None
    # TODO: uncomment and remove below when deprecating Pydantic v1
    # It generates a list of schemas for tuples, before prefixItems was available
    # items: Optional["SchemaOrBool"] = None
    items: Optional[Union["SchemaOrBool", list["SchemaOrBool"]]] = None
    contains: Optional["SchemaOrBool"] = None

    void setInactiveProfileIds(List<String> inactiveProfileIds);

    List<String> getInactiveProfileIds();

    /**
     * Add a {@link org.apache.maven.model.Profile} that has come from an external source. This may be from a custom
     * configuration like the MavenCLI settings.xml file, or from a custom dialog in an IDE integration like M2Eclipse.
     *
     * @param profile
     */

   * and returns it. Callers should use this to verify the request was sent as intended within the
   * given time.
   *
   * @param timeout how long to wait before giving up, in units of [unit]
   * @param unit a [TimeUnit] determining how to interpret the [timeout] parameter
   * @return the head of the request queue
   */
  @Throws(InterruptedException::class)

   * multimap, save that if all values associated with a key are removed and then the key is added
   * back into the multimap, that key will come last in the key iteration order.
   */
  public static MultimapBuilderWithKeys<@Nullable Object> linkedHashKeys() {
    return linkedHashKeys(DEFAULT_EXPECTED_KEYS);
  }

  /**

 *         .onResultOf(getBarFunction)
 *         .nullsLast();
 * }
 *
 * Note that each chaining method returns a new ordering instance which is backed by the previous
 * instance, but has the chance to act on values <i>before</i> handing off to that backing instance.
 * As a result, it usually helps to read chained ordering expressions <i>backwards</i>. For example,
 * when {@code compare} is called on the above ordering:
 *
 * <ol>