org.approvaltests.combinations.pairwise.Pairwise Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of approvaltests Show documentation
There is a newer version: 24.14.2
package org.approvaltests.combinations.pairwise;

import org.lambda.query.Query;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Pairwise implements Iterable
{
  private final List> parameters;
  private final List                    cases;
  private Pairwise(List> parameters, List cases)
  {
    this.parameters = parameters;
    this.cases = (List) (Object) cases;
  }
  public static Pairwise toPairWise(Object[]... parameters)
  {
    ArrayList> list = new ArrayList<>();
    for (int i = 0; i < parameters.length; i++)
    {
      list.add(new OptionsForAParameter<>(i, parameters[i]));
    }
    return new Builder().withParameters(list).build();
  }
  public int getTotalPossibleCombinations()
  {
    int totalPossibleSize = 1;
    for (OptionsForAParameter parameter : getParameters())
    {
      totalPossibleSize *= parameter.size();
    }
    return totalPossibleSize;
  }
  public List> getParameters()
  {
    return parameters;
  }
  public List getCases()
  {
    return cases;
  }
  public List verify()
  {
    return InParameterOrderStrategy.generatePairs(parameters).stream().flatMap(cases1 -> cases1.stream())
        .filter(pair -> !stream().filter(pair1 -> pair.matches(pair1)).findFirst().isPresent())
        .collect(Collectors.toList());
  }
  @Override
  public Iterator iterator()
  {
    return cases.iterator();
  }
  public Stream stream()
  {
    return cases.stream();
  }
  public static class Builder
  {
    private List> parameters;
    public List> getParameters()
    {
      return parameters;
    }
    public void setParameters(List> parameters)
    {
      this.parameters = parameters;
    }
    public Builder()
    {
      this.parameters = new ArrayList<>();
    }
    public Builder withParameter(OptionsForAParameter parameter)
    {
      this.parameters.add(parameter);
      return this;
    }
    public Builder withParameters(List> parameters)
    {
      this.parameters.addAll(parameters);
      return this;
    }
    public Pairwise build()
    {
      List minimalCases = getMinimalCases(parameters);
      Case.resetRandom();
      return new Pairwise(this.parameters, minimalCases);
    }
    public static List getMinimalCases(List> parameters)
    {
      final List> listOfPairs = InParameterOrderStrategy.generatePairs(parameters);
      List minimalCases = createEssentialCasesWithGaps(listOfPairs);
      return fillGaps(combineParametersToMap(parameters), minimalCases);
    }
    public static Map combineParametersToMap(List> parameters)
    {
      final Map params = parameters.stream()
          .collect(Collectors.toMap(objects -> objects.getPosition(), objects1 -> objects1.toArray()));
      return params;
    }
    public static List createEssentialCasesWithGaps(List> listOfPairs)
    {
      List createManyCases = new ArrayList<>();
      for (List cases : listOfPairs)
      {
        if (createManyCases.isEmpty())
        {
          createManyCases = cases;
        }
        else
        {
          createManyCases = InParameterOrderStrategy.combineAppleSauce(createManyCases, cases);
        }
      }
      return createManyCases;
    }
    public static List fillGaps(Map params, List createManyCases)
    {
      return Query.select(createManyCases, c -> c.replaceNullsWithRandomParameters(params));
    }
  }
}