@Override
public List<T> doShrink(SourceOfRandomness random, T larger) {
  @SuppressWarnings("unchecked")
  List<Object> asList = new ArrayList<>(larger);

  List<T> shrinks = new ArrayList<>();
  shrinks.addAll(removals(asList));

  @SuppressWarnings("unchecked")
  Shrink<Object> generator = (Shrink<Object>) componentGenerators().get(0);

  List<List<Object>> oneItemShrinks = shrinksOfOneItem(random, asList, generator);
  shrinks.addAll(oneItemShrinks.stream().map(this::convert).filter(this::inSizeRange)
      .collect(Collectors.toList()));

  return shrinks;
}
 

@Override
public InputStream generate(SourceOfRandomness random, GenerationStatus status) {
    buf = ByteBuffer.allocate(this.capacity);
    try {
        // Populate byte buffer
        populate(random);

    } catch (BufferOverflowException e) {
        // throw new AssumptionViolatedException("Generated input is too large", e);
    }

    // Return the bytes as an inputstream
    int len = buf.position();
    buf.rewind();
    byte[] bytes = new byte[len];
    buf.get(bytes);
    return new ByteArrayInputStream(bytes);
}
 

@Override
public Graph generate(SourceOfRandomness sourceOfRandomness, GenerationStatus generationStatus) {
    // Ensure that a model exists
    if (model == null) {
        throw new IllegalArgumentException("Graph generators MUST be configured with @GraphModel");
    }

    // Create graph instance
    Graph<Integer, DefaultEdge> graph = createGraph();

    // Generate nodes and edges using JGraphT generators
    getModel(model, sourceOfRandomness)
            .generateGraph(graph, createNodeFactory(), null);

    // If weighted, generate edge weights
    if (model.weighted()) {
        WeightedGraph<Integer, DefaultEdge> wgraph = (WeightedGraph<Integer, DefaultEdge>) graph;
        // Set edges
        for (DefaultEdge e : wgraph.edgeSet()) {
            wgraph.setEdgeWeight(e, sourceOfRandomness.nextFloat());
        }
    }

    // Return handle to this graph
    return graph;
}
 

@Override
public Schema generate(SourceOfRandomness random, GenerationStatus status) {
  List<Schema.Field> fields =
      IntStream.range(0, random.nextInt(0, status.size()) + 1)
          .mapToObj(
              i -> {
                // deterministically avoid collisions in record names
                branchPush(status, String.valueOf(i));
                Schema.Field field =
                    createField(i, SchemaGenerator.INSTANCE.generate(random, status));
                branchPop(status);
                return field;
              })
          .collect(Collectors.toList());

  return Schema.createRecord("record_" + branch(status), "", "example", false, fields);
}
 

@Override public RedBlackBSTNode<Integer,Integer> generate(SourceOfRandomness r, GenerationStatus status){
    Optional<Integer> treesizeOpt = status.valueOf(SUBTREE_SIZE);
    if (!treesizeOpt.isPresent()) return null;
    Integer treesize = treesizeOpt.get();
    if (treesize == 0 ){
        return null;
    }
    treesize = treesize -1;
    int leftSize = r.nextInt(0, treesize);
    int rightSize = treesize - leftSize;
    //System.out.println("leftSize: " + leftSize + ", rightSize: " + rightSize);


    RedBlackBSTNode<Integer,Integer> retNode = new RedBlackBSTNode<>(r.nextInt(), r.nextInt(), r.nextBoolean(), treesize + 1);
 //   System.out.println(retNode.key);
    retNode.left= generate(r, status.setValue(SUBTREE_SIZE, leftSize));
    retNode.right = generate(r, status.setValue(SUBTREE_SIZE, rightSize));
    return retNode;
}
 

private String generateTypeSignature(SourceOfRandomness r, boolean arraysAllowed) {
    String typeSig;
    if (r.nextBoolean()) {
        // Primitive
        typeSig = r.choose(primitiveTypes);
    } else {
        // Class type
        typeSig = "L" + generateClassName(r) + ";";
    }
    if (arraysAllowed && r.nextBoolean()) {
        // Generate array depth with geometric distribution
        int depth = geom.sampleWithMean(MEAN_ARRAY_DEPTH, r);
        for (int i = 0; i < depth; i++) {
            typeSig = "[" + typeSig;
        }
    }
    return typeSig;
}
 

