public void Direct_Task_With_NotificationMask_Is_Error()
{
//Arrange
var functions = new Mock <Functions>();
var target = new AsyncManager(functions.Object);
var namespaceCtx = new IntPtr(37);
var parms = new PRJ_NOTIFICATION_PARAMETERS();
//Act
var hr = target.ProcessCommandPossibleAsyncWithNotificationMask(namespaceCtx, 1, (cts) => throw new Exception(), parms);
//Assert
Assert.Equal(HRESULT.E_INVALIDARG, hr);
}
private HRESULT ProcessNotification(
PRJ_CALLBACK_DATA callbackData,
bool isDirectory,
PRJ_NOTIFICATION notification,
String destinationFileName,
ref PRJ_NOTIFICATION_PARAMETERS operationParameters
)
{
switch (notification)
{
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_FILE_OPENED:
return(_asyncOperations.ProcessCommandPossibleAsyncWithNotificationMask(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileOpened(callbackData.FilePathName, isDirectory, cts.Token), operationParameters));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_NEW_FILE_CREATED:
return(_asyncOperations.ProcessCommandPossibleAsyncWithNotificationMask(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileCreated(callbackData.FilePathName, isDirectory, cts.Token), operationParameters));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_FILE_OVERWRITTEN:
return(_asyncOperations.ProcessCommandPossibleAsyncWithNotificationMask(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileOverwritten(callbackData.FilePathName, isDirectory, cts.Token), operationParameters));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_PRE_DELETE:
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.PreDelete(callbackData.FilePathName, isDirectory, cts.Token), b => b ? HRESULT.S_OK : HRESULT.E_INVALIDARG));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_PRE_RENAME:
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.PreRename(callbackData.FilePathName, destinationFileName, isDirectory, cts.Token), b => b ? HRESULT.S_OK : HRESULT.E_INVALIDARG));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_PRE_SET_HARDLINK:
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.PreHardlink(callbackData.FilePathName, destinationFileName, isDirectory, cts.Token), b => b ? HRESULT.S_OK : HRESULT.E_INVALIDARG));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_FILE_RENAMED:
return(_asyncOperations.ProcessCommandPossibleAsyncWithNotificationMask(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileRenamed(callbackData.FilePathName, destinationFileName, isDirectory, cts.Token), operationParameters));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_HARDLINK_CREATED:
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileHardlinked(callbackData.FilePathName, destinationFileName, isDirectory, cts.Token)));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_FILE_HANDLE_CLOSED_NO_MODIFICATION:
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileClosed(callbackData.FilePathName, isDirectory, CloseState.Unmodified, cts.Token)));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_FILE_HANDLE_CLOSED_FILE_MODIFIED:
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileClosed(callbackData.FilePathName, isDirectory, CloseState.Modified, cts.Token)));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_FILE_HANDLE_CLOSED_FILE_DELETED:
CloseState state = operationParameters.IsFileModified ? CloseState.Modified | CloseState.Deleted : CloseState.Deleted;
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.FileClosed(callbackData.FilePathName, isDirectory, state, cts.Token)));
case PRJ_NOTIFICATION.PRJ_NOTIFICATION_FILE_PRE_CONVERT_TO_FULL:
return(_asyncOperations.ProcessCommandPossibleAsync(callbackData.NamespaceVirtualizationContext, callbackData.CommandId, cts => Notifiable.PreConvertToFull(callbackData.FilePathName, isDirectory, cts.Token)));
}
return(HRESULT.E_INVALIDARG);
}
public void Task_With_NotificationMask_Is_S_OK()
{
//Arrange
var functions = new Mock <Functions>();
var target = new AsyncManager(functions.Object);
var namespaceCtx = new IntPtr(37);
var parms = new PRJ_NOTIFICATION_PARAMETERS();
//Act
var hr = target.ProcessCommandPossibleAsyncWithNotificationMask(namespaceCtx, 1, (cts) => Task.FromResult(NotificationRequired.FileCreated), parms);
//Assert
Assert.Equal(HRESULT.S_OK, hr);
Assert.Equal(PRJ_NOTIFY_TYPES.PRJ_NOTIFY_NEW_FILE_CREATED, parms.NotificationMask);
}
public async Task Indirect_Task_With_NotificationMask_Is_Error()
{
//Arrange
var functions = new Mock <Functions>();
var namespaceCtx = new IntPtr(37);
functions.Setup(f => f.PrjCompleteCommand(namespaceCtx, 1, HRESULT.E_INVALIDARG, IntPtr.Zero));
var tcs = new TaskCompletionSource <NotificationRequired>();
var target = new AsyncManager(functions.Object);
var parms = new PRJ_NOTIFICATION_PARAMETERS();
//Act
var hr = target.ProcessCommandPossibleAsyncWithNotificationMask(namespaceCtx, 1, (cts) => tcs.Task, parms);
tcs.SetException(new Exception());
await Task.Delay(50);
//Assert
Assert.Equal(HRESULT.ERROR_IO_PENDING, hr);
functions.VerifyAll();
}
public HRESULT ProcessCommandPossibleAsyncWithNotificationMask(
IntPtr namespaceVirtualizationContext,
int commandId,
Func <CancellationTokenSource, Task <NotificationRequired> > kickOff,
PRJ_NOTIFICATION_PARAMETERS parameters
)
{
try
{
var cts = new CancellationTokenSource();
if (!_inFlight.TryAdd(commandId, cts))
{
return(HRESULT.E_INVALIDARG);
}
var inter = kickOff(cts);
if (inter.IsCompletedSuccessfully)
{
_inFlight.TryRemove(commandId, out _);
parameters.NotificationMask = (PRJ_NOTIFY_TYPES)(int)inter.Result;
return(HRESULT.S_OK);
}
if (inter.IsFaulted)
{
return(HRESULT.E_INVALIDARG);
}
inter.ContinueWith(inter2 =>
{
AsyncProvideHRESULTWithNotificationMask(namespaceVirtualizationContext, commandId, HRESULT.S_OK, (PRJ_NOTIFY_TYPES)(int)inter2.Result);
}, TaskContinuationOptions.OnlyOnRanToCompletion);
inter.ContinueWith(inter3 =>
{
AsyncProvideHRESULT(namespaceVirtualizationContext, commandId, HRESULT.E_INVALIDARG);
}, TaskContinuationOptions.OnlyOnFaulted);
return(HRESULT.ERROR_IO_PENDING);
}
catch (Exception)
{
return(HRESULT.E_INVALIDARG);
}
}
public async Task Task_With_NotificationMask_Is_S_OK()
{
//Arrange
var functions = new Mock <Functions>();
var namespaceCtx = new IntPtr(37);
functions.Setup(f => f.PrjCompleteCommand(namespaceCtx, 1, HRESULT.S_OK, It.IsAny <IntPtr>()));
var tcs = new TaskCompletionSource <NotificationRequired>();
var target = new AsyncManager(functions.Object);
var parms = new PRJ_NOTIFICATION_PARAMETERS();
//Act
var hr = target.ProcessCommandPossibleAsyncWithNotificationMask(namespaceCtx, 1, (cts) => tcs.Task, parms);
tcs.SetResult(NotificationRequired.FileCreated);
await Task.Delay(50);
//Assert
Assert.Equal(HRESULT.ERROR_IO_PENDING, hr);
Assert.Equal(PRJ_NOTIFY_TYPES.PRJ_NOTIFY_NONE, parms.NotificationMask);
functions.VerifyAll();
}