storageClass     string
	bucketName       string
	enableSha256     bool
	enableMultipart  bool
	creds            auth.Credentials
}

// Get the max throughput and iops numbers.
func objectSpeedTest(ctx context.Context, opts speedTestOpts) chan madmin.SpeedTestResult {
	ch := make(chan madmin.SpeedTestResult, 1)
	go func() {
		defer xioutil.SafeClose(ch)

		concurrency := opts.concurrencyStart

		if opts.autotune {

     * The returned list of versions is only dependent on the configured repositories and their contents.
     * The supplied request may also refer to a single concrete version rather than a version range.
     * In this case though, the result contains simply the (parsed) input version, regardless of the
     * repositories and their contents.
     *
     * @param session the session to use
     * @param artifactCoordinates t

                              status.get());
  std::unique_ptr<TFE_Context, decltype(&TFE_DeleteContext)> context(
      TFE_NewContext(opts.get(), status.get()), TFE_DeleteContext);
  ASSERT_EQ(TF_GetCode(status.get()), TF_OK) << TF_Message(status.get());
  BasicTestsForTwoDevices(context.get(),
                          "/job:localhost/replica:0/task:0/device:CPU:0",

public final class Collections2FilterArrayListTest
    extends AbstractFilteredCollectionTest<Collection<Integer>> {
  @Override
  Collection<Integer> createUnfiltered(Iterable<Integer> contents) {
    return Lists.newArrayList(contents);
  }

  @Override
  Collection<Integer> filter(Collection<Integer> elements, Predicate<? super Integer> predicate) {
    return Collections2.filter(elements, predicate);
  }

	xls := xlStorage{drivePath: base, diskInfoCache: cachevalue.New[DiskInfo]()}
	xls.diskInfoCache.InitOnce(time.Second, cachevalue.Opts{}, func(ctx context.Context) (DiskInfo, error) {
		return DiskInfo{Total: 1 << 40, Free: 1 << 40}, nil
	})
	weSleep := func() bool { return false }

	got, err := scanDataFolder(context.Background(), nil, &xls, dataUsageCache{Info: dataUsageCacheInfo{Name: bucket}}, getSize, 0, weSleep)
	if err != nil {
		t.Fatal(err)
	}

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String field = getSearchField(context.getDefaultField(), prefixQuery.getField());
        final String text = prefixQuery.getPrefix().text();

        if (Constants.DEFAULT_FIELD.equals(field)) {
            context.addFieldLog(field, text + "*");

)

var encryptDecryptTests = []struct {
	Data    []byte
	Context kms.Context
}{
	{
		Data:    nil,
		Context: nil,
	},
	{
		Data:    []byte{1},
		Context: nil,
	},
	{
		Data:    []byte{1},
		Context: kms.Context{"key": "value"},
	},
	{
		Data:    make([]byte, 1<<20),
		Context: kms.Context{"key": "value", "a": "b"},
	},
}

func TestEncryptDecrypt(t *testing.T) {

	var (
		// clone statement
		tx  = db.getInstance().Session(&Session{Context: db.Statement.Context, NewDB: db.clone == 1})
		opt *sql.TxOptions
		err error
	)

	if len(opts) > 0 {
		opt = opts[0]
	}

	switch beginner := tx.Statement.ConnPool.(type) {
	case TxBeginner:
		tx.Statement.ConnPool, err = beginner.BeginTx(tx.Statement.Context, opt)
	case ConnPoolBeginner:

Fess 14.17 est désormais disponible et peut être téléchargé sur la [page de Releases](https://github.com/codelibs/fess/releases "download"). Les téléchargements sont disponibles en 3 formats : deb, rpm, zip.

Les commandes suivantes montrent comment utiliser le téléchargement zip :

    $ unzip fess-14.17.x.zip
    $ cd fess-14.17.x
    $ ./bin/fess

Pour plus de détails, consultez le [guide d'installation](https://fess.codelibs.org/14.17/install/index.html).

pkg compress/lzw, type Reader struct
pkg compress/lzw, type Writer struct
pkg crypto/tls, method (*CertificateRequestInfo) Context() context.Context
pkg crypto/tls, method (*ClientHelloInfo) Context() context.Context
pkg crypto/tls, method (*Conn) HandshakeContext(context.Context) error
pkg database/sql, method (*NullByte) Scan(interface{}) error
pkg database/sql, method (*NullInt16) Scan(interface{}) error