private String generateExpression(SourceOfRandomness random) {
    expressionDepth++;
    // Choose between terminal or non-terminal
    String result;
    if (expressionDepth >= MAX_EXPRESSION_DEPTH || random.nextBoolean()) {
        result = random.choose(Arrays.<Function<SourceOfRandomness, String>>asList(
                this::generateLiteralNode,
                this::generateIdentNode
        )).apply(random);
    } else {
        result = random.choose(Arrays.<Function<SourceOfRandomness, String>>asList(
                this::generateBinaryNode,
                this::generateUnaryNode,
                this::generateTernaryNode,
                this::generateCallNode,
                this::generateFunctionNode,
                this::generatePropertyNode,
                this::generateIndexNode,
                this::generateArrowFunctionNode
        )).apply(random);
    }
    expressionDepth--;
    return "(" + result + ")";
}
 

@Override
public T generate(SourceOfRandomness random, GenerationStatus status) {
  int size = size(random, status);

  T items = empty();
  for (int i = 0; i < size; ++i) {
    // Object item0 = componentGenerators().get(0).generate(random, status);
    // Object item1 = componentGenerators().get(1).generate(random, status);
    // Object item2 = componentGenerators().get(2).generate(random, status);

    Object triple = componentGenerators().get(3).generate(random, status);

    items = (T) items.__insert(triple);
  }

  return items;
}
 

private String generateForNode(SourceOfRandomness random) {
    String s = "for(";
    if (random.nextBoolean()) {
        s += generateExpression(random);
    }
    s += ";";
    if (random.nextBoolean()) {
        s += generateExpression(random);
    }
    s += ";";
    if (random.nextBoolean()) {
        s += generateExpression(random);
    }
    s += ")";
    s += generateBlock(random);
    return s;
}
 

private String generateCastles(SourceOfRandomness r) {
    if (r.nextBoolean()) {
        return "-";
    }
    String castle = "";
    if (r.nextBoolean()) {
        castle += "K";
    }
    if (r.nextBoolean()) {
        castle += "Q";
    }
    if (r.nextBoolean()) {
        castle += "k";
    }
    if (r.nextBoolean()) {
        castle += "q";
    }
    if (castle.isEmpty()) {
        castle = "-";
    }
    return castle;
}
 

@Override
public List<T> doShrink(SourceOfRandomness random, T larger) {
  List<Object> asList = new ArrayList<>(larger);

  List<T> shrinks = new ArrayList<>();
  shrinks.addAll(removals(asList));

  Shrink<Object> generator = (Shrink<Object>) componentGenerators().get(0);

  List<List<Object>> oneItemShrinks = shrinksOfOneItem(random, asList, generator);
  shrinks.addAll(oneItemShrinks.stream()
      .map(this::convert)
      .filter(this::inSizeRange)
      .collect(Collectors.toList()));

  return shrinks;
}
 

@Override
public InputStream generate(SourceOfRandomness sourceOfRandomness, GenerationStatus generationStatus) {
    return new InputStream() {
       @Override
       public int read() throws IOException {
           // Keep asking for new random bytes until the
           // SourceOfRandomness runs out of parameters. This is designed
           // to work with fixed-size parameter sequences, such as when
           // fuzzing with AFL.
           try {
               byte nextByte = sourceOfRandomness.nextByte(Byte.MIN_VALUE, Byte.MAX_VALUE);
               int nextInt = nextByte & 0xFF;
               return nextInt;
           } catch (IllegalStateException e) {
               if (e.getCause() instanceof EOFException) {
                   return -1;
               } else {
                   throw e;
               }
           }
       }
   };
}
 

@Override
public Pair generate(final SourceOfRandomness random, final GenerationStatus status) {
    return Pair.of(
            componentGenerators().get(FIRST).generate(random, status),
            componentGenerators().get(SECOND).generate(random, status)
    );
}
 

@Override
public Schema generate(SourceOfRandomness random, GenerationStatus status) {
  Schema.Type type;

  if (nesting(status) >= MAX_NESTING) {
    type = random.choose(PRIMITIVE_TYPES);
  } else {
    type = random.choose(ALL_TYPES);
  }

  if (PRIMITIVE_TYPES.contains(type)) {
    return Schema.create(type);
  } else {
    nestingInc(status);

    if (type == Schema.Type.FIXED) {
      int size = random.choose(Arrays.asList(1, 5, 12));
      return Schema.createFixed("fixed_" + branch(status), "", "", size);
    } else if (type == Schema.Type.UNION) {
      // only nullable fields, everything else isn't supported in row conversion code
      return UnionSchemaGenerator.INSTANCE.generate(random, status);
    } else if (type == Schema.Type.ENUM) {
      return EnumSchemaGenerator.INSTANCE.generate(random, status);
    } else if (type == Schema.Type.RECORD) {
      return RecordSchemaGenerator.INSTANCE.generate(random, status);
    } else if (type == Schema.Type.MAP) {
      return Schema.createMap(generate(random, status));
    } else if (type == Schema.Type.ARRAY) {
      return Schema.createArray(generate(random, status));
    } else {
      throw new AssertionError("Unexpected AVRO type: " + type);
    }
  }
}
 

