Most functional terms do not accept NULL as arguments. If this happens, they become NULL.
515497
private Map.Entry<Variable, ImmutableTerm> applyNullNormalization(
            Map.Entry<Variable, ImmutableTerm> substitutionEntry) {
        ImmutableTerm value = substitutionEntry.getValue();
        if (value instanceof ImmutableFunctionalTerm) {
            ImmutableTerm newValue = normalizeFunctionalTerm((ImmutableFunctionalTerm) value);
            return newValue.equals(value)
                    ? substitutionEntry
                    : new AbstractMap.SimpleEntry<>(substitutionEntry.getKey(), newValue);
        }
        return substitutionEntry;
    }
356173
protected void addStep(String methodName, Object[] args) {
    	if(StringUtils.isBlank(methodName)) {
        	throw new IllegalArgumentException("methodName cannot be null or empty.");
        }
    	addStep(methodName, args, false);
    }
718560
def nullable(self, ctype: ContentType) -> bool:
        """"""
        return (not self.check_when() or self.pattern.nullable(ctype))
65241
@SuppressWarnings("unchecked")
	private <T> T nullFor(DataType dataType)
	{
		switch(dataType)
		{
			case Long: return (T)Long.valueOf(-1);
			default: return null;
		}
	}
393655
@NonNull
  public static Term function(
      @Nullable String keyspaceName,
      @NonNull String functionName,
      @NonNull Iterable<Term> arguments) {
    return function(
        keyspaceName == null ? null : CqlIdentifier.fromCql(keyspaceName),
        CqlIdentifier.fromCql(functionName),
        arguments);
  }
230285
@SuppressWarnings("nullness")
  private static <T> T castNonNull(@javax.annotation.Nullable T arg) {
    return arg;
  }
187068
public static String notEmptyIfNotNull(String value, String name, String info) {
        if (value == null) {
            return value;
        }

        if (value.trim().length() == 0) {
            throw new IllegalArgumentException(name + " cannot be empty" + (info == null ? "" : ", " + info));
        }
        return value.trim();
    }
261713
@SuppressFBWarnings(value = "NP_BOOLEAN_RETURN_NULL", justification = "That's the point (but dubious)")
    public static Boolean falseToNull(Boolean bool) {
        if (bool != null && bool) {
            return true;
        }
        return null;
    }
794020
private static void checkPreconditions(final Set<Object> possibleValues) {
		if( possibleValues == null ) {
			throw new NullPointerException("possibleValues Set should not be null");
		} else if( possibleValues.isEmpty() ) {
			throw new IllegalArgumentException("possibleValues Set should not be empty");
		}
	}
927818
function(cb) {
        var args;
        try {
          args = self._getArguments();
        } catch(e) {
          return cb(e);
        }

        cb(null, args);
      }
1000517
function firstFunction(args) {
  for (var i = 0, len = args.length; i < len; i++) {
    if (typeof args[i] === 'function') {
      return args[i];
    }
  }

  return null;
}
793326
def raise_null_argument(func):
    """"""
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except TypeError as ex:
            if any(statement in ex.args[0] for statement in ['takes exactly',
                                                             'required positional argument']):
                raise NullArgument('Wrong number of arguments provided: ' + str(ex.args[0]))
            else:
                raise
    return wrapper
917361
private boolean containsNull(Object[] arguments) {
        for (Object argument : arguments) {
            if (argument == null) {
                return true;
            }
        }
        return false;
    }
1268744
@NonNull
    public static List<String> unmodifiableNonNullListOfStrings(@Nullable Object[] args) {
        if (args == null || args.length == 0) {
            return emptyList();
        } else {
            final List<String> list = new ArrayList<String>(args.length);

            //noinspection ForLoopReplaceableByForEach -> on Android it's faster
            for (int i = 0; i < args.length; i++) {
                final Object arg = args[i];
                list.add(arg != null ? arg.toString() : "null");
            }

            return unmodifiableList(list);
        }
    }
1110966
public static void notEmpty(final String arg, final String name) {
        if(arg == null) {
            throw new NullPointerException(String.format("%s should not be null.", name));
        }
        
        if(arg.isEmpty()) {
            throw new IllegalArgumentException(String.format("%s should not be empty.", name));
        }
    }
740611
public static final <X> Function<X,Boolean> isNotNullBy(final IFunction<X,?> by) {
        return FnFunc.chain(by, IS_NOT_NULL);
    }
713933
public static void checkArgumentNotNull(Object reference, String argumentName) {
        if (reference == null) {
            throw ValidatorLogger.LOG.argumentNull(argumentName);
        }
    }