private Expression AggregateAndReduce(Expression expr)
{
var aggregator = new Aggregator();
aggregator.Visit(expr);
if (aggregator.Source is DomainExpression)
{
return ProjectionFromAggregation(aggregator);
}
else
{
var source = Visit(aggregator.Source);
var projector = aggregator.Projector;
if (projector != null)
{
return Expression.Call(
typeof(Enumerable).GetMethod("Select", new []{ typeof(IEnumerable<>), typeof(Func<,>) }).MakeGenericMethod(source.Type, projector.Type),
source,
projector);
}
else
{
return source;
}
}
}
public static IList<NArray> Evaluate(Func<NArray> function, IList<NArray> independentVariables, StringBuilder expressionsOut = null,
Aggregator aggregator = Aggregator.ElementwiseAdd, IList<NArray> existingStorage = null, VectorExecutionOptions vectorOptions = null)
{
if (existingStorage != null && existingStorage.Count != independentVariables.Count + 1)
throw new ArgumentException(string.Format("storage provided does not match requirement for 1 result and {0} derivatives",
independentVariables.Count));
var timer = new ExecutionTimer();
timer.Start();
NArray[] outputs = new NArray[independentVariables.Count + 1];
var context = new DeferredExecutionContext(new VectorExecutionOptions(), independentVariables);
NArray dependentVariable;
try
{
// execute function as deferred operations and obtain reference to the dependentVariable
dependentVariable = function();
}
finally
{
context.Finish();
}
timer.MarkFunctionComplete();
for (int i = 0; i < outputs.Length; ++i)
{
// if new storage is required, we create scalars in the first instance
outputs[i] = (existingStorage == null) ? NArray.CreateScalar(0) : existingStorage[i];
}
context._executor.Evaluate(context._options, outputs, dependentVariable, independentVariables,
timer, expressionsOut, aggregator);
//Console.WriteLine(timer.Report());
return outputs;
}
public void produces_the_view_type()
{
var aggregator = new Aggregator<QuestParty>();
var projection = new AggregationProjection<QuestParty>(null, aggregator);
projection.Produces.ShouldBe(typeof(QuestParty));
}
public void consumes_delegates_to_internal_aggregation()
{
var aggregator = new Aggregator<QuestParty>();
var projection = new AggregationProjection<QuestParty>(null, aggregator);
projection.Consumes.ShouldHaveTheSameElementsAs(aggregator.EventTypes);
}
public SystemtapRunner(Log log)
: base()
{
parser = new SystemtapParser ();
aggregator = new Aggregator (log, parser);
modulename = String.Format("mortadelo{0}", UnixProcess.GetCurrentProcessId());
}
public void AddAllMultiplesOf3Or5ThatAreLessThan1000AddsUpTo233168()
{
var iterator = new Iterator(0, 1000, i => i % 3 == 0 || i % 5 == 0);
var aggregator = new Aggregator(iterator);
int result = aggregator.GetSum();
Assert.That(result, Is.EqualTo(233168)); // see Verification.xls for confirmation of this result.
}
public void AddingAllMultiplesOf3Or5ThatAreLessThan10AddsUpTo23()
{
var iterator = new Iterator(0, 10, i => i % 3 == 0 || i % 5 == 0);
var aggregator = new Aggregator(iterator);
int result = aggregator.GetSum();
Assert.That(result, Is.EqualTo(23));
}
public HashTree(Aggregator aggregator)
{
this.Tree = new Dictionary<int, Node>();
this.Height = 0;
this.LatestLeafNode = new Node();
this.LatestLeafNode.Index = 0;
this.Aggregator = aggregator;
}
public void AggregatorCanSumAllValuesReturnedFromIterator()
{
var iterator = MockRepository.GenerateStub<IIterator>();
iterator.Stub(it => it.GetValues()).Return(new[] { 3, 5, 6, 9 });
var aggregator = new Aggregator(iterator);
int result = aggregator.GetSum();
Assert.That(result, Is.EqualTo(23));
}
public AggregateHandler()
{
_agg = new Aggregator();
_agg.ProgressChanged += () =>
{
if (_agg.InProgress == 0)
{
NotificationHandler.Instance.AddNotification("Поиск сообщений завершен.");
}
};
}
public void MoqStubsTest()
{
// Arrange
var depend = Mock.Of<IDepend>();
var another = Mock.Of<IAnother>(t => t.Calabanga("WAKAWAKA") == 100500);
var aggr = new Aggregator(depend, another);
// Act
var result1 = aggr.Aggregate("WAKAWAKA");
var result2 = aggr.Aggregate("WAKAWAKA");
// Assert
Assert.AreEqual(result1, result2);
Assert.AreEqual(result1, 100500);
}
public void VariablesWithInitializersTest()
{
// Arrange
var service = Mock.Of<IService>(t => t.Details == new List<Detail>());
var aggregator = new Aggregator(Mock.Of<IDepend>(), Mock.Of<IAnother>())
{
Service = service,
Serial = 1
};
// Act
var details = aggregator.Aggregate();
// Assert
Assert.NotNull(details);
}
public void Setup()
{
connection = Substitute.For<IReliableConnection>();
model = Substitute.For<IModelWithConnection>();
connection.CreateModel().Returns(model);
publishModule = Substitute.For<IPublishModule>();
aggregator = new Aggregator();
sut = new QueueingPublishingProcess(Substitute.For<IIdGenerator>(),
Substitute.For<ISequenceGenerator>(),
Substitute.For<IExchangeResolver>(),
Substitute.For<IMessageSerializer>(),
Substitute.For<IMessageTypeResolver>(),
publishModule, aggregator);
sut.Start();
}
private Expression ProjectionFromAggregation(Aggregator aggregator)
{
var domain = aggregator.Source;
var where = aggregator.AggregatedWhere;
var order = aggregator.AggregatedOrderBy;
var select = aggregator.AggregatedSelect;
var projector = aggregator.Projector;
var limit = aggregator.Limit;
var useConsistency = aggregator.UseConsistency;
return SimpleDbExpression.Project(
SimpleDbExpression.Query(
select,
domain,
where,
order,
limit,
useConsistency),
projector);
}
public void Setup()
{
connection = Substitute.For<IReliableConnection>();
model = Substitute.For<IModelWithConnection>();
connection.CreateModel().Returns(model);
queueFactory = Substitute.For<IQueueFactory>();
aggregator = new Aggregator();
sut = new DefaultConsumingProcess(Substitute.For<IIdGenerator>(),
Substitute.For<IExchangeResolver>(),
Substitute.For<IMessageSerializer>(),
Substitute.For<IMessageTypeResolver>(),
Substitute.For<IConsumerContainer>(),
Substitute.For<IMessageFilter>(),
queueFactory,
Substitute.For<IConsumerInvoker>(),
new RogerOptions(), aggregator);
}
public void FirstAggTest()
{
CustomerFactory factory = new CustomerFactory(new ObjectContext(CreateDataStore()));
Customer customer = factory.FindFirst("Name = {0}", "Joe Blow");
IList<WME> factlist = customer.GenerateFactsForRootObject();
Assert.IsTrue(factlist.Count == 11, "Wrong count.");
Agenda agenda = new Agenda();
agenda.LoadRulesFromAssemblies = false;
Variable customer_var = new Variable("Customer");
Variable orders = new Variable("Orders");
Variable order = new Variable("Order");
Variable val = new Variable("?Value");
Aggregator ag = new Aggregator("Count of customer orders.");
ag.GroupBy = customer_var;
ag.AggregatorFunction = new Count("$Customer.Orders.Order", "$Customer.Orders.Count");
ag.AddConditionToLHS(new AND(customer_var, "$Customer.Orders", orders));
ag.AddConditionToLHS(new AND(orders, "$Customer.Orders.Order", order));
agenda.AddAggregator(ag);
Production mostSimple = new Production("If Big Spender");
mostSimple.AddConditionToLHS(new AND(customer_var, "$Customer.Orders.Count", val));
mostSimple.AddConditionToRHS(new INVOKE("shout", customer_var, "Shout", val));
agenda.AddProduction(mostSimple);
agenda.AddFacts(factlist);
agenda.Run();
agenda.VisualizeNetworkToFile(@"C:\Temp\FirstAggTest.log", false);
Assert.IsTrue(agenda.TotalFacts == 11, "Bad");
Assert.IsTrue(agenda.ActionsTaken.Count == 1, "Bad");
Assert.IsTrue(agenda.ActionsSkipped.Count == 0, "Bad");
Assert.IsTrue(agenda.ActivatedRuleCount == 1, "Bad");
Assert.IsTrue(customer.Result != null && customer.Result.StartsWith("Shout"), "Did not invoke method.");
}
public void SecondAggTest()
{
CustomerFactory factory = new CustomerFactory(new ObjectContext(CreateDataStore()));
ObjectList<Customer> customers = factory.FindAllObjects();
Agenda agenda = new Agenda();
agenda.LoadRulesFromAssemblies = false;
agenda.AddObjects(customers);
Variable customer_var = new Variable("Customer");
Variable orders = new Variable("Orders");
Variable order = new Variable("Order");
Variable count = new Variable("OrderCount");
Aggregator ag = new Aggregator("Count of customer orders.");
ag.GroupBy = customer_var;
ag.AggregatorFunction = new Count("$Customer.Orders.Order", "Customer.Orders.Count");
ag.AddConditionToLHS(new AND(customer_var, "$Customer.Orders", orders));
ag.AddConditionToLHS(new AND(orders, "$Customer.Orders.Order", order));
agenda.AddAggregator(ag);
Production mostSimple = new Production("If Big Spender");
mostSimple.AddConditionToLHS(new AND(customer_var, "Customer.Orders.Count", count));
mostSimple.AddConditionToRHS(new INVOKE("shout", customer_var, "Shout", count));
agenda.AddProduction(mostSimple);
agenda.Run();
agenda.VisualizeNetworkToFile(@"C:\Temp\SecondAggTest.log", false);
Assert.IsTrue(agenda.TotalFacts == 22, "Bad");
Assert.IsTrue(agenda.ActionsTaken.Count == 2, "Bad");
Assert.IsTrue(agenda.ActionsSkipped.Count == 0, "Bad");
Assert.IsTrue(agenda.ActivatedRuleCount == 1, "Bad");
foreach (Customer customer in customers)
{
Assert.IsTrue(customer.Result != null && customer.Result.StartsWith("Shout"), "Did not invoke method.");
}
}
public override Task OnNavigatingFromAsync(NavigatingEventArgs args)
{
Aggregator.Unsubscribe(this);
return(Task.CompletedTask);
}
/// <summary>
/// Here we execute the expression, but without attempting to compile it.
/// The performance gain comes only from reducing the amount of memory allocation required, not
/// from compiling an optimised kernel.
/// </summary>
/// <param name="block"></param>
/// <param name="provider"></param>
/// <param name="vectorOptions"></param>
public static void RunNonCompiling(BlockExpressionBuilder _builder,
LinearAlgebraProvider provider, VectorExecutionOptions vectorOptions,
NArray[] outputs, int[] outputsIndices, Aggregator aggregator, ExecutionTimer timer)
{
var block = _builder.ToBlock();
if (block.Operations.Count == 0)
{
return;
}
// we will cycle through arrays in order of increasing index
var getter = new OutputGetter <double>(outputs, outputsIndices);
int chunksLength = _builder.VectorLength; //5000;
var arrayPoolStack = ExecutionContext.ArrayPool.GetStack(chunksLength);
int length = (block.ArgumentParameters.First() as ReferencingVectorParameterExpression <double>)
.Array.Length;
int chunkCount = length / chunksLength;
if (length % chunksLength != 0)
{
chunkCount++;
}
List <NArray <double> >[] localsToFree; // the storage that can be freed up after each operation is complete
AssignNArrayStorage <double>(block, chunkCount, chunksLength, length, out localsToFree);
// for integer support, add here
var options = new ParallelOptions();
if (!vectorOptions.MultipleThreads)
{
options.MaxDegreeOfParallelism = 1;
}
timer.MarkExecutionTemporaryStorageAllocationComplete();
// can multi-thread here, but better to do so at higher level
//Parallel.For(0, chunkCount, options, (i) =>
for (int i = 0; i < chunkCount; ++i)
{
int startIndex = i * chunksLength;
int vectorLength = Math.Min(chunksLength, length - startIndex);
for (int j = 0; j < block.Operations.Count; ++j)
{
var operation = block.Operations[j];
if (operation.Type == typeof(NArray))
{
var newOperation = _builder.SimplifyOperation(operation); // deal with any expressions containing scalars that can be simplified
ExecuteSingleVectorOperation <double>(newOperation, provider,
arrayPoolStack, localsToFree[j],
getter, aggregator,
vectorLength,
i, startIndex, timer);
}
}
}
;
if (!arrayPoolStack.StackCountEqualsCreated)
{
throw new Exception("not all storage arrays created returned to stack");
}
}
void CreateFixture(Type fixtureGenericInterfaceType)
{
var fixtureType = fixtureGenericInterfaceType.GetGenericArguments().Single();
Aggregator.Run(() => collectionFixtureMappings[fixtureType] = Activator.CreateInstance(fixtureType));
}
/// <inheritdoc/>
protected override Task BeforeTestCaseFinishedAsync()
{
Aggregator.Aggregate(cleanupAggregator);
return(base.BeforeTestCaseFinishedAsync());
}
private protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries,
out Action <uint, ReadOnlyMemory <char>, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate)
{
var stratCol = new List <uint>();
var stratVal = new List <ReadOnlyMemory <char> >();
var isWeighted = new List <bool>();
var nmi = new List <Double>();
var avgMinScores = new List <Double>();
var dbi = new List <Double>();
bool hasStrats = Utils.Size(dictionaries) > 0;
bool hasWeight = aggregator.Weighted;
addAgg =
(stratColKey, stratColVal, agg) =>
{
Host.Check(agg.Weighted == hasWeight, "All aggregators must either be weighted or unweighted");
Host.Check(agg.UnweightedCounters.CalculateDbi == aggregator.UnweightedCounters.CalculateDbi,
"All aggregators must either compute DBI or not compute DBI");
stratCol.Add(stratColKey);
stratVal.Add(stratColVal);
isWeighted.Add(false);
nmi.Add(agg.UnweightedCounters.Nmi);
avgMinScores.Add(agg.UnweightedCounters.AvgMinScores);
if (agg.UnweightedCounters.CalculateDbi)
{
dbi.Add(agg.UnweightedCounters.Dbi);
}
if (agg.Weighted)
{
stratCol.Add(stratColKey);
stratVal.Add(stratColVal);
isWeighted.Add(true);
nmi.Add(agg.WeightedCounters.Nmi);
avgMinScores.Add(agg.WeightedCounters.AvgMinScores);
if (agg.WeightedCounters.CalculateDbi)
{
dbi.Add(agg.WeightedCounters.Dbi);
}
}
};
consolidate =
() =>
{
var overallDvBldr = new ArrayDataViewBuilder(Host);
if (hasStrats)
{
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), (ulong)dictionaries.Length, stratCol.ToArray());
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextDataViewType.Instance, stratVal.ToArray());
}
if (hasWeight)
{
overallDvBldr.AddColumn(MetricKinds.ColumnNames.IsWeighted, BooleanDataViewType.Instance, isWeighted.ToArray());
}
overallDvBldr.AddColumn(Nmi, NumberDataViewType.Double, nmi.ToArray());
overallDvBldr.AddColumn(AvgMinScore, NumberDataViewType.Double, avgMinScores.ToArray());
if (aggregator.UnweightedCounters.CalculateDbi)
{
overallDvBldr.AddColumn(Dbi, NumberDataViewType.Double, dbi.ToArray());
}
var result = new Dictionary <string, IDataView>
{
{ MetricKinds.OverallMetrics, overallDvBldr.GetDataView() }
};
return(result);
};
}
private RunSummary FailEntireClass(IEnumerable <ObservationTestCase> testCases, ExecutionTimer timer)
{
foreach (var testCase in testCases)
{
MessageBus.QueueMessage(new TestFailed(new ObservationTest(testCase, testCase.DisplayName), timer.Total,
"Exception was thrown in class constructor", Aggregator.ToException()));
}
int count = testCases.Count();
return(new RunSummary {
Failed = count, Total = count
});
}
public override void Subscribe()
{
Aggregator.Subscribe <UpdateGroupCall>(this, Handle)
.Subscribe <UpdateGroupCallParticipant>(Handle);
}
private protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries,
out Action <uint, ReadOnlyMemory <char>, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate)
{
var stratCol = new List <uint>();
var stratVal = new List <ReadOnlyMemory <char> >();
var isWeighted = new List <bool>();
var l1 = new List <Double>();
var l2 = new List <Double>();
var dist = new List <Double>();
var perLabelL1 = new List <Double[]>();
var perLabelL2 = new List <Double[]>();
var perLabelRms = new List <Double[]>();
var perLabelLoss = new List <Double[]>();
bool hasStrats = Utils.Size(dictionaries) > 0;
bool hasWeight = aggregator.Weighted;
addAgg =
(stratColKey, stratColVal, agg) =>
{
Host.Check(agg.Weighted == hasWeight, "All aggregators must either be weighted or unweighted");
stratCol.Add(stratColKey);
stratVal.Add(stratColVal);
isWeighted.Add(false);
l1.Add(agg.UnweightedCounters.L1);
l2.Add(agg.UnweightedCounters.L2);
dist.Add(agg.UnweightedCounters.Dist);
perLabelL1.Add(agg.UnweightedCounters.PerLabelL1);
perLabelL2.Add(agg.UnweightedCounters.PerLabelL2);
perLabelRms.Add(agg.UnweightedCounters.PerLabelRms);
perLabelLoss.Add(agg.UnweightedCounters.PerLabelLoss);
if (agg.Weighted)
{
stratCol.Add(stratColKey);
stratVal.Add(stratColVal);
isWeighted.Add(true);
l1.Add(agg.WeightedCounters.L1);
l2.Add(agg.WeightedCounters.L2);
dist.Add(agg.WeightedCounters.Dist);
perLabelL1.Add(agg.WeightedCounters.PerLabelL1);
perLabelL2.Add(agg.WeightedCounters.PerLabelL2);
perLabelRms.Add(agg.WeightedCounters.PerLabelRms);
perLabelLoss.Add(agg.WeightedCounters.PerLabelLoss);
}
};
consolidate =
() =>
{
var overallDvBldr = new ArrayDataViewBuilder(Host);
if (hasStrats)
{
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), (ulong)dictionaries.Length, stratCol.ToArray());
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, stratVal.ToArray());
}
if (hasWeight)
{
overallDvBldr.AddColumn(MetricKinds.ColumnNames.IsWeighted, BoolType.Instance, isWeighted.ToArray());
}
overallDvBldr.AddColumn(PerLabelL1, aggregator.GetSlotNames, NumberType.R8, perLabelL1.ToArray());
overallDvBldr.AddColumn(PerLabelL2, aggregator.GetSlotNames, NumberType.R8, perLabelL2.ToArray());
overallDvBldr.AddColumn(PerLabelRms, aggregator.GetSlotNames, NumberType.R8, perLabelRms.ToArray());
overallDvBldr.AddColumn(PerLabelLoss, aggregator.GetSlotNames, NumberType.R8, perLabelLoss.ToArray());
overallDvBldr.AddColumn(L1, NumberType.R8, l1.ToArray());
overallDvBldr.AddColumn(L2, NumberType.R8, l2.ToArray());
overallDvBldr.AddColumn(Dist, NumberType.R8, dist.ToArray());
var result = new Dictionary <string, IDataView>();
result.Add(MetricKinds.OverallMetrics, overallDvBldr.GetDataView());
return(result);
};
}
protected override async void SendExecute()
{
var user = SelectedItems.FirstOrDefault();
if (user == null)
{
return;
}
Task <MTProtoResponse <TLUpdatesBase> > task = null;
if (_item is TLChannel channel)
{
task = ProtoService.InviteToChannelAsync(channel.ToInputChannel(), new TLVector <TLInputUserBase> {
user.ToInputUser()
});
}
else if (_item is TLChat chat)
{
var count = 100;
var config = CacheService.GetConfig();
if (config != null)
{
count = config.ForwardedCountMax;
}
task = ProtoService.AddChatUserAsync(chat.Id, user.ToInputUser(), count);
}
if (task == null)
{
return;
}
var response = await task;
if (response.IsSucceeded)
{
NavigationService.GoBack();
if (response.Result is TLUpdates updates)
{
var newMessage = updates.Updates.FirstOrDefault(x => x is TLUpdateNewMessage) as TLUpdateNewMessage;
if (newMessage != null)
{
Aggregator.Publish(newMessage.Message);
}
var newChannelMessage = updates.Updates.FirstOrDefault(x => x is TLUpdateNewChannelMessage) as TLUpdateNewChannelMessage;
if (newChannelMessage != null)
{
Aggregator.Publish(newChannelMessage.Message);
}
}
}
else
{
if (response.Error.TypeEquals(TLErrorType.PEER_FLOOD))
{
var dialog = new TLMessageDialog();
dialog.Title = "Telegram";
dialog.Message = AppResources.PeerFloodAddContact;
dialog.PrimaryButtonText = "More info";
dialog.SecondaryButtonText = "OK";
var confirm = await dialog.ShowQueuedAsync();
if (confirm == ContentDialogResult.Primary)
{
MessageHelper.HandleTelegramUrl("t.me/SpamBot");
}
}
else if (response.Error.TypeEquals(TLErrorType.USERS_TOO_MUCH))
{
await TLMessageDialog.ShowAsync(AppResources.UsersTooMuch, "Telegram", "OK");
}
else if (response.Error.TypeEquals(TLErrorType.BOTS_TOO_MUCH))
{
await TLMessageDialog.ShowAsync(AppResources.BotsTooMuch, "Telegram", "OK");
}
else if (response.Error.TypeEquals(TLErrorType.USER_NOT_MUTUAL_CONTACT))
{
await TLMessageDialog.ShowAsync(AppResources.UserNotMutualContact, "Telegram", "OK");
}
Execute.ShowDebugMessage("channels.inviteToChannel error " + response.Error);
}
}
public async Task LoadContactsAsync()
{
//var contacts = CacheService.GetContacts();
//foreach (var item in contacts.OfType<TLUser>())
//{
// var user = item as TLUser;
// if (user.IsSelf)
// {
// continue;
// }
// //var status = LastSeenHelper.GetLastSeen(user);
// //var listItem = new UsersPanelListItem(user as TLUser);
// //listItem.fullName = user.FullName;
// //listItem.lastSeen = status.Item1;
// //listItem.lastSeenEpoch = status.Item2;
// //listItem.Photo = listItem._parent.Photo;
// //listItem.PlaceHolderColor = BindConvert.Current.Bubble(listItem._parent.Id);
// Items.Add(user);
//}
var contacts = new TLUser[0];
var input = string.Join(",", contacts.Select(x => x.Id).Union(new[] { SettingsHelper.UserId }).OrderBy(x => x));
var hash = Utils.ComputeMD5(input);
var hex = BitConverter.ToString(hash).Replace("-", string.Empty).ToLower();
var response = await ProtoService.GetContactsAsync(hex);
if (response.IsSucceeded)
{
var result = response.Result as TLContactsContacts;
if (result != null)
{
Execute.BeginOnUIThread(() =>
{
foreach (var item in result.Users.OfType <TLUser>())
{
var user = item as TLUser;
if (user.IsSelf)
{
continue;
}
//var status = LastSeenHelper.GetLastSeen(user);
//var listItem = new UsersPanelListItem(user as TLUser);
//listItem.fullName = user.FullName;
//listItem.lastSeen = status.Item1;
//listItem.lastSeenEpoch = status.Item2;
//listItem.Photo = listItem._parent.Photo;
//listItem.PlaceHolderColor = BindConvert.Current.Bubble(listItem._parent.Id);
Items.Add(user);
}
});
if (ApplicationSettings.Current.IsContactsSyncEnabled)
{
await _contactsService.SyncContactsAsync(response.Result);
}
}
}
Aggregator.Subscribe(this);
}
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
Aggregator.Subscribe(this);
return(Task.CompletedTask);
}
/// <summary>
/// Runs the tests in the test assembly.
/// </summary>
/// <returns>Returns summary information about the tests that were run.</returns>
public async Task <RunSummary> RunAsync()
{
var cancellationTokenSource = new CancellationTokenSource();
var totalSummary = new RunSummary();
#if NETFRAMEWORK
var currentDirectory = Directory.GetCurrentDirectory();
#endif
var testFrameworkEnvironment = GetTestFrameworkEnvironment();
var testFrameworkDisplayName = GetTestFrameworkDisplayName();
using (var messageBus = CreateMessageBus())
{
#if NETFRAMEWORK
Directory.SetCurrentDirectory(Path.GetDirectoryName(TestAssembly.Assembly.AssemblyPath));
#endif
if (messageBus.QueueMessage(new TestAssemblyStarting(TestCases.Cast <ITestCase>(), TestAssembly, DateTime.Now, testFrameworkEnvironment, testFrameworkDisplayName)))
{
try
{
await AfterTestAssemblyStartingAsync();
var masterStopwatch = Stopwatch.StartNew();
totalSummary = await RunTestCollectionsAsync(messageBus, cancellationTokenSource);
// Want clock time, not aggregated run time
totalSummary.Time = (decimal)masterStopwatch.Elapsed.TotalSeconds;
Aggregator.Clear();
await BeforeTestAssemblyFinishedAsync();
if (Aggregator.HasExceptions)
{
messageBus.QueueMessage(new TestAssemblyCleanupFailure(TestCases.Cast <ITestCase>(), TestAssembly, Aggregator.ToException()));
}
}
finally
{
messageBus.QueueMessage(new TestAssemblyFinished(TestCases.Cast <ITestCase>(), TestAssembly, totalSummary.Time, totalSummary.Total, totalSummary.Failed, totalSummary.Skipped));
#if NETFRAMEWORK
Directory.SetCurrentDirectory(currentDirectory);
#endif
}
}
}
return(totalSummary);
}
private async Task ExecuteTestMethod(MethodInfo runtimeMethod, RunSummary runSummary, IEnumerable <IApplicationAttribute> applicationAttributes, object[] dataRow)
{
foreach (var applicationAttribute in applicationAttributes)
{
Application application = null;
Window mainWindow = null;
WindowFixture fixture = null;
try
{
application = applicationAttribute.ProvideApplication(runtimeMethod);
application.WaitWhileBusy();
mainWindow = null;
if (!string.IsNullOrEmpty(applicationAttribute.Window))
{
mainWindow = application.GetWindow(applicationAttribute.Window);
}
else
{
mainWindow = application.GetWindows().FirstOrDefault();
}
if (mainWindow == null)
{
throw new Exception("Could not locate main window " + applicationAttribute.Window);
}
fixture = new WindowFixture(application, mainWindow);
ITypeInfo[] resolvedTypes = null;
var methodToRun = runtimeMethod;
if (methodToRun.IsGenericMethodDefinition)
{
resolvedTypes = TestCase.TestMethod.Method.ResolveGenericTypes(dataRow);
methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray());
}
List <object> parameterList = new List <object>();
var parameters = methodToRun.GetParameters().ToArray();
object initializerReturn = null;
int dataRowIndex = 0;
for (int i = 0; i < parameters.Length; i++)
{
var parameter = parameters[i];
var attributes = parameter.GetCustomAttributes(true);
if (parameter.ParameterType == typeof(Window))
{
parameterList.Add(mainWindow);
}
else if (parameter.ParameterType == typeof(IWindowFixture))
{
parameterList.Add(fixture);
}
else if (attributes.Any(a => a is GenerateAttribute))
{
var generateAttribute = (GenerateAttribute)attributes.First(a => a is GenerateAttribute);
InitializeCustomAttribute(generateAttribute, runtimeMethod, parameter);
var constraintName = generateAttribute.ConstraintName ?? parameter.Name;
var min = generateAttribute.Min;
var max = generateAttribute.Max;
var value = fixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max });
parameterList.Add(value);
}
else if (attributes.Any(a => a is LocateAttribute))
{
var locateAttribute = (LocateAttribute)attributes.First(a => a is LocateAttribute);
InitializeCustomAttribute(locateAttribute, runtimeMethod, parameter);
var value = locateAttribute.Value;
if (value == null)
{
value = fixture.Data.Generate(new SimpleFixture.DataRequest(null,
fixture.Data,
parameter.ParameterType,
parameter.Name,
false,
null,
null));
}
parameterList.Add(value);
}
else if (attributes.Any(a => a is FreezeAttribute))
{
var freeze = (FreezeAttribute)attributes.FirstOrDefault(a => a is FreezeAttribute);
InitializeCustomAttribute(freeze, runtimeMethod, parameter);
var value = freeze.Value;
if (value == null)
{
var constraintName = freeze.ConstraintName ?? parameter.Name;
var min = freeze.Min;
var max = freeze.Max;
value = fixture.Data.Generate(parameter.ParameterType, constraintName, new { min, max });
}
parameterList.Add(value);
object lastObject = parameterList.Last();
var closedFreezeMethod =
FreezeMethod.MakeGenericMethod(lastObject.GetType());
closedFreezeMethod.Invoke(null, new object[] { fixture.Data, value, freeze.For });
}
else if (initializerReturn != null && parameter.ParameterType == initializerReturn.GetType())
{
parameterList.Add(initializerReturn);
initializerReturn = null;
}
else if (dataRowIndex < dataRow.Length)
{
var dataValue = dataRow[dataRowIndex];
dataRowIndex++;
parameterList.Add(dataValue);
}
else
{
var value = fixture.Data.Generate(parameter.ParameterType, parameter.Name);
parameterList.Add(value);
}
}
var convertedDataRow = Reflector.ConvertArguments(parameterList.ToArray(), parameters.Select(p => p.ParameterType).ToArray());
var theoryDisplayName =
TestCase.TestMethod.Method.GetDisplayNameWithArguments(DisplayName + " " + applicationAttribute.Application,
dataRow,
resolvedTypes);
var test = new XunitTest(TestCase, theoryDisplayName);
var skipReason = SkipReason;
XunitTestRunner testRunner = CreateTestRunner(test, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, skipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource);
runSummary.Aggregate(await testRunner.RunAsync());
}
catch (Exception exp)
{
Aggregator.Add(exp);
}
finally
{
var timer = new ExecutionTimer();
timer.Aggregate(() => DisposeOfData(application, mainWindow, fixture, dataRow));
runSummary.Time += timer.Total;
}
}
}
internal LatestPriceProviderContext(IPublicPricingProvider provider, Aggregator aggregator)
{
Provider = provider;
Aggregator = aggregator;
}
/// <summary>
/// Called when [aggregator] is visited.
/// </summary>
/// <param name="aggregator">The aggregator.</param>
public virtual void OnAggregator(Aggregator aggregator)
{
}
public void AggregatorClassifier()
{
List <MainData> dataList = new List <MainData>();
using (StreamReader sr = File.OpenText("Copy of DCManualLog.txt"))
{
string line;
while ((line = sr.ReadLine()) != null)
{
string[] read = line.Split(',');
dataList.Add(new MainData()
{
Time = DateTime.Parse(read[0]),
Process = read[1],
Title = read[2],
Frequency = 1
}); // This can hit OOM if file is HUGE
}
}
Aggregator agg = new Aggregator();
for (int i = 0; i < dataList.Count; i++)
{
agg.Add(dataList[i].Process, dataList[i].Title);
}
var aggRes = agg.GetAggregationResult();
List <MainData> aggregatedDataList = new List <MainData>();
for (int i = 0; i < aggRes.GetLength(0); i++)
{
dataList[aggRes[i, 0]].Frequency = aggRes[i, 1];
aggregatedDataList.Add(dataList[aggRes[i, 0]]);
}
Classifier cs = new Classifier();
for (int i = 0; i < aggregatedDataList.Count; i++)
{
cs.Add(i, aggregatedDataList[i].Process + aggregatedDataList[i].Title, aggregatedDataList[i].Frequency);
}
var csResult = cs.GetClassificationResult();
List <MainData> finalDataList = new List <MainData>();
for (int i = 0; i < csResult.GetLength(0); i++)
{
aggregatedDataList[(int)csResult[i, 0]].Frequency = csResult[i, 1];
finalDataList.Add(aggregatedDataList[(int)csResult[i, 0]]);
}
using (StreamWriter sw = File.AppendText("ClassifiedAnalysis.txt"))
{
foreach (var item in finalDataList)
{
sw.WriteLine(string.Format("{0},{1},{2},{3}", item.Time, item.Process, item.Title, item.Frequency));
}
}
}
public KTableAggregateProcessor(string storeName, bool sendOldValues, Initializer <T> initializer, Aggregator <K, V, T> add, Aggregator <K, V, T> remove)
: base(storeName, sendOldValues, true)
{
this.initializer = initializer;
this.add = add;
this.remove = remove;
}
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
var chatId = (long)parameter;
Chat = ProtoService.GetChat(chatId);
var chat = _chat;
if (chat == null)
{
return(Task.CompletedTask);
}
Aggregator.Subscribe(this);
Delegate?.UpdateChat(chat);
if (chat.Type is ChatTypePrivate privata)
{
var item = ProtoService.GetUser(privata.UserId);
var cache = ProtoService.GetUserFull(privata.UserId);
Delegate?.UpdateUser(chat, item, false);
if (cache == null)
{
ProtoService.Send(new GetUserFullInfo(privata.UserId));
}
else
{
Delegate?.UpdateUserFullInfo(chat, item, cache, false);
}
}
else if (chat.Type is ChatTypeSecret secretType)
{
var secret = ProtoService.GetSecretChat(secretType.SecretChatId);
var item = ProtoService.GetUser(secretType.UserId);
var cache = ProtoService.GetUserFull(secretType.UserId);
Delegate?.UpdateSecretChat(chat, secret);
Delegate?.UpdateUser(chat, item, true);
if (cache == null)
{
ProtoService.Send(new GetUserFullInfo(secret.UserId));
}
else
{
Delegate?.UpdateUserFullInfo(chat, item, cache, true);
}
}
else if (chat.Type is ChatTypeBasicGroup basic)
{
var item = ProtoService.GetBasicGroup(basic.BasicGroupId);
var cache = ProtoService.GetBasicGroupFull(basic.BasicGroupId);
Delegate?.UpdateBasicGroup(chat, item);
if (cache == null)
{
ProtoService.Send(new GetBasicGroupFullInfo(basic.BasicGroupId));
}
else
{
Delegate?.UpdateBasicGroupFullInfo(chat, item, cache);
}
}
else if (chat.Type is ChatTypeSupergroup super)
{
var item = ProtoService.GetSupergroup(super.SupergroupId);
var cache = ProtoService.GetSupergroupFull(super.SupergroupId);
Delegate?.UpdateSupergroup(chat, item);
if (cache == null)
{
ProtoService.Send(new GetSupergroupFullInfo(super.SupergroupId));
}
else
{
Delegate?.UpdateSupergroupFullInfo(chat, item, cache);
}
}
return(Task.CompletedTask);
}
private protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries,
out Action <uint, ReadOnlyMemory <char>, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate)
{
var stratCol = new List <uint>();
var stratVal = new List <ReadOnlyMemory <char> >();
var isWeighted = new List <bool>();
var ndcg = new List <Double[]>();
var dcg = new List <Double[]>();
var groupName = new List <ReadOnlyMemory <char> >();
var groupNdcg = new List <Double[]>();
var groupDcg = new List <Double[]>();
var groupMaxDcg = new List <Double[]>();
var groupStratCol = new List <uint>();
var groupStratVal = new List <ReadOnlyMemory <char> >();
bool hasStrats = Utils.Size(dictionaries) > 0;
bool hasWeight = aggregator.Weighted;
bool groupSummary = aggregator.UnweightedCounters.GroupSummary;
addAgg =
(stratColKey, stratColVal, agg) =>
{
Host.Check(agg.Weighted == hasWeight, "All aggregators must either be weighted or unweighted");
Host.Check(agg.UnweightedCounters.GroupSummary == aggregator.UnweightedCounters.GroupSummary,
"All aggregators must either compute group summary or not compute group summary");
stratCol.Add(stratColKey);
stratVal.Add(stratColVal);
isWeighted.Add(false);
ndcg.Add(agg.UnweightedCounters.Ndcg);
dcg.Add(agg.UnweightedCounters.Dcg);
if (agg.UnweightedCounters.GroupSummary)
{
groupStratCol.AddRange(agg.UnweightedCounters.GroupDcg.Select(x => stratColKey));
groupStratVal.AddRange(agg.UnweightedCounters.GroupDcg.Select(x => stratColVal));
groupName.AddRange(agg.GroupId.Select(sb => sb.ToString().AsMemory()));
groupNdcg.AddRange(agg.UnweightedCounters.GroupNdcg);
groupDcg.AddRange(agg.UnweightedCounters.GroupDcg);
groupMaxDcg.AddRange(agg.UnweightedCounters.GroupMaxDcg);
}
if (agg.Weighted)
{
stratCol.Add(stratColKey);
stratVal.Add(stratColVal);
isWeighted.Add(true);
ndcg.Add(agg.WeightedCounters.Ndcg);
dcg.Add(agg.WeightedCounters.Dcg);
}
};
consolidate =
() =>
{
var overallDvBldr = new ArrayDataViewBuilder(Host);
if (hasStrats)
{
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, stratCol.ToArray());
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, stratVal.ToArray());
}
if (hasWeight)
{
overallDvBldr.AddColumn(MetricKinds.ColumnNames.IsWeighted, BoolType.Instance, isWeighted.ToArray());
}
overallDvBldr.AddColumn(Ndcg, aggregator.GetSlotNames, NumberType.R8, ndcg.ToArray());
overallDvBldr.AddColumn(Dcg, aggregator.GetSlotNames, NumberType.R8, dcg.ToArray());
var groupDvBldr = new ArrayDataViewBuilder(Host);
if (hasStrats)
{
groupDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, groupStratCol.ToArray());
groupDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, groupStratVal.ToArray());
}
if (groupSummary)
{
groupDvBldr.AddColumn(GroupId, TextType.Instance, groupName.ToArray());
groupDvBldr.AddColumn(Ndcg, aggregator.GetGroupSummarySlotNames("NDCG"), NumberType.R8, groupNdcg.ToArray());
groupDvBldr.AddColumn(Dcg, aggregator.GetGroupSummarySlotNames("DCG"), NumberType.R8, groupDcg.ToArray());
groupDvBldr.AddColumn(MaxDcg, aggregator.GetGroupSummarySlotNames("MaxDCG"), NumberType.R8, groupMaxDcg.ToArray());
}
var result = new Dictionary <string, IDataView>();
result.Add(MetricKinds.OverallMetrics, overallDvBldr.GetDataView());
if (groupSummary)
{
result.Add(GroupSummary, groupDvBldr.GetDataView());
}
return(result);
};
}
/// <summary>
/// Called when [aggregator] is visited.
/// </summary>
/// <param name="aggregator">The aggregator.</param>
public virtual void OnAggregator(Aggregator aggregator)
{
}
public override Task OnNavigatedFromAsync(IDictionary <string, object> pageState, bool suspending)
{
Aggregator.Unsubscribe(this);
return(Task.CompletedTask);
}
public void SetUp()
{
log = new Log ();
parser = new SystemtapParser ();
aggregator = new Aggregator (log, parser);
}
/// <inheritdoc/>
protected override async Task AfterTestCaseStartingAsync()
{
await base.AfterTestCaseStartingAsync();
try
{
var dataAttributes = TestCase.TestMethod.Method.GetCustomAttributes(typeof(DataAttribute));
foreach (var dataAttribute in dataAttributes)
{
var discovererAttribute = dataAttribute.GetCustomAttributes(typeof(DataDiscovererAttribute)).First();
var args = discovererAttribute.GetConstructorArguments().Cast <string>().ToList();
var discovererType = SerializationHelper.GetType(args[1], args[0]);
if (discovererType == null)
{
if (dataAttribute is IReflectionAttributeInfo reflectionAttribute)
{
Aggregator.Add(new InvalidOperationException($"Data discoverer specified for {reflectionAttribute.Attribute.GetType()} on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not exist."));
}
else
{
Aggregator.Add(new InvalidOperationException($"A data discoverer specified on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not exist."));
}
continue;
}
IDataDiscoverer discoverer;
try
{
discoverer = ExtensibilityPointFactory.GetDataDiscoverer(DiagnosticMessageSink, discovererType);
}
catch (InvalidCastException)
{
if (dataAttribute is IReflectionAttributeInfo reflectionAttribute)
{
Aggregator.Add(new InvalidOperationException($"Data discoverer specified for {reflectionAttribute.Attribute.GetType()} on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not implement IDataDiscoverer."));
}
else
{
Aggregator.Add(new InvalidOperationException($"A data discoverer specified on {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name} does not implement IDataDiscoverer."));
}
continue;
}
var data = discoverer.GetData(dataAttribute, TestCase.TestMethod.Method);
if (data == null)
{
Aggregator.Add(new InvalidOperationException($"Test data returned null for {TestCase.TestMethod.TestClass.Class.Name}.{TestCase.TestMethod.Method.Name}. Make sure it is statically initialized before this test method is called."));
continue;
}
foreach (var dataRow in data)
{
toDispose.AddRange(dataRow.OfType <IDisposable>());
ITypeInfo[] resolvedTypes = null;
var methodToRun = TestMethod;
var convertedDataRow = methodToRun.ResolveMethodArguments(dataRow);
if (methodToRun.IsGenericMethodDefinition)
{
resolvedTypes = TestCase.TestMethod.Method.ResolveGenericTypes(convertedDataRow);
methodToRun = methodToRun.MakeGenericMethod(resolvedTypes.Select(t => ((IReflectionTypeInfo)t).Type).ToArray());
}
var parameterTypes = methodToRun.GetParameters().Select(p => p.ParameterType).ToArray();
convertedDataRow = Reflector.ConvertArguments(convertedDataRow, parameterTypes);
var theoryDisplayName = TestCase.TestMethod.Method.GetDisplayNameWithArguments(DisplayName, convertedDataRow, resolvedTypes);
var test = CreateTest(TestCase, theoryDisplayName);
var skipReason = SkipReason ?? dataAttribute.GetNamedArgument <string>("Skip");
testRunners.Add(CreateTestRunner(test, MessageBus, TestClass, ConstructorArguments, methodToRun, convertedDataRow, skipReason, BeforeAfterAttributes, Aggregator, CancellationTokenSource));
}
}
}
catch (Exception ex)
{
// Stash the exception so we can surface it during RunTestAsync
dataDiscoveryException = ex;
}
}
protected void Aggregate <Tseries, Tval>(TimeSeriesResampler <Tseries, Tval> resampler, ITimeSeries <Tval> series, Aggregator defaultFunc, Func <Tval, decimal> selector, Func <decimal, Tval> resultCast) where Tval : struct where Tseries : TimeSeriesBase <Tval>
{
Aggregate(resampler, new List <ITimeSeries <Tval> >()
{
series
}, defaultFunc, selector, resultCast);
}
private static void ExecuteSingleVectorOperation <T>(BinaryExpression operation,
LinearAlgebraProvider provider,
ArrayPoolStack <T> arrayPoolStack, List <NArray <T> > localsToFree,
OutputGetter <T> getter, Aggregator aggregator,
int vectorLength,
int chunkIndex, int startIndex, ExecutionTimer timer)
{
if (operation == null || operation.NodeType != ExpressionType.Assign)
{
return;
}
if (operation == null)
{
return;
}
NArray <T> result;
var left = operation.Left as ReferencingVectorParameterExpression <T>;
NArray <T> aggregationTarget = null;
if (left.ParameterType == ParameterType.Local)
{
result = left.Array;
var chunkyStorage = result.Storage as ChunkyStorage <T>;
if (chunkyStorage != null)
{
var newStorage = arrayPoolStack.Pop();
chunkyStorage.SetChunk(chunkIndex, newStorage);
}
aggregationTarget = getter.TryGetNext(left.Index);
}
else
{
result = (operation.Left as ReferencingVectorParameterExpression <T>).Array;
}
if (operation.Right is UnaryMathsExpression)
{
var unaryOperation = operation.Right as UnaryMathsExpression;
if (unaryOperation.UnaryType == UnaryElementWiseOperation.ScaleOffset)
{
var scaleOffset = unaryOperation as ScaleOffsetExpression <T>;
(provider as IElementWise <T>).ScaleOffset(Slice <T>(unaryOperation.Operand, chunkIndex, startIndex, vectorLength),
scaleOffset.Scale, scaleOffset.Offset,
Slice(result, chunkIndex, startIndex, vectorLength));
}
else if (unaryOperation.UnaryType == UnaryElementWiseOperation.ScaleInverse)
{
var scaleInverse = unaryOperation as ScaleInverseExpression <T>;
(provider as IElementWise <T>).ScaleInverse(Slice <T>(unaryOperation.Operand, chunkIndex, startIndex, vectorLength),
scaleInverse.Scale,
Slice(result, chunkIndex, startIndex, vectorLength));
}
else
{
(provider as IElementWise <T>).UnaryElementWiseOperation(
Slice <T>(unaryOperation.Operand, chunkIndex, startIndex, vectorLength),
Slice(result, chunkIndex, startIndex, vectorLength),
unaryOperation.UnaryType);
}
}
if (operation.Right is BinaryExpression)
{
var binaryOperation = operation.Right as BinaryExpression;
(provider as IElementWise <T>).BinaryElementWiseOperation(Slice <T>(binaryOperation.Left, chunkIndex, startIndex, vectorLength),
Slice <T>(binaryOperation.Right, chunkIndex, startIndex, vectorLength),
Slice(result, chunkIndex, startIndex, vectorLength),
binaryOperation.NodeType);
}
if (aggregationTarget != null)
{
if (aggregator != Aggregator.ElementwiseAdd)
{
throw new NotImplementedException();
}
if (aggregationTarget.IsScalar)
{
throw new Exception();
}
var slice = Slice <T>(aggregationTarget, chunkIndex, startIndex, vectorLength);
(provider as IElementWise <T>).BinaryElementWiseOperation(
slice,
Slice(result, chunkIndex, startIndex, vectorLength),
slice, ExpressionType.Add);
}
foreach (var item in localsToFree)
{
arrayPoolStack.Push((item.Storage as ChunkyStorage <T>).GetChunk(chunkIndex));
}
}
protected virtual void StoreColumn(QuerySelectColumnData column)
{
Aggregator.AddSelect(column);
}
/// <summary>
/// Runs the test.
/// </summary>
/// <returns>Returns summary information about the test that was run.</returns>
public async Task <RunSummary> RunAsync()
{
var runSummary = new RunSummary {
Total = 1
};
var output = String.Empty; // TODO: Add output facilities for v2
if (!MessageBus.QueueMessage(new TestStarting(TestCase, DisplayName)))
{
CancellationTokenSource.Cancel();
}
else
{
AfterTestStarting();
if (!String.IsNullOrEmpty(SkipReason))
{
runSummary.Skipped++;
if (!MessageBus.QueueMessage(new TestSkipped(TestCase, DisplayName, SkipReason)))
{
CancellationTokenSource.Cancel();
}
}
else
{
var aggregator = new ExceptionAggregator(Aggregator);
if (!aggregator.HasExceptions)
{
runSummary.Time = await aggregator.RunAsync(() => InvokeTestAsync(aggregator));
}
var exception = aggregator.ToException();
TestResultMessage testResult;
if (exception == null)
{
testResult = new TestPassed(TestCase, DisplayName, runSummary.Time, output);
}
else
{
testResult = new TestFailed(TestCase, DisplayName, runSummary.Time, output, exception);
runSummary.Failed++;
}
if (!CancellationTokenSource.IsCancellationRequested)
{
if (!MessageBus.QueueMessage(testResult))
{
CancellationTokenSource.Cancel();
}
}
}
Aggregator.Clear();
BeforeTestFinished();
if (Aggregator.HasExceptions)
{
if (!MessageBus.QueueMessage(new TestCleanupFailure(TestCase, DisplayName, Aggregator.ToException())))
{
CancellationTokenSource.Cancel();
}
}
}
if (!MessageBus.QueueMessage(new TestFinished(TestCase, DisplayName, runSummary.Time, output)))
{
CancellationTokenSource.Cancel();
}
return(runSummary);
}
private void ApplyAggregatorResults(Aggregator aggregator)
{
aggregator.Evaluate();
DoIt(aggregator.InferredFacts);
}
/// <summary>
/// Called when [aggregator] is visited.
/// </summary>
/// <param name="aggregator">The aggregator.</param>
public override void OnAggregator(Aggregator aggregator)
{
_sb.AppendLine(aggregator.ToString());
}
/// <summary>
/// Runs the tests in the test case.
/// </summary>
/// <returns>Returns summary information about the tests that were run.</returns>
public async Task <RunSummary> RunAsync()
{
var summary = new RunSummary();
if (!MessageBus.QueueMessage(new TestCaseStarting(TestCase)))
{
CancellationTokenSource.Cancel();
}
else
{
try
{
await AfterTestCaseStartingAsync();
summary = await RunTestAsync();
Aggregator.Clear();
await BeforeTestCaseFinishedAsync();
if (Aggregator.HasExceptions)
{
if (!MessageBus.QueueMessage(new TestCaseCleanupFailure(TestCase, Aggregator.ToException())))
{
CancellationTokenSource.Cancel();
}
}
}
finally
{
if (!MessageBus.QueueMessage(new TestCaseFinished(TestCase, summary.Time, summary.Total, summary.Failed, summary.Skipped)))
{
CancellationTokenSource.Cancel();
}
}
}
return(summary);
}
/// <summary>
/// Adds the aggregator.
/// </summary>
/// <param name="m">The m.</param>
public void AddAggregator(Aggregator m)
{
AggregatorNode new_production = new AggregatorNode(m.Label);
new_production.Aggregator = m;
AddProduction(new_production, m.lhs);
m.AggregatorNode = new_production;
}
protected override void CreateCollectionFixture(Type fixtureType)
{
Aggregator.Run(() => CollectionFixtureMappings[fixtureType] = _testCollectionLifetimeScope.Resolve(fixtureType));
}
/// <summary>
/// Adds the aggregator to the internal list.
/// </summary>
/// <param name="aggregator">The aggregator.</param>
public void AddAggregator(Aggregator aggregator)
{
_aggregators.Add(aggregator);
}
public override Task OnNavigatedToAsync(object parameter, NavigationMode mode, IDictionary <string, object> state)
{
ProtoService.Send(new GetInstalledStickerSets(false), result =>
{
if (result is StickerSets sets)
{
BeginOnUIThread(() => Items.ReplaceWith(sets.Sets));
}
});
var chatId = (long)parameter;
Chat = ProtoService.GetChat(chatId);
var chat = _chat;
if (chat == null)
{
return(Task.CompletedTask);
}
Aggregator.Subscribe(this);
//Delegate?.UpdateChat(chat);
if (chat.Type is ChatTypeSupergroup super)
{
var item = ProtoService.GetSupergroup(super.SupergroupId);
var cache = ProtoService.GetSupergroupFull(super.SupergroupId);
//Delegate?.UpdateSupergroup(chat, item);
if (cache == null)
{
ProtoService.Send(new GetSupergroupFullInfo(super.SupergroupId));
}
else
{
UpdateSupergroupFullInfo(chat, item, cache);
}
}
return(Task.CompletedTask);
//Item = null;
//Full = null;
//SelectedItem = null;
//var channel = parameter as TLChannel;
//var peer = parameter as TLPeerChannel;
//if (peer != null)
//{
// channel = CacheService.GetChat(peer.ChannelId) as TLChannel;
//}
//if (channel != null)
//{
// Item = channel;
// var full = CacheService.GetFullChat(channel.Id) as TLChannelFull;
// if (full == null)
// {
// var response = await LegacyService.GetFullChannelAsync(channel.ToInputChannel());
// if (response.IsSucceeded)
// {
// full = response.Result.FullChat as TLChannelFull;
// }
// }
// if (full != null)
// {
// Full = full;
// SelectedItem = _stickersService.GetGroupStickerSetById(full.StickerSet);
// }
//}
}
public AggregationFunction GetAggregator(Aggregator aggregator)
{
switch (aggregator)
{
case Aggregator.Sum: return AggregationFunction.Sum;
case Aggregator.Count: return AggregationFunction.Count;
case Aggregator.Min: return AggregationFunction.Min;
case Aggregator.Max: return AggregationFunction.Max;
case Aggregator.DistinctCount: return AggregationFunction.DistinctCount;
case Aggregator.None: return AggregationFunction.None;
case Aggregator.ByAccount: return AggregationFunction.ByAccount;
case Aggregator.AverageOfChildren: return AggregationFunction.AverageOfChildren;
case Aggregator.FirstChild: return AggregationFunction.FirstChild;
case Aggregator.LastChild: return AggregationFunction.LastChild;
case Aggregator.FirstNonEmpty: return AggregationFunction.FirstNonEmpty;
case Aggregator.LastNonEmpty: return AggregationFunction.LastNonEmpty;
}
throw new NotSupportedException(string.Format("不支持此枚举类型{0}", aggregator));
}
protected override void GetAggregatorConsolidationFuncs(Aggregator aggregator, AggregatorDictionaryBase[] dictionaries,
out Action <uint, DvText, Aggregator> addAgg, out Func <Dictionary <string, IDataView> > consolidate)
{
var stratCol = new List <uint>();
var stratVal = new List <DvText>();
var auc = new List <Double>();
var drAtK = new List <Double>();
var drAtP = new List <Double>();
var drAtNumAnomalies = new List <Double>();
var thresholdAtK = new List <Single>();
var thresholdAtP = new List <Single>();
var thresholdAtNumAnomalies = new List <Single>();
var numAnoms = new List <DvInt8>();
var scores = new List <Single>();
var labels = new List <Single>();
var names = new List <DvText>();
var topKStratCol = new List <uint>();
var topKStratVal = new List <DvText>();
bool hasStrats = Utils.Size(dictionaries) > 0;
addAgg =
(stratColKey, stratColVal, agg) =>
{
agg.Finish();
stratCol.Add(stratColKey);
stratVal.Add(stratColVal);
auc.Add(agg.Auc);
drAtK.Add(agg.DrAtK);
drAtP.Add(agg.DrAtP);
drAtNumAnomalies.Add(agg.DrAtNumAnomalies);
thresholdAtK.Add(agg.ThresholdAtK);
thresholdAtP.Add(agg.ThresholdAtP);
thresholdAtNumAnomalies.Add(agg.ThresholdAtNumAnomalies);
numAnoms.Add(agg.AggCounters.NumAnomalies);
names.AddRange(agg.Names.Take(agg.NumTopExamples));
scores.AddRange(agg.Scores.Take(agg.NumTopExamples));
labels.AddRange(agg.Labels.Take(agg.NumTopExamples));
if (hasStrats)
{
topKStratCol.AddRange(agg.Scores.Select(x => stratColKey));
topKStratVal.AddRange(agg.Scores.Select(x => stratColVal));
}
};
consolidate =
() =>
{
var overallDvBldr = new ArrayDataViewBuilder(Host);
if (hasStrats)
{
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, stratCol.ToArray());
overallDvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, stratVal.ToArray());
}
overallDvBldr.AddColumn(BinaryClassifierEvaluator.Auc, NumberType.R8, auc.ToArray());
overallDvBldr.AddColumn(OverallMetrics.DrAtK, NumberType.R8, drAtK.ToArray());
overallDvBldr.AddColumn(OverallMetrics.DrAtPFpr, NumberType.R8, drAtP.ToArray());
overallDvBldr.AddColumn(OverallMetrics.DrAtNumPos, NumberType.R8, drAtNumAnomalies.ToArray());
overallDvBldr.AddColumn(OverallMetrics.ThreshAtK, NumberType.R4, thresholdAtK.ToArray());
overallDvBldr.AddColumn(OverallMetrics.ThreshAtP, NumberType.R4, thresholdAtP.ToArray());
overallDvBldr.AddColumn(OverallMetrics.ThreshAtNumPos, NumberType.R4, thresholdAtNumAnomalies.ToArray());
overallDvBldr.AddColumn(OverallMetrics.NumAnomalies, NumberType.I8, numAnoms.ToArray());
var topKdvBldr = new ArrayDataViewBuilder(Host);
if (hasStrats)
{
topKdvBldr.AddColumn(MetricKinds.ColumnNames.StratCol, GetKeyValueGetter(dictionaries), 0, dictionaries.Length, topKStratCol.ToArray());
topKdvBldr.AddColumn(MetricKinds.ColumnNames.StratVal, TextType.Instance, topKStratVal.ToArray());
}
topKdvBldr.AddColumn(TopKResultsColumns.Instance, TextType.Instance, names.ToArray());
topKdvBldr.AddColumn(TopKResultsColumns.AnomalyScore, NumberType.R4, scores.ToArray());
topKdvBldr.AddColumn(TopKResultsColumns.Label, NumberType.R4, labels.ToArray());
var result = new Dictionary <string, IDataView>();
result.Add(MetricKinds.OverallMetrics, overallDvBldr.GetDataView());
result.Add(TopKResults, topKdvBldr.GetDataView());
return(result);
};
}
protected void Aggregate <Tseries, Tval>(TimeSeriesResampler <Tseries, Tval> resampler, IEnumerable <ITimeSeries <Tval> > series, Aggregator defaultFunc, Func <Tval, decimal> selector, Func <decimal, Tval> resultCast) where Tval : struct where Tseries : TimeSeriesBase <Tval>
{
switch (AggregatorFunction == Aggregator.Default ? defaultFunc : AggregatorFunction)
{
case Aggregator.Minimum:
{
resampler.SampleAggregate(series, x => resultCast(x.Min(selector) * CorrectionFactor + CorrectionOffset));
break;
}
case Aggregator.Maximum:
{
resampler.SampleAggregate(series, x => resultCast(x.Max(selector) * CorrectionFactor + CorrectionOffset));
break;
}
case Aggregator.Sum:
{
resampler.SampleAggregate(series, x => resultCast(x.Sum(selector) * CorrectionFactor + CorrectionOffset));
break;
}
case Aggregator.Average: goto default;
default:
{
resampler.SampleAggregate(series, x => resultCast(x.Average(selector) * CorrectionFactor + CorrectionOffset));
break;
}
}
}
public void Run(Aggregator aggregator, string[] argv, string stdin_str)
{
if (state != State.PreRun)
throw new ApplicationException ("Tried to Run() an AggregatorRunner which was not in PreRun state");
if (aggregator == null)
throw new ArgumentNullException ("aggregator");
if (argv == null)
throw new ArgumentNullException ("argv");
this.aggregator = aggregator;
try {
int[] pipe;
spawn = new Spawn ();
pipe = new int[2];
if (unix.pipe (pipe) != 0)
throw new UnixIOException (Mono.Unix.Native.Stdlib.GetLastError ());
Spawn.ChildSetupFunc child_setup_fn = delegate () {
int process_group;
UnixStream child_stream;
StreamWriter child_writer;
process_group = unix.setsid ();
child_stream = new UnixStream (pipe[1], false);
child_writer = new StreamWriter (child_stream);
child_writer.Write ("{0}\n", process_group);
child_writer.Close ();
};
spawn.SpawnAsyncWithPipes (null,
argv,
null,
GSpawnFlags.G_SPAWN_DO_NOT_REAP_CHILD | GSpawnFlags.G_SPAWN_SEARCH_PATH,
child_setup_fn,
out child_pid,
out child_stdin,
out child_stdout,
out child_stderr);
child_watch_id = spawn.ChildWatchAdd (child_pid, child_watch_cb);
UnixStream parent_stream;
StreamReader parent_reader;
string str;
parent_stream = new UnixStream (pipe[0], false);
parent_reader = new StreamReader (parent_stream);
str = parent_reader.ReadLine ();
parent_reader.Close ();
child_process_group = int.Parse (str);
if (child_process_group == -1)
throw new ApplicationException ("Could not get the child process group");
state = State.Running;
stdout_reader = new UnixReader (child_stdout);
stdout_reader.DataAvailable += stdout_reader_data_available_cb;
stdout_reader.Closed += stdout_reader_closed_cb;
stderr_reader = new UnixReader (child_stderr);
stderr_reader.DataAvailable += stderr_reader_data_available_cb;
stderr_reader.Closed += stderr_reader_closed_cb;
line_reader = new LineReader ();
line_reader.LineAvailable += line_reader_line_available_cb;
if (stdin_str != null)
write_stdin_to_child (stdin_str);
} catch (GException e) {
Console.WriteLine ("error when spawning: {0}", e);
/* FIXME: report something better --- re-throw the exception here? */
state = State.Error;
}
}