@Override
public ImageInputStream generate(SourceOfRandomness random, GenerationStatus status) {
    try {
        // Create an image input stream from an input stream
        return ImageIO.createImageInputStream(gen().make(InputStreamGenerator.class).generate(random, status));
    } catch (IOException e) {
        throw new RuntimeException("I/O exceptions should not occur for byte arrays");
    }
}
 

@Override
public T generate(SourceOfRandomness random, GenerationStatus status) {
  Object item0 = componentGenerators().get(0).generate(random, status);
  Object item1 = componentGenerators().get(1).generate(random, status);

  return (T) entryOf(item0, item1);
}
 

@Override
public T generate(SourceOfRandomness random, GenerationStatus status) {
  int size = size(random, status);

  T items = empty();
  for (int i = 0; i < size; ++i) {
    Object item = componentGenerators().get(0).generate(random, status);
    items = (T) items.__insert(item);
  }

  return items;
}
 

private static<E extends DefaultEdge> GraphGenerator<Integer, E, Integer>
    getModel(GraphModel model, SourceOfRandomness randomSource) {


    Random random = randomSource.toJDKRandom();

    if (model.nodes() <= 0) {
        throw new IllegalArgumentException("nodes must be > 0");
    }

    if (model.edges() > 0) {
        if (model.multiGraph() == false) {
            return new FastGnmRandomGraphGenerator<>(model.nodes(), model.edges(),
                    random, model.loops());
        } else {
            return new GnmRandomGraphGenerator<>(model.nodes(), model.edges(),
                    random, model.loops(), model.multiGraph());
        }
    }

    if (model.multiGraph()) {
        throw new IllegalArgumentException("Multi-graphs must specify edges and use GNM model");
    }

    if (model.p() < 0.0 || model.p() > 1.0) {
        throw new IllegalArgumentException("p must be in [0, 1]");
    }

    if (model.p() == 0.0) {
        return new EmptyGraphGenerator<>(model.nodes());
    } else if (model.p() == 1.0) {
        return new CompleteGraphGenerator<>(model.nodes());
    } else if (model.loops() == false && model.p() == 0.5) {
        return new BitSetBasedSimpleGraphGenerator<>(model.nodes(), random);
    } else {
        return new GnpRandomGraphGenerator<>(model.nodes(), model.p(),
                random, model.loops());
    }
}
 

@Override
public DirectedGraph generate(SourceOfRandomness sourceOfRandomness, GenerationStatus generationStatus) {
    ModelBasedGraphGenerator graphGenerator = new ModelBasedGraphGenerator();
    graphGenerator.configure(model);
    graphGenerator.setDirected(true);
    return (DirectedGraph) graphGenerator.generate(sourceOfRandomness, generationStatus);
}
 

public JavaClass generate(SourceOfRandomness r, GenerationStatus s) {
    constants = new ConstantPoolGen();

    // Generate a class with its meta-data
    String className = "example.A";
    String superName = r.nextBoolean() ? "example.B" : "java.lang.Object";
    String fileName = "A.class";
    int flags = r.nextInt(0, Short.MAX_VALUE);
    int numInterfaces = r.nextBoolean() ? 0 : geom.sampleWithMean(MEAN_INTERFACE_COUNT, r);
    String[] interfaces = new String[numInterfaces];
    for (int i = 0; i < numInterfaces; i++) {
        interfaces[i] = "example.I"+i;
    }
    ClassGen classGen = new ClassGen(className, superName, fileName, flags, interfaces, constants);

    // Validate flags
    Assume.assumeFalse(classGen.isFinal() && (classGen.isAbstract() | classGen.isInterface()));

    int numFields = geom.sampleWithMean(MEAN_FIELDS_COUNT, r);
    for (int i = 0; i < numFields; i++) {
        classGen.addField(generateField(r));
    }

    int numMethods = geom.sampleWithMean(MEAN_METHODS_COUNT, r);
    for (int i = 0; i < numMethods; i++) {
        classGen.addMethod(generateMethod(className, r));
    }

    return classGen.getJavaClass();

}
 

static SparseListModification gen(SourceOfRandomness random, int listSize) {
    int x = listSize == 0 ? random.nextInt(2, 7) : random.nextInt(8);
    switch(x) {
        case 0: return ElemUpdate  .generate(random, listSize);
        case 1: return ElemRemoval .generate(random, listSize);
        case 2: return RangeRemoval.generate(random, listSize);
        case 3: return ElemInsert  .generate(random, listSize);
        case 4: return ElemsInsert .generate(random, listSize);
        case 5: return VoidInsert  .generate(random, listSize);
        case 6: return ElemsSplice .generate(random, listSize);
        case 7: return VoidSplice  .generate(random, listSize);
        default: throw new AssertionError();
    }
}
 

