doDelete(entity, null);
    }

    public int queryDelete(CBCall<ScheduledJobCB> cbLambda) {
        return doQueryDelete(createCB(cbLambda), null);
    }

    public int[] batchInsert(List<ScheduledJob> list) {
        return batchInsert(list, null, null);
    }

    public int[] batchInsert(List<ScheduledJob> list, RequestOptionCall<BulkRequestBuilder> call) {

func (w *nullResponseWriter) Header() http.Header {
	return nil
}

func (w *nullResponseWriter) Write(p []byte) (int, error) {
	return len(p), nil
}

func (w *nullResponseWriter) WriteHeader(statusCode int) {
}

func (w *nullResponseWriter) Flush() {
}

func benchmarkSelect(b *testing.B, count int, query string) {
	requestXML := []byte(`
<?xml version="1.0" encoding="UTF-8"?>
<SelectObjectContentRequest>

    return absl::OkStatus();
  }
  absl::Status SetAttrShapeList(const char* attr_name, const int64_t** dims,
                                const int* num_dims, int num_values) override {
    std::vector<PartialTensorShape> shapes;
    shapes.reserve(num_values);
    for (int i = 0; i < num_values; ++i) {
      if (num_dims[i] < 0) {
        shapes.emplace_back();
      } else {
        shapes.emplace_back(ArraySlice<int64_t>(

public class TestLocking implements Runnable
{

    int numThreads = 1;
    int numIter = 1;
    long delay = 100;
    String url = null;
    int numComplete = 0;
    long ltime = 0L;

    public void run()
    {
        try {
            SmbFile f = new SmbFile(url);
            SmbFile d = new SmbFile(f.getParent());
            byte[] buf = new byte[1024];

            for (int ii = 0; ii < numIter; ii++) {

/**
 */
abstract class AbstractVersionTest {

    protected static final int X_LT_Y = -1;

    protected static final int X_EQ_Y = 0;

    protected static final int X_GT_Y = 1;

    protected abstract Version newVersion(String version);

    protected void assertOrder(int expected, String version1, String version2) {
        Version v1 = newVersion(version1);

        this.type = SESSION_RETARGET_RESPONSE;
        this.length = 6;
    }


    @Override
    int writeTrailerWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }


    @Override
    int readTrailerWireFormat ( InputStream in, byte[] buffer, int bufferIndex ) throws IOException {
        if ( in.read(buffer, bufferIndex, this.length) != this.length ) {

    }

    @Override
    public Entry<K, V>[] createArray(int length) {
      return generator.createArray(length);
    }

    @Override
    public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return generator.order(insertionOrder);
    }

    @SuppressWarnings("unchecked")
    @Override
    public K[] createKeyArray(int length) {
      return (K[]) new Object[length];
    }

    TYPE_DISALLOWED -> TYPE_DISALLOWED

    else -> error("unexpected type: $type")
  }
}

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

        new CollectionBenchmarkSampleData(true, random, 0.8, size);
    setToTest = (Set<Element>) impl.create(sampleData.getValuesInSet());
  }

  @Benchmark
  int iteration(int reps) {
    int x = 0;

    for (int i = 0; i < reps; i++) {
      for (Element y : setToTest) {
        x ^= System.identityHashCode(y);
      }
    }
    return x;
  }

  }

  @Override
  public void write(int c) throws IOException {
    super.write(c);
    flush(); // flush write to TestOutputStream to get its behavior
  }

  @Override
  public void write(char[] cbuf, int off, int len) throws IOException {
    super.write(cbuf, off, len);
    flush();
  }

  @Override
  public void write(String str, int off, int len) throws IOException {
    super.write(str, off, len);