"input": {"title": "Input"},
                            "loc": {
                                "items": {
                                    "anyOf": [{"type": "string"}, {"type": "integer"}]
                                },
                                "type": "array",
                                "title": "Location",
                            },

  private final CountDownLatch taskLatch = new CountDownLatch(1);
  private final CountDownLatch listenerLatch = new CountDownLatch(1);

  private volatile boolean throwException = false;

  private final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          () -> {
            runLatch.countDown();
            taskLatch.await();
            if (throwException) {
              throw new IllegalStateException("Fail");

    public Enums() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super(AnEnum.B, AnEnum.A, AnEnum.C, AnEnum.D, AnEnum.E);
    }
  }

  public static class Ints extends SampleElements<Integer> {
    public Ints() {
      // elements aren't sorted, to better test SortedSet iteration ordering
      super(1, 0, 2, 3, 4);
    }
  }

  public static <K extends @Nullable Object, V extends @Nullable Object>

      }
    } catch (ArithmeticException e) {
      throw new IllegalArgumentException(
          "Cartesian product too large; must have size at most Integer.MAX_VALUE");
    }
    this.axesSizeProduct = axesSizeProduct;
  }

  private int getAxisIndexForProductIndex(int index, int axis) {
    return (index / axesSizeProduct[axis + 1]) % axes.get(axis).size();
  }

            .metadata(metadata)
            .routingTable(routingTable)
            .nodes(nb)
            .build();
    }

    private int toInt(String v) {
        return Integer.valueOf(v.trim());
    }

    @Benchmark
    public ClusterState measureAllocation() {
        ClusterState clusterState = initialClusterState;
        while (clusterState.getRoutingNodes().hasUnassignedShards()) {

        assertEquals(40, response.dataOffset);
        assertEquals(0, response.dataDisplacement);
        assertEquals(1, response.setupCount);
    }

    // Helper method to write a 4-byte integer to a byte array.
    private void writeInt4(int val, byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) val;
        dst[dstIndex + 1] = (byte) (val >> 8);
        dst[dstIndex + 2] = (byte) (val >> 16);

  // whatever warnings might come along with it. :(

  /**
   * Returns an immutable list containing the given elements, in order.
   *
   * <p>The array {@code others} must not be longer than {@code Integer.MAX_VALUE - 12}.
   *
   * @throws NullPointerException if any element is null
   * @since 3.0 (source-compatible since 2.0)
   */

            TestNegotiateContextRequest request3 = new TestNegotiateContextRequest(Integer.MAX_VALUE);

            assertEquals(0x1, request1.getContextType());
            assertEquals(0x2, request2.getContextType());
            assertEquals(Integer.MAX_VALUE, request3.getContextType());
        }

        @Test
        @DisplayName("Should verify interface is Encodable")

	for _, disk := range disks {
		if disk == nil {
			continue
		}
		diskCount++
	}
	return diskCount
}

// hashOrder - hashes input key to return consistent
// hashed integer slice. Returned integer order is salted
// with an input key. This results in consistent order.
// NOTE: collisions are fine, we are not looking for uniqueness
// in the slices returned.

            @Override
            public String getIndexerDataMaxDocumentRequestSize() {
                return "1048576"; // 1MB
            }

            @Override
            public Integer getIndexerDataMaxDocumentCacheSizeAsInteger() {
                return 10000;
            }

            @Override
            public String getIndexFieldUrl() {
                return "url";
            }