Methode qui teste si une chaine ne contient que des caracteres alphanumeriques
@param text	Chaine a tester
@return	Statut de contenance
326917
public static boolean isAlphaNumericString(String text){
		
		// Le Pattern representant une chaine AlphaNumerique
		Pattern pattern = Pattern.compile("\\w+");
		
		// Test
		return (text != null) && (text.trim().length() > 0) && (pattern.matcher(text).matches());
	}
880989
public Snackbar text(CharSequence text) {
        mText = text;
        if (snackbarText != null) {
            snackbarText.setText(mText);
        }
        return this;
    }
591322
public void setAsText(final String text) {
        if (BeanUtils.isNull(text)) {
            setValue(null);
            return;
        }
        try {
            Object newValue = Short.decode(text);
            setValue(newValue);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Failed to parse short.", e);
        }
    }
336134
public static boolean hasText(final String text) {
		if (text != null && !"".equals(text.trim())) {
			return true;
		}
		return false;
	}
64058
public static Condition exactText(final String text) {
    return new Condition("exact text") {
      @Override
      public boolean apply(Driver driver, WebElement element) {
        return Html.text.equals(element.getText(), text);
      }

      @Override
      public String toString() {
        return name + " '" + text + '\'';
      }
    };
  }
1064245
public Element text(String text) {
        Validate.notNull(text);

        empty();
        TextNode textNode = new TextNode(text);
        appendChild(textNode);

        return this;
    }
370138
public String encryptText(String text)
	throws Exception
	{
		return toByteText(this.encrypt(text.getBytes(IO.CHARSET)));

	}
674803
public int search(String text) {

        // Searching
        int i = pattern.length() - 1;
        int j = pattern.length() - 1;
        while (i < text.length()) {
            if (pattern.charAt(j) == text.charAt(i)) {
                if (j == 0) {
                    //the left-most match is found
                    return i;
                }
                j--;
                i--;
            } else { //a difference
                i += pattern.length() - j - 1 + Math.max(j - last[text.charAt(i)], match[j]);
                j = pattern.length() - 1;
            }
        }
        return -1;
    }
1183327
public List<Term> seg(char[] text)
    {
        assert text != null;
        if (HanLP.Config.Normalization)
        {
            CharTable.normalization(text);
        }
        return segSentence(text);
    }
1011297
public static String[] simpleTokenize(String text) {
		if (GeneralUtils.isEmpty(text))
			return null;
		return text.split("[ ,.;:><^`�\\]\\[}{|��+_)(*&�%$#@!=\\-?�\\/\"]+", -1);
	}
715387
public static String keepNumbers(String text) {
        StringBuffer sb = new StringBuffer();
        for (int k = 0; k < text.length(); ++k) {
            char c = text.charAt(k);
            if (c >= '0' && c <= '9')
                sb.append(c);
        }
        return sb.toString();
    }
950135
public boolean hasText(String text) throws WidgetException {
		try {
			Element element = new Element(getByLocator());
			List<WebElement> childElements = element.getWebElement().findElements(By.xpath(".//*"));
			for (WebElement we : childElements) {
				if (we.getText().contains(text)) {
					return true;
				}
			}

			return false;
		} catch (Exception e2) {
			throw new WidgetException("Error while determining if element has text '" + text + "'", getByLocator(), e2);
		}
	}
1225267
static String getPattern(String text) {
		int length = text.length();

		if (length > 23) {
			return FULL;
		}
		if (length > 20) {
			return LONG;
		}
		if (length > 11) {
			return NORMAL;
		}
		return SHORT;
	}
921465
public static boolean has(String text){
        for(char c : text.toCharArray()){
            if(is(c)){
                return true;
            }
        }
        return false;
    }
706786
protected boolean verifyPatternMatch(String text) {
		if (this.expectedPattern == null) {
			return false;
		}
		return this.expectedPattern.matcher(text).matches();
	}
30424
public CharSequence getCoveredText(CharSequence text) {
    if (getEnd() > text.length()) {
      throw new IllegalArgumentException("The span " + toString()
          + " is outside the given text!");
    }

    return text.subSequence(getStart(), getEnd());
  }
648911
protected Number parseNumber(String text) {
        if (INTEGER_PATTERN.matcher(text).matches()) {
            return Integer.parseInt(text);
        }

        if (DOUBLE_PATTERN.matcher(text).matches()) {
            return Double.parseDouble(text);
        }

        if (FLOAT_PATTERN.matcher(text).matches()) {
            return Float.parseFloat(text);
        }

        return null;
    }