Adds full new case for the argument that are of specific classes (matched by instanceOf, null is a wildcard).
434959
@Nonnull
	public <V1 extends T1, V2 extends T2> ToIntBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, ToIntBiFunction<V1, V2> function) {
		PartialCaseWithIntProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
19014
@Nonnull
	public <V extends T> LObjIntCharFunctionBuilder<T, R> casesOf(Class<V> argC1, Consumer<LObjIntCharFunctionBuilder<V, R>> pcpConsumer) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)));

		pc.specifySubCases((Consumer) pcpConsumer);
		return self();
	}
579582
@Nonnull
	public <V extends T> LUnaryOperatorBuilder<T> aCase(Class<V> argC, LUnaryOperator<V> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}
713892
@Nonnull
	public <V1 extends T1, V2 extends T2> LTieConsumerBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC3, LTieConsumer<V1, V2> function) {
		PartialCase.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC3 == null || argC3.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
1119830
@Nonnull
	public <V extends T> LOiToByteFunctionBuilder<T> aCase(Class<V> argC1, LOiToByteFunction<V> function) {
		PartialCaseWithByteProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		return self();
	}
144484
public final <T> void addArgument(Class<T> cls, String name)
    {
        if (map.containsKey(name))
        {
            throw new IllegalArgumentException(name+" is already added as option");
        }
        if (hasArrayArgument)
        {
            throw new IllegalArgumentException("no argument allowed after array argument");
        }
        types.add(cls);
        names.add(name);
        if (cls.isArray())
        {
            hasArrayArgument = true;
        }
    }
728823
@Nonnull
	public <V extends T> LOiToLongFunctionBuilder<T> aCase(Class<V> argC1, LOiToLongFunction<V> function) {
		PartialCaseWithLongProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		return self();
	}
86927
@Nonnull
	public <V extends T> LOiToDblFunctionBuilder<T> aCase(Class<V> argC1, LOiToDblFunction<V> function) {
		PartialCaseWithDblProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)));

		pc.evaluate(function);
		return self();
	}
843216
private List<TestCaseDef> extendBaseCases( FunctionInputDef inputDef, VarTupleSet validTuples, Iterator<TestCaseDef> baseCases)
    {
    List<TestCaseDef> testCases = new ArrayList<TestCaseDef>();
    
    // For each base test case...
    while( baseCases.hasNext())
      {
      TestCaseDef testCase = baseCases.next();
      logger_.debug( "Extending base test case={}", testCase);

      // Complete all variable bindings.
      if( makeComplete( testCase, validTuples, getVarsRemaining( inputDef, testCase)))
        {
        logger_.debug( "Completed test case={}", testCase);
        validTuples.used( testCase);
        testCases.add( testCase);
        }
      else
        {
        logger_.debug( "Can't complete test case={}", testCase);
        }
      }

    return testCases;
   }
1276921
@Nonnull
	public <V1 extends T1, V2 extends T2> LObjIntObjFunctionBuilder<T1, T2, R> aCase(Class<V1> argC1, Class<V2> argC3, LObjIntObjFunction<V1, V2, R> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC3 == null || argC3.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
1140003
public CaseForEqBuilder<T> when(Expression<? extends T> other) {
        return new CaseForEqBuilder<T>(mixin, other);
    }
646971
@Nonnull
	public <V1 extends T1, V2 extends T2, V3 extends T3> LTriFunctionBuilder<T1, T2, T3, R> aCase(Class<V1> argC1, Class<V2> argC2, Class<V3> argC3, LTriFunction<V1, V2, V3, R> function) {
		PartialCaseWithProduct.The pc = partialCaseFactoryMethod((a1, a2, a3) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)) && (argC3 == null || argC3.isInstance(a3)));

		pc.evaluate(function);
		return self();
	}
1167580
public static <T extends Case2<A, B>, A, B, EB extends B> DecomposableMatchBuilder0<T> case2(
      Class<T> clazz, MatchesExact<A> a, DecomposableMatchBuilder0<EB> b) {
    List<Matcher<Object>> matchers = Lists.of(ArgumentMatchers.eq(a.t), ArgumentMatchers.any());
    return new DecomposableMatchBuilder1<T, EB>(matchers, 1, new Case2FieldExtractor<>(clazz))
        .decomposeFirst(b);
  }
638631
public static <T extends Case1<A>, A> DecomposableMatchBuilder0<T> case1(
      Class<T> clazz, MatchesExact<A> a) {
    List<Matcher<Object>> matchers = Lists.of(ArgumentMatchers.eq(a.t));
    return new DecomposableMatchBuilder0<T>(matchers, new Case1FieldExtractor<>(clazz));
  }
481792
@Nonnull
	public <V1 extends T1, V2 extends T2> LToDblBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, LToDblBiFunction<V1, V2> function) {
		PartialCaseWithDblProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
904579
@Nonnull
	public <V1 extends T1, V2 extends T2> ToLongBiFunctionBuilder<T1, T2> aCase(Class<V1> argC1, Class<V2> argC2, ToLongBiFunction<V1, V2> function) {
		PartialCaseWithLongProduct.The pc = partialCaseFactoryMethod((a1, a2) -> (argC1 == null || argC1.isInstance(a1)) && (argC2 == null || argC2.isInstance(a2)));

		pc.evaluate(function);
		return self();
	}
1148139
@Nonnull
	public <V extends T> LToSrtFunctionBuilder<T> aCase(Class<V> argC, LToSrtFunction<V> function) {
		PartialCaseWithSrtProduct.The pc = partialCaseFactoryMethod(a -> (argC == null || argC.isInstance(a)));

		pc.evaluate(function);
		return self();
	}