)

func pathJoinOld(elem ...string) string {
	trailingSlash := ""
	if len(elem) > 0 {
		if hasSuffixByte(elem[len(elem)-1], SlashSeparatorChar) {
			trailingSlash = SlashSeparator
		}
	}
	return path.Join(elem...) + trailingSlash
}

func concatNaive(ss ...string) string {
	rs := ss[0]
	for i := 1; i < len(ss); i++ {
		rs += ss[i]
	}
	return rs
}

func benchmark(b *testing.B, data []string) {

	defer cancel()

	configCmds := []string{
		"etcd",
		"endpoints=" + etcdServer,
		"path_prefix=" + mustGetUUID(),
	}
	_, err := s.adm.SetConfigKV(ctx, strings.Join(configCmds, " "))
	if err != nil {
		c.Fatalf("unable to setup Etcd for tests: %v", err)
	}

	s.RestartIAMSuite(c)
}

func (s *TestSuiteIAM) SetUpSuite(c *check) {

   */
  private int findSuffixOfType(Optional<PublicSuffixType> desiredType) {
    int partsSize = parts.size();

    for (int i = 0; i < partsSize; i++) {
      String ancestorName = DOT_JOINER.join(parts.subList(i, partsSize));

      if (i > 0
          && matchesType(
              desiredType, Optional.fromNullable(PublicSuffixPatterns.UNDER.get(ancestorName)))) {
        return i - 1;
      }

	// Therefore, we need to record the UniqueIndex on this column (exclude Mul UniqueIndex) for MigrateColumnUnique.
	UniqueIndex string
}

func (field *Field) BindName() string {
	return strings.Join(field.BindNames, ".")
}

// ParseField parses reflect.StructField to Field
func (schema *Schema) ParseField(fieldStruct reflect.StructField) *Field {
	var (
		err        error

func newStorageRESTClient(endpoint Endpoint, healthCheck bool, gm *grid.Manager) (*storageRESTClient, error) {
	serverURL := &url.URL{
		Scheme: endpoint.Scheme,
		Host:   endpoint.Host,
		Path:   path.Join(storageRESTPrefix, endpoint.Path, storageRESTVersion),
	}

	restClient := rest.NewClient(serverURL, globalInternodeTransport, newCachedAuthToken())
	if healthCheck {
		// Use a separate client to avoid recursive calls.

		t.Errorf("failed to create:%v", err)
	}

	err = DB.Create(&q2).Error
	if err != nil {
		t.Errorf("failed to create:%v", err)
	}

	var qs []QueryResetNullValue
	err = DB.Joins("Item1").Joins("Item2").Find(&qs).Error
	if err != nil {
		t.Errorf("failed to find:%v", err)
	}

	if len(qs) != 2 {
		t.Fatalf("find count not equal:%d", len(qs))
	}

	AssertEqual(t, q1, qs[0])

	return func(sz int64, err error) {
		duration := time.Since(startTime)
		if globalTrace.NumSubscribers(madmin.TraceRebalance) > 0 {
			globalTrace.Publish(rebalanceTrace(r, poolIdx, startTime, duration, err, strings.Join(paths, " "), sz))
		}
	}

     */
    @PreDestroy
    public void destroy() {
        generating = false;
        thumbnailQueueThread.interrupt();
        try {
            thumbnailQueueThread.join(10000);
        } catch (final InterruptedException e) {
            logger.warn("Thumbnail thread is timeouted.", e);
        }
        generatorList.forEach(g -> {
            try {
                g.destroy();

	relation.Type = Many2Many

	var (
		err             error
		joinTableFields []reflect.StructField
		fieldsMap       = map[string]*Field{}
		ownFieldsMap    = map[string]*Field{} // fix self join many2many
		referFieldsMap  = map[string]*Field{}
		joinForeignKeys = toColumns(field.TagSettings["JOINFOREIGNKEY"])
		joinReferences  = toColumns(field.TagSettings["JOINREFERENCES"])
	)

            builder.setSize(fessConfig.getPagingSearchPageMaxSizeAsInteger());
            builder.setFetchSource(fields, null);
            queryHelper.processSearchPreference(builder, userBean, String.join(StringUtil.EMPTY, docIds));
            return true;
        });
    }

    /**
     * Updates a single field of a document.
     *
     * @param id The document ID to update