entries := make([]string, 0, len(store.entries))
	for entry := range store.entries {
		entries = append(entries, entry)
	}

	// Sort entries...
	sort.Slice(entries, func(i, j int) bool {
		return store.entries[entries[i]] < store.entries[entries[j]]
	})

	for i := range entries {
		keys = append(keys, parseKey(entries[i]))
	}

	return keys
}

// list will read all entries from disk.

    public void testConvertWithLongText() throws IOException {
        // Test convert with long text
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            sb.append("word").append(i).append(" ");
        }
        String text = sb.toString();
        String field = "content";

        List<String> results = converter.convert(text, field, "en");

        assertNotNull(results);

		if f.ModifiedTime != 0 || f.ModifiedDate != 0 {
			f.Modified = modified.In(timeZone(msdosModified.Sub(modified)))
		}
	}

	// Assume that uncompressed size 2³²-1 could plausibly happen in
	// an old zip32 file that was sharding inputs into the largest chunks
	// possible (or is just malicious; search the web for 42.zip).
	// If needUSize is true still, it means we didn't see a zip64 extension.

    reader = new CharSequenceReader(charSequence);
    buf = new char[5];
    StringBuilder builder = new StringBuilder();
    int read;
    while ((read = reader.read(buf, 0, buf.length)) != -1) {
      builder.append(buf, 0, read);
    }
    assertThat(builder.toString()).isEqualTo(expected);
    assertFullyRead(reader);

    // read all to one CharBuffer
    reader = new CharSequenceReader(charSequence);

            buffer.append("[");
            for (Item item : this) {
                if (buffer.length() > 1) {
                    buffer.append(", ");
                }
                if (item instanceof ListItem listItem) {
                    buffer.append(listItem.toListString());
                } else {
                    buffer.append(item);
                }
            }

			if len(*lri) == 1 {
				// Remove the write lock.
				delete(l.lockMap, name)
			} else {
				// Remove the appropriate read lock.
				*lri = append((*lri)[:index], (*lri)[index+1:]...)
				l.lockMap[name] = *lri
			}
			delete(l.lockUID, formatUUID(args.UID, entry.idx))
			return true
		}
	}

			switch c {
			case '{', '[':
				nest++
			case '}', ']':
				nest--
			case ',':
				buf = append(buf, ',')
				if nest == 0 {
					buf = append(buf, ' ')
				}
				for i+1 < len(printed) && (printed[i+1] == ' ' || printed[i+1] == '\t') {
					i++
				}
				continue
			}
			buf = append(buf, c)
		}

		f := strings.Fields(string(buf))

                    DERGeneralString stringPart = ASN1Util.as(DERGeneralString.class, part);
                    nameBuilder.append(stringPart.getString());
                    if (parts.hasMoreElements()) {
                        nameBuilder.append('/');
                    }
                }
                this.serverPrincipalName = nameBuilder.toString();
                break;

                StringBuilder message = new StringBuilder("In: " + pom + "\n\n");
                for (ModelProblem problem : modelBuildingException.getProblems()) {
                    message.append(problem).append("\n");
                }
                System.out.println(message);
                fail(message.toString());
            }

            throw e;
        }
    }

			matches = append(matches, madmin.KMSKeyInfo{Name: keyName, CreatedAt: StubCreatedAt, CreatedBy: StubCreatedBy})
		}
	}

	return matches, "", nil
}

// CreateKey creates a new key with the given name.
func (s *StubKMS) CreateKey(_ context.Context, req *CreateKeyRequest) error {
	if s.containsKeyName(req.Name) {
		return ErrKeyExists
	}
	s.KeyNames = append(s.KeyNames, req.Name)
	return nil
}