}
            return entity;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });

        return asJson(new ApiUpdateResponse().id(dataConfig.getId()).created(true).status(Status.OK).result());
    }

    /**

      patch: Int = 0,
    ): Boolean {
      val conscryptVersion = Conscrypt.version() ?: return false

      if (conscryptVersion.major() != major) {
        return conscryptVersion.major() > major
      }

      if (conscryptVersion.minor() != minor) {
        return conscryptVersion.minor() > minor
      }

      return conscryptVersion.patch() >= patch
    }
  }

      tmp += Double.doubleToRawLongBits(DoubleMath.log2(positiveDoubles[j]));
    }
    return tmp;
  }

  @Benchmark
  long factorial(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(DoubleMath.factorial(factorials[j]));
    }
    return tmp;
  }

  @Benchmark
  int isMathematicalInteger(int reps) {
    int tmp = 0;

            this.i = i;
        }

        /**
         * @return the i
         */
        public int getI() {
            return i;
        }

        /**
         * @param s
         *            the s to set
         */
        public void setS(final String s) {
            this.s = s;
        }

        /**
         * @return the s
         */
        public String getS() {
            return s;

  public void shutdown() {
    delegate.shutdown();
  }

  @Override
  public List<Runnable> shutdownNow() {
    return delegate.shutdownNow();
  }

  @Override
  public boolean isShutdown() {
    return delegate.isShutdown();
  }

  @Override
  public boolean isTerminated() {
    return delegate.isTerminated();
  }

  @Override

  public void shutdown() {
    delegate.shutdown();
  }

  @Override
  public List<Runnable> shutdownNow() {
    return delegate.shutdownNow();
  }

  @Override
  public boolean isShutdown() {
    return delegate.isShutdown();
  }

  @Override
  public boolean isTerminated() {
    return delegate.isTerminated();
  }

  @Override

	// Update numversions
	for i := range fivs.Versions {
		fivs.Versions[i].NumVersions = n
	}
	return fivs, nil
}

func getAllFileInfoVersions(xlMetaBuf []byte, volume, path string, allParts bool) (FileInfoVersions, error) {
	var versions []FileInfo
	var err error

	if buf, _, e := isIndexedMetaV2(xlMetaBuf); e != nil {
		return FileInfoVersions{}, e
	} else if buf != nil {
		versions, err = buf.ListVersions(volume, path, allParts)

                // The response buffer points to the internal tmp buffer
                if (response.b != null && response.off < response.b.length) {
                    response.b[response.off] = 42; // Return byte value 42
                }
                return null;
            }
        }).when(smbFile).send(any(SmbComReadAndX.class), any(SmbComReadAndXResponse.class));

        int result = smbRandomAccessFile.read();

        if (PREFERENCE_QUERY.equals(pref)) {
            return Integer.toString(query.hashCode());
        }
        if (StringUtil.isNotBlank(pref)) {
            return pref;
        }
        return null;
    }

    /**
     * Gets the sort prefix used for identifying sort parameters in search queries.
     *
     * @return the sortPrefix
     */
    public String getSortPrefix() {

var erasureHealTests = []struct {
	dataBlocks, disks int

	// number of offline disks is also number of staleDisks for
	// erasure reconstruction in this test
	offDisks int

	// bad disks are online disks which return errors
	badDisks, badStaleDisks int

	blocksize, size int64
	algorithm       BitrotAlgorithm
	shouldFail      bool
}{