private Queue createSimpleWork()

in src/main/java/org/apache/accumulo/testing/gcs/Generator.java [102:194]
76 lines of code
10 McCabe index (conditional complexity)

  private Queue<Mutator> createSimpleWork() {
    long groupId = nextGroupId++;
    int bucket = rand.nextInt(maxBuckets);

    ArrayDeque<Mutator> work = new ArrayDeque<>();

    List<Item> newItems = new ArrayList<>();
    int numItems = rand.nextInt(10) + 1;
    for (int i = 0; i < numItems; i++) {
      newItems.add(new Item(clientId, groupId, nextItemId++));
    }

    // copy because lambda will execute later
    List<Item> itemsToAdd = new ArrayList<>(newItems);
    work.add(p -> {
      for (Item item : itemsToAdd) {
        p.save(item, ItemState.NEW);
      }
      p.flush();
    });

    List<ItemRef> referencedItems = new ArrayList<>();

    while (!newItems.isEmpty() || !referencedItems.isEmpty()) {
      if (newItems.isEmpty()) {
        int size = referencedItems.size();
        List<ItemRef> subList = referencedItems.subList(rand.nextInt(size), size);
        List<ItemRef> refsToDelete = new ArrayList<>(subList);
        subList.clear();

        work.add(p -> {
          for (ItemRef ir : refsToDelete) {
            p.save(new Candidate(ir.clientId, ir.groupId, ir.itemId));
          }
          p.flush();
        });

        work.add(p -> {
          p.delete(refsToDelete);
          p.flush();
        });
      } else if (referencedItems.isEmpty()) {
        int size = newItems.size();
        List<Item> subList = newItems.subList(rand.nextInt(size), size);
        List<Item> itemsToRef = new ArrayList<>(subList);
        subList.clear();

        List<ItemRef> refsToAdd = new ArrayList<>();
        itemsToRef.forEach(item -> refsToAdd.add(new ItemRef(bucket, item)));
        referencedItems.addAll(refsToAdd);

        work.add(p -> {
          p.save(refsToAdd);
          p.flush();
        });

        work.add(p -> {
          for (Item item : itemsToRef) {
            p.save(item, ItemState.REFERENCED);
          }
          p.flush();
        });

      } else {
        int size = referencedItems.size();
        List<ItemRef> subList = referencedItems.subList(rand.nextInt(size), size);
        List<ItemRef> refsToDelete = new ArrayList<>(subList);
        subList.clear();

        Item itemToRef = newItems.remove(newItems.size() - 1);
        referencedItems.add(new ItemRef(bucket, itemToRef));

        work.add(p -> {
          for (ItemRef ir : refsToDelete) {
            p.save(new Candidate(ir.clientId, ir.groupId, ir.itemId));
          }
          p.flush();
        });

        work.add(p -> {
          p.replace(refsToDelete, new ItemRef(bucket, itemToRef));
          p.flush();
        });

        work.add(p -> {
          p.save(itemToRef, ItemState.REFERENCED);
          p.flush();
        });
      }
    }

    return work;
  }