typedef struct {
		[string] wchar_t *entry_path;
	} DfsInfo1;

	typedef struct {
		uint32_t count;
		[size_is(count)] DfsInfo1 *s;
	} DfsEnumArray1;

	typedef struct {
		uint32_t state;
		[string] wchar_t *server_name;
		[string] wchar_t *share_name;
	} DfsStorageInfo;

	typedef struct {
		[string] wchar_t *path;
		[string] wchar_t *comment;
		uint32_t state;

package mountinfo

// mountInfo - This represents a single line in /proc/mounts.
type mountInfo struct {
	Device  string
	Path    string
	FSType  string
	Options []string
	Freq    string
	Pass    string
}

func (m mountInfo) String() string {
	return m.Path
}

// mountInfos - This represents the entire /proc/mounts.

        .build(),
    )
    val url = server.url("/")
    assertThat(get(url).body.string()).isEqualTo("A")
    assertThat(get(url).body.string()).isEqualTo("A")
    assertThat(get(url).body.string()).isEqualTo("B")
    assertThat(get(url).body.string()).isEqualTo("B")
    assertThat(server.takeRequest().headers["If-None-Match"]).isNull()

	}
	return md.labelSet
}

func (md *MetricDescriptor) toPromName(namePrefix string) string {
	return prometheus.BuildFQName(namePrefix, "", string(md.Name))
}

func (md *MetricDescriptor) toPromDesc(namePrefix string, extraLabels map[string]string) *prometheus.Desc {
	return prometheus.NewDesc(
		md.toPromName(namePrefix),
		md.Help,
		md.VariableLabels, extraLabels,
	)
}

  }

  @GwtIncompatible // Iterators.toArray(Iterator, Class)
  public void testToArray() {
    String[] sourceArray = new String[] {"a", "b", "c"};
    Iterator<String> iterator = asList(sourceArray).iterator();
    String[] newArray = Iterators.toArray(iterator, String.class);
    assertThat(newArray).isEqualTo(sourceArray);
  }

  public void testFilterSimple() {

	public final fun -deprecated_method ()Ljava/lang/String;
	public final fun -deprecated_path ()Ljava/lang/String;
	public final fun -deprecated_response ()Lokhttp3/mockwebserver/MockResponse;
	public fun <init> (Ljava/lang/String;Ljava/lang/String;Lokhttp3/Headers;Lokhttp3/mockwebserver/MockResponse;)V
	public final fun headers ()Lokhttp3/Headers;
	public final fun method ()Ljava/lang/String;
	public final fun path ()Ljava/lang/String;

  @Test
  fun emptyTags() {
    val tags = EmptyTags
    assertThat(tags[String::class]).isNull()
  }

  @Test
  fun singleElement() {
    val tags = EmptyTags.plus(String::class, "hello")
    assertThat(tags[String::class]).isEqualTo("hello")
  }

  @Test
  fun multipleElements() {
    val tags =
      EmptyTags
        .plus(String::class, "hello")
        .plus(Integer::class, 5 as Integer)

        assertNotSame(builder.contents, prevArray);
        prevArray = builder.contents;
      }
    }
  }

  public void testCreation_arrayOfArray() {
    String[] array = new String[] {"a"};
    Set<String[]> set = ImmutableSet.<String[]>of(array);
    assertEquals(singleton(array), set);
  }

  @GwtIncompatible // ImmutableSet.chooseTableSize
  public void testChooseTableSize() {

    private final String revision;
    private final String origin;

    private GitInfo(String revision, String origin) {
        this.revision = revision;
        this.origin = origin;
    }

    public String getRevision() {
        return revision;
    }

    public String getOrigin() {
        return origin;
    }

			t.Errorf("%v: expected %v, got %v", c.values, c.key, key)
		}
	}
}

func TestContains(t *testing.T) {
	containsTests := []struct {
		name  string
		elems []string
		elem  string
		out   bool
	}{
		{"exists", []string{"1", "2", "3"}, "1", true},
		{"not exists", []string{"1", "2", "3"}, "4", false},
	}
	for _, test := range containsTests {
		t.Run(test.name, func(t *testing.T) {