We need to implement the custom exclusive parameter check.
967512
def update(self, **kwargs):
        """"""
        self._check_exclusive_parameters(**kwargs)
        return super(Rule, self)._update(**kwargs)
189332
function mandatoryCheck (params = {}) {
        assert.ok(params.host !== void 0, 'no host given');
        assert.ok(params.path !== void 0, 'no path given');
        assert.ok(params.wsdl !== void 0, 'no wsdl given');
    }
1192068
public void prepareParameters(Map<String, Object> extra) {
        if (paramConfig == null) return;
        for (ParamConfig param : paramConfig)
        {
            param.prepareParameter(extra);
        }
    }
607016
function () {
            /*  determine parameters  */
            var params = $cs.params("subscribe", arguments, {
                name:      { pos: 0,     req: true  },
                spec:      {             def: {}    },
                ctx:       {             def: this  },
                func:      { pos: 1,     req: true  },
                args:      { pos: "...", def: []    },
                capturing: {             def: false },
                spreading: {             def: false },
                bubbling:  {             def: true  },
                noevent:   {             def: false },
                exclusive: {             def: false },
                spool:     {             def: null  }
            });

            /*  honor exclusive request
                (attention: name can also be a regular expression object!)  */
            var subscriptions = this._subscriptions(params.name.toString(), params.spec);
            if (subscriptions.length === 1 && subscriptions[0].exclusive)
                throw _cs.exception("subscribe", "existing exclusive subscription prevents additional one");
            if (params.exclusive && subscriptions.length > 0)
                throw _cs.exception("subscribe", "non-exclusive subscription(s) prevent exclusive one");

            /*  attach parameters to component  */
            var id = _cs.cid();
            this.__subscription[id] = params;

            /*  optionally spool reverse operation  */
            if (params.spool !== null) {
                var info = _cs.spool_spec_parse(this, params.spool);
                info.comp.spool(info.name, this, "unsubscribe", id);
            }

            return id;
        }
456962
@Override
    protected void checkParameters() {
        super.checkParameters();

        if (outputFile == null) {
            throw new BuildException("output attribute is required", getLocation());
        }

        if (inputFile == null) {
            throw new BuildException("inputFile element is required");
        }

        checkBoolean(withMessages, "withMessages");
        checkBoolean(resetSource, "resetSource");
    }
948558
private void initParameters(ProcessingParameters pParams) {
        processingConfig = pParams;
        String ignoreErrors = processingConfig.get(ConfigKey.IGNORE_ERRORS);
        if (ignoreErrors != null && ignoreErrors.matches("^(true|yes|on|1)$")) {
            valueFaultHandler = ValueFaultHandler.IGNORING_VALUE_FAULT_HANDLER;
        } else {
            valueFaultHandler = ValueFaultHandler.THROWING_VALUE_FAULT_HANDLER;
        }
    }
111364
def _check_exclusive_parameters(self, **kwargs):
        
        if len(self._meta_data['exclusive_attributes']) > 0:
            attr_set = set(list(iterkeys(kwargs)))
            ex_set = set(self._meta_data['exclusive_attributes'][0])
            common_set = sorted(attr_set.intersection(ex_set))
            if len(common_set) > 1:
                cset = ', '.join(common_set)
                error = 'Mutually exclusive arguments submitted. ' \
                        'The following arguments cannot be set ' \
                        'together: "%s".' % cset
                raise ExclusiveAttributesPresent(error)
95096
private void checkAmbiguousValues(Option o, Map<String, String> data) throws RequiredParametersException{
		if (data.containsKey(o.getAlt()) && !Objects.equals(data.get(o.getAlt()), ParameterTool.NO_VALUE_KEY)) {
			throw new RequiredParametersException("Value passed for parameter " + o.getName() +
					" is ambiguous. Value passed for short and long name.");
		}
	}
