assertThat(stringIdentityConverter.toString()).isEqualTo("Converter.identity()");

    assertThat(Converter.identity()).isSameInstanceAs(Converter.identity());
  }

  public void testFrom() {
    Function<String, Integer> forward = Integer::parseInt;
    Function<Object, String> backward = toStringFunction();

    Converter<String, Number> converter = Converter.<String, Number>from(forward, backward);

    FluentIterable<TimeUnit> units = FluentIterable.from(TimeUnit.values());
    assertThrows(UnsupportedOperationException.class, () -> removeIf(units, equalTo(SECONDS)));
  }

  public void testFrom() {
    assertEquals(
        ImmutableList.of(1, 2, 3, 4),
        Lists.newArrayList(FluentIterable.from(ImmutableList.of(1, 2, 3, 4))));
  }

  @SuppressWarnings({
    "deprecation", // test of deprecated method

package clause_test

import (
	"fmt"
	"testing"

	"gorm.io/gorm/clause"
)

func TestFrom(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Select{}, clause.From{}},
			"SELECT * FROM `users`", nil,
		},
		{
			[]clause.Interface{
				clause.Select{}, clause.From{
					Tables: []clause.Table{{Name: "users"}},

  final Closeable mockCloseable = mock(Closeable.class);

  @Override
  protected void tearDown() throws Exception {
    assertNoExpectedFailures();
    super.tearDown();
  }

  public void testFrom() throws Exception {
    ClosingFuture<String> closingFuture =
        ClosingFuture.from(executor.submit(Callables.returning(closeable1)))
            .transform(

    assertThat(reserialize(comparator)).isSameInstanceAs(comparator);
    assertThat(comparator.toString()).isEqualTo("Ordering.natural()");
  }

  public void testFrom() {
    Ordering<String> caseInsensitiveOrdering = Ordering.from(String.CASE_INSENSITIVE_ORDER);
    assertEquals(0, caseInsensitiveOrdering.compare("A", "a"));
    assertTrue(caseInsensitiveOrdering.compare("a", "B") < 0);

  final Closeable mockCloseable = mock(Closeable.class);

  @Override
  protected void tearDown() throws Exception {
    assertNoExpectedFailures();
    super.tearDown();
  }

  public void testFrom() throws Exception {
    ClosingFuture<String> closingFuture =
        ClosingFuture.from(executor.submit(Callables.returning(closeable1)))
            .transform(

    assertThat(reserialize(comparator)).isSameInstanceAs(comparator);
    assertThat(comparator.toString()).isEqualTo("Ordering.natural()");
  }

  public void testFrom() {
    Ordering<String> caseInsensitiveOrdering = Ordering.from(String.CASE_INSENSITIVE_ORDER);
    assertEquals(0, caseInsensitiveOrdering.compare("A", "a"));
    assertTrue(caseInsensitiveOrdering.compare("a", "B") < 0);

    Properties testProp = new Properties();

    Map<String, String> result = Maps.fromProperties(testProp);
    assertTrue(result.isEmpty());
    testProp.setProperty("first", "true");

    result = Maps.fromProperties(testProp);
    assertThat(result.get("first")).isEqualTo("true");
    assertEquals(1, result.size());
    testProp.setProperty("second", "null");

            // Domains: single domain named TESTDOM
            lsarpc.LsarRefDomainList domains = new lsarpc.LsarRefDomainList();
            domains.count = 1;
            domains.max_count = 1;
            domains.domains = new lsarpc.LsarTrustInformation[1];
            domains.domains[0] = new lsarpc.LsarTrustInformation();
            domains.domains[0].name = new UnicodeString("TESTDOM", false);

  }

  public void testContainsRow() {
    assertFalse(INSTANCE.containsRow('a'));
  }

  public void testContainsValue() {
    assertFalse(INSTANCE.containsValue("blah"));
  }

  public void testRow() {
    assertEquals(ImmutableMap.of(), INSTANCE.row('a'));
  }

  public void testRowKeySet() {
    assertEquals(ImmutableSet.of(), INSTANCE.rowKeySet());
  }

  public void testRowMap() {