Not a problem on UNIX type systems since the OS handles is case sensitive.
354978
public static boolean uriCaseCheck(File file, String matchString) throws java.io.IOException {

        if (isCaseInsensitive || isWindows) { // security measure to ensure that this check is only performed on case
            // sensitive servers

            // begin 154268
            matchString = WSUtil.resolveURI(matchString);
            // (removed since it is changed to "//" inside of resolveURI
            // matchString = matchString.replace ('/', '\\'); // change string from
            // url format to Windows format
            // end 154268

            matchString = matchString.replace('/', File.separatorChar);
            String canPath = file.getCanonicalPath();
            // begin 540920 change for drive letter ignore case on Win 2008
            int offset = 0;
            int inx = matchString.length();
            if (isWindows && inx > 1 && canPath.length() > 0 && matchString.charAt(1) == ':') {
                // check that the string to match starts with a drive letter (':'), and
                // the drive letter is the same as canonical
                if (!(matchString.substring(0, 1).equalsIgnoreCase(canPath.substring(0, 1)))) {
                    return false;
                }
                // make the offset 1 for the regionMatches so that we do not compare the
                // drive letters
                offset = 1;
            }
            return canPath.regionMatches(canPath.length() - inx + offset, matchString, offset, inx - offset);
            // end 540920
        }
        return true;
    }
29837
private static boolean isNameCase(String str) {
    if (str.length() < 2) {
      return false;
    }
    if (!(Character.isUpperCase(str.charAt(0)) || Character.isTitleCase(str.charAt(0)))) {
      return false;
    }
    for (int i = 1; i < str.length(); i++) {
      if (Character.isUpperCase(str.charAt(i))) {
        return false;
      }
    }
    return true;
  }
1107903
def sbo_case_insensitive(self):
        
        if "--case-ins" in self.flag:
            data = SBoGrep(name="").names()
            data_dict = Utils().case_sensitive(data)
            for key, value in data_dict.iteritems():
                if key == self.name.lower():
                    self.name = value
613324
public static boolean containsIgnoreCase(String pString, int pChar) {
        return ((pString != null)
                && ((pString.indexOf(Character.toLowerCase((char) pChar)) >= 0)
                || (pString.indexOf(Character.toUpperCase((char) pChar)) >= 0)));

        // NOTE: I don't convert the  string to uppercase, but instead test
        // the string (potentially) two times, as this is more efficient for
        // long strings (in most cases).
    }
651588
protected String caseInsensitiveHeader(String orig, String normative) {
        if (_compliances.contains(HttpComplianceSection.FIELD_NAME_CASE_INSENSITIVE))
            return normative;
        if (!orig.equals(normative))
            handleViolation(HttpComplianceSection.FIELD_NAME_CASE_INSENSITIVE, orig);
        return orig;
    }
208927
boolean isEnvKeyInteresting(final String key) {
    final List<String> disallowedKeys = Arrays.asList("windir", "SystemDrive", "CommonProgramFiles", "ComSpec", "SystemRoot", "Path", "ProgramFiles");

    if (key == null || key.length() == 0)
      return false;
    // No all-uppercase keys
    if (key.toUpperCase().equals(key))
      return false;
    // No keys in the list
    if (disallowedKeys.contains(key))
      return false;

    return true;
  }
691365
void expectSwitchMatchesCase(Node n, JSType switchType, JSType caseType) {
    // ECMA-262, page 68, step 3 of evaluation of CaseBlock,
    // but allowing extra autoboxing.
    // TODO(user): remove extra conditions when type annotations
    // in the code base have adapted to the change in the compiler.
    if (!switchType.canTestForShallowEqualityWith(caseType)
        && (caseType.autoboxesTo() == null || !caseType.autoboxesTo().isSubtypeOf(switchType))) {
      mismatch(n.getFirstChild(), "case expression doesn't match switch", caseType, switchType);
    } else if (!switchType.canTestForShallowEqualityWith(caseType)
        && (caseType.autoboxesTo() == null
            || !caseType.autoboxesTo().isSubtypeWithoutStructuralTyping(switchType))) {
      TypeMismatch.recordImplicitInterfaceUses(this.implicitInterfaceUses, n, caseType, switchType);
      TypeMismatch.recordImplicitUseOfNativeObject(this.mismatches, n, caseType, switchType);
    }
  }
