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); }