


import contextlib
import csv
import json
import os
import sqlitea
import tarfile
import textwrap
import zipfile

import pyarrow as pa
import pyarrow.parquet as pq
import pytest

import datasets
import datasets.config
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					)->		Dict:
			UpperCamelCase__       =							10
			UpperCamelCase__       =							datasets.Features(
			    {
			        "tokens": datasets.Sequence(datasets.Value("string"	)	),
			        "labels": datasets.Sequence(datasets.ClassLabel(names=["negative", "positive"]	)	),
			        "answers": datasets.Sequence(
			            {
			                "text": datasets.Value("string"	),
			                "answer_start": datasets.Value("int32"	),
			            }	),
			        "id": datasets.Value("int64"	),
			    }	)
			UpperCamelCase__       =							datasets.Dataset.from_dict(
			    {
			        "tokens": [["foo"] * 5] * n,
			        "labels": [[1] * 5] * n,
			        "answers": [{"answer_start": [97], "text": ["1976"]}] * 10,
			        "id": list(range(_A	)	),
			    }					,  features=_A					,  )
			return dataset
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]					,  _A :Any	)->		Tuple:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "file.arrow"	)
			dataset.map(cache_file_name=_A	)
			return filename


# FILE_CONTENT + files


__UpperCamelCase     		=							'\\n    Text data.\n    Second line of data.'
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Dict	)->		List[Any]:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt"
			UpperCamelCase__       =							FILE_CONTENT
			with open(_A					,  "w"	) as f:
						f.write(_A	)
			return filename
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :str	)->		List[str]:
			import bza

			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt.bz2"
			UpperCamelCase__       =							bytes(_A					,  "utf-8"	)
			with bza.open(_A					,  "wb"	) as f:
						f.write(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]	)->		Dict:
			import gzip

			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "file.txt.gz"	)
			UpperCamelCase__       =							bytes(_A					,  "utf-8"	)
			with gzip.open(_A					,  "wb"	) as f:
						f.write(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Any	)->		List[str]:
			if datasets.config.LZ4_AVAILABLE:
						import lza.frame

						UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt.lz4"
						UpperCamelCase__       =							bytes(_A					,  "utf-8"	)
						with lza.frame.open(_A					,  "wb"	) as f:
									f.write(_A	)
						return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]					,  _A :Any	)->		List[Any]:
			if datasets.config.PY7ZR_AVAILABLE:
						import pyazr

						UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt.7z"
						with pyazr.SevenZipFile(_A					,  "w"	) as archive:
									archive.write(_A					,  arcname=os.path.basename(_A	)	)
						return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Any					,  _A :Optional[Any]	)->		List[str]:
			import tarfile

			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt.tar"
			with tarfile.TarFile(_A					,  "w"	) as f:
						f.add(_A					,  arcname=os.path.basename(_A	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :str	)->		List[str]:
			import lzma

			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt.xz"
			UpperCamelCase__       =							bytes(_A					,  "utf-8"	)
			with lzma.open(_A					,  "wb"	) as f:
						f.write(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :List[Any]					,  _A :Union[str, Any]	)->		Union[str, Any]:
			import zipfile

			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.basename(_A	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :int	)->		Union[str, Any]:
			if datasets.config.ZSTANDARD_AVAILABLE:
						import zstandard as zstd

						UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.txt.zst"
						UpperCamelCase__       =							bytes(_A					,  "utf-8"	)
						with zstd.open(_A					,  "wb"	) as f:
									f.write(_A	)
						return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Tuple	)->		int:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "file.xml"
			UpperCamelCase__       =							textwrap.dedent(
			    "\\n    <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n    <tmx version=\"1.4\">\n      <header segtype=\"sentence\" srclang=\"ca\" />\n      <body>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 1</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 1</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 2</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 2</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 3</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 3</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 4</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 4</seg></tuv>\n        </tu>\n        <tu>\n          <tuv xml:lang=\"ca\"><seg>Contingut 5</seg></tuv>\n          <tuv xml:lang=\"en\"><seg>Content 5</seg></tuv>\n        </tu>\n      </body>\n    </tmx>"	)
			with open(_A					,  "w"	) as f:
						f.write(_A	)
			return filename