976324
def bin_case_insensitive(self):
        
        if "--case-ins" in self.flag:
            data_dict = Utils().case_sensitive(self.names)
            for key, value in data_dict.iteritems():
                if key == self.name.lower():
                    self.name = value
450266
def is_unix_style(flags):
    """"""

    return (util.platform() != "windows" or (not bool(flags & REALPATH) and get_case(flags))) and not flags & _FORCEWIN
506634
def DoesNotContainIgnoreCase(self, value):
    
    self._awql = self._CreateSingleValueCondition(
        value, 'DOES_NOT_CONTAIN_IGNORE_CASE')
    return self._query_builder
678201
def normcase(self, path):
        """"""
        path = self.filesystem.normcase(path)
        if self.filesystem.is_windows_fs:
            path = path.lower()
        return path
1143385
public static function isSupportedShell()
    {
        if (strtoupper(substr(PHP_OS, 0, 3)) === 'WIN') {
            return false !== getenv('ANSICON') || 'ON' === getenv('ConEmuANSI') || 'xterm' === getenv('TERM');
        }

        return defined('STDOUT') && function_exists('posix_isatty') && posix_isatty(STDOUT);
    }
942053
function stringCase(str, caseValue) {
		switch (String(caseValue || '').toLowerCase()) {
			case 'lower':
				return str.toLowerCase();
			case 'upper':
				return str.toUpperCase();
		}
		
		return str;
	}
1950
def CheckUpperLowerCase(filename, linenumber, clean_lines, errors):
    
    line = clean_lines.lines[linenumber]
    if ContainsCommand(line):
        command = GetCommand(line)
        if IsCommandMixedCase(command):
            return errors(
                    filename,
                    linenumber,
                    'readability/wonkycase',
                    'Do not use mixed case commands')
        if clean_lines.have_seen_uppercase is None:
            clean_lines.have_seen_uppercase = IsCommandUpperCase(command)
        else:
            is_upper = IsCommandUpperCase(command)
            if is_upper != clean_lines.have_seen_uppercase:
                return errors(
                        filename,
                        linenumber,
                        'readability/mixedcase',
                        'Do not mix upper and lower case commands')
586393
private static boolean isCollationCorrect(String collation) {
    return containsIgnoreCase(collation, CASE_SENSITIVE_ACCENT_SENSITIVE)
      || containsIgnoreCase(collation, BIN)
      || containsIgnoreCase(collation, BIN2);
  }
762947
public static boolean isCaseInsensitive()
  {
    Boolean value = _caseInsensitive.get();

    if (value == null) {
      return _isCaseInsensitive;
    }
    else
      return value.booleanValue();
  }
276975
public static boolean acceptsPrecision(int type) {

        switch (type) {

            case Types.SQL_BINARY :
            case Types.SQL_BIT :
            case Types.SQL_BIT_VARYING :
            case Types.SQL_BLOB :
            case Types.SQL_CHAR :
            case Types.SQL_NCHAR :
            case Types.SQL_CLOB :
            case Types.NCLOB :
            case Types.SQL_VARBINARY :
            case Types.SQL_VARCHAR :
            case Types.SQL_NVARCHAR :
            case Types.VARCHAR_IGNORECASE :
            case Types.SQL_DECIMAL :
            case Types.SQL_NUMERIC :
            case Types.SQL_FLOAT :
            case Types.SQL_TIME :
            case Types.SQL_TIMESTAMP :
            case Types.SQL_INTERVAL_YEAR :
            case Types.SQL_INTERVAL_YEAR_TO_MONTH :
            case Types.SQL_INTERVAL_MONTH :
            case Types.SQL_INTERVAL_DAY :
            case Types.SQL_INTERVAL_DAY_TO_HOUR :
            case Types.SQL_INTERVAL_DAY_TO_MINUTE :
            case Types.SQL_INTERVAL_DAY_TO_SECOND :
            case Types.SQL_INTERVAL_HOUR :
            case Types.SQL_INTERVAL_HOUR_TO_MINUTE :
            case Types.SQL_INTERVAL_HOUR_TO_SECOND :
            case Types.SQL_INTERVAL_MINUTE :
            case Types.SQL_INTERVAL_MINUTE_TO_SECOND :
            case Types.SQL_INTERVAL_SECOND :
            case Types.VOLT_GEOGRAPHY :
                return true;

            default :
                return false;
        }
    }