private InstructionList generateCode(SourceOfRandomness r, Type[] argTypes, Type returnType) {
    InstructionList code = new InstructionList();

    while (r.nextBoolean()) {
        Instruction ins = generateInstruction(r, argTypes.length+1, code); // TODO: Allocate some locals
        if (ins instanceof BranchInstruction) {
            // Call the overloaded append()
            code.append((BranchInstruction) ins);
        } else {
            code.append(ins);
        }
    }
    return code;
}
 

InstructionHandle generateLabel(SourceOfRandomness r, InstructionList code) {
    InstructionHandle handles[] = code.getInstructionHandles();
    // If no instructions generated so far, emit a NOP to get some label
    if (handles.length == 0) {
        handles = new InstructionHandle[]{ code.append(new NOP()) };
    }
    return r.choose(handles);
}
 

@Override
public String generate(SourceOfRandomness random, GenerationStatus status) {
  StringBuilder sb = new StringBuilder(CAPACITY);
  for (int i = 0; i < CAPACITY; i++) {
    int randomIndex = random.nextInt(ALL_MY_CHARS.length());
    sb.append(ALL_MY_CHARS.charAt(randomIndex));
  }
  return sb.toString();
}
 

@Override
public String generate(SourceOfRandomness random, GenerationStatus status) {
    this.status = status;
    this.identifiers = new HashSet<>();
    this.statementDepth = 0;
    this.expressionDepth = 0;
    return generateStatement(random).toString();
}
 

private static <T> List<T> generateItems(Function<SourceOfRandomness, T> generator, SourceOfRandomness random,
                                         double mean) {
    int len = sampleGeometric(random, mean);
    List<T> items = new ArrayList<>(len);
    for (int i = 0; i < len; i++) {
        items.add(generator.apply(random));
    }
    return items;
}
 

private String generateStatement(SourceOfRandomness random) {
    statementDepth++;
    String result;
    if (statementDepth >= MAX_STATEMENT_DEPTH || random.nextBoolean()) {
        result = random.choose(Arrays.<Function<SourceOfRandomness, String>>asList(
                this::generateExpressionStatement,
                this::generateBreakNode,
                this::generateContinueNode,
                this::generateReturnNode,
                this::generateThrowNode,
                this::generateVarNode,
                this::generateEmptyNode
        )).apply(random);
    } else {
        result = random.choose(Arrays.<Function<SourceOfRandomness, String>>asList(
                this::generateIfNode,
                this::generateForNode,
                this::generateWhileNode,
                this::generateNamedFunctionNode,
                this::generateSwitchNode,
                this::generateTryNode,
                this::generateBlockStatement
        )).apply(random);
    }
    statementDepth--;
    return result;
}
 

private String generateBinaryNode(SourceOfRandomness random) {
    String token = random.choose(BINARY_TOKENS);
    String lhs = generateExpression(random);
    String rhs = generateExpression(random);

    return lhs + " " + token + " " + rhs;
}
 

private String generateCallNode(SourceOfRandomness random) {
    String func = generateExpression(random);
    String args = String.join(",", generateItems(this::generateExpression, random, 3));

    String call = func + "(" + args + ")";
    if (random.nextBoolean()) {
        return call;
    } else {
        return "new " + call;
    }
}
 

@Override
public Schema generate(SourceOfRandomness random, GenerationStatus status) {
  Map<String, Schema> schemaMap =
      IntStream.range(0, random.nextInt(0, status.size()) + 1)
          .mapToObj(
              i -> {
                // deterministically avoid collisions in record names
                branchPush(status, String.valueOf(i));
                Schema schema =
                    SchemaGenerator.INSTANCE
                        // nested unions aren't supported in AVRO
                        .filter(x -> x.getType() != Schema.Type.UNION)
                        .generate(random, status);
                branchPop(status);
                return schema;
              })
          // AVRO requires uniqueness by full name
          .collect(Collectors.toMap(Schema::getFullName, Function.identity(), (x, y) -> x));

  List<Schema> schemas = new ArrayList<>(schemaMap.values());

  if (random.nextBoolean()) {
    org.apache.avro.Schema nullSchema = org.apache.avro.Schema.create(Schema.Type.NULL);
    schemas.add(nullSchema);
    Collections.shuffle(schemas, random.toJDKRandom());
  }

  return Schema.createUnion(schemas);
}