} else {
            result = text.substring(0, maxTextLength);
        }
        return result.replaceAll("\\s+", " ");
    }

    /**
     * Returns the supported language for a given language.
     *
     * @param lang The language to check.
     * @return The supported language, or null if not supported.
     */
    protected String getSupportedLanguage(final String lang) {

import org.jspecify.annotations.NullUnmarked;

/**
 * A generator of {@code TestSuite} instances for testing {@code CharSource} implementations.
 * Generates tests of all methods on a {@code CharSource} given various inputs the source is
 * expected to contain.
 *
 * @author Colin Decker
 */
@AndroidIncompatible // TODO(b/230620681): Make this available (even though we won't run it).
@NullUnmarked

      // copy the resources to the filesystem as needed
      testDir = createTempDir();
    }

    return testDir;
  }

  /** Returns the file with the given name under the testdata directory. */
  protected final @Nullable File getTestFile(String name) throws IOException {
    File file = new File(getTestDir(), name);
    if (!file.exists()) {

            return smbFile.exists();
        } catch (CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * Request directory lease for the given directory
     *
     * @param smbFile the directory to request lease for
     * @param requestedState requested lease state
     * @param scope cache scope
     * @return lease key or null if not supported

     * is an ArrayList of SIDs represents the local groups that the account is
     * a member of.
     *
     * This method is designed to assist with computing access control for a
     * given user when the target object's ACL has local groups. Local groups
     * are not listed in a user's group membership (e.g. as represented by the
     * tokenGroups constructed attribute retrieved via LDAP).
     *

16* drives.  Therefore, the number of drives you present must be a multiple of one of these numbers.  Each object is written to a single erasure-coding set.

Minio uses the largest possible EC set size which divides into the number of drives given. For example, *18 drives* are configured as *2 sets of 9 drives*, and *24 drives* are configured as *2 sets of 12 drives*.  This is true for scenarios when running MinIO as a standalone erasure coded deployment. In [distributed setup however node (affinity)...

        static {
            ALIASES.put("cr", "rc");
        }

        /**
         * A comparable value for the empty-string qualifier. This one is used to determine if a given qualifier makes
         * the version older than one without a qualifier, or more recent.
         */
        private static final String RELEASE_VERSION_INDEX = String.valueOf(QUALIFIERS.indexOf(""));

@SuppressWarnings("serial") // No serialization is used in this test
@GwtCompatible
@NullMarked
public class PeekingIteratorTest extends TestCase {

  /**
   * Version of {@link IteratorTester} that compares an iterator over a given collection of elements
   * (used as the reference iterator) against a {@code PeekingIterator} that *wraps* such an
   * iterator (used as the target iterator).
   *

                .filter(ChannelInfo::isHealthy)
                .collect(ArrayList::new, (list, item) -> list.add(item), (list1, list2) -> list1.addAll(list2));
    }

    /**
     * Select a channel for the given message
     *
     * @param message message to send
     * @return selected channel
     */
    public ChannelInfo selectChannel(CommonServerMessageBlock message) {

    assertWithMessage("Min long").that(Ints.tryParse(Long.toString(Long.MIN_VALUE))).isNull();
    assertThat(Ints.tryParse("\u0662\u06f3")).isNull();
  }

  /**
   * Applies {@link Ints#tryParse(String)} to the given string and asserts that the result is as
   * expected.
   */
  private static void tryParseAndAssertEquals(Integer expected, String value) {
    assertThat(Ints.tryParse(value)).isEqualTo(expected);
  }