return nil
	}
	names := make([]string, 0, len(embeddedRelations.Relations)+len(embeddedRelations.EmbeddedRelations))
	for _, relation := range embeddedRelations.Relations {
		// skip first struct name
		names = append(names, strings.Join(relation.Field.EmbeddedBindNames[1:], "."))
	}
	for _, relations := range embeddedRelations.EmbeddedRelations {
		names = append(names, embeddedValues(relations)...)
	}
	return names

    @DisplayName("null and empty names are handled explicitly")
    @NullAndEmptySource
    @ValueSource(strings = { " \t\n" })
    void handlesNullAndEmptyNames(String name) throws Exception {
        // Filter accepts only when name is exactly null, otherwise false
        SmbFilenameFilter filter = (dir, n) -> n == null;

        boolean result = filter.accept(mockDir, name);

        if (name == null) {

			riscv64SpecialOperand[opd.String()] = opd
		}
		// Add the CSRs
		for csrCode, csrName := range riscv.CSRs {
			// The set of RVV special operand names and the set of CSR special operands
			// names are disjoint and so can safely share a single namespace. However,
			// it's possible that a future update to the CSRs in inst.go could introduce
			// a conflict. This check ensures that such a conflict does not go
			// unnoticed.

  InternetDomainName(String name) {
    // Normalize:
    // * ASCII characters to lowercase
    // * All dot-like characters to '.'
    // * Strip trailing '.'

    name = Ascii.toLowerCase(DOTS_MATCHER.replaceFrom(name, '.'));

    if (name.endsWith(".")) {
      name = name.substring(0, name.length() - 1);
    }

    checkArgument(name.length() <= MAX_LENGTH, "Domain name too long: '%s':", name);

            binder.bind(XmlNode.class)
                    .annotatedWith(Names.named(extension.getKey()))
                    .toInstance(configuration);
            binder.bind(PlexusConfiguration.class)
                    .annotatedWith(Names.named(extension.getKey()))
                    .toInstance(XmlPlexusConfiguration.toPlexusConfiguration(configuration));
        }
    }

                pw.println("Some API names were found that, when client code is generated for these APIS,");
                pw.println("could conflict with the reserved words in some programming languages. It may");
                pw.println("still be possible to use these API names, but you will need to verify whether");
                pw.println("the API name (and its components) can be used as method names, and update the");

var (
	oidEmailAddress = []int{1, 2, 840, 113549, 1, 9, 1}
)

// printName prints the fields of a distinguished name, which include such
// things as its common name and locality.
func printName(names []pkix.AttributeTypeAndValue, buf *strings.Builder) []string {
	values := []string{}
	for _, name := range names {
		oid := name.Type
		//nolint:gocritic
		if len(oid) == 4 && oid[0] == 2 && oid[1] == 5 && oid[2] == 4 {
			switch oid[3] {

### French instructions about technical terms

Do not try to translate everything. In particular, keep common programming terms (e.g. `framework`, `endpoint`, `plug-in`, `payload`).

Keep class names, function names, modules, file names, and CLI commands unchanged.

### List of English terms and their preferred French translations

    - type: object  # regular objects with zero or more older versions
      name: NAME # match object names that satisfy the wildcard expression.
      olderThan: 7d10h # match objects older than this value
      createdBefore: "2006-01-02T15:04:05.00Z" # match objects created before "date"
      tags:
        - key: name
          value: pick* # match objects with tag 'name', all values starting with 'pick'
      metadata:
        - key: content-type

	var buf bytes.Buffer
	tw := tar.NewWriter(&buf)
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
		{"todo.txt", "Get animal handling license."},
	}
	for _, file := range files {
		hdr := &tar.Header{
			Name: file.Name,
			Mode: 0600,
			Size: int64(len(file.Body)),
		}