String simple = "a,b,c";
    List<String> letters = COMMA_SPLITTER.splitToStream(simple).collect(toImmutableList());
    assertThat(letters).containsExactly("a", "b", "c").inOrder();
  }

  public void testToString() {
    assertThat(COMMA_SPLITTER.split("").toString()).isEqualTo("[]");
    assertThat(COMMA_SPLITTER.split("a,b,c").toString()).isEqualTo("[a, b, c]");
    assertThat(Splitter.on(", ").split("yam, bam, jam, ham").toString())

    }

    @Nested
    @DisplayName("String Representation Tests")
    class StringRepresentationTests {

        @Test
        @DisplayName("toString should format message with all fields")
        void testToString() {
            // Given
            CIFSContext mockContext = createMockContext();
            Type2Message message = new Type2Message(mockContext, Type2Message.NTLMSSP_NEGOTIATE_UNICODE, TEST_CHALLENGE, TEST_TARGET);

    // Different lengths.
    a = asList(4, 8, 15, 16, 23);
    b = asList(4, 8, 15, 16, 23, 42);
    assertFalse(elementsEqual(a, b));
    assertFalse(elementsEqual(b, a));
  }

  public void testToString() {
    List<String> list = emptyList();
    assertThat(Iterables.toString(list)).isEqualTo("[]");

    list = newArrayList("yam", "bam", "jam", "ham");

	beforeDrives = make([]madmin.HealDriveInfo, len(endpoints))
	// Existing formats are available (i.e. ok), so save it in
	// result, also populate disks to be healed.
	for i, format := range formats {
		drive := endpoints.GetString(i)
		state := madmin.DriveStateCorrupt
		switch {
		case format != nil:
			state = madmin.DriveStateOk
		case sErrs[i] == errUnformattedDisk:
			state = madmin.DriveStateMissing

  private static Enumeration<Integer> enumerate(int... ints) {
    Vector<Integer> vector = new Vector<>(Ints.asList(ints));
    return vector.elements();
  }

  public void testToString() {
    Iterator<String> iterator = Lists.newArrayList("yam", "bam", "jam", "ham").iterator();
    assertThat(Iterators.toString(iterator)).isEqualTo("[yam, bam, jam, ham]");
  }

  private static Enumeration<Integer> enumerate(int... ints) {
    Vector<Integer> vector = new Vector<>(Ints.asList(ints));
    return vector.elements();
  }

  public void testToString() {
    Iterator<String> iterator = Lists.newArrayList("yam", "bam", "jam", "ham").iterator();
    assertThat(Iterators.toString(iterator)).isEqualTo("[yam, bam, jam, ham]");
  }

        .addEqualityGroup(TypeToken.of(new TypeCapture<B>() {}.capture()))
        .testEquals();
  }

  // T is used inside to test type variable
  public <T> void testToString() {
    assertThat(new TypeToken<String>() {}.toString()).isEqualTo(String.class.getName());
    assertThat(TypeToken.of(new TypeCapture<T>() {}.capture()).toString()).isEqualTo("T");

#include "tensorflow/c/tf_attrtype.h"
#include "tensorflow/c/tf_buffer.h"
#include "tensorflow/c/tf_datatype.h"
#include "tensorflow/c/tf_status.h"
#include "tensorflow/c/tf_tensor.h"
#include "tensorflow/c/tf_tstring.h"

// --------------------------------------------------------------------------
// C API for TensorFlow.
//
// The API leans towards simplicity and uniformity instead of convenience

pkg math/big, method (*Float) SetMode(RoundingMode) *Float
pkg math/big, method (*Float) SetPrec(uint) *Float
pkg math/big, method (*Float) SetRat(*Rat) *Float
pkg math/big, method (*Float) SetString(string) (*Float, bool)
pkg math/big, method (*Float) SetUint64(uint64) *Float
pkg math/big, method (*Float) Sign() int
pkg math/big, method (*Float) Signbit() bool
pkg math/big, method (*Float) String() string

        .addEqualityGroup(TypeToken.of(new TypeCapture<B>() {}.capture()))
        .testEquals();
  }

  // T is used inside to test type variable
  public <T> void testToString() {
    assertThat(new TypeToken<String>() {}.toString()).isEqualTo(String.class.getName());
    assertThat(TypeToken.of(new TypeCapture<T>() {}.capture()).toString()).isEqualTo("T");