* specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.settings.building;

import org.apache.maven.building.StringSource;

/**
 * Wraps an ordinary {@link CharSequence} as a settings source.
 *
 *
 * @deprecated instead use {@link StringSource}
 */
@Deprecated
public class StringSettingsSource extends StringSource implements SettingsSource {

    /**

  public void testContainsPattern_apply() {
    Predicate<CharSequence> isFoobar = Predicates.containsPattern("^Fo.*o.*bar$");
    assertTrue(isFoobar.apply("Foxyzoabcbar"));
    assertFalse(isFoobar.apply("Foobarx"));
  }

  @GwtIncompatible // Predicates.containsPattern
  public void testContains_apply() {
    Predicate<CharSequence> isFoobar = Predicates.contains(Pattern.compile("^Fo.*o.*bar$"));

 *   protected Object handleInvocation(Object proxy, Method method, Object[] args) {
 *     throw new UnsupportedOperationException();
 *   }
 * }
 *
 * CharSequence unsupported = Reflection.newProxy(CharSequence.class, new Unsupported());
 * </pre>
 *
 * @author Ben Yu
 * @since 12.0
 */
public abstract class AbstractInvocationHandler implements InvocationHandler {

        return str == null ? defaultStr : str;
    }

    /**
     * <p>Checks if the CharSequence contains only ASCII printable characters.</p>
     *
     * <p>{@code null} will return {@code false}.
     * An empty CharSequence (length()=0) will return {@code true}.</p>
     *
     * <pre>
     * StringUtils.isAsciiPrintable(null)     = false

        }
        return this;
      }

      @Override
      public Hasher putUnencodedChars(CharSequence chars) {
        for (Hasher hasher : hashers) {
          hasher.putUnencodedChars(chars);
        }
        return this;
      }

      @Override
      public Hasher putString(CharSequence chars, Charset charset) {
        for (Hasher hasher : hashers) {
          hasher.putString(chars, charset);

import jakarta.validation.ConstraintValidatorContext;

/**
 * Validator implementation for the CustomSize constraint.
 */
public class CustomSizeValidator implements ConstraintValidator<CustomSize, CharSequence> {

    /**
     * Default constructor.
     */
    public CustomSizeValidator() {
        // Empty constructor
    }

    private int min = 0;
    private int max = Integer.MAX_VALUE;

   *
   * <p><b>Note:</b> When implementing an escaper it is a good idea to override this method for
   * efficiency by inlining the implementation of {@link #nextEscapeIndex(CharSequence, int, int)}
   * directly. Doing this for {@link com.google.common.net.PercentEscaper} more than doubled the
   * performance for unescaped strings (as measured by {@code CharEscapersBenchmark}).
   *

   * surprising behavior of {@code toUpperCase()} and {@code toLowerCase()}.
   *
   * @since 16.0
   */
  public static boolean equalsIgnoreCase(CharSequence s1, CharSequence s2) {
    // Calling length() is the null pointer check (so do it before we can exit early).
    int length = s1.length();
    if (s1 == s2) {
      return true;
    }
    if (length != s2.length()) {

    }

    private static boolean isEmpty(Object value) {
      // Put types estimated to be the most frequent first.
      if (value instanceof CharSequence) {
        return ((CharSequence) value).length() == 0;
      } else if (value instanceof Collection) {
        return ((Collection<?>) value).isEmpty();
      } else if (value instanceof Map) {

  }

  public void testGetGenericSuperclass_wildcard_boundIsInterface() {
    assertThat(TypeToken.of(Types.subtypeOf(CharSequence.class)).getGenericSuperclass()).isNull();
    assertEquals(
        new TypeToken<CharSequence[]>() {},
        TypeToken.of(Types.subtypeOf(CharSequence[].class)).getGenericSuperclass());
  }

  public <T> void testGetGenericInterfaces_typeVariable_unbounded() {