__UpperCamelCase     		=							[
    {'col_1': '0', 'col_2': 0, 'col_3': 0.0},
    {'col_1': '1', 'col_2': 1, 'col_3': 1.0},
    {'col_1': '2', 'col_2': 2, 'col_3': 2.0},
    {'col_1': '3', 'col_2': 3, 'col_3': 3.0},
]
__UpperCamelCase     		=							[
    {'col_1': '4', 'col_2': 4, 'col_3': 4.0},
    {'col_1': '5', 'col_2': 5, 'col_3': 5.0},
]
__UpperCamelCase     		=							{
    'col_1': ['0', '1', '2', '3'],
    'col_2': [0, 1, 2, 3],
    'col_3': [0.0, 1.0, 2.0, 3.0],
}

__UpperCamelCase     		=							[
    {'col_3': 0.0, 'col_1': '0', 'col_2': 0},
    {'col_3': 1.0, 'col_1': '1', 'col_2': 1},
]

__UpperCamelCase     		=							[
    {'col_1': 's0', 'col_2': 0, 'col_3': 0.0},
    {'col_1': 's1', 'col_2': 1, 'col_3': 1.0},
    {'col_1': 's2', 'col_2': 2, 'col_3': 2.0},
    {'col_1': 's3', 'col_2': 3, 'col_3': 3.0},
]
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					)->		int:
			return DATA_DICT_OF_LISTS
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :int	)->		Optional[Any]:
			UpperCamelCase__       =							datasets.Dataset.from_dict(_A	)
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.arrow"	)
			dataset.map(cache_file_name=_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[Any]	)->		Dict:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.sqlite"	)
			with contextlib.closing(sqlitea.connect(_A	)	) as con:
						UpperCamelCase__       =							con.cursor()
						cur.execute("CREATE TABLE dataset(col_1 text, col_2 int, col_3 real)"	)
						for item in DATA:
									cur.execute("INSERT INTO dataset(col_1, col_2, col_3) VALUES (?, ?, ?)"					,  tuple(item.values()	)	)
						con.commit()
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]	)->		Optional[int]:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.csv"	)
			with open(_A					,  "w"					,  newline=""	) as f:
						UpperCamelCase__       =							csv.DictWriter(_A					,  fieldnames=["col_1", "col_2", "col_3"]	)
						writer.writeheader()
						for item in DATA:
									writer.writerow(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Tuple	)->		Optional[Any]:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset2.csv"	)
			with open(_A					,  "w"					,  newline=""	) as f:
						UpperCamelCase__       =							csv.DictWriter(_A					,  fieldnames=["col_1", "col_2", "col_3"]	)
						writer.writeheader()
						for item in DATA:
									writer.writerow(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :int					,  _A :Any	)->		Tuple:
			import bza

			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.csv.bz2"
			with open(_A					,  "rb"	) as f:
						UpperCamelCase__       =							f.read()
			# data = bytes(FILE_CONTENT, "utf-8")
			with bza.open(_A					,  "wb"	) as f:
						f.write(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[Any]					,  _A :Dict					,  _A :List[str]	)->		List[Any]:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.csv.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.basename(_A	)	)
						f.write(_A					,  arcname=os.path.basename(_A	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Union[str, Any]					,  _A :str					,  _A :int	)->		Any:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.csv.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.basename(csv_path.replace(".csv"					,  ".CSV"	)	)	)
						f.write(_A					,  arcname=os.path.basename(csva_path.replace(".csv"					,  ".CSV"	)	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]					,  _A :Optional[Any]					,  _A :Union[str, Any]	)->		Union[str, Any]:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset_with_dir.csv.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.join("main_dir"					,  os.path.basename(_A	)	)	)
						f.write(_A					,  arcname=os.path.join("main_dir"					,  os.path.basename(_A	)	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Any	)->		Dict:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.parquet"	)
			UpperCamelCase__       =							pa.schema(
			    {
			        "col_1": pa.string(),
			        "col_2": pa.intaa(),
			        "col_3": pa.floataa(),
			    }	)
			with open(_A					,  "wb"	) as f:
						UpperCamelCase__       =							pq.ParquetWriter(_A					,  schema=_A	)
						UpperCamelCase__       =							pa.Table.from_pydict({k: [DATA[i][k] for i in range(len(_A	)	)] for k in DATA[0]}					,  schema=_A	)
						writer.write_table(_A	)
						writer.close()
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]	)->		Any:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.json"	)
			UpperCamelCase__       =							{"data": DATA}
			with open(_A					,  "w"	) as f:
						json.dump(_A					,  _A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :str	)->		Union[str, Any]:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.json"	)
			UpperCamelCase__       =							{"data": DATA_DICT_OF_LISTS}
			with open(_A					,  "w"	) as f:
						json.dump(_A					,  _A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Dict	)->		List[str]:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.jsonl"	)
			with open(_A					,  "w"	) as f:
						for item in DATA:
									f.write(json.dumps(_A	) + "\n"	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :List[str]	)->		int:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset2.jsonl"	)
			with open(_A					,  "w"	) as f:
						for item in DATA:
									f.write(json.dumps(_A	) + "\n"	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Dict	)->		Any:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset_312.jsonl"	)
			with open(_A					,  "w"	) as f:
						for item in DATA_312:
									f.write(json.dumps(_A	) + "\n"	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :List[str]	)->		int:
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset-str.jsonl"	)
			with open(_A					,  "w"	) as f:
						for item in DATA_STR:
									f.write(json.dumps(_A	) + "\n"	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Union[str, Any]					,  _A :Dict	)->		int:
			import gzip

			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.txt.gz"	)
			with open(_A					,  "rb"	) as orig_file:
						with gzip.open(_A					,  "wb"	) as zipped_file:
									zipped_file.writelines(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :List[str]					,  _A :List[str]	)->		Tuple:
			import gzip

			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.jsonl.gz"	)
			with open(_A					,  "rb"	) as orig_file:
						with gzip.open(_A					,  "wb"	) as zipped_file:
									zipped_file.writelines(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]					,  _A :Optional[Any]					,  _A :str	)->		Optional[Any]:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.jsonl.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.basename(_A	)	)
						f.write(_A					,  arcname=os.path.basename(_A	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]					,  _A :Dict					,  _A :List[str]					,  _A :List[Any]	)->		str:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset_nested.jsonl.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.join("nested"					,  os.path.basename(_A	)	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]					,  _A :int					,  _A :Any	)->		Dict:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset_with_dir.jsonl.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.join("main_dir"					,  os.path.basename(_A	)	)	)
						f.write(_A					,  arcname=os.path.join("main_dir"					,  os.path.basename(_A	)	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Tuple					,  _A :Dict					,  _A :Optional[int]	)->		Tuple:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.jsonl.tar"
			with tarfile.TarFile(_A					,  "w"	) as f:
						f.add(_A					,  arcname=os.path.basename(_A	)	)
						f.add(_A					,  arcname=os.path.basename(_A	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[Any]					,  _A :List[str]					,  _A :Any					,  _A :str	)->		Union[str, Any]:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset_nested.jsonl.tar"
			with tarfile.TarFile(_A					,  "w"	) as f:
						f.add(_A					,  arcname=os.path.join("nested"					,  os.path.basename(_A	)	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Union[str, Any]	)->		List[str]:
			UpperCamelCase__       =							["0", "1", "2", "3"]
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset.txt"	)
			with open(_A					,  "w"	) as f:
						for item in data:
									f.write(item + "\n"	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Optional[int]	)->		List[str]:
			UpperCamelCase__       =							["0", "1", "2", "3"]
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset2.txt"	)
			with open(_A					,  "w"	) as f:
						for item in data:
									f.write(item + "\n"	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Union[str, Any]	)->		int:
			UpperCamelCase__       =							["0", "1", "2", "3"]
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.abc"
			with open(_A					,  "w"	) as f:
						for item in data:
									f.write(item + "\n"	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :List[str]					,  _A :List[str]					,  _A :Optional[Any]	)->		Union[str, Any]:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.text.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.basename(_A	)	)
						f.write(_A					,  arcname=os.path.basename(_A	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :str					,  _A :Union[str, Any]					,  _A :Dict	)->		Tuple:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset_with_dir.text.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.join("main_dir"					,  os.path.basename(_A	)	)	)
						f.write(_A					,  arcname=os.path.join("main_dir"					,  os.path.basename(_A	)	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Any					,  _A :Optional[int]					,  _A :int	)->		Any:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.ext.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.basename("unsupported.ext"	)	)
						f.write(_A					,  arcname=os.path.basename("unsupported_2.ext"	)	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Dict	)->		Any:
			UpperCamelCase__       =							"\n".join(["First", "Second\u2029with Unicode new line", "Third"]	)
			UpperCamelCase__       =							str(tmp_path_factory.mktemp("data"	) / "dataset_with_unicode_new_lines.txt"	)
			with open(_A					,  "w"					,  encoding="utf-8"	) as f:
						f.write(_A	)
			return path
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					)->		List[Any]:
			return os.path.join("tests"					,  "features"					,  "data"					,  "test_image_rgb.jpg"	)
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					)->		Optional[int]:
			return os.path.join("tests"					,  "features"					,  "data"					,  "test_audio_44100.wav"	)
