protected List<List<Statement>> buildContext(
      InputContext inputContext, List<Statement> stmts, int targetIndex) {
    VarCartesianProduct varCartesianProduct = new VarCartesianProduct();
    Statement statement = stmts.get(targetIndex);

    for (CtVariableReference var : statement.getInputContext().getVar()) {

      varCartesianProduct.addReplaceVar(var, valueCreator.createNull(var.getType()));

      List<CtVariableReference> candidates = inputContext.allCandidate(var.getType(), true, false);
      if (!candidates.isEmpty()) {
        varCartesianProduct.addReplaceVar(
            var, candidates.get(AmplificationHelper.getRandom().nextInt(candidates.size())));
      }

      Statement cfLocalVar = getLocalVar(var.getType(), inputContext);
      if (cfLocalVar != null) {
        varCartesianProduct.addReplaceVar(var, cfLocalVar);
      }

      CtLocalVariable localVariable =
          createLocalVarFromMethodLiterals(currentMethod, var.getType());
      if (localVariable != null) {
        varCartesianProduct.addReplaceVar(var, localVariable);
      }

      CtLocalVariable randomVar = valueCreator.createRandomLocalVar(var.getType());
      if (randomVar != null) {
        varCartesianProduct.addReplaceVar(var, randomVar);
      }
    }

    return varCartesianProduct.apply(stmts, targetIndex);
  }
 protected CtType findClassUnderTest(CtType testClass) {
   String testClassName = testClass.getQualifiedName();
   return AmplificationHelper.computeClassProvider(testClass)
       .stream()
       .filter(cl -> cl != null)
       .filter(cl -> cl != testClass)
       .filter(cl -> testClassName.contains(cl.getSimpleName()))
       .findFirst()
       .orElse(null);
 }
  public void reset(Coverage coverage, CtType testClass) {
    AmplificationHelper.reset();
    literalsByMethod = new HashMap<>();

    Set<CtType> codeFragmentsProvide = AmplificationHelper.computeClassProvider(testClass);

    List<Statement> codeFragmentsByClass =
        codeFragmentsProvide
            .stream()
            .flatMap(
                cl -> {
                  List<CtStatement> list = Query.getElements(cl, new TypeFilter(CtStatement.class));
                  return list.stream();
                })
            .filter(
                stmt -> {
                  try {
                    return stmt.getParent() != null;
                  } catch (Exception e) {
                    return false;
                  }
                })
            .filter(stmt -> stmt.getParent() instanceof CtBlock)
            .filter(stmt -> !stmt.toString().startsWith("super"))
            .filter(stmt -> !stmt.toString().startsWith("this("))
            .map(stmt -> new Statement(stmt))
            .collect(Collectors.toList());

    if (findClassUnderTest(testClass) != null) {
      coverageBycodeFragments = buildCodeFragmentFor(findClassUnderTest(testClass), coverage);
    } else {
      coverageBycodeFragments = new HashMap<>();
    }

    Set<Integer> ids = new HashSet<>();
    localVars =
        codeFragmentsByClass
            .stream()
            .filter(cf -> isValidCodeFragment(cf))
            .filter(cf -> ids.add(cf.id()))
            .collect(Collectors.toList());
  }
  protected CtMethod apply(CtMethod method, List<Statement> statements, int index) {
    CtMethod cloned_method = AmplificationHelper.cloneMethodTest(method, "_cf", 1000);
    CtStatement stmt = getAssertStatement(cloned_method).get(index);
    statements
        .stream()
        .forEach(
            c -> {
              stmt.insertBefore((CtStatement) c.getCtCodeFragment());
              c.getCtCodeFragment().setParent(stmt.getParent());
            });

    return cloned_method;
  }
  protected CtLocalVariable createLocalVarFromMethodLiterals(
      CtMethod method, CtTypeReference type) {
    List<CtLiteral> literals =
        getLiterals(method)
            .stream()
            .filter(lit -> lit.getType() != null)
            .filter(lit -> lit.getType().equals(type))
            .collect(Collectors.toList());

    if (literals.isEmpty()) {
      return null;
    }

    CtLiteral lit = literals.get(AmplificationHelper.getRandom().nextInt(literals.size()));
    return type.getFactory().Code().createLocalVariable(type, "vc_" + count++, lit);
  }
  protected Statement getLocalVar(CtTypeReference type, InputContext inputContext) {
    List<Statement> list =
        localVars
            .stream()
            .filter(var -> var.getCtCodeFragment() != null)
            .filter(var -> type.equals(((CtLocalVariable) var.getCtCodeFragment()).getType()))
            .filter(
                var ->
                    inputContext.getVariableOrFieldNamed(
                            ((CtLocalVariable) var.getCtCodeFragment()).getSimpleName())
                        == null)
            .collect(Collectors.toList());

    if (list.isEmpty()) {
      return null;
    } else {
      boolean localVarFind;
      while (!list.isEmpty()) {
        Statement localVar = list.remove(AmplificationHelper.getRandom().nextInt(list.size()));
        localVarFind = true;
        for (CtVariableReference var : localVar.getInputContext().getVar()) {
          CtVariableReference<?> candidate = inputContext.candidate(var.getType(), true);
          if (candidate == null) {
            localVarFind = false;
            break;
          }
        }
        if (localVarFind) {
          Statement cloneLocalVar = localVar.clone();
          for (CtVariableReference var : localVar.getInputContext().getVar()) {
            try {
              CtVariableReference variable =
                  cloneLocalVar.getInputContext().getVariableOrFieldNamed(var.getSimpleName());
              cloneLocalVar
                  .getInputContext()
                  .getVariableOrFieldNamed(var.getSimpleName())
                  .replace(variable);
            } catch (Exception e) {
              continue;
            }
            return cloneLocalVar;
          }
        }
      }
      return null;
    }
  }
 @Override
 public List<CtMethod> apply(CtMethod method) {
   currentMethod = method;
   List<CtMethod> newMethods = new ArrayList<>();
   if (!coverageBycodeFragments.isEmpty()) {
     List<InputContext> inputContexts = getInputContexts(method);
     if (!inputContexts.isEmpty()) {
       int index = inputContexts.size() - 1;
       List<List<Statement>> statements = buildStatements(inputContexts.get(index));
       for (List<Statement> list : statements) {
         try {
           newMethods.add(apply(method, list, index));
         } catch (Exception e) {
           throw new RuntimeException(e);
         }
       }
     }
   }
   return AmplificationHelper.updateAmpTestToParent(newMethods, method);
 }