ImmutableValueGraph<String, Integer> graph =
        ValueGraphBuilder.directed().<String, Integer>immutable().addNode("A").build();

    assertThat(graph.nodes()).containsExactly("A");
    assertThat(graph.edges()).isEmpty();
  }

  @Test
  public void immutableValueGraphBuilder_putEdgeFromNodes() {
    ImmutableValueGraph<String, Integer> graph =
        ValueGraphBuilder.directed()
            .<String, Integer>immutable()

        {
            expressionsBySyntax = new java.util.HashMap();

            java.util.List expressions = getExpressions();

            if ( expressions != null && !expressions.isEmpty() )
            {
                for ( java.util.Iterator it = expressions.iterator(); it.hasNext(); )
                {
                    Expression expr = (Expression) it.next();

  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ONE)
  public void testSingletonSetPollFirst() {
    assertEquals(a, navigableSet.pollFirst());
    assertTrue(navigableSet.isEmpty());
  }

  @CollectionSize.Require(ONE)
  public void testSingletonSetNearby() {
    assertNull(navigableSet.lower(e0()));
    assertEquals(a, navigableSet.floor(e0()));

        messages.add(message);
    }

    @Override
    public String toString() {
        return render("");
    }

    public String render(String indentation) {
        if (messages.isEmpty()) {
            return indentation + "There were no validation errors.";
        }

        StringBuilder message = new StringBuilder();
        for (int i = 0; i < messages.size(); i++) {

            buf.append(",\"related_contents\":");
            buf.append(escapeJson(relatedContents));
            buf.append(',');
            buf.append("\"data\":[");
            if (!documentItems.isEmpty()) {
                boolean first1 = true;
                for (final Map<String, Object> document : documentItems) {
                    if (!first1) {
                        buf.append(',');

        resourceManager.registerResource(resource);

        var activeResources = resourceManager.getActiveResources();
        assertNotNull(activeResources);
        assertFalse(activeResources.isEmpty());

        boolean found = activeResources.stream().anyMatch(desc -> desc.contains("TestResource"));
        assertTrue(found);
    }

    @Test

        void shouldReturnMeaningfulToString() {
            String result = transport.toString();
            assertTrue(result.startsWith("Transport"));
            assertFalse(result.isEmpty());
        }

        @Test
        @DisplayName("should handle response map operations")
        void shouldHandleResponseMapOperations() {
            assertEquals(0, transport.getResponseMapSize());

    public ImmutableBiMap<K, V> build() {
      return buildOrThrow();
    }

    @Override
    public ImmutableBiMap<K, V> buildOrThrow() {
      ImmutableMap<K, V> map = super.buildOrThrow();
      if (map.isEmpty()) {
        return of();
      }
      return new RegularImmutableBiMap<K, V>(super.buildOrThrow());
    }

    @Override
    ImmutableBiMap<K, V> buildJdkBacked() {
      return build();
    }

    @Override
    public Artifact createPluginArtifact(Plugin plugin) {
        VersionRange versionRange;
        try {
            String version = plugin.getVersion();
            if (version == null || version.isEmpty()) {
                version = "RELEASE";
            }
            versionRange = VersionRange.createFromVersionSpec(version);
        } catch (InvalidVersionSpecificationException e) {
            return null;

            }
        }

        public void removeChannel(ChannelInfo channel) {
            channels.remove(channel);
            if (primaryChannel == channel && !channels.isEmpty()) {
                primaryChannel = channels.get(0);
            }
        }

        public ChannelInfo getPrimaryChannel() {
            return primaryChannel;
        }