.build(),
    )
    val webSocket: WebSocket = newWebSocket()
    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")
    serverListener.assertTextMessage("abc")
    server.send("def")
    clientListener.assertTextMessage("def")
    closeWebSockets(webSocket, server)
  }

  @Test
  @Throws(IOException::class)

            + "field1=This is string., field2=[abc, def, ghi], field3={abc=1, def=2, ghi=3}}";

    assertThat(toTest).isEqualTo(expected);
  }

  public void testToStringLenient_complexFields() {
    Map<String, Integer> map =
        ImmutableMap.<String, Integer>builder().put("abc", 1).put("def", 2).put("ghi", 3).build();
    String toTest =
        MoreObjects.toStringHelper(new TestClass())

	}
	if !reflect.DeepEqual(v, v2) {
		t.Errorf("MSS: %v != %v", v, v2)
	}
}

func BenchmarkMarshalMsgMSS(b *testing.B) {
	v := MSS{"abc": "def", "ghi": "jkl"}
	b.ReportAllocs()

	for b.Loop() {
		v.MarshalMsg(nil)
	}
}

func BenchmarkAppendMsgMSS(b *testing.B) {
	v := MSS{"abc": "def", "ghi": "jkl"}
	bts := make([]byte, 0, v.Msgsize())
	bts, _ = v.MarshalMsg(bts[0:0])
	b.SetBytes(int64(len(bts)))
	b.ReportAllocs()

          },
        )
      }

    assertThat(response.trailers()["a"]).isEqualTo("b")
  }

  @Test fun peekAfterReadingResponse() {
    val response = newResponse(responseBody("abc"))
    assertThat(response.body.string()).isEqualTo("abc")

    assertFailsWith<IllegalStateException> {
      response.peekBody(3)
    }
  }

  /**

Plain objects are automatically JSON-serialized as `data:` fields, declare the return type so the serialization is done by Pydantic:

```python
from collections.abc import AsyncIterable

from fastapi import FastAPI
from fastapi.sse import EventSourceResponse
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float

		}
	}
	return true, ""
}

func TestCmpReaders(t *testing.T) {
	{
		r1 := bytes.NewReader([]byte("abc"))
		r2 := bytes.NewReader([]byte("abc"))
		ok, msg := cmpReaders(r1, r2)
		if !ok || msg != "" {
			t.Fatalf("unexpected")
		}
	}

	{
		r1 := bytes.NewReader([]byte("abc"))
		r2 := bytes.NewReader([]byte("abcd"))
		ok, _ := cmpReaders(r1, r2)
		if ok {
			t.Fatalf("unexpected")
		}

        assertEquals("abc", fessXpathTransformer.removeCommentTag("abc"));
        assertEquals("abc ", fessXpathTransformer.removeCommentTag("abc<!-- foo -->"));
        assertEquals("abc 123", fessXpathTransformer.removeCommentTag("abc<!-- fo\no -->123"));
        assertEquals("abc 123", fessXpathTransformer.removeCommentTag("abc<!--\n foo -->123"));

from collections.abc import AsyncGenerator
from contextlib import AbstractContextManager
from contextlib import asynccontextmanager as asynccontextmanager
from typing import TypeVar

import anyio.to_thread
from anyio import CapacityLimiter
from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
from starlette.concurrency import (  # noqa

  }

  @Test
  fun setBodyAdjustsHeaders() {
    val response = MockResponse().setBody("ABC")
    assertThat(headersToList(response)).containsExactly("Content-Length: 3")
    assertThat(response.getBody()!!.readUtf8()).isEqualTo("ABC")
  }

  @Test
  fun mockResponseAddHeader() {
    val response =
      MockResponse()
        .clearHeaders()

        assertEquals("plaintext", permissionHelper.encode("plaintext"));
        assertEquals("plaintext", permissionHelper.decode("plaintext"));

        assertEquals("abc", permissionHelper.encode("abc"));
        assertEquals("abc", permissionHelper.decode("abc"));

        assertEquals("special@chars", permissionHelper.encode("special@chars"));
        assertEquals("special@chars", permissionHelper.decode("special@chars"));
    }