com.github.dakusui.jcunit.plugins.caengines.CoveringArrayEngine Maven / Gradle / Ivy

Go to download
package com.github.dakusui.jcunit.plugins.caengines;

/**
 */

import com.github.dakusui.jcunit.core.BaseBuilder;
import com.github.dakusui.jcunit.core.Checks;
import com.github.dakusui.jcunit.core.Utils;
import com.github.dakusui.jcunit.core.factor.FactorSpace;
import com.github.dakusui.jcunit.core.factor.Factors;
import com.github.dakusui.jcunit.core.tuples.Tuple;
import com.github.dakusui.jcunit.plugins.Plugin;
import com.github.dakusui.jcunit.plugins.constraints.ConstraintChecker;
import com.github.dakusui.jcunit.runners.core.RunnerContext;
import com.github.dakusui.jcunit.runners.standard.annotations.Generator;
import com.github.dakusui.jcunit.runners.standard.annotations.Value;

import java.util.Collections;
import java.util.List;

import static com.github.dakusui.jcunit.core.Checks.checknotnull;

public interface CoveringArrayEngine extends Plugin {
  CoveringArray generate(FactorSpace factorSpace);

  /**
   * A class to build a tuple generator.
   *
   * @param  data source type. Can be {@literal @}Param, {@code String}, etc.
   */
  class Builder {

    private RunnerContext                        runnerContext;
    private Factors                              factors;
    private ConstraintChecker                    constraintChecker;
    private Param.Resolver                    resolver;
    private List                              configArgsForEngine;
    private Class engineClass;

    public Builder(
        RunnerContext runnerContext,
        Factors factors, ConstraintChecker cm, Class engineClass
    ) {
      this.runnerContext = checknotnull(runnerContext);
      this.factors = factors;
      this.engineClass = checknotnull(engineClass);
      this.constraintChecker = checknotnull(cm);
    }

    public Builder setConfigArgsForEngine(List parameters) {
      this.configArgsForEngine = parameters;
      return this;
    }

    public Builder setResolver(Param.Resolver resolver) {
      this.resolver = resolver;
      return this;
    }


    public Factors getFactors() {
      return factors;
    }

    public ConstraintChecker getConstraintChecker() {
      return constraintChecker;
    }

    public CoveringArrayEngine build() {
      checknotnull(this.constraintChecker);
      checknotnull(this.engineClass);
      checknotnull(this.factors);
      checknotnull(this.constraintChecker);
      checknotnull(this.runnerContext);
      CoveringArrayEngine ret;
      Plugin.Factory factory;
      List configArgsForEngine;
      if (this.resolver != null) {
        // PECS cast: Factory uses a class object as a consumer.
        //noinspection unchecked
        factory = new Factory(
            (Class) this.engineClass,
            this.resolver,
            runnerContext
        );
        configArgsForEngine = this.configArgsForEngine;
      } else {
        // PassThroughResolver is always safe.
        //noinspection unchecked
        factory = new Factory(
            (Class) this.engineClass,
            (Param.Resolver) Param.Resolver.passThroughResolver(),
            runnerContext
        );
        configArgsForEngine = Collections.emptyList();
      }
      ret = factory.create(configArgsForEngine);
      return ret;
    }

    public Class getEngineClass() {
      return engineClass;
    }

    public List getConfigArgsForEngine() {
      return configArgsForEngine;
    }

    public Param.Resolver getResolver() {
      return resolver;
    }
  }

  /**
   * An abstract base class that provides a basic implementation of {@code CAEngine}.
   * Users can create a new tuple generator by extending this class.
   */
  abstract class Base extends Plugin.Base implements CoveringArrayEngine, Plugin {

    public Base() {
    }

    final public CoveringArray generate(FactorSpace factorSpace) {
      Checks.checknotnull(factorSpace);
      return createCoveringArray(Utils.dedup(generate(factorSpace.factors, factorSpace.constraintChecker)));
    }

    protected CoveringArray createCoveringArray(List testCase) {
      return new CoveringArray.Base(testCase);
    }

    /**
     * Implementation of this method must return a list of tuples (test cases)
     * generated by this object.
     * 
     *
     * @param factors    factors from which tuples will be generated.
     * @param constraintChecker constraint on tuple generation.
     */
    abstract protected List generate(Factors factors, ConstraintChecker constraintChecker);
  }

  class FromAnnotation implements BaseBuilder {
    private final Class engineClass;
    private final RunnerContext                        runnerContext;
    private final List                          configValues;

    public FromAnnotation(Generator engine, RunnerContext runnerContext) {
      this(engine.value(), runnerContext, Utils.asList(engine.args()));
    }

    private FromAnnotation(Class engineClass, RunnerContext context, List configValues) {
      this.engineClass = checknotnull(engineClass);
      this.runnerContext = checknotnull(context);
      this.configValues = checknotnull(Collections.unmodifiableList(configValues));
    }

    @Override
    public CoveringArrayEngine build() {
      Factory pluginFactory
          = Factory.newFactory(engineClass, new Value.Resolver(), this.runnerContext);
      //noinspection unchecked
      return pluginFactory.create(this.configValues);
    }
  }
}