The input parameter must contain the string c. if yes, the check passes

@param c contained strings
@return Validation
3098
public static Validation<String> contains(String c) {
        return contains(c, I18N_MAP.get(i18nPrefix + "CONTAINS"));
    }
177156
private static int decodeHex(final char c) {
    if (c < '0') {
      return INVALID;
    }
    if (c <= '9') {
      return c - '0';
    }
    if (c < 'A') {
      return INVALID;
    }
    if (c <= 'F') {
      return c - 'A' + 10;
    }
    if (c < 'a') {
      return INVALID;
    }
    if (c <= 'f') {
      return c - 'a' + 10;
    }
    return INVALID;
  }
394473
private boolean validParameter(final String s) {
        final String[] tokens = PARAMS_REGEX.split(s);
        if (tokens.length != 2) {
            return false;
        }

        final char first = s.charAt(0);
        String second = tokens[1];
        if (second.endsWith(VARARGS_SUFFIX)) {
            // value encoding / return type var args, mangle argument
            second = varargsRoot(second);
        }

        if (first == 'E') {
            if (isWildcard(second)) {
                return true;
            }

            // Verify value encoding exists as an enum
            if (getValueEncoding(second) != null) {
                return true;
            }

            // Fallback to verification based on all character discriminators
            for (final Character c : second.toCharArray()) {
                if (getValueEncoding(c) == null) {
                    return false;
                }
            }
            return true;
        } else if (first == 'F') {
            // Verify return type exists as an enum
            if (ReturnType.getReturnType(second) != null) {
                return true;
            }
        }
        return false;
    }
128010
public static void validate(final String string, final List<String> params) {
        final List<String> vars = findVars(string);
        for (String param : params) {
            Preconditions.checkState(vars.contains(param),
                    "Variable '%s' not found in target string '%s'", param, string);
        }
        vars.removeAll(params);
        Preconditions.checkState(vars.isEmpty(),
                "No parameter binding defined for variables '%s' from string '%s'",
                Joiner.on(',').join(vars), string);
    }
1070415
function (c) {

// If a c parameter is provided, verify that it matches the current character.

            if (c && c !== ch) {
                error("Expected '" + c + "' instead of '" + ch + "'");
            }

// Get the next character. When there are no more characters,
// return the empty string.

            ch = text.charAt(at);
            at += 1;
            return ch;
        }
285294
public static <T extends CharSequence> T validateWord(T value, String errorMsg) throws ValidateException {
		if (false == isWord(value)) {
			throw new ValidateException(errorMsg);
		}
		return value;
	}
172425
public static Function<Object,Character> c(final String methodName, final Object... optionalParameters) {
        return methodForCharacter(methodName, optionalParameters);
    }
598501
public final boolean contains(CharSequence s) {

        int cp = getSingleCP(s);
        if (cp < 0) {
            return strings.contains(s.toString());
        } else {
            return contains(cp);
        }
    }
809153
public static boolean checkCharacter(int c, boolean foundQuestionMark) throws IOException {
		if(foundQuestionMark) {
			switch(c) {
				case '.':
				case '-':
				case '*':
				case '_':
				case '+': // converted space
				case '%': // encoded value
				// Other characters used outside the URL data
				//case ':':
				//case '/':
				//case '@':
				//case ';':
				//case '?':
				// Parameter separators
				case '=':
				case '&':
				// Anchor separator
				case '#':
					return true;
				default:
					if(
						(c<'a' || c>'z')
						&& (c<'A' || c>'Z')
						&& (c<'0' || c>'9')
					) throw new IOException(ApplicationResources.accessor.getMessage("UrlValidator.invalidCharacter", Integer.toHexString(c)));
					return true;
			}
		} else {
			return c=='?';
		}
	}
1314663
public static String shrink(String string, char c) {
		if (string == null) {
			return null;
		}
		string = string.trim();
		Pattern pattern = Pattern.compile("\\" + String.valueOf(c) + "{2,}");
		return pattern.matcher(string).replaceAll(String.valueOf(c));
	}
1176162
public static String getName(final Constructor<?> c) {
		StringBuilder ret = new StringBuilder("(");
		Class<?>[] parameterTypes = c.getParameterTypes();
		for (int i = 0; i < parameterTypes.length; i++) {
			if (i > 0)
				ret.append(',');
			ret.append(getName(parameterTypes[i]));
		}
		ret.append(')');
		return ret.toString();
	}
924122
private static boolean isAllowed(char c, String allow) {
        return (c >= 'A' && c <= 'Z')
                || (c >= 'a' && c <= 'z')
                || (c >= '0' && c <= '9')
                || "_-!.~'()*".indexOf(c) != NOT_FOUND
                || (allow != null && allow.indexOf(c) != NOT_FOUND);
    }
522041
private static void verify(char[][] strings) {
        int length = strings.length;
        for (int i = 0; i < length; i++) {
            char[] a = strings[i];
            inner:
            for (int j = i + 1; j < length; j++) {
                char[] b = strings[j];
                if (b.length < a.length) continue;
                for (int k = 0; k < a.length; k++) {
                    if (a[k] != b[k]) continue inner;
                }
                String sa = '"' + String.valueOf(a) + '"';
                String sb = '"' + String.valueOf(b) + '"';
                String msg = a.length == b.length ? sa + " is specified twice in a FirstOf(String...)" : sa +
                        " is a prefix of " + sb + " in a FirstOf(String...) and comes before " +
                        sb + ", which prevents " + sb +
                        " from ever matching! You should reverse the order of the two alternatives.";
                throw new GrammarException(msg);
            }
        }
    }
648960
public static String validateInput(final String context,
			final String input, final String type, final int maxLength,
			final boolean allowNull, final boolean canonicalize)
			throws ValidationException {
		return validator.getValidInput(context, input, type, maxLength,
				allowNull, canonicalize);
	}
476345
private boolean containsEliminated(final CLClause c) {
        for (int i = 0; i < c.lits().size(); i++) { if (var(c.lits().get(i)).state() == CLVar.State.ELIMINATED) { return true; } }
        return false;
    }
899097
public static boolean in( char c, String str ) {
        return Chr.in ( c, FastStringUtils.toCharArray(str) );
    }
582334
@Override
  public ValidationResult validateCode(String system, String code, String display) {
    Coding c = new Coding(system, code, display);
    return validateCode(c, null);
  }