1289642
public void addParameter(ISUPParameter param) throws ParameterException {
        if (param == null) {
            throw new IllegalArgumentException("Argument must not be null");
        }
        int paramCode = param.getCode();
        if (this.mandatoryCodes.contains(paramCode)) {
            int index = this.mandatoryCodeToIndex.get(paramCode);
            this.f_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }

        if (this.mandatoryVariableCodes.contains(paramCode)) {
            int index = this.mandatoryVariableCodeToIndex.get(paramCode);
            this.v_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }
        if (this.optionalCodes.contains(paramCode)) {
            int index = this.optionalCodeToIndex.get(paramCode);
            this.o_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }

        throw new ParameterException("Parameter with code: " + paramCode
                + " is not defined in any type: mandatory, mandatory variable or optional");
    }
1060238
function checkRequiredParameter (param) {
  return (
    typeof param === 'function' || typeof param === 'undefined' || param === '' || param === null || (typeof param === 'number' && isNaN(param))
  );
}
816319
def _check_custom_url_parameters(self):
        
        for param in self.custom_url_params:
            if param not in CustomUrlParam:
                raise ValueError('Parameter %s is not a valid custom url parameter. Please check and fix.' % param)

        if self.service_type is ServiceType.FIS and CustomUrlParam.GEOMETRY in self.custom_url_params:
            raise ValueError('{} should not be a custom url parameter of a FIS request'.format(CustomUrlParam.GEOMETRY))
1031644
public Violation checkInstantiation(
      Collection<TypeVariableSymbol> typeParameters, Collection<Type> typeArguments) {
    return Streams.zip(
            typeParameters.stream(),
            typeArguments.stream(),
            (sym, type) -> {
              if (!hasThreadSafeTypeParameterAnnotation(sym)) {
                return Violation.absent();
              }
              Violation info =
                  isThreadSafeType(
                      /* allowContainerTypeParameters= */ true,
                      /* containerTypeParameters= */ ImmutableSet.of(),
                      type);
              if (!info.isPresent()) {
                return Violation.absent();
              }
              return info.plus(
                  String.format(
                      "instantiation of '%s' is %s", sym, purpose.mutableOrNotThreadSafe()));
            })
        .filter(Violation::isPresent)
        .findFirst()
        .orElse(Violation.absent());
  }
710626
private String validateDialect(String confParam)
   {
      for (String dbType : DBConstants.DB_DIALECTS)
      {
         if (confParam.equals(dbType))
         {
            return dbType;
         }
      }

      return DBConstants.DB_DIALECT_AUTO; // by default
   }
1372924
public static void validateBindParametersTypes(Parameters parameters) {
		final Iterator<Parameter> it = parameters.iterator();

		while (it.hasNext()) {
			final Parameter param = it.next();
			final Class<?> paramType = param.getType();

			if (!(param.isSpecialParameter() || SupportedCoreTypes
					.isSupported(paramType))) {
				throw (new IllegalArgumentException("Type " + paramType
						+ " not supported as an annotated query parameter!"));
			}
		}
	}
844354
private void check() {
		final Method method = getMethod();
		final XParameter[] parameters = getParameters();
		final Class<?>[] parameterTypes = method.getParameterTypes();
		Validate.isTrue(parameters.length == parameterTypes.length,
				"Wrong number of parameters: [" + parameters.length
						+ "], expected [" + parameterTypes.length + "].");
		for (int index = 0; index < parameters.length; index++) {
			final XParameter parameter = parameters[index];
			final Class<?> parameterType = parameterTypes[index];
			Validate.isTrue(parameterType.equals(parameter.getType()),
					"Wrong parameter type: [" + parameter.getType()
							+ "], expected [" + parameterType + "]");
		}
	}
1202794
public void assertAtLeastOneDefined(final String param1, final String param2) {
    if (!isPresent(param1) && !isPresent(param2)) {
      throw new ParameterException(
          String.format("At least one of %s and %s must be defined.", param1, param2));
    }
  }
388779
private void onTypedParameter(Object value, UpdateClause updateClause, String fieldName) {
        String token = value.toString();
        if (token != null && token.startsWith(":")) {
            addTypedParameter(Type.NAMED, token, updateClause);
            filterJPAParameterInfo(Type.NAMED, token.substring(1), fieldName);
        } else if (token != null && token.startsWith("?")) {
            addTypedParameter(Type.INDEXED, token, updateClause);
            filterJPAParameterInfo(Type.INDEXED, token.substring(1), fieldName);
        }
    }