@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :int					,  _A :Dict	)->		Dict:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data"	) / "dataset.img.zip"
			with zipfile.ZipFile(_A					,  "w"	) as f:
						f.write(_A					,  arcname=os.path.basename(_A	)	)
						f.write(_A					,  arcname=os.path.basename(_A	).replace(".jpg"					,  "2.jpg"	)	)
			return path







@pytest.fixture(scope="session"	)
def 							UpperCamelCase_(					_A :Dict	)->		Dict:
			UpperCamelCase__       =							tmp_path_factory.mktemp("data_dir"	)

			(data_dir / "subdir").mkdir()
			with open(data_dir / "subdir" / "train.txt"					,  "w"	) as f:
						f.write("foo\n" * 10	)
			with open(data_dir / "subdir" / "test.txt"					,  "w"	) as f:
						f.write("bar\n" * 10	)
			# hidden file
			with open(data_dir / "subdir" / ".test.txt"					,  "w"	) as f:
						f.write("bar\n" * 10	)

			# hidden directory
			(data_dir / ".subdir").mkdir()
			with open(data_dir / ".subdir" / "train.txt"					,  "w"	) as f:
						f.write("foo\n" * 10	)
			with open(data_dir / ".subdir" / "test.txt"					,  "w"	) as f:
						f.write("bar\n" * 10	)

			return data_dir






from unittest.mock import Mock, patch

from file_transfer.send_file import send_file
@patch("socket.socket"	)
@patch("builtins.open"	)
def 							UpperCamelCase_(					_A :Tuple					,  _A :str	)->		int:
			# ===== initialization =====
			UpperCamelCase__       =							Mock()
			UpperCamelCase__       =							conn, Mock()
			UpperCamelCase__       =							iter([1, None]	)
			UpperCamelCase__       =							lambda _A	: next(_A	)

			# ===== invoke =====
			send_file(filename="mytext.txt"					,  testing=_A	)

			# ===== ensurance =====
			sock.assert_called_once()
			sock.return_value.bind.assert_called_once()
			sock.return_value.listen.assert_called_once()
			sock.return_value.accept.assert_called_once()
			conn.recv.assert_called_once()

			file.return_value.__enter__.assert_called_once()
			file.return_value.__enter__.return_value.read.assert_called()

			conn.send.assert_called_once()
			conn.close.assert_called_once()
			sock.return_value.shutdown.assert_called_once()
			sock.return_value.close.assert_called_once()


