blob: 7d8e7a5636bd7c5dc323543f22663620ded985d5 [file] [log] [blame]
// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// @dart = 2.9
import 'dart:async';
import 'dart:convert';
import 'dart:io';
import 'package:expect/expect.dart';
import 'test_utils.dart' show withTempDir;
Future testAddress(String name) async {
var address = InternetAddress('$name/sock', type: InternetAddressType.unix);
var server = await ServerSocket.bind(address, 0);
var client = await Socket.connect(address, server.port);
var completer = Completer<void>();
server.listen((socket) async {
Expect.equals(socket.port, 0);
Expect.equals(socket.port, server.port);
Expect.equals(client.port, socket.remotePort);
Expect.equals(client.remotePort, socket.port);
// Client has not bound to a path. This is an unnamed socket.
Expect.equals(socket.remoteAddress.toString(), "InternetAddress('', Unix)");
Expect.equals(client.remoteAddress.toString(), address.toString());
socket.destroy();
client.destroy();
await server.close();
completer.complete();
});
await completer.future;
}
testBindShared(String name) async {
var address = InternetAddress('$name/sock', type: InternetAddressType.unix);
var socket = await ServerSocket.bind(address, 0, shared: true);
Expect.isTrue(socket.port == 0);
// Same path
var socket2 = await ServerSocket.bind(address, 0, shared: true);
Expect.equals(socket.address.address, socket2.address.address);
Expect.equals(socket.port, socket2.port);
// Test relative path
var path = name.substring(name.lastIndexOf('/') + 1);
address = InternetAddress('${name}/../${path}/sock',
type: InternetAddressType.unix);
var socket3 = await ServerSocket.bind(address, 0, shared: true);
Expect.isTrue(FileSystemEntity.identicalSync(
socket.address.address, socket3.address.address));
Expect.equals(socket.port, socket2.port);
await socket.close();
await socket2.close();
await socket3.close();
}
testBind(String name) async {
final address = InternetAddress('$name/sock', type: InternetAddressType.unix);
final server = await ServerSocket.bind(address, 0, shared: false);
Expect.isTrue(server.address.toString().contains(name));
// Unix domain socket does not have a valid port number.
Expect.equals(server.port, 0);
final serverContinue = Completer();
final clientContinue = Completer();
server.listen((s) async {
await serverContinue.future;
clientContinue.complete();
});
final socket = await Socket.connect(address, server.port);
socket.write(" socket content");
serverContinue.complete();
await clientContinue.future;
socket.destroy();
await server.close();
}
Future testListenCloseListenClose(String name) async {
var address = InternetAddress('$name/sock', type: InternetAddressType.unix);
ServerSocket socket = await ServerSocket.bind(address, 0, shared: true);
ServerSocket socket2 =
await ServerSocket.bind(address, socket.port, shared: true);
// The second socket should have kept the OS socket alive. We can therefore
// test if it is working correctly.
await socket.close();
// For robustness we ignore any clients unrelated to this test.
List<int> sendData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
socket2.listen((Socket client) async {
client.add(sendData);
await Future.wait([client.drain(), client.close()]);
});
final client = await Socket.connect(address, socket2.port);
List<int> data = [];
var completer = Completer<void>();
client.listen(data.addAll, onDone: () {
Expect.listEquals(sendData, data);
completer.complete();
});
await completer.future;
await client.close();
// Close the second server socket.
await socket2.close();
}
Future testSourceAddressConnect(String name) async {
var address = InternetAddress('$name/sock', type: InternetAddressType.unix);
ServerSocket server = await ServerSocket.bind(address, 0);
var completer = Completer<void>();
var localAddress =
InternetAddress('$name/local', type: InternetAddressType.unix);
server.listen((Socket socket) async {
Expect.equals(socket.address.address, address.address);
Expect.equals(socket.remoteAddress.address, localAddress.address);
socket.drain();
socket.close();
completer.complete();
});
Socket client =
await Socket.connect(address, server.port, sourceAddress: localAddress);
Expect.equals(client.remoteAddress.address, address.address);
await completer.future;
await client.close();
await client.drain();
await server.close();
}
Future testAbstractAddress(String uniqueName) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
var serverAddress =
InternetAddress('@temp.sock.$uniqueName', type: InternetAddressType.unix);
ServerSocket server = await ServerSocket.bind(serverAddress, 0);
final completer = Completer<void>();
final content = 'random string';
server.listen((Socket socket) {
socket.listen((data) {
Expect.equals(content, utf8.decode(data));
socket.close();
server.close();
completer.complete();
});
});
Socket client = await Socket.connect(serverAddress, 0);
client.write(content);
await client.drain();
await client.close();
await completer.future;
}
String getAbstractSocketTestFileName() {
var executable = Platform.executable;
var dirIndex = executable.lastIndexOf('dart');
var buffer = new StringBuffer(executable.substring(0, dirIndex));
buffer.write('abstract_socket_test');
return buffer.toString();
}
Future testShortAbstractAddress(String uniqueName) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
var retries = 10;
var retryDelay = const Duration(seconds: 1);
Process process;
var stdoutFuture;
var stderrFuture;
try {
var socketAddress = '@temp.sock.$uniqueName';
var abstractSocketServer = getAbstractSocketTestFileName();
// check if the executable exists, some build configurations do not
// build it (e.g: precompiled simarm/simarm64)
if (!File(abstractSocketServer).existsSync()) {
return;
}
// Start up a subprocess that listens on [socketAddress].
process = await Process.start(abstractSocketServer, [socketAddress]);
stdoutFuture = process.stdout
.transform(const Utf8Decoder(allowMalformed: true))
.listen(stdout.write)
.asFuture(null);
stderrFuture = process.stderr
.transform(const Utf8Decoder(allowMalformed: true))
.listen(stderr.write)
.asFuture(null);
var serverAddress =
InternetAddress(socketAddress, type: InternetAddressType.unix);
// The subprocess may take some time to start, so retry setting up the
// connection a few times.
Socket client;
while (true) {
try {
client = await Socket.connect(serverAddress, 0);
break;
} catch (e, st) {
if (retries <= 0) {
rethrow;
}
retries--;
}
await Future.delayed(retryDelay);
}
List<int> sendData = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
List<int> data = [];
var completer = Completer<void>();
client.listen(data.addAll, onDone: () {
Expect.listEquals(sendData, data);
completer.complete();
});
client.add(sendData);
await client.close();
await completer.future;
client.destroy();
var exitCode = await process.exitCode;
process = null;
Expect.equals(exitCode, 0);
} catch (e, st) {
Expect.fail('Failed with exception:\n$e\n$st');
} finally {
process?.kill(ProcessSignal.sigkill);
await stdoutFuture;
await stderrFuture;
await process?.exitCode;
}
}
Future testExistingFile(String name) async {
// Test that a leftover file(In case of previous process being killed and
// finalizer doesn't clean up the file) will be cleaned up and bind() should
// be able to bind to the socket.
var address = InternetAddress('$name/sock', type: InternetAddressType.unix);
// Create a file with the same name
File(address.address).createSync();
try {
ServerSocket server = await ServerSocket.bind(address, 0);
server.close();
} catch (e) {
Expect.type<SocketException>(e);
return;
}
Expect.fail("bind should fail with existing file");
}
Future testSetSockOpt(String name) async {
var address = InternetAddress('$name/sock', type: InternetAddressType.unix);
var server = await ServerSocket.bind(address, 0, shared: false);
var sub;
sub = server.listen((s) {
sub.cancel();
server.close();
});
var socket = await Socket.connect(address, server.port);
socket.write(" socket content");
// Get some socket options.
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelTcp, i, false);
var result = socket.getRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelUdp, i, false);
var result = socket.getRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelIPv4, i, false);
var result = socket.getRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelIPv6, i, false);
var result = socket.getRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelSocket, i, false);
var result = socket.getRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Protocol not available'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option = RawSocketOption.fromBool(
RawSocketOption.IPv4MulticastInterface, i, false);
var result = socket.getRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option = RawSocketOption.fromBool(
RawSocketOption.IPv6MulticastInterface, i, false);
var result = socket.getRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
// Set some socket options
try {
socket.setOption(SocketOption.tcpNoDelay, true);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelTcp, i, false);
var result = socket.setRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelUdp, i, false);
var result = socket.setRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelIPv4, i, false);
var result = socket.setRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelIPv6, i, false);
var result = socket.setRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option =
RawSocketOption.fromBool(RawSocketOption.levelSocket, i, false);
var result = socket.setRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Protocol not available'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option = RawSocketOption.fromBool(
RawSocketOption.IPv4MulticastInterface, i, false);
var result = socket.setRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
for (int i = 0; i < 5; i++) {
try {
RawSocketOption option = RawSocketOption.fromBool(
RawSocketOption.IPv6MulticastInterface, i, false);
var result = socket.setRawOption(option);
} catch (e) {
Expect.isTrue(e.toString().contains('Operation not supported'));
}
}
socket.destroy();
await server.close();
}
Future testHttpServer(String name) async {
var address = InternetAddress('$name/sock', type: InternetAddressType.unix);
var httpServer = await HttpServer.bind(address, 0);
var sub;
sub = httpServer.listen((s) {
sub.cancel();
httpServer.close();
});
var socket = await Socket.connect(address, httpServer.port);
socket.destroy();
await httpServer.close();
}
Future testFileMessage(String tempDirPath) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final completer = Completer<bool>();
final address =
InternetAddress('$tempDirPath/sock', type: InternetAddressType.unix);
final server = await RawServerSocket.bind(address, 0, shared: false);
server.listen((RawSocket socket) async {
print('server started a socket $socket');
socket.listen((e) {
if (e == RawSocketEvent.read) {
final SocketMessage message = socket.readMessage();
if (message == null) {
return;
}
print('server received message $message');
final String messageData = String.fromCharCodes(message.data);
print('server received messageData $messageData');
if (messageData == 'EmptyMessage') {
Expect.equals('EmptyMessage'.length, message.data.length);
Expect.isTrue(message.controlMessages.isEmpty);
return;
}
Expect.equals('Hello', messageData);
Expect.equals('Hello'.length, message.data.length);
Expect.equals(1, message.controlMessages.length);
final SocketControlMessage controlMessage = message.controlMessages[0];
final handles = controlMessage.extractHandles();
Expect.isNotNull(handles);
Expect.equals(1, handles.length);
final receivedFile = handles[0].toFile();
receivedFile.writeStringSync('Hello, server!\n');
print("server has written to the $receivedFile file");
socket.write('abc'.codeUnits);
} else if (e == RawSocketEvent.readClosed) {
print('server socket got readClosed');
socket.close();
server.close();
}
});
});
final file = File('$tempDirPath/myfile.txt');
final randomAccessFile = file.openSync(mode: FileMode.write);
// Send a message with sample file.
final socket = await RawSocket.connect(address, 0);
socket.listen((e) {
if (e == RawSocketEvent.write) {
randomAccessFile.writeStringSync('Hello, client!\n');
socket.sendMessage(<SocketControlMessage>[
SocketControlMessage.fromHandles(
<ResourceHandle>[ResourceHandle.fromFile(randomAccessFile)])
], 'Hello'.codeUnits);
print('client sent a message');
socket.sendMessage(<SocketControlMessage>[], 'EmptyMessage'.codeUnits);
print('client sent a message without control data');
} else if (e == RawSocketEvent.read) {
final data = socket.read();
Expect.equals('abc', String.fromCharCodes(data));
Expect.equals(
'Hello, client!\nHello, server!\n', file.readAsStringSync());
socket.close();
completer.complete(true);
}
});
return completer.future;
}
Future testTooLargeControlMessage(String tempDirPath) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final completer = Completer<bool>();
final address =
InternetAddress('$tempDirPath/sock', type: InternetAddressType.unix);
final server = await RawServerSocket.bind(address, 0, shared: false);
server.listen((RawSocket socket) async {
print('server started a socket $socket');
socket.listen((e) {
if (e == RawSocketEvent.read) {
throw "Server should not receive request from the client";
} else if (e == RawSocketEvent.readClosed) {
socket.close();
server.close();
}
});
});
final file = File('$tempDirPath/myfile.txt');
final randomAccessFile = file.openSync(mode: FileMode.write);
// Send a message with sample file.
final socket = await RawSocket.connect(address, 0);
runZonedGuarded(
() => socket.listen((e) {
if (e == RawSocketEvent.write) {
randomAccessFile.writeStringSync('Hello, client!\n');
const int largeHandleCount = 1024;
final manyResourceHandles = List<ResourceHandle>.filled(
largeHandleCount, ResourceHandle.fromFile(randomAccessFile));
socket.sendMessage(<SocketControlMessage>[
SocketControlMessage.fromHandles(manyResourceHandles)
], 'Hello'.codeUnits);
server.close();
socket.close();
}
}), (e, st) {
// print('Got expected unhandled exception $e $st');
Expect.equals(true, e is SocketException);
completer.complete(true);
});
return completer.future;
}
Future testFileMessageWithShortRead(String tempDirPath) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final completer = Completer<bool>();
final address =
InternetAddress('$tempDirPath/sock', type: InternetAddressType.unix);
final server = await RawServerSocket.bind(address, 0, shared: false);
server.listen((RawSocket socket) async {
print('server started a socket $socket');
socket.listen((e) {
if (e == RawSocketEvent.read) {
Expect.throws(
() => socket.readMessage(0),
(e) =>
e is ArgumentError &&
e.toString().contains('Illegal length 0'));
final SocketMessage message = socket.readMessage(/*count=*/ 1);
if (message == null) {
return;
}
print('server received message $message');
final String messageData = String.fromCharCodes(message.data);
print('messageData: $messageData');
if (messageData[0] == 'H') {
Expect.equals(1, message.controlMessages.length);
final SocketControlMessage controlMessage =
message.controlMessages[0];
final handles = controlMessage.extractHandles();
Expect.isNotNull(handles);
Expect.equals(1, handles.length);
final handlesAgain = controlMessage.extractHandles();
Expect.isNotNull(handlesAgain);
Expect.equals(1, handlesAgain.length);
handles[0].toFile().writeStringSync('Hello, server!\n');
socket.write('abc'.codeUnits);
} else {
Expect.equals('i', messageData[0]);
Expect.equals(0, message.controlMessages.length);
}
} else if (e == RawSocketEvent.readClosed) {
print('server socket got readClosed');
socket.close();
server.close();
}
});
});
final file = File('$tempDirPath/myfile.txt');
final randomAccessFile = file.openSync(mode: FileMode.write);
// Send a message with sample file.
final socket = await RawSocket.connect(address, 0);
socket.listen((e) {
if (e == RawSocketEvent.write) {
randomAccessFile.writeStringSync('Hello, client!\n');
socket.sendMessage(<SocketControlMessage>[
SocketControlMessage.fromHandles(
<ResourceHandle>[ResourceHandle.fromFile(randomAccessFile)])
], 'Hi'.codeUnits);
print('client sent a message');
} else if (e == RawSocketEvent.read) {
final data = socket.read();
Expect.equals('abc', String.fromCharCodes(data));
Expect.equals(
'Hello, client!\nHello, server!\n', file.readAsStringSync());
socket.close();
completer.complete(true);
}
});
return completer.future;
}
Future<RawServerSocket> createTestServer() async {
final server = await RawServerSocket.bind(InternetAddress.loopbackIPv4, 0);
return server
..listen((client) {
String receivedData = "";
client.writeEventsEnabled = false;
client.listen((event) {
switch (event) {
case RawSocketEvent.read:
assert(client.available() > 0);
final buffer = client.read(200);
receivedData += String.fromCharCodes(buffer);
break;
case RawSocketEvent.readClosed:
client.close();
server.close();
break;
case RawSocketEvent.closed:
Expect.equals(
"Hello, client 1!\nHello, client 2!\nHello, server!\n",
receivedData);
break;
default:
throw "Unexpected event $event";
}
}, onError: (e) {
print("client ERROR $e");
});
});
}
Future testSocketMessage(String uniqueName) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final address =
InternetAddress('$uniqueName/sock', type: InternetAddressType.unix);
final server = await RawServerSocket.bind(address, 0, shared: false);
server.listen((RawSocket socket) async {
socket.listen((e) {
switch (e) {
case RawSocketEvent.read:
final SocketMessage message = socket.readMessage();
if (message == null) {
return;
}
Expect.equals('Hello', String.fromCharCodes(message.data));
Expect.equals(1, message.controlMessages.length);
final SocketControlMessage controlMessage =
message.controlMessages[0];
final handles = controlMessage.extractHandles();
Expect.isNotNull(handles);
Expect.equals(1, handles.length);
final receivedSocket = handles[0].toRawSocket();
receivedSocket.write('Hello, server!\n'.codeUnits);
socket.write('server replied'.codeUnits);
receivedSocket.close();
break;
case RawSocketEvent.readClosed:
socket.close();
server.close();
break;
}
});
});
final RawServerSocket testServer = await createTestServer();
final testSocket = await RawSocket.connect("127.0.0.1", testServer.port);
// Send a message with opened [testSocket] socket.
final socket = await RawSocket.connect(address, 0);
socket.listen((e) {
switch (e) {
case RawSocketEvent.write:
testSocket.write('Hello, client 1!\n'.codeUnits);
socket.sendMessage(<SocketControlMessage>[
SocketControlMessage.fromHandles(
<ResourceHandle>[ResourceHandle.fromRawSocket(testSocket)])
], 'Hello'.codeUnits);
testSocket.write('Hello, client 2!\n'.codeUnits);
break;
case RawSocketEvent.read:
final data = socket.read();
if (data == null) {
return;
}
final dataString = String.fromCharCodes(data);
Expect.equals('server replied', dataString);
socket.close();
testSocket.close();
testServer.close();
}
});
}
Future testStdioMessage(String tempDirPath, {bool caller: false}) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final completer = Completer<bool>();
if (caller) {
final process = await Process.start(Platform.resolvedExecutable,
<String>[Platform.script.toFilePath(), '--start-stdio-message-test']);
String processStdout = "";
String processStderr = "";
process.stdout.transform(utf8.decoder).listen((line) {
processStdout += line;
print('stdout:>$line<');
});
process.stderr.transform(utf8.decoder).listen((line) {
processStderr += line;
print('stderr:>$line<');
});
process.stdin.writeln('Caller wrote to stdin');
Expect.equals(0, await process.exitCode);
Expect.equals("client sent a message\nHello, server!\n", processStdout);
Expect.equals(
"client wrote to stderr\nHello, server too!\n", processStderr);
return;
}
final address =
InternetAddress('$tempDirPath/sock', type: InternetAddressType.unix);
final server = await RawServerSocket.bind(address, 0, shared: false);
server.listen((RawSocket socket) async {
socket.listen((e) {
if (e == RawSocketEvent.read) {
final SocketMessage message = socket.readMessage();
if (message == null) {
return;
}
Expect.equals('Hello', String.fromCharCodes(message.data));
Expect.equals(message.controlMessages.length, 1);
final SocketControlMessage controlMessage = message.controlMessages[0];
final handles = controlMessage.extractHandles();
Expect.isNotNull(handles);
Expect.equals(3, handles.length);
final receivedStdin = handles[0].toFile();
final receivedString = String.fromCharCodes(receivedStdin.readSync(32));
Expect.equals('Caller wrote to stdin\n', receivedString);
final receivedStdout = handles[1].toFile();
receivedStdout.writeStringSync('Hello, server!\n');
final receivedStderr = handles[2].toFile();
receivedStderr.writeStringSync('Hello, server too!\n');
socket.write('abc'.codeUnits);
} else if (e == RawSocketEvent.readClosed) {
socket.close();
server.close();
}
});
});
final file = File('$tempDirPath/myfile.txt');
final randomAccessFile = file.openSync(mode: FileMode.write);
// Send a message with sample file.
var socket = await RawSocket.connect(address, 0);
socket.listen((e) {
if (e == RawSocketEvent.write) {
socket.sendMessage(<SocketControlMessage>[
SocketControlMessage.fromHandles(<ResourceHandle>[
ResourceHandle.fromStdin(stdin),
ResourceHandle.fromStdout(stdout),
ResourceHandle.fromStdout(stderr)
])
], 'Hello'.codeUnits);
stdout.writeln('client sent a message');
stderr.writeln('client wrote to stderr');
} else if (e == RawSocketEvent.read) {
final data = socket.read();
if (data == null) {
return;
}
Expect.equals('abc', String.fromCharCodes(data));
socket.close();
completer.complete(true);
}
});
return completer.future;
}
Future testDeleteFile(String tempDirPath) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final address =
InternetAddress('$tempDirPath/sock', type: InternetAddressType.unix);
var server = await RawServerSocket.bind(address, 0, shared: false);
final file = File('$tempDirPath/sock');
Expect.isTrue(file.existsSync());
Expect.isTrue(await file.exists());
file.deleteSync();
Expect.isFalse(file.existsSync());
Expect.isFalse(await file.exists());
await server.close();
server = await RawServerSocket.bind(address, 0, shared: false);
Expect.isTrue(file.existsSync());
Expect.isTrue(await file.exists());
await file.delete();
Expect.isFalse(file.existsSync());
Expect.isFalse(await file.exists());
await server.close();
}
Future testFileStat(String tempDirPath) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final name = '$tempDirPath/sock';
final address = InternetAddress(name, type: InternetAddressType.unix);
var server = await RawServerSocket.bind(address, 0, shared: false);
FileStat fileStat = FileStat.statSync(name);
Expect.equals(FileSystemEntityType.unixDomainSock, fileStat.type);
server.close();
}
Future testFileRename(String tempDirPath) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final name1 = '$tempDirPath/sock1';
final name2 = '$tempDirPath/sock2';
final address = InternetAddress(name1, type: InternetAddressType.unix);
var server = await RawServerSocket.bind(address, 0, shared: false);
final file1 = File(name1);
final file2 = file1.renameSync(name2);
Expect.isFalse(file1.existsSync());
Expect.isTrue(file2.existsSync());
await server.close();
file2.deleteSync();
Expect.isFalse(file1.existsSync());
Expect.isFalse(file2.existsSync());
}
Future testFileCopy(String tempDirPath) async {
if (!Platform.isLinux && !Platform.isAndroid) {
return;
}
final name1 = '$tempDirPath/sock1';
final name2 = '$tempDirPath/sock2';
final address = InternetAddress(name1, type: InternetAddressType.unix);
final file1 = File(name1);
var server = await RawServerSocket.bind(address, 0, shared: false);
try {
final file2 = file1.copySync(name2);
Expect.isFalse(true);
} catch (e) {
Expect.isTrue(e is FileSystemException);
}
await server.close();
Expect.isFalse(file1.existsSync());
}
void main(List<String> args) async {
runZonedGuarded(() async {
if (args.length > 0 && args[0] == '--start-stdio-message-test') {
await withTempDir('unix_socket_test', (Directory dir) async {
await testStdioMessage('${dir.path}', caller: false);
});
return;
}
await withTempDir('unix_socket_test', (Directory dir) async {
await testAddress('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testBind('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testBindShared('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testListenCloseListenClose('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testSourceAddressConnect('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testAbstractAddress(dir.uri.pathSegments.last);
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testExistingFile('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testSetSockOpt('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testHttpServer('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testShortAbstractAddress(dir.uri.pathSegments.last);
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testFileMessage('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testFileMessageWithShortRead('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testTooLargeControlMessage('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testSocketMessage('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testStdioMessage('${dir.path}', caller: true);
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testDeleteFile('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testFileStat('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testFileRename('${dir.path}');
});
await withTempDir('unix_socket_test', (Directory dir) async {
await testFileCopy('${dir.path}');
});
}, (e, st) {
if (Platform.isMacOS || Platform.isLinux || Platform.isAndroid) {
Expect.fail("Unexpected exception $e is thrown");
} else {
Expect.isTrue(e is SocketException);
Expect.isTrue(e.toString().contains('not available'));
}
});
}