// Closure to handle TCPListener until done channel is closed.
	handleListener := func(idx int, listener net.Listener) {
		for {
			conn, err := listener.Accept()
			send(acceptResult{conn, err, idx})
		}
	}

	// Start separate goroutine for each TCP listener to handle connection.
	for idx, tcpListener := range listener.listeners {
		go handleListener(idx, tcpListener)
	}
}

			}
			hr, err := hash.NewReaderWithOpts(ctx, bytes.NewReader(fanOutBuf), hopts)
			if err != nil {
				errs[idx] = err
				return
			}

			reader := NewPutObjReader(hr)
			defer func() {
				if err := reader.Close(); err != nil {
					errs[idx] = err
				}
				if err := hr.Close(); err != nil {
					errs[idx] = err
				}
			}()

			userDefined := make(map[string]string, len(req.UserMetadata))

            String[] tok = part1.split("\\.");
            int idx = 0;
            if (idx < tok.length) {
                majorVersion = getNextIntegerToken(tok[idx++]);
                if (majorVersion == null) {
                    fallback = true;
                }
            } else {
                fallback = true;
            }
            if (idx < tok.length) {

		sort.Slice(expect.Pets, func(i, j int) bool {
			return expect.Pets[i].ID > expect.Pets[j].ID
		})

		for idx, pet := range user.Pets {
			if pet == nil || expect.Pets[idx] == nil {
				t.Errorf("pets#%v should equal, expect: %v, got %v", idx, expect.Pets[idx], pet)
			} else {
				doCheckPet(t, *pet, *expect.Pets[idx], unscoped)
			}
		}
	})

	t.Run("Toys", func(t *testing.T) {

			for _, index := range fieldIndexes {
				idx := indexes[index.Name]
				idx.Name = index.Name
				if idx.Class == "" {
					idx.Class = index.Class
				}
				if idx.Type == "" {
					idx.Type = index.Type
				}
				if idx.Where == "" {
					idx.Where = index.Where
				}
				if idx.Comment == "" {
					idx.Comment = index.Comment
				}
				if idx.Option == "" {
					idx.Option = index.Option
				}

  {{- range $idx, $policy := .Values.policies }}
  # Policy: {{ $policy.name }}
  policy_{{ $idx }}.json: |-
    {{- include (print $.Template.BasePath "/_helper_policy.tpl") . | nindent 4 }}
  {{ end }}
  {{- range $idx, $svc := .Values.svcaccts }}
  {{- if $svc.policy }}
  # SVC: {{ $svc.accessKey }}
  svc_policy_{{ $idx }}.json: |-

// Table return the table name of the index.
func (idx Index) Table() string {
	return idx.TableName
}

// Name return the name of the index.
func (idx Index) Name() string {
	return idx.NameValue
}

// Columns return the columns of the index
func (idx Index) Columns() []string {
	return idx.ColumnList
}

// PrimaryKey returns the index is primary key or not.
func (idx Index) PrimaryKey() (isPrimaryKey bool, ok bool) {

        }
    }


    protected final FileEntry advance ( boolean last ) throws CIFSException {
        FileEntry[] results = getResults();
        while ( this.ridx < results.length ) {
            FileEntry itm = results[ this.ridx ];
            this.ridx++;
            if ( filter(itm) ) {
                return itm;
            }
        }

        if ( !last && !isDone() ) {
            if ( !fetchMore() ) {

        int n = this.response.getStatus() == WinError.ERROR_MORE_DATA ? this.response.getNumEntries() - 1 : this.response.getNumEntries();
        while ( this.ridx < n ) {
            FileEntry itm = this.response.getResults()[ this.ridx ];
            this.ridx++;
            if ( filter(itm) ) {
                return itm;
            }
        }

        if (result != null) {
            while (true) {
                int idx = result.indexOf("/../");
                if (idx < 0) {
                    break;
                } else if (idx == 0) {
                    result = result.substring(3);
                    continue;
                }
                int parent = idx - 1;
                while (parent >= 0 && result.charAt(parent) == '/') {