public async Task LazyImmediate()
{
{
var l = UniTask.Lazy(() => UniTask.FromResult(1).AsUniTask());
var a = AwaitAwait(l.Task);
var b = AwaitAwait(l.Task);
var c = AwaitAwait(l.Task);
await a;
await b;
await c;
}
{
var l = UniTask.Lazy(() => UniTask.FromException(new TaskTestException()));
var a = AwaitAwait(l.Task);
var b = AwaitAwait(l.Task);
var c = AwaitAwait(l.Task);
await Assert.ThrowsAsync <TaskTestException>(async() => await a);
await Assert.ThrowsAsync <TaskTestException>(async() => await b);
await Assert.ThrowsAsync <TaskTestException>(async() => await c);
}
}
public async Task LazyImmediate()
{
{
var l = UniTask.Lazy(() => UniTask.FromResult(1));
var a = AwaitAwait(l.Task);
var b = AwaitAwait(l.Task);
var c = AwaitAwait(l.Task);
var a2 = await a;
var b2 = await b;
var c2 = await c;
(a2, b2, c2).Should().Be((1, 1, 1));
}
{
var l = UniTask.Lazy(() => UniTask.FromException <int>(new TaskTestException()));
var a = AwaitAwait(l.Task);
var b = AwaitAwait(l.Task);
var c = AwaitAwait(l.Task);
await Assert.ThrowsAsync <TaskTestException>(async() => await a);
await Assert.ThrowsAsync <TaskTestException>(async() => await b);
await Assert.ThrowsAsync <TaskTestException>(async() => await c);
}
}
/// <summary>
/// Start listening for incoming connection attempts.
/// </summary>
/// <returns>Returns completed if started up correctly.</returns>
public override UniTask ListenAsync()
{
try
{
if (!_enetInitialized)
{
if (InitializeEnet())
{
Debug.Log("Ignorance successfully initialized ENET.");
_enetInitialized = true;
}
else
{
Debug.LogError("Ignorance failed to initialize ENET! Cannot continue.");
return(UniTask.CompletedTask);
}
}
_server = new IgnoranceServer(Config, this);
// start server up and listen for connections
_server.Start();
_listenCompletionSource = AutoResetUniTaskCompletionSource.Create();
return(_listenCompletionSource.Task);
}
catch (Exception ex)
{
return(UniTask.FromException(ex));
}
}
public UniTask Show(IUnit unit)
{
var unitCoords = _gridUnitManager.GetUnitCoords(unit);
if (unitCoords == null)
{
var msg = $"Unit not in tile: {unit}";
_logger.LogError(LoggedFeature.Units, msg);
return(UniTask.FromException(new Exception(msg)));
}
// Acquire input lock.
_lockToken = _inputLock.Lock();
// Set selected unit and events
_unit = unit;
_moveUnitButton.onClick.AddListener(HandleMoveUnitButtonPressed);
_removeUnitButton.onClick.AddListener(HandleRemoveUnitButtonPressed);
_rotateUnitButton.onClick.AddListener(HandleRotateUnitPressed);
_cancelButton.onClick.AddListener(HandleCancelButtonPressed);
// Show radial menu
var worldPosition = _gridPositionCalculator.GetTileCenterWorldPosition(unitCoords.Value);
_menuScreenPositon = _camera.WorldToScreenPoint(worldPosition);
return(_radialMenu.Show(_menuScreenPositon));
}
private UniTask <string> ReadFileAsync(string path)
{
// 与えられたパスが不正な場合はArgumentExceptionを返す
if (string.IsNullOrEmpty(path))
{
return(UniTask.FromException <string>(new ArgumentException("Path is invalid.")));
}
return(UniTask.Run(() => System.IO.File.ReadAllText(path)));
}
public IEnumerator Connect() => UniTask.ToCoroutine(async() =>
{
transport1.Scheme.Returns(new[] { "yomama" });
transport2.Scheme.Returns(new[] { "kcp" });
transport1.ConnectAsync(Arg.Any <Uri>())
.Returns(UniTask.FromException <IConnection>(new ArgumentException("Invalid protocol")));
// transport2 gives a connection
transport2.ConnectAsync(Arg.Any <Uri>())
.Returns(UniTask.FromResult(conn2));
IConnection accepted1 = await transport.ConnectAsync(new Uri("kcp://localhost"));
Assert.That(accepted1, Is.SameAs(conn2));
});
/// <summary>
/// 发送网络请求
/// </summary>
/// <param name="messageType"></param>
/// <param name="msg"></param>
public async UniTask <T> RpcCall <T>(int opcode, IMessage msg) where T : IMessage, new()
{
HFSocket socket = null;
byte[] bytes = await socket.Call(opcode, msg.ToByteArray());
if (!IsDisposed)
{
T t = new T();
t.MergeFrom(bytes);
return(t);
}
else
{
return(await UniTask.FromException <T>(new Exception("Entity已经被dispose")));
}
}
public IEnumerator CannotConnect() => UniTask.ToCoroutine(async() =>
{
transport1.ConnectAsync(Arg.Any <Uri>())
.Returns(UniTask.FromException <IConnection>(new ArgumentException("Invalid protocol")));
// transport2 gives a connection
transport2.ConnectAsync(Arg.Any <Uri>())
.Returns(UniTask.FromException <IConnection>(new ArgumentException("Invalid protocol")));
try
{
_ = await transport.ConnectAsync(new Uri("kcp://localhost"));
Assert.Fail("Should not be able to connect if none of the transports can connect");
}
catch (ArgumentException)
{
// ok
}
});
/// <summary>
/// Open up the port and listen for connections
/// Use in servers.
/// </summary>
/// <exception>If we cannot start the transport</exception>
/// <returns></returns>
public override UniTask ListenAsync()
{
try
{
socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Dgram, ProtocolType.Udp)
{
DualMode = true
};
socket.Bind(new IPEndPoint(IPAddress.IPv6Any, Port));
// transport started
Started?.Invoke();
ListenCompletionSource = new UniTaskCompletionSource();
return(ListenCompletionSource.Task);
}
catch (Exception ex)
{
return(UniTask.FromException(ex));
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public UniTask <Maze> ConstructAsync()
{
return(!_isInit
? UniTask.FromException <Maze>(new MazeException("Director has not been initialize yet."))
: new UniTask <Maze>(ConstructInternal));
}
public UniTask <bool> MoveNextAsync()
{
cancellationToken.ThrowIfCancellationRequested();
return(UniTask.FromException <bool>(exception));
}
