TODO: check the input in TEST MODE
969631
@Override
    public VariableNullability appendNewVariables(ImmutableMap<Variable, Variable> nullabilityBindings) {
        ImmutableList<ImmutableSet<Variable>> groupList = ImmutableList.copyOf(nullableGroups);
        ImmutableMap<Variable, Integer> originalVariableMap = extractVariableMap(groupList);

        AtomicInteger groupCount = new AtomicInteger(groupList.size());

        ImmutableMultimap<Integer, Variable> newVariableMultimap = nullabilityBindings.entrySet().stream()
                .collect(ImmutableCollectors.toMultimap(
                        e -> e.getKey().equals(e.getValue())
                                ? groupCount.getAndIncrement()
                                : originalVariableMap.get(e.getValue()),
                        Map.Entry::getKey));

        ImmutableSet<ImmutableSet<Variable>> newNullableGroups = IntStream.range(0, groupCount.get())
                .boxed()
                .map(i -> i < groupList.size()
                        ? Sets.union(groupList.get(i), ImmutableSet.copyOf(newVariableMultimap.get(i)))
                            .immutableCopy()
                        : ImmutableSet.copyOf(newVariableMultimap.get(i)))
                .collect(ImmutableCollectors.toSet());

        return new VariableNullabilityImpl(newNullableGroups);
    }
131242
public static boolean isValidJavaClassName(String input) {
		if (!StringUtils.hasText(input)) {
			return false;
		}
		if (!Character.isJavaIdentifierStart(input.charAt(0))) {
			return false;
		}
		if (input.length() > 1) {
			for (int i = 1; i < input.length(); i++) {
				if (!Character.isJavaIdentifierPart(input.charAt(i))) {
					return false;
				}
			}
		}
		return true;
	}
317947
@Override
    public boolean isValid(Object input) {
        String str = input.toString();
        int len = str.length();
        if (minLength != null && len < minLength)
            return false;
        if (maxLength != null && len > maxLength)
            return false;

        return regex == null || str.matches(regex);
    }
233781
function parseInput(input) {
  var match = re.exec(input);

  if (match !== null) {
    var _match = _slicedToArray(match, 6),
        pre_keyword = _match[1],
        operator_keyword = _match[2],
        value = _match[3],
        unit = _match[4],
        post_keyword = _match[5];

    if (pre_keyword && post_keyword || pre_keyword && operator_keyword || post_keyword && operator_keyword) {
      return null;
    }

    return {
      value: sanitizeValue({
        value: value,
        operator_keyword: operator_keyword,
        post_keyword: post_keyword
      }),
      unit: unit
    };
  }

  return null;
}
1018141
@Override
    public boolean condition(Object input) {
        Number n = (Number) input;
        return op.apply(n.longValue(), (value == null ? 0 : value), set);
    }
1005776
private boolean checkAnswer(String input) {
        StringTokenizer tok = new StringTokenizer(validAnswers, ANSWER_SEPARATOR);

        while (tok.hasMoreTokens()) {
            if (tok.nextElement().toString().trim().equalsIgnoreCase(input.trim())) {
                return true;
            }
        }

        log.info("User input is not valid - must be one of " + validAnswers);

        return false;
    }
218880
function () {
        var s = null;
        if (PFT.tester._suites.length > 0) {
            s = PFT.tester._suites[PFT.tester._suites.length - 1];
        }
        return s;
    }
56900
function init(input) {

		// rgba
		result = /rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]?(?:\.[0-9]+)?)\s*\)/.exec(input);
		if (result) {
			rgba = [pInt(result[1]), pInt(result[2]), pInt(result[3]), parseFloat(result[4], 10)];
		} else { // hex
			result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(input);
			if (result) {
				rgba = [pInt(result[1], 16), pInt(result[2], 16), pInt(result[3], 16), 1];
			}
		}

	}
1370193
function(input) {
        var state = this.state;
        var eventType = input.eventType;

        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);
        var isValid = this.attrTest(input);

        // on cancel input and we've recognized before, return STATE_CANCELLED
        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {
            return state | STATE_CANCELLED;
        } else if (isRecognized || isValid) {
            if (eventType & INPUT_END) {
                return state | STATE_ENDED;
            } else if (!(state & STATE_BEGAN)) {
                return STATE_BEGAN;
            }
            return state | STATE_CHANGED;
        }
        return STATE_FAILED;
    }
381437
function( input ) {

		if ( input == null ) {

			input = this.result;

		}

			this.result = input.replace(/(\s[\u0645]+[\u06CC])+\s/g, "$1\u200C");

			this.result = this.result.replace(/([\u0647])+\s+([\u0627]+[\u0645]||[\u0627]+[\u0649]||[\u0627]+[\u0649]+[\u0649]||[\u0627]+[\u0649]+[\u0645]||[\u0649]+[\u0646]+[\u062f]||[\u0627]+[\u0649]+[\u062f])/g, "$1\u200C$2");

			return this;

	}
1042239
@Override
    public boolean condition(Object input) {
        Number d = (Number) input;
        return op.apply(d.doubleValue(), (value == null ? Double.NaN : value), set);
    }
278252
@Override
    public boolean condition(Object input) {
        Number n = (Number) input;
        switch (op) {
            case LessThan:
                return n.intValue() < value;
            case LessOrEqual:
                return n.intValue() <= value;
            case GreaterThan:
                return n.intValue() > value;
            case GreaterOrEqual:
                return n.intValue() >= value;
            case Equal:
                return n.intValue() == value;
            case NotEqual:
                return n.intValue() != value;
            case InSet:
                return set.contains(n.intValue());
            case NotInSet:
                return !set.contains(n.intValue());
            default:
                throw new RuntimeException("Unknown or not implemented op: " + op);
        }
    }
1281509
public final String input() throws RecognitionException {
        String value = null;


        String unquoted_string3 =null;

        String quoted_string4 =null;


        try {
            // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:87:3: ( unquoted_string | quoted_string )
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==STRING) ) {
                alt6=1;
            }
            else if ( ((LA6_0 >= STRING_WITH_QUOTE && LA6_0 <= STRING_WITH_QUOTE_DOUBLE)) ) {
                alt6=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;

            }
            switch (alt6) {
                case 1 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:87:5: unquoted_string
                    {
                    pushFollow(FOLLOW_unquoted_string_in_input238);
                    unquoted_string3=unquoted_string();

                    state._fsp--;


                     value = unquoted_string3; 

                    }
                    break;
                case 2 :
                    // C:\\Project\\Obdalib\\obdalib-parent\\obdalib-core\\src\\main\\java\\it\\unibz\\inf\\obda\\gui\\swing\\utils\\MappingFilter.g:88:5: quoted_string
                    {
                    pushFollow(FOLLOW_quoted_string_in_input246);
                    quoted_string4=quoted_string();

                    state._fsp--;


                     value = quoted_string4; 

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return value;
    }
919593
private boolean checkText(final Characters paramEvent) {
        assert paramEvent != null;
        final String text = paramEvent.getData().trim();
        return mWtx.getNode().getKind() == IConstants.TEXT && mWtx.getValueOfCurrentNode().equals(text);
    }
1022787
public boolean verify(JComponent input) {
        JTextField tf = (JTextField) input;
        try {
            int inputInt = Integer.parseInt(tf.getText());
            return (inputInt >= min && inputInt <= max);
        } catch (NumberFormatException e) {
            return false;
        }
    }
1145415
function input(s,startIndex,_debug) {
  startIndex=startIndex || 0;
  var _this=this;
  return _input(s,startIndex,'start',[],startIndex-1);
  function _input(s,startIndex,fromState,stack,lastIndex) {
    recur:do {
      var c,range,advanceIndex,lastResult;
      var path=_this.router[fromState];
      if (!path) break;
      var eMove=path.eMove,charMove=path.charMove,trans;
      if (startIndex<s.length) {
        c=s[startIndex];
        if (charMove.hasOwnProperty(c)) {
          trans=charMove[c];
        } else if (range=findRange(path.ranges,c)) {
          trans=charMove[range];
        } else {
          trans=eMove;
        }
      } else {
        trans=eMove;
      }

      var sp=stack.length,t,skip,ret,oldLastIndex=lastIndex;
      for (var j=0,n=trans.length;j<n;j++) {
        t=trans[j];
        advanceIndex=t.eMove?0:1;
        lastIndex=oldLastIndex;
        stack.splice(0,stack.length-sp);
        sp=stack.length; // backup stack length
        if (t.assert) {
          if ((skip=t.assert(stack,c,startIndex,fromState,s))===false) continue;
          // For backref skip num chars
          if (typeof skip==='number') {startIndex+=skip;lastIndex+=skip;}
        }
        if (t.action) stack=t.action(stack,c,startIndex,fromState,s) || stack;
        lastIndex=t.eMove?lastIndex:startIndex;
        _debug && K.log(c+":"+fromState+">"+t.to);
        if (j===n-1) {
          startIndex+=advanceIndex;
          fromState=t.to;
          continue recur; // Human flesh tail call optimize?
        } else {
          ret=_input(s,startIndex+advanceIndex,t.to,stack,lastIndex);
        }
        if (ret.acceptable) return ret;
        lastResult=ret;
      }
      if (lastResult) return lastResult;
      break;
    } while (true);

    return {
      stack:stack,lastIndex:lastIndex,lastState:fromState,
      acceptable:_this.accept(fromState)
    };
  }
}
1006012
function (input) {
    debug('requiredTextFilter(%s)', input);
    if (_.isString(input) && !_.isEmpty(input)) return input;
    if (_.isNumber(input)) return '' + input;
    return undefined;
  }