}
        }
        lastName = numEntries == 0 ? null : e.name;

        return bufferIndex - start;
    }

    @Override
    public String toString() {
        return ("NetServerEnum2Response[" + super.toString() + ",status=" + status + ",converter=" + converter + ",entriesReturned="
                + numEntries + ",totalAvailableEntries=" + totalAvailableEntries + ",lastName=" + lastName + "]");
    }

        apply plugin:'elasticsearch.java'

        assert compileJava.sourceCompatibility == JavaVersion.VERSION_1_10.toString()
        assert compileJava.targetCompatibility == JavaVersion.VERSION_1_10.toString()
        """

        then:
        gradleRunner("help").build()
    }

    def "compile option --release is configured from targetCompatibility"() {
        when:

                final StringBuilder tempBuf = new StringBuilder();
                appendJson(e.getKey().toString(), e.getValue(), tempBuf);
                return tempBuf.toString();
            }).collect(Collectors.joining(","));
            buf.append(json);
            buf.append('}');
        } else if (value instanceof Long || value instanceof Integer) {

        NegTokenInit init = new NegTokenInit(mechs, flags, null, mic);
        String s = init.toString();

        assertTrue(s.contains("flags=" + flags), "toString should include flags");
        assertTrue(s.contains(Arrays.toString(mechs)), "toString should include mechanisms");
        assertTrue(s.contains("000AFF"), "toString should include MIC hex");
    }

    @Test

    }

    @Test
    public void test_toString_containsClassNameAndMessage() {
        // Test toString() method output
        String message = "SSO authentication timeout";
        SsoProcessException exception = new SsoProcessException(message);

        String toStringResult = exception.toString();
        assertTrue(toStringResult.contains("SsoProcessException"));
        assertTrue(toStringResult.contains(message));

        String expectedHex = String.format("%04X", action);
        assertTrue(result.contains("0x" + expectedHex));
    }

    @Test
    @DisplayName("Test toString with empty object")
    void testToStringEmpty() {
        String result = notifyInfo.toString();

        assertNotNull(result);
        assertTrue(result.contains("FileNotifyInformation"));
        assertTrue(result.contains("nextEntry=0"));

            when(mockInetAddress.toString()).thenReturn("/192.168.1.1");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            assertEquals("/192.168.1.1", uniAddress.toString());
        }

        @Test
        void shouldReturnWrappedAddressToStringWhenWrappedIsNbtAddress() {
            when(mockNbtAddress.toString()).thenReturn("NBT_HOST/192.168.1.2");

                resourceexists {
                    file(file: failureMarker.toString())
                }
                and {
                    resourceexists {
                        file(file: pidFile.toString())
                    }
                    resourceexists {
                        file(file: portsFile.toString())
                    }
                }
            }
        }

                                            .append(searchRequestBuilder.toString())//
                                            .append(",\"response\":")
                                            .append(r.toString())
                                            .append('}');
                                    logger.warn(buf.toString());
                                }
                            });

      assertBitEquals(serialClone(d).get(), d.get());
    }
  }

  /** toString returns current value */
  public void testToString() {
    AtomicDouble at = new AtomicDouble();
    assertThat(at.toString()).isEqualTo("0.0");
    for (double x : VALUES) {
      at.set(x);
      assertThat(at.toString()).isEqualTo(Double.toString(x));
    }
  }

  /** intValue returns current value. */