is the name <code>foo</code> as an address in memory.
This form is used to name global functions and data.
Adding <code>&lt;&gt;</code> to the name, as in <span style="white-space: nowrap"><code>foo&lt;&gt;(SB)</code></span>, makes the name
visible only in the current source file, like a top-level <code>static</code> declaration in a C file.
Adding an offset to the name refers to that offset from the symbol's address, so

                Collections.addAll(innerSet, elements);
                return Collections.checkedNavigableSet(innerSet, String.class);
              }
            })
        .named("checkedNavigableSet/TreeSet, natural")
        .withFeatures(
            SetFeature.GENERAL_PURPOSE,
            CollectionFeature.KNOWN_ORDER,
            CollectionFeature.SERIALIZABLE,

                    populateForRowKeySet(table, elements);
                    return table.rowKeySet();
                  }
                })
            .named("ArrayTable.rowKeySet")
            .withFeatures(
                CollectionSize.ONE,
                CollectionSize.SEVERAL,
                CollectionFeature.KNOWN_ORDER,

                    putEntries(map, entries);
                    return Maps.unmodifiableNavigableMap(map);
                  }
                })
            .named("unmodifiableNavigableMap[SafeTreeMap]")
            .withFeatures(
                CollectionSize.ANY, MapFeature.ALLOWS_NULL_VALUES, CollectionFeature.SERIALIZABLE)
            .createTestSuite());
    suite.addTest(

    }

    @Named
    static class MySingletonBean {
        @Inject
        @Named("scoped")
        BeanItf myBean;

        @Inject
        @Named("another")
        BeanItf2 anotherBean;
    }

    @Named
    static class MySingletonBean2 {
        @Inject
        @Named("scoped")
        MySessionScopedBean myBean;

        @Inject

                                .toBeanEntry(bean)
                                .prioritize(bean.getRank());
                        String name = bean.getKey() instanceof com.google.inject.name.Named n ? n.value() : "";
                        map.compute(name, (n, ob) -> ob == null || ob.getPriority() < b.getPriority() ? b : ob);
                    }
                }
                //noinspection unchecked

 * </pre>
 *
 * </td>
 * <td>
 * Open the Named Pipe foo for reading and writing. The pipe will behave like the <code>CallNamedPipe</code> interface.
 * </td>
 * </tr>
 * <tr>
 * <td >
 *
 * <pre>
 * new SmbNamedPipe("smb://server/IPC$/foo", SmbNamedPipe.PIPE_TYPE_RDWR | SmbNamedPipe.PIPE_TYPE_TRANSACT, context);
 * </pre>
 *
 * </td>
 * <td>

        unknownParameters = getUnknownParameters(mojoExecution, parametersNamesAll);

        unknownParameters.forEach(name -> {
            MessageBuilder messageBuilder = messageBuilderFactory
                    .builder()
                    .warning("Parameter '")
                    .warning(name)
                    .warning("' is unknown for plugin '")
                    .warning(mojoExecution.getArtifactId())

                public Collection<Phase> phases() {
                    List<String> names = lifecycle.getPhases();
                    List<Phase> phases = new ArrayList<>();
                    for (int i = 0; i < names.size(); i++) {
                        String name = names.get(i);
                        String prev = i > 0 ? names.get(i - 1) : null;
                        phases.add(new Phase() {

            new TestStringListGenerator() {
              @Override
              public List<String> create(String[] elements) {
                return emptyList();
              }
            })
        .named("emptyList")
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
        .suppressing(suppressForEmptyList())
        .createTestSuite();
  }

  public Test testsForSingletonList() {