public void Minimal()
{
var data = new[] {
new Group {
items = new object[] { 1, 5 }
},
new Group {
items = new object[] { 7 }
}
};
var calculator = new AggregateCalculator <int>(data, new DefaultAccessor <int>(),
new[] { new SummaryInfo {
Selector = "this", SummaryType = "sum"
} },
new[] { new SummaryInfo {
Selector = "this", SummaryType = "sum"
} }
);
var totals = calculator.Run();
Assert.Equal(13M, totals[0]);
Assert.Equal(6M, data[0].summary[0]);
Assert.Equal(7M, data[1].summary[0]);
}
public void SumFix()
{
var summary = Enumerable.Range(1, 4)
.Select(i => new SummaryInfo {
SummaryType = "sum", Selector = "Item" + i
})
.ToArray();
var data = new[] {
new Group {
items = new[] { new SumFixItem() }
},
new Group {
items = new object[] { null }
},
new Group {
items = Array.Empty <object>()
}
};
var totals = new AggregateCalculator <SumFixItem>(data, new DefaultAccessor <SumFixItem>(), summary, summary).Run();
foreach (var values in new[] {
totals,
data[0].summary,
data[1].summary,
data[2].summary
})
{
Assert.Equal(0m, values[0]);
Assert.Equal(0d, values[1]);
Assert.Equal(default(TimeSpan), values[2]);
Assert.Equal(0m, values[3]);
}
}
public static RemoteGroupingResult Run(IEnumerable<IRemoteGroup> flatGroups, int groupCount, SummaryInfo[] totalSummary, SummaryInfo[] groupSummary) {
var accessor = new RemoteGroupAccessor();
List<Group> hierGroups = null;
if(groupCount > 0) {
hierGroups = new GroupHelper<IRemoteGroup>(accessor).Group(
flatGroups,
Enumerable.Range(0, groupCount).Select(i => new GroupingInfo { Selector = "K" + i }).ToArray()
);
}
IEnumerable dataToAggregate = hierGroups;
if(dataToAggregate == null)
dataToAggregate = flatGroups;
var transformedTotalSummary = TransformSummary(totalSummary, "T");
var transformedGroupSummary = TransformSummary(groupSummary, "G");
transformedTotalSummary.Add(new SummaryInfo { SummaryType = "remoteCount" });
var totals = new AggregateCalculator<IRemoteGroup>(dataToAggregate, accessor, transformedTotalSummary, transformedGroupSummary).Run();
var totalCount = (int)totals.Last();
totals = totals.Take(totals.Length - 1).ToArray();
if(totals.Length < 1)
totals = null;
return new RemoteGroupingResult {
Groups = hierGroups,
Totals = totals,
TotalCount = totalCount
};
}
public void CustomAggregator()
{
CustomAggregatorsBarrier.Run(delegate {
CustomAggregators.RegisterAggregator("comma", typeof(CommaAggregator <>));
var data = new[] {
new Group {
items = new Tuple <int>[] { Tuple.Create(1), Tuple.Create(5) }
},
new Group {
items = new Tuple <int>[] { Tuple.Create(7) }
},
new Group {
items = new Tuple <int>[] { }
}
};
var calculator = new AggregateCalculator <Tuple <int> >(data, new DefaultAccessor <Tuple <int> >(),
new[] { new SummaryInfo {
Selector = "Item1", SummaryType = "comma"
} },
new[] { new SummaryInfo {
Selector = "Item1", SummaryType = "comma"
} }
);
var totals = calculator.Run();
Assert.Equal("1,5,7", totals[0]);
Assert.Equal("1,5", data[0].summary[0]);
Assert.Equal("7", data[1].summary[0]);
Assert.Equal(string.Empty, data[2].summary[0]);
});
}
public void TimeSpanType()
{
var data = new[] {
TimeSpan.FromMinutes(1),
TimeSpan.FromMinutes(3)
};
var calculator = new AggregateCalculator <TimeSpan>(data, new DefaultAccessor <TimeSpan>(),
new[] {
new SummaryInfo {
Selector = "this", SummaryType = "min"
},
new SummaryInfo {
Selector = "this", SummaryType = "max"
},
new SummaryInfo {
Selector = "this", SummaryType = "sum"
},
new SummaryInfo {
Selector = "this", SummaryType = "avg"
}
},
null
);
Assert.Equal(
new object[] {
TimeSpan.FromMinutes(1),
TimeSpan.FromMinutes(3),
TimeSpan.FromMinutes(4),
TimeSpan.FromMinutes(2)
},
calculator.Run()
);
}
public void NestedGroups()
{
var data = new[] {
new Group {
items = new[] {
new Group {
items = new object[] { 1, 5 }
}
}
}
};
var calculator = new AggregateCalculator <int>(data, new DefaultAccessor <int>(), null, new[] {
new SummaryInfo {
Selector = "this", SummaryType = "sum"
}
});
var totals = calculator.Run();
Assert.Null(totals);
Assert.Equal(6M, data[0].summary[0]);
Assert.Equal(6M, (data[0].items[0] as Group).summary[0]);
}
public void IgnoreGroupSummaryIfNoGroups()
{
var data = new object[] { 1 };
var calculator = new AggregateCalculator <int>(data, new DefaultAccessor <int>(), null, new[] {
new SummaryInfo {
Selector = "ignore me", SummaryType = "ignore me"
}
});
calculator.Run();
}
public void NoStrategy_ThrowsException()
{
// Arrange
var calculations = Enumerable.Empty <IBinaryCalculation>();
var calculator = new AggregateCalculator(calculations);
// Act
Action run = () => calculator.Solve(new CalculationCommand());
// Assert
run.ShouldThrow <ArgumentException>();
}
public static RemoteGroupingResult Run(IEnumerable <AnonType> flatGroups, int groupCount, ContosoRetail.SharedKernel.DataAccess.DataLoader.SummaryInfo[] totalSummary, ContosoRetail.SharedKernel.DataAccess.DataLoader.SummaryInfo[] groupSummary)
{
var accessor = new AnonTypeAccessor();
var markup = new RemoteGroupTypeMarkup(
groupCount,
totalSummary != null ? totalSummary.Length : 0,
groupSummary != null ? groupSummary.Length : 0
);
List <Group> hierGroups = null;
if (groupCount > 0)
{
hierGroups = new GroupHelper <AnonType>(accessor).Group(
flatGroups,
Enumerable.Range(0, groupCount).Select(i => new ContosoRetail.SharedKernel.DataAccess.DataLoader.GroupingInfo {
Selector = AnonType.ITEM_PREFIX + (RemoteGroupTypeMarkup.KeysStartIndex + i)
}).ToArray()
);
}
IEnumerable dataToAggregate = hierGroups;
if (dataToAggregate == null)
{
dataToAggregate = flatGroups;
}
var transformedTotalSummary = TransformSummary(totalSummary, markup.TotalSummaryStartIndex);
var transformedGroupSummary = TransformSummary(groupSummary, markup.GroupSummaryStartIndex);
transformedTotalSummary.Add(new SummaryInfo {
SummaryType = "remoteCount"
});
var totals = new AggregateCalculator <AnonType>(dataToAggregate, accessor, transformedTotalSummary, transformedGroupSummary).Run();
var totalCount = (int)totals.Last();
totals = totals.Take(totals.Length - 1).ToArray();
if (totals.Length < 1)
{
totals = null;
}
return(new RemoteGroupingResult
{
Groups = hierGroups,
Totals = totals,
TotalCount = totalCount
});
}
public void Issue147()
{
var data = Enumerable.Repeat(Double.MaxValue / 3, 2);
var calculator = new AggregateCalculator <double>(data, new DefaultAccessor <double>(),
new[] { new SummaryInfo {
Selector = "this", SummaryType = "sum"
} },
null
);
Assert.Equal(data.Sum(), calculator.Run()[0]);
}
public void ValidStrategy_CallsStrategy()
{
// Arrange
var calculation = CreateMockCalculation();
var calculations = Enumerable.Repeat(calculation, 1);
var calculator = new AggregateCalculator(calculations);
// Act
calculator.Solve(new CalculationCommand());
// Assert
calculation.Received().Apply(0, 0);
}
void AssertCalculation(object[] data, object expectedSum, object expectedMin, object expectedMax, object expectedAvg, object expectedCount)
{
/*
* SQL script to validate
*
* drop table if exists t1;
*
#create table t1 (a int);
#insert into t1 (a) values (1), (3), (5);
*
#create table t1 (a varchar(32));
#insert into t1 (a) values ('a'), ('z');
*
#insert into t1 (a) values (null);
*
* select concat(
* " sum=", coalesce(sum(a), 'N'),
* " min=", coalesce(min(a), 'N'),
* " max=", coalesce(max(a), 'N'),
* " avg=", coalesce(avg(a), 'N'),
* " count=", coalesce(count(*), 'N')
* ) from t1;
*
*/
var summaries = new[] {
new SummaryInfo {
Selector = "this", SummaryType = "sum"
},
new SummaryInfo {
Selector = "this", SummaryType = "min"
},
new SummaryInfo {
Selector = "this", SummaryType = "max"
},
new SummaryInfo {
Selector = "this", SummaryType = "avg"
},
new SummaryInfo {
SummaryType = "count"
},
};
var totals = new AggregateCalculator <object>(data, new DefaultAccessor <object>(), summaries, null).Run();
Assert.Equal(expectedSum, totals[0]);
Assert.Equal(expectedMin, totals[1]);
Assert.Equal(expectedMax, totals[2]);
Assert.Equal(expectedAvg, totals[3]);
Assert.Equal(expectedCount, totals[4]);
}
public void CustomAggregator()
{
try {
CustomAggregators.RegisterAggregator("totalSales", typeof(TotalSalesAggregator <>));
var data = new[] {
new Group {
items = new[] {
new CustomAggregatorDataItem {
UnitPrice = 4.04M, Quantity = 5, Discount = 0.10M
},
new CustomAggregatorDataItem {
UnitPrice = 10.10M, Quantity = 2, Discount = 0.20M
}
}
},
new Group {
items = new[] {
new CustomAggregatorDataItem {
UnitPrice = 15.15M, Quantity = 4, Discount = 0.30M
}
}
},
new Group {
items = new CustomAggregatorDataItem[] { }
}
};
var calculator = new AggregateCalculator <CustomAggregatorDataItem>(data, new DefaultAccessor <CustomAggregatorDataItem>(),
new[] { new SummaryInfo {
Selector = "this", SummaryType = "totalSales"
} },
new[] { new SummaryInfo {
Selector = "this", SummaryType = "totalSales"
} }
);
var totals = calculator.Run();
Assert.Equal(76.76M, totals[0]);
Assert.Equal(34.34M, data[0].summary[0]);
Assert.Equal(42.42M, data[1].summary[0]);
Assert.Equal(0M, data[2].summary[0]);
} finally {
CustomAggregators.Clear();
}
}
public void MultipleStrategies_ShouldAggregate()
{
// Arrange
var calculation = Substitute.For <IBinaryCalculation>();
calculation.Operation.Returns((string)null);
var calculations = Enumerable.Range(0, 10)
.Select(x => x.ToString())
.Select(CreateMockCalculation);
var calculator = new AggregateCalculator(calculations);
// Act
var result = calculator.GetSupportedOperations();
// Assert
result.ShouldBe(Enumerable.Range(0, 10).Select(x => x.ToString()));
}
public static RemoteGroupingResult Run(Type sourceItemType, IEnumerable <AnonType> flatGroups, int groupCount, SummaryInfo[] totalSummary, SummaryInfo[] groupSummary)
{
List <Group> hierGroups = null;
if (groupCount > 0)
{
hierGroups = new GroupHelper <AnonType>(AnonTypeAccessor.Instance).Group(
flatGroups,
Enumerable.Range(0, groupCount).Select(i => new GroupingInfo {
Selector = AnonType.IndexToField(1 + i)
}).ToArray()
);
}
IEnumerable dataToAggregate = hierGroups;
if (dataToAggregate == null)
{
dataToAggregate = flatGroups;
}
var fieldIndex = 1 + groupCount;
var transformedTotalSummary = TransformSummary(totalSummary, ref fieldIndex);
var transformedGroupSummary = TransformSummary(groupSummary, ref fieldIndex);
transformedTotalSummary = transformedTotalSummary ?? new List <SummaryInfo>();
transformedTotalSummary.Add(new SummaryInfo {
SummaryType = AggregateName.REMOTE_COUNT
});
var sumFix = new SumFix(sourceItemType, totalSummary, groupSummary);
var totals = new AggregateCalculator <AnonType>(dataToAggregate, AnonTypeAccessor.Instance, transformedTotalSummary, transformedGroupSummary, sumFix).Run();
var totalCount = (int)totals.Last();
totals = totals.Take(totals.Length - 1).ToArray();
if (totals.Length < 1)
{
totals = null;
}
return(new RemoteGroupingResult {
Groups = hierGroups,
Totals = totals,
TotalCount = totalCount
});
}
public static RemoteGroupingResult Run(IEnumerable <IRemoteGroup> flatGroups, int groupCount, SummaryInfo[] totalSummary, SummaryInfo[] groupSummary)
{
var accessor = new RemoteGroupAccessor();
List <Group> hierGroups = null;
if (groupCount > 0)
{
hierGroups = new GroupHelper <IRemoteGroup>(accessor).Group(
flatGroups,
Enumerable.Range(0, groupCount).Select(i => new GroupingInfo {
Selector = "K" + i
}).ToArray()
);
}
IEnumerable dataToAggregate = hierGroups;
if (dataToAggregate == null)
{
dataToAggregate = flatGroups;
}
var transformedTotalSummary = TransformSummary(totalSummary, "T");
var transformedGroupSummary = TransformSummary(groupSummary, "G");
transformedTotalSummary.Add(new SummaryInfo {
SummaryType = "remoteCount"
});
var totals = new AggregateCalculator <IRemoteGroup>(dataToAggregate, accessor, transformedTotalSummary, transformedGroupSummary).Run();
var totalCount = (int)totals.Last();
totals = totals.Take(totals.Length - 1).ToArray();
if (totals.Length < 1)
{
totals = null;
}
return(new RemoteGroupingResult {
Groups = hierGroups,
Totals = totals,
TotalCount = totalCount
});
}
public void Minimal() {
var data = new[] {
new Group {
items = new object[] { 1, 5 }
},
new Group {
items = new object[] { 7 }
}
};
var calculator = new AggregateCalculator<int>(data, new DefaultAccessor<int>(),
new[] { new SummaryInfo { Selector = "this", SummaryType = "sum" } },
new[] { new SummaryInfo { Selector = "this", SummaryType = "sum" } }
);
var totals = calculator.Run();
Assert.Equal(13M, totals[0]);
Assert.Equal(6M, data[0].summary[0]);
Assert.Equal(7M, data[1].summary[0]);
}
void AssertCalculation(object[] data, object expectedSum, object expectedMin, object expectedMax, object expectedAvg, object expectedCount) {
/*
SQL script to validate
drop table if exists t1;
#create table t1 (a int);
#insert into t1 (a) values (1), (3), (5);
#create table t1 (a varchar(32));
#insert into t1 (a) values ('a'), ('z');
#insert into t1 (a) values (null);
select concat(
" sum=", coalesce(sum(a), 'N'),
" min=", coalesce(min(a), 'N'),
" max=", coalesce(max(a), 'N'),
" avg=", coalesce(avg(a), 'N'),
" count=", coalesce(count(*), 'N')
) from t1;
*/
var summaries = new[] {
new SummaryInfo { Selector = "this", SummaryType = "sum" },
new SummaryInfo { Selector = "this", SummaryType = "min" },
new SummaryInfo { Selector = "this", SummaryType = "max" },
new SummaryInfo { Selector = "this", SummaryType = "avg" },
new SummaryInfo { SummaryType = "count" },
};
var totals = new AggregateCalculator<object>(data, new DefaultAccessor<object>(), summaries, null).Run();
Assert.Equal(expectedSum, totals[0]);
Assert.Equal(expectedMin, totals[1]);
Assert.Equal(expectedMax, totals[2]);
Assert.Equal(expectedAvg, totals[3]);
Assert.Equal(expectedCount, totals[4]);
}
public void NestedGroups() {
var data = new[] {
new Group {
items = new[] {
new Group {
items = new object[] { 1, 5 }
}
}
}
};
var calculator = new AggregateCalculator<int>(data, new DefaultAccessor<int>(), null, new[] {
new SummaryInfo { Selector = "this", SummaryType = "sum" }
});
var totals = calculator.Run();
Assert.Null(totals);
Assert.Equal(6M, data[0].summary[0]);
Assert.Equal(6M, (data[0].items[0] as Group).summary[0]);
}
static void DoTest(TestCase test, string filePath)
{
List <DataValue> expectedValues = GetExpectedResults(test.ExpectedResultsPath, test.TestId);
ArchiveItem item = new ArchiveItem(test.DataPath, Assembly.GetExecutingAssembly(), test.DataPath);
DataFileReader reader = new DataFileReader();
reader.LoadConfiguration(null, item);
reader.LoadHistoryData(null, item);
AggregateConfiguration configuration = new AggregateConfiguration();
configuration.PercentDataBad = 100;
configuration.PercentDataGood = 100;
configuration.TreatUncertainAsBad = test.TreatUncertainAsBad;
configuration.UseSlopedExtrapolation = test.UseSlopedExtrapolation;
configuration.UseServerCapabilitiesDefaults = false;
DateTime startTime = DateTime.UtcNow;
startTime = new DateTime(startTime.Year, startTime.Month, startTime.Day, startTime.Hour, 0, 0, DateTimeKind.Utc);
AggregateCalculator calculator = new AggregateCalculator(
test.AggregateId,
startTime.AddSeconds(0),
startTime.AddSeconds(100),
5000,
test.Stepped,
configuration);
StringBuilder buffer = new StringBuilder();
List <DataValue> values = new List <DataValue>();
foreach (DataRowView row in item.DataSet.Tables[0].DefaultView)
{
DataValue rawValue = (DataValue)row.Row[2];
if (!calculator.QueueRawValue(rawValue))
{
Utils.Trace("Oops!");
continue;
}
DataValue processedValue = calculator.GetProcessedValue(false);
if (processedValue != null)
{
values.Add(processedValue);
}
}
for (DataValue processedValue = calculator.GetProcessedValue(true); processedValue != null; processedValue = calculator.GetProcessedValue(true))
{
values.Add(processedValue);
}
for (int ii = 0; ii < values.Count && ii < expectedValues.Count; ii++)
{
if (values[ii].SourceTimestamp != expectedValues[ii].SourceTimestamp)
{
Utils.Trace("Wrong Status Timestamp");
continue;
}
if (values[ii].StatusCode != expectedValues[ii].StatusCode)
{
Utils.Trace("Wrong Status Code");
continue;
}
if (StatusCode.IsNotBad(values[ii].StatusCode))
{
double value1 = Math.Round(Convert.ToDouble(values[ii].Value), 4);
double value2 = Math.Round(Convert.ToDouble(expectedValues[ii].Value), 4);
if (value1 != value2)
{
Utils.Trace("Wrong Value");
continue;
}
}
}
foreach (DataValue processedValue in values)
{
buffer.Append(processedValue.SourceTimestamp.ToString("HH:mm:ss"));
buffer.Append(", ");
buffer.Append(processedValue.WrappedValue);
buffer.Append(", ");
buffer.Append(new StatusCode(processedValue.StatusCode.CodeBits));
buffer.Append(", ");
buffer.Append(processedValue.StatusCode.AggregateBits);
buffer.Append("\r\n");
}
// write to the file.
using (StreamWriter writer = new StreamWriter(filePath))
{
writer.Write(buffer.ToString());
}
}
public void IgnoreGroupSummaryIfNoGroups() {
var data = new object[] { 1 };
var calculator = new AggregateCalculator<int>(data, new DefaultAccessor<int>(), null, new[] {
new SummaryInfo { Selector = "ignore me", SummaryType = "ignore me" }
});
calculator.Run();
}
