public async Task TestTakeWhileAsync()
{
var idx = 0;
var array = await AsyncEnumerable.Neverending(1, asyncProvider : DefaultAsyncProvider.Instance).TakeWhile(async item => { await Task.Delay(100); return(++idx <= 3); }).ToArrayAsync();
Assert.IsTrue(ArrayEqualityComparer <Int32> .ArrayEquality(array, Enumerable.Repeat(1, 3).ToArray()));
}
public async Task TestSelectMany4()
{
var array = await AsyncEnumerable.Range(0, 1, DefaultAsyncProvider.Instance).SelectMany(async x =>
{
await Task.Delay(100);
return(AsyncEnumerable.Range(x, x + 2, DefaultAsyncProvider.Instance));
}).ToArrayAsync();
Assert.IsTrue(ArrayEqualityComparer <Int32> .ArrayEquality(array, new[] { 0, 1 }));
}
public void TestTaskItemSpecEcho()
{
PerformTestPackageTest(
"EchoTaskItemSpec",
(task, ignored) =>
{
var input = new TaskItem[] { new TaskItem(TEST_VALUE) };
task.GetType().GetRuntimeProperty("Value").SetMethod.Invoke(task, new Object[] { input });
Assert.IsTrue(task.Execute());
var outputProperty = task.GetType().GetRuntimeProperty("Result");
Assert.IsTrue(ArrayEqualityComparer <ITaskItem> .ArrayEquality(input, (ITaskItem[])outputProperty.GetMethod.Invoke(task, null), (t1, t2) => String.Equals(t1.ItemSpec, t2.ItemSpec)));
});
}
public void TestTaskItemWithMetaDataEcho()
{
PerformTestPackageTest(
"EchoTaskItemWithMetaData",
(task, ignored) =>
{
const String MD1 = "MD1";
const String MD2 = "MD2";
var input = new TaskItem[] { new TaskItem(TEST_VALUE, new Dictionary <String, String>()
{
{ "MetaData1", MD1 }, { "MetaData2", MD2 }
}) };
task.GetType().GetRuntimeProperty("Value").SetMethod.Invoke(task, new Object[] { input });
Assert.IsTrue(task.Execute());
var outputProperty = task.GetType().GetRuntimeProperty("Result");
Assert.IsTrue(ArrayEqualityComparer <ITaskItem> .ArrayEquality(input, (ITaskItem[])outputProperty.GetMethod.Invoke(task, null), TaskItemEquality));
});
}
private void VerifyNativeVsFluentCryptography(
TNativeAlgorithmFactory nativeFactory,
TUtilPackAlgorithmFactory utilPackFactory,
Byte[] key,
Int32 minLength,
Int32 maxLength
)
{
var r = new Random();
var count = minLength + (Math.Abs(r.NextInt32()) % (maxLength - minLength));
var bytez = r.NextBytes(count);
Byte[] nativeHash;
using (var native = nativeFactory(key.CreateArrayCopy()))
{
nativeHash = native.ComputeHash(bytez);
}
Byte[] camHash;
using (var cam = utilPackFactory(key.CreateArrayCopy()))
{
camHash = cam.ComputeDigest(bytez, 0, bytez.Length);
Assert.IsTrue(
ArrayEqualityComparer <Byte> .ArrayEquality(nativeHash, camHash),
"The hash differed:\nNative hash: {0}\nUtilPack hash: {1}\ninput: {2}",
StringConversions.CreateHexString(nativeHash),
StringConversions.CreateHexString(camHash),
StringConversions.CreateHexString(bytez)
);
// Test that resetting works by computing same digest again
camHash = cam.ComputeDigest(bytez, 0, bytez.Length);
Assert.IsTrue(
ArrayEqualityComparer <Byte> .ArrayEquality(nativeHash, camHash),
"The hash differed:\nNative hash: {0}\nUtilPack hash: {1}\ninput: {2}",
StringConversions.CreateHexString(nativeHash),
StringConversions.CreateHexString(camHash),
StringConversions.CreateHexString(bytez)
);
}
}
public void TestMultipleSmallWrites()
{
var b1 = new Byte[] { 1, 2, 3 };
var b2 = new Byte[] { 4, 5, 6 };
Byte[] nativeHash;
using (var native = System.Security.Cryptography.SHA512.Create())
{
nativeHash = native.ComputeHash(b1.Concat(b2).ToArray());
}
var utilPackHash = new Byte[SHA512.DIGEST_BYTE_COUNT];
using (var utilPack = new SHA512())
{
utilPack.ProcessBlock(b1.ToArray());
utilPack.ProcessBlock(b2.ToArray());
utilPack.WriteDigest(utilPackHash);
}
Assert.IsTrue(ArrayEqualityComparer <Byte> .ArrayEquality(nativeHash, utilPackHash));
}
private static Boolean IsAssignableFromIgnoreAssemblyVersion(this TTypeInfo parentType, TTypeInfo childType)
{
return(parentType.IsAssignableFrom(childType) || childType.AsDepthFirstEnumerable(t => t.BaseType?.GetTypeInfo().Singleton().Concat(t.
#if NET40
GetInterfaces()
#else
ImplementedInterfaces
#endif
.Select(i => i.GetTypeInfo())
)).Any(t =>
String.Equals(t.Namespace, parentType.Namespace) &&
String.Equals(t.Name, parentType.Name) &&
String.Equals(t.Assembly.GetName().Name, parentType.Assembly.GetName().Name) &&
ArrayEqualityComparer <Byte> .ArrayEquality(parentType.Assembly.GetName().GetPublicKeyToken(), t.Assembly.GetName().GetPublicKeyToken())
));
}
public async Task TestSelectMany1()
{
var array = await AsyncEnumerable.Range(0, 1, DefaultAsyncProvider.Instance).SelectMany(x => new[] { x, x + 1 }).ToArrayAsync();
Assert.IsTrue(ArrayEqualityComparer <Int32> .ArrayEquality(array, new[] { 0, 1 }));
}
public async Task TestTakeNeverEnding()
{
var array = await AsyncEnumerable.Neverending(1, asyncProvider : DefaultAsyncProvider.Instance).Take(3).ToArrayAsync();
Assert.IsTrue(ArrayEqualityComparer <Int32> .ArrayEquality(array, Enumerable.Repeat(1, 3).ToArray()));
}
protected override async Task <TStatementExecutionSimpleTaskParameter> ExecuteStatementAsBatch(StatementBuilder statement, ReservedForStatement reservedState)
{
// TODO somehow make statement name and chunk size parametrizable
(var parameterIndices, var typeInfos, var typeIDs) = GetVariablesForExtendedQuerySequence(statement, this.TypeRegistry, (stmt, idx) => stmt.GetBatchParameterInfo(0, idx));
var ioArgs = this.GetIOArgs();
var stmtName = ((PgReservedForStatement)reservedState).StatementName;
var chunkSize = 1000;
// Send a parse message with statement name
await new ParseMessage(statement.SQL, parameterIndices, typeIDs, stmtName).SendMessageAsync(ioArgs, true);
// Now send describe message
await new DescribeMessage(true, stmtName).SendMessageAsync(ioArgs, true);
// And then Flush message for backend to send responses
await FrontEndMessageWithNoContent.FLUSH.SendMessageAsync(ioArgs, false);
// Receive first batch of messages
BackendMessageObject msg = null;
SQLStatementExecutionResult current = null;
List <PgSQLError> notices = new List <PgSQLError>();
var sendBatch = true;
while (msg == null)
{
msg = (await this.ReadMessagesUntilMeaningful(notices)).Item1;
switch (msg)
{
case MessageWithNoContents nc:
switch (nc.Code)
{
case BackendMessageCode.ParseComplete:
// Continue reading messages
msg = null;
break;
case BackendMessageCode.EmptyQueryResponse:
// The statement does not produce any data, we are done
sendBatch = false;
break;
case BackendMessageCode.NoData:
// Do nothing, thus causing batch messages to be sent
break;
default:
throw new PgSQLException("Unrecognized response at this point: " + msg.Code);
}
break;
case RowDescription rd:
throw new PgSQLException("Batch statements may only be used for non-query statements.");
case ParameterDescription pd:
if (!ArrayEqualityComparer <Int32> .ArrayEquality(pd.ObjectIDs, typeIDs))
{
throw new PgSQLException("Backend required certain amount of parameters, but either they were not supplied, or were of wrong type.");
}
// Continue to RowDescription/NoData message
msg = null;
break;
default:
throw new PgSQLException("Unrecognized response at this point: " + msg.Code);
}
}
if (sendBatch)
{
var batchCount = statement.BatchParameterCount;
var affectedRowsArray = new Int32[batchCount];
// Send and receive messages asynchronously
var commandTag = new String[1];
await Task.WhenAll(
this.SendMessagesForBatch( statement, typeInfos, stmtName, ioArgs, chunkSize, batchCount ),
this.ReceiveMessagesForBatch( notices, affectedRowsArray, commandTag )
);
current = new BatchCommandExecutionResultImpl(
commandTag[0],
new Lazy <SQLException[]>(() => notices?.Select(n => new PgSQLException(n))?.ToArray()),
affectedRowsArray
);
}
return(current